Referencia completa

Esta sección resume todas las funciones, métodos y clases que encontrarás en pilas.

Es una buena referencia a la hora explorar en profundidad alguna característica de la biblioteca y conocer las posibilidades que ofrece.

Módulo pilas

Pilas es una biblioteca para facilitar el desarrollo de videojuegos. Es útil para programadores principiantes o para el desarrollo de juegos casuales.

Este módulo contiene las funciones principales para iniciar y ejecutar la biblioteca.

pilas.abrir_asistente()[fuente]

Abre una ventana que permite iniciar pilas graficamente.

Las opciones que ofrece son “leer el manual” (si esta disponible), “abrir un interprete”, “explorar los ejemplos” etc.

Esta ventana se ha diseñado para mostrarse a los nuevos usuarios de pilas, por ejemplo cuando eligen abrir pilas desde el icono principal.

pilas.abrir_cargador()[fuente]

Abre un cargador de ejemplos con varios códigos de prueba.

Ejemplo:

>>> pilas.abrir_cargador()

El cargador de ejemplos se ve de esta forma:

_images/cargador.png
pilas.abrir_interprete(parent=None, do_raise=False, con_aplicacion=False)[fuente]

Abre un intérprete interactivo de python con una ventana.

Esta función se ejecuta cuando un usuario escribe:

pilas -i

en una consola del sistema.

pilas.avisar(mensaje, retraso=5)[fuente]

Emite un mensaje en la ventana principal.

Este mensaje aparecerá en la parte inferior de la pantalla durante 5 segundo, por ejemplo:

>>> pilas.avisar("Use la tecla <esc> para terminar el programa")
pilas.ejecutar(ignorar_errores=False)[fuente]

Pone en funcionamiento las actualizaciones y dibujado.

Esta función es necesaria cuando se crea un juego en modo no-interactivo.

pilas.esta_inicializada()[fuente]

Indica si la biblioteca pilas ha sido inicializada con pilas.iniciar()

pilas.iniciar(ancho=640, alto=480, titulo='Pilas', usar_motor='qtgl', rendimiento=60, modo=None, area_fisica=None, gravedad=(0, -90), pantalla_completa=False, permitir_depuracion=True, audio=None, centrado=True)[fuente]

Inicia la ventana principal del juego con algunos detalles de funcionamiento.

Ejemplo de invocación:

>>> pilas.iniciar(ancho=320, alto=240)
_images/iniciar_320_240.png

Parámetros:

Ancho:el tamaño en pixels para la ventana.
Alto:el tamaño en pixels para la ventana.
Titulo:el titulo a mostrar en la ventana.
Usar_motor:el motor multimedia a utilizar, puede ser ‘qt’, ‘qtgl’, ‘qtsugar’ o ‘qtsugargl’.
Rendimiento:cantidad de cuadros por segundo a mostrar.
Modo:si se utiliza modo interactivo o no.
Area_fisica:recibe una tupla con el ancho y el alto que tendra el mundo de fisica, por defecto sera el tamaño de la ventana
Gravedad:el vector de aceleracion para la simulacion de fisica.
Pantalla_completa:
 si debe usar pantalla completa o no.
Permitir_depuracion:
 si se desea tener habilidatas las funciones de depuracion de las teclas F5 a F12
Audio:selecciona el motor de sonido a utilizar, los valores permitidos son ‘deshabilitado’, ‘pygame’, ‘phonon’ o ‘gst’.
Centrado:Indica si se desea centrar la ventana de pilas.
pilas.iniciar_con_lanzador(ancho=640, alto=480, titulo='Pilas', rendimiento=60, modo='detectar', area_fisica=None, gravedad=(0, -90), imagen='asistente.png', permitir_depuracion=True)[fuente]

Identica a la función iniciar, solo que permite al usuario seleccionar el motor multimedia y el modo de video a utilizar.

Esta función es útil cuando se quiere distribuir un juego y no se conoce exáctamente el equipo del usuario.

pilas.obtener_configuracion()[fuente]

