pilas.camara

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

# Source Code for Module pilas.camara

      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
     11 -class Camara(object):
     12      """Representa el punto de vista de la ventana.
     13
     14      Los atributos ``x`` e ``y`` indican cual debe ser el
     15      punto central de la pantalla. Por defecto estos
     16      valores con (0, 0)."""
     17
     18 -    def __init__(self, motor):
     19          """Inicializa la cámara.
     20
     21          :param motor: Referencia al motor de pilas.
     22          """
     23          self.motor = motor
     24
     25      @pilas.utils.interpolable
     26 -    def _set_x(self, x):
     27          """Define la posición horizontal de la cámara.
     28
     29          :param x: Posición horizontal.
     30          """
     31          pilas.escena_actual().mueve_camara.emitir(x=x, y=self.y, dx=x-self.x, dy=0)
     32          pilas.mundo.motor.definir_centro_de_la_camara(x, self.y)
     33
     34 -    def _get_x(self):
     35          """Retorna la posición horizontal."""
     36          x, y = pilas.mundo.motor.obtener_centro_de_la_camara()
     37          return x
     38
     39      @pilas.utils.interpolable
     40 -    def _set_y(self, y):
     41          """Define la posición vertical de la cámara.
     42
     43          :param y: Posición vertical.
     44          """
     45          pilas.escena_actual().mueve_camara.emitir(x=self.x, y=y, dx=0, dy=y-self.y)
     46          pilas.mundo.motor.definir_centro_de_la_camara(self.x, y)
     47
     48 -    def _get_y(self):
     49          """Retorna la posición vertical."""
     50          x, y = pilas.mundo.motor.obtener_centro_de_la_camara()
     51          return y
     52
     53      x = property(_get_x, _set_x)
     54      y = property(_get_y, _set_y)
     55
     56
     57 -    def obtener_area_visible(self):
     58          """Retorna el area del escenario que está visible por la cámara.
     59
     60          Por ejemplo, si la cámara está en posición inicial, esta
     61          función podría retornar:
     62
     63              >>> pilas.escena_actual().camara.obtener_area_visible()
     64              (0, 640, 240, -240)
     65
     66          y si movemos la cámara un poco para la derecha:
     67
     68              >>> pilas.escena_actual().camara.x = 100
     69              >>> pilas.escena_actual().camara.obtener_area_visible()
     70              (100, 740, 240, -240)
     71
     72          Es decir, la tupla representa un rectángulo de la forma::
     73
     74              (izquierda, derecha, arriba, abajo)
     75
     76          En nuestro caso, el último ejemplo muestra que cuando
     77          la cámara se mueve a ``x = 100`` el area de pantalla
     78          visible es ``(izquierda=100, derecha=740, arriba=240, abajo=-240)``.
     79          ¡ ha quedado invisible todo lo que está a la izquierda de ``x=100`` !
     80
     81          Esta función es útil para ``despetar`` actores o simplemente
     82
     83
     84          Si quieres saber si un actor está fuera de la pantalla hay un
     85          atajo, existe un método llamado ``esta_fuera_de_la_pantalla`` en
     86          los propios actores:
     87
     88              >>> mi_actor = pilas.actores.Mono(x=0, y=0)
     89              >>> mi_actor.esta_fuera_de_la_pantalla()
     90              False
     91              >>> pilas.escena_actual().camara.x == 900
     92              >>> mi_actor.esta_fuera_de_la_pantalla()
     93              True
     94          """
     95          ancho, alto = pilas.mundo.motor.obtener_area()
     96          return (self.x - ancho/2, self.x + ancho/2, self.y + alto/2, self.y - alto/2)
     97
     98 -    def desplazar(self, posicion):
     99          """Mueve la cámara hacia una posición en particular.
    100
    101          :param posicion: La posición destino, a donde enfocar.
    102          """
    103          x, y = posicion
    104          return (x - self.x, y - self.y)
    105