void irq_isr(void) __interrupt {
    // atender interrupción de audio
}

void nmi_isr(void) __interrupt {
    // atender interrupción de retrazo vertical (vblank)
}

void main(void) {
    // código principal del juego
}

#define  PPUCTRL    *((volatile uint8_t *) 0x2000)
#define  PPUMASK    *((volatile uint8_t *) 0x2001)
#define  PPUSTATUS  *((volatile uint8_t *) 0x2002)
#define  OAMADDR    *((volatile uint8_t *) 0x2003)
#define  OAMDATA    *((volatile uint8_t *) 0x2004)
#define  PPUSCROLL  *((volatile uint8_t *) 0x2005)
#define  PPUADDR    *((volatile uint8_t *) 0x2006)
#define  PPUDATA    *((volatile uint8_t *) 0x2007)

void irq_isr(void) __interrupt {
}

volatile uint16_t v;

void nmi_isr(void) __interrupt {
    PPUSTATUS;
    PPUADDR = 0x20;
    PPUADDR = 0x05;
    PPUDATA = (v >> 3) & 0x00FF;   // change some tile each 2^3 = 8 frames
    PPUCTRL = 0x80;   // base nametable = 0x2000, VRAM increment = 1, sprite pattern table = 0, background pattern table = 0, sprite size = 8x8, enable VBlank NMI
    PPUSTATUS;
    PPUSCROLL = 0x00;
    PPUSCROLL = 0x00;
    v++;
}

const char STR_1[] = "TEST1";
const char STR_2[] = "TEST2";

void show_str(const char *p) {
    while (*p != 0) {
        PPUDATA = *p;
        p++;
    }
}

void main(void) {
    v = 0;
    // disable rendering
    PPUCTRL = 0x00;
    PPUMASK = 0x00;
    // put STR_1 and STR_2 string in nametable (at 1st and 2nd line respectively)
    PPUSTATUS;
    PPUADDR = 0x20;     // STR_1 at 1st line of nametable 0x2000
    PPUADDR = 0x00;
    show_str(STR_1);
    PPUSTATUS;
    PPUADDR = 0x20;     // STR_2 at 2nd line of nametable 0x2000
    PPUADDR = 0x20;
    show_str(STR_2);
    // init palette
    PPUSTATUS;
    PPUADDR = 0x3F;
    PPUADDR = 0x00;
    PPUDATA = 0x0F;   // palette 0, color 0, black
    PPUDATA = 0x12;   // palette 0, color 1, blue
    PPUDATA = 0x2A;   // palette 0, color 2, green
    PPUDATA = 0x30;   // palette 0, color 3, white
    // enable rendering
    PPUMASK = 0x0A;   // color, show background in leftmost 8 pixels, enable background rendering
    PPUCTRL = 0x80;   // base nametable = 0x2000 (bits 1 and 0 = 0), VRAM increment = 1, sprite pattern table = 0, background pattern table = 0, sprite size = 8x8, enable VBlank NMI
    PPUSTATUS;
    PPUSCROLL = 0x00;   // update "t" internal register so top-left at beginning of nametable
    PPUSCROLL = 0x00;
    // infinite loop (wait vblank NMI)
    while (1)
        ;
}

PPUSTATUS;     // se fuerza el reset del flip-flop que determina qué parte de la dirección se carga primero
PPUADDR = byte alto de la direccion VRAM
PPUADDR = byte bajo de la direccion VRAM
PPUDATA = primer byte
PPUDATA = segundo byte

// antes de terminar “limpiamos” el registro interno que hemos “ensuciado”
PPUCTRL = 0x80;   // nametable = 0x2000, VRAM increment = 1, sprite pattern table = 0, background pattern table = 0, sprite size = 8x8, enable VBlank NMI
PPUSTATUS;
PPUSCROLL = 0x00;   // sin scroll
PPUSCROLL = 0x00;

struct screen_t {
    void (*on_load)(struct inter_screen_data_t *);
    const struct screen_t *(*on_vblank)(uint8_t, struct inter_screen_data_t *);
    void (*on_unload)(struct inter_screen_data_t *);
};

volatile struct inter_screen_data_t isd;

void irq_isr(void) __interrupt {
}

volatile uint8_t vblank;

void nmi_isr(void) __interrupt {
    vblank = 1;
}

const struct screen_t screens[] = {
    {
        title_screen_on_load,
        title_screen_on_vblank,
        title_screen_on_unload
    },
    {
        board_screen_on_load,
        board_screen_on_vblank,
        board_screen_on_unload
    },
    {
        end_screen_on_load,
        end_screen_on_vblank,
        end_screen_on_unload
    }
};

void main(void) {
    vblank = 0;
    const struct screen_t *current_screen = screens;
    current_screen->on_load(&isd);
    uint8_t controller_mask = controller_read();
    // infinite loop (wait vblank NMI)
    while (1) {
        if (vblank) {
            vblank = 0;
            const struct screen_t *next_screen = current_screen->on_vblank(controller_mask, &isd);
            if ((next_screen != NULL) && (next_screen != current_screen)) {
                current_screen = next_screen;
                current_screen->on_load(&isd);
            }
            controller_mask = controller_read();
        }
    }
}

void title_screen_on_load(struct inter_screen_data_t *d);
const struct screen_t *title_screen_on_vblank(uint8_t controller_mask, struct inter_screen_data_t *d);
void title_screen_on_unload(struct inter_screen_data_t *d);

void title_screen_on_load(struct inter_screen_data_t *d) {
    // deshabilitar renderizado
    // inicializar esta pantalla
    // configurar PPU (baldosas, paletas, sprites, etc.) para esta pantallaines);
    // habilitar renderizado
}

const struct screen_t *title_screen_on_vblank(uint8_t controller_mask, struct inter_screen_data_t *d) {
    // rutina porincipal de vblank
    // devolver NULL para permanecer en esta pantalla
    // devolver puntero a otra screen si se quiere cambiar de pantalla
}

void title_screen_on_unload(struct inter_screen_data_t *d) {
    // código a ejecutar antes de irse de esta pantalla (puede estar vacío)
}

#define  BCD_INC(bcd_v)  ((((bcd_v) & 0x0F) == 0x09) ? (((bcd_v) + 0x10) & 0xF0) : ((bcd_v) + 1))
#define  BCD_DEC(bcd_v)  ((((bcd_v) & 0x0F) == 0x00) ? ((((bcd_v) - 0x10) & 0xF0) | 0x09) : ((bcd_v) - 1))

// obtener offset a partir de coordenadas
uint8_t offset = (y << 4) | x;
uint8_t valor = tablero[offset];

// obtener coordenadas a partir de offset
uint8_t x = offset & 0x0F;
uint8_t y = offset >> 4;

struct sprite_t {
    uint8_t y;
    uint8_t tile;
    uint8_t attr;
    uint8_t x;
};


// sprites al final de la RAM
#define  SPRITES   ((struct sprite_t *) 0x0700)


// En el on_load situamos los 4 sprites
// en la esquina superior izquierda del tablero
    SPRITES[0].x = 63;                 // top left sprite
    SPRITES[0].y = 54;
    SPRITES[0].tile = 0x93;
    SPRITES[0].attr = 0x00;
    SPRITES[1].x = 71;                 // top right sprite
    SPRITES[1].y = 54;
    SPRITES[1].tile = 0x94;
    SPRITES[1].attr = 0x00;
    SPRITES[2].x = 63;                 // bottom left sprite
    SPRITES[2].y = 62;
    SPRITES[2].tile = 0xA3;
    SPRITES[2].attr = 0x00;
    SPRITES[3].x = 71;                 // bottom right sprite
    SPRITES[3].y = 62;
    SPRITES[3].tile = 0xA4;
    SPRITES[3].attr = 0x00;
    OAMADDR = 0;          // transferencia DMA
    OAMDMA = 0x07;


