windgate's bennugd tutorial

Programacin de VideojuegosIntroduccin

Ejecutar los videojuegos

Introduccin: Ejecutar los videojuegos

Windows

La forma ms sencilla de ejecutar un videojuego programado con Bennu en Windows es a partir de su fichero de cdigo con extensin .prg

Con el Bennupack instalado, los ficheros .prg se abren automticamente con Notepad++, el entorno de programacin que adems usaremos para programar nuestros videojuegos.

Con el fichero .prg, abierto en Notepad++ pulsamos la tecla F6, esto abrir una ventana del sistema en la se realizar una verificacin de que el cdigo es correcto y no tiene errores, esta tarea se denomina compilacin.

Si la compilacin es correcta, se generar un fichero .dcb y se ejecutar el videojuego, en caso contrario tendremos que solucionar el problema de compilacin modificando el cdigo del videojuego.

Todos los videojuegos de ejemplo asociados a cada tema del tutorial compilarn y se ejecutarn sin problemas.

Linux

Para ejecutar un videojuego programado con Bennu en Linux tendremos que abrir una terminal.

Con el paquete de Bennu para Linux instalado, en la terminal introduciremos en primer lugar el comando bgdc seguido de la ruta del fichero .prg que queremos compilar.

Si la compilacin es correcta, se generar un fichero .dcb, y deberemos introducir el comando bgdi seguido de la ruta del fichero .dcb generado para ejecutar el videojuego.

Tanto en Linux como en Windows no habr problemas de compilacin para ejecutar los videojuegos de ejemplo. Ser cuando editemos nuestro propio cdigo o modifiquemos el de los videojuegos existentes cuando empezaremos a encontrarnos con los primeros errores de compilacin.

A lo largo de este tutorial aprenderemos a utilizar el lenguaje de programacin BennuGD y solucionar los problemas de compilacin que pronto nos encontraremos durante nuestra experiencia como programadores.

Introduccin Ejecutar los videojuegos Pg. 1

Programacin de VideojuegosTema 1

Grficos I

1. Grficos I

Si vamos a programar un videojuego, lo primero que vamos a necesitar son los grficos.

Podramos empezar con simples dibujos hechos a mano con Paint o cualquier otro programa bsico de dibujo, pero ya que vamos a dedicar varias horas de trabajo a nuestro videojuego, es mejor que seleccionemos unos grficos atractivos, que pueden ser por ejemplo nuestros personajes favoritos o los escenarios de aqul videojuego con el que pasamos cientos de horas jugando aos atrs.

En primer lugar crea una carpeta personal donde guardar tu trabajo, vamos a aprender a seleccionar grficos.

1.1 Sprites

Un spriteset es una tabla de grficos con todas las animaciones de un determinado personaje:

Tendrs que elegir varios spritesets. Puedes encontrar una amplia coleccin en internet, ya sea por ejemplo en webs como http://spritedatabase.net o simplemente buscando en Google Imgenes con las palabras claves sprite y ripped, esta ltima palabra significa extrado de un videojuego.

Tambin puedes buscar en el DVD de recursos de la actividad, en la seccin Biblioteca GFX.

Al seleccionar nuestros spritesets debemos tener en cuenta:

Perspectiva Lateral, superior o isomtrica. Es recomendable comenzar con spritesets en perspectiva lateral.

Animaciones Nuestro personaje NO podr realizar ms acciones que las que tiene su spriteset.

Resolucin El tamao en pxeles de cada animacin (Sprite) es una buena indicacin de la calidad del spriteset.

Observa que en la Imagen 1, tenemos un spriteset de perspectiva isomtrica, sin animacin de salto y con una resolucin media, ni muy alta como pudiera ser la de Street Fighter II ni muy baja como pudiera ser la del primer Super Mario Bros.

Tema 1 Grficos I Pg. 1

Imagen 1: Ejemplo de spriteset


Grficos I

1.2 Backgrounds

Un background es el grfico del escenario donde transcurrir la accin de nuestro videojuego.

Selecciona varios backgrounds. Nuevamente podrs encontrarlos en webs como http://vgmaps.com, en Google Imgenes con las palabras clave scroll o background, y tambin ripped.

Y de la misma forma tambin encontrars muchos en el DVD de recursos de la actividad, en la Biblioteca GFX, en la seccin de Scrolls, fondos y escenarios.

Al igual que los spritesets, los backgrounds tambin pueden tener perspectiva lateral, superior o isomtrica. Selecciona backgrounds con la misma perspectiva que tus spritesets. Recuerda que, como ya hemos dicho, es mejor comenzar con un videojuego en perspectiva lateral.

En cuanto a la resolucin, evita backgrounds con una resolucin demasiado pequea (Inferior a 320x240 pxeles) porque probablemente no lleguen a cubrir la pantalla, y evita tambin resoluciones demasiado

grandes (Superiores a 4096x4096 pxeles) porque consumiremos muchos recursos y ralentizaremos el PC, tanto a la hora de trabajar con ellos como a la hora de moverlos dentro de nuestro videojuego. En el peor caso podremos escalar el tamao de los backgrounds, pero es algo que tenderemos a evitar por ahora.

Observa que los backgrounds y los sprites son algo totalmente separado. En ocasiones nos encontraremos con backgrounds que conservan algunos elementos como enemigos o items. stos se denominan backgrounds sucios, ya que probablemente tengamos que terminar limpiando esas impurezas antes de incluirlos en nuestro videojuego.

Observa que en la Imagen 2, tenemos un background de perspectiva superior, con una resolucin algo baja, y que podemos considerar sucio si nuestra idea es que esos arbustos puedan ser cortados.

Tema 1 Grficos I Pg. 2

Imagen 2: Ejemplo de bakground


Grficos II

2. Grficos II

En el tema anterior hicimos una cuidadosa seleccin de grficos para nuestro videojuego. Ahora vamos a trabajar con ellos para dejarlos listos para ser incluidos en un videojuego.

2.1 Recorte de spritesets

Cada spriteset almacena una gran cantidad de animaciones (Sprites) distintas. Lo primero que tenemos que hacer es recortarlas para dejar cada sprite en un archivo de imagen distinto. Es algo que podramos hacer con Paint, seleccionando un rectngulo, copindolo, pegndolo en un archivo nuevo... Pero esa sera una tarea demasiado costosa, es por eso que haremos uso de un programa especfico para esta tarea de recorte: Castle Split Image.

Este programa nos permite dividir cualquier imagen en filas y columnas, tantas como queramos, de manera que pulsando despus un botn el programa se encarga de generar todos los recortes del spriteset, cada uno en un archivo distinto. Observa que en el Dibujo 1 hemos usado 2 reglas verticales para separar las animaciones, es aconsejable que cada regla quede lo ms cercana posible a la animacin, lo ideal sera por ejemplo a 1 pixel de distancia.

Debes observar que cada spriteset tiene un color de fondo distinto y en general muy contrastado. Cuando terminemos de recortar lo prximo que haremos ser eliminar ese color de fondo, y para poder hacerlo es imprescindible que todos los sprites que generemos tengan formato de archivo .png. Otros formatos como .bmp, .jpg, etc. no nos servirn, as que establece el formato .png como el formato de corte en el men File/Preferences... de Castle Split Image.

Salvo excepciones, un spriteset siempre est ordenado por filas. Por esa razn, cada vez que trazamos una lnea vertical observaremos que amputamos partes de los sprites superiores e inferiores. Por esta razn tendremos que trabajar cada vez una fila del spriteset, guardando los resultados de cada corte en una carpeta distinta.

Cada vez que recortamos generamos una cierta cantidad de recortes no vlidos que tendremos que ir borrando. Esto es sencillo si activamos las Vistas en Miniatura en el men Ver de la carpeta en la que residen los cortes

Si has seguido estos pasos cuidadosamente, ya puedes ir al men File/Generate Images... para generar todos los sprites.

Tema 2 Grficos II Pg. 1

Imagen 1: Reglas horizontales y verticales en Castle Split Image


Grficos II

2.2 Eliminar el color de fondo

Para poder hacerlo es imprescindible que hayas generado los cortes en formato .png. Ests a tiempo de asegurarte, ya que si no estn en ese formato todo lo que hagas de aqu en adelante no servir de nada.

Para eliminar el color de fondo usaremos Paint.NET, un programa con decenas de funcionalidades que iremos viendo poco a poco, aunque por ahora nos bastar con una de ellas: La herramienta Varita Mgica.

La varita mgica permite seleccionar una zona de color uniforme haciendo clic sobre un color de la imagen, podemos eliminar esa zona pulsando la tecla Supr.

Slo queremos eliminar el color de fondo, as que configuraremos la Tolerancia a 0% para evitar que seleccione otros colores similares. Vers la barra de tolerancia en la parte central superior del programa.

Ten en cuenta que en ocasiones el color de fondo no est contiguo, sera el caso de un grfico en forma de donut, cuyo centro tambin tendr el color de fondo. Para evitar tener que hacer 2 (O ms) veces el mismo proceso, podemos configurar la saturacin en modo global haciendo clic en el icono en forma de Relmpago, que pasar a tomar forma de Planeta indicando que se seleccionar todo el color en toda la imagen.

Debes eliminar el color de fondo en todos y cada uno de tus recortes. Puedes agilizar mucho esta tarea si seleccionas todos tus recortes y los arrastras al lienzo de Paint.NET. El

programa los abrir todos a la vez y podrs trabajar mucho ms rpido. Cuando hayas terminado, en lugar de guardar uno por uno los recortes, puedes cerrar directamente el programa y te avisar de si quieres guardar todo el trabajo.

Las tareas de recorte de grficos y de eliminacin del color de fondo son bastante montonas, pero son imprescindibles si queremos hacer un videojuego 100% personalizado por nosotros. Es recomendable recortar los spritesets completamente as como eliminar el color de fondo de todos los recortes, as no tendremos que volver a repetir esta tarea.


Imagen 2: Varita mgica en Paint.NET


Grficos II

2.3 Crear un fichero para grficos (FPG)

Todos los grficos que vamos a usar en nuestro videojuego deben estar almacenados en un fichero de extensin FPG, en el que se guardan asignndoles un nmero distinto a cada uno. Para realizar esta tarea usaremos el programa FPG Edit.

FPG Edit tiene una seccin superior en la que podemos navegar por nuestras carpetas buscando nuestros grficos, mientras que en la seccin inferior tenemos las imgenes que contiene nuestro FPG, con un nmero asociado en lugar de su nombre de archivo original.

