def actualizar(self):
     if pilas.escena_actual().control.izquierda:
         self.x -= 5
         self.espejado = True
     elif pilas.escena_actual().control.derecha:
         self.x += 5
         self.espejado = False
コード例 #2
0
 def actualizar(self):
     if pilas.escena_actual().control.izquierda:
         self.x -= 5
         self.espejado = True
     elif pilas.escena_actual().control.derecha:
         self.x += 5
         self.espejado = False
コード例 #3
0
 def dibuja_al_actor(self, motor, painter, lienzo, actor):
     lienzo.circulo(painter,
                    actor.x - pilas.escena_actual().camara.x,
                    actor.y - pilas.escena_actual().camara.y,
                    actor.radio_de_colision,
                    color=pilas.colores.verde,
                    grosor=ModoDepurador.grosor_de_lineas)
コード例 #4
0
ファイル: Juego.py プロジェクト: JavierCoggiola/PablitoGame
 def perder(self, mensaje):
     self.vidas = 3
     pilas.actores.Actor.decir(self, mensaje)
     self.definir_imagen(self.image_perdio)
     pilas.avisar("Para regresar al menu presione la tecla 'Esc'")
     mensaje = pilas.actores.Texto("Perdiste!!!")
     pilas.escena_actual().tareas.eliminar_todas()
コード例 #5
0
ファイル: habilidades.py プロジェクト: hectorsanchez/pilas
    def __init__(self,
                 receptor,
                 control=None,
                 direcciones=OCHO_DIRECCIONES,
                 velocidad_maxima=4,
                 aceleracion=1,
                 deceleracion=0.1,
                 con_rotacion=False,
                 velocidad_rotacion=1,
                 marcha_atras=True):
        Habilidad.__init__(self, receptor)
        pilas.escena_actual().actualizar.conectar(self.on_key_press)

        if control == None:
            self.control = self.receptor.escena.control
        else:
            self.control = control

        self.direcciones = direcciones

        self.velocidad = 0
        self.deceleracion = deceleracion
        self._velocidad_maxima = velocidad_maxima
        self._aceleracion = aceleracion
        self.con_rotacion = con_rotacion
        self.velocidad_rotacion = velocidad_rotacion
        self.marcha_atras = marcha_atras
