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