Menú invasores

# coding: utf-8

En esta linea decimos la importación de todo el código de pilasengine.

import pilasengine

Iniciamos el programa de pilasengine.

pilas = pilasengine.iniciar()

Indicamos que el fondo es selva

fondo = pilas.fondos.Selva()

Definimos el inicio del juego.

def iniciar_juego():

Esta linea indica que el fondo de pilas es normal.

pilas.escenas.Normal()

puntos = pilas.actores.Puntaje(x=-280, y=200, color=pilas.colores.cyan)

avisar=pilas.avisar("Pulsa el espacio del teclado para disparar")

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)

Función que indica el final del juego, que tendremos que definir.

def fin_juego():

Esta linea indica que el juego ha terminado y que pulse cualquier tecla para salir.

texto = pilas.actores.Texto("Has perdido, Pulsa una tecla para salir")

Esta linea va ligada a la anterior, ya que esta saldrá del juego mediante la función salir_de_juego.

pilas.evento.pulsa_tecla.conectar(salir_de_juego)

Definiremos la función para salir del juego como he dicho anteriormente.

def salir_de_juego(evento):

Finalmente, esta indicara el fin del juego.

pilas.terminar()

#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():

pilas.terminar()

Mediante el menú podemos realizar una lista, donde el primer elemento es la cadena de texto que queremos mostrar.

pilas.actores.Menu(

El segundo elemento son las siguientes dos funciones.

[

('iniciar juego', iniciar_juego),

('salir', salir_del_juego),

])

Por ultimo, indicamos que el programa pilasengine se debe ejecutar.

pilas.ejecutar()

JUEGO DE DISPAROS

Escribe una entrada en tu blog en la que expliques los cambios que has realizado en el programa para codificar JUEGO DE DISPAROS.

#! /usr/bin/env python

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

import pilasengine

import random

pilas = pilasengine.iniciar()

En primer lugar, he cambiado las variables del actor y le he indicado que el tipo de bala sea misil.

# Variables y Constantes

balas_simples = pilasengine.actores.Misil

Creamos un nuevo enemigo, los cuales no están determinados.

Nave = []

tiempo=6

fin_de_juego=False

# Funciones

def Nave_destruida(disparo, enemigo):

# Eliminar la nave alcanzada

enemigo.eliminar()

disparo.eliminar()

# Actualizar el marcador con un efecto bonito

puntos.escala = 1

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

puntos.aumentar(1)

def crear_Nave():

Indicamos que el nuevo enemigo son  Naves.
# Crear un enemigo nuevo

enemigo = pilas.actores.Nave()

Estas linea hace que la transición dure 5 segundo hasta llegar a escala 3
# Hacer que se aparición sea con un efecto bonito

enemigo.escala = 2

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

# Dotarle de la habilidad de que explote al ser alcanzado por un disparo

enemigo.aprender(pilas.habilidades.PuedeExplotar)

# Situarlo en una posición al azar, no demasiado cerca del jugador

x = random.randrange(270, 320)

y = random.randrange(-190, 240)

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(-320, 320)

b=random.randrange(-1000, 1000)

enemigo.x = [a, b], 1

enemigo.y = [b, a], 1

# Añadirlo a la lista de enemigos

Nave.append(enemigo)

# Permitir la creación de enemigos mientras el juego esté en activo

if fin_de_juego:

return False

else:

return True

def perder(Planeta, enemigo):

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

global fin_de_juego

Planeta.eliminar()

pilas.tareas.eliminar_todas()

fin_de_juego = True

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

Indicamos un nuevo fondo, Espacio.

# Usar un fondo estándar

pilas.fondos.Espacio()

# Añadir un marcador

puntos = pilas.actores.Puntaje(x=-240, y=-220, color=pilas.colores.verde)

puntos.magnitud = 40

# Añadir el conmutador de Sonido

pilas.actores.Sonido()

# Añadir la torreta del jugador

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

enemigos=Nave,

cuando_elimina_enemigo=Nave_destruida)

# Crear un enemigo cada segundo

pilas.tareas.agregar(1, crear_Nave)

# Añadir la colisión de enemigos con la torreta para finalizar el juego

pilas.colisiones.agregar(Torreta, Nave, perder)

# Arrancar el juego

pilas.ejecutar()

Invasores

#! /usr/bin/env python

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

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 que 

devuelve un número al azar entre los dos dados.

import pilasengine

import random

Las siguientes líneas indican que el programa tiene que iniciar. La siguiente indica la coordenada donde se sitúa el marcador y también indica el color.

La última pondrá en la pantalla que se tendra que pulsar los cursores del teclado para dispar.

pilas = pilasengine.iniciar()

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

avisar=pilas.avisar("Pulsa los cursores del teclado para disparar")

pilas.ejecutar()

Este código indica que el actor Planeta sera el enemigo. Por tanto habrá que definir una serie de atributos que tendrá este actor.

class PlanetaEnemigo(pilasengine.actores.Planeta):

def iniciar(self):

Indica que la imagen del actor es planeta azul. 

self.imagen = "planeta_azul.png" #carpeta pilasengine/data

También la escala que tiene este actor. 

self.escala = 0.25

self.escala = [0.5], 5

Le indicamos que tenga la habilidad de explotar cuando sea alcanzado. 

self.aprender( pilas.habilidades.PuedeExplotarConHumo )

Estas ultimas indican la coordenada en que se situara.

self.x = pilas.azar(-200, 200)

self.y = 290

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

La siguiente indicara que el actor planeta podrá rotar y tendrá una velocidad.

def actualizar(self):

self.rotacion += 10

self.y -= self.velocidad

Esta eliminara el actor cuando se salga de la pantalla.
# Elimina el objeto cuando sale de la pantalla.

if self.y < -300:

self.eliminar()

def crear_enemigo():

actor= PlanetaEnemigo(pilas)

enemigos.agregar(actor)

#Programa principal

Indicara que el fondo es Galaxia

pilas.fondos.Galaxia()

Esta linea indica que el actor sera un grupo.

enemigos= pilas.actores.Grupo()

pilas.tareas.siempre(0.5,crear_enemigo)

Situara a la nave en una coordenada concreta.
nave=pilas.actores.NaveRoja(y=-200)

Esta indica que la nave no saldrá de los bordes.

nave.aprender(pilas.habilidades.LimitadoABordesDePantalla)

Se ira aumentando el marcador cada vez que se mate a un enemigo y este se eliminara.
nave.definir_enemigos(enemigos,puntos.aumentar)

pilas.colisiones.agregar(nave,enemigos,nave.eliminar)

pilas.ejecutar()