X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fcontent_sao.cpp;h=5b0dc3eb4739649f53b987f540f5fb5919e6ea65;hb=18350ad37fbfb7027f2ab82ead5be58c1435cdf0;hp=0b81855c16aec55f0c9fffaa685e9ed411ba86ca;hpb=2587bb361cfc96b3a695d1476e39b9c0ecaa6553;p=minetest.git

diff --git a/src/content_sao.cpp b/src/content_sao.cpp
index 0b81855c1..5b0dc3eb4 100644
--- a/src/content_sao.cpp
+++ b/src/content_sao.cpp
@@ -20,852 +20,1107 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "content_sao.h"
 #include "collision.h"
 #include "environment.h"
+#include "settings.h"
+#include "main.h" // For g_profiler
+#include "profiler.h"
+#include "serialization.h" // For compressZlib
+#include "tool.h" // For ToolCapabilities
+#include "gamedef.h"
+#include "player.h"
+#include "scriptapi.h"
+#include "genericobject.h"
 
 core::map<u16, ServerActiveObject::Factory> ServerActiveObject::m_types;
 
 /*
-	TestSAO
+	DummyLoadSAO
 */
 
-// Prototype
-TestSAO proto_TestSAO(NULL, 0, v3f(0,0,0));
-
-TestSAO::TestSAO(ServerEnvironment *env, u16 id, v3f pos):
-	ServerActiveObject(env, id, pos),
-	m_timer1(0),
-	m_age(0)
+class DummyLoadSAO : public ServerActiveObject
 {
-	ServerActiveObject::registerType(getType(), create);
-}
+public:
+	DummyLoadSAO(ServerEnvironment *env, v3f pos, u8 type):
+		ServerActiveObject(env, pos)
+	{
+		ServerActiveObject::registerType(type, create);
+	}
+	// Pretend to be the test object (to fool the client)
+	u8 getType() const
+	{ return ACTIVEOBJECT_TYPE_TEST; }
+	// And never save to disk
+	bool isStaticAllowed() const
+	{ return false; }
+	
+	static ServerActiveObject* create(ServerEnvironment *env, v3f pos,
+			const std::string &data)
+	{
+		return new DummyLoadSAO(env, pos, 0);
+	}
 
-ServerActiveObject* TestSAO::create(ServerEnvironment *env, u16 id, v3f pos,
-		const std::string &data)
+	void step(float dtime, bool send_recommended)
+	{
+		m_removed = true;
+		infostream<<"DummyLoadSAO step"<<std::endl;
+	}
+
+private:
+};
+
+// Prototype (registers item for deserialization)
+DummyLoadSAO proto1_DummyLoadSAO(NULL, v3f(0,0,0), ACTIVEOBJECT_TYPE_RAT);
+DummyLoadSAO proto2_DummyLoadSAO(NULL, v3f(0,0,0), ACTIVEOBJECT_TYPE_OERKKI1);
+DummyLoadSAO proto3_DummyLoadSAO(NULL, v3f(0,0,0), ACTIVEOBJECT_TYPE_FIREFLY);
+DummyLoadSAO proto4_DummyLoadSAO(NULL, v3f(0,0,0), ACTIVEOBJECT_TYPE_MOBV2);
+
+/*
+	TestSAO
+*/
+
+class TestSAO : public ServerActiveObject
 {
-	return new TestSAO(env, id, pos);
-}
+public:
+	TestSAO(ServerEnvironment *env, v3f pos):
+		ServerActiveObject(env, pos),
+		m_timer1(0),
+		m_age(0)
+	{
+		ServerActiveObject::registerType(getType(), create);
+	}
+	u8 getType() const
+	{ return ACTIVEOBJECT_TYPE_TEST; }
+	
+	static ServerActiveObject* create(ServerEnvironment *env, v3f pos,
+			const std::string &data)
+	{
+		return new TestSAO(env, pos);
+	}
 