コード例 #6
0
ファイル: robot.py プロジェクト: DrDub/pilas
    def _realizarMovimiento(self, vel, seconds):
        """ El robot avanza con velocidad vel durante seconds segundos. """

        def adelanteSinTiempo():
            self.actor.hacer(pilas.comportamientos.Avanzar(self.actor.velocidad, self.actor.velocidad))
            return (self.movimiento)

        def atrasSinTiempo():
            self.actor.hacer(pilas.comportamientos.Retroceder(self.actor.velocidad, self.actor.velocidad))
            return (self.movimiento)

        self.stop()
        self._setVelocidad(vel)

        if (self._velocidadValida(vel, 10, 100)) :
            self.movimiento = True
            self.tarea = pilas.escena_actual().tareas.condicional(0.1, adelanteSinTiempo)
            if (seconds != -1):
                wait(seconds)
                self.stop()
        elif (self._velocidadValida(vel, -100, -10)) :
            self.movimiento = True
            self.tarea = pilas.escena_actual().tareas.condicional(0.1, atrasSinTiempo)
            self.actor.velocidad = self.actor.velocidad * -1
            if (seconds != -1):
                wait(seconds)
                self.stop()
        else:
            print   """ Rangos de velocidades válidas:
コード例 #7
0
ファイル: texto_inferior.py プロジェクト: Morfyo/PYTHON
    def __init__(self, texto="None", x=0, y=0, magnitud=17, autoeliminar=False, retraso=5):
        """Inicializa el texto.

        :param texto: Texto a mostrar.
        :param x: Posición horizontal.
        :param y: Posición vertical.
        :param magnitud: Tamaño del texto.
        :param vertical: Si el texto será vertical u horizontal, como True o False.
        """
        Texto.__init__(self, texto, x, y, magnitud)
        izquierda, derecha, arriba, abajo = pilas.utils.obtener_bordes()

        # Se asegura de que solo exista un texto inferior
        if TextoInferior.anterior_texto:
            TextoInferior.anterior_texto.eliminar()

        self.z = -100
        TextoInferior.anterior_texto = self
        self._crear_sombra()

        self.centro = ("centro", "centro")
        self.izquierda = izquierda + 10
        self.color = pilas.colores.blanco
        self.abajo = abajo + 10
        self.fijo = True

        if autoeliminar:
            pilas.escena_actual().tareas.una_vez(retraso, self.eliminar)
コード例 #8
0
ファイル: habilidades.py プロジェクト: lmartinezh/pilas
 def cuando_termina_de_arrastrar(self, evento):
     "Suelta al actor porque se ha soltado el botón del mouse."
     pilas.escena_actual().mueve_mouse.desconectar_por_id(
         id='cuando_arrastra')
     self.termina_de_arrastrar()
     pilas.escena_actual().termina_click.desconectar_por_id(
         id='cuando_termina_de_arrastrar')
コード例 #9
0
    def comenzar(self):

        y = 300  #comienzo de la lista

        self.mono = pilas.actores.Mono()
        #self.mono.aprender(pilas.habilidades.SeguirClicks)

        self.mono.z = 1
        self.mono.escala = 0
        self.mono.radio_de_colision = 10
        self.mono.x = 500
        self.mono.click_de_mouse(self.mover_al_mono)

        for elem in self.lista_de_nombre:
            self.m = pilas.actores.Texto(
                texto=elem,
                magnitud=55,
                fuente='./escenas/interfazusuario/AGENCYB.TTF')
            self.m.radio_de_colision = 15
            self.lista_de_botones.append(self.m)
            y = y - 75
            self.m.y = y
            self.m.x = -800
            self.m.z = -5

        pilas.escena_actual().colisiones.agregar(self.mono,
                                                 self.lista_de_botones,
                                                 self.cambiar_escena)
コード例 #10
0
ファイル: fisica.py プロジェクト: lucas096/pilas
    def BeginContact(self, *args, **kwargs):
        objeto_colisionado_1 = args[0].fixtureA
        objeto_colisionado_2 = args[0].fixtureB

        if (not objeto_colisionado_1.userData == None) and (not objeto_colisionado_2.userData == None):
            pilas.escena_actual().colisiones.verificar_colisiones_fisicas(objeto_colisionado_1.userData['id'],
                                                                          objeto_colisionado_2.userData['id'])
コード例 #11
0
ファイル: utils.py プロジェクト: franquitt/pilas
def eliminar_a_todos():
    a_eliminar = pilas.escena_actual().actores[1:]    # evita borrar el fondo.

    for x in a_eliminar:
        x.eliminar()

    pilas.escena_actual().actores = []
コード例 #12
0
ファイル: mapa.py プロジェクト: Morfyo/PYTHON
    def __init__(self, grilla=None, x=0, y=0, filas=20, columnas=20):
        """Inicializa el mapa.

        :param grilla: La imagen a utilizar cómo grilla con los bloques del escenario.
        :param x: Posición horizontal del mapa.
        :param y: Posición vertical del mapa.
        :param filas: Cantidad de filas que tendrá el mapa.
        :param columnas: Cantidad de columnas que tendrá el mapa.
        """
        Actor.__init__(self, 'invisible.png', x, y)

        self.filas = filas
        self.columnas = columnas

        # Genera una matriz indicando cuales de los bloque son solidos.
        self.matriz_de_bloques = self._generar_matriz_de_bloques(filas, columnas)

        if not grilla:
            grilla = pilas.imagenes.cargar_grilla("grillas/plataformas_10_10.png", 10, 10)

        self.grilla = grilla
        self.superficie = pilas.imagenes.cargar_superficie(columnas * self.grilla.cuadro_ancho, filas * self.grilla.cuadro_alto)
        #self.imagen = self.superficie
        self.centro_mapa_x, self.centro_mapa_y = self.superficie.centro()

        pilas.escena_actual().mueve_camara.conectar(self._actualizar_imagen)
        self.fijo = True
コード例 #13
0
ファイル: camara.py プロジェクト: lucciano/pilas
    def _set_x(self, x):
        """Define la posición horizontal de la cámara.

        :param x: Posición horizontal.
        """
        pilas.escena_actual().mueve_camara.emitir(x=x, y=self.y, dx=x-self.x, dy=0)
        pilas.mundo.motor.definir_centro_de_la_camara(x, self.y)
コード例 #14
0
 def cuando_intenta_arrastrar(self, evento):
     "Intenta mover el objeto con el mouse cuando se pulsa sobre el."
     if (evento.boton == 1):
         if self.receptor.colisiona_con_un_punto(evento.x, evento.y):
             pilas.escena_actual().termina_click.conectar(self.cuando_termina_de_arrastrar, id='cuando_termina_de_arrastrar')
             pilas.escena_actual().mueve_mouse.conectar(self.cuando_arrastra, id='cuando_arrastra')
             self.comienza_a_arrastrar()
コード例 #15
0
 def cuando_arrastra(self, evento):
     "Arrastra el actor a la posicion indicada por el puntero del mouse."
     if self._el_receptor_tiene_fisica():
         pilas.escena_actual().fisica.cuando_mueve_el_mouse(evento.x, evento.y)
     else:
         self.receptor.x += evento.dx
         self.receptor.y += evento.dy
コード例 #16
0
    def _realizarGiro(self, vel, seconds):
        def izquierdaSinTiempo():
            self.actor.hacer(
                pilas.comportamientos.Girar(-abs(self.actor.velocidad),
                                            self.actor.velocidad))
            return (self.movimiento)

        def derechaSinTiempo():
            self.actor.hacer(
                pilas.comportamientos.Girar(abs(self.actor.velocidad),
                                            self.actor.velocidad))
            return (self.movimiento)

        self.stop()
        self._setVelocidad(vel)

        if (self._velocidadValida(vel, 10, 100)):
            self.movimiento = True
            self.tarea = pilas.escena_actual().tareas.condicional(
                0.1, derechaSinTiempo)
            if (seconds != -1):
                wait(seconds)
                self.stop()
        elif (self._velocidadValida(vel, -100, -10)):
            self.movimiento = True
            self.tarea = pilas.escena_actual().tareas.condicional(
                0.1, izquierdaSinTiempo)
            self.actor.velocidad = self.actor.velocidad * -1
            if (seconds != -1):
                wait(seconds)
                self.stop()
        else:
            print """ Rangos de velocidades válidas:
コード例 #17
0
ファイル: disparar.py プロジェクト: franquitt/pilas
def perder(arma, enemigo):

    enemigo.sonreir()
    arma.eliminar()
    pilas.escena_actual().tareas.eliminar_todas()
    fin_de_juego = True
    pilas.avisar("HAS PERDIDO. Conseguiste %d putnos" %(puntos.obtener()))