Un botn verde con forma de flecha (Add) nos permite aadir nuevas imgenes, cuyo nmero podemos indicar modificando el valor que hay a la derecha de la barra central del programa y pulsando a continuacin el botn '#' que hay a su lado.

Podemos numerar los grficos de nuestro videojuego como queramos, pero para llevar un orden y evitar confusiones al seguir este curso, es aconsejable que sigas la siguiente numeracin:

Nmero en el FPG Grficos a guardar

Del 1 al 200 Protagonista/s de nuestro videojuego.

Del 201 al 400 Disparos, hechizos e items.

Del 401 al 600 Scrolls, escenarios y fondos.

Del 601 al 800 Enemigos u otros personajes.

Del 801 al 999 Elementos decorativos y otros elementos.


Imagen 3: Interfaz del programa FPG Edit


Introduccin al lenguaje de programacin Bennu

3. Introduccin al lenguaje de programacin Bennu

En el tema anterior construimos un fichero FPG con todos los grficos que vamos a utilizar en nuestro videojuego. Ya estamos listos para comenzar a hacer uso de l y empezar a ver en pantalla nuestros grficos.

3.1 Concepto de lenguaje de programacin

Un lenguaje de programacin consiste en una serie de palabras clave que, correctamente asociadas y ordenadas, nos permiten dialogar con el procesador expresando el comportamiento que queremos obtener para nuestro programa o videojuego.

El lenguaje Bennu posee una gran cantidad de palabras clave, con distinta utilidad, potencia y complejidad, que iremos introduciendo poco a poco durante este tutorial. Si es la primera vez que te encuentras con un lenguaje de programacin debes saber que en general son una mezcla entre la lengua inglesa y las matemticas. No te dejes intimidar por su aparente complejidad, seguro que vas a disfrutar mucho utilizndolo.

3.2 Concepto de proceso en Bennu

Existen muchos tipos de lenguajes de programacin. Java es un lenguaje orientado a objetos, C es un lenguaje imperativo, Bennu en cuestin es un poco especial, segn la teora de lenguajes de programacin puede considerarse un lenguaje orientado al proceso.

Para hacernos una idea, todo elemento que haya en pantalla es un proceso: Nuestro protagonista, cada disparo, cada enemigo...

El lenguaje nos permite definir el comportamiento de un proceso, por ejemplo el de un disparo, y ste puede ser invocado tantas veces como queramos de una manera tan sencilla como es escribir su nombre. Es algo que veremos a fondo en los siguientes temas, por ahora vamos a trabajar a fondo con un nico proceso, que definiremos como queramos, y que ser invocado tan slo 1 vez.

Tema 3 Introduccin al lenguaje de programacin Bennu Pg. 1



3.3 Aspectos bsicos de un proceso en Bennu

Todo proceso en Bennu tiene una serie de aspectos que determinan cmo lo visualizaremos en la pantalla, o incluso si estar visible en la pantalla o fuera de ella.

A continuacin vamos a enumerar los aspectos bsicos de un proceso en Bennu. Todos los aspectos tienen un determinado valor numrico. Te dars cuenta de que con ellos y con nuestro FPG tenemos lo suficiente para modelar prcticamente cualquier comportamiento que hayas visto en cualquier videojuego comercial en 2 dimensiones.

Aspecto Funcionamiento

graph Es el aspecto fundamental de un proceso. Es el nmero de grfico del FPG que nuestro proceso utilizar para mostrarse en pantalla. Por ejemplo, si hacemos que graph valga 201 y ese nmero corresponde al grfico de un misil en nuestro FPG, entonces nuestro proceso se mostrar en pantalla con el aspecto de ese misil. Si no le decimos a nuestro proceso cul es su valor de graph, entonces graph valdr 0 y el proceso ser invisible.

x Sirve para determinar la posicin de un proceso en pantalla. Generalmente la pantalla tiene una resolucin de 640x480 pxeles, aunque Bennu nos permitir cambiarla ms adelante. El valor de x es el pxel, medido desde el extremo izquierdo de la pantalla, en el que se mostrar el proceso. Por ejemplo, si hacemos que x valga 320, entonces el proceso se mostrar en el centro de la pantalla horizontalmente. Si no le decimos a nuestro proceso cul es su valor de x, entonces x valdr 0 y el proceso aparecer en el extremo izquierdo de la pantalla.

y De forma similar a x, sirve para determinar la posicin de un proceso en pantalla. El valor de y es el pxel, medido desde la parte superior de la pantalla, en el que se mostrar el proceso. Por ejemplo, si hacemos que y valga 240, entonces el proceso se mostrar en el centro de la pantalla verticalmente. Si no le decimos a nuestro proceso cul es su valor de y, entonces y valdr 0 y el proceso aparecer en el extremo superior de la pantalla.

size Determina cul es el tamao con el que se dibujar el proceso en pantalla. Observa que la pantalla tiene una cierta resolucin en pxeles y cada grfico del FPG un cierto tamao en pxeles. El valor de size indica en tanto por ciento (%) el tamao con el que veremos el grfico en pantalla. Por ejemplo, si hacemos que size valga 200 y el graph del proceso tiene un tamao de 20x20 pxeles, entonces el proceso se dibujar en pantalla con un tamao de 40x40 pxeles, un 200% ms grande que su tamao original. Si no le decimos a nuestro proceso cul es el valor de size, entonces size valdr 100 y el proceso se dibujar con el tamao original de su grfico.




angle Indica cul es el ngulo de giro con el que se dibujar el proceso en pantalla. Gracias a este aspecto, con un nico grfico de un baln podremos hacer que ste gire. El valor de angle indica en milsimas de grado la inclinacin con la que se dibujar el grfico en pantalla. Por ejemplo si hacemos que angle valga 180000 el proceso se ver girado 180 grados, boca abajo. Si no le decimos a nuestro proceso cul es su valor de angle, entonces angle vale 0 y el proceso se dibujar normalmente. La razn por la cual angle se mide en milsimas de grado es para permitir giros con mucha precisin, sobre todo en grficos grandes, como pudiera ser un escenario.

3.4 Aspectos avanzados de un proceso en Bennu

A continuacin una serie de aspectos de un proceso que no utilizaremos por el momento, pero que nos permitirn ms adelante programar comportamientos ms complejos de una manera mucho ms cmoda.


flags Este aspecto avanzado permite que el proceso sea dibujado aplicando distintos efectos grficos. Su valor numrico no tiene ninguna unidad de medida, simplemente cada nmero ofrece un efecto distinto y hay que consultar esta tabla para conocer su funcionamiento. Valores posibles de flags son: 0 para dibujado normal, 1 para dibujar el grfico espejado horizontalmente, 2 para dibujar el grfico espejado verticalmente, 4 para dibujar el grfico con una transparencia del 50%, 8 para dibujar el grfico con una transparencia del 90%, y el resto los probaremos ms adelante, en general no se usan los flags a partir del 8. Los valores de flags corresponden a potencias de 2, esto permite que puedan sumarse entre ellos obteniendo la aplicacin de todos los valores sumados. Por ejemplo si hacemos que flags valga 7 estaremos aplicando 1+2+4, y el proceso se dibujar espejado horizontalmente, espejado verticalmente y adems con una transparencia del 50%. Si no indicamos cul es el valor de flags, entonces flags vale 0 y el proceso se dibuja normalmente.

z Este aspecto avanzado es til cuando tenemos una gran cantidad de procesos distintos en pantalla. En esos casos observaremos que unos procesos son dibujados por encima o por debajo de otros, y no siempre obtendremos el orden de dibujado esperado. El valor de z indica la profundidad de dibujado, de forma que procesos con valores mayores de z se dibujarn por debajo de los procesos con menores valores de z. Por ejemplo si a nuestro proceso protagonista le damos un valor de z que vale 1 y a un proceso aura situado sobre el protagonista le damos un valor de z que vale 2, entonces veremos el aura detrs de nuestro protagonista. Sin embargo si intercambiamos los valores de z veremos el aura por delante de nuestro protagonista, ocultando su grfico. Si no especificamos el valor de z, entonces z vale 0 y los procesos se dibujan con el orden que decida el procesador.





ctype Este aspecto avanzado es til cuando tenemos un escenario o scroll cuyo tamao en pxeles es superior a la resolucin en pxeles de la pantalla. En ese caso el scroll no cabe en la pantalla y slo podemos ver una determinada zona del scroll cada vez. Si esto sucede, es probable que nos interese que los aspectos bsicos x,y de nuestro proceso no tengan como origen la esquina superior izquierda de la pantalla, sino que tengan como origen la esquina superior izquierda del escenario o scroll. Si no especificamos el valor de ctype, entonces ctype vale 0 y las coordenadas x,y tienen como origen la esquina superior izquierda de la pantalla. En cambio si hacemos que ctype valga 1, entonces las coordenadas x,y tienen como origen la esquina superior izquierda de nuestro scroll.

3.5 Ejercicio terico: Los aspectos de un proceso Bennu en un videojuego comercial

Piensa en Galaxian, un sencillo arcade de los aos 80, e intenta adivinar el posible valor de los aspectos de proceso en Bennu que corresponderan para cada uno de los elementos que muestra en pantalla.

Piensa despus en The Legend of Zelda, un RPG ms complejo desarrollado para SNES en los aos 90, e imagina cmo cambiaran los valores de los aspectos, especialmente los avanzados como ctype, que facilitara calcular las coordenadas x,y de los diferentes procesos que recorren el escenario o que se mantienen fijos en pantalla.


Imagen 1: Galaxian, un arcade de los aos 80

Imagen 2: The Legend of Zelda, un RPG de los aos 90


El lenguaje: Asignaciones

4. El lenguaje: Asignaciones

En el tema anterior explicamos los aspectos bsicos de cualquier proceso grfico en Bennu. Estos eran:

Aspectos bsicos

graph Su nmero de grfico dentro del fichero .fpg que creamos en las primeras sesiones.

x,y Su posicin horizontal y vertical medida en pixels respecto de la esquina superior izquierda de la pantalla.

size Su tamao medido en % respecto del tamao original de su graph (Por defecto 100).

angle Su ngulo medido en milsimas de grado (Por defecto 0).

Aspectos avanzados

flags Efectos visuales (0 = Normal, 1 = Espejo horizontal, 2 = Espejo vertical, 4 = Transparencia 50%, etc.)

ctype Indica si las coordenadas x,y son relativas a la pantalla o al scroll (Valores 0 1 respectivamente).

z Indica la profundidad de dibujado, que indica si un proceso se dibuja por encima o por debajo de otro.

file Especifica el fichero .fpg en el que se buscar el graph (Slo cuando usemos mltiples ficheros .fpg).

