Día 3

Ahora que sabemos lo básico de C, y estamos más o menos habituados a PAlib, es hora de empezar a sumergirnos de verdad en este mundo. ¿Y qué hay más simple y usado que los fondos? Podremos poner desde fondos pintorescos y que hagan bonito, a un tremendo mapa para nuestro personaje, pasando por la creación de un mapa de colisiones, todo en uno. Entremos pues, al tutorial que coloreará las hasta ahora oscurecidas pantallas de nuestra DS.

Antes de comenzar: conceptos previos

Si queremos entrar en este tutorial con ganas de aprovecharlo al máximo, es mejor que echemos un vistazo hacia atrás y repasemos conceptos, o aprendamos unos nuevos, necesarios y útiles para dominar fondos.

Tanto si os suenan como si no, recomiendo al menos la lectura de estos conceptos, debido al uso que le daremos a lo largo de este tutorial.

• Píxeles: Un píxel es la parte más pequeña en la que se divide un gráfico (dibujo) mostrado en pantalla. Una pantalla de la Nintendo DS y DS Lite se divide en 256 píxeles de largo por 192 de alto. Veréis mucho por ahí el dato 256x192.
• Tiles: Segunda parte en la que se divide un gráfico. La equivalencia es de 1 tile = 8x8 píxels. Seguramente os sonará porque lo mencionamos con los textos del Día 1.
• Paleta: Una paleta es el conjunto de colores que puede mostrar un píxel. Los colores se consiguen de la mezcla de los 3 colores primarios (Rojo, Verde y Azul, los veréis escritos como RGB). Una DS puede mostrar en pantalla gráficos (tanto fondos como sprites incluyendo textos) con paleta de 16 colores (típica de las Game Boy), de 256 colores (muy habitual), 8bit y 16bit de profundidad.
• Capas: Si recordáis lo visto en el Día 1, sabreis que las capas son la prioridad que tienen los gráficos para aparecer unos encima de otros. Los que no lo recuerden, pues ya se lo he dicho xD. Ampliemos este concepto de manera más técnica: Cuando en un determinado píxel de pantalla es ocupado a la vez por dos gráficos, se coloreará del color del gráfico que tenga menor número de prioridad (3 el más bajo y 0 el más alto).
• VRAM: (VideoRAM) es la RAM reservada para el cargado de gráficos en pantalla. Si sois novatos, no le haréis mucho caso. Si sois más experimentados, os interesará saber cómo administrar esta RAM.
• Color transparente: A la hora de hacer fondos, seguramente querreis que se vean los fondos de detrás por un agujero, por el cielo, etc. Esto se consigue con un color transparente. Dicho color no se verá en la DS, permitiendo ver los fondos de capas inferiores.

Eso es todo. ¿Os parece muy lioso? No os preocupéis, seguid el tutorial despacito y entenderéis todo (esa es la idea, ¿no? xD).

Paso 1: Obtener los fondos

Antes de hacer nada, habréis deducido que se necesita primero tener fondos con los que practicar :P. Debeis saber que no vale una imagen en cualquier formato. Los datos, en cualquier aparato tecnológico, se procesan en su forma básica: en lenguaje binario.

Ahora me diréis "¡¡No me fastidies que tengo que traducirlo yo mismo píxel a píxel!!". Antes de que os tiréis a mi cuello, os recuerdo que en estos mundillos ¡siempre hay alguien que inventa algo para facilitarnos la vida ;)! Les presento el programa que solucionará nuestras vidas: ¡el PAGfx! (Interesados llamen al 5825-41@Log53)

¿Dónde encontrar el PAGfx?

En teoría, este magnífico programa debió de instalarse junto con PAlib. Para localizarlo, entrad en:

(Directorio donde tengáis DevKitPRO)\palib\tools\PAGfx\

Una vez en esa carpeta, localizad dos documentos: un ejecutable y un archivo *.ini . Ambos se llaman PAGfx.

Archivos en la carpeta PAGfx. Los remarcados en Rojo son los que buscamos

Crearemos proyecto para nuestras prácticas (si no recordáis como, mirad en Día 1, primer párrafo de 1.-Main.c) en donde pongamos todos nuestros proyectos. Una vez hecho esto, iremos a la carpeta de nuestro nuevo proyecto, buscaremos una que se llama source, y entramos en ella. Encontraremos un archivo *.txt llamado main.c. Ahí, crearemos nueva carpeta, le ponemos de nombre gfx (muy importante), y entramos en ella. Ahora, cogemos los archivos de PAGfx y los metemos aquí.