// Para moverlos una posición del tablero
// a la derecha en on_vblank bastaría con hacer
    SPRITES[0].x += 8;
    SPRITES[1].x += 8;
    SPRITES[2].x += 8;
    SPRITES[3].x += 8;
    OAMADDR = 0;
    OAMDMA = 0x07;     // transferencia DMA

using namespace std;

void ext_isr()  __attribute__((interrupt, section(".ext_isr")));

void ext_isr() {
    //
}

void h_blank_isr()  __attribute__((interrupt, section(".h_blank_isr")));

void h_blank_isr() {
    //
}

void v_blank_isr()  __attribute__((interrupt, section(".v_blank_isr")));

void v_blank_isr() {
    //
}

#define  W_VDP_DATA        *((uint16_t *) 0xC00000)
#define  W_VDP_CTRL        *((uint16_t *) 0xC00004)
#define  W_VDP_HV_COUNTER  *((uint16_t *) 0xC00008)
#define  L_VDP_DATA        *((uint32_t *) 0xC00000)
#define  L_VDP_CTRL        *((uint32_t *) 0xC00004)

#define  VDPREG_MODE1      0x8000  // Mode register #1
#define  VDPREG_MODE2      0x8100  // Mode register #2
#define  VDPREG_PLANEA     0x8200  // Plane A table address
#define  VDPREG_WINDOW     0x8300  // Window table address
#define  VDPREG_PLANEB     0x8400  // Plane B table address
#define  VDPREG_SPRITE     0x8500  // Sprite table address
#define  VDPREG_BGCOL      0x8700  // Background color
#define  VDPREG_HRATE      0x8A00  // HBlank interrupt rate
#define  VDPREG_MODE3      0x8B00  // Mode register #3
#define  VDPREG_MODE4      0x8C00  // Mode register #4
#define  VDPREG_HSCROLL    0x8D00  // HScroll table address
#define  VDPREG_INCR       0x8F00  // Autoincrement
#define  VDPREG_SIZE       0x9000  // Plane A and B size
#define  VDPREG_WINX       0x9100  // Window X split position
#define  VDPREG_WINY       0x9200  // Window Y split position
#define  VDPREG_DMALEN_L   0x9300  // DMA length (low)
#define  VDPREG_DMALEN_H   0x9400  // DMA length (high)
#define  VDPREG_DMASRC_L   0x9500  // DMA source (low)
#define  VDPREG_DMASRC_M   0x9600  // DMA source (mid)
#define  VDPREG_DMASRC_H   0x9700  // DMA source (high)

/*
screen width : 40 tiles * 8 = 320
screen height: 28 tiles * 8 = 224

Plane A table          : 0xC000
Window name table      : 0xD000
Plane B table          : 0xE000
Sprite attribute table : 0xF000
H scroll data          : 0xF400

 */
void vdp_init() {
    W_VDP_CTRL = VDPREG_MODE1 | 0x04;    // mode register #1: display disabled
    W_VDP_CTRL = VDPREG_MODE2 | 0x04;    // mode register #2: display disabled, v blank interrupt disabled, mode 5 video mode, 28 tiles height
    W_VDP_CTRL = VDPREG_PLANEA | 0x30;   // plane A address: upper 3 bits of VRAM location of plane A name table = 0xC000
    W_VDP_CTRL = VDPREG_WINDOW | 0x34;   // window address: upper 5 bits of VRAM location of window name table = 0xD000
    W_VDP_CTRL = VDPREG_PLANEB | 0x07;   // plane B address: upper 3 bits of VRAM location of plane B name table = 0xE000
    W_VDP_CTRL = VDPREG_SPRITE | 0x78;   // sprite address: upper 7 bits of VRAM location of sprite attribute table = 0xF000
    W_VDP_CTRL = VDPREG_BGCOL | 0x00;    // background color: palette 0, index 0
    W_VDP_CTRL = VDPREG_HRATE | 0xFF;    // h blank irq rate: horizontal line at wich the h blank interrupt will be triggered
    W_VDP_CTRL = VDPREG_MODE3 | 0x00;    // mode register #3: external interrupt disabled, entire panel vertical scroll, entire panel horizontal scroll
    W_VDP_CTRL = VDPREG_MODE4 | 0x81;    // mode register #4: 40 tiles width, no interlaced mode
    W_VDP_CTRL = VDPREG_HSCROLL | 0x3D;  // H scroll address: upper 6 bits of VRAM location of horizontal scroll table = 0xF400
    W_VDP_CTRL = VDPREG_INCR | 0x02;     // autoincrement: 2 (each VRAM data write will autoincrement VRAM pointer by 2, one 16 bit word at once)
    W_VDP_CTRL = VDPREG_SIZE | 0x00;     // tilemap size: 32x32 tiles for both A and B planes
    W_VDP_CTRL = VDPREG_WINX | 0x00;     // window x split: window plane x = 0
    W_VDP_CTRL = VDPREG_WINY | 0x00;     // window y split: window plane y = 0
    // clear vram
    L_VDP_CTRL = 0x40000000;
    uint16_t n = 65536 >> 1;
    while (n > 0) {
        W_VDP_DATA = 0;
        n--;
    }
    // clear cram
    L_VDP_CTRL = 0xC0000000;
    n = 128 >> 1;
    while (n > 0) {
        W_VDP_DATA = 0;
        n--;
    }
    // clear vsram
    L_VDP_CTRL = 0x40000010;
    n = 80 >> 1;
    while (n > 0) {
        W_VDP_DATA = 0;
        n--;
    }
}

void vdp_vram_write(const uint16_t *src, uint16_t size_bytes, uint16_t vram_addr) {
    uint16_t test = W_VDP_CTRL;          // prepare vdp
    L_VDP_CTRL = 0x40000000 | ((((uint32_t) vram_addr) & 0x3FFF) << 16) | (((uint32_t) vram_addr) >> 14);
    size_bytes >>= 1;
    while (size_bytes > 0) {
        W_VDP_DATA = *src;
        size_bytes--;
        src++;
    }
}

void vdp_cram_write(const uint16_t *src, uint16_t size_bytes, uint16_t cram_addr) {
    uint16_t test = W_VDP_CTRL;          // prepare vdp
    L_VDP_CTRL = 0xC0000000 | ((((uint32_t) cram_addr) & 0x3FFF) << 16) | (((uint32_t) cram_addr) >> 14);
    size_bytes >>= 1;
    while (size_bytes > 0) {
        W_VDP_DATA = *src;
        size_bytes--;
        src++;
    }
}

void vdp_vsram_write(const uint16_t *src, uint16_t size_bytes, uint16_t vsram_addr) {
    uint16_t test = W_VDP_CTRL;          // prepare vdp
    L_VDP_CTRL = 0x40000010 | ((((uint32_t) vsram_addr) & 0x3FFF) << 16) | (((uint32_t) vsram_addr) >> 14);
    size_bytes >>= 1;
    while (size_bytes > 0) {
        W_VDP_DATA = *src;
        size_bytes--;
        src++;
    }
}

void vdp_enable(bool v) {
    uint16_t test = W_VDP_CTRL;          // prepare vdp
    if (v) {
        W_VDP_CTRL = VDPREG_MODE1 | 0x05;    // mode register #1: display enabled
        W_VDP_CTRL = VDPREG_MODE2 | 0x64;    // mode register #2: display enabled, v blank interrupt enabled, mode 5 video mode
    }
    else {
        W_VDP_CTRL = VDPREG_MODE1 | 0x04;    // mode register #1: display enabled
        W_VDP_CTRL = VDPREG_MODE2 | 0x04;    // mode register #2: display disabled, v blank interrupt disabled, mode 5 video mode
    }
}

