6. Evitemos esperar al teclado. Tercer juego: motos de luz.
Contenido de este apartado:
6.1. Ideas generales.
En la mayoría de los juegos no ocurre lo que en el anterior: no podemos permitirnos que el ordenador que "parado " esperando a que se pulse una tecla, sino que la acción debe proseguir aunque nosotros no toquemos el teclado.
Esto es muy fácil de conseguir. Entre la rutinas estándar de casi cualquier compilador de C tenemos la función kbhit(), que devuelve "verdadero" (distinto de cero) si se ha pulsado alguna tecla y "falso" (cero) si no se ha pulsado ninguna. Posteriormente, con getch( ) sabríamos exactamente qué tecla es la que se ha pulsado y vaciaríamos el "buffer" (memoria intermedia) del teclado para que se pudieran seguir comprobando nuevas teclas.
En el caso de Allegro, la rutina que comprueba si hemos pulsado alguna tecla se llama keypressed( ), y en la práctica podríamos hacer cosas como esta para que el programa no se pare pero a la vez esté pendiente de qué teclas pulsemos:
do{
/*Actualizar reloj y pantalla, mover nave, etc */
}
while ( ! keypressed () );
teclaPulsada = readkey();
Al principio del programa deberemos añadir la línea "install_keyboard()" para tener acceso a estas rutinas de manejo de teclado.
En el caso de Pascal (Free Pascal) es muy similar, incluso con los mismos nombres de funciones auxiliares (que están en la unidad CRT):
repeat
(*
Actualizar reloj y
pantalla, mover
nave, etc *)
until
keypressed;
teclaPulsada := readkey;
Para Java... existe una dificultad en este juego con una de las cosas que no hemos comentado aún, y que surgirá enseguida...
Vamos a aplicarlo a un primer juego de habilidad, el clásico de las "motos de luz" (si alguien recuerda la película Tron, quizá sepa a qué me refiero; si no se conoce esa película, la imagen inferior dará un pista de lo que perseguimos). La idea es la siguiente:
- Participan dos jugadores.
- Cada uno de los jugadores maneja una "moto", que va dejando un rastro cuando se desplaza.
- Si una de las motos "choca" con el rastro dejado por la otra, o por ella misma, o con el borde de la pantalla, estalla y pierde la partida.
- Por tanto, el objetivo es "arrinconar" al contrario sin ser arrinconado antes por él.
- Borrar la pantalla y dibujar un recuadro alrededor de ella.
- Preparar las variables iniciales: dirección de cada jugador (incremento en X e Y de la posición de cada uno). En el instante inicial, las motos se desplazarán en direcciones contrarias. En un juego "más real", este incremento podría ser variable (o disminuir el tiempo de pausa entre un movimiento y otro), de modo que las motos circularan cada vez más deprisa, para mayor dificultad.
- Parte repetitiva:
- Si la siguiente posición de alguna de las motos está ocupada, la moto estalla y ese jugador ha perdido: se acabó el juego.
- Desplazar las motos a su siguiente posición.
- Si se ha pulsado alguna tecla, analizar esta tecla y cambiar la dirección de la moto según corresponda.
- Pausa fija (o variable según la dificultad) antes de la siguiente repetición, fijada por nuestro programa, para que la velocidad no dependa de la rapidez del ordenador que se utilice.
- Repetir indefinidamente (la condición de salida la comprobamos "dentro").
Eso de que una moto choque con otra... suena difícil, pero en este primer caso nos bastará con mirar el punto de la pantalla al que nos vamos a mover. Si ese punto tiene un color distinto del fondo, habremos chocado (quizá sea con el borde de la pantalla, quizá con nuestra estela, quizá con la del otro jugador... pero eso nos da igual).
Ese es el problema en el caso de Java: no se puede leer un punto de la pantalla con esa facilidad, lo que nos obligaría a "memorizar" de otra forma las posiciones que no se pueden tocar. No es difícil, pero es algo que veremos dentro de poco, así que aplazamos un poco la versión en Java de este juego.
Lo único que aún no sabemos hacer es la pausa. Con C y Allegro usaremos la función
rest(n);
(donde "n" es el tiempo en milisegundos), que requiere que antes hayamos instalado el manejador de temporizadores (también será necesario para otras cosas, por ejemplo cuando accedamos al ratón, y al reproducir ciertos tipos de animaciones y de ficheros musicales) con:
install_timer():
En Pascal,
la pausa de "n" milisegundos se haría con
delay(n);
Y en Java (que insisto que no usaremos aún en este ejemplo), la pausa sería
try {
Thread.sleep( n );
}
catch ( InterruptedException e ) {
}
pero nos obligará también a hacer algunos cambios más en la estructura del fuente.
La apariencia del juego será también sencilla, así:
6.2 Las motos en C.
Debería ser fácil de seguir.../*----------------------------*/ /* Intro a la programac de */ /* juegos, por Nacho Cabanes */ /* */ /* ipj06c.c */ /* */ /* Quinto ejemplo: juego de */ /* "motos de luz" */ /* */ /* Comprobado con: */ /* - Djgpp 2.03 (gcc 3.2) */ /* y Allegro 4.02 - MsDos */ /* - MinGW 2.0.0-3 (gcc 3.2) */ /* y Allegro 4.02 - Win 98 */ /*----------------------------*/ #include <allegro.h> /* Posiciones X e Y iniciales de ambos jugadores */ #define POS_X_INI_1 150 #define POS_X_INI_2 170 #define POS_Y_INI_1 100 #define POS_Y_INI_2 100 #define INC_X_INI_1 -1 #define INC_X_INI_2 1 #define INC_Y_INI_1 0 #define INC_Y_INI_2 0 /* Pausa en milisegundos entre un "fotograma" y otro */ #define PAUSA 150 /* Teclas predefinidas para cada jugador */ #define TEC_ARRIBA_1 KEY_E #define TEC_ABAJO_1 KEY_X #define TEC_IZQDA_1 KEY_S #define TEC_DCHA_1 KEY_D #define TEC_ARRIBA_2 KEY_8_PAD #define TEC_ABAJO_2 KEY_2_PAD #define TEC_IZQDA_2 KEY_4_PAD #define TEC_DCHA_2 KEY_6_PAD int posX1, posY1, posX2, posY2; /* Posiciones actuales */ int incX1, incY1, incX2, incY2; /* Incremento de la posicion */ int futX1, futY1, futX2, futY2; /* Posiciones futuras */ /* Si ha chocado alguna moto */ int chocado; /* La tecla pulsada */ int tecla; int main() { allegro_init(); /* Inicializamos Allegro */ install_keyboard(); install_timer(); /* Intentamos entrar a modo grafico */ if (set_gfx_mode(GFX_SAFE,320,200,0,0)!=0){ set_gfx_mode(GFX_TEXT,0,0,0,0); allegro_message( "Incapaz de entrar a modo grafico\n%s\n", allegro_error); return 1; } /* Si todo ha ido bien: empezamos */ /* Rectangulo amarillo alrededor */ rect(screen,0,0,319,199, palette_color[14]); /* Valores iniciales */ posX1 = POS_X_INI_1; posX2 = POS_X_INI_2; posY1 = POS_Y_INI_1; posY2 = POS_Y_INI_2; incX1 = INC_X_INI_1; incX2 = INC_X_INI_2; incY1 = INC_Y_INI_1; incY2 = INC_Y_INI_2; /* Parte repetitiva: */ do { chocado = FALSE; /* Compruebo si alguna va a colisionar */ futX1 = posX1 + incX1; futX2 = posX2 + incX2; futY1 = posY1 + incY1; futY2 = posY2 + incY2; if (getpixel(screen, futX1, futY1)!=0){ textout(screen, font, "La moto 1 ha chocado!", 100,90, palette_color[13]); chocado =TRUE; } if (getpixel(screen, futX2, futY2)!=0){ textout(screen, font, "La moto 2 ha chocado!", 100,110, palette_color[12]); chocado = TRUE; } if (chocado)break; /* Si ninguna ha colisionado, avanzan */ line (screen, posX1, posY1, futX1, futY1, palette_color[13]); posX1 = futX1; posY1 = futY1; line (screen, posX2, posY2, futX2, futY2, palette_color[12]); posX2 = futX2; posY2 = futY2; /* Compruebo si se ha pulsado alguna tecla */ if ( keypressed() ){ tecla = readkey() >>8; switch(tecla){ case TEC_ARRIBA_1: incX1 = 0; incY1 = -1;break; case TEC_ABAJO_1: incX1 = 0; incY1 = 1;break; case TEC_IZQDA_1: incX1 = -1; incY1 = 0;break; case TEC_DCHA_1: incX1 = 1; incY1 = 0;break; case TEC_ARRIBA_2: incX2 = 0; incY2 = -1;break; case TEC_ABAJO_2: incX2 = 0; incY2 = 1;break; case TEC_IZQDA_2: incX2 = -1; incY2 = 0;break; case TEC_DCHA_2: incX2 = 1; incY2 = 0;break; } } /* Pequea pausa antes de seguir */ rest ( PAUSA ); } while (TRUE);/* Repetimos indefininamente */ /* (la condicin de salida la comprobamos "dentro") */ readkey(); return 0; } /* Termino con la "macro" que me pide Allegro */ END_OF_MAIN();
6.3. Las motos desde Pascal.
Muuuuy parecido a la versión en C:(*----------------------------*) (* Intro a la programac de *) (* juegos, por Nacho Cabanes *) (* *) (* IPJ06P.PAS *) (* *) (* Sexto ejemplo: juego de *) (* "motos de luz" *) (* *) (* Comprobado con: *) (* - FreePascal 1.10 (Dos) *) (* - FreePascal 2.0 -Windows *) (*----------------------------*) uses graph, crt; (* Cambiar por "uses wincrt, ..." bajo Windows *) const (* Posiciones X e Y iniciales de ambos jugadores *) POS_X_INI_1 = 150; POS_X_INI_2 = 170; POS_Y_INI_1 = 100; POS_Y_INI_2 = 100; INC_X_INI_1 = -1; INC_X_INI_2 = 1; INC_Y_INI_1 = 0; INC_Y_INI_2 = 0; (* Pausa en milisegundos entre un "fotograma" y otro *) PAUSA = 150; (* Teclas predefinidas para cada jugador *) TEC_ARRIBA_1 = 'E'; TEC_ABAJO_1 = 'X'; TEC_IZQDA_1 = 'S'; TEC_DCHA_1 = 'D'; TEC_ARRIBA_2 = '8'; TEC_ABAJO_2 = '2'; TEC_IZQDA_2 = '4'; TEC_DCHA_2 = '6'; var posX1, posY1, posX2, posY2: integer; (* Posiciones actuales *) incX1, incY1, incX2, incY2: integer; (* Incremento de la posicion *) futX1, futY1, futX2, futY2: integer; (* Posiciones futuras *) (* Si ha chocado alguna moto *) chocado: boolean; (* La tecla pulsada *) tecla:char; var gd,gm, error : integer; begin gd := D8bit; gm := m320x200; (* Si falla bajo Windows, probar gd:=0; gm:=0; *) initgraph(gd, gm, ''); (* Intentamos entrar a modo grafico *) error := graphResult; if error <> grOk then begin writeLn('No se pudo entrar a modo grafico'); writeLn('Error encontrado: '+ graphErrorMsg(error) ); halt(1); end; (* Si todo ha ido bien: empezamos *) (* Rectangulo amarillo alrededor *) setcolor(14); rectangle(0,0, 319, 199); (* Valores iniciales *) posX1 := POS_X_INI_1; posX2 := POS_X_INI_2; posY1 := POS_Y_INI_1; posY2 := POS_Y_INI_2; incX1 := INC_X_INI_1; incX2 := INC_X_INI_2; incY1 := INC_Y_INI_1; incY2 := INC_Y_INI_2; (* Parte repetitiva: *) repeat chocado := FALSE; (* Compruebo si alguna va a colisionar *) futX1 := posX1 + incX1; futX2 := posX2 + incX2; futY1 := posY1 + incY1; futY2 := posY2 + incY2; if (getpixel(futX1, futY1) <> 0) then begin SetColor(13); OutTextXY( 100, 90, 'La moto 1 ha chocado!'); chocado := TRUE; end; if (getpixel(futX2, futY2) <> 0) then begin SetColor(12); OutTextXY( 100, 110, 'La moto 2 ha chocado!'); chocado := TRUE; end; if chocado then break; (* Si ninguna ha colisionado, avanzan *) setColor(13); line (posX1, posY1, futX1, futY1); posX1 := futX1; posY1 := futY1; setColor(12); line (posX2, posY2, futX2, futY2); posX2 := futX2; posY2 := futY2; (* Compruebo si se ha pulsado alguna tecla *) if keypressed then begin tecla := upcase(readkey); case tecla of TEC_ARRIBA_1: begin incX1 := 0; incY1 := -1; end; TEC_ABAJO_1: begin incX1 := 0; incY1 := 1; end; TEC_IZQDA_1: begin incX1 := -1; incY1 := 0; end; TEC_DCHA_1: begin incX1 := 1; incY1 := 0; end; TEC_ARRIBA_2: begin incX2 := 0; incY2 := -1; end; TEC_ABAJO_2: begin incX2 := 0; incY2 := 1; end; TEC_IZQDA_2: begin incX2 := -1; incY2 := 0; end; TEC_DCHA_2: begin incX2 := 1; incY2 := 0; end; end; end; (* Pequea pausa antes de seguir *) delay ( PAUSA ); until FALSE; (* Repetimos indefininamente *) (* (la condicin de salida la comprobamos "dentro") *) readkey(); end.
6.4. Problemas en el caso de Java.
Como hemos dicho en la introducción, en el caso de Java, la situación se complica ligeramente, porque no tenemos ninguna función que nos diga cual es el color de un punto de la pantalla. Así que para imitar el funcionamiento de las versiones anteriores, tendríamos que "memorizar" el contenido de cada punto de la pantalla. Supone guardar información sobre 320x200 = 64.000 puntos. Hay al menos un par de formas de hacerlo, y las dos son sencillas, pero para llevar un poco de orden, lo aplazamos... el próximo tema nos ayudará a entender lo que nos falta.
También será en el próximo apartado donde veamos cómo hacer eso de que nuestro juego "avance" cada cierto tiempo, incluso aunque no se pulse una tecla.