Con esto tendremos situado todo para empezar a trabajar.

Uso del PAGfx

Muy bien, tenemos el programa, ahora toca obtener los archivos que necesitaremos para incluir en nuestro proyecto. Procedamos.

Cogemos la imagen que más rabia nos dé de todas las que tengamos por ahí. ¿Un fondo que os atraiga, un dibujo, una foto? Cualquier cosa vale. PEEEROOO... necesitan cumplir determinados requisitos. ¿Cuales? Eso lo veréis en cada uno de las minietapas de este tutorial. Por lo tanto, os recomiendo que consigáis las imágenes que cumplan los requisitos que os voy a indicar (no es necesario tenerlas, pero con estos fondos podréis practicar todos los tipos que hay):

- Un fondo de colores normalillo (paleta de 256 colores). Preferible de tamaño 256x192, ni más ni menos. Ejemplo que usaremos en el tutorial.

- Otro fondo más grande, tamaño a vuestro gusto (recomendable no pasarse, sobre 2048x2048 a lo sumo... suficiente, ¿no?), también a 256 colores. Ejemplo usado en este tutorial (este fondo lo podéis encontrar en los ejemplos de PAlib [...\palib\examples\Backgrounds\BgLoading\LargeMaps]).

-Otro fondo más (evidentemente xD), tamaño 256x192 exactamente, lo más colorido que podáis. Ejemplo de este tutorial.

¡ATENCIÓN!: Este ejemplo lo hice con fondos con colores muy fuertes (es un efecto óptico). Os advierto que os puede hacer un poco de daño la vista si lo mirais mucho rato. Es por eso que lo pongo en un link aparte.

En caso de que no consigáis dichos fondos, siempre podéis coger los que usaremos aquí. Entrad en el link y copiad imagen.

OK, ahora que tenemos los fondos, toca convertirlos a los bin necesarios. Sigamos estos pasos y tendremos todo en un par de minutos:

1. PASO RECOMENDABLE: Ponemos nuestros fondos en formato .PNG en la misma carpeta gfx que el programa PAGfx. NO ES OBLIGATORIO.
2. Abriremos el archivo PAGfx.ini (el bloc de notas con ruedita).
3. En él veremos varios apartados escritos (#TranspColor, #Sprites, #Backgrounds, y #Textures). Ahora nos interesa el apartado de #Backgrounds y el de #TranspColour (explicación más adelante), el resto lo veremos en otros tutoriales.
4. En #Backgrounds pondremos lo siguiente: nombrefondo.PNG tipofondo, poniendo el nombre del fondo con la extensión .PNG, y el tipo de fondo del que se trata (explicación más adelante). Ej: soyunfondo.PNG LargeMap. NOTA: Si el archivo no se encuentra en el mismo directorio que el programa, pondremos el directorio completo en el que se encuentre. Ej: C:\Imagenes\fondo.PNG
5. Cerramos el PAGfx.ini guardando cambios, y ejecutamos el convertidor. Lo dejamos trabajar.

Et, ¡voilá!. Si todo va bien, veremos aparecer los siguientes documentos junto al convertidor:

• PAGfx.txt: Este archivo se crea al ejecutar el archivo PAGfx.ini. No sirve de nada para nuestros intereses, únicamente es el historial de conversión del programa.
• nombrefondo.c: Básicamente, se trata de la información del fondo. Píxel por píxel. Podéis abrir el archivo para ver de la que os habéis librado de transcribir ;). Sin el archivo nombrefondo.pal.c, este archivo no servirá de nada, a menos que se trate de un fondo de 16bit, puesto que sólo tendrá este archivo.
• nombrefondo.pal.c: Paleta usada por el fondo. Sin su correspondiente nombrefondo.c, este archivo no servirá de nada. Los fondos de 16bit no usan este archivo.
• bin (carpeta): En esta carpeta, se incluyen los archivos binarios de nuestros gráficos. Se trata de más archivos que los que hay fuera. Son los imprescindibles para que todo vaya,, pero no nos interesará profundizar en este directorio... de momento.
• all_gfx.c y all_gfx.h: Los archivos que realmente nos interesan. Reúne en dos archivos los punteros (entendámolos como hipervínculos o links de momento) al resto de archivos. Así nos ahorraremos el incluir todos estos de uno en uno en el proyecto.