void vdp_vram_write_tile_indices() {
    uint16_t test = W_VDP_CTRL;          // prepare vdp
    uint16_t vram_addr = 0xE000;         // draw tiles on plane b with low priority
    L_VDP_CTRL = 0x40000000 | ((((uint32_t) vram_addr) & 0x3FFF) << 16) | (((uint32_t) vram_addr) >> 14);
    uint16_t i = 1;     // put tiles 1, 2, 3, 4, 5, 6, 7, 8... 1023 and 1024 (tile 0 is full transparent)
    int16_t n = 32 * 32;
    while (n > 0) {
        W_VDP_DATA = i;
        n--;
        i++;
    }
}

#include "ghg.h"     // include "s_tile" constant with all 1024 (32 * 32) tiles

int main() {
    vdp_init();
    vdp_cram_write(s_palette, 32, 0);   // palette 0
    vdp_vram_write((const uint16_t *) s_tiles, 32 * 32 * 8 * 4, 32);      // 1st tile at tile index 1 in VRAM (keep tile 0 full transparent)
    vdp_vram_write_tile_indices();
    vdp_enable(true);
    asm volatile ("move.w #0x2300, %sr");    // enable interrupts
    while (true)
        ;
    return 0;
}

#include "circular_scroll_offsets.h"    // precalculated circular scroll offsets

uint16_t next_circular_scroll_offset;

void v_blank_isr()  __attribute__((interrupt, section(".v_blank_isr")));

void v_blank_isr() {
    // update VRAM and VSRAM
    vdp_vram_write((const uint16_t *) (s_circular_scroll_offsets + next_circular_scroll_offset),      2, 0xF402);   // update plane B (background) horizontal scroll
    vdp_vsram_write((const uint16_t *) (s_circular_scroll_offsets + next_circular_scroll_offset + 1), 2, 2);        // update plane B (background) vertical scroll
    .
    .
    .
    // update scroll offsets for next frame
    next_circular_scroll_offset += 2;
    if (next_circular_scroll_offset == (s_circular_scroll_offsets_steps << 1))
        next_circular_scroll_offset = 0;
}

const uint32_t s_sprite_tile[] __attribute__((aligned(2))) = {
    0xFFFFFFFF,
    0xF000000F,
    0xF0F00F0F,
    0xF000000F,
    0xF0F00F0F,
    0xF00FF00F,
    0xF000000F,
    0xFFFFFFFF
};

int main() {
    .
    .
    .
    // sprite tile at tile index 1121 in VRAM
    vdp_vram_write((const uint16_t *) s_sprite_tile, 32, 32 + (32 * 32 * 8 * 4));
    .
    .
    .
}

struct sprite_attribute_t {
    uint16_t y;
    uint16_t size_and_link_data;
    uint16_t pattern;
    uint16_t x;
}  __attribute__((packed));

sprite_attribute_t sa  __attribute__((aligned(2)));
int16_t x;
int16_t y;
int16_t dx;
int16_t dy

.
.
.

int main() {
    .
    .
    .
    sa.x = 128;
    sa.y = 128;
    x = y = 0;
    dx = dy = 1;
    sa.size_and_link_data = 0;
    // priority = 0, palette = 0, no vertical flip, no horizontal flip,
    // pattern = 1025 (pattern 0 = transparent, patterns 1...1024 = plane B)
    sa.pattern = 1025;
    .
    .
    .
}

void v_blank_isr() {
    .
    .
    .
    // first sprite in the sprite attribute table
    // sprite = 8 bytes, sizeof(sprite_attribute_t)
    vdp_vram_write((const uint16_t *) &sa, 8, 0xF000);
    // update sprite position for next frame
    x += dx;
    if (x >= (320 - 8))
        dx = -1;
    else if (x <= 0)
        dx = 1;
    y += dy;
    if (y >= (224 - 8))
        dy = -1;
    else if (y <= 0)
        dy = 1;
    sa.x = (128 + x) & 0x01FF;
    sa.y = (128 + y) & 0x03FF;
    .
    .
    .
}

void vblankISR(void) __critical __interrupt(0) {
}

void nmISR(void) __critical __interrupt {
}

#define  YM2612_STATUS     *((volatile uint8_t *) 0x4000)
#define  YM2612_A0         *((volatile uint8_t *) 0x4000)
#define  YM2612_D0         *((volatile uint8_t *) 0x4001)
#define  YM2612_A1         *((volatile uint8_t *) 0x4002)
#define  YM2612_D1         *((volatile uint8_t *) 0x4003)
#define  M68K_BANK_SELECT  *((volatile uint8_t *) 0x6000)
#define  M68K_BANK         ((const volatile uint8_t *) 0x8000)

#ifndef  LOOP_SIZE
#error "LOOP_SIZE must be defined"
#endif

void ym2612_write(uint8_t address, uint8_t value) {
    while (YM2612_STATUS & 0x80)
        ;
    YM2612_A0 = address;
    YM2612_D0 = value;
}

uint8_t ym2612_read(uint8_t address) {
    while (YM2612_STATUS & 0x80)
        ;
    YM2612_A0 = address;
    return YM2612_D0;
}

void main(void) {
    __asm__ ("di");
    // sound loop at address 0x1F8000 on 68000 memory: A23...A15 = 0001 1111 1xxx xxxx xxxx xxxx
    M68K_BANK_SELECT = 1;   // A15
    M68K_BANK_SELECT = 1;
    M68K_BANK_SELECT = 1;
    M68K_BANK_SELECT = 1;
    M68K_BANK_SELECT = 1;
    M68K_BANK_SELECT = 1;
    M68K_BANK_SELECT = 0;
    M68K_BANK_SELECT = 0;
    M68K_BANK_SELECT = 0;   // A23
    // enable DAC on YM2612
    ym2612_write(0x2B, 0x80);
    const uint8_t *p = M68K_BANK;
    uint16_t n = LOOP_SIZE;
    while (1) {
        // write sample
        ym2612_write(0x2A, *p);
        // next sample
        p++;
        n--;
        if (n == 0) {
            p = M68K_BANK;
            n = LOOP_SIZE;
        }
    }
}

const unsigned char s_z80_binary[] = {
  0xf3, 0xed, 0x56, 0xc3, 0x69, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0x00, 0x02, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0x03, 0x02, 0x31, 0x00, 0x20,
  0xcd, 0x75, 0x02, 0xfb, 0xcd, 0x24, 0x02, 0xc3, 0x73, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfb, 0xed, 0x4d, 0xed,
  0x45, 0x47, 0x4d, 0x3a, 0x00, 0x40, 0x07, 0x38, 0xfa, 0x21, 0x00, 0x40,
  0x70, 0x2e, 0x01, 0x71, 0xc9, 0x4f, 0x3a, 0x00, 0x40, 0x07, 0x38, 0xfa,
  0x21, 0x00, 0x40, 0x71, 0x3a, 0x01, 0x40, 0xc9, 0xf3, 0x21, 0x00, 0x60,
  0x36, 0x01, 0x36, 0x01, 0x36, 0x01, 0x36, 0x01, 0x36, 0x01, 0x36, 0x01,
  0x36, 0x00, 0x36, 0x00, 0x36, 0x00, 0x2e, 0x80, 0x3e, 0x2b, 0xcd, 0x05,
  0x02, 0x2e, 0xff, 0x3e, 0x24, 0xcd, 0x05, 0x02, 0x2e, 0x01, 0x3e, 0x25,
  0xcd, 0x05, 0x02, 0x2e, 0x10, 0x3e, 0x27, 0xcd, 0x05, 0x02, 0x21, 0x00,
  0x80, 0x01, 0x83, 0x6c, 0x7e, 0xe5, 0xc5, 0x6f, 0x3e, 0x2a, 0xcd, 0x05,
  0x02, 0xc1, 0xe1, 0x23, 0x0b, 0x78, 0xb1, 0x20, 0xef, 0x21, 0x00, 0x80,
  0x01, 0x83, 0x6c, 0x18, 0xe7, 0xc9
};
const unsigned int s_z80_binary_len = 630;

