X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fcontent_sao.cpp;h=4ee92f4d34255408e83f1159cfadb73f359fb26b;hb=b8ba6318d6ed9edd59455674d39ff1d5018393df;hp=5eed17eaf9e854a586a474c28258d3b27e38e8f7;hpb=497ff1ecd64c8908f988e15ca879824f2781e3fd;p=minetest.git

diff --git a/src/content_sao.cpp b/src/content_sao.cpp
index 5eed17eaf..4ee92f4d3 100644
--- a/src/content_sao.cpp
+++ b/src/content_sao.cpp
@@ -1,6 +1,6 @@
 /*
 Minetest
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -27,11 +27,12 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "tool.h" // For ToolCapabilities
 #include "gamedef.h"
 #include "player.h"
-#include "scriptapi.h"
+#include "scripting_game.h"
 #include "genericobject.h"
 #include "util/serialize.h"
+#include "util/mathconstants.h"
 
-core::map<u16, ServerActiveObject::Factory> ServerActiveObject::m_types;
+std::map<u16, ServerActiveObject::Factory> ServerActiveObject::m_types;
 
 /*
 	DummyLoadSAO
@@ -64,6 +65,14 @@ class DummyLoadSAO : public ServerActiveObject
 		infostream<<"DummyLoadSAO step"<<std::endl;
 	}
 
+	bool getCollisionBox(aabb3f *toset) {
+		return false;
+	}
+
+	bool collideWithObjects() {
+		return false;
+	}
+
 private:
 };
 
@@ -132,6 +141,14 @@ class TestSAO : public ServerActiveObject
 		}
 	}
 
+	bool getCollisionBox(aabb3f *toset) {
+		return false;
+	}
+
+	bool collideWithObjects() {
+		return false;
+	}
+
 private:
 	float m_timer1;
 	float m_age;
@@ -174,7 +191,7 @@ class ItemSAO : public ServerActiveObject
 	}
 
 	ItemSAO(ServerEnvironment *env, v3f pos,
-			const std::string itemstring):
+			const std::string &itemstring):
 		ServerActiveObject(env, pos),
 		m_itemstring(itemstring),
 		m_itemstring_changed(false),
@@ -208,8 +225,7 @@ class ItemSAO : public ServerActiveObject
 		v3f pos_f_old = pos_f;
 		v3f accel_f = v3f(0,0,0);
 		f32 stepheight = 0;
-		IGameDef *gamedef = m_env->getGameDef();
-		moveresult = collisionMoveSimple(&m_env->getMap(), gamedef,
+		moveresult = collisionMoveSimple(m_env,m_env->getGameDef(),
 				pos_max_d, box, stepheight, dtime,
 				pos_f, m_speed_f, accel_f);
 		
@@ -314,6 +330,13 @@ class ItemSAO : public ServerActiveObject
 		return 0;
 	}
 
+	bool getCollisionBox(aabb3f *toset) {
+		return false;
+	}
+
+	bool collideWithObjects() {
+		return false;
+	}
 
 private:
 	std::string m_itemstring;
@@ -327,7 +350,7 @@ class ItemSAO : public ServerActiveObject
 ItemSAO proto_ItemSAO(NULL, v3f(0,0,0), "");
 
 ServerActiveObject* createItemSAO(ServerEnvironment *env, v3f pos,
-		const std::string itemstring)
+                                  const std::string &itemstring)
 {
 	return new ItemSAO(env, pos, itemstring);
 }
@@ -370,15 +393,13 @@ LuaEntitySAO::LuaEntitySAO(ServerEnvironment *env, v3f pos,
 	}
 	
 	// Initialize something to armor groups
-	m_armor_groups["fleshy"] = 3;
-	m_armor_groups["snappy"] = 2;
+	m_armor_groups["fleshy"] = 100;
 }
 
 LuaEntitySAO::~LuaEntitySAO()
 {
 	if(m_registered){
-		lua_State *L = m_env->getLua();
-		scriptapi_luaentity_rm(L, m_id);
+		m_env->getScriptIface()->luaentity_Remove(m_id);
 	}
 }
 
@@ -387,16 +408,18 @@ void LuaEntitySAO::addedToEnvironment(u32 dtime_s)
 	ServerActiveObject::addedToEnvironment(dtime_s);
 	
 	// Create entity from name
-	lua_State *L = m_env->getLua();
-	m_registered = scriptapi_luaentity_add(L, m_id, m_init_name.c_str());
+	m_registered = m_env->getScriptIface()->
+		luaentity_Add(m_id, m_init_name.c_str());
 	
 	if(m_registered){
 		// Get properties
-		scriptapi_luaentity_get_properties(L, m_id, &m_prop);
+		m_env->getScriptIface()->
+			luaentity_GetProperties(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(), dtime_s);
+		m_env->getScriptIface()->
+			luaentity_Activate(m_id, m_init_state.c_str(), dtime_s);
 	}
 }
 
@@ -486,14 +509,14 @@ void LuaEntitySAO::step(float dtime, bool send_recommended)
 			box.MaxEdge *= BS;
 			collisionMoveResult moveresult;
 			f32 pos_max_d = BS*0.25; // Distance per iteration
-			f32 stepheight = 0; // Maximum climbable step height
 			v3f p_pos = m_base_position;
 			v3f p_velocity = m_velocity;
 			v3f p_acceleration = m_acceleration;
-			IGameDef *gamedef = m_env->getGameDef();
-			moveresult = collisionMoveSimple(&m_env->getMap(), gamedef,
-					pos_max_d, box, stepheight, dtime,
-					p_pos, p_velocity, p_acceleration);
+			moveresult = collisionMoveSimple(m_env,m_env->getGameDef(),
+					pos_max_d, box, m_prop.stepheight, dtime,
+					p_pos, p_velocity, p_acceleration,
+					this, m_prop.collideWithObjects);
+
 			// Apply results
 			m_base_position = p_pos;
 			m_velocity = p_velocity;
@@ -503,11 +526,15 @@ void LuaEntitySAO::step(float dtime, bool send_recommended)
 					* dtime * m_acceleration;
 			m_velocity += dtime * m_acceleration;
 		}
+
+		if((m_prop.automatic_face_movement_dir) &&
+				(fabs(m_velocity.Z) > 0.001 || fabs(m_velocity.X) > 0.001)){
+			m_yaw = atan2(m_velocity.Z,m_velocity.X) * 180 / M_PI + m_prop.automatic_face_movement_dir_offset;
+		}
 	}
 
 	if(m_registered){
-		lua_State *L = m_env->getLua();
-		scriptapi_luaentity_step(L, m_id, dtime);
+		m_env->getScriptIface()->luaentity_Step(m_id, dtime);
 	}
 
 	if(send_recommended == false)
@@ -617,8 +644,8 @@ std::string LuaEntitySAO::getStaticData()
 	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);
+		std::string state = m_env->getScriptIface()->
+			luaentity_GetStaticdata(m_id);
 		os<<serializeLongString(state);
 	} else {
 		os<<serializeLongString(m_init_state);
@@ -664,8 +691,14 @@ int LuaEntitySAO::punch(v3f dir,
 	{
 		setHP(getHP() - result.damage);
 		
+
+		std::string punchername = "nil";
+
+		if ( puncher != 0 )
+			punchername = puncher->getDescription();
+
 		actionstream<<getDescription()<<" punched by "
-				<<puncher->getDescription()<<", damage "<<result.damage
+				<<punchername<<", damage "<<result.damage
 				<<" hp, health now "<<getHP()<<" hp"<<std::endl;
 		
 		{
@@ -679,8 +712,7 @@ int LuaEntitySAO::punch(v3f dir,
 			m_removed = true;
 	}
 
-	lua_State *L = m_env->getLua();
-	scriptapi_luaentity_punch(L, m_id, puncher,
+	m_env->getScriptIface()->luaentity_Punch(m_id, puncher,
 			time_from_last_punch, toolcap, dir);
 
 	return result.wear;
@@ -693,8 +725,7 @@ void LuaEntitySAO::rightClick(ServerActiveObject *clicker)
 	// It's best that attachments cannot be clicked
 	if(isAttached())
 		return;
-	lua_State *L = m_env->getLua();
-	scriptapi_luaentity_rightclick(L, m_id, clicker);
+	m_env->getScriptIface()->luaentity_Rightclick(m_id, clicker);
 }
 
 void LuaEntitySAO::setPos(v3f pos)
@@ -880,6 +911,26 @@ void LuaEntitySAO::sendPosition(bool do_interpolate, bool is_movement_end)
 	m_messages_out.push_back(aom);
 }
 
+bool LuaEntitySAO::getCollisionBox(aabb3f *toset) {
+	if (m_prop.physical)
+	{
+		//update collision box
+		toset->MinEdge = m_prop.collisionbox.MinEdge * BS;
+		toset->MaxEdge = m_prop.collisionbox.MaxEdge * BS;
+
+		toset->MinEdge += m_base_position;
+		toset->MaxEdge += m_base_position;
+
+		return true;
+	}
+
+	return false;
+}
+
+bool LuaEntitySAO::collideWithObjects(){
+	return m_prop.collideWithObjects;
+}
+
 /*
 	PlayerSAO
 */
