pilasengine.actores¶

pilasengine.actores.aceituna¶

class pilasengine.actores.aceituna.Aceituna(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

actualizar()¶

pre_iniciar(x=0, y=0)¶

terminar()¶

pilasengine.actores.actor¶

class pilasengine.actores.actor.Actor(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.estudiante.Estudiante

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

Un objeto Actor se tiene que crear siempre indicando una imagen. Si no se especifica una imagen, se verán los signos de interrogación de color rojo.

Una forma de crear el actor con una imagen es:

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

incluso, es equivalente hacer lo siguiente:

>>> imagen = pilas.imagenes.cargar("planeta_azul.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')

abajo¶: Establece el espacio entre la parte inferior del actor y el centro de coordenadas del mundo.

actor_mas_cercano()¶: Retorna otro actor mas cercano a este actor

actualizar()¶

Método de actualización lógico del actor.

Este método se llama automáticamente 60 veces por segundo, es donde se puede colocar lógica de actualización y temporizadores.

agregar(actor)¶

agregar_al_grupo(grupo)¶

alto¶: Obtiene el alto del Actor.

ancho¶: Obtiene el ancho del Actor.

anexar(otro_actor)¶

Agrega un Actor a la lista de actores anexados al Actor actual. Cuando se elimina un Actor, se eliminan los actores anexados.

Parámetros:	otro_actor (Actor) – Actor a anexar.

area_de_colision¶

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.

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 de los actores dentro de pilas. Es aconsejable pulsar la tecla + para que el punto del modo F8 se vea bien.

centro_x¶

centro_y¶

click_de_mouse(callback)¶: Acceso directo para conectar el actor al evento de click_de_mouse. No se debe redefinir este método.

colisiona_con(otro_actor)¶

Determina si este actor colisiona con otro_actor

Parámetros:	otro_actor (pilas.actores.Actor) – El otro actor para verificar si colisiona.

colisiona_con_un_punto(x, y)¶

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. Si el actor tiene la propiedad fijo en True, el cálculo se hace independientemente de la cámara.

Parámetros:	x (int) – Posición horizontal del punto. y (int) – Posición vertical del punto.

crear_figura_de_colision_circular(radio, x=0, y=0)¶

crear_figura_de_colision_rectangular(x, y, ancho, alto)¶

cuando_hace_click¶

cuando_mueve_el_mouse¶

decir(mensaje, autoeliminar=True)¶

Emite un mensaje usando un globo similar al de los comics.

Parámetros:	mensaje (string) – Texto a mostrar en el mensaje. autoeliminar (boolean) – Establece si se eliminará el globo al cabo de unos segundos.

definir_area_colision(x, y, ancho, alto)¶

definir_centro((x, y))¶

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'))

Parámetros:	x (int) – Coordenadas horizontal en la que se establecerá el centro del Actor. y (int) – Coordenadas vertical en la que se establecerá el centro del Actor.

definir_centro_x(x)¶

definir_centro_y(y)¶

definir_color(c)¶

definir_escala(s)¶

definir_escala_x(s)¶

definir_escala_y(s)¶

definir_espejado(espejado)¶

definir_figura_de_colision(figura)¶

definir_fijo(fijo)¶

definir_imagen(imagen)¶

Define la imagen del Actor y establece el centro del mismo a (‘centro,’centro’).

Parámetros:	imagen (string) – Ruta de la imagen del Actor.

definir_posicion(x, y)¶

Define la posición del Actor en el mundo.

Parámetros:	x (int) – Posición horizontal del Actor en el mundo. y (int) – Posición vertical del Actor en el mundo.

definir_radio_de_colision(radio)¶

definir_rotacion(rotacion)¶

definir_transparencia(transparencia)¶

definir_vy()¶

definir_x(x)¶

definir_y(y)¶

definir_z(z)¶

derecha¶: Establece el espacio entre la derecha del actor y el centro de coordenadas del mundo.

dibujar(painter)¶

Pinta el personaje sobre la ventana.

Este método es interno, se invoca automáticamente desde el bucle de pilas-engine.

disparar()¶: Permite que cualquier actor que tenga una habilidad para disparar pueda hacerlo.

distancia_al_punto(x, y)¶

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.

Parámetros:	x (int) – Posición horizontal del punto. y (int) – Posición vertical del punto.

distancia_con(otro_actor)¶

Determina la distancia con el otro_actor

Parámetros:	otro_actor (pilas.actores.Actor) – El otro actor para ver la distancia

duplicar(**kv)¶

Duplica un Actor.

Devuelve:	Actor.

eliminar()¶: Elimina el actor de la lista que se imprimen en pantalla.

eliminar_del_grupo(grupo)¶

es_fondo()¶: Comprueba si el actor es un fondo del juego.

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 horizontalmente la imagen del actor.

esta_dentro_de_la_pantalla()¶

esta_eliminado()¶

esta_fuera_de_la_pantalla()¶

Indica si el actor está fuera del area visible de la pantalla.

Devuelve:	boolean

esta_imitando_su_figura()¶

figura_de_colision¶

fijo¶: Indica si el actor debe ser independiente a la cámara.

get_abajo()¶

get_arriba()¶

get_cuando_hace_click()¶

get_cuando_mueve_el_mouse()¶

get_derecha()¶

get_izquierda()¶

imagen¶: Define la imagen a mostrar.

imitar(otro_actor_o_figura, *args, **kwargs)¶

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)

Parámetros:	otro_actor_o_figura (Actor, Figura) – Actor o Figura física a imitar.

iniciar(*k, **kw)¶

izquierda¶: Establece el espacio entre la izquierda del actor y el centro de coordenadas del mundo.

mover_figura_de_colision()¶

mueve_camara(callback)¶: Acceso directo para conectar el actor al evento de mueve_camara. No se debe redefinir este método.

mueve_mouse(callback)¶: Acceso directo para conectar el actor al evento de mueve_mouse. No se debe redefinir este método.

mueve_rueda(callback)¶: Acceso directo para conectar el actor al evento de mueve_rueda. No se debe redefinir este método.

obtener_alto()¶

obtener_ancho()¶

obtener_area_colision()¶

obtener_cantidad_de_grupos_al_que_pertenece()¶

obtener_centro()¶: Obtiene las coordenadas del centro del Actor.

obtener_centro_x()¶

obtener_centro_y()¶

obtener_escala()¶

obtener_escala_x()¶

obtener_escala_y()¶

obtener_espejado()¶

obtener_figura_de_colision()¶

obtener_fijo()¶

obtener_imagen()¶: Obtinene la imagen del Actor.

obtener_posicion()¶: Obtiene la posición del Actor en el mundo.

obtener_radio_de_colision()¶

obtener_rotacion()¶

obtener_transparencia()¶

obtener_vx()¶

obtener_x()¶

obtener_y()¶

obtener_z()¶

pos_actualizar()¶

pre_actualizar()¶: Actualiza comportamiento y habilidades antes de la actualización. También actualiza la velocidad horizontal y vertical que lleva el actor.

pre_iniciar(x=0, y=0, imagen='sin_imagen.png')¶

Ejecuta el código inicial del actor.

Este método se llama automáticamente cuando el actor se genera y agrega dentro de una escena.

pulsa_tecla(callback)¶: Acceso directo para conectar el actor al evento de pulsa_tecla. No se debe redefinir este método.

pulsa_tecla_escape(callback)¶: Acceso directo para conectar el actor al evento de pulsa_tecla_escape. No se debe redefinir este método.

quitar_de_la_escena_completamente()¶

radio_de_colision¶

rotacion¶: Angulo de rotación (en grados, de 0 a 360)

set_abajo(valor)¶

set_arriba(valor)¶

set_cuando_hace_click(callback)¶

set_cuando_mueve_el_mouse(callback)¶

set_derecha(valor)¶

set_izquierda(valor)¶

suelta_tecla(callback)¶: Acceso directo para conectar el actor al evento de suelta_tecla. No se debe redefinir este método.

termina_click(callback)¶: Acceso directo para conectar el actor al evento de termina_click. No se debe redefinir este método.

terminar()¶: Se ejecuta justo antes de eliminar el actor de la escena.

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.

class pilasengine.actores.actor.ActorEliminado¶

Clases base: object

Representa a un actor que ha sido eliminado y ya no se puede usar.

Esta clase entra en acción cuando se toma cualquier actor y se lo elimina. Cualquier actor de pilas, al momento de ser eliminado, cambia de clase y pasa a formar parte de esta clase.

Observá el método ‘_destruir’ de la clase actor.

eliminar()¶

esta_eliminado()¶

exception pilasengine.actores.actor.ActorEliminadoException¶: Clases base: exceptions.Exception

class pilasengine.actores.actor.Etiquetas¶

Clases base: object

Representa una lista de etiquetas que tiene un actor.

Las etiquetas permiten clasificar a los actores e indentificarlos al momento de detectar una colision.

Por ejemplo, para acceder a las etiquetas de una actor podemos escribir:

>>> actor.etiquetas
['Mono']
>>> actor.etiquetas.agregar('enemigo')
['Mono', 'enemigo']

agregar(etiqueta)¶

contar()¶

eliminar(etiqueta)¶

interseccion(otra_lista)¶

obtener_como_lista()¶

pre_iniciar(*k, **kw)¶

pilasengine.actores.actor_invisible¶

class pilasengine.actores.actor_invisible.ActorInvisible(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

pre_iniciar(x=0, y=0)¶

pilasengine.actores.animacion¶

class pilasengine.actores.animacion.Animacion(pilas, *k, **kv)¶

Clases base: pilasengine.actores.animado.Animado

Representa una animacion de una grilla de imagenes.

Este actor toma una grilla de cuadros de animacion y los reproduce hasta que la animacion termina. Cuando la animacion termina se elimina a si mismo.

El constructor tiene algunos parámetros de utilidad:

El parámetro ciclica permite hacer animaciones infinitas,

que se repiten siempre, por defecto vale False que significa que la animación terminará y no se repetirá.

El parámetro velocidad tiene que ser un número que indicará la

cantidad de cuadros por segundo que se tienen que mostrar en la animación.

Por ejemplo, para mostrar una explosión infinita podrías escribir:
>>> grilla = pilas.imagenes.cargar_grilla("explosion.png", 7)
>>> animacion = pilas.actores.Animacion(grilla, ciclica=True,
                                        velocidad=1)

actualizar()¶: Hace avanzar la animacion.

definir_velocidad_de_animacion(velocidad_de_animacion)¶

Define la cantidad de frames por segundo que se mostrarán.

Parámetros:	velocidad_de_animacion (int) – Cantidad de cuadros por segundo.

obtener_velocidad_de_animacion()¶

Obtiene la cantidad de cuadros por segundo de la animacion.

Devuelve:	int

pre_iniciar(grilla=None, ciclica=False, x=0, y=0, velocidad=10)¶

Constructor de la Animación.

Parámetros:	grilla (Grilla) – Grilla de imagenes obtenida mediante pilas.imagenes.cargar_grilla() ciclica (boolean) – Indica si la animación se realizará de forma infinita. x (int) – Posicion horizontal del Actor. y (int) – Posicion vertical del Actor. velocidad (int) – Indica la cantidad de cuadros por segundo que se monstrarán.

velocidad_de_animacion¶: Es la cantidad de cuadros por segundo a mostrar

pilasengine.actores.animado¶

class pilasengine.actores.animado.Animado(pilas, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

Representa un actor que tiene asociada una grilla con cuadros de animacion.

Una de las variantes que introduce este actor es el método ‘definir_cuadro’, que facilita la animación de personajes.

Por ejemplo, si tenemos una grilla con un pingüino, podríamos mostrarlo usando este código:

>>> grilla = pilas.imagenes.cargar_grilla("pingu.png", 10)
>>> actor = Animado(grilla)
>>> actor.definir_cuadro(2)
>>> actor.definir_cuadro(5)

definir_cuadro(indice)¶

Permite cambiar el cuadro de animación a mostrar

Parámetros:	indice (int) – Número del frame de la grilla que se quiere monstrar.

pre_iniciar(x=0, y=0, grilla=None)¶

pilasengine.actores.bala¶

class pilasengine.actores.bala.Bala(pilas, x=0, y=0, rotacion=0, velocidad_maxima=9, angulo_de_movimiento=90)¶

Clases base: pilasengine.actores.actor.Actor

Representa una bala que va en línea recta.

eliminar()¶

pilasengine.actores.banana¶

class pilasengine.actores.banana.Banana(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

Muestra una banana que se combina (temáticamente) con el actor Mono.

Este actor se podría usar cómo alimento o bonus para otros actores.

Este actor tiene solo dos cuadros de animación que se pueden mostrar con los métodos abrir y cerrar:

>>> banana = pilas.actores.Banana()
>>> banana.abrir()
>>> banana.cerrar()

abrir()¶: Muestra el gráfico de la banana abierta con menos cáscara.

cerrar()¶: Muestra el gráfico de banana normal (con cáscara).

definir_cuadro(indice)¶: Define el frame de la Banana a mostrar.

pre_iniciar(x=0, y=0)¶

pilasengine.actores.bomba¶

class pilasengine.actores.bomba.Bomba(pilas, *k, **kv)¶

Clases base: pilasengine.actores.animacion.Animacion

Representa una bomba que puede explotar...

La bomba adquiere la habilidad explotar al momento de crearse, así que puedes invocar a su método “explotar” y la bomba hará un explosión en pantalla con sonido.

Este es un ejemplo de uso del actor:

>>> bomba = pilas.actores.Bomba()
>>> bomba.explotar()

explotar()¶: Hace explotar a la bomba y la elimina de la pantalla.

pre_iniciar(x=0, y=0)¶

pilasengine.actores.boton¶

class pilasengine.actores.boton.Boton(pilas, x=0, y=0, ruta_normal='boton/boton_normal.png', ruta_press='boton/boton_press.png', ruta_over='boton/boton_over.png')¶

Clases base: pilasengine.actores.actor.Actor

Representa un boton que reacciona al ser presionado.

../../pilas/data/manual/imagenes/actores/boton_normal.png

activar()¶

conectar_normal(funcion, *args, **kwargs)¶

Permite conectar un metodo para que sea ejecutado cuando el botón pase al estado normal.

>>> def cuando_deja_de_pulsar():
>>>     b.pintar_normal()
>>>
>>> mi_boton.conectar_normal(cuando_deja_de_pulsar)

Parámetros:	funcion – Método a llamar cuando el botón pase a estado Normal. arg – Argumentos a pasar a la funcion.

conectar_presionado(funcion, *args, **kwargs)¶

Permite conectar un metodo para que sea ejecutado cuando el botón se presiona.

>>> def cuando_pulsan_el_boton():
>>>     b.pintar_presionado()
>>>
>>> mi_boton.conectar_presionado(cuando_pulsan_el_boton)

Parámetros:	funcion – Método a llamar cuando el botón pase a estado Normal. arg – Argumentos a pasar a la funcion.

conectar_sobre(funcion, *args, **kwargs)¶

Permite conectar un metodo para que sea ejecutado cuando el ratón pasa por encima del botón.

>>> def cuando_pasa_sobre_el_boton():
>>>     b.pintar_sobre()
>>>
>>> mi_boton.conectar_sobre(cuando_pasa_sobre_el_boton)

Parámetros:	funcion – Método a llamar cuando el botón pase a estado Normal. arg – Argumentos a pasar a la funcion.

desactivar()¶

desconectar_normal(funcion, *args, **kwargs)¶

Elimina el método indicado asociado al estado normal del botón.

Parámetros:	funcion – Método al que se llama cuando el botón pasa estado Normal. arg – Argumentos que se pasaban a la funcion.

desconectar_normal_todo()¶: Elimina todas las funciones asociadas al estado normal del botón.

desconectar_presionado(funcion, *args, **kwargs)¶

Elimina el método indicado asociado al estado presinado del botón.

Parámetros:	funcion – Método al que se llama cuando el botón pasa estado Presionado. arg – Argumentos que se pasaban a la funcion.

desconectar_presionado_todo()¶: Elimina todas las funciones asociadas al estado presionado del botón.

desconectar_sobre(funcion, *args, **kwargs)¶

Elimina el método indicado asociado al estado sobre del botón.

Parámetros:	funcion – Método al que se llama cuando el botón pasa estado Sobre. arg – Argumentos que se pasaban a la funcion.

desconectar_sobre_todo()¶: Elimina todas las funciones asociadas al estado sobre del botón.

detection_click_mouse(click)¶

detection_end_click_mouse(end_click)¶

detection_move_mouse(evento)¶

ejecutar_funciones_normal()¶

ejecutar_funciones_over()¶

ejecutar_funciones_press()¶

pintar_normal()¶: Dibuja el botón en estado normal.

pintar_presionado(ruta_press=None)¶

Dibuja el botón en estado presinado.

Parámetros:	ruta_press (string) – Opcional. Ruta de la imagen del boton presionado.

pintar_sobre()¶: Dibuja el botón en estado sobre.

pilasengine.actores.caja¶

class pilasengine.actores.caja.Caja(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

Representa una caja que posee fisica.

iniciar(x=0, y=0)¶

pilasengine.actores.calvo¶

class pilasengine.actores.calvo.Calvo(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.maton.Maton

Representa un personaje de juego tipo RPG.

iniciar(x=0, y=0)¶

pilasengine.actores.controlador¶

class pilasengine.actores.controlador.Controlador(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

agregar(actor, propiedad, minimo, maximo)¶

agregar_espacio()¶

pre_iniciar(x=0, y=0)¶

pilasengine.actores.cooperativista¶

class pilasengine.actores.cooperativista.Caminando(pilas=None)¶

Clases base: pilasengine.comportamientos.comportamiento.Comportamiento

Clase que define un comportamiento del actor Cooperativista.

actualizar()¶

avanzar_animacion()¶

iniciar(receptor)¶

Inicializa el comportamiento.

Parámetros:	receptor – La referencia al actor.

class pilasengine.actores.cooperativista.Cooperativista(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

Representa un Cooperativista que puede caminar y trabajar.

cambiar_animacion(nombre)¶

Cambia la animación del Cooperativista.

Parámetros:	nombre – El nombre de la animación que se quiere mostar.

definir_cuadro(indice)¶

Define el cuadro de la animación del actor.

Parámetros:	indice – el cuadro que la animación que se quiere mostrar.

pre_iniciar(x=0, y=0)¶

class pilasengine.actores.cooperativista.DecirOk(pilas=None)¶

Clases base: pilasengine.comportamientos.comportamiento.Comportamiento

Clase que define un comportamiento del actor Cooperativista.

actualizar()¶

iniciar(receptor)¶

Inicializa el comportamiento.

Parámetros:	receptor – La referencia al actor.

class pilasengine.actores.cooperativista.Esperando(pilas=None)¶

Clases base: pilasengine.comportamientos.comportamiento.Comportamiento

Clase que define un comportamiento del actor Cooperativista.

actualizar()¶

iniciar(receptor)¶

Inicializa el comportamiento.

Parámetros:	receptor – La referencia al actor.

pilasengine.actores.cursor_disparo¶

class pilasengine.actores.cursor_disparo.CursorDisparo(pilas, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

pre_iniciar(x=0, y=0, usar_el_mouse=True)¶

pilasengine.actores.cursor_mano¶

class pilasengine.actores.cursor_mano.CursorMano(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

cuando_mueve_el_mouse(evento)¶

cuando_pulsa_el_mouse(evento)¶

cuando_suelta_el_mouse(evento)¶

pre_iniciar(x=0, y=0)¶

pilasengine.actores.deslizador_horizontal¶

class pilasengine.actores.deslizador_horizontal.DeslizadorHorizontal(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

actualizar_imagen()¶

actualizar_texto()¶

click_del_mouse(click)¶

conectar(f)¶

desconectar(f)¶

ejecutar_funciones(valor)¶

iniciar(x=0, y=0, _min=0, _max=100, etiqueta='sin titulo', valor_inicial=-21)¶

movimiento_del_mouse(movimiento)¶

pre_iniciar(x=0, y=0, actor='actor', propiedad='x', _min=0, _max=100)¶

termino_del_click(noclick)¶

pilasengine.actores.dialogo¶

class pilasengine.actores.dialogo.Dialogo(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

Representa una secuencia de mensajes entre varios actores.

>>> mono = pilas.actores.Mono()
>>> mono2 = pilas.actores.Mono()
>>> dialogo = pilas.actores.Dialogo()
>>> dialogo.decir(mono, "Hola Mundo")
>>> dialogo.decir(mono2, "Estoy diciendo algo")
>>> dialogo.comenzar()

avanzar_al_siguiente_dialogo(evento=None)¶

comenzar()¶

Inicia el dialogo que se haya definido.

>>> d = pilas.actores.Dialogo()
>>> d.decir(mono, "¿Cual es tu color favorito?")
>>> d.comenzar()

decir(actor, texto)¶

Añade un texto a la conversación y establece el actor que lo dice.

Parámetros:	actor (Actor) – Actor que dirá el texto. texto (string) – Texto que dirá el actor.

decir_inmediatamente(actor, texto)¶

Muestra un texto de dialogo inmediatamente sin seguir una secuencia de dialogo.

Parámetros:	actor (Actor) – Actor que dirá el texto. texto (string) – Texto que dirá el actor.

ejecutar(funcion)¶

elegir(actor, texto, opciones, funcion_a_invocar)¶

Muestra un texto de dialogo con una lista de opciones para poder seleccionar y ejecutar una accion cuando se seleccione una de las opciones del cuadro de dialogo.

Parámetros:

actor (Actor) – Actor que dirá el texto.
texto (string) – Texto que aparecerá en la parte superior del dialogo de opciones.
opciones (Array) – Array de posibles opciones que mostrará el cuadrio de dialogo.
funcion_a_invocar – Método al que se llamará cuando se seleccione una de las opciones del listado. Este metodo recibirá como parámetro la opción que se haya seleccinado.

>>> def cuando_responde_color_favorito(respuesta):
>>>    colores = {
>>>               'rojo': pilas.colores.rojo,
>>>               'verde': pilas.colores.verde,
>>>               'azul': pilas.colores.azul,
>>>              }
>>>
>>>    pilas.fondos.Color(colores[respuesta])
>>>    mono.sonreir()
>>>    d.decir(mono, '¡mira!')
>>>
>>> d.elegir(mono_chiquito, 'Mi color favorito es el...', ['rojo', 'verde', 'azul'], cuando_responde_color_favorito)

obtener_siguiente_dialogo_o_funcion()¶

pre_iniciar(x=0, y=0)¶

pilasengine.actores.dinamita¶

class pilasengine.actores.dinamita.Dinamita(pilas, *k, **kv)¶

Clases base: pilasengine.actores.animacion.Animacion

actualizar()¶

pre_iniciar(x=0, y=0, rotacion=0, velocidad_maxima=4, angulo_de_movimiento=90)¶

Construye la Dinamita.

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

pilasengine.actores.disparo_laser¶

class pilasengine.actores.disparo_laser.DisparoLaser(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

Muestra un disparo que avanza por la pantalla.

Este actor se podría usar como arma para juegos de naves generalmente. Por ejemplo, el actor NaveRoja dispara usando este actor como munición.

actualizar()¶

eliminar()¶

pre_iniciar(x=0, y=0, rotacion=0, velocidad=10, imagen='sin_imagen.png')¶

pilasengine.actores.ejes¶

class pilasengine.actores.ejes.Ejes(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

Representa el eje de coordenadas tomado como sistema de referencia.

Este actor es útil para mostrar que la ventana de pilas tiene una referencia, y que las posiciones responden a este modelo.

Para crear el eje podrías ejecutar:

>>> eje = pilas.actore.Eje()

actualizar()¶

pre_iniciar(x=0, y=0)¶

terminar()¶

pilasengine.actores.emisor¶

class pilasengine.actores.emisor.Emisor(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

actualizar()¶

composicion¶

crear_particula()¶

definir_composicion(valor)¶

obtener_composicion()¶

pre_iniciar(x=0, y=0)¶

rand_float_range(start, end)¶

rango(minimo, maximo)¶

se_elimina_particula(particula)¶

pilasengine.actores.energia¶

class pilasengine.actores.energia.Energia(pilas, x=0, y=0, progreso=100, ancho=200, alto=30, color_relleno=<Color (255, 255, 0, 255)>, con_sombra=True, con_brillo=True)¶

Clases base: pilasengine.actores.actor.Actor

Representa un indicador de energia (en forma de barra horizontal).

actualizar()¶: Actualiza la barra de estado por si hubiera incrementado o decrementado.

cargar_miniatura(imagen)¶

Permite cargar una imagen a la izqiuerda de la barra de Energia.

Parámetros:	imagen (string) – Ruta de la imagen que se desea mostrar a la izquierda de la barra de Energia.

definir_progreso(progreso)¶

obtener_progreso()¶

pintar_imagen()¶: Dibuja la barra de energia en pantalla.

progreso¶: Cambia el nivel de progreso de la energia, entre 0 y 100

pilasengine.actores.estrella¶

class pilasengine.actores.estrella.Estrella(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

actualizar()¶

pre_iniciar(x=0, y=0)¶

terminar()¶

pilasengine.actores.estrella_ninja¶

class pilasengine.actores.estrella_ninja.EstrellaNinja(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

Representa una estrella ninja.

actualizar()¶

pre_iniciar(x=0, y=0)¶

pilasengine.actores.estudiante¶

class pilasengine.actores.estudiante.Estudiante¶

Clases base: object

Componente que permite a los actores aprender habilidades o realizar comportamientos.

actualizar_comportamientos()¶: Actualiza la lista de comportamientos

actualizar_habilidades()¶: Realiza una actualización sobre todas las habilidades.

agregar_habilidad(classname, *k, **w)¶

Agrega una habilidad a la lista de cosas que puede hacer un actor.

Parámetros:	habilidad – Referencia a la clase que representa la habilidad.

aprender(classname, *k, **w)¶

Comienza a realizar una habilidad indicada por parametros.

Parámetros:	classname – Referencia a la clase que representa la habilidad.

eliminar_comportamientos()¶: Elimina todos los comportamientos que tiene que hacer el actor.

eliminar_habilidad(classname)¶

Elimina una habilidad asociada a un Actor.

Parámetros:	classname – Referencia a la clase que representa la habilidad.

eliminar_habilidades()¶: Elimina todas las habilidades asociadas al actor.

hacer(classname, *args, **kwargs)¶

Define el comportamiento para el actor de manera inmediata.

Parámetros:	classname – Referencia al comportamiento a realizar.

hacer_inmediatamente(classname, *args, **kwargs)¶

hacer_luego(classname, repetir_por_siempre=False, *args, **kwargs)¶

Define un nuevo comportamiento para realizar al final.

Los actores pueden tener una cadena de comportamientos, este metodo agrega el comportamiento al final de la cadena.

Parámetros:	comportamiento – Referencia al comportamiento. repetir_por_siempre – Si el comportamiento se volverá a ejecutar luego de terminar.

obtener_habilidad(classname)¶

Obtiene la habilidad asociada a un Actor.

Parámetros:	habilidad – Referencia a la clase que representa la habilidad.
Devuelve:	Devuelve None si no se encontró.

tiene_comportamiento(classname)¶

Comprueba si el actor tiene el comportamiento indicado.

Parámetros:	classname – Referencia a la clase que representa el comportamiento.

tiene_habilidad(classname)¶

Comprueba si el actor ha aprendido la habilidad indicada.

Parámetros:	classname – Referencia a la clase que representa la habilidad.
Devuelve:	Devuelve True si el actor tiene asignada la habilidad

pilasengine.actores.estudiante.estructura_comportamiento¶: alias de Comportamiento

pilasengine.actores.explosion¶

class pilasengine.actores.explosion.Explosion(pilas, x, y)¶

Clases base: pilasengine.actores.animacion.Animacion

Representa una explosion para una bomba, dinamita etc...

El actor simplemente aparece reproduciendo un sonido y haciendo una animación:

>>> actor = pilas.actores.Bomba()

y una vez que termina se elimina a sí mismo.

Este actor también se puede anexar a cualquier otro para producir explosiones. Cuando enseñamos a un actor a explotar (por ejemplo un pingüino), el actor Explosion aparece cuando se elimina al actor:

>>> actor = pilas.actores.Pingu()
>>> actor.aprender(pilas.habilidades.PuedeExplotar)
>>> actor.eliminar()

pilasengine.actores.explosion_de_humo¶

class pilasengine.actores.explosion_de_humo.ExplosionDeHumo(pilas, x, y)¶

Clases base: pilasengine.actores.animacion.Animacion

Representa una explosion para una bomba, dinamita etc...

Este actor se puede anexar a cualquier a otro para producir un efecto de explosión, por ejemplo:

>>> actor = pilas.actores.Aceituna()
>>> actor.aprender(pilas.habilidades.PuedeExplotarConHumo)
>>> actor.eliminar()

pilasengine.actores.fantasma¶

class pilasengine.actores.fantasma.Fantasma(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

Representa al fantasman del clasico pac-man.

actualizar()¶

definir_cuadro(indice)¶

Cambia el cuadro de animación a mostrar.

Parámetros:	indice – Número de cuadro a mostrar.

pre_iniciar(x=0, y=0)¶

pilasengine.actores.globo¶

class pilasengine.actores.globo.Globo(pilas, texto='', x=0, y=0, dialogo=None, avance_con_clicks=True, autoeliminar=False, ancho_globo=0, alto_globo=0, objetivo=None)¶

Clases base: pilasengine.actores.actor.Actor

Representa un cuadro de dialogo estilo historietas.

El actor se tiene que inicializar con una cadena de texto:

>>> globo = pilas.actores.Globo("Hola mundo")

actualizar()¶

colocar_origen_del_globo(x, y)¶: Cambia la posicion del globo para que el punto de donde se emite el globo sea (x, y). :param x: Posición horizontal del globo. :type x: int :param y: Posición vertical del globo. :type y: int

cuando_quieren_avanzar(*k)¶: Función que se ejecuta al hacer click para avanzar o eliminar el globo.

pilasengine.actores.grupo¶

class pilasengine.actores.grupo.AgrupadorEtiquetas(grupo)¶

Clases base: object

Representa el atributo etiquetas de todos los actores en el grupo.

agregar(etiqueta)¶

eliminar(etiqueta)¶

class pilasengine.actores.grupo.Grupo(pilas)¶

Clases base: _abcoll.MutableSequence

Representa un grupo que puede almacenar actores.

Los grupos pueden ser útiles para clasificar y organizar _actores dentro de un juego. Por ejemplo, todas las naves en un grupo, los enemigos en otro grupo y las estrellas en otro etc.

Para crear un grupo y asignarle un actor podemos escribir:

>>> grupo = pilas.actores.Grupo()
>>> actor = pilas.actores.Actor()
>>> grupo.agregar(actor)

abajo¶: Establece el espacio entre la parte inferior de los actores del grupo y el centro de coordenadas del mundo.

agregar(actor)¶

aprender(habilidad, *k, **kw)¶

arriba¶: Establece el espacio entre la parte superior de los actores del grupo y el centro de coordenadas del mundo.

derecha¶: Establece el espacio entre la derecha de los actores del grupo y el centro de coordenadas del mundo.

eliminar(actor)¶: Agrega el actor a una lista para eliminarlo mas tarde.

escala¶: Escala de todos los actores del grupo

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 horizontalmente la imagen de los actores.

fijo¶: Indica si los actores del grupo deben ser independiente a la cámara.

insert(i, key)¶

izquierda¶: Establece el espacio entre la izquierda de los actores del grupo y el centro de coordenadas del mundo.

obtener_actores(fijos=None, sin_padre=False)¶

Retorna una lista de actores.

El argumento fijos sirve para filtrar los actores. Si se especifica True solo se retornan los actores fijos, en cambio con False se retornan los actores normales.

obtener_cantidad_de_actores()¶

rotacion¶: Angulo de rotación en grados de (0 a 360) de todos los actores del grupo

sort()¶

transparencia¶: Define el nivel de transparencia, 0 indica opaco y 100 la maxima transparencia.

x¶: Define la posición horizontal del grupo de actores.

y¶: Define la posición vertical del grupo de actores.

pilasengine.actores.humo¶

class pilasengine.actores.humo.Humo(pilas, x, y)¶

Clases base: pilasengine.actores.animacion.Animacion

Muestra una animación de una nube de humo.

../../pilas/data/manual/imagenes/actores/humo.png

La animación se ejecuta una vez y desaparece.

pilasengine.actores.manejador_propiedad¶

class pilasengine.actores.manejador_propiedad.ManejadorPropiedad(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.deslizador_horizontal.DeslizadorHorizontal

cuando_cambia(valor)¶

iniciar(x=0, y=0, actor='actor', propiedad='x', _min=0, _max=100)¶

pre_iniciar(x=0, y=0, actor='actor', propiedad='x', _min=0, _max=100)¶

pilasengine.actores.manzana¶

class pilasengine.actores.manzana.Manzana(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

Muestra una manzana.

Este actor se podría usar cómo alimento o bonus para otros actores.

pre_iniciar(x=0, y=0)¶

pilasengine.actores.mapa¶

class pilasengine.actores.mapa.Mapa(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

actualizar()¶

convertir_de_coordenada_absoluta_a_coordenada_mapa(x, y)¶

Toma un punto de pantalla y lo convierte a una coordenada dentro del mapa.

Parámetros:	x – Coordenada horizontal de pantalla. y – Coordenada vertical de pantalla.

definir_figura_de_colision(figura)¶

es_bloque_solido(fila, columna)¶

Indica si un determinado bloque es solido.

Los bloques sólidos se utilizan para marcar paredes y plataformas, es decir que son bloques que generalmente no se pueden sobrepasar.

Parámetros:	fila – La fila que se observará. columna – La columna que se observará.

es_punto_solido(x, y)¶

Indica si una coordenada del escenario está sobre un bloque solido.

Parámetros:	x – Posición horizontal a consultar. y – Posición vertical a consultar.

es_punto_solido_coordenada_mapa(x, y)¶

Consulta si un punto (x, y) está señalando un bloque sólido.

Parámetros:	x – Coordenada horizontal. y – Coordenada vertical.

iniciar(x=0, y=0, grilla=None, filas=20, columnas=20, densidad=1.0, restitucion=0.56, friccion=10.5, amortiguacion=0.1)¶

Inicializa el mapa.

Parámetros:

grilla – La imagen a utilizar cómo grilla con los bloques del escenario.
x – Posición horizontal del mapa.
y – Posición vertical del mapa.
filas – Cantidad de filas que tendrá el mapa.
columnas – Cantidad de columnas que tendrá el mapa.
densidad – La densidad de la física de los bloques solidos.
restitucion – La restitucion de la física de los bloques solidos.
friccion – La friccion de la física de los bloques solidos.
amortiguacion – La amortiguacion de la física de los bloques solidos.

obtener_distancia_al_suelo(x, y, maximo)¶

Retorna la distancia en pixels desde un punto del mundo al suelo.

Es importante mostrar que las coordenadas x e y son coordenadas del mundo, no coordenadas de mouse o relativas al mapa.

El argumento maximo es la cantidad de pixels que tomaremos como valor limite de la busqueda. Por ejemplo, si colocamos 100 como limite y la funcion nos retorna 100 es porque no encontró un suelo a menos de 100 pixels. Este límite existe por una cuestión de eficiencia.

Parámetros:	x – Posición horizontal de referencia. y – Posición vertical de referencia. maximo – Cantidad máxima de pixels a leer.

obtener_numero_de_columna(x)¶

Retorna el número de columna correspondiente a una coordenada horizontal.

Parámetros:	x – La coordenada horizontal (relativa al mapa, no a la pantalla).

obtener_numero_de_fila(y)¶

Retorna el número de fila correspondiente a una coordenada vertical.

Parámetros:	y – La coordenada vertical (relativa al mapa, no a la pantalla).

pintar_bloque(fila, columna, indice, es_bloque_solido=True)¶

Define un bloque de la grilla.

Parámetros:	fila – La fila que se definirá (comenzando desde 0). columna – La columna que se definirá (comenzando desde 0). indice – El número de cuadro referente a la grilla (comenzando desde 0). es_bloque_solido – True o False para indicar si los objetos físicos deberán colisionar con este bloque.

pintar_limite_de_bloques()¶: Dibuja los bordes de cada bloque.

pre_iniciar(x=0, y=0, grilla=None, filas=20, columnas=20, densidad=1.0, restitucion=0.56, friccion=10.5, amortiguacion=0.1)¶

terminar()¶

pilasengine.actores.mapa_tiled¶

class pilasengine.actores.mapa_tiled.MapaTiled(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.mapa.Mapa

Representa mapas creados a partir de imagenes mas pequeñas.

Este actor te permite crear escenarios tipo tiles, a partir de archivos .tmx, creados con el programa tiled (ver http://www.mapeditor.org).

Por ejemplo, para crear un mapa desde un archivo del programa tiled puedes escribir:

>>> mapa = pilas.actores.MapaTiled('untitled2.tmx')

Tiled trabaja con capas, así que cuando pilas carga las capas las interpreta de la siguiente manera:

Tos las capas se van a dibujar.

Toda capa que comienza con la palabra “solido” armará bloques con física y colisión.

cuadro_alto()¶: Retorna el alto de un bloque del mapa

cuadro_ancho()¶: Retorna el ancho de un bloque del mapa

iniciar(ruta_mapa=None, x=0, y=0, densidad=0, restitucion=0, friccion=10.5, amortiguacion=0.1, reiniciar_si_cambia=True)¶

pre_iniciar(ruta_mapa=None, x=0, y=0, densidad=0, restitucion=0, friccion=10.5, amortiguacion=0.1)¶

class pilasengine.actores.mapa_tiled.XmlNode(domElement)¶

Representa un nodo XML.

getAttributeValue(name)¶: Returns the value of the attribute having the specified name.

getChild(tag)¶: Retorna el primer nodo hijo que contenga el tag especificado.

getChildren(tag)¶: Retorna una lista de todos los nodos hijos que tienen el tag especificado.

getData()¶: Extrae datos desde un nodo del DOM.

pilasengine.actores.mapa_tiled.makeRootNode(xmlFileName)¶

Genera un nodo XML dado un archivo.

Parámetros:	xmlFileName – El nombre del archivo .xml

pilasengine.actores.martian¶

class pilasengine.actores.martian.Caminando(pilas=None)¶

Clases base: pilasengine.actores.martian.Esperando

Representa al actor caminando hacia la izquierda o derecha.

actualizar()¶

avanzar_animacion()¶: Cambia el cuado de animación para avanzar la animación

iniciar(receptor)¶

Inicia el comportamiento y define los valores iniciales.

Parámetros:	receptor – El actor que será controlado por este comportamiento.”

class pilasengine.actores.martian.Esperando(pilas=None)¶

Clases base: pilasengine.comportamientos.comportamiento.Comportamiento

Representa al actor en posicion normal.

Este comportamiento espera a que el usuario pulse alguna tecla para entrar en movimiento.

actualizar()¶

caer_si_no_toca_el_suelo()¶

iniciar(receptor)¶

Inicia el comportamiento y define los valores iniciales.

Parámetros:	receptor – El actor que será controlado por este comportamiento.”

class pilasengine.actores.martian.Martian(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

Es un personaje de un marciano que puede caminar y saltar.

Este actor se puede mover con el teclado, pulsando las teclas izquierda, arriba, abajo y derecha.

El marciano necesita un mapa para no caer al vacio y desaparecer de la pantalla.

>>> marciano = pilas.actores.Martian(pilas.actores.Mapa())

actualizar()¶: Sigue el movimiento de la figura.

definir_cuadro(indice)¶

Define el cuadro de animación a mostrar.

Parámetros:	indice – El número de cuadro comenzando desde 0.

definir_figura_fisica()¶

mover(vx)¶

obtener_colisiones()¶

obtener_distancia_al_suelo()¶: Retorna la distancia en pixels al suelo.

pre_iniciar(mapa=None, x=0, y=0)¶

puede_saltar()¶: Indica si el persona puede saltar.

class pilasengine.actores.martian.Saltando(pilas=None)¶

Clases base: pilasengine.comportamientos.comportamiento.Comportamiento

Representa al actor realizando un salto.

actualizar()¶

iniciar(receptor, velocidad_de_salto)¶

Inicia el comportamiento y define los valores iniciales.

Parámetros:	receptor – El actor que será controlado por este comportamiento.”

pilasengine.actores.maton¶

class pilasengine.actores.maton.Caminando(pilas=None)¶

Clases base: pilasengine.actores.maton.Esperando

actualizar()¶

avanzar_animacion()¶

iniciar(receptor)¶

class pilasengine.actores.maton.Esperando(pilas=None)¶

Clases base: pilasengine.comportamientos.comportamiento.Comportamiento

actualizar()¶

iniciar(receptor)¶

class pilasengine.actores.maton.Maton(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

Representa un personaje de juego tipo RPG.

actualizar()¶

definir_cuadro(indice)¶

pre_iniciar(x=0, y=0)¶

pilasengine.actores.mensaje_error¶

class pilasengine.actores.mensaje_error.MensajeError(pilas, titulo, descripcion)¶

Clases base: pilasengine.actores.actor.Actor

iniciar()¶

pilasengine.actores.menu¶

class pilasengine.actores.menu.Menu(pilas, x=0, y=0, opciones=[], fuente=None, color_normal=<Color (128, 128, 128, 255)>, color_resaltado=<Color (255, 255, 255, 255)>)¶

Clases base: pilasengine.actores.actor.Actor

Un actor que puede mostrar una lista de opciones a seleccionar.

activar()¶: Se ejecuta para activar el comportamiento del menú.

actualizar()¶: Se ejecuta de manera periodica.

crear_texto_de_las_opciones(opciones, fuente, color_normal, color_resaltado)¶

Genera un actor por cada opcion del menu.

Parámetros:	opciones – Una lista con todas las opciones que tendrá el menú.

cuando_hace_click_con_el_mouse(evento)¶

Se ejecuta cuando se hace click con el mouse.

Parámetros:	evento – objeto que representa el evento click de mouse.

cuando_mueve_el_mouse(evento)¶

Permite cambiar la opcion actual moviendo el mouse. Retorna True si el mouse esta sobre alguna opcion.

Parámetros:	evento – El evento que representa el movimiento del mouse.

desactivar()¶: Deshabilita toda la funcionalidad del menú.

mover_cursor(delta)¶

Realiza un movimiento del cursor que selecciona opciones.

Parámetros:	delta – El movimiento a realizar (+1 es avanzar y -1 retroceder).

seleccionar_opcion_actual()¶: Se ejecuta para activar y lanzar el item actual.

seleccionar_primer_opcion()¶: Destaca la primer opción del menú.

pilasengine.actores.misil¶

class pilasengine.actores.misil.Misil(pilas, x=0, y=0, rotacion=0, velocidad_maxima=9, angulo_de_movimiento=90)¶

Clases base: pilasengine.actores.actor.Actor

Representa un misil que va en línea recta con aceleración.

actualizar()¶

eliminar()¶

pilasengine.actores.moneda¶

class pilasengine.actores.moneda.Moneda(pilas, x=0, y=0)¶

Clases base: pilasengine.actores.animacion.Animacion

Representa una moneda con animación.

Ejemplo:

>>> moneda = pilas.actores.Moneda()

pilasengine.actores.mono¶

class pilasengine.actores.mono.Mono(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

decir(mensaje)¶: Emite un mensaje y además sonrie mientras habla.

gritar()¶: Hace que el mono grite emitiendo un sonido.

iniciar(*k, **kw)¶

normal()¶

Restaura la expresión del mono.

Este función se suele ejecutar por si misma, unos segundos después de haber gritado y sonreir.

pre_iniciar(x=0, y=0)¶

saltar()¶: Hace que el mono sonria y salte.

sonreir()¶: Hace que el mono sonria y emita un sonido.

pilasengine.actores.municion¶

class pilasengine.actores.municion.Municion(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

actualizar()¶

iniciar(x=0, y=0)¶

terminar()¶

pilasengine.actores.nave¶

class pilasengine.actores.nave.Nave(pilas, x=0, y=0, velocidad=2)¶

Clases base: pilasengine.actores.animacion.Animacion

Representa una nave que puede disparar.

actualizar()¶

definir_enemigos(grupo, cuando_elimina_enemigo=None)¶

Hace que una nave tenga como enemigos a todos los actores del grupo.

Parámetros:	grupo (array) – El grupo de actores que serán sus enemigos. cuando_elimina_enemigo – Funcion que se ejecutará cuando se elimine un enemigo.

hacer_explotar_al_enemigo(mi_disparo, el_enemigo)¶

Es el método que se invoca cuando se produce una colisión ‘tiro <-> enemigo’

Parámetros:	mi_disparo – El disparo de la nave. el_enemigo – El enemigo que se eliminará.

pilasengine.actores.nave_kids¶

class pilasengine.actores.nave_kids.NaveKids(pilas, x=0, y=0, velocidad=2)¶

Clases base: pilasengine.actores.animacion.Animacion

Representa una nave de aspecto infantil que puede disparar.

../../pilas/data/manual/imagenes/actores/spacekids.png

actualizar()¶

definir_enemigos(grupo, cuando_elimina_enemigo=None)¶

Hace que una nave tenga como enemigos a todos los actores del grupo.

Parámetros:	grupo (array) – El grupo de actores que serán sus enemigos. cuando_elimina_enemigo – Funcion que se ejecutará cuando se elimine un enemigo.

hacer_explotar_al_enemigo(mi_disparo, el_enemigo)¶

Es el método que se invoca cuando se produce una colisión ‘tiro <-> enemigo’

Parámetros:	mi_disparo – El disparo de la nave. el_enemigo – El enemigo que se eliminará.

pilasengine.actores.nave_roja¶

class pilasengine.actores.nave_roja.NaveRoja(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

actualizar()¶

crear_disparo()¶

definir_enemigos(grupo, cuando_elimina_enemigo=None)¶: Hace que una nave tenga como enemigos a todos los actores del grupo.

disparar()¶

hacer_explotar_al_enemigo(mi_disparo, el_enemigo)¶: Es el método que se invoca cuando se produce una colisión ‘tiro <-> enemigo’

intenta_disparar()¶

pre_iniciar(x=0, y=0)¶

terminar()¶

pilasengine.actores.opcion¶

class pilasengine.actores.opcion.Opcion(pilas, texto='', x=0, y=0, funcion_a_invocar=None, argumentos=None, fuente=None, color_normal=<Color (128, 128, 128, 255)>, color_resaltado=<Color (255, 255, 255, 255)>)¶

Clases base: pilasengine.actores.texto.Texto

Un item discreto, dispara una funcion al seleccionares.

resaltar(estado=True)¶

Pinta la opcion actual de un color mas claro.

Parámetros:	estado – True o False indicando si se tiene que resaltar o deseleccionar la opción.

seleccionar()¶: Invoca a la funcion que tiene asociada para ejecutar.

pilasengine.actores.ovni¶

class pilasengine.actores.ovni.Ovni(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

Representa Ovni que explota al momento de ser eliminado.

actualizar()¶

pre_iniciar(x=0, y=0)¶

pilasengine.actores.pacman¶

class pilasengine.actores.pacman.Pacman(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

Muestra un personaje similar al juego Pac-Man

Este actor se puede mover con el teclado, pulsando las teclas izquierda, arriba, abajo y derecha.

>>> pacman = pilas.actores.Pacman(velocidad=5)

actualizar()¶

definir_cuadro(indice)¶: Cambia el cuadro de animación del actor.

pre_iniciar(x=0, y=0)¶

pilasengine.actores.palo¶

class pilasengine.actores.palo.Palo(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

actualizar()¶

iniciar(x, y)¶

terminar()¶

pilasengine.actores.particula¶

class pilasengine.actores.particula.Particula(pilas, emisor, x, y, dx, dy, imagen, vida)¶

Clases base: pilasengine.actores.actor.Actor

aceleracion_x¶

aceleracion_y¶

actualizar()¶

definir_aceleracion_x(valor)¶

definir_aceleracion_y(valor)¶

definir_escala_fin(valor)¶

definir_rotacion_fin(valor)¶

definir_transparencia_fin(valor)¶

escala_fin¶

rotacion_fin¶

transparencia_fin¶

pilasengine.actores.pelota¶

class pilasengine.actores.pelota.Pelota(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

Representa una pelota de Volley, que puede rebotar e interactuar con la física del escenario.

iniciar(x=0, y=0)¶

pilasengine.actores.piedra¶

class pilasengine.actores.piedra.Piedra(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

Representa una piedra que podría ser usada como meteoríto.

actualizar()¶: Realiza una actualización de la posición.

definir_tamano(tamano)¶

empujar(dx, dy)¶

iniciar(x, y)¶

pilasengine.actores.pingu¶

class pilasengine.actores.pingu.Caminando(pilas=None)¶

Clases base: pilasengine.comportamientos.comportamiento.Comportamiento

Representa al personaje caminando por el escenario.

actualizar()¶

avanzar_animacion()¶

iniciar(receptor)¶

class pilasengine.actores.pingu.Esperando(pilas=None)¶

Clases base: pilasengine.comportamientos.comportamiento.Comportamiento

Un actor en posición normal o esperando a que el usuario pulse alguna tecla.

actualizar()¶

iniciar(receptor)¶

class pilasengine.actores.pingu.Pingu(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

Muestra a un pingüino que sabe caminar con el teclado.

Este actor responde al teclado, así que podremos usar los direccionales del teclado izquierda, arriba y derecha:

>>> pingu = pilas.actores.Pingu()

definir_cuadro(indice)¶

Define el cuadro de la animación.

Parámetros:	indice – Número de cuadro.

iniciar(x, y)¶

class pilasengine.actores.pingu.Saltando(pilas=None)¶

Clases base: pilasengine.comportamientos.comportamiento.Comportamiento

Representa al actor saltando con animación.

actualizar()¶

iniciar(receptor)¶

pilasengine.actores.pizarra¶

class pilasengine.actores.pizarra.Pizarra(pilas, x=0, y=0, ancho=None, alto=None)¶

Clases base: pilasengine.actores.actor.Actor

Representa una superficie de dibujo inicialmente transparente.

Puedes pintar sobre esta pizarra usando métodos que simulan un lapiz, que se puede mover sobre una superficie.

dibujar_punto(x, y, color=<Color (0, 0, 0, 255)>)¶

Dibuja un punto sobre la pizarra.

El punto será 3 pixels de radio, y si no se especifica tendrá color negro.

Este es un ejemplo de invocación:

>>> pizarra.dibujar_punto(20, 30, pilas.colores.rojo)

Parámetros:	x – Posición horizontal para el punto. y – Posición vertical para el punto. color – El color para el punto.

limpiar()¶: Borra toda la pizarra y los dibujos que hay en ella.

linea(x, y, x2, y2, color=<Color (0, 0, 0, 255)>, grosor=1)¶

Dibuja una linea recta sobre la pizarra.

Parámetros:	x – Coordenada horizontal desde donde comenzará la linea. y – Coordenada vertical desde donde comenzará la linea. x2 – Coordenada horizontal desde donde terminará la linea. y2 – Coordenada vertical desde donde terminará la linea. color – El color de la linea. grosor – Cuan gruesa será la linea en pixels.

obtener_coordenada_fisica(x, y)¶

Convierte las coordenadas de pantalla a coordenadas físicas.

Una coordenanda de pantalla, comienza en el punto (0, 0) y corresponde al centro de la pizarra. Mientras que una coordenada física tiene un sistema parecido al de los juegos viejos, donde (0, 0) es la esquina superir izquierda de la pantalla.

Parámetros:	x – Coordenada x a convertir. y – Coordenada y a convertir.

pintar(color)¶

Pinta toda la pizarra de un solo color.

Por ejemplo:

>>> pizarra.pintar(pilas.colores.rojo)

Parámetros:	color – El color que pintará toda la pizarra.

pintar_grilla(grilla, x, y)¶

Dibuja un cuadro de animación sobre la pizarra.

Parámetros:	grilla – La grilla a dibujar. x – Coordenada horizontal sobre la pizarra. y – Coordenada vertical sobre la pizarra.

pintar_imagen(imagen, x, y)¶

Dibuja una imagen sobre la pizarra.

Parámetros:	imagen – Referencia a la imagen que se quiere pintar. x – Coordenada destino horizontal. y – Coordenada destino vertical.

pintar_parte_de_imagen(imagen, origen_x, origen_y, ancho, alto, x, y)¶

Dibuja una porción de una imagen sobre la pizarra.

Este método, a diferencia de “pintar_imagen”, capturará un rectángulo de la imagen fuente.

Parámetros:	imagen – Imagen fuente que se quiere dibujar sobre la pizarra. origen_x – Marca la esquina superior izquierda desde donde se recortar. origen_y – Marca la esquina superior izquierda desde donde se recortar. ancho – Ancho del rectángulo de corte. alto – Alto del rectángulo de corte.

poligono(puntos, color=<Color (0, 0, 0, 255)>, grosor=1, cerrado=False)¶

Dibuja un polígono sobre la pizarra.

Ejemplo:

>>> pizarra = pilas.actores.Pizarra()
>>> pizarra.poligono([(10, 20), (100, 140)], color=pilas.colores.verde, grosor=4)

Parámetros:	puntos – Una lista de puntos en forma de tupla (x, y) que conforman el polígono. color – El color de la linea a trazar. grosor – El grosor de la linea a trazar en pixels.

rectangulo(x, y, ancho, alto, color=<Color (0, 0, 0, 255)>, relleno=False, grosor=1)¶

Dibuja un rectángulo sobre la pizarra.

Si el rectángulo se dibuja con relleno, el color será el que pintará todo el rectángulo, en caso contrario, el color será utilizado para dibujar el contorno del rectángulo.

Parámetros:	x – Posición horizontal de la esquina superior izquierda. y – Posición horizontal de la esquina superior izquierda. ancho – Ancho del rectángulo. alto – Altura del rectángulo. relleno – Indica con True o False si el rectángulo se tiene que pintar completamente. grosor – Grosor del contorno del rectángulogulo.

texto(cadena, x=0, y=0, magnitud=10, fuente=None, color=<Color (0, 0, 0, 255)>)¶

Dibuja una cadena de texto sobre la pizarra.

Parámetros:	cadena – El string que se quiere dibujar. x – Coordenada horizontal. y – Coordenada vertical. magnitud – Tamaño que tendrá la tipografía. fuente – Nombre de la tipografía a utilizar. color – Color del texto a dibujar.

pilasengine.actores.planeta¶

class pilasengine.actores.planeta.Planeta(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

Representa un planeta para utilizar con el ovni.

actualizar()¶

cambiar_color(color)¶

iniciar(x, y)¶

pilasengine.actores.puntaje¶

class pilasengine.actores.puntaje.Puntaje(pilas, texto='0', x=0, y=0, color=<Color (0, 0, 0, 255)>)¶

Clases base: pilasengine.actores.texto.Texto

Representa un contador de Puntaje

aumentar(cantidad=1)¶

Incrementa el puntaje.

Parámetros:	cantidad – La cantidad de puntaje que se aumentará.

definir(puntaje_variable='0')¶

Cambia el texto que se mostrará cómo puntaje.

Parámetros:	puntaje_variable – Texto a definir.

obtener()¶: Retorna el puntaje en forma de número.

reducir(cantidad=1)¶

Reduce el puntaje.

Parámetros:	cantidad – La cantidad de puntaje que se reducirá.

pilasengine.actores.shaolin¶

class pilasengine.actores.shaolin.Caminar(pilas=None)¶

Clases base: pilasengine.comportamientos.comportamiento.Comportamiento

actualizar()¶

iniciar(receptor)¶

class pilasengine.actores.shaolin.Parado(pilas=None)¶

Clases base: pilasengine.comportamientos.comportamiento.Comportamiento

actualizar()¶

iniciar(receptor)¶

Inicializa el comportamiento.

Parámetros:	receptor – La referencia al actor.

class pilasengine.actores.shaolin.Saltar(pilas=None)¶

Clases base: pilasengine.comportamientos.comportamiento.Comportamiento

actualizar()¶

iniciar(receptor)¶

class pilasengine.actores.shaolin.Shaolin(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

Representa un luchador que se puede controlar con el teclado, puede saltar, golpear y recibir golpes.

actualizar()¶

iniciar(x=0, y=0)¶

pilasengine.actores.sombra¶

class pilasengine.actores.sombra.Sombra(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

actualizar()¶

iniciar(x, y)¶

terminar()¶

pilasengine.actores.sonido¶

class pilasengine.actores.sonido.Sonido(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

Un icono de sonido en la parte inferior derecha de la pantalla.

Este actor se utilizará para habilitar el sonido o deshabilitarlo al hacer click sobre él.

cuando_pulsa()¶: Alterna entre sonido habilitado o deshabilitado.

iniciar(x=0, y=0)¶

pilasengine.actores.temporizador¶

class pilasengine.actores.temporizador.Temporizador(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

Representa un contador de tiempo con cuenta regresiva.

Por ejemplo:

>>> t = pilas.actores.Temporizador()
>>> def hola_mundo():
...     pilas.avisar("Hola mundo, pasaron 10 segundos...")
...
>>> t.ajustar(10, hola_mundo)
>>> t.comenzar()

ajustar(tiempo=1, funcion=None)¶

Indica una funcion para ser invocada en el tiempo indicado.

La función no tiene que recibir parámetros, y luego de ser indicada se tiene que iniciar el temporizador.

comenzar()¶

definir_tiempo_texto(variable)¶

Define el texto a mostrar en el temporizador.

Parámetros:	variable – La cadena de texto a mostrar.

detener()¶

iniciar(x=0, y=0)¶: Inicia el contador de tiempo con la función indicada.

reiniciar()¶

pilasengine.actores.texto¶

class pilasengine.actores.texto.Texto(pilas, texto='Sin texto', magnitud=20, vertical=False, fuente=None, fijo=True, ancho=0, x=0, y=0)¶

Clases base: pilasengine.actores.actor.Actor

actualizar()¶

ancho¶

color¶

definir_ancho(ancho)¶

definir_color(color)¶

definir_texto(texto)¶: Define el texto a mostrar.

iniciar()¶

obtener_ancho()¶

obtener_color()¶

obtener_texto()¶: Retorna el texto definido.

texto¶: El texto que se tiene que mostrar.

pilasengine.actores.texto_inferior¶

class pilasengine.actores.texto_inferior.TextoInferior(pilas, texto='Sin texto', magnitud=20, retraso=5)¶

Clases base: pilasengine.actores.texto.Texto

Representa un texto al pie de la ventana.

Esta clase se utiliza desde el método “pilas.avisar()”.

desvanecer()¶

obtener_bordes()¶

pilasengine.actores.torreta¶

class pilasengine.actores.torreta.Torreta(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

Representa una torreta que puede disparar y rota con el mouse.

get_municion()¶: Retorna la munción que está utilizando la torreta.

iniciar(municion_bala_simple=None, enemigos=[], cuando_elimina_enemigo=None, x=0, y=0, frecuencia_de_disparo=10)¶

Inicializa la Torreta.

Parámetros:	municion_bala_simple – Indica el tipo de munición que se utilizará. enemigos – Lista o grupo de enemigos que podría eliminar la torreta. x – Posición horizontal inicial. y – Posición vertical inicial. frecuencia_de_disparo – Frecuencia con la que se dispararán las municiones.

municion¶: Define la munición de la torreta.

set_municion(municion)¶: Define la munición que utilizará la torreta.

pilasengine.actores.tortuga¶

class pilasengine.actores.tortuga.Tortuga(pilas, x=0, y=0, dibuja=True)¶

Clases base: pilasengine.actores.actor.Actor

Representa una tortuga que se puede mover por la pantalla.

Este actor está profundamente inspirado por la tortuga de Logo, creada por Seymour Papert en el año 1967.

actualizar()¶: Actualiza su estado interno.

av(pasos)¶

Se mueve hacia adelante la cantidad de pasos indicada.

Parámetros:	pasos – Los pasos que debe avanzar.

avanzar(pasos)¶

Se mueve hacia adelante la cantidad de pasos indicada.

Parámetros:	pasos – Los pasos que debe avanzar.

bajalapiz()¶: Le indica a la tortuga si debe comenzar a dibujar con cada movimiento.

bl()¶: Le indica a la tortuga si debe comenzar a dibujar con cada movimiento.

color¶: Retorna el color que se utilizará para trazar.

crear_circulo(radio=30, sentido=-1)¶

Dibuja un circulo.

Parámetros:	radio – El radio que deberá tener el circulo. sentido – El sentido de dibujado, -1 indica hacia la izquierda y 1 hacia la derecha.

crear_poligono(lados=4, escala=100, sentido=-1)¶

dibuja un poligono de lados de los lados indicados.

Parámetros:	lados – La cantidad de lados a dibujar. escala – El tamaño del polígono a dibujar. sentido – El sentido de dibujado, -1 indica hacia la izquierda y 1 hacia la derecha.

dibujar_linea_desde_el_punto_anterior()¶: Realiza el trazado de una linea desde su posición actual hacia la anterior.

gd(delta)¶

Da un giro hacia la derecha de la tortuga.

Parámetros:	delta – Los grados que digará en ese sentido.

get_color()¶: Retorna el color que se utilizará para trazar.

gi(delta)¶

Realiza un giro hacia la izquierda.

Parámetros:	delta – Los grados que digará en ese sentido.

giraderecha(delta)¶

Da un giro hacia la derecha de la tortuga.

Parámetros:	delta – Los grados que digará en ese sentido.

giraizquierda(delta)¶

Realiza un giro hacia la izquierda.

Parámetros:	delta – Los grados que digará en ese sentido.

pc(color)¶: Define el color de trazado cuando comienza a moverse.

pintar(color=None)¶

Pinta todo el fondo de un solo color.

Parámetros:	color – El color que se utilizará para pintar el fondo.

pon_color(color)¶: Define el color de trazado cuando comienza a moverse.

set_color(color)¶

Define el color que se utilizará para trazar.

Parámetros:	color – El color a utilizar.

sl()¶: Le indica a la tortuga que deje de dibujar con cada movimiento.

subelapiz()¶: Le indica a la tortuga que deje de dibujar con cada movimiento.

pilasengine.actores.zanahoria¶

class pilasengine.actores.zanahoria.Zanahoria(pilas=None, *k, **kv)¶

Clases base: pilasengine.actores.actor.Actor

Representa un actor que parece una Zanahoria.

decir(mensaje)¶

Emite un mensaje usando un globo similar al de los commics.

Parámetros:	mensaje – La cadena de mensaje que mostrará.

iniciar(x, y)¶

normal()¶: Cambia la imagen actual por una donde se ve la zanahora normal.

saltar()¶: Realiza un salto hacia arriba.

sonreir()¶: Cambia la imagen actual por una en donde tiene una sonrisa