#include "z80/mdz80binary.h"

#define  Z80RAM     ((uint8_t *) 0xA00000)
#define  Z80BUSREQ  *((uint16_t *) 0xA11100)
#define  Z80RESET   *((uint16_t *) 0xA11200)

void z80_init(const uint8_t *code, const uint16_t code_size) {
    // request z80 bus to load z80 code
    Z80RESET = 0;
    Z80BUSREQ = 0x0100;
    Z80RESET = 0x0100;
    // copy z80 code
    const uint8_t *src = code;
    uint8_t *dst = Z80RAM;
    uint16_t n = code_size;
    while (n > 0) {
        *dst = *src;
        src++;
        dst++;
        n--;
    }
    // release bus and reset z80
    Z80RESET = 0;
    for (int i = 0; i < 192; i++)
        ;
    Z80RESET = 0x0100;
    Z80BUSREQ = 0;
}


int main() {
    .
    .
    .
    // load and start running z80 code
    z80_init(s_z80_binary, s_z80_binary_len);
    .
    .
    .
}

const uint8_t HEART_PATTERN[32] = {
//  bit
//  0     1     2     3     cada byte: msb=pixel más izq, lsb=pixel más derecha
    0x00, 0x00, 0x00, 0x00,
    0x00, 0x6C, 0x00, 0x00,
    0x6C, 0x92, 0x00, 0x00,
    0x7C, 0x82, 0x00, 0x00,
    0x38, 0x44, 0x00, 0x00,
    0x10, 0x28, 0x00, 0x00,
    0x00, 0x10, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00
};

#include <stdint.h>
#include "ana.h"


__sfr __at (0xBE) VDP_DATA;
__sfr __at (0xBF) VDP_ADDRESS;


#define  PALETTE_OFFSET_TILES    0
#define  PALETTE_OFFSET_SPRITES  16


void write_palette(uint8_t offset, const uint8_t *palette) {
    VDP_ADDRESS = offset;    // start at color 0
    VDP_ADDRESS = 0b11000000;
    uint8_t n = 16;
    while (n > 0) {
        VDP_DATA = *palette;
        palette++;
        n--;
    }
}


void write_vram(const uint8_t *src, uint16_t size, uint16_t vram_addr) {
    VDP_ADDRESS = (uint8_t) (vram_addr & 0x00FF);
    VDP_ADDRESS = 0b01000000 | ((uint8_t) ((vram_addr >> 8) & 0x3F));
    while (size > 0) {
        VDP_DATA = *src;
        src++;
        size--;
    }
}


void write_vram_2(const uint8_t *src, uint16_t size, uint16_t vram_addr) {
    VDP_ADDRESS = (uint8_t) (vram_addr & 0x00FF);
    VDP_ADDRESS = 0b01000000 | ((uint8_t) ((vram_addr >> 8) & 0x3F));
    while (size > 0) {
        VDP_DATA = *src;
        VDP_DATA = 0;
        src++;
        size--;
    }
}


void vblankISR(void) __critical __interrupt(0) {
    uint8_t vdp_status = VDP_ADDRESS;
}


void nmISR(void) __critical __interrupt {
}


void main(void) {
    __asm__ ("di");
    // draw background image
    write_palette(PALETTE_OFFSET_TILES, ANA_PALETTE);
    write_vram(ANA_TILE_PATTERNS, 241 * 4 * 8, 0);    // 240 + 1 tile patterns --> vram pattern address (0x0000)
    write_vram_2(ANA_TILE_MAP, 32 * 24, 0x3800);        // 32 * 24 tiles --> vram tile map address (0x3800)
    // enable display
    VDP_ADDRESS = 0b01100000;
    VDP_ADDRESS = 0x81;
    __asm__ ("ei");
    while (1)
        ;
}

#include <stdint.h>
#include "ana.h"


__sfr __at (0xBE) VDP_DATA;
__sfr __at (0xBF) VDP_ADDRESS;


const uint8_t SPRITE_PALETTE[16] = {
//        red   white
    0x00, 0x03, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};


const uint8_t SPRITE_PATTERN[32] = {
//  bit
//  0     1     2     3       each byte: msb=leftmost pixel, lsb=rightmost pixel
    0x00, 0x00, 0x00, 0x00,
    0x00, 0x6C, 0x00, 0x00,
    0x6C, 0x92, 0x00, 0x00,
    0x7C, 0x82, 0x00, 0x00,
    0x38, 0x44, 0x00, 0x00,
    0x10, 0x28, 0x00, 0x00,
    0x00, 0x10, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00
};


#define  PALETTE_OFFSET_TILES    0
#define  PALETTE_OFFSET_SPRITES  16


void write_palette(uint8_t offset, const uint8_t *palette) {
    VDP_ADDRESS = offset;    // start at color 0
    VDP_ADDRESS = 0b11000000;
    uint8_t n = 16;
    while (n > 0) {
        VDP_DATA = *palette;
        palette++;
        n--;
    }
}


void write_vram(const uint8_t *src, uint16_t size, uint16_t vram_addr) {
    VDP_ADDRESS = (uint8_t) (vram_addr & 0x00FF);
    VDP_ADDRESS = 0b01000000 | ((uint8_t) ((vram_addr >> 8) & 0x3F));
    while (size > 0) {
        VDP_DATA = *src;
        src++;
        size--;
    }
}


void write_vram_2(const uint8_t *src, uint16_t size, uint16_t vram_addr) {
    VDP_ADDRESS = (uint8_t) (vram_addr & 0x00FF);
    VDP_ADDRESS = 0b01000000 | ((uint8_t) ((vram_addr >> 8) & 0x3F));
    while (size > 0) {
        VDP_DATA = *src;
        VDP_DATA = 0;
        src++;
        size--;
    }
}


uint8_t sprite_x;
uint8_t sprite_y;
int8_t sprite_x_inc;
int8_t sprite_y_inc;


void vblankISR(void) __critical __interrupt(0) {
    uint8_t vdp_status = VDP_ADDRESS;
    // apply (sprite_x, sprite_y) coordinates to sprite vram
    VDP_ADDRESS = 0;
    VDP_ADDRESS = 0b01000000 | 0x3F;
    VDP_DATA = sprite_y;
    VDP_ADDRESS = 0x80;
    VDP_ADDRESS = 0b01000000 | 0x3F;
    VDP_DATA = sprite_x;
    // update (sprite_x, sprite_y)
    sprite_x += sprite_x_inc;
    if (sprite_x == (256 - 8))
        sprite_x_inc = -1;
    else if (sprite_x == 0)
        sprite_x_inc = 1;
    sprite_y += sprite_y_inc;
    if (sprite_y == (192 - 8))
        sprite_y_inc = -1;
    else if (sprite_y == 0)
        sprite_y_inc = 1;
}


void nmISR(void) __critical __interrupt {
}


void main(void) {
    __asm__ ("di");
    // draw background image
    write_palette(PALETTE_OFFSET_TILES, ANA_PALETTE);
    write_vram(ANA_TILE_PATTERNS, 241 * 4 * 8, 0);    // 240 + 1 tile patterns --> vram pattern address (0x0000)
    write_vram_2(ANA_TILE_MAP, 32 * 24, 0x3800);        // 32 * 24 tiles --> vram tile map address (0x3800)
    // draw sprite
    write_palette(PALETTE_OFFSET_SPRITES, SPRITE_PALETTE);
    VDP_ADDRESS = 0;      // border color = color 0 of sprite palette
    VDP_ADDRESS = 0x87;
    write_vram(SPRITE_PATTERN, 4 * 8, 0x2000);
    // locate sprite
    sprite_x = 80;
    sprite_y = 80;
    sprite_x_inc = 1;
    sprite_y_inc = 1;
    VDP_ADDRESS = (uint8_t) (0x3F00 & 0x00FF);
    VDP_ADDRESS = 0b01000000 | ((uint8_t) ((0x3F00 >> 8) & 0x3F));
    VDP_DATA = sprite_y;
    VDP_DATA = 208;         // end of sprite list (sprite_y = 208)
    VDP_ADDRESS = (uint8_t) (0x3F80 & 0x00FF);
    VDP_ADDRESS = 0b01000000 | ((uint8_t) ((0x3F80 >> 8) & 0x3F));
    VDP_DATA = sprite_x;
    VDP_DATA = 0;           // tile 0 of sprite tiles
    // enable display
    VDP_ADDRESS = 0b01100000;
    VDP_ADDRESS = 0x81;
    __asm__ ("ei");
    while (1)
        ;
}