Retorna la configuración del usuario almacenada en su directorio HOME.

La configuración permite definir los valores por omisión cuando se abre la ventana de pilas. Por ejemplo, si se llama a pilas.iniciar() sin argumentos, los valores de ‘motor’ o ‘sistema de sonido’ a utilizar se cargarán desde esa configuración.

pilas.reiniciar()[fuente]

Elimina todos los actores y vuelve al estado inicial.

pilas.terminar()[fuente]

Finaliza la ejecución de pilas y cierra la ventana principal.

pilas.ver(objeto, imprimir=True, retornar=False)[fuente]

Imprime en pantalla el codigo fuente asociado a un objeto.

pilas.version()[fuente]

Retorna el número de version de pilas.

Módulo pilas.control

class pilas.control.Control(escena, mapa_teclado=None)[fuente]

Representa un control de teclado sencillo.

Este objeto permite acceder al estado del teclado usando atributos.

Por ejemplo, con este objeto, para saber si el usuario está pulsando el direccional hacia la izquierda de puedes ejecutar:

if pilas.escena_actual().control.izquierda:
    print 'Ha pulsado hacia la izquierda'

Es decir, si bien Control es una clase, no hace falta instanciarla. Ya existe un objeto que se puede consultar bajo el nombre pilas.escena_actual().control.

Entonces, una vez que tienes la referencia para consultar, los atributos que tiene este objeto control son:

izquierda
derecha
arriba
abajo
boton

Cada uno de estos atributos te pueden devolver True, o False, indicando si el control está pulsado o no.

Ten en cuenta que este objeto también se puede imprimir usando la sentencia print. Esto es útil para ver el estado completo del control de una sola vez:

>>> print pilas.mundo.control
<Control izquierda: False derecha: False arriba: False abajo: False boton: False>

También tienes la posibilidad de crearte un control estableciendo las teclas personalizadas. Para ello debes crearte un diccionario con las claves izquierda, derecha, arriba, abajo y boton. Con las constantes de pilas.simbolos, puedes asignar una tecla a cada una de las entradas del diccionario.

>>>    teclas = {pilas.simbolos.a: 'izquierda',
                          pilas.simbolos.d: 'derecha',
                          pilas.simbolos.w: 'arriba',
                          pilas.simbolos.s: 'abajo',
                          pilas.simbolos.ESPACIO: 'boton'}
>>>    mi_control = pilas.control.Control(pilas.escena_actual(), teclas)

Consultando controles desde un actor:

Una forma habitual de usar los controles, es consultarlos directamente desde el codigo de un actor.

Para consultar los controles para cambiar la posicion horizontal de un actor podrías implementar el método actualizar:

class Patito(pilas.actores.Actor):

    def __init__(self):
        pilas.actores.Actor.__init__(self)
        self.imagen = "patito.png"

    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
_images/patito.png
__init__(escena, mapa_teclado=None)[fuente]

Módulo pilas.escena

class pilas.escena.Logos(escena_siguiente, pilas_logo=True, mostrar_almenos=2, pasar_con_teclado=False, pasar_con_click_de_mouse=False)

Esta escena es el clásico inicio donde se van mostrando todas las tecnologías y empresas involucradas en el juego y luego pasa a la primer escena propiamente del juego.

Por defecto ya agrega como primer pantalla el logo de Pilas en 640*480.

Por ejemplo, para mostrar el logo de pilas seguido del tuyo y luego pasar a la escena de Menú Principal podrias hacer:

>>> logos = pilas.escenas.Logos(MiMenuPrincipal())
>>> logos.agregar_logo("mi_logo.png")
>>> pilas.cambiar_escena(logos)

Si por otro lado si querés que el logo se muestre en pantalla por 10 segundos, y no 2 como es por defecto, puedes hacer:

>>> logos = pilas.escenas.Logos(MiMenuPrincipal())
>>> logos.agregar_logo("mi_logo.png", timer=10)
>>> pilas.cambiar_escena(logos)

También puedes agregarle alguna musica o sonido a tus logos utilizando el parámetro sonido en agregar logo.

