X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fplayer.cpp;h=3bde8a56324f0bf193ab4c8a90ca29cc87f01d4b;hb=7df125c249dc9b99b66f047a395106c2038eb00e;hp=9817d590d125ca48785692a1165efb1d1651424a;hpb=25a7fabed83caccb2c321bb4d080c5907f37b60a;p=dragonfireclient.git

diff --git a/src/player.cpp b/src/player.cpp
index 9817d590d..3bde8a563 100644
--- a/src/player.cpp
+++ b/src/player.cpp
@@ -30,7 +30,11 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 Player::Player():
 	touching_ground(false),
 	in_water(false),
+	in_water_stable(false),
+	swimming_up(false),
 	peer_id(PEER_ID_INEXISTENT),
+	m_pitch(0),
+	m_yaw(0),
 	m_speed(0,0,0),
 	m_position(0,0,0)
 {
@@ -231,7 +235,7 @@ void RemotePlayer::updateName(const char *name)
 	}
 }
 
-void RemotePlayer::move(f32 dtime, Map &map)
+void RemotePlayer::move(f32 dtime, Map &map, f32 pos_max_d)
 {
 	m_pos_animation_time_counter += dtime;
 	m_pos_animation_counter += dtime;
@@ -255,7 +259,9 @@ void RemotePlayer::move(f32 dtime, Map &map)
 	LocalPlayer
 */
 
-LocalPlayer::LocalPlayer()
+LocalPlayer::LocalPlayer():
+	m_sneak_node(32767,32767,32767),
+	m_sneak_node_exists(false)
 {
 }
 
@@ -263,23 +269,23 @@ LocalPlayer::~LocalPlayer()
 {
 }
 
-void LocalPlayer::move(f32 dtime, Map &map)
+void LocalPlayer::move(f32 dtime, Map &map, f32 pos_max_d)
 {
 	v3f position = getPosition();
 	v3f oldpos = position;
-	v3s16 oldpos_i = floatToInt(oldpos);
+	v3s16 oldpos_i = floatToInt(oldpos, BS);
 
 	/*std::cout<<"oldpos_i=("<<oldpos_i.X<<","<<oldpos_i.Y<<","
 			<<oldpos_i.Z<<")"<<std::endl;*/
 
+	/*
+		Calculate new position
+	*/
 	position += m_speed * dtime;
 
+	// Skip collision detection if a special movement mode is used
 	bool free_move = g_settings.getBool("free_move");
-	bool terrain_viewer = g_settings.getBool("terrain_viewer");
-	
-	// Skip collision detection if player is non-local or
-	// a special movement mode is used
-	if(isLocal() == false || free_move || terrain_viewer)
+	if(free_move)
 	{
 		setPosition(position);
 		return;
@@ -288,21 +294,24 @@ void LocalPlayer::move(f32 dtime, Map &map)
 	/*
 		Collision detection
 	*/
-
-	v3s16 pos_i = floatToInt(position);
+	
+	// Player position in nodes
+	v3s16 pos_i = floatToInt(position, BS);
 	
 	/*
-		Check if player is in water
+		Check if player is in water (the oscillating value)
 	*/
 	try{
+		// If in water, the threshold of coming out is at higher y
 		if(in_water)
 		{
-			v3s16 pp = floatToInt(position + v3f(0,0,0));
+			v3s16 pp = floatToInt(position + v3f(0,BS*0.1,0), BS);
 			in_water = content_liquid(map.getNode(pp).d);
 		}
+		// If not in water, the threshold of going in is at lower y
 		else
 		{
-			v3s16 pp = floatToInt(position + v3f(0,BS/2,0));
+			v3s16 pp = floatToInt(position + v3f(0,BS*0.5,0), BS);
 			in_water = content_liquid(map.getNode(pp).d);
 		}
 	}
@@ -311,31 +320,88 @@ void LocalPlayer::move(f32 dtime, Map &map)
 		in_water = false;
 	}
 
-	// The frame length is limited to the player going 0.1*BS per call
-	f32 d = (float)BS * 0.15;
+	/*
+		Check if player is in water (the stable value)
+	*/
+	try{
+		v3s16 pp = floatToInt(position + v3f(0,0,0), BS);
+		in_water_stable = content_liquid(map.getNode(pp).d);
+	}
+	catch(InvalidPositionException &e)
+	{
+		in_water_stable = false;
+	}
 
-#define PLAYER_RADIUS (BS*0.3)
-#define PLAYER_HEIGHT (BS*1.7)
+	/*
+		Collision uncertainty radius
+		Make it a bit larger than the maximum distance of movement
+	*/
+	//f32 d = pos_max_d * 1.1;
+	// A fairly large value in here makes moving smoother
+	f32 d = 0.15*BS;
 
+	// This should always apply, otherwise there are glitches
+	assert(d > pos_max_d);
+
+	float player_radius = BS*0.35;
+	float player_height = BS*1.7;
+	
+	// Maximum distance over border for sneaking
+	f32 sneak_max = BS*0.4;
+
+	/*
+		If sneaking, player has larger collision radius to keep from
+		falling
+	*/
+	/*if(control.sneak)
+		player_radius = sneak_max + d*1.1;*/
+	
+	/*
+		If sneaking, keep in range from the last walked node and don't
+		fall off from it
+	*/
+	if(control.sneak && m_sneak_node_exists)
+	{
+		f32 maxd = 0.5*BS + sneak_max;
+		v3f lwn_f = intToFloat(m_sneak_node, BS);
+		position.X = rangelim(position.X, lwn_f.X-maxd, lwn_f.X+maxd);
+		position.Z = rangelim(position.Z, lwn_f.Z-maxd, lwn_f.Z+maxd);
+		
+		f32 min_y = lwn_f.Y + 0.5*BS;
+		if(position.Y < min_y)
+		{
+			position.Y = min_y;
+			if(m_speed.Y < 0)
+				m_speed.Y = 0;
+		}
+	}
+
+	/*
+		Calculate player collision box (new and old)
+	*/
 	core::aabbox3d<f32> playerbox(
-		position.X - PLAYER_RADIUS,
+		position.X - player_radius,
 		position.Y - 0.0,
-		position.Z - PLAYER_RADIUS,
-		position.X + PLAYER_RADIUS,
-		position.Y + PLAYER_HEIGHT,
-		position.Z + PLAYER_RADIUS
+		position.Z - player_radius,
+		position.X + player_radius,
+		position.Y + player_height,
+		position.Z + player_radius
 	);
 	core::aabbox3d<f32> playerbox_old(
-		oldpos.X - PLAYER_RADIUS,
+		oldpos.X - player_radius,
 		oldpos.Y - 0.0,
-		oldpos.Z - PLAYER_RADIUS,
-		oldpos.X + PLAYER_RADIUS,
-		oldpos.Y + PLAYER_HEIGHT,
-		oldpos.Z + PLAYER_RADIUS
+		oldpos.Z - player_radius,
+		oldpos.X + player_radius,
+		oldpos.Y + player_height,
+		oldpos.Z + player_radius
 	);
 
-	//hilightboxes.push_back(playerbox);
+	/*
+		If the player's feet touch the topside of any node, this is
+		set to true.
 
+		Player is allowed to jump when this is true.
+	*/
 	touching_ground = false;
 	
 	/*std::cout<<"Checking collisions for ("
@@ -343,88 +409,204 @@ void LocalPlayer::move(f32 dtime, Map &map)
 			<<") -> ("
 			<<pos_i.X<<","<<pos_i.Y<<","<<pos_i.Z
 			<<"):"<<std::endl;*/
+	
+	/*
+		Go through every node around the player
+	*/
+	for(s16 y = oldpos_i.Y - 1; y <= oldpos_i.Y + 2; y++)
+	for(s16 z = oldpos_i.Z - 1; z <= oldpos_i.Z + 1; z++)
+	for(s16 x = oldpos_i.X - 1; x <= oldpos_i.X + 1; x++)
+	{
+		try{
+			// Player collides into walkable nodes
+			if(content_walkable(map.getNode(v3s16(x,y,z)).d) == false)
+				continue;
+		}
+		catch(InvalidPositionException &e)
+		{
+			// Doing nothing here will block the player from
+			// walking over map borders
+		}
 
-	for(s16 y = oldpos_i.Y - 1; y <= oldpos_i.Y + 2; y++){
-		for(s16 z = oldpos_i.Z - 1; z <= oldpos_i.Z + 1; z++){
-			for(s16 x = oldpos_i.X - 1; x <= oldpos_i.X + 1; x++){
-				try{
-					if(content_walkable(map.getNode(v3s16(x,y,z)).d) == false){
-						continue;
-					}
-				}
-				catch(InvalidPositionException &e)
+		core::aabbox3d<f32> nodebox = getNodeBox(v3s16(x,y,z), BS);
+		
+		/*
+			See if the player is touching ground.
+
+			Player touches ground if player's minimum Y is near node's
+			maximum Y and player's X-Z-area overlaps with the node's
+			X-Z-area.
+
+			Use 0.15*BS so that it is easier to get on a node.
+		*/
+		if(
+				//fabs(nodebox.MaxEdge.Y-playerbox.MinEdge.Y) < d
+				fabs(nodebox.MaxEdge.Y-playerbox.MinEdge.Y) < 0.15*BS
+				&& nodebox.MaxEdge.X-d > playerbox.MinEdge.X
+				&& nodebox.MinEdge.X+d < playerbox.MaxEdge.X
+				&& nodebox.MaxEdge.Z-d > playerbox.MinEdge.Z
+				&& nodebox.MinEdge.Z+d < playerbox.MaxEdge.Z
+		){
+			touching_ground = true;
+		}
+		
+		// If player doesn't intersect with node, ignore node.
+		if(playerbox.intersectsWithBox(nodebox) == false)
+			continue;
+		
+		/*
+			Go through every axis
+		*/
+		v3f dirs[3] = {
+			v3f(0,0,1), // back-front
+			v3f(0,1,0), // top-bottom
+			v3f(1,0,0), // right-left
+		};
+		for(u16 i=0; i<3; i++)
+		{
+			/*
+				Calculate values along the axis
+			*/
+			f32 nodemax = nodebox.MaxEdge.dotProduct(dirs[i]);
+			f32 nodemin = nodebox.MinEdge.dotProduct(dirs[i]);
+			f32 playermax = playerbox.MaxEdge.dotProduct(dirs[i]);
+			f32 playermin = playerbox.MinEdge.dotProduct(dirs[i]);
+			f32 playermax_old = playerbox_old.MaxEdge.dotProduct(dirs[i]);
+			f32 playermin_old = playerbox_old.MinEdge.dotProduct(dirs[i]);
+			
+			/*
+				Check collision for the axis.
+				Collision happens when player is going through a surface.
+			*/
+			/*f32 neg_d = d;
+			f32 pos_d = d;
+			// Make it easier to get on top of a node
+			if(i == 1)
+				neg_d = 0.15*BS;
+			bool negative_axis_collides =
+				(nodemax > playermin && nodemax <= playermin_old + neg_d
+					&& m_speed.dotProduct(dirs[i]) < 0);
+			bool positive_axis_collides =
+				(nodemin < playermax && nodemin >= playermax_old - pos_d
+					&& m_speed.dotProduct(dirs[i]) > 0);*/
+			bool negative_axis_collides =
+				(nodemax > playermin && nodemax <= playermin_old + d
+					&& m_speed.dotProduct(dirs[i]) < 0);
+			bool positive_axis_collides =
+				(nodemin < playermax && nodemin >= playermax_old - d
+					&& m_speed.dotProduct(dirs[i]) > 0);
+			bool main_axis_collides =
+					negative_axis_collides || positive_axis_collides;
+			
+			/*
+				Check overlap of player and node in other axes
+			*/
+			bool other_axes_overlap = true;
+			for(u16 j=0; j<3; j++)
+			{
+				if(j == i)
+					continue;
+				f32 nodemax = nodebox.MaxEdge.dotProduct(dirs[j]);
+				f32 nodemin = nodebox.MinEdge.dotProduct(dirs[j]);
+				f32 playermax = playerbox.MaxEdge.dotProduct(dirs[j]);
+				f32 playermin = playerbox.MinEdge.dotProduct(dirs[j]);
+				if(!(nodemax - d > playermin && nodemin + d < playermax))
 				{
-					// Doing nothing here will block the player from
-					// walking over map borders
+					other_axes_overlap = false;
+					break;
 				}
+			}
+			
+			/*
+				If this is a collision, revert the position in the main
+				direction.
+			*/
+			if(other_axes_overlap && main_axis_collides)
+			{
+				m_speed -= m_speed.dotProduct(dirs[i]) * dirs[i];
+				position -= position.dotProduct(dirs[i]) * dirs[i];
+				position += oldpos.dotProduct(dirs[i]) * dirs[i];
+			}
+		
+		}
+	} // xyz
 
-				core::aabbox3d<f32> nodebox = Map::getNodeBox(
-						v3s16(x,y,z));
-				
-				// See if the player is touching ground
-				if(
-						fabs(nodebox.MaxEdge.Y-playerbox.MinEdge.Y) < d
-						&& nodebox.MaxEdge.X-d > playerbox.MinEdge.X
-						&& nodebox.MinEdge.X+d < playerbox.MaxEdge.X
-						&& nodebox.MaxEdge.Z-d > playerbox.MinEdge.Z
-						&& nodebox.MinEdge.Z+d < playerbox.MaxEdge.Z
-				){
-					touching_ground = true;
-				}
-				
-				if(playerbox.intersectsWithBox(nodebox))
-				{
-				
-	v3f dirs[3] = {
-		v3f(0,0,1), // back
-		v3f(0,1,0), // top
-		v3f(1,0,0), // right
-	};
-	for(u16 i=0; i<3; i++)
+	/*
+		Check the nodes under the player to see from which node the
+		player is sneaking from, if any.
+	*/
 	{
-		f32 nodemax = nodebox.MaxEdge.dotProduct(dirs[i]);
-		f32 nodemin = nodebox.MinEdge.dotProduct(dirs[i]);
-		f32 playermax = playerbox.MaxEdge.dotProduct(dirs[i]);
-		f32 playermin = playerbox.MinEdge.dotProduct(dirs[i]);
-		f32 playermax_old = playerbox_old.MaxEdge.dotProduct(dirs[i]);
-		f32 playermin_old = playerbox_old.MinEdge.dotProduct(dirs[i]);
-
-		bool main_edge_collides = 
-			((nodemax > playermin && nodemax <= playermin_old + d
-				&& m_speed.dotProduct(dirs[i]) < 0)
-			||
-			(nodemin < playermax && nodemin >= playermax_old - d
-				&& m_speed.dotProduct(dirs[i]) > 0));
-
-		bool other_edges_collide = true;
-		for(u16 j=0; j<3; j++)
+		v3s16 pos_i_bottom = floatToInt(position - v3f(0,BS/2,0), BS);
+		v2f player_p2df(position.X, position.Z);
+		f32 min_distance_f = 100000.0*BS;
+		// If already seeking from some node, compare to it.
+		/*if(m_sneak_node_exists)
 		{
-			if(j == i)
+			v3f sneaknode_pf = intToFloat(m_sneak_node, BS);
+			v2f sneaknode_p2df(sneaknode_pf.X, sneaknode_pf.Z);
+			f32 d_horiz_f = player_p2df.getDistanceFrom(sneaknode_p2df);
+			f32 d_vert_f = fabs(sneaknode_pf.Y + BS*0.5 - position.Y);
+			// Ignore if player is not on the same level (likely dropped)
+			if(d_vert_f < 0.15*BS)
+				min_distance_f = d_horiz_f;
+		}*/
+		v3s16 new_sneak_node = m_sneak_node;
+		for(s16 x=-1; x<=1; x++)
+		for(s16 z=-1; z<=1; z++)
+		{
+			v3s16 p = pos_i_bottom + v3s16(x,0,z);
+			v3f pf = intToFloat(p, BS);
+			v2f node_p2df(pf.X, pf.Z);
+			f32 distance_f = player_p2df.getDistanceFrom(node_p2df);
+			f32 max_axis_distance_f = MYMAX(
+					fabs(player_p2df.X-node_p2df.X),
+					fabs(player_p2df.Y-node_p2df.Y));
+					
+			if(distance_f > min_distance_f ||
+					max_axis_distance_f > 0.5*BS + sneak_max + 0.1*BS)
 				continue;
-			f32 nodemax = nodebox.MaxEdge.dotProduct(dirs[j]);
-			f32 nodemin = nodebox.MinEdge.dotProduct(dirs[j]);
-			f32 playermax = playerbox.MaxEdge.dotProduct(dirs[j]);
-			f32 playermin = playerbox.MinEdge.dotProduct(dirs[j]);
-			if(!(nodemax - d > playermin && nodemin + d < playermax))
+
+			try{
+				// The node to be sneaked on has to be walkable
+				if(content_walkable(map.getNode(p).d) == false)
+					continue;
+				// And the node above it has to be nonwalkable
+				if(content_walkable(map.getNode(p+v3s16(0,1,0)).d) == true)
+					continue;
+			}
+			catch(InvalidPositionException &e)
 			{
-				other_edges_collide = false;
-				break;
+				continue;
 			}
+
+			min_distance_f = distance_f;
+			new_sneak_node = p;
 		}
 		
-		if(main_edge_collides && other_edges_collide)
+		bool sneak_node_found = (min_distance_f < 100000.0*BS*0.9);
+		
+		if(control.sneak && m_sneak_node_exists)
 		{
-			m_speed -= m_speed.dotProduct(dirs[i]) * dirs[i];
-			position -= position.dotProduct(dirs[i]) * dirs[i];
-			position += oldpos.dotProduct(dirs[i]) * dirs[i];
+			if(sneak_node_found)
+				m_sneak_node = new_sneak_node;
+		}
+		else
+		{
+			m_sneak_node = new_sneak_node;
+			m_sneak_node_exists = sneak_node_found;
 		}
-	
-	}
-				} // if(playerbox.intersectsWithBox(nodebox))
-			} // for x
-		} // for z
-	} // for y
 
+		/*
+			If sneaking, the player's collision box can be in air, so
+			this has to be set explicitly
+		*/
+		if(sneak_node_found && control.sneak)
+			touching_ground = true;
+	}
+	
+	/*
+		Set new position
+	*/
 	setPosition(position);
 }
 
