pilas.actores.actor.Actor

Package pilas :: Package actores :: Module actor :: Class Actor |
[hide private]
[frames] | no frames]

# Class Actor

source code

                   object --+
                            |
    estudiante.Estudiante --+
                            |
                           Actor

Known Subclasses:
  - fondos.Fondo
  - , proyectil.Bala
  - , interfaz.base_interfaz.BaseInterfaz
  - , cooperativista.Cooperativista
  - , mapa.Mapa
  - , personajes_rpg.BasePersonajeRPG
  - , pausa.Pausa
  - , boton.Boton
  - , menu.Menu
  - , animado.Animado
  - , texto.Texto
  - , estrella.Estrella
  - , cursordisparo.CursorDisparo
  - , aceituna.Aceituna
  - , mano.CursorMano
  - , mono.Mono
  - , pingu.Pingu
  - , ejes.Ejes
  - , martian.Martian
  - , pacman.Pacman
  - , globo.Globo
  - , torreta.Torreta
  - , caja.Caja
  - , ovni.Ovni
  - , ovni.Planeta
  - , tortuga.Tortuga
  - , piedra.Piedra
  - , banana.Banana
  - , energia.Energia
  - , zanahoria.Zanahoria
  - , pizarra.Pizarra
  - , fantasma.Fantasma
  - , pelota.Pelota
  - , proyectil.EstrellaNinja

Representa un objeto visible en pantalla, algo que se ve y tiene posicion.

.. image:: images/actores/actor.png

Un objeto Actor se tiene que crear siempre indicando una imagen. Si no se especifica una imagen, se verá una pila de color gris cómo la que está mas arriba.

Una forma de crear el actor con una imagen es:

    >>> protagonista = Actor("protagonista_de_frente.png")

incluso, es equivalente hacer lo siguiente:

    >>> imagen = pilas.imagenes.cargar("protagonista_de_frente.png")
    >>> protagonista = Actor(imagen)

Luego, una vez que ha sido ejecutada la sentencia aparecerá el nuevo actor para que puedas manipularlo. Por ejemplo alterando sus propiedades:

    >>> protagonista.x = 100
    >>> protagonista.escala = 2
    >>> protagonista.rotacion = 30

Estas propiedades también se pueden manipular mediante interpolaciones. Por ejemplo, para aumentar el tamaño del personaje de 1 a 5 en 7 segundos:

    >>> protagonista.escala = 1
    >>> protagonista.escala = [5], 7

Si quieres que el actor sea invisible, un truco es crearlo con la imagen ``invisible.png``:

    >>> invisible = pilas.actores.Actor('invisible.png')

