Día 2

Bueno, a los que siguiesen el anterior tutorial, lo más probable es que les hayan entrado más ganas de seguir, ¿no? Pero he de advertir que no todo en PAlib es un camino de rosas. De hecho, los textos simples es lo más sencillo de todo. Debido que hay que conocer el lenguaje C/C++, este tutorial constará de teoría que hay que saber para poder hacer algo decentillo con este programa, y unos cuantos ejemplos para comprender sus aplicaciones. No os asustéis, es más sencillo de lo que parece a simple vista, en cuanto os acostumbréis a utilizarlos será como saber leer y escribir. Señoras y señores, es hora de presentarles el mundo de las variables, sentencias y funciones.

1. Variables: llamarlas y utilizarlas.

Es hora de ir al grano. Básicamente, la programación se puede definir como la utilización de números de manera que cumplan lo que les pidamos. Dicho de otra manera, decir 2+2 sabiendo que el resultado será 4. Pero el uso de estos números sería bastante complicado: si queremos modificar un número en un determinado momento, pero sin cambiarlo siempre, ¿cómo haríamos?

Esto no es programación, pero así lo explicaré. Si tenemos, por ejemplo:

x=1
 
y=4
 
x+y=5
 
x-y=0

No, todavía sé contar. Imaginad que necesitamos que la resta dé 0, pero sin alterar los resultados anteriores. ¿Cómo hacemos?

La respuesta la encontramos en las variables. Ponemos:

x=1
 
y=4
 
x+y=5
 
y=1
 
x-y=0

Bueno, parece estúpido, pero os explicaré cómo cambia la cosa en programación. Recordad que el interior del main, a excepción del while (y de otros bucles que pongamos, ya iré explicando),se ejecutaba una vez, ¿cierto? Bueno, pues suponed que eso es código. Miradlo por separado, línea por línea. ¿Véis por dónde van los tiros? Da igual, para eso estoy yo aquí, para aclarar dudas.

Somos el compilador. Nuestra tarea es el analizar los códigos y realizar lo que nos digan. Bueno, si esto lo tuviésemos que analizar una vez, iríamos así:

x=1  // Muy bien, siempre que veamos x, equivaldra a 1
y=4  // OK, y valdra 4
x+y=5  // De acuerdo, si sumamos x e y tendremos 5
y=1  // Vaya, segun esto, a partir de aqui y valdra 1. (TENED EN CUENTA que esto no afectaria a lo anterior)
x-y=0  // Si restamos x con el nuevo valor de y, esto da: 0! 

¡Y esto que habéis visto es sólo una de todas las utilidades que tienen las variables!

Visto esto, y suponiendo que sabéis que las variables son como incógnitas (letras o palabras que tienen valor numérico), pasaremos a aprender los diversos tipos de variables que hay. (Podéis echarle un vistazo al tutorial de variables de AlmamuPP, os haréis una idea. Yo los explicaré de todos modos)

variables int : del inglés integer (enteras) las podemos usar cuando necesitemos variables sin decimales (desde -32768 a +32767).

variables float: (flotantes) ni idea de por qué ese nombre. En fin, ideales para los números con decimales (hasta 7 decimales [diezmillonésimas])

variables double: (doble) aguanta hasta 13 decimales (diezbillonésima) en un número. Esto es una barbaridad, de hecho nunca les encontré utilidad (aunque quién sabe...)

variables char: del inglés character (carácter), almacena un número que asigna a una letra (sin decimales).

Bueno, estos son muy útiles, pero ante la duda de cuál usar, yo recomiendo usar los s o u (signed o unsigned[con o sin signo]), seguidos del número de bits que usará el número. Pongamos unos ejemplos, o no os enteraréis.

u8 variable=1;

Esta variable (se llamará como le pongamos)es sin signo (u), ocupa unos 8 bits de memoria (os pondré más abajo la tabla con los números que aguantan x número de bits), y valdrá 1 hasta que se indique lo contrario.Este número podrá tener los números posibles dependiendo del número de bits (8, 16, 32), así que vigila que luego no necesitarás darle luego valores fuera del límite.

Muy bien, pero para usar los números se necesitan operaciones, ¿no? La DS es capaz de realizar bastantes tipos de cálculos, desde simples sumas a potencias (tampoco le pidáis mucho más...) Concretamente, éstas son las formas de interactuar con los números y variables:

+ -> Suma

- -> Resta

* -> Multiplicación

/ -> División (poco recomendables para mi gusto, son la operación más lenta de procesar de todas)