@@ -434,10 +616,8 @@ void LocalPlayer::applyControl(float dtime)
 	swimming_up = false;
 
 	// Random constants
-#define WALK_ACCELERATION (4.0 * BS)
-#define WALKSPEED_MAX (4.0 * BS)
-	f32 walk_acceleration = WALK_ACCELERATION;
-	f32 walkspeed_max = WALKSPEED_MAX;
+	f32 walk_acceleration = 4.0 * BS;
+	f32 walkspeed_max = 4.0 * BS;
 	
 	setPitch(control.pitch);
 	setYaw(control.yaw);
@@ -523,13 +703,20 @@ void LocalPlayer::applyControl(float dtime)
 		else if(touching_ground)
 		{
 			v3f speed = getSpeed();
+			/*
+				NOTE: The d value in move() affects jump height by
+				raising the height at which the jump speed is kept
+				at its starting value
+			*/
 			speed.Y = 6.5*BS;
 			setSpeed(speed);
 		}
+		// Use the oscillating value for getting out of water
+		// (so that the player doesn't fly on the surface)
 		else if(in_water)
 		{
 			v3f speed = getSpeed();
-			speed.Y = 2.0*BS;
+			speed.Y = 1.5*BS;
 			setSpeed(speed);
 			swimming_up = true;
 		}
@@ -537,7 +724,9 @@ void LocalPlayer::applyControl(float dtime)
 
 	// The speed of the player (Y is ignored)
 	if(superspeed)
-		speed = speed.normalize() * walkspeed_max * 5;
+		speed = speed.normalize() * walkspeed_max * 5.0;
+	else if(control.sneak)
+		speed = speed.normalize() * walkspeed_max / 3.0;
 	else
 		speed = speed.normalize() * walkspeed_max;