X-Git-Url: https://git.ctpug.org.za/?a=blobdiff_plain;f=koperkapel%2Fscenes%2Flevel.py;h=54041baa7cc20e863e0c0457ba8a9cbe70a77b47;hb=f1955c8e7345b183c12682caa9daac0741d52af1;hp=2484119350570d93fdfb49b37f5d0c02106876d6;hpb=663cf50f914ef479622e517463f4b03604c297c9;p=koperkapel.git diff --git a/koperkapel/scenes/level.py b/koperkapel/scenes/level.py index 2484119..54041ba 100644 --- a/koperkapel/scenes/level.py +++ b/koperkapel/scenes/level.py @@ -1,17 +1,45 @@ """Render a level""" +import random from pgzero.constants import keys from pygame import Surface import pygame.locals as pgl from ..loaders.levelloader import levels -from .base import Scene, ChangeSceneEvent, MoveViewportEvent +from .base import ( + Scene, ChangeSceneEvent, MoveViewportEvent, WorldEvent, defer_to_update) from ..constants import TILE_SIZE, WIDTH, HEIGHT -from ..roaches import default_roaches +from ..gamelib.items import clone_old_item, create_new_item +from ..roaches import build_roach +from ..vehicles.base import Vehicle +from ..weapons import weapon_by_name + + +class PlayerStats: + def __init__(self, world): + roaches = world.roaches + self.health = sum(r.health for r in roaches) + self.smart = self._count_attr("smart", roaches) + self.fast = self._count_attr("fast", roaches) + self.strong = self._count_attr("strong", roaches) + + def __str__(self): + return "" % ( + self.health, self.smart, self.fast, self.strong) + + def _count_attr(self, attr, roaches): + attrs = [r[attr] for r in roaches] + attrs = [a for a in attrs if a] + return len(attrs) class BaseLevelScene(Scene): """ Level scene. """ + def __init__(self): + super().__init__() + self._level = None + self._stats = None + def enter(self, world): self._level = levels.load(world.level.name) self._tiles = self._level.tiles @@ -21,6 +49,14 @@ class BaseLevelScene(Scene): 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) + self._bullets = self.actors.add_layer("bullets", level=10) + # 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 _render(self, layer): # We cache the rendered surface to avoid doing a large number @@ -38,17 +74,29 @@ class BaseLevelScene(Scene): surface.blit(tile[layer_key], pos) return surface.convert_alpha() - def draw(self, screen, viewport): + def update(self, world, engine, dt): + """Fix the door and keypad positions""" + super().update(world, engine, dt) + for door in self._doors: + door.pos = self.calc_offset( + door.game_pos[0] * TILE_SIZE, door.game_pos[1] * TILE_SIZE) + for keypad in self._keypads: + keypad.pos = self.calc_offset( + keypad.game_pos[0] * TILE_SIZE, keypad.game_pos[1] * TILE_SIZE) + + def draw(self, screen): 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 + viewport = self.viewport 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) + 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): @@ -60,63 +108,276 @@ class BaseLevelScene(Scene): class GameLevelScene(BaseLevelScene): def enter(self, world): + self._held_keys = set() + if self._level is not None: + for generator in self._generators: + generator.unpause() + return + self._update_player_stats(world) super().enter(world) self._roaches = self.actors.add_layer("roaches", level=10) + self._friends = self.actors.add_layer("friendly roaches", level=9) + self._items = self.actors.add_layer("items", level=9) + self._generators = self.actors.add_layer("enemy generators", level=8) + self._enemies = self.actors.add_layer("enemies", level=11) + self._vehicle = Vehicle.current(world) self._mode = 'walk' - return self._init_roaches(world.roaches) + self._angle = 0 # up + self._angle_dp = (0, -1) # up + self._init_items() + self._init_friendly_roaches() + self._init_generators() + self._key_rate = 0.2 + self._last_key_down = 0 + self._last_dmg = 0 + return self._init_roaches(world) + + def _init_items(self): + for item in self._level.items: + self._items.add(item) + + def _init_friendly_roaches(self): + for friend in self._level.friends: + self._friends.add(friend) - def _init_roaches(self, roaches): - for roach in roaches: - roach_actor = self._roaches.add(default_roaches.assemble(roach)) - roach_actor.anchor = (0, 0) - roach_actor.pos = (WIDTH // 2, HEIGHT // 2) + def exit(self, world): + for generator in self._generators: + # We don't want these running while we're on other levels, but we + # don't want to delete them here either (because of the vehicle + # management view) + generator.pause() + + def _init_generators(self): + for generator in self._level.enemy_generators: + self._generators.add(generator) + generator.unpause() + + def _init_roaches(self, world): x, y = self._level.start_pos - self._set_pos(x, y) 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))] + return [ + MoveViewportEvent(( + x * TILE_SIZE - WIDTH // 2, + y * TILE_SIZE - HEIGHT // 2))] def _set_pos(self, x, y): self._player_pos = (x, y) + # print('At ', (x, y)) def _can_move(self, x, y): if self._mode == 'walk': - return self._level.can_walk(x, y, self._level_layer) + if not self._level.enemy_at(x, y): + return self._level.can_walk(x, y, self._level_layer) + return False 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): - for roach in self._roaches: - roach.angle = angle + def _set_angle(self, angle, dp): + self._angle = angle + self._angle_dp = dp + self._avatar.angle = angle - def on_key_down(self, key, mod, unicode): - offset = None + @defer_to_update + def _vehicle_changed(self, world): + self._roaches.remove(self._avatar) + self._vehicle = Vehicle.current(world) + self._avatar = self._vehicle.get_avatar(world) + self._avatar.pos = (WIDTH // 2, HEIGHT // 2) + self._roaches.add(self._avatar) + self._set_angle(self._angle, self._angle_dp) + + @defer_to_update + def _add_roach(self, world): + world.roaches.append(build_roach(world)) + self._vehicle_changed() + + @defer_to_update + def _damage_player(self, world): + if not world.roaches: + # Skip out if we're already dead + return + roach = random.choice(world.roaches) + roach.health -= self._last_dmg + self._last_dmg = 0 + if roach.health < 0: + index = [x.name for x in world.roaches].index(roach.name) + world.roaches.pop(index) + # We can't check for empty, because updates will be processed later + if len(world.roaches) > 1: + self._vehicle_changed() + + @defer_to_update + def _gain_item(self, world, item): + if item.item_type == "serum": + world.serums.append(item.item_data["serum"]) + elif item.item_type == "weapon": + old_weapon = world.weapons.current + world.weapons.current = item.item_data["weapon"] + if old_weapon != "spit": + clone = clone_old_item(item, weapon=old_weapon) + self._level.items.append(clone) + self._items.add(clone) + self._vehicle_changed() + + def _hit_enemy(self, enemy, weapon): + enemy.health -= weapon.damage + if enemy.health <= 0: + self._level.remove_enemy(enemy) + self._enemies.remove(enemy) + + def _fire_bullet(self, bullet, pos, dp, angle): + if len(self._bullets) >= 10: + return + bullet.game_pos = pos + bullet.game_dp = dp + bullet.dt = 0 + bullet.level_layer = self._level_layer + bullet.angle = angle + self._bullets.add(bullet) + + def _check_for_bullet_hits(self): + for bullet in list(self._bullets): + for enemy in list(self._enemies): + if enemy.collidepoint(bullet.pos): + self._hit_enemy(enemy, bullet.weapon) + self._bullets.remove(bullet) + + def _update_bullet(self, bullet, dt): + bullet.dt += dt + if bullet.dt > 0.1: + bullet.dt = 0 + bullet.game_pos = pos = ( + bullet.game_pos[0] + bullet.game_dp[0], + bullet.game_pos[1] + bullet.game_dp[1]) + if not self._level.can_bullet(pos[0], pos[1], bullet.level_layer): + self._bullets.remove(bullet) + + @defer_to_update + def _fire_weapon(self, world): + weapon = weapon_by_name(world.weapons.current) + weapon.play_sound() + if weapon.bullet_range > 0: + self._fire_bullet( + weapon.assemble_bullet(), self._player_pos, self._angle_dp, + self._angle) + else: + # melee + pos, dp = self._player_pos, self._angle_dp + pos = (pos[0] + dp[0], pos[1] + dp[1]) + enemy = self._level.get_enemy(pos[0], pos[1]) + if enemy: + self._hit_enemy(enemy, weapon) + + @defer_to_update + def _change_vehicle(self, world): 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.S: - if self._level_layer == 'floor' and self._level.can_crawl(x, y, 'floor'): - # We're probably on a grate + + old_vehicle = world.vehicles.current + + item = self._level.item_at(x, y) + + if item and item.item_type == "vehicle": + world.vehicles.current = item.item_data["vehicle"] + self._level.remove_item(item) + self._items.remove(item) + else: + world.vehicles.current = "walking" + + if old_vehicle != "walking": + dropped_vehicle = create_new_item( + "vehicle", (x, y), vehicle=old_vehicle) + self._level.items.append(dropped_vehicle) + self._items.add(dropped_vehicle) + + self._vehicle_changed() + + def update(self, world, engine, dt): + if not world.roaches: + # Catch death here + from .menu import MenuScene + return [ChangeSceneEvent(MenuScene())] + super().update(world, engine, dt) + events = world.pop_events() + for friend in self._friends: + friend.pos = self.calc_offset( + friend.game_pos[0] * TILE_SIZE, friend.game_pos[1] * TILE_SIZE) + for item in self._items: + item.pos = self.calc_offset( + item.game_pos[0] * TILE_SIZE, item.game_pos[1] * TILE_SIZE) + self._check_enemies(dt) + for enemy in self._enemies: + enemy.pos = self.calc_offset( + enemy.game_pos[0] * TILE_SIZE, enemy.game_pos[1] * TILE_SIZE) + for bullet in list(self._bullets): + self._update_bullet(bullet, dt) + bullet.pos = self.calc_offset( + bullet.game_pos[0] * TILE_SIZE + (TILE_SIZE // 2), + bullet.game_pos[1] * TILE_SIZE + (TILE_SIZE // 2)) + self._check_for_bullet_hits() + self._update_player_stats(world) + more = self._check_held_keys(dt) + if more: + events.extend(more) + return events + + def _update_player_stats(self, world): + self._stats = PlayerStats(world) + + def _check_enemies(self, dt): + if len(self._level.enemies) != len(self._enemies): + # New nemy has spawned + for enemy in self._level.enemies: + if enemy not in self._enemies: + self._enemies.add(enemy) + for enemy in self._enemies: + dmg = enemy.attack(self._player_pos, self._level_layer, dt) + if dmg is not None: + self._last_dmg += dmg + if self._last_dmg: + self._damage_player() + + def _check_held_keys(self, dt): + for key in self._held_keys: + self._last_key_down += dt + if key in (keys.DOWN, keys.UP, keys.LEFT, keys.RIGHT): + return self._movement_key(key, dt) + elif key == keys.X: + return self._fire_key(dt) + + def _movement_key(self, key, dt): + x, y = self._player_pos + for k, dp, angle in ( + (keys.DOWN, (0, 1), 180), + (keys.UP, (0, -1), 0), + (keys.LEFT, (-1, 0), 90), + (keys.RIGHT, (1, 0), -90), + ): + if key == k: + if (self._angle == angle and + self._last_key_down > self._key_rate): + nx, ny = x + dp[0], y + dp[1] + if self._can_move(nx, ny): + self._set_pos(nx, ny) + offset = (TILE_SIZE * dp[0], TILE_SIZE * dp[1]) + self._set_angle(angle, dp) + self._last_key_down = 0 + return [MoveViewportEvent(offset)] + else: + # just turn + self._set_angle(angle, dp) + + def _activate_key(self): + x, y = self._player_pos + 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' @@ -124,9 +385,59 @@ class GameLevelScene(BaseLevelScene): # Must be in the tunnels already self._level_layer = 'floor' self._mode = 'walk' - return - if offset: - return [MoveViewportEvent(offset)] + elif self._level.is_keypad(x, y): + self._level.press_keypad(x, y, self._roaches) + elif self._level.friend_at(x, y): + friend = self._level.friend_at(x, y) + self._level.remove_friend(friend) + self._friends.remove(friend) + self._add_roach() + elif self._level.item_at(x, y): + item = self._level.item_at(x, y) + if item.item_type != "vehicle": + self._level.remove_item(item) + self._items.remove(item) + self._gain_item(item) + elif self._level.is_exit(x, y): + next_level = self._level.get_exit_level() + return [ + WorldEvent('set', {'level.name': next_level}), + ChangeSceneEvent(GameLevelScene())] + + def _fire_key(self, dt): + if self._last_key_down > self._key_rate: + self._last_key_down = 0 + self._fire_weapon() + + def _vehicle_management_key(self): + from .roach_management import RoachesScene + return [ChangeSceneEvent(RoachesScene(level_scene=self))] + + def on_key_down(self, key, mod, unicode): + x, y = self._player_pos + if key in (keys.DOWN, keys.UP, keys.LEFT, keys.RIGHT): + firing = (keys.X in self._held_keys) + self._held_keys.clear() + self._held_keys.add(key) + if firing: + self._held_keys.add(keys.X) + # We do this so pressing the key has an instant effect, and can + # then be held + self._last_key_down = self._key_rate + 0.01 + return self._movement_key(key, 0.01) + elif key == keys.C: + return self._activate_key() + elif key == keys.X: + self._held_keys.clear() + self._held_keys.add(key) + self._last_key_down = self._key_rate + 0.01 + return self._fire_key(0.01) + elif key == keys.V: + return self._change_vehicle() + elif key == keys.Z: + return self._vehicle_management_key() return super(GameLevelScene, self).on_key_down(key, mod, unicode) - - + + def on_key_up(self, key, mode): + self._held_keys.discard(key) + self._last_key_down = 0