Cleanup more state - hopefully fix some stale game running bugs

[erdslangetjie.git] / erdslangetjie / __main__.py

diff --git a/erdslangetjie/__main__.py b/erdslangetjie/__main__.py
index 74a0c33a2509ac939988175ea4de3624d6a033f2..935d212b98ccb6b246859c91b24efee773d63122 100644 (file)
--- a/erdslangetjie/__main__.py
+++ b/erdslangetjie/__main__.py
@@ -49,6 +49,7 @@ class GameWindow(RelativeLayout):
         self.player_tile = None
         self.nemesis_tile = None
         self.timer_set = False
+        self.move_counter = 0
 
         self.player.pos = self.level_obj.enter_pos
         if platform() != 'android':
@@ -67,18 +68,22 @@ class GameWindow(RelativeLayout):
         for tile_line in tiles:
             bx = 0
             for tile in tile_line:
-                node = Widget(size=(TILE_SIZE, TILE_SIZE),
-                        pos=(bx, by),
-                        size_hint=(None, None))
-                self.add_widget(node)
-                with node.canvas:
-                    Color(1, 1, 1)
-                    Rectangle(pos=node.pos, size=node.size,
-                            texture=tile.texture)
-                self.tiles[(bx, by)] = node
+                self.draw_tile((bx, by), tile)
                 bx += TILE_SIZE
             by += TILE_SIZE
 
+    def draw_tile(self, pos, tile):
+        if pos in self.tiles:
+            self.remove_widget(self.tiles[pos])
+        node = Widget(size=(TILE_SIZE, TILE_SIZE),
+                pos=pos, size_hint=(None, None))
+        self.add_widget(node)
+        with node.canvas:
+            Color(1, 1, 1)
+            Rectangle(pos=node.pos, size=node.size,
+                    texture=tile.texture)
+        self.tiles[pos] = node
+
     def draw_player(self):
         if self.player_tile:
             self.remove_widget(self.player_tile)
@@ -118,20 +123,15 @@ class GameWindow(RelativeLayout):
                 if true_point[0] >= self.view.size[0]:
                     self.view.scroll_x += self.x_scroll_margin
                     true_point = self.to_parent(*check_point)
-                    #print '-x', self.view.scroll_x, self.view.scroll_y
                 elif true_point[0] < 0:
                     self.view.scroll_x -= self.x_scroll_margin
                     true_point = self.to_parent(*check_point)
-                    #print '+x', self.view.scroll_x, self.view.scroll_y
                 elif true_point[1] >= self.view.size[1]:
                     self.view.scroll_y += self.y_scroll_margin
                     true_point = self.to_parent(*check_point)
-                    #print '+y', self.view.scroll_x, self.view.scroll_y
                 elif true_point[1] < 0:
                     self.view.scroll_y -= self.y_scroll_margin
                     true_point = self.to_parent(*check_point)
-                    #print '-y', self.view.scroll_x, self.view.scroll_y
-                #print true_point, self.view.size
 
     def included(self, point, margin):
         if point[0] < margin:
@@ -179,24 +179,35 @@ class GameWindow(RelativeLayout):
     def do_move(self, direction):
         if not self.level_obj:
             return
-        self.player.move(direction, self.level_obj)
-        self.draw_player()
+        # Do nothing on null moves
+        if not self.player.move(direction, self.level_obj):
+            return
         self.check_state()
-        if not self.timer_set:
-            self.reset_timer()
+        self.do_nemesis_move()
+
+    def do_nemesis_move(self):
+        self.nemesis.move(self.level_obj, self.player.pos)
+        self.check_state()
+        if self.move_counter > 4:
+            self.move_counter = 0
+            self.draw_nemesis()
+            self.nemesis.move(self.level_obj, self.player.pos)
+            self.check_state()
+        else:
+            self.move_counter += 1
+        self.draw_nemesis()
+        self.draw_player()
+        self.reset_timer()
 
     def timed_move(self, event):
         if not self.level_obj:
             return
-        self.nemesis.move(self.level_obj, self.check_caught)
-        self.draw_nemesis()
-        self.check_state()
-        self.reset_timer()
+        self.do_nemesis_move()
 
     def reset_timer(self):
         self.timer_set = True
         Clock.unschedule(self.timed_move)
-        Clock.schedule_once(self.timed_move, 0.5)
+        Clock.schedule_once(self.timed_move, 3)
 
     def check_caught(self):
         return self.nemesis.pos == self.player.pos
@@ -204,9 +215,12 @@ class GameWindow(RelativeLayout):
     def reset_level(self):
         Clock.unschedule(self.timed_move)
         self.timer_set = False
+        self.move_counter = 0
         if self.nemesis_tile:
             self.remove_widget(self.nemesis_tile)
         self.nemesis.reset_pos()
+
+    def load_level(self):
         if self.level_obj:
             self.level_obj.load_tiles()
             self.player.pos = self.level_obj.enter_pos
@@ -220,14 +234,33 @@ class GameWindow(RelativeLayout):
         return False
 
     def check_state(self):
+        if not self.level_obj:
+            return
         if self.level_obj.at_exit(self.player.pos):
+            self.reset_level()
             # Jump to next level
             self.level_obj = self.level_list.advance_to_next_level()
-            if not self.reset_level():
-                self.app.game_over(True)
+            if not self.load_level():
+                app = self.app
+                self.app = None
+                self._closed()
+                app.game_over(True)
+            return
         elif self.check_caught():
             # Caught
-            self.app.game_over(False)
+            self.reset_level()
+            app = self.app
+            self.app = None
+            self._closed()
+            app.game_over(False)
+            return
+        elif self.level_obj.is_button(self.player.pos):
+            self.level_obj.trigger_button(self.player.pos)
+        elif self.level_obj.is_button(self.nemesis.pos):
+            self.level_obj.trigger_button(self.nemesis.pos)
+        for map_pos, new_tile in self.level_obj.get_changed_tiles():
+            pos = (map_pos[0] * TILE_SIZE, map_pos[1] * TILE_SIZE)
+            self.draw_tile(pos, new_tile)
 
     def _calc_mouse_pos(self, pos):
         pos = self.to_local(*pos)
@@ -308,6 +341,7 @@ class GameApp(App):
     def __init__(self):
         super(GameApp, self).__init__()
         self.levels = LevelList()
+        self.game = None
 
     def build(self):
         root = ScrollView(size_hint=(None, None))
@@ -337,15 +371,15 @@ class GameApp(App):
 
     def start_game(self, label, ref):
         """Start the game"""
-        game = GameWindow(self.levels, self)
-        game.build()
+        self.game = GameWindow(self.levels, self)
+        self.game.build()
         self.root.clear_widgets()
-        self.root.add_widget(game)
+        self.root.add_widget(self.game)
         # Ensure the player is visible
         self.root.scroll_x = 0
         self.root.scroll_y = 0
-        game.draw_player()
-        game.draw_nemesis()
+        self.game.draw_player()
+        self.game.draw_nemesis()
 
     def game_over(self, won):
         if won:
@@ -353,6 +387,8 @@ class GameApp(App):
             self.levels.reset()
         else:
             screen = LostScreen(self)
+        del self.game
+        self.game = None
         self.root.clear_widgets()
         self.root.add_widget(screen)