Fácil, rápido y sencillo. No os quejaréis que Mollusk no nos lo pudo dejar más facil :D. Pero para empezar vosotros con vuestra conversión, os indicaré unas cosas que hay que tener claras:

Elegir color transparente para nuestros fondos

Recordad el concepto de color transparente (en el comienzo del tutorial). PAGfx nos permite tener como color transparente el que nosotros queramos de los siguientes: Magenta, Negro, Blanco y Verde. Escoged el que más rabia os dé, pero tened en cuenta que el color transparente será el mismo para cada fondo. Yo personalmente os recomiendo Magenta (255, 0, 255).

¿Cómo poner el color que queremos de transparente? En la línea #TranspColour, pondremos el nombre del color en inglés (Magenta, Black, White y Green). Así de fácil :D.

¿Qué fondos podremos convertir con el PAGfx?

Prácticamente todos. Pero como todo en esta vida, deberemos organizar los tipos de fondo mediante sus características. ¿Que el fondo es 1024x1024? El tipo de fondo es largo. ¿Que usa poca paleta? El fondo será de 256 colores. Tendremos que indicarle a PAGfx el tipo de fondo que es para una correcta conversión. Veamos:

• TiledBg: Fondo tileado. El más simple de todos. Su nombre viene del hecho de que se la información se divide en tiles, de modo que el fondo se carga en paquetes de 8x8 píxels. Los tamaños usados son, evidentemente, múltiplos de 8x8, a saber: 256x256, 512x256, 256x512, 512x512. La paleta obligatoriamente será de 256 colores.
• LargeMap: Igual que el TiledBg. ¿Diferencia? Aquí puedes poner el tamaño de fondo que te dé la real gana. Sigue usando tiles, así que recomiendo usar múltiplos de 8x8 (1024x1024, 2048x2048 y un largo etc.). La paleta será de 256 colores.
• RotBg: Fondos rotativos. Para entendernos, se pueden girar a placer sobre sí mismas. Suena interesante, pero por desgracia nos lo reservaremos para otros tutoriales, ya que mayoritariamente se usará para efectos y animaciones... (Si estáis en contra decídmelo e incluyo una breve introducción) Tamaños permitidos: 128x128, 256x256, 512x512, 1024x1024. Otro de paleta de 256 colores.
• 8bit: Fondos de 8 bits de paleta. A diferencia de los anteriores, se dibuja píxel a píxel, por lo que tardará 64 veces más en cargar. Tamaño exclusivamente 256x192.
• 16bit: Fondos de 16bit de paleta... traduciendo, prácticamente infinitos colores (infinito es suficiente, ¿no? :P). También de 256x192 de tamaño exclusivo...
• EasyBg: En realidad esto no es un tipo de fondo. Si ponemos esto en lugar de tipofondo, PAGfx determinará por nosotros si se trata de un fondo TiledBg o LargeMap. Ideal para no romperse la cabeza :D.

¡Y con esto, sabemos lo necesario para usar el programa! Si aún así teneis problemas para compilar fondos, comentad y ampliaré aún más esta sección del tuto si es necesario. Y ahora, toca lo más divertido. ¡El código! :).

Paso 2: Cargar el fondo

Ahora, si ya no lo hemos hecho, abriremos nuestro proyecto. Dividiremos este apartado en los distintos tipos de fondos que hay, así que a menos que se indique lo contrario, ése código sólo servirá para ese tipo de fondo.

El código que pondré es genérico (sin dar valores a los argumentos), para que sepáis para qué sirve cada variable. Luego pondré un ejemplo simple si es necesario.

PEEROO... Antes de hacer nada, hay que indicarle a PAlib que los archivos existen... ¿cómo? Pues si el archivo all_gfx.c y *.h incluyen los anteriores archivos... ¡lo único que hay que hacer es indicarle que estes 2 archivos existen! ¿Recordáis esta línea del main principal?:

#include <PA9.h>  //Include de las PAlib

Si esta línea sirve para incluir PAlib al proyecto, unas líneas parecidas y:

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

Y ya ta. Las comillas son im-pres-cin-di-bles, no las cambiéis por los <> del otro. (Las comillas se escriben con Shift+2). Con esto, PAlib ya sabe que existen nuestros fondos y los incluirá al proyecto ;).

TiledBg y LargeMap, más simples imposible