>>> logos = pilas.escenas.Logos(MiMenuPrincipal())
>>> logos.agregar_logo("mi_logo.png", sonido="misonido.mp3")
>>> pilas.cambiar_escena(logos)
__init__(escena_siguiente, pilas_logo=True, mostrar_almenos=2, pasar_con_teclado=False, pasar_con_click_de_mouse=False)

Constructor de Logos

Parámetros:
  • escena_siguiente (pilas.escena.Base) – Cual sera la escena siguiente a mostrar luego de todos los logos.
  • pilas_logo (bool) – Si el primer logo a mostrar va a ser el de Pilas
  • mostrar_almenos – El minimo tiempo que se debe mostrar cada logo aunque se intente acelerar.
  • pasar_con_teclado (bool) – Si es True cuando aprietes una tecla el pasará al siguiente logo
  • pasar_con_click_de_mouse – Si es True cuando hagas click con el mouse pasará al siguiente logo.

Agrega una nueva imagen a la lista de imagenes a mostrar antes de pasar a la escena siguiente

Parámetros:
  • imagen (str) – El nombre de una imagen a mostrar.
  • timer (float) – Cuanto tiempo quieres que se muestre esta imagen. Si timer es None se usara como valor el de mostrar_almenos
  • sonido (str) – El sonido para la imagen

Módulo pilas.evento

class pilas.evento.ProxyEventos[fuente]

Representa el objeto pilas.evento, que internamente delega todos los metodos conectados a la escena actual.

Para acceder a este objeto, usar una sentencia como la siguiente:

>>> pilas.eventos.click_de_mouse.conectar(una_funcion)

La función enviada como parámetro será invocada cuando el evento ocurra. Y se enviará como argumento los datos del evento, por ejemplo:

>>> def cuando_hace_click(evento):
...     print evento.x
...     print evento.y
...
>>> pilas.eventos.click_de_mouse.conectar(cuando_hace_click)
actualizar[fuente]

Se invoca regularmente, 60 veces por segundo.

click_de_mouse[fuente]

Informa ante la pulsación del mouse.

Parámetros:
  • x – Posición horizontal del mouse.
  • y – Posición vertical del mouse.
  • dx – Posición horizontal relativa del mouse.
  • dy – Posición vertical relativa del mouse.
  • boton – Botón del mouse que se pulsó (1 - Izquierdo, 2 - Derecho, 4 - Central)
log[fuente]

Indica que se emitió un mensaje para depuración usando la función pilas.log.

mueve_camara[fuente]

Informa que ha cambiado la posición de la cámara.

Parámetros:
  • x – Posición horizontal de la cámara.
  • y – Posición vertical de la cámara.
  • dx – Movimiento relativo horizontal que sufrió la cámara.
  • dy – Movimiento relativo vertical que sufrió la cámara.
mueve_mouse[fuente]

Informa que la posición del mouse ha cambiado.

Parámetros:
  • x – Posición horizontal del mouse.
  • y – Posición vertical del mouse.
  • dx – Posición horizontal relativa del mouse.
  • dy – Posición vertical relativa del mouse.
mueve_rueda[fuente]

Indica que cambió la rueda del mouse que se utiliza para desplazamiento o scroll.

Parámetros:delta – indica el grado de rotación de la rueda del mouse.
pulsa_tecla[fuente]

Informa que se ha pulsado una tecla del teclado.

Parámetros:
  • codigo – Codigo de la tecla normalizado, por ejemplo simbolos.m.
  • es_repeticion – Indica si el evento surgió por repetición de teclado. False indica que es la primer pulsación.
  • texto – Cadena de texto que indica la tecla pulsada, por ejemplo "m".
pulsa_tecla_escape[fuente]

Indica que se ha pulsado la tecla scape.

suelta_tecla[fuente]

Informa que se ha soltado una tecla del teclado.

Parámetros:
  • codigo – Codigo de la tecla normalizado, por ejemplo simbolos.m.
  • es_repeticion – Indica si el evento surgió por repetición de teclado. False indica que es la primer pulsación.
  • texto – Cadena de texto que indica la tecla pulsada, por ejemplo "m".
