Engine::ReplayReader Class Reference

Show a replay from a stream. More...

#include <ReplayReader.h>

Inheritance diagram for Engine::ReplayReader:


Public Member Functions
	ReplayReader (std::istream &data)
	Replay from a stream.
virtual	~ReplayReader ()
virtual void	posttick ()
	Process any events that happen next tick.
void	operator() (GameScene *)
	Called by LoadScene when it has finished loading.
Scene *	get_scene ()
	Return the scene that will show the replay.
Protected Member Functions
void	ReadEvents (std::istream &data)
	Read the events in the file into replay_events.
Protected Attributes
std::vector< ReplayEvent >	replay_events
	The list of events in the replay, sorted in time order.
std::vector< ReplayEvent >::iterator	current_iterator
	Iterator to the next event to process.
std::vector< boost::shared_ptr< InputDeviceReplay > >	devices
	Input devices to relay the events through. There is one per player.
std::map< long unsigned int, Engine::InputHandler::iterator >	input_map
	Map identifiers found in the replay data to InputDeviceReplays.
std::vector< std::pair< Engine::InputHandler::iterator, unsigned int > >	game_scene_devices_list
LoadScene< GameScene, ReplayReader > *	load_scene
	The scene used to load the track.
GameScene *	scene
	The scene the replay takes place in.
Classes
struct	ReplayEvent

Detailed Description

Show a replay from a stream.

The replay is stored as some metadata, plus a series of timestamped events recorded from input devices. When created it reads the metadata. It can explain the metadata, and create an appropriate scene. As the scene runs, it will report the events at the correct time so that the same things happen.

For this method to work, we require that all physics, game logic, and AI is deterministic, i.e. when presented with the same events with the same timings, things turn out just as before.

The alternative would be to store a set of states. This has the following disadvantages:

More complex, as there would be a wider variety of events to record.
Every part of the game state would have to be regenerated from state saved in the replay and calculated in the inital run, or saved and restored.
It is likey to take up far more space.

With just the input, we only need to have a list of InputReport objects saved and timestamped, and determinstic state determined only from an input.

Definition at line 49 of file ReplayReader.h.