コード例 #18
0
    def _verificar_colisiones_fisicas_en_tupla(self, tupla, id_actor_a, id_actor_b):
        "Toma dos grupos de actores y analiza colisiones entre ellos."
        (grupo_a, grupo_b, funcion_a_llamar) = tupla

        for a in grupo_a:
            for b in grupo_b:
                try:
                    if self._es_objeto_fisico_con_actor_asociado(a):
                        a_id = a.figura.id
                    else:
                        a_id = a.id

                    if self._es_objeto_fisico_con_actor_asociado(b):
                        b_id = b.figura.id
                    else:
                        b_id = b.id

                    if a_id == id_actor_a and b_id == id_actor_b:
                        funcion_a_llamar(a, b)

                        # verifica si alguno de los dos objetos muere en la colision.
                        if (self._es_objeto_fisico_con_actor_asociado(a)):
                            if a not in pilas.escena_actual().actores:
                                if a in grupo_a:
                                    list.remove(grupo_a, a)

                        if (self._es_objeto_fisico_con_actor_asociado(b)):
                            if b not in pilas.escena_actual().actores:
                                if b in grupo_b:
                                    list.remove(grupo_b, b)

                except Exception as e:
                    list.remove(grupo_a, a)
                    raise e
コード例 #19
0
    def _realizarMovimiento(self, vel, seconds):
        """ El robot avanza con velocidad vel durante seconds segundos. """
        def adelanteSinTiempo():
            self.actor.hacer(
                pilas.comportamientos.Avanzar(self.actor.velocidad,
                                              self.actor.velocidad))
            return (self.movimiento)

        def atrasSinTiempo():
            self.actor.hacer(
                pilas.comportamientos.Retroceder(self.actor.velocidad,
                                                 self.actor.velocidad))
            return (self.movimiento)

        self.stop()
        self._setVelocidad(vel)

        if (self._velocidadValida(vel, 10, 100)):
            self.movimiento = True
            self.tarea = pilas.escena_actual().tareas.condicional(
                0.1, adelanteSinTiempo)
            if (seconds != -1):
                wait(seconds)
                self.stop()
        elif (self._velocidadValida(vel, -100, -10)):
            self.movimiento = True
            self.tarea = pilas.escena_actual().tareas.condicional(
                0.1, atrasSinTiempo)
            self.actor.velocidad = self.actor.velocidad * -1
            if (seconds != -1):
                wait(seconds)
                self.stop()
        else:
            print """ Rangos de velocidades válidas:
コード例 #20
0
    def actualizar(self):
        if pilas.escena_actual().control.izquierda:
            x = self.objeto_a_imitar.x-32
            y = self.objeto_a_imitar.y
            self.receptor.x = x
            self.receptor.y = y

        if pilas.escena_actual().control.derecha:
            x = self.objeto_a_imitar.x+32
            y = self.objeto_a_imitar.y
            self.receptor.x = x
            self.receptor.y = y

        if pilas.escena_actual().control.abajo:
            x = self.objeto_a_imitar.x
            y = self.objeto_a_imitar.y-32
            self.receptor.x = x
            self.receptor.y = y

        if pilas.escena_actual().control.arriba:
            x = self.objeto_a_imitar.x
            y = self.objeto_a_imitar.y+32
            self.receptor.x = x
            self.receptor.y = y

        if (self.con_rotacion):
            self.receptor.rotacion = self.objeto_a_imitar.rotacion
コード例 #21
0
ファイル: atajos.py プロジェクト: unrblt/pilas
def definir_gravedad(x, y):
    """Define la gravedad del motor de física.

    :param x: Aceleración horizontal.
    :param y: Aceleración vertical.
    """
    pilas.escena_actual().fisica.definir_gravedad(x, y)
コード例 #22
0
ファイル: comelon.py プロジェクト: debian789/ClonMarioPilas
    def actualizar(self):
        self.avanzar_animacion()
        vx = 0

        if pilas.escena_actual().control.izquierda:
            vx = -(self.receptor.velocidad)
            if not self.receptor.espejado:
                self.receptor.espejado = True
            #self.receptor.x -= VELOCIDAD
            self.receptor.obtener_colisiones()
            if not (self.receptor.colisiona_arriba_izquierda
                    or self.receptor.colisiona_abajo_izquierda):
                self.receptor.x += vx

        elif pilas.escena_actual().control.derecha:
            vx = self.receptor.velocidad
            if self.receptor.espejado:
                self.receptor.espejado = False
            #self.receptor.x += VELOCIDAD
            self.receptor.obtener_colisiones()
            if not (self.receptor.colisiona_arriba_derecha
                    or self.receptor.colisiona_abajo_derecha):
                self.receptor.x += vx
        else:
            self.receptor.hacer(Esperando())

        if pilas.escena_actual().control.arriba:
            self.receptor.hacer(Saltando(-9))

        self.caer_si_no_toca_el_suelo()
コード例 #23
0
    def __init__(self,
                 texto="None",
                 x=0,
                 y=0,
                 magnitud=17,
                 autoeliminar=False,
                 retraso=5):
        """Inicializa el texto.

        :param texto: Texto a mostrar.
        :param x: Posición horizontal.
        :param y: Posición vertical.
        :param magnitud: Tamaño del texto.
        :param vertical: Si el texto será vertical u horizontal, como True o False.
        """
        Texto.__init__(self, texto, x, y, magnitud)
        izquierda, derecha, arriba, abajo = pilas.utils.obtener_bordes()

        # Se asegura de que solo exista un texto inferior
        if TextoInferior.anterior_texto:
            TextoInferior.anterior_texto.eliminar()

        self.z = -100
        TextoInferior.anterior_texto = self
        self._crear_sombra()

        self.centro = ("centro", "centro")
        self.izquierda = izquierda + 10
        self.color = pilas.colores.blanco
        self.abajo = abajo + 10
        self.fijo = True

        if autoeliminar:
            pilas.escena_actual().tareas.una_vez(retraso, self.eliminar)
コード例 #24
0
def definir_gravedad(x, y):
    """Define la gravedad del motor de física.

    :param x: Aceleración horizontal.
    :param y: Aceleración vertical.
    """
    pilas.escena_actual().fisica.definir_gravedad(x, y)
コード例 #25
0
    def __init__(self, receptor, control=None, direcciones=OCHO_DIRECCIONES, velocidad_maxima=4,
                 aceleracion=1, deceleracion=0.1, con_rotacion=False, velocidad_rotacion=1, marcha_atras=True):
        """Inicializa la habilidad.

        :param receptor: Referencia al actor que aprenderá la habilidad.
        :param control: Control al que va a responder para mover el Actor.
        :param direcciones: Establece si puede mover en cualquier direccion o unicamente en 4 direcciones arriba, abajo, izquierda y derecha. El parametro con_rotacion establece las direcciones a OCHO_DIRECCIONES siempre.
        :param velocidad_maxima: Velocidad maxima en pixeles a la que se moverá el Actor.
        :param aceleracion: Indica lo rapido que acelera el actor hasta su velocidad máxima.
        :param deceleracion: Indica lo rapido que decelera el actor hasta parar.
        :param con_rotacion: Si deseas que el actor rote pulsando las teclas de izquierda y derecha.
        :param velocidad_rotacion: Indica lo rapido que rota un actor sobre si mismo.
        :param marcha_atras: Posibilidad de ir hacia atrás. (True o False)
        """

        Habilidad.__init__(self, receptor)
        pilas.escena_actual().actualizar.conectar(self.on_key_press)

        if control == None:
            self.control = self.receptor.escena.control
        else:
            self.control = control

        self.direcciones = direcciones

        self.velocidad = 0
        self.deceleracion = deceleracion
        self._velocidad_maxima = velocidad_maxima
        self._aceleracion = aceleracion
        self.con_rotacion = con_rotacion
        self.velocidad_rotacion = velocidad_rotacion
        self.marcha_atras = marcha_atras
コード例 #26
0
ファイル: camara.py プロジェクト: lucciano/pilas
    def _set_y(self, y):
        """Define la posición vertical de la cámara.

        :param y: Posición vertical.
        """
        pilas.escena_actual().mueve_camara.emitir(x=self.x, y=y, dx=0, dy=y-self.y)
        pilas.mundo.motor.definir_centro_de_la_camara(self.x, y)
コード例 #27
0
ファイル: Pjs.py プロジェクト: Gaston1997/FortunaPilas
    def actualizar(self):
        self.avanzar_animacion()

        vx = 0

        if pilas.escena_actual().control.izquierda:
            vx = -(self.receptor.velocidad)
            self.receptor.espejado = True
            self.receptor.habilidades.Disparar.angulo_salida_disparo = 90
            self.receptor.obtener_colisiones()
            if not(self.receptor.colisiona_arriba_izquierda or self.receptor.colisiona_abajo_izquierda):
                self.receptor.x += vx

        elif pilas.escena_actual().control.derecha:
            vx = self.receptor.velocidad
            self.receptor.espejado = False
            self.receptor.habilidades.Disparar.angulo_salida_disparo = -90
            self.receptor.obtener_colisiones()
            if not(self.receptor.colisiona_arriba_derecha or self.receptor.colisiona_abajo_derecha):
                self.receptor.x += vx
        else:
            self.receptor.hacer(Esperando())


        if pilas.escena_actual().control.arriba:
            self.receptor.hacer(Saltando(-8))

        self.caer_si_no_toca_el_suelo()
コード例 #28
0
ファイル: Pjs.py プロジェクト: Gaston1997/FortunaPilas
    def actualizar(self):
        self.velocidad_de_salto += 0.25
        distancia = self.receptor.obtener_distancia_al_suelo()

        # Si toca el suelo se detiene.
        if self.velocidad_de_salto > distancia:
            self.receptor.y -= distancia
            self.receptor.hacer(Esperando())
        else:
            self.receptor.y -= self.velocidad_de_salto

        # obtiene la veloridad del personaje para detectar cuando
        # toca el suelo.
        vx, vy = 0, 0 #self.receptor.figura.obtener_velocidad_lineal()

        if pilas.escena_actual().control.izquierda:
            vx = -(self.receptor.velocidad)
            self.receptor.espejado = True
            self.receptor.habilidades.Disparar.angulo_salida_disparo = 90
            self.receptor.obtener_colisiones()
            if not(self.receptor.colisiona_arriba_izquierda or self.receptor.colisiona_abajo_izquierda):
                self.receptor.x += vx

        elif pilas.escena_actual().control.derecha:
            vx = self.receptor.velocidad
            self.receptor.espejado = False
            self.receptor.habilidades.Disparar.angulo_salida_disparo = -90
            self.receptor.obtener_colisiones()
            if not(self.receptor.colisiona_arriba_derecha or self.receptor.colisiona_abajo_derecha):
                self.receptor.x += vx
コード例 #29
0
ファイル: colisiones.py プロジェクト: DanKaLeo/pilas
    def _verificar_colisiones_fisicas_en_tupla(self, tupla, id_actor_a, id_actor_b):
        "Toma dos grupos de actores y analiza colisiones entre ellos."
        (grupo_a, grupo_b, funcion_a_llamar) = tupla

        for a in grupo_a:
            for b in grupo_b:
                try:
                    if self._es_objeto_fisico_con_actor_asociado(a):
                        a_id = a.figura.id
                    else:
                        a_id = a.id

                    if self._es_objeto_fisico_con_actor_asociado(b):
                        b_id = b.figura.id
                    else:
                        b_id = b.id

                    if a_id == id_actor_a and b_id == id_actor_b:
                        funcion_a_llamar(a, b)

                        # verifica si alguno de los dos objetos muere en la colision.
                        if (self._es_objeto_fisico_con_actor_asociado(a)):
                            if a not in pilas.escena_actual().actores:
                                if a in grupo_a:
                                    list.remove(grupo_a, a)

                        if (self._es_objeto_fisico_con_actor_asociado(b)):
                            if b not in pilas.escena_actual().actores:
                                if b in grupo_b:
                                    list.remove(grupo_b, b)

                except Exception as e:
                    list.remove(grupo_a, a)
                    raise e
コード例 #30
0
     def cuando_colisionan2(protagonista2, bombas):
         """Es la funcion que se ejecuta cuando se pierde"""
         for i in range(len(self.bombas)):
             self.bombas[i].eliminar()
         self.temporizador.eliminar()
         pilas.escena_actual().tareas.eliminar_todas()
         self.perdiste.reproducir()
         textoo=pilas.actores.Texto("PERDISTE!! =S")
         textoo.y=70
         textoo.color=pilas.colores.rojo
         texto3=pilas.actores.Texto("Tu puntaje: " + self.puntaje.obtener_texto())
         texto3.y=130
         texto3.color=pilas.colores.rojo
         fondo = pilas.fondos.Fondo("loser.png")
         fondo.escala = 1.30
         self.musica.detener()
         def iniciar_juego_de_nuevo(): #Inicia de nuevo el juego
             pilas.cambiar_escena(Juego())
         def volver_menu(): #Vuelve al menu principal
             pilas.mundo.motor.mostrar_puntero_del_mouse()
             pilas.cambiar_escena(Menu())
         def salir_del_juego(): #sale del juego
             pilas.terminar()
         self.moneda.eliminar()
         def guarda_puntaje():
             pilas.mundo.motor.mostrar_puntero_del_mouse()
             puntaje = self.puntaje.obtener_texto()
             pilas.cambiar_escena(GuardarPuntaje(puntaje))
 
         menu = pilas.actores.Menu([("Reiniciar juego", iniciar_juego_de_nuevo),
                                    ("Volver al menu principal", volver_menu),
                                    ("Guardar puntaje", guarda_puntaje),
                                    ("Salir", salir_del_juego),
                                    ])
         menu.color = pilas.colores.rojo
コード例 #31
0
ファイル: habilidades.py プロジェクト: DanKaLeo/pilas
 def cuando_arrastra(self, evento):
     "Arrastra el actor a la posicion indicada por el puntero del mouse."
     if self._el_receptor_tiene_fisica():
         pilas.escena_actual().fisica.cuando_mueve_el_mouse(evento.x, evento.y)
     else:
         self.receptor.x += evento.dx
         self.receptor.y += evento.dy
コード例 #32
0
ファイル: habilidades.py プロジェクト: DanKaLeo/pilas
 def cuando_intenta_arrastrar(self, evento):
     "Intenta mover el objeto con el mouse cuando se pulsa sobre el."
     if (evento.boton == 1):
         if self.receptor.colisiona_con_un_punto(evento.x, evento.y):
             pilas.escena_actual().termina_click.conectar(self.cuando_termina_de_arrastrar, id='cuando_termina_de_arrastrar')
             pilas.escena_actual().mueve_mouse.conectar(self.cuando_arrastra, id='cuando_arrastra')
             self.comienza_a_arrastrar()
コード例 #33
0
ファイル: utils.py プロジェクト: hectorsanchez/pilas
def eliminar_a_todos():
    a_eliminar = pilas.escena_actual().actores[1:]  # evita borrar el fondo.

    for x in a_eliminar:
        x.eliminar()

    pilas.escena_actual().actores = []
コード例 #34
0
ファイル: martian.py プロジェクト: FacuSautu/Kombat_System
    def actualizar(self):
        self.velocidad_de_salto += 0.25
        distancia = self.receptor.obtener_distancia_al_suelo()

        # Si toca el suelo se detiene.
        if self.velocidad_de_salto > distancia:
            self.receptor.y -= distancia
            self.receptor.hacer(Esperando())
        else:
            self.receptor.y -= self.velocidad_de_salto

        # obtiene la veloridad del personaje para detectar cuando
        # toca el suelo.
        vx, vy = 0, 0  #self.receptor.figura.obtener_velocidad_lineal()

        if pilas.escena_actual().control.izquierda:
            vx = -(self.receptor.velocidad)
            self.receptor.espejado = True
            self.receptor.habilidades.Disparar.angulo_salida_disparo = 90
            self.receptor.obtener_colisiones()
            if not (self.receptor.colisiona_arriba_izquierda
                    or self.receptor.colisiona_abajo_izquierda):
                self.receptor.x += vx

        elif pilas.escena_actual().control.derecha:
            vx = self.receptor.velocidad
            self.receptor.espejado = False
            self.receptor.habilidades.Disparar.angulo_salida_disparo = -90
            self.receptor.obtener_colisiones()
            if not (self.receptor.colisiona_arriba_derecha
                    or self.receptor.colisiona_abajo_derecha):
                self.receptor.x += vx
コード例 #35
0
ファイル: texto_inferior.py プロジェクト: hectorsanchez/pilas
    def __init__(self,
                 texto="None",
                 x=0,
                 y=0,
                 magnitud=17,
                 autoeliminar=False,
                 retraso=5):
        Texto.__init__(self, texto, x, y, magnitud)
        izquierda, derecha, arriba, abajo = pilas.utils.obtener_bordes()

        # Se asegura de que solo exista un texto inferior
        if TextoInferior.anterior_texto:
            TextoInferior.anterior_texto.eliminar()

        self.z = -100
        TextoInferior.anterior_texto = self
        self._crear_sombra()

        self.centro = ("centro", "centro")
        self.izquierda = izquierda + 10
        self.color = pilas.colores.blanco
        self.abajo = abajo + 10
        self.fijo = True

        if autoeliminar:
            pilas.escena_actual().tareas.una_vez(retraso, self.eliminar)
コード例 #36
0
ファイル: habilidades.py プロジェクト: DanKaLeo/pilas
    def __init__(self, receptor, control=None, direcciones=OCHO_DIRECCIONES, velocidad_maxima=4,
                 aceleracion=1, deceleracion=0.1, con_rotacion=False, velocidad_rotacion=1, marcha_atras=True):
        """Inicializa la habilidad.

        :param receptor: Referencia al actor que aprenderá la habilidad.
        :param control: Control al que va a responder para mover el Actor.
        :param direcciones: Establece si puede mover en cualquier direccion o unicamente en 4 direcciones arriba, abajo, izquierda y derecha. El parametro con_rotacion establece las direcciones a OCHO_DIRECCIONES siempre.
        :param velocidad_maxima: Velocidad maxima en pixeles a la que se moverá el Actor.
        :param aceleracion: Indica lo rapido que acelera el actor hasta su velocidad máxima.
        :param deceleracion: Indica lo rapido que decelera el actor hasta parar.
        :param con_rotacion: Si deseas que el actor rote pulsando las teclas de izquierda y derecha.
        :param velocidad_rotacion: Indica lo rapido que rota un actor sobre si mismo.
        :param marcha_atras: Posibilidad de ir hacia atrás. (True o False)
        """

        Habilidad.__init__(self, receptor)
        pilas.escena_actual().actualizar.conectar(self.on_key_press)

        if control == None:
            self.control = self.receptor.escena.control
        else:
            self.control = control

        self.direcciones = direcciones

        self.velocidad = 0
        self.deceleracion = deceleracion
        self._velocidad_maxima = velocidad_maxima
        self._aceleracion = aceleracion
        self.con_rotacion = con_rotacion
        self.velocidad_rotacion = velocidad_rotacion
        self.marcha_atras = marcha_atras
コード例 #37
0
ファイル: martian.py プロジェクト: FacuSautu/Kombat_System
    def actualizar(self):
        self.avanzar_animacion()

        vx = 0

        if pilas.escena_actual().control.izquierda:
            vx = -(self.receptor.velocidad)
            self.receptor.espejado = True
            self.receptor.habilidades.Disparar.angulo_salida_disparo = 90
            self.receptor.obtener_colisiones()
            if not (self.receptor.colisiona_arriba_izquierda
                    or self.receptor.colisiona_abajo_izquierda):
                self.receptor.x += vx

        elif pilas.escena_actual().control.derecha:
            vx = self.receptor.velocidad
            self.receptor.espejado = False
            self.receptor.habilidades.Disparar.angulo_salida_disparo = -90
            self.receptor.obtener_colisiones()
            if not (self.receptor.colisiona_arriba_derecha
                    or self.receptor.colisiona_abajo_derecha):
                self.receptor.x += vx
        else:
            self.receptor.hacer(Esperando())

        if pilas.escena_actual().control.arriba:
            self.receptor.hacer(Saltando(-8))

        self.caer_si_no_toca_el_suelo()
コード例 #38
0
ファイル: personajes_rpg.py プロジェクト: hectorsanchez/pilas
    def actualizar(self):
        self.avanzar_animacion()

        dx = 0
        dy = 0

        if pilas.escena_actual().control.izquierda:
            dx = self.receptor.velocidad * -1
            self.receptor.direccion = pilas.actores.personajes_rpg.OESTE
        elif pilas.escena_actual().control.derecha:
            dx = self.receptor.velocidad
            self.receptor.direccion = pilas.actores.personajes_rpg.ESTE
        elif pilas.escena_actual().control.arriba:
            dy = self.receptor.velocidad
            self.receptor.direccion = pilas.actores.personajes_rpg.NORTE
        elif pilas.escena_actual().control.abajo:
            dy = self.receptor.velocidad * -1
            self.receptor.direccion = pilas.actores.personajes_rpg.SUR
        else:
            self.receptor.hacer(Esperando())

        if not (self.receptor.mapa.es_punto_solido(self.receptor.x + dx,
                                                   self.receptor.y + dy)):
            self.receptor.x += dx
            self.receptor.y += dy
コード例 #39
0
ファイル: robot.py プロジェクト: DrDub/pilas
    def _realizarGiro(self, vel, seconds):

        def izquierdaSinTiempo():
            self.actor.hacer(pilas.comportamientos.Girar(-abs(self.actor.velocidad), self.actor.velocidad))
            return (self.movimiento)

        def derechaSinTiempo():
            self.actor.hacer(pilas.comportamientos.Girar(abs(self.actor.velocidad), self.actor.velocidad))
            return (self.movimiento)

        self.stop()
        self._setVelocidad(vel)


        if (self._velocidadValida(vel, 10, 100)) :
            self.movimiento = True
            self.tarea = pilas.escena_actual().tareas.condicional(0.1, derechaSinTiempo)
            if (seconds != -1):
                wait(seconds)
                self.stop()
        elif (self._velocidadValida(vel, -100, -10)) :
            self.movimiento = True
            self.tarea = pilas.escena_actual().tareas.condicional(0.1, izquierdaSinTiempo)
            self.actor.velocidad = self.actor.velocidad * -1
            if (seconds != -1):
                 wait(seconds)
                 self.stop()
        else:
            print   """ Rangos de velocidades válidas:
