Cargamos las monedas

Vamos a cargar las monedas en el mundo de New Super Mario Bros, y para hacer esto utilizaremos el programa que nos genera los mapas.

Se ha agregado una nueva opción al generador de mapas para que permita editar una capa denominada coins (monedas). En la siguinete imagen se puede ver al editor a pleno rendimiento:


El editor al guardar generará un nuevo fichero que se llamará coins_mapa_8_nombre del txt) y coins_mapa_16_nombre del txt). Este último será el que utilizaremos.

ahora veamos los cambios en el código del juego.

En primer lugar seguimos añadiendo funcionalidades a las librerías:
En la clase ScreenManager.h se ha añadido una función para cargar sprites de fondo a partir de una array (el que genera el editor de mapas):

 /**
  * Carga una serie de sprites de tipo background a partir de un mapa y de un primer sprite de tipo background
  * ya cargado.
  * Este primwr sprite será reubicado a la priemra posición indicada por el mapa.
  *
  * @param sprite El sprite a cargar
  * @param map mapa que indica donde colocar cada sprite
  * @param mapCols número de columnas del mapa
  */
 void LoadBackgroundSprites(Sprite *sprite, int *map, int map_columns, int map_rows);

En ScreenManager.cpp hemos codificado la funcion de la siguiente forma:

void ScreenManager::LoadBackgroundSprites(Sprite *sprite, int *map, int map_columns, int map_rows) {
 unsigned int i;
 unsigned int length = map_columns * map_rows;
 bool primero = true;
 for (i = 0; i < length; i++)
  if (map[i] > 0) {
   int y = i / map_columns;
   int x = i - (y * map_columns);
   if (primero) {
    sprite->SetXY(x * 16, y * 16);
    primero = false;
   } else CloneBackgroundSprite(sprite, x * 16, y * 16);
  }
}

Lo que hace esta función es coger un sprite de fondo y un array y donde el array le indique coloca un copia del sprite de fondo, que en este caso serán modenas.

Vamos a ver como se usa esta nueva función en nuestro juego:

