Programar para Nintendo DS y Wii

Retomamos

2009-11-10T03:08:00.001-08:00

Ha habido un cierre temporal del blog estos meses, que espero que sea eso, temporal.

Como penitencia voy a crear unos post hablando de la Wii y de como programar para ella. Ya tengo portado el tetris (por ahora usando el mando como un pad) y no hemos pasado el New Super Mario Bros, porque lo van a hacer los de Nintendo este mes y no era cuestión de adelantarnos a ellos :D

Por supuesto, seguiremos con el New Super Mario Bros para la Nintendo DS.

Este viernes posteamos fijo!!!

Saludos

P.D. Hemos cambiado el título del blog, ahora es Programar para la Nintendo DS y Wii, la url por supuesto sigue igual!!

La aventura de Mario

2009-09-18T00:00:00.000-07:00

Por fin ponemos a Mario en su sitio. Mario se hace dueño y señor de su mundo. Un juego que se llama New Super Mario Bros y que no saliera él por ningún sitio era algo extraño. Pues nada un poco de photoshop para ponerle guapo y ya está. Quitamos a koopa y ponemos a Mario.

Nos ha hecho cambiar alguna cosa más, como por ejemplo el mario_collision_map. Es que este Mario es un poco más bajito que Koopa. También cambia el número de frames que forman la animación (el número de imágenes que representan el movimiento).

El aspecto de nuestro juego DS es el siguient:

Es el Mario pequeñito. Ya pondremos al intermedio, porque el grande es otra historia.

Saludos

Instalar DevkitPro en linux - Ubuntu

2009-09-11T00:00:00.000-07:00

Hemos instalado devkitpro y PAlib en una distribución de Ubuntu.

Hemos seguido los siguientes pasos:

Hemos descargado de la red los siguientes ficheros:

devkitarm, libNds, DSwifi, libfat de http://sourceforge.net/project/showfiles.php?group_id=114505
y PAlib: http://www.palib.info/wiki/doku.php

Se han descargado en el Escritorio. Abrimos un terminal y ejecutamos los siguientes comandos:

$ cd Escritorio
$ sudo mkdir /usr/local/devkitpro
$ sudo chmod 777 /usr/local/devkitpro
$ sudo bunzip2 devkitARM_r26-i686-linux.tar.bz2
$ sudo tar xvf devkitARM_r26-i686-linux.tar -C /usr/local/devkitpro
$ sudo mkdir /usr/local/devkitpro/libnds
$ sudo chmod 777 /usr/local/devkitpro/libnds
$ sudo bunzip2 libnds-1.3.6.tar.bz2
$ sudo tar xvf libnds-1.3.6.tar -C /usr/local/devkitpro/libnds
$ sudo bunzip2 dswifi-0.3.9.tar.bz2
$ sudo tar xvf dswifi-0.3.9.tar -C /usr/local/devkitpro/libnds
$ sudo bunzip2 libfat-nds-20070127.tar.bz2
$ sudo tar xvf libfat-nds-20070127.tar -C /usr/local/devkitpro/libnds
$ sudo mkdir /usr/local/devkitpro/PAlib
$ sudo chmod 777 /usr/local/devkitpro/PAlib

Aquí me cansé de lanzar tantos comandos y lo que hice fue copiar con el explorador de archivos el
fichero PAlib99999.7z a devkitpro y con el ratón ejecutar descomprimir aquí.

Para acabar lanzamos el siguiente comando:
$ gksudo gedit /etc/environment

y añadimos al final las siguientes líneas:

DEVKITPRO="/usr/local/devkitpro"
DEVKITARM="/usr/local/devkitpro/devkitARM"
PAPATH="/usr/local/devkitpro/PAlib"

Para instalar un emulador realizamos los siguientes pasos:

En el menú principal: Sistema/administración/gestor de paquetes synaptic
buscamos 'Desmume' y lo bajamos. Son dos paquetes.

Y ya está todo.

He creado la carpeta devDS en /home/inigo/devDS (donde inigo es mi usuario) y ahí he copiado el proyecto. Dentro de SuperMarioDS se puede ejecutar (desde el terminal) la sentencia make. Una vez compilado para ejecutarlo escribimos desmume SuperMarioDS.nds y ...

Es Mario y no Koopa!!.....la semana que viene lo vemos.

Saludos

Nueva versión del entorno de desarrollo

2009-09-04T00:10:00.000-07:00

Tenemos nueva versión de devkitPro y parece que muchos de los problemas de instalación han desaparecido. Ya no hace falta cambiar algunas de las librerías que vienen por defecto con el devkitPro para que PAlib funcione.

Pero sí que va a ser necesario cambiar algo de nuestro código. Pero eso lo veremos más adelante.

Ahora mismo los pasos para instalar el entorno de homebrew de la nintendo DS son los siguientes:

Para instalar devkitPro en windows:

1. Bajar devkitPro Updater 1.5.0 de esta dirección.
2. En una de las pantallas nos muestra esta opción 'Download and install/install from downloaded files' la dejamos pulsada y seguimos
3. La siguiente nos preunta que hacer con los ficheros que ha bajado. Por defecto está seleccionada Keep downloaded files, que lo único que hace es dejar todos los ficheros en la carpeta de descargas. Yo lo dejé por si tenía algún problema. Cada uno... Seguimos.
4. Seleccionamos devkitARM -> para trabajar con la DS (la que usamos en este blog)
devkitPPC -> para gamecube/wii
devkitPSP -> para la PSP
2. A la hora de instalarlo Lo instalaremos en c:\devkitPro (Instalarlo donde queráis pero que la ruta no tenga espacios en blanco)
6. Se tirará un ratito bajando e instalando cosas...

Y ya está, ahora le toca el turno a PAlib.

7. Bajamos la última versión (es una beta).
8. Creamos la carpeta c:\devkitPro\PAlib y descomprimimos el zip PAlib090801.7z ahí.

Y ya está todo!!!!.

Ahora un emulador. Yo he bajado no$gba y lo he instalado en C:\devkitPro\emulators\no$gba.

Ahora le toca el turno a nuestro programa, el SuperMarioDS.

Hay que cambiar una serie de cosas en el código, así que crearemos un proyecto nuevo y trasladaremos las cosas del antiguo a este. Lo primero que hacemos es copiar la carpeta C:\devkitPro\PAlib\template a c:\devDS o donde trabajemos. Cambiamos el nombre template por SuperMarioDS y borramos el fichero main.c de source. Yo para hecer esto renombre el antiguo SuperMarioDS por SuperMarioDS_old

Si nos fijamos las carpetas han cambiado un poco. El mayor cambio es la carpeta gfx, que pasa de source a estar al nivel de todas las demás. El programa ha cambiado un poco así que únicamente copiaremos los ficheros PNG a la nueva carpeta. El ini ha cambiado, también, así que lanzamos el programa PAGfxFrontend.exe (se necesita tener instalado .net) y se cargan como sprites lo siguientes ficheros: coin.png, goomba.png y koopa.png
Como backgrounds se cargarán estos otros: fondo_azul.png, newImage_0.png, newImage_1.png

Salvamos y generamos, ningún problema. Sólo que únicamente crea all_gfx.h y NO all_gfx.c. Tendremos que quitar esa referencia.

En el make file hacemos una pequeña modificamos en la línea 46:

Antes: SOURCES := source data gfx/bin
Ahora: SOURCES := source data gfx/bin source/devnintendods

De esta forma podemos usar las fuentes que hay en source/devnintendods.

Ahora el resto de cosas. Los ficheros que estaban en data (dos .raw) siguen en la nueva data.

El fichero devnintendods.h de include se va al nuevo include y source sigue igual quitando el gfx antiguo, claro.

Ahora, si compilamos, saldrán una serie de errores. En mi caso bastantes. Lo primero, quitar all_gfx.c de NSMB.cpp.

Otra cosa, en ScreenManager.cpp cambia la línea 45 y en el .h correspondiente la línea 137:
Lo que antes era:
SetBackground(unsigned int background, int *info, void * pal, const unsigned char *tiles, u32 tiles_size, const unsigned short *mapa)
ahora es:
SetBackground(unsigned int background, int *info, void * pal, const unsigned char *tiles, unsigned int tiles_size, const unsigned int *mapa)

El array Blank, que era un array a blanco ha desaparecido, así que da error la línea 16 del TileSet.cpp, la he comentado. Ahora no se usa, pero...

Y no recuerdo más cambios.

El juego ya compila y se puede ejecutar.

La semana que viene veremos como instalar en ubuntu, que es un poco más largo, pero no da ningún tipo de problema.

Saludos

P.D. Tras el descanso veraniego, en que le blog no ha sido actualizado, vamos a intentar seguir con el blog. No sé de cuanto tiempo dispondré pero bueno...

Enlaces paqtrocinados
alta en buscadores
como salir en google
Consultas trabajo
Ganar Dinero Extra
Ibiza apartments
marketing on-line
Tarot telefónico
Tarot VISA
vender enlaces
Videncia

Dejamos el salto fino

2009-07-17T00:01:00.000-07:00

Hasta ahora a la hora de caer de un salto nuestro personaje realizaba una misteriosa maniobra. Justo antes de caer al suelo frenaba de forma misteriosa. Lo que ocurría era que el código al obtener una colisión con el suelo reseteaba todos los valores del salto y empezaba a caer de nuevo.

Eso hay que cambiarlo.

Lo único que se necesita es que al obtener una colisión, como estamos cayendo con una 'fuerza' de más de un pixel, debemos encontrar la primera posición libre antes de las plataformas. Un sencillo for realizará este trabajo (NSMB.cpp):


bool NSMB::BeforeVBL() {
 if (tiempoSalto-- < 0) { 

  tiempoSalto = MOVIMIENTO_VELOCIDAD_INTERMEDIA;
  int y = koopa->GetY();
  koopa->SetY(y + fuerzaSalto);
  if (topScreen->IsCollision(koopa, topScreen->GetBackgroundsX() / 8, topScreen->GetBackgroundsY() / 8)) {
   if (fuerzaSalto > 0) {   
    int i = 0;
    for (i = 0; i < MAXIMA_FUERZA_CAIDA; i++) {
     koopa->MoveUp();
     if (!topScreen->IsCollision(koopa, topScreen->GetBackgroundsX() / 8, topScreen->GetBackgroundsY() / 8)) break;
    }
   } else {
    koopa->SetY(y);
   }
   fuerzaSalto = 0;
   volando = false;
  } else {
   if (fuerzaSalto < MAXIMA_FUERZA_CAIDA) fuerzaSalto++;
   volando = true;
  }
 }
 return 1;
}

