lunes, 10 de marzo de 2008

Movernos por nuestro juego

Ya tenemos cargado el fondo en nuestro juego, ahora sólo nos queda movernos por él.

Antes de nada vamos a ordenar un poco el código, porque si no la cosa se irá poniendo fea. En primer lugar deberíamos cambiar el nombre al proyecto, o mejor crear un proyecto nuevo, ya que HelloWorld no es lo más apropiado. Quizás un buen nombre sea PokemonDS.

Pues nada manos a la obra:

1. ¿Hemos modificado el PalibTemplate? Con esto me refiero a únicamente crear la carpeta gfx dentro del source y copiar en ella los ficheros que viene en C:\devkitPro\PAlib\Tools\PAGfx.

2. Copiamos PalibTemplate a c:\DevDS y cambiamos el nombre por PokemonDS. Tanto el nombre de la carpeta como dentro del fichero make. Si vamos a usar el Programmer's Notepad deberemos modificar el fichero Template.pnproj por PokemonDS.pnproj y en el interior del fichero cambiar la palabra template por PokemonDS.

3. Vamos a crear una librería, un .h para dejar nuestras constantes y no tener que andar con números raros en las funciones. Esta librería se podría poner en el template para tenerla siempre accesible. La librería la denominaremos 'devnintendods.h'.

En un primer momento la librería tendrá este código:

#define SCREEN_TOP 1
#define SCREEN_BOTTOM 0

#define BACKGROUND_ZERO 0
#define BACKGROUND_ONE 1
#define BACKGROUND_TWO 2
#define BACKGROUND_THREE 3

Con esto tendremos definidas una serie de constante para distinguir las dos ventanas de la DS (SCREEN_TOP -> será la ventana superior) y una serie de constantes para definir los cuatro fondos o backgrounds que puede tener cada pantalla.

¿Para que sirve tener cuatro fondos? Pues jugando con las transparencias se pueden crear efectos muy chulos.

Llegados a este punto sólo nos queda poner el código para mover la pantalla:

1. Para activar el movimiento de un fondo (o de los cuatro a la vez) utilizaremos la rutina PA_InitParallaxX y PA_InitParallaxY, que permite inicializar el movimiento tanto horizontal como vertical y las velocidades de desplazamiento (256 es la normal)

PA_InitParallaxX(SCREEN_TOP, 0, 0, 256, 0); indica que para la pantalla superior de la DS el tercer fondo se moverá a velocidad normal, los otros no se desplazarán.

2. Vamos a movernos utilizando los cursores que hay en la DS. Existe una estructura denominada Pad, que es la que nos permitirá acceder a las pulsaciones de los botones.

El código quedará así:

// Includes
#include <pa9.h> // Include for PA_Lib
#include "gfx/all_gfx.h"
#include "gfx/all_gfx.c"

#include "devnintendods.h"

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

PA_EasyBgLoad(SCREEN_TOP, BACKGROUND_THREE, fondo);

PA_InitParallaxX(SCREEN_TOP, 0, 0, 256, 0);
PA_InitParallaxY(SCREEN_TOP, 0, 0, 256, 0);

s32 fondoX = 0;
s32 fondoY = 0;
while (1) {
fondoX += Pad.Held.Right - Pad.Held.Left;
fondoY += Pad.Held.Down - Pad.Held.Up;

PA_EasyBgScrollXY(SCREEN_TOP, BACKGROUND_THREE, fondoX, fondoY);
PA_WaitForVBL();
}
return 0;
}

Si ya lo tenéis funcionando, veréis un efecto extraño en el fondo, se solapa en vertical y aparece un espacio negro en horizontal. Esto es por que la imagen no coincide con el tamaño de la pantalla, que es de 256 (0 a 255) por 192 (0 a 191).
Aún así La DS espera fondos de 256x256 (y múltiplos de este tamaño), así que meteremos nuestro fondo en una imagen de 512x512.

Como hemos indicado, el objeto Pad controla todas las teclas de la consola. Estas son todas las teclas:

Pad.Held.Start
Pad.Held.Select
Pad.Held.Right
Pad.Held.Left
Pad.Held.Up
Pad.Held.Down
Pad.Held.A
Pad.Held.B
Pad.Held.X
Pad.Held.Y
Pad.Held.L
Pad.Held.R

