CONALEP #165

LIC. JESUS REYES HEROLES

Docente:
Miguel ngel Ramos Grande
Alumnos:
Brenda Cruz Mata
Jorge Alberto Hernndez Rojas
Francisco Javier Flores Romn
Modulo:
Programacin Para Videojuegos
Grupo:
604 Informtica

PRACTICA 6
USO DE MAPAS. JUEGO MINI SERPIENTE 1

Propsito de la prctica:
Elaborar un juego donde una figura va avanzando por la pantalla; si choca en la pared
exterior, con su propia cola o con algn otro obstculo, muere.

Escenario: Laboratorio de informtica Duracin: 2 hrs.



INTRODUCCIN:
En la prctica realizada el da lunes 19 de mayo hicimos un juego sobre una serpiente la
cual coma unas manzanas y si chocaba con la pared se mora pero si se coma 7 manzanas
ganaba.
DESARROLLO:
Colocamos la posicin inicial de nuestra serpiente. Definimos las letras con las cuales
moveremos la serpiente. Declaramos las variables necesarias como lo es cuando l juega a
terminado ya sea porque perdi o por haber ganado.
Lo primero que se tiene que hacer al iniciar el programa es colocar las bibliotecas que
utilizaremos:
#include <allegro.h>

Se coloca la posicin inicial de la serpiente por medio de las coordenadas, primero
colocando la variable y despus el nmero.
/* Posiciones X e Y iniciales */
#define POS_X_INI 16
#define POS_Y_INI 10

#define INC_X_INI 1
#define INC_Y_INI 0

Colocamos una pausa para que las imgenes se puedan apreciar correctamente.
/* Pausa en milisegundos entre un "fotograma" y otro */
#define PAUSA 350

Se colocan las teclas con las cuales se manejara el juego por comodidad pero si se
prefieren otras es muy fcil modificar.
/* Teclas predefinidas */
#define TEC_ARRIBA KEY_W
#define TEC_ABAJO KEY_A
#define TEC_IZQDA KEY_S
#define TEC_DCHA KEY_D

Se manda a llamar a la variable declarada anteriormente para mostrar la posicin de la
serpiente.
int posX, posY; /* Posicin actual */
int incX, incY; /* Incremento de la posicin */

Se declaran las variables principales con las cuales funcionara el programa.
/* Terminado: Si ha chocado o comido todas las frutas */
int terminado;

/* La tecla pulsada */
int tecla;

/* Escala: relacin entre tamao de mapa y de pantalla */
#define ESCALA 10

Se coloca el ancho y alto del mapa del bits.
/* Ancho y alto de los sprites */
#define ANCHOSPRITE 10
#define ALTOSPRITE 10

Se colocan la cantdad de filas y columnas que contendr el mapa del juego.
/* Y el mapa que representa a la pantalla */
/* Como usaremos modo grafico de 320x200 puntos */
/* y una escala de 10, el tablero medir 32x20 */
#define MAXFILAS 20
#define MAXCOLS 32

Se dibuja internamente el mapa del juego.
char mapa[MAXFILAS][MAXCOLS]={
"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
"X X X",
"X F X X",
"X F X F X",
"X XXXXX X X",
"X X X X",
"X X X X X",
"X X X X X",
"X X X X",
"X X X X",
"X X X X",
"X F X X",
"X X X",
"X X F X",
"X X X X",
"X X X X",
"X X F X X",
"X F X X X",
"X X F X",
"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
};

Se declara el nmero de frutas que contendr el juego.
int numFrutas = 7;

/* Nuestros sprites */
BITMAP *ladrilloFondo, *comida, *jugador;


typedef
char tipoSprite[ANCHOSPRITE][ALTOSPRITE];
/* El sprite en si: matriz de 30x30 bytes */

Se dibujo la parte de los ladrillos y la comida. Al igual que se coloco los ciclos
comparativos para los colores.
tipoSprite spriteLadrillo =
{{0,2,2,2,2,2,2,2,2,0},
{2,1,1,1,1,1,1,1,1,2},
{2,1,1,1,1,1,1,1,1,2},
{2,1,1,1,1,1,1,1,1,2},
{2,1,1,1,1,1,1,1,1,2},
{2,1,1,1,1,1,1,1,3,2},
{2,1,1,1,1,1,1,3,3,2},
{2,1,1,1,1,1,3,3,2,2},
{2,2,2,2,2,2,2,2,2,0}
};

tipoSprite spriteComida =
{{0,0,0,2,0,0,0,0,0,0},
{0,0,2,2,0,0,2,2,0,0},
{0,4,4,4,2,2,4,4,0,0},
{4,4,4,4,4,2,4,4,4,0},
{4,4,4,4,4,4,4,4,4,0},
{4,4,4,4,4,4,4,4,4,0},
{4,4,4,4,4,4,4,4,4,0},
{4,4,4,4,4,4,4,4,4,0},
{0,4,4,4,4,4,4,4,0,0}
};

