pilas.interpolaciones

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

# Source Code for Module pilas.interpolaciones

      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  import pilas.pytweener
      9
     10 -class Interpolacion(object):
     11      """Representa una interpolacion, que pasa por varios puntos clave.
     12
     13      Las interpolacione se utilizan para realizar movimientos de
     14      actores en la pantalla. O simplemente para cambiar el
     15      estado de un actor de un punto a otro, por ejemplo, de 0 a 360
     16      grados de manera gradual.
     17
     18      Todo objeto de interpolaciones se puede asignar directamente a
     19      una propiedad de un actor. Por ejemplo:
     20
     21          actor.rotation = pilas.interpolations.Lineal(400)
     22
     23      note que hay un atajo para usar estos objetos, es mejor
     24      utilizar directamente una sentencias como la que sigue::
     25
     26          actor.rotation = pilas.interpolate(360)
     27      """
     28 -    def __init__(self, values, duration, delay):
     29          """Inicializa la interpolación.
     30
     31          ``values`` tiene que ser una lista con todos los puntos
     32          por los que se quiere adoptar valores y ``duration`` es la cantidad
     33          de segundos que deben tomarse para realizar la interpolación.
     34          """
     35          self.values = values
     36          self.duration = duration
     37          self.delay = delay
     38
     39 -    def apply(self, target, function, type):
     40          """Aplica la interpolación a un actor usando un método.
     41
     42          Esta funcionalidad se utiliza para que toda interpolación
     43          se pueda acoplar a un actor.
     44
     45          La idea es contar con la interpolación, un actor y luego
     46          ponerla en funcionamiento::
     47
     48              mi_interpolacion.apply(mono, set_rotation)
     49
     50          de esta forma los dos objetos están y seguirán estando
     51          desacoplados."""
     52
     53          import pilas
     54
     55          # Tiempo que se debe invertir para hacer cada interpolacion
     56          # individual.
     57          step = self.duration / float(len(self.values))
     58          step *= 1000.0
     59
     60          # En base a la funcion busca el getter que le dara
     61          # el valor inicial.
     62          getter = function.replace('set_', 'get_')
     63          function_to_get_value = getattr(target, getter)
     64          fist_value = function_to_get_value()
     65
     66          # Le indica al objeto que tiene que hacer para cumplir
     67          # con cada paso de la interpolacion.
     68          for index, value in enumerate(self.values):
     69              pilas.escena_actual().tweener.addTweenNoArgs(target, function=function,
     70                      initial_value=fist_value,
     71                      value=value,
     72                      tweenDelay=self.delay * 1000.0 + (index * step),
     73                      tweenTime=step,
     74                      tweenType=type)
     75              # El siguiente valor inicial sera el que ha alcanzado.
     76              fist_value = value
     77
     78 -class Lineal(Interpolacion):
     79      "Representa una interpolación lineal."
     80
     81 -    def __init__(self, values, duration, delay):
     82          Interpolacion.__init__(self, values, duration, delay)
     83
     84 -    def __neg__(self):
     85          "Retorna la interpolación inversa a la original."
     86          new_values = list(self.values)
     87          new_values.reverse()
     88          return Lineal(new_values, self.duration, self.delay)
     89
     90 -    def apply(self, target, function):
     91          Interpolacion.apply(self, target, function, pilas.pytweener.Easing.Linear.easeNone)
     92
     93 -class AceleracionGradual(Interpolacion):
     94      "Representa una interpolación con aceleración gradual."
     95
     96 -    def __init__(self, values, duration, delay):
     97          Interpolacion.__init__(self, values, duration, delay)
     98
     99 -    def __neg__(self):
    100          "Retorna la interpolación inversa a la original."
    101          new_values = list(self.values)
    102          new_values.reverse()
    103          return AceleracionGradual(new_values, self.duration, self.delay)
    104
    105 -    def apply(self, target, function):
    106          Interpolacion.apply(self, target, function, pilas.pytweener.Easing.Cubic.easeIn)
    107
    108 -class DesaceleracionGradual(Interpolacion):
    109      "Representa una interpolación con aceleración gradual."
    110
    111 -    def __init__(self, values, duration, delay):
    112          Interpolacion.__init__(self, values, duration, delay)
    113
    114 -    def __neg__(self):
    115          "Retorna la interpolación inversa a la original."
    116          new_values = list(self.values)
    117          new_values.reverse()
    118          return DesaceleracionGradual(new_values, self.duration, self.delay)
    119
    120 -    def apply(self, target, function):
    121          Interpolacion.apply(self, target, function, pilas.pytweener.Easing.Cubic.easeOut)
    122
    123 -class ReboteInicial(Interpolacion):
    124      "Representa una interpolación con rebote."
    125
    126 -    def __init__(self, values, duration, delay):
    127          Interpolacion.__init__(self, values, duration, delay)
    128
    129 -    def __neg__(self):
    130          "Retorna la interpolación inversa a la original."
    131          new_values = list(self.values)
    132          new_values.reverse()
    133          return ReboteInicial(new_values, self.duration, self.delay)
    134
    135 -    def apply(self, target, function):
    136          Interpolacion.apply(self, target, function, pilas.pytweener.Easing.Bounce.easeIn)
    137
    138 -class ReboteFinal(Interpolacion):
    139      "Representa una interpolación con rebote."
    140
    141 -    def __init__(self, values, duration, delay):
    142          Interpolacion.__init__(self, values, duration, delay)
    143
    144 -    def __neg__(self):
    145          "Retorna la interpolación inversa a la original."
    146          new_values = list(self.values)
    147          new_values.reverse()
    148          return ReboteFinal(new_values, self.duration, self.delay)
    149
    150 -    def apply(self, target, function):
    151          Interpolacion.apply(self, target, function, pilas.pytweener.Easing.Bounce.easeOut)
    152
    153 -class ElasticoInicial(Interpolacion):
    154      "Representa una interpolación con rebote."
    155
    156 -    def __init__(self, values, duration, delay):
    157          Interpolacion.__init__(self, values, duration, delay)
    158
    159 -    def __neg__(self):
    160          "Retorna la interpolación inversa a la original."
    161          new_values = list(self.values)
    162          new_values.reverse()
    163          return ReboteInicial(new_values, self.duration, self.delay)
    164
    165 -    def apply(self, target, function):
    166          Interpolacion.apply(self, target, function, pilas.pytweener.Easing.Elastic.easeIn)
    167
    168
    169 -class ElasticoFinal(Interpolacion):
    170      "Representa una interpolación con rebote."
    171
    172 -    def __init__(self, values, duration, delay):
    173          Interpolacion.__init__(self, values, duration, delay)
    174
    175 -    def __neg__(self):
    176          "Retorna la interpolación inversa a la original."
    177          new_values = list(self.values)
    178          new_values.reverse()
    179          return ReboteInicial(new_values, self.duration, self.delay)
    180
    181 -    def apply(self, target, function):
    182          Interpolacion.apply(self, target, function, pilas.pytweener.Easing.Elastic.easeOut)
    183