El aspecto del juego no ha cambido demasiado:

Otras cosas que hemos hecho es seguir 'mejorando' la librería. Por ejemplo, las funciones de mover un sprite, MoveLeft, MoveUp que tengan el parámetro opcional y así realizar un movimiento de 1 por defecto, preparando el código para coger las monedas, etc.

Esta semana si vamos a colgar el proyecto, tal cual está.

Saludos

P.D. Otra cosa, estamos en verano y los post no serán tan fluidos, pero supongo que tampoco las visitas.

Mejoramos el movimiento

2009-06-19T00:00:00.000-07:00

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

Los sonidos

2009-06-12T00:00:00.000-07:00

A partir del post de como programar los sonidos en la Nintendo DS, con el código de David que publicamos hace ya un tiempo, vamos a implementar los sonidos de nuestro juego.

Como ya explicamos en aquel post, las librerías PALib leen los ficheros de audio en formato raw.

Para pasar de mp3 a raw lo he hecho con 'Switch Sound File Converter'. Para editar los ficheros hemos usado Audacity.

Los ficheros de sonido se dejan en la carpeta data de SuperMarioDS.

La Instrucción PA_InitSound la hemos puesto en el constructor de GameManager.cpp. Ahora en la instalación que tengo de PALib ha empezado a dar problemas y he tenido que cambiar el código, que ha quedad de esta forma:


