PDF de programación - Programación de un video juego con Pilas Engine

Programación de un video juego con Pilas Engine.

Pablo Mileti. Junio de 2013.

Como introducción al entorno Pilas Engine, vamos a desarrollar un video juego que transcurra en el
patio de la escuela y nos permita aprender la potencia y facilidad que tiene Pilas Engine para trabajar
con colisiones, movimientos, choques y rebote entre los personajes de nuestro juego.

Se tomaron fotos del patio de la escuela con la finalidad de tener el escenario donde transcurra el
juego. A partir de una de las fotos surgió la idea, en la que un personaje se desplace por la planta alta y
arroje cosas, las cuales se deberán recoger o esquivar para recibir o restar puntos según corresponda. La
foto que disparó la idea es la siguiente:

Ahora debemos pensar que personajes participarán del juego. Propongo para este documento que
Tux sea el jugador que debemos controlar y lo objetos que caen desde planta alta sean licencias del tipo
Copyleft y Copyright. Obviamente Tux deberá recoger las licencias Copyleft y evitar ser alcanzado por
las licencias Copyright. Cuando Tux consiga la suficiente cantidad de licencias Copyleft la vaca
identificativa del sistema operativo Huayra saldrá volando. Quien arroje las licencias desde el primer
piso será el ñu del proyecto GNU.

Así deberá quedar el juego al finalizar este documento:


Se utilizará la versión 0.77 de Pilas que trae el sistema operativo Huayra de Conectar Igualdad, lo

encontramos en la sección Programación:



Arranquemos entonces creando un documento de texto con cualquier editor, por ejemplo Pulma, e

ingresamos el código que construya el escenario del juego:

import pilas
pilas.iniciar()
pilas.fondos.Fondo("fondo.png")
pilas.ejecutar()

Lo probamos arrastrando el archivo creado a la ventana de Pilas (el nombre debe utilizar la
extensión .py). En caso de no funcionar debemos verificar la sintaxis dado que Pilas distingue entre
minúsculas y mayúsculas. Además es necesario que la imagen fondo.png (al igual que todas las que se
utilicen en este juego) estén en la misma carpeta donde se encuentra el código fuente (archivo con
extensión .py).

A continuación vamos a colocar el logo de GNU en el primer piso. Para ello vamos a incorporar un
actor, Aceituna en este caso, y luego reemplazaremos la imagen por la del ñu. Lo crearemos bajo el
nombre de gnu (en negrita se resaltará el nuevo código a incorporar):

import pilas
pilas.iniciar()
pilas.fondos.Fondo("fondo.png")
gnu=pilas.actores.Aceituna()
gnu.imagen="gnu.png"
gnu.y=150
pilas.ejecutar()

Como verán no queda muy bien delante de la pared. Para ubicarlo dentro del pasillo de arriba vamos
a utilizar el truco de colocar por encima de todas las imágenes otra imagen del fondo, pero ahora con
transparencia total salvo en la pared, las barandas y las columnas. Esto lo podemos hacer retocando el
fondo con la aplicación Gimp. La imagen resultante es la siguiente:

Ahora vamos a incorporar un nuevo actor llamado adelante, para asignarle la imagen anteriormente

creada cuyo nombre es justamente adelante.png, lo hacemos de la siguiente forma:

import pilas
pilas.iniciar()
pilas.fondos.Fondo("fondo.png")
gnu=pilas.actores.Aceituna()
gnu.imagen="gnu.png"
gnu.y=150
imagen = pilas.imagenes.cargar("adelante.png")
adelante = pilas.actores.Actor(imagen)
pilas.ejecutar()

Si lo ejecutamos, veremos que ha quedado mucho mejor:

Es momento entonces de hacer que el ñu se mueva de forma impredecible por toda la planta alta. Lo
hacemos mediante random.randrange(-320,320). Si esto lo ejecutamos cada 1 segundo se moverá el ñu
a una coordenada de X comprendida entre -320 (izquierda de la ventana) y 320 (derecha de la ventana).
Para hacerlo ingresamos el siguiente código:

import pilas
import random
pilas.iniciar()
pilas.fondos.Fondo("fondo.png")
gnu=pilas.actores.Aceituna()
gnu.imagen="gnu.png"
gnu.y=150
imagen = pilas.imagenes.cargar("adelante.png")
adelante = pilas.actores.Actor(imagen)
def moverGNU():

gnu.x=[random.randrange(-320,320)]

pilas.mundo.agregar_tarea_siempre(1,moverGNU)
pilas.ejecutar()

Lo que hemos hecho es crear un procedimiento bajo el nombre moverGNU() con el fin de

automatizar esa tarea cada 1 segundo.

Ahora vamos a incorporar la funcionalidad que cada cierto tiempo arroje licencias del tipo copyright
(las que debemos esquivar). Como es una tarea que vamos a automatizar la creamos como un
procedimiento que recibirá el nombre de tirarCopyright(). Así será el código:

import pilas
import random
pilas.iniciar()
pilas.fondos.Fondo("fondo.png")
gnu=pilas.actores.Aceituna()
gnu.imagen="gnu.png"
gnu.y=150

imagen = pilas.imagenes.cargar("adelante.png")
adelante = pilas.actores.Actor(imagen)
copyright=[]
def moverGNU():

gnu.x=[random.randrange(-320,320)]

def tirarCopyright():

b=pilas.actores.Bomba()
b.imagen="copyright.png"
b.x=gnu.x
b.y=gnu.y
b.aprender(pilas.habilidades.RebotarComoPelota)
copyright.append(b)

pilas.mundo.agregar_tarea_siempre(1,moverGNU)
pilas.mundo.agregar_tarea_siempre(6,tirarCopyright)
pilas.ejecutar()

