robot reveals cards at end of game

1 files changed, 64 insertions, 62 deletions

diff --git a/PathsActivity.py b/PathsActivity.py
index 649b43a..21ba867 100644
--- a/PathsActivity.py
+++ b/PathsActivity.py
@@ -68,20 +68,20 @@ def _label_factory(label, toolbar):
     my_label = gtk.Label(label)
     my_label.set_line_wrap(True)
     my_label.show()
-    _toolitem = gtk.ToolItem()
-    _toolitem.add(my_label)
-    toolbar.insert(_toolitem, -1)
-    _toolitem.show()
+    toolitem = gtk.ToolItem()
+    toolitem.add(my_label)
+    toolbar.insert(toolitem, -1)
+    toolitem.show()
     return my_label
 
 
 def _separator_factory(toolbar, visible=True, expand=False):
     """ Factory for adding a separator to a toolbar """
-    _separator = gtk.SeparatorToolItem()
-    _separator.props.draw = visible
-    _separator.set_expand(expand)
-    toolbar.insert(_separator, -1)
-    _separator.show()
+    separator = gtk.SeparatorToolItem()
+    separator.props.draw = visible
+    separator.set_expand(expand)
+    toolbar.insert(separator, -1)
+    separator.show()
 
 
 class PathsActivity(activity.Activity):
@@ -101,13 +101,13 @@ class PathsActivity(activity.Activity):
         canvas.show()
         self.show_all()
 
-        self.game = Game(canvas, self)
+        self._game = Game(canvas, self)
 
         # Restore game state from Journal or start new game
         if 'deck0' in self.metadata:
             self._restore()
         else:
-            self.game.new_game()
+            self._game.new_game()
 
     def _setup_toolbars(self, have_toolbox):
         """ Setup the toolbars.. """
@@ -135,13 +135,13 @@ class PathsActivity(activity.Activity):
             toolbox.set_current_toolbar(1)
             toolbar = games_toolbar
 
-        self.new_game_button = _button_factory('new-game',
-                                               _('Start a new game.'),
-                                               self.new_game_cb, toolbar)
+        self._new_game_button = _button_factory('new-game',
+                                                _('Start a new game.'),
+                                                self._new_game_cb, toolbar)
 
-        self.robot_button = _button_factory('robot-off',
-                                            _('Play with the computer.'),
-                                            self.robot_cb, toolbar)
+        self._robot_button = _button_factory('robot-off',
+                                             _('Play with the computer.'),
+                                             self._robot_cb, toolbar)
 
         self.status = _label_factory('play on', toolbar)
 
@@ -153,22 +153,24 @@ class PathsActivity(activity.Activity):
             toolbox.toolbar.insert(stop_button, -1)
             stop_button.show()
 
-    def new_game_cb(self, button=None):
+    def _new_game_cb(self, button=None):
         ''' Start a new game. '''
-        self.game.new_game()
+        self._game.new_game()
 
-    def robot_cb(self, button=None):
+    def _robot_cb(self, button=None):
         ''' Play with the computer (or not). '''
-        if not self.game.playing_with_robot:
-             self.game.playing_with_robot = True
-             self.game.grid.set_robot_status(True)
-             self.robot_button.set_icon('robot-on')
-             self.game.new_game()
+        if not self._game.playing_with_robot:
+            self.set_robot_status(True, 'robot-on')
+            self._game.new_game()
         else:
-             self.game.playing_with_robot = False
-             self.game.grid.set_robot_status(False)
-             self.robot_button.set_icon('robot-off')
-             self.game.new_game()
+            self.set_robot_status(False, 'robot-off')
+            self._game.new_game()
+
+    def set_robot_status(self, status, icon):
+        ''' Reset robot icon and status '''
+        self._game.playing_with_robot = status
+        self._game.grid.set_robot_status(status)
+        self._robot_button.set_icon(icon)
 
     def write_file(self, file_path):
         """ Write the grid status to the Journal """
@@ -176,79 +178,79 @@ class PathsActivity(activity.Activity):
             return
         for i in range(64):
             self.metadata['deck' + str(i)] = \
-                str(self.game.deck.cards[i].number)
+                str(self._game.deck.cards[i].number)
         for i in range(64):
-            if self.game.grid.grid[i] is not None:
+            if self._game.grid.grid[i] is not None:
                 self.metadata['grid' + str(i)] = \
-                    str(self.game.grid.grid[i].number)
+                    str(self._game.grid.grid[i].number)
                 self.metadata['rotate' + str(i)] = \