-void TestSAO::step(float dtime, bool send_recommended)
+	void step(float dtime, bool send_recommended)
+	{
+		m_age += dtime;
+		if(m_age > 10)
+		{
+			m_removed = true;
+			return;
+		}
+
+		m_base_position.Y += dtime * BS * 2;
+		if(m_base_position.Y > 8*BS)
+			m_base_position.Y = 2*BS;
+
+		if(send_recommended == false)
+			return;
+
+		m_timer1 -= dtime;
+		if(m_timer1 < 0.0)
+		{
+			m_timer1 += 0.125;
+
+			std::string data;
+
+			data += itos(0); // 0 = position
+			data += " ";
+			data += itos(m_base_position.X);
+			data += " ";
+			data += itos(m_base_position.Y);
+			data += " ";
+			data += itos(m_base_position.Z);
+
+			ActiveObjectMessage aom(getId(), false, data);
+			m_messages_out.push_back(aom);
+		}
+	}
+
+private:
+	float m_timer1;
+	float m_age;
+};
+
+// Prototype (registers item for deserialization)
+TestSAO proto_TestSAO(NULL, v3f(0,0,0));
+
+/*
+	ItemSAO
+*/
+
+class ItemSAO : public ServerActiveObject
 {
-	m_age += dtime;
-	if(m_age > 10)
+public:
+	u8 getType() const
+	{ return ACTIVEOBJECT_TYPE_ITEM; }
+	
+	float getMinimumSavedMovement()
+	{ return 0.1*BS; }
+
+	static ServerActiveObject* create(ServerEnvironment *env, v3f pos,
+			const std::string &data)
 	{
-		m_removed = true;
-		return;
+		std::istringstream is(data, std::ios::binary);
+		char buf[1];
+		// read version
+		is.read(buf, 1);
+		u8 version = buf[0];
+		// check if version is supported
+		if(version != 0)
+			return NULL;
+		std::string itemstring = deSerializeString(is);
+		infostream<<"create(): Creating item \""
+				<<itemstring<<"\""<<std::endl;
+		return new ItemSAO(env, pos, itemstring);
 	}
 
-	m_base_position.Y += dtime * BS * 2;
-	if(m_base_position.Y > 8*BS)
-		m_base_position.Y = 2*BS;
+	ItemSAO(ServerEnvironment *env, v3f pos,
+			const std::string itemstring):
+		ServerActiveObject(env, pos),
+		m_itemstring(itemstring),
+		m_itemstring_changed(false),
+		m_speed_f(0,0,0),
+		m_last_sent_position(0,0,0)
+	{
+		ServerActiveObject::registerType(getType(), create);
+	}
 
-	if(send_recommended == false)
-		return;
+	void step(float dtime, bool send_recommended)
+	{
+		ScopeProfiler sp2(g_profiler, "step avg", SPT_AVG);
+
+		assert(m_env);
+
+		const float interval = 0.2;
+		if(m_move_interval.step(dtime, interval)==false)
+			return;
+		dtime = interval;
+		
+		core::aabbox3d<f32> box(-BS/3.,0.0,-BS/3., BS/3.,BS*2./3.,BS/3.);
+		collisionMoveResult moveresult;
+		// Apply gravity
+		m_speed_f += v3f(0, -dtime*9.81*BS, 0);
+		// Maximum movement without glitches
+		f32 pos_max_d = BS*0.25;
+		// Limit speed
+		if(m_speed_f.getLength()*dtime > pos_max_d)
+			m_speed_f *= pos_max_d / (m_speed_f.getLength()*dtime);
+		v3f pos_f = getBasePosition();
+		v3f pos_f_old = pos_f;
+		IGameDef *gamedef = m_env->getGameDef();
+		moveresult = collisionMoveSimple(&m_env->getMap(), gamedef,
+				pos_max_d, box, dtime, pos_f, m_speed_f);
+		
+		if(send_recommended == false)
+			return;
 
-	m_timer1 -= dtime;
-	if(m_timer1 < 0.0)
+		if(pos_f.getDistanceFrom(m_last_sent_position) > 0.05*BS)
+		{
+			setBasePosition(pos_f);
+			m_last_sent_position = pos_f;
+
+			std::ostringstream os(std::ios::binary);
+			// command (0 = update position)
+			writeU8(os, 0);
+			// pos
+			writeV3F1000(os, m_base_position);
+			// create message and add to list
+			ActiveObjectMessage aom(getId(), false, os.str());
+			m_messages_out.push_back(aom);
+		}
+		if(m_itemstring_changed)
+		{
+			m_itemstring_changed = false;
+
+			std::ostringstream os(std::ios::binary);
+			// command (1 = update itemstring)
+			writeU8(os, 1);
+			// itemstring
+			os<<serializeString(m_itemstring);
+			// create message and add to list
+			ActiveObjectMessage aom(getId(), false, os.str());
+			m_messages_out.push_back(aom);
+		}
+	}
+
+	std::string getClientInitializationData()
 	{
-		m_timer1 += 0.125;
-		//dstream<<"TestSAO: id="<<getId()<<" sending data"<<std::endl;
+		std::ostringstream os(std::ios::binary);
+		// version
+		writeU8(os, 0);
+		// pos
+		writeV3F1000(os, m_base_position);
+		// itemstring
+		os<<serializeString(m_itemstring);
+		return os.str();
+	}
 
-		std::string data;
+	std::string getStaticData()
+	{
+		infostream<<__FUNCTION_NAME<<std::endl;
+		std::ostringstream os(std::ios::binary);
+		// version
+		writeU8(os, 0);
+		// itemstring
+		os<<serializeString(m_itemstring);
+		return os.str();
+	}
 
-		data += itos(0); // 0 = position
-		data += " ";
-		data += itos(m_base_position.X);
-		data += " ";
-		data += itos(m_base_position.Y);
-		data += " ";
-		data += itos(m_base_position.Z);
+	ItemStack createItemStack()
+	{
+		try{
+			IItemDefManager *idef = m_env->getGameDef()->idef();
+			ItemStack item;
+			item.deSerialize(m_itemstring, idef);
+			infostream<<__FUNCTION_NAME<<": m_itemstring=\""<<m_itemstring
+					<<"\" -> item=\""<<item.getItemString()<<"\""
+					<<std::endl;
+			return item;
+		}
+		catch(SerializationError &e)
+		{
+			infostream<<__FUNCTION_NAME<<": serialization error: "
+					<<"m_itemstring=\""<<m_itemstring<<"\""<<std::endl;
+			return ItemStack();
+		}
+	}
 
-		ActiveObjectMessage aom(getId(), false, data);
-		m_messages_out.push_back(aom);
+	int punch(v3f dir,
+			const ToolCapabilities *toolcap,
+			ServerActiveObject *puncher,
+			float time_from_last_punch)
+	{
+		// Directly delete item in creative mode
+		if(g_settings->getBool("creative_mode") == true)
+		{
+			m_removed = true;
+			return 0;
+		}
+		
+		// Take item into inventory
+		ItemStack item = createItemStack();
+		Inventory *inv = puncher->getInventory();
+		if(inv != NULL)
+		{
+			std::string wieldlist = puncher->getWieldList();
+			ItemStack leftover = inv->addItem(wieldlist, item);
+			puncher->setInventoryModified();
+			if(leftover.empty())
+			{
+				m_removed = true;
+			}
+			else
+			{
+				m_itemstring = leftover.getItemString();
+				m_itemstring_changed = true;
+			}
+		}
+		
+		return 0;
 	}
-}
 
 
+private:
+	std::string m_itemstring;
+	bool m_itemstring_changed;
+	v3f m_speed_f;
+	v3f m_last_sent_position;
+	IntervalLimiter m_move_interval;
+};
+
+// Prototype (registers item for deserialization)
+ItemSAO proto_ItemSAO(NULL, v3f(0,0,0), "");
+
+ServerActiveObject* createItemSAO(ServerEnvironment *env, v3f pos,
+		const std::string itemstring)
+{
+	return new ItemSAO(env, pos, itemstring);
+}
+
 /*
-	ItemSAO
+	LuaEntitySAO
 */
 
-// Prototype
-ItemSAO proto_ItemSAO(NULL, 0, v3f(0,0,0), "");
+#include "luaentity_common.h"
+
+// Prototype (registers item for deserialization)
+LuaEntitySAO proto_LuaEntitySAO(NULL, v3f(0,0,0), "_prototype", "");
+
+LuaEntitySAO::LuaEntitySAO(ServerEnvironment *env, v3f pos,
+		const std::string &name, const std::string &state):
+	ServerActiveObject(env, pos),
+	m_init_name(name),
+	m_init_state(state),
+	m_registered(false),
+	m_prop(new LuaEntityProperties),
+	m_hp(-1),
+	m_velocity(0,0,0),
+	m_acceleration(0,0,0),
+	m_yaw(0),
+	m_properties_sent(true),
+	m_last_sent_yaw(0),
+	m_last_sent_position(0,0,0),
+	m_last_sent_velocity(0,0,0),
+	m_last_sent_position_timer(0),
+	m_last_sent_move_precision(0),
+	m_armor_groups_sent(false)
+{
+	// Only register type if no environment supplied
+	if(env == NULL){
+		ServerActiveObject::registerType(getType(), create);
+		return;
+	}
+	
+	// Initialize something to armor groups
+	m_armor_groups["fleshy"] = 3;
+	m_armor_groups["snappy"] = 2;
+}
 
-ItemSAO::ItemSAO(ServerEnvironment *env, u16 id, v3f pos,
-		const std::string inventorystring):
-	ServerActiveObject(env, id, pos),
-	m_inventorystring(inventorystring),
-	m_speed_f(0,0,0),
-	m_last_sent_position(0,0,0)
+LuaEntitySAO::~LuaEntitySAO()
 {
-	ServerActiveObject::registerType(getType(), create);
+	if(m_registered){
+		lua_State *L = m_env->getLua();
+		scriptapi_luaentity_rm(L, m_id);
+	}
+	delete m_prop;
 }
 
