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()[source]

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()[source]

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)[source]

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)[source]

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)[source]

Pone en funcionamiento las actualizaciones y dibujado.

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

pilas.esta_inicializada()[source]

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='detectar', gravedad=(0, -90), pantalla_completa=False, permitir_depuracion=True, audio='phonon')[source]

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.
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
pilas.iniciar_con_lanzador(ancho=640, alto=480, titulo='Pilas', rendimiento=60, modo='detectar', gravedad=(0, -90), imagen='asistente.png', permitir_depuracion=True)[source]

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.reiniciar()[source]

Elimina todos los actores y vuelve al estado inicial.

pilas.terminar()[source]

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

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

Imprime en pantalla el codigo fuente asociado a un objeto.

pilas.version()[source]

Retorna el número de version de pilas.

Módulo pilas.control

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

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)[source]

Módulo pilas.evento

class pilas.evento.ProxyEventos[source]

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[source]

Se invoca regularmente, 60 veces por segundo.

click_de_mouse[source]

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[source]

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

mueve_camara[source]

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[source]

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[source]

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[source]

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[source]

Indica que se ha pulsado la tecla scape.

suelta_tecla[source]

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[source]

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

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.

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.

decir(mensaje, autoeliminar=True)

Emite un mensaje usando un globo similar al de los commics

destruir()

Elimina a un actor pero de manera inmediata.

eliminar()

Elimina el actor de la lista de actores que se imprimen en pantalla.

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.

fijo

Indica si el actor debe ser independiente a la camara.

imagen

Define la imagen a mostrar.

obtener_velocidad()

Obtiene la velocidad que lleva el actor

pre_actualizar()

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

rotacion

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

transparencia

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

vx

Obtiene la velocidad horizontal del actor.

vy

Obtiene la velocidad vertical del actor.

x

Define la posición horizontal.

y

Define la posición vertical.

z

Define lejania respecto del observador.

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)
decir(mensaje)

Emite un mensaje y además sonrie mientras habla.

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.

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)
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 pongü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)
definir_cuadro(indice)

Permite cambiar el cuadro de animación a mostrar

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

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

_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 con sonido en pantalla.

Este es un ejemplo de uso del actor:

>>> bomba = pilas.actores.Bomba()
>>> bomba.explotar()
__init__(x=0, y=0)
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)
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)
abrir()

Muestra el gráfico de la banana abierta con menos cáscara.

cerrar()

Muestra el gráfico de banana normal (con cáscara)

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

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

Color del texto.

magnitud

El tamaño del texto.

texto

El texto que se tiene que mostrar.

class pilas.actores.Temporizador(x=0, y=0, color=<pilas.colores.Color object at 0x10a8f68d0>)

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 0x10a8f68d0>)
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.

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.

>>> moneda = pilas.actores.Moneda()
_images/moneda.png
__init__(x=0, y=0)
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)
class pilas.actores.Pelota(x=0, y=0)

Representa una pelota de Volley.

__init__(x=0, y=0)
class pilas.actores.Puntaje(texto='0', x=0, y=0, color=<pilas.colores.Color object at 0x10a8f68d0>)

Representa un contador de Puntaje

__init__(texto='0', x=0, y=0, color=<pilas.colores.Color object at 0x10a8f68d0>)
class pilas.actores.Estrella(x=0, y=0)

Representa una estrella de color amarillo.

__init__(x=0, y=0)
class pilas.actores.Caja(x=0, y=0)

Representa un bloque que tiene fisica como una caja.

__init__(x=0, y=0)
class pilas.actores.Nave(x=0, y=0, velocidad=2)

Representa una nave que puede disparar.

__init__(x=0, y=0, velocidad=2)
definir_enemigos(grupo, cuando_elimina_enemigo=None)

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

El argumento cuando_elimina_enemigo tiene que ser una funcion que se ejecutara cuando se produzca la colision.

hacer_explotar_al_enemigo(mi_disparo, el_enemigo)

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

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

Representa un bloque que tiene fisica como una caja.

__init__(x=0, y=0)
class pilas.actores.Piedra(x=0, y=0, tamano='grande', dx=0, dy=0)

Representa un bloque que tiene fisica como una caja.

__init__(x=0, y=0, tamano='grande', dx=0, dy=0)
class pilas.actores.Menu(opciones, x=0, y=0)

Una lista de Opciones que se pueden seleccionar :param opciones: Tupla con al menos dos elementos obligatorios (:texto:, :funcion:) y :argumentos: opcionales :param x: Posicion en el eje x :param y: Posicion en el eje y

__init__(opciones, x=0, y=0)
actualizar()

Se ejecuta de manera periodica.

crear_texto_de_las_opciones(opciones)

Genera un actor por cada opcion del menu.

cuando_mueve_el_mouse(evento)

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

class pilas.actores.Opcion(texto, x=0, y=0, funcion_a_invocar=None, argumentos=None)

Un item discreto, dispara una funcion al seleccionares :param texto: Etiqueta a mostrar :param x: Posicion en el eje x :param y: Posicion en el eje y :param funcion_a_invocar: Manejador, se dispara al seleccionar la opcion :param argumentos: Argumentos posicionales para :funcion_a_invocar:

__init__(texto, x=0, y=0, funcion_a_invocar=None, argumentos=None)
resaltar(estado=True)

Pinta la opcion actual de un color mas claro.

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 mueve por la pantalla como la tortuga de Logo.

__init__(x=0, y=0, dibuja=True)
crear_circulo(radio=30, sentido=-1)

dibuja un circulo

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

dibuja un poligono de n lados

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.

__init__(x=0, y=0, ruta_normal='boton/boton_normal.png', ruta_press='boton/boton_press.png', ruta_over='boton/boton_over.png')
class pilas.actores.EntradaDeTexto(x=0, y=0, color=<pilas.colores.Color object at 0x10a8f68d0>, limite=10, tamano=32, fuente='Arial', cursor_intermitente=True, acepta_multilinea=True)

Representa una caja de texto que puede servir para ingresar texto.

Este actor, en la mayoria de los casos, se utiliza para solicitarle el nombre a un usuario. Por ejemplo, cuando completa un record de puntaje.

__init__(x=0, y=0, color=<pilas.colores.Color object at 0x10a8f68d0>, limite=10, tamano=32, fuente='Arial', cursor_intermitente=True, acepta_multilinea=True)
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.

__init__(texto, x=0, y=0, dialogo=None, avance_con_clicks=True, autoeliminar=False, ancho_globo=0, alto_globo=0)
colocar_origen_del_globo(x, y)

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

Representa una secuencia de mensajes entre varios actores.

__init__(modo_automatico=True)
class pilas.actores.CursorMano(x=0, y=0)

Representa un bloque que tiene fisica como una caja.

__init__(x=0, y=0)

Contenidos

Tema anterior

Integrando Pilas a una Aplicación Qt

Próximo tema

Módulo pilas.habilidades

Esta página