Line data Source code
1 : /*
2 : Minetest
3 : Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
4 :
5 : This program is free software; you can redistribute it and/or modify
6 : it under the terms of the GNU Lesser General Public License as published by
7 : the Free Software Foundation; either version 2.1 of the License, or
8 : (at your option) any later version.
9 :
10 : This program is distributed in the hope that it will be useful,
11 : but WITHOUT ANY WARRANTY; without even the implied warranty of
12 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 : GNU Lesser General Public License for more details.
14 :
15 : You should have received a copy of the GNU Lesser General Public License along
16 : with this program; if not, write to the Free Software Foundation, Inc.,
17 : 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 : */
19 :
20 : #ifndef SERVEROBJECT_HEADER
21 : #define SERVEROBJECT_HEADER
22 :
23 : #include "irrlichttypes_bloated.h"
24 : #include "activeobject.h"
25 : #include "inventorymanager.h"
26 : #include "itemgroup.h"
27 : #include "util/container.h"
28 :
29 : /*
30 :
31 : Some planning
32 : -------------
33 :
34 : * Server environment adds an active object, which gets the id 1
35 : * The active object list is scanned for each client once in a while,
36 : and it finds out what objects have been added that are not known
37 : by the client yet. This scan is initiated by the Server class and
38 : the result ends up directly to the server.
39 : * A network packet is created with the info and sent to the client.
40 : * Environment converts objects to static data and static data to
41 : objects, based on how close players are to them.
42 :
43 : */
44 :
45 : class ServerEnvironment;
46 : struct ItemStack;
47 : class Player;
48 : struct ToolCapabilities;
49 : struct ObjectProperties;
50 :
51 : class ServerActiveObject : public ActiveObject
52 : {
53 : public:
54 : /*
55 : NOTE: m_env can be NULL, but step() isn't called if it is.
56 : Prototypes are used that way.
57 : */
58 : ServerActiveObject(ServerEnvironment *env, v3f pos);
59 : virtual ~ServerActiveObject();
60 :
61 0 : virtual ActiveObjectType getSendType() const
62 0 : { return getType(); }
63 :
64 : // Called after id has been set and has been inserted in environment
65 0 : virtual void addedToEnvironment(u32 dtime_s){};
66 : // Called before removing from environment
67 0 : virtual void removingFromEnvironment(){};
68 : // Returns true if object's deletion is the job of the
69 : // environment
70 0 : virtual bool environmentDeletes() const
71 0 : { return true; }
72 :
73 : // Create a certain type of ServerActiveObject
74 : static ServerActiveObject* create(ActiveObjectType type,
75 : ServerEnvironment *env, u16 id, v3f pos,
76 : const std::string &data);
77 :
78 : /*
79 : Some simple getters/setters
80 : */
81 0 : v3f getBasePosition(){ return m_base_position; }
82 0 : void setBasePosition(v3f pos){ m_base_position = pos; }
83 0 : ServerEnvironment* getEnv(){ return m_env; }
84 :
85 : /*
86 : Some more dynamic interface
87 : */
88 :
89 0 : virtual void setPos(v3f pos)
90 0 : { setBasePosition(pos); }
91 : // continuous: if true, object does not stop immediately at pos
92 0 : virtual void moveTo(v3f pos, bool continuous)
93 0 : { setBasePosition(pos); }
94 : // If object has moved less than this and data has not changed,
95 : // saving to disk may be omitted
96 : virtual float getMinimumSavedMovement();
97 :
98 0 : virtual std::string getDescription(){return "SAO";}
99 :
100 : /*
101 : Step object in time.
102 : Messages added to messages are sent to client over network.
103 :
104 : send_recommended:
105 : True at around 5-10 times a second, same for all objects.
106 : This is used to let objects send most of the data at the
107 : same time so that the data can be combined in a single
108 : packet.
109 : */
110 0 : virtual void step(float dtime, bool send_recommended){}
111 :
112 : /*
113 : The return value of this is passed to the client-side object
114 : when it is created
115 : */
116 0 : virtual std::string getClientInitializationData(u16 protocol_version){return "";}
117 :
118 : /*
119 : The return value of this is passed to the server-side object
120 : when it is created (converted from static to active - actually
121 : the data is the static form)
122 : */
123 0 : virtual std::string getStaticData()
124 : {
125 : assert(isStaticAllowed());
126 0 : return "";
127 : }
128 : /*
129 : Return false in here to never save and instead remove object
130 : on unload. getStaticData() will not be called in that case.
131 : */
132 0 : virtual bool isStaticAllowed() const
133 0 : {return true;}
134 :
135 : // Returns tool wear
136 0 : virtual int punch(v3f dir,
137 : const ToolCapabilities *toolcap=NULL,
138 : ServerActiveObject *puncher=NULL,
139 : float time_from_last_punch=1000000)
140 0 : { return 0; }
141 0 : virtual void rightClick(ServerActiveObject *clicker)
142 0 : {}
143 0 : virtual void setHP(s16 hp)
144 0 : {}
145 0 : virtual s16 getHP() const
146 0 : { return 0; }
147 :
148 0 : virtual void setArmorGroups(const ItemGroupList &armor_groups)
149 0 : {}
150 0 : virtual ItemGroupList getArmorGroups()
151 0 : { return ItemGroupList(); }
152 0 : virtual void setPhysicsOverride(float physics_override_speed, float physics_override_jump, float physics_override_gravity)
153 0 : {}
154 0 : virtual void setAnimation(v2f frames, float frame_speed, float frame_blend, bool frame_loop)
155 0 : {}
156 0 : virtual void getAnimation(v2f *frames, float *frame_speed, float *frame_blend, bool *frame_loop)
157 0 : {}
158 0 : virtual void setBonePosition(const std::string &bone, v3f position, v3f rotation)
159 0 : {}
160 0 : virtual void getBonePosition(const std::string &bone, v3f *position, v3f *lotation)
161 0 : {}
162 0 : virtual void setAttachment(int parent_id, const std::string &bone, v3f position, v3f rotation)
163 0 : {}
164 0 : virtual void getAttachment(int *parent_id, std::string *bone, v3f *position, v3f *rotation)
165 0 : {}
166 0 : virtual ObjectProperties* accessObjectProperties()
167 0 : { return NULL; }
168 0 : virtual void notifyObjectPropertiesModified()
169 0 : {}
170 :
171 : // Inventory and wielded item
172 0 : virtual Inventory* getInventory()
173 0 : { return NULL; }
174 0 : virtual const Inventory* getInventory() const
175 0 : { return NULL; }
176 0 : virtual InventoryLocation getInventoryLocation() const
177 0 : { return InventoryLocation(); }
178 0 : virtual void setInventoryModified()
179 0 : {}
180 0 : virtual std::string getWieldList() const
181 0 : { return ""; }
182 0 : virtual int getWieldIndex() const
183 0 : { return 0; }
184 : virtual ItemStack getWieldedItem() const;
185 : virtual bool setWieldedItem(const ItemStack &item);
186 :
187 : /*
188 : Number of players which know about this object. Object won't be
189 : deleted until this is 0 to keep the id preserved for the right
190 : object.
191 : */
192 : u16 m_known_by_count;
193 :
194 : /*
195 : - Whether this object is to be removed when nobody knows about
196 : it anymore.
197 : - Removal is delayed to preserve the id for the time during which
198 : it could be confused to some other object by some client.
199 : - This is set to true by the step() method when the object wants
200 : to be deleted.
201 : - This can be set to true by anything else too.
202 : */
203 : bool m_removed;
204 :
205 : /*
206 : This is set to true when an object should be removed from the active
207 : object list but couldn't be removed because the id has to be
208 : reserved for some client.
209 :
210 : The environment checks this periodically. If this is true and also
211 : m_known_by_count is true, object is deleted from the active object
212 : list.
213 : */
214 : bool m_pending_deactivation;
215 :
216 : /*
217 : Whether the object's static data has been stored to a block
218 : */
219 : bool m_static_exists;
220 : /*
221 : The block from which the object was loaded from, and in which
222 : a copy of the static data resides.
223 : */
224 : v3s16 m_static_block;
225 :
226 : /*
227 : Queue of messages to be sent to the client
228 : */
229 : std::queue<ActiveObjectMessage> m_messages_out;
230 :
231 : protected:
232 : // Used for creating objects based on type
233 : typedef ServerActiveObject* (*Factory)
234 : (ServerEnvironment *env, v3f pos,
235 : const std::string &data);
236 : static void registerType(u16 type, Factory f);
237 :
238 : ServerEnvironment *m_env;
239 : v3f m_base_position;
240 :
241 : private:
242 : // Used for creating objects based on type
243 : static std::map<u16, Factory> m_types;
244 : };
245 :
246 : #endif
247 :
|
