Plaataformas

En el siguiente apartado examinaremos el código del juego plataformas.

import pilasengine  #importación de todo el modulo de pilasengine

pilas = pilasengine.iniciar( ) #inicio del programa
pilas.reiniciar_si_cambia(__file__) #instrucción para tener mayor fluidez

mapa = pilas.actores.MapaTiled('plataformas.tmx', densidad=0, #instrucción para aplicar física al
restitucion=0, friccion=0, amortiguacion=0)                                  fondo del juego

caja= pilas.actores.Caja()  #importación del actor caja
caja.aprender('arrastrable') #aplicación de la habilidad arrastable al actor caja

pilas.fondos.Tarde() #instrucción para tener el fondo "Tarde"

class Protagonista(pilasengine.actores.Actor): #instrucción para crear una nueva clase llamada "Protagonista" donde determinaremos los atributos del actor 
 def iniciar(self):  #función para crear el actor aceituna
   self.imagen = "aceituna.png" #indicación de la imagen que se usara para el actor  
   self.figura= pilas.fisica.Circulo(self.x,self.y,17) #instrucción para darlle la fisica del circulo a la     aceituna
   self.figura.sin_rotacion= True #instrucción para darle al actor el atributo de sin rotación
   self.escala_de_gravedad=2  #indicación para darle una gravedad de valor 2
   self.sensor_pies=pilas.fisica.Rectangulo(self.x, self.y, 20, sensor=True, dinamica=False)
   #instrucción para que el actor al tocar el suelo, este tenga la física del rectangulo

 def actualizar(self): #función para actualizar los movimientos que hace nuestro actor 
   velocidad=10 #indicación para darle el valor de 10 a la velocidad del actor
   salto=15 #indicación para darle el valor de 15 al salto el actor
   self.x=self.figura.x #instrucción para igualar la "x" y la "y" del objeto con él de las figuras
   self.y=self.figura.y
 if self.pilas.control.derecha: #condición para el control de la derecha de la figura
   self.figura.velocidad_x=velocidad #instrucción para que la "x" de la velocidad tome el valor velocidad
   self.rotacion-=velocidad  #instrucción para quela rotación se decremente con el valor de la velocidad
 elif self.pilas.control.izquierda: #condición para el control de la izquierda de la figura
   self.figura.velocidad_x=-velocidad #instrucción para que la "x" de la velocidad tome el valor velocidad
   self.rotacion+=velocidad #instrucción para que la rotación se incremente con el valor de la velocidad
 else:
   self.figura.velocidad_x=0   #instrucción para que la "x" de la velocidad toma el valor 0 y por tanto, se para

 if self.si_esta_pisando_suelo(): #condición para cuando el actor este en el sueloo
   if self.pilas.control.arriba and (int(self.figura.velocidad_y))<=0:
     self.figura.impulsar(0,salto)  #instrucción para que si pulsamos el control arriba y el componente y de la velocidad es negativo, entonces la figura se impulsa con valores 0 y variable salto

self.sensor_pies.x=self.x  #instrucción para que valor x del sensor de pies tenga el valor x 
self.sensor_pies.y=self.y-20  #instrucción para que el valor y del sensor de pies tenga el valor y-20

 if self.si_esta_pisando_suelo(): #condición para cuando el actor esté en el suelo
  self.imagen= "aceituna.png" #instrucción para que introduzca la imagen aceituna
 else:
  self.imagen="aceituna_risa.png" #instrucción para que si no lo esta, introduzca la imagen                                                                     aceituna sonriendo

 def si_esta_pisando_suelo(self): #función para que el actor pueda pisar el suelo
   return len(self.sensor_pies.figuras_en_contacto)>0

#Programa Principal
pilas.actores.vincular(Protagonista) #vinculo del actor con la classe protagonista
prota=pilas.actores.Protagonista() #instrucción para llamar al actor protagonista

pilas.ejecutar() #instrucción para que ejecute el program

Juego Invasores con Menú

# coding: utf-8
import pilasengine

pilas = pilasengine.iniciar()
fondo = pilas.fondos.Noche() #fondo que recibirá por defecto la ventana del menú mientras se permanezca en el