^ -> Elevado a (para las potencias)

= -> Igual a (asigna un valor a una variable, por ejemplo)

== -> Comparador de igualdad. Podría decirse que significa "si vale". Muy útil para las ramas condicionales (más abajo).

< / <= -> Menor que / menor o igual que. El < y el = deben estar juntos.

> / >= -> Mayor que / mayor o igual que. El > y el = deben estar juntos.

!= -> Distinto de. Para cuando la variable tiene un valor distinto de éste. {}

>> -> Si fuese, por ejemplo, a>>b, se traduciría por a/2^b. ¿?

<< -> Lo mismo, solo que si a<<b, significa a*2^b. ¿?

OPERACIONES ABREVIADAS:

variable++; / ++variable;  -> De ambas maneras se le suma 1 a la variable, la diferencia es que en el primero crea la variable, le suma 1 y devuelve el resultado,  mientras que en el otro se coge 1 y se le suma directamente devolviendo el resultado. Dicho de otro modo, la segunda forma lleva menos tiempo para el compilador.

variable--; / --variable;  -> Se deduce lo que hace ¿no?

variable+=x  -> Se traduce por "variable es igual a sumarle x a variable". Siempre significa sumarle lo que viene después del =

variable-=x  -> De la misma manera que el anterior, pero restándole x.

variable*=  -> Lo mismo.

variable/=  -> Igual.

{} El !=, aunque se puede usar como se dijo anteriormente, tiene otra función. Este tipo de variables son conocidas como bool o booleanos, y se distinguen en que sólo existen dos valores: el verdadero y el falso. Veamos:

bool variable;
 
variable=true;
 
if(!variable)
 
{
 
} 

Sólo decir que el if (explicado en las ramas condicionales) se activará cuando variable NO sea verdadera, o sea, cuando la variable no tenga el valor true.

Los booleanos únicamente tienen un problema, y es que los valores falsos incluyen al 0, así que si queremos tener al 0 como valor verdadero, habrá que poner:

bool variable;
 
variable=true;
 
if(!variable && variable !=0)
 
{
 
}

ANTES DE NADA, tengo que comentar que si a una variable no se le asigna un valor, por defecto se le asignará 0.

Bueno, aclarado esto, digamos que en el if pone: "si la variable no tiene un valor verdadero ni vale 0".

Únicamente queda comentar las distintas maneras de crear variables y ya estará.

¿? Esto signos son conocidos como Bitwhise Shift (Desplazamiento lateral de bits), así que seguramente oiréis hablar de ellos como desplazar a la izquierda (<<) o derecha (>>).

     1.  ¿Globales o locales?

Principales diferencias: Se distinguen dependiendo del momento en el que las llames. Las globales son declaradas antes del comienzo del main, y por lo tanto se pueden llamar (hacer uso de ellas) en cualquier lugar del código. En ambio, las locales se llaman después del comienzo de la función, y sólo se podrán llamar en el bucle desde el cual se las llame. Para llamarlas desde otro lado, sería necesario declararlas de nuevo.

NOTA: Las variables globales suelen ser consideradas código sucio y pobre (prescindibles y que podrían producir errores), así que personalmente sólo las recomiendo en ocasiones en las que sea total e inevitable su uso.

     2. ¿Individuales o colectivas?

Principales diferencias: Si se da el caso de que distintas variables tengan destinadas funciones similares, o todas corresponden a un sprite o a una rama o a una función, se pueden declarar todas en una sola línea. Yo las llamo variables colectivas, pero cada una tiene nombre propio.

               2.1.  Colectivas

        Bueno, de las colectivas se distinguen dos clases: Arrays y Tuplas

                           2.1.1.  Arrays

                Los arrays se pueden considerar un número definido de números para la misma variable. Tan simple como declarar una variable y poner entre corchetes el  número de variables que queremos que se creen. Así:

                         u32 array[1000];

                Con esto se crearían 1000 variables asignadas a la variable array(ojo si usáis s o u de poner suficientes bits), que serían de 0 a 999 (en C siempre se usa  el 0 como primer número).

                Ahora para usarlas simplemente hay que tener cuidado. Distinguir:

                        ++array;

                Así esta función afectaría a los 1000 valores de array.

                Si queremos usar un único valor, simplemente se pone:

                        ++array[50];

                Con esto sólo afectaría al valor 50 del array.

                           2.1.2.  Tuplas

                Las tuplas son parecidas a los arrays, con la diferencia que en lugar de variables con el mismo nombre, son nombres asignados a otro general.Pero bueno, una imagen vale más que mil palabras, ¿no?