typedef struct {
    const uint8_t *first_byte;
    const uint8_t *next_byte;
    uint16_t wait_counter;
} vgm_info;


void vgm_init(vgm_info *vgm, const uint8_t *file_data) {
    uint32_t version = *((uint32_t *) (file_data + 0x08));
    if (version < 0x00000150)
        vgm->next_byte = file_data + 0x40;
    else {
        uint32_t data_offset = *((uint32_t *) (file_data + 0x34));
        if (data_offset == 0x0000000C)
            vgm->next_byte = file_data + 0x40;
        else
            vgm->next_byte = file_data + data_offset + 0x34;
    }
    vgm->first_byte = vgm->next_byte;
    vgm->wait_counter = 0;
}


void vgm_tick(vgm_info *vgm) {
    if (vgm->wait_counter > 0) {
        vgm->wait_counter--;
        return;
    }
    const uint8_t *p = vgm->next_byte;
    if (*p == 0x50) {
        vgm->wait_counter = 0;
        while (*p == 0x50) {
            p++;
            PSG = *p;
            p++;
        }
    }
    while ((*p == 0x61) || (*p == 0x62) || (*p == 0x63)) {
        if ((*p == 0x62) || (*p == 0x63)) {
            vgm->wait_counter++;
            p++;
        }
        else {
            p++;
            uint16_t num_samples = *((uint16_t *) p);
            p += 2;
            //vgm->wait_counter += num_samples / 882;    // convert samples to ticks (requires stdlib because of integer division)
            //
            // aproximate num_samples / 882 with num_samples / 768 = num_samples / (256 * 3)
            // (1 / 3) * 65536 = 21845, so:
            // num_samples / 768 = ((num_samples / 256) * 21845) / 65536
            // num_samples / 768 = ((num_samples >> 8) * 21845) >> 16
            // num_samples / 768 = (ns * 21845) >> 24
            // num_samples / 768 = (ns * (16384 + 4096 + 512 + 256 + 32 + 4)) >> 24
            // num_samples / 768 = (ns * (16384 + 4096 + 512 + 256 + 32 + 4)) >> 24
            // num_samples / 768 = ((ns << 14) + (ns << 12) + (ns << 8) + (ns << 5) + (ns << 2) + ns) >> 24
            uint32_t aux = num_samples;
            aux = ((aux << 14) + (aux << 12) + (aux << 8) + (aux << 5) + (aux << 2)) >> 24;
            vgm->wait_counter = aux;
        }
    }
    while ((*p & 0x70) == 0x70)    // wait n + 1 samples, 1 tick = 882 samples, so ignore 0x7X commands
        p++;
    if (*p == 0x66) {
        vgm->wait_counter = 0;
        vgm->next_byte = vgm->first_byte;
    }
    else
        vgm->next_byte = p;
}

void AlarmControl::run() {
    Status localStatus = this->status;
    do {
        this->status = localStatus;
        if (localStatus == Status::RESET) {
            this->io.stopTrigSound();
            this->io.stopTrigSilence();
            localStatus = Status::TRIG_SILENCE;
        }
        else if (localStatus == Status::TRIG_SILENCE) {
            this->io.startTrigSilence();
            this->counter = N_SILENCE;
            localStatus = Status::WAIT_SILENCE;
        }
        else if (localStatus == Status::WAIT_SILENCE) {
            this->counter--;
            if (this->counter == 0) {
                this->io.stopTrigSilence();
                localStatus = Status::WAIT_1;
            }
        }
        else if (localStatus == Status::WAIT_1) {
            if (this->io.getAlarm())
                localStatus = Status::TRIG_SOUND;
        }
        else if (localStatus == Status::TRIG_SOUND) {
            this->io.startTrigSound();
            this->counter = N_SOUND;
            localStatus = Status::WAIT_SOUND;
        }
        else if (localStatus == Status::WAIT_SOUND) {
            this->counter--;
            if (this->counter == 0) {
                this->io.stopTrigSound();
                localStatus = Status::WAIT_0;
            }
        }
        else if (localStatus == Status::WAIT_0) {
            if (!this->io.getAlarm())
                localStatus = Status::TRIG_SILENCE;
        }
    } while (localStatus != this->status);
}

    class AlarmControlIO {
        public:
            virtual bool getAlarm() = 0;
            virtual void startTrigSound() = 0;
            virtual void stopTrigSound() = 0;
            virtual void startTrigSilence() = 0;
            virtual void stopTrigSilence() = 0;
    };

    class AlarmControl {
        protected:
            AlarmControlIO &io;
            enum class Status { RESET, TRIG_SILENCE, WAIT_SILENCE, WAIT_1, TRIG_SOUND, WAIT_SOUND, WAIT_0 };
            Status status;
            uint32_t counter;
            static const uint32_t N_SILENCE = 4;
            static const uint32_t N_SOUND = 4;
        public:
            AlarmControl(AlarmControlIO &alarmControlIO) : io(alarmControlIO), status(Status::RESET) { };
            void run();
    };

void MyListener::timerExpired() {
    this->alarmControl.run();
}

bool MyListener::getAlarm() {
    return (GPIOC_INDR & (((uint32_t) 1) << 1)) ? true : false;     // read PC1
}

void MyListener::startTrigSound() {
    GPIOA_OUTDR &= ~(((uint32_t) 1) << 1);      // PA1 = 0
}

void MyListener::stopTrigSound() {
    GPIOA_OUTDR |= (((uint32_t) 1) << 1);      // PA1 = high z
}

void MyListener::startTrigSilence() {
    GPIOA_OUTDR &= ~(((uint32_t) 1) << 2);      // PA2 = 0
}

void MyListener::stopTrigSilence() {
    GPIOA_OUTDR |= (((uint32_t) 1) << 2);      // PA2 = high z
}

int main() {
    interruptInit();
    MyListener myListener;
    Timer::init(myListener, 100_msForTimer);
    while (true)
        asm volatile ("wfi");
}

void SnakeMainScreen::advance(Collide &c) {
    c = Collide::NO;
    // check direction
    int16_t newHeadX = this->headX + this->dir->x;
    int16_t newHeadY = this->headY + this->dir->y;
    if ((newHeadX < 0) || (newHeadX >= BOARD_WIDTH) || (newHeadY < 0) || (newHeadX >= BOARD_HEIGHT))
        c = Collide::YES;
    else {
        // no collision to borders
        uint16_t oldHeadOffset = (this->headY * BOARD_WIDTH) + this->headX;
        uint8_t oldHeadValue = this->board[oldHeadOffset];
        uint16_t newHeadOffset = (newHeadY * BOARD_WIDTH) + newHeadX;
        uint8_t newHeadValue = this->board[newHeadOffset];
        if ((newHeadValue == SnakeDirection::TO_UP) || (newHeadValue == SnakeDirection::TO_DOWN) || (newHeadValue == SnakeDirection::TO_LEFT) || (newHeadValue == SnakeDirection::TO_RIGHT))
            c = Collide::YES;
        else if (newHeadValue == 0) {
            uint16_t tailOffset = (this->tailY * BOARD_WIDTH) + this->tailX;
            uint8_t tailValue = this->board[tailOffset];
            int16_t newTailX, newTailY;
            this->calculateNewTail(tailValue, newTailX, newTailY);
            this->board[tailOffset] = 0;
            this->drawBoardPosition(this->tailX, this->tailY, 0);
            this->tailX = newTailX;
            this->tailY = newTailY;
        }
        else if (newHeadValue == FOOD) {
            int16_t foodX, foodY;
            this->allocateNewFood(foodX, foodY);
            this->drawBoardPosition(foodX, foodY, 1);
            this->fruitCounter++;
            this->display.drawNumber(100, 32, this->fruitCounter, 3, Display::ShowZeros::YES);
        }
        this->board[oldHeadOffset] = this->dir->to;
        this->board[newHeadOffset] = this->dir->to;
        this->drawBoardPosition(newHeadX, newHeadY, 1);
        this->display.notifyFrameBufferChanged();
        this->headX = newHeadX;
        this->headY = newHeadY;
    }
}

