Volver al blog
Desarrollo / NOTAS DE DESARROLLO

Tetris para Mega Drive: piezas y colisiones con SGDK

Cómo representé las piezas, las rotaciones y el tablero de un Tetris escrito en C para Mega Drive.

Cartucho flash para Mega Drive

Volver a tener una Mega Drive me animó a probar algo que no había hecho de pequeño: desarrollar un juego para ella. El resultado fue una versión de Tetris escrita en C con SGDK.

Cartucho flash para Mega Drive

Preparar el entorno

SGDK es un kit de desarrollo para Mega Drive. En este proyecto utilicé Code::Blocks y un emulador para probar la ROM después de cada compilación. El archivo start.bat del repositorio recoge ese flujo de trabajo.

Proyecto SGDK en Code::Blocks

Representar las piezas

Los siete tetrominós se pueden describir mediante celdas. En esta implementación almaceno cuatro estados de rotación por pieza, aunque algunas piezas tengan estados visualmente equivalentes.

Estados de rotación de los tetrominós

Un valor cero representa una celda vacía; los demás valores identifican el tile que se debe dibujar. Cuatro cuadrículas de 4 × 4 ocupan 64 posiciones en un array.

const u8 piece[64] = {
    0,0,0,0,
    0,0,0,0,
    2,2,2,0,
    0,0,2,0,

    0,0,0,0,
    0,2,0,0,
    0,2,0,0,
    2,2,0,0,

    0,0,0,0,
    2,0,0,0,
    2,2,2,0,
    0,0,0,0,

    0,0,0,0,
    0,2,2,0,
    0,2,0,0,
    0,2,0,0
};

Recorrer una rotación

El índice de rotación va de 0 a 3. Cada estado ocupa 16 celdas, y el acceso por filas se calcula con offset + y * 4 + x.

const int offset = rot * 16; // rot: 0, 1, 2, 3
for (int y = 0; y < 4; ++y) {
    for (int x = 0; x < 4; ++x) {
        const u8 tile = piece[offset + y * 4 + x];
        // Dibujar tile si su valor no es cero.
    }
}

Esta revisión corrige el límite del bucle interior del ejemplo original y utiliza un orden por filas coherente con la representación del array.

Tablero y movimiento

El tablero tiene 10 columnas y 20 filas: 200 posiciones. Una pieza se puede mover si ninguna de sus celdas ocupadas sale de los límites o coincide con un bloque ya colocado.

Representación del tablero de Tetris

En el siguiente esquema, los nombres de los controles y del temporizador representan la entrada del jugador. La condición importante es mantener la misma convención: get_collision devuelve cero cuando el movimiento es válido.

if (left_pressed && get_collision(x - 1, y, rot) == 0) x--;
if (right_pressed && get_collision(x + 1, y, rot) == 0) x++;

if (gravity_tick || down_pressed) {
    if (get_collision(x, y + 1, rot) == 0) {
        y++;
    } else {
        inserta_pieza();
        crea_nueva_pieza();
    }
}

Comprobar cada celda ocupada

La función recorre la rotación activa y convierte cada índice local en coordenadas del tablero. Comprueba los límites antes de acceder al array. Las celdas que todavía quedan por encima del tablero no se utilizan como índices de memoria.

int get_collision(int posx, int posy, int rot) {
    const u8* piece = pieces[current_piece];
    int local_x, local_y;
    int off = piece_off * rot;
    int i;
    for(i = off; i < off + piece_off; ++i) {
        if(piece[i]) {
            local_y = (i - off) / piece_size + posy;
            if(local_y > 19) return 1;          // bottom collision
            local_x = (i % piece_size) + posx;
            if(local_x < 0) return 2;           // left collision
            if(local_x > 9) return 3;           // right collision
            if(local_y >= 0 && board[local_y * 10 + local_x]) { // board collision
                return 4;
            }
        }
    }
    return 0;
}

Seguir explorando

Estos fragmentos explican la representación y la detección de colisiones. El proyecto completo reúne la entrada, el dibujo y el resto de la partida. También puedes comparar el enfoque con la versión de Tetris en JavaScript.

Código fuente

Explorar el proyecto en GitHub

Escrito por Sergio Soriano

Desarrollo, curiosidad y proyectos compartidos.

Sobre Sergio Soriano