4.1 Definicin de asignacin

Una asignacin establece un valor numrico a cualquiera de los aspectos de un proceso. Su sintaxis es la siguiente:

Aspecto = Valor; //Es importante no olvidar el smbolo ';' (Un punto y coma) que indica el fin de la asignacin.

A continuacin aadiremos las siguientes asignaciones entre las etiquetas BEGIN y END del proceso principal de nuestro videojuego y comprobaremos que el funcionamiento es exactamente el indicado en la tabla anterior.

graph=1; El proceso toma el grfico nmero 1 de nuestro fichero .fpg.

x=100; Posiciona el proceso a 100 pixels del lateral izquierdo de la pantalla.

y=200; Posiciona el proceso a 200 pixels de la parte superior de la pantalla.

size=50; Cambia el tamao del proceso a un 50% de su tamao original.

angle=90000; El proceso se muestra rotado 90 grados (Recuerda que angle se mide en milsimas de grado).

Tema 4 El lenguaje: Asignaciones Pg. 1


El lenguaje: Asignaciones

4.2 Primeras pruebas con nuestro videojuego Bennu

En la carpeta Videojuego que lleva asociada este tema, encontrars un programa tan sencillo que no puede considerarse un videojuego, pero que nos servir para realizar todas las pruebas iniciales y ser la base para el videojuego que crearemos a medida que avancemos en este tutorial.

El contenido de la carpeta es el siguiente:

DLL En esta carpeta se encuentra toda la maquinaria (Archivos DLL) que hace que nuestro videojuego pueda ejecutarse. Por el momento no tocaremos nada de esa carpeta.

images En esta carpeta se guarda el/los ficheros para grficos (FPG) del videojuego. Por ahora trabajaremos con el FPG que tiene y en el prximo tema lo sustituiremos por el nuestro.

videojuego.prg Este archivo contiene el cdigo fuente que editaremos para aadir nuevas instrucciones. Podras editarlo perfectamente con el Bloc de Notas, aunque si instalas la utilidad Bennupack podrs editarlo con el programa Notepad++, que resulta mucho ms cmodo de utilizar e incluye algunas otras utilidades interesantes.

Ejecutar en Windows.bat

Comprueba errores en el cdigo (sto se llama compilar) y si todo es correcto ejecuta el videojuego.

Ejecutar en Linux.sh

Lo mismo que lo anterior, pero funciona en el sistema operativo Linux.

videojuego.dcb Este fichero se genera a partir del cdigo cuando compilamos, y es lo que realmente se ejecuta.

Ya ests listo para hacer las pruebas propuestas en este tema y otras que se te puedan ocurrir. No olvides guardar el archivo .prg cada vez que modifiques el cdigo, no olvides asegurarte de que el resultado de la compilacin no muestra errores, y durante tus primeros pasos como programador, no olvides que las instrucciones deben terminarse con un ';'.

Los errores anteriores sern el 99% de tus posibles problemas a la hora de empezar a programar, el resto los iremos viendo ms adelante.

Tema 4 El lenguaje: Asignaciones Pg. 2


El lenguaje: Incrementos

5. El lenguaje: Incrementos

En el tema anterior establecimos valores numricos fijos a los diferentes aspectos de un proceso. La asignacin de valores fijos no es suficiente para poder crear nuestro videojuego, as que ahora aprenderemos a hacer que esos aspectos se modifiquen automticamente durante la ejecucin gracias a las instrucciones de incremento.

5.1 Definicin de incremento

Una incremento establece una variacin sobre cualquiera de los aspectos de un proceso a partir de una operacin matemtica que generalmente es muy sencilla, por ejemplo una suma. Su sintaxis es la siguiente:

Aspecto = Aspecto + Valor; //Una vez ms, no olvides el ';' (Punto y coma).

Prueba a aadir las siguientes asignaciones entre las etiquetas LOOP y END del proceso protagonista de tu videojuego y comprueba que el incremento da resultado.

graph=graph+1; El proceso toma el siguiente nmero de grfico del fichero .fpg cada vez que se muestra en pantalla.

x=x+4; El proceso se desplaza 4 pxeles hacia la derecha cada vez que se muestra en pantalla.

y=y-1; El proceso sube 1 pxel cada vez que se muestra en pantalla.

size=size+2; El proceso aumenta en un 2% su tamao cada vez que se muestra en pantalla.

angle=angle-1000; El proceso rota 1 grado en sentido antihorario cada vez que se muestra en pantalla.

5.2 Aclaraciones sobre las asignaciones y los incrementos

Tanto las asignaciones como los incrementos son instrucciones, y por tanto siempre deben situarse entre las etiquetas BEGIN y END, que indican el principio y el final de la zona de instrucciones que ejecuta un proceso.

Los procesos tiene un nico bloque de instrucciones BEGIN END, y para facilitar su ubicacin, la etiqueta BEGIN se tabula exactamente a la misma altura que la etiqueta END que la cierra.

Dentro del bloque BEGIN END, justo al final del mismo, encontraremos un bloque LOOP END. Las instrucciones que vienen antes del bloque LOOP END se ejecutan una nica vez al iniciar el proceso y suelen ser asignaciones , mientras que las instrucciones dentro del LOOP END se ejecutan todo el tiempo y suelen ser incrementos .

Tema 5 El lenguaje: Incrementos Pg. 1


El lenguaje: Incrementos

5.3 Ejercicio: Uso de los aspectos bsicos de un proceso

Con lo aprendido hasta ahora ya deberas saber hacer que tu proceso protagonista aparezca inicialmente en la esquina superior izquierda de la pantalla, y se desplace hasta la esquina inferior derecha al tiempo que gira y aumenta de tamao.

Truco: La proporcin de pantalla en pxeles es 4:3, por tanto avanzando 4 pxeles en horizontal (Eje X) y 3 pxeles en vertical (Eje Y) debera recorrer exactamente la diagonal de la pantalla.

Ejemplos de resolucin de pantalla que cumplen la proporcin 4:3 son 640x480, 800x600 y 1024x768. Estas resoluciones pueden establecerse modificando los valores de la instruccin set_mode(800,600,16,MODE_WINDOW); que encontrars en el primer BEGIN del cdigo de tu videojuego.

5.4 Ejercicio: Uso de los aspectos avanzados de un proceso

El aspecto flags de un proceso produce efectos visuales muy interesantes. Aprovechando lo aprendido sobre incrementos puedes hacer que tu proceso incremente en 1 el valor de su variable flags con la instruccin: flags=flags+1;

De esta forma podremos ver la totalidad de los efectos visuales que podremos aplicar modificando esta variable.

Truco: Los diferentes flags son apilables, esto significa que cuando flags vale 5 estamos aplicando flags=1 (Espejo horizontal) y flags=4 (Transparencia 50%) al mismo tiempo, puesto que 1+4=5. Otro ejemplo ms complejo sera cuando flags vale 209, que aplicara los flags 128+64+16+1 y cuyo efecto sera bastante extrao... En general no usaremos flags ms all del 16.

Tema 5 El lenguaje: Incrementos Pg. 2


El lenguaje: Condiciones

6. El lenguaje: Condiciones

En el tema anterior establecimos incrementos en los aspectos del proceso principal de nuestro videojuego logrando que su grfico, su posicin, su tamao, etc. Variasen durante la ejecucin.

El uso de instrucciones de incremento ofrecen dinamismo en el videojuego, pero el comportamiento que obtenemos siempre es el mismo y no hay ningn tipo de interaccin. Para lograr interaccin y un resultado mucho ms sofisticado debemos hacer uso de las condiciones.

6.1 Definicin de condicin

Su nombre exacto es condicional. Consiste en establecer una condicin, de manera que, slo cuando sta se cumpla se ejecutarn una o ms instrucciones, que pueden ser asignaciones, incrementos o incluso otras condiciones.

Los condicionales son algo que utilizaremos extensivamente durante toda nuestra vida como programadores, as que es conveniente que te quede totalmente claro su funcionamiento. Su sintaxis es la siguiente:

IF ()

END

Observa que hemos encerrado entre la condicin sin explicar su sintaxis exacta. Esto se debe a que puede haber una gran diversidad de ellas. Vamos a ver unas cuantas en este tema, y ms adelante veremos una descripcin ms formal de todas las condiciones que podemos llegar a usar.

key(_right) Se cumple cuando se pulsa la tecla direccional derecha (_right) del teclado. Podemos sustituir _right por cualquier otra tecla direccional, cualquier letra o nmero, _enter, _space, etc. El nombre de la tecla siempre va precedido por el carcter '_'.

x600 Se cumple cuando el aspecto y (La posicin vertical en pxeles) del proceso tiene un valor mayor que 600. Esto ocurre cuando el proceso se sale por la parte inferior de la pantalla. Siempre y cuando estemos ejecutando con una resolucin de pantalla de 800x600 pxeles.

graph==9 Se cumple cuando el aspecto graph (El nmero de grfico del FPG) del proceso tiene un valor exactamente igual a 9. Esta condicin nos permite por ejemplo detectar cundo termina una animacin. Observa que se usan 2 smbolos '=' para comprobar (leer), y 1 smbolo '=' para asignar (escribir).

Tema 6 El lenguaje: Condiciones Pg. 1


El lenguaje: Condiciones

6.2 Instrucciones a ejecutar cuando se cumple una determinada condicin

Vamos a ver unos cuantos ejemplos tpicos de uso de las condiciones:

IF (x>800) x=0;END

Cuando el aspecto x del proceso tiene un valor mayor que 800 pxeles (Se sale por la derecha de la pantalla), se le asigna un 0 a su aspecto x para hacer que vuelva a aparecer por la izquierda.

IF (key(_down)) y=y+4;END

Cuando se pulsa la tecla direccional abajo, el proceso incrementa su aspecto y en 4, bajando 4 pxeles cada vez. Servira para desplazar nuestro proceso por la pantalla.

IF (key(_right)) graph=graph+1; IF (graph>9) graph=1; ENDEND

Cuando se pulsa la tecla direccional derecha, el proceso incrementa su grfico en 1 (Recorre 1 a 1 los grficos del FPG y por tanto se anima).

Si adems de pulsar la tecla direccional derecha el valor de graph se hace mayor que 9, volvemos a asignar el graph 1, logrando as que el proceso utilice la animacin cuyos grficos van del 1 al 9.

Ten en cuenta que las nuevas instrucciones condicionales que estamos aadiendo pueden entrar en conflicto con incrementos o asignaciones anteriores que pudiera haber en nuestro proceso. Asegrate de que entiendes lo que ocurrir cuando aadas nuevas instrucciones, y si notas algn comportamiento extrao, no dudes en borrar todas las instrucciones y volver a empezar.