GameManager::GameManager() {
 PA_Init();
 PA_InitVBL();
 
 //PA_InitSound();
 AS_Init(AS_MODE_SURROUND | AS_MODE_16CH );
 AS_SetDefaultSettings(AS_PCM_8BIT, 11025, AS_SURROUND);

El código a cambiar en NSMB.cpp es el siguiente:


#include 
#include "salto.h"

....

bool NSMB::HeldUp() {
 if (!volando) { //Si no estamos volando podremos saltar
  //PA_PlaySimpleSound(0, salto);
  PA_PlaySimpleSound(salto);
  tiempoSalto = TIEMPO_SALTO;
  volando = true;
  fuerzaSalto = FUERZA_SALTO_INICIAL;
 }
 return 1;
}

El error que aparecía al compilar era
'PA_InitSound' was not declared in this scope, y ahí me he quedado, he cambiado PA_InitSound y PA_PlaySimpleSound(0, salto) por las otras instrucciones y ya funciona (¿?¿?¿?¿?).

Ahora habrá que ir poniendo sonidos a las distintas acciones...

Saludos

La gravedad y el salto

2009-06-05T00:01:00.000-07:00

Bueno, aquí no vamos a explicar lo que es la gravedad, pero si que es necesario ponerla en nuestro juego.

Vamos a programar la gravedad en nuestro juego.

El tema está en que al saltar, Mario no sube y después baja, no....si no que al saltar Mario sube, el bajar es cosa de la gravedad, no del salto. Por lo que habrá que programar primero el tema de la gravedad.

Lo primero será hacer un mapa con una zona elevada y poner ahí a nuestro héroe. Y que al salir de dicha zona la gravedad le haga caer y que lo haga hasta que ocurra una colisión.

he creado varias variables, una para saber que estamos cayendo, ya que en esos momentos no podemos saltar. Sólo se salta desde el suelo.
Otra es para el tema de la fuerza al caer, es decir, cada vez se cae más deprisa y el retardo del salto para que no caiga demasiado deprisa.


bool NSMB::BeforeVBL() {
 if (tiempoSalto-- < 0) { 
  tiempoSalto = MOVIMIENTO_VELOCIDAD;
  int y = koopa->GetY();
  koopa->SetY(y + fuerzaSalto);
  if (topScreen->IsCollision(koopa, mundo_plataformas_cero->GetX(), mundo_plataformas_cero->GetY())) {
   koopa->SetY(y);
   fuerzaSalto = 1;//inicializar
   volando = false;
  } else {
   if (fuerzaSalto < MAXIMA_FUERZA_CAIDA) fuerzaSalto++;
   volando = true;
  }
 }
 return 1;
}

El código lo hemos colocado en la función BeforeVBL que se ejecuta en cada vuelta del bucle y antes del refresco de la pantalla. Esto se ha hecho así porque la gravedad actua continuamente.

Lo que realmente hace nuestro código es coger la coordenada 'Y' de nuestro héroe y sumarle la fuerza. La hemos llamado fuerzaSalto porque sirve igualmente para saltar que para caer, ya hemos dicho que saltar y caer es lo mismo.

Una vez sumados los valores vemos si hay colisión, si no es el caso aumentamos la fuerza, cada vez caemos más fuerte (hasta un límite 'MAXIMA_FUERZA_CAIDA'). Este algoritmo se ejecutará hasta llegar a un suelo.

Y ahora que pasa si fuerzaSalto es negativo. Pues que tenemos a nuestro héroe saltando. Por lo que necesitamos este código para comenzar a saltar:


bool NSMB::HeldUp() {
 if (!volando) { //Si no estamos volando podremos saltar
  tiempoSalto = TIEMPO_SALTO;
  volando = true;
  fuerzaSalto = FUERZA_SALTO_INICIAL;
 }
 return 1;
}

Y ya está, programando la gravedad nos ha salido gratis el salto. Así da gusto!

El juego tiene este aspecto ahora mismo:

Aún así queda un efecto feo al aterrizar. Ya lo trabajaremos más adelate.

Ahora sólo queda coger las monedas, meter los sonidos, los efectos de fondo, más plataformas,... esto no acaba nunca.

Saludos, nos vemos en los comentarios.

Las monedas

2009-05-29T00:01:00.000-07:00

El tema de las monedas nos va a permitir crear un nuevo tipo de Sprite, los Sprites de fondo. Esto no es algo de PALib, si no que es algo implementado por nuestra pequeña librería.

Los sprites de fondo o 'background sprite' se moverán con el fondo, por lo que habrá que hacer también funciones que muevan el fondo.

Se ha implementado casi todo dentro de ScreenManager. La función para crear un Sprite de fondo es 'CreateBackgroundSprite'. Tiene los mismos parámetros que 'CreateSprite', lo único que el Sprite queda en una lista de sprites de fondo. También se ha preparado 'CloneBackgroundSprite' que crea un sprite idéntico ahorrando espacio en memoria.

Antes de ver las funciones, conviene resaltar que se ha usado por primera vez una clase de C++ denominada Vector. Esta clase permite tener una especie de 'array' que se puede ir cargando de forma dinámica. En este caso se ha usado de esta forma:


//ScreenManager.h
std::vector  *m_backgroundSprites;

Esta es la forma de crear un vector de clases de Sprite. Más delante se ve como recorrerlo, en 'MoveRightBackgroundSprites' y en 'MoveLeftBackgroundSprites'.

Las funciones nuevas son las siguientes:


Sprite *ScreenManager::CreateBackgroundSprite(unsigned int background, unsigned int shape, unsigned int sizes, void *palette, void *sprite, int x, int y) {
 return CreateBackgroundSprite(background, shape, sizes, palette, sprite, x, y, 0);
}

Sprite *ScreenManager::CreateBackgroundSprite(unsigned int background, unsigned int shape, unsigned int sizes, void *palette, void *sprite, int x, int y, int hflip) {
 Sprite *newSprite = new Sprite(m_screen, background, shape, sizes, palette, sprite, x, y, hflip);
 if (!m_backgroundSprites) m_backgroundSprites = new std::vector();
 m_backgroundSprites->push_back(newSprite);
 return newSprite;
}

Sprite *ScreenManager::CloneBackgroundSprite(Sprite *sprite) {
 return CloneBackgroundSprite(sprite, sprite->GetX(), sprite->GetY());
}

Sprite *ScreenManager::CloneBackgroundSprite(Sprite *sprite, int x, int y) {
 Sprite *clone = sprite->Clone(x, y);
 m_backgroundSprites->push_back(clone);
 return clone;
}

Y, finalmente, las funciones encargadas de mover todos los sprites de fondo de un golpe son:


void ScreenManager::MoveRightBackgroundSprites(int offset) {
 unsigned int i;
 for(i = 0; i < m_backgroundSprites->size(); i++) {
  Sprite *sprite = (Sprite *)m_backgroundSprites->at(i);
  sprite->MoveRight(offset);
 }
}

void ScreenManager::MoveLeftBackgroundSprites(int offset) {
 unsigned int i;
 for(i = 0; i < m_backgroundSprites->size(); i++) {
  Sprite *sprite = (Sprite *)m_backgroundSprites->at(i);
  sprite->MoveLeft(offset);
 }
}

En este punto surgió un problema y es que cuando la x se hacía negativa o mayor de 256 aparecían los sprites por el otro lado. Este tema se ha corregido creando una función nueva que permite ocultar los sprites:


void Sprite::SetVisible(int visible) {
 if (!visible) {
  if (PA_GetSpriteMode(m_screen, m_index_sprite) != 1) {
   PA_SetSpriteMode(m_screen, m_index_sprite, 1);
   PA_EnableSpecialFx(m_screen, SFX_ALPHA, 0, SFX_BG0 | SFX_BG1 | SFX_BG2 | SFX_BG3 | SFX_BD);
   PA_SetSFXAlpha(m_screen, 0, 0);
  }
 } else if (PA_GetSpriteMode(m_screen, m_index_sprite) != 0) {
  PA_SetSpriteMode(m_screen, m_index_sprite, 0);
 }
}

Esta función pone el sprite totalmente transparente (Esto no es cierto del todo, Existen dos modos y en uno de ellos serán todos los sprites transparentes). Se puede utilizar desde nuestros programas y además lo utilizan las funciones SetX, SetY y SetXY si las coordenadas están fuera de la pantalla:


void Sprite::SetX(int x) {
 m_x = x;
 PA_SetSpriteX(m_screen, m_index_sprite, m_x);
 if (m_x < 0 || m_x > 256) SetVisible(0);
 else SetVisible(1);
}

void Sprite::SetY(int y) {
 m_y = y;
 PA_SetSpriteY(m_screen, m_index_sprite, m_y);
 if (m_y < 0 || m_y > 192) SetVisible(0);
 else SetVisible(1);
}

void Sprite::SetXY(int x, int y) {
 m_x = x;
 m_y = y;
 PA_SetSpriteXY(m_screen, m_index_sprite, m_x, m_y);
 if (m_x < 0 || m_x > 256) SetVisible(0);
 else SetVisible(1);
}

Las monedas las hemos creado en NSMB.cpp de la siguiente manera:


Sprite *coin = topScreen->CreateBackgroundSprite(BACKGROUND_TWO, COIN, 192, 80);
coin->SetAnim(0, 3, 4);
coin->StartAnim();
topScreen->CloneBackgroundSprite(coin, 224, 88);
topScreen->CloneBackgroundSprite(coin, 248, 96);
topScreen->CloneBackgroundSprite(coin, 548, 104);

La primera línea crea una moneda (un sprite de fondo).
La segunda define los frames para la animación.
La tercera pone a girar la moneda.
Y las otras tres crean tres monedas más.

Este es el aspecto del juego en estos momentos:

¡¡Ahora solo nos falta saltar para coger esas monedas!!

Tenemos que hacer el tema de la gravedad y lo de saltar.

El código correspondiente a esta última entrega lo podéis descargar desde aquí.

Nos vemos en los comentarios.

Saludos

Creación de mapas para el Juego (II)

2009-05-22T00:01:00.000-07:00

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

El movimiento

2009-05-15T00:01:00.000-07:00

Otra característica del Mario Bros es que Mario no está siempre en el centro de la pantalla. Si no que cuando se acaban las plataformas, tanto a un lado como a otro, llega hasta el borde de la pantalla.

Esta característica hay que programarla dentro del juego y no de las librerías, es decir, lo pondremos en NSMB.cpp.

El código fuente de la función avanzar será el siguiente:


int NSMB::avanzar() {
 velocidad--;
 if (velocidad == 0) {
  velocidad = MOVIMIENTO_VELOCIDAD;
  if (movimiento == MOVIMIENTO_DERECHA) {
   if (koopa->GetX() < 128) {//128 = pixeles mitad pantalla
    koopa->MoveRight(MOVIMIENTO_VELOCIDAD);
    if (topScreen->IsCollision(koopa, mundo_plataformas->GetX(), mundo_plataformas->GetY()))
     koopa->MoveLeft(MOVIMIENTO_VELOCIDAD);//deshacemos el avance
   } else {
    int x = mundo_plataformas->GetX() + 1;
    if (x < COLUMNAS_MAPA - COLUMNAS_PANTALLA) {
     if (!topScreen->IsCollision(koopa, x, mundo_plataformas->GetY())) {
      mundo_plataformas->SetX(x);
      mundo_plataformas->PrintMap8x8(MAPA_PLATAFORMAS);
     }
    } else if (koopa->GetX() < 256) {
     koopa->MoveRight(MOVIMIENTO_VELOCIDAD);
     if (topScreen->IsCollision(koopa, mundo_plataformas->GetX(), mundo_plataformas->GetY()))
      koopa->MoveLeft(MOVIMIENTO_VELOCIDAD);//deshacemos el avance
    }
   }
  } else {//MOVIMIENTO_IZQUIERDA
   if (koopa->GetX() > 128) {//128 = pixeles mitad pantalla
    koopa->MoveLeft(MOVIMIENTO_VELOCIDAD);
    if (topScreen->IsCollision(koopa, mundo_plataformas->GetX(), mundo_plataformas->GetY()))
     koopa->MoveRight(MOVIMIENTO_VELOCIDAD);//deshacemos el avance
   } else if (mundo_plataformas->GetX() > 0) {
    int x = mundo_plataformas->GetX() - 1;
    if (!topScreen->IsCollision(koopa, x, mundo_plataformas->GetY())) {
     mundo_plataformas->SetX(x);
     mundo_plataformas->PrintMap8x8(MAPA_PLATAFORMAS);
    }
   } else if (koopa->GetX() > 0) {
    koopa->MoveLeft(MOVIMIENTO_VELOCIDAD);
    if (topScreen->IsCollision(koopa, mundo_plataformas->GetX(), mundo_plataformas->GetY()))
     koopa->MoveRight(MOVIMIENTO_VELOCIDAD);//deshacemos el avance
   }
  }
 }
 return 1;
}

Hoy no voy a poner una versión del código porque está cambiando bastante por lo que lo dejaré para futuros post. Sólo os puedo decir que las funciones Print de ScreenManager están ahora a nivel de TileSet. La clase Sprite está cambiando y mantener varias versiones no me es posible.

Saludos

Las colisiones

2009-05-08T00:01:00.000-07:00

Quizás es uno de los temas más importantes de nuestro juego: no demos salirnos de nuestro mundo, ni atravesar las paredes. La intención de este post es de dotar a las librerías que estamos creando, y de paso al NSMB, de esta cualidad tan necesaria.

Vamos a ver cosas que hemos tenido en cuenta a la hora de programar el tema de las colisiones:

Veamos cómo está definido Koopa, nuestro héroe:

Está dentro de un array de 4x4, pero en el fondo sólo ocupa 2x4 (2 columnas y 4 filas). Es decir, una colisión se dará en el caso en que un objeto entrase en las coordenadas (x+1, y) o (x+1, y+1) o (x+1, y+2) o (x+1, y+3) o (x+2, y) o (x+2, y+1) o (x+2, y+2) o (x+2, y+3). El resto de coordenadas no causan colisión.

Otro tema a tener en cuenta. Nuestro juego es de plataformas y Koopa está siempre en las mismas coordenadas, son las plataformas las que se mueven, por lo que habrá que calcular en que casillas del mapa está nuestra tortuga.

En el código que tenemos hecho hasta la fecha estamos trabajando con formas de 16x16 pixeles,

y esto nos va a dar problemas. Hay que cambiar las cosas, tenemos que pasar a que nuestro mapa vuelva a ser de 8x8. Dejaremos las funciones de 16x16 por si otro proyecto las necesitase.

El mapa de colisiones, es decir un array parecido al que define la forma de nuestro mundo pero de colisiones.

En definitiva hemos añadido el siguiente código:

Se ha creado una función que nos permite asignar un array donde definir los obstáculos de nuestro mundo:
void ScreenManager::SetCollisionMap8x8(void *collisionMap, unsigned int cols, unsigned int rows).

Y una que nos permita preguntar por una posible colisión:
int ScreenManager::IsCollision(Sprite *sprite, int x, int y). Ambas funciones se han implementado en la clase ScreenManager.

En la clase Sprite se han definido las siguientes funciones:
void SetCollisionMap(void *collisionMap, unsigned int cols, unsigned int rows);
void *GetCollisionMap();
unsigned int GetCollisionCols();
unsigned int GetCollisionRows();
Que son las que sirven para definir el mapa de colisiones del Sprite.

En NSMB.cpp hemos añadido el control de colisiones. Para hacer pruebas hemos dejado el código de subir y bajar, que no son del juego de NSMB, pero nos sirven, en este momento, para probar la funcionalidad. Este control lo encontraréis en la función int NSMB::avanzar() que es invocada desde HeldRight y HeldLeft.

El editor de pantallas tiene nuevas opciones como son la de grabar mapas de 8x8 y uno de colisiones.

Para ver la versión que corresponde a este post pinchar aquí.
La nueva versión del editor de mapas está aquí.

Esto empieza a tener algo de forma. Nos falta que nuestro héroe, que tiene que ser Mario y no koopa, empiece a saltar. Lo dejaremos para próximos post. Y las monedas, tenemos que llenar nuestro mundo de monedas!!!

Nos vemos en los comentarios.

Saludos

Creación de mapas para el Juego

2009-04-24T00:01:00.000-07:00

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

Doxygen :: Comentar el código

2009-04-10T00:01:00.000-07:00

He estado hablando con David y estamos viendo la posibilidad de comentar el código de una forma más extensa que hasta ahora. O mejor dicho, hasta ahora no se comentaba casi nada en las fuentes.

Hemos estado mirando las distintas herramientas que hay en Internet para documentar un proyecto y parece que Doxygen es la que nos parece más potente y fácil de usar. Posee una opción para utilizar los comentarios JavaDoc por lo que el que conozca esta forma de comentar ya lo tiene todo hecho, y ese es más o menos mi caso.

El resultado es algo parecido a esto:

¡Ahora sólo queda comentar el código!

Saludos

Sonidos en la Nintendo DS

2009-04-03T00:10:00.000-07:00

Esta semana vamos a tocar un tema que hasta el momento no habíamos hecho nada, el sonido.

Para ilustrar el tema tenemos código que ha mandado David. David es un crack de la programación de la nintendo DS, además de ser quien aporta más comentarios al Blog.

El código es el siguiente:


#include &lh;PA9.h>

#include "intro.h"
#include "uno.h"  // Include the sound (found in the data folder in .raw format)
#include "dos.h"
#include "tres.h"
#include "cuatro.h"

#include "constantes.h"

int main(void)
{
 PA_Init();    // Initializes PA_Lib
 PA_InitVBL(); // Initializes a standard VBL

 PA_InitSound();
 
 PA_InitText(SCREEN_TOP, BACKGROUND_ZERO);  // Initialise the text system on the top screen
 PA_InitText(SCREEN_BOTTOM, BACKGROUND_ZERO);  // Initialise the text system on the top screen

 PA_OutputSimpleText(SCREEN_TOP, 0, 1, "Prueba raw,pulsa Arriba para escuchar");
 PA_OutputSimpleText(SCREEN_TOP, 0, 3, "--------------------------------");
 
 PA_WaitForVBL();
 
 s32 sonido = 1;
 while (1)
 {
  if (Pad.Newpress.Up)
  {
   switch (sonido)
   {
    case 1:
     PA_PlaySimpleSound(0, uno);
     sonido ++;
     break;
    case 2:
     PA_PlaySimpleSound(0, dos);
     sonido ++;
     break;
    case 3:
     PA_PlaySimpleSound(0, tres);
     sonido ++;
     break;
    case 4:
     PA_PlaySimpleSound(0, cuatro);
     sonido = 1;
     break;
    default:
     PA_PlaySimpleSound(0, intro);
     break;
   }
  }
  
  PA_OutputText(SCREEN_BOTTOM, 1, 3, "sonido %d  ", sonido);
  
  PA_WaitForVBL();
 }
 
 return 0;
}

Para realizar este proyecto se han de seguir los siguientes pasos:

1. Copiar los ficheros de sonido .raw a la carpeta data
2. realizar los includes de los sonidos
3. constants.h se encuentra en la carpeta 'include'. Como ya nos enseñó David, en esa carpeta puedes dejar cosas comunes y el compilador va a buscarlas ahí por defecto. constants.h hace las veces de devnintendods.h en los proyectos mios.
4. PA_InitSound(); Esta función de PALib no la habíamos usado nunca hasta ahora. Inicializa el sistema de sonido de la consola.
5.PA_PlaySimpleSound(0, uno); Hace sonar el fichero de sonido uno, por el canal 0. Tenemos hasta 8 canales disponibles, lo que permite tener varios sonidos sonando a la vez. En este ejemplo sólo falta una música de fondo, como si fuera la melodía de un juego.

El programa mantiene una variable, sonido, que va pasando de 1 a 4 para que suenen los distintos ficheros.

Un código sencillo y elegante.

El proyecto lo dejo donde siempre.

Saludos y gracias David.

P.D. En estos momentos estoy sin tiempo, y con la proximidad de semana santa quizás no consiga llegar a mi cita semanal...

NSMB.cpp

2009-03-27T00:01:00.000-07:00

Hoy vamos a ver la clase NSMB.cpp que, al fin y al cabo, es lo único programado del juego hasta la fecha. El resto es una especie de librería que con el paso del tiempo podría servir para programar todo tipo de juegos para la Nintendo DS.

Lo primero, si vemos el código, es que apenas hay nada de PALib en el código. Sólo está el include y un par de constantes. Las clases han conseguido encapsular todo el código PALib.

Veamos el código del programa:


NSMB::NSMB() {
    gameManager = new GameManager();
    gameManager->SetKeypadManager(this);
    topScreen = gameManager->GetTopScreenManager();
    koopa = topScreen->CreateSprite(BACKGROUND_THREE, KOOPA, 16, 0, 1);
    koopa->SetAnim(0, 15, 15);

    tileSet = topScreen->CreateTileSet(BACKGROUND_TWO, PLATAFORMAS);
    topScreen->PrintMap(MAPA_PLATAFORMAS, tileSet, x, y);
}

Parece poco código, veamos lo que hace:

gameManager = new GameManager();: Es la clase que crea el motor del juego. Podemos decir que engloba el HelloWorld de PaLib, es decir los init y el bucle principal.

gameManager->SetKeypadManager(this);: En esta línea le estamos diciendo que clase va a recibir la información de entrada del juego (el teclado y el sylus). 'this' significa que será la propia clase NSMB la que los recibirá.
Esto es una aproximación a lo que se suele llamar programación orientada a eventos. Es decir, cuando el usuario pulse un botón de la consola, NSMB recibirá una llamada a una de las funciones que tiene que implementar. Si, por ejemplo, se pulsa el botón de A se lanzará la función NewpressA.
Sería algo parecido a los callback, pero más orientado a objetos.

topScreen = gameManager->GetTopScreenManager();: Esto es una forma de tener una variable que apunte a la pantalla superior y no tener que ir todo el rato arrastrándo gameManager->GetTopScreenManager().

topScreen->CreateSprite(BACKGROUND_THREE, KOOPA, 16, 0, 1);: Ya tenemos un sprite hecho. Más fácil imposible. Los parámetros último son x, y y si lo queremos girar horizontalmente (1 = si).

koopa->SetAnim(0, 15, 15);: Y ahora lo animamos, entre los frames 0 a 15 y la velocidad es de 15.

tileSet = topScreen->CreateTileSet(BACKGROUND_TWO, PLATAFORMAS);: Creamos los tileset (serían los ladrillos de nuestro juego) para los fondos.

topScreen->PrintMap(MAPA_PLATAFORMAS, tileSet, x, y);: Y dibujamos el fondo de la pantalla superior.

Ya está...........

No parece muy complicado. Si no se tiene mucha experiencia en la programación con PALib puede resultar rara la definición de KOOPA. Pues nada, con echar un ojo a la entrada que se hizo en su día explicando los Sprites creo que será suficiente.

Por ahora estamos trabajando con Koopa como personaje. En cuanto saque tiempo prepararé los sprites de Mario.

El resto del código es:

void NSMB::Run() {
gameManager->Run();
}
Se podía haber puesto en el constructor (NSMB::NSMB()) pero aquí parece que queda mejor.


bool NSMB::HeldLeft() {
    if (movimiento != MOVIMIENTO_IZQUIERDA) {
        koopa->Hflip(0);
        movimiento = MOVIMIENTO_IZQUIERDA;
        koopa->StartAnim();
    } else {
        koopa->RestartAnim();
    }
    velocidad--;
    if (velocidad == 0){
        velocidad = MOVIMIENTO_VELOCIDAD;
        x--;
    }
    return 1;
}

Cuando el jugador pulse en el botón de flecha izquierda se ejecutará este código, que ahora mismo únicamente, anima a nuestra tortuga. Usa la variable 'movimiento' para hacerlo una animación más fluida, y girar a nuestro héroe cuando sea necesario. Falta el tema de las colisiones.
Con más detalle: si la tortuga estaba con otra orientación (if (movimiento != MOVIMIENTO_IZQUIERDA)) no hace falta girarlo (Hflip(0) = lo desgiramos - el sprite original mira a la izquierda) y empezamos la animación. Si ya estábamos mirando a la izquierda, únicamente, continuamos con la animación (RestartAnim). El resto del código es para ir poco a poco (lo intentaremos mejorar llamando a una función, que también la llamará HeldRight, que será la encargada de mover a nuestro héroe y mirar las colisiones).


bool NSMB::HeldRight() {
    if (movimiento != MOVIMIENTO_DERECHA) {
        koopa->Hflip(1);
        movimiento = MOVIMIENTO_DERECHA;
        koopa->StartAnim();
    } else {
        koopa->RestartAnim();
    }
    velocidad--;
    if (velocidad == 0){
        velocidad = MOVIMIENTO_VELOCIDAD;
        x++;
    }
    return 1;
}

Igual que el anterior pero para ir a la derecha.


bool NSMB::NoKey() {
    koopa->PauseAnim();
    return 1;
}

Si no se ha pulsado ninguna tecla se ejecutará esta función. Nosotros la usaremos para parar la animación de nuestro héroe.


bool NSMB::BeforeVBL() {
    topScreen->PrintMap(MAPA_PLATAFORMAS, tileSet, x, y);
    return 1;
}

Esto se ejecutará siempre, una vez por cada vuelta del bucle, después de tratar el teclado (incluida la función de que no se ha pulsado ninguna tecla).

Y esto es todo, por ahora. La primera versión de GameManager ha sido publicada, esperemos que no sea la última.

Y ¿cómo usarlo? Es decir, ¿cómo llamar a NSMB?

Vemos el código de main.cpp:


#include "NSMB.h"

int main(int argc, char ** argv) {
    NSMB *nsmb = new NSMB();
    nsmb->Run();
    return 0;
}

Uhmmm, no sé que se puede explicar. Se crea un objeto de tipo NSMB y ejecutamos un 'run'.

Nos vemos en los comentarios.

Saludos

Nueva versión del Tetris

2009-03-20T00:00:00.000-07:00

Hacemos un paréntesis en la programación del NSMB y vamos a presentar la última versión del Tetris.

Se ha creado un menú en la pantalla táctil, por lo que usaremos el stylus por primera vez en este blog. La imagen es la siguiente:

Posibilita la selección de tres tipos de juegos.

PALib controla cuando se pulsa en la pantalla táctil y devuelve las coordenadas (x, y) donde se ha pulsado.

if (Stylus.Held) {
tipo_juego = obtener_tipo_juego(Stylus.X, Stylus.Y);

El Stylus.Held indica que se está pulsando en la pantalla y las coordenadas quedan en Stylus.X y en Stylus.Y. Ahora para saber si se ha pulsado un botón u otro se ha creado esta función:


u8 obtener_tipo_juego(s32 xStylus, s32 yStylus) {
    if (pulsado_boton_con_stylus(xStylus, yStylus, 60, 37, 205, 79)) {
        return JUEGO_MARATON;
    } else if (pulsado_boton_con_stylus(xStylus, yStylus, 74, 83, 224, 125)) {
        return JUEGO_EXPERTO;
    } else if (pulsado_boton_con_stylus(xStylus, yStylus, 61, 133, 226, 170)) {
        return JUEGO_SUPER_BLOQUES;
    } else {
        return 0;
    }
}

bool pulsado_boton_con_stylus(s32 xStylus, s32 yStylus, s32 x1, s32 y1, s32 x2, s32 y2) {
    return (xStylus > x1 && xStylus <> y1 && yStylus < y2);
}

Esta última función es la que uso en todos los proyectos. Sirve para saber si un punto (x, y) esta dentro de un rectángulo (x1, y1) - (x2, y2).
Los rectángulos los sacamos de la imagen, y aunque los botones estén un poco torcidos más o menos he trazado unos rectángulos y son esas coordenadas las que he usado:

El modo superbloques muestra fichas de distintas formas, posibilidad que nos da el haber creado las fichas como matrices de 4x4. Y tanto este modo como el experto van incrementando las velocidad a medida que se consigue aumentar la puntuación.

Veamos la función actualizar_puntuacion:


if (tipo_juego == JUEGO_EXPERTO || tipo_juego == JUEGO_SUPER_BLOQUES) {
    if (nivel != puntos / 100) {
        nivel = puntos / 100; velocidad -= nivel;
    }
}

Cada cien puntos aumentamos la velocidad (o disminuimos el tiempo de espera).

Os dejo todo el código en el lugar habitual para que echéis un vistazo. Como siempre nos vemos en los comentarios.

Saludos

Clases básicas: TileSet

2009-03-14T02:59:00.000-07:00

TileSet es una clase que nos permite trabajar con los tiles. Los tiles son esas pequeñas imágenes, de 8x8 pixeles, que sirven para dibujar en las pantallas de la nintendo DS.

Para explicarlo mejor, las pantalla de la DS tienen 256x192 pixeles. Dividido entre 8 nos da 32x24 casillas. Es decir, cada pantalla tienen 32x24 casillas, y en cada casilla se puede dibujar un tile.

PaLib nos permite trabajar con estos tiles de una forma muy sencilla, pero la clase TileSet nos permite aún una mayor abstracción. Sólo contiene, por ahora, tres funciones.

El constructor de la clase nos permite cargar en memoria la imagen con todos los tiles de nuestro juego.

La función SetTile16x16 nos permitirá dibujar en una ubicación dada un tile.

La función GetTile nos permite ver que tile hay en una ubicación dada. Esto nos servirá para el tema de colisiones.

Esta es la imagen que usamos, en este momento, en el proyecto:

Si os fijáis bien el primer rectángulo es rosa, eso significa que el 0 será un recuadro transparente.

Un ejemplo de uso:

#define PLATAFORMAS (void *)plataformas_Pal, (void *)plataformas_Tiles, SIZEOF_16BIT(plataformas_Tiles), (void *)plataformas_Map

#define COLUMNAS_16x16_PANTALLA 16
#define COLUMNAS_16x16_MAPA 48
#define FILAS_16x16 12
#define MAPA_PLATAFORMAS (void *)mapa, COLUMNAS_16x16_PANTALLA, FILAS_16x16, COLUMNAS_16x16_MAPA

int mapa[COLUMNAS_16x16_MAPA * FILAS_16x16] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1, 5, 2, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
7, 12, 8, 11, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
7, 8, 13, 12, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0,
7, 12, 8, 11, 14, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
7, 11, 12, 13, 14, 0, 0, 0, 0, 0, 0, 7, 9, 8, 10, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
7, 12, 13, 8, 14, 0, 0, 0, 0, 0, 0, 7, 12, 10, 13, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
7, 13, 9, 10, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
7, 12, 8, 12, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
7, 8, 12, 13, 15, 4, 3, 3, 4, 2, 3, 4, 2, 5, 4, 4, 3, 5, 2, 3, 5, 4, 3, 3, 4, 2, 3, 4, 2, 5, 4, 2, 3, 5, 2, 3, 5, 4, 3, 3, 4, 2, 3, 4, 2, 5, 4, 6,
7, 11, 13, 12, 8, 10, 9, 11, 12, 11, 8, 12, 12, 13, 12, 8, 10, 9, 11, 12, 11, 8, 12, 9, 11, 12, 11, 8, 12, 9, 13, 12, 8, 10, 9, 11, 8, 12, 12, 13, 12, 10, 12, 11, 8, 12, 9, 14
};

TileSet *newTileSet = new TileSet(SCREEN_TOP, BACKGROUND_TWO, PLATAFORMAS);
newTileSet->SetTile16x16(MAPA_PLATAFORMAS, 10, 10);

Es muy sencillo. Me gusta usar los defines, porque el código queda mucho más claro, desaparecen * y (void *) y queda todo más cómodo.

Saludos

Clases básicas - Sprite

2009-03-06T01:33:00.000-08:00

En nuestro NSMB vamos a empezar a definir una serie de clases que se encargarán, cada una de ellas, de un apartado propio del juego.

NOTA:
Aquí vamos a explicar como se han construido estas clases y como funcionan. Si no te interesa o tu nivel de programación aún no ha llegado a esto, podrías saltarte la explicación y únicamente aprender a usarlas.

Incluso podemos diferenciar la lógica del juego del apartado gráfico (las propias librerías PALib) por lo que sería más fácil pasar el juego a otro sistema. Vamos a presentar en este post la clase Sprite (vimos una primera versión en el post anterior).

Esta clase será la encargada de cargar y mostrar los personajes o los objetos con los que interactuaremos en nuestros juegos. Podremos animar los Sprites, rotarlos, moverlos, etc.

En C++ las clases se componen de dos ficheros, el .h y el .cpp.
En el .h se almacena la definición de la clase, su nombre, las funciones públicas, las privadas y las variables miembro.
En el .cpp está el código, la implementación de la propia clase.

Sprite.h

#ifndef SPRITE_H
#define SPRITE_H

class Sprite {

private:
    static unsigned int index_sprites;
    static unsigned int index_sprites_pals;

protected:
    unsigned int m_index_sprite;
    unsigned int m_index_pal;
    unsigned int m_screen;
    unsigned int m_background;
    unsigned int m_size;

    unsigned int m_firstframe;
    unsigned int m_lastframe;
    unsigned int m_speed;

    int m_x;
    int m_y;

    Sprite(unsigned int screen, unsigned int background, unsigned int size, int x, int y);

public:
    Sprite(unsigned int screen, unsigned int background, unsigned int shape, unsigned int size, void *palette, void *sprite, int x, int y, int hflip = 0);
    ~Sprite();

    unsigned int GetIndexSprite();
    unsigned int GetScreen();

    Sprite *Clone();
    Sprite *Clone(int x, int y);

    void SetAnim(unsigned int firstframe, unsigned int lastframe, unsigned int speed);
    void StartAnim(unsigned int firstframe, unsigned int lastframe, unsigned int speed);
    void StartAnim();
    void StopAnim();
    void RestartAnim();
    void PauseAnim();

    void Hflip(bool hflip);

    void SetX(int x);
    void SetY(int y);
    void SetXY(int x, int y);

    int GetX();
    int GetY();

    int MoveRight(int offset);
    int MoveLeft(int offset);
    int MoveUp(int offset);
    int MoveDown(int offset);
};

#endif

Las variables miembro son las que definen el estado de un objeto. En nuestro caso son las variables que tienen como prefijo una m_ :
m_index_sprite, m_index_pal, m_screen, m_background, m_firstframe, m_lastframe, m_speed, m_x, m_y.

Las variables miembro son las que almacenan el estado, es decir son las que diferencian un objeto de otro. Veamos cada una que hace:

m_index_sprite, m_index_pal quedan ocultas a la programación. Son valores necesarios para PALib. Si os fijaís existen unas variables (index_sprites, index_sprites_pals) que son estáticas, es decir son únicas para todos los objetos, y son las encargadas de crear los índices para cada Sprite y cada Paleta). (En el primer tutorial son los valores HEROE_PALLETE y HEROE_SPRITE, gracias a la POO nos olvidamos de ellas)