-ServerActiveObject* ItemSAO::create(ServerEnvironment *env, u16 id, v3f pos,
+void LuaEntitySAO::addedToEnvironment()
+{
+	ServerActiveObject::addedToEnvironment();
+	
+	// Create entity from name
+	lua_State *L = m_env->getLua();
+	m_registered = scriptapi_luaentity_add(L, m_id, m_init_name.c_str());
+	
+	if(m_registered){
+		// Get properties
+		scriptapi_luaentity_get_properties(L, m_id, m_prop);
+		// Initialize HP from properties
+		m_hp = m_prop->hp_max;
+	}
+	
+	// Activate entity, supplying serialized state
+	scriptapi_luaentity_activate(L, m_id, m_init_state.c_str());
+}
+
+ServerActiveObject* LuaEntitySAO::create(ServerEnvironment *env, v3f pos,
 		const std::string &data)
 {
-	std::istringstream is(data, std::ios::binary);
-	char buf[1];
-	// read version
-	is.read(buf, 1);
-	u8 version = buf[0];
-	// check if version is supported
-	if(version != 0)
-		return NULL;
-	std::string inventorystring = deSerializeString(is);
-	dstream<<"ItemSAO::create(): Creating item \""
-			<<inventorystring<<"\""<<std::endl;
-	return new ItemSAO(env, id, pos, inventorystring);
+	std::string name;
+	std::string state;
+	s16 hp = 1;
+	v3f velocity;
+	float yaw = 0;
+	if(data != ""){
+		std::istringstream is(data, std::ios::binary);
+		// read version
+		u8 version = readU8(is);
+		// check if version is supported
+		if(version == 0){
+			name = deSerializeString(is);
+			state = deSerializeLongString(is);
+		}
+		else if(version == 1){
+			name = deSerializeString(is);
+			state = deSerializeLongString(is);
+			hp = readS16(is);
+			velocity = readV3F1000(is);
+			yaw = readF1000(is);
+		}
+	}
+	// create object
+	infostream<<"LuaEntitySAO::create(name=\""<<name<<"\" state=\""
+			<<state<<"\")"<<std::endl;
+	LuaEntitySAO *sao = new LuaEntitySAO(env, pos, name, state);
+	sao->m_hp = hp;
+	sao->m_velocity = velocity;
+	sao->m_yaw = yaw;
+	return sao;
 }
 
-void ItemSAO::step(float dtime, bool send_recommended)
+void LuaEntitySAO::step(float dtime, bool send_recommended)
 {
-	assert(m_env);
+	if(!m_properties_sent)
+	{
+		m_properties_sent = true;
+		std::string str = getPropertyPacket();
+		// create message and add to list
+		ActiveObjectMessage aom(getId(), true, str);
+		m_messages_out.push_back(aom);
+	}
 
-	const float interval = 0.2;
-	if(m_move_interval.step(dtime, interval)==false)
-		return;
-	dtime = interval;
-	
-	core::aabbox3d<f32> box(-BS/3.,0.0,-BS/3., BS/3.,BS*2./3.,BS/3.);
-	collisionMoveResult moveresult;
-	// Apply gravity
-	m_speed_f += v3f(0, -dtime*9.81*BS, 0);
-	// Maximum movement without glitches
-	f32 pos_max_d = BS*0.25;
-	// Limit speed
-	if(m_speed_f.getLength()*dtime > pos_max_d)
-		m_speed_f *= pos_max_d / (m_speed_f.getLength()*dtime);
-	v3f pos_f = getBasePosition();
-	v3f pos_f_old = pos_f;
-	moveresult = collisionMoveSimple(&m_env->getMap(), pos_max_d,
-			box, dtime, pos_f, m_speed_f);
+	m_last_sent_position_timer += dtime;
 	
+	if(m_prop->physical){
+		core::aabbox3d<f32> box = m_prop->collisionbox;
+		box.MinEdge *= BS;
+		box.MaxEdge *= BS;
+		collisionMoveResult moveresult;
+		f32 pos_max_d = BS*0.25; // Distance per iteration
+		v3f p_pos = getBasePosition();
+		v3f p_velocity = m_velocity;
+		IGameDef *gamedef = m_env->getGameDef();
+		moveresult = collisionMovePrecise(&m_env->getMap(), gamedef,
+				pos_max_d, box, dtime, p_pos, p_velocity);
+		// Apply results
+		setBasePosition(p_pos);
+		m_velocity = p_velocity;
+
+		m_velocity += dtime * m_acceleration;
+	} else {
+		m_base_position += dtime * m_velocity + 0.5 * dtime
+				* dtime * m_acceleration;
+		m_velocity += dtime * m_acceleration;
+	}
+
+	if(m_registered){
+		lua_State *L = m_env->getLua();
+		scriptapi_luaentity_step(L, m_id, dtime);
+	}
+
 	if(send_recommended == false)
 		return;
+	
+	// TODO: force send when acceleration changes enough?
+	float minchange = 0.2*BS;
+	if(m_last_sent_position_timer > 1.0){
+		minchange = 0.01*BS;
+	} else if(m_last_sent_position_timer > 0.2){
+		minchange = 0.05*BS;
+	}
+	float move_d = m_base_position.getDistanceFrom(m_last_sent_position);
+	move_d += m_last_sent_move_precision;
+	float vel_d = m_velocity.getDistanceFrom(m_last_sent_velocity);
+	if(move_d > minchange || vel_d > minchange ||
+			fabs(m_yaw - m_last_sent_yaw) > 1.0){
+		sendPosition(true, false);
+	}
 
-	if(pos_f.getDistanceFrom(m_last_sent_position) > 0.05*BS)
-	{
-		setBasePosition(pos_f);
-		m_last_sent_position = pos_f;
-
-		std::ostringstream os(std::ios::binary);
-		char buf[6];
-		// command (0 = update position)
-		buf[0] = 0;
-		os.write(buf, 1);
-		// pos
-		writeS32((u8*)buf, m_base_position.X*1000);
-		os.write(buf, 4);
-		writeS32((u8*)buf, m_base_position.Y*1000);
-		os.write(buf, 4);
-		writeS32((u8*)buf, m_base_position.Z*1000);
-		os.write(buf, 4);
+	if(m_armor_groups_sent == false){
+		m_armor_groups_sent = true;
+		std::string str = gob_cmd_update_armor_groups(
+				m_armor_groups);
 		// create message and add to list
-		ActiveObjectMessage aom(getId(), false, os.str());
+		ActiveObjectMessage aom(getId(), true, str);
 		m_messages_out.push_back(aom);
 	}
 }
 
-std::string ItemSAO::getClientInitializationData()
+std::string LuaEntitySAO::getClientInitializationData()
 {
 	std::ostringstream os(std::ios::binary);
-	char buf[6];
-	// version
-	buf[0] = 0;
-	os.write(buf, 1);
-	// pos
-	writeS32((u8*)buf, m_base_position.X*1000);
-	os.write(buf, 4);
-	writeS32((u8*)buf, m_base_position.Y*1000);
-	os.write(buf, 4);
-	writeS32((u8*)buf, m_base_position.Z*1000);
-	os.write(buf, 4);
-	// inventorystring
-	os<<serializeString(m_inventorystring);
+	writeU8(os, 0); // version
+	os<<serializeString(""); // name
+	writeU8(os, 0); // is_player
+	writeV3F1000(os, m_base_position);
+	writeF1000(os, m_yaw);
+	writeS16(os, m_hp);
+	writeU8(os, 3); // number of messages stuffed in here
+	os<<serializeLongString(getPropertyPacket()); // message 1
+	os<<serializeLongString(gob_cmd_update_armor_groups(m_armor_groups)); // 2
+	os<<serializeLongString(gob_cmd_set_sprite( // 3
+		m_prop->initial_sprite_basepos,
+		1, 1.0, false
+	));
+	// return result
 	return os.str();
 }
 
-std::string ItemSAO::getStaticData()
+std::string LuaEntitySAO::getStaticData()
 {
-	dstream<<__FUNCTION_NAME<<std::endl;
+	verbosestream<<__FUNCTION_NAME<<std::endl;
 	std::ostringstream os(std::ios::binary);
-	char buf[1];
 	// version
-	buf[0] = 0;
-	os.write(buf, 1);
-	// inventorystring
-	os<<serializeString(m_inventorystring);
+	writeU8(os, 1);
+	// name
+	os<<serializeString(m_init_name);
+	// state
+	if(m_registered){
+		lua_State *L = m_env->getLua();
+		std::string state = scriptapi_luaentity_get_staticdata(L, m_id);
+		os<<serializeLongString(state);
+	} else {
+		os<<serializeLongString(m_init_state);
+	}
+	// hp
+	writeS16(os, m_hp);
+	// velocity
+	writeV3F1000(os, m_velocity);
+	// yaw
+	writeF1000(os, m_yaw);
 	return os.str();
 }
 
-InventoryItem * ItemSAO::createInventoryItem()
+int LuaEntitySAO::punch(v3f dir,
+		const ToolCapabilities *toolcap,
+		ServerActiveObject *puncher,
+		float time_from_last_punch)
 {
-	try{
-		std::istringstream is(m_inventorystring, std::ios_base::binary);
-		InventoryItem *item = InventoryItem::deSerialize(is);
-		dstream<<__FUNCTION_NAME<<": m_inventorystring=\""
-				<<m_inventorystring<<"\" -> item="<<item
-				<<std::endl;
-		return item;
+	if(!m_registered){
+		// Delete unknown LuaEntities when punched
+		m_removed = true;
+		return 0;
 	}
-	catch(SerializationError &e)
-	{
-		dstream<<__FUNCTION_NAME<<": serialization error: "
-				<<"m_inventorystring=\""<<m_inventorystring<<"\""<<std::endl;
-		return NULL;
+	
+	ItemStack *punchitem = NULL;
+	ItemStack punchitem_static;
+	if(puncher){
+		punchitem_static = puncher->getWieldedItem();
+		punchitem = &punchitem_static;
 	}
-}
 
+	PunchDamageResult result = getPunchDamage(
+			m_armor_groups,
+			toolcap,
+			punchitem,
+			time_from_last_punch);
+	
+	if(result.did_punch)
+	{
+		setHP(getHP() - result.damage);
+		
+		actionstream<<getDescription()<<" punched by "
+				<<puncher->getDescription()<<", damage "<<result.damage
+				<<" hp, health now "<<getHP()<<" hp"<<std::endl;
+		
+		{
+			std::string str = gob_cmd_punched(result.damage, getHP());
+			// create message and add to list
+			ActiveObjectMessage aom(getId(), true, str);
+			m_messages_out.push_back(aom);
+		}
 
-/*
-	RatSAO
-*/
+		if(getHP() == 0)
+			m_removed = true;
+	}
+
+	lua_State *L = m_env->getLua();
+	scriptapi_luaentity_punch(L, m_id, puncher,
+			time_from_last_punch, toolcap, dir);
 
-// Prototype
-RatSAO proto_RatSAO(NULL, 0, v3f(0,0,0));
+	return result.wear;
+}
 
-RatSAO::RatSAO(ServerEnvironment *env, u16 id, v3f pos):
-	ServerActiveObject(env, id, pos),
-	m_is_active(false),
-	m_speed_f(0,0,0)
+void LuaEntitySAO::rightClick(ServerActiveObject *clicker)
 {
-	ServerActiveObject::registerType(getType(), create);
+	if(!m_registered)
+		return;
+	lua_State *L = m_env->getLua();
+	scriptapi_luaentity_rightclick(L, m_id, clicker);
+}
 
-	m_oldpos = v3f(0,0,0);
-	m_last_sent_position = v3f(0,0,0);
-	m_yaw = 0;
-	m_counter1 = 0;
-	m_counter2 = 0;
-	m_age = 0;
-	m_touching_ground = false;
+void LuaEntitySAO::setPos(v3f pos)
+{
+	m_base_position = pos;
+	sendPosition(false, true);
 }
 
-ServerActiveObject* RatSAO::create(ServerEnvironment *env, u16 id, v3f pos,
-		const std::string &data)
+void LuaEntitySAO::moveTo(v3f pos, bool continuous)
 {
-	std::istringstream is(data, std::ios::binary);
-	char buf[1];
-	// read version
-	is.read(buf, 1);
-	u8 version = buf[0];
-	// check if version is supported
-	if(version != 0)
-		return NULL;
-	return new RatSAO(env, id, pos);
+	m_base_position = pos;
+	if(!continuous)
+		sendPosition(true, true);
 }
 
-void RatSAO::step(float dtime, bool send_recommended)
+float LuaEntitySAO::getMinimumSavedMovement()
 {
-	assert(m_env);
+	return 0.1 * BS;
+}
 
-	if(m_is_active == false)
-	{
-		if(m_inactive_interval.step(dtime, 0.5)==false)
-			return;
-	}
+std::string LuaEntitySAO::getDescription()
+{
+	std::ostringstream os(std::ios::binary);
+	os<<"LuaEntitySAO at (";
+	os<<(m_base_position.X/BS)<<",";
+	os<<(m_base_position.Y/BS)<<",";
+	os<<(m_base_position.Z/BS);
+	os<<")";
+	return os.str();
+}
 
-	/*
-		The AI
-	*/
+void LuaEntitySAO::setHP(s16 hp)
+{
+	if(hp < 0) hp = 0;
+	m_hp = hp;
+}
 
-	/*m_age += dtime;
-	if(m_age > 60)
-	{
-		// Die
-		m_removed = true;
-		return;
-	}*/
+s16 LuaEntitySAO::getHP() const
+{
+	return m_hp;
+}
 
-	// Apply gravity
-	m_speed_f.Y -= dtime*9.81*BS;
+void LuaEntitySAO::setArmorGroups(const ItemGroupList &armor_groups)
+{
+	m_armor_groups = armor_groups;
+	m_armor_groups_sent = false;
+}
 
-	/*
-		Move around if some player is close
-	*/
-	bool player_is_close = false;
-	// Check connected players
-	core::list<Player*> players = m_env->getPlayers(true);
-	core::list<Player*>::Iterator i;
-	for(i = players.begin();
-			i != players.end(); i++)
-	{
-		Player *player = *i;
-		v3f playerpos = player->getPosition();
-		if(m_base_position.getDistanceFrom(playerpos) < BS*10.0)
-		{
-			player_is_close = true;
-			break;
-		}
-	}
+void LuaEntitySAO::setVelocity(v3f velocity)
+{
+	m_velocity = velocity;
+}
 
-	m_is_active = player_is_close;
-	
-	if(player_is_close == false)
-	{
-		m_speed_f.X = 0;
-		m_speed_f.Z = 0;
-	}
-	else
-	{
-		// Move around
-		v3f dir(cos(m_yaw/180*PI),0,sin(m_yaw/180*PI));
-		f32 speed = 2*BS;
-		m_speed_f.X = speed * dir.X;
-		m_speed_f.Z = speed * dir.Z;
-
-		if(m_touching_ground && (m_oldpos - m_base_position).getLength()
-				< dtime*speed/2)
-		{
-			m_counter1 -= dtime;
-			if(m_counter1 < 0.0)
-			{
-				m_counter1 += 1.0;
-				m_speed_f.Y = 5.0*BS;
-			}
-		}
+v3f LuaEntitySAO::getVelocity()
+{
+	return m_velocity;
+}
 
-		{
-			m_counter2 -= dtime;
-			if(m_counter2 < 0.0)
-			{
-				m_counter2 += (float)(myrand()%100)/100*3.0;
-				m_yaw += ((float)(myrand()%200)-100)/100*180;
-				m_yaw = wrapDegrees(m_yaw);
-			}
-		}
-	}
-	
-	m_oldpos = m_base_position;
+void LuaEntitySAO::setAcceleration(v3f acceleration)
+{
+	m_acceleration = acceleration;
+}
 
-	/*
-		Move it, with collision detection
-	*/
+v3f LuaEntitySAO::getAcceleration()
+{
+	return m_acceleration;
+}
 
-	core::aabbox3d<f32> box(-BS/3.,0.0,-BS/3., BS/3.,BS*2./3.,BS/3.);
-	collisionMoveResult moveresult;
-	// Maximum movement without glitches
-	f32 pos_max_d = BS*0.25;
-	// Limit speed
-	if(m_speed_f.getLength()*dtime > pos_max_d)
-		m_speed_f *= pos_max_d / (m_speed_f.getLength()*dtime);
-	v3f pos_f = getBasePosition();
-	v3f pos_f_old = pos_f;
-	moveresult = collisionMoveSimple(&m_env->getMap(), pos_max_d,
-			box, dtime, pos_f, m_speed_f);
-	m_touching_ground = moveresult.touching_ground;
-	
-	setBasePosition(pos_f);
+void LuaEntitySAO::setYaw(float yaw)
+{
+	m_yaw = yaw;
+}
 
-	if(send_recommended == false)
-		return;
+float LuaEntitySAO::getYaw()
+{
+	return m_yaw;
+}
 
-	if(pos_f.getDistanceFrom(m_last_sent_position) > 0.05*BS)
-	{
-		m_last_sent_position = pos_f;
+void LuaEntitySAO::setTextureMod(const std::string &mod)
+{
+	std::string str = gob_cmd_set_texture_mod(mod);
+	// create message and add to list
+	ActiveObjectMessage aom(getId(), true, str);
+	m_messages_out.push_back(aom);
+}
 
-		std::ostringstream os(std::ios::binary);
-		// command (0 = update position)
-		writeU8(os, 0);
-		// pos
-		writeV3F1000(os, m_base_position);
-		// yaw
-		writeF1000(os, m_yaw);
-		// create message and add to list
-		ActiveObjectMessage aom(getId(), false, os.str());
-		m_messages_out.push_back(aom);
-	}
+void LuaEntitySAO::setSprite(v2s16 p, int num_frames, float framelength,
+		bool select_horiz_by_yawpitch)
+{
+	std::string str = gob_cmd_set_sprite(
+		p,
+		num_frames,
+		framelength,
+		select_horiz_by_yawpitch
+	);
+	// create message and add to list
+	ActiveObjectMessage aom(getId(), true, str);
+	m_messages_out.push_back(aom);
 }
 
-std::string RatSAO::getClientInitializationData()
+std::string LuaEntitySAO::getName()
 {
-	std::ostringstream os(std::ios::binary);
-	// version
-	writeU8(os, 0);
-	// pos
-	writeV3F1000(os, m_base_position);
-	return os.str();
+	return m_init_name;
 }
 
-std::string RatSAO::getStaticData()
+std::string LuaEntitySAO::getPropertyPacket()
 {
-	//dstream<<__FUNCTION_NAME<<std::endl;
-	std::ostringstream os(std::ios::binary);
-	// version
-	writeU8(os, 0);
-	return os.str();
+	return gob_cmd_set_properties(
+		m_prop->hp_max,
+		m_prop->physical,
+		m_prop->weight,
+		m_prop->collisionbox,
+		m_prop->visual,
+		m_prop->visual_size,
+		m_prop->textures,
+		m_prop->spritediv,
+		true, // is_visible
+		false // makes_footstep_sound
+	);
 }
 
-InventoryItem* RatSAO::createPickedUpItem()
+void LuaEntitySAO::sendPosition(bool do_interpolate, bool is_movement_end)
 {
-	std::istringstream is("CraftItem rat 1", std::ios_base::binary);
-	InventoryItem *item = InventoryItem::deSerialize(is);
-	return item;
+	m_last_sent_move_precision = m_base_position.getDistanceFrom(
+			m_last_sent_position);
+	m_last_sent_position_timer = 0;
+	m_last_sent_yaw = m_yaw;
+	m_last_sent_position = m_base_position;
+	m_last_sent_velocity = m_velocity;
+	//m_last_sent_acceleration = m_acceleration;
+
+	float update_interval = m_env->getSendRecommendedInterval();
+
+	std::string str = gob_cmd_update_position(
+		m_base_position,
+		m_velocity,
+		m_acceleration,
+		m_yaw,
+		do_interpolate,
+		is_movement_end,
+		update_interval
+	);
+	// create message and add to list
+	ActiveObjectMessage aom(getId(), false, str);
 }
 
 /*
-	Oerkki1SAO
+	PlayerSAO
 */
 
-// Y is copied, X and Z change is limited
-void accelerate_xz(v3f &speed, v3f target_speed, f32 max_increase)
+// No prototype, PlayerSAO does not need to be deserialized
+
+PlayerSAO::PlayerSAO(ServerEnvironment *env_, Player *player_, u16 peer_id_):
+	ServerActiveObject(env_, v3f(0,0,0)),
+	m_player(player_),
+	m_peer_id(peer_id_),
+	m_inventory(NULL),
+	m_last_good_position(0,0,0),
+	m_last_good_position_age(0),
+	m_time_from_last_punch(0),
+	m_wield_index(0),
+	m_position_not_sent(false),
+	m_armor_groups_sent(false),
+	m_properties_sent(true),
+	m_teleported(false),
+	m_inventory_not_sent(false),
+	m_hp_not_sent(false),
+	m_wielded_item_not_sent(false)
 {
-	v3f d_wanted = target_speed - speed;
-	d_wanted.Y = 0;
-	f32 dl_wanted = d_wanted.getLength();
-	f32 dl = dl_wanted;
-	if(dl > max_increase)
-		dl = max_increase;
-	
-	v3f d = d_wanted.normalize() * dl;
-
-	speed.X += d.X;
-	speed.Z += d.Z;
-	speed.Y = target_speed.Y;
+	assert(m_player);
+	assert(m_peer_id != 0);
+	setBasePosition(m_player->getPosition());
+	m_inventory = &m_player->inventory;
+	m_armor_groups["choppy"] = 2;
+	m_armor_groups["fleshy"] = 3;
 }
 
-// Prototype
-Oerkki1SAO proto_Oerkki1SAO(NULL, 0, v3f(0,0,0));
-
-Oerkki1SAO::Oerkki1SAO(ServerEnvironment *env, u16 id, v3f pos):
-	ServerActiveObject(env, id, pos),
-	m_is_active(false),
-	m_speed_f(0,0,0)
+PlayerSAO::~PlayerSAO()
 {
-	ServerActiveObject::registerType(getType(), create);
+	if(m_inventory != &m_player->inventory)
+		delete m_inventory;
 
-	m_oldpos = v3f(0,0,0);
-	m_last_sent_position = v3f(0,0,0);
-	m_yaw = 0;
-	m_counter1 = 0;
-	m_counter2 = 0;
-	m_age = 0;
-	m_touching_ground = false;
-	m_hp = 20;
-	m_after_jump_timer = 0;
 }
 
-ServerActiveObject* Oerkki1SAO::create(ServerEnvironment *env, u16 id, v3f pos,
-		const std::string &data)
+std::string PlayerSAO::getDescription()
 {
-	std::istringstream is(data, std::ios::binary);
-	// read version
-	u8 version = readU8(is);
-	// read hp
-	u8 hp = readU8(is);
-	// check if version is supported
-	if(version != 0)
-		return NULL;
-	Oerkki1SAO *o = new Oerkki1SAO(env, id, pos);
-	o->m_hp = hp;
-	return o;
+	return std::string("player ") + m_player->getName();
 }
 
-void Oerkki1SAO::step(float dtime, bool send_recommended)
+// Called after id has been set and has been inserted in environment
+void PlayerSAO::addedToEnvironment()
 {
-	assert(m_env);
+	ServerActiveObject::addedToEnvironment();
+	ServerActiveObject::setBasePosition(m_player->getPosition());
+	m_player->setPlayerSAO(this);
+	m_player->peer_id = m_peer_id;
+	m_last_good_position = m_player->getPosition();
+	m_last_good_position_age = 0.0;
+}
 
-	if(m_is_active == false)
+// Called before removing from environment
+void PlayerSAO::removingFromEnvironment()
+{
+	ServerActiveObject::removingFromEnvironment();
+	if(m_player->getPlayerSAO() == this)
 	{
-		if(m_inactive_interval.step(dtime, 0.5)==false)
-			return;
+		m_player->setPlayerSAO(NULL);
+		m_player->peer_id = 0;
 	}
+}
 
-	/*
-		The AI
-	*/
-
-	m_age += dtime;
-	if(m_age > 120)
-	{
-		// Die
-		m_removed = true;
-		return;
-	}
+bool PlayerSAO::isStaticAllowed() const
+{
+	return false;
+}
 
-	m_after_jump_timer -= dtime;
+bool PlayerSAO::unlimitedTransferDistance() const
+{
+	return g_settings->getBool("unlimited_player_transfer_distance");
+}
 
-	v3f old_speed = m_speed_f;
+std::string PlayerSAO::getClientInitializationData()
+{
+	std::ostringstream os(std::ios::binary);
+	writeU8(os, 0); // version
+	os<<serializeString(m_player->getName()); // name
+	writeU8(os, 1); // is_player
+	writeV3F1000(os, m_player->getPosition() + v3f(0,BS*1,0));
+	writeF1000(os, m_player->getYaw());
+	writeS16(os, getHP());
+	writeU8(os, 2); // number of messages stuffed in here
+	os<<serializeLongString(getPropertyPacket()); // message 1
+	os<<serializeLongString(gob_cmd_update_armor_groups(m_armor_groups)); // 2
+	return os.str();
+}
 
-	// Apply gravity
-	m_speed_f.Y -= dtime*9.81*BS;
+std::string PlayerSAO::getStaticData()
+{
+	assert(0);
+	return "";
+}
 
-	/*
-		Move around if some player is close
-	*/
-	bool player_is_close = false;
-	bool player_is_too_close = false;
-	v3f near_player_pos;
-	// Check connected players
-	core::list<Player*> players = m_env->getPlayers(true);
-	core::list<Player*>::Iterator i;
-	for(i = players.begin();
-			i != players.end(); i++)
+void PlayerSAO::step(float dtime, bool send_recommended)
+{
+	if(!m_properties_sent)
 	{
-		Player *player = *i;
-		v3f playerpos = player->getPosition();
-		f32 dist = m_base_position.getDistanceFrom(playerpos);
-		if(dist < BS*1.45)
-		{
-			player_is_too_close = true;
-			near_player_pos = playerpos;
-			break;
-		}
-		else if(dist < BS*15.0)
-		{
-			player_is_close = true;
-			near_player_pos = playerpos;
-		}
+		m_properties_sent = true;
+		std::string str = getPropertyPacket();
+		// create message and add to list
+		ActiveObjectMessage aom(getId(), true, str);
+		m_messages_out.push_back(aom);
 	}
 
-	m_is_active = player_is_close;
-
-	v3f target_speed = m_speed_f;
-
-	if(!player_is_close)
-	{
-		target_speed = v3f(0,0,0);
-	}
-	else
-	{
-		// Move around
-
-		v3f ndir = near_player_pos - m_base_position;
-		ndir.Y = 0;
-		ndir.normalize();
-
-		f32 nyaw = 180./PI*atan2(ndir.Z,ndir.X);
-		if(nyaw < m_yaw - 180)
-			nyaw += 360;
-		else if(nyaw > m_yaw + 180)
-			nyaw -= 360;
-		m_yaw = 0.95*m_yaw + 0.05*nyaw;
-		m_yaw = wrapDegrees(m_yaw);
-		
-		f32 speed = 2*BS;
+	m_time_from_last_punch += dtime;
 
-		if((m_touching_ground || m_after_jump_timer > 0.0)
-				&& !player_is_too_close)
-		{
-			v3f dir(cos(m_yaw/180*PI),0,sin(m_yaw/180*PI));
-			target_speed.X = speed * dir.X;
-			target_speed.Z = speed * dir.Z;
-		}
+	/*
+		Check player movements
 
-		if(m_touching_ground && (m_oldpos - m_base_position).getLength()
-				< dtime*speed/2)
-		{
-			m_counter1 -= dtime;
-			if(m_counter1 < 0.0)
-			{
-				m_counter1 += 0.2;
-				// Jump
-				target_speed.Y = 5.0*BS;
-				m_after_jump_timer = 1.0;
-			}
-		}
+		NOTE: Actually the server should handle player physics like the
+		client does and compare player's position to what is calculated
+		on our side. This is required when eg. players fly due to an
+		explosion.
+	*/
 
-		{
-			m_counter2 -= dtime;
-			if(m_counter2 < 0.0)
-			{
-				m_counter2 += (float)(myrand()%100)/100*3.0;
-				//m_yaw += ((float)(myrand()%200)-100)/100*180;
-				m_yaw += ((float)(myrand()%200)-100)/100*90;
-				m_yaw = wrapDegrees(m_yaw);
-			}
+	//float player_max_speed = BS * 4.0; // Normal speed
+	float player_max_speed = BS * 20; // Fast speed
+	float player_max_speed_up = BS * 20;
+	player_max_speed *= 2.5; // Tolerance
+	player_max_speed_up *= 2.5;
+
+	m_last_good_position_age += dtime;
+	if(m_last_good_position_age >= 1.0){
+		float age = m_last_good_position_age;
+		v3f diff = (m_player->getPosition() - m_last_good_position);
+		float d_vert = diff.Y;
+		diff.Y = 0;
+		float d_horiz = diff.getLength();
+		/*infostream<<m_player->getName()<<"'s horizontal speed is "
+				<<(d_horiz/age)<<std::endl;*/
+		if(d_horiz <= age * player_max_speed &&
+				(d_vert < 0 || d_vert < age * player_max_speed_up)){
+			m_last_good_position = m_player->getPosition();
+		} else {
+			actionstream<<"Player "<<m_player->getName()
+					<<" moved too fast; resetting position"
+					<<std::endl;
+			m_player->setPosition(m_last_good_position);
+			m_teleported = true;
 		}
+		m_last_good_position_age = 0;
 	}
-	
-	if((m_speed_f - target_speed).getLength() > BS*4 || player_is_too_close)
-		accelerate_xz(m_speed_f, target_speed, dtime*BS*8);
-	else
-		accelerate_xz(m_speed_f, target_speed, dtime*BS*4);
-	
-	m_oldpos = m_base_position;
 
-	/*
-		Move it, with collision detection
-	*/
+	if(send_recommended == false)
+		return;
 
-	core::aabbox3d<f32> box(-BS/3.,0.0,-BS/3., BS/3.,BS*5./3.,BS/3.);
-	collisionMoveResult moveresult;
-	// Maximum movement without glitches
-	f32 pos_max_d = BS*0.25;
-	/*// Limit speed
-	if(m_speed_f.getLength()*dtime > pos_max_d)
-		m_speed_f *= pos_max_d / (m_speed_f.getLength()*dtime);*/
-	v3f pos_f = getBasePosition();
-	v3f pos_f_old = pos_f;
-	moveresult = collisionMovePrecise(&m_env->getMap(), pos_max_d,
-			box, dtime, pos_f, m_speed_f);
-	m_touching_ground = moveresult.touching_ground;
-	
-	// Do collision damage
-	float tolerance = BS*12;
-	float factor = BS*0.5;
-	v3f speed_diff = old_speed - m_speed_f;
-	// Increase effect in X and Z
-	speed_diff.X *= 2;
-	speed_diff.Z *= 2;
-	float vel = speed_diff.getLength();
-	if(vel > tolerance)
+	if(m_position_not_sent)
 	{
-		f32 damage_f = (vel - tolerance)/BS*factor;
-		u16 damage = (u16)(damage_f+0.5);
-		doDamage(damage);
+		m_position_not_sent = false;
+		float update_interval = m_env->getSendRecommendedInterval();
+		std::string str = gob_cmd_update_position(
+			m_player->getPosition() + v3f(0,BS*1,0),
+			v3f(0,0,0),
+			v3f(0,0,0),
+			m_player->getYaw(),
+			true,
+			false,
+			update_interval
+		);
+		// create message and add to list
+		ActiveObjectMessage aom(getId(), false, str);
+		m_messages_out.push_back(aom);
 	}
 
-	setBasePosition(pos_f);
-
-	if(send_recommended == false && m_speed_f.getLength() < 3.0*BS)
-		return;
-
-	if(pos_f.getDistanceFrom(m_last_sent_position) > 0.05*BS)
+	if(m_wielded_item_not_sent)
 	{
-		m_last_sent_position = pos_f;
+		m_wielded_item_not_sent = false;
+		// GenericCAO has no special way to show this
+	}
 
-		std::ostringstream os(std::ios::binary);
-		// command (0 = update position)
-		writeU8(os, 0);
-		// pos
-		writeV3F1000(os, m_base_position);
-		// yaw
-		writeF1000(os, m_yaw);
+	if(m_armor_groups_sent == false){
+		m_armor_groups_sent = true;
+		std::string str = gob_cmd_update_armor_groups(
+				m_armor_groups);
 		// create message and add to list
-		ActiveObjectMessage aom(getId(), false, os.str());
+		ActiveObjectMessage aom(getId(), true, str);
 		m_messages_out.push_back(aom);
 	}
 }
 
-std::string Oerkki1SAO::getClientInitializationData()
+void PlayerSAO::setBasePosition(const v3f &position)
 {
-	std::ostringstream os(std::ios::binary);
-	// version
-	writeU8(os, 0);
-	// pos
-	writeV3F1000(os, m_base_position);
-	return os.str();
+	ServerActiveObject::setBasePosition(position);
+	m_position_not_sent = true;
 }
 
-std::string Oerkki1SAO::getStaticData()
+void PlayerSAO::setPos(v3f pos)
 {
-	//dstream<<__FUNCTION_NAME<<std::endl;
-	std::ostringstream os(std::ios::binary);
-	// version
-	writeU8(os, 0);
-	// hp
-	writeU8(os, m_hp);
-	return os.str();
+	m_player->setPosition(pos);
+	// Movement caused by this command is always valid
+	m_last_good_position = pos;
+	m_last_good_position_age = 0;
+	// Force position change on client
+	m_teleported = true;
 }
 
-u16 Oerkki1SAO::punch(const std::string &toolname, v3f dir)
+void PlayerSAO::moveTo(v3f pos, bool continuous)
 {
-	m_speed_f += dir*12*BS;
-
-	u16 amount = 5;
-	doDamage(amount);
-	return 65536/100;
+	m_player->setPosition(pos);
+	// Movement caused by this command is always valid
+	m_last_good_position = pos;
+	m_last_good_position_age = 0;
+	// Force position change on client
+	m_teleported = true;
 }
 
-void Oerkki1SAO::doDamage(u16 d)
+int PlayerSAO::punch(v3f dir,
+	const ToolCapabilities *toolcap,
+	ServerActiveObject *puncher,
+	float time_from_last_punch)
 {
-	dstream<<"oerkki damage: "<<d<<std::endl;
-	
-	if(d < m_hp)
-	{
-		m_hp -= d;
-	}
-	else
-	{
-		// Die
-		m_hp = 0;
-		m_removed = true;
+	if(!toolcap)
+		return 0;
+
+	// No effect if PvP disabled
+	if(g_settings->getBool("enable_pvp") == false){
+		if(puncher->getType() == ACTIVEOBJECT_TYPE_PLAYER){
+			std::string str = gob_cmd_punched(0, getHP());
+			// create message and add to list
+			ActiveObjectMessage aom(getId(), true, str);
+			m_messages_out.push_back(aom);
+			return 0;
+		}
 	}
 
+	HitParams hitparams = getHitParams(m_armor_groups, toolcap,
+			time_from_last_punch);
+
+	actionstream<<"Player "<<m_player->getName()<<" punched by "
+			<<puncher->getDescription()<<", damage "<<hitparams.hp
+			<<" HP"<<std::endl;
+
+	setHP(getHP() - hitparams.hp);
+
+	if(hitparams.hp != 0)
 	{
-		std::ostringstream os(std::ios::binary);
-		// command (1 = damage)
-		writeU8(os, 1);
-		// amount
-		writeU8(os, d);
+		std::string str = gob_cmd_punched(hitparams.hp, getHP());
 		// create message and add to list
-		ActiveObjectMessage aom(getId(), false, os.str());
+		ActiveObjectMessage aom(getId(), true, str);
 		m_messages_out.push_back(aom);
 	}
-}
-
-/*
-	FireflySAO
-*/
 
-// Prototype
-FireflySAO proto_FireflySAO(NULL, 0, v3f(0,0,0));
+	return hitparams.wear;
+}
 
-FireflySAO::FireflySAO(ServerEnvironment *env, u16 id, v3f pos):
-	ServerActiveObject(env, id, pos),
-	m_is_active(false),
-	m_speed_f(0,0,0)
+void PlayerSAO::rightClick(ServerActiveObject *clicker)
 {
-	ServerActiveObject::registerType(getType(), create);
-
-	m_oldpos = v3f(0,0,0);
-	m_last_sent_position = v3f(0,0,0);
-	m_yaw = 0;
-	m_counter1 = 0;
-	m_counter2 = 0;
-	m_age = 0;
-	m_touching_ground = false;
 }
 
-ServerActiveObject* FireflySAO::create(ServerEnvironment *env, u16 id, v3f pos,
-		const std::string &data)
+s16 PlayerSAO::getHP() const
 {
-	std::istringstream is(data, std::ios::binary);
-	char buf[1];
-	// read version
-	is.read(buf, 1);
-	u8 version = buf[0];
-	// check if version is supported
-	if(version != 0)
-		return NULL;
-	return new FireflySAO(env, id, pos);
+	return m_player->hp;
 }
 
-void FireflySAO::step(float dtime, bool send_recommended)
+void PlayerSAO::setHP(s16 hp)
 {
-	assert(m_env);
+	s16 oldhp = m_player->hp;
+
+	if(hp < 0)
+		hp = 0;
+	else if(hp > PLAYER_MAX_HP)
+		hp = PLAYER_MAX_HP;
 
-	if(m_is_active == false)
+	if(hp < oldhp && g_settings->getBool("enable_damage") == false)
 	{
-		if(m_inactive_interval.step(dtime, 0.5)==false)
-			return;
+		m_hp_not_sent = true; // fix wrong prediction on client
+		return;
 	}
 
-	/*
-		The AI
-	*/
+	m_player->hp = hp;
 
-	// Apply (less) gravity
-	m_speed_f.Y -= dtime*3*BS;
+	if(hp != oldhp)
+		m_hp_not_sent = true;
 
-	/*
-		Move around if some player is close
-	*/
-	bool player_is_close = false;
-	// Check connected players
-	core::list<Player*> players = m_env->getPlayers(true);
-	core::list<Player*>::Iterator i;
-	for(i = players.begin();
-			i != players.end(); i++)
+	// On death or reincarnation send an active object message
+	if((hp == 0) != (oldhp == 0))
 	{
-		Player *player = *i;
-		v3f playerpos = player->getPosition();
-		if(m_base_position.getDistanceFrom(playerpos) < BS*10.0)
-		{
-			player_is_close = true;
-			break;
-		}
+		// Will send new is_visible value based on (getHP()!=0)
+		m_properties_sent = false;
+		// Send new HP
+		std::string str = gob_cmd_punched(0, getHP());
+		ActiveObjectMessage aom(getId(), true, str);
+		m_messages_out.push_back(aom);
 	}
+}
 
-	m_is_active = player_is_close;
-	
-	if(player_is_close == false)
-	{
-		m_speed_f.X = 0;
-		m_speed_f.Z = 0;
-	}
-	else
-	{
-		// Move around
-		v3f dir(cos(m_yaw/180*PI),0,sin(m_yaw/180*PI));
-		f32 speed = BS/2;
-		m_speed_f.X = speed * dir.X;
-		m_speed_f.Z = speed * dir.Z;
-
-		if(m_touching_ground && (m_oldpos - m_base_position).getLength()
-				< dtime*speed/2)
-		{
-			m_counter1 -= dtime;
-			if(m_counter1 < 0.0)
-			{
-				m_counter1 += 1.0;
-				m_speed_f.Y = 5.0*BS;
-			}
-		}
+void PlayerSAO::setArmorGroups(const ItemGroupList &armor_groups)
+{
+	m_armor_groups = armor_groups;
+	m_armor_groups_sent = false;
+}
 
-		{
-			m_counter2 -= dtime;
-			if(m_counter2 < 0.0)
-			{
-				m_counter2 += (float)(myrand()%100)/100*3.0;
-				m_yaw += ((float)(myrand()%200)-100)/100*180;
-				m_yaw = wrapDegrees(m_yaw);
-			}
-		}
-	}
-	
-	m_oldpos = m_base_position;
+Inventory* PlayerSAO::getInventory()
+{
+	return m_inventory;
+}
+const Inventory* PlayerSAO::getInventory() const
+{
+	return m_inventory;
+}
 
-	/*
-		Move it, with collision detection
-	*/
+InventoryLocation PlayerSAO::getInventoryLocation() const
+{
+	InventoryLocation loc;
+	loc.setPlayer(m_player->getName());
+	return loc;
+}
 
-	core::aabbox3d<f32> box(-BS/3.,-BS*2/3.0,-BS/3., BS/3.,BS*4./3.,BS/3.);
-	collisionMoveResult moveresult;
-	// Maximum movement without glitches
-	f32 pos_max_d = BS*0.25;
-	// Limit speed
-	if(m_speed_f.getLength()*dtime > pos_max_d)
-		m_speed_f *= pos_max_d / (m_speed_f.getLength()*dtime);
-	v3f pos_f = getBasePosition();
-	v3f pos_f_old = pos_f;
-	moveresult = collisionMoveSimple(&m_env->getMap(), pos_max_d,
-			box, dtime, pos_f, m_speed_f);
-	m_touching_ground = moveresult.touching_ground;
-	
-	setBasePosition(pos_f);
+void PlayerSAO::setInventoryModified()
+{
+	m_inventory_not_sent = true;
+}
 
-	if(send_recommended == false)
-		return;
+std::string PlayerSAO::getWieldList() const
+{
+	return "main";
+}
 
-	if(pos_f.getDistanceFrom(m_last_sent_position) > 0.05*BS)
-	{
-		m_last_sent_position = pos_f;
+int PlayerSAO::getWieldIndex() const
+{
+	return m_wield_index;
+}
 
-		std::ostringstream os(std::ios::binary);
-		// command (0 = update position)
-		writeU8(os, 0);
-		// pos
-		writeV3F1000(os, m_base_position);
-		// yaw
-		writeF1000(os, m_yaw);
-		// create message and add to list
-		ActiveObjectMessage aom(getId(), false, os.str());
-		m_messages_out.push_back(aom);
+void PlayerSAO::setWieldIndex(int i)
+{
+	if(i != m_wield_index)
+	{
+		m_wield_index = i;
+		m_wielded_item_not_sent = true;
 	}
 }
 
-std::string FireflySAO::getClientInitializationData()
+void PlayerSAO::disconnected()
 {
-	std::ostringstream os(std::ios::binary);
-	// version
-	writeU8(os, 0);
-	// pos
-	writeV3F1000(os, m_base_position);
-	return os.str();
+	m_peer_id = 0;
+	m_removed = true;
+	if(m_player->getPlayerSAO() == this)
+	{
+		m_player->setPlayerSAO(NULL);
+		m_player->peer_id = 0;
+	}
 }
 
-std::string FireflySAO::getStaticData()
+void PlayerSAO::createCreativeInventory()
 {
-	//dstream<<__FUNCTION_NAME<<std::endl;
-	std::ostringstream os(std::ios::binary);
-	// version
-	writeU8(os, 0);
-	return os.str();
+	if(m_inventory != &m_player->inventory)
+		delete m_inventory;
+
+	m_inventory = new Inventory(m_player->inventory);
+	m_inventory->clearContents();
+	scriptapi_get_creative_inventory(m_env->getLua(), this);
 }
 
-InventoryItem* FireflySAO::createPickedUpItem()
+std::string PlayerSAO::getPropertyPacket()
 {
-	std::istringstream is("CraftItem firefly 1", std::ios_base::binary);
-	InventoryItem *item = InventoryItem::deSerialize(is);
-	return item;
+	core::array<std::string> textures;
+	textures.push_back("player.png");
+	textures.push_back("player_back.png");
+	return gob_cmd_set_properties(
+		PLAYER_MAX_HP,
+		false,
+		75,
+		core::aabbox3d<f32>(-1/3.,-1.0,-1/3., 1/3.,1.0,1/3.),
+		"upright_sprite",
+		v2f(1, 2),
+		textures,
+		v2s16(1,1),
+		(getHP() != 0), // is_visible
+		true // makes_footstep_sound
+	);
 }
+