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.

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.

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.

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.

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.