@@ -892,8 +943,8 @@ PlayerSAO::PlayerSAO(ServerEnvironment *env_, Player *player_, u16 peer_id_,
 	m_player(player_),
 	m_peer_id(peer_id_),
 	m_inventory(NULL),
+	m_damage(0),
 	m_last_good_position(0,0,0),
-	m_last_good_position_age(0),
 	m_time_from_last_punch(0),
 	m_nocheat_dig_pos(32767, 32767, 32767),
 	m_nocheat_dig_time(0),
@@ -903,21 +954,30 @@ PlayerSAO::PlayerSAO(ServerEnvironment *env_, Player *player_, u16 peer_id_,
 	m_properties_sent(true),
 	m_privs(privs),
 	m_is_singleplayer(is_singleplayer),
+	m_animation_speed(0),
+	m_animation_blend(0),
 	m_animation_sent(false),
 	m_bone_position_sent(false),
+	m_attachment_parent_id(0),
 	m_attachment_sent(false),
 	// public
 	m_moved(false),
 	m_inventory_not_sent(false),
 	m_hp_not_sent(false),
-	m_wielded_item_not_sent(false)
+	m_breath_not_sent(false),
+	m_wielded_item_not_sent(false),
+	m_physics_override_speed(1),
+	m_physics_override_jump(1),
+	m_physics_override_gravity(1),
+	m_physics_override_sneak(true),
+	m_physics_override_sneak_glitch(true),
+	m_physics_override_sent(false)
 {
 	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;
+	m_armor_groups["fleshy"] = 100;
 
 	m_prop.hp_max = PLAYER_MAX_HP;
 	m_prop.physical = false;
@@ -957,7 +1017,6 @@ void PlayerSAO::addedToEnvironment(u32 dtime_s)
 	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;
 }
 
 // Called before removing from environment
@@ -968,6 +1027,8 @@ void PlayerSAO::removingFromEnvironment()
 	{
 		m_player->setPlayerSAO(NULL);
 		m_player->peer_id = 0;
+		m_env->savePlayer(m_player->getName());
+		m_env->removePlayer(m_player->getName());
 	}
 }
 
@@ -995,7 +1056,7 @@ std::string PlayerSAO::getClientInitializationData(u16 protocol_version)
 		writeF1000(os, m_player->getYaw());
 		writeS16(os, getHP());
 
-		writeU8(os, 4 + m_bone_position.size()); // number of messages stuffed in here
+		writeU8(os, 5 + m_bone_position.size()); // 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_update_animation(m_animation_range, m_animation_speed, m_animation_blend)); // 3
@@ -1003,6 +1064,9 @@ std::string PlayerSAO::getClientInitializationData(u16 protocol_version)
 			os<<serializeLongString(gob_cmd_update_bone_position((*ii).first, (*ii).second.X, (*ii).second.Y)); // m_bone_position.size
 		}
 		os<<serializeLongString(gob_cmd_update_attachment(m_attachment_parent_id, m_attachment_bone, m_attachment_position, m_attachment_rotation)); // 4