Como bien dice el título esto no puede ser más simple. Una única línea:

PA_EasyBgLoad(pantalla,capa,nombrefondo);

Lo único a tener en cuenta, es que no pongáis esto en un bucle while, for... porque si no recordad que tendréis 60 fondos en 1 segundo... Error de los buenos, vamos.

AVISO: Cuando nos refiramos a ambos tipos de fondos (TiledBg y LargeMap), en adelante usaremos el término EasyBg, tanto en las explicaciones como en las propias PAlib y sus funciones.

A continuación un par de ejemplitos, usando valores reales para los argumentos.

#include <PA9.h>
 
#include "gfx/all_gfx.c"	//Includes con
#include "gfx/all_gfx.h"	//info de fondos
 
int main(void) 
{
 
   // init PA_Lib
   PA_Init();
   PA_InitVBL();
 
	PA_EasyBgLoad(1,0,EasyBg);		//Cargado del fondo en la pantalla superior
	PA_EasyBgLoad(0,0,EasyBg);		//y en la táctil
 
   while(1)
   { 
 
		PA_WaitForVBL();
   }
 
   return 0;
}

Un main normal con un par de líneas para los fondos. ¿Existe algo más simple?. Y aquí una captura con el resultado final:

Pondría un ejemplo con LargeMap, pero es exactamente lo mismo. Únicamente, al ser mayores de 256x192, no se vería todo en pantalla.

8bit y 16bit: Cuando los colores no son suficientes

Ambos tipos de fondo son bastante similares, lo único que cambia es que los 8bit necesitan una pequeña preparación...

Simplemente deberéis conocer estas líneas:

Para 8bit:

PA_Init8bitBg(pantalla,capa);   //Inicia el modo 8bit en la pantalla y capa indicadas.
 
PA_Load8bitBgPal(pantalla,(void*)nombrepaleta_Pal);   //Carga la paleta del fondo que usemos.
//El void es el puntero ("hipervínculo") que enlaza a la paleta.
//Deberemos ponerle siempre la terminación _Pal.
 
PA_Load8bitBitmap(pantalla,nombrefondo_Bitmap);   //Carga el fondo.
//Deberemos ponerle la terminación _Bitmap al nombre del éste.

Para 16bit:

PA_Init16bitBg(pantalla,capa);   //Inicia el modo 16bit en la pantalla y capa indicados.
 
PA_Load16bitBitmap(pantalla,nombrefondo_Bitmap);   //Carga el fondo.
//Debemos poner la terminación _Bitmap a éste.

Si comparáis, las única diferencia que hay entre ambos tipos de fondo (aparte de poner 8bit o 16bit en cada caso), es que los fondos de 8bit necesitan cargar la paleta antes de nada.

Veamos un ejemplo:

#include <PA9.h>
 
#include "gfx/all_gfx.c"	//Includes con
#include "gfx/all_gfx.h"	//info de fondos
 
int main(void) 
{
 
   // init PA_Lib
   PA_Init();
   PA_InitVBL();
 
	PA_Init16bitBg(1,3);		//Inicio del modo 16bit en la pantalla superior
	PA_Init16bitBg(0,3);		//y en la táctil
 
 
	PA_Load16bitBitmap(1,Ejemplo16bit_Bitmap);		//Cargado del fondo en la pantalla superior
	PA_Load16bitBitmap(0,Ejemplo16bit_Bitmap);		//y en la táctil
 
   while(1)
	{ 
 
		PA_WaitForVBL();
   }
 
   return 0;
}

No incluyo ejemplo con 8bit porque viene a ser más de lo mismo. Tán sólo cargad paleta después de los Init y antes de cargar el fondo (aparte de cambiar los 16bit por 8bit :P).

Aquí teneis el ejemplo compilado:

¡ATENCIÓN!: Este ejemplo lo hice con fondos con colores muy fuertes (es un efecto óptico). Os advierto que os puede hacer un poco de daño la vista si lo mirais mucho rato. Es por eso que lo pongo en un link aparte.

http://nds.scenebeta.com/archivos/nds/TutorialPalibDia316bitCompilado.JPG

DualBackgrounds, fusionando pantallas

¿Qué es un fondo Dual (DualBackground)? Se trata de un fondo normal y corriente de 256 colores (se acostumbra a usar LargeMaps), en la que su esquina superior izquierda aparece en la pantalla superior, y el fondo sigue para abajo por la pantalla táctil. Básicamente, como si las 2 pantallas fuesen 1. Muy útil en bastantes ocasiones, como una lista de créditos, un mapa de juego...

