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)
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()
def setUp(self):
import pilasengine
self.pilas = pilasengine.iniciar()
# -*- 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
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 -*-
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):
def setUp(self):
self.pilas = pilasengine.iniciar(modo_test=True)
self.pilas.actores.vincular(TestActoresPersonalizados.MiActor)
# 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)
def setUp(self):
self.pilas = pilasengine.iniciar()
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
