pilas.actores.martian

Package pilas :: Package actores :: Module martian |
[hide private]
[frames] | no frames]

# Source Code for Module pilas.actores.martian

      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 pilas
     10  from pilas.actores import Actor
     11  from pilas.comportamientos import Comportamiento
     12
     13  VELOCIDAD = 100
     14
     15
     16 -class Martian(Actor):
     17      """Es un personaje de un marciano que puede caminar, saltar y disparar.
     18
     19          .. image:: images/actores/martian.png
     20
     21      Este actor se puede mover con el teclado, pulsando las teclas ``izquierda``,
     22      ``arriba``, ``abajo`` y ``derecha`` ademas de disparar con la
     23      ``barra espaciadora``.
     24
     25      El marciano necesita un mapa para no caer al vacio y desaparecer de la
     26      pantalla.
     27
     28          >>> marciano = pilas.actores.Martian(pilas.actores.Mapa())
     29
     30      """
     31
     32 -    def __init__(self, mapa, x=0, y=0):
     33          """Constructor del marciano
     34
     35          :param mapa: el mapa para que interactue el marciano.
     36          :type mapa: pilas.actores.Mapa
     37          :param x: Posición horizontal del marciano.
     38          :type x: int
     39          :param y: Posición vertical del marciano.
     40          :type y: int
     41
     42          """
     43          Actor.__init__(self, x=x, y=y)
     44          self.imagen = pilas.imagenes.cargar_grilla("marcianitos/martian.png", 12)
     45          self.definir_cuadro(0)
     46          self.mapa = mapa
     47          self.hacer(Esperando())
     48          self.municion = pilas.actores.proyectil.Bala
     49          self.aprender(pilas.habilidades.Disparar,
     50                         municion=pilas.actores.proyectil.Bala,
     51                         angulo_salida_disparo=-90,
     52                         frecuencia_de_disparo=8,
     53                         offset_disparo=(25,0),
     54                         offset_origen_actor=(25,23))
     55
     56
     57 -    def definir_cuadro(self, indice):
     58          """Define el cuadro de animación a mostrar.
     59
     60          :param indice: El número de cuadro comenzando desde 0.
     61          """
     62          self.imagen.definir_cuadro(indice)
     63          self.definir_centro((32, 123))
     64
     65 -    def actualizar(self):
     66          "Sigue el movimiento de la figura."
     67          pass
     68
     69 -    def puede_saltar(self):
     70          "Indica si el persona puede saltar."
     71          return True
     72
     73 -    def obtener_distancia_al_suelo(self):
     74          "Retorna la distancia en pixels al suelo."
     75          return self.mapa.obtener_distancia_al_suelo(self.x, self.y, 100)
     76
     77
     78 -class Esperando(Comportamiento):
     79      """Representa al actor en posicion normal.
     80
     81      Este comportamiento espera a que el usuario pulse
     82      alguna tecla para entrar en movimiento.
     83      """
     84 -    def iniciar(self, receptor):
     85          """Inicia el comportamiento y define los valores iniciales.
     86
     87          :param receptor: El actor que será controlado por este comportamiento."
     88          """
     89          self.receptor = receptor
     90          self.receptor.definir_cuadro(0)
     91
     92 -    def actualizar(self):
     93          if pilas.escena_actual().control.izquierda:
     94              self.receptor.hacer(Caminando())
     95          elif pilas.escena_actual().control.derecha:
     96              self.receptor.hacer(Caminando())
     97
     98          if pilas.escena_actual().control.arriba and self.receptor.puede_saltar():
     99              self.receptor.hacer(Saltando(-8))
    100
    101          if pilas.escena_actual().control.boton:
    102              self.receptor.hacer(Disparar(self.receptor))
    103
    104          self.caer_si_no_toca_el_suelo()
    105
    106 -    def caer_si_no_toca_el_suelo(self):
    107          if self.receptor.obtener_distancia_al_suelo() > 0:
    108              self.receptor.hacer(Saltando(0))
    109
    110 -class Caminando(Esperando):
    111      """Representa al actor caminando hacia la izquierda o derecha."""
    112
    113 -    def __init__(self):
    114          self.cuadros = [1, 1, 1, 2, 2, 2]
    115          self.paso = 0
    116
    117 -    def iniciar(self, receptor):
    118          """Inicia el comportamiento y define los valores iniciales.
    119
    120          :param receptor: El actor que será controlado por este comportamiento."
    121          """
    122          self.receptor = receptor
    123
    124 -    def actualizar(self):
    125          self.avanzar_animacion()
    126
    127          if pilas.escena_actual().control.izquierda:
    128              self.receptor.x -= 3
    129              self.receptor.espejado = True
    130              self.receptor.habilidades.Disparar.angulo_salida_disparo = 90
    131          elif pilas.escena_actual().control.derecha:
    132              self.receptor.x += 3
    133              self.receptor.espejado = False
    134              self.receptor.habilidades.Disparar.angulo_salida_disparo = -90
    135          else:
    136              self.receptor.hacer(Esperando())
    137
    138          if pilas.escena_actual().control.arriba:
    139              self.receptor.hacer(Saltando(-8))
    140
    141          self.caer_si_no_toca_el_suelo()
    142
    143 -    def avanzar_animacion(self):
    144          """Cambia el cuado de animación para avanzar la animación"""
    145          self.paso += 1
    146
    147          if self.paso >= len(self.cuadros):
    148              self.paso = 0
    149
    150          self.receptor.definir_cuadro(self.cuadros[self.paso])
    151
    152 -class Saltando(Comportamiento):
    153      """Representa al actor realizando un salto."""
    154
    155 -    def __init__(self, velocidad_de_salto):
    156          self.velocidad_de_salto = velocidad_de_salto
    157          Comportamiento.__init__(self)
    158
    159 -    def iniciar(self, receptor):
    160          """Inicia el comportamiento y define los valores iniciales.
    161
    162          :param receptor: El actor que será controlado por este comportamiento."
    163          """
    164          self.receptor = receptor
    165          self.receptor.definir_cuadro(3)
    166
    167 -    def actualizar(self):
    168          self.velocidad_de_salto += 0.25
    169          distancia = self.receptor.obtener_distancia_al_suelo()
    170
    171          # Si toca el suelo se detiene.
    172          if self.velocidad_de_salto > distancia:
    173              self.receptor.y -= distancia
    174              self.receptor.hacer(Esperando())
    175          else:
    176              self.receptor.y -= self.velocidad_de_salto
    177
    178          # obtiene la veloridad del personaje para detectar cuando
    179          # toca el suelo.
    180          vx, vy = 0, 0 #self.receptor.figura.obtener_velocidad_lineal()
    181
    182          if pilas.escena_actual().control.izquierda:
    183              self.receptor.espejado = True
    184              self.receptor.habilidades.Disparar.angulo_salida_disparo = 90
    185              self.receptor.x -= 3
    186          elif pilas.escena_actual().control.derecha:
    187              self.receptor.espejado = False
    188              self.receptor.habilidades.Disparar.angulo_salida_disparo = -90
    189              self.receptor.x += 3
    190
    191 -class Disparar(Comportamiento):
    192      """Representa al actor disparando un proyectil."""
    193
    194 -    def __init__(self, receptor):
    195          self.cuadros = [6, 6, 7, 7, 8, 8]
    196          self.paso = 0
    197
    198 -    def actualizar(self):
    199          termina = self.avanzar_animacion()
    200
    201          if termina:
    202              self.receptor.hacer(Esperando())
    203
    204 -    def avanzar_animacion(self):
    205          self.paso += 1
    206
    207          if self.paso >= len(self.cuadros):
    208              self.paso = 0
    209              return True
    210
    211          self.receptor.definir_cuadro(self.cuadros[self.paso])
    212