Lo de Held es el momento de pulsar el botón (nos olvidamos de ello por ahora).

El aspecto actual de nuestro juego es el siguiente:

Y con esto ya tenemos un poco más de nuestro juego. ahora nos falta poner el muñequito, pero eso será para la próxima entrega.

Saludos

viernes, 7 de marzo de 2008

Cargar fondos

La librería PAlib, nos proporciona unos comandos muy sencillos para realizar una serie de acciones con imágenes. Una de ella es cargar fondos o backgrounds.
Pero antes de escribir más código veamos el que presentamos en el post anterior:

Todo lo que empiece por // es un comentario.

#include <PA9.h> Esto nos permitirá poder usar la librería PAlib.

int main(int argc, char ** argv) { Esta línea define la función main que es la primera función a la que llamará nuestra consola.

PA_Init();
PA_InitVBL(); //Inicializa la librería PAlib.

while (1) {
PA_WaitForVBL();
}

Esto es un bucle. Se ejecutará mientras 1, es decir siempre, por que el 1 es el valor cierto. la sentencia WAIT es la que espera a que se refresque la pantalla y es necesaria para que las aplicaciones no parpadeen.

return 0;
} fin de la aplicación

La imagen que vamos a cargar será esta:
El código necesario para cargar la imágen es este:

PA_EasyBgLoad(0, 3, fondo);

donde 0 es la pantalla de abajo de la DS, 3 es uno de los 4 posibles fondos que puede tener cada pantalla y fondo es el nombre que se da a la imagen desde la aplicación PAGfx.

¿Qué es PAGfx? Es una aplicación que convierte las imágenes de formato gráfico a un formato entendible por PAlib. La aplicación necesita tener .net instalado en tu máquina. PAGfx está en C:\devkitPro\PAlib\Tools\PAGfx.

Yo suelo crear una carpeta denominda gfx dentro de source y copio ahí todos los ficheros de PGAfx (se puede hacer en el template para tenerlo ya preparado). Copiamos la imagen en esa carpeta y ejecutamos el programa PAGC Frontend.exe:


Cargamos la imagen (que guardaremos con el nombre fondo.png) en la pestaña de backgrounds y damos a "Save and Convert".

Incluimos estas dos líneas en nuestro código:

#include "gfx/all_gfx.h"
#include "gfx/all_gfx.c"
justo debajo del otro include. El código finalmente quedará así:

// Includes
#include        // Include for PA_Lib

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

// Function: main()
int main(int argc, char ** argv) {
    PA_Init();    // Initializes PA_Lib
    PA_InitVBL(); // Initializes a standard VBLPA_InitText(1, 2); //Tell it to use text on screen 1, background number 2 PA_OutputSimpleText(1, 1, 1, "Hello World !");   //Print the text on screen 1, with coordinate 1,1
    PA_EasyBgLoad(0, 3, fondo);

    // Infinite loop to keep the program running
    while (1) {
        PA_WaitForVBL();
    }
    return 0;
} // End of main()
finalmente el programa de HelloWorld quedará así:


En la próxima entrega moveremos la pantalla.

Saludos

Nuestro primer programa, HelloWorld

¿Cómo puedo programar la Nintendo DS? Pues muy fácil siguiendo las instrucciones de este blog. vamos con nuestro primer programa. Trabajaremos en una carpeta denominada c:\devDS, donde iremos dejando nuestros trabajos.

Para empezar a hacer un programa copiaremos la carpeta C:\devkitPro\PAlibTemplate a c:\devDS cambiando el nombre por HelloWorld. Dentro de c:\devDS\HelloWorld cambiaremos el fichero Template.pnproj por HelloWorld.pnproj si queremos trabajar con el Programmers Notepad que viene con el kit. Editaremos el fichero y cambiaremos la palabra Template por HelloWorld.

Por ahora vamos a trabajar con el Programmers Notepad que trae el kit.



Con las teclas Alt+1 podemos compilar la aplicación. Pero claro está, esto es el esqueleto por lo que no hace nada. Modificaremos un poco el proyecto para crear nuestro Hola Mundo.

