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         if self.nemesis_tile:
 207             self.remove_widget(self.nemesis_tile)
 208         self.nemesis.reset_pos()
 209         if self.level_obj:
 210             self.level_obj.load_tiles()
 211             self.player.pos = self.level_obj.enter_pos
 212             self.remove_widget(self.player_tile)
 213             self.view.scroll_x = 0
 214             self.view.scroll_y = 0
 215             self.build()
 216             self.draw_nemesis()
 217             self.draw_player()
 218             return True
 219         return False
 220
 221     def check_state(self):
 222         if self.level_obj.at_exit(self.player.pos):
 223             # Jump to next level
 224             self.level_obj = self.level_list.advance_to_next_level()
 225             if not self.reset_level():
 226                 self.app.game_over(True)
 227         elif self.check_caught():
 228             # Caught
 229             self.app.game_over(False)
 230
 231     def _calc_mouse_pos(self, pos):
 232         pos = self.to_local(*pos)
 233         return (int(pos[0] / TILE_SIZE), int(pos[1] / TILE_SIZE))
 234
 235     def on_touch_down(self, touch):
 236         pos = self._calc_mouse_pos(touch.pos)
 237         if pos == self.player.pos:
 238             self.mouse_move = True
 239             self.mouse_start = pos
 240
 241     def on_touch_up(self, touch):
 242         self.mouse_move = False
 243
 244     def on_touch_move(self, touch):
 245         if self.mouse_move:
 246             pos = self._calc_mouse_pos(touch.pos)
 247             if (pos[0] - self.mouse_start[0] != 0) or (
 248                     pos[1] - self.mouse_start[1] != 0):
 249                 direction = (pos[0] - self.mouse_start[0],
 250                         pos[1] - self.mouse_start[1])
 251                 self.do_move(direction)
 252                 self.mouse_start = pos
 253
 254
 255 class Screen(Widget):
 256
 257     BACKGROUND = None
 258     START = 'Start'
 259
 260     def __init__(self, app):
 261         super(Screen, self).__init__()
 262         self.image = load_image(self.BACKGROUND)
 263         self.app = app
 264         with self.canvas:
 265             Rectangle(pos=(0, 0), size=(1026, 760),
 266                     texture=self.image.texture)
 267
 268         self.stop_button = Label(
 269                 text='[ref=quit][color=ff0066]Quit[/color][/ref]',
 270                 font_size=30,
 271                 markup=True,
 272                 size=(200, 40),
 273                 pos=((1026 - 200) / 2 - 100, 100))
 274         self.stop_button.bind(on_ref_press=self.app.stop_app)
 275         self.start_button = Label(
 276                 text="[ref=start][color=00ff66]%s[/color][/ref]" % self.START,
 277                 font_size=30,
 278                 markup=True, size=(200, 40),
 279                 pos=((1026 - 200) / 2 + 100, 100))
 280         self.start_button.bind(on_ref_press=self.app.start_game)
 281         self.add_widget(self.stop_button)
 282         self.add_widget(self.start_button)
 283
 284
 285 class IntroScreen(Screen):
 286
 287     BACKGROUND = 'screens/intro_screen.png'
 288     START = 'Start the Game'
 289
 290
 291 class WonScreen(Screen):
 292
 293     BACKGROUND = 'screens/won.png'
 294     START = 'Play again?'
 295
 296
 297 class LostScreen(Screen):
 298
 299     BACKGROUND = 'screens/lost.png'
 300     START = 'Retry?'
 301
 302
 303 class GameApp(App):
 304
 305     title = "Peter's thread snake"
 306
 307     def __init__(self):
 308         self.levels = LevelList()
 309         super(GameApp, self).__init__()
 310
 311     def build(self):
 312         root = ScrollView(size_hint=(None, None))
 313         return root
 314
 315     def on_start(self):
 316         from kivy.base import EventLoop
 317         window = EventLoop.window
 318         if platform() == 'android':
 319             window.fullscreen = True
 320         self.root.size = window.size
 321         self.make_intro()
 322
 323     def make_intro(self):
 324         self.root.clear_widgets()
 325         screen = IntroScreen(self)
 326         self.root.add_widget(screen)
 327
 328     def stop_app(self, label, ref):
 329         self.stop()
 330
 331     def start_game(self, label, ref):
 332         """Start the game"""
 333         game = GameWindow(self.levels, self)
 334         game.build()
 335         self.root.clear_widgets()
 336         self.root.add_widget(game)
 337         # Ensure the player is visible
 338         self.root.scroll_x = 0
 339         self.root.scroll_y = 0
 340         game.draw_player()
 341         game.draw_nemesis()
 342
 343     def game_over(self, won):
 344         if won:
 345             screen = WonScreen(self)
 346             self.levels.reset()
 347         else:
 348             screen = LostScreen(self)
 349         self.root.clear_widgets()
 350         self.root.add_widget(screen)
 351
 352
 353 def main():
 354     """ Erdslangetjie, a maze game of eluding nemesis
 355     """
 356     GameApp().run()