コード例 #40
0
ファイル: utils.py プロジェクト: lucciano/pilas
def insertar_como_nuevo_actor(actor):
    """Coloca a un actor en la lista de actores a imprimir en pantalla.

    :param actor: Actor que se quiere comenzar a mostrar en pantalla.
    """
    pilas.escena_actual().actores.append(actor)
    actor.escena = pilas.escena_actual()
コード例 #41
0
ファイル: utils.py プロジェクト: FacuSautu/Kombat_System
def insertar_como_nuevo_actor(actor):
    """Coloca a un actor en la lista de actores a imprimir en pantalla.

    :param actor: Actor que se quiere comenzar a mostrar en pantalla.
    """
    pilas.escena_actual().actores.append(actor)
    actor.escena = pilas.escena_actual()
コード例 #42
0
            def cuando_colisionan(autobueno,autito):
                for i in range(len(self.autitosmalos)):
                    self.autitosmalos[i].eliminar()
                autobueno.eliminar()
                pilas.escena_actual().tareas.eliminar_todas()
                Fondo= pilas.imagenes.cargar("personajes/autos.jpg")
                fondo_perdedor= pilas.fondos.Fondo(Fondo)
                texto3=pilas.actores.Texto("Tu ultimo puntaje es : " + self.puntaje.obtener_texto())
                texto3.y=70
                texto3.color = pilas.colores.verde 
                textoo=pilas.actores.Texto("Termino el juego mas suerte para la proxima ")
                textoo.y=130
                textoo.color = pilas.colores.amarillo
 #___________________________________menu de colision_____________________________________________#
                
                def iniciar_juego_de_nuevo(): #Inicia de nuevo el juego
                    pilas.cambiar_escena(EscenaDeJuego())
                def volver_menu(): #Vuelve al menu principal
                    pilas.mundo.motor.mostrar_puntero_del_mouse()
                    pilas.cambiar_escena(EscenaDeMenu())
                def salir_del_juego(): #sale del juego
                    pilas.terminar()
                def guarda_puntaje():
                    pilas.mundo.motor.mostrar_puntero_del_mouse()
                    puntaje = self.puntaje.obtener_texto()
                    pilas.cambiar_escena(GuardarPuntaje(puntaje))
               
                menu = pilas.actores.Menu([("Reiniciar juego", iniciar_juego_de_nuevo),
                                           ("Volver al menu principal", volver_menu),
                                           ("Guardar puntaje", guarda_puntaje),
                                           ("Salir", salir_del_juego),
                                          ]) 
