import os
from pgzero.loaders import images
from ..actors.orientatedsurf import OrientatedSurfActor
+from ..constants import TILE_SIZE
class Door(OrientatedSurfActor):
def __init__(self, x, y, angle):
self._closed = True
self._open_surf = images.load(os.path.join('fixtures', 'door_open'))
- self._closed_surf = images.load(os.path.join('fixtures', 'door_closed'))
+ self._closed_surf = images.load(os.path.join('fixtures', 'door'))
self.game_pos = (x, y)
- super().__init__(self._closed_surf, angle)
+ super().__init__(self._closed_surf, angle=angle, anchor=(0, 0))
def open(self):
self._closed = False
import os
from pgzero.loaders import images
from ..actors.orientatedsurf import SurfActor
+from ..constants import TILE_SIZE
class Keypad(SurfActor):
self._doors = doors
self.game_pos = (x, y)
surf = images.load(os.path.join('fixtures', 'keypad'))
- super().__init__(surf)
+ super().__init__(surf, anchor=(0, 0))
def activate(self):
# FIXME: Check stats
if 'walk' in self.tiles[y][x][layer]['behaviour']:
# check doors
for door in self.doors:
- if (x, y) == door.pos and door.closed():
+ if (x, y) == door.game_pos and door.is_closed():
return False
return True
return False
def can_fly(self, x, y, layer):
if 'fly' in self.tiles[y][x][layer]['behaviour']:
for door in self.doors:
- if (x, y) == door.pos and door.closed():
+ if (x, y) == door.game_pos and door.is_closed():
return False
return True
def keypad_at(self, x, y):
for keypad in self.keypads:
- if (x, y) == keypad.pos:
+ if (x, y) == keypad.game_pos:
return keypad
return None
doors = []
for door in door_info['doors']:
# Sort out angle
- new_door = Door(0, door[0], door[1])
+ new_door = Door(door[0], door[1], 0)
self._level.doors.append(new_door)
# Add the keypads
for keypad in door_info['keypads']:
- new_keypad = Keypad(doors, keypad[0], keypad[1])
+ new_keypad = Keypad(keypad[0], keypad[1], doors)
self._level.keypads.append(new_keypad)
return self._level
self._viewport = (self._viewport[0] + offset[0],
self._viewport[1] + offset[1])
+ def calc_offset(self, x, y):
+ """Return a position offset by the viewport"""
+ return x - self._viewport[0], y - self._viewport[1]
+
@apply_events
def update(self, dt):
- return self._scene.update(self._world.proxy(), dt)
+ return self._scene.update(self._world.proxy(), self, dt)
def draw(self):
self._scene.draw(self._app.screen, self._viewport)
def exit(self, world):
pass
- def update(self, world, dt):
+ def update(self, world, engine, dt):
pass
def draw(self, screen, viewport):
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=15)
- self._keypads = self.actors.add_layer("keypads", level=16)
+ 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.append(door)
+ self._doors.add(door)
for keypad in self._level.keypads:
- self._keypads.append(keypads)
+ self._keypads.add(keypad)
def _render(self, layer):
# We cache the rendered surface to avoid doing a large number
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
def _eject_roach(self):
print("Eject roach.")
- def update(self, world, dt):
+ def update(self, world, engine, dt):
self._update_inventory(world)
self._update_roaches(world)