xrb_engine2_world.hpp

// ///////////////////////////////////////////////////////////////////////////
// xrb_engine2_world.hpp by Victor Dods, created 2004/06/08
// ///////////////////////////////////////////////////////////////////////////
// Unless a different license was explicitly granted in writing by the
// copyright holder (Victor Dods), this software is freely distributable under
// the terms of the GNU General Public License, version 2.  Any works deriving
// from this work must also be released under the GNU GPL.  See the included
// file LICENSE for details.
// ///////////////////////////////////////////////////////////////////////////

#if !defined(_XRB_ENGINE2_WORLD_HPP_)
#define _XRB_ENGINE2_WORLD_HPP_

#include "xrb.hpp"

#include <list>
#include <vector>

#include "xrb_engine2_entity.hpp"
#include "xrb_eventhandler.hpp"
#include "xrb_eventqueue.hpp"
#include "xrb_framehandler.hpp"

namespace Xrb
{

class Serializer;

namespace Engine2
{

class ObjectLayer;
class Object;
class PhysicsHandler;
class WorldView;

// The World class embodies the physical state of sprites in the world,
// and is view-independent.  This allows rendering-independent physics
// and gameplay to be computed.
class World : public EventHandler, public FrameHandler
{
public:

    enum
    {
        MAXIMUM_ENTITY_CAPACITY = ENTITY_IS_NOT_IN_WORLD - 1,
        DEFAULT_ENTITY_CAPACITY = 0x1000
    };

    typedef std::list<ObjectLayer *> ObjectLayerList;

    virtual ~World ();

    static World *Create (
        Serializer &serializer,
        CreateEntityFunction CreateEntity,
        PhysicsHandler *physics_handler);
    static World *CreateEmpty (
        PhysicsHandler *physics_handler,
        EntityWorldIndex entity_capacity = DEFAULT_ENTITY_CAPACITY);
    void Write (Serializer &serializer) const;

    inline Uint32 EntityCapacity () const { ASSERT1(m_entity_vector.capacity() == m_entity_vector.size()); return m_entity_vector.size(); }
    inline Uint32 EntityCount () const { return m_entity_count; }
    inline Entity const *GetEntity (Uint32 index) const { ASSERT1(index < m_entity_vector.size()); return m_entity_vector[index]; }
    inline Entity *GetEntity (Uint32 index) { ASSERT1(index < m_entity_vector.size()); return m_entity_vector[index]; }
    inline ObjectLayerList &GetObjectLayerList () { return m_object_layer_list; }
    virtual ObjectLayer const *MainObjectLayer () const { return m_main_object_layer; }
    virtual ObjectLayer *MainObjectLayer () { return m_main_object_layer; }
    inline Float Timescale () { return m_timescale; }

    inline void SetTimescale (Float timescale)
    {
        ASSERT1(timescale >= 0.0f);
        m_timescale = timescale;
    }

    // you must call this method after creating a WorldView
    void AttachWorldView (WorldView *world_view);
    // you must call this method before destroying a WorldView
    void DetachWorldView (WorldView *world_view);

    void AddObjectLayer (ObjectLayer *object_layer);
    void SetMainObjectLayer (ObjectLayer *main_object_layer);

    // for adding static objects only (because it will be added only to
    // the object layer, which will delete it upon destruction.
    // there is no way to remove a static object).
    void AddStaticObject (Object *static_object, ObjectLayer *object_layer);

    // for adding dynamic objects only (causes them to be added to
    // the dynamic object vector and the physics handler).
    void AddDynamicObject (Object *dynamic_object, ObjectLayer *object_layer);
    // for removing a dynamic object (causes them to be removed from
    // the dynamic object vector and the physics handler).
    void RemoveDynamicObject (Object *dynamic_object);

protected:

    World (
        PhysicsHandler *physics_handler,
        EntityWorldIndex entity_capacity = DEFAULT_ENTITY_CAPACITY);

    virtual Uint32 MainObjectLayerIndex () const;

    virtual void SetMainObjectLayerIndex (Uint32 index);

    // process an event
    virtual bool HandleEvent (Event const *e);
    // this calculates one frame, called by the game loop
    virtual void HandleFrame ();
    void IncrementLowestAvailableEntityIndex ();
    void UpdateLowestAvailableEntityIndex (EntityWorldIndex removed_entity_index);

    // this function should be called only from constructors (or Create)
    void Read (Serializer &serializer, CreateEntityFunction CreateEntity);

    // this function is called after the worldview is added to the
    // worldview list during AttachWorldView.
    virtual void HandleAttachWorldView (WorldView *world_view) { }
    // this function is called before the worldview is removed from the
    // worldview list during DetachWorldView.
    virtual void HandleDetachWorldView (WorldView *world_view) { }

    virtual void ReadObjectLayers (
        Serializer &serializer,
        CreateEntityFunction CreateEntity);
    virtual void ReadDynamicObjectsBelongingToLayer (
        Serializer &serializer,
        ObjectLayer *object_layer,
        CreateEntityFunction CreateEntity);

    typedef std::list<WorldView *> WorldViewList;

    // list of WorldViews
    WorldViewList m_world_view_list;
    // the physics handler for this world
    PhysicsHandler *const m_physics_handler;
    // list of ObjectLayers, starting at the back-most layer
    ObjectLayerList m_object_layer_list;
    // the "main" object layer
    ObjectLayer *m_main_object_layer;
    // controls how fast world time moves compared to real time
    Float m_timescale;

private:

    void WriteObjectLayers (Serializer &serializer) const;
    void WriteDynamicObjectsBelongingToLayer (
        Serializer &serializer,
        ObjectLayer const *object_layer) const;

    typedef std::vector<Entity *> EntityVector;

    // array of dynamic objects (Object with attached Entity)
    EntityVector m_entity_vector;
    // lowest available entity number
    EntityWorldIndex m_lowest_available_entity_index;
    // number of entities in this World
    Uint32 m_entity_count;
    // the world's own private event queue
    EventQueue m_owner_event_queue;
}; // end of class Engine2::World

} // end of namespace Engine2

} // end of namespace Xrb

#endif // !defined(_XRB_ENGINE2_WORLD_HPP_)

---