def iniciar_juego(): #función que iniciará el juego cuando comience
    pilas.escenas.Normal() #cambio de fondo de pantalla que recibe el programa
    puntos = pilas.actores.Puntaje(x=-280, y=200, color=pilas.colores.blanco)
    avisar=pilas.avisar("Tete dale a las flechas y al espacio pa'jugar")   

    class PlanetaEnemigo(pilasengine.actores.Actor):
        def iniciar (self):
            self.imagen = "planeta_azul.png"
            self.escala=0.25
            self.escala =[0.5],5
            self.aprender(pilas.habilidades.PuedeExplotarConHumo)
            self.x = pilas.azar(-200,200)
            self.y=290
            self.velocidad=pilas.azar(10,40)/10.0

        def actualizar(self):
            self.rotacion+=10   
            self.y-=self.velocidad  
            if self.y <-300:
               self.eliminar

    def crear_enemigo():
        actor=PlanetaEnemigo(pilas)
        enemigo.agregar(actor)

    def fin_juego():
        texto = pilas.actores.Texto("Perdiste bro, pulsa cualquier tecla para salir")
        pilas.evento.pulsa_tecla.conectar(salir_de_juego) #definición que determina la salida del juego por parte de la función de salir_de_juego explicada más abajo al clickar en la pantalla

    def salir_de_juego(evento): #función anclada al juego
        pilas.terminar() #instrucción para terminar el juego

  #Programa principal
    pilas.fondos.Galaxia()
    enemigo=pilas.actores.Grupo()
    pilas.tareas.siempre(0.5, crear_enemigo)
    nave=pilas.actores.NaveRoja(y=-200)
    nave.aprender(pilas.habilidades.LimitadoABordesDePantalla)
    nave.definir_enemigos(enemigo,puntos.aumentar)
    pilas.colisiones.agregar(nave, enemigo, nave.eliminar)
    pilas.colisiones.agregar(nave, enemigo, fin_juego) 

def salir_del_juego(): #definición de que ocurrirá en caso de que el jugador lo seleccione en el menú principal
      pilas.terminar() #se termina pilasengine

pilas.actores.Menu( #función que determina al Menú como un actor a fin de poder agregarle elementos que aparecerán en el juego

        [
            ('Iniciar Juego', iniciar_juego), #nombre de la función que el jugador verá

            ('Salir', salir_del_juego), #nombre de la función que el jugador verá
        ])

pilas.ejecutar()

Juego Invasores

En esta ocasión, he creado con la ayuda de mi profesora y mis compañeros un juego estilo retro de una nave al puro estilo asteroids pero con un mejor diseño gráfico.

# -*- coding: utf-8

import pilasengine #se cargan todos los datos de pilasengine

pilas = pilasengine.iniciar() #iniciamos el programa

puntos=pilas.actores.Puntaje(x=-280, y=200, color=pilas.colores.blanco) #determinamos la posición y color del marcador que indicará los puntos obtenidos al jugador a lo largo de la partida

avisar = pilas.avisar("Tete, dale a las flechas y el espacio pa' jugar") #mensaje al jugador de que herramientas puede utilizar para jugar (de forma basta en mi caso)

class PlanetaEnemigo(pilasengine.actores.Actor): #instrución que determinará los parámetros de el actor PlanetaEnemigo

def iniciar(self): #función para crear el actor

self.imagen = "planeta_azul.png" #imagen que usará el actor enemigo

self.escala = 0.25 #instrucción que determina el tamaño del actor

self.escala=[0.5],5 #instrucción que aumentará el tamaño a lo largo de 5 segundos hasta llegar al punto deseado, en este caso el tamaño deseado es 0.5

self.aprender(pilas.habilidades.PuedeExplotarConHumo)#esta instrucción determina que el actor es dotado de la habilidad de explotar con humo

self.x = pilas.azar(-200,200) #instrucción que dará un valor aleatorio al actor para aparecer en la pantalla

self.y = 290 #esta instrucción determinamos que la ordenada de aparición del actor, siendo esta ordenada invariable

self.velocidad = pilas.azar(10,40)/10.0 #velocidad del actor

def actualizar(self): #función para actualizar el movimiento que hace el actor

