#ifndef SERVEROBJECT_HEADER
#define SERVEROBJECT_HEADER
-#include "common_irrlicht.h"
+#include "irrlichttypes.h"
#include "activeobject.h"
#include "utility.h"
class ServerEnvironment;
class InventoryItem;
class Player;
+struct ToolDiggingProperties;
class ServerActiveObject : public ActiveObject
{
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);
+ ServerActiveObject(ServerEnvironment *env, v3f pos);
virtual ~ServerActiveObject();
+ // Called after id has been set and has been inserted in environment
+ virtual void addedToEnvironment(){};
+ // Called before removing from environment
+ virtual void removingFromEnvironment(){};
+ // Returns true if object's deletion is the job of the
+ // environment
+ virtual bool environmentDeletes() const
+ { return true; }
+
// Create a certain type of ServerActiveObject
static ServerActiveObject* create(u8 type,
ServerEnvironment *env, u16 id, v3f pos,
/*
Some simple getters/setters
*/
- v3f getBasePosition()
- {return m_base_position;}
- void setBasePosition(v3f pos)
- {m_base_position = pos;}
- ServerEnvironment* getEnv()
- {return m_env;}
+ v3f getBasePosition(){ return m_base_position; }
+ void setBasePosition(v3f pos){ m_base_position = pos; }
+ ServerEnvironment* getEnv(){ return m_env; }
+
+ /*
+ Some more dynamic interface
+ */
+
+ virtual void setPos(v3f pos)
+ { setBasePosition(pos); }
+ // continuous: if true, object does not stop immediately at pos
+ virtual void moveTo(v3f pos, bool continuous)
+ { setBasePosition(pos); }
+ // If object has moved less than this and data has not changed,
+ // saving to disk may be omitted
+ virtual float getMinimumSavedMovement()
+ { return 2.0*BS; }
+
+ virtual bool isPeaceful(){return true;}
+
+ virtual std::string getDescription(){return "SAO";}
/*
Step object in time.
when it is created (converted from static to active - actually
the data is the static form)
*/
- virtual std::string getStaticData(){return "";}
-
+ virtual std::string getStaticData()
+ {
+ assert(isStaticAllowed());
+ return "";
+ }
/*
- Item that the player gets when this object is picked up.
- If NULL, object cannot be picked up.
+ Return false in here to never save and instead remove object
+ on unload. getStaticData() will not be called in that case.
*/
- virtual InventoryItem* createPickedUpItem(){return NULL;}
+ virtual bool isStaticAllowed() const
+ {return true;}
- /*
- If the object doesn't return an item, this will be called.
- Return value is tool wear.
- */
- virtual u16 punch(const std::string &toolname, v3f dir)
- {return 0;}
+ // time_from_last_punch is used for lessening damage if punching fast
+ virtual void punch(ServerActiveObject *puncher,
+ float time_from_last_punch=1000000)
+ {}
+ virtual void rightClick(ServerActiveObject *clicker)
+ {}
+ virtual void getWieldDiggingProperties(ToolDiggingProperties *dst);
+ virtual void damageWieldedItem(u16 amount)
+ {}
+ // If all fits, eats item and returns true. Otherwise returns false.
+ virtual bool addToInventory(InventoryItem *item)
+ { return false; }
+ virtual void addToInventoryLater(InventoryItem *item)
+ {}
+ virtual void setHP(s16 hp)
+ {}
+ virtual s16 getHP()
+ { return 0; }
- /*
- */
- virtual void rightClick(Player *player){}
-
/*
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
bool m_removed;
/*
- This is set to true when a block should be removed from the active
+ This is set to true when an object 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,
+ m_known_by_count is true, object is deleted from the active object
+ list.
*/
bool m_pending_deactivation;
protected:
// Used for creating objects based on type
typedef ServerActiveObject* (*Factory)
- (ServerEnvironment *env, u16 id, v3f pos,
+ (ServerEnvironment *env, v3f pos,
const std::string &data);
static void registerType(u16 type, Factory f);