En el ejemplo siguiente voy a desarrollar un juego de Tetris utilizando C++.
Tetris
fue diseñado por Alexey Pajitnov en 1984, en una computadora
Electronika 60 cuando
trabajaba en la Academia Soviética de Ciencias.
Durante el juego
las piezas caen desde la parte superior de la pantalla, y se apilan a
medida que se depositan sobre la parte inferior, o sobre las piezas
anteriores que se van acumulando. Los tipos de piezas son 7 en total,
todos con diferentes formas (algunos son el inverso de otros). El
objetivo del juego es lograr colocar las piezas de forma tal que no
queden espacios entre una y otra. Para esto, el jugador puede
rotarlas antes de que lleguen a apilarse. Cada vez que una linea
horizontal ha sido completada la misma desaparece y las piezas que
estaban acumuladas sobre esta linea caen una linea hacia abajo
permitiendo así que el juego continúe. Finalmente el juego concluye
cuando las piezas apiladas han alcanzado la parte superior de la
pantalla.
Consideraciones generales:
En principio este juego comprende varios desafíos. Vamos a
enumerarlos para poder desarrollar más fácilmente su resolución.
Necesitamos resolver:
-El formato de diseño de las piezas y su rotación.
-La forma en que se van a almacenar las piezas apiladas.
-El control de colisión para que las piezas puedan detener el
movimiento y apilarse.
Sabemos
que será necesario implementar un loop
principal que mantendrá a las piezas siempre cayendo, cambiando de
pieza y comenzando nuevamente cada vez que una se apila.
Ahora
vamos a ir viendo como se resuelven estos tres problemas principales
en cada una de las tres clases
que utilizaremos para este proyecto.
Al igual que en los ejemplos anteriores, al final de este artículo se encuentra el link del proyecto, listo para descargar y compilar.
Sobre el enfoque del código,
objetos y clases
El lenguaje de programación que vamos a utilizar es C++. Este es un
lenguaje orientado a objetos así que vamos a hacer uso de las características propias del lenguaje.
El compilador utilizado fue GNU GCC
con el IDE CodeBlocks.
Para mantener la simplicidad no utilizaré en este ejemplo ningún
tipo de librerías gráficas, pero sí una técnica muy interesante de
buffering doble en consola mediante el API de Windows.
Vamos
a dividir el proyecto en 3 clases:
la clase Piezas, la clase Tablero, y la clase Tetris que será la
clase principal del juego.
La clase 'Piezas':
Vamos a tratar aquí el primer problema: el diseño y rotación de
piezas.
Para saber como diseñarlas tenemos que saber primero como es que van
a rotar. Esto podemos conseguirlo de dos maneras. Podemos crear una
pieza de cada tipo y luego utilizar una formula para leerla en otros
sentidos durante la ejecución del programa, o también podemos
almacenar cada pieza con sus 4 rotaciones ya predefinidas. La forma
que vamos a utilizar es esta ultima.
Habiendo definido lo anterior llegamos a la conclusión de que vamos
a necesitar un array de, por lo menos, 2 dimensiones: una para la
cantidad de piezas (7), y otra para cada rotación de cada pieza (4).
Ahora bien, la pieza mas pequeña (el cuadrado) requiere una matriz
de 2x2 para ser almacenada, y la pieza mas extensa (el palito)
requiere una matriz de 4x4. Para poder utilizar un mismo array para
todas las piezas vamos a tener que tomar como parámetro el tamaño
de la pieza mas grande. Sin embargo, para poder realizar una correcta
rotación de cada una de las piezas debemos respetar un eje de
rotación central, lo cual no nos permitiría emplear una matriz de
4x4, de manera tal que tendremos que utilizar una de 5x5. Así es como
finalmente el array que necesitamos para poder almacenar todas las
piezas es un array de 4 dimensiones: [7][4][5][5].
Ahora
necesitamos inicializar el array
en la clase Piezas. Según los principios del paradigma orientado a
objetos y las normas ISO C++ un array no puede (y no debería poder)
ser inicializado dentro de una clase. En el plano teórico esto es
correcto, desde el punto de vista práctico nos resultaría muy
conveniente poder definir las piezas dentro de la clase Piezas. Ya
que no podemos utilizar la notación de lista para la inicialización
del array (sólo se puede usar en la declaración del mismo, que ya
fue declarado en el header)
y es muy impráctico cargar los valores uno por uno, vamos a realizar
un pequeño hack
Utilizaremos un array de caracteres y copiaremos los valores al array
utilizando la función strcpy()
de strings.h.
Hemos
resuelto de esta manera uno de los principales problemas del proyecto
utilizando un array de tipo char.
Como estos datos son de acceso privado tendremos que hacer también
una función get para poder acceder a los mismos desde afuera
de la clase.
A continuación vemos el código completo de la clase 'Piezas' y el
header correspondiente:
La clase
'Tablero':
Para representar el tablero vamos a utilizar una matriz de dos
dimensiones. Nuestro tablero de juego va a tener 20x20 y necesitamos
agregar 4 bordes que marquen los límites con lo cual vamos a
necesitar una matriz de 22x22.
La
matriz, de tipo int,
será inicializada con el valor 0 en todos los indices a excepción
de los bordes que serán inicializados en 1. Esto queda expuesto en el
método inicializo().
También
vamos a tener que utilizar métodos get
y set
para poder leer y escribir los campos privados desde afuera de la
clase.
El funcionamiento del tablero es simple. Las piezas iran avanzando
por la pantalla, al momento de detenerse y apilarse (determinado por
la detección de colisión) tomaremos los valores de posición que
utilizamos para imprimir la pieza en pantalla y los utilizaremos para
determinar su posición en la matriz. Una vez determinada la misma le
asignaremos el valor 1 a cada indice de la matriz que coincida con un
bloque sólido de la pieza. Podemos observar este mecanismo en el
método imprimoEnMatriz(Piezas, int, int, int, int) que recibe
como parámetros un objeto Piezas que contiene todas las piezas, el
nro de pieza, el nro de rotación, la posición de la pieza sobre el
eje X y la posición sobre el eje Y.
Una vez almacenados en la matriz no será un problema mostrar en
pantalla el tablero con los espacios ocupados imprimiendo bloques en
los lugares donde el valor sea 1 y espacios en blanco donde el valor
sea 0.
Tambiénqueda listo el tablero para poder realizar la detección de
colisión de las piezas nuevas con las piezas apiladas anteriormente.
Esto lo veremos en la clase 'Tetris'.
Incluiremos en esta clase dos funciones mas que servirán para
comprobar si hay lineas completas y para despejar las lineas
completas en caso de que las haya.
La primera recorre la matriz de abajo hacia arriba buscando las
lineas donde todos los elementos tengan asignado el valor 1, si
encuentra un 0 pasa a la próxima linea. Si encuentra una linea
completa guarda el numero de linea. El máximo de lineas completas
que se pueden realizar a la ves es 4 de manera que buscamos hasta 4
lineas completas y las almacenamos en un vector de 4 elementos. En
caso de que se encuentren menos lineas completas el resto de los
elementos tendrán asignado el valor 0.
La segunda función es la que despeja las lineas. Para eso se
posiciona en la linea detectada en LineasCompletas[] y a
partir de ahí recorre la matriz hacia arriba copiando cada linea un
lugar hacia abajo.
Vemos el código completo de la clase 'Tablero' y el header:
La clase 'Tetris':
Esta
es nuestra clase principal. Desde aquí vamos a instanciar a las
otras clases y también es donde encontramos el loop
de juego.
Un poco mas adelante en este artículo pasaremos a explicar todas las
funciones pero en esta visión general quisiera apuntar al núcleo
que hace funcionar el juego y que se encuentra en el corazón de esta
clase.
Sabemos
que para mostrar en pantalla una pieza que esta almacenada en una
matriz multidimensional de 5x5 necesitamos anidar dos bucles for
de 5 vueltas cada uno, de esta manera recorremos punto por punto la
pieza e imprimimos un bloque donde encontremos guardado un valor 1 y
un espacio en blanco donde encontremos un valor 0. Esto mostrará la
pieza en pantalla.
Si
además queremos que esta pieza se vaya moviendo en dirección hacia
abajo tenemos que agregar un tercer bucle for
que contenga los dos anteriores. Este le pasará su valor a la
función que posiciona el cursor para mostrar la pieza que lo
utilizará sumando su valor sobre el eje Y. A medida que el valor se
vaya incrementando la pieza irá avanzando hacia abajo por la
pantalla.
Nos
quedan así tres for
anidados: el primero desde adentro recorre las columnas de la pieza,
el segundo las filas, y el tercero actualiza su posición sobre el
eje Y.
Dentro
del primer for
que es el que itera con mas frecuencia y el que imprime los bloques y
espacios es donde vamos a realizar varias operaciones.
La primera de ellas será llamar a una función que comprueba si hay
colisión próxima. Para esto le pasamos a la función la posición
del elemento que estamos imprimiendo en pantalla. Dentro de la
función lo comparamos con las posiciones próximas hacia abajo y
hacia los lados en la matriz de acuerdo a donde esta la pieza en este
momento anticipándose a un posible próximo movimiento en cualquier
dirección. En tal caso si la colisión es detectada hacia los
laterales no nos permitirá seguir moviendo la pieza en esa
dirección, y si se detecta colisión hacia abajo detendrá
completamente el movimiento de la pieza para guardarla en la matriz y
que pase a ser parte del tablero.
Las otras operaciones que realizamos son para comprobar los valores
de la matriz del tablero mientras vamos imprimiendo la pieza en
pantalla. Si, por ejemplo, en el elemento 0-0 de la pieza actual hay
un espacio en blanco, pero en el tablero ese espacio esta ocupado por
una pared u otra pieza entonces ponemos en pantalla el bloque
correspondiente en vez de un espacio en blanco.
Queda expuesto de esta manera que es lo que necesitamos para resolver
el problema de la detección de colisiones y el movimiento de las
piezas.
Faltaría poder comprobar si es posible realizar una rotación o no.
Esta comprobación sera realizada cada vez que el jugador presione la
tecla de rotar y antes de hacer el movimiento. Vamos a resolverlo
mediante una función que anticipe la posición de la pieza rotada y
detecte si tiene o no espacio libre en esa posición.
Sobre el funcionamiento del
buffering doble en la consola:
Vamos
a utilizar una técnica muy sencilla de double
buffering
para poder redibujar la pantalla sin interrupciones.
Primero
vamos a inicializar el buffer 1 y el buffer 2 y crear los campos
necesarios para su utilización. Esto lo encontramos luego de la
declaración de funciones:
Le
asigno el buffer actual a buffer1,
luego creo un nuevo buffer y se lo asigno a buffer2.
Será
necesario crear un array que servirá para copiar temporalmente el
contenido que queremos copiar de un buffer al otro. Este sera de tipo
CHAR_INFO, lo cual nos permitirá tambien guardar la información de
color, y tendra el tamaño del numero total de caracteres de la
pantalla.
Voy
a necesitar también dos campos de tipo COORD, que almacenan cada uno
dos puntos (x e y) para guardar la posición de destino del buffer a
copiar y sus dimensiones.
Finalmente
creamos dos campos de tipo SMALL_RECT, que almacenan cada uno cuatro
puntos para guardar las dimensiones de la pantalla. Utilizaremos uno
para lectura y otro para escritura.
Al
comienzo del método main nos vemos a encontrar con la siguiente
linea:
De
esta manera establecemos que el buffer que vamos a estar viendo en
pantalla va a ser el segundo, o sea el que fue creado por nosotros.
A
partir de aquí lo que va a ocurrir es que el programa va a estar
redibujando la pantalla siempre en buffer1,
que permanece oculto, y cada vez que termine de dibujar va a copiar
el contenido de buffer1
en buffer2,
que es el que sale por pantalla. Esto lo vamos a realizar mediante la
función actualizarScreenBuffer()
que vemos a continuación:
Ahora
que han sido resueltos los problemas principales que plantea el
desarrollo de este ejemplo presento el código completo de la clase
'Tetris':
En
el header FUNC.H podremos encontrar algunas de las funciones que
hemos utilizado también en otros ejemplos:
De
esta manera queda presentado el proyecto completo de un juego de
Tetris en C++.
Hemos visto como resolver los principales problemas que encontramos en este tipo de juegos. También vimos características propias del lenguaje C++ y de la programación orientada a objetos, y utilizamos una técnica sencilla de double buffering en la consola mediante el API de Windows.
Links
de descarga del proyecto:
https://dl.dropbox.com/u/103165598/TetrisFinal.rar
