pilas.actores.pizarra

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

# Source Code for Module pilas.actores.pizarra

      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 import colores
     12
     13 -class Pizarra(Actor):
     14      """Representa una superficie de dibujo inicialmente transparente.
     15
     16      Puedes pintar sobre esta pizarra usando métodos que simulan
     17      un lapiz, que se puede mover sobre una superficie.
     18      """
     19
     20 -    def __init__(self, x=0, y=0, ancho=None, alto=None):
     21          """Inicializa el actor Pizarra.
     22
     23          :param x: Posición horizontal inicial.
     24          :param y: Posición horizontal inicial.
     25          :param ancho: El tamaño horizontal en pixels, si no se especifica será el tamaño de la ventana.
     26          :param alto: El tamaño vertical en pixels, si no se especifica será el tamaño de la ventana.
     27          """
     28          # Si no define area de la pizarra toma el tamano de la ventana.
     29          if not ancho or not alto:
     30              ancho, alto = pilas.mundo.motor.obtener_area()
     31
     32          Actor.__init__(self, x=x, y=y)
     33          self.imagen = pilas.imagenes.cargar_superficie(ancho, alto)
     34
     35 -    def dibujar_punto(self, x, y, color=colores.negro):
     36          """Dibuja un punto sobre la pizarra.
     37
     38          El punto será 3 pixels de radio, y si no se especifica tendrá
     39          color negro.
     40
     41          Este es un ejemplo de invocación:
     42
     43              >>> pizarra.dibujar_punto(20, 30, pilas.colores.rojo)
     44
     45          :param x: Posición horizontal para el punto.
     46          :param y: Posición vertical para el punto.
     47          :param color: El color para el punto.
     48          """
     49
     50          x, y = self.obtener_coordenada_fisica(x, y)
     51          self.imagen.dibujar_punto(x, y, color=color)
     52
     53 -    def obtener_coordenada_fisica(self, x, y):
     54          """Convierte las coordenadas de pantalla a coordenadas físicas.
     55
     56          Una coordenanda de pantalla, comienza en el punto (0, 0) y corresponde
     57          al centro de la pizarra. Mientras que una coordenada física tiene un
     58          sistema parecido al de los juegos viejos, donde (0, 0) es la esquina
     59          superir izquierda de la pantalla.
     60
     61          :param x: Coordenada x a convertir.
     62          :param y: Coordenada y a convertir.
     63          """
     64          x = (self.imagen.ancho()/2) + x
     65          y = (self.imagen.alto()/2) - y
     66          return x, y
     67
     68 -    def pintar_imagen(self, imagen, x, y):
     69          """Dibuja una imagen sobre la pizarra.
     70
     71          :param imagen: Referencia a la imagen que se quiere pintar.
     72          :param x: Coordenada destino horizontal.
     73          :param y: Coordenada destino vertical.
     74          """
     75          self.pintar_parte_de_imagen(imagen, 0, 0, imagen.ancho(), imagen.alto(), x, y)
     76
     77 -    def pintar_parte_de_imagen(self, imagen, origen_x, origen_y, ancho, alto, x, y):
     78          """Dibuja una porción de una imagen sobre la pizarra.
     79
     80          Este método, a diferencia de "pintar_imagen", capturará un rectángulo
     81          de la imagen fuente.
     82
     83          :param imagen: Imagen fuente que se quiere dibujar sobre la pizarra.
     84          :param origen_x: Marca la esquina superior izquierda desde donde se recortar.
     85          :param origen_y: Marca la esquina superior izquierda desde donde se recortar.
     86          :param ancho: Ancho del rectángulo de corte.
     87          :param alto: Alto del rectángulo de corte.
     88          """
     89          x, y = self.obtener_coordenada_fisica(x, y)
     90          self.imagen.pintar_parte_de_imagen(imagen, origen_x, origen_y, ancho, alto, x, y)
     91
     92 -    def pintar_grilla(self, grilla, x, y):
     93          """Dibuja un cuadro de animación sobre la pizarra.
     94
     95          :param grilla: La grilla a dibujar.
     96          :param x: Coordenada horizontal sobre la pizarra.
     97          :param y: Coordenada vertical sobre la pizarra.
     98          """
     99          grilla.dibujarse_sobre_una_pizarra(self, x, y)
    100
    101 -    def pintar(self, color):
    102          """Pinta toda la pizarra de un solo color.
    103
    104          Por ejemplo:
    105
    106              >>> pizarra.pintar(pilas.colores.rojo)
    107
    108          :param color: El color que pintará toda la pizarra.
    109          """
    110          self.imagen.pintar(color)
    111
    112 -    def linea(self, x, y, x2, y2, color=colores.negro, grosor=1):
    113          """Dibuja una linea recta sobre la pizarra.
    114
    115          :param x: Coordenada horizontal desde donde comenzará la linea.
    116          :param y: Coordenada vertical desde donde comenzará la linea.
    117          :param x2: Coordenada horizontal desde donde terminará la linea.
    118          :param y2: Coordenada vertical desde donde terminará la linea.
    119          :param color: El color de la linea.
    120          :param grosor: Cuan gruesa será la linea en pixels.
    121          """
    122          x, y = self.obtener_coordenada_fisica(x, y)
    123          x2, y2 = self.obtener_coordenada_fisica(x2, y2)
    124          self.imagen.linea(x, y, x2, y2, color, grosor)
    125
    126 -    def rectangulo(self, x, y, ancho, alto, color=colores.negro, relleno=False, grosor=1):
    127          """Dibuja un rectángulo sobre la pizarra.
    128
    129          Si el rectángulo se dibuja con relleno, el color será el que pintará todo
    130          el rectángulo, en caso contrario, el color será utilizado para dibujar el
    131          contorno del rectángulo.
    132
    133          :param x: Posición horizontal de la esquina superior izquierda.
    134          :param y: Posición horizontal de la esquina superior izquierda.
    135          :param ancho: Ancho del rectángulo.
    136          :param alto: Altura del rectángulo.
    137          :param relleno: Indica con True o False si el rectángulo se tiene que pintar completamente.
    138          :param grosor: Grosor del contorno del rectángulogulo.
    139          """
    140          x, y = self.obtener_coordenada_fisica(x, y)
    141          self.imagen.rectangulo(x, y, ancho, alto, color, relleno, grosor)
    142
    143 -    def texto(self, cadena, x=0, y=0, magnitud=10, fuente=None, color=colores.negro):
    144          """Dibuja una cadena de texto sobre la pizarra.
    145
    146          :param cadena: El string que se quiere dibujar.
    147          :param x: Coordenada horizontal.
    148          :param y: Coordenada vertical.
    149          :param magnitud: Tamaño que tendrá la tipografía.
    150          :param fuente: Nombre de la tipografía a utilizar.
    151          :param color: Color del texto a dibujar.
    152          """
    153          x, y = self.obtener_coordenada_fisica(x, y)
    154          self.imagen.texto(cadena, x, y, magnitud, fuente, color)
    155
    156 -    def poligono(self, puntos, color=pilas.colores.negro, grosor=1):
    157          """Dibuja un polígono sobre la pizarra.
    158
    159          Ejemplo:
    160
    161              >>> pizarra = pilas.actores.Pizarra()
    162              >>> pizarra.poligono([(10, 20), (100, 140)], color=pilas.colores.verde, grosor=4)
    163
    164          :param puntos: Una lista de puntos en forma de tupla (x, y) que conforman el polígono.
    165          :param color: El color de la linea a trazar.
    166          :param grosor: El grosor de la linea a trazar en pixels.
    167          """
    168          puntos = [self.obtener_coordenada_fisica(*p) for p in puntos]
    169          self.imagen.poligono(puntos, color, grosor)
    170
    171 -    def limpiar(self):
    172          """Borra toda la pizarra y los dibujos que hay en ella."""
    173          self.imagen.limpiar()
    174