コード例 #43
0
ファイル: comelon.py プロジェクト: debian789/ClonMarioPilas
	def actualizar(self):
		self.avanzar_animacion()
		vx = 0

		if pilas.escena_actual().control.izquierda:
			vx = -(self.receptor.velocidad)
			if not self.receptor.espejado:
				self.receptor.espejado = True
			#self.receptor.x -= VELOCIDAD
			self.receptor.obtener_colisiones()
			if not(self.receptor.colisiona_arriba_izquierda or self.receptor.colisiona_abajo_izquierda):
				self.receptor.x += vx

		elif pilas.escena_actual().control.derecha:
			vx =  self.receptor.velocidad
			if self.receptor.espejado:
				self.receptor.espejado = False 
			#self.receptor.x += VELOCIDAD
			self.receptor.obtener_colisiones()
			if not(self.receptor.colisiona_arriba_derecha or self.receptor.colisiona_abajo_derecha):
				self.receptor.x +=vx
		else:
			self.receptor.hacer(Esperando())

		if pilas.escena_actual().control.arriba:
			self.receptor.hacer(Saltando(-9))


		self.caer_si_no_toca_el_suelo()
コード例 #44
0
 def destruir(self):
     """Elimina a un actor pero de manera inmediata."""
     self._vivo = False
     self.eliminar_habilidades()
     self.eliminar_comportamientos()
     # Solo permite eliminar el actor si está en su escena.
     if self in pilas.escena_actual().actores:
         pilas.escena_actual().actores.remove(self)
