¿Cómo curiosear en Pilas y buscar más información?


Además del manual y de los tutoriales que podéis encontrar en esta wiki y en la página de Pilas, hay otras formas para profundizar un poco más y averiguar más detalles de cómo está hecho, qué componentes tiene y cómo funcionan.

A menudo nos surgen preguntas del tipo: ¿Qué fondos tiene predefinidos Pilas? ¿Cómo funciona el método pilas.avisar( ) ? Estas y otras preguntas pueden estar respondidas en el manual o los tutoriales, pero pueden también no estarlo. A fin de cuentas, ¡no pueden escribirse todos los detalles de todo!

La manera más adecuada de buscar respuestas es mirando las tripas de Pilas y la documentación que acompaña al propio código. Podemos hacerlo usando tres métodos distintos: dir( ), help( ) y pilas.ver( ).

Método dir( )


Todo en Pilas es un objeto y la función dir( ) nos devuelve una lista con los elementos que tiene el objeto que le pasemos como argumento.

Pongamos un ejemplo: Imagina que nos preguntamos qué habilidades tiene predefinidas Pilas en el módulo pilas.habilidades. Bien, esta es la primera tentativa que podemos probar:

>>> import pilas
>>> pilas.iniciar()
>>> dir(pilas.habilidades)

Y ésta es la respuesta que nos devolverá Pilas (en versiones posteriores a la 0.73 puede haber variaciones a lo mostrado):

['Arrastrable', 'AumentarConRueda', 'ColisionableComoPelota', 'Disparar',
 'DispararConClick', 'Habilidad', 'Imitar', 'MirarAlActor',
 'MoverseComoCoche', 'MoverseConElTeclado', 'PisaPlataformas',
 'PuedeExplotar', 'RebotarComoCaja', 'RebotarComoPelota', 'RotarConMouse',
 'SeMantieneEnPantalla', 'SeguirAlMouse', 'SeguirClicks',
 'SiempreEnElCentro', '__builtins__', '__doc__', '__file__', '__name__',
 '__package__', 'math', 'pilas', 'random']

Como quiera que devuelve en el listado todos los elementos (atributos, funciones especiales, etc), ésta es una manera rápida de ver lo que tiene definido sin más detalles.

Método help( )


Si queremos más, help( ) devuelve la información que el propio programador ha incluido en el código.

Siguiendo con el ejemplo de antes, probemos a poner

>>> help(pilas.habilidades)

La respuesta será mucho más larga... (sólo incluimos parte de ella):

Help on module pilas.habilidades in pilas:
 
NAME
    pilas.habilidades
 
FILE
    /home/fsalamero/pilas/pilas/habilidades.py
 
DESCRIPTION
    # -*- encoding: utf-8 -*-
    # Pilas engine - A video game framework.
    #
    # Copyright 2010 - Hugo Ruscitti
    # License: LGPLv3 (see http://www.gnu.org/licenses/lgpl.html)
    #
    # Website - http://www.pilas-engine.com.ar
 
CLASSES
    __builtin__.object
        Habilidad
            Arrastrable
            AumentarConRueda
            Disparar
                DispararConClick
            Imitar
            MirarAlActor
            MoverseConElTeclado
                MoverseComoCoche
            PisaPlataformas
            PuedeExplotar
            RebotarComoCaja
            RebotarComoPelota
                ColisionableComoPelota
            RotarConMouse
            SeMantieneEnPantalla
            SeguirAlMouse
            SeguirClicks
            SiempreEnElCentro
 
    class Arrastrable(Habilidad)
     |  Hace que un objeto se pueda arrastrar con el puntero del mouse.
     |
     |  Cuando comienza a mover al actor se llama al metodo ''comienza_a_arrastrar''
     |  y cuando termina llama a ''termina_de_arrastrar''. Estos nombres
     |  de metodos se llaman para que puedas personalizar estos eventos, dado
     |  que puedes usar polimorfismo para redefinir el comportamiento
     |  de estos dos metodos. Observa un ejemplo de esto en
     |  el ejemplo ``pilas.ejemplos.Piezas``.
     |
     |  Method resolution order:
     |      Arrastrable
     |      Habilidad
     |      __builtin__.object
     |
     |  Methods defined here:
     |
     |  __init__(self, receptor)
     |
     |  comienza_a_arrastrar(self)
     |
     |  cuando_arrastra(self, evento)
     |      Arrastra el actor a la posicion indicada por el puntero del mouse.
     |
     |  cuando_intenta_arrastrar(self, evento)
     |      Intenta mover el objeto con el mouse cuando se pulsa sobre el.
     |
     |  cuando_termina_de_arrastrar(self, evento)
     |      Suelta al actor porque se ha soltado el botón del mouse.
     |
     |  termina_de_arrastrar(self)
     |
     |  ----------------------------------------------------------------------
     |  Methods inherited from Habilidad:
     |
     |  actualizar(self)
     |
     |  eliminar(self)
     |
     |  ----------------------------------------------------------------------
     |  Data descriptors inherited from Habilidad:
     |
     |  __dict__
     |      dictionary for instance variables (if defined)
     |
     |  __weakref__
     |      list of weak references to the object (if defined)
 