self.rotacion+=10 #instrucción que determina la rotación del actor

self.y-=self.velocidad #instrucción para aminorar la velocidad del actor

if self.y<-300:

self.eliminar #si el actor llega a estas coordenadas es eliminado

def crear_enemigo(): #función para crear al enemigo

actor = PlanetaEnemigo(pilas) 

enemigo.agregar(actor) #instrucción que determina que el actor es un enemigo

#Programa Principal#

pilas.fondos.Galaxia() #fondo que usaremos para el juego

enemigo=pilas.actores.Grupo() #instrucción para que se creen enemigos

pilas.tareas.siempre(0.5,crear_enemigo) #tarea que hará que mientras el juego continué, se crearan enemigos

nave=pilas.actores.NaveRoja(y=-200) #localización de aparición de la nave

nave.aprender(pilas.habilidades.LimitadoABordesDePantalla) #instrucción que dota a la nave de la habilidad de no salirse de los bordes de la pantalla

nave.definir_enemigos(enemigo, puntos.aumentar) #instrucción que aumentará los puntos del jugador por cada planeta destruido, dado que no damos valor alguno se queda por defecto en 1

pilas.colisiones.agregar(nave,enemigo,nave.eliminar) #instrucción que permite las colisiones entre los asteroides y la nave, en caso de ocurrir durante la patida esta terminaria, significando el fin de la partida

pilas.ejecutar()

Mi versión del Juego

Vengo a explicar los cambios realizados en el juego de disparar a monos. En mi caso me he decantado por una versión respetuosa con el reino animal y en vez de disparar a monos, tratará de disparar a manzanas.

#! /usr/bin/env python

# -*- coding: utf-8 -*-

import pilasengine #Esta acción carga todos los componentes de pilasegine

import random #Esta acción carga las variables que se darán aleatoriamente

pilas = pilasengine.iniciar() #Aquí iniciamos el programa

#Variables y Constantes#

fin_de_juego=False #Esta variable mientras este en "False" el juego NO acabará

balas_simples = pilasengine.actores.Bala #Aquí cargamos el actor de las balas

manzana = [] #Esta constante no determina el límite de manzanas que pueden 

estar simultáneamente en el juego

tiempo= 6 #Inicia la variable tiempo

#Definiciones#

def manzana_destruido(disparo, enemigo): #Función que determina que elimina a un mono y que ocurrirá, en este caso aumentará los puntos del jugador si el actor balas impacta a los enemigos

  enemigo.eliminar()

  disparo.eliminar()

  puntos.escala = 0

  puntos.escala = pilas.utils.interpolar(puntos, 'escala', 1, duracion=0.5)

  puntos.aumentar(1)

def crear_manzana(): #En esta función determinaremos los parámetros de creación de las manzanas. Estas las saque de pilasengine y les añadí las habilidades de explotar y de que no puedan salir de la pantalla. Juntamente ajuste el espectro de los valores para la aparición de las mismas con la intención de que el jugador pueda ver en todo momento donde están las manzanas. Además cambie el tiempo que lleva el crecimiento de estas al crearse utilizando interpolar. En cuanto a lo demás no he realizado ningún otro cambio en cuanto a la distancia mínima de la aparición de las manzanas o a que mientras no se acabe el juego las manzanas seguirán apareciendo

enemigo = pilas.actores.Manzana()

enemigo.escala = 0

enemigo.escala =pilas.utils.interpolar(enemigo, 'escala', 0.5, duracion=3)

enemigo.aprender(pilas.habilidades.PuedeExplotar)

enemigo.aprender(pilas.habilidades.LimitadoABordesDePantalla)

x = random.randrange(-250, 250)

y = random.randrange(-200, 200)

if x >= 0 and x <= 100:

x = 180

elif x <= 0 and x >= -100:

x = -180

if y >= 0 and y <= 100:

y = 180

elif y <= 0 and y >= -100:

y = -180

enemigo.x = x

enemigo.y = y

a=random.randrange(-250, 250)

b=random.randrange(-200, 200)

enemigo.x = [a, b], 1

enemigo.y = [b, a], 1

manzana.append(enemigo)

if fin_de_juego:

return False

else:

return True