コード例 #45
0
    def actualizar(self):
        if pilas.escena_actual().control.izquierda:
            self.receptor.hacer(Caminando())
        elif pilas.escena_actual().control.derecha:
            self.receptor.hacer(Caminando())

        if pilas.escena_actual().control.arriba:
            self.receptor.hacer(Saltando())
コード例 #46
0
ファイル: habilidades.py プロジェクト: hectorsanchez/pilas
    def __init__(self, receptor, lado_seguimiento=ARRIBA):
        Habilidad.__init__(self, receptor)
        pilas.escena_actual().mueve_mouse.conectar(self.se_movio_el_mouse)
        pilas.escena_actual().actualizar.conectar(self.rotar)
        self.lado_seguimiento = lado_seguimiento

        self.raton_x = receptor.x
        self.raton_y = receptor.y
コード例 #47
0
ファイル: disparar_a_monos.py プロジェクト: DanKaLeo/pilas
def perder(torreta, enemigo):
    global fin_de_juego

    enemigo.sonreir()
    torreta.eliminar()
    pilas.escena_actual().tareas.eliminar_todas()
    fin_de_juego = True
    pilas.avisar("GAME OVER. Conseguiste %d puntos" %(puntos.obtener()))
コード例 #48
0
ファイル: habilidades.py プロジェクト: hectorsanchez/pilas
    def __init__(self, receptor, lado_seguimiento=ARRIBA):
        Habilidad.__init__(self, receptor)
        pilas.escena_actual().mueve_mouse.conectar(self.se_movio_el_mouse)
        pilas.escena_actual().actualizar.conectar(self.rotar)
        self.lado_seguimiento = lado_seguimiento

        self.raton_x = receptor.x
        self.raton_y = receptor.y