Como siempre es más difícil explicarlo que verlo o hacerlo.

El resto de variables miembro nos indican a que pantalla pertenece el Sprite y dentro de cada pantalla a que fondo, m_screen y m_background.

m_firstFrame y m_lastFrame, sirven para realizar la animación. m_speed nos indica la velocidad de la misma.

m_x y m_y almacenan las coordenadas del sprite.

El resto del fichero .h son las declaraciones de las funciones. Tenemos un constructor, con el último campo puesto = 0. Esto significa que se puede no usar y por defecto es cero. Es decir al crear el sprite lo podemos rotar horizontalmente si ponemos un 1 en ese campo, si no queremos rotarlo,no ponemos nada.

El resto son una serie de funciones que su nombre ya las explica.

Ahora veamos como usarlo:

#define COIN OBJ_SIZE_16X16, (void*)coin_Pal, (void*)coin_Sprite

Sprite coin_i(BACKGROUND_THREE, COIN, 96, 32);
coin_i.StartAnim(0, 3, 5);
Sprite coin_ii = coin_i.Clone(112, 16);
Sprite coin_iii = coin_ii.Clone();
coin_iii.MoveRight(16);
Sprite coin_iv = coin_i.Clone(144, 32);

No creo que necesite más explicación, si no, nos vemos en los comentarios.