termina_click[fuente]

Informa cuando la pulsación del mouse termina.

Parámetros:
  • x – Posición horizontal del mouse.
  • y – Posición vertical del mouse.
  • dx – Posición horizontal relativa del mouse.
  • dy – Posición vertical relativa del mouse.
  • boton – Botón del mouse que se pulsó (1 - Izquierdo, 2 - Derecho, 4 - Central)

Módulo pilas.actores

El módulo actores contiene una serie de clases para representar personajes de videojuegos.

Para crear actores en una escena del juego simplemente se tiene que crear un nuevo objeto a partir de una clase.

Por ejemplo, para crear un pongüino podríamos escribir la siguiente sentencia:

>>> p = pilas.actores.Pingu()
class pilas.actores.Actor(imagen='sin_imagen.png', x=0, y=0)

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

_images/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')
__init__(imagen='sin_imagen.png', x=0, y=0)

Constructor del Actor.

Parámetros:
  • imagen (string) – Ruta de la imagen del Actor.
  • x (int) – Posición horizontal del Actor.
  • y (int) – Posición vertical del Actor.
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()

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.

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

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.
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_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_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.
derecha

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

destruir()

Elimina a un actor pero de manera inmediata.

dibujar(aplicacion)

Metodo interno para el dibujado del Actor en pantalla.

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 de actores que se imprimen en pantalla.

es_fondo()

Comprueba si el actor es un fondo del juego.

Devuelve:boolean
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.

esta_fuera_de_la_pantalla()

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

Devuelve:boolean
fijo

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

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.
izquierda

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

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_centro()

Obtiene las coordenadas del centro del Actor.

obtener_imagen()

Obtinene la imagen del Actor.

obtener_posicion()

Obtiene la posición del Actor en el mundo.

pre_actualizar()

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

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.

rotacion

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

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.

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 pilas.actores.Mono(x=0, y=0)

Representa la cara de un mono de color marrón.

_images/mono.png

Este personaje se usa como ejemplo básico de un actor. Por ejemplo, esta es una forma de usar al actor:

>>> mono = pilas.actores.Mono()
>>> mono.decir("Hola!!!")
>>> mono.gritar()
__init__(x=0, y=0)

Constructor del Mono.

Parámetros:
  • x (int) – posicion horizontal del mono.
  • y (int) – posicion vertical del mono.
decir(mensaje)

Emite un mensaje y además sonrie mientras habla.

Parámetros:mensaje (string) – Texto que se desea mostrar.

Por ejemplo:

>>> mono.decir("Estoy hablando!!!")
_images/mono_dice.png
gritar()

Hace que el mono grite emitiendo un sonido.

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.

saltar()

Hace que el mono sonria y salte.

sonreir()

Hace que el mono sonria y emita un sonido.

class pilas.actores.Ejes(x=0, y=0)

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()
__init__(x=0, y=0)

Constructor de los ejes.

Parámetros:
  • x (int) – Posición horizontal de los ejes.
  • y (int) – Posición vertical de los ejes.
class pilas.actores.Animado(grilla, x=0, y=0)

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)
_images/pingu1.png
__init__(grilla, x=0, y=0)

Constructor del Actor.

