Example #1
0
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
Example #3
0
    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)
Example #4
0
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
Example #5
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()
Example #6
0
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()
Example #8
0
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
Example #9
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
Example #10
0
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
Example #11
0
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()
Example #12
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
Example #13
0
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]
Example #14
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
Example #15
0
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()
Example #17
0
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
Example #18
0
        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()
Example #19
0
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
Example #20
0
    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}
Example #21
0
    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}
Example #22
0
    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}
Example #23
0
    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}
Example #24
0
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()
Example #25
0
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)
Example #26
0
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
Example #27
0
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
Example #28
0
    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}
Example #29
0
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()
Example #31
0
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
Example #32
0
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
Example #33
0
    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
Example #34
0
    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
Example #35
0
    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
Example #36
0
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
Example #37
0
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
Example #38
0
    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()
Example #39
0
# -*- 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

Example #40
0
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:")
Example #42
0
import pilas


pilas.iniciar(titulo="Buscador de comida")

import escena_menu

pilas.cambiar_escena(escena_menu.EscenaMenu())
pilas.ejecutar()
Example #43
0
 def setUp(self):
     pilas.iniciar()
     self.eactual = pilas.escena_actual()
     for t in list(self.eactual.tareas.tareas_planificadas):
         t.terminar()
Example #44
0
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']:
Example #46
0
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()
Example #48
0
# -*- 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()
Example #49
0
# -*- 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:
Example #50
0
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()
Example #51
0
                               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()
Example #52
0
import pilas
from aplicacion import App

pilas.iniciar(ancho = 1280, alto = 800, titulo = "Aplicadion para Docente")
pilas.cambiar_escena(App())
pilas.ejecutar()
Example #53
0
 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()
Example #55
0
import pilas

pilas.iniciar(titulo="3 en Raya")

# ejecuta escena actual.
import escena_menu

pilas.cambiar_escena(escena_menu.EscenaMenu())

pilas.ejecutar()