pilas

Package pilas |
[hide private]
[frames] | no frames]

# Source Code for Package pilas

      1  # -*- encoding: utf-8 -*-
      2  # pilas engine - a video game framework.
      3  #
      4  # copyright 2010 - hugo ruscitti
      5  # license: lgplv3 (see http://www.gnu.org/licenses/lgpl.html)
      6  #
      7  # website - http://www.pilas-engine.com.ar
      8
      9  mundo = None
     10  bg = None
     11
     12  import sys
     13  import utils
     14  from mundo import Mundo
     15  import actores
     16  import grupo
     17  import escena
     18  import escenas
     19  import fondos
     20  import habilidades
     21  import sonidos
     22  import musica
     23  import colores
     24  import demos
     25  import atajos
     26  import interfaz
     27  import interprete
     28  import municion
     29  from pilas.escena import Normal
     30
     31  # Permite cerrar el programa usando CTRL+C
     32  import signal
     33  signal.signal(signal.SIGINT, signal.SIG_DFL)
     34
     35  __doc__ = """
     36  Módulo pilas
     37  ============
     38
     39  Pilas es una biblioteca para facilitar el desarrollo
     40  de videojuegos. Es útil para programadores
     41  principiantes o para el desarrollo de juegos casuales.
     42
     43  Este módulo contiene las funciones principales
     44  para iniciar y ejecutar la biblioteca.
     45  """
     46
     47 -def iniciar(ancho=640, alto=480, titulo='Pilas', usar_motor='qtgl',
     48              rendimiento=60, modo='detectar', gravedad=(0, -90), pantalla_completa=False,
     49              permitir_depuracion=True, audio='phonon'):
     50      """
     51      Inicia la ventana principal del juego con algunos detalles de funcionamiento.
     52
     53      Ejemplo de invocación:
     54
     55          >>> pilas.iniciar(ancho=320, alto=240)
     56
     57      .. image:: images/iniciar_320_240.png
     58
     59      Parámetros:
     60
     61      :ancho: el tamaño en pixels para la ventana.
     62      :alto: el tamaño en pixels para la ventana.
     63      :titulo: el titulo a mostrar en la ventana.
     64      :usar_motor: el motor multimedia a utilizar, puede ser 'qt', 'qtgl', 'qtsugar' o 'qtsugargl'.
     65      :rendimiento: cantidad de cuadros por segundo a mostrar.
     66      :modo: si se utiliza modo interactivo o no.
     67      :gravedad: el vector de aceleracion para la simulacion de fisica.
     68      :pantalla_completa: si debe usar pantalla completa o no.
     69      :permitir_depuracion: si se desea tener habilidatas las funciones de depuracion de las teclas F5 a F12
     70
     71      """
     72
     73      global mundo
     74
     75      if not esta_inicializada():
     76          motor = _crear_motor(usar_motor, permitir_depuracion, audio)
     77
     78          if motor:
     79              mundo = Mundo(motor, ancho, alto, titulo, rendimiento, gravedad, pantalla_completa)
     80              mundo.gestor_escenas.cambiar_escena(Normal())
     81
     82              if _usa_interprete_lanas():
     83                  mundo.motor.ventana.show()
     84      else:
     85          mundo.motor.modificar_ventana(ancho, alto, titulo, pantalla_completa)
     86          escena_actual().fisica.definir_gravedad(*gravedad)
     87
     88
     89 -def esta_inicializada():
     90      "Indica si la biblioteca pilas ha sido inicializada con pilas.iniciar()"
     91      global mundo
     92      return isinstance(mundo, Mundo)
     93
     94
     95 -def iniciar_con_lanzador(ancho=640, alto=480, titulo='Pilas',
     96              rendimiento=60, modo='detectar', gravedad=(0, -90), imagen="asistente.png",
     97              permitir_depuracion=True):
     98      """Identica a la función iniciar, solo que permite al usuario seleccionar
     99      el motor multimedia y el modo de video a utilizar.
    100
    101      Esta función es útil cuando se quiere distribuir un juego y no se conoce
    102      exáctamente el equipo del usuario.
    103      """
    104      import lanzador
    105
    106      usar_motor, pantalla_completa, audio = lanzador.ejecutar(imagen, titulo)
    107      iniciar(ancho, alto, titulo, usar_motor, rendimiento, modo, gravedad, pantalla_completa, permitir_depuracion, audio)
    108
    109
    110 -def abrir_asistente():
    111      """Abre una ventana que permite iniciar pilas graficamente.
    112
    113      Las opciones que ofrece son "leer el manual" (si esta disponible),
    114      "abrir un interprete", "explorar los ejemplos" etc.
    115
    116      Esta ventana se ha diseñado para mostrarse a los nuevos usuarios
    117      de pilas, por ejemplo cuando eligen abrir pilas desde el icono principal.
    118      """
    119      import asistente
    120      asistente.ejecutar()
    121
    122 -def ejecutar(ignorar_errores=False):
    123      """Pone en funcionamiento las actualizaciones y dibujado.
    124
    125      Esta función es necesaria cuando se crea un juego
    126      en modo ``no-interactivo``."""
    127      mundo.ejecutar_bucle_principal(ignorar_errores)
    128
    129 -def terminar():
    130      """Finaliza la ejecución de pilas y cierra la ventana principal."""
    131      mundo.terminar()
    132
    133 -def ver(objeto, imprimir=True, retornar=False):
    134      """Imprime en pantalla el codigo fuente asociado a un objeto."""
    135      return utils.ver_codigo(objeto, imprimir, retornar)
    136
    137 -def version():
    138      """Retorna el número de version de pilas."""
    139      import pilasversion
    140      return pilasversion.VERSION
    141
    142 -def _crear_motor(usar_motor, permitir_depuracion, audio):
    143      """Genera instancia del motor multimedia en base a un nombre.
    144
    145      Esta es una función interna y no debe ser ejecutada
    146      excepto por el mismo motor pilas."""
    147
    148      if usar_motor in ['qt', 'qtgl', 'qtwidget', 'qtsugar', 'qtsugargl']:
    149          from motores import motor_qt
    150
    151          if _usa_interprete_lanas():
    152              usar_motor = 'qtsugar'
    153
    154          motor = motor_qt.Motor(usar_motor, permitir_depuracion, audio)
    155      else:
    156          print "El motor multimedia seleccionado (%s) no esta disponible" %(usar_motor)
    157          print "Las opciones de motores que puedes probar son 'qt', 'qtgl', 'qtwidget', 'qtsugar' y 'qtsugargl'."
    158          motor = None
    159
    160      return motor
    161
    162 -def _usa_interprete_lanas():
    163      "Retorna True si se ha iniciado pilas desde lanas"
    164      import os
    165      return os.environ.has_key('lanas')
    166
    167 -def reiniciar():
    168      """Elimina todos los actores y vuelve al estado inicial."""
    169      mundo.reiniciar()
    170
    171 -def avisar(mensaje, retraso=5):
    172      """Emite un mensaje en la ventana principal.
    173
    174      Este mensaje aparecerá en la parte inferior de la pantalla durante
    175      5 segundo, por ejemplo:
    176
    177          >>> pilas.avisar("Use la tecla <esc> para terminar el programa")
    178      """
    179      actores.TextoInferior(mensaje, autoeliminar=True, retraso=retraso)
    180
    181 -def abrir_cargador():
    182      """Abre un cargador de ejemplos con varios códigos de prueba.
    183
    184      Ejemplo:
    185
    186          >>> pilas.abrir_cargador()
    187
    188      El cargador de ejemplos se ve de esta forma:
    189
    190      .. image:: images/cargador.png
    191      """
    192
    193      try:
    194          import ejemplos
    195          ejemplos.ejecutar()
    196      except ImportError:
    197          print "Lo siento, no tienes instalada la extesion de ejemplos."
    198          print "Instale el paquete 'pilas-examples' para continuar."
    199
    200      return []
    201
    202 -def abrir_interprete(parent=None, do_raise=False):
    203      """Abre un intérprete interactivo de python con una ventana.
    204
    205      Esta función se ejecuta cuando un usuario escribe::
    206
    207          pilas -i
    208
    209      en una consola del sistema.
    210      """
    211      interprete.main(parent, do_raise)
    212
    213 -def log(*parametros):
    214      eventos.log.emitir(data=parametros)
    215
    216  interpolar = utils.interpolar
    217
    218 -def escena_actual():
    219      return mundo.gestor_escenas.escena_actual()
    220
    221 -def cambiar_escena(escena):
    222      mundo.gestor_escenas.cambiar_escena(escena)
    223
    224 -def almacenar_escena(escena):
    225      mundo.gestor_escenas.almacenar_escena(escena)
    226
    227 -def recuperar_escena():
    228      mundo.gestor_escenas.recuperar_escena()
    229
    230  # Representa el viejo acceso al modulo eventos, pero convierte cada uno
    231  # de los eventos en una referencia al evento dentro de la escena actual.
    232  from evento import ProxyEventos
    233  eventos = ProxyEventos()
    234