Instance Methods | [hide private]
__actualizar_velocidad(self) Calcula la velocidad horizontal y vertical del actor. | source code
__cmp__(self, otro_actor) Compara dos actores para determinar cual esta mas cerca de la camara. | source code
__init__(self, imagen=`'``sin_imagen.png``'`, x=0, y=0) Constructor del Actor. | source code
__mul__(self, cantidad) | source code
__str__(self) str(x) | source code
_eliminar_anexados(self) | source code
_interpretar_y_convertir_posicion(self, posicion, maximo_valor) | source code
actor_mas_cercano(self) Retorna otro actor mas cercano a este actor | source code
actualizar(self) Actualiza el estado del actor. | source code
anexar(self, otro_actor) Agrega un Actor a la lista de actores anexados al Actor actual. | source code
colisiona_con(self, otro_actor) Determina si este actor colisiona con ``otro_actor`` | source code
colisiona_con_un_punto(self, x, y) Determina si un punto colisiona con el area del actor. | source code
decir(self, mensaje, autoeliminar=True) Emite un mensaje usando un globo similar al de los comics. | source code
definir_centro(self, (x, y)) Define en que posición estará el centro del Actor. | source code
definir_color(self, c) | source code
definir_escala(self, escala) | source code
definir_imagen(self, imagen) Define la imagen del Actor y establece el centro del mismo a ('centro,'centro'). | source code
definir_posicion(self, x, y) Define la posición del Actor en el mundo. | source code
definir_rotacion(self, r) | source code
definir_transparencia(self, valor) | source code
destruir(self) Elimina a un actor pero de manera inmediata. | source code
dibujar(self, aplicacion) Metodo interno para el dibujado del Actor en pantalla. | source code
distancia_al_punto(self, x, y) Determina la distancia desde el centro del actor hasta el punto determinado | source code
distancia_con(self, otro_actor) Determina la distancia con el ``otro_actor`` | source code
duplicar(self, **kv) Duplica un Actor. | source code
eliminar(self) Elimina el actor de la lista de actores que se imprimen en pantalla. | source code
es_fondo(self) Comprueba si el actor es un fondo del juego. | source code
esta_fuera_de_la_pantalla(self) Indica si el actor está fuera del area visible de la pantalla. | source code
get_abajo(self) | source code
get_arriba(self) | source code
get_derecha(self) | source code
get_espejado(self) | source code
get_fijo(self) | source code
get_imagen(self) | source code
get_izquierda(self) | source code
get_rotation(self) | source code
get_scale(self) | source code
get_scale_x(self) | source code
get_scale_y(self) | source code
get_transparencia(self) | source code
get_vx(self) | source code
get_vy(self) | source code
get_x(self) | source code
get_y(self) | source code
get_z(self) | source code
imitar(self, otro_actor_o_figura) Hace que un Actor copie la posición y la rotación de otro Actor o Figura fisica. | source code
obtener_alto(self) | source code
obtener_ancho(self) | source code
obtener_centro(self) Obtiene las coordenadas del centro del Actor. | source code
obtener_escala(self) | source code
obtener_imagen(self) Obtinene la imagen del Actor. | source code
obtener_posicion(self) Obtiene la posición del Actor en el mundo. | source code
obtener_rotacion(self) | source code
pre_actualizar(self) Actualiza comportamiento y habilidades antes de la actualización. | source code
set_abajo(*args, **kwargs) | source code
set_arriba(*args, **kwargs) | source code
set_derecha(*args, **kwargs) | source code
set_espejado(self, nuevo_valor) | source code
set_fijo(self, fijo) | source code
set_imagen(self, imagen) | source code
set_izquierda(*args, **kwargs) | source code
set_rotation(*args, **kwargs) | source code
set_scale(*args, **kwargs) | source code
set_scale_x(*args, **kwargs) | source code
set_scale_y(*args, **kwargs) | source code
set_transparencia(*args, **kwargs) | source code
set_x(*args, **kwargs) | source code
set_y(*args, **kwargs) | source code
set_z(*args, **kwargs) | source code
Inherited from `object`: `__delattr__`, `__format__`, `__getattribute__`, `__hash__`, `__new__`, `__reduce__`, `__reduce_ex__`, `__repr__`, `__setattr__`, `__sizeof__`, `__subclasshook__` Inherited from `estudiante.Estudiante`: `actualizar_comportamientos`, `actualizar_habilidades`, `agregar_habilidad`, `aprender`, `eliminar_comportamientos`, `eliminar_habilidad`, `eliminar_habilidades`, `hacer`, `hacer_luego`, `obtener_habilidad`, `tiene_comportamiento`, `tiene_habilidad` Inherited from `estudiante.Estudiante` (private): `_adoptar_el_siguiente_comportamiento`

Properties | [hide private]
| abajo Establece el espacio entre la parte inferior del actor y el centro de coordenadas del mundo.
| alto Obtiene el alto del Actor.
| ancho Obtiene el ancho del Actor.
| arriba Establece el espacio entre la parte superior del actor y el centro de coordenadas del mundo.
| centro Cambia la posición del punto (x, y) dentro de actor.
| derecha Establece el espacio entre la derecha del actor y el centro de coordenadas del mundo.
| escala Escala de tamaño, 1 es normal, 2 al doble de tamaño etc...)
| escala_x Escala de tamaño horizontal, 1 es normal, 2 al doble de tamaño etc...)
| escala_y Escala de tamaño vertical, 1 es normal, 2 al doble de tamaño etc...)
| espejado Indica si se tiene que invertir horizonaltamente la imagen del actor.
| fijo Indica si el actor debe ser independiente a la camara.
| imagen Define la imagen a mostrar.
| izquierda Establece el espacio entre la izquierda del actor y el centro de coordenadas del mundo.
| rotacion Angulo de rotación (en grados, de 0 a 360)
| transparencia Define el nivel de transparencia, 0 indica opaco y 100 la maxima transparencia.
| vx Obtiene la velocidad horizontal del actor.
| vy Obtiene la velocidad vertical del actor.
| x Define la posición horizontal.
| y Define la posición vertical.
| z Define lejania respecto del observador.
Inherited from `object`: `__class__`

Method Details | [hide private]

### __cmp__(self, otro_actor) (Comparison operator) | source code
Compara dos actores para determinar cual esta mas cerca de la camara. Este metodo se utiliza para ordenar los actores antes de imprimirlos en pantalla. De modo tal que un usuario pueda seleccionar que actores se ven mas arriba de otros cambiando los valores de los atributos `z`.