コード例 #49
0
ファイル: utils.py プロジェクト: ariel17/pilas
def eliminar_a_todos():
    """Elimina a todos los actores de la escena."""
    a_eliminar = pilas.escena_actual().actores[1:]    # evita borrar el fondo.

    for x in a_eliminar:
        x.eliminar()

    pilas.escena_actual().actores = []
コード例 #50
0
ファイル: utils.py プロジェクト: ariel17/pilas
def destruir_a_todos():
    """Elimina a los actores inmediatamente (evita que exploten o hagan algo)."""
    a_eliminar = pilas.escena_actual().actores

    for x in a_eliminar:
        x.destruir()

    pilas.escena_actual().actores = []
コード例 #51
0
ファイル: actor.py プロジェクト: apehua/m6
 def destruir(self):
     """Elimina a un actor pero de manera inmediata."""
     self._vivo = False
     self.eliminar_habilidades()
     self.eliminar_comportamientos()
     # Solo permite eliminar el actor si está en su escena.
     if self in pilas.escena_actual().actores:
         pilas.escena_actual().actores.remove(self)
コード例 #52
0
ファイル: tank.py プロジェクト: quiqueporta/tank
    def plantar_bomba(self):
        if self.tiene_bomba:
            bomba = pilas.actores.Bomba(x=self.x, y=self.y)
            bomba.escala = 0.5

            self.tiene_bomba = False

            pilas.escena_actual().colisiones.agregar(self.enemigo, bomba, self.destruir_enemigo)