def perder(torreta, enemigo):  #Función que determinara el fin del juego

global fin_de_juego

torreta.eliminar()

pilas.tareas.eliminar_todas()

fin_de_juego = True

pilas.avisar("FIN has conseguido %d puntos, ahora a estudiar" % (puntos.obtener()))

#Aquí aparecerá el mensaje resultante al terminar el juego

#Programa Principal#

fondo = pilas.fondos.Fondo() #Instrucción determina que usaremos un fondo

fondo.imagen = pilas.imagenes.cargar('huerto.jpg') #Aqui el fondo que usaremos, en mi caso uso un huerto muy bonito

pilas.actores.Sonido() #instrucción que carga los sonidos de pilasengine

pilas.ejecutar()

torreta = pilas.actores.Torreta(municion_bala_simple=balas_simples,

enemigos=manzana,

cuando_elimina_enemigo=manzana_destruido)

#Instrucción en la que ajustamos el actor torreta, su munición y quienes son sus enemigos sus parámetros

puntos = pilas.actores.Puntaje(x=-230, y=200, color=pilas.colores.violeta)

puntos.magnitud = 40

#Esta instrucción determina la ubicación del marcador y su color, en mi caso violeta para contrastar y hacerlo visible con el fondo

pilas.colisiones.agregar(torreta, manzana, perder) #Instrucción que permite la colisión entre las manzanas y la torreta

pilas.tareas.agregar(1, crear_manzana) #Tarea que determina el funcionamiento de la función manzana, así pues, hasta que el jugador pierda, se crearán manzanas

Función Perder

Ahora, el último paso a seguir será determinar cuando acaba. El fin del juego se dará cuando un mono colisione con la torreta esta desaparecerá, y esto significará que el juego se ha acabado. A esto también le añadiremos un mensaje en el cual aparezca la cantidad de puntos logrados junto con un mensaje bien grande de que el juego esta acabado.

def perder(torreta, enemigo):

# Indicar fin de juego y eliminar lo que ya no se necesita

global fin_de_juego

enemigo.sonreir()

torreta.eliminar()

pilas.tareas.eliminar_todas()

fin_de_juego = True

pilas.avisar("GAME OVER. Conseguiste %d puntos" % (puntos.obtener()))

Dado que el juego se ha acabado todos los procesos que se estaban dando lugar terminarán. Y para frustrar al jugador a fin de que lo vuelva a intentar los monos sonreirán en forma de burla.

Mono Destruido

A continuación determinaremos los parámetros que permitirán la destrucción del mono y la puntuación por ello.

# Eliminar el mono alcanzado

enemigo.eliminar() 
disparo.eliminar()

# Actualizar el marcador con un efecto bonito

puntos.escala = 0

puntos.escala = pilas.utils.interpolar(puntos, 'escala', 1, duracion=0.5)

puntos.aumentar(1)

En primer lugar esta instrucción determina que elimina al enemigo.
enemigo.eliminar()

Esta, determina que son los disparos los encargados de eliminar a los enemigos.
disparo.eliminar()

Las siguientes instrucciones aumentarán los puntos del marcador a medida que los monos son destruidos, estableciendo así una meta al juagador.

puntos.escala = 0

puntos.escala = pilas.utils.interpolar(puntos, 'escala', 1, duracion=0.5)

puntos.aumentar(1)

Agregar Tarea

pilas.tareas.agregar(1, crear_mono)

Este es el siguiente paso a seguir. Gracias a este comando seremos capaces de crear un mono cada segundo. El cual es la base del juego (pues va de disparar a monos). Ahora quedaría destruirlos y determinar que ocurre cuando se pierde.

Crear Mono

a. Cada vez que se llame, hay que crear un nuevo mono; eso es lo que hacemos utilizando el 
 módulo pilas.actores y almacenándolo en la variable local enemigo para su uso. Fíjate que 
no queremos que simplemente aparezca, si no que lo haga con un efecto vistoso. Explica 
qué dos líneas de código realizan dicha acción.

enemigo.escala = 0

enemigo.escala =pilas.utils.interpolar(enemigo, 'escala', 0.5, duracion=5)