Parámetros:
  • grilla (Grilla) – Grilla de imagenes obtenida mediante pilas.imagenes.cargar_grilla()
  • x (int) – Posición horizontal del Actor.
  • y (int) – Posición vertical del Actor.
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.
class pilas.actores.Animacion(grilla, ciclica=False, x=0, y=0, velocidad=10)

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)
_images/explosion.png
__init__(grilla, 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.
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
velocidad_de_animacion

Es la cantidad de cuadros por segundo a mostrar

class pilas.actores.Explosion(x=0, y=0)

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

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

>>> actor = pilas.actores.Bomba()
_images/explosion.png

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()
__init__(x=0, y=0)

Constructor de la Explosion

Parámetros:
  • x (int) – Posición horizontal de la explosion.
  • y (int) – Posición vertical de la explosion.
class pilas.actores.Bomba(x=0, y=0)

Representa una bomba que puede explotar...

_images/bomba.png

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()
__init__(x=0, y=0)

Constructor de la Bomba.

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

Hace explotar a la bomba y la elimina de la pantalla.

class pilas.actores.Pingu(x=0, y=0)

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

_images/pingu1.png

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

>>> pingu = pilas.actores.Pingu()
__init__(x=0, y=0)

Inicializa al actor.

Parámetros:
  • x – Posición horizontal.
  • y – Posición vertical.
definir_cuadro(indice)

Define el cuadro de la animación.

Parámetros:indice – Número de cuadro.
class pilas.actores.Banana(x=0, y=0)

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

_images/banana.png

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()
__init__(x=0, y=0)

Constructor de la Banana.

Parámetros:
  • x (int) – Posición horizontal del Actor.
  • y (int) – Posición vertical del Actor.
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.

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

Representa un texto en pantalla.

El texto tiene atributos como texto, magnitud y color, por ejemplo para crear un mensaje de saludo podríamos escribir:

>>> saludo = pilas.actores.Texto("Hola mundo!")
__init__(texto='None', x=0, y=0, magnitud=20, vertical=False, fuente=None, fijo=True, ancho=0)

Inicializa el actor.

Parámetros:
  • texto – Texto a mostrar.
  • x – Posición horizontal.
  • y – Posición vertical.
  • magnitud – Tamaño del texto.
  • vertical – Si el texto será vertical u horizontal, como True o False.
  • fuente – Nombre de la fuente a utilizar.
  • fijo – Determina si el texto se queda fijo aunque se mueva la camara. Por defecto está fijo.
  • ancho – El limite horizontal en pixeles para la cadena, el texto de mostrara en varias lineas si no cabe en este límite.
ancho

Ancho del texto a mostrar

color

Color del texto.

definir_color(color)

Define el color del texto.

definir_magnitud(magnitud)

Define el tamaño del texto a mostrar.

definir_texto(texto)

Define el texto a mostrar.

magnitud

El tamaño del texto.

obtener_color()

Devuelve el color que tiene asignado el texto.

obtener_magnitud()

Devuelve el tamaño del texto.

obtener_texto()

Retorna el texto definido.

texto

El texto que se tiene que mostrar.

class pilas.actores.Temporizador(x=0, y=0, color=<pilas.colores.Color object at 0x105e3a790>, fuente=None, autoeliminar=False)

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.iniciar()
__init__(x=0, y=0, color=<pilas.colores.Color object at 0x105e3a790>, fuente=None, autoeliminar=False)

Inicializa el temporizador.

Parámetros:
  • x – Posición horizontal.
  • y – Posición vertical.
  • color – El color que tendrá el texto.
  • autoeliminar – Indica si se desea eliminar el Temporizador

cuando acabe.

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.

definir_tiempo_texto(variable)

Define el texto a mostrar en el temporizador.

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

Inicia el contador de tiempo con la función indicada.

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

Representa una moneda con animación.

_images/moneda.png

Ejemplo:

>>> moneda = pilas.actores.Moneda()
__init__(x=0, y=0)

Constructor de la moneda

Parámetros:
  • x (int) – Posición horizontal del moneda.
  • y (int) – Posición vertical del moneda.
class pilas.actores.Pizarra(x=0, y=0, ancho=None, alto=None)

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.

__init__(x=0, y=0, ancho=None, alto=None)

Inicializa el actor Pizarra.

Parámetros:
  • x – Posición horizontal inicial.
  • y – Posición horizontal inicial.
  • ancho – El tamaño horizontal en pixels, si no se especifica será el tamaño de la ventana.
  • alto – El tamaño vertical en pixels, si no se especifica será el tamaño de la ventana.
dibujar_punto(x, y, color=<pilas.colores.Color object at 0x105e3a790>)

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=<pilas.colores.Color object at 0x105e3a790>, 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=<pilas.colores.Color object at 0x105e3a790>, grosor=1)

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=<pilas.colores.Color object at 0x105e3a790>, 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=<pilas.colores.Color object at 0x105e3a790>)

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.
class pilas.actores.Pelota(x=0, y=0)

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

