"""Render a level"""
+import random
from pgzero.constants import keys
from pygame import Surface
import pygame.locals as pgl
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 "<PlayerStats health=%d smart=%d fast=%d strong=%d>" % (
+ 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)
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=7)
+ self._enemies = self.actors.add_layer("enemies", level=11)
self._vehicle = Vehicle.current(world)
self._mode = 'walk'
self._angle = 0 # up
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):
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":
self._level.remove_enemy(enemy)
self._enemies.remove(enemy)
- def _fire_bullet(self, bullet, pos, dp):
+ 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:
weapon.play_sound()
if weapon.bullet_range > 0:
self._fire_bullet(
- weapon.assemble_bullet(), self._player_pos, self._angle_dp)
+ weapon.assemble_bullet(), self._player_pos, self._angle_dp,
+ self._angle)
else:
# melee
pos, dp = self._player_pos, self._angle_dp
x, y = self._player_pos
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)
world.vehicles.current = "walking"
if old_vehicle != "walking":
- dropped_vehicle = create_new_item("vehicle", (x, y), vehicle=old_vehicle)
+ 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:
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()
+ 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)
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 _check_enemies(self):
+ 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:
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
projects / koperkapel.git / blobdiff