diff options
Diffstat (limited to 'src/serverobject.h')
| -rw-r--r-- | src/serverobject.h | 215 |
1 files changed, 157 insertions, 58 deletions
diff --git a/src/serverobject.h b/src/serverobject.h index 557d9b618..955969819 100644 --- a/src/serverobject.h +++ b/src/serverobject.h @@ -32,40 +32,54 @@ Some planning * Server environment adds an active object, which gets the id 1 * The active object list is scanned for each client once in a while, and it finds out what objects have been added that are not known - by the client yet. This scan is initiated by the server and the - result ends up directly to the server. + by the client yet. This scan is initiated by the Server class and + the result ends up directly to the server. * A network packet is created with the info and sent to the client. +* Environment converts objects to static data and static data to + objects, based on how close players are to them. */ class ServerEnvironment; +class InventoryItem; class ServerActiveObject : public ActiveObject { public: - ServerActiveObject(ServerEnvironment *env, u16 id, v3f pos=v3f(0,0,0)); + /* + NOTE: m_env can be NULL, but step() isn't called if it is. + Prototypes are used that way. + */ + ServerActiveObject(ServerEnvironment *env, u16 id, v3f pos); virtual ~ServerActiveObject(); - v3f getBasePosition() - { - return m_base_position; - } + // Create a certain type of ServerActiveObject + static ServerActiveObject* create(u8 type, + ServerEnvironment *env, u16 id, v3f pos, + const std::string &data); + /* + Some simple getters/setters + */ + v3f getBasePosition() + {return m_base_position;} void setBasePosition(v3f pos) - { - m_base_position = pos; - } - + {m_base_position = pos;} ServerEnvironment* getEnv() - { - return m_env; - } + {return m_env;} /* Step object in time. Messages added to messages are sent to client over network. + + send_recommended: + True at around 5-10 times a second, same for all objects. + This is used to let objects send most of the data at the + same time so that the data can be combined in a single + packet. */ - virtual void step(float dtime, Queue<ActiveObjectMessage> &messages){} + virtual void step(float dtime, Queue<ActiveObjectMessage> &messages, + bool send_recommended){} /* The return value of this is passed to the client-side object @@ -75,28 +89,74 @@ public: /* The return value of this is passed to the server-side object - when it is loaded from disk or from a static object + when it is created (converted from static to active - actually + the data is the static form) + */ + virtual std::string getStaticData(){return "";} + + /* + Item that the player gets when this object is picked up. + If NULL, object cannot be picked up. */ - virtual std::string getServerInitializationData(){return "";} + virtual InventoryItem* createPickedUpItem(){return NULL;} /* - This takes the return value of getServerInitializationData + If the object doesn't return an item, this will be called. + Return value is tool wear. */ - virtual void initialize(const std::string &data){} + virtual u16 punch(const std::string &toolname){return 0;} - // Number of players which know about this object + /* + Number of players which know about this object. Object won't be + deleted until this is 0 to keep the id preserved for the right + object. + */ u16 m_known_by_count; + /* - Whether this object is to be removed when nobody knows about - it anymore. - Removal is delayed to preserve the id for the time during which - it could be confused to some other object by some client. + - Whether this object is to be removed when nobody knows about + it anymore. + - Removal is delayed to preserve the id for the time during which + it could be confused to some other object by some client. + - This is set to true by the step() method when the object wants + to be deleted. + - This can be set to true by anything else too. */ bool m_removed; + /* + This is set to true when a block should be removed from the active + object list but couldn't be removed because the id has to be + reserved for some client. + + The environment checks this periodically. If this is true and also + m_known_by_count is true, + */ + bool m_pending_deactivation; + + /* + Whether the object's static data has been stored to a block + */ + bool m_static_exists; + /* + The block from which the object was loaded from, and in which + a copy of the static data resides. + */ + v3s16 m_static_block; + protected: + // Used for creating objects based on type + typedef ServerActiveObject* (*Factory) + (ServerEnvironment *env, u16 id, v3f pos, + const std::string &data); + static void registerType(u16 type, Factory f); + ServerEnvironment *m_env; v3f m_base_position; + +private: + // Used for creating objects based on type + static core::map<u16, Factory> m_types; }; class TestSAO : public ServerActiveObject @@ -104,51 +164,90 @@ class TestSAO : public ServerActiveObject public: TestSAO(ServerEnvironment *env, u16 id, v3f pos); u8 getType() const - { - return ACTIVEOBJECT_TYPE_TEST; - } - void step(float dtime, Queue<ActiveObjectMessage> &messages); + {return ACTIVEOBJECT_TYPE_TEST;} + static ServerActiveObject* create(ServerEnvironment *env, u16 id, v3f pos, + const std::string &data); + void step(float dtime, Queue<ActiveObjectMessage> &messages, + bool send_recommended); private: float m_timer1; float m_age; }; -extern "C"{ -#include "lua.h" -#include "lualib.h" -#include "lauxlib.h" -} - -class LuaSAO : public ServerActiveObject +class ItemSAO : public ServerActiveObject { public: - LuaSAO(ServerEnvironment *env, u16 id, v3f pos); - virtual ~LuaSAO(); - + ItemSAO(ServerEnvironment *env, u16 id, v3f pos, + const std::string inventorystring); u8 getType() const - { - return ACTIVEOBJECT_TYPE_LUA; - } - - virtual std::string getClientInitializationData(); - virtual std::string getServerInitializationData(); - - void initializeFromNothing(const std::string &script_name); - void initializeFromSave(const std::string &data); - - void loadScripts(const std::string &script_name); - - void step(float dtime, Queue<ActiveObjectMessage> &messages); + {return ACTIVEOBJECT_TYPE_ITEM;} + static ServerActiveObject* create(ServerEnvironment *env, u16 id, v3f pos, + const std::string &data); + void step(float dtime, Queue<ActiveObjectMessage> &messages, + bool send_recommended); + std::string getClientInitializationData(); + std::string getStaticData(); + InventoryItem* createInventoryItem(); + InventoryItem* createPickedUpItem(){return createInventoryItem();} +private: + std::string m_inventorystring; + v3f m_speed_f; + v3f m_last_sent_position; + IntervalLimiter m_move_interval; +}; - /* - Stuff available for usage for the lua callbacks - */ - // This is moved onwards at the end of step() - Queue<ActiveObjectMessage> m_message_queue; +class RatSAO : public ServerActiveObject +{ +public: + RatSAO(ServerEnvironment *env, u16 id, v3f pos); + u8 getType() const + {return ACTIVEOBJECT_TYPE_RAT;} + static ServerActiveObject* create(ServerEnvironment *env, u16 id, v3f pos, + const std::string &data); + void step(float dtime, Queue<ActiveObjectMessage> &messages, + bool send_recommended); + std::string getClientInitializationData(); + std::string getStaticData(); + InventoryItem* createPickedUpItem(); +private: + bool m_is_active; + IntervalLimiter m_inactive_interval; + v3f m_speed_f; + v3f m_oldpos; + v3f m_last_sent_position; + float m_yaw; + float m_counter1; + float m_counter2; + float m_age; + bool m_touching_ground; +}; +class Oerkki1SAO : public ServerActiveObject +{ +public: + Oerkki1SAO(ServerEnvironment *env, u16 id, v3f pos); + u8 getType() const + {return ACTIVEOBJECT_TYPE_OERKKI1;} + static ServerActiveObject* create(ServerEnvironment *env, u16 id, v3f pos, + const std::string &data); + void step(float dtime, Queue<ActiveObjectMessage> &messages, + bool send_recommended); + std::string getClientInitializationData(); + std::string getStaticData(); + InventoryItem* createPickedUpItem(){return NULL;} + u16 punch(const std::string &toolname); private: - lua_State* L; - std::string m_script_name; + bool m_is_active; + IntervalLimiter m_inactive_interval; + v3f m_speed_f; + v3f m_oldpos; + v3f m_last_sent_position; + float m_yaw; + float m_counter1; + float m_counter2; + float m_age; + bool m_touching_ground; + u8 m_hp; }; #endif |