Use accelerometer

This change implement the following funtionality:
* Detect when the xo is in ebook mode, and use the accelerometer
if available. Detect the sensr the ebook switch in XO-4 only.
* The player advance only one step by accelerator lecture,
and only in the direction selected by the user. Is different to
the mode by default, where walk until the first fork in the maze.

2 files changed, 60 insertions, 2 deletions

diff --git a/game.py b/game.py
index 7acf5d9..359c971 100644
--- a/game.py
+++ b/game.py
@@ -39,6 +39,7 @@ presenceService = presenceservice.get_instance()
 
 from maze import Maze, Rectangle
 from player import Player
+import sensors
 
 
 class MazeGame(Gtk.DrawingArea):
@@ -126,6 +127,14 @@ class MazeGame(Gtk.DrawingArea):
             Gdk.EventMask.TOUCH_MASK)
         self.set_can_focus(True)
         self.grab_focus()
+        self._ebook_mode_detector = sensors.EbookModeDetector()
+        self._accelerometer = sensors.Accelerometer()
+        self._read_accelerator_id = None
+        if self._ebook_mode_detector.get_ebook_mode():
+            self._read_accelerator_id = GObject.timeout_add(
+                200, self._read_accelerometer)
+        self._ebook_mode_detector.connect('changed',
+                                          self._ebook_mode_changed_cb)
 
     def __configure_cb(self, event):
         ''' Screen size has changed '''
@@ -293,6 +302,54 @@ class MazeGame(Gtk.DrawingArea):
         """Mark a single point that needs to be redrawn."""
         self.dirtyPoints.append(pt)
 
+    def _ebook_mode_changed_cb(self, detector, ebook_mode):
+        if ebook_mode:
+            if self._read_accelerator_id is None:
+                self._read_accelerator_id = GObject.timeout_add(
+                    200, self._read_accelerometer)
+        else:
+            self._read_accelerator_id = None
+
+    def _read_accelerometer(self):
+        x, y, z = self._accelerometer.read_position()
+        logging.error('read_acceleromter %s', (x, y, z))
+        TRIGGER = 150
+        if abs(x) < TRIGGER:
+            x = 0
+        if abs(y) < TRIGGER:
+            y = 0
+
+        player = self.localplayers[0]
+        player.hidden = False
+        if x > 0:
+            # RIGHT
+            player.direction = (1, 0)
+        if x < 0:
+            # LEFT
+            player.direction = (-1, 0)
+        if y < 0:
+            # UP
+            player.direction = (0, -1)
+        if y > 0:
+            # DOWN
+            player.direction = (0, 1)
+        if x == 0 and y == 0:
+            player.direction = (0, 0)
+
+        oldposition = player.position
+        newposition = player.animate(self.maze, False)
+        if oldposition != newposition:
+            self.markPointDirty(oldposition)
+            self.markPointDirty(newposition)
+            if player in self.localplayers:
+                self.maze.map[player.previous[0]][player.previous[1]] = \
+                    self.maze.SEEN
+                if self.maze.map[newposition[0]][newposition[1]] == \
+                        self.maze.GOAL:
+                    self.finish(player)
+            self.queue_draw()
+        return self._read_accelerator_id is not None
+
     def __event_cb(self, widget, event):
 
         if event.type in (Gdk.EventType.TOUCH_BEGIN,
diff --git a/player.py b/player.py
index 39b8f53..82026d0 100644
--- a/player.py
+++ b/player.py
@@ -81,7 +81,7 @@ class Player:
         self.previous = (1, 1)
         self.elapsed = None
 
-    def animate(self, maze):
+    def animate(self, maze, change_direction=True):
         # if the player finished the maze, then don't move
         if maze.map[self.position[0]][self.position[1]] == maze.GOAL:
             self.direction = (0, 0)
@@ -89,7 +89,8 @@ class Player:
             return self.position
         if self.canGo(self.direction, maze):
             self.move(self.direction, maze)
-            self.keepGoing(self.direction, maze)
+            if change_direction:
+                self.keepGoing(self.direction, maze)
         else:
             self.direction = (0, 0)
         return self.position