El código es tremendísimamente parecido a los EasyBg. Tán sólo se añade el prefijo Dual- a la función, y (evidentemente) no se indica pantalla.

PA_DualEasyBgLoad(capa,nombrefondo);

Sencillísimo. No creo ni que haga falta un ejemplo sobre esto, es cambiar la línea EasyBgLoad por esta.

Y con esto ya está todo aprendido sobre cargado de fondos. Pero esto no es todo. Por ejemplo, en los fondos LargeMap, ¿cómo hacemos para ver el resto de mapa? Si (vagamente) recordais los comandos básicos de los botones, resolveremos enseguida ese error.

Paso 3: Mover el fondo

Aparte de cargarlos, los fondos sirven para 12979532709 cosas más. ¿La más básica de todas? Moverlo.

Mover fondos con botones o Stylus (Scroll)

Antes de nada, demosles un repaso a los argumentos de los botones y Stylus que usaremos para esto.

Pad.Held.Up     //Mantener pulsado arriba. Los botones disponibles son: Up, Down, Left, Right, A, B, X, Y, L, R, Start y Select.
 
Stylus.X     //Mantener el Stylus presionando la pantalla. Los Stylus disponibles son... Ah, no, que sólo hay un Stylus :P.
//Las coordenadas son X e Y

¿Recordáis lo que eran las variables? esas letras, palabras... que almacenaban un valor. Recordando Día 2, sabréis que:

if(Pad.Newpress.Up)
{
    x++;
}

Aquí, al pulsar una vez arriba, la variable aumentaba su valor en una unidad.

Pero... ¿y si yo pongo esto?:

x+=Pad.Held.Up;

Es exactamente lo mismo. ¿Por qué? Os preguntaréis. Pues porque si no pulsamos arriba, Pad.Held.Up devuelve valor 0. Por tanto, el número no varía. En cambio, si se pulsa, devuelve 1, por lo que entonces sí que variaría el número. ¿Lioso? Puede... pero hasta que no explique por qué os hablo de esto tal vez no se os aclaren las ideas. Sigamos modificando el código:

x+=Pad.Held.Down-Pad.Held.Up;

¿Qué es esto? A simple vista, parece una resta entre botones, pero no. Es una comprobación. Una comprobación entre dos argumentos que devuelven valores 1 o 0 (booleanos), puede parecer rara, pero es sencilla.

Imaginad un partido de fútbol. Dos equipos (no quiero discusiones entre madrileños y barçistas :P), uno en su lado del campo. Pero las reglas son un poco distintas. Si el equipo de la izquierda puntúa, el marcador de goles sube 1 punto. Ahora viene lo distinto: si el equipo de la derecha marca, el marcador resta 1 punto. Por tanto, si el equipo de la izquierda es el booleano que se encuentra a la izquierda del guión, y el marcar gol es pulsar dicho botón, el valor que adquiere es 1. Si el de la derecha es el booleano de ese lado del guión, y el marcar un gol es pulsar dicho botón, el valor que adquiere también es uno. ¿Qué pasa? Que si el argumento de la izquierda da 1, el valor será +1, y se suma a x. En cambio, si el argumento de la derecha es 1, entonces el valor será -1. Por estar a la derecha. Igual que el partido. Da igual qué argumento sea, si está a la derecha devuelve -1, y a la izquierda devuelve +1.

En definitiva, y hablando en Español, Si se pulsa abajo el valor de x aumenta, y si se pulsa arriba disminuye. Si no se pulsa ninguno, no se devuelve 1 ni por izquierda ni por derecha, por lo que x no varía. Igual si ambos botones están pulsados, porque: ¿cuánto da +1 sumado a -1? ;).

Si aún no lo tenéis muy claro, ya sabéis, postead para ser escuchados.

Y ahora llega lo irónico del asunto. ¿Entendisteis lo que os he explicado? Pues ya sabeis mover fondos :P. Simplemente os queda por conocer esta función:

//Para mover un fondo por la coordenada X (horizontalmente)
 
PA_EasyBgScrollX(pantalla,capa del fondo a mover,valorx);
 
//Para mover un fondo por la coordenada Y (verticalmente)
 
PA_EasyBgScrollY(pantalla,capa del fondo a mover,valory);
 
