pilas.depurador

Package pilas :: Module depurador |
[hide private]
[frames] | no frames]

# Source Code for Module pilas.depurador

      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  import sys
     10  import pilas
     11  from pilas import pilasversion
     12
     13  try:
     14      import widget_log
     15  except ImportError, e:
     16      print e
     17      pass
     18
     19 -class DepuradorDeshabilitado(object):
     20
     21 -    def comienza_dibujado(self, motor, painter):
     22          pass
     23
     24 -    def dibuja_al_actor(self, motor, painter, actor):
     25          pass
     26
     27 -    def termina_dibujado(self, motor, painter):
     28          pass
     29
     30 -    def cuando_pulsa_tecla(self, codigo_tecla, texto_tecla):
     31          pass
     32
     33 -    def cuando_mueve_el_mouse(self, x, y):
     34          pass
     35
     36 -class Depurador(DepuradorDeshabilitado):
     37      """Esta clase permite hacer depuraciones visuales.
     38
     39      La depuracion visual en pilas consiste en poder mostrar informacion
     40      que generalmente es invisible a los jugadores. Por ejemplo, donde
     41      estan situados los puntos de control, los radios de colision etc.
     42
     43      Esta clase administra varios modos depuracion, que son los
     44      que dibujan figuras geometricas.
     45      """
     46
     47 -    def __init__(self, lienzo, fps):
     48          self.modos = []
     49          self.lienzo = lienzo
     50          ModoDepurador.grosor_de_lineas = 1
     51          self.fps = fps
     52          self.posicion_del_mouse = (0, 0)
     53
     54 -    def comienza_dibujado(self, motor, painter):
     55          for m in self.modos:
     56              m.comienza_dibujado(motor, painter, self.lienzo)
     57
     58 -    def dibuja_al_actor(self, motor, painter, actor):
     59          for m in self.modos:
     60              m.dibuja_al_actor(motor, painter, self.lienzo, actor)
     61
     62 -    def termina_dibujado(self, motor, painter):
     63          if self.modos:
     64              self._mostrar_cantidad_de_actores(painter)
     65              self._mostrar_cuadros_por_segundo(painter)
     66              self._mostrar_posicion_del_mouse(painter)
     67              self._mostrar_nombres_de_modos(painter)
     68
     69              for m in self.modos:
     70                  m.termina_dibujado(motor, painter, self.lienzo)
     71
     72 -    def cuando_pulsa_tecla(self, codigo_tecla, texto_tecla):
     73          if codigo_tecla == 'F5':
     74              self._alternar_modo(ModoWidgetLog)
     75          elif codigo_tecla == 'F6':
     76              pilas.utils.imprimir_todos_los_eventos()
     77          elif codigo_tecla == 'F7':
     78              self._alternar_modo(ModoInformacionDeSistema)
     79          elif codigo_tecla == 'F8':
     80              self._alternar_modo(ModoPuntosDeControl)
     81          elif codigo_tecla == 'F9':
     82              self._alternar_modo(ModoRadiosDeColision)
     83          elif codigo_tecla == 'F10':
     84              self._alternar_modo(ModoArea)
     85          elif codigo_tecla == 'F11':
     86              self._alternar_modo(ModoFisica)
     87          elif codigo_tecla == 'F12':
     88              self._alternar_modo(ModoPosicion)
     89          elif texto_tecla == '+':
     90              self._cambiar_grosor_de_bordes(+1)
     91          elif texto_tecla == '-':
     92              self._cambiar_grosor_de_bordes(-1)
     93
     94 -    def cuando_mueve_el_mouse(self, x, y):
     95          self.posicion_del_mouse = x, y
     96          return True
     97
     98 -    def _cambiar_grosor_de_bordes(self, cambio):
     99          ModoDepurador.grosor_de_lineas = max(1, ModoDepurador.grosor_de_lineas + cambio)
    100
    101 -    def _alternar_modo(self, clase_del_modo):
    102          clases_activas = [x.__class__ for x in self.modos]
    103
    104          if clase_del_modo in clases_activas:
    105              self._desactivar_modo(clase_del_modo)
    106          else:
    107              self._activar_modo(clase_del_modo)
    108
    109 -    def _activar_modo(self, clase_del_modo):
    110          instancia_del_modo = clase_del_modo(self)
    111          self.modos.append(instancia_del_modo)
    112          self.modos.sort(key=lambda x: x.orden_de_tecla())
    113
    114 -    def _desactivar_modo(self, clase_del_modo):
    115          instancia_a_eliminar = [x for x in self.modos
    116                                  if x.__class__ == clase_del_modo]
    117          self.modos.remove(instancia_a_eliminar[0])
    118          instancia_a_eliminar[0].sale_del_modo()
    119
    120 -    def _mostrar_nombres_de_modos(self, painter):
    121          dy = 0
    122          izquierda, derecha, arriba, abajo = pilas.utils.obtener_bordes()
    123
    124          for modo in self.modos:
    125              texto = modo.tecla + " " + modo.__class__.__name__ + " habilitado."
    126              self.lienzo.texto_absoluto(painter, texto, izquierda + 10, arriba -20 +dy, color=pilas.colores.blanco)
    127              dy -= 20
    128
    129 -    def _mostrar_posicion_del_mouse(self, painter):
    130          izquierda, derecha, arriba, abajo = pilas.utils.obtener_bordes()
    131          x, y = self.posicion_del_mouse
    132          texto = u"Posición del mouse: x=%d y=%d " %(x, y)
    133          self.lienzo.texto_absoluto(painter, texto, derecha - 230, abajo + 10, color=pilas.colores.blanco)
    134
    135 -    def _mostrar_cuadros_por_segundo(self, painter):
    136          izquierda, derecha, arriba, abajo = pilas.utils.obtener_bordes()
    137          rendimiento = self.fps.obtener_cuadros_por_segundo()
    138          texto = "Cuadros por segundo: %s" %(rendimiento)
    139          self.lienzo.texto_absoluto(painter, texto, izquierda + 10, abajo + 10, color=pilas.colores.blanco)
    140
    141 -    def _mostrar_cantidad_de_actores(self, painter):
    142          izquierda, derecha, arriba, abajo = pilas.utils.obtener_bordes()
    143          total_de_actores = len(pilas.escena_actual().actores)
    144          texto = "Cantidad de actores: %s" %(total_de_actores)
    145          self.lienzo.texto_absoluto(painter, texto, izquierda + 10, abajo + 30, color=pilas.colores.blanco)
    146
    147 -    def definir_modos(self, fisica=False, info=False, puntos_de_control=False,
    148                              radios=False, areas=False, posiciones=False, log=False):
    149          """Permite habilitar o deshabilitar los modos depuración.
    150
    151          Cada uno de los argumentos representa un modo depuración, el valor True
    152          habilita el modo, False lo deshabilita.
    153          """
    154          self._desactivar_todos_los_modos()
    155
    156          if log:
    157              self._alternar_modo(ModoWidgetLog)
    158
    159          if info:
    160              self._alternar_modo(ModoInformacionDeSistema)
    161
    162          if puntos_de_control:
    163              self._alternar_modo(ModoPuntosDeControl)
    164
    165          if radios:
    166              self._alternar_modo(ModoRadiosDeColision)
    167
    168          if areas:
    169              self._alternar_modo(ModoArea)
    170
    171          if fisica:
    172              self._alternar_modo(ModoFisica)
    173
    174          if posiciones:
    175              self._alternar_modo(ModoPosicion)
    176
    177
    178 -    def _desactivar_todos_los_modos(self):
    179          clases_activas = [x.__class__ for x in self.modos]
    180
    181          for clase in clases_activas:
    182              self._desactivar_modo(clase)
    183
    184
    185 -class ModoDepurador(object):
    186      tecla = "F00"
    187
    188 -    def __init__(self, depurador):
    189          self.depurador = depurador
    190
    191 -    def comienza_dibujado(self, motor, painter, lienzo):
    192          pass
    193
    194 -    def dibuja_al_actor(self, motor, painter, lienzo, actor):
    195          pass
    196
    197 -    def termina_dibujado(self, motor, painter, lienzo):
    198          pass
    199
    200 -    def orden_de_tecla(self):
    201          return int(self.tecla[1:])
    202
    203 -    def sale_del_modo(self):
    204          pass
    205
    206 -class ModoWidgetLog(ModoDepurador):
    207      tecla = "F5"
    208
    209 -    def __init__(self, depurador):
    210          ModoDepurador.__init__(self, depurador)
    211          self.widget = widget_log.WidgetLog()
    212          self.widget.show()
    213          self.widget.imprimir(locals())
    214
    215 -    def sale_del_modo(self):
    216          self.widget.close()
    217
    218
    219
    220 -class ModoInformacionDeSistema(ModoDepurador):
    221      tecla = "F7"
    222
    223 -    def __init__(self, depurador):
    224          ModoDepurador.__init__(self, depurador)
    225
    226          self.informacion = [
    227              "Usando el motor: " + pilas.mundo.motor.nombre,
    228              "Sistema: " + sys.platform,
    229              "Version de pilas: " + pilasversion.VERSION,
    230              "Version de python: " + sys.subversion[0] + " " + sys.subversion[1],
    231              "Version de Box2D: " + pilas.fisica.obtener_version(),
    232              ]
    233
    234 -    def termina_dibujado(self, motor, painter, lienzo):
    235          izquierda, derecha, arriba, abajo = pilas.utils.obtener_bordes()
    236
    237          for (i, texto) in enumerate(self.informacion):
    238              posicion_y = abajo + 50 + i * 20
    239              lienzo.texto(painter, texto, izquierda + 10, posicion_y, color=pilas.colores.blanco)
    240
    241
    242 -class ModoPuntosDeControl(ModoDepurador):
    243      tecla = "F8"
    244
    245 -    def dibuja_al_actor(self, motor, painter, lienzo, actor):
    246          lienzo.cruz(painter, actor.x - pilas.escena_actual().camara.x, actor.y - pilas.escena_actual().camara.y, color=pilas.colores.blanco, grosor=ModoDepurador.grosor_de_lineas)
    247
    248
    249 -class ModoRadiosDeColision(ModoDepurador):
    250      tecla = "F9"
    251
    252 -    def dibuja_al_actor(self, motor, painter, lienzo, actor):
    253          lienzo.circulo(painter, actor.x - pilas.escena_actual().camara.x, actor.y - pilas.escena_actual().camara.y, actor.radio_de_colision, color=pilas.colores.blanco, grosor=ModoDepurador.grosor_de_lineas)
    254
    255
    256 -class ModoArea(ModoDepurador):
    257      tecla = "F10"
    258
    259 -    def dibuja_al_actor(self, motor, painter, lienzo, actor):
    260          dx, dy = actor.centro
    261          lienzo.rectangulo(painter, actor.x - dx - pilas.escena_actual().camara.x, actor.y + dy - pilas.escena_actual().camara.y, actor.ancho, actor.alto, color=pilas.colores.blanco, grosor=ModoDepurador.grosor_de_lineas)
    262
    263
    264 -class ModoFisica(ModoDepurador):
    265      tecla = "F11"
    266
    267 -    def termina_dibujado(self, motor, painter, lienzo):
    268          grosor = ModoDepurador.grosor_de_lineas
    269          pilas.escena_actual().fisica.dibujar_figuras_sobre_lienzo(painter, lienzo, grosor)
    270
    271
    272 -class ModoPosicion(ModoDepurador):
    273      tecla = "F12"
    274
    275 -    def __init__(self, depurador):
    276          ModoDepurador.__init__(self, depurador)
    277          self.eje = pilas.actores.Ejes()
    278
    279 -    def dibuja_al_actor(self, motor, painter, lienzo, actor):
    280          if not isinstance(actor, pilas.fondos.Fondo):
    281              texto = "(%d, %d)" %(actor.x, actor.y)
    282              lienzo.texto(painter, texto, actor.derecha - pilas.escena_actual().camara.x, actor.abajo - pilas.escena_actual().camara.y, color=pilas.colores.blanco)
    283
    284 -    def sale_del_modo(self):
    285          self.eje.eliminar()
    286