### __init__(self, imagen=`'``sin_imagen.png``'`, x=0, y=0) (Constructor) | source code
Constructor del Actor. :param imagen: Ruta de la imagen del Actor. :type imagen: string :param x: Posición horizontal del Actor. :type x: int :param y: Posición vertical del Actor. :type y: int Overrides: estudiante.Estudiante.__init__

### __str__(self) (Informal representation operator) | source code
str(x) Overrides: object.__str__ (inherited documentation)

### actualizar(self) | source code
Actualiza el estado del actor. Este metodo se llama una vez por frame, y generalmente se suele usar para implementar el comportamiento del actor. Si estás haciendo una subclase de Actor, es aconsejable que re-definas este método.

### anexar(self, otro_actor) | source code
Agrega un Actor a la lista de actores anexados al Actor actual. Cuando se elimina un Actor, se eliminan los actores anexados. :param otro_actor: Actor a anexar. :type otro_actor: `Actor`

### colisiona_con(self, otro_actor) | source code
Determina si este actor colisiona con ``otro_actor`` :param otro_actor: El otro actor para verificar si colisiona. :type otro_actor: pilas.actores.Actor

### colisiona_con_un_punto(self, x, y) | source code
Determina si un punto colisiona con el area del actor. Todos los actores tienen un area rectangular, pulsa la tecla **F10** para ver el area de colision. :param x: Posición horizontal del punto. :type x: int :param y: Posición vertical del punto. :type y: int

### decir(self, mensaje, autoeliminar=True) | source code
Emite un mensaje usando un globo similar al de los comics. :param mensaje: Texto a mostrar en el mensaje. :type mensaje: string :param autoeliminar: Establece si se eliminará el globo al cabo de unos segundos. :type autoeliminar: boolean

### definir_centro(self, (x, y)) | source code
Define en que posición estará el centro del Actor. Se puede definir la posición mediante unas coordenadas numéricas o mediante texto. La forma de definirlo mediante coordenadas numéricas seria así:
    >>> mi_actor.definir_centro((10,50))
La otra forma de definirlo mediante texto sería:
    >>> mi_actor.definir_centro(('centro','derecha'))
:param x: Coordenadas horizontal en la que se establecerá el centro del Actor. :type x: int :param y: Coordenadas vertical en la que se establecerá el centro del Actor. :type y: int