// Includes
#include <pa9.h> // Include for PA_Lib

// Function: main()
int main(int argc, char ** argv) {
PA_Init(); // Initializes PA_Lib
PA_InitVBL(); // Initializes a standard VBL

PA_InitText(1, 2); //Tell it to use text on screen 1, background number 2
PA_OutputSimpleText(1, 1, 1, "Hello World !"); //Print the text on screen 1, with coordinate 1,1

// Infinite loop to keep the program running
while (1) {
PA_WaitForVBL();
}

return 0;
} // End of main()


Lo compilamos y lanzamos el emulador, cargamos el fichero helloworld.ds.gba y ya tenemos nuestro programa.

En la próxima entrega veremos el código que hemos escrito y empezaremos a cargar imágenes para nuestro juego Pokemon.

Saludos

Instalar el kit de desarrollo

Hoy empezaremos por instalar el kit de desarrollo para nintendo DS.

Cambios a día 24/12/2008.

Lo bajaremos de la web de devkitpro.org. Este kit permite programar utilizando el compilador GC y se instala junto con las librerías necesarias para programar las diferentes consolas. Para la NintendoDS están presentes las librerías ARM, para la Wii y la GameCube las librerías PPC, y para la PSP las librerías PSP.

Guardamos el instalador en nuestro equipo, el programa es devkitProUpdater-1.4.5.exe. Este programa es mejor instalarlo en una carpeta con nombre corto y sin espacios en blanco, por lo que lo guardaremos en c:\devkitpro. Al ejecutar el instalador nos preguntará si queremos mantener los ficheros bajados (para posteriores instalaciones sin tener que acceder a Internet). Tenemos la opción de bajar e instalar más adelante o bajar e instalar de una sola vez.

Para programar la Nintendo DS únicamente es necesario bajar el kit de ARM. Nosotros hemos bajado el de ARM y el de PPC para poder trabajar, en un futuro, con la Wii.


La carpeta devkitpro debería quedar más o menos así:
Instalaremos igualmente la librería PAlib, que nos ayudará a realizar nuestro trabajo. Yo he descargado la última versión estable 'PAlib 070323 Installer' de palib.info.

Descargaremos la librería en la misma carpeta que el kit de desarrollo, en nuestro caso en c:\devkitpro. Ahora la carpeta debe contener todos estos ficheros:

Llegados a este punto sólo nos falta un paso. La librería PAlib no es compatible con devkitARM 2.1 que es la que se baja por defecto con el kit. Pues nada descargamos la versión 2.0 y la instalamos en la carpeta c:\devkitpro, no sin antes renombrar la carpeta C:\devkitPro\devkitARM a C:\devkitPro\devkitARM_21.

Ya tenemos todo. En palibexamples podremos compilar algún proyecto, con los ficheros build.bat.

Muy bien, si hemos llegado a este punto tenemos todo preparado para programar, ¿pero para ejecutar? Para poder ejecutar en nuestro ordenador los programas que hagamos debemos descargar algún emulador. Para mi el mejor es No%GBA. Lo descargamos y lo guardamos dentro de C:\devkitPro\No$gba.

En el próximo post empezaremos a programar.

Saludos

Bienvenido al blog

Desde este blog tenemos la intención de mostrar como programar para la consola Nintendo DS, es decir lo que en la web se conoce como hacer Homebrew para DS. Pronto empezaremos con su hermana mayor la Wii.

Intentaremos explicar todo de tal forma que no se necesiten grandes conocimientos de programación, con un poco de práctica aprenderemos a hacer unos juegos con una presencia totalmente profesional. Utilizaremos el lenguaje de programación C++.

Empezaremos por instalar los programas que nos ayuden a configurar nuestro equipo para poder hacer nuestros primeros programas. Si eres usuario de Windows, son únicamente unos pocos clicks del ratón.

El juego que nos proponemos programar será uno tipo Pokemon. Te mostramos una pantalla de como quedará nuestro juego:



Creo que tiene buen aspecto. Si quieres aprender a programar para la Nintendo DS este es tu blog.

Saludos

Enlaces patrocinados: