Versión: 0.47, de 10-Jul-2011


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:

Con un poco más de detalle, lo que tendría que hacer nuestro programa será lo siguiente:
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; 
        } 
    } 
 
    /* Pequeña pausa antes de seguir */ 
    rest ( PAUSA ); 
 
  } 
  while (TRUE);/* Repetimos indefininamente */ 
               /* (la condición 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.

Anterior Siguiente