//Combinación de los anteriores en uno solo
 
PA_EasyBgScrollXY(pantalla,capa del fondo a mover,valorx,valory);
 
//Para mover un fondo Dual, son las mismas funciones que las anteriores añadiendo el prefijo Dual.
 
PA_DualEasyBgScrollX(capa del fondo a mover,valorx);
 
PA_DualEasyBgScrollY(capa del fondo a mover,valory);
 
PA_DualEasyBgScrollXY(capa del fondo a mover,valorx,valory);

El valorx (y valory), se modificarán con el sistema explicado más arriba. ¡Y con esto, ya moveremos el fondo a nuestro antojo!

Un ejemplo rápido para dejar las cosas claras:

#include <PA9.h>
 
#include "gfx/all_gfx.c"	//Includes con
#include "gfx/all_gfx.h"	//info de fondos
 
s32 x;	//¡No nos olvidemos de declarar nuestras variables antes!
s32 y;	//Preferiremos usar s32 para ellas, veremos en otros tutos por qué.
 
int main(void) 
{
 
   // init PA_Lib
   PA_Init();
   PA_InitVBL();
 
	PA_EasyBgLoad(1,0,zelda);	//Cargaremos el fondo a mover (sin fondo, difícil mover algo :P)
 
   while(1)
	{ 
	   //Mover el LargeMap (tanto X como Y)
 
	   x+=Pad.Held.Right-Pad.Held.Left;		//Comprobación para x
	   y+=Pad.Held.Down-Pad.Held.Up;		//Y más de lo mismo para y
	   PA_EasyBgScrollXY(1,0,x,y);	//Movemos el fondo con las variables debidamente actualizadas.
 
		PA_WaitForVBL();
   }
 
   return 0;
}

Únicamente una aclaración: ¿Por qué ponemos primero Right y luego Left? Porque por lógica, si los ponemos del revés al pulsar izquierda el fondo se movería a la derecha y viceversa, debido a que las coordenadas x (e y) aumentan de izquierda a derecha y de arriba a abajo respectivamente.

NOTA: No hace falta decir que hay que poner este código en el bucle while, para que la(s) variable(s) se actualice(n) constantemente, al igual que el fondo...

NOTA2: Los fondos siempre se "envuelven", es decir, cuando veamos el final del fondo, podremos ver que vuelve a comenzar. Imaginaos un globo terráqueo. Por muchas vueltas que le deis, llega un momento en que se vuelve a ver el principio... Europa a la derecha de América, Asia a la derecha de Europa, y a la derecha de Asia, de nuevo América. Y así una y otra vez...

Pondría una captura de este ejemplo, pero a menos que haga un vídeo, no veríais cómo se mueve el fondo... Sin embargo, podéis encontrar el ejemplo correspondiente en (donde tengáis DevkitPRO)\palib\examples\Backgrounds\BgLoading\LargeMaps\.

Muy bien, es hora de pasar a otra cosa.

...

¡Ups! ¡El Stylus! ¡Que se me olvidaba xD! Gracias por recordármelo (¿o no os acordábais? ¬¬).

A diferencia de los botones, los argumentos Stylus.X y Stylus.Y no devuelven 1 y 0, sino... coordenadas. Donde pulses con el Stylus, obtendrás la posición X e Y, que se pueden usar con estos argumentos. O sea, Stylus.X tiene valores de 0 a 255, y Stylus.Y de 0 a 191.

Entonces, partiendo del ejemplo anterior:

#include <PA9.h>
 
#include "gfx/all_gfx.c"	//Includes con
#include "gfx/all_gfx.h"	//info de fondos
 
//s32 x;	//En el caso del Stylus,
//s32 y;	//no hay variables que declarar
 
int main(void) 
{
 
   // init PA_Lib
   PA_Init();
   PA_InitVBL();
 
	PA_EasyBgLoad(1,0,zelda);	//Cargaremos el fondo a mover (sin fondo, difícil mover algo :P)
 
   while(1)
	{ 
	   //Mover el LargeMap (tanto X como Y)
 
	   //x+=Pad.Held.Right-Pad.Held.Left;		//Líneas
	   //y+=Pad.Held.Down-Pad.Held.Up;		//innecesarias
	   PA_EasyBgScrollXY(1,0,Stylus.X,Stylus.Y);	//Movemos el fondo con las variables que nos proporciona Stylus.X e Y.
 
		PA_WaitForVBL();
   }
 
   return 0;
}