int coins_map[48 * 12] = {
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 56, 0, 
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 56, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 56, 0, 0, 0, 
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 56, 0, 56, 0, 56, 0, 0, 0, 0, 0, 
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
#define COINS_MAPA coins_map, 48, 12

....

Sprite *coin = topScreen->CreateBackgroundSprite(BACKGROUND_THREE, COIN, 0, 0);
coin->SetAnim(0, 3, 4);
coin->StartAnim();
topScreen->LoadBackgroundSprites(coin, COINS_MAPA); 

La explicación sería algo así:
Carga una primera moneda (las coordenadas dan igual, en este caso se ha puesto 0, 0),
Se anima el sprite,
y finalmente se cargan tantas monedas como diga el mapa.

Los números que aparecen en el mapa no es importante (por ahora). Sólo es importante que sea cero donde no va moneda y distinto de cero donde queremos una moneda.

Nos falta coger las dichosas monedas!!

En el próximo post intentaremos cogerlas y de paso publicaremos código.

Saludos

Mejoramos el movimiento

Todas estas semanas atrás hemos estado programando el juego utilizando las funcionalidades de los Tiles que nos brinda PALib. Esto está muy bien para juegos tipo Tetris, de tablero, etc. Pero para el New Super Mario Bros, o para los Pokemon no es totalmente válido.

El programar con tiles permite dibujar la pantalla con 'azulejos' de 8x8 pixeles, por lo que el movimiento del fondo (necesario en este tipo de juegos) ha de ser de 8 en 8 pixeles y eso no puede ser. Necesitamos unas transiciones más suaves.

PALib permite crear tiles y mover el fondo como de si una imagen se tratara. Así que hemos realizado los siguientes cambios en nuestra librería y en el editor de mapas.

Con respecto a la nueva librería hemos creado nuevas funciones para tratar los fondos. Estas funciones estarán en ScreenManager:

 /**
  * Asigna una imagen de fondo
  *
  * @param background Cada pantalla de la consola permite cuatro niveles de
  * fondos. Los valores posibles son: BACKGROUND_ZERO, BACKGROUND_ONE,
  * BACKGROUND_TWO, BACKGROUND_THREE (de mayor a menor prioridad)
  */
 void SetBackground(unsigned int background, int *info, void * pal, const unsigned char *tiles, u32 tiles_size, const unsigned short *mapa);

 /**
  * Devuelve la coordenada X única a todos los fondos.
  */
 int GetBackgroundsX();

 /**
  * Devuelve la coordenada Y única a todos los fondos.
  */
 int GetBackgroundsY();

 /**
  * Asigna la coordenada X única a todos los fondos.
  * Se utiliza para mover todos los fondos a la vez
  *
  * @param y coordenada x
  */
 void SetBackgroundsX(int x);

 /**
  * Asigna la coordenada Y única a todos los fondos.
  * Se utiliza para mover todos los fondos a la vez
  *
  * @param y coordenada Y
  */
 void SetBackgroundsY(int y);

 /**
  * Asigna las coordenadas X, Y única a todos los fondos.
  * Se utiliza para mover todos los fondos a la vez
  *
  * @param y coordenada x
  * @param y coordenada Y
  */
 void SetBackgroundsXY(int x, int y);

 /**
  * Desplaza a la izquierda todos los fondos una cantidad dada
  * Se utiliza para mover todos los fondos a la vez
  *
  * @param offset desplazamiento
   * @return la nueva coordenada x
  */
 int MoveBackgroundsLeft(int offset);

 /**
  * Desplaza a la derecha todos los fondos una cantidad dada
  * Se utiliza para mover todos los fondos a la vez
  *
  * @param offset desplazamiento
   * @return la nueva coordenada x
  */
 int MoveBackgroundsRight(int offset);

 /**
  * Desplaza arriba todos los fondos una cantidad dada
  * Se utiliza para mover todos los fondos a la vez
  *
  * @param offset desplazamiento
   * @return la nueva coordenada y
  */
 int MoveBackgroundsUp(int offset);

 /**
  * Desplaza abajo todos los fondos una cantidad dada
  * Se utiliza para mover todos los fondos a la vez
  *
  * @param offset desplazamiento
  * @return la nueva coordenada y
  */
 int MoveBackgroundsBottom(int offset);

De esta forma podemos asignar una serie de imágenes a los distintos fondos y moverlos sin problema los pixeles que se desean. En nuestro caso los fondos se moverán de izquierda a derecha.

Las funciones utilizadas hasta hoy, CreateTileSet, y la clase TileSet se dejarán para los proyectos que lo necesiten.

En cuanto al programa de edición de mapas se han cambiado los ficheros de salida. Ahora genera un png con el dibujo que se ha editado. Este dibujo debe pasar por PAGfx para generar los ficheros de salida. A continuación publicamos las dos imágenes de salida del programa de edición:


Fondo cero


Fondo uno

El código en NSMB.cpp quedará así:

 topScreen->SetBackground(BACKGROUND_ZERO, FONDO_CERO);
 topScreen->SetBackground(BACKGROUND_ONE, FONDO_UNO);
 topScreen->SetBackground(BACKGROUND_THREE, FONDO_TRES);
 topScreen->SetCollisionMap8x8((void *)newImage_0_Map, newImage_0_Info[1] / 8, newImage_0_Info[2] / 8);

Esta semana no voy a publicar código. Son demasiados cambios de un solo golpe y no puedo mantener bien las versiones. Además de que el código estará lleno de errores.

Ahora mi objetivo es dejar el salto fino y coger las monedas.

Espero tener para la semana que viene cosas nuevas que ofrecer, aunque el verano me va a quitar tiempo.

Saludos

Creación de mapas para el Juego (II)

Hemos seguido desarrollando el programa de Java para crear mapas. Se ha detectado un error a la hora de generar los mapas de 8 pixeles y se ha añadido la posibilidad de crear más niveles (hasta los cuatro que permite la Nintendo DS).



En la foto se puede ver que se ha añadido una lista de opciones con el nombre 'cero', 'one', 'two' y 'three'. Al añadir dibujos a la pantalla se añadirán al mapa que esté seleccionado. tener en cuenta que el mapa 'cero' es de de mayor prioridad, y así hasta el 'three'. (Por supuesto, mayor prioridad es que sale encima).

En la foto las plantas están en la pantalla 'one', y los ladrillos en la 'two'.

A la hora de cargar un mapa se ha de cargar el cero_mapa_16.txt, con la opción abrir mapa 16. A la hora de guardar se pondrá, únicamente, el nombre de un txt.
Si por ejemplo se pone casa.txt el programa generará:
cero_mapa_16_casa.txt, (este es el que habrá que cargar la próxima vez para editar todos los mapas)
cero_mapa_8_casa.txt,
cero_collision_8_casa.txt,
one_mapa_16_casa.txt,
one_mapa_8_casa.txt,
one_collision_8_casa.txt,
two_mapa_16_casa.txt,
two_mapa_8_casa.txt,
two_collision_8_casa.txt,
three_mapa_16_casa.txt,
three_mapa_8_casa.txt y
three_collision_8_casa.txt

Los ficheros de colisión serán los que utilizaremos para el tema de las colisiones. En nuestro caso sólo usaremos el cero_collision_8_...

La última versión la encontraréis aquí.

Con todo esto creo que tenemos toda la información necesaria para poder programar nuestro juego. Otra cosa que se puede hacer en el futuro es cargar estos txt directamente desde el juego. Tiempo al tiempo.

Saludos

Creación de mapas para el Juego

Después del paréntesis de la semana santa volvemos al proyecto en que estamos metidos, hacer el New Super Mario Bros para la Nintendo DS.

En esta entrada vamos a presentar un programa que sirve para hacer los mapas del juego. Es un poco cutre, pero el tiempo no da para más. Aquí os dejo un pantallazo del programa.



Su uso es muy sencillo:

• Primero, se debe cargar el tileset con el que queremos dibujar el mapa (fichero/abrir tileset...),


• Segundo, si queremos modificar un mapa ya hecho lo cargamos con la opción fichero/abrir mapa 16,


• Tercero, seleccionamos el tile que queremos dibujar en la parte superior,


• Cuarto, vamos 'clickando' por la pantalla para ir poniendo los cuadraditos y


• Finalmente guardamos el mapa con la opción 'guardar 16'.

Si os fijáis, al cargar se carga con la opción de cargar mapa 16. Esto es que el programa trabaja con tiles de 16x16 pixeles, así que el mapa a cargar sera de 16.

La opción de 'grabar 16' graba el mapa con tiles de 16x16 pixeles (salida_16.txt).
La opción de 'grabar 8' graba con tiles de 8x8 pixeles (salida_8.txt).

El proyecto java lo encontrareis aquí.

No he explicado nada de java, no es tema de este blog, pero si alguien quiere saber algo, que lo diga. Por otra parte, ¡¡¡he comentado bastante el código!!!


Para ver el mapa dentro de nuestro juego, únicamente, tendremos que copiar el contenido del fichero a NSMB.cpp. Es el array denominado mapa8.

El último código lo encontraréis aquí.

Hay un cambio con respecto a la anterior versión y es que antes dibujábamos casillas de 16x16 y ahora de 8x8. Dejaremos la anterior funcionalidad en las librerías por si a algún otro proyecto le pueda interesar.

Ahora ya podemos ir a por el tema de las colisiones y, después, a por el tema de la gravedad.

Ya siento no poder avanzar más pero de donde no hay no se puede sacar, y no tengo nada de tiempo.

Nos vemos en los comentarios, saludos