En estas dos líneas observamos como estamos definiendo el tamaño del mono. Al principio 
 este aparece como 0, es decir, sin tamaño e invisible para el jugador. Esto se hace para 
después, mediante "interpolar" aumente de tamaño gradualmente hasta un punto y en un
 tiempo determinados.

2. Las siguientes líneas, generan las coordenadas x e y del enemigo creado para situarlo
   en una posición aleatoria en la ventana. Para ello hemos utilizado la función randrange()
    que devuelve un número al azar entre los dos dados. ¿Podrías decir que módulo hemos
    importado en Python para poder usar la función? 
   x = random.randrange(-320, 320)

   y = random.randrange(-240, 240)

   
   

    La función es import randmon, al igual que al comienzo del programa se utiliza import 

   pilasengine es en esencia el conjunto de significados que recibirán posteriores instrucciones.
3. Además, para evitar que el enemigo aparezca demasiado cerca de la torreta y haga el 
   juego imposible, si las coordenadas generadas son menores de 100, se le aleja una 
   distancia de 180. Analiza el código que hace posible esta acción en una entrada de tu blog.
   
   if x >= 0 and x <= 100:

   x = 180

   elif x <= 0 and x >= -100:

   x = -180

   
   

   if y >= 0 and y <= 100:

   y = 180

   elif y <= 0 and y >= -100:

   y = -180

   Pues básicamente como podemos observar en este código se determina que si los valores
   dados tanto a x como a y se encuentran en los parámetros deseados estos recibirán otro,
    también previamente determinados. Esto es para no poder imposibilitar al jugador, pues, 
   si estos recibiesen valores cercanos al de la torreta supondría una más rápida derrota.
   

d. Finalmente, actualizamos la posición del mono modificando enemigo.x y enemigo.y.  
¿Cuales son las instrucciones que realizan esta acción? 

        enemigo.x = x
          enemigo.y = y

En estas instrucciones nos podemos percatar que se trata del lugar en los que apareceran los
enemigos. Pues, una vez ya se han concretado la ubicación, esta instrucción es la confirmación 
de que aparezcan. 

Class Sonido

def iniciar(self, x=0, y=0): #se inicia el juego y el objeto es situado en una posición

self.x = x concreta, esta obviamente es modificable

self.y = y

self.ruta_normal = 'iconos/sonido_on.png' #ruta para abrir el archivo en su estado normal

self.ruta_press = 'iconos/sonido_off.png' #ruta para abrir el archivo en función de si se 
aprieta un botón o no

self.imagen = self.ruta_normal #ruta para abrir el archivo de la imágen

self.radio_de_colision = 15 #determinación de el espacio del que dispone un objeto 
para su interacción con otros

self.cuando_hace_click = self.cuando_pulsa #cuando el usuario pulsa el botón uno del ratón se considerará de una determinada manera, en este caso se considerará pulsar

# Colocamos el boton en la esquina inferior derecha de la pantalla.

self._ancho_mundo, self._alto_mundo = self.pilas.widget.obtener_area()

self.x = (self._ancho_mundo / 2) - self.ancho

self.y = -1 * (self._alto_mundo / 2) + self.alto
#determinación de la ubicación del botón de sonido

self.activado = True #esta activado de base el botón anterior

def cuando_pulsa(self): #esta acción determina que el botón ha 
sido pulsado y pasa al modo contrario

"""Alterna entre sonido habilitado o deshabilitado."""

if self.activado:

self.pilas.deshabilitar_musica() #instrucciones de las acciones que desactivan la musica

self.pilas.deshabilitar_sonido() y el sonido

self.imagen = self.ruta_press #imagen del botón que aparecerá indicando que no hay sonido

self.pilas.avisar("Sonido deshabilitado") #se avisa de que ha desactivado el volumen

self.activado = False #determinación del estado de la acción

else:

self.pilas.deshabilitar_musica(estado=False) #se desactivan las funciones de la acción

self.pilas.deshabilitar_sonido(estado=False) por lo tanto se activan la musica y el sonido

self.imagen = self.ruta_normal #la imágen pasará a indicar que hay sonido

self.pilas.avisar("Sonido habilitado") #se avisa de que ha activado el volumen

self.activado = True #determinación del estado de la acción