more pages

1 files changed, 103 insertions, 34 deletions

diff --git a/game.py b/game.py
index fb4af94..d8bd707 100644
--- a/game.py
+++ b/game.py
@@ -55,8 +55,8 @@ def read_accelerometer(game):
 
 
 # Grid dimensions must be even
-TEN = 9
-SIX = 5
+NINE = 9
+FIVE = 5
 DOT_SIZE = 40
 YELLOW = 6
 RED = 4
@@ -122,10 +122,10 @@ class Game():
         self._label._vert_align = ["bottom"]
 
         self._dots = []
-        for y in range(SIX):
-            for x in range(TEN):
-                xoffset = int((self._width - TEN * self._dot_size - \
-                                   (TEN - 1) * self._space) / 2.)
+        for y in range(FIVE):
+            for x in range(NINE):
+                xoffset = int((self._width - NINE * self._dot_size - \
+                                   (NINE - 1) * self._space) / 2.)
                 self._dots.append(
                     Sprite(self._sprites,
                            xoffset + x * (self._dot_size + self._space),
@@ -134,7 +134,7 @@ class Game():
                 self._dots[-1].type = DOT
                 self._dots[-1].set_label_attributes(40)
 
-        n = SIX / 2.
+        n = FIVE / 2.
 
         # and initialize a few variables we'll need.
         self._yellow_dot()
@@ -143,21 +143,22 @@ class Game():
         self._pausing = False
 
     def _yellow_dot(self):
-        self._label.set_label('Click on the yellow dot.')
-        self._targets = [int(uniform(0, TEN * SIX))]
+        self._label.set_label('Tap on the yellow dot.')
+        self._targets = [int(uniform(0, NINE * FIVE))]
         self._next = self._yellow_dot_too
         self._dots[self._targets[0]].set_shape(
             self._new_dot(self._colors[YELLOW]))
         self._dots[self._targets[0]].type = YELLOW
         self._rubbing = False
 
-    def _yellow_dot_too(self):
+    def _yellow_dot_too(self, append=True):
         ''' Things to reinitialize when starting up a new game. '''
-        i = self._targets[0]
-        while i in self._targets:
-            i = int(uniform(0, TEN * SIX))
-        self._targets.append(i)
-        self._label.set_label('Well done! Click on the other yellow dot.')
+        if append:
+            i = self._targets[0]
+            while i in self._targets:
+                i = int(uniform(0, NINE * FIVE))
+            self._targets.append(i)
+            self._label.set_label('Well done! Now tap on the other yellow dot.')
         self._next = self._yellow_dots_three
         self._dots[self._targets[1]].set_shape(
             self._new_dot(self._colors[YELLOW]))
@@ -166,9 +167,13 @@ class Game():
 
     def _yellow_dots_three(self):
         ''' Things to reinitialize when starting up a new game. '''
+        if self._release == self._targets[0]:
+            self._yellow_dot_too(append=False)
+            self._label.set_label('The other yellow dot!')
+            return
         i = self._targets[0]
         while i in self._targets:
-            i = int(uniform(0, TEN * SIX))
+            i = int(uniform(0, NINE * FIVE))
         self._targets.append(i)
         self._label.set_label('Great! Now rub on one of the yellow dots.')
         self._next = self._red_dot
@@ -180,7 +185,8 @@ class Game():
     def _red_dot(self):
         if self._release is None:
             return
-        self._label.set_label('Good job! Now rub on another yellow dot.')
+        self._label.set_label('Good job! \
+Now rub on another one of the yellow dots.')
         self._next = self._blue_dot
         self._dots[self._release].set_shape(self._new_dot(self._colors[RED]))
         self._dots[self._release].type = RED
@@ -191,7 +197,7 @@ class Game():
             return
         if self._dots[self._release].type != YELLOW:
             return
-        self._label.set_label('Now slowly tap on the yellow dot five times.')
+        self._label.set_label('Now gently tap on the yellow dot five times.')
         self._next = self._yellow_tap
         self._dots[self._release].set_shape(self._new_dot(self._colors[BLUE]))
         self._dots[self._release].type = BLUE
@@ -206,12 +212,12 @@ class Game():
         if self._count > 4:
             self._count = 0
             self._next = self._red_tap
-            self._label.set_label('Now slowly tap on the red dot five times.')
+            self._label.set_label('Now gently tap on the red dot five times.')
         else:
             self._label.set_label('Keep tapping.')
         i = self._targets[0]
         while i in self._targets:
-            i = int(uniform(0, TEN * SIX))
+            i = int(uniform(0, NINE * FIVE))
         self._targets.append(i)
         self._dots[i].set_shape(self._new_dot(self._colors[YELLOW]))
         self._dots[i].type = YELLOW
@@ -224,12 +230,12 @@ class Game():
         if self._count > 4:
             self._count = 0
             self._next = self._blue_tap
-            self._label.set_label('Now slowly tap on the blue dot five times.')
+            self._label.set_label('Now gently tap on the blue dot five times.')
         else:
             self._label.set_label('Keep tapping.')
         i = self._targets[0]
         while i in self._targets:
-            i = int(uniform(0, TEN * SIX))
+            i = int(uniform(0, NINE * FIVE))
         self._targets.append(i)
         self._dots[i].set_shape(self._new_dot(self._colors[RED]))
         self._dots[i].type = RED
@@ -249,7 +255,7 @@ class Game():
             self._label.set_label('Keep tapping.')
         i = self._targets[0]
         while i in self._targets:
-            i = int(uniform(0, TEN * SIX))
+            i = int(uniform(0, NINE * FIVE))
         self._targets.append(i)
         self._dots[i].set_shape(self._new_dot(self._colors[BLUE]))
         self._dots[i].type = BLUE
@@ -267,7 +273,7 @@ class Game():
     def _shake_it_more(self):
         self._label.set_label('Shake it harder!!')
         self._next = self._turn_left
-        self._shake = 'random'
+        self._shake = 'random2'
         self._pausing = True
         GObject.timeout_add(10000, self._clear_pause)
 
@@ -280,24 +286,57 @@ class Game():
 
     def _turn_right(self):
         self._label.set_label('Now turn it to the right.')
-        self._next = None
+        self._next = self._align
         self._shake = 'right'
         self._pausing = True
         GObject.timeout_add(10000, self._clear_pause)
 
+    def _align(self):
+        self._label.set_label('Shake it one more time.')
+        self._next = None
+        self._shake = 'align'
+        self._pausing = True
+        GObject.timeout_add(10000, self._clear_pause)
+
     def _set_label(self, string):
         ''' Set the label in the toolbar or the window frame. '''
         self._activity.status.set_label(string)
 
     def motion_cb(self, x, y, z):
+        jiggle_factor = 5
         if self._shake is None:
             return
-        elif self._shake == 'random':
+        elif self._shake in ['random', 'random2']:
+            if self._shake == 'random2':
+                jiggle_factor = 10
             for dot in self._dots:
                 if dot.type in [RED, YELLOW, BLUE]:
-                    r = int(uniform(-10, 10))
-                    dot.move_relative((x + r, z + r))
+                    x += int(uniform(-jiggle_factor, jiggle_factor))
+                    z += int(uniform(-jiggle_factor, jiggle_factor))
+                    # Randomize z drift, which tends toward up...
+                    if int(uniform(0, 2)) == 0:
+                        z = -z
+                    dot.move_relative((x, z))
+        elif self._shake == 'align':
+            docked = True
+            yellow = 0
+            red = 0
+            blue = 0
+            for dot in self._dots:
+                if dot.type == YELLOW:
+                    docked = self._dock_dot(dot, yellow + 1, 1, docked)
+                    yellow += 1
+                elif dot.type == RED:
+                    docked = self._dock_dot(dot, red + 2, 2, docked)
+                    red += 1
+                elif dot.type == BLUE:
+                    docked = self._dock_dot(dot, blue + 3, 3, docked)
+                    blue += 1
+            if docked and not self._timer is None:
+                GObject.source_remove(self._timer)
+                self._pausing = False
         elif self._shake == 'left':
+            right = False
             for dot in self._dots:
                 if dot.type in [RED, YELLOW, BLUE]:
                     pos = dot.get_xy()
@@ -316,7 +355,14 @@ class Game():
                             z = int(uniform(0, 20))
                         if pos[0] > -x:
                             dot.move_relative((x, z))
+                    pos = dot.get_xy()
+                    if pos[0] > 100:
+                        right = True
+            if not right and not self._timer is None:
+                GObject.source_remove(self._timer)
+                self._pausing = False
         elif self._shake == 'right':
+            left = False
             for dot in self._dots:
                 if dot.type in [RED, YELLOW, BLUE]:
                     pos = dot.get_xy()
@@ -335,6 +381,12 @@ class Game():
                             z = int(uniform(0, 20))
                         if pos[0] < self._width - x - self._dot_size:
                             dot.move_relative((x, z))
+                    pos = dot.get_xy()
+                    if pos[0] < self._width - self._dot_size - 100:
+                        left = True
+            if not left and not self._timer is None:
+                GObject.source_remove(self._timer)
+                self._pausing = False
         if self._pausing is not True:
             if self._next is not None:
                 GObject.timeout_add(500, self._next)
@@ -344,14 +396,33 @@ class Game():
         GObject.timeout_add(100, read_accelerometer, self)
         return
 
+    def _dock_dot(self, dot, n, m, docked):
+        x = (self._dot_size + self._space) * n
+        y = (self._dot_size + self._space) * m
+        pos = dot.get_xy()
+        dx = x - pos[0]
+        dy = y - pos[1]
+        if abs(dx) < 11 and abs(dy) < 11:
+            dot.move((x, y))
+            return docked
+        else:
+            if dx < 0:
+                dx = max(-10, dx)
+            elif dx > 0:
+                dx = min(10, dx)
+            if dy < 0:
+                dy = max(-10, dy)
+            elif dy > 0:
+                dy = min(10, dy)
+            dot.move_relative((dx, dy))
+            return False
+
     def _button_press_cb(self, win, event):
         if self._shake is not None:
             return True
         win.grab_focus()
         x, y = map(int, event.get_coords())
         self._press = True
-        if not self._timer is None:
-            GObject.source_remove(self._timer)
 
         spr = self._sprites.find_sprite((x, y))
         if spr == None:
@@ -368,8 +439,6 @@ class Game():
             return True
         self._press = False
         self._release = None
-        if not self._timer is None:
-            GObject.source_remove(self._timer)
 
         if self._pausing:
             self._label.set_label('Rub a little longer.')
@@ -394,11 +463,11 @@ class Game():
 
     def _grid_to_dot(self, pos):
         ''' calculate the dot index from a column and row in the grid '''
-        return pos[0] + pos[1] * TEN
+        return pos[0] + pos[1] * NINE
 
     def _dot_to_grid(self, dot):
         ''' calculate the grid column and row for a dot '''
-        return [dot % TEN, int(dot / TEN)]
+        return [dot % NINE, int(dot / NINE)]
 
     def _expose_cb(self, win, event):
         self.do_expose_event(event)