X-Git-Url: https://git.ctpug.org.za/?a=blobdiff_plain;f=koperkapel%2Fscenes%2Flevel.py;h=ebd87e120d3575ff795df1caa253fadab796ff5d;hb=029b435e6e3a79f122122c47c41bd773149e6480;hp=71373c06a08a80c86f1d9368074d94ba53f9a6f9;hpb=bc78ad7ce0a69ad00b10cf29a86d7596c1f90139;p=koperkapel.git diff --git a/koperkapel/scenes/level.py b/koperkapel/scenes/level.py index 71373c0..ebd87e1 100644 --- a/koperkapel/scenes/level.py +++ b/koperkapel/scenes/level.py @@ -1,32 +1,168 @@ """Render a level""" from pgzero.constants import keys +from pygame import Surface +import pygame.locals as pgl from ..loaders.levelloader import levels -from .base import Scene, ChangeSceneEvent +from .base import Scene, ChangeSceneEvent, MoveViewportEvent from ..constants import TILE_SIZE, WIDTH, HEIGHT +from ..vehicles.base import Vehicle -class LevelScene(Scene): +class BaseLevelScene(Scene): """ Level scene. """ - def __init__(self, level_name): - self._level_data = levels.load(level_name) - self._tiles = self._level_data['tiles'] + def enter(self, world): + self._level = levels.load(world.level.name) + self._tiles = self._level.tiles + self._level_layer = 'floor' + self._surfaces = {} + self._overlay = {} + for layer in ['floor', 'tunnels']: + self._surfaces[layer] = self._render(layer) + self._overlay = self._surfaces['floor'].copy() + self._doors = self.actors.add_layer("doors", level=9) + self._keypads = self.actors.add_layer("keypads", level=8) + # These are already Actors + for door in self._level.doors: + self._doors.add(door) + for keypad in self._level.keypads: + self._keypads.add(keypad) - def draw(self, screen, viewport=(0, 0)): - screen.clear() + def _render(self, layer): + # We cache the rendered surface to avoid doing a large number + # of blits each frame, as that introduces a large performance + # overhead. + surface = Surface((len(self._tiles[0]) * TILE_SIZE, + len(self._tiles) * TILE_SIZE)) + layer_key = '%s image' % layer for y, row in enumerate(self._tiles): for x, tile in enumerate(row): - pos = (x * TILE_SIZE - viewport[0], - y * TILE_SIZE - viewport[1]) - if 'image' not in tile: + pos = (x * TILE_SIZE, y * TILE_SIZE) + if layer_key not in tile: # Skip broken tiles for now continue - if 0 <= pos[0] < WIDTH: - if 0 <= pos[1] < HEIGHT: - screen.blit(tile['image'], pos) + surface.blit(tile[layer_key], pos) + return surface.convert_alpha() + + def update(self, world, engine, dt): + """Fix the door and keypad positions""" + for door in self._doors: + door.pos = engine.calc_offset(door.game_pos[0] * TILE_SIZE, door.game_pos[1] * TILE_SIZE) + for keypad in self._keypads: + keypad.pos = engine.calc_offset(keypad.game_pos[0] * TILE_SIZE, keypad.game_pos[1] * TILE_SIZE) + + def draw(self, screen, viewport): + screen.clear() + # Viewport is the position of the screen relative to the + # surface. We need the position of the surface relative to + # the screen for the blit, so this conversion + screen.surface.blit(self._surfaces[self._level_layer], (0, 0), + area=(viewport[0], viewport[1], WIDTH, HEIGHT)) + if self._level_layer != 'floor': + screen.surface.blit(self._overlay, (0, 0), + area=(viewport[0], viewport[1], WIDTH, HEIGHT), + special_flags=pgl.BLEND_MULT) + self.actors.draw(screen) def on_key_down(self, key, mod, unicode): if key == keys.ESCAPE: from .menu import MenuScene return [ChangeSceneEvent(MenuScene())] + + +class GameLevelScene(BaseLevelScene): + + def enter(self, world): + super().enter(world) + self._roaches = self.actors.add_layer("roaches", level=10) + self._vehicle = Vehicle.current(world) + self._mode = 'walk' + self._angle = 0 + return self._init_roaches(world) + + def _init_roaches(self, world): + x, y = self._level.start_pos + self._level_layer = 'floor' + self._avatar = self._vehicle.get_avatar(world) + self._set_pos(x, y) + self._avatar.pos = (WIDTH // 2, HEIGHT // 2) + self._roaches.add(self._avatar) + # Fix viewport offset + return [MoveViewportEvent((x * TILE_SIZE - WIDTH // 2, y * TILE_SIZE - HEIGHT // 2))] + + def _set_pos(self, x, y): + self._player_pos = (x, y) + print('Now at ', x, y) + + def _can_move(self, x, y): + if self._mode == 'walk': + return self._level.can_walk(x, y, self._level_layer) + elif self._mode == 'fly': + return self._level.can_fly(x, y, self._level_layer) + elif self._mode == 'crawl': + return self._level.can_crawl(x, y, self._level_layer) + + def _set_angle(self, angle): + self._angle = angle + self._avatar.angle = angle + + def update(self, world, engine, dt): + if self._vehicle.changed(): + self._roaches.remove(self._avatar) + self._avatar = self._vehicle.get_avatar(world) + self._avatar.pos = (WIDTH // 2, HEIGHT // 2) + self._roaches.add(self._avatar) + self._avatar.set_angle(self._angle) + super().update(world, engine, dt) + + def on_key_down(self, key, mod, unicode): + offset = None + x, y = self._player_pos + if key == keys.DOWN: + if self._can_move(x, y + 1): + self._set_pos(x, y + 1) + offset = (0, TILE_SIZE) + self._set_angle(180) + elif key == keys.UP: + if self._can_move(x, y - 1): + self._set_pos(x, y - 1) + offset = (0, -TILE_SIZE) + self._set_angle(0) + elif key == keys.LEFT: + if self._can_move(x - 1, y): + self._set_pos(x - 1, y) + offset = (-TILE_SIZE, 0) + self._set_angle(90) + elif key == keys.RIGHT: + if self._can_move(x + 1, y): + self._set_pos(x + 1, y) + offset = (TILE_SIZE, 0) + self._set_angle(270) + elif key == keys.C: + # Activate + if self._level.is_grate(x, y): + if self._level_layer == 'floor' and self._level.can_crawl(x, y, 'floor'): + if self._level.can_crawl(x, y, 'tunnels'): + self._level_layer = 'tunnels' + self._mode = 'crawl' + elif self._level.can_crawl(x, y, 'floor'): + # Must be in the tunnels already + self._level_layer = 'floor' + self._mode = 'walk' + elif self._level.is_keypad(x, y): + self._level.press_keypad(x, y, self._roaches) + return + elif key == keys.X: + # Fire + print('Boom') + elif key == keys.V: + # Leave vehicle + print('Vehicle key pressed') + elif key == keys.Z: + # Vehicle management + from .roach_management import RoachesScene + return[ChangeSceneEvent(RoachesScene())] + if offset: + return [MoveViewportEvent(offset)] + return super(GameLevelScene, self).on_key_down(key, mod, unicode)