6.3 Ejercicio: Programar los controles de un juego de naves

Con las indicaciones dadas en los ejemplos anteriores ya deberas ser capaz de aadir las condiciones necesarias en el proceso principal de tu videojuego para que se mueva hacia arriba, abajo, izquierda y derecha con las teclas direccionales correspondientes.

Adems puedes programarlo de manera que, si el proceso se sale por arriba, por abajo, por la izquierda o por la derecha de la pantalla, vuelva a aparecer por el lado opuesto.

No te compliques demasiado programando la animacin, ya que es un tema ms complejo de lo que parece a simple vista y lo veremos con detenimiento ms adelante.

Tema 6 El lenguaje: Condiciones Pg. 2


Procesos I

7. Procesos I

Ya hemos modificado el proceso principal de nuestro videojuego y hemos practicado con l las instrucciones fundamentales para modificar los aspectos de un proceso en Bennu.

En el punto 3.2 de este temario comentamos que era posible definir el comportamiento de un proceso y a continuacin poderlo invocar tantas veces como queramos.

Hasta ahora slo hemos modificado el proceso principal de nuestro videojuego. Hemos definido cual era su comportamiento, y no hemos tenido necesidad de invocarlo porque el proceso principal se invoca siempre (Y una sola vez.) cuando ejecutamos el videojuego.

7.1 Definir un proceso en Bennu

Vamos a definir un proceso. Sus instrucciones sern exactamente las mismas que habamos incluido en el proceso principal de nuestro videojuego, la diferencia es que ahora podemos darle un nombre, el que nosotros queramos, por ejemplo protagonista. La sintaxis de un proceso en Bennu es la siguiente:

PROCESS ( )BEGIN

LOOP

FRAME;

ENDEND

Despus del END del proceso principal (Al final del cdigo), podemos aadir todas las definiciones de proceso que queramos, aunque por ahora slo vamos a aadir una.

Observa que el nombre del proceso debe ir seguido de los caracteres ( ), un parntesis de apertura y uno de cierre que pronto veremos para qu sirven.

Entre las etiquetas BEGIN y END iran las instrucciones que determinan el comportamiento del proceso. Puedes cortar directamente todas las instrucciones entre el BEGIN END que tenas en el proceso principal de tu videojuego y pegarlas aqu, a excepcin de las instrucciones set_mode(); y load_fpg(); que slo se deben ejecutar al principio para configurar el modo de vdeo y cargar el archivo FPG con los grficos, respectivamente.

Tema 7 Procesos I Pg. 1


Procesos I

7,2 Invocar un proceso en Bennu

Si has definido correctamente el proceso anterior, al compilar no deberas tener errores, pero al ejecutar es probable que no veas nada en pantalla. Esto se debe a que todava no has invocado el proceso, y tu videojuego no hace nada ms que establecer el modo de vdeo con set_mode();, cargar el archivo FPG con load_fpg(); y terminar.

Para invocar un proceso basta con escribir su nombre, es lo que haremos despus de cargar el archivo FPG. Si nuestro proceso se llamaba protagonista, entonces la invocacin tendra la siguiente sintaxis:

protagonista ( ) ;

Observa nuevamente que la invocacin tambin incorpora los caracteres ( ), y adems un ';' al final, como las instrucciones de asignacin e incremento que vimos en los temas anteriores.

Antes de seguir adelante, si no consigues resultados, recuerda que cada tema lleva asociado un videojuego donde puedes comprobar el cdigo correcto. Si tienes algn problema lo ms probable es que te hayas dejado alguna de las etiquetas END, que sirven para indicar el fin de los bloques de cdigo que abren las etiquetas BEGIN, LOOP e IF, entre otras.

7.3 Ejercicio: Invocar un proceso disparo

Una vez hayas conseguido crear tu proceso Bennu correctamente, vamos a hacer la prueba de crear otro proceso adicional que ser el disparo de nuestro protagonista.

Lo llamaremos disparo (Por ejemplo.), y su definicin se encontrar justo despus del ltimo END del proceso protagonista. Puedes darle las asignaciones iniciales que creas convenientes, por ahora no te preocupes por su posicin inicial ya que ms adelante aprenderemos a hacer que los disparos aparezcan en la posicin exacta donde se encuentra el protagonista.

El disparo debe tener necesariamente un bloque LOOP END donde se incluyan los incrementos necesarios para desplazarlo por la pantalla. Adems, antes del END, deberemos tener una instruccin FRAME;, esto generalmente se cumplir para todos los procesos dentro de su bloque LOOP END, ya que de lo contrario no mostrarn nada en pantalla, e incluso haremos que el videojuego se quede bloqueado. Ms adelante explicaremos la instruccin FRAME; en profundidad.

Para invocar el disparo aadiremos el siguiente condicional dentro del bloque LOOP END del protagonista:

IF ( key(_space) )disparo ( ) ;

END

Tema 7 Procesos I Pg. 2


Procesos II

8. Procesos II

Ya hemos aprendido lo ms bsico para definir e invocar nuevos procesos. Es importante que en este punto tengas bien clara la diferencia entre definir un proceso e invocarlo:

Definir un proceso: Consiste en escribir todo su cdigo en un bloque PROCESS - END.Slo se hace una vez.El proceso no aparece en pantalla hasta que sea invocado..

Invocar un proceso:

Consiste en escribir su nombre seguido de ( );Podemos hacerlo tantas veces como queramos.Hace que el proceso aparezca en pantalla.

Si has realizado correctamente el programa del tema anterior, habrs comprobado que el proceso disparo no era capaz de ser invocado en la misma coordenada x,y en la que se encontraba el protagonista. En este tema vamos a ver una sencilla forma de lograr esto.

8.1 Jerarqua de procesos en Bennu

Ahora que distinguimos entre definir e invocar un proceso, podemos comenzar con uno de los aspectos ms avanzados del lenguaje Bennu. Se trata de la jerarqua de procesos, y es que todos los procesos en Bennu se organizan exactamente igual que un rbol genealgico.

El padre que gobierna toda la jerarqua de procesos es el proceso principal, se que est definido dentro del primer bloque BEGIN END y que por ahora se encarga de ejecutar las instrucciones set_mode(); y load_fpg();.

El proceso protagonista era invocado dentro del BEGIN END del proceso principal, por tanto podemos decir que el protagonista es hijo del proceso principal, y obviamente, que el proceso principal es el padre del protagonista.

Finalmente el proceso disparo era invocado dentro del BEGIN END del proceso protagonista, por tanto decimos que el proceso disparo es hijo del proceso protagonista, y de la misma manera, el proceso protagonista es padre del proceso disparo.

Tema 8 Procesos II Pg. 1

Procesoprincipal

Procesoprotagonista

Procesodisparo


Procesos II

8.2 Herencia de procesos en Bennu

Apoyndose en la jerarqua de procesos, Bennu nos ofrece un mecanismo muy sencillo para hacer que ciertos procesos puedan heredar aspectos (Como graph, x, y, size, etc.) de sus padres.

Esto nos servir para, por ejemplo, hacer que el proceso disparo herede la coordenada x, y de su padre (El protagonista) y as lograr que los disparos nos ofrezcan la sensacin correcta, apareciendo siempre en la posicin del protagonista, sea cual sea.

Para ello usaremos uno de los aspectos ms avanzados de un proceso Bennu. Se trata de un aspecto llamado father, que mediante el operador '.' nos permite acceder a los aspectos bsicos del proceso padre segn esta table:

father.graph Indica el nmero de grfico en el archivo FPG de nuestro proceso padre.

father.x Indica la posicin horizonal en pxeles de nuestro proceso padre.

father.y Indica la posicin vertical en pxeles de nuestro proceso padre.

... ...y lo mismo con father.size, father.angle, father.flags, etc.

Para hacer que el disparo herede la coordenada x, y de su padre (El protagonista) al ser invocado, podemos usar la asignacin, asignando a su x el valor de father.x y asignando a su y el valor de father.y. Estas instrucciones estaran dentro del bloque BEGIN END del proceso disparo, antes del bloque LOOP END, ya que nos interesa que la herencia slo se realice una vez nada ms ser invocado el disparo.

PROCESS disparo() //Definicin del proceso disparo:BEGIN //Inicio de las instrucciones del proceso

x=father.x; //Asignamos la x del padrey=father.y; //Asignamos la y del padregraph=45; //Asignamos el grfico que queramosLOOP //A partir de aqu repetimos siempre

x=x+10; //Incrementamos la x en 10FRAME; //Mostramos resultado en la pantalla

END //Fin de la repeticinEND //Fin de las instrucciones del proceso

Adems de father, podemos acceder a la jerarqua en otras direcciones utilizando son (El ltimo hijo de un proceso), smallbro (El hermano anterior de un proceso) y bigbro (El siguiente hermano de un proceso). Tambin podramos acceder a un abuelo utilizando father.father, pero no es necesario complicarse, ya que en la prctica nos bastar con usar father solamente.

Tema 8 Procesos II Pg. 2


Prcticas

9. Prcticas

Es un buen momento para hacer un uso ms avanzado de todos los conceptos que hemos visto sobre el lenguaje Bennu. El inters principal de este tema no es introducir conceptos nuevos, sino ms bien aprovechar lo que ya sabemos para mejorar ciertos aspectos de nuestro videojuego, especialmente el apartado de animacin.

Como nica novedad explicaremos algunos usos ms avanzado de los condicionales.

9.1 Condicionales con varias alternativas

En ocasiones puede interesarnos crear un condicional en el que se evalen varias condiciones, pero slo se ejecuten las instrucciones asociadas a la primera que se cumpla, ignorando las siguientes.

El ejemplo ms sencillo es el caso de las teclas direccionales izquierda y derecha. Vamos a utilizar los condicionales de manera que, cuando se pulsen ambas teclas a la vez, nuestro videojuego interprete slo una.

Para ello podemos utilizar un condicional mltiple, cuya sintaxis es la siguiente:

IF () //Primera condicin a evaluar //Ejecutaremos esto si se cumple

ELSIF () //Segunda condicin a evaluar //Ejecutaremos esto si se cumple

ELSIF //Siguientes condiciones a evaluar...

ELSE //Si no se cumple ninguna de las anteriores condiciones //Ejecutaremos esto

END //Fin del condicional mltiple

Es nmero de ELSIF que sirven como alternativas a la primera condicin es ilimitado, podemos poner tantos como queramos.

