|
#!/usr/bin/env python3
import time, pyglet
from .errors import *
from .forums import Forum
from .multiplayer import ClientForum, ServerActor
class Theater:
"""
Manage whichever stage is currently active. This involves both
updating the current stage and handling transitions between stages.
"""
def __init__(self, initial_stage=None, gui=None):
self._gui = gui
self._initial_stage = initial_stage
self._current_stage = None
self._current_update = self._update_before_loop
self._previous_time = time.time()
@property
def gui(self):
return self._gui
@gui.setter
def gui(self, gui):
if self._current_stage:
raise ApiUsageError("theater already playing; can't set gui.")
self._gui = gui
@property
def initial_stage(self):
return self._initial_stage
@initial_stage.setter
def initial_stage(self, stage):
require_stage(stage)
if self._current_stage:
raise ApiUsageError("theater already playing; can't set initial stage.")
self._initial_stage = stage
@property
def current_stage(self):
return self._current_stage
@property
def is_finished(self):
return self._current_update == self._update_after_loop
def update(self, dt=None):
self._current_update(dt)
def exit(self):
if self._current_stage:
self._current_stage.on_exit_stage()
self._current_update = self._update_after_loop
def _update_before_loop(self, dt):
self._current_stage = self._initial_stage
self._current_stage.theater = self
self._current_stage.on_enter_stage()
self._current_update = self._update_main_loop
self._current_update(dt)
def _update_main_loop(self, dt):
if dt is None:
current_time = time.time()
dt = current_time - self._previous_time
self._previous_time = current_time
self._current_stage.on_update_stage(dt)
if self._current_stage.is_finished:
self._current_stage.on_exit_stage()
self._current_stage = self._current_stage.successor
if not self._current_stage:
self.exit()
else:
require_stage(self._current_stage)
self._current_stage.theater = self
self._current_stage.on_enter_stage()
def _update_after_loop(self, dt):
raise AssertionError("shouldn't update the theater after the game has ended.")
class PygletTheater(Theater):
def play(self, frames_per_sec=50):
pyglet.clock.schedule_interval(self.update, 1/frames_per_sec)
pyglet.app.run()
def exit(self):
super().exit()
pyglet.app.exit()
class Stage:
def __init__(self):
self.theater = None
self.successor = None
self.is_finished = False
@property
def gui(self):
return self.theater.gui
def exit_stage(self):
"""
Stop this stage from executing once the current update ends.
"""
self.is_finished = True
def exit_theater(self):
"""
Exit the game once the current update ends.
"""
self.theater.exit()
def on_enter_stage(self):
"""
Give the stage a chance to set itself up before it is updated for the
first time.
"""
pass
def on_update_stage(self, dt):
"""
Give the stage a chance to react to each clock cycle.
The amount of time that passed since the last clock cycle is provided
as an argument.
"""
pass
def on_exit_stage(self):
"""
Give the stage a chance to react before it is stopped and the next
stage is started.
You can define the next stage by setting the Stage.successor attribute.
If the successor is static, you can just set it in the constructor.
But if it will differ depending on the context, this method may be a
good place to calculate it because it is called only once and just
before the theater queries for the successor.
"""
pass
class GameStage(Stage):
def __init__(self, world, forum, actors):
Stage.__init__(self)
from .tokens import require_world; require_world(world)
from .forums import require_forum; require_forum(forum)
from .actors import require_actors; require_actors(actors)
self.world = world
self.forum = forum
self.actors = actors
self.successor = None
def on_enter_stage(self):
"""
Prepare the actors, the world, and the messaging system to begin
playing the game.
This method is guaranteed to be called exactly once upon entering the
game stage.
"""
with self.world._unlock_temporarily():
self.forum.connect_everyone(self.world, self.actors)
# 1. Setup the forum.
self.forum.on_start_game()
# 2. Setup the world.
with self.world._unlock_temporarily():
self.world.on_start_game()
# 3. Setup the actors. Because this is done after the forum and the
# world have been setup, this signals to the actors that they can
# send messages and query the game world as usual.
num_players = len(self.actors) - 1
for actor in self.actors:
actor.on_setup_gui(self.gui)
for actor in self.actors:
actor.on_start_game(num_players)
def on_update_stage(self, dt):
"""
Sequentially update the actors, the world, and the messaging system.
The theater terminates once all of the actors indicate that they are done.
"""
for actor in self.actors:
actor.on_update_game(dt)
self.forum.on_update_game()
with self.world._unlock_temporarily():
self.world.on_update_game(dt)
if self.world.has_game_ended():
self.exit_stage()
def on_exit_stage(self):
"""
Give the actors, the world, and the messaging system a chance to react
to the end of the game.
"""
# 1. Let the forum react to the end of the game. Local forums don't
# react to this, but remote forums take the opportunity to stop
# trying to extract tokens from messages.
self.forum.on_finish_game()
# 2. Let the actors react to the end of the game.
for actor in self.actors:
actor.on_finish_game()
# 3. Let the world react to the end of the game.
with self.world._unlock_temporarily():
self.world.on_finish_game()
class UniplayerGameStage(GameStage):
def __init__(self, world, referee, gui_actor, ai_actors=None):
forum = Forum()
actors = [referee, gui_actor] + list(ai_actors or [])
GameStage.__init__(self, world, forum, actors)
class MultiplayerClientGameStage(Stage):
def __init__(self, world, gui_actor, pipe):
super().__init__()
self.forum = ClientForum(pipe)
self.successor = GameStage(world, self.forum, [gui_actor])
def on_update_stage(self, dt):
if self.forum.receive_id_from_server():
self.exit_stage()
class MultiplayerServerGameStage(GameStage):
def __init__(self, world, referee, ai_actors, pipes):
forum = Forum()
actors = [referee] + [ServerActor(x) for x in pipes] + ai_actors
GameStage.__init__(self, world, forum, actors)
@debug_only
def require_stage(object):
require_instance(Stage(), object)
|
