erdslangetjie/__main__.py

   1 import pygame
   2
   3 from erdslangetjie.constants import TILE_SIZE
   4
   5 from kivy.app import App
   6 from kivy.uix.widget import Widget
   7 from kivy.uix.relativelayout import RelativeLayout
   8 from kivy.uix.scrollview import ScrollView
   9 from kivy.uix.label import Label
  10 from kivy.graphics import Color, Rectangle
  11 from kivy.utils import platform
  12
  13 from erdslangetjie.level import LevelList
  14 from erdslangetjie.data import load_image
  15 from erdslangetjie.player import ThePlayer, Nemesis
  16
  17
  18 class GameWindow(RelativeLayout):
  19
  20     def __init__(self, level_list, app):
  21         self.level_list = level_list
  22         self.level_obj = self.level_list.get_current_level()
  23         self.level_obj.load_tiles()
  24         self.tiles = {}
  25         self.view = app.root
  26         self.app = app
  27
  28         cols, rows = self.level_obj.get_size()
  29
  30         super(GameWindow, self).__init__(
  31                 size=(cols * TILE_SIZE, rows * TILE_SIZE),
  32                 size_hint=(None, None))
  33
  34         self.x_scroll_margin = float(TILE_SIZE) / self.view.size[0]
  35         self.y_scroll_margin = float(TILE_SIZE) / self.view.size[1]
  36
  37         self.mouse_move = False
  38
  39         self.player = ThePlayer()
  40         self.nemesis = Nemesis()
  41         if not self.level_obj.enter_pos:
  42             raise RuntimeError('No entry point')
  43         self.player_tile = None
  44         self.nemesis_tile = None
  45
  46         self.player.pos = self.level_obj.enter_pos
  47         if platform() != 'android':
  48             # Very hack'ish
  49             # We need to delay this import until after the window creation by
  50             # the app, else our size config doesn't work
  51             from kivy.core.window import Window
  52             self.keyboard = Window.request_keyboard(self._closed, self)
  53             self.keyboard.bind(on_key_down=self._on_key_down)
  54
  55     def build(self):
  56         self.clear_widgets()
  57         self.tiles = {}
  58         tiles = self.level_obj.get_tiles()
  59         bx, by = 0, 0
  60         for tile_line in tiles:
  61             bx = 0
  62             for tile in tile_line:
  63                 node = Widget(size=(TILE_SIZE, TILE_SIZE),
  64                         pos=(bx, by),
  65                         size_hint=(None, None))
  66                 self.add_widget(node)
  67                 with node.canvas:
  68                     Color(1, 1, 1)
  69                     Rectangle(pos=node.pos, size=node.size,
  70                             texture=tile.texture)
  71                 self.tiles[(bx, by)] = node
  72                 bx += TILE_SIZE
  73             by += TILE_SIZE
  74
  75     def draw_player(self):
  76         if self.player_tile:
  77             self.remove_widget(self.player_tile)
  78         sprite_pos = (self.player.pos[0] * TILE_SIZE,
  79                 self.player.pos[1] * TILE_SIZE)
  80         self.player_tile = Widget(size=(TILE_SIZE, TILE_SIZE),
  81                 pos=sprite_pos)
  82         with self.player_tile.canvas:
  83             Color(1, 1, 1)
  84             Rectangle(pos=sprite_pos, size=self.player_tile.size,
  85                     texture=self.player.get_texture())
  86         self.add_widget(self.player_tile)
  87         for offset in [(TILE_SIZE - 1, TILE_SIZE - 1),
  88                 (-TILE_SIZE + 1, TILE_SIZE - 1),
  89                 (TILE_SIZE - 1, -TILE_SIZE + 1),
  90                 (-TILE_SIZE + 1, -TILE_SIZE + 1),
  91                 (0, 2 * TILE_SIZE - 2),
  92                 (-2 * TILE_SIZE + 2, 0),
  93                 (2 * TILE_SIZE - 2, 0),
  94                 (0, -2 * TILE_SIZE + 2),
  95                 (0, 0)]:
  96             # Aim is to ensure a 'neighbourhood' around the player
  97             # is visible if possible
  98             check_point = (sprite_pos[0] + offset[0] + TILE_SIZE / 2,
  99                     sprite_pos[1] + offset[1] + TILE_SIZE / 2)
 100             true_point = self.to_parent(*check_point)
 101             if check_point[0] < 0:
 102                 continue
 103             if check_point[1] < 0:
 104                 continue
 105             if check_point[0] >= self.size[0]:
 106                 continue
 107             if check_point[1] >= self.size[1]:
 108                 continue
 109             while not self.included(true_point, 0):
 110                 # Scroll ourselves
 111                 if true_point[0] >= self.view.size[0]:
 112                     self.view.scroll_x += self.x_scroll_margin
 113                     true_point = self.to_parent(*check_point)
 114                     #print '-x', self.view.scroll_x, self.view.scroll_y
 115                 elif true_point[0] < 0:
 116                     self.view.scroll_x -= self.x_scroll_margin
 117                     true_point = self.to_parent(*check_point)
 118                     #print '+x', self.view.scroll_x, self.view.scroll_y
 119                 elif true_point[1] >= self.view.size[1]:
 120                     self.view.scroll_y += self.y_scroll_margin
 121                     true_point = self.to_parent(*check_point)
 122                     #print '+y', self.view.scroll_x, self.view.scroll_y
 123                 elif true_point[1] < 0:
 124                     self.view.scroll_y -= self.y_scroll_margin
 125                     true_point = self.to_parent(*check_point)
 126                     #print '-y', self.view.scroll_x, self.view.scroll_y
 127                 #print true_point, self.view.size
 128
 129     def included(self, point, margin):
 130         if point[0] < margin:
 131             return False
 132         if point[0] >= self.view.size[0] - margin:
 133             return False
 134         if point[1] < margin:
 135             return False
 136         if point[1] >= self.view.size[1] - margin:
 137             return False
 138         return True
 139
 140     def draw_nemesis(self):
 141         if not self.nemesis.on_board():
 142             return
 143         if self.nemesis_tile:
 144             self.remove_widget(self.nemesis_tile)
 145         sprite_pos = (self.nemesis.pos[0] * TILE_SIZE,
 146                 self.nemesis.pos[1] * TILE_SIZE)
 147         self.nemesis_tile = Widget(size=(TILE_SIZE, TILE_SIZE),
 148                 pos=sprite_pos)
 149         with self.nemesis_tile.canvas:
 150             Color(1, 1, 1)
 151             Rectangle(pos=sprite_pos, size=self.nemesis_tile.size,
 152                     texture=self.nemesis.get_texture())
 153         self.add_widget(self.nemesis_tile)
 154
 155     def _closed(self):
 156         self.keyboard.unbind(on_key_down=self._on_key_down)
 157
 158     def _on_key_down(self, keyboard, keycode, text, modifiers):
 159         # FIXME - likely portablity issues
 160         direction = None
 161         if keycode[0] == pygame.K_UP:
 162             direction = (0, 1)
 163         elif keycode[0] == pygame.K_DOWN:
 164             direction = (0, -1)
 165         elif keycode[0] == pygame.K_LEFT:
 166             direction = (-1, 0)
 167         elif keycode[0] == pygame.K_RIGHT:
 168             direction = (1, 0)
 169         if direction:
 170             self.do_move(direction)
 171
 172     def do_move(self, direction):
 173         if not self.level_obj:
 174             return
 175         self.nemesis.move(self.level_obj)
 176         self.draw_nemesis()
 177         self.player.move(direction, self.level_obj)
 178         self.draw_player()
 179         self.check_state()
 180         self.reset_timer()
 181
 182     def timed_move(self):
 183         if not self.level_obj:
 184             return
 185         self.nemesis.move(self.level_obj)
 186         self.draw_nemesis()
 187         self.check_state()
 188         self.reset_timer()
 189
 190     def reset_timer(self):
 191         pass
 192
 193     def check_state(self):
 194         if self.level_obj.at_exit(self.player.pos):
 195             # Jump to next level
 196             self.level_obj = self.level_list.advance_to_next_level()
 197             self.remove_widget(self.nemesis_tile)
 198             self.nemesis.reset_pos()
 199             if self.level_obj:
 200                 self.level_obj.load_tiles()
 201                 self.player.pos = self.level_obj.enter_pos
 202                 self.remove_widget(self.player_tile)
 203                 self.view.scroll_x = 0
 204                 self.view.scroll_y = 0
 205                 self.build()
 206                 self.draw_nemesis()
 207                 self.draw_player()
 208             else:
 209                 self.app.game_over(True)
 210         elif self.nemesis.pos == self.player.pos:
 211             # Caught
 212             self.app.game_over(False)
 213
 214     def _calc_mouse_pos(self, pos):
 215         pos = self.to_local(*pos)
 216         return (int(pos[0] / TILE_SIZE), int(pos[1] / TILE_SIZE))
 217
 218     def on_touch_down(self, touch):
 219         pos = self._calc_mouse_pos(touch.pos)
 220         if pos == self.player.pos:
 221             self.mouse_move = True
 222             self.mouse_start = pos
 223
 224     def on_touch_up(self, touch):
 225         self.mouse_move = False
 226
 227     def on_touch_move(self, touch):
 228         if self.mouse_move:
 229             pos = self._calc_mouse_pos(touch.pos)
 230             if (pos[0] - self.mouse_start[0] != 0) or (
 231                     pos[1] - self.mouse_start[1] != 0):
 232                 direction = (pos[0] - self.mouse_start[0],
 233                         pos[1] - self.mouse_start[1])
 234                 self.do_move(direction)
 235                 self.mouse_start = pos
 236
 237
 238 class Screen(Widget):
 239
 240     BACKGROUND = None
 241     START = 'Start'
 242
 243     def __init__(self, app):
 244         super(Screen, self).__init__()
 245         self.image = load_image(self.BACKGROUND)
 246         self.app = app
 247         with self.canvas:
 248             Rectangle(pos=(0, 0), size=(1026, 760),
 249                     texture=self.image.texture)
 250
 251         self.stop_button = Label(
 252                 text='[ref=quit][color=ff0066]Quit[/color][/ref]',
 253                 font_size=30,
 254                 markup=True,
 255                 size=(200, 40),
 256                 pos=((1026 - 200) / 2 - 100, 100))
 257         self.stop_button.bind(on_ref_press=self.app.stop_app)
 258         self.start_button = Label(
 259                 text="[ref=start][color=00ff66]" + self.START + "[/color][/ref]",
 260                 font_size=30,
 261                 markup = True, size=(200, 40),
 262                 pos=((1026 - 200) / 2 + 100, 100))
 263         self.start_button.bind(on_ref_press=self.app.start_game)
 264         self.add_widget(self.stop_button)
 265         self.add_widget(self.start_button)
 266
 267
 268 class IntroScreen(Screen):
 269
 270     BACKGROUND = 'screens/intro_screen.png'
 271     START = 'Start the Game'
 272
 273
 274 class WonScreen(Screen):
 275
 276     BACKGROUND = 'screens/won.png'
 277     START = 'Play again?'
 278
 279
 280 class LostScreen(Screen):
 281
 282     BACKGROUND = 'screens/lost.png'
 283     START = 'Retry?'
 284
 285
 286 class GameApp(App):
 287
 288     title = "Peter's thread snake"
 289
 290     def __init__(self):
 291         self.levels = LevelList()
 292         super(GameApp, self).__init__()
 293
 294     def build(self):
 295         root = ScrollView(size_hint=(None, None))
 296         return root
 297
 298     def on_start(self):
 299         from kivy.base import EventLoop
 300         window = EventLoop.window
 301         if platform() == 'android':
 302             window.fullscreen = True
 303         self.root.size = window.size
 304         self.make_intro()
 305
 306     def make_intro(self):
 307         self.root.clear_widgets()
 308         screen = IntroScreen(self)
 309         self.root.add_widget(screen)
 310
 311     def stop_app(self, label, ref):
 312         self.stop()
 313
 314     def start_game(self, label, ref):
 315         """Start the game"""
 316         game = GameWindow(self.levels, self)
 317         game.build()
 318         self.root.clear_widgets()
 319         self.root.add_widget(game)
 320         # Ensure the player is visible
 321         self.root.scroll_x = 0
 322         self.root.scroll_y = 0
 323         game.draw_player()
 324         game.draw_nemesis()
 325
 326     def game_over(self, won):
 327         if won:
 328             screen = WonScreen(self)
 329             self.levels.reset()
 330         else:
 331             screen = LostScreen(self)
 332         self.root.clear_widgets()
 333         self.root.add_widget(screen)
 334
 335
 336 def main():
 337     """ Erdslangetjie, a maze game of eluding nemesis
 338     """
 339     GameApp().run()