En cuanto a la librería PALib, en esta clase utilizo por primera vez la función PA_SpriteAnimPause. Esta función permite parar una animación y continuarla posteriormente. Utiliza como parámetros el fondo donde está el sprite, así como su índice (para saber cual parar) y el último parámetro es un 1 para parar la animación y 0 para reanudarla. Ejemplo de uso:

void Sprite::RestartAnim() {
PA_SpriteAnimPause(m_screen, m_index_sprite, 0);
}

void Sprite::PauseAnim() {
PA_SpriteAnimPause(m_screen, m_index_sprite, 1);
}

De esta forma al pulsar poco a poco el teclado, la animación se hace continua y no parece que esté andando a la pata coja.

Otra función que se utiliza por primera vez en este tutorial es la de Clonar un Sprite, PA_CloneSprite. Como parámetros se le pasa la pantalla de la DS donde está cargado el Sprite, el índice de este para saber cual clonar y, por último, el índice del nuevo Sprite. Clonar Sprites nos ahorra espacio en memoria, ya que comparten toda la información gráfica. En nuestro caso va a ser muy util para las monedas que aparecen a lo largo de todo el juego.

Saludos

PD: Voy a dejar todo el proyecto, tal y como está ahora, en la siguiente dirección: http://sites.google.com/site/devnintendods/Home/nsmb. Lo que dejo ahí es todo lo que tengo hecho hasta ahora (SuperMarioDS_0.2). Es todo el montaje que estoy haciendo. Lo iré explicando en los siguientes Post. Sólo decir que main.cpp únicamente llama a NSMB.cpp que es el que lo hace todo.

Aún así, se pueden usar las clases de forma independiente en cualquier otro proyecto.

Enlaces patrocinados

New Super Mario Bros

2009-02-27T01:00:00.000-08:00

¡Cómo programar un juego tipo New Super Mario Bros (NSMB)!

Pues no es muy difícil, pero tampoco es fácil. Ante la cantidad de elementos que intervienen en el juego yo me inclinaría más por programar con orientación a objetos. Por lo que se necesita un poco más de nivel de programación del que hemos empleado hasta ahora.

Pero no nos desanimemos, utilizaremos la orientación a objetos de una forma sencilla y didáctica y, seguramente, tomaremos decisiones para que resulte lo más sencillo posible.

Otra cosa, en algún comentario se apunta a la posibilidad de hacer pantallas desde donde se puedan elegir opciones, y de esta forma, dejar un acabado más elegante a los juegos. El problema para mi estriba en que todo lleva tiempo y el poco de que dispongo me gusta más emplearlo en hacer el motor propio del juego. Aún así, intentaremos hacer cosas en ese sentido.

Empecemos con con la Orientación a objetos.

A la hora de ir a compilar un fichero .cpp (c++) PALib puede que de algún que otro error de compilación. En mi caso esta fue la pantalla del error:

La solución fue poner lo siguiente en el fichero PA_Sound.h:

línea 212: FS_wav[PA_Channel] = (u32*)PA_Malloc(FS_wav[PA_Channel], PA_FSFile[PAFS_wav_number].Length+4);

línea 430: FS_mod = (u32*)PA_Malloc(FS_mod, PA_FSFile[PAFS_mod_number].Length+4);

Antes de hacer este cambio mirar si os da error al compilar c++.

Y ahora ¿Qué es la orientación a objetos?

Pues es una forma de describir el mundo que estamos programando. Por ejemplo, en el primer tutorial de este blog presentamos un juego muy sencillo, un sprite moviéndose por un pueblecito. En este caso sólo era necesario las coordenadas de nuestro héroe y el mapa para las colisiones. Todo esto era lo único necesario para describir nuestro mundo.
En el Tetris las cosas se complicaban un poco más, teníamos un tablero y unas fichas que giraban. Para describir ese mundo tendríamos dos clases, la del tablero y la de ficha.

Ahora tenemos el NSMB, donde todo es mucho más complejo, no sólo en cantidad, si no en la forma de interactuar entre los distintos elementos del juego, los enemigos, las plataformas, las monedas, incluso nuestro héroe, Mario, puede cambiar de tamaño, salta, etc.

La orientación a objetos permite describir cada parte de nuestro mundo en un fichero aparte, teniendo todo muy bien organizado. Nos permitirá tener personajes con distinto comportamiento moviéndose por el juego. Incluso las propias plataformas serán una clase, desde donde se describirá su aspecto, así como su comportamiento.

