erdslangetjie/__main__.py

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