コード例 #53
0
ファイル: pingu.py プロジェクト: franquitt/pilas
    def actualizar(self):
        if pilas.escena_actual().control.izquierda:
            self.receptor.hacer(Caminando())
        elif pilas.escena_actual().control.derecha:
            self.receptor.hacer(Caminando())

        if pilas.escena_actual().control.arriba:
            self.receptor.hacer(Saltando())
コード例 #54
0
def perder(torreta, enemigo):
    global fin_de_juego

    enemigo.sonreir()
    torreta.eliminar()
    pilas.escena_actual().tareas.eliminar_todas()
    fin_de_juego = True
    pilas.avisar("GAME OVER. Conseguiste %d puntos" % (puntos.obtener()))
コード例 #55
0
ファイル: utils.py プロジェクト: hectorsanchez/pilas
def destruir_a_todos():
    "Elimina a los actores inmediatamente (evita que exploten o hagan algo)."
    a_eliminar = pilas.escena_actual().actores

    for x in a_eliminar:
        x.destruir()

    pilas.escena_actual().actores = []
コード例 #56
0
 def dibuja_al_actor(self, motor, painter, lienzo, actor):
     if not isinstance(actor, pilas.fondos.Fondo):
         texto = "(%d, %d)" % (actor.x, actor.y)
         lienzo.texto(painter,
                      texto,
                      actor.derecha - pilas.escena_actual().camara.x,
                      actor.abajo - pilas.escena_actual().camara.y,
                      color=pilas.colores.violeta)
コード例 #57
0
def crear_enemigo():

    enemigo = pilas.actores.Mono()
    x = random.randrange(-320, 320)
    y = random.randrange(-240, 240)

    # Hace que la aceituna aparezca gradualmente, aumentando de tamaño.
    enemigo.escala = 0
    enemigo.escala = pilas.interpolar(0.5, duracion=0.5, tipo='elastico_final')

    enemigo.aprender(pilas.habilidades.PuedeExplotar)

    if x >= 0 and x <= 100:
        x = 180
    elif x <= 0 and x >= -100:
        x = -180

    if y >= 0 and y <= 100:
        y = 180
    elif y <= 0 and y >= -100:
        y = -180

    enemigo.x = x
    enemigo.y = y

    enemigos.append(enemigo)

    tipo_interpolacion = [
        'lineal', 'aceleracion_gradual', 'desaceleracion_gradual',
        'rebote_inicial', 'rebote_final'
    ]

    enemigo.x = pilas.interpolar(0,
                                 tiempo,
                                 tipo=random.choice(tipo_interpolacion))
    enemigo.y = pilas.interpolar(0,
                                 tiempo,
                                 tipo=random.choice(tipo_interpolacion))

    if random.randrange(0, 20) > 15:
        if issubclass(torreta.habilidades.DispararConClick.municion,
                      municion_bala_simple):

            estrella = pilas.actores.Estrella(x, y)
            estrella.escala = pilas.interpolar(0.5,
                                               duracion=0.5,
                                               tipo='elastico_final')

            pilas.escena_actual().colisiones.agregar(
                estrella, torreta.habilidades.DispararConClick.proyectiles,
                asignar_arma_doble)

            pilas.mundo.agregar_tarea(3, eliminar_estrella, estrella)

    if fin_de_juego:
        return False
    else:
        return True