Tambin es importante que entiendas que todas las condiciones se evalan por orden, y una vez se cumple la primera de ellas, se ejecutan sus instrucciones asociadas y se sale del condicional mltiple. Esto quiere decir que slo se interpreta como mximo una condicin.

Y finalmente debes saber que es posible tener un condicional mltiple con ELSE pero sin ningn ELSIF o bien con uno o ms ELSIF pero sin el ltimo ELSE.

Tema 9 Prcticas Pg. 1


Prcticas

9.2 Ejercicio: Aplicar todo lo anterior a nuestro videojuego

Gracias a todo lo que hemos visto hasta ahora en este temario, debemos ser capaces de lograr que nuestro protagonista sea capaz de mirar a izquierda y a derecha (Modificando su aspecto flags) cuando pulsamos la tecla correspondiente. Tambin deberamos poder conseguir que se anime, utilizando su animacin de andar.

Con el disparo ocurre lo mismo, deberamos ser capaces de lograr que los disparos avancen en la direccin a la que mira nuestro protagonista (Nuevamente gracias al aspecto flags). Tambin deberan poder animarse con su animacin correspondiente.

Aplica todo esto a tu videojuego. Si tienes dudas puedes mirar el videojuego de ejemplo de este tema.

Sobre todo evita copiar y pegar las instrucciones del videojuego de ejemplo en tu videojuego. Aunque resulta tentador, en general no trae ms que problemas, ya que el objetivo no es hacer que el videojuego funcione correctamente, sino que t entiendas cmo hacer que el videojuego funcione correctamente.

Tema 9 Prcticas Pg. 2


Un Matamarcianos

10. Un Matamarcianos

Si has completado con xito el reto del tema anterior ya estas preparado para realizar tu primer videojuego jugable.

Gracias a la generacin de nmeros aleatorios de Bennu, su sistema de deteccin de colisiones entre procesos y unas breves nociones sobre destruccin (Formalmente muerte) de procesos, dotaremos a nuestro videojuego de todo lo necesario para ser un matamarcianos de los aos 80.

10.1 Introduccin a la generacin de nmeros aleatorios en Bennu

La generacin de nmeros aleatorios es un aspecto bsico en cualquier videojuego para garantizar que el resultado de la ejecucin no sea siempre el mismo.

En nuestro caso vamos utilizar los nmeros aleatorios para crear un proceso enemigo capaz de moverse aleatoriamente en los ejes x, y de manera que su movimiento sea siempre impredecible.

La sintaxis de la generacin de un nmero aleatorio es la siguiente:

rand ( , );

Donde valor_mnimo y valor_mximo son los valores numricos del intervalo dentro del que ser generado el nmero aleatorio. Unos ejemplos de aplicacin de los nmeros aleatorios seran los siguientes:

Rand ( 1 , 100 ); Devuelve un valor aleatorio entre 1 y 100. Es el ejemplo ms sencillo, pero utilizada por s sola esta instruccin no tiene ningn efecto.

x = x + rand ( -4 , 4 ); El proceso modifica su posicin en el eje x una cantidad aleatoria de pxeles comprendida entre -4 y 4.

IF ( rand ( 0 , 1 ) == 0 ) x = x + 4;END

El proceso ejecuta la instruccin x = x + 4; una de cada dos veces. Es como tirar una moneda al aire, y si sale cara, realizar una accin.

Con estas nociones crea un nuevo proceso llamado enemigo, con lo que has aprendido hasta ahora puedes echarle imaginacin o bien puedes consultar el enemigo en el videojuego de ejemplo asociado a este tema.

Tema 10 Un Matamarcianos Pg. 1


Un Matamarcianos

10.2 Introduccin a la muerte de procesos en Bennu

Existen varias formas de matar a un proceso en Bennu, aunque vamos a ver la ms sencilla de todas.

Generalmente nos interesar que un proceso muera cuando se cumpla una determinada condicin. Dado que nuestros enemigos son capaces de moverse libre y aleatoriamente por la pantalla, vamos a proponer un ejemplo de muerte muy sencillo:

Si uno de los enemigos sale fuera de los lmites de pantalla, entonces morir.

Con esto evitaremos que los enemigos salgan de pantalla y se vayan hasta el infinito, ya que si se diese ese caso estaran consumiendo memoria y recursos del PC innecesariamente.

Para matar a los enemigos haremos que utilicen la instruccin BREAK;

La instruccin BREAK; no mata directamente al proceso, pero hace que ste abandone su bloque LOOP-END, y como despus del LOOP-END no hay ms instrucciones el proceso deja de ejecutar instrucciones y muere. Es una forma relativamente sencilla y limpia de matar procesos.

El cdigo a aadir en nuestro enemigo, dentro de su bloque LOOP-END, sera el siguiente:

IF ( x < 0 ) //Si sale de la pantalla por la izquierdaBREAK; //Abandona el LOOP y muere

ELSIF ( x > 800 ) //Si sale de la pantalla por la derechaBREAK; //Abandona el LOOP y muere

ELSIF ( y < 0 ) //Si sale de la pantalla por arribaBREAK; //Abandona el LOOP y muere

ELSIF ( y > 600 ) //Si sale de la pantalla por abajoBREAK; //Abandona el LOOP y muere

END //Fin de las condiciones

Otra forma que ofrece Bennu para conseguir el mismo resultado sera la siguiente, haciendo uso de los operadores lgicos, en este caso OR, que sirve para activar una condicin cuando se cumpla una cualquiera de sus subcondiciones:

IF ( ( x < 0 ) OR ( x > 800 ) OR ( y < 0 ) OR ( y > 800 ) )BREAK;

END

De la misma forma que OR, podemso usar el operador lgico AND, que servira para activar una condicin cuando se cumplan t todas sus subcondiciones. Aunque es algo que ya iremos viendo a medida que avance el temario.



Un Matamarcianos

10.3 Deteccin de colisiones entre procesos

El funcionamiento de nuestro matamarcianos ser as de sencillo:

Si un enemigo colisiona con nuestro protagonista, entonces nuestro protagonista morir. Si un enemigo colisiona con un disparo, entonces el enemigo morir.

Para ello haremos uso de la funcin collision(); cuya sintaxis es la siguiente:

collision ( type )

La expresin anterior activar un condicional si el proceso que la ejecuta est colisionando en pantalla con cualquier proceso del tipo dado por .

Por ejemplo, para que los enemigos mueran al colisionar con un proceso de tipo disparo deberan ejecutar el siguiente cdigo dentro de su bloque LOOP-END:

IF ( collision ( type disparo ) )BREAK;

END

10.4 Generacin aleatoria de enemigos

Hemos definido el proceso enemigo, pero no lo hemos invocado. De momento haremos que sea el protagonista quien genere aleatoriamente enemigos en el escenario, no es la mejor solucin pero s la ms sencilla. Para ello el protagonista debera ejecutar las siguientes instrucciones:

IF ( rand ( 1 , 10 ) == 1 ) //Si un dado de 10 caras saca como resultado 1enemigo ( ) ; //Invocamos un enemigo

END //Fin del condicional

Y para que los enemigos aparezcan aleatoriamente en las esquinas de la pantalla podemos aadir estas instrucciones iniciales, antes de su bloque LOOP-END:

x = rand ( 0 , 1 ) * 800; //Su posicin x podr valer o bien 0 o bien 800y = rand ( 0 , 1 ) * 600; //Su posicin y podr valer o bien 0 o bien 600

Nota que el carcter '*' (Asterisco) es el signo de multiplicacin en Bennu.



Variables I

11. Variables I

Has aprendido a crear un matamarcianos y ya deberas tener base suficiente como para explotar tu imaginacin y aadir otros elementos como explosiones, distintos enemigos, incluso un segundo protagonista para que se trate de un juego para 2 jugadores, siempre que cuentes con los grficos necesarios.

Pero todava nos queda muchsimo por descubrir del lenguaje Bennu. En este tema vamos a aprender a tratar conceptos un poco ms abstractos de un videojuego, generalmente valores numricos diversos como pueden ser la puntuacin o los puntos de vida de un determinado proceso.

11.1 Concepto de variable

Una variable es un pedazo de la memoria de nuestro PC en el que podemos almacenar un valor, generalmente numrico, aunque ms adelante veremos otras posibilidades.

El ejemplo ms claro son los aspectos bsicos de un proceso en Bennu como graph, size, etc. No son ms que variables, simples nmeros que se almacenan en la memoria de nuestro PC y a los que podemos hacer referencia con su nombre.

Todos los aspectos bsicos de un proceso en Bennu que hemos visto hasta ahora son tiles para crear un videojuego bsico, pero no nos permiten recrear aspectos ms complejos como la puntuacin o los puntos de vida. Para ello necesitaremos crear nuevas variables, como veremos a continuacin.

11.2 mbito de una variable

Como ya hemos dicho, una variable puede almacenar datos como la puntuacin o los puntos de vida. Es importante que observes que se trata de valores que se comportarn de manera muy distinta si tenemos en cuenta que la puntuacin es un valor nico, mientras que cada enemigo puede tener un valor de vida distinto...

Tema 11 Variables I Pg. 1


Variables I

Para salvar estas dificultades se utiliza el mbito de las variables, que por ahora distinguiremos entre global o privado, segn la siguiente definicin:

GLOBAL: Una variable tiene este mbito cuando almacena un valor nico y comn para todos los procesos del videojuego. El caso ms claro es la puntuacin del juego, ya que hay slo una zona de memoria donde se almacena ese dato.

PRIVATE: Una variable tiene este mbito cuando almacena un valor que puede ser distinto para distintos procesos. El caso ms claro son los puntos de vida, ya que puede haber varios enemigos y cada uno tendr una zona de memoria donde almacenar su valor de vida.

Este concepto nos permitir inventar nuevas variables a las que podremos dar el nombre y los valores iniciales que queramos.

11.3 Variables GLOBAL

Las variables GLOBAL se incluyen en la zona de cdigo que se sita al principio del programa, justo debajo de la sentencia PROGRAM y antes de la primera sentencia BEGIN.

Por ejemplo, para aadir una variable encargada de almacenar la puntuacin, que tenga un valor inicial 0, nuestro programa quedara as:

PROGRAM videojuego;

INCLUDE "DLL\import.prg"; //Incluye las DLL necesarias

GLOBALpuntos=0;...

BEGINset_mode(800,600,32,MODE_WINDOW); //Establecemos el modo de vdeo

END

Tema 11 Variables I Pg. 2


Variables I

Una vez incluida una variable GLOBAL, cualquier proceso es capaz de modificar su valor como si se tratase de cualquiera de sus aspectos bsicos. Ejemplos de uso de la variable GLOBAL puntos seran los siguientes:

