Python actores.Actor类代码示例

    def __init__(self, x=0, y=0, ancho=None, alto=None):
        # Si no define area de la pizarra toma el tamano de la ventana.
        if not ancho or not alto:
            ancho, alto = pilas.mundo.motor.obtener_area()

        Actor.__init__(self, x=x, y=y)
        self.imagen = pilas.imagenes.cargar_superficie(ancho, alto)

    def __init__(self, x=0, y=0, tamano="grande", dx=0, dy=0):
        """Genera el actor.

        :param x: Posición horizontal del actor.
        :param y: Posición vertical del actor.
        :param tamano: Tamaño que tendrá la piedra, puerde ser "grande", "media" o  "chica"
        :param dx: Velocidad horizontal del movimiento.
        :param dy: Velocidad vertical del movimiento.
        """

        imagen = pilas.imagenes.cargar('piedra_' + tamano + '.png')
        Actor.__init__(self, imagen)
        self.rotacion = 0
        self.x = x
        self.y = y
        self.dx = dx
        self.dy = dy

        radios = {
                'grande': 25,
                'media': 20,
                'chica': 10,
                }

        self.radio_de_colision = radios[tamano]
        self.aprender(pilas.habilidades.SeMantieneEnPantalla)

 def __init__(self, x=0, y=0):
     imagen = pilas.imagenes.cargar('caja.png')
     Actor.__init__(self, imagen)
     self.rotacion = 0
     self.x = x
     self.y = y
     self.radio_de_colision = 25

    def __init__(self, control, imagen, puntaje):

        # Obtenemos la imagen del tanque.
        imagen_tanque = pilas.imagenes.cargar_imagen(imagen)

        x = random.randrange(-320, 320)
        y = random.randrange(-240, 240)

        # Iniciamos el actor con la imagen del tanque.
        Actor.__init__(self, imagen_tanque, x=x, y=y)

        # Establecemos la habilidad de disparar al tanque.
        self.aprender(
            pilas.habilidades.Disparar, control=control, frecuencia_de_disparo=2, cuando_dispara=self.plantar_bomba
        )

        # Establecemos la habilidad de moverse.
        self.aprender(
            pilas.habilidades.MoverseComoCoche,
            control=control,
            velocidad_maxima=2,
            deceleracion=0.05,
            velocidad_rotacion=0.5,
        )

        # Habilidad para que nunca desaparezca de la pantalla.
        self.aprender(pilas.habilidades.SeMantieneEnPantalla)

        self.aprender(pilas.habilidades.PuedeExplotar)

        self.tiene_bomba = False

        self.vidas = puntaje

    def __init__(self, x=0, y=0):
        """
        Constructor del cursor de la mano.

        :param x: posicion horizontal del cursor.
        :type x: int
        :param y: posicion vertical del cursor.
        :type y: int

        """
        self._cargar_imagenes()
        Actor.__init__(self, self.imagen_normal)
        self.x = x
        self.y = y

        self.aprender(pilas.habilidades.SeguirAlMouse)
        pilas.mundo.motor.ocultar_puntero_del_mouse()
        self.z = -200
        self.pulsado = False

        self.centro = ("izquierda", "arriba")

        self.escena.mueve_mouse.conectar(self.cuando_mueve_el_mouse)
        self.escena.click_de_mouse.conectar(self.cuando_pulsa_el_mouse)
        self.escena.termina_click.conectar(self.cuando_suelta_el_mouse)

 def __init__(self, pelotas):
     self.pelotas = pelotas
     Actor.__init__(self, x=20)
     self.animacion = pilas.imagenes.cargar_grilla("pingu.png", 10)
     self.definir_cuadro(4)
     self.hacer(Saltando(0))
     self.radio_de_colision = 30

    def __init__(self, mapa, x=0, y=0):
        Actor.__init__(self, x=x, y=y)
        self.imagen = pilas.imagenes.cargar_grilla("megaman.png", 12)
        self.definir_cuadro(0)
        self.mapa = mapa
        self.hacer(Esperando())
        self.cuadros = [1, 1, 1, 2, 2, 2]
        self.paso=0
        self.radio_de_colision = 18
        self.municion = pilas.actores.proyectil.Bala
        self.centro = ("centro", "centro")
        self.aprender(pilas.habilidades.Disparar,
                       municion=pilas.actores.proyectil.Bala,
                       angulo_salida_disparo=-90,
                       frecuencia_de_disparo=8,
                       offset_disparo=(25,0),
                       offset_origen_actor=(25,23))
        
        self.velocidad = 5

        self.colisiona_arriba_izquierda = False
        self.colisiona_arriba_derecha = False
        self.colisiona_abajo_izquierda = False
        self.colisiona_abajo_derecha = False

        self.obtener_colisiones()

    def __init__(self, opciones, x=0, y=0, fuente=None,
                    color_normal=pilas.colores.gris,
                    color_resaltado=pilas.colores.blanco):
        """Inicializa el menú.

        :param opciones: Tupla con al menos dos elementos obligatorios (:texto:, :funcion:) y :argumentos: opcionales
        :param x: Posicion en el eje x
        :param y: Posicion en el eje y
        """
        self.opciones_como_actores = []
        self.iconos_de_opciones = []
        self.demora_al_responder = 0
        Actor.__init__(self, "invisible.png", x=x, y=y)
        self._verificar_opciones(opciones)
        self.crear_texto_de_las_opciones(opciones, fuente, color_normal, color_resaltado)
        self.opciones = opciones
        self.seleccionar_primer_opcion()
        self.opcion_actual = 0
        # contador para evitar la repeticion de teclas
        self.activar()

        # Mapeamos unas teclas para mover el menu
        teclas = {pilas.simbolos.IZQUIERDA: 'izquierda',
                              pilas.simbolos.DERECHA: 'derecha',
                              pilas.simbolos.ARRIBA: 'arriba',
                              pilas.simbolos.ABAJO: 'abajo',
                              pilas.simbolos.SELECCION: 'boton'}

        # Creamos un control personalizado
        self.control_menu = pilas.control.Control(pilas.escena_actual(), teclas)

    def __init__(self, x=0, y=0,
                ruta_normal='boton/boton_normal.png',
                ruta_press='boton/boton_press.png',
                ruta_over='boton/boton_over.png',
                ):
        """ Constructor del Boton.

        :param x: Posición horizontal del Actor.
        :type x: int
        :param y: Posición vertical del Actor.
        :type y: int
        :param ruta_normal: Ruta de la imagen del boton en estado normal.
        :type ruta_normal: string
        :param ruta_press: Ruta de la imagen del boton cuando se presiona.
        :type ruta_press: string
        :param ruta_over: Ruta de la imagen del boton cuando el ratón pasa por encima.
        :type ruta_over: string
        """

        self.ruta_normal = ruta_normal
        self.ruta_press = ruta_press
        self.ruta_over = ruta_over

        self.funciones_normal = []
        self.funciones_press = []
        self.funciones_over = []

        self.estado = True

        Actor.__init__(self, ruta_normal, x=x, y=y)
        self._cargar_imagenes(self.ruta_normal, self.ruta_press, self.ruta_over)

        self.escena.mueve_mouse.conectar(self.detection_move_mouse)
        self.escena.click_de_mouse.conectar(self.detection_click_mouse)
        self.escena.termina_click.conectar(self.detection_end_click_mouse)

    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

 def __init__(self, x=0, y=0):
     '''Genera el actor, carga la imágen y su radio, y le enseña sus habilidades.'''
     Actor.__init__(self, x=x, y=y)
     self.imagen = pilas.imagenes.cargar('escena/actor/base/azul.bmp')
     self.radio_de_colision = 15
     self.aprender(SeMantieneEnPantalla)
     self.aprender(self.MoverseConArribaAbajo)

    def __init__(self, x=0, y=0, progreso=100, ancho=200, alto=30, color_relleno=pilas.colores.amarillo, con_sombra=True, con_brillo=True):
        """ Constructor de la barra de Energia.

        :param x: Posición horizontal de la barra.
        :type x: int
        :param y: Posición vertical de la barra.
        :type y: int
        :param progreso: Valor actual de la barra de enegia. Debe tener un valor entre 0 o 100.
        :type progreso: int
        :param ancho: Ancho de la barra de energia en pixeles.
        :type ancho: int
        :param alto: Alto de la barra de energia en pixeles.
        :type alto: int
        :param color_relleno: Color de la barra de Energia.
        :type color_relleno: pilas.colores.Color
        :param con_sombra: Permite mostrar una pequeña sombra en la barra de Energia.
        :type con_sombra: boolean
        :param con_brillo: Permite mostrar un pequeño brillo en la barra de Energia.
        :type con_brillo: boolean

        """
        Actor.__init__(self, x=x, y=y)
        self.area_ancho = ancho
        self.area_alto = alto
        self.progreso = progreso
        self.progreso_anterior = progreso
        self.imagen = pilas.imagenes.cargar_superficie(self.area_ancho, self.area_alto)
        self.color_relleno = color_relleno
        self.con_sombra = con_sombra
        self.con_brillo = con_brillo
        self.pintar_imagen()
        self.fijo = True
        self.miniatura = None

    def __init__(self, x=0, y=0):
        self.cuadro_normal = pilas.imagenes.cargar("zanahoria_normal.png")
        self.cuadro_reir = pilas.imagenes.cargar("zanahoria_sonrie.png")

        Actor.__init__(self, x=x, y=y)
        self.normal()
        self.radio_de_colision = 25

 def __init__(self, x=0, y=0):
     Actor.__init__(self, x=x, y=y)
     self.imagen = pilas.imagenes.cargar_grilla("pingu.png", 10)
     self.definir_cuadro(4)
     self.hacer(Esperando())
     self.radio_de_colision = 30
     self.centro = ("centro", "abajo")

    def __init__(self, x=0, y=0, rotacion=0, velocidad_maxima=6,
                 angulo_de_movimiento=90):

        """
        Construye la Ojota.

        :param x: Posición x del proyectil.
        :param y: Posición y del proyectil.
        :param rotacion: Angulo de rotación del Actor.
        :param velocidad_maxima: Velocidad máxima que alcanzará el proyectil.
        :param angulo_de_movimiento: Angulo en que se moverá el Actor..

        """
        imagen = pilas.imagenes.cargar('imagenes/proyectiles/chancleta.png')
        Actor.__init__(self, imagen)
        self.x = x
        self.y = y
        self.rotacion = rotacion
        self.escala = 2
        self.radio_de_colision = 20

        self.hacer(pilas.comportamientos.Proyectil(velocidad_maxima=velocidad_maxima,
                                                   aceleracion=1,
                                                   angulo_de_movimiento=angulo_de_movimiento,
                                                   gravedad=0))