tipoSprite spriteJugador =
{{0,0,3,3,3,3,3,0,0,0},
{0,3,1,1,1,1,1,3,0,0},
{3,1,1,1,1,1,1,1,3,0},
{3,1,1,1,1,1,1,1,3,0},
{3,1,1,1,1,1,1,1,3,0},
{3,1,1,1,1,1,1,1,3,0},
{0,3,1,1,1,1,1,3,0,0},
{0,0,3,3,3,3,3,0,0,0}
};

/* -------------- Rutina de crear los sprites ------------- */


void creaSprites()
{
int i, j;

ladrilloFondo = create_bitmap(10, 10);
clear_bitmap(ladrilloFondo);
for(i=0; i<ANCHOSPRITE; i++)
for (j=0; j<ALTOSPRITE; j++)
putpixel(ladrilloFondo, i, j,
palette_color[ spriteLadrillo[j][i] ]);

comida = create_bitmap(10, 10);
clear_bitmap(comida);
for(i=0; i<ANCHOSPRITE; i++)
for (j=0; j<ALTOSPRITE; j++)
putpixel(comida, i, j,
palette_color[ spriteComida[j][i] ]);

jugador = create_bitmap(10, 10);
clear_bitmap(jugador);
for(i=0; i<ANCHOSPRITE; i++)
for (j=0; j<ALTOSPRITE; j++)
putpixel(jugador, i, j,
palette_color[ spriteJugador[j][i] ]);

}


/* -------------- Rutina de dibujar el fondo ------------- */

void dibujaFondo()
{
int i, j;

En esta parte tambien se colocan los ciclos repetitivos como lo es el for para los colores
para cada uno de las cosas necesarios en el juego.
clear_bitmap(screen);

for(i=0; i<MAXCOLS; i++)
for (j=0; j<MAXFILAS; j++) {
if (mapa[j][i] == 'X')
draw_sprite(screen, ladrilloFondo, i*ESCALA, j*ESCALA);
if (mapa[j][i] == 'F')
draw_sprite(screen, comida, i*ESCALA, j*ESCALA);
}

}
Esta parte es un poco confusa para mi ya que volvemos a inicializar la bibliotecas para el
cuerpo del programa.
/* -------------- Cuerpo del programa ------------- */

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 */

Lo siguiente es para dibujar el mapa y tambien se colocan los ciclos con los cuales se
hara el borrado de la fruta al momento de comercela y faltara una menos para ganar.
creaSprites();
dibujaFondo();
/* Valores iniciales */
posX = POS_X_INI;
posY = POS_Y_INI;

incX = INC_X_INI;
incY = INC_Y_INI;


/* Parte repetitiva: */
do {
dibujaFondo();
draw_sprite (screen, jugador, posX*ESCALA, posY*ESCALA);

terminado = FALSE;

/* Si paso por una fruta: la borro y falta una menos */
if (mapa[posY][posX] == 'F') {
mapa[posY][posX] = ' ';
numFrutas --;
if (numFrutas == 0) {
textout(screen, font,
"Ganaste!", 100, 90, palette_color[14]);
terminado = TRUE;
}
}


Para comprobar si se a pulsado alguna tecla tambien se colocan los ciclos repetitivos
como lo es el if.
/* Si choco con la pared, se acabo */
if (mapa[posY][posX] == 'X') {
textout(screen, font,
"Chocaste!", 100, 90, palette_color[13]);
terminado = TRUE;
}

if (terminado) break;

/* Compruebo si se ha pulsado alguna tecla */
if ( keypressed() ) {
tecla = readkey() >> 8;

switch (tecla) {
case TEC_ARRIBA:
incX = 0; incY = -1; break;
case TEC_ABAJO:
incX = 0; incY = 1; break;
case TEC_IZQDA:
incX = -1; incY = 0; break;
case TEC_DCHA:
incX = 1; incY = 0; break;
}

}
posX += incX;
posY += incY;

/* Pequea pausa antes de seguir */
rest ( PAUSA );

}
Por ultimo colocamos una condiccion con la cual nos damos cuanta cuando termina el
programa ademas colocamos el codigo fin para cerrar el programa.
while (TRUE); /* Repetimos indefinidamente */
/* (la condicin de salida la comprobamos "dentro") */

readkey();
return 0;

}

/* Termino con la "macro" que me pide Allegro */
END_OF_MAIN();
En la siguiente pantalla se muestra como es graficamente el juego.

En esta pantalla se muestra cuando la serpiente choco contra una pared y por eso se
muere.




En la ltima pantalla se muestra cuando se gana el juego comiendo 7 manzanas.

CONCLUSIN:
Esta prctica fue muy sencilla lo nico que le cambie fueron las teclas con las cuales se
movera la serpiente, ya que para m son ms cmodas. No tuve ningn problema al
momento de compilarla ya que no me marcaba ningn error.
Al momento de realizar el mapa de bits se me complico un poco ya que tena que contar
cada uno de los espacios que dejaba de separacin por las cuales tena que pasar la
serpiente para comerse las frutas y no chocar con las paredes.