koperkapel/scenes/level.py

   1 """Render a level"""
   2
   3 import random
   4 from pgzero.constants import keys
   5 from pgzero.loaders import sounds
   6 from pygame import Surface
   7 import pygame.locals as pgl
   8 from ..loaders.levelloader import levels
   9 from .base import (
  10     Scene, ChangeSceneEvent, MoveViewportEvent, WorldEvent, defer_to_update)
  11 from ..constants import TILE_SIZE, WIDTH, HEIGHT
  12 from ..gamelib.items import clone_old_item, create_new_item
  13 from ..hud import HudActor
  14 from ..roaches import build_roach
  15 from ..vehicles.base import Vehicle
  16 from ..weapons import weapon_by_name
  17
  18
  19 class PlayerStats:
  20     def __init__(self, world):
  21         roaches = world.roaches
  22         self.health = sum(r.health for r in roaches)
  23         self.smart = self._count_attr("smart", roaches)
  24         self.fast = self._count_attr("fast", roaches)
  25         self.strong = self._count_attr("strong", roaches)
  26
  27     def __str__(self):
  28         return "<PlayerStats health=%d smart=%d fast=%d strong=%d>" % (
  29             self.health, self.smart, self.fast, self.strong)
  30
  31     def __eq__(self, other):
  32         if not isinstance(other, PlayerStats):
  33             return NotImplemented
  34         return all(
  35             (self.health == other.health, self.smart == other.smart,
  36              self.fast == other.fast, self.strong == other.strong))
  37
  38     def _count_attr(self, attr, roaches):
  39         attrs = [r[attr] for r in roaches]
  40         attrs = [a for a in attrs if a]
  41         return len(attrs)
  42
  43
  44 class BaseLevelScene(Scene):
  45     """ Level scene. """
  46
  47     def __init__(self):
  48         super().__init__()
  49         self._level = None
  50         self._stats = None
  51
  52     def enter(self, world):
  53         self._level = levels.load(world.level.name)
  54         self._tiles = self._level.tiles
  55         self._level_layer = 'floor'
  56         self._surfaces = {}
  57         self._overlay = {}
  58         for layer in ['floor', 'tunnels']:
  59             self._surfaces[layer] = self._render(layer)
  60         self._overlay = self._surfaces['floor'].copy()
  61         self._doors = self.actors.add_layer("doors", level=9)
  62         self._keypads = self.actors.add_layer("keypads", level=8)
  63         self._bullets = self.actors.add_layer("bullets", level=10)
  64         # These are already Actors
  65         for door in self._level.doors:
  66             self._doors.add(door)
  67         for keypad in self._level.keypads:
  68             self._keypads.add(keypad)
  69
  70     def _render(self, layer):
  71         # We cache the rendered surface to avoid doing a large number
  72         # of blits each frame, as that introduces a large performance
  73         # overhead.
  74         surface = Surface((len(self._tiles[0]) * TILE_SIZE,
  75                            len(self._tiles) * TILE_SIZE))
  76         layer_key = '%s image' % layer
  77         for y, row in enumerate(self._tiles):
  78             for x, tile in enumerate(row):
  79                 pos = (x * TILE_SIZE, y * TILE_SIZE)
  80                 if layer_key not in tile:
  81                     # Skip broken tiles for now
  82                     continue
  83                 surface.blit(tile[layer_key], pos)
  84         return surface.convert_alpha()
  85
  86     def update(self, world, engine, dt):
  87         """Fix the door and keypad positions"""
  88         super().update(world, engine, dt)
  89         for door in self._doors:
  90             door.pos = self.calc_offset(
  91                 door.game_pos[0] * TILE_SIZE, door.game_pos[1] * TILE_SIZE)
  92         for keypad in self._keypads:
  93             keypad.pos = self.calc_offset(
  94                 keypad.game_pos[0] * TILE_SIZE, keypad.game_pos[1] * TILE_SIZE)
  95
  96     def draw(self, screen):
  97         screen.clear()
  98         # Viewport is the position of the screen relative to the
  99         # surface. We need the position of the surface relative to
 100         # the screen for the blit, so this conversion
 101         viewport = self.viewport
 102         screen.surface.blit(self._surfaces[self._level_layer], (0, 0),
 103                             area=(viewport[0], viewport[1], WIDTH, HEIGHT))
 104         if self._level_layer != 'floor':
 105             screen.surface.blit(
 106                 self._overlay, (0, 0),
 107                 area=(viewport[0], viewport[1], WIDTH, HEIGHT),
 108                 special_flags=pgl.BLEND_MULT)
 109         self.actors.draw(screen)
 110
 111     def on_key_down(self, key, mod, unicode):
 112         if key == keys.ESCAPE:
 113             from .menu import MenuScene
 114             return [ChangeSceneEvent(MenuScene())]
 115
 116
 117 class GameLevelScene(BaseLevelScene):
 118
 119     def enter(self, world):
 120         self._held_keys = set()
 121         if self._level is not None:
 122             for generator in self._generators:
 123                 generator.unpause()
 124             return
 125         self._update_player_stats(world)
 126         super().enter(world)
 127         self._roaches = self.actors.add_layer("roaches", level=10)
 128         self._friends = self.actors.add_layer("friendly roaches", level=9)
 129         self._items = self.actors.add_layer("items", level=9)
 130         self._generators = self.actors.add_layer("enemy generators", level=8)
 131         self._enemies = self.actors.add_layer("enemies", level=11)
 132         self._hud = self.actors.add_layer("hud", level=12)
 133         self._hud.add(HudActor(
 134             self._stats, anchor=("right", "bottom"), pos=(WIDTH, HEIGHT)))
 135         self._vehicle = Vehicle.current(world)
 136         self._mode = 'walk'
 137         self._angle = 0  # up
 138         self._angle_dp = (0, -1)  # up
 139         self._init_items()
 140         self._init_friendly_roaches()
 141         self._init_generators()
 142         self._key_rate = 0.2
 143         self._last_key_down = 0
 144         self._last_dmg = 0
 145         self._screech = sounds.load("screech")
 146         return self._init_roaches(world)
 147
 148     def _init_items(self):
 149         for item in self._level.items:
 150             self._items.add(item)
 151
 152     def _init_friendly_roaches(self):
 153         for friend in self._level.friends:
 154             self._friends.add(friend)
 155
 156     def exit(self, world):
 157         for generator in self._generators:
 158             # We don't want these running while we're on other levels, but we
 159             # don't want to delete them here either (because of the vehicle
 160             # management view)
 161             generator.pause()
 162
 163     def _init_generators(self):
 164         for generator in self._level.enemy_generators:
 165             self._generators.add(generator)
 166             generator.unpause()
 167
 168     def _init_roaches(self, world):
 169         x, y = self._level.start_pos
 170         self._level_layer = 'floor'
 171         self._avatar = self._vehicle.get_avatar(world)
 172         self._set_pos(x, y)
 173         self._avatar.pos = (WIDTH // 2, HEIGHT // 2)
 174         self._roaches.add(self._avatar)
 175         # Fix viewport offset
 176         return [
 177             MoveViewportEvent((
 178                 x * TILE_SIZE - WIDTH // 2,
 179                 y * TILE_SIZE - HEIGHT // 2))]
 180
 181     def _set_pos(self, x, y):
 182         self._player_pos = (x, y)
 183         # print('At ', (x, y))
 184
 185     def _can_move(self, x, y):
 186         if self._mode == 'walk':
 187             if not self._level.enemy_at(x, y):
 188                 return self._level.can_walk(x, y, self._level_layer)
 189             return False
 190         elif self._mode == 'fly':
 191             return self._level.can_fly(x, y, self._level_layer)
 192         elif self._mode == 'crawl':
 193             return self._level.can_crawl(x, y, self._level_layer)
 194
 195     def _set_angle(self, angle, dp):
 196         self._angle = angle
 197         self._angle_dp = dp
 198         self._avatar.angle = angle
 199
 200     @defer_to_update
 201     def _vehicle_changed(self, world):
 202         self._roaches.remove(self._avatar)
 203         self._vehicle = Vehicle.current(world)
 204         self._avatar = self._vehicle.get_avatar(world)
 205         self._avatar.pos = (WIDTH // 2, HEIGHT // 2)
 206         self._roaches.add(self._avatar)
 207         self._set_angle(self._angle, self._angle_dp)
 208
 209     @defer_to_update
 210     def _add_roach(self, world):
 211         world.roaches.append(build_roach(world))
 212         self._vehicle_changed()
 213
 214     @defer_to_update
 215     def _damage_player(self, world):
 216         if not world.roaches:
 217             # Skip out if we're already dead
 218             return
 219         roach = random.choice(world.roaches)
 220         roach.health -= self._last_dmg
 221         self._screech.play()
 222         self._last_dmg = 0
 223         if roach.health < 0:
 224             index = [x.name for x in world.roaches].index(roach.name)
 225             world.roaches.pop(index)
 226             # We can't check for empty, because updates will be processed later
 227             if len(world.roaches) > 1:
 228                 self._vehicle_changed()
 229
 230     @defer_to_update
 231     def _gain_item(self, world, item):
 232         if item.item_type == "serum":
 233             world.serums.append(item.item_data["serum"])
 234         elif item.item_type == "weapon":
 235             old_weapon = world.weapons.current
 236             world.weapons.current = item.item_data["weapon"]
 237             if old_weapon != "spit":
 238                 clone = clone_old_item(item, weapon=old_weapon)
 239                 self._level.items.append(clone)
 240                 self._items.add(clone)
 241         self._vehicle_changed()
 242
 243     def _hit_enemy(self, enemy, weapon):
 244         enemy.health -= weapon.damage
 245         enemy.hit_sound.play()
 246         if enemy.health <= 0:
 247             self._level.remove_enemy(enemy)
 248             self._enemies.remove(enemy)
 249
 250     def _fire_bullet(self, bullet, pos, dp, angle):
 251         if len(self._bullets) >= 10:
 252             return
 253         bullet.game_pos = pos
 254         bullet.game_dp = dp
 255         bullet.dt = 0
 256         bullet.level_layer = self._level_layer
 257         bullet.angle = angle
 258         self._bullets.add(bullet)
 259
 260     def _check_for_bullet_hits(self):
 261         for bullet in list(self._bullets):
 262             for enemy in list(self._enemies):
 263                 if enemy.collidepoint(bullet.pos) and bullet.level_layer == enemy.level_layer:
 264                     self._hit_enemy(enemy, bullet.weapon)
 265                     self._bullets.remove(bullet)
 266
 267     def _update_bullet(self, bullet, dt):
 268         bullet.dt += dt
 269         if bullet.dt > 0.1:
 270             bullet.dt = 0
 271             bullet.game_pos = pos = (
 272                 bullet.game_pos[0] + bullet.game_dp[0],
 273                 bullet.game_pos[1] + bullet.game_dp[1])
 274             if not self._level.can_bullet(pos[0], pos[1], bullet.level_layer):
 275                 self._bullets.remove(bullet)
 276
 277     @defer_to_update
 278     def _fire_weapon(self, world):
 279         weapon = weapon_by_name(world.weapons.current)
 280         weapon.play_sound()
 281         if weapon.bullet_range > 0:
 282             self._fire_bullet(
 283                 weapon.assemble_bullet(), self._player_pos, self._angle_dp,
 284                 self._angle)
 285         else:
 286             # melee
 287             pos, dp = self._player_pos, self._angle_dp
 288             pos = (pos[0] + dp[0], pos[1] + dp[1])
 289             enemy = self._level.get_enemy(pos[0], pos[1])
 290             if enemy:
 291                 self._hit_enemy(enemy, weapon)
 292
 293     @defer_to_update
 294     def _change_vehicle(self, world):
 295         x, y = self._player_pos
 296
 297         old_vehicle = world.vehicles.current
 298
 299         item = self._level.item_at(x, y)
 300
 301         if item and item.item_type == "vehicle":
 302             world.vehicles.current = item.item_data["vehicle"]
 303             self._level.remove_item(item)
 304             self._items.remove(item)
 305         else:
 306             world.vehicles.current = "walking"
 307
 308         if old_vehicle != "walking":
 309             dropped_vehicle = create_new_item(
 310                 "vehicle", (x, y), vehicle=old_vehicle)
 311             self._level.items.append(dropped_vehicle)
 312             self._items.add(dropped_vehicle)
 313
 314         self._vehicle_changed()
 315
 316     def update(self, world, engine, dt):
 317         if not world.roaches:
 318             # Catch death here
 319             from .menu import MenuScene
 320             return [ChangeSceneEvent(MenuScene())]
 321         super().update(world, engine, dt)
 322         events = world.pop_events()
 323         for friend in self._friends:
 324             friend.pos = self.calc_offset(
 325                 friend.game_pos[0] * TILE_SIZE, friend.game_pos[1] * TILE_SIZE)
 326         for item in self._items:
 327             item.pos = self.calc_offset(
 328                 item.game_pos[0] * TILE_SIZE, item.game_pos[1] * TILE_SIZE)
 329         self._check_enemies(dt)
 330         for enemy in self._enemies:
 331             enemy.pos = self.calc_offset(
 332                 enemy.game_pos[0] * TILE_SIZE, enemy.game_pos[1] * TILE_SIZE)
 333         for bullet in list(self._bullets):
 334             self._update_bullet(bullet, dt)
 335             bullet.pos = self.calc_offset(
 336                 bullet.game_pos[0] * TILE_SIZE + (TILE_SIZE // 2),
 337                 bullet.game_pos[1] * TILE_SIZE + (TILE_SIZE // 2))
 338         self._check_for_bullet_hits()
 339         self._update_player_stats(world)
 340         self._hud[0].stats = self._stats
 341         more = self._check_held_keys(dt)
 342         if more:
 343             events.extend(more)
 344         return events
 345
 346     def _update_player_stats(self, world):
 347         self._stats = PlayerStats(world)
 348
 349     def _check_enemies(self, dt):
 350         if len(self._level.enemies) != len(self._enemies):
 351             # New nemy has spawned
 352             for enemy in self._level.enemies:
 353                 if enemy not in self._enemies:
 354                     self._enemies.add(enemy)
 355         for enemy in self._enemies:
 356             dmg = enemy.attack(self._player_pos, self._level_layer, dt)
 357             if dmg is not None:
 358                 self._last_dmg += dmg
 359         if self._last_dmg:
 360             self._damage_player()
 361
 362     def _check_held_keys(self, dt):
 363         for key in self._held_keys:
 364             self._last_key_down += dt
 365             if key in (keys.DOWN, keys.UP, keys.LEFT, keys.RIGHT):
 366                 return self._movement_key(key, dt)
 367             elif key == keys.X:
 368                 return self._fire_key(dt)
 369
 370     def _movement_key(self, key, dt):
 371         x, y = self._player_pos
 372         for k, dp, angle in (
 373             (keys.DOWN, (0, 1), 180),
 374             (keys.UP, (0, -1), 0),
 375             (keys.LEFT, (-1, 0), 90),
 376             (keys.RIGHT, (1, 0), -90),
 377         ):
 378             if key == k:
 379                 if (self._angle == angle and
 380                         self._last_key_down > self._key_rate):
 381                     nx, ny = x + dp[0], y + dp[1]
 382                     if self._can_move(nx, ny):
 383                         self._set_pos(nx, ny)
 384                         offset = (TILE_SIZE * dp[0], TILE_SIZE * dp[1])
 385                         self._set_angle(angle, dp)
 386                         self._last_key_down = 0
 387                         return [MoveViewportEvent(offset)]
 388                 else:
 389                     # just turn
 390                     self._set_angle(angle, dp)
 391
 392     def _activate_key(self):
 393         x, y = self._player_pos
 394         if self._level.is_grate(x, y):
 395             if (self._level_layer == 'floor' and
 396                     self._level.can_crawl(x, y, 'floor')):
 397                 if self._level.can_crawl(x, y, 'tunnels'):
 398                     self._level_layer = 'tunnels'
 399                     self._mode = 'crawl'
 400             elif self._level.can_crawl(x, y, 'floor'):
 401                 # Must be in the tunnels already
 402                 self._level_layer = 'floor'
 403                 self._mode = 'walk'
 404         elif self._level.is_keypad(x, y):
 405             self._level.press_keypad(x, y, self._stats.smart)
 406         elif self._level.friend_at(x, y):
 407             friend = self._level.friend_at(x, y)
 408             self._level.remove_friend(friend)
 409             self._friends.remove(friend)
 410             self._add_roach()
 411         elif self._level.item_at(x, y):
 412             item = self._level.item_at(x, y)
 413             if item.item_type != "vehicle":
 414                 self._level.remove_item(item)
 415                 self._items.remove(item)
 416                 self._gain_item(item)
 417         elif self._level.is_exit(x, y):
 418             next_level = self._level.get_exit_level()
 419             return [
 420                 WorldEvent('set', {'level.name': next_level}),
 421                 ChangeSceneEvent(GameLevelScene())]
 422
 423     def _fire_key(self, dt):
 424         if self._last_key_down > self._key_rate:
 425             self._last_key_down = 0
 426             self._fire_weapon()
 427
 428     def _vehicle_management_key(self):
 429         from .roach_management import RoachesScene
 430         return [ChangeSceneEvent(RoachesScene(level_scene=self))]
 431
 432     def on_key_down(self, key, mod, unicode):
 433         x, y = self._player_pos
 434         if key in (keys.DOWN, keys.UP, keys.LEFT, keys.RIGHT):
 435             firing = (keys.X in self._held_keys)
 436             self._held_keys.clear()
 437             self._held_keys.add(key)
 438             if firing:
 439                 self._held_keys.add(keys.X)
 440             # We do this so pressing the key has an instant effect, and can
 441             # then be held
 442             self._last_key_down = self._key_rate + 0.01
 443             return self._movement_key(key, 0.01)
 444         elif key == keys.C:
 445             return self._activate_key()
 446         elif key == keys.X:
 447             self._held_keys.clear()
 448             self._held_keys.add(key)
 449             self._last_key_down = self._key_rate + 0.01
 450             return self._fire_key(0.01)
 451         elif key == keys.V:
 452             return self._change_vehicle()
 453         elif key == keys.Z:
 454             return self._vehicle_management_key()
 455         return super(GameLevelScene, self).on_key_down(key, mod, unicode)
 456
 457     def on_key_up(self, key, mode):
 458         self._held_keys.discard(key)
 459         self._last_key_down = 0