# -*- 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
mundo = None
bg = None
import sys
import utils
from mundo import Mundo
import actores
import grupo
import escena
import fondos
import habilidades
import sonidos
import musica
import colores
import demos
import atajos
import interfaz
import interprete
import manual
import tutoriales
import municion
import dev
from pilas.escena import Normal
# Permite cerrar el programa usando CTRL+C
import signal
signal.signal(signal.SIGINT, signal.SIG_DFL)
__doc__ = """
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.
"""
[documentos]def 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):
"""
Inicia la ventana principal del juego con algunos detalles de funcionamiento.
Ejemplo de invocación:
>>> pilas.iniciar(ancho=320, alto=240)
.. image:: 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.
"""
global mundo
if not esta_inicializada():
configuracion = obtener_configuracion()
if not usar_motor:
usar_motor = configuracion['usar_motor']
if not audio:
audio = configuracion['audio']
motor = _crear_motor(usar_motor, permitir_depuracion, audio)
if motor:
mundo = Mundo(motor, ancho, alto, titulo, rendimiento, area_fisica, gravedad, pantalla_completa, centrado)
mundo.gestor_escenas.cambiar_escena(Normal())
if _usa_interprete_lanas():
mundo.motor.ventana.show()
else:
mundo.motor.modificar_ventana(ancho, alto, titulo, pantalla_completa)
escena_actual().fisica.definir_gravedad(*gravedad)
[documentos]def esta_inicializada():
"Indica si la biblioteca pilas ha sido inicializada con pilas.iniciar()"
global mundo
return isinstance(mundo, Mundo)
[documentos]def 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):
"""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.
"""
import lanzador
usar_motor, pantalla_completa, audio = lanzador.ejecutar(imagen, titulo)
iniciar(ancho, alto, titulo, usar_motor, rendimiento, modo, area_fisica, gravedad, pantalla_completa, permitir_depuracion, audio)
[documentos]def abrir_asistente():
"""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.
"""
import asistente
asistente.ejecutar()
[documentos]def ejecutar(ignorar_errores=False):
"""Pone en funcionamiento las actualizaciones y dibujado.
Esta función es necesaria cuando se crea un juego
en modo ``no-interactivo``."""
mundo.ejecutar_bucle_principal()
[documentos]def terminar():
"""Finaliza la ejecución de pilas y cierra la ventana principal."""
mundo.terminar()
[documentos]def ver(objeto, imprimir=True, retornar=False):
"""Imprime en pantalla el codigo fuente asociado a un objeto."""
return utils.ver_codigo(objeto, imprimir, retornar)
[documentos]def version():
"""Retorna el número de version de pilas."""
import pilasversion
return pilasversion.VERSION
def _crear_motor(usar_motor, permitir_depuracion, audio):
"""Genera instancia del motor multimedia en base a un nombre.
Esta es una función interna y no debe ser ejecutada
excepto por el mismo motor pilas."""
if usar_motor in ['qt', 'qtgl', 'qtwidget', 'qtsugar', 'qtsugargl']:
from motores import motor_qt
if _usa_interprete_lanas():
usar_motor = 'qtsugar'
motor = motor_qt.Motor(usar_motor, permitir_depuracion, audio)
else:
print "El motor multimedia seleccionado (%s) no esta disponible" % (usar_motor)
print "Las opciones de motores que puedes probar son 'qt', 'qtgl', 'qtwidget', 'qtsugar' y 'qtsugargl'."
motor = None
return motor
def _usa_interprete_lanas():
"Retorna True si se ha iniciado pilas desde lanas"
import os
return 'lanas' in os.environ
[documentos]def reiniciar():
"""Elimina todos los actores y vuelve al estado inicial."""
mundo.reiniciar()
[documentos]def avisar(mensaje, retraso=5):
"""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")
"""
actores.TextoInferior(mensaje, autoeliminar=True, retraso=retraso)
[documentos]def abrir_cargador():
"""Abre un cargador de ejemplos con varios códigos de prueba.
Ejemplo:
>>> pilas.abrir_cargador()
El cargador de ejemplos se ve de esta forma:
.. image:: images/cargador.png
"""
try:
import ejemplos
ejemplos.ejecutar()
except ImportError:
print "Lo siento, no tienes instalada la extesion de ejemplos."
print "Instale el paquete 'pilas-examples' para continuar."
return []
[documentos]def abrir_interprete(parent=None, do_raise=False, con_aplicacion=False):
"""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.
"""
if con_aplicacion:
from PyQt4 import QtGui
app = QtGui.QApplication(sys.argv)
app.setApplicationName("pilas-engine")
interprete.main(parent, do_raise)
return app
def log(*parametros):
global mundo
mundo.motor.log(parametros)
interpolar = utils.interpolar
def escena_actual():
return mundo.gestor_escenas.escena_actual()
def cambiar_escena(escena):
mundo.gestor_escenas.cambiar_escena(escena)
def almacenar_escena(escena):
mundo.gestor_escenas.almacenar_escena(escena)
def recuperar_escena():
mundo.gestor_escenas.recuperar_escena()
[documentos]def obtener_configuracion():
"""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.
"""
opciones = {}
opciones['usar_motor'] = 'qtgl'
opciones['audio'] = 'pygame'
return opciones
# Representa el viejo acceso al modulo eventos, pero convierte cada uno
# de los eventos en una referencia al evento dentro de la escena actual.
from evento import ProxyEventos
eventos = ProxyEventos()