¿Ves la diferencia? Aquí podemos ver los detalles del módulo u objeto que queramos conocer, con las explicaciones que ha incluido el programador. Observa, por ejemplo, lo claro que está el listado de habilidades disponibles. O las explicaciones de la habilidad (la clase) Arrastrable.

Pero... ¿quieres todavía más?

Método pilas.ver( )


A diferencia de los métodos anteriores, proporcionados directamente por Python, Pilas posee una función propia, pilas.ver( ), que permite ver el código fuente del objeto que le pasemos como argumento.

Ya que acabamos de ver la habilidad Arrastrable, vamos a pedirle que nos enseñe su código:

>>> pilas.ver(pilas.habilidades.Arrastrable)

Y he aquí la respuesta:

class Arrastrable(Habilidad):
    """Hace que un objeto se pueda arrastrar con el puntero del mouse.
 
    Cuando comienza a mover al actor se llama al metodo ''comienza_a_arrastrar''
    y cuando termina llama a ''termina_de_arrastrar''. Estos nombres
    de metodos se llaman para que puedas personalizar estos eventos, dado
    que puedes usar polimorfismo para redefinir el comportamiento
    de estos dos metodos. Observa un ejemplo de esto en
    el ejemplo ``pilas.ejemplos.Piezas``.
    """
 
    def __init__(self, receptor):
        Habilidad.__init__(self, receptor)
        pilas.escena_actual().click_de_mouse.conectar(self.cuando_intenta_arrastrar)
 
    def cuando_intenta_arrastrar(self, evento):
        "Intenta mover el objeto con el mouse cuando se pulsa sobre el."
        if (evento.boton == 1):
            if self.receptor.colisiona_con_un_punto(evento.x, evento.y):
                pilas.escena_actual().termina_click.conectar(self.cuando_termina_de_arrastrar,
                                       id='cuando_termina_de_arrastrar')
                pilas.escena_actual().mueve_mouse.conectar(self.cuando_arrastra,
                                       id='cuando_arrastra')
                self.comienza_a_arrastrar()
 
    def cuando_arrastra(self, evento):
        "Arrastra el actor a la posicion indicada por el puntero del mouse."
        if self._el_receptor_tiene_fisica():
            pilas.escena_actual().fisica.cuando_mueve_el_mouse(evento.x, evento.y)
        else:
            self.receptor.x += evento.dx
            self.receptor.y += evento.dy
 
    def cuando_termina_de_arrastrar(self, evento):
        "Suelta al actor porque se ha soltado el botón del mouse."
        pilas.escena_actual().mueve_mouse.desconectar_por_id(id='cuando_arrastra')
        self.termina_de_arrastrar()
        pilas.escena_actual().termina_click.desconectar_por_id(id='cuando_termina_de_arrastrar')
 
    def comienza_a_arrastrar(self):
        if self._el_receptor_tiene_fisica():
            pilas.escena_actual().fisica.capturar_figura_con_el_mouse(self.receptor.figura)
 
    def termina_de_arrastrar(self):
        if self._el_receptor_tiene_fisica():
            pilas.escena_actual().fisica.cuando_suelta_el_mouse()
 
    def _el_receptor_tiene_fisica(self):
        return hasattr(self.receptor, 'figura')

Interesante, ¿verdad?