Puntos=100; Asigna el valor 100 a la variable puntos.

puntos=puntos+1; Suma 1 al valor de la variable puntos.

IF (puntos>1000) BREAK;END

Si la variable puntos almacena un valor mayor que 100 el proceso muere.

11.4 Variables PRIVATE

Las variables PRIVATE se incluyen en la zona de cdigo entre el PROCESS que encabeza la declaracin de un proceso y el BEGIN que indica el comienzo de sus instrucciones.

Por ejemplo, para aadir una variable encargada de almacenar un valor de 100 en la vida inicial de cada enemigo, nuestro proceso enemigo quedara as:

PROCESS enemigo();PRIVATE

vida=100;BEGIN

END

Una vez incluida una variable PRIVATE, cada proceso es capaz de modificar su valor como si se tratase de cualquiera de sus aspectos bsicos, siendo posible que distintos procesos conserven distintos valores. Ejemplos de uso de la variable PRIVATE puntos seran los siguientes:

vida=100; Asigna el valor 100 a la variable vida del proceso.

vida=vida-1; Suma 1 al valor de la variable vida del proceso.

IF (vida


Variables I

11.5 Aplicando GLOBAL y PRIVATE

Crea la variable GLOBAL que almacena la puntuacin y la variable PRIVATE que almacena la vida de cada proceso enemigo. Haz el uso adecuado de estas variables para conseguir que los enemigos sean capaces de resistir 10 golpes antes de morir, y que antes de morir sumen 1 a la puntuacin.

Un ejemplo bsico de enemigo que haga uso de las variables sera:

PROCESS enemigo();PRIVATE

vida=10;BEGIN

LOOP...IF ( collision (type disparo) )

vida = vida -1;ENDIF ( vida


Variables II

12. Variables II

Ya sabes cmo declarar nuevas variables en tu videojuego, pero todava tenemos muchsimo que aprender sobre ellas y sus aplicaciones.

Habrs observado que el comportamiento de tus enemigos no tiene demasiado sentido, ya que aparecen en las esquinas de la pantalla y su movimiento aleatorio no suele ser capaz de hacerlos llegar al centro de la misma. En este tema vamos a hacer uso de las variables para conseguir que los enemigos vayan siempre al centro de la pantalla.

12.1 Una variable tiene el significado que nosotros queramos darle

Todos los aspectos bsicos de un proceso en Bennu como pueden ser graph, size o angle tienen un significado concreto: Indican su nmero de grfico dentro del FPG, su tamao en tanto por ciento, su ngulo en milsimas de grado, etc.

En cambio las nuevas variables que creamos no tienen un significado por s mismas sino que debemos ser nosotros, a travs del cdigo, los que les demos un significado concreto, por ejemplo haciendo que sucedan determinadas cosas cuando una de las variables que hemos declarado tome un determinado valor.

Recuerda que en el tema anterior hemos declarado la variable PRIVATE vida y nos ha servido para lograr que los enemigos sean capaces de resistir varios golpes antes de morir... Observa que mediante el lenguaje Bennu cada vez nos resulta ms fcil expresar comportamientos ms y ms complejos.

Ahora vamos a crear una nueva variable PRIVATE que llamaremos direccin (Sin acento), y nos servir para indicar dnde aparecer cada nuevo enemigo y hacia dnde debe moverse.

Por qu la direccin es PRIVATE y no GLOBAL? Pues porque cada enemigo podr tener una direccin distinta, recuerda que el mbito GLOBAL slo nos sirve para declarar un valor que resulte nico para todos los procesos del videojuego.

Tema 12 Variables II Pg. 1


Variables II

12.2 Ejemplo del significado que le podemos dar a una variable

Haciendo uso de la funcin rand(), vamos a hacer que la nueva variable PRIVATE direccion de nuestro enemigo tome un valor inicial aleatorio entre 1 y 4 antes de entrar en el bloque LOOP-END.

Consultando el valor obtenido, el enemigo decidir su posicin inicial y la direccin hacia la que se debe mover, segn la siguiente tabla:

direccion == 1 El enemigo aparece en la esquina superior izquierda y debe moverse hacia la esquina inferior derecha.

direccion == 2 El enemigo aparece en la esquina superior derecha y debe moverse hacia la esquina inferior izquierda.

direccion == 3 El enemigo aparece en la esquina inferior derecha y debe moverse hacia la esquina superior izquierda.

direccion == 4 El enemigo aparece en la esquina inferior izquierda y debe moverse hacia la esquina superior derecha.

Para aplicar este concepto, el cdigo del enemigo deber cambiar ligeramente a la hora de decidir su posicin inicial (Antes del bloque LOOP-END) as como deber modificar su comportamiento al desplazarse por la pantalla (Dentro del bloque LOOP-END).



Variables II

Un ejemplo de utilizacin de la variable direccin sera el siguiente:

PROCESS enemigo()

PRIVATE //Datos privados de cada proceso enemigo

vida=10; //vida con un valor inicial de 10 direccin;BEGIN

graph=50;

direccion=rand(1,4); //Toma un valor de direccin aleatorio entre 1 y 4

IF ( direccion == 1 ) //Condicin: Si la direccin es 1

x = 0; //Nos posicionamos arriba a la izquierda

y = 0;

ELSIF ( direccion == 2 ) //Alternativa: Si la direccin es 2

x=800; //Nos posicionamos arriba a la derecha

y=0;

ELSIF ( direccion == 3 ) //Alternativa: Si la direccion es 3

x=800; //Nos posicionamos abajo a la derecha

y=600;


x=0;

y=600; //Nos posicionamos abajo a la izquierda

END



Variables II

LOOP

IF ( direccion == 1 ) //Condicin: Si la direccin es 1

x = x + 4; //Nos desplazamos hacia abajo a la derecha

y = y + 4; ELSIF ( direccion == 2 ) //Alternativa: Si la direccin es 2

x = x - 4; //Nos desplazamos hacia abajo a la izquierda

y = y + 4;


x = x - 4; //Nos desplazamos hacia arriba a la izquierda

y = y - 4;


x = x + 4; //Nos desplazamos hacia arriba a la derecha

y = y - 4;

END FRAME; END END


Programacin de VideojuegosTema 13Textos I

13. Textos I

Hasta ahora hemos aprendido a mostrar procesos grficos por pantalla y a modificar su comportamiento cambiando los valores de sus variables.

Un videojuego tiene otros elementos adems de los procesos grficos, uno de los ms importantes son los textos que se muestran por pantalla, ya que entre otras cosas, nos permiten ver los valores que almacenan algunas variables en cada momento: El nmero de grfico, la posicin, los puntos de vida...

En este tema aprenderemos a escribir textos bsicos en pantalla de una forma muy sencilla.

13.1 Fuente de texto

La fuente de texto es el tipo de letra que se utilizara para imprimir por pantalla los textos de nuestro videojuego. Lo primero que vamos a necesitar es disear nuestra propia fuente de texto.

Es muy sencillo si utilizamos el programa FNT Edit, incluido en el Bennupack. Este programa nos permite seleccionar cualquiera de las fuentes del sistema, como por ejemplo Arial, Verdana u otras que hayamos instalado. Nos permite seleccionar el tamao de la fuente, su color, su tipo y color de sombra y su tipo y color de borde, permitiendo as disear prcticamente cualquier tipo de letra, bien sea para un pequeo marcador de puntuacin o para el ttulo de presentacin del videojuego.

Tema 13 Textos I Pg. 1


Su interfaz permite generar la fuente para previsualizarla, y una vez hayas terminado, puedes pulsar Guardar para guardarla en formato .fnt, que es el mas sencillo soportado por Bennu.

Genera unas cuantas fuentes y guardarlas con nombres apropiados, como por ejemplo fuente_texto.fnt, fuente_titulo.fnt, etc.

Al igual que el FPG de nuestro videojuego esta guardado en un subdirectorio llamado images, conviene que las fuentes tambin se guarden en un subdirectorio. En el caso del videojuego de ejemplo de este tema el subdirectorio se llama fonts y a la hora de cargar el/los archivos de fuente tendremos que tener en cuenta que se encuentran dentro de ese subdirectorio.

13.2 Cargar fuentes de texto con Bennu

Antes de poder utilizar una de nuestras fuentes, es necesario cargarla en el videojuego. Es algo que haremos desde el cdigo haciendo uso de la funcin de Bennu load_fnt() y una variable GLOBAL a la que llamaremos fuente.

Para declarar la variable:

GLOBALint fuente; //Crea una variable llamada fuente, el prefijo int indica que ser un nmero, aunque no

//es obligatorio ya que las nuevas variables por Bennu son por defecto nmeros

Para cargar la fuente utilizaremos la instruccin load_fnt(), as que recuerda que las instrucciones siempre deben encontrarse dentro de un bloque BEGINEND. En nuestro caso usaremos el primer bloque BEGIN-END de nuestro videojuego y cargaremos la fuente justo despus de cargar el fpg de esta forma:

BEGINfuente = load_fnt ( fonts/fuente_texto.fnt );

END

Esto no producir todava ningn efecto visual en nuestro videojuego, pero a partir de ahora podremos hacer uso de la fuente para escribir lo que queramos, como veremos a continuacin.

Fjate que la sintaxis de la carga de fuentes es muy sencilla. Formalmente se dice que load_fnt() es una funcin a la que se le pasa como parmetro la ruta de un archivo .fnt entre comillas, y nos retorna un identificador numrico, un entero.



En el manual de referencia se especifica formalmente su sintaxis abreviada as:

int load_fnt ( string )

Un string es un texto entre comillas, pero no te preocupes demasiado por ese detalle porque es algo que tendremos tiempo de ver a fondo mas adelante.

13.3 Escribiendo textos en la pantalla

Aunque se trata de una operacin muy sencilla, hay que tener en cuenta una serie de cosas a la hora de escribir en la pantalla: Por ejemplo no haremos lo mismo para escribir un texto fijo que para escribir el valor de una puntuacin que podr cambiar de valor a medida que avance el juego, ahora mismo veremos por que.

La funcin write() de Bennu sirve para escribir textos fijos, aunque en el prximo tema le daremos tambin otra utilidad interesante. Para escribir un texto necesitamos especificar una serie de cosas, que sern los parmetros de write, estas cosas son:

N de parmetro Tipo de parmetro Ejemplos

Parmetro 1 La variable donde hemos almacenado la fuente de texto que queremos utilizar. Podemos poner un 0 si queremos utilizar la fuente por defecto de Bennu, aunque resulta poco agradable.

fuente_textofuente_presentacion0

Parmetro 2 Coordenada horizontal donde aparecer el texto, especificada en pxeles como si se tratase de la x de un proceso.

0400800

Parmetro 3 Coordenada vertical donde aparecer el texto, especificada en pxeles como si se tratase de la y de un proceso.

0300600

Parmetro 4 Valor de centrado, que nos indica si el texto estar alineado a izquierda, centro o derecha, tanto horizontal como verticalmente, respecto de la posicin x,y que le hemos dado.

Puede ser de 0 a 8, ver el funcionamiento en la imagen al pie de la tabla.

Parmetro 5 El texto que queremos escribir, entre comillas. HolaPuntos: Has muerto



Tabla de valores posibles para la

alineacin de textos

Alineacin horizontal

Izquierda Centro Derecha

Alineacin vertical Arriba 0 1 2

Centro 3 4 5

Abajo 6 7 8

Para poner en prueba todo esto, especialmente los diferentes valores de centrado, ya que es el concepto que al principio parece ms complicado, vamos a hacer un pequeo cambio en nuestro videojuego.

Recuerdas que los enemigos hasta ahora aparecan en las esquinas? Pues vamos a poner en cada esquina un texto de advertencia. La coordenada de cada esquina la daremos de forma absoluta, pero con el valor de centrado correcto para que el texto cuelgue adecuadamente y no se salga de la pantalla.

Todava no lo sabemos todo sobre el manejo de textos, de momento ten en cuenta que consumen ms recursos de lo que parece, y por eso debemos evitar poner instrucciones de escritura de textos dentro de un LOOP. Pondremos las siguientes instrucciones dentro del primer bloque BEGIN-END, por ejemplo despus de cargar la fuente:

BEGINwrite ( fuente_texto, 0, 0, 0, Enemigos );write ( fuente_texto, 800, 0, 2, Enemigos );write ( fuente_texto, 800, 600, 8, Enemigos );write ( fuente_texto, 0, 600, 6, Enemigos );

END

Puedes poner algn texto ms si lo deseas y as practicar un poco mejor con el valor de centrado. Es ms sencillo de lo que parece.



Textos II

14. Textos II

La escritura de textos fijos resulta interesante, pero no nos servir de gran ayuda si no somos capaces de escribir informacin sobre valores de variables como puede ser la puntuacin o la vida.

Vamos a aprender un poco ms sobre textos y ya estaremos casi listos para escribir cualquier tipo de informacin por pantalla.

14.1 Escribir valores de variables en pantalla

La funcin write_var() tiene un funcionamiento prcticamente idntico a la funcin write() que hemos estudiado en el tema anterior. La nica diferencia es su ltimo parmetro, ya que en lugar de tratarse de una cadena de texto entre comillas, en ese parmetro podemos poner el nombre de cualquier variable de nuestro videojuego, y ste ser escrito en pantalla.

Qu ocurre si el valor de la variable cambia? Pues no hay ningn problema, ya que write_var() es una funcin que se encarga de actualizar automticamente el valor, sin mayores complicaciones.

Vamos a sacarle un poco ms de partido al uso de los valores de centrado. Imagina que quieres colocar en la parte superior de la pantalla un texto fijo PUNTOS y a su derecha el valor de la variable puntos.

Observa que el valor de la variable puede crecer ms y ms a medida que avanza el juego, y no sera en absoluto deseable que el nmero pase a sobreescribir el texto PUNTOS. El valor de centrado nos ayudar a evitar ese tipo de cosas si centramos ambos textos en el mismo punto pero con distinta alineacin horizontal, por ejemplo as:

BEGINwrite ( fuente_texto, 400, 0 , 2, PUNTOS: );write_var ( fuente_texto, 400, 0, 0, puntos );...

END

14.2 Una especificacin ms formal de la sintaxis de write()

En el tema anterior hemos comentado que la escritura de textos consume muchos recursos y no es recomendable incluir instrucciones write() dentro de un bloque LOOP-END.

Tema 14 Textos II Pg. 1


Textos II

En algunas ocasiones puede interesarnos tener un texto capaz de moverse por la pantalla. En esos casos no nos queda ms remedio que utilizar continuamente la funcin write() con distintas coordenadas x,y dentro de un LOOP, pero a cada nueva llamada a la funcin write() necesitaremos borrar el texto escrito anteriormente...

Para eso write() nos retorna un identificador numrico del texto, que podemos pasar como parmetro a la funcin delete_text() para borrar el texto escrito. Formalmente la sintaxis de write() y delete_text() es la siguiente:

int write ( int, int, int, int, string) // write retorna un identificador numricodelete_text (int ) // delete_text recibe el identificador numrico retornado por write()

El funcionamiento es algo especial, ya que la escritura debe realizarse antes de la sentencia FRAME; y el borrado despus, para asegurar que el texto se borra despus de haber sido mostrado, y no antes.

Para probar todo esto vamos a crear un nuevo proceso encargado de mostrar el nombre de nuestro videojuego de izquierda a derecha de la pantalla:

PROCESS titulo()PRIVATE

int texto;BEGIN

x = 0;y = 300;LOOP

x = x + 10;IF ( x > 1600 )

BREAK;ENDtexto = write ( fuente_texto, x, y, 5, BIENVENIDO A MI VIDEOJUEGO );FRAME;delete_text ( texto );

ENDEND

Observa que comprobamos cuando la coordenda x es suficiemente grande como para que el texto haya salido por la derecha de la pantalla, y es entonces cuando el proceso muere para no seguir escribiendo ms el ttulo.

Tema 14 Textos II Pg. 2


Tipos de Dato I

15. Tipos de Dato I

Por ahora ya sabemos lo suficiente sobre el muestreo de textos por pantalla, aunque por supuesto a falta de practicar un poco. Vamos a cambiar un poco de temtica y vamos a ver otros aspectos avanzados del lenguaje que nos permitirn hacer cosas ms complicadas.

Hasta ahora slo hemos visto conceptos sobre variables cuyos valores eran numricos. Si haces memoria recientemente hablamos de aplicar el prefijo int a la hora de definir una variable, con ello indicbamos que en ella slo queramos guardar valores enteros (integer), y por supuesto no siempre ser suficiente con ello, de eso trata este nuevo tema.

15.1 Tipos de dato predefinidos

Toda variable en Bennu lleva asociado el tipo de dato que se va a almacenar en ella. Si no lo especificamos, la variable slo servir para almacenar enteros, pero por supuesto hay otras cosas que podemos guardar en una variable, como por ejemplo un texto o un nmero real.

Bennu y la mayora de los lenguajes de programacin vienen con una serie de tipos de dato predefinidos que podemos utilizar con diferentes fines. En el caso particular de Bennu, para especificar el tipo de dato de una determinada variable basta con aadirle un prefijo determinado a la hora de declararla.

Tema 15 Tipos de Dato I Pg. 1


Tipos de Dato I

Los prefijos que podemos aadir para declarar variables con los tipos de dato predefinidos en Bennu son los siguientes:

Prefijo Utilidad del tipo de dato Ejemplo de declaracin

int Almacena un nmero entero, es decir, nmeros positivos y negativos includo el cero, sin decimales. Es el tipo de dato por defecto de toda variable definida en Bennu, as que si omitimos este prefijo la variable que declaremos ser de tipo int.

Para qu sirve entonces aadir este prefijo? Pues para aclararnos ms fcilmente a la hora de leer nuestro cdigo, es algo que debemos tener en cuenta a largo plazo, la legibilidad de nuestro cdigo.

int puntos = 0;int vida = 100;

float Almacena un nmero real, es decir, nmeros positivos y negativos, con o sin decimales. Un float puede almacenar cualquier tipo de dato int, pero no al revs. Si queremos tener una variable de tipo float s que es obligatorio aadir el prefijo float.

Lo ms probable es que para los primeros videojuegos que programemos no tendremos necesidad de utilizar este tipo de dato.

float porcentaje = 0,0;float precio = 19,95;

char Almacena un carcter de teclado, ya sea alfanumrico, un smbolo o incluso un espacio, la tecla de salto de lnea o la de borrado. Los caracteres almacenables pertenecen al denominado cdigo ASCII y son 256 en total, aunque cambian segn la distribucin de teclas. Para asignar un valor a las variables de este tipo es necesario escribirlo entre comillas simples ( ' ).

No debes darle mayor importancia a este tipo de dato ya que su utilidad actual es muy limitada.

char letra = 'a';char otra_letra = 'w';

string Almacena un texto de cualquier longitud. Es como una serie de char concatenados y este tipo de dato s que nos resultar til para nuestro videojuego.

Para asignar un texto a las variables de este tipo es necesario escribirlo entre comillas dobles ( ).

string nombre = Secret of Evermore;string texto = GAME OVER;



Tipos de Dato I

Debes tener en cuenta que seguimos hablando de variables, idnticas a todas aquellas con las que hemos trabajado hasta ahora: Pueden ser GLOBAL y PRIVATE, podemos asignarles un valor inicial o no, debemos aadir siempre al final de su declaracin un punto y coma ( ; ), etc.

Prueba a aadir unas cuantas variables adicionales a tu videojuego dentro de sus secciones GLOBAL y PRIVATE y experimenta con la funcin write_var() para comprobar cmo almacenan valores que ya no son simples enteros.

Es muy importante que compruebes que el compilador no muestra ningn error, eso significa que el lenguaje Bennu acepta estas nuevas expresiones que estamos incluyendo.

15.2 Arrays o vectores

Aunque su nombre no resulta muy ilustrativo y en la primera toma de contacto se tiene a pensar que un array o vector es algo muy complicado, se trata de un aspecto muy sencillo del lenguaje que facilita algunas tareas de programacin.

Hasta ahora declarbamos las variables de 1 en 1, esto es, cada vez que queramos tener una variable donde almacenar un valor necesariamente tenamos que escribir la lnea de cdigo correspondiente. Imagina que queremos que los enemigos de nuestro videojuego puedan tener 10 valores de puntos de vida distintos, no simples valores aleatorios, sino valores fijos como por ejemplo: 10, 25, 50, 100, 250, 750, etc.

La serie de nmeros anterior podra generarse a partir de nmeros aleatorios dados por la funcin rand(), aunque si lo piensas vers que llevara algunas complicaciones adicionales.

Para almacenar esa serie o lista de nmeros podemos utilizar un array o vector (En adelante lo llamaremos siempre vector). Un vector no es ms que una lista de variables, tantas como queramos, cada una de ellas con su valor asociado.

En el caso de la lista anterior necesitamos una lista de 10 nmeros enteros, cada uno con un valor distinto. Observa que el tipo del dato a almacenar es un simple entero (Prefijo int), la nica diferencia es que queremos una variable que no almacene un nico entero sino 10 en nuestro caso.



Tipos de Dato I

Podemos declarar una lista de 10 enteros en la seccin GLOBAL de nuestro videojuego as:

GLOBALint puntos_de_vida [ 10 ];

Observa que al final de la declaracin hemos aadido, entre corchetes, el nmero de variables que queremos declarar.

La sintaxis formal de la declaracin de un vector, sea cual sea su tipo de dato, es la siguiente:

nombre_del_vector [ ] ;

Donde el tipo de dato puede ser cualquiera de los vistos anteriormente como int, float o string, y la longitud del vector puede ser cualquier nmero positivo, teniendo en cuenta que cuanta mayor sea la longitud mayor ser le memoria que consuma nuestro videojuego.

Por ejemplo, si tenemos en cuenta que un nmero entero ocupa 4 bytes en memoria, un vector de 1024 enteros ocupara 4096 bytes, que son 4 kilobytes. Fjate que es un valor despreciable teniendo en cuenta que las memorias actuales se miden en gigabytes.

Para almacenar en nuestro vector los valores de vida de los enemigos mencionados anteriormente podemos hacerlo en el mismo momento de su declaracin de la siguiente forma:

GLOBALint puntos_de_vida [ 10 ] = ( 10, 25, 50, 100, 250, 750, 1000, 2000, 5000, 10000 );

Fjate que los valores que almacenamos en la lista van separados por comas y encerrados entre parntesis. Qu ocurrira si almacenamos ms nmeros de los que hemos declarado en la lista? Simplemente evita hacerlo, ya que podra provocar errores de ejecucin en nuestro videojuego, ms adelante veremos por qu.

Slo nos queda un detalle: Cmo podemos hacer que cada enemigo tenga una vida distinta de entre los valores almacenados en nuestro vector?



Tipos de Dato I

Para ello necesitamos acceder a los datos del mismo y asignarlos a su vida. Lo haremos con una simple instruccin de asignacin que podremos incluir dentro de su bloque BEGIN END como cualquier otra instruccin. Por ejemplo:

Instruccin Utilidad Aclaraciones

vida = puntos_de_vida [ 0 ]; Asignara a la vida de nuestro enemigo el primero valor del vector de puntos de vida, en nuestro caso el valor que almacena es 10.

La posicin 0 es la primera posicin de todo vector declarado. Para un vector de longitud 10 podemos acceder a sus posiciones desde la 0 hasta la 9.

vida = puntos_de_vida [ 6 ]; Asignara a la vida de nuestro enemigo el sptimo valor del vector de puntos de vida, en nuestro caso el valor que almacena es 2000.

No olvides que para un vector de longitud N sus posiciones van desde la 0 hasta la N-1, es algo que siempre debers tener en cuenta.

vida = puntos_de_vida [ rand (0 , 9 ) ]; Asignara a la vida de nuestro enemigo un valor aleatorio, entre la posicin 0 y la posicin 9 de nuestro vector de puntos de vida.

S, podemos utilizar la funcin rand() para este tipo de propsitos, al fin y al cabo es una funcin muy sencilla que simplemente devuelve un valor aleatorio dentro del intervalo dado.

Y con lo aprendido sobre muestreo de textos tambin podramos hacer que la vida de cada enemigo aparezca sobre el mismo, Te atreves a intentarlo?.



Tipos de Dato II

16. Tipos de Dato II

En el tema anterior aprendimos a crear variables de tipo vector, que no son otra cosa que listas de variables predefinidas como int, float o string, con la longitud que queramos.

En este tema vamos a continuar con los tipos de dato, aunque vamos a cambiar un poco el concepto, ya que ahora aprenderemos a crear nuestros propios tipos de dato en los que podremos almacenar informacin ms compleja, como podran ser las estadsticas completas del protagonista de un RPG, todo en una nica variable.

16.1 Estructuras o types

Bennu nos ofrece la posibilidad de agrupar varias variables, sean del tipo que sean, incluso vectores, para crear un nuevo tipo de dato. Un tipo de dato con estas caractersticas se denomina estructura o type.

En un type podramos incluir diversos aspectos, como por ejemplo una string con el nombre de un enemigo, un int con sus puntos de vida, etc.

La declaracin de un type se realiza antes de la etiqueta PROGRAM, esto es, al principio del cdigo, y su sintaxis es la siguiente:

TYPE ; ;

END

Una vez declarado un type, el nombre del tipo puede utilizarse como prefijo a la hora de declarar variables, al igual que int, string y el resto de tipos de dato predefinidos. Es importante que veas la diferencia entre declarar un nuevo tipo de dato y declarar una variable asociada al nuevo tipo de dato, es un error comn pensar que una vez declarado el type ya tenemos una variable, pero no es as, para tener una variable tenemos que declararla dentro de GLOBAL o PRIVATE, como hemos hecho hasta ahora.

Vamos a crear un nuevo tipo de dato donde almacenar unas estadsticas bsicas para nuestro protagonista. Podemos dar el nombre que queramos al nuevo tipo de dato, aunque es recomendable que empiece por tp_, ya que esto nos ayudar a distinguir el nombre del tipo de dato del nombre de las variables de ese tipo.

Tema 16 Parmetros Pg. 1


Tipos de Dato II

TYPE tp_estadisticasstring nombre;int vida;int velocidad;

END

Observa que las variables que componen el type se declaran exactamente igual que el resto de variables que hemos definido hasta ahora en las secciones GLOBAL y PRIVATE. Las variables que componen un type se denominan formalmente campos, y pueden ser vectores o incluso otros types definidos anteriormente.

Por supuesto, tambin podramos asignar un valor por defecto a los campos, por ejemplo:

TYPE tp_estadisticasstring nombre = Sonic ;int vida = 100 ;int velocidad = 4 ;

END

Recuerda que hemos definido un nuevo tipo de dato, pero todava no tenemos ninguna variable de ese tipo. Podemos aadirla en la seccin PRIVATE de nuestro protagonista, quedara as:

PROCESS protagonista ()PRIVATE

tp_estadisticas estadisticas;

BEGIN

END

Cmo accedemos a los campos de un type? Si recuerdas lo visto en temas anteriores sobre la variable father de todo proceso en Bennu, utilizbamos el operador punto ( . ) para acceder a los distintos campos. La variable father es un type, y en todo type se accede as a sus campos.

.



Tipos de Dato II

16.2 Haciendo uso de nuestro nuevo tipo de dato

Modifica el protagonista de tu videojuego para que haga uso de los campos de la variable estadsticas y reduzca su campo vida al colisionar con los enemigos y se desplace a la velocidad que marca el campo velocidad. Tambin puedes hacer uso de la funcin write_var() sobre estadisticas.vida para tener un marcador en pantalla donde mostrar sus puntos de vida restantes.

Tambin puedes usar adecuadamente las funciones write_var() y delete_text() para conseguir que el nombre de Sonic permanezca siempre situado sobre nuestro protagonista, Por supuesto haciendo uso del campo nombre de nuestra variable estadisticas.

Para trabajar con ms detenimiento todo lo aprendido sobre tipos de dato tambin puedes asociar a cada enemigo un TYPE con su nombre y sus puntos de vida, de forma que antes de comenzar a ejecutar su bloque de instrucciones dentro de LOOP END asigne aleatoriamente su nombre y sus puntos de vida, y los muestre en pantalla.

Para ello puedes reaprovechar el TYPE tp_estadisticas o bien crear un tipo de dato nuevo.



Parmetros

17. Parmetros

Durante el tema anterior pudiste comprobar la potencia que ofrecen las variables en Bennu: Comprobaste que pueden almacenar datos con diversas caractersticas, incluso grandes cantidades de ellos, el principal lmite de todo ello es nuestra imaginacin.

El tema que viene a continuacin pretende darle todava ms utilidad al concepto de variable en Bennu, puesto que aprenderemos a ofrecer a los distintos procesos los valores que queremos que tomen para su ejecucin. En primera instancia podremos comunicar a un proceso aspectos bsicos como cul es su grfico o su posicin a la hora de invocarlo, pero tambin veremos que podemos ofrecerle informacin ms compleja como las estadsticas de fuerza, agilidad o inteligencia que queremos para l, de la misma forma que se hara en un RPG.

17.1 Paso de parmetros

Como ya sabes, la primera lnea de la declaracin de cualquier proceso en Bennu tiene la siguiente estructura:

PROCESS nombre_del_proceso ( )...BEGIN

END

El parntesis de apertura y cierre que aadimos junto al nombre del proceso tiene una utilidad especial, ya que en l podemos enumerar una serie de parmetros que el proceso recibir a la hora de ser invocado.

Por ejemplo, en los parmetros podremos indicar que el proceso va a recibir un entero indicando su posicin inicial o una string indicando su nombre. Cul es la utilidad de todo sto?, pues que gracias a ello, con una nica declaracin de proceso podremos lograr distintos comportamientos segn cules sean los parmetros que reciba a la hora de ser invocado.

Para ilustrar todo esto con un ejemplo, vamos a disear un sencillo proceso disparo que recibir como parmetros los valores de grfico inicial y final sobre los cules deber animarse.

Para ello indicaremos en la declaracin del proceso que recibiremos 2 valores enteros (De tipo int) a los cuales llamaremos graph_ini y graph_fin. (Debes notar que el nombre de los parmetros lo damos nosotros, vers que son algo muy similar a las variables.)



Parmetros

La declaracin de nuestro proceso disparo quedara as:

PROCESS disparo ( int graph_ini , int graph_fin )

Fjate que los parmetros se aaden con la misma sintaxis con la que se declaraban variables, esto es una gran ventaja, ya que nos permite declarar procesos que reciben parmetros de cualquier tipo.

Ahora la invocacin del proceso cambiar, ya que cada vez que lo invoquemos deberemos darle los valores enteros que necesita para graph_ini y graph_fin. Ejemplos de invocacin seran los siguientes:

disparo ( 1, 10 );disparo ( 25, 40 );...

17.2 Dando utilidad a los parmetros

Antes de darle el uso adecuado a esos nuevos valores graph_ini y graph_fin, comprueba que el programa compila correctamente.

Comprobars que la ejecucin no muestra ninguna diferencia de comportamiento, y es que hemos aadido parmetros, pero no hemos incluido dentro del proceso disparo las instrucciones adecuadas que nos permitan sacar prove

windgate's bennugd tutorial

Documents