Creando un primer programa con pyBta.
Llegado a este punto, me gustaría
explicar como generar un primer programa con esta biblioteca.
El programa será el típico hola
mundo.
En un futuro hablaré tranquilamente
sobre cada módulo y sobre como estoy enfocando la idea.
Para este ejemplo voy a utilizar
elementos del módulo de controles y elementos del módulo de
escenas.
Primero voy a poner el código del
ejemplo y luego pasaré a comentarlo poco a poco.
#
-*- coding: ISO-8859-1 -*-
#!
/usr/local/bin/python
import
pyBta
from
pyBta import
escenas
from
pyBta import
controles
pyBta.iniciar(titulo="Saludo.",dimensiones=(640,480),fps=30)
class
Escena(escenas.BtaEscena):
def
__init__(self):
escenas.BtaEscena.__init__(self)
def
cargar_escena(self):
self.medidas=640,440
self.ente=escenas.biblioteca.Brady()
self.poner(self.ente)
class
Formulario(controles.BtaFormulario):
def
__init__(self):
controles.BtaFormulario.__init__(self)
def
pre_iniciar(self):
self.medidas=640,40
self.y=440
self.boton=controles.BtaBotonTextual("Púlsame.")
self.boton.ancho=640
self.boton.alto=40
self.poner(self.boton)
return
True
class
Pantalla(pyBta.BtaPantalla):
def
__init__(self):
pyBta.BtaPantalla.__init__(self)
def
pre_iniciar(self):
self.formulario=Formulario()
self.poner(self.formulario)
self.escena=Escena()
pyBta.gestorDeEscenas.poner_escena(self.escena)
return
True
def
post_iniciar(self):
self.formulario.boton.EventoClick=self.saludar
return
True
def
saludar(self,evento):
self.escena.ente.hablar("Hola
mundo. \n Bienvenidos a pyBta.")
pantalla=Pantalla()
pyBta.poner_pantalla(pantalla)
pyBta.ejecutar()
Al
ejecutar el ejemplo debería verse así.
El
personaje camina cuando se pulsa con el botón izquierdo del ratón
sobre alguna zona de la escena. Si se pulsa sobre el botón
“púlsame.” el personaje mostrará el mensaje: Hola mundo.
Bienvenidos a pyBta.
Voy
a explicar, como funciona el código de este ejemplo.
import
pyBta
from
pyBta import
escenas
from
pyBta import
controles
La
primera linea importa la biblioteca. La segunda importa el módulo de
escenas y la tercera el de controles.
También
se puede acceder a estos módulos importando solo pyBta, para
después, dirigirte a cualquiera de ellos de esta manera:
pyBta.controles
pyBta.escenas
La
siguiente linea inicia la ventana.
pyBta.iniciar(titulo="Saludo.",dimensiones=(640,480),fps=30)
el
atributo fps, se usa para limitar el número de cuadros por segundo
que mostrará la aplicación. El fps o frame rate es la tasa de
imágenes por segundo que es capaz de mostrar un programa. PyBta
arranca de serie a sesenta fps, pero para hacer aplicaciones y juegos
pequeños, que es para lo que esta pensada esta biblioteca, sobra con
treinta fps por segundo.
class
Escena(escenas.BtaEscena):
def
__init__(self):
escenas.BtaEscena.__init__(self)
def
cargar_escena(self):
self.medidas=640,440
self.ente=escenas.biblioteca.Brady()
self.poner(self.ente)
Esta
parte del código, expresa la creación de una escena con pyBta.
Como
se ve, para generar una escena, se debe crear una clase que herede
del objeto BtaEscena, el cual existe dentro del módulo escenas.
Este
objeto provee de los métodos y atributos necesarios para generar una
escena de manera sencilla.
La
función “cargar_escena” se entrega al usuario inicialmente
vacía.
El
usuario es el encargado de sobrescribirla, para cargar en ella todos
los recursos que quiera usar dentro de la escena.
La
primera linea dentro de la función declara el tamaño de la escena y
también su parte visible sobre la pantalla.
La
segunda declara un ente de la biblioteca. PyBta trae dentro del
módulo escenas, un submódulo llamado biblioteca. En este voy
guardando una serie de BtaEntes (sprites) ya diseñados para hacer
pruebas rápidas.
La
tercera pone el ente creado dentro de la escena.
Con
esto ya tenemos una escena sencilla lista para ser usada.
class
Formulario(controles.BtaFormulario):
def
__init__(self):
controles.BtaFormulario.__init__(self)
def
pre_iniciar(self):
self.medidas=640,40
self.y=440
self.boton=controles.BtaBotonTextual("Púlsame.")
self.boton.ancho=640
self.boton.alto=40
self.poner(self.boton)
return
True
Esta
parte del código, expresa la creación de un formulario. Existen dos
objetos preparados para trabajar con controles dentro de pyBta: el
objeto BtaFormulario y el objeto BtaDialogo.
Como
se observa en la imagen, a la izquierda puede verse un BtaFormulario
vacío y a la derecha un BtaDialogo también vacío.
Los
formularios y los diálogos proveen la interfaz necesaria para
interactuar con los controles y son los dos únicos objetos que
pueden posarse directamente sobre una BtaPantalla.
La
función pre_iniciar, tiene el mismo uso que la función
cargar_escena usada en la creación de la escena anterior. Solo que
en esta ocasión, lo que se crea dentro de el formulario son
controles.
La
primera linea de la función, funciona como en la escena y expresa
las medidas del formulario.
La
segunda, expresa la posición que tendrá el formulario sobre la
pantalla.
La
tercera, delara un control de tipo BtaBotonTextual y carga dentro de
el el texto “Púlsame.”
La
cuarta y la quinta, expresan el tamaño del botón. Estos dos
atributos funcionan igual que el atributo medidas y queda a decisión
del usuario usar unos u otros según le convengan.
Después
se pone el botón creado en el formulario mediante la función poner.
La
función “pre_iniciar” debe acabar siempre retornando True. Esto
es debido a que esta función pertenece a una cadena de métodos que
se ejecutan al iniciar un control. De no retornar true, la cadena de
inicio se romperá dando fallos en el programa.
class
Pantalla(pyBta.BtaPantalla):
def
__init__(self):
pyBta.BtaPantalla.__init__(self)
def
pre_iniciar(self):
self.formulario=Formulario()
self.poner(self.formulario)
self.escena=Escena()
pyBta.gestorDeEscenas.poner_escena(self.escena)
return
True
Aquí
se declara la pantalla para el ejemplo. Esta vez se usa su función
“pre_iniciar” para declarar tanto la escena, como el formulario
creados anteriormente.
Como
se puede observar en este pedazo de código, el formulario se pone
directamente sobre la pantalla, pero la escena, se pone en un objeto
llamado
gestorDeEscenas.
El
objeto gestor es el encargado de lidiar con las escenas y en ningún
momento se debe poner una escena directamente sobre una pantalla.
Más
adelante daré más información sobre este objeto.
def
post_iniciar(self):
self.formulario.boton.EventoClick=self.saludar
return
True
def
saludar(self,evento):
self.escena.ente.hablar("Hola
mundo. \n Bienvenidos a pyBta.")
En
estas dos funciones, me sirven para expresar, un poco, como se
comunican los objetos dentro de pyBta.
PyBta
se basa en eventos para la comunicación entre objetos. Para ello
necesita básicamente dos cosas:
*la
primera es una función que usar como respuesta a un evento, en este
caso es la función saludar.
*La
segunda es un modo de conectar esta función al objeto que
proporcionará su ejecución. Esto se hace dentro de la función
post_iniciar.
Dentro
de esta función llamamos al objeto formulario y después al objeto
botón que habíamos creado dentro de el. Finalmente llamamos al
atributo “EventoClick” y le añadimos la función que queremos
usar como respuesta. Esto hará que cada vez que pulsemos y soltemos
sobre el botón, pyBta reaccionará emitiendo la función saludar.
La
función post_iniciar pertenece al la misma cadena que la función
pre_iniciar.
Y
también debe retornar True para terminar de crear el elemento
correctamente.
La
función pre_iniciar, se ejecuta antes de iniciar la parte interna de
un control.
La
función post_iniciar, se lanza después de tener iniciada la parte
interna del control.
Lo
que existe dentro de la función saludar, es una llamada a una
función ya programada dentro del ente generado. Esta muestra un
texto sobre la escena mientras el ente mueve los labios.
pantalla=Pantalla()
pyBta.poner_pantalla(pantalla)
pyBta.ejecutar()
Estas
tres últimas lineas, son las mismas que mostré en la entrada
anterior y expresan, la generación de la pantalla, como se pone
dentro de PyBta y como se ejecuta finalmente la biblioteca.
En
próximas entradas hablaré más detalladamente sobre cada módulo
que constituye la biblioteca.
No hay comentarios:
Publicar un comentario