---

world_template.h

Go to the documentation of this file.

/*
        $Id: world_template.h,v 1.10 2001/03/20 13:22:20 mbn Exp $

        ------------------------------------------------------------------------
        ClanLib, the platform independent game SDK.

        This library is distributed under the GNU LIBRARY GENERAL PUBLIC LICENSE
        version 2. See COPYING for details.

        For a total list of contributers see CREDITS.

        ------------------------------------------------------------------------
*/

#ifndef header_world_template
#define header_world_template


#include "../Core/System/cl_assert.h"
#include "netobject_channel.h"
#include "netobject.h"

template<class World>
class CL_GameObject
//: Game object template.
{
// Predefined message types:
public:
        enum EGameObjectMessageTypes
        {
                msgtype_full_update = 0,
                msgtype_tick_update = 1,
                msgtype_destroy     = 2,
                msgtype_user        = 1000 // reserve first 1000 entries for clanlib.
        };

public:
        // server constructor.
        CL_GameObject(World *world, int object_type)
        : world(world), object_type(object_type), netobject(object_type, &world->get_netobject_channel())
        {
                common_init();
        }

        // client construtor.
        CL_GameObject(World *world, int object_type, const CL_NetObject &netobject)
        : world(world), object_type(object_type), netobject(netobject)
        {
                common_init();
        }

        virtual ~CL_GameObject() { return; }

public:
        World *get_world() { return world; }

        bool get_destroy_flag() { return destroy_flag; }

        CL_NetObject &get_netobject() { return netobject; }

        int get_object_type() { return object_type; }

public:
        void set_destroy_flag(bool new_value = true) { destroy_flag = new_value; }

        void set_tick_rate(float time_per_tick) { tick_rate = time_per_tick; }

        void send_full(const CL_NetComputer *dest = NULL)
        {
                CL_OutputSource_Memory output;
                output.write_int32(object_type);
                write_full_update(output);
                netobject.send(/*dest,*/ msgtype_full_update, output.get_data());
        }

        void send_tick(const CL_NetComputer *dest = NULL)
        {
                CL_OutputSource_Memory output;
                write_tick_update(output);
                netobject.send(/*dest,*/ msgtype_tick_update, output.get_data());
        }

        void send_destroy(const CL_NetComputer *dest = NULL)
        {
                CL_OutputSource_Memory output;
                write_destroy(output);
                netobject.send(/*dest,*/ msgtype_destroy, output.get_data());
        }

        void recv_full(CL_InputSource &message)
        {
                int type = message.read_int32();
                cl_assert(type == object_type);
                read_full_update(message);
        }

        void recv_tick(CL_InputSource &message)
        {
                read_tick_update(message);
        }

        void recv_destroy(CL_InputSource &message)
        {
                read_destroy(message);
        }

public:
        virtual void update(int time_elapsed)
        {
                if (tick_rate > 0.0f)
                {
                        tick_time += time_elapsed;

                        while (tick_time >= tick_rate)
                        {
                                tick_time -= tick_rate;
                                send_tick();
                        }
                }
        }

        virtual void read_full_update(CL_InputSource &message) { return; }

        virtual void read_tick_update(CL_InputSource &message) { return; }

        virtual void read_destroy(CL_InputSource &message) { set_destroy_flag(); }

        virtual void write_full_update(CL_OutputSource &message) { return; }

        virtual void write_tick_update(CL_OutputSource &message) { return; }

        virtual void write_destroy(CL_InputSource &message) { return; }

public:
        void common_init()
        {
                destroy_flag = false;
                tick_rate = 0.0f; // disable tick updates per default.
                tick_time = 0.0f;

                slot_full = netobject.connect(
                        msgtype_full_update,
                        CL_CreateSlot(this, &CL_GameObject<World>::recv_full));

                slot_tick = netobject.connect(
                        msgtype_tick_update,
                        CL_CreateSlot(this, &CL_GameObject<World>::recv_tick));

                slot_destroy = netobject.connect(
                        msgtype_destroy,
                        CL_CreateSlot(this, &CL_GameObject<World>::recv_destroy));
        }

        World *world;
        int object_type;
        bool destroy_flag;
        CL_NetObject netobject;
        float tick_rate;
        float tick_time;

        CL_Slot slot_full;
        CL_Slot slot_tick;
        CL_Slot slot_destroy;
};

template<class GameObject>
class CL_World
//: World template.
{
public:
        CL_World(CL_NetSession *session, int object_netchannel)
        :
                session(session),
                netobject_channel(session, object_netchannel),
                last_time(CL_System::get_time()),
                max_tick_elapsed(0.05f)
        {
                slot_create_object = netobject_channel.sig_create_object().connect(
                        CL_CreateSlot(this, &CL_World<GameObject>::sig_create_object));
        }

        virtual ~CL_World()
        {
        }

public:
        CL_NetObjectChannel &get_netobject_channel() { return netobject_channel; }

        CL_NetSession *get_session() { return session; }

        std::list<GameObject *> &get_objects() { return objects; }

public:
        void set_max_tick_elapsed(float time) { max_tick_elapsed = time; }

        void add_object(GameObject *object) { objects.push_back(object); }

        void remove_object(GameObject *object) { objects.remove(object); }

        void update()
        {
                float delta_time = (CL_System::get_time() - last_time);
                last_time = CL_System::get_time();

                for (; delta_time > 0; delta_time -= max_tick_elapsed)
                {
                        float elapsed = (delta_time > max_tick_elapsed) ? max_tick_elapsed : delta_time;

                        std::list<GameObject *>::iterator it;
                        std::list<GameObject *> remove_list;
                        for (it = objects.begin(); it != objects.end(); it++)
                        {
                                (*it)->update(delta_time);
                                if ((*it)->get_destroy_flag()) remove_list.push_back(*it);
                        }
                                
                        for (it = remove_list.begin(); it != remove_list.end(); it++)
                        {
                                delete *it;
                        }
                }
        }

protected:
        virtual void on_create_object(
                const CL_NetObject &netobj,
                int msgType,
                const std::string &message) { return; }

private:
        void sig_create_object(
                const CL_NetObject &netobj,
                int msgType,
                const std::string &message)
        {
                // this function is needed because I'm not sure how to connect a signal to a virtual
                // table function.
                on_create_object(netobj, msgType, message);
        }

        std::list<GameObject *> objects;
        CL_NetSession *session;
        CL_NetObjectChannel netobject_channel;
        float max_tick_elapsed;
        unsigned long last_time;
        CL_Slot slot_create_object;
};

#endif

---