def _iniciar_pilas(self): pilas = pilasengine.iniciar(640, 400) pilas.definir_iniciado_desde_asistente(True) scope = {"pilas": pilas, "self": self, "colores": pilasengine.colores, "pilasengine": pilasengine} self.canvas.addWidget(pilas.widget) return scope
def _iniciar_pilas(self): pilas = pilasengine.iniciar(640, 400) pilas.definir_iniciado_desde_asistente(True) scope = {'pilas': pilas, 'self': self, 'colores': pilasengine.colores, 'pilasengine': pilasengine} self.canvas.addWidget(pilas.widget) return scope
def main(): app = QtGui.QApplication(sys.argv) ventana = VentanaAsistente() # similar a la funcion "iniciar" pero simplemente # arma el widget para utilizar dentro de una aplicacion. pilas = pilasengine.iniciar() widget_de_pilas = pilas.obtener_widget() ventana.agregar_widget(widget_de_pilas) widget_de_pilas.show() pilas.actores.Aceituna() sys.exit(app.exec_())
def _insertar_ventana_principal_de_pilas(self): pilas = pilasengine.iniciar(640, 400) pilas.definir_iniciado_desde_asistente(True) scope = {'pilas': pilas, 'self': self, 'pilasengine': pilasengine } ventana = pilas.obtener_widget() self.cargando = QtGui.QLabel("Cargando ...") self.cargando.setAlignment(QtCore.Qt.AlignHCenter | QtCore.Qt.AlignVCenter) self.canvas.addWidget(self.cargando) self.canvas.setCurrentWidget(self.cargando) self.ventana_pilas = ventana self.stimer = QtCore.QTimer() return scope
# -*- encoding: utf-8 -*- import random import pilasengine pilas = pilasengine.iniciar() pilas.reiniciar_si_cambia(__file__) teclas2 = { pilas.simbolos.a: 'izquierda', pilas.simbolos.d: 'derecha', pilas.simbolos.w: 'arriba', pilas.simbolos.s: 'abajo', pilas.simbolos.CTRL: 'boton', } class Municion1(pilasengine.actores.Actor): def iniciar(self): self.imagen=pilas.imagenes.cargar_grilla("disparo.png", 2) class Municion2(pilasengine.actores.Actor): def iniciar(self): self.imagen=pilas.imagenes.cargar_grilla("disparo.png", 2) class Tanque1(pilasengine.actores.Actor): def iniciar(self): self.aprender("LimitadoABordesDePantalla") self.aprender("PuedeExplotar")
restitucion=1, friccion=0, amortiguacion=0) self.imitar(self.circulo) self._empujar() def _empujar(self): self.circulo.impulsar(2, 2) def cuando_colisionan(aceituna, bomba): bomba.explotar() pilas = pilasengine.iniciar(gravedad=(0, 0)) protagonista = pilas.actores.Aceituna() protagonista.aprender(pilas.habilidades.SeguirAlMouse) pilas.mundo.motor.ocultar_puntero_del_mouse() bomba_1 = BombaConMovimiento(pilas) bomba_2 = BombaConMovimiento(pilas, x=200, y=0) bomba_3 = BombaConMovimiento(x=0, y=200) lista_de_bombas = [bomba_1, bomba_2, bomba_3] pilas.mundo.colisiones.agregar(protagonista, lista_de_bombas, cuando_colisionan) pilas.ejecutar()
#!/usr/bin/env python # -*- coding: utf-8 -*- import pilasengine import os from System.Modulos import menu_ppal from System.Modulos import historia from System.Modulos import acciones from System.Modulos import menu_decision from System.Modulos import puntuacion from System.Modulos import escena from System.Modulos.Actores import Protagonista pilas = pilasengine.iniciar(ancho=1000, alto=700) def vincular_comportamientos(): pilas.comportamientos.vincular(acciones.correr) pilas.comportamientos.vincular(acciones.caminar) pilas.comportamientos.vincular(acciones.posicionar) pilas.comportamientos.vincular(acciones.salto) pilas.comportamientos.vincular(acciones.volverse_loco) pilas.comportamientos.vincular(acciones.reir) pilas.comportamientos.vincular(acciones.llorar) pilas.comportamientos.vincular(acciones.seguir_a) pilas.comportamientos.vincular(acciones.sonar) pilas.comportamientos.vincular(acciones.hablar_infinitivo) pilas.comportamientos.vincular(acciones.hablar_normal) pilas.comportamientos.vincular(acciones.escalar_actor) pilas.comportamientos.vincular(acciones.empujar) pilas.comportamientos.vincular(acciones.rodar_hacia)
def setUp(self): self.pilas = pilasengine.iniciar()
import pilasengine import sys pilas = pilasengine.iniciar() pizarra = pilas.actores.Pizarra() def dibujar_en_la_pizarra(evento): pizarra.dibujar_punto(evento.x, evento.y, pilas.colores.negro) pilas.escena_actual().mueve_mouse.conectar(dibujar_en_la_pizarra) pilas.avisar("Usa el mouse para dibujar circulos.") pilas.ejecutar()
def setUp(self): self.pilas = pilasengine.iniciar(modo_test=True)
# coding: utf-8 import pilasengine from settings import * pilas = pilasengine.iniciar(2900, 800) class MM(pilasengine.actores.Actor): def iniciar(self): self.imagen = SMALL_IMG_DIR+'/eslabon.png' # self.figura = pilas.fisica.Rectangulo( # alto=self.imagen.alto(),ancho=self.imagen.ancho(), # friccion=0,restitucion=0,dinamica=1) def actualizar(self): pilas.fisica.gravedad_y = -10 # if self.y > -100: # self.figura.rotacion = 35 # self.x = self.figura.x # self.y = self.figura.y # self.rotacion = self.figura.rotacion if self.pilas.control.izquierda: self.figura.velocidad_x = -2 if self.pilas.control.derecha: self.figura.velocida_x = 2 class MM2(pilasengine.actores.Actor): def iniciar(self, x, y, sigue): self.x = sigue.x + 10 self.sigue = sigue self.figura = pilas.fisica.Circulo()
def setUp(self): self.pilas = pilasengine.iniciar(modo_test=True) self.pilas.actores.vincular(TestActoresPersonalizados.MiActor)
# -*- coding:utf-8 -*- # !/usr/bin/env python """ Autor: @Statick_ds Objetivo del Juego: Atrapar la mayor cantidad de Tortas de Jamon que caen y evitar tocar las fotografias de la Bruja del 71 """ # Importamos la Biblioteca de Pilas-Engine y el módulo random import random import sys import pilasengine # Iniciando PilasEngine en un sola variable para facilitar la programación pilas = pilasengine.iniciar(800, 490) try: pilas.reiniciar_si_cambia(sys.argv[0]) except OSError: pilas.reiniciar_si_cambia(__file__) # Declarando la clase Chavo class Chavo(pilasengine.actores.Actor): # Creando la función iniciar del actor chavo def iniciar(self): self.imagen = "data/chavo.png" self.y = -144
from escenas.menuPrincipal import MenuPrincipal from escenas.configurar import Configurar from escenas.elegirColor import ElegirColor from escenas.conectarseAlServidor import ConectarseAlServidor from escenas.pantallaJuego import PantallaJuego from escenas.menuPromocion import MenuPromocion from escenas.menuDesafios import MenuDesafios from escenas.desafioSuperado import DesafioSuperado from escenas.desafio import Desafio from escenas.modoJuego import ModoJuego from escenas.creditos import Creditos from escenas.ganasteLosDesafios import GanasteLosDesafios # iniciamos: pilas = pilasengine.iniciar(ancho=1024,alto=768, titulo='pydrez 1.1 - alpha', capturar_errores=False, habilitar_mensajes_log=False) pilas.forzar_habilitacion_de_audio() # vinculamos las pantallas: pilas.escenas.vincular(MenuPrincipal) pilas.escenas.vincular(Configurar) pilas.escenas.vincular(ElegirColor) pilas.escenas.vincular(ConectarseAlServidor) pilas.escenas.vincular(PantallaJuego) pilas.escenas.vincular(MenuPromocion) pilas.escenas.vincular(MenuDesafios) pilas.escenas.vincular(Desafio) pilas.escenas.vincular(DesafioSuperado) pilas.escenas.vincular(ModoJuego) pilas.escenas.vincular(Creditos) pilas.escenas.vincular(GanasteLosDesafios)
# -*- coding: utf-8 -*- import pilasengine from pantallas import ANCHO, ALTO from pantallas import PantallaInicial, PantallaJuego # crea una instancia del motor de pilas pilas = pilasengine.iniciar(ancho=ANCHO, alto=ALTO) # añade las escenas al gestor de escenas pilas.escenas.vincular(PantallaInicial) pilas.escenas.vincular(PantallaJuego) # seleccionar la escena inicial pilas.escenas.PantallaInicial() # correr motor ya configurado pilas.ejecutar()
#! /usr/bin/env python from ChessBoard import ChessBoard import pilasengine import virtkeyboard import OpeningBook TCASILLA = 80 pilas = pilasengine.iniciar(titulo='ChessBoard Client', ancho=1024, alto=TCASILLA * 8) tCasilla = 80 class Pieza(pilasengine.actores.Actor): def iniciar(self, tipo="p", color=0, fila=0, columna=0): def mainLoop(self): pieces = {} chess = ChessBoard() board = chess.getBoard() turn = chess.getTurn() libro_activo = True libro_overwrite = False
import pilasengine from config import PILAS_SCREEN_X, PILAS_SCREEN_Y from actores import MiMono, MiBomba from colisiones import jugador_choca_bomba from utilidades import crear_bombas if __name__ == "__main__": # Inicio el motor pilas-engine pilas = pilasengine.iniciar(ancho=PILAS_SCREEN_X, alto=PILAS_SCREEN_Y, pantalla_completa=True) # pilas.definir_pantalla_completa(True) # Esc / Alt + f pilas.actores.vincular(MiBomba) pilas.actores.vincular(MiMono) mono = pilas.actores.MiMono() bombas = pilas.actores.Grupo() pilas.colisiones.agregar(mono, bombas, jugador_choca_bomba) pilas.tareas.siempre(2, crear_bombas, bombas, pilas.actores.MiBomba) pilas.ejecutar()
# coding: utf-8 import pilasengine from ruedolph import Ruedolph pilas = pilasengine.iniciar(alto=900,ancho=1600) pilas.actores.vincular(Ruedolph) ruedolph = Ruedolph(pilas) c = pilas.fisica.Circulo(y=-300, x=-748, radio=50, amortiguacion=0,restitucion=0,) ruedolph.imitar(c) xs = [] #for i in range(0,30): # xs.append(pilas.fisica.Rectangulo(ancho=200,alto=2, y=-190-20*i, x=500-150*i, # plataforma=1, dinamica=False,amortiguacion=1)) for i in range(-30,9): xs.append(pilas.fisica.Rectangulo(ancho=40,dinamica=0,plataforma=1,amortiguacion=1, x=i*25-150,y=i*5-290)) for j in range(1,40): xs.append(pilas.fisica.Rectangulo(ancho=40,dinamica=0,plataforma=1,amortiguacion=1, x=j*25,y=j*-5-245)) pilas.fisica.definir_gravedad_y(-100) pilas.ejecutar()
#coding: utf-8 from __future__ import division import pilasengine from settings import IMG_DIR from movimientos import * from circulo_personalizado import Mi_Circulo import math import pickle from coordenadas import * # GLOBAL en_colision = False pilas = pilasengine.iniciar(2000, 1080, pantalla_completa=False) SMALL_IMG_DIR = IMG_DIR + 'mapa-chico-separado/' cam = pilas.camara class Ruedolph(pilasengine.actores.Actor): def iniciar(self): self.imagen = SMALL_IMG_DIR + 'ruedolph.png' self.radio_de_colision = 20 self.figura = pilas.fisica.Circulo(-780,-389, 50, friccion=0, restitucion=0, dinamica=1) self.figura_encaje = pilas.fisica.Circulo(self.x, self.y, 20, friccion=0, restitucion=0, dinamica=0, sensor=1) self.imantado = False self.se_puede_mover = False self.figura.sin_rotacion = True self.figura.escala_de_gravedad = 3
def setUp(self): import pilasengine self.pilas = pilasengine.iniciar()
import pilasengine from escena.JuegoTerminado import PantallaJuegoTerminado from escena.pantallaDeJuego import PantallaJuego from actor.jugador import Jugador from actor.enemigo import Enemigo from actor.powerUp import PowerUp from actor.golpe import Golpe from actor.pinche import Pinche pilas = pilasengine.iniciar(titulo='Crystal - alpha', habilitar_mensajes_log=False) pilas.escenas.vincular(PantallaJuegoTerminado) pilas.escenas.vincular(PantallaJuego) pilas.actores.vincular(Jugador) pilas.actores.vincular(Enemigo) pilas.actores.vincular(PowerUp) pilas.actores.vincular(Pinche) pilas.actores.vincular(Golpe) pilas.escenas.PantallaJuego(pilas=pilas) pilas.ejecutar()
#!/usr/bin/env python # coding: utf-8 import pilasengine #from protagonista import * from settings import IMG_DIR pilas = pilasengine.iniciar(ancho=1600, alto=900) class Ruedolph(pilasengine.actores.Actor): def iniciar(self): self.imagen = IMG_DIR + "ruedolph_small.png" self.figura = pilas.fisica.Circulo(self.x, self.y, 50, friccion=0, restitucion=0,dinamica=1) self.figura.sin_rotacion = True self.figura.escala_de_gravedad = 3 self.sensor_pies = pilas.fisica.Rectangulo(self.x, self.y, 30, 5, sensor=True, dinamica=False,restitucion=0,amortiguacion=0) def actualizar(self): velocidad = 10 salto = 125 self.x = self.figura.x self.y = self.figura.y if self.pilas.control.derecha: self.figura.velocidad_x = velocidad self.rotacion -= velocidad
def agregar_widget(self): self.pilas = pilasengine.iniciar() widget_de_pilas = self.pilas.obtener_widget() self.canvas.addWidget(widget_de_pilas) self.canvas.setCurrentWidget(widget_de_pilas) widget_de_pilas.show()
# -*- encoding: utf-8 -*- import pilasengine import escena_menu pilas = pilasengine.iniciar(titulo="Tres en raya") pilas.escenas.definir_escena(escena_menu.EscenaMenu(pilas)) pilas.ejecutar()
# -*- encoding: utf-8 -*- import pilasengine pilas = pilasengine.iniciar(titulo="alpha test") try: pilas.forzar_habilitacion_de_audio() except AttributeError: print("Omitiendo forzar la inicializacion, version anterior a 1.4.8") music = pilas.musica.cargar("audio/rayman.ogg") class MonoConControles(pilasengine.actores.mono.Mono): def iniciar(self): self.imagen = "mono.png" self.sonido = pilas.sonidos.cargar('audio/tick.wav') def actualizar(self): if self.pilas.escena_actual().control.arriba: self.y += 2 self.sonido.reproducir() elif self.pilas.escena_actual().control.abajo: self.y -= 2 self.sonido.reproducir() if self.pilas.escena_actual().control.izquierda: self.x -= 2 self.sonido.reproducir() elif self.pilas.escena_actual().control.derecha: self.x += 2
# coding: utf-8 import pilasengine from settings import * pilas = pilasengine.iniciar(2900, 800) class MM(pilasengine.actores.Actor): def iniciar(self): self.imagen = SMALL_IMG_DIR + '/eslabon.png' # self.figura = pilas.fisica.Rectangulo( # alto=self.imagen.alto(),ancho=self.imagen.ancho(), # friccion=0,restitucion=0,dinamica=1) def actualizar(self): pilas.fisica.gravedad_y = -10 # if self.y > -100: # self.figura.rotacion = 35 # self.x = self.figura.x # self.y = self.figura.y # self.rotacion = self.figura.rotacion if self.pilas.control.izquierda: self.figura.velocidad_x = -2 if self.pilas.control.derecha: self.figura.velocida_x = 2 class MM2(pilasengine.actores.Actor):
# coding: utf-8 import pilasengine import gameScene import menuScene import endScene pilas = pilasengine.iniciar(ancho=1280, alto=720) pilas.escenas.vincular(GameScene) pilas.escenas.vincular(MenuScene) pilas.escenas.vincular(EndScene) gameScene = pilas.escenas.MenuScene() gameScene.ejecutar()
import pilasengine # Permite que este ejemplo funcion incluso si no has instalado pilas. import sys sys.path.insert(0, "..") pilas = pilasengine.iniciar(capturar_errores=False) pilas.depurador.definir_modos(True, posiciones=True, puntos_de_control=True, fisica=True) pilas.avisar("Usa el mouse para mover al mono y ayudarlo a comer.") # Creamos al mono que se puede arrastrar con el mouse mono = pilas.actores.Mono() mono.aprender(pilas.habilidades.Arrastrable) mono.z = 1 pelotas = pilas.actores.Pelota() * 3 # Creamos las bananas y las colocamos en una lista. b1 = pilas.actores.Banana() b1.x = 200 b2 = pilas.actores.Banana() b2.y = 200 b3 = pilas.actores.Banana() b3.y = -200 b2.aprender(pilas.habilidades.RebotarComoPelota)
# -*- coding: utf-8 -*- ''' Created on 14 nov. 2017 Cuando tu juego crece, comienza la necesidad de crear tus propios actores, darles personalidad y lograr funcionalidad personalizada. En base a los actores prediseñados de pilas, vamos a crear nuestros propios actores para utilizar en el juego disparar monos. @author: Ruiz Jose ''' import pilasengine import random pilas = pilasengine.iniciar(ancho=800, alto=600, titulo="Disparar Monos") from pilasengine.actores.torreta import Torreta class Protagonista(Torreta): def iniciar(self, municion_bala_simple=None, enemigos=[], cuando_elimina_enemigo=None, x=0, y=0, frecuencia_de_disparo=10): Torreta.iniciar(self, municion_bala_simple, enemigos, cuando_elimina_enemigo, x, y, frecuencia_de_disparo) self.imagen = "../data/imagenes/tanque2.png" self.aprender("PuedeExplotarConHumo")
# GNU General Public License for more details. # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 # Importamos la libreira de PySerial import serial # Permite que este ejemplo funcion incluso si no has instalado pilas. import sys sys.path.insert(0, "..") import pilasengine pilas = pilasengine.iniciar(ancho=438, alto=360, titulo='Control ROBOT T-2') # Abrimos el puerto del arduino a 9600 PuertoSerie = serial.Serial('/dev/ttyACM0', 9600) # Cargo el fondo fondo = pilas.fondos.Fondo('mifondo.png') class ecu(pilasengine.actores.Actor): def iniciar(self): animacion = pilas.imagenes.cargar_animacion('grilla_ecualizador.png', 7) animacion.definir_animacion('andando', [1,2,3,4,5,6], 10) animacion.definir_animacion('parado', [0], 0)
# -*- encoding: utf-8 -*- import pilasengine pilas = pilasengine.iniciar(titulo='Reloj') paso_un_segundo = pilas.evento.Evento(['x', 'y']) class RelojDigital(pilasengine.actores.ActorInvisible): def iniciar(self): self.color = pilas.colores.negro self.contador = 0 self.y = -100 self.x = -10 self.actor_texto = self.pilas.actores.Texto(cadena_de_texto='') def avanzar_segundero(self, evento): self.contador += 1 self.actor_texto.texto = str(self.contador) class RelojAnalogico(pilasengine.actores.Actor): def iniciar(self): self.imagen = 'flecha.png' self.centro = ("izquierda", "centro") self.rotacion = 90 def avanzar_segundero(self, evento): self.rotacion -= 360 / 60 pass
# -*- encoding: utf-8 -*- # Permite que este ejemplo funcion incluso si no has instalado pilas. import sys sys.path.insert(0, "..") import pilasengine pilas = pilasengine.iniciar(ancho=624, alto=480, audio='phonon') class Pastilla(pilas.actores.Actor): def __init__(self, x, y): pilas.actores.Actor.__init__(self, "pastilla_1.png", x - 12, y - 12) self.radio_de_colision = 5 class Pacman(pilas.actores.Pacman): def __init__(self, mapa): self.mapa = mapa pilas.actores.Pacman.__init__(self, -12, -12) def actualizar(self): if self.control.izquierda: self.posicion = 0 self.y = self.ajustar_coordenada_a_grilla(self.y) elif self.control.derecha: self.posicion = 1 self.y = self.ajustar_coordenada_a_grilla(self.y) elif self.control.abajo:
#! /usr/bin/env python # -*- coding: utf-8 -*- import pilasengine import random Fin_del_juego = False # Iniciar el motor de PilasEngine pilas = pilasengine.iniciar(ancho=288, alto=511) # Añadir un marcador puntos = pilas.actores.Puntaje(x=100, y=240, color=pilas.colores.naranja) puntos.magnitud = 40 # Añadir el conmutador de sonido Sonido = pilas.actores.Sonido # Variables y constantes Tubos1 = [] Tubos2 = [] Pisos = [] Puntos = [] # Define todas las cualidades del Fondo class FondoConMovimiento(pilasengine.fondos.Fondo): def iniciar(self): # define que imagen se usara como fondo self.imagen = "flappyfondo.png" # velocidad a la que se movera el fondo self.velocidad = 1 def actualizar(self): # define que se movera hacia la izquierda self.x -= self.velocidad # Si el fondo llega al borde izquierdo de la pantalla entonces cambiar su posicion en X if self.x + self.ancho <= 0:
import pilasengine import escenas pilas = pilasengine.iniciar(1366, 768, capturar_errores=False) escena = escenas.EscenaJuego(pilas) pilas.definir_escena(escena) pilas.ejecutar()
import pilasengine pilas = pilasengine.iniciar(gravedad=(0,0)) mapa = pilas.actores.MapaTiled('mapa.tmx') # Genera un personaje en movimiento. aceituna = pilas.actores.personajes_rpg.Maton(mapa) pilas.avisar("Use el teclado para mover al personaje.") pilas.ejecutar()
from __future__ import division import pilasengine from random import randint from settings import IMG_DIR from movimientos import * from circulo_personalizado import Mi_Circulo import math from coordenadas import coor_esc_1, coor_esc_2, coor_cad, coor_rod_cinta, coor_rod_cinta_rota # original (small) = 2000, 1080 # debug = 1000, 500 # GLOBAL en_colision = False chequear = True # GLOBAL r = None pilas = pilasengine.iniciar(2000, 1080, pantalla_completa=False, con_aceleracion='OpenGL') SMALL_IMG_DIR = IMG_DIR + 'mapa-chico-separado/' #mapa = pilas.fondos.Fondo(imagen= # SMALL_IMG_DIR+"fondo_small.jpg") ################################################### ##################### Actores ###################### #################################################### class Ruedolf(pilasengine.actores.Actor): def iniciar(self):
# coding: utf-8 import pilasengine from settings import IMG_DIR from movimientos import * pilas = pilasengine.iniciar(4000, 2160) mapa = pilas.fondos.Fondo(imagen=IMG_DIR+"/mapa.jpg") pilas.camara.escala = 1.1 pilas.camara.definir_y(60) pilas.camara.definir_x(-150) class RuedaGenerica(pilasengine.actores.Actor): def iniciar(self, x, y): self.x = x self.y = y self.imagen = IMG_DIR + '/metal_block.png' pilas.actores.vincular(RuedaGenerica) def generar_rueda(): b = RuedaGenerica(pilas,-1550,530) b.escala = 1.5 return b pilas.comportamientos.vincular(Desaparecer) pilas.comportamientos.vincular(Mueve_x) pilas.comportamientos.vincular(Mueve_y) pilas.comportamientos.vincular(Eliminar) def mueve_x(g, stamina, img=''): g.hacer("Mueve_x", stamina, img)
'vaca_voladora/nube2.png', ] self.imagen = random.choice(rutas_imagenes_nubes) def actualizar(self): self.x -= self.velocidad if self.derecha < -320: self.reiniciar_posicion() def reiniciar_posicion(self): self.izquierda = 320 self.y = random.randint(-210, 210) pilas = pilasengine.iniciar(capturar_errores=False) fondo = pilas.fondos.Fondo('vaca_voladora/nubes.png') puntos = pilas.actores.Puntaje(x=-290, y=210) vaca = Vaca(pilas) items = [] enemigos = [] def crear_item(): un_item = Item(pilas) items.append(un_item) return True pilas.tareas.agregar(2, crear_item)
4# -*- encoding: utf-8 -*- import pilasengine pilas = pilasengine.iniciar(alto=768, ancho=1366) class Menu(pilasengine.escenas.Escena): def iniciar(self): fondo=pilas.fondos.Fondo("menu.jpg") fondo.definir_escala(3) intro=pilas.musica.cargar("mememe.mp3") intro.reproducir(repetir=True) self.menu=pilas.actores.Menu( [ ('Iniciar juego', self.Juego), ('Ayuda', self.ayuda), ('Salir', self.salir), ]) def Juego(self): pilas.escenas.Juego() def ayuda(self): pilas.escenas.Ayuda() def salir(self): exit() class Puerta(pilasengine.actores.Actor): def iniciar(self): self.imagen="puerta.png" class Ayuda(pilasengine.escenas.Escena): def iniciar(self): fondo=pilas.fondos.Fondo("menu.jpg")
# coding: utf-8 import pilasengine import time import random pilas = pilasengine.iniciar(alto=640,ancho=800) puntajeJ1=0 puntajeJ2=0 class Menu(pilasengine.escenas.Escena): def iniciar(self): fondo=pilas.fondos.Fondo("fondo.jpg") fondo.definir_escala(4) intro = pilas.musica.cargar("Battle City (NES) Music - Game Start.mp3") intro.reproducir() self.menu=pilas.actores.Menu([("Iniciar Juego",self.iniciar_juego), ("Instrucciones",self.instrucciones),("Salir",self.salir)]) def iniciar_juego(self): self.menu.eliminar() pilas.escenas.Juego() def salir(self): exit() def instrucciones(self): self.menu.eliminar() pilas.escenas.Instr() class Instr(pilasengine.escenas.Escena):
#!/usr/bin/env python # -*- coding: utf-8 import pilasengine from globales import * from emisorHUMO import * from pantalla_config import * from pantallas_juego import * from juego_tierraluna import * #from juego_tierraluna_DEMO import * from juego_tierraluna_DEMO import * # Inicializamos PILAS-ENGINE # pasando como parámetros la resolución gráfica de la ventana y el título de la misma: pilas = pilasengine.iniciar(ancho=900, alto=550, titulo='TierraLuna') # Habilitando el Audio en PILAS: try: pilas.forzar_habilitacion_de_audio() except AttributeError: print u"Omitiendo Habilitación forzada de audio, version anterior a 1.4.8".encode('utf-8') pilas.escenas.vincular(PantallaJuego) pilas.escenas.vincular(PantallaMenu) pilas.escenas.vincular(PantallaDemo) pilas.escenas.vincular(PantallaConfig) pilas.escenas.vincular(PantallaFinal) pilas.escenas.PantallaMenu(tema_actual_init, tema_sprites_init, tema_fondos_init, tema_textos_init)
PUNTOS_POR_HIT = 10 PUNTOS_POR_FALLO = -10 PUNTOS_POR_NO_DISPARO = -50 class Capas(): fondo = 30 cajas = 20 bomba = 10 avion = 1 ''' Variables globales ''' pilas = pilasengine.iniciar(ancho=Config.ANCHO_DE_PANTALLA, alto=Config.ALTO_DE_PANTALLA) sonido_encendido = True cancion_de_fondo = pilas.musica.cargar('des.mp3') cancion_de_fondo.reproducir() cancion_de_fondo.detener_gradualmente(10) ''' Objetos del juego ''' class Bomba(pilasengine.actores.Actor): def iniciar(self): self.imagen = 'bomba.png' self.escala = 0.15 self.z = Capas.bomba