¡Y ya ta!

NOTA: En contra de lo que seguramente habréis pensado, los fondos se pueden poner perfectamente en la pantalla superior. Simplemente, os costará más ser precisos, pero bueno...

Paso 4: Borrar el fondo

Da igual lo bonito que quede un fondo, da igual lo útil que sea, da igual lo que nos costase hacerlo. En algún momento, nos veremos en la necesidad de borrarlo, bien sea para sustituírlo por otro, bien sea para tener la pantalla limpia. Esto es sencillísimo, tán sólo conocer estos comandos:

PA_DeleteBg(pantalla,capa);

No falla, con esta línea podremos despedirnos del fondo. Si en algún momento vuelve a hacer falta, simplemente se vuelve a cargar.

Aún así, el caso de los 8bit y los 16bit merecen una mención especial en este aspecto. Si recordáis, se iniciaba su modo correspondiente en una capa. Es decir, desde el momento que se inicia el modo, en esa determinada capa de esa determinada pantalla sólo se podrán cargar fondos de ese tipo de paleta... un problema si queremos cargar otro tipo de fondo. ¿Qué hacer? Simple:

PA_ResetBgSys(void);   //Esta función tiene un argumento vacío, o sea, tenéis que dejarlo sin argumento, no le hace falta.
//Es un caso similar al PA_WaitForVBL o el PA_Init
 
PA_ResetBgSysScreen(pantalla);   //En caso de ser una sola pantalla la que queramos restablecer, usaremos esta función.
//Útil en caso de que tengamos capas iniciadas en la otra pantalla que no deseemos restablecer.

Estas funciones restablecen las capas de la(s) pantalla(s). Traduciendo, podremos volver a usar fondos distintos de los iniciados anteriormente. Poned esto después del DeleteBg. Cuando volvamos a usar fondos de 8 o 16bit, hay que iniciar de nuevo.

Información importante

Por qué no abusar de los fondos de 8bit y 16bit

Si aún no habéis investigado un poco más profundamente las PAlib, no sabréis que entre gráficos, música... en definitiva, TODO, estáis limitados a 4Mb de proyecto. Después de la cara tan laaarga que habréis puesto, os explicaré por qué. Simple y llanamente, por el hardware de la DS.

Cuando metemos nuestros archivos por el método general (el que ahora estamos aprendiendo, por ejemplo, con los fondos), estes se almacenan en la RAM de la DS. Es por ello que todo cargue casi instantáneamente, porque ya se halla todo en la RAM. ¿Cuál es el problema? Pues que una Nintendo DS... sólo tiene 4Mb de RAM. Esto es fácilmente solucionable, basta con usar librerías para que todo se almacene en ROM (entonces el límite sería la microSD de nuestra Flashcard), como PAFS (obsoletas), FAT o EFS (las actuales). Estas librerías aún son muy avanzadas para el nivel en el que estáis, así que en el hipotético caso de que 4Mb no os lleguen... me temo que sólo os queda esperar :S.

¿Y qué tiene que ver esto con los fondos de 8 y 16bit? Para empezar, mirad cuánto ocupa un fondo de éstos. Como para no pensar en limitarse un poquito, ¿no? :P

Y, en segundo lugar, por la VRAM. Recordad lo que era en los conceptos de arriba. Veamos:

VRAM usado por un fondo de 8bit:

¡Pues la friolera de 3/8 partes de VRAM de una pantalla! ¿Os parece poco? ¡Pues es prácticamente la mitad! Limitará bastante el tener muchos sprites y fondos en pantalla...

VRAM usado por un fondo de 16bit:

Cuidado de no desmayaros... 6/8 partes de VRAM. Esto, un fondo sencillito y un par de sprites, y la pantalla no te admitirá más...

Aunque en determinados casos, el uso de fondos de 8bit y 16bit pueden ser bastante útiles: En el modo de 16bit puedes dibujar con el Stylus, por ejemplo. Y en el de 8bit, cargas un GIF sin demasiado problema.

Y con esto, damos por finalizado el aprendizaje por hoy. Sólo nos faltan... ¡Los deberes! Si sois capaces de hacer un fondo que se mueva indefinidamente a la derecha en la pantalla táctil, y ponerme un fondo de 16bit en la superior, creo que sabréis lo básico de este tutorial.

¡Disfrutad iluminando con colores vuestros proyectos!