Algunas de las clases que presentaremos podrían pasar perfectamente a un proyecto que se denominase PALib++, pero eso ya es harina de otro costal.

Podéis acceder a un primer proyecto para probar el compilador de c++. Esto el lo que se verá si ponéis en marcha el proyecto:

Este código contiene una clase llamada Sprite (en sprite.h está la definición de la clase y en Sprite.cpp el código) que es la responsable de cargar un sprite en la pantalla. Es mejorable, repite paletas y se puede simplificar, aún más, su utilización, pero lo dejaremos para el siguiente post.

Una de las mejoras que nos da el uso de clases es el poder simplificar el algoritmo propio del juego. Main.cpp queda más sencillo, y eso mejora la legibilidad del código. Por ejemplo, si quiero añadir un nuevo Sprite, únicamente serían dos líneas de código.

//Con clases
Sprite koopa(SCREEN_TOP, BACKGROUND_THREE, OBJ_SIZE_32X32, (void*)koopa_Pal, (void*)koopa_Sprite, 128, 140);
koopa.rotar_horizontal();
koopa.animar(0, 15, 15);

//Sin clases
PA_LoadSpritePal(SCREEN_TOP, KOOPA_PALLETE,(void*)koopa_Pal);
PA_CreateSprite(SCREEN_TOP, KOOPA_SPRITE, (void*)koopa_Sprite, OBJ_SIZE_32X32, COLOR_MODE_256, KOOPA_PALLETE, 128, 140);
PA_SetSpritePrio(SCREEN_TOP, KOOPA_SPRITE, BACKGROUND_THREE);
PA_SetSpriteHflip(SCREEN_TOP, KOOPA_SPRITE, 1);
PA_StartSpriteAnim(SCREEN_TOP, KOOPA_SPRITE, 0, 15, 15);

En las siguientes entregas iremos mejorando la clase Sprite. Estoy pensando en hacerla en Inglés para que se pueda distinguir bien del algoritmo del juego.

Saludos

La ficha siguiente

2009-02-20T01:00:00.000-08:00

Para poder mostrar la siguiente ficha que va a salir tendremos que tener dos variables 'ficha' y 'ficha_siguiente'.

Modificaremos la función 'obtener_ficha' para que en vez de asignar a la variable 'ficha' la ficha buscada de forma aleatoria, se le asigne a la variable 'ficha_siguiente'. La función 'obtener_ficha' quedará de la siguiente manera:

u8 obtener_ficha() {
    u8 tipo = PA_RandMax(6); //0..6
    u8 color = PA_RandMinMax(2, 7); //2..7
    ficha.y = 0;
    ficha.x = TABLERO_ANCHO / 2;
    copiar_ficha_siguiente();
    if (tipo == 0) crear_ficha_t(color);
    else if (tipo == 1) crear_ficha_l(color);
    else if (tipo == 2) crear_ficha_o(color);
    else if (tipo == 3) crear_ficha_z(color);
    else if (tipo == 4) crear_ficha_s(color);
    else if (tipo == 5) crear_ficha_j(color);
    else crear_ficha_i(color);
    dibujar_ficha_siguiente();
    return existe_colision(ficha.x, ficha.y);
}

void copiar_ficha_siguiente() {
    u8 i, j;
    ficha.radio = ficha_siguiente.radio;
    for(i = 0; i < FICHA_ANCHO; i++)
        for(j = 0; j < FICHA_ALTO; j++)
            ficha.ficha[i][j] = ficha_siguiente.ficha[i][j];
}

Con esto ya dejamos más o menos el juego terminado. En está página está disponible el código completo del proyecto.

Hay un tema en cuanto a la forma de programar.

En los dos juegos que hemos programado hasta la fecha, hemos utilizado una serie de variables globales y funciones que trabajan sobre ellas, siendo esto válido para juegos sencillos pero no tanto para juegos más complicados.

Conceptos como el ámbito de las variables han de ser considerados a la hora de realizar este tipo de programas. Por ejemplo, la función obtener_ficha, así como las de rotar deberían de trabajar sobre un parámetro ficha, y no sobre las variables globales. Esto dejaría el código más limpio y daría mayor flexibilidad si se quisieran introducir más funcionalidades.

Por ahora lo dejaremos así, pero si queremos hacer el New Super Mario Bros, deberemos empezar a hacer las cosas más limpias.

Saludos

Volcar las fichas al tablero

2009-02-13T01:00:00.000-08:00

En este post vamos a dar forma completamente al motor del juego. Lo que nos queda es pasar las fichas al tablero cuando estas colisiones. Una vez hecho esto mirar si se ha hecho una línea y posteriormente quitarla.

Así que manos a la obra.

Para pasar las fichas al tablero necesitaremos esta función:

void copiar_ficha_a_tablero() {
    u8 i, j;

    for(i = 0; i < FICHA_ANCHO; i++)
        for(j = 0; j < FICHA_ALTO; j++)
            if (ficha.ficha[i][j] != CASILLA_VACIA)
                tablero[ficha.x + i][ficha.y + j] = ficha.ficha[i][j];
}

Para saber si se ha hecho una o más líneas:

u8 es_linea_completa(u8 fila) {
    u8 i;

    for(i = 0; i < TABLERO_ANCHO; i++)
        if (tablero[i][fila] == CASILLA_VACIA) return 0;
    return 1;
}

Para quitar esa línea que se hallado:

void quitar_linea(u8 fila) {
    u8 i, j;

    for(i = 0; i < TABLERO_ANCHO; i++)
        for(j = fila; j > 0; j--)
            tablero[i][j] = tablero[i][j - 1];
}

Por último, actualizaremos la puntuación, dependiendo del número de lineas que se hagan de una sola vez:

void actualizar_puntuacion(u8 lineas) {
    if (lineas == 1) puntos += 10;
    else if (lineas == 2) puntos += 30;
    else if (lineas == 3) puntos += 60;
    else if (lineas == 4) puntos += 100;

    PA_OutputText(SCREEN_TOP, 25, 12, "%d   ", puntos);
}

El último código lo podeis descargar, junto a todo el proyecto, desde esta página.

En esta versión he puesto una pantalla de entrada, para ir decorando el juego. Se nota que no soy diseñador gráfico!!!

Saludos

Controlar las fichas

2009-02-06T01:00:00.000-08:00

El siguiente paso es crear las fichas y que empiecen a caer por el tablero. Las funciones ya las presentamos en los primeros post de este tutorial así que aquí se presentan todas las de las fichas.

Hemos introducido el control el teclado, donde se puede ver la diferencia entre pulsar una tecla y tenerla pulsada.

Usaremos Pad.Newpress.Right/Left para controlar que pulsen, y suelten, la tecla de ir a la derecha. Esto es para controlar el movimiento horizontal de la ficha de un modo más preciso. Sin embargo, la tecla de bajar se quiere que sea algo rápido, por lo que usaremos Pad.Held.Down (estar pulsado).

Por último, merece la pena ver la función de existe_colision:

01.u8 existe_colision(int x, int y) {
02.    u8 i, j;

03.    for(i = 0; i < FICHA_ANCHO; i++)
04.        for(j = 0; j < FICHA_ALTO; j++)
05.            if (ficha.ficha[i][j] != CASILLA_VACIA) {
06.                if (x + i < 0) return 1;
07.                if (x + i >= TABLERO_ANCHO) return 1;
08.                if (y + j >= TABLERO_ALTO) return 1;
09.                if (tablero[x + i][y + j] != CASILLA_VACIA) return 1;
10.            }
11.    return 0; //false
12}

Se utiliza el tipo 'int' porque x puede ser negativo.
En la línea 5 se puede ver que únicamente se mirará si alguna casilla de la ficha produce colisión si no está vacía.
Las líneas 6, 7 y 8 miran los bordes del tablero y por fin la línea 9 es la que mira que si en el tablero hay ocupada una casilla se produzca colición.

Otro tema es el de la variable ficha_timer y la constante VELOCIDAD_MINIMA. Se utilizan para que las fichas caigan a una velocidad controlada.

El código:

#include <PA9.h>

#include "gfx/all_gfx.h"
#include "gfx/all_gfx.c"

#include "devnintendods.h"

#define TABLERO_ANCHO 10
#define TABLERO_ALTO 21

#define FICHA_ANCHO 4
#define FICHA_ALTO 4

#define CASILLA_VACIA 1
#define CASILLA_ROJA 2
#define CASILLA_AZUL 3
#define CASILLA_VERDE 4
#define VELOCIDAD_MINIMA 25
#define BORDE_IZQUIERDO 1

//La fila 0 es la de más arriba y la 16 la de la base. La columna 0 es la de la izquierda.
u8 tablero[TABLERO_ANCHO][TABLERO_ALTO];

typedef struct {
    int x, y;
    u8 radio;
    u8 ficha[FICHA_ANCHO][FICHA_ALTO];
} tipo_ficha;

tipo_ficha ficha;

u8 ficha_timer = 0;

void inicializar_tablero();
void dibujar_tablero();
void dibujar_casilla(int x, int y, u8 ficha);

void dibujar_ficha();

u8 existe_colision(int x, int y);
u8 obtener_ficha();

void crear_ficha_t(u8 color);
void crear_ficha_l(u8 color);
void crear_ficha_o(u8 color);
void crear_ficha_z(u8 color);
void crear_ficha_i(u8 color);
void crear_ficha_s(u8 color);
void crear_ficha_j(u8 color);
void girar_ficha_derecha();
void girar_ficha_izquierda();

int main(int argc, char ** argv) {
    PA_Init();
    PA_InitVBL();
    PA_InitText(SCREEN_TOP, BACKGROUND_TWO);

    PA_DualLoadBgPal(BACKGROUND_THREE, (void *)tiles_Pal);
    PA_DualLoadSimpleBg(BACKGROUND_THREE, tiles_Tiles, Blank, BG_256X256, 0, 1);
    PA_EasyBgScrollXY(SCREEN_BOTTOM, BACKGROUND_THREE, 0, 0);

    PA_EasyBgLoad(SCREEN_TOP, BACKGROUND_ONE, fondo_top);
    PA_EasyBgLoad(SCREEN_BOTTOM, BACKGROUND_ONE, fondo_bottom);

    inicializar_tablero();
    dibujar_tablero();
    obtener_ficha();

    while  (1) {
        if (Pad.Newpress.Left) {
            if (!existe_colision(ficha.x - 1, ficha.y)) ficha.x--;
        } else if (Pad.Newpress.Right) {
            if (!existe_colision(ficha.x + 1, ficha.y)) ficha.x++;
        } else if (Pad.Held.Down) {
            if (!existe_colision(ficha.x, ficha.y + 1)) ficha.y++;
        } else if (Pad.Newpress.Y) {//girar izquierda
            girar_ficha_izquierda();
            if (existe_colision(ficha.x, ficha.y)) girar_ficha_derecha();
        } else if (Pad.Newpress.A) {//girar derecha
            girar_ficha_derecha();
            if (existe_colision(ficha.x, ficha.y)) girar_ficha_izquierda();
        } else {
            ficha_timer++;
            if (ficha_timer > VELOCIDAD_MINIMA) {
                ficha_timer = 0;
                if (!existe_colision(ficha.x, ficha.y + 1)) {
                    ficha.y++;
                } else {
                    obtener_ficha();
                }
            }
        }
        dibujar_tablero();
        dibujar_ficha();
        PA_WaitForVBL();
    }
}

void inicializar_tablero() {
    u8 i, j;

    for(i = 0; i < TABLERO_ANCHO; i++)
        for(j = 0; j < TABLERO_ALTO; j++)
            tablero[i][j] = CASILLA_VACIA;
}

void dibujar_tablero() {
    u8 i, j;

    for(i = 0; i < TABLERO_ANCHO; i++)
        for(j = 0; j < TABLERO_ALTO; j++)
            dibujar_casilla(i, j, tablero[i][j]);
}

void dibujar_casilla(int x, int y, u8 ficha) {
    u8 x1 = x * 2;
    u8 y1 = y;
    u8 screen = SCREEN_TOP;
    if (y1 >= 12) {
        screen = SCREEN_BOTTOM;
        y1 = y1 - 12;
    }
    y1 = y1 * 2;
    x1 += BORDE_IZQUIERDO;
    PA_SetMapTileEx(screen, BACKGROUND_THREE, x1, y1, ficha, 0, 0, 0);
    PA_SetMapTileEx(screen, BACKGROUND_THREE, x1, y1 + 1, ficha, 0, 1, 0);
    PA_SetMapTileEx(screen, BACKGROUND_THREE, x1 + 1, y1, ficha, 1, 0, 0);
    PA_SetMapTileEx(screen, BACKGROUND_THREE, x1 + 1, y1 + 1, ficha, 1, 1, 0);
}

void dibujar_ficha() {
    u8 i, j;

    for(i = 0; i < FICHA_ANCHO; i++)
        for(j = 0; j < FICHA_ALTO; j++)
            if (ficha.ficha[i][j] != CASILLA_VACIA) dibujar_casilla(ficha.x + i, ficha.y + j, ficha.ficha[i][j]);
}

u8 existe_colision(int x, int y) {
    u8 i, j;

    for(i = 0; i < FICHA_ANCHO; i++)
        for(j = 0; j < FICHA_ALTO; j++)
            if (ficha.ficha[i][j] != CASILLA_VACIA) {
                if (x + i < 0) return 1;
                if (x + i >= TABLERO_ANCHO) return 1;
                if (y + j >= TABLERO_ALTO) return 1;
                if (tablero[x + i][y + j] != CASILLA_VACIA) return 1;
            }
    return 0; //false
}

u8 obtener_ficha() {
    u8 tipo = PA_RandMax(6); //0..6
    u8 color = PA_RandMinMax(2, 7); //2..7
    ficha.y = 0;
    ficha.x = TABLERO_ANCHO / 2;
    if (tipo == 0) crear_ficha_t(color);
    else if (tipo == 1) crear_ficha_l(color);
    else if (tipo == 2) crear_ficha_o(color);
    else if (tipo == 3) crear_ficha_z(color);
    else if (tipo == 4) crear_ficha_s(color);
    else if (tipo == 5) crear_ficha_j(color);
    else crear_ficha_i(color);
    return existe_colision(ficha.x, ficha.y);
}

void crear_ficha_t(u8 color) {
    ficha.radio = 3;
    ficha.ficha[0][0] = color;
    ficha.ficha[1][0] = color;
    ficha.ficha[2][0] = color;
    ficha.ficha[3][0] = CASILLA_VACIA;
    ficha.ficha[0][1] = CASILLA_VACIA;
    ficha.ficha[1][1] = color;
    ficha.ficha[2][1] = CASILLA_VACIA;
    ficha.ficha[3][1] = CASILLA_VACIA;
    ficha.ficha[0][2] = CASILLA_VACIA;
    ficha.ficha[1][2] = CASILLA_VACIA;
    ficha.ficha[2][2] = CASILLA_VACIA;
    ficha.ficha[3][2] = CASILLA_VACIA;
    ficha.ficha[0][3] = CASILLA_VACIA;
    ficha.ficha[1][3] = CASILLA_VACIA;
    ficha.ficha[2][3] = CASILLA_VACIA;
    ficha.ficha[3][3] = CASILLA_VACIA;
}

void crear_ficha_l(u8 color) {
    ficha.radio = 3;
    ficha.ficha[0][0] = color;
    ficha.ficha[1][0] = CASILLA_VACIA;
    ficha.ficha[2][0] = CASILLA_VACIA;
    ficha.ficha[3][0] = CASILLA_VACIA;
    ficha.ficha[0][1] = color;
    ficha.ficha[1][1] = CASILLA_VACIA;
    ficha.ficha[2][1] = CASILLA_VACIA;
    ficha.ficha[3][1] = CASILLA_VACIA;
    ficha.ficha[0][2] = color;
    ficha.ficha[1][2] = color;
    ficha.ficha[2][2] = CASILLA_VACIA;
    ficha.ficha[3][2] = CASILLA_VACIA;
    ficha.ficha[0][3] = CASILLA_VACIA;
    ficha.ficha[1][3] = CASILLA_VACIA;
    ficha.ficha[2][3] = CASILLA_VACIA;
    ficha.ficha[3][3] = CASILLA_VACIA;
}

void crear_ficha_j(u8 color) {
    ficha.radio = 3;
    ficha.ficha[0][0] = CASILLA_VACIA;
    ficha.ficha[1][0] = color;
    ficha.ficha[2][0] = CASILLA_VACIA;
    ficha.ficha[3][0] = CASILLA_VACIA;
    ficha.ficha[0][1] = CASILLA_VACIA;
    ficha.ficha[1][1] = color;
    ficha.ficha[2][1] = CASILLA_VACIA;
    ficha.ficha[3][1] = CASILLA_VACIA;
    ficha.ficha[0][2] = color;
    ficha.ficha[1][2] = color;
    ficha.ficha[2][2] = CASILLA_VACIA;
    ficha.ficha[3][2] = CASILLA_VACIA;
    ficha.ficha[0][3] = CASILLA_VACIA;
    ficha.ficha[1][3] = CASILLA_VACIA;
    ficha.ficha[2][3] = CASILLA_VACIA;
    ficha.ficha[3][3] = CASILLA_VACIA;
}

void crear_ficha_o(u8 color) {
    ficha.radio = 2;
    ficha.ficha[0][0] = color;
    ficha.ficha[1][0] = color;
    ficha.ficha[2][0] = CASILLA_VACIA;
    ficha.ficha[3][0] = CASILLA_VACIA;
    ficha.ficha[0][1] = color;
    ficha.ficha[1][1] = color;
    ficha.ficha[2][1] = CASILLA_VACIA;
    ficha.ficha[3][1] = CASILLA_VACIA;
    ficha.ficha[0][2] = CASILLA_VACIA;
    ficha.ficha[1][2] = CASILLA_VACIA;
    ficha.ficha[2][2] = CASILLA_VACIA;
    ficha.ficha[3][2] = CASILLA_VACIA;
    ficha.ficha[0][3] = CASILLA_VACIA;
    ficha.ficha[1][3] = CASILLA_VACIA;
    ficha.ficha[2][3] = CASILLA_VACIA;
    ficha.ficha[3][3] = CASILLA_VACIA;
}

void crear_ficha_z(u8 color) {
    ficha.radio = 3;
    ficha.ficha[0][0] = color;
    ficha.ficha[1][0] = color;
    ficha.ficha[2][0] = CASILLA_VACIA;
    ficha.ficha[3][0] = CASILLA_VACIA;
    ficha.ficha[0][1] = CASILLA_VACIA;
    ficha.ficha[1][1] = color;
    ficha.ficha[2][1] = color;
    ficha.ficha[3][1] = CASILLA_VACIA;
    ficha.ficha[0][2] = CASILLA_VACIA;
    ficha.ficha[1][2] = CASILLA_VACIA;
    ficha.ficha[2][2] = CASILLA_VACIA;
    ficha.ficha[3][2] = CASILLA_VACIA;
    ficha.ficha[0][3] = CASILLA_VACIA;
    ficha.ficha[1][3] = CASILLA_VACIA;
    ficha.ficha[2][3] = CASILLA_VACIA;
    ficha.ficha[3][3] = CASILLA_VACIA;
}

void crear_ficha_s(u8 color) {
    ficha.radio = 3;
    ficha.ficha[0][0] = CASILLA_VACIA;
    ficha.ficha[1][0] = color;
    ficha.ficha[2][0] = color;
    ficha.ficha[3][0] = CASILLA_VACIA;
    ficha.ficha[0][1] = color;
    ficha.ficha[1][1] = color;
    ficha.ficha[2][1] = CASILLA_VACIA;
    ficha.ficha[3][1] = CASILLA_VACIA;
    ficha.ficha[0][2] = CASILLA_VACIA;
    ficha.ficha[1][2] = CASILLA_VACIA;
    ficha.ficha[2][2] = CASILLA_VACIA;
    ficha.ficha[3][2] = CASILLA_VACIA;
    ficha.ficha[0][3] = CASILLA_VACIA;
    ficha.ficha[1][3] = CASILLA_VACIA;
    ficha.ficha[2][3] = CASILLA_VACIA;
    ficha.ficha[3][3] = CASILLA_VACIA;
}

void crear_ficha_i(u8 color) {
    ficha.radio = 4;
    ficha.ficha[0][0] = color;
    ficha.ficha[1][0] = CASILLA_VACIA;
    ficha.ficha[2][0] = CASILLA_VACIA;
    ficha.ficha[3][0] = CASILLA_VACIA;
    ficha.ficha[0][1] = color;
    ficha.ficha[1][1] = CASILLA_VACIA;
    ficha.ficha[2][1] = CASILLA_VACIA;
    ficha.ficha[3][1] = CASILLA_VACIA;
    ficha.ficha[0][2] = color;
    ficha.ficha[1][2] = CASILLA_VACIA;
    ficha.ficha[2][2] = CASILLA_VACIA;
    ficha.ficha[3][2] = CASILLA_VACIA;
    ficha.ficha[0][3] = color;
    ficha.ficha[1][3] = CASILLA_VACIA;
    ficha.ficha[2][3] = CASILLA_VACIA;
    ficha.ficha[3][3] = CASILLA_VACIA;
}

void girar_ficha_derecha() {
    u8 nueva_ficha[FICHA_ANCHO][FICHA_ALTO];
    u8 i, j;

    for(i = 0; i < FICHA_ANCHO; i++)
        for(j = 0; j < FICHA_ALTO; j++)
            nueva_ficha[i][j] = ficha.ficha[i][j];
    if (ficha.radio == 3) {
        ficha.ficha[0][0] = nueva_ficha[0][2];
        ficha.ficha[1][0] = nueva_ficha[0][1];
        ficha.ficha[2][0] = nueva_ficha[0][0];
        ficha.ficha[0][1] = nueva_ficha[1][2];
        //ficha.ficha[1][1] = nueva_ficha[1][1];
        ficha.ficha[2][1] = nueva_ficha[1][0];
        ficha.ficha[0][2] = nueva_ficha[2][2];
        ficha.ficha[1][2] = nueva_ficha[2][1];
        ficha.ficha[2][2] = nueva_ficha[2][0];
    } else if (ficha.radio == 4) {
        ficha.ficha[0][0] = nueva_ficha[0][3];
        ficha.ficha[1][0] = nueva_ficha[0][2];
        ficha.ficha[2][0] = nueva_ficha[0][1];
        ficha.ficha[3][0] = nueva_ficha[0][0];
        ficha.ficha[0][1] = nueva_ficha[1][3];
        ficha.ficha[1][1] = nueva_ficha[1][2];
        ficha.ficha[2][1] = nueva_ficha[1][1];
        ficha.ficha[3][1] = nueva_ficha[1][0];
        ficha.ficha[0][2] = nueva_ficha[2][3];
        ficha.ficha[1][2] = nueva_ficha[2][2];
        ficha.ficha[2][2] = nueva_ficha[2][1];
        ficha.ficha[3][2] = nueva_ficha[2][0];
        ficha.ficha[0][3] = nueva_ficha[3][3];
        ficha.ficha[1][3] = nueva_ficha[3][2];
        ficha.ficha[2][3] = nueva_ficha[3][1];
        ficha.ficha[3][3] = nueva_ficha[3][0];
    }
}

void girar_ficha_izquierda() {
    u8 nueva_ficha[FICHA_ANCHO][FICHA_ALTO];
    u8 i, j;

    for(i = 0; i < FICHA_ANCHO; i++)
        for(j = 0; j < FICHA_ALTO; j++)
            nueva_ficha[i][j] = ficha.ficha[i][j];
    if (ficha.radio == 3) {
        ficha.ficha[0][0] = nueva_ficha[2][0];
        ficha.ficha[1][0] = nueva_ficha[2][1];
        ficha.ficha[2][0] = nueva_ficha[2][2];
        ficha.ficha[0][1] = nueva_ficha[1][0];
        //ficha.ficha[1][1] = nueva_ficha[1][1];
        ficha.ficha[2][1] = nueva_ficha[1][2];
        ficha.ficha[0][2] = nueva_ficha[0][0];
        ficha.ficha[1][2] = nueva_ficha[0][1];
        ficha.ficha[2][2] = nueva_ficha[0][2];
    } else if (ficha.radio == 4) {
        ficha.ficha[0][0] = nueva_ficha[3][0];
        ficha.ficha[1][0] = nueva_ficha[3][1];
        ficha.ficha[2][0] = nueva_ficha[3][2];
        ficha.ficha[3][0] = nueva_ficha[3][3];
        ficha.ficha[0][1] = nueva_ficha[2][0];
        ficha.ficha[1][1] = nueva_ficha[2][1];
        ficha.ficha[2][1] = nueva_ficha[2][2];
        ficha.ficha[3][1] = nueva_ficha[2][3];
        ficha.ficha[0][2] = nueva_ficha[2][0];
        ficha.ficha[1][2] = nueva_ficha[1][1];
        ficha.ficha[2][2] = nueva_ficha[1][2];
        ficha.ficha[3][2] = nueva_ficha[1][3];
        ficha.ficha[0][3] = nueva_ficha[0][0];
        ficha.ficha[1][3] = nueva_ficha[0][1];
        ficha.ficha[2][3] = nueva_ficha[0][2];
        ficha.ficha[3][3] = nueva_ficha[0][3];
    }
}

En el próximo post hablaremos de como manejar el tablero.

Saludos

P.D.: Supongo que os estáis dando cuenta que el código se está haciendo muy grande. En el próximo post publicaremos un zip con todo el proyecto.

Enlaces patrocinados:

Los tiles y cómo dibujar el Tablero

2009-01-28T23:28:00.000-08:00

Por fin vamos a ver una nueva técnica que nos ofrece las librerías PALib.

A la hora de programar juegos de tablero, o a la hora de dibujar nuestros mundos, no es necesario cargar unos fondos enormes. PALib ofrece la posibilidad de poder dibujar tiles.

Los tiles son pequeñas casillas que se pueden dibujar en la pantalla tantas veces como se quiera. Son casillas de 8x8 pixeles, por lo que una pantalla de la DS que tiene 256x192 tendrá 32x24 tiles.

La siguiente imágen nos carga los tiles que vamos a usar en esta primera versión del Tetris:

Si os fijáis bien, se han creado una serie de cuadraditos de 8x8 pixeles que serán las posibles casillas a dibujar. Cómo las fichas del Tetris tienen distintos colores pues hemos hecho casillas de diferentes colores.

Ahora veamos el código poco a poco para ver cómo funciona todo:

En primer lugar:

Cargamos la imagen de los tiles en las dos pantallas mediante estas dos funciones de la API de PALib.
PA_DualLoadBgPal(BACKGROUND_TWO, (void *)tiles_Pal);
PA_DualLoadSimpleBg(BACKGROUND_TWO, tiles_Tiles, Blank, BG_256X256, 0, 1);

La primera carga la paleta de la imagen, y la segunda carga, en las dos pantallas, la imagen como si fueran tiles y lo muestra en pantalla.
¿Pero que muestra? Un array de ceros, Blank, de 32x24 en cada una de las pantallas. Como la primera casilla de la imagen (la casilla cero) de tiles es negra, mostrará una pantalla negra.

Para dibujar por la pantalla los distintos tiles se puede utilizar la función PALib:
PA_SetMapTileEx(screen, BACKGROUND_TWO, x1, y1, ficha, 0, 0, 0);
donde x1,y1 serán las coordenadas del array de 32x24 en que está dividida cada pantalla de la DS. Los tres últimos parámetros ya los veremos más adelante.

Para poder ver todo lo que se ha dicho aquí, probar el siguiente código quitando las dos líneas que cargan los fondos: PA_EasyBgLoad(SCREEN_TOP, BACKGROUND_ONE, fondo_top); y PA_EasyBgLoad(SCREEN_BOTTOM, BACKGROUND_ONE, fondo_bottom);.

Dibujar_casilla:

Esta función dibuja cada casilla del tablero y cada bloque de una ficha del tetris. Como 8x8 pixeles es muy pequeño, vamos a dibujar casillas de 16x16, es decir cuatro veces la casilla de 8x8.
PA_SetMapTileEx(screen, BACKGROUND_THREE, x1, y1, ficha, 0, 0, 0);
PA_SetMapTileEx(screen, BACKGROUND_THREE, x1, y1 + 1, ficha, 0, 1, 0);
PA_SetMapTileEx(screen, BACKGROUND_THREE, x1 + 1, y1, ficha, 1, 0, 0);
PA_SetMapTileEx(screen, BACKGROUND_THREE, x1 + 1, y1 + 1, ficha, 1, 1, 0);

Los parámetros son:
PA_SetMapTileEx(screen, background, x, y, tile, girar_horizontal, girar_vertical, paleta);

Debido a un pequeño problema que ocurre en la pantalla inferior (la posición 0,0 se baja unos 16 pixeles), hay que poner el scroll de esta pantalla a 0 (!?!?!?!?!?) :

PA_EasyBgScrollXY(SCREEN_BOTTOM, BACKGROUND_THREE, 0, 0);

Por último dibujaremos la pantalla de la aplicación. Por ahora he usado estos dos fondos (fondo_top y fondo_bottom)

El código es el siguiente:

La programación con 'tiles' nos permitirá crear el juego de plataformas. Si nos da tiempo volveremos sobre el juego de Pokemon para poder hacer mundos más grandes, sin ocupar demasiado espacio en memoria.

Saludos

Empezamos a crear el Tetris

2009-01-23T23:45:00.000-08:00

Con los post anteriores veíamos cosas de la programación pero nada tangible. Así que en este post empezaremos a crear el juego.

Lo primero el fondo del juego. Por ahora no vamos a hacer nada de puntuación y ficha siguiente, así que por ahora el fondo serán estas dos imágenes:

fondo_top y

fondo_bottom

Las imágenes deben pasar por el PAGX, como se indica aquí.

PALib nos da estas dos funciones para cargar dichos fondos:
PA_EasyBgLoad(SCREEN_TOP, BACKGROUND_ONE, fondo_top);
PA_EasyBgLoad(SCREEN_BOTTOM, BACKGROUND_ONE, fondo_bottom);

El código sería:

#include <PA9.h>

#include "gfx/all_gfx.h"
#include "gfx/all_gfx.c"

#include "devnintendods.h"

#define TABLERO_ANCHO 10
#define TABLERO_ALTO 20

#define FICHA_ANCHO 4
#define FICHA_ALTO 4

u8 tablero[TABLERO_ANCHO][TABLERO_ALTO];

typedef struct {
    u8 x, y, radio;
    u8 ficha[FICHA_ANCHO][FICHA_ALTO];
} tipo_ficha;

tipo_ficha ficha;

u8 ficha_timer = 0;

int main(int argc, char ** argv) {
    PA_Init();
    PA_InitVBL();

    PA_EasyBgLoad(SCREEN_TOP, BACKGROUND_ONE, fondo_top);
    PA_EasyBgLoad(SCREEN_BOTTOM, BACKGROUND_ONE, fondo_bottom);

    while  (1) {
        PA_WaitForVBL();
    }
    return 0;
}

Para los que no han seguido el tutorial desde el principio devnintendods.h lo podeís encontrar aquí, y se debe guardar en la carpeta source.

Bueno, esto va tomando forma. En el próximo post veremos como programar el pintado del tablero en pantalla.

Saludos