__init__(x=0, y=0)

Construye una pelota y define la posición inicial.

Parámetros:
  • x – Posición horizontal inicial.
  • y – posición vertical inicial.
class pilas.actores.Puntaje(texto='0', x=0, y=0, color=<pilas.colores.Color object at 0x105e3a790>)

Representa un contador de Puntaje

__init__(texto='0', x=0, y=0, color=<pilas.colores.Color object at 0x105e3a790>)

Inicializa el Puntaje.

Parámetros:
  • texto – El número inicial del puntaje.
  • x – Posición horizontal para el puntaje.
  • y – Posición vertical para el puntaje.
  • color – Color que tendrá el texto 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á.
class pilas.actores.Estrella(x=0, y=0)

Representa una estrella de color amarillo.

_images/estrella.png
__init__(x=0, y=0)

Constructor de la Estrella

Parámetros:
  • x (int) – Posición horizontal de la estrella.
  • y (int) – Posición vertical de la estrella.
class pilas.actores.Caja(x=0, y=0)

Representa una caja que posee fisica.

_images/caja.png
__init__(x=0, y=0)

Constructor de la Caja.

Parámetros:
  • x (int) – Posición horizontal de la Caja.
  • y (int) – Posición vertical del Caja.
class pilas.actores.Nave(x=0, y=0, velocidad=2)

Representa una nave que puede disparar.

_images/nave.png
__init__(x=0, y=0, velocidad=2)

Constructor de la Nave.

Parámetros:
  • x (int) – posicion horizontal de la nave.
  • y (int) – posicion vertical de la nave.
  • velocidad (int) – Velocidad que llevará la nave.
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á.
class pilas.actores.CursorDisparo(x=0, y=0)

Representa un cursor con una cruz roja.

__init__(x=0, y=0)

Constructor del CursorDisparo

Parámetros:
  • x (int) – Posición horizontal del cursor.
  • y (int) – Posición vertical del cursor.
class pilas.actores.Piedra(x=0, y=0, tamano='grande', dx=0, dy=0)

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

__init__(x=0, y=0, tamano='grande', dx=0, dy=0)

Genera el actor.

Parámetros:
  • x – Posición horizontal del actor.
  • y – Posición vertical del actor.
  • tamano – Tamaño que tendrá la piedra, puerde ser “grande”, “media” o “chica”
  • dx – Velocidad horizontal del movimiento.
  • dy – Velocidad vertical del movimiento.
actualizar()

Realiza una actualización de la posición.

class pilas.actores.Menu(opciones, x=0, y=0, fuente=None, color_normal=<pilas.colores.Color object at 0x105e3a8d0>, color_resaltado=<pilas.colores.Color object at 0x105e3a7d0>)

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

__init__(opciones, x=0, y=0, fuente=None, color_normal=<pilas.colores.Color object at 0x105e3a8d0>, color_resaltado=<pilas.colores.Color object at 0x105e3a7d0>)

Inicializa el menú.

Parámetros:
  • opciones – Tupla con al menos dos elementos obligatorios (:texto:, :funcion:) y :argumentos: opcionales
  • x – Posicion en el eje x
  • y – Posicion en el eje y
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ú.

class pilas.actores.Opcion(texto, x=0, y=0, funcion_a_invocar=None, argumentos=None, fuente=None, color_normal=<pilas.colores.Color object at 0x105e3a8d0>, color_resaltado=<pilas.colores.Color object at 0x105e3a7d0>)

Un item discreto, dispara una funcion al seleccionares.

__init__(texto, x=0, y=0, funcion_a_invocar=None, argumentos=None, fuente=None, color_normal=<pilas.colores.Color object at 0x105e3a8d0>, color_resaltado=<pilas.colores.Color object at 0x105e3a7d0>)

Inicializa el actor.

