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. 

Torreta

1. ¿Cuál es el motivo por el que se utiliza la instrucción pilasengine.actores.Bala?
   Para así utilizar una representación de la bala, dando lugar a una posterior customización de la 
   misma. Pudiéndose modificar la velocidad de la misma, tamaño, cuantas son disparadas e 
   inclusive introduciendo mecánicas como el daño que hacen.
2. ¿Por qué se representa la variable monos como una lista vacía?
    Se presenta vacía pues aún no se sabe como será
3. ¿Para qué se utiliza la función mono_destruido?
   Para indicar que ocurre cuando una bala impacta a un mono
4. Cuando se añade la torreta del jugador, explica los parámetros que se pasan, y porque se utiliza
   mono_destruido en lugar de enemigo_destruido()
   Para así pasarle como hacer la función y no el resultado de hacerla