+		os<<serializeLongString(gob_cmd_update_physics_override(m_physics_override_speed,
+				m_physics_override_jump, m_physics_override_gravity, m_physics_override_sneak,
+				m_physics_override_sneak_glitch)); // 5
 	}
 	else
 	{
@@ -1060,6 +1124,19 @@ void PlayerSAO::step(float dtime, bool send_recommended)
 		m_moved = true;
 	}
 
+	//dstream<<"PlayerSAO::step: dtime: "<<dtime<<std::endl;
+
+	// Set lag pool maximums based on estimated lag
+	const float LAG_POOL_MIN = 5.0;
+	float lag_pool_max = m_env->getMaxLagEstimate() * 2.0;
+	if(lag_pool_max < LAG_POOL_MIN)
+		lag_pool_max = LAG_POOL_MIN;
+	m_dig_pool.setMax(lag_pool_max);
+	m_move_pool.setMax(lag_pool_max);
+
+	// Increment cheat prevention timers
+	m_dig_pool.add(dtime);
+	m_move_pool.add(dtime);
 	m_time_from_last_punch += dtime;
 	m_nocheat_dig_time += dtime;
 
@@ -1069,66 +1146,8 @@ void PlayerSAO::step(float dtime, bool send_recommended)
 	{
 		v3f pos = m_env->getActiveObject(m_attachment_parent_id)->getBasePosition();
 		m_last_good_position = pos;
-		m_last_good_position_age = 0;
 		m_player->setPosition(pos);
 	}