Parámetros:
  • texto – Etiqueta a mostrar
  • x – Posicion en el eje x
  • y – Posicion en el eje y
  • funcion_a_invocar – Manejador, se dispara al seleccionar la opcion
  • argumentos – Argumentos posicionales para :funcion_a_invocar:
  • fuente – Tipografía a utilizar.
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.

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

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.

__init__(x=0, y=0, dibuja=True)

Inicializa la tortuga.

Parámetros:
  • x – Posición horizontal inicial.
  • y – Posición vertical inicial.
  • dibuja – Indica si a tortuga dejará marcada una linea al moverse.
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.

class pilas.actores.Mapa(grilla=None, x=0, y=0, filas=20, columnas=20)

Representa una mapa de bloques rectangulares, ideal para crear escenarios de plataformas y mapas.

__init__(grilla=None, x=0, y=0, filas=20, columnas=20)

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.
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.
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.
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.

class pilas.actores.Martian(mapa, x=0, y=0)

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

_images/martian.png

Este actor se puede mover con el teclado, pulsando las teclas izquierda, arriba, abajo y derecha ademas de disparar con la barra espaciadora.

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

>>> marciano = pilas.actores.Martian(pilas.actores.Mapa())
__init__(mapa, x=0, y=0)

Constructor del marciano

Parámetros:
  • mapa (pilas.actores.Mapa) – el mapa para que interactue el marciano.
  • x (int) – Posición horizontal del marciano.
  • y (int) – Posición vertical del marciano.
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.
obtener_distancia_al_suelo()

Retorna la distancia en pixels al suelo.

puede_saltar()

Indica si el persona puede saltar.

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

Representa un boton que reacciona al ser presionado.

_images/boton_normal.png
__init__(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.

Parámetros:
  • x (int) – Posición horizontal del Actor.
  • y (int) – Posición vertical del Actor.
  • ruta_normal (string) – Ruta de la imagen del boton en estado normal.
  • ruta_press (string) – Ruta de la imagen del boton cuando se presiona.
  • ruta_over (string) – Ruta de la imagen del boton cuando el ratón pasa por encima.
conectar_normal(funcion, arg='null')

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, arg='null')

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, arg='null')

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.
desconectar_normal(funcion, arg='null')

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, arg='null')

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, arg='null')

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.

pintar_normal()

Dibuja el botón en estado normal.

pintar_presionado(ruta_press='null')

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.

class pilas.actores.Aceituna(x=0, y=0)

Representa una Aceituna. Tiene la capacidad de reir, burlarse, gritar y saltar.

_images/aceituna.png
__init__(x=0, y=0)

Constructor de la Aceituna

Parámetros:
  • x (int) – Posición horizontal de la aceituna.
  • y (int) – Posición vertical de la aceituna.
burlar()

Hace que la aceituna aparezca sacando la lengua.

burlarse()

Hace que la aceituna aparezca sacando la lengua.

gritar()

Hace que la aceituna abra la boca.

normal()

Establece la imagen de la aceituna a Normal.

reir()

Hace que la aceituna aparezca sonriendo.

saltar()

Hace que la aceituna salte y emita un sonido de ‘boing’.

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

Representa un cuadro de dialogo estilo historietas.

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

>>> globo = pilas.actores.Globo("Hola mundo")
_images/globo.png
__init__(texto, x=0, y=0, dialogo=None, avance_con_clicks=True, autoeliminar=False, ancho_globo=0, alto_globo=0)

Constructor del Globo

Parámetros:
  • texto (boolean) – Texto a mostrar en el globo.
  • x (int) – posicion horizontal del globo.
  • y (int) – posicion vertical del globo.
  • dialogo (Dialogo) – Dialogo que contiene las frases a mostrar en el globo.
  • avance_con_clicks (boolean) – Permite avanzar el dialogo pulsando el ratón.
  • autoeliminar (boolean) – Indica si se desea eliminar el globo cuando pasen 3 segundos.
  • ancho_globo (int) – Estabece el ancho del globo en pixeles.
  • alto_globo (int) – Estabece el alto del globo en pixeles.
