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
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):
import pilasengine
self.pilas = pilasengine.iniciar()
def setUp(self):
self.pilas = pilasengine.iniciar(modo_test=True)
# 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()
#! /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
# -*- 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:
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()
# -*- 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 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 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()
# -*- 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()
# 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
import pilasengine import escenas pilas = pilasengine.iniciar(1366, 768, capturar_errores=False) escena = escenas.EscenaJuego(pilas) pilas.definir_escena(escena) pilas.ejecutar()
#! /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:
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):
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()
# 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)
def setUp(self):
self.pilas = pilasengine.iniciar(modo_test=True)
self.pilas.actores.vincular(TestActoresPersonalizados.MiActor)
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")
'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)
# 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)
# -*- 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()
def setUp(self):
self.pilas = pilasengine.iniciar()
#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
