def test_todos_los_objetos_de_interfaz_se_pueden_crear():
pilas.iniciar()
deslizador = pilas.interfaz.Deslizador()
assert deslizador
assert deslizador.progreso == 0
boton = pilas.interfaz.Boton()
assert boton
ingreso = pilas.interfaz.IngresoDeTexto()
assert ingreso
try:
pilas.interfaz.ListaSeleccion()
except TypeError:
assert True # Se espera esta excepcion, porque un argumento es obligatorio
lista = pilas.interfaz.ListaSeleccion([('uno')])
assert lista
try:
pilas.interfaz.Selector()
except TypeError:
assert True # el argumento texto es obligatorio.
selector = pilas.interfaz.Selector("hola")
assert selector
def test_actor_texto():
pilas.iniciar()
texto = pilas.actores.Texto("Hola")
assert texto.texto == "Hola"
# verificando que el tamaño inicial es de 30 y el color negro
assert texto.magnitud == 30
def __init__(self, parent=None, pilas_width=320, pilas_height=240):
QtGui.QWidget.__init__(self, parent)
vbox = QtGui.QVBoxLayout(self)
pilas.iniciar(usar_motor='qt')
ventana_pilas = pilas.mundo.motor
ventana_pilas.setMinimumWidth(pilas_width)
ventana_pilas.setMinimumHeight(pilas_height)
horizontalLayout = QtGui.QHBoxLayout()
spacer1 = QtGui.QSpacerItem(58, 20, QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Minimum)
horizontalLayout.addItem(spacer1)
horizontalLayout.addWidget(ventana_pilas)
spacer2 = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Minimum)
horizontalLayout.addItem(spacer2)
vbox.addLayout(horizontalLayout)
#vbox.addWidget(self.horizontalLayout)
#hbox.addWidget(ventana_pilas)
#Crear actor
self.mono = pilas.actores.Mono()
pilas.eventos.click_de_mouse.conectar(self.sonreir)
# Agrega la Consola
locals = {'pilas': pilas, 'mono': self.mono}
self.consoleWidget = console_widget.ConsoleWidget(locals)
vbox.addWidget(self.consoleWidget)
def test_cambio_horizontal_de_centro():
pilas.iniciar()
caja = pilas.actores.Actor("caja.png")
caja.escala = 1
caja.centro = ("izquierda", "centro")
# +------------+
# | |
# | |
# |x |
# | |
# | |
# +------------+
assert caja.alto == 48
assert caja.ancho == 48
assert caja.arriba == 24
assert caja.abajo == -24
assert caja.izquierda == 0
assert caja.derecha == 48
caja.centro = ("derecha", "centro")
# +------------+
# | |
# | |
# | x|
# | |
# | |
# +------------+
assert caja.arriba == 24
assert caja.abajo == -24
assert caja.izquierda == -48
assert caja.derecha == 0
def __init__(self, parent=None, pilas_width=320, pilas_height=240):
GtkMotor.__init__(self)
self.set_title("Hola")
vbox = Gtk.VBox()
self.add(vbox)
pilas.iniciar(motor=self)
horizontalLayout = Gtk.HBox()
vbox.pack_start(horizontalLayout, True, True, 0)
#Crear actor
self.mono = pilas.actores.Mono()
pilas.eventos.click_de_mouse.conectar(self.sonreir)
# Agrega la Consola
locals = {'pilas': pilas, 'mono': self.mono}
self.consoleWidget = console_widget.ConsoleWidget(locals)
vbox.pack_start(self.consoleWidget, True, True, 0)
self.connect("destroy", Gtk.main_quit)
self.show_all()
def test_perseguir():
pilas.iniciar()
# se asegura que persigue bien en las cuatro direcciones
mono = pilas.actores.Mono()
mono.x = 100
mono.y = 100
bomba = pilas.actores.Bomba()
bomba.aprender(pilas.habilidades.PerseguirAOtroActor, mono)
bomba.habilidades.habilidades[1].actualizar()
assert bomba.x > 0
assert bomba.y > 0
bomba.x = 0
bomba.y = 0
mono.x = 100
mono.y = -100
bomba.habilidades.habilidades[1].actualizar()
assert bomba.x > 0
assert bomba.y < 0
bomba.x = 0
bomba.y = 0
mono.x = -100
mono.y = 100
bomba.habilidades.habilidades[1].actualizar()
assert bomba.x < 0
assert bomba.y > 0
bomba.x = 0
bomba.y = 0
mono.x = -100
mono.y = -100
bomba.habilidades.habilidades[1].actualizar()
assert bomba.x < 0
assert bomba.y < 0
# se asegura que la velocidad funciona como tiene que funcionar
mono.x = 100
mono.y = 100
bomba.x = 0
bomba.y = 0
bomba.habilidades.habilidades[1].velocidad = 1
bomba.habilidades.habilidades[1].actualizar()
assert bomba.x == 1
assert bomba.y == 1
bomba.x = 0
bomba.y = 0
bomba.habilidades.habilidades[1].velocidad = 5
bomba.habilidades.habilidades[1].actualizar()
assert bomba.x == 5
assert bomba.y == 5
def test_mapa_y_distancia_al_suelo():
pilas.iniciar()
mapa = pilas.actores.Mapa(filas=14, columnas=14)
mapa.pintar_bloque(13, 9, 1, True)
mapa.pintar_bloque(13, 10, 1, True)
# Me aseguro de que el mapa interpreta correctamente
# cuales de los bloques son solidos.
assert mapa.es_punto_solido(80, -210)
assert not mapa.es_punto_solido(0, 0)
# Me aseguro de calcular la distancia al suelo correctamente
assert mapa.obtener_distancia_al_suelo(80, -100, 200) == 108
# Si no hay suelo en toda la columna, se tiene que retornar
# el limite maximo
#assert mapa.obtener_distancia_al_suelo(0, 0, 2000) == 2000
# Me aseguro, que que el mapa responde a cuales
# son los bloques solidos aunque cambie la posicion del
# mapa entero..
mapa.x = 200
mapa.y = 200
assert mapa.es_punto_solido(80+200, -210+200)
assert not mapa.es_punto_solido(0+200, 0+200)
mapa.x = 0
mapa.y = 0
mapa.pintar_limite_de_bloques()
def test_cambio_horizontal_de_centro():
pilas.iniciar()
caja = pilas.actores.Actor("caja.png")
caja.escala = 1
caja.centro = ("izquierda", "centro")
# +------------+
# | |
# | |
# |x |
# | |
# | |
# +------------+
assert caja.alto == 48
assert caja.ancho == 48
assert caja.arriba == 24
assert caja.abajo == -24
assert caja.izquierda == 0
assert caja.derecha == 48
caja.centro = ("derecha", "centro")
# +------------+
# | |
# | |
# | x|
# | |
# | |
# +------------+
assert caja.arriba == 24
assert caja.abajo == -24
assert caja.izquierda == -48
assert caja.derecha == 0
def test_actor_texto():
pilas.iniciar()
texto = pilas.actores.Texto("Hola")
assert texto.texto == "Hola"
# verificando que el tamaño inicial es de 30 y el color negro
assert texto.magnitud == 30
def test_perseguir():
pilas.iniciar()
# se asegura que persigue bien en las cuatro direcciones
mono = pilas.actores.Mono()
mono.x = 100
mono.y = 100
bomba = pilas.actores.Bomba()
bomba.aprender(pilas.habilidades.PerseguirAOtroActor, mono)
bomba.habilidades.habilidades[1].actualizar()
assert bomba.x > 0
assert bomba.y > 0
bomba.x = 0
bomba.y = 0
mono.x = 100
mono.y = -100
bomba.habilidades.habilidades[1].actualizar()
assert bomba.x > 0
assert bomba.y < 0
bomba.x = 0
bomba.y = 0
mono.x = -100
mono.y = 100
bomba.habilidades.habilidades[1].actualizar()
assert bomba.x < 0
assert bomba.y > 0
bomba.x = 0
bomba.y = 0
mono.x = -100
mono.y = -100
bomba.habilidades.habilidades[1].actualizar()
assert bomba.x < 0
assert bomba.y < 0
# se asegura que la velocidad funciona como tiene que funcionar
mono.x = 100
mono.y = 100
bomba.x = 0
bomba.y = 0
bomba.habilidades.habilidades[1].velocidad = 1
bomba.habilidades.habilidades[1].actualizar()
assert bomba.x == 1
assert bomba.y == 1
bomba.x = 0
bomba.y = 0
bomba.habilidades.habilidades[1].velocidad = 5
bomba.habilidades.habilidades[1].actualizar()
assert bomba.x == 5
assert bomba.y == 5
def test_mapa_y_distancia_al_suelo():
pilas.iniciar()
mapa = pilas.actores.Mapa(filas=14, columnas=14)
mapa.pintar_bloque(13, 9, 1, True)
mapa.pintar_bloque(13, 10, 1, True)
# Me aseguro de que el mapa interpreta correctamente
# cuales de los bloques son solidos.
assert mapa.es_punto_solido(80, -210)
assert not mapa.es_punto_solido(0, 0)
# Me aseguro de calcular la distancia al suelo correctamente
assert mapa.obtener_distancia_al_suelo(80, -100, 200) == 92
# Si no hay suelo en toda la columna, se tiene que retornar
# el limite maximo
assert mapa.obtener_distancia_al_suelo(0, 0, 2000) == 2000
# Me aseguro, que que el mapa responde a cuales
# son los bloques solidos aunque cambie la posicion del
# mapa entero..
mapa.x = 200
mapa.y = 200
assert mapa.es_punto_solido(80 + 200, -210 + 200)
assert not mapa.es_punto_solido(0 + 200, 0 + 200)
mapa.x = 0
mapa.y = 0
mapa.pintar_limite_de_bloques()
def test_cargar_imagenes():
pilas.iniciar()
original_image = pilas.imagenes.cargar('mono.png')
actor = pilas.actores.Actor(original_image)
actors_image = actor.imagen
assert original_image == actors_image
def test_interpolacion():
pilas.iniciar()
a = pilas.interpolar([0, 100])
assert a.values == [0, 100]
# Invierte la interpolacion.
a = -a
assert a.values == [100, 0]
def test_cargar_imagenes():
pilas.iniciar()
original_image = pilas.imagenes.cargar('mono.png')
actor = pilas.actores.Actor(original_image)
actors_image = actor.imagen
assert original_image == actors_image
def test_interpolacion():
pilas.iniciar()
a = pilas.interpolar([0, 100])
assert a.values == [0, 100]
# Invierte la interpolacion.
a = -a
assert a.values == [100, 0]
def main():
pilas.iniciar()
protagonista=pilas.actores.Aceituna()
protagonista.aprender(pilas.habilidades.SeguirAlMouse)
bomba_1=BombaConMovimiento()
bomba_2=BombaConMovimiento(x=200,y=0)
bomba_3=BombaConMovimiento(x=0,y=200)
pilas.ejecutar()
def test_reemplazar_fondo():
pilas.iniciar()
# se asegura de que solo exite un fondo.
fondos = [x for x in pilas.actores.todos if x.es_fondo()]
assert len(fondos) == 1
# y al crear un nuevo fondo se asegura de que sigue existiendo solo uno.
pilas.fondos.Espacio()
fondos = [x for x in pilas.actores.todos if x.es_fondo()]
assert len(fondos) == 1
def __init__(self):
"""
Instancia de inicio
"""
pilas.iniciar(600, 600, "Mono come bananas")
# Sonido
self.sonido1 = pilas.sonidos.cargar("smile.ogg")
self.sonido2 = pilas.sonidos.cargar("shout.ogg")
self.sonido3 = pilas.sonidos.cargar("explosion.ogg")
self.runGame()
def test_reemplazar_fondo():
pilas.iniciar()
# se asegura de que solo exite un fondo.
fondos = [x for x in pilas.actores.todos if x.es_fondo()]
assert len(fondos) == 1
# y al crear un nuevo fondo se asegura de que sigue existiendo solo uno.
pilas.fondos.Espacio()
fondos = [x for x in pilas.actores.todos if x.es_fondo()]
assert len(fondos) == 1
def _insertar_ventana_principal_de_pilas(self):
pilas.iniciar(usar_motor='qtsugar')
mono = pilas.actores.Mono()
mono.aprender(pilas.habilidades.MoverseConElTeclado)
ventana = pilas.mundo.motor.ventana
canvas = pilas.mundo.motor.canvas
canvas.setFocusPolicy(QtCore.Qt.ClickFocus)
self.canvas.setFocus()
self.canvas.addWidget(ventana)
self.canvas.setCurrentWidget(ventana)
return {'pilas': pilas, 'mono': mono}
def _insertar_ventana_principal_de_pilas(self):
pilas.iniciar(usar_motor="qtsugar")
mono = pilas.actores.Mono()
mono.aprender(pilas.habilidades.MoverseConElTeclado)
ventana = pilas.mundo.motor.ventana
canvas = pilas.mundo.motor.canvas
canvas.setFocusPolicy(QtCore.Qt.ClickFocus)
self.canvas.setFocus()
self.canvas.addWidget(ventana)
self.canvas.setCurrentWidget(ventana)
return {"pilas": pilas, "mono": mono}
def _insertar_ventana_principal_de_pilas(self):
pilas.iniciar(usar_motor='qtsugar', ancho=640, alto=400)
mono = pilas.actores.Mono()
ventana = pilas.mundo.motor.ventana
canvas = pilas.mundo.motor.canvas
canvas.setFocusPolicy(QtCore.Qt.ClickFocus)
self.canvas.setFocus()
self.canvas.addWidget(ventana)
self.canvas.setCurrentWidget(ventana)
return {'pilas': pilas, 'mono': mono}
def _insertar_ventana_principal_de_pilas(self):
pilas.iniciar(usar_motor='qtsugar', ancho=640, alto=400)
mono = pilas.actores.Mono()
ventana = pilas.mundo.motor.ventana
canvas = pilas.mundo.motor.canvas
canvas.setFocusPolicy(QtCore.Qt.ClickFocus)
self.canvas.setFocus()
self.canvas.addWidget(ventana)
self.canvas.setCurrentWidget(ventana)
return {'pilas': pilas, 'mono': mono, 'self': self}
def main():
pilas.iniciar(titulo="Malondon",
pantalla_completa=conf.get("pantalla_completa", False))
logos = pilas.escena.Logos(escena_menu.Menu(), pilas_logo=False,
pasar_con_click_de_mouse=True,
pasar_con_teclado=True)
logos.agregar_logo("pilasengine.png", sonido="roar.wav")
logos.agregar_logo("globalgamejam2013.png")
logos.agregar_logo("cbagamejam2013.png", timer=2.5,
sonido="corazon_corto.mp3"),
logos.agregar_logo("gpl3.png")
#pilas.cambiar_escena(escena_juego.Juego())
pilas.cambiar_escena(logos)
pilas.ejecutar()
def test_posicion_de_los_actores():
pilas.iniciar()
mono = pilas.actores.Mono()
assert pilas.obtener_cantidad_de_actores() == 1
assert len(pilas.obtener_actores()) == 1
# el actor comienza en el centro de la ventana
assert mono.x == 0
assert mono.y == 0
# un cambio de posicion sencillo
mono.x = 100
mono.y = 100
assert mono.x == 100
assert mono.y == 100
# rotacion
assert mono.rotacion == 0
mono.rotacion = 180
assert mono.rotacion == 180
# Verificnado que las rotaciones siempre estan entre 0 y 360
mono.rotacion = 361
assert mono.rotacion == 1
mono.rotacion = -10
assert mono.rotacion == 350
# Analizando el actor existira en la escena
assert mono in pilas.escena_actual().actores
# Escalas
assert mono.escala == 1
mono.escala = 0
assert mono.escala == 0.001
mono.escala = 0.5
assert mono.escala == 0.5
mono.escala = 5
assert mono.escala == 5
# verificando que el mono se elimina de la escena.
mono.eliminar()
assert not (mono in pilas.escena_actual().actores)
def test_escala_ampliada():
pilas.iniciar()
caja = pilas.actores.Actor("caja.png")
caja.escala = 2
assert caja.alto == 48*2
assert caja.ancho == 48*2
assert caja.x == 0
assert caja.y == 0
assert caja.arriba == 48
assert caja.abajo == -48
assert caja.izquierda == -48
assert caja.derecha == 48
def test_escala_ampliada():
pilas.iniciar()
caja = pilas.actores.Actor("caja.png")
caja.escala = 2
assert caja.alto == 48 * 2
assert caja.ancho == 48 * 2
assert caja.x == 0
assert caja.y == 0
assert caja.arriba == 48
assert caja.abajo == -48
assert caja.izquierda == -48
assert caja.derecha == 48
def _insertar_ventana_principal_de_pilas(self):
pilas.iniciar(usar_motor='qtsugar', ancho=640, alto=400)
ventana = pilas.mundo.motor.ventana
canvas = pilas.mundo.motor.canvas
canvas.setFocusPolicy(QtCore.Qt.ClickFocus)
self.canvas.setFocus()
self.canvas.addWidget(ventana)
self.canvas.setCurrentWidget(ventana)
b = pilas.actores.Board("/dev/tty/USB0")
r = pilas.actores.Robot(b, 1)
return {'pilas': pilas, 'b': b, 'r': r, 'self': self}
def test_posicion_de_los_actores():
pilas.iniciar()
mono = pilas.actores.Mono()
# el actor comienza en el centro de la ventana
assert mono.x == 0
assert mono.y == 0
# un cambio de posicion sencillo
mono.x = 100
mono.y = 100
assert mono.x == 100
assert mono.y == 100
# rotacion
assert mono.rotacion == 0
mono.rotacion = 180
assert mono.rotacion == 180
# Verificnado que las rotaciones siempre estan entre 0 y 360
mono.rotacion = 361
assert mono.rotacion == 1
mono.rotacion = -10
assert mono.rotacion == 350
# Analizando el actor existira en la escena
assert mono in pilas.escena_actual().actores
# Escalas
assert mono.escala == 1
mono.escala = 0
assert mono.escala == 0.001
mono.escala = 0.5
assert mono.escala == 0.5
mono.escala = 5
assert mono.escala == 5
# verificando que el mono se elimina de la escena.
mono.eliminar()
assert not (mono in pilas.escena_actual().actores)
def avanzar():
pilas.iniciar()
class MiActor(pilas.actores.Actor):
def __init__(self):
pilas.actores.Actor.__init__(self)
self.imagen = pilas.imagenes.cargar("grillas/3.png")
def actualizar(self):
if pilas.escena_actual().control.izquierda:
self.x -= 10
if pilas.escena_actual().control.derecha:
self.x += 10
MiActor()
pilas.ejecutar()
def test_posiciones_de_los_actores():
pilas.iniciar()
caja = pilas.actores.Actor("caja.png")
# +------------+
# | |
# | |
# | x |
# | |
# | |
# +------------+
assert caja.alto == 48
assert caja.ancho == 48
assert caja.arriba == 24
assert caja.abajo == -24
assert caja.izquierda == -24
assert caja.derecha == 24
def test_posiciones_de_los_actores():
pilas.iniciar()
caja = pilas.actores.Actor("caja.png")
# +------------+
# | |
# | |
# | x |
# | |
# | |
# +------------+
assert caja.alto == 48
assert caja.ancho == 48
assert caja.arriba == 24
assert caja.abajo == -24
assert caja.izquierda == -24
assert caja.derecha == 24
def _insertar_ventana_principal_de_pilas(self, ejecutar_codigo_inicial):
if pilas.esta_inicializada():
pilas.reiniciar()
pilas.iniciar(usar_motor='qtsugargl', ancho=640, alto=400)
if ejecutar_codigo_inicial:
mono = pilas.actores.Mono()
scope = {'pilas': pilas, 'mono': mono, 'self': self, 'inspect': inspect}
else:
scope = {'pilas': pilas, 'self': self}
ventana = pilas.mundo.motor.ventana
canvas = pilas.mundo.motor.canvas
canvas.setFocusPolicy(QtCore.Qt.ClickFocus)
self.canvas.setFocus()
self.canvas.addWidget(ventana)
self.canvas.setCurrentWidget(ventana)
return scope
def _insertar_ventana_principal_de_pilas(self, ejecutar_codigo_inicial):
if pilas.esta_inicializada():
pilas.reiniciar()
pilas.iniciar(usar_motor='qtsugargl', ancho=640, alto=400)
if ejecutar_codigo_inicial:
mono = pilas.actores.Mono()
scope = {'pilas': pilas, 'mono': mono, 'self': self, 'inspect': inspect}
else:
scope = {'pilas': pilas, 'self': self}
ventana = pilas.mundo.motor.ventana
canvas = pilas.mundo.motor.canvas
canvas.setFocusPolicy(QtCore.Qt.ClickFocus)
self.canvas.setFocus()
self.canvas.addWidget(ventana)
self.canvas.setCurrentWidget(ventana)
return scope
def _insertar_ventana_principal_de_pilas(self, ejecutar_codigo_inicial):
if pilas.esta_inicializada():
pilas.reiniciar()
pilas.iniciar(usar_motor='qtsugargl', ancho=640, alto=400)
if ejecutar_codigo_inicial:
from pilas.actores.robot import wait
b = pilas.actores.Board("/dev/tty/USB0")
r = pilas.actores.Robot(b, 1)
scope = {'pilas': pilas, 'b': b, 'r': r, 'wait' : wait , 'self': self}
else:
scope = {'pilas': pilas, 'self': self}
ventana = pilas.mundo.motor.ventana
canvas = pilas.mundo.motor.canvas
canvas.setFocusPolicy(QtCore.Qt.ClickFocus)
self.canvas.setFocus()
self.canvas.addWidget(ventana)
self.canvas.setCurrentWidget(ventana)
return scope
def test_escala_reducida():
pilas.iniciar()
caja = pilas.actores.Actor("caja.png")
caja.escala = 0.5
# +------------+ # La caja resultado
# | | # es la interior.
# | +----+ |
# | | | |
# | +----+ |
# | |
# +------------+
assert caja.alto == 24
assert caja.ancho == 24
assert caja.x == 0
assert caja.y == 0
assert caja.arriba == 12
assert caja.abajo == -12
assert caja.izquierda == -12
assert caja.derecha == 12
def test_escala_reducida():
pilas.iniciar()
caja = pilas.actores.Actor("caja.png")
caja.escala = 0.5
# +------------+ # La caja resultado
# | | # es la interior.
# | +----+ |
# | | | |
# | +----+ |
# | |
# +------------+
assert caja.alto == 24
assert caja.ancho == 24
assert caja.x == 0
assert caja.y == 0
assert caja.arriba == 12
assert caja.abajo == -12
assert caja.izquierda == -12
assert caja.derecha == 12
def __init__(self, handle):
"""Set up the Pilas activity."""
ActivityBase.__init__(self, handle)
# we do not have collaboration features,
# make the share option insensitive
self.max_participants = 1
# Pilas
pilas.iniciar(motor=self)
#Crear actor
self.mono = pilas.actores.Mono()
self.mono.x = self.ancho / 2 - self.mono.imagen.ancho() / 4
self.mono.y = 0 + self.mono.imagen.alto() / 2
pilas.eventos.click_de_mouse.conectar(self.sonreir)
# Agrega la Consola
locals = {'pilas': pilas, 'mono': self.mono, 'self': self}
self.consoleWidget = console_widget.ConsoleWidget(locals)
self.consoleWidget.set_size_request(1, 200)
self.layout.pack_end(self.consoleWidget, False, False, 0)
self.show_all()
# -*- encoding: utf-8 -*-
import pilas
pilas.iniciar(titulo='Reloj')
paso_un_segundo = pilas.eventos.Evento(['x', 'y'])
class RelojDigital(pilas.actores.Texto):
def __init__(self):
pilas.actores.Texto.__init__(self, texto="")
self.color = pilas.colores.negro
self.contador = 0
self.y = -100
self.x = -10
def avanzar_segundero(self, evento):
self.contador += 1
self.texto = str(self.contador)
class RelojAnalogico(pilas.actores.Actor):
def __init__(self):
pilas.actores.Actor.__init__(self, "flecha.png")
self.centro = ("izquierda", "centro")
self.rotacion -= 90
def avanzar_segundero(self, evento):
self.rotacion += 360 / 60
pass
import pilas
pilas.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()
# Creando el primer mensaje
self.lista.clear()
self.item = QtGui.QListWidgetItem("Bienvenido a Truco-Chat\nEstas desconectado(no puedes enviar mensajes!)")
self.lista.addItem(self.item)
app = QtGui.QApplication(sys.argv[1:])
pilas.iniciar(usar_motor="qtsugar", ancho=1058, alto=725)
canvas = pilas.mundo.motor.canvas
ventana = Ventana(canvas)
aceituna = pilas.actores.Actor("aceituna.png")
aceituna.radio_de_colision = 17
aceituna.aprender(pilas.habilidades.RebotarComoPelota)
aceituna.aprender(pilas.habilidades.Arrastrable)
boton = pilas.interfaz.Boton("Desconectar")
boton.y = 100
boton.x = -390
boton2 = pilas.interfaz.Boton("nick:")
boton2.y = 100
boton2.x = -310
boton3 = pilas.interfaz.Boton("cantar:")
import pilas pilas.iniciar(titulo="Buscador de comida") import escena_menu pilas.cambiar_escena(escena_menu.EscenaMenu()) pilas.ejecutar()
def setUp(self):
pilas.iniciar()
self.eactual = pilas.escena_actual()
for t in list(self.eactual.tareas.tareas_planificadas):
t.terminar()
def test_posicion_de_los_actores():
pilas.iniciar()
texto = pilas.actores.Texto('Hola')
assert texto.texto == 'Hola'
assert texto.obtener_texto() == "Hola"
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
import time
import pilas
import piano
import partitura
import osvaldo
pilas.iniciar(usar_motor='qt', titulo='Simon pugliese', audio='pygame')
class Juego(pilas.escena.Base):
def __init__(self):
pilas.escena.Base.__init__(self)
def iniciar(self):
pilas.fondos.Fondo('img/fondo_juego.png')
self.piano = piano.PianoNuevo(-240, -75)
self.partitura = partitura.Partitura('partituras/la_yumba.csv')
self.maestro = osvaldo.Osvaldo(self.partitura, self.piano)
boton = BotonMenu(x=190, y=190, ruta_normal='salir_interno_normal.png', ruta_press='salir_interno_press.png', ruta_over='salir_interno_over.png')
boton.conectar_presionado(pilas.terminar)
self.notas_a_ejecutar = 1
self.partitura.cortar_partitura(self.notas_a_ejecutar)
self.maestro.interpretar()
osvaldo.termine_de_evaluar.conectar(self.avanzar)
def avanzar(self, datos_evento):
if datos_evento['estuvo_bien']:
import pilas
import webbrowser
from OsoGordo import EscenaDespensa
from info import EscenaInfo
#Inicio PILAS
pilas.iniciar(ancho=1024, alto=600, titulo='Oso Gordo')
class EscenaDeMenu(pilas.escena.Base):
def __init__(self):
pilas.escena.Base.__init__(self)
def iniciar(self):
class GirarPorSiempre(pilas.habilidades.Habilidad):
def __init__(self, receptor):
self.receptor = receptor
def actualizar(self):
self.receptor.rotacion += 0.1
img_back = pilas.imagenes.cargar('pics/back.jpg')
back = pilas.actores.Actor(img_back, x=0, y=0)
back.escala = 1.3
back.aprender(GirarPorSiempre)
presentacion = pilas.imagenes.cargar('pics/presentacion.png')
presFondo = pilas.actores.Actor(presentacion)
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.iniciar(gravedad=(0, 0))
protagonista = pilas.actores.Aceituna()
protagonista.aprender(pilas.habilidades.SeguirAlMouse)
pilas.mundo.motor.ocultar_puntero_del_mouse()
bomba_1 = BombaConMovimiento()
bomba_2 = BombaConMovimiento(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()
# -*- encoding: utf-8 -*- # For pilas engine - a video game framework. # # copyright 2011 - Pablo Garrido # license: lgplv3 (see http://www.gnu.org/licenses/lgpl.html) # # website - http://www.pilas-engine.com.ar import pilas pilas.iniciar(titulo="Memorice") # ejecuta escena actual. import escena_menu pilas.cambiar_escena(escena_menu.EscenaMenu()) pilas.ejecutar()
# -*- encoding: utf-8 -*-
# Permite que este ejemplo funcion incluso si no has instalado pilas.
import sys
sys.path.insert(0, "..")
import pilas
pilas.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:
import pilas
pilas.iniciar(usar_motor='qtgl')
cielo = pilas.actores.Actor("cielo.png")
montes = pilas.actores.Actor("montes.png")
arboles = pilas.actores.Actor("arboles.png")
pasto = pilas.actores.Actor("pasto.png", y=-179)
cielo.z = 10
montes.z = 5
arboles.z = 0
pasto.z = -10
fondo = pilas.fondos.Desplazamiento()
fondo.agregar(cielo, 0)
fondo.agregar(montes, 0.5)
fondo.agregar(arboles, 0.9)
fondo.agregar(pasto, 2)
pilas.escena_actual().camara.x = [200], 10
pilas.ejecutar()
grosor=2)
else:
texto = "No hay un suelo a menos de 200 px..."
self.pizarra.linea(x - 5,
y + self.distancia - 4,
x,
y + self.distancia + 4,
grosor=2)
self.pizarra.linea(x + 5,
y + self.distancia - 4,
x,
y + self.distancia + 4,
grosor=2)
self.pizarra.texto(texto, x + 20, y + self.distancia / 2)
pilas.iniciar()
mapa = pilas.actores.Mapa(filas=15, columnas=20)
#mapa.pintar_limite_de_bloques()
mapa.pintar_bloque(10, 10, 1)
mapa.pintar_bloque(10, 11, 1)
mapa.pintar_bloque(10, 12, 1)
distancia_al_suelo = DistanciaAlSuelo(mapa)
pilas.avisar("Mueva el mouse para detectar distancias al suelo.")
pilas.ejecutar()
import pilas from aplicacion import App pilas.iniciar(ancho = 1280, alto = 800, titulo = "Aplicadion para Docente") pilas.cambiar_escena(App()) pilas.ejecutar()
def setUp(self):
pilas.iniciar()
import pilas
# Permite que este ejemplo funcion incluso si no has instalado pilas.
import sys
sys.path.insert(0, "..")
pilas.iniciar()
mono = pilas.actores.Mono()
def mover_al_mono(contexto):
mono.x = contexto.x
mono.y = contexto.y
pilas.eventos.mueve_mouse.connect(mover_al_mono)
pilas.avisar("Moviendo un actor en base a la posicion del mouse.")
pilas.ejecutar()
import pilas pilas.iniciar(titulo="3 en Raya") # ejecuta escena actual. import escena_menu pilas.cambiar_escena(escena_menu.EscenaMenu()) pilas.ejecutar()