En el código anterior se introduce la orden copyright=[], que representa a una variable que contendrá
una lista o colección de elementos. Todas las licencias copyright que se arrojen se incorporaran a esta
lista, es decir mediante la variable copyright tenemos acceso a todas las licencias copyright que anden
rebotando por la escena del juego. La licencias copyright las instanciamos a partir del actor Bomba, y
le asignamos las misma coordenadas del ñu (variable gnu) por ser de este desde donde se desprenden.
Luego le agregamos la habilidad de rebotar como si fuesen pelotas. Finalmente incorporamos este
objeto a través del método append de la colección copyright.

Las licencias copyright fueron creadas a partir del actor Bomba con el fin que exploten al caer sobre
Tux o al tocar el suelo. Como todavía no tenemos incorporado a Tux en la escena del juego, vamos a
programar primero que cada cierto tiempo exploten como bombas las licencias copyright que están en
contacto con el piso. Lo hacemos creando un procedimiento al que llamaremos cada 5 segundos:

import pilas
import random
pilas.iniciar()
pilas.fondos.Fondo("fondo.png")
gnu=pilas.actores.Aceituna()

gnu.imagen="gnu.png"
gnu.y=150
imagen = pilas.imagenes.cargar("adelante.png")
adelante = pilas.actores.Actor(imagen)
copyright=[]
def moverGNU():

gnu.x=[random.randrange(-320,320)]

def tirarCopyright():

b=pilas.actores.Bomba()
b.imagen="copyright.png"
b.x=gnu.x
b.y=gnu.y
b.aprender(pilas.habilidades.RebotarComoPelota)
copyright.append(b)

if c.y<-210:

c.explotar()
c.eliminar()
copyright.remove(c)

def explotan():
for c in copyright:



pilas.mundo.agregar_tarea_siempre(1,moverGNU)
pilas.mundo.agregar_tarea_siempre(6,tirarCopyright)
pilas.mundo.agregar_tarea_siempre(5,explotan)
pilas.ejecutar()

El código anterior incorpora la estructura repetitiva for que se encarga de recorrer todos los
elementos de la colección copyright para acceder a cada uno de los elementos bajo el nombre de c. Por
cada uno de ellos se aplica la estructura de decisión if con el fin de determinar si está en contacto con el
piso (coordenada de y menor a -210). De cumplirse esa condición se hace explotar el logo de copyright
y se lo elimina de la colección.

Ahora es el momento de crear a nuestro jugador: Tux. Lo haremos a partir de la clase Mono, le
cambiaremos la imagen por la de Tux, lo colocaremos en -200 de la coordenada de Y, y le asignaremos
la habilidad de moverse por medio del teclado:

import pilas
import random
pilas.iniciar()
pilas.fondos.Fondo("fondo.png")
gnu=pilas.actores.Aceituna()
gnu.imagen="gnu.png"
gnu.y=150
imagen = pilas.imagenes.cargar("adelante.png")
adelante = pilas.actores.Actor(imagen)
tux=pilas.actores.Mono()
tux.imagen="tux.png"
tux.y=-200
tux.aprender(pilas.habilidades.MoverseConElTeclado)
copyright=[]
def moverGNU():

gnu.x=[random.randrange(-320,320)]

def tirarCopyright():

b=pilas.actores.Bomba()
b.imagen="copyright.png"
b.x=gnu.x
b.y=gnu.y

b.aprender(pilas.habilidades.RebotarComoPelota)
copyright.append(b)

def explotan():
for c in copyright:
if c.y<-210:
c.explotar()
c.eliminar()
copyright.remove(c)
pilas.mundo.agregar_tarea_siempre(1,moverGNU)
pilas.mundo.agregar_tarea_siempre(6,tirarCopyright)
pilas.mundo.agregar_tarea_siempre(5,explotan)
pilas.ejecutar()

Ahora que Tux se mueve debemos avisarle a pilas que nuestro Tux puede chocar con cada una de los
obstaculos que caen. Lo hacemos creando un procedimiento que involucre a Tux y la colección
copyright:

import pilas
import random
pilas.iniciar()
pilas.fondos.Fondo("fondo.png")
gnu=pilas.actores.Aceituna()
gnu.imagen="gnu.png"
gnu.y=150
imagen = pilas.imagenes.cargar("adelante.png")
adelante = pilas.actores.Actor(imagen)
tux=pilas.actores.Mono()
tux.imagen="tux.png"
tux.y=-200
tux.aprender(pilas.habilidades.MoverseConElTeclado)
copyright=[]
def moverGNU():

gnu.x=[random.randrange(-320,320)]

def tirarCopyright():

b=pilas.actores.Bomba()
b.imagen="copyright.png"
b.x=gnu.x
b.y=gnu.y
b.aprender(pilas.habilidades.RebotarComoPelota)
copyright.append(b)

pilas.mundo.agregar_tarea_siempre(1,moverGNU)
pilas.mundo.agregar_tarea_siempre(6,tirarCopyright)
pilas.mundo.agregar_tarea_siempre(5,explotan)
pilas.escena_actual().colisiones.agregar(tux,copyright,chocoCopyright)
pilas.ejecutar()

def explotan():
for c in copyright:
if c.y<-210:
c.explotar()
c.eliminar()
copyright.remove(c)
def chocoCopyright(tux,copyright):

copyright.explotar()

Anteriormente hemos incorporado a la escena actual nuestra primera colisión, los dos primeros
parámetros son los objetos que pueden colisionar y el tercer parámetro es el método que se debe
procesar cuando efectivamente choquen los objetos involucrados.

Ahora es momento de hacer que caigan