const Level TanksMainScreen::LEVELS[] = {
    {     // nivel 0
/*
     +---+
cada |   | es un cuadrado de 10x10 unidades del mundo, P es el jugador
     +---+

    +---+---+---+---+---+---+---+---+
    |                               |
    +   P-->            +           +
    |                   |           |
    +                   +---+---+---+
    |                               |
    +---+---+---+---+               +
    |               |               |
    +               +               +
    |               |               |
    +               +               +
    |                               |
    +---+---+---+---+---+---+---+---+
*/
        80,    // width = 80 (integer)
        60,    // height = 60 (integer)
        8,    // 8 segments
        {
            {{0, 0}, {5242880, 0}},    // scene segments (Q16.16 fixed point)
            {{5242880, 0}, {5242880, 3932160}},
            {{5242880, 3932160}, {0, 3932160}},
            {{0, 3932160}, {0, 0}},
            {{0, 1966080}, {2621440, 1966080}},
            {{2621440, 1966080}, {2621440, 3276800}},
            {{3276800, 655360}, {3276800, 1310720}},
            {{3276800, 1310720}, {5242880, 1310720}}
        },
        {655360, 655360},    // (10, 10) (Q16.16 fixed point)
        0,            // player at (10, 10) looking with ANGLE[0]
        2             // 2 collectable/shootable items
    },

    // ... other levels

};

para cada coordenada x entre -31 y +31 (se asume que 0 es el centro de la pantalla)
    rayo = vector unitario que va desde el jugador y apunta a la columna x
    distanciaColision = infinita
    segmentoAPintar = ninguno
    para cada segmento s del nivel
        calcular las posible colisión entre el rayo y s
        si colisiona y (distancia < distanciaColision) entonces
            distanciaColision = distancia
            segmentoAPintar = s
        fin si
    fin para
    si (segmentoAPintar != ninguno) entonces
        alturaEnPantalla = ALTURA * distanciaAPantalla / distanciaColision
        pintar en la columna x un segmento vertical de tamaño alturaEnPantalla
    en caso contrario
        pintar en la columna x un punto en el centro (horizonte)
    fin si
fin para

TanksMainScreen::Intersection TanksMainScreen::getIntersection(const Segment &seg, const Vector &ray, const fixedpoint_t minRayT, fixedpoint_t &segT, fixedpoint_t &rayT) {
    fixedpoint_t dxs = seg.p2.x - seg.p1.x;
    fixedpoint_t dys = seg.p2.y - seg.p1.y;
    if ((dxs != 0) || (dys != 0)) {
        fixedpoint_t denRayT = (ray.dir.y * dxs) - (ray.dir.x * dys);
        if (denRayT != 0) {
            rayT = ((dxs * seg.p1.y) + (ray.p.x * dys) - (seg.p1.x * dys) - (ray.p.y * dxs)) / denRayT;
            if (rayT >= minRayT) {
                if (dxs != 0)
                    segT = (ray.p.x + (rayT * ray.dir.x) - seg.p1.x) / dxs;
                else
                    segT = (ray.p.y + (rayT * ray.dir.y) - seg.p1.y) / dys;
                if ((segT >= 0) && (segT <= fixedpoint_t::get(1)))
                    return Intersection::ONE_POINT;
            }
        }
    }
    return Intersection::NO_POINT;
}

class fixedpoint_t {
    public:
        int32_t v;
        fixedpoint_t(int32_t x = 0) : v(x) { };
        inline fixedpoint_t &operator = (const int32_t &x) { this->v = x << 16; return *this; };
        inline fixedpoint_t operator + (const fixedpoint_t &x) const { fixedpoint_t ret; ret.v = this->v + x.v; return ret; };
        inline fixedpoint_t operator - (const fixedpoint_t &x) const { fixedpoint_t ret; ret.v = this->v - x.v; return ret; };
        inline fixedpoint_t operator - () const { fixedpoint_t ret; ret.v = -(this->v); return ret; };
        inline fixedpoint_t operator * (const fixedpoint_t &x) const { fixedpoint_t ret; ret.v = (((int64_t) this->v) * ((int64_t) x.v)) >> 16; return ret; };
        inline fixedpoint_t operator / (const fixedpoint_t &x) const { fixedpoint_t ret; ret.v = (((int64_t) this->v) << 16) / ((int64_t) x.v); return ret; };
        inline bool operator == (const fixedpoint_t &x) const { return (this->v == x.v); };
        inline bool operator != (const fixedpoint_t &x) const { return (this->v != x.v); };
        inline bool operator < (const fixedpoint_t &x) const { return (this->v < x.v); };
        inline bool operator > (const fixedpoint_t &x) const { return (this->v > x.v); };
        inline bool operator <= (const fixedpoint_t &x) const { return (this->v <= x.v); };
        inline bool operator >= (const fixedpoint_t &x) const { return (this->v >= x.v); };
        inline fixedpoint_t operator += (const fixedpoint_t &x) { this->v += x.v; return *this; };
        inline fixedpoint_t operator -= (const fixedpoint_t &x) { this->v -= x.v; return *this; };
        inline int32_t getIntegerPart() { return this->v >> 16; };
        inline static fixedpoint_t get(int32_t x) { fixedpoint_t ret; ret.v = x << 16; return ret; };
};

const AngleAndDistance TanksMainScreen::DISPLAY_ANGLES_AND_DISTANCES[32] = {
    // precalculated vector of angles and distances to display from player
    // DISPLAY_ANGLES_AND_DISTANCES(i).angle       = the angle in radians from center os display of pixel located at center +/- i  (not used in code)
    // DISPLAY_ANGLES_AND_DISTANCES(i).cosineAngle = cos(angle)
    // DISPLAY_ANGLES_AND_DISTANCES(i).sineAngle   = sin(angle)
    // DISPLAY_ANGLES_AND_DISTANCES(i).distance    = the distance in world units from player to the pixel in the display located at center +/- i
    {0, 65536, 0, 327680},                     // ./calculate_display_angles.sh 5 15          distance from player to center of display = 5 world units, display width = 15 world units
    {3069, 65464, 3068, 328039},
    {6126, 65249, 6117, 329116},
    {9155, 64897, 9126, 330904},
    {12146, 64413, 12077, 333390},
    {15087, 63806, 14954, 336559},
    {17967, 63088, 17743, 340393},
    {20778, 62269, 20432, 344869},
    {23512, 61363, 23011, 349962},
    {26163, 60382, 25473, 355646},
    {28726, 59340, 27815, 361893},
    {31199, 58248, 30034, 368675},
    {33579, 57119, 32129, 375962},
    {35866, 55963, 34102, 383726},
    {38060, 54791, 35956, 391939},
    {40161, 53610, 37694, 400572},
    {42172, 52428, 39321, 409600},
    {44094, 51253, 40842, 418996},
    {45931, 50088, 42262, 428736},
    {47684, 48940, 43587, 438799},
    {49358, 47810, 44822, 449161},
    {50955, 46704, 45974, 459803},
    {52480, 45622, 47048, 470705},
    {53934, 44567, 48049, 481851},
    {55322, 43539, 48982, 493223},
    {56647, 42540, 49852, 504807},
    {57912, 41570, 50664, 516587},
    {59120, 40629, 51421, 528551},
    {60274, 39717, 52129, 540687},
    {61378, 38834, 52790, 552983},
    {62433, 37979, 53408, 565429},
    {63442, 37152, 53987, 578016}
};

