Stage Architecture

Stage consists of the following subsystems:
Echo, Galileo, Mercury, Pegasus, Proteus, Shepherd and Thor. 

Thor
    Is the foundation upon which the game server rests.
    Performs basic services that pretty much every application
    requires, game or no.    

 
    Manages game initialization and shutdown, operates the
    main loop controlling the game, interfaces with the
    console, and handles configuration management.  Very
    top level things.

 
    Thor also serves as the harness to which external modules
    are attached.  Thor exposes a standard common interface
    that serves as a Facade through which the module can 
    interact with the game server.

 
    Thor knows about all of the other subsystems, but none of
    the other systems know about or use any of Thor's functions.

 
Mercury
    Is the layer closest to the network, and directly tackles
    or filters a great deal of the information gathered from
    clients, thereby encapsulating and isolating a good deal
    of operations from the server proper.  

 
    Mercury knows about Pegasus and can manipulate things
    within it, but Pegasus does not know anything about Mercury
    and is forbidden from calling any of Mercury's functions.

 
    Example: Mercury handles events and when new event is 
    created, one logs on Mercury asks for Pegasus to 
    provide the changes to enitities required.

 
Pegasus
    This is the central dispatcher.  Pegasus runs through as
    many of the game operations as time in a given turn permits.
    If there is insufficient time to get through all needed
    operations, then the least important items are skipped and
    left for later.

 
    Pegasus knows about Shepherd and can interact with it 
    directly, but the Shepherd subsystem knows nothing about
    Pegasus' functionality.  

 
Shepherd
    Shepherd is the guardian of ingame objects called Entities.
    (Majority of Entities will have 3d presentation in the 
    ingame world.) Shepherd provides the basis for a massive
    3d world. It takes care of the consistency and persistence
    of the 3d world and the Entities in it. Basic kinematics and
    collision detection are included in the Shepherd functionality
    as rest of the physics are taken care of by a plugin physics
    module. 

 
    Shepherd keeps list of Entity ArcheTypes which are base types
    for other Entities. 

 
    Shepherd has access to the full public interface of Echo for 
    persistence related functionality, but echo doesn't know a single
    thing about Shepherd.

 
Echo
    Provides an interface between shepherd and the underlying
    database system for persisting information.  Echo doesn't
    have a clue what an entity is and knows nothing about
    Shepherd's functionality.

 
Galileo
    Galileo provides logging to database and other media. It 
    is also possible for logging channels to register 
    so that they can receive logging messages from Galileo. 

 
Proteus
    Proteus handles dynamic module loading, dynamic data 
    member extension of classes and dynamic inheritable action /
    ability extension of entities. (Dynamic refers to run time
    operation.)