### definir_imagen(self, imagen) | source code
Define la imagen del Actor y establece el centro del mismo a ('centro,'centro'). :param imagen: Ruta de la imagen del Actor. :type imagen: string

### definir_posicion(self, x, y) | source code
Define la posición del Actor en el mundo. :param x: Posición horizontal del Actor en el mundo. :type x: int :param y: Posición vertical del Actor en el mundo. :type y: int

### distancia_al_punto(self, x, y) | source code
Determina la distancia desde el centro del actor hasta el punto determinado Todos los actores tienen un area rectangular, pulsa la tecla **F10** para ver el area de colision. :param x: Posición horizontal del punto. :type x: int :param y: Posición vertical del punto. :type y: int

### distancia_con(self, otro_actor) | source code
Determina la distancia con el ``otro_actor`` :param otro_actor: El otro actor para ver la distancia :type otro_actor: pilas.actores.Actor

### duplicar(self, **kv) | source code
Duplica un Actor. :return: `Actor`.

### es_fondo(self) | source code
Comprueba si el actor es un fondo del juego. :return: boolean

### esta_fuera_de_la_pantalla(self) | source code
Indica si el actor está fuera del area visible de la pantalla. :return: boolean

### imitar(self, otro_actor_o_figura) | source code
Hace que un Actor copie la posición y la rotación de otro Actor o Figura fisica. Por ejemplo:
    >>> circulo_dinamico = pilas.fisica.Circulo(10, 200, 50)
    >>> mi_actor.imitar(circulo_dinamico)
:param otro_actor_o_figura: Actor o Figura física a imitar. :type otro_actor_o_figura: `Actor`, `Figura`

### pre_actualizar(self) | source code
Actualiza comportamiento y habilidades antes de la actualización. También actualiza la velocidad horizontal y vertical que lleva el actor.

### set_abajo(*args, **kwargs) | source code
Decorators: `@pilas.utils.interpolable`

### set_arriba(*args, **kwargs) | source code
Decorators: `@pilas.utils.interpolable`

### set_derecha(*args, **kwargs) | source code
Decorators: `@pilas.utils.interpolable`

### set_izquierda(*args, **kwargs) | source code
Decorators: `@pilas.utils.interpolable`

### set_rotation(*args, **kwargs) | source code
Decorators: `@pilas.utils.interpolable`

### set_scale(*args, **kwargs) | source code
Decorators: `@pilas.utils.interpolable`

### set_scale_x(*args, **kwargs) | source code
Decorators: `@pilas.utils.interpolable`

### set_scale_y(*args, **kwargs) | source code
Decorators: `@pilas.utils.interpolable`

### set_transparencia(*args, **kwargs) | source code
Decorators: `@pilas.utils.interpolable`

### set_x(*args, **kwargs) | source code
Decorators: `@pilas.utils.interpolable`

### set_y(*args, **kwargs) | source code
Decorators: `@pilas.utils.interpolable`

### set_z(*args, **kwargs) | source code
Decorators: `@pilas.utils.interpolable`

Property Details | [hide private]

### abajo Establece el espacio entre la parte inferior del actor y el centro de coordenadas del mundo. Get Method: get_abajo(self) Set Method: set_abajo(*args, **kwargs)

### alto Obtiene el alto del Actor. Get Method: obtener_alto(self)

### ancho Obtiene el ancho del Actor. Get Method: obtener_ancho(self)

### arriba Establece el espacio entre la parte superior del actor y el centro de coordenadas del mundo. Get Method: get_arriba(self) Set Method: set_arriba(*args, **kwargs)

### centro Cambia la posición del punto (x, y) dentro de actor. Inicialmente, cuando tomamos un actor y definimos sus atributos (x, y). Ese punto, será el que representa el centro del personaje. Eso hace que las rotaciones sean siempre sobre el centro del personajes, igual que los cambios de escala y la posición. En algunas ocasiones, queremos que el punto (x, y) sea otra parte del actor. Por ejemplo sus pies. En esos casos es útil definir el centro del actor. Por ejemplo, si queremos mover el centro del actor podemos usar sentencias cómo estas:
    >>> actor.centro = ("izquierda", "abajo")
    >>> actor.centro = ("centro", "arriba")
Pulsa la tecla **F8** para ver el centro del los actores dentro de pilas. Es aconsejable pulsar la tecla **+** para que el punto del modo **F8** se vea bien. Get Method: obtener_centro(self) - Obtiene las coordenadas del centro del Actor. Set Method: definir_centro(self, (x, y)) - Define en que posición estará el centro del Actor.

### derecha Establece el espacio entre la derecha del actor y el centro de coordenadas del mundo. Get Method: get_derecha(self) Set Method: set_derecha(*args, **kwargs)

### escala Escala de tamaño, 1 es normal, 2 al doble de tamaño etc...) Get Method: get_scale(self) Set Method: set_scale(*args, **kwargs)

### escala_x Escala de tamaño horizontal, 1 es normal, 2 al doble de tamaño etc...) Get Method: get_scale_x(self) Set Method: set_scale_x(*args, **kwargs)

### escala_y Escala de tamaño vertical, 1 es normal, 2 al doble de tamaño etc...) Get Method: get_scale_y(self) Set Method: set_scale_y(*args, **kwargs)

### espejado Indica si se tiene que invertir horizonaltamente la imagen del actor. Get Method: get_espejado(self) Set Method: set_espejado(self, nuevo_valor)

### fijo Indica si el actor debe ser independiente a la camara. Get Method: get_fijo(self) Set Method: set_fijo(self, fijo)

### imagen Define la imagen a mostrar. Get Method: get_imagen(self) Set Method: set_imagen(self, imagen)

### izquierda Establece el espacio entre la izquierda del actor y el centro de coordenadas del mundo. Get Method: get_izquierda(self) Set Method: set_izquierda(*args, **kwargs)

### rotacion Angulo de rotación (en grados, de 0 a 360) Get Method: get_rotation(self) Set Method: set_rotation(*args, **kwargs)

### transparencia Define el nivel de transparencia, 0 indica opaco y 100 la maxima transparencia. Get Method: get_transparencia(self) Set Method: set_transparencia(*args, **kwargs)

### vx Obtiene la velocidad horizontal del actor. Get Method: get_vx(self)

### vy Obtiene la velocidad vertical del actor. Get Method: get_vy(self)

### x Define la posición horizontal. Get Method: get_x(self) Set Method: set_x(*args, **kwargs)

### y Define la posición vertical. Get Method: get_y(self) Set Method: set_y(*args, **kwargs)

### z Define lejania respecto del observador. Get Method: get_z(self) Set Method: set_z(*args, **kwargs)