-	else
-	{
-		if(m_is_singleplayer || g_settings->getBool("disable_anticheat"))
-		{
-			m_last_good_position = m_player->getPosition();
-			m_last_good_position_age = 0;
-		}
-		else
-		{
-			/*
-				Check player movements
-
-				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. Altough a node-based alternative might be possible
-				too, and much more lightweight.
-			*/
-
-			float player_max_speed = 0;
-			float player_max_speed_up = 0;
-			if(m_privs.count("fast") != 0){
-				// Fast speed
-				player_max_speed = BS * 20;
-				player_max_speed_up = BS * 20;
-			} else {
-				// Normal speed
-				player_max_speed = BS * 4.0;
-				player_max_speed_up = BS * 4.0;
-			}
-			// Tolerance
-			player_max_speed *= 2.5;
-			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_moved = true;
-				}
-				m_last_good_position_age = 0;
-			}
-		}
-	}
 
 	if(send_recommended == false)
 		return;
@@ -1172,6 +1191,16 @@ void PlayerSAO::step(float dtime, bool send_recommended)
 		m_messages_out.push_back(aom);
 	}
 
+	if(m_physics_override_sent == false){
+		m_physics_override_sent = true;
+		std::string str = gob_cmd_update_physics_override(m_physics_override_speed,
+				m_physics_override_jump, m_physics_override_gravity,
+				m_physics_override_sneak, m_physics_override_sneak_glitch);
+		// create message and add to list
+		ActiveObjectMessage aom(getId(), true, str);
+		m_messages_out.push_back(aom);
+	}
+
 	if(m_animation_sent == false){
 		m_animation_sent = true;
 		std::string str = gob_cmd_update_animation(m_animation_range, m_animation_speed, m_animation_blend);
@@ -1213,7 +1242,6 @@ void PlayerSAO::setPos(v3f pos)
 	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_moved = true;
 }
@@ -1225,11 +1253,24 @@ void PlayerSAO::moveTo(v3f pos, bool continuous)
 	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_moved = true;
 }
 