colocar_origen_del_globo(x, y)

Cambia la posicion del globo para que el punto de donde se emite el globo sea (x, y).

Parámetros:
  • x (int) – Posición horizontal del globo.
  • y (int) – Posición vertical del globo.
cuando_quieren_avanzar(*k)

Función que se ejecuta al hacer click para avanzar o eliminar el globo.

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.iniciar()
_images/mono_dice.png
__init__(modo_automatico=True)

Constructor del Diálogo

Parámetros:modo_automatico (boolean) – Establece si el dialogo ira cambiando automatiamente.
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.
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)
iniciar()

Inicia el dialogo que se haya definido.

>>> d = pilas.actores.Dialogo()
>>> d.decir(mono, "¿Cual es tu color favorito?")
>>> d.iniciar()
class pilas.actores.GloboElegir(texto, opciones, funcion_a_invocar, x=0, y=0, dialogo=None)

Representa un mensaje de globo (similar a las historietas), pero con opciones para elegir.

>>> mensaje = u"Mi color favorito es el..."
>>> globo = pilas.actores.GloboElegir(mensaje, [u"rojo", u"verde", u"azul"], cuando_responde_color_favorito)
_images/globo_elegir.png

El primer argumento es el mensaje a mostrar, el segundo una lista de opciones que se ofrecerán y por último una función de respuesta. Que podría ser codificada así:

def cuando_responde_color_favorito(respuesta):
    print "Ha seleccionado la opcion: " + respuesta
__init__(texto, opciones, funcion_a_invocar, x=0, y=0, dialogo=None)

Constructor del dialogo:

Parámetros:
  • texto – Cadena de texto que se tiene que mostrar.
  • opciones – Lista de opciones a mostrar.
  • funcion_a_invocar – Referencia a la función que se tiene que ejecutar cuando responde el usuario.
  • x – Posición horizontal.
  • y – Posición vertical.
  • dialogo – Instancia del manejador de dialogos, para crear mensajes enlazados.
colocar_origen_del_globo(x, y)

Cambia el punto de referencia del globo.

Parámetros:
  • x – Punto de referencia horizontal.
  • y – Punto de referencia vertical.
class pilas.actores.Pausa(x=0, y=0)

Representa un ícono que se mostrará cuando el juego esté en pausa.

__init__(x=0, y=0)

Inicia el actor de pausa.

Parámetros:
  • x – Posición horizontal del ícono.
  • y – Posición vertical del ícono.
class pilas.actores.CursorMano(x=0, y=0)

Representa un cusor del raton en forma de mano. Cuando se pulsa el boton del ratón la mano cambia a un puño cerrado.

_images/mano.png
__init__(x=0, y=0)

Constructor del cursor de la mano.

Parámetros:
  • x (int) – posicion horizontal del cursor.
  • y (int) – posicion vertical del cursor.
class pilas.actores.Pacman(x=0, y=0, velocidad=3)

Muestra un personaje similar al juego Pac-Man

_images/pacman.png

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

>>> pacman = pilas.actores.Pacman(velocidad=5)
__init__(x=0, y=0, velocidad=3)

Constructor de Pacman

Parámetros:
  • x (int) – Posición horizontal del pacman.
  • y (int) – Posición vertical del pacman.
  • velocidad (int) – velocidad en la que se desplaza pacman
definir_cuadro(indice)

Cambia el cuadro de animación del actor.

class pilas.actores.Ovni(x=0, y=0)

Representa Ovni que explota al momento de ser eliminado.

_images/ovni.png
__init__(x=0, y=0)

Constructor de la Ovni

Parámetros:
  • x (int) – Posición horizontal del ovni.
  • y (int) – Posición vertical del ovni.
pilas.actores.listar_actores()[fuente]

Devuelve una lista con todos los actores disponibles para crear en pilas

Tabla de Contenidos

Tema anterior

Integrando Pilas a una Aplicación Qt

Próximo tema

Módulo pilas.habilidades

Esta página