Implementacion de movimiento de lineas

Se agrego la implementacion del movimiento de las lineas
que se detienen cuando se presiona cualquier tecla. Falta
implementar el calculo del puntaje de acuerdo a la interseccion
de las lineas, mostrarlo y que luego inicie de nuevo el juego

1 files changed, 120 insertions, 11 deletions

diff --git a/board.py b/board.py
index d425aa6..1e9b76f 100755
--- a/board.py
+++ b/board.py
@@ -2,6 +2,10 @@
 import gtk
 import gobject
 
+DELAY = 5
+DELTA = 1
+WIDTH = 512
+HEIGHT = 512
 
 class Darts():
 
@@ -9,18 +13,42 @@ class Darts():
         window = gtk.Window()
 
         drawing_area = gtk.DrawingArea()
-        drawing_area.set_size_request(512, 512)
+        drawing_area.set_size_request(WIDTH, HEIGHT)
 
         self.pixbuf = gtk.gdk.pixbuf_new_from_file('images/dartboard.png')
 
         window.connect('destroy', self.destroy)
         drawing_area.connect('configure_event', self.__configure_cb)
         drawing_area.connect('expose-event', self.__expose_cb)
+        window.connect('key-press-event', self.__key_press_cb, drawing_area)
 
         window.add(drawing_area)
 
         window.show_all()
-#        my_rectangle = self.draw_rectangle(drawing_area, 10)
+
+        self.DELTA_X = DELTA
+        self.DELTA_Y = DELTA
+
+        # Variable global que ira indicando el "indice" de pixel donde dibujar
+        # la linea vertical
+        self._x = 0
+
+        # Variable global que contendra el "indice" de pixel donde el usuario
+        # presiono alguna tecla para detenerlo. El valor inicial -1 indica que
+        # todavia no se ha presionado una tecla para la linea vertical
+        self._selected_x = -1
+
+        # Variable global que ira indicando el "indice" de pixel donde dibujar
+        # la linea horizontal
+        self._y = 0
+
+        # Variable global que contendra el "indice" de pixel donde el usuario
+        # presiono alguna tecla para detenerlo. El valor inicial -1 indica que
+        # todavia no se ha presionado una tecla para la linea horizontal
+        self._selected_y = -1
+        
+        gobject.timeout_add(DELAY, self.__move_vertical_line, drawing_area)
+        
 
     def destroy(self, window, data=None):
         gtk.main_quit()
@@ -31,8 +59,6 @@ class Darts():
         canvas = drawing_area.window
         self.pixmap = gtk.gdk.Pixmap(canvas, width, height)
 
-        self.pixmap.draw_pixbuf(None, self.pixbuf, 0, 0, 0, 0, -1, -1,
-                                gtk.gdk.RGB_DITHER_NONE, 0, 0)
         return True
 
     def __expose_cb(self, drawing_area, data=None):
@@ -42,18 +68,101 @@ class Darts():
         canvas = drawing_area.window
         canvas.draw_drawable(context, self.pixmap, x, y, x, y, width, height)
         
-        rectangle = self.draw_rectangle(drawing_area, 10, height)
-        
         return False
+
+    def draw_background(self, drawing_area):
+        #Utilizado para dibujar objetos en el pixmap
+        cr = self.pixmap.cairo_create()
+        
+        # Dibujar inicialmente un fondo negro
+        cr.set_source_rgb(0, 0, 0)
+        rectangle = gtk.gdk.Rectangle(0, 0, WIDTH, HEIGHT)
+        rectangle = cr.rectangle(rectangle)
+        drawing_area.queue_draw() 
+        cr.fill()
+
+        # Dibujar la diana sobre el fondo negro
+        self.pixmap.draw_pixbuf(None, self.pixbuf, 0, 0, 0, 0, -1, -1,
+                                gtk.gdk.RGB_DITHER_NONE, 0, 0)
     
-    def draw_rectangle(self, drawing_area, x, height):
-        cr = drawing_area.window.cairo_create()
-        cr.set_line_width(5)
+    def draw_line(self, drawing_area, orientation, line_index):
+        #Utilizado para dibujar objetos en el pixmap
+        cr = self.pixmap.cairo_create()
+
+        # Dibujar una linea vertical cuya altura ocupe toda la pantalla y sea de
+        # color blanco para contrastarlo con la diana
         cr.set_source_rgb(255, 255, 255)
-        rectangle = gtk.gdk.Rectangle(x,0,1, height)
+
+        if orientation == "VERTICAL":
+            rectangle = gtk.gdk.Rectangle(line_index, 0, 1, HEIGHT)
+        else:
+            rectangle = gtk.gdk.Rectangle(0, line_index, WIDTH, 1)
+
         rectangle = cr.rectangle(rectangle)
+        drawing_area.queue_draw() 
         cr.fill()
-        return rectangle
+    
+    
+    def __move_vertical_line(self, drawing_area):
+        #Dibujar el fondo sobre el cual movemos las lineas, si aun no hemos
+        #presionado un boton para dejar la linea vertical en una coordenada dada
+        if self._selected_x < 0:
+            self.draw_background(drawing_area)
+        
+        # Mover el indice x para que aparente movimiento
+        self._x += self.DELTA_X;
+        if self._x > WIDTH:
+            self.DELTA_X *= -1
+        elif self._x < 0:
+            self.DELTA_X *= -1
+
+        # Dibujar una linea vertical en la x correspondiente
+        self.draw_line(drawing_area, "VERTICAL", self._x)
+        
+        # Si aun no se selecciono un indice para x, seguir permitiendo invocar
+        # al timer. Caso contrario, retornar False para evitar mas invocaciones
+        if self._selected_x < 0:
+            return True
+        else:
+            return False
+    
+    def __move_horizontal_line(self, drawing_area):
+        #Dibujar el fondo sobre el cual movemos las lineas
+        self.draw_background(drawing_area)
+
+        # Como la linea vertical ya se detuvo para poder mover la linea 
+        # horizontal, dibujar la linea vertical en la x seleccionada
+        self.draw_line(drawing_area, "VERTICAL", self._selected_x)
+
+        # Mover el indice y para que aparente movimiento
+        self._y += self.DELTA_Y;
+        if self._y > HEIGHT:
+            self.DELTA_Y *= -1
+        elif self._y < 0:
+            self.DELTA_Y *= -1
+
+        # Dibujar una linea horizontal en la y correspondiente
+        self.draw_line(drawing_area, "HORIZONTAL", self._y)
+
+        # Si aun no se selecciono un indice para y, seguir permitiendo invocar
+        # al timer. Caso contrario, retornar False para evitar mas invocaciones
+        if self._selected_y < 0:
+            return True
+        else:
+            return False
+
+    def __key_press_cb(self, window, event, drawing_area):
+        # Al presionar cualquier tecla, determinar la accion a tomar, de 
+        # acuerdo al estado de las lineas.
+        if self._selected_x == -1:
+            self._selected_x = self._x
+            gobject.timeout_add(DELAY, self.__move_horizontal_line, drawing_area)            
+        elif self._selected_y == -1:
+            self._selected_y = self._y
+        else:
+            # TO-DO: Calcular el puntaje de acuerdo a _selected_x y _selected_y
+            pass
+            # TO-DO: Mostrar el puntaje, y al presionar algo iniciar de nuevo
 
 if __name__ == "__main__":
     my_darts = Darts()