...

void TanksMainScreen::calculateRay(Vector &ray, fixedpoint_t &distToDisplay, int32_t x) {     // x = -31..31
    ray = this->player;
    fixedpoint_t cosine = 1;
    fixedpoint_t sine = 0;
    if (x < 0) {
        cosine = DISPLAY_ANGLES_AND_DISTANCES[-x].cosineAngle;
        sine = DISPLAY_ANGLES_AND_DISTANCES[-x].sineAngle;
        distToDisplay = DISPLAY_ANGLES_AND_DISTANCES[-x].distance;
    }
    else {
        cosine = DISPLAY_ANGLES_AND_DISTANCES[x].cosineAngle;
        sine = -DISPLAY_ANGLES_AND_DISTANCES[x].sineAngle;
        distToDisplay = DISPLAY_ANGLES_AND_DISTANCES[x].distance;
    }
    ray.rotate(cosine, sine);
}

const Angle TanksMainScreen::ANGLES[16] = {              // 16 angles (cosines and sines) for first quadrant (other quadrant values are calculated changing cos/sin signs)
    {65536, 0},                                          // ./calculate_dir_vector.sh 16
    {65220, 6423},
    {64276, 12785},
    {62714, 19024},
    {60547, 25079},
    {57797, 30893},
    {54491, 36409},
    {50660, 41575},
    {46340, 46340},
    {41575, 50660},
    {36409, 54491},
    {30893, 57797},
    {25079, 60547},
    {19024, 62714},
    {12785, 64276},
    {6423, 65220}
};

...

void TanksMainScreen::fillAngle(Angle &a, const uint8_t i) {
    if (i < 16)
        a = ANGLES[ i ];
    else if ((i >= 16) && (i < 32)) {
        a.cosine = -ANGLES[i - 16].sine;
        a.sine = ANGLES[i - 16].cosine;
    }
    else if ((i >= 32) && (i < 48)) {
        a.cosine = -ANGLES[i - 32].cosine;
        a.sine = -ANGLES[i - 32].sine;
    }
    else if (i >= 48) {
        a.cosine = ANGLES[i - 48].sine;
        a.sine = -ANGLES[i - 48].cosine;
    }
}

...

void TanksMainScreen::rotatePlayer(RotateTo t) {
    if (t == RotateTo::LEFT)
        this->playerAngle = (this->playerAngle + 1) & 0x3F;   // 0..63
    else if (t == RotateTo::RIGHT)
        this->playerAngle = (this->playerAngle + 64 - 1) & 0x3F;   // 0..63
    Angle a;
    fillAngle(a, this->playerAngle);
    this->player.dir.x = a.cosine;
    this->player.dir.y = a.sine;
}

    static const int32_t BOARD_WIDTH = 10;
    static const int32_t BOARD_HEIGHT = 20;
    static const int32_t BOARD_SIZE = BOARD_WIDTH * BOARD_HEIGHT;
    uint8_t board[BOARD_SIZE]            __attribute__ ((aligned(4)));

class TetrisFigure {
    public:
        static const int32_t MAX_WIDTH = 4;
        static const int32_t MAX_SIZE = MAX_WIDTH * MAX_WIDTH;
        int32_t width;
        int32_t height;
        uint8_t data[MAX_SIZE]  __attribute__ ((aligned(4)));
        TetrisFigure &operator = (const TetrisFigure &other);
        void rotateInto(TetrisFigure &other);
        void rotate();
};

...

const TetrisFigure TetrisMainScreen::FIGURES[7] = {
    {
        4,
        1,
        {
            1, 1, 1, 1,
            0, 0, 0, 0,
            0, 0, 0, 0,
            0, 0, 0, 0
        }
    },
    {
        3,
        2,
        {
            1, 1, 0, 0,
            0, 1, 1, 0,
            0, 0, 0, 0,
            0, 0, 0, 0
        }
    },
    {
        3,
        2,
        {
            0, 1, 1, 0,
            1, 1, 0, 0,
            0, 0, 0, 0,
            0, 0, 0, 0
        }
    },
    {
        3,
        2,
        {
            1, 1, 1, 0,
            0, 0, 1, 0,
            0, 0, 0, 0,
            0, 0, 0, 0
        }
    },
    {
        3,
        2,
        {
            1, 1, 1, 0,
            1, 0, 0, 0,
            0, 0, 0, 0,
            0, 0, 0, 0
        }
    },
    {
        3,
        2,
        {
            0, 1, 0, 0,
            1, 1, 1, 0,
            0, 0, 0, 0,
            0, 0, 0, 0
        }
    },
    {
        2,
        2,
        {
            1, 1, 0, 0,
            1, 1, 0, 0,
            0, 0, 0, 0,
            0, 0, 0, 0
        }
    }
};

Screen *TetrisMainScreen::onUpdate() {
    bool boardChanged = false;
    uint8_t b = this->buttons.getValue();
    LevelChanged levelChanged = LevelChanged::NO;
    if (this->status == St::NEW_FIGURE) {
        this->generateNewRandomFigure();
        this->nextFigureChanged = true;
        this->figureX = this->rnd.getNextValue() % (10 - this->figure.width);
        this->figureY = 0;
        if (this->getFigureValidAt(this->figure, this->figureX, this->figureY)) {
            this->status = St::FALLING;
            this->ticksBetweenMovs = this->initialTicksBetweenMovs;
            boardChanged = true;
        }
        else {
            this->status = St::GAME_OVER;    // game over is a dead state (console must be reseted)
        }
    }
    else if (this->status == St::FALLING) {
        this->ticksBetweenMovs--;
        if ((this->ticksBetweenMovs <= 0) || (b & Buttons::MASK_DOWN)) {
            if (this->getCanMoveFigureTo(Direction::DOWN)) {
                this->figureY++;
            }
            else {
                this->finalizeFigure(levelChanged);
                this->status = St::NEW_FIGURE;
            }
            if (this->ticksBetweenMovs <= 0)
                this->ticksBetweenMovs = this->initialTicksBetweenMovs;
            boardChanged = true;
        }
        else if ((b & Buttons::MASK_A) && this->getCanRotateFigure()) {
            this->figure.rotate();
            boardChanged = true;
        }
        else if ((b & Buttons::MASK_LEFT) && this->getCanMoveFigureTo(Direction::LEFT)) {
            this->figureX--;
            boardChanged = true;
        }
        else if ((b & Buttons::MASK_RIGHT) && this->getCanMoveFigureTo(Direction::RIGHT)) {
            this->figureX++;
            boardChanged = true;
        }
    }
    if (boardChanged) {
        this->updateBoardWithFigure();
        if (levelChanged == LevelChanged::YES)
            this->drawLevelLabel();
        this->drawBoardWithFigureOnFrameBuffer();
        if (this->nextFigureChanged) {
            this->drawNextFigureOnFrameBuffer();
            this->nextFigureChanged = false;
        }
        this->display.notifyFrameBufferChanged();
    }
    return nullptr;
}

frameBuffer[(y * 128) + x] = 1;     // encender pixel (x, y)
frameBuffer[(y * 128) + x] = 0;     // apagar pixel (x, y)

class InterScreenData {
}; 
    
class Screen;