+void PlayerSAO::setYaw(float yaw)
+{
+	m_player->setYaw(yaw);
+	// Force change on client
+	m_moved = true;
+}
+
+void PlayerSAO::setPitch(float pitch)
+{
+	m_player->setPitch(pitch);
+	// Force change on client
+	m_moved = true;
+}
+
 int PlayerSAO::punch(v3f dir,
 	const ToolCapabilities *toolcap,
 	ServerActiveObject *puncher,
@@ -1256,20 +1297,17 @@ int PlayerSAO::punch(v3f dir,
 	HitParams hitparams = getHitParams(m_armor_groups, toolcap,
 			time_from_last_punch);
 
+	std::string punchername = "nil";
+
+	if ( puncher != 0 )
+		punchername = puncher->getDescription();
+
 	actionstream<<"Player "<<m_player->getName()<<" punched by "
-			<<puncher->getDescription()<<", damage "<<hitparams.hp
+			<<punchername<<", damage "<<hitparams.hp
 			<<" HP"<<std::endl;
 
 	setHP(getHP() - hitparams.hp);
 
-	if(hitparams.hp != 0)
-	{
-		std::string str = gob_cmd_punched(hitparams.hp, getHP());
-		// create message and add to list
-		ActiveObjectMessage aom(getId(), true, str);
-		m_messages_out.push_back(aom);
-	}
-
 	return hitparams.wear;
 }
 
@@ -1282,6 +1320,13 @@ s16 PlayerSAO::getHP() const
 	return m_player->hp;
 }
 
+s16 PlayerSAO::readDamage()
+{
+	s16 damage = m_damage;
+	m_damage = 0;
+	return damage;
+}
+
 void PlayerSAO::setHP(s16 hp)
 {
 	s16 oldhp = m_player->hp;
@@ -1299,19 +1344,25 @@ void PlayerSAO::setHP(s16 hp)
 
 	m_player->hp = hp;
 
-	if(hp != oldhp)
+	if(hp != oldhp) {
 		m_hp_not_sent = true;
+		if(oldhp > hp)
+			m_damage += oldhp - hp;
+	}
 
-	// On death or reincarnation send an active object message
+	// Update properties on death
 	if((hp == 0) != (oldhp == 0))
-	{
-		// 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);
-	}
+}
+
+u16 PlayerSAO::getBreath() const
+{
+	return m_player->getBreath();
+}
+
+void PlayerSAO::setBreath(u16 breath)
+{
+	m_player->setBreath(breath);
 }
 
 void PlayerSAO::setArmorGroups(const ItemGroupList &armor_groups)
@@ -1420,3 +1471,73 @@ std::string PlayerSAO::getPropertyPacket()
 	return gob_cmd_set_properties(m_prop);
 }
 
+bool PlayerSAO::checkMovementCheat()
+{
+	bool cheated = false;
+	if(isAttached() || m_is_singleplayer ||
+			g_settings->getBool("disable_anticheat"))
+	{
+		m_last_good_position = m_player->getPosition();
+	}
+	else
+	{
+		/*
+			Check player movements
+
+			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. Altough a node-based alternative might be possible
+			too, and much more lightweight.
+		*/
+
+		float player_max_speed = 0;
+		float player_max_speed_up = 0;
+		if(m_privs.count("fast") != 0){
+			// Fast speed
+			player_max_speed = m_player->movement_speed_fast;
+			player_max_speed_up = m_player->movement_speed_fast;
+		} else {
+			// Normal speed
+			player_max_speed = m_player->movement_speed_walk;
+			player_max_speed_up = m_player->movement_speed_walk;
+		}
+		// Tolerance. With the lag pool we shouldn't need it.
+		//player_max_speed *= 2.5;
+		//player_max_speed_up *= 2.5;
+
+		v3f diff = (m_player->getPosition() - m_last_good_position);
+		float d_vert = diff.Y;
+		diff.Y = 0;
+		float d_horiz = diff.getLength();
+		float required_time = d_horiz/player_max_speed;
+		if(d_vert > 0 && d_vert/player_max_speed > required_time)
+			required_time = d_vert/player_max_speed;
+		if(m_move_pool.grab(required_time)){
+			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_moved = true;
+			cheated = true;
+		}
+	}
+	return cheated;
+}
+
+bool PlayerSAO::getCollisionBox(aabb3f *toset) {
+	//update collision box
+	*toset = m_player->getCollisionbox();
+
+	toset->MinEdge += m_base_position;
+	toset->MaxEdge += m_base_position;
+
+	return true;
+}
+
+bool PlayerSAO::collideWithObjects(){
+	return true;
+}
+