minetest/src/client/localplayer.cpp

1213 lines
36 KiB
C++
Raw Normal View History

/*
2013-02-24 18:40:43 +01:00
Minetest
2013-02-24 19:38:45 +01:00
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
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "localplayer.h"
#include <cmath>
#include "mtevent.h"
#include "collision.h"
#include "nodedef.h"
#include "settings.h"
#include "environment.h"
#include "map.h"
#include "client.h"
#include "content_cao.h"
/*
LocalPlayer
*/
LocalPlayer::LocalPlayer(Client *client, const char *name):
Player(name, client->idef()),
m_client(client)
{
}
static aabb3f getNodeBoundingBox(const std::vector<aabb3f> &nodeboxes)
{
if (nodeboxes.empty())
2019-08-21 16:23:48 +02:00
return aabb3f(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
aabb3f b_max;
std::vector<aabb3f>::const_iterator it = nodeboxes.begin();
b_max = aabb3f(it->MinEdge, it->MaxEdge);
++it;
for (; it != nodeboxes.end(); ++it)
b_max.addInternalBox(*it);
return b_max;
}
bool LocalPlayer::updateSneakNode(Map *map, const v3f &position,
2019-08-21 16:23:48 +02:00
const v3f &sneak_max)
{
// Acceptable distance to node center
// This must be > 0.5 units to get the sneak ladder to work
// 0.05 prevents sideways teleporting through 1/16 thick walls
constexpr f32 allowed_range = (0.5f + 0.05f) * BS;
static const v3s16 dir9_center[9] = {
v3s16( 0, 0, 0),
v3s16( 1, 0, 0),
v3s16(-1, 0, 0),
v3s16( 0, 0, 1),
v3s16( 0, 0, -1),
v3s16( 1, 0, 1),
v3s16(-1, 0, 1),
v3s16( 1, 0, -1),
v3s16(-1, 0, -1)
};
const NodeDefManager *nodemgr = m_client->ndef();
MapNode node;
bool is_valid_position;
bool new_sneak_node_exists = m_sneak_node_exists;
// We want the top of the sneak node to be below the players feet
f32 position_y_mod = 0.02f * BS;
if (m_sneak_node_exists)
position_y_mod = m_sneak_node_bb_top.MaxEdge.Y - position_y_mod;
// Get position of current standing node
2019-08-21 16:23:48 +02:00
const v3s16 current_node = floatToInt(position - v3f(0.0f, position_y_mod, 0.0f), BS);
if (current_node != m_sneak_node) {
new_sneak_node_exists = false;
} else {
node = map->getNode(current_node, &is_valid_position);
if (!is_valid_position || !nodemgr->get(node).walkable)
new_sneak_node_exists = false;
}
// Keep old sneak node
if (new_sneak_node_exists)
return true;
// Get new sneak node
m_sneak_ladder_detected = false;
f32 min_distance_sq = HUGE_VALF;
for (const auto &d : dir9_center) {
const v3s16 p = current_node + d;
node = map->getNode(p, &is_valid_position);
// The node to be sneaked on has to be walkable
if (!is_valid_position || !nodemgr->get(node).walkable)
continue;
v3f pf = intToFloat(p, BS);
{
std::vector<aabb3f> nodeboxes;
node.getCollisionBoxes(nodemgr, &nodeboxes);
pf += getNodeBoundingBox(nodeboxes).getCenter();
}
const v2f diff(position.X - pf.X, position.Z - pf.Z);
const f32 distance_sq = diff.getLengthSQ();
if (distance_sq > min_distance_sq ||
std::fabs(diff.X) > allowed_range + sneak_max.X ||
std::fabs(diff.Y) > allowed_range + sneak_max.Z)
continue;
// And the node(s) above have to be nonwalkable
bool ok = true;
if (!physics_override.sneak_glitch) {
2019-08-21 16:23:48 +02:00
u16 height =
ceilf((m_collisionbox.MaxEdge.Y - m_collisionbox.MinEdge.Y) / BS);
for (u16 y = 1; y <= height; y++) {
node = map->getNode(p + v3s16(0, y, 0), &is_valid_position);
if (!is_valid_position || nodemgr->get(node).walkable) {
ok = false;
break;
}
}
} else {
// legacy behavior: check just one node
node = map->getNode(p + v3s16(0, 1, 0), &is_valid_position);
ok = is_valid_position && !nodemgr->get(node).walkable;
}
if (!ok)
continue;
min_distance_sq = distance_sq;
m_sneak_node = p;
new_sneak_node_exists = true;
}
if (!new_sneak_node_exists)
return false;
// Update saved top bounding box of sneak node
node = map->getNode(m_sneak_node);
std::vector<aabb3f> nodeboxes;
node.getCollisionBoxes(nodemgr, &nodeboxes);
m_sneak_node_bb_top = getNodeBoundingBox(nodeboxes);
if (physics_override.sneak_glitch) {
// Detect sneak ladder:
// Node two meters above sneak node must be solid
node = map->getNode(m_sneak_node + v3s16(0, 2, 0),
&is_valid_position);
if (is_valid_position && nodemgr->get(node).walkable) {
// Node three meters above: must be non-solid
node = map->getNode(m_sneak_node + v3s16(0, 3, 0),
&is_valid_position);
m_sneak_ladder_detected = is_valid_position &&
!nodemgr->get(node).walkable;
}
}
return true;
}
2014-04-15 19:49:32 +02:00
void LocalPlayer::move(f32 dtime, Environment *env, f32 pos_max_d,
std::vector<CollisionInfo> *collision_info)
{
2019-08-21 16:23:48 +02:00
// Node at feet position, update each ClientEnvironment::step()
if (!collision_info || collision_info->empty())
m_standing_node = floatToInt(m_position, BS);
// Temporary option for old move code
if (!physics_override.new_move) {
old_move(dtime, env, pos_max_d, collision_info);
return;
}
Map *map = &env->getMap();
const NodeDefManager *nodemgr = m_client->ndef();
v3f position = getPosition();
Update attachments at the ending of the addToScene function for parents. And with this... *drum roll* Client-side attachments are at last functional and stick visibly. Fix the last segmentation fault (apparently). So far attachments seem to be fully functional, although removing the parent causes children to go to origin 0,0,0 and possibly still cause such a fault (though this should already be addressed) Fix a bug in falling code where entities get stuck Also check if the parent has been removed server-side, and detach the child if so. Fixes children going to origin 0,0,0 when their parent is removed. Unset all attachment properties when permanently detaching (on both the client and server). Also store less data we don't need Create a separate function for detaching, and also update lua api documentation When a child is detached, update its position from the server to clients. This WILL cause it to get positioned slightly differently client side, as the server attachment system only copies parent origin and knows not about mesh / bone transformation. This prevents different clients seeing the object detached in different spots which is most correct Update the position of attached players to clients. An attached player will see himself move, but this is currently VERY ugly and laggy as it is done by the server (it probably must stay this way too) Use a different approach for locally attached players. This allows for smooth positio transitions to work, as well at the player turning around freely. Still buggy however
2012-11-07 17:42:38 +01:00
// Copy parent position if local player is attached
if (getParent()) {
setPosition(m_cao->getPosition());
m_added_velocity = v3f(0.0f); // ignored
Update attachments at the ending of the addToScene function for parents. And with this... *drum roll* Client-side attachments are at last functional and stick visibly. Fix the last segmentation fault (apparently). So far attachments seem to be fully functional, although removing the parent causes children to go to origin 0,0,0 and possibly still cause such a fault (though this should already be addressed) Fix a bug in falling code where entities get stuck Also check if the parent has been removed server-side, and detach the child if so. Fixes children going to origin 0,0,0 when their parent is removed. Unset all attachment properties when permanently detaching (on both the client and server). Also store less data we don't need Create a separate function for detaching, and also update lua api documentation When a child is detached, update its position from the server to clients. This WILL cause it to get positioned slightly differently client side, as the server attachment system only copies parent origin and knows not about mesh / bone transformation. This prevents different clients seeing the object detached in different spots which is most correct Update the position of attached players to clients. An attached player will see himself move, but this is currently VERY ugly and laggy as it is done by the server (it probably must stay this way too) Use a different approach for locally attached players. This allows for smooth positio transitions to work, as well at the player turning around freely. Still buggy however
2012-11-07 17:42:38 +01:00
return;
}
PlayerSettings &player_settings = getPlayerSettings();
// Skip collision detection if noclip mode is used
bool fly_allowed = m_client->checkLocalPrivilege("fly");
bool noclip = m_client->checkLocalPrivilege("noclip") && player_settings.noclip;
bool free_move = player_settings.free_move && fly_allowed;
if (noclip && free_move) {
position += m_speed * dtime;
setPosition(position);
touching_ground = false;
m_added_velocity = v3f(0.0f); // ignored
return;
}
m_speed += m_added_velocity;
m_added_velocity = v3f(0.0f);
/*
Collision detection
*/
bool is_valid_position;
MapNode node;
v3s16 pp;
/*
2013-02-08 21:54:01 +01:00
Check if player is in liquid (the oscillating value)
*/
// If in liquid, the threshold of coming out is at higher y
if (in_liquid)
{
2019-08-21 16:23:48 +02:00
pp = floatToInt(position + v3f(0.0f, BS * 0.1f, 0.0f), BS);
node = map->getNode(pp, &is_valid_position);
if (is_valid_position) {
const ContentFeatures &cf = nodemgr->get(node.getContent());
in_liquid = cf.liquid_move_physics;
move_resistance = cf.move_resistance;
} else {
in_liquid = false;
}
2019-08-21 16:23:48 +02:00
} else {
// If not in liquid, the threshold of going in is at lower y
pp = floatToInt(position + v3f(0.0f, BS * 0.5f, 0.0f), BS);
node = map->getNode(pp, &is_valid_position);
if (is_valid_position) {
const ContentFeatures &cf = nodemgr->get(node.getContent());
in_liquid = cf.liquid_move_physics;
move_resistance = cf.move_resistance;
} else {
in_liquid = false;
}
}
/*
2013-02-08 21:54:01 +01:00
Check if player is in liquid (the stable value)
*/
2019-08-21 16:23:48 +02:00
pp = floatToInt(position + v3f(0.0f), BS);
node = map->getNode(pp, &is_valid_position);
if (is_valid_position) {
in_liquid_stable = nodemgr->get(node.getContent()).liquid_move_physics;
} else {
2013-02-08 21:54:01 +01:00
in_liquid_stable = false;
}
/*
2019-08-21 16:23:48 +02:00
Check if player is climbing
*/
2019-08-21 16:23:48 +02:00
pp = floatToInt(position + v3f(0.0f, 0.5f * BS, 0.0f), BS);
v3s16 pp2 = floatToInt(position + v3f(0.0f, -0.2f * BS, 0.0f), BS);
node = map->getNode(pp, &is_valid_position);
bool is_valid_position2;
MapNode node2 = map->getNode(pp2, &is_valid_position2);
if (!(is_valid_position && is_valid_position2)) {
is_climbing = false;
} else {
2019-08-21 16:23:48 +02:00
is_climbing = (nodemgr->get(node.getContent()).climbable ||
nodemgr->get(node2.getContent()).climbable) && !free_move;
}
/*
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
2019-08-21 16:23:48 +02:00
f32 d = 0.15f * BS;
// This should always apply, otherwise there are glitches
sanity_check(d > pos_max_d);
// Player object property step height is multiplied by BS in
// /src/script/common/c_content.cpp and /src/content_sao.cpp
float player_stepheight = (m_cao == nullptr) ? 0.0f :
(touching_ground ? m_cao->getStepHeight() : (0.2f * BS));
v3f accel_f(0, -gravity, 0);
const v3f initial_position = position;
const v3f initial_speed = m_speed;
collisionMoveResult result = collisionMoveSimple(env, m_client,
pos_max_d, m_collisionbox, player_stepheight, dtime,
&position, &m_speed, accel_f);
bool could_sneak = control.sneak && !free_move && !in_liquid &&
!is_climbing && physics_override.sneak;
// Add new collisions to the vector
if (collision_info && !free_move) {
v3f diff = intToFloat(m_standing_node, BS) - position;
f32 distance_sq = diff.getLengthSQ();
// Force update each ClientEnvironment::step()
bool is_first = collision_info->empty();
for (const auto &colinfo : result.collisions) {
collision_info->push_back(colinfo);
if (colinfo.type != COLLISION_NODE ||
colinfo.axis != COLLISION_AXIS_Y ||
(could_sneak && m_sneak_node_exists))
continue;
diff = intToFloat(colinfo.node_p, BS) - position;
// Find nearest colliding node
f32 len_sq = diff.getLengthSQ();
if (is_first || len_sq < distance_sq) {
m_standing_node = colinfo.node_p;
distance_sq = len_sq;
is_first = false;
}
}
}
/*
If the player's feet touch the topside of any node
at the END of clientstep, then this is set to true.
Player is allowed to jump when this is true.
*/
bool touching_ground_was = touching_ground;
touching_ground = result.touching_ground;
bool sneak_can_jump = false;
// Max. distance (X, Z) over border for sneaking determined by collision box
// * 0.49 to keep the center just barely on the node
v3f sneak_max = m_collisionbox.getExtent() * 0.49f;
if (m_sneak_ladder_detected) {
// restore legacy behavior (this makes the m_speed.Y hack necessary)
2019-08-21 16:23:48 +02:00
sneak_max = v3f(0.4f * BS, 0.0f, 0.4f * BS);
}
/*
If sneaking, keep on top of last walked node and don't fall off
*/
if (could_sneak && m_sneak_node_exists) {
const v3f sn_f = intToFloat(m_sneak_node, BS);
const v3f bmin = sn_f + m_sneak_node_bb_top.MinEdge;
const v3f bmax = sn_f + m_sneak_node_bb_top.MaxEdge;
const v3f old_pos = position;
const v3f old_speed = m_speed;
f32 y_diff = bmax.Y - position.Y;
m_standing_node = m_sneak_node;
// (BS * 0.6f) is the basic stepheight while standing on ground
if (y_diff < BS * 0.6f) {
// Only center player when they're on the node
position.X = rangelim(position.X,
bmin.X - sneak_max.X, bmax.X + sneak_max.X);
position.Z = rangelim(position.Z,
bmin.Z - sneak_max.Z, bmax.Z + sneak_max.Z);
if (position.X != old_pos.X)
2019-08-21 16:23:48 +02:00
m_speed.X = 0.0f;
if (position.Z != old_pos.Z)
2019-08-21 16:23:48 +02:00
m_speed.Z = 0.0f;
}
2019-08-21 16:23:48 +02:00
if (y_diff > 0 && m_speed.Y <= 0.0f &&
(physics_override.sneak_glitch || y_diff < BS * 0.6f)) {
// Move player to the maximal height when falling or when
// the ledge is climbed on the next step.
// Smoothen the movement (based on 'position.Y = bmax.Y')
position.Y += y_diff * dtime * 22.0f + BS * 0.01f;
position.Y = std::min(position.Y, bmax.Y);
2019-08-21 16:23:48 +02:00
m_speed.Y = 0.0f;
}
// Allow jumping on node edges while sneaking
2019-08-21 16:23:48 +02:00
if (m_speed.Y == 0.0f || m_sneak_ladder_detected)
sneak_can_jump = true;
if (collision_info &&
m_speed.Y - old_speed.Y > BS) {
// Collide with sneak node, report fall damage
CollisionInfo sn_info;
sn_info.node_p = m_sneak_node;
sn_info.old_speed = old_speed;
sn_info.new_speed = m_speed;
collision_info->push_back(sn_info);
}
}
/*
Find the next sneak node if necessary
*/
bool new_sneak_node_exists = false;
if (could_sneak)
new_sneak_node_exists = updateSneakNode(map, position, sneak_max);
/*
Set new position but keep sneak node set
*/
setPosition(position);
m_sneak_node_exists = new_sneak_node_exists;
/*
Report collisions
*/
2019-08-21 16:23:48 +02:00
if (!result.standing_on_object && !touching_ground_was && touching_ground) {
m_client->getEventManager()->put(new SimpleTriggerEvent(MtEvent::PLAYER_REGAIN_GROUND));
// Set camera impact value to be used for view bobbing
camera_impact = getSpeed().Y * -1;
}
/*
Check properties of the node on which the player is standing
*/
const ContentFeatures &f = nodemgr->get(map->getNode(m_standing_node));
const ContentFeatures &f1 = nodemgr->get(map->getNode(m_standing_node + v3s16(0, 1, 0)));
// We can jump from a bouncy node we collided with this clientstep,
// even if we are not "touching" it at the end of clientstep.
int standing_node_bouncy = 0;
if (result.collides && m_speed.Y > 0.0f) {
// must use result.collisions here because sometimes collision_info
// is passed in prepopulated with a problematic floor.
for (const auto &colinfo : result.collisions) {
if (colinfo.axis == COLLISION_AXIS_Y) {
// we cannot rely on m_standing_node because "sneak stuff"
standing_node_bouncy = itemgroup_get(nodemgr->get(map->getNode(colinfo.node_p)).groups, "bouncy");
if (standing_node_bouncy != 0)
break;
}
}
}
// Determine if jumping is possible
m_disable_jump = itemgroup_get(f.groups, "disable_jump") ||
itemgroup_get(f1.groups, "disable_jump");
m_can_jump = ((touching_ground && !is_climbing) || sneak_can_jump || standing_node_bouncy != 0)
&& !m_disable_jump;
m_disable_descend = itemgroup_get(f.groups, "disable_descend") ||
itemgroup_get(f1.groups, "disable_descend");
// Jump/Sneak key pressed while bouncing from a bouncy block
float jumpspeed = movement_speed_jump * physics_override.jump;
if (m_can_jump && (control.jump || control.sneak) && standing_node_bouncy > 0) {
// controllable (>0) bouncy block
if (!control.jump) {
// sneak pressed, but not jump
// Subjective testing indicates 1/3 bounce decrease works well.
jumpspeed = -m_speed.Y / 3.0f;
} else {
// jump pressed
// Reduce boost when speed already is high
jumpspeed = jumpspeed / (1.0f + (m_speed.Y * 2.8f / jumpspeed));
}
m_speed.Y += jumpspeed;
setSpeed(m_speed);
m_can_jump = false;
} else if(m_speed.Y > jumpspeed && standing_node_bouncy < 0) {
// uncontrollable bouncy is limited to normal jump height.
m_can_jump = false;
}
// Prevent sliding on the ground when jump speed is 0
m_can_jump = m_can_jump && jumpspeed != 0.0f;
// Autojump
handleAutojump(dtime, env, result, initial_position, initial_speed, pos_max_d);
}
2014-04-15 19:49:32 +02:00
void LocalPlayer::move(f32 dtime, Environment *env, f32 pos_max_d)
{
move(dtime, env, pos_max_d, NULL);
}
void LocalPlayer::applyControl(float dtime, Environment *env)
{
// Clear stuff
2013-02-08 21:54:01 +01:00
swimming_vertical = false;
swimming_pitch = false;
setPitch(control.pitch);
setYaw(control.yaw);
// Nullify speed and don't run positioning code if the player is attached
if (getParent()) {
2019-08-21 16:23:48 +02:00
setSpeed(v3f(0.0f));
return;
}
PlayerSettings &player_settings = getPlayerSettings();
// All vectors are relative to the player's yaw,
2019-05-04 09:13:31 +02:00
// (and pitch if pitch move mode enabled),
// and will be rotated at the end
2019-08-21 16:23:48 +02:00
v3f speedH, speedV; // Horizontal (X, Z) and Vertical (Y)
bool fly_allowed = m_client->checkLocalPrivilege("fly");
bool fast_allowed = m_client->checkLocalPrivilege("fast");
bool free_move = fly_allowed && player_settings.free_move;
bool fast_move = fast_allowed && player_settings.fast_move;
bool pitch_move = (free_move || in_liquid) && player_settings.pitch_move;
// When aux1_descends is enabled the fast key is used to go down, so fast isn't possible
bool fast_climb = fast_move && control.aux1 && !player_settings.aux1_descends;
bool always_fly_fast = player_settings.always_fly_fast;
// Whether superspeed mode is used or not
bool superspeed = false;
if (always_fly_fast && free_move && fast_move)
superspeed = true;
// Old descend control
2019-08-21 16:23:48 +02:00
if (player_settings.aux1_descends) {
2012-12-27 18:33:24 +01:00
// If free movement and fast movement, always move fast
2019-08-21 16:23:48 +02:00
if (free_move && fast_move)
2012-12-27 18:33:24 +01:00
superspeed = true;
// Auxiliary button 1 (E)
2019-08-21 16:23:48 +02:00
if (control.aux1) {
if (free_move) {
// In free movement mode, aux1 descends
2019-08-21 16:23:48 +02:00
if (fast_move)
2013-02-08 21:54:01 +01:00
speedV.Y = -movement_speed_fast;
else
2013-02-08 21:54:01 +01:00
speedV.Y = -movement_speed_walk;
} else if ((in_liquid || in_liquid_stable) && !m_disable_descend) {
speedV.Y = -movement_speed_walk;
2013-02-08 21:54:01 +01:00
swimming_vertical = true;
} else if (is_climbing && !m_disable_descend) {
2023-09-15 20:10:08 +02:00
speedV.Y = -movement_speed_climb * physics_override.speed_climb;
2019-08-21 16:23:48 +02:00
} else {
// If not free movement but fast is allowed, aux1 is
// "Turbo button"
2019-08-21 16:23:48 +02:00
if (fast_move)
superspeed = true;
}
}
2019-08-21 16:23:48 +02:00
} else {
// New minecraft-like descend control
// Auxiliary button 1 (E)
2019-08-21 16:23:48 +02:00
if (control.aux1) {
if (!is_climbing) {
2012-12-27 18:33:24 +01:00
// aux1 is "Turbo button"
2019-08-21 16:23:48 +02:00
if (fast_move)
superspeed = true;
}
}
if (control.sneak && !control.jump) {
// Descend player in freemove mode, liquids and climbable nodes by sneak key, only if jump key is released
2019-08-21 16:23:48 +02:00
if (free_move) {
// In free movement mode, sneak descends
if (fast_move && (control.aux1 || always_fly_fast))
2013-02-08 21:54:01 +01:00
speedV.Y = -movement_speed_fast;
else
2013-02-08 21:54:01 +01:00
speedV.Y = -movement_speed_walk;
} else if ((in_liquid || in_liquid_stable) && !m_disable_descend) {
2019-08-21 16:23:48 +02:00
if (fast_climb)
2013-02-08 21:54:01 +01:00
speedV.Y = -movement_speed_fast;
else
speedV.Y = -movement_speed_walk;
swimming_vertical = true;
} else if (is_climbing && !m_disable_descend) {
2019-08-21 16:23:48 +02:00
if (fast_climb)
2013-02-08 21:54:01 +01:00
speedV.Y = -movement_speed_fast;
else
2023-09-15 20:10:08 +02:00
speedV.Y = -movement_speed_climb * physics_override.speed_climb;
}
}
}
speedH = v3f(sin(control.movement_direction), 0.0f, cos(control.movement_direction));
2019-08-21 16:23:48 +02:00
if (m_autojump) {
// release autojump after a given time
m_autojump_time -= dtime;
if (m_autojump_time <= 0.0f)
m_autojump = false;
}
2019-08-21 16:23:48 +02:00
if (control.jump) {
if (free_move) {
if (!control.sneak) {
// Don't fly up if sneak key is pressed
if (player_settings.aux1_descends || always_fly_fast) {
if (fast_move)
speedV.Y = movement_speed_fast;
else
speedV.Y = movement_speed_walk;
} else {
if (fast_move && control.aux1)
speedV.Y = movement_speed_fast;
else
speedV.Y = movement_speed_walk;
}
2012-12-27 18:33:24 +01:00
}
2019-08-21 16:23:48 +02:00
} else if (m_can_jump) {
/*
NOTE: The d value in move() affects jump height by
raising the height at which the jump speed is kept
at its starting value
*/
2013-02-08 21:54:01 +01:00
v3f speedJ = getSpeed();
2019-08-21 16:23:48 +02:00
if (speedJ.Y >= -0.5f * BS) {
speedJ.Y = movement_speed_jump * physics_override.jump;
setSpeed(speedJ);
m_client->getEventManager()->put(new SimpleTriggerEvent(MtEvent::PLAYER_JUMP));
}
} else if (in_liquid && !m_disable_jump && !control.sneak) {
if (fast_climb)
2013-02-08 21:54:01 +01:00
speedV.Y = movement_speed_fast;
else
speedV.Y = movement_speed_walk;
swimming_vertical = true;
} else if (is_climbing && !m_disable_jump && !control.sneak) {
if (fast_climb)
2013-02-08 21:54:01 +01:00
speedV.Y = movement_speed_fast;
else
2023-09-15 20:10:08 +02:00
speedV.Y = movement_speed_climb * physics_override.speed_climb;
}
}
// The speed of the player (Y is ignored)
2019-08-21 16:23:48 +02:00
if (superspeed || (is_climbing && fast_climb) ||
((in_liquid || in_liquid_stable) && fast_climb))
2013-02-08 21:54:01 +01:00
speedH = speedH.normalize() * movement_speed_fast;
2019-08-21 16:23:48 +02:00
else if (control.sneak && !free_move && !in_liquid && !in_liquid_stable)
2023-09-15 20:10:08 +02:00
speedH = speedH.normalize() * movement_speed_crouch * physics_override.speed_crouch;
else
2013-02-08 21:54:01 +01:00
speedH = speedH.normalize() * movement_speed_walk;
speedH *= control.movement_speed; /* Apply analog input */
2013-02-08 21:54:01 +01:00
// Acceleration increase
2019-08-21 16:23:48 +02:00
f32 incH = 0.0f; // Horizontal (X, Z)
f32 incV = 0.0f; // Vertical (Y)
if ((!touching_ground && !free_move && !is_climbing && !in_liquid) ||
(!free_move && m_can_jump && control.jump)) {
2013-02-08 21:54:01 +01:00
// Jumping and falling
2019-08-21 16:23:48 +02:00
if (superspeed || (fast_move && control.aux1))
2013-02-08 21:54:01 +01:00
incH = movement_acceleration_fast * BS * dtime;
else
2023-09-15 20:10:08 +02:00
incH = movement_acceleration_air * physics_override.acceleration_air * BS * dtime;
2019-08-21 16:23:48 +02:00
incV = 0.0f; // No vertical acceleration in air
} else if (superspeed || (is_climbing && fast_climb) ||
((in_liquid || in_liquid_stable) && fast_climb)) {
2013-02-08 21:54:01 +01:00
incH = incV = movement_acceleration_fast * BS * dtime;
2019-08-21 16:23:48 +02:00
} else {
2023-09-15 20:10:08 +02:00
incH = incV = movement_acceleration_default * physics_override.acceleration_default * BS * dtime;
2019-08-21 16:23:48 +02:00
}
2013-02-08 21:54:01 +01:00
float slip_factor = 1.0f;
if (!free_move && !in_liquid && !in_liquid_stable)
slip_factor = getSlipFactor(env, speedH);
// Don't sink when swimming in pitch mode
if (pitch_move && in_liquid) {
v3f controlSpeed = speedH + speedV;
if (controlSpeed.getLength() > 0.01f)
swimming_pitch = true;
}
// Accelerate to target speed with maximum increment
accelerate((speedH + speedV) * physics_override.speed,
incH * physics_override.speed * slip_factor, incV * physics_override.speed,
2019-08-21 16:23:48 +02:00
pitch_move);
}
v3s16 LocalPlayer::getStandingNodePos()
{
2019-08-21 16:23:48 +02:00
if (m_sneak_node_exists)
return m_sneak_node;
2019-08-21 16:23:48 +02:00
return m_standing_node;
}
v3s16 LocalPlayer::getFootstepNodePos()
{
v3f feet_pos = getPosition() + v3f(0.0f, m_collisionbox.MinEdge.Y, 0.0f);
2019-08-21 16:23:48 +02:00
// Emit swimming sound if the player is in liquid
if (in_liquid_stable)
return floatToInt(feet_pos, BS);
2019-08-21 16:23:48 +02:00
// BS * 0.05 below the player's feet ensures a 1/16th height
// nodebox is detected instead of the node below it.
if (touching_ground)
return floatToInt(feet_pos - v3f(0.0f, BS * 0.05f, 0.0f), BS);
2019-08-21 16:23:48 +02:00
// A larger distance below is necessary for a footstep sound
// when landing after a jump or fall. BS * 0.5 ensures water
// sounds when swimming in 1 node deep water.
return floatToInt(feet_pos - v3f(0.0f, BS * 0.5f, 0.0f), BS);
}
v3s16 LocalPlayer::getLightPosition() const
{
2019-08-21 16:23:48 +02:00
return floatToInt(m_position + v3f(0.0f, BS * 1.5f, 0.0f), BS);
}
v3f LocalPlayer::getEyeOffset() const
{
return v3f(0.0f, BS * m_eye_height, 0.0f);
}
ClientActiveObject *LocalPlayer::getParent() const
{
return m_cao ? m_cao->getParent() : nullptr;
}
bool LocalPlayer::isDead() const
{
2019-08-21 16:23:48 +02:00
FATAL_ERROR_IF(!getCAO(), "LocalPlayer's CAO isn't initialized");
return !getCAO()->isImmortal() && hp == 0;
}
// 3D acceleration
void LocalPlayer::accelerate(const v3f &target_speed, const f32 max_increase_H,
2019-08-21 16:23:48 +02:00
const f32 max_increase_V, const bool use_pitch)
{
const f32 yaw = getYaw();
const f32 pitch = getPitch();
v3f flat_speed = m_speed;
// Rotate speed vector by -yaw and -pitch to make it relative to the player's yaw and pitch
flat_speed.rotateXZBy(-yaw);
if (use_pitch)
flat_speed.rotateYZBy(-pitch);
v3f d_wanted = target_speed - flat_speed;
2019-08-21 16:23:48 +02:00
v3f d;
// Then compare the horizontal and vertical components with the wanted speed
2019-08-21 16:23:48 +02:00
if (max_increase_H > 0.0f) {
v3f d_wanted_H = d_wanted * v3f(1.0f, 0.0f, 1.0f);
if (d_wanted_H.getLength() > max_increase_H)
d += d_wanted_H.normalize() * max_increase_H;
else
d += d_wanted_H;
}
2019-08-21 16:23:48 +02:00
if (max_increase_V > 0.0f) {
f32 d_wanted_V = d_wanted.Y;
if (d_wanted_V > max_increase_V)
d.Y += max_increase_V;
else if (d_wanted_V < -max_increase_V)
d.Y -= max_increase_V;
else
d.Y += d_wanted_V;
}
// Finally rotate it again
if (use_pitch)
d.rotateYZBy(pitch);
d.rotateXZBy(yaw);
m_speed += d;
}
// Temporary option for old move code
void LocalPlayer::old_move(f32 dtime, Environment *env, f32 pos_max_d,
2019-08-21 16:23:48 +02:00
std::vector<CollisionInfo> *collision_info)
{
Map *map = &env->getMap();
const NodeDefManager *nodemgr = m_client->ndef();
v3f position = getPosition();
// Copy parent position if local player is attached
if (getParent()) {
setPosition(m_cao->getPosition());
m_sneak_node_exists = false;
m_added_velocity = v3f(0.0f);
return;
}
PlayerSettings &player_settings = getPlayerSettings();
// Skip collision detection if noclip mode is used
bool fly_allowed = m_client->checkLocalPrivilege("fly");
bool noclip = m_client->checkLocalPrivilege("noclip") && player_settings.noclip;
bool free_move = noclip && fly_allowed && player_settings.free_move;
if (free_move) {
position += m_speed * dtime;
setPosition(position);
touching_ground = false;
m_sneak_node_exists = false;
m_added_velocity = v3f(0.0f);
return;
}
m_speed += m_added_velocity;
m_added_velocity = v3f(0.0f);
// Apply gravity (note: this is broken, but kept since this is *old* move code)
m_speed.Y -= gravity * dtime;
/*
Collision detection
*/
bool is_valid_position;
MapNode node;
v3s16 pp;
/*
Check if player is in liquid (the oscillating value)
*/
if (in_liquid) {
// If in liquid, the threshold of coming out is at higher y
2019-08-21 16:23:48 +02:00
pp = floatToInt(position + v3f(0.0f, BS * 0.1f, 0.0f), BS);
node = map->getNode(pp, &is_valid_position);
if (is_valid_position) {
const ContentFeatures &cf = nodemgr->get(node.getContent());
in_liquid = cf.liquid_move_physics;
move_resistance = cf.move_resistance;
} else {
in_liquid = false;
}
} else {
// If not in liquid, the threshold of going in is at lower y
2019-08-21 16:23:48 +02:00
pp = floatToInt(position + v3f(0.0f, BS * 0.5f, 0.0f), BS);
node = map->getNode(pp, &is_valid_position);
if (is_valid_position) {
const ContentFeatures &cf = nodemgr->get(node.getContent());
in_liquid = cf.liquid_move_physics;
move_resistance = cf.move_resistance;
} else {
in_liquid = false;
}
}
/*
Check if player is in liquid (the stable value)
*/
2019-08-21 16:23:48 +02:00
pp = floatToInt(position + v3f(0.0f), BS);
node = map->getNode(pp, &is_valid_position);
if (is_valid_position)
in_liquid_stable = nodemgr->get(node.getContent()).liquid_move_physics;
else
in_liquid_stable = false;
/*
Check if player is climbing
*/
2019-08-21 16:23:48 +02:00
pp = floatToInt(position + v3f(0.0f, 0.5f * BS, 0.0f), BS);
v3s16 pp2 = floatToInt(position + v3f(0.0f, -0.2f * BS, 0.0f), BS);
node = map->getNode(pp, &is_valid_position);
bool is_valid_position2;
MapNode node2 = map->getNode(pp2, &is_valid_position2);
if (!(is_valid_position && is_valid_position2))
is_climbing = false;
else
is_climbing = (nodemgr->get(node.getContent()).climbable ||
2019-08-21 16:23:48 +02:00
nodemgr->get(node2.getContent()).climbable) && !free_move;
/*
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
2019-08-21 16:23:48 +02:00
f32 d = 0.15f * BS;
// This should always apply, otherwise there are glitches
sanity_check(d > pos_max_d);
// Maximum distance over border for sneaking
2019-08-21 16:23:48 +02:00
f32 sneak_max = BS * 0.4f;
/*
If sneaking, keep in range from the last walked node and don't
fall off from it
*/
if (control.sneak && m_sneak_node_exists &&
!(fly_allowed && player_settings.free_move) && !in_liquid &&
physics_override.sneak) {
2019-08-21 16:23:48 +02:00
f32 maxd = 0.5f * 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);
if (!is_climbing) {
// Move up if necessary
2019-08-21 16:23:48 +02:00
f32 new_y = (lwn_f.Y - 0.5f * BS) + m_sneak_node_bb_ymax;
if (position.Y < new_y)
position.Y = new_y;
/*
Collision seems broken, since player is sinking when
sneaking over the edges of current sneaking_node.
TODO (when fixed): Set Y-speed only to 0 when position.Y < new_y.
*/
2019-08-21 16:23:48 +02:00
if (m_speed.Y < 0.0f)
m_speed.Y = 0.0f;
}
}
2019-08-21 16:23:48 +02:00
// TODO: This shouldn't be hardcoded but decided by the server
float player_stepheight = touching_ground ? (BS * 0.6f) : (BS * 0.2f);
2019-08-21 16:23:48 +02:00
v3f accel_f;
const v3f initial_position = position;
const v3f initial_speed = m_speed;
collisionMoveResult result = collisionMoveSimple(env, m_client,
pos_max_d, m_collisionbox, player_stepheight, dtime,
&position, &m_speed, accel_f);
// Position was slightly changed; update standing node pos
if (touching_ground)
2019-08-21 16:23:48 +02:00
m_standing_node = floatToInt(m_position - v3f(0.0f, 0.1f * BS, 0.0f), BS);
else
m_standing_node = floatToInt(m_position, BS);
/*
If the player's feet touch the topside of any node
at the END of clientstep, then this is set to true.
Player is allowed to jump when this is true.
*/
bool touching_ground_was = touching_ground;
touching_ground = result.touching_ground;
2019-05-04 09:13:31 +02:00
//bool standing_on_unloaded = result.standing_on_unloaded;
/*
Check the nodes under the player to see from which node the
2019-05-04 09:13:31 +02:00
player is sneaking from, if any. If the node from under
the player has been removed, the player falls.
*/
2019-08-21 16:23:48 +02:00
f32 position_y_mod = 0.05f * BS;
if (m_sneak_node_bb_ymax > 0.0f)
position_y_mod = m_sneak_node_bb_ymax - position_y_mod;
2019-08-21 16:23:48 +02:00
v3s16 current_node = floatToInt(position - v3f(0.0f, position_y_mod, 0.0f), BS);
if (m_sneak_node_exists &&
nodemgr->get(map->getNode(m_old_node_below)).name == "air" &&
m_old_node_below_type != "air") {
// Old node appears to have been removed; that is,
// it wasn't air before but now it is
m_need_to_get_new_sneak_node = false;
m_sneak_node_exists = false;
} else if (nodemgr->get(map->getNode(current_node)).name != "air") {
// We are on something, so make sure to recalculate the sneak
// node.
m_need_to_get_new_sneak_node = true;
}
if (m_need_to_get_new_sneak_node && physics_override.sneak) {
2019-08-21 16:23:48 +02:00
m_sneak_node_bb_ymax = 0.0f;
v3s16 pos_i_bottom = floatToInt(position - v3f(0.0f, position_y_mod, 0.0f), BS);
v2f player_p2df(position.X, position.Z);
2019-08-21 16:23:48 +02:00
f32 min_distance_f = 100000.0f * BS;
// If already seeking from some node, compare to it.
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(
2019-08-21 16:23:48 +02:00
std::fabs(player_p2df.X - node_p2df.X),
std::fabs(player_p2df.Y - node_p2df.Y));
if (distance_f > min_distance_f ||
2019-08-21 16:23:48 +02:00
max_axis_distance_f > 0.5f * BS + sneak_max + 0.1f * BS)
continue;
// The node to be sneaked on has to be walkable
node = map->getNode(p, &is_valid_position);
if (!is_valid_position || !nodemgr->get(node).walkable)
continue;
// And the node above it has to be nonwalkable
node = map->getNode(p + v3s16(0, 1, 0), &is_valid_position);
if (!is_valid_position || nodemgr->get(node).walkable)
continue;
// If not 'sneak_glitch' the node 2 nodes above it has to be nonwalkable
if (!physics_override.sneak_glitch) {
2019-08-21 16:23:48 +02:00
node = map->getNode(p + v3s16(0, 2, 0), &is_valid_position);
if (!is_valid_position || nodemgr->get(node).walkable)
continue;
}
min_distance_f = distance_f;
new_sneak_node = p;
}
2019-08-21 16:23:48 +02:00
bool sneak_node_found = (min_distance_f < 100000.0f * BS * 0.9f);
m_sneak_node = new_sneak_node;
m_sneak_node_exists = sneak_node_found;
if (sneak_node_found) {
2019-08-21 16:23:48 +02:00
f32 cb_max = 0.0f;
MapNode n = map->getNode(m_sneak_node);
std::vector<aabb3f> nodeboxes;
n.getCollisionBoxes(nodemgr, &nodeboxes);
for (const auto &box : nodeboxes) {
if (box.MaxEdge.Y > cb_max)
cb_max = box.MaxEdge.Y;
}
m_sneak_node_bb_ymax = cb_max;
}
/*
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 but keep sneak node set
*/
bool sneak_node_exists = m_sneak_node_exists;
setPosition(position);
m_sneak_node_exists = sneak_node_exists;
/*
Report collisions
*/
2019-08-21 16:23:48 +02:00
// Don't report if flying
if (collision_info && !(player_settings.free_move && fly_allowed)) {
for (const auto &info : result.collisions) {
collision_info->push_back(info);
}
}
if (!result.standing_on_object && !touching_ground_was && touching_ground) {
m_client->getEventManager()->put(new SimpleTriggerEvent(MtEvent::PLAYER_REGAIN_GROUND));
// Set camera impact value to be used for view bobbing
2019-08-21 16:23:48 +02:00
camera_impact = getSpeed().Y * -1.0f;
}
/*
Update the node last under the player
*/
2019-08-21 16:23:48 +02:00
m_old_node_below = floatToInt(position - v3f(0.0f, BS / 2.0f, 0.0f), BS);
m_old_node_below_type = nodemgr->get(map->getNode(m_old_node_below)).name;
/*
Check properties of the node on which the player is standing
*/
2019-08-21 16:23:48 +02:00
const ContentFeatures &f = nodemgr->get(map->getNode(getStandingNodePos()));
// We can jump from a bouncy node we collided with this clientstep,
// even if we are not "touching" it at the end of clientstep.
int standing_node_bouncy = 0;
if (result.collides && m_speed.Y > 0.0f) {
// must use result.collisions here because sometimes collision_info
// is passed in prepopulated with a problematic floor.
for (const auto &colinfo : result.collisions) {
if (colinfo.axis == COLLISION_AXIS_Y) {
// we cannot rely on m_standing_node because "sneak stuff"
standing_node_bouncy = itemgroup_get(nodemgr->get(map->getNode(colinfo.node_p)).groups, "bouncy");
if (standing_node_bouncy != 0)
break;
}
}
}
// Determine if jumping is possible
m_disable_jump = itemgroup_get(f.groups, "disable_jump");
m_can_jump = (touching_ground || standing_node_bouncy != 0) && !m_disable_jump;
m_disable_descend = itemgroup_get(f.groups, "disable_descend");
// Jump/Sneak key pressed while bouncing from a bouncy block
float jumpspeed = movement_speed_jump * physics_override.jump;
if (m_can_jump && (control.jump || control.sneak) && standing_node_bouncy > 0) {
// controllable (>0) bouncy block
if (!control.jump) {
// sneak pressed, but not jump
// Subjective testing indicates 1/3 bounce decrease works well.
jumpspeed = -m_speed.Y / 3.0f;
} else {
// jump pressed
// Reduce boost when speed already is high
jumpspeed = jumpspeed / (1.0f + (m_speed.Y * 2.8f / jumpspeed));
}
m_speed.Y += jumpspeed;
setSpeed(m_speed);
m_can_jump = false;
} else if(m_speed.Y > jumpspeed && standing_node_bouncy < 0) {
// uncontrollable bouncy is limited to normal jump height.
m_can_jump = false;
}
// Autojump
handleAutojump(dtime, env, result, initial_position, initial_speed, pos_max_d);
}
float LocalPlayer::getSlipFactor(Environment *env, const v3f &speedH)
{
// Slip on slippery nodes
const NodeDefManager *nodemgr = env->getGameDef()->ndef();
Map *map = &env->getMap();
2019-08-21 16:23:48 +02:00
const ContentFeatures &f = nodemgr->get(map->getNode(getStandingNodePos()));
int slippery = 0;
if (f.walkable)
slippery = itemgroup_get(f.groups, "slippery");
if (slippery >= 1) {
2019-08-21 16:23:48 +02:00
if (speedH == v3f(0.0f))
slippery *= 2;
return core::clamp(1.0f / (slippery + 1), 0.001f, 1.0f);
}
return 1.0f;
}
void LocalPlayer::handleAutojump(f32 dtime, Environment *env,
2019-08-21 16:23:48 +02:00
const collisionMoveResult &result, const v3f &initial_position,
const v3f &initial_speed, f32 pos_max_d)
{
PlayerSettings &player_settings = getPlayerSettings();
if (!player_settings.autojump)
return;
if (m_autojump)
return;
bool could_autojump =
m_can_jump && !control.jump && !control.sneak && control.isMoving();
2019-08-21 16:23:48 +02:00
if (!could_autojump)
return;
bool horizontal_collision = false;
for (const auto &colinfo : result.collisions) {
if (colinfo.type == COLLISION_NODE && colinfo.plane != 1) {
horizontal_collision = true;
break; // one is enough
}
}
// must be running against something to trigger autojumping
if (!horizontal_collision)
return;
// check for nodes above
v3f headpos_min = m_position + m_collisionbox.MinEdge * 0.99f;
v3f headpos_max = m_position + m_collisionbox.MaxEdge * 0.99f;
headpos_min.Y = headpos_max.Y; // top face of collision box
v3s16 ceilpos_min = floatToInt(headpos_min, BS) + v3s16(0, 1, 0);
v3s16 ceilpos_max = floatToInt(headpos_max, BS) + v3s16(0, 1, 0);
const NodeDefManager *ndef = env->getGameDef()->ndef();
bool is_position_valid;
2019-08-21 16:23:48 +02:00
for (s16 z = ceilpos_min.Z; z <= ceilpos_max.Z; ++z) {
for (s16 x = ceilpos_min.X; x <= ceilpos_max.X; ++x) {
MapNode n = env->getMap().getNode(v3s16(x, ceilpos_max.Y, z), &is_position_valid);
if (!is_position_valid)
break; // won't collide with the void outside
if (n.getContent() == CONTENT_IGNORE)
return; // players collide with ignore blocks -> same as walkable
const ContentFeatures &f = ndef->get(n);
if (f.walkable)
return; // would bump head, don't jump
}
}
float jumpspeed = movement_speed_jump * physics_override.jump;
float peak_dtime = jumpspeed / gravity; // at the peak of the jump v = gt <=> t = v / g
float jump_height = (jumpspeed - 0.5f * gravity * peak_dtime) * peak_dtime; // s = vt - 1/2 gt^2
v3f jump_pos = initial_position + v3f(0.0f, jump_height, 0.0f);
v3f jump_speed = initial_speed;
// try at peak of jump, zero step height
collisionMoveResult jump_result = collisionMoveSimple(env, m_client, pos_max_d,
2019-08-21 16:23:48 +02:00
m_collisionbox, 0.0f, dtime, &jump_pos, &jump_speed, v3f(0.0f));
// see if we can get a little bit farther horizontally if we had
// jumped
v3f run_delta = m_position - initial_position;
run_delta.Y = 0.0f;
v3f jump_delta = jump_pos - initial_position;
jump_delta.Y = 0.0f;
if (jump_delta.getLengthSQ() > run_delta.getLengthSQ() * 1.01f) {
m_autojump = true;
m_autojump_time = 0.1f;
}
}