class Screen {
    public:
        virtual void onLoad(InterScreenData *dataFromPreviousScreen) = 0;
        virtual Screen *onUpdate() = 0;
        virtual InterScreenData *onUnload() = 0;
};

class ScreenManager : public Task {
    public:
        Screen *currentScreen;
        ScreenManager(Screen &initialScreen, InterScreenData *initialInterScreenData);
        virtual void run();
};

ScreenManager::ScreenManager(Screen &initialScreen, InterScreenData *initialInterScreenData) : currentScreen(&initialScreen) {
    this->currentScreen->onLoad(initialInterScreenData);
}   

void ScreenManager::run() {
    Screen *nextScreen = this->currentScreen->onUpdate();
    if ((nextScreen != this->currentScreen) && (nextScreen != nullptr)) {
        InterScreenData *isd = this->currentScreen->onUnload();
        nextScreen->onLoad(isd);
        this->currentScreen = nextScreen;
    }
}

int main() {
    // init hardware
    interruptInit();
    RGBLed::init();
    GPIOButtons buttons;
    Random random(buttons);
    SPIGMG12864Display display;
    display.blank();
    // create screens
    InitialSplashScreen initialSplashScreen(display, buttons);
    MainMenuScreen mainMenuScreen(display, buttons);
    TetrisMainScreen tetrisMainScreen(display, buttons, random);
    TanksMainScreen tanksMainScreen(display, buttons, random);
    SnakeMainScreen snakeMainScreen(display, buttons, random);
    SnoopyMainScreen snoopyMainScreen(display, buttons, random);
    // link screens
    initialSplashScreen.setNextScreen(mainMenuScreen);
    mainMenuScreen.setBackScreen(initialSplashScreen);
    mainMenuScreen.setTetrisScreen(tetrisMainScreen);
    mainMenuScreen.setTanksScreen(tanksMainScreen);
    mainMenuScreen.setSnakeScreen(snakeMainScreen);
    mainMenuScreen.setSnoopyScreen(snoopyMainScreen);
    // main loop
    ScreenManager m(initialSplashScreen, nullptr);
    MyListener myListener(display, buttons, m);
    Timer::init(myListener, 20_msForTimer);
    while (true)
        asm volatile ("wfi");
}

    img.header.jump_instruction =	/* b instruction */
        0xEA000000 | /* jump to the first instruction after the header */
        (
            (sizeof(boot_file_head_t) / sizeof(int) - 2)
            & 0x00FFFFFF
        );

    u32 code_offset = sizeof(boot_file_head_t);
    img.header.jump_instruction =	/* risc-v "jal" instruction */
        (((code_offset >> 20) & 1) << 31) |
        (((code_offset >> 1) & 0x3FF) << 21) |
        (((code_offset >> 11) & 1) << 20) |
        (((code_offset >> 12) & 0xFF) << 12) |
        0x00000006F;

#include <stdint.h>

void spl() __attribute__ ((naked, section(".spl")));

#define  WAIT       40000000ULL
#define  GPIO_BASE  0x02000000
#define  PC_CFG     *((uint32_t *) (GPIO_BASE + 0x0060))
#define  PC_DAT     *((uint32_t *) (GPIO_BASE + 0x0070))
#define  PC_PULL0   *((uint32_t *) (GPIO_BASE + 0x0084))

void spl() {
    PC_CFG = (PC_CFG & 0xFFFFFF0F) | 0x00000010;       // PC1 = output
    PC_PULL0 = (PC_PULL0 & 0xFFFFFFF3) | 0x00000008;   // PC1 = pull-down
    while (true) {
        PC_DAT |= 0x00000002;     // PC1 = 1
        for (uint64_t n = 0; n < WAIT; n++)
            ;
        PC_DAT &= 0xFFFFFFFD;     // PC1 = 0
        for (uint64_t n = 0; n < WAIT; n++)
            ;
    }
}

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

entity Max1000TRNG is
    port  (
        ClkIn : in std_logic;
        Led1Out : out std_logic;
        Led2Out : out std_logic;
        Led3Out : out std_logic;
        Led4Out : out std_logic;
        Led5Out : out std_logic;
        Led6Out : out std_logic;
        Led7Out : out std_logic;
        Led8Out : out std_logic;
        Star1Out : out std_logic;
        Star2Out : out std_logic;
        Star3Out : out std_logic;
        Star4Out : out std_logic;
        Star5Out : out std_logic;
        Star6Out : out std_logic;
        Star7Out : out std_logic;
        Star8Out : out std_logic
    );
end entity;

architecture A of Max1000TRNG is
    signal CounterD : std_logic_vector(23 downto 0);
    signal CounterQ : std_logic_vector(23 downto 0);
    signal FreeOsc1A : std_logic;
    signal FreeOsc1B : std_logic;
    signal FreeOsc1C : std_logic;
    signal FreeOsc1D : std_logic;
    signal FreeOsc1E : std_logic;
    signal FreeOsc2A : std_logic;
    signal FreeOsc2B : std_logic;
    signal FreeOsc2C : std_logic;
    signal FreeOsc2D : std_logic;
    signal FreeOsc2E : std_logic;
    attribute keep : boolean;
    attribute keep of FreeOsc1A : signal is true;
    attribute keep of FreeOsc1B : signal is true;
    attribute keep of FreeOsc1C : signal is true;
    attribute keep of FreeOsc1D : signal is true;
    attribute keep of FreeOsc1E : signal is true;
    attribute keep of FreeOsc2A : signal is true;
    attribute keep of FreeOsc2B : signal is true;
    attribute keep of FreeOsc2C : signal is true;
    attribute keep of FreeOsc2D : signal is true;
    attribute keep of FreeOsc2E : signal is true;
    signal RandomD : std_logic_vector(7 downto 0);
    signal RandomQ : std_logic_vector(7 downto 0);
    signal LatchD : std_logic_vector(7 downto 0);
    signal LatchQ : std_logic_vector(7 downto 0);
begin
    process (ClkIn)
    begin
        if (ClkIn'event and (ClkIn = '1')) then
            CounterQ <= CounterD;
            RandomQ <= RandomD;
            LatchQ <= LatchD;
        end if;
    end process;

    -- free oscillator 1
    FreeOsc1A <= not(FreeOsc1E);
    FreeOsc1B <= not(FreeOsc1A);
    FreeOsc1C <= not(FreeOsc1B);
    FreeOsc1D <= not(FreeOsc1C);
    FreeOsc1E <= not(FreeOsc1D);
    -- free oscillator 2
    FreeOsc2A <= not(FreeOsc2E);
    FreeOsc2B <= not(FreeOsc2A);
    FreeOsc2C <= not(FreeOsc2B);
    FreeOsc2D <= not(FreeOsc2C);
    FreeOsc2E <= not(FreeOsc2D);
    -- random bit generated from jittering between free oscillators
    RandomD <= RandomQ(6 downto 0) & (FreeOsc1A xor FreeOsc2A);
    -- latch the random number every time counter overflows
    CounterD <= std_logic_vector(unsigned(CounterQ) + 1);
    LatchD <= RandomQ when (CounterQ = std_logic_vector(to_unsigned(0, 24))) else
              LatchQ;
    Led1Out <= LatchQ(0);
    Led2Out <= LatchQ(1);
    Led3Out <= LatchQ(2);
    Led4Out <= LatchQ(3);
    Led5Out <= LatchQ(4);
    Led6Out <= LatchQ(5);
    Led7Out <= LatchQ(6);
    Led8Out <= LatchQ(7);
    Star1Out <= LatchQ(0);
    Star2Out <= LatchQ(1);
    Star3Out <= LatchQ(2);
    Star4Out <= LatchQ(3);
    Star5Out <= LatchQ(4);
    Star6Out <= LatchQ(5);
    Star7Out <= LatchQ(6);
    Star8Out <= LatchQ(7);
end architecture;