src/serverobject.h

   1 /*
   2 Minetest-c55
   3 Copyright (C) 2010-2011 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 General Public License as published by
   7 the Free Software Foundation; either version 2 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 General Public License for more details.
  14
  15 You should have received a copy of the GNU 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 "common_irrlicht.h"
  24 #include "activeobject.h"
  25 #include "utility.h"
  26
  27 /*
  28
  29 Some planning
  30 -------------
  31
  32 * Server environment adds an active object, which gets the id 1
  33 * The active object list is scanned for each client once in a while,
  34   and it finds out what objects have been added that are not known
  35   by the client yet. This scan is initiated by the Server class and
  36   the result ends up directly to the server.
  37 * A network packet is created with the info and sent to the client.
  38 * Environment converts objects to static data and static data to
  39   objects, based on how close players are to them.
  40
  41 */
  42
  43 class ServerEnvironment;
  44 class InventoryItem;
  45
  46 class ServerActiveObject : public ActiveObject
  47 {
  48 public:
  49         /*
  50                 NOTE: m_env can be NULL, but step() isn't called if it is.
  51                 Prototypes are used that way.
  52         */
  53         ServerActiveObject(ServerEnvironment *env, u16 id, v3f pos);
  54         virtual ~ServerActiveObject();
  55
  56         // Create a certain type of ServerActiveObject
  57         static ServerActiveObject* create(u8 type,
  58                         ServerEnvironment *env, u16 id, v3f pos,
  59                         const std::string &data);
  60
  61         /*
  62                 Some simple getters/setters
  63         */
  64         v3f getBasePosition()
  65                 {return m_base_position;}
  66         void setBasePosition(v3f pos)
  67                 {m_base_position = pos;}
  68         ServerEnvironment* getEnv()
  69                 {return m_env;}
  70
  71         /*
  72                 Step object in time.
  73                 Messages added to messages are sent to client over network.
  74
  75                 send_recommended:
  76                         True at around 5-10 times a second, same for all objects.
  77                         This is used to let objects send most of the data at the
  78                         same time so that the data can be combined in a single
  79                         packet.
  80         */
  81         virtual void step(float dtime, Queue<ActiveObjectMessage> &messages,
  82                         bool send_recommended){}
  83
  84         /*
  85                 The return value of this is passed to the client-side object
  86                 when it is created
  87         */
  88         virtual std::string getClientInitializationData(){return "";}
  89
  90         /*
  91                 The return value of this is passed to the server-side object
  92                 when it is created (converted from static to active - actually
  93                 the data is the static form)
  94         */
  95         virtual std::string getStaticData(){return "";}
  96
  97         /*
  98                 Item that the player gets when this object is picked up.
  99                 If NULL, object cannot be picked up.
 100         */
 101         virtual InventoryItem* createPickedUpItem(){return NULL;}
 102
 103         /*
 104                 If the object doesn't return an item, this will be called.
 105                 Return value is tool wear.
 106         */
 107         virtual u16 punch(const std::string &toolname){return 0;}
 108
 109         // Number of players which know about this object
 110         u16 m_known_by_count;
 111         /*
 112                 - Whether this object is to be removed when nobody knows about
 113                   it anymore.
 114                 - Removal is delayed to preserve the id for the time during which
 115                   it could be confused to some other object by some client.
 116                 - This is set to true by the step() method when the object wants
 117                   to be deleted.
 118                 - This can be set to true by anything else too.
 119         */
 120         bool m_removed;
 121
 122         /*
 123                 Whether the object's static data has been stored to a block
 124         */
 125         bool m_static_exists;
 126         /*
 127                 The block from which the object was loaded from, and in which
 128                 a copy of the static data resides.
 129         */
 130         v3s16 m_static_block;
 131
 132 protected:
 133         // Used for creating objects based on type
 134         typedef ServerActiveObject* (*Factory)
 135                         (ServerEnvironment *env, u16 id, v3f pos,
 136                         const std::string &data);
 137         static void registerType(u16 type, Factory f);
 138
 139         ServerEnvironment *m_env;
 140         v3f m_base_position;
 141
 142 private:
 143         // Used for creating objects based on type
 144         static core::map<u16, Factory> m_types;
 145 };
 146
 147 class TestSAO : public ServerActiveObject
 148 {
 149 public:
 150         TestSAO(ServerEnvironment *env, u16 id, v3f pos);
 151         u8 getType() const
 152                 {return ACTIVEOBJECT_TYPE_TEST;}
 153         static ServerActiveObject* create(ServerEnvironment *env, u16 id, v3f pos,
 154                         const std::string &data);
 155         void step(float dtime, Queue<ActiveObjectMessage> &messages,
 156                         bool send_recommended);
 157 private:
 158         float m_timer1;
 159         float m_age;
 160 };
 161
 162 class ItemSAO : public ServerActiveObject
 163 {
 164 public:
 165         ItemSAO(ServerEnvironment *env, u16 id, v3f pos,
 166                         const std::string inventorystring);
 167         u8 getType() const
 168                 {return ACTIVEOBJECT_TYPE_ITEM;}
 169         static ServerActiveObject* create(ServerEnvironment *env, u16 id, v3f pos,
 170                         const std::string &data);
 171         void step(float dtime, Queue<ActiveObjectMessage> &messages,
 172                         bool send_recommended);
 173         std::string getClientInitializationData();
 174         std::string getStaticData();
 175         InventoryItem* createInventoryItem();
 176         InventoryItem* createPickedUpItem(){return createInventoryItem();}
 177 private:
 178         std::string m_inventorystring;
 179         v3f m_speed_f;
 180         v3f m_last_sent_position;
 181         IntervalLimiter m_move_interval;
 182 };
 183
 184 class RatSAO : public ServerActiveObject
 185 {
 186 public:
 187         RatSAO(ServerEnvironment *env, u16 id, v3f pos);
 188         u8 getType() const
 189                 {return ACTIVEOBJECT_TYPE_RAT;}
 190         static ServerActiveObject* create(ServerEnvironment *env, u16 id, v3f pos,
 191                         const std::string &data);
 192         void step(float dtime, Queue<ActiveObjectMessage> &messages,
 193                         bool send_recommended);
 194         std::string getClientInitializationData();
 195         std::string getStaticData();
 196         InventoryItem* createPickedUpItem();
 197 private:
 198         bool m_is_active;
 199         IntervalLimiter m_inactive_interval;
 200         v3f m_speed_f;
 201         v3f m_oldpos;
 202         v3f m_last_sent_position;
 203         float m_yaw;
 204         float m_counter1;
 205         float m_counter2;
 206         float m_age;
 207         bool m_touching_ground;
 208 };
 209
 210 class Oerkki1SAO : public ServerActiveObject
 211 {
 212 public:
 213         Oerkki1SAO(ServerEnvironment *env, u16 id, v3f pos);
 214         u8 getType() const
 215                 {return ACTIVEOBJECT_TYPE_OERKKI1;}
 216         static ServerActiveObject* create(ServerEnvironment *env, u16 id, v3f pos,
 217                         const std::string &data);
 218         void step(float dtime, Queue<ActiveObjectMessage> &messages,
 219                         bool send_recommended);
 220         std::string getClientInitializationData();
 221         std::string getStaticData();
 222         InventoryItem* createPickedUpItem(){return NULL;}
 223         u16 punch(const std::string &toolname);
 224 private:
 225         bool m_is_active;
 226         IntervalLimiter m_inactive_interval;
 227         v3f m_speed_f;
 228         v3f m_oldpos;
 229         v3f m_last_sent_position;
 230         float m_yaw;
 231         float m_counter1;
 232         float m_counter2;
 233         float m_age;
 234         bool m_touching_ground;
 235         u8 m_hp;
 236 };
 237
 238 #endif
 239