-                    str(self.game.grid.grid[i].orientation)
+                    str(self._game.grid.grid[i].orientation)
             else:
                 self.metadata['grid' + str(i)] = 'None'
         for i in range(8):
-            if self.game.grid.hand[i] is not None:
+            if self._game.grid.hand[i] is not None:
                 self.metadata['hand' + str(i)] = \
-                    str(self.game.grid.hand[i].number)
+                    str(self._game.grid.hand[i].number)
             else:
                 self.metadata['hand' + str(i)] = 'None'
-        if self.game.last_spr_moved is not None and \
-           self.game.grid.spr_to_grid(self.game.last_spr_moved) is not None:
-            self.metadata['last'] = str(self.game.grid.grid[
-                self.game.grid.spr_to_grid(self.game.last_spr_moved)].number)
+        if self._game.last_spr_moved is not None and \
+           self._game.grid.spr_to_grid(self._game.last_spr_moved) is not None:
+            self.metadata['last'] = str(self._game.grid.grid[
+                self._game.grid.spr_to_grid(self._game.last_spr_moved)].number)
 
     def _restore(self):
         """ Restore the game state from metadata """
         deck = []
         for i in range(64):
             if 'deck' + str(i) in self.metadata:
-                deck.append(self.game.deck.cards[
+                deck.append(self._game.deck.cards[
                         int(self.metadata['deck' + str(i)])])
         if len(deck) == 64:  # We've retrieved an entire deck
-            self.game.deck.cards = deck[:]
+            self._game.deck.cards = deck[:]
 
         for i in range(64):
             if 'grid' + str(i) in self.metadata:
                 if self.metadata['grid' + str(i)] == 'None':
-                    self.game.grid.grid[i] = None
+                    self._game.grid.grid[i] = None
                 else:
                     j = int(self.metadata['grid' + str(i)])
                     for k in range(64):
-                        if self.game.deck.cards[k].number == j:
-                            self.game.grid.grid[i] = self.game.deck.cards[k]
-                    self.game.grid.grid[i].spr.move(
-                        self.game.grid.grid_to_xy(i))
-                    self.game.grid.grid[i].spr.set_layer(CARDS)
+                        if self._game.deck.cards[k].number == j:
+                            self._game.grid.grid[i] = self._game.deck.cards[k]
+                    self._game.grid.grid[i].spr.move(
+                        self._game.grid.grid_to_xy(i))
+                    self._game.grid.grid[i].spr.set_layer(CARDS)
                     if 'rotate' + str(i) in self.metadata:
                         o = int(self.metadata['rotate' + str(i)])
                         while o > 0:
-                            self.game.grid.grid[i].rotate_clockwise()
+                            self._game.grid.grid[i].rotate_clockwise()
                             o -= 90
             else:
-                self.game.grid.grid[i] = None
-        self.game.show_connected_tiles()
+                self._game.grid.grid[i] = None
+        self._game.show_connected_tiles()
 
         for i in range(8):
             if 'hand' + str(i) in self.metadata:
                 if self.metadata['hand' + str(i)] == 'None':
-                    self.game.grid.hand[i] = None
+                    self._game.grid.hand[i] = None
                 else:
                     j = int(self.metadata['hand' + str(i)])
                     for k in range(64):
-                        if self.game.deck.cards[k].number == j:
-                            self.game.grid.hand[i] = self.game.deck.cards[k]
-                    self.game.grid.hand[i].spr.move(
-                        self.game.grid.hand_to_xy(i))
-                    self.game.grid.hand[i].spr.set_layer(CARDS)
+                        if self._game.deck.cards[k].number == j:
+                            self._game.grid.hand[i] = self._game.deck.cards[k]
+                    self._game.grid.hand[i].spr.move(
+                        self._game.grid.hand_to_xy(i))
+                    self._game.grid.hand[i].spr.set_layer(CARDS)
             else:
-                self.game.grid.hand[i] = None
+                self._game.grid.hand[i] = None
 
-        self.game.deck.index = 64 - self.game.grid.grid.count(None) + \
-                                8 - self.game.grid.hand.count(None)
+        self._game.deck.index = 64 - self._game.grid.grid.count(None) + \
+                                8 - self._game.grid.hand.count(None)
 
-        self.game.last_spr_moved = None
+        self._game.last_spr_moved = None
         if 'last' in self.metadata:
             j = int(self.metadata['last'])
             for k in range(64):
-                if self.game.deck.cards[k].number == j:
-                    self.game.last_spr_moved = self.game.deck.cards[k].spr
+                if self._game.deck.cards[k].number == j:
+                    self._game.last_spr_moved = self._game.deck.cards[k].spr
                     return