typedef struct
{
float a;
s8 b;
u8 c;
}    tupla;

Ahora la explicación por partes:

                      typedef struct   La declaración de la tupla. Con esto indicamos que las variables entre corchetes serán comunes entre sí. Declararemos las variables entre los corchetes como haríamos normalmente.

                      float a;

                      s8 b;

                      u8 c;       Las variables pertenecientes a la tupla. Se declaran como cualquier otra.

                      tupla;     El nombre genérico que tendremos para las variables. Asignar un nombre genérico será obligatorio a menos que queramos un estupendo mensaje de error cada vez que usemos la tupla. Por ejemplo:

                           tupla ejemplo;

                      Así se asigna un nombre genérico en cualquier momento, ahora la tupla tupla se conocerá como ejemplo.

                 Ahora, ¿cómo usamos las variables de tupla? simplemente poniendo nombregenérico.variable, que en este caso sería ejemplo.a, ejemplo.b o ejemplo.c. Así de simple.

                 NOTA: Más de uno pensará que esto no tiene ninguna clase de uso. Todo a su tiempo, todo a su tiempo...

Y eso es todo sobre variables. A lo mejor esto es un poco lioso, pero en el momento de usarlo no es tan complicado. A ver si con un pequeño ejemplo se aclaran las ideas:

 // Includes
#include // Include de las PAlib
u8 variable1;
u8 variable2=1;
u8 variable3=2;
// Funcion main()
int main(int argc, char ** argv)
{
PA_Init();
PA_InitVBL();
++variable3;
while (1)
{
variable1+=variable2*variable3;
++variable2;
PA_WaitForVBL();
}
return 0;
} // Fin de main()

Ahora toca la explicación (me saltaré la parte que ya venía con el main.c):

u8 variable1;

u8 variable2=1;

u8 variable3=2;          Con esto declaramos las variables, les damos nombre y valor. Las puse dentro del main, aunque se pueden declarar en cualquier momento.

++variable3;               Sumamos 1 a la variable3. Cabe decir que, al realizarse antes del while, sólo se ejecutará una vez.

variable1+=variable2*variable3;     Una sencilla operación. el valor de variable1 cambia de 0 al resultado de sumarleel producto de variabl2 y variable3.

++variable2;           Se suma 1 a variable2. A diferencia de variable3, al encontrarse dentro del while, el valor de variable2 irá aumentando cada vez que el bucle se repita.

Y ya está. Compiladlo sin queréis, pero no vais a ver nada (ambas pantallas en negro). Entonces, ¿quién me dice lo que hace esto? A ver, el chaval del fondo. Correcto, la cosa es así: variable1 irá aumentando cada vez más su valor debido a que variable2 también aumenta su valor. Puff, si viésemos el resultado en pantalla (que es posible) en un minuto no cogería en pantalla. Pero como ejemplo bien vale.

Muy bien, hora de deberes. La cosa es así de simple: creadme un texto que cambie de posición en pantalla indefinidamente. Pista: Basta con usar operaciones y variables (además de haber creado texto claro).

Con esto ya debería estar. Sabiendo esto podréis presumir de saber usar las variables.

(Es recomendable tener clara esta parte antes de pasar a la siguiente. Por favor, aseguraos de que entendisteis y sabéis utilizar las variables.)

2. Ramas condicionales

Lo primero, ¿qué son las ramas condicionales? Pues vienen a ser líneas de código (por lo general bucles) que se activan si se cumple la condición (que viene dada por los argumentos). Y ahora diréis,¿y eso qué utilidades tiene? Pues para que os hagáis una idea, las ramas condicionales va a ser lo que más utilicéis en vuestros proyectos. Por citar ejemplos, con un par de if (ya veréis qué es) podremos crear el menú de un juego: Si se pulsa una opción, pasa esto, si no, esto otro...

Bueno, si la gente no se perdió en el camino de las variables, los que quedemos podremos explicar esto a fondo:

         2.1. if: el condicional perezoso

            Empezaremos con la rama más sencilla. El if se le puede considerar el condicional vago: sólo trabaja una vez y gracias.

            Bueno, después de esta penosa comparación-amago de chiste, explicaré el porqué. Un if se divide en tres partes:

if  -> Primero llamar a la condicion
(argumento/s)  -> Lo que tiene que pasar para realizar el bucle
{  }  -> Lo que se realizara en caso de que se cumpla el argumento

             Facil, ¿no? Bueno, visto esto, pasemos ahora a código propiamente dicho:

PA_InitText(0,0);
if(Pad.Newpress.A)
{
PA_OutputSimpleText(0,0,0,"Pulsaste A, no?");<br />

              NOTA: TODOS los condicionales se deben declarar dentro del while (que curiosamente también es un condicional), puesto que lo anterior dentro del main es una "preparación" del programa, o sea, realiza lo que pasará inicialmente. Por decirlo de otro modo, el jugador tendrá control del homebrew dentro del while.

              Aclarado esto, explicaré el código.

PA_InitText(0,0); -> Bueno, esto no pienso explicarlo.

if(Pad.Newpress.A) -> El if se activará cuando se pulse A

PA_OutputSimpleText(0,0,0,"Pulsaste A, no?"); -> Esto es el código que se activará cuando se pulse A

               Únicamente destacar de los if: Como ya dije, el código se activa una vez y salta del bucle (si compilas este código, verás que al volver a pulsar no pasa nada). Ten en cuenta esto siempre.

                    2.1.1. Variante: if...else

                      El else sirve para decirle al programa "si no". Por ejemplo:

PA_InitText(0,0);
if(Pad.Newpress.A)   PA_OutputSimpleText(0,0,0,"A fue pulsado");
else    PA_ClearTextBg(0,0);

                     Si os fijáis, el if vendría a ser: "Si se pulsa A escribir el texto", y el else significa: "Si no, borrar el texto". Simple y fácil.

         2.2. while: el condicional currante

                Si se comprendió el if, el while no debería dar mayor problema. La única diferencia entre el if y el while es que elbucle del while se realizará mientras el argumento sea correcto. Dicho de otro modo: si, por ejemplo, el while se activa manteniendo pulsado A, mientras se mantenga pulsado A no se saldrá del bucle. Si este argumento se utiliza para un if, el código se ejecuta mientras se mantenga A, pero saltará fuera del bucle y seguirá con el siguiente código.

                Y, bueno, después de esto, el mejor ejemplo es el while de main.c

while(1)
{
PA_WaitForVBL();
}

                Muy bien, nada más sencillo. Mientras el argumento de while valga 1 (la consola esté encendida), se seguirá ejecutando lo de dentro de los corchetes, y de ahí no saldrá. Si esto fuese un if,si la consola está encendida ejecuta el código, y después pasa a lo siguiente.

                El while tiene muchas utilidades, que ya iréis viendo en los próximos tutoriales.

                NOTA: NUNCA metáis un while dentro de otro, porque lo más seguro es que se os quede congelada la imagen cuando se active ese while.

                      2.2.1. Variante: do...while

               Esta variante del while sirve para indicar primero lo que tiene que hacer y luego indicarle los argumento. Dicho de otro modo, primero ejecuta el código del do, y luego, en caso de cumplirse la condición, el do se repetiría.

do
{
PA_OutputSimpleText(0,0,0,"A pulsado");
}
while(Pad.Held.A);

                Volvemos a ser el código. Si leemos el do, lo ejecutaremos. Hasta ahí todo bien. Luego leeremos el while. Observamos que dice mientras se pulse A. Si A se mantiene pulsado, volveremos a realizar el do. Si no, seguiremos con el código de abajo.

                Fácil de entender, ¿no? En un while normal, primero comprobaría los argumentos, y luego ejecutaría el código. Con el do...while es al revés, primero se ejecuta y luego se comprueba para ver si hay que ejecutarlo de nuevo. OJO no os hagáis ilusiones, recordad que la DS ejecuta el código rapidísimo, así que a simple vista no distinguiríais si este código es un do...while o un while a secas, a lo sumo veríais un flash.

                      2.2.2. Variante: for

                 El for es una rama mucho más completa que el while: con tres argumentos resumimos unas cuantas líneas. Veamos:

for(variable=0; variable<120; variable++)
{
//código a ejecutar
}

                 El código está claro por sí mismo, así que únicamente compararemos con un while para entenderlo. Así sería con un while.

u8 variable;
while(variable<120)
{
//código a ejecutar
variable++;
}

                   NOTA: Recordad que el objetivo de este tutorial es para que aprendáis PAlib de una manera sencilla y clara. Por favor, si no entendéis algo, o alguna explicación no os lo deja claro, avisad y será corregido.

         2.3. Switch...case: El condicional organizado

                Ahora toca ver el condicional más específico de todos: con switch...case el efecto vendría a ser el de varios if juntos. La manera más sencilla de entenderlo es así: Si consideramos que el switch es un detective a lo Sherlock Holmes, el argumento sería una variable, que podría ser el arma de un crimen. Pues muy bien, dependiendo del valor de la variable, o el arma que usase el asesino, el crimen se cometería de una forma u otra, o sea, se ejecutaría un código case específico.

u8 arma;
switch(arma)
{
case 1:  //  Si arma vale uno...
//código a ejecutar
break;
case 2:  //  Si arma vale 2...
//código a ejecutar
break;
default:  // Si arma tiene un valor distinto de los anteriores...
//código a ejecutar
break;
}

                  Ahora la explicación:

switch(arma)          Con esto se inicia la condición

case 1:                 En caso de que la variable arma tenga el valor indicado (en este caso 1)

default:                     Esto incluye cualquier valor que no sea de ningún caso.

                  Los break después del código sirven para saltar fuera del switch. Si no, se ejecutarían los siguientes case por orden. De todos modos hablaré de ellos más adelante.

            IMPORTANTE: break y continue

                  Estos códigos, aunque considerados código despreciable, merece la pena tratarlos un poco, puesto su uso obligatorio en el switch.

                       break;  -> Sirven para romper el bucle, o sea, cuandoel compilador llega a esta línea, salta hasta fuera del bucle en el que se encuentre y sigue con el código.

                       continue;  ->Parecidos a los break, la única diferencia es que al llegar al continue, reinicia el bucle, volviendo al principio y comprobando los argumentos.

3. Funciones

Bueno, ¿qué decir de las funciones? Esto es lo máximo que tendremos que aprender de C. Sabiendo esto último podremos ponernos a trabajar seriamente en PAlib, así que un poco de paciencia .

Las funciones las definiremos como la pieza más grande de código que puede haber. Si ordenamos de más pequeño a mas grande:

1. Variables
2. Líneas de código
3. Ramas condicionales (Bucles)
4. Funciones

Lo más grande sería el programa en sí. Sabiendo manejar esto y usando la lógica podréis realizar bastantes cosas. Pero a lo que vamos.

                     3.1. Estructura de las funciones

           Una función se divide en tres partes: tipo de valor que devuelve, nombre y argumentos. ¿El ejemplo más cercano? El main principal.

                  int main(int argc, char ** argv)

           Vamos por partes: int es el tipo de valor que devuelve la función (vamos, devuelve un entero), main el nombre de la función, y (int argc, char ** argv) el argumento.

           Todas las funciones tienen que devolver un valor, que puede ser una variable o un número. Por eso al final de todo vemos:

                  return 0;

           Devuelve 0 al finalizar la función, que sería en este caso: ¡consola apagada, fin de main!

           Conviene saber algo muy importante de las funciones: NUNCA debe haber una función dentro de otra, así que si quereis hacer funciones ponedlas fuera del main.

           Después de esto, únicamente una cosa que comentar: las funciones no tienen por qué devolver un valor, devuelven void, o sea, nada. Si tu función no tiene que devolver un valor, basta con poner void como tipo de valor que devuelve. Lo mismo con los argumentos: no tiene por qué haberlos.

                  void funcion();

           Esta función no tiene argumentos ni devuelve valores (los () es lo mismo que (void))

                        3.1. Utilidades de las funciones

     1.  Para cálculos (por lo general complejos)

 u16 calculo(maximo,minimo)
{
resultado=maximo-minimo;
return resultado;
}

     2.  Como una variable cualquiera

                   valor1+=calculo();

     3.  Y muchos más...

Y con esto, señoras y señores, han aprendido suficiente lenguaje C/C++  como para afrontar los próximos tutoriales. Bueno, no era tan difícil ¿no? Ahora es el momento de sacarle el mayor provecho posible a esa maquinita que Nintendo ha creado. ¡¡Ánimo, que a partir de ahora llega la parte divertida de la programación!!

Ojito que no me he olvidado, es hora de deberes. Lo mejor que podéis hacer es intentar encontrarle un uso a todo esto con lo que ya sabes. Sorprendedme .

      NOTA: Si no habéis entendido pero NADA, tenéis tutoriales muy buenos en nuestra página madre (referentes a C/C++), o la página oficial de PAlibWiki (en los menús de la izquierda están los tutos en Español). Eso sí, no os olvidéis de comentarlo para que este tutorial se pueda ir mejorando.

¡Salu2 y hasta el próximo tutorial!