Mirrorlandia_minetest/minetest
1
0
Fork 1
mirror of https://github.com/minetest/minetest.git synced 2024-12-24 15:12:23 +01:00
Code Issues Packages Projects Releases Wiki Activity

LocalPlayer: Fix code-style

Browse Source
This commit is contained in:
ANAND 2019-08-21 19:53:48 +05:30 committed by sfan5
parent eea082ee3f
commit 16d6ca3937
2 changed files with 181 additions and 205 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

372
src/client/localplayer.cpp
View File

@ -41,7 +41,7 @@ LocalPlayer::LocalPlayer(Client *client, const char *name):
static aabb3f getNodeBoundingBox(const std::vector<aabb3f> &nodeboxes) static aabb3f getNodeBoundingBox(const std::vector<aabb3f> &nodeboxes)
{ {
if (nodeboxes.empty()) if (nodeboxes.empty())
return aabb3f(0, 0, 0, 0, 0, 0); return aabb3f(0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
aabb3f b_max; aabb3f b_max;
@ -56,7 +56,7 @@ static aabb3f getNodeBoundingBox(const std::vector<aabb3f> &nodeboxes)
} }
bool LocalPlayer::updateSneakNode(Map *map, const v3f &position, bool LocalPlayer::updateSneakNode(Map *map, const v3f &position,
const v3f &sneak_max) const v3f &sneak_max)
{ {
static const v3s16 dir9_center[9] = { static const v3s16 dir9_center[9] = {
v3s16( 0, 0, 0), v3s16( 0, 0, 0),
@ -76,12 +76,12 @@ bool LocalPlayer::updateSneakNode(Map *map, const v3f &position,
bool new_sneak_node_exists = m_sneak_node_exists; bool new_sneak_node_exists = m_sneak_node_exists;
// We want the top of the sneak node to be below the players feet // We want the top of the sneak node to be below the players feet
f32 position_y_mod = 0.05 * BS; f32 position_y_mod = 0.05f * BS;
if (m_sneak_node_exists) if (m_sneak_node_exists)
position_y_mod = m_sneak_node_bb_top.MaxEdge.Y - position_y_mod; position_y_mod = m_sneak_node_bb_top.MaxEdge.Y - position_y_mod;
// Get position of current standing node // Get position of current standing node
const v3s16 current_node = floatToInt(position - v3f(0, position_y_mod, 0), BS); const v3s16 current_node = floatToInt(position - v3f(0.0f, position_y_mod, 0.0f), BS);
if (current_node != m_sneak_node) { if (current_node != m_sneak_node) {
new_sneak_node_exists = false; new_sneak_node_exists = false;
@ -97,7 +97,7 @@ bool LocalPlayer::updateSneakNode(Map *map, const v3f &position,
// Get new sneak node // Get new sneak node
m_sneak_ladder_detected = false; m_sneak_ladder_detected = false;
f32 min_distance_f = 100000.0 * BS; f32 min_distance_f = 100000.0f * BS;
for (const auto &d : dir9_center) { for (const auto &d : dir9_center) {
const v3s16 p = current_node + d; const v3s16 p = current_node + d;
@ -106,8 +106,8 @@ bool LocalPlayer::updateSneakNode(Map *map, const v3f &position,
f32 distance_f = diff.getLength(); f32 distance_f = diff.getLength();
if (distance_f > min_distance_f || if (distance_f > min_distance_f ||
fabs(diff.X) > (.5 + .1) * BS + sneak_max.X || fabs(diff.X) > (0.5f + 0.1f) * BS + sneak_max.X ||
fabs(diff.Y) > (.5 + .1) * BS + sneak_max.Z) fabs(diff.Y) > (0.5f + 0.1f) * BS + sneak_max.Z)
continue; continue;
@ -118,9 +118,8 @@ bool LocalPlayer::updateSneakNode(Map *map, const v3f &position,
// And the node(s) above have to be nonwalkable // And the node(s) above have to be nonwalkable
bool ok = true; bool ok = true;
if (!physics_override_sneak_glitch) { if (!physics_override_sneak_glitch) {
u16 height = ceilf( u16 height =
(m_collisionbox.MaxEdge.Y - m_collisionbox.MinEdge.Y) / BS ceilf((m_collisionbox.MaxEdge.Y - m_collisionbox.MinEdge.Y) / BS);
);
for (u16 y = 1; y <= height; y++) { for (u16 y = 1; y <= height; y++) {
node = map->getNode(p + v3s16(0, y, 0), &is_valid_position); node = map->getNode(p + v3s16(0, y, 0), &is_valid_position);
if (!is_valid_position || nodemgr->get(node).walkable) { if (!is_valid_position || nodemgr->get(node).walkable) {
@ -169,10 +168,9 @@ bool LocalPlayer::updateSneakNode(Map *map, const v3f &position,
void LocalPlayer::move(f32 dtime, Environment *env, f32 pos_max_d, void LocalPlayer::move(f32 dtime, Environment *env, f32 pos_max_d,
std::vector<CollisionInfo> *collision_info) std::vector<CollisionInfo> *collision_info)
{ {
if (!collision_info || collision_info->empty()) { // Node at feet position, update each ClientEnvironment::step()
// Node at feet position, update each ClientEnvironment::step() if (!collision_info || collision_info->empty())
m_standing_node = floatToInt(m_position, BS); m_standing_node = floatToInt(m_position, BS);
}
// Temporary option for old move code // Temporary option for old move code
if (!physics_override_new_move) { if (!physics_override_new_move) {
@ -188,7 +186,7 @@ void LocalPlayer::move(f32 dtime, Environment *env, f32 pos_max_d,
// Copy parent position if local player is attached // Copy parent position if local player is attached
if (isAttached) { if (isAttached) {
setPosition(overridePosition); setPosition(overridePosition);
added_velocity = v3f(); // ignored added_velocity = v3f(0.0f); // ignored
return; return;
} }
@ -202,12 +200,12 @@ void LocalPlayer::move(f32 dtime, Environment *env, f32 pos_max_d,
if (noclip && free_move) { if (noclip && free_move) {
position += m_speed * dtime; position += m_speed * dtime;
setPosition(position); setPosition(position);
added_velocity = v3f(); // ignored added_velocity = v3f(0.0f); // ignored
return; return;
} }
m_speed += added_velocity; m_speed += added_velocity;
added_velocity = v3f(); added_velocity = v3f(0.0f);
/* /*
Collision detection Collision detection
@ -224,7 +222,7 @@ void LocalPlayer::move(f32 dtime, Environment *env, f32 pos_max_d,
// If in liquid, the threshold of coming out is at higher y // If in liquid, the threshold of coming out is at higher y
if (in_liquid) if (in_liquid)
{ {
pp = floatToInt(position + v3f(0,BS*0.1,0), BS); pp = floatToInt(position + v3f(0.0f, BS * 0.1f, 0.0f), BS);
node = map->getNode(pp, &is_valid_position); node = map->getNode(pp, &is_valid_position);
if (is_valid_position) { if (is_valid_position) {
in_liquid = nodemgr->get(node.getContent()).isLiquid(); in_liquid = nodemgr->get(node.getContent()).isLiquid();
@ -232,11 +230,10 @@ void LocalPlayer::move(f32 dtime, Environment *env, f32 pos_max_d,
} else { } else {
in_liquid = false; in_liquid = false;
} }
} } else {
// If not in liquid, the threshold of going in is at lower y // If not in liquid, the threshold of going in is at lower y
else
{ pp = floatToInt(position + v3f(0.0f, BS * 0.5f, 0.0f), BS);
pp = floatToInt(position + v3f(0,BS*0.5,0), BS);
node = map->getNode(pp, &is_valid_position); node = map->getNode(pp, &is_valid_position);
if (is_valid_position) { if (is_valid_position) {
in_liquid = nodemgr->get(node.getContent()).isLiquid(); in_liquid = nodemgr->get(node.getContent()).isLiquid();
@ -250,7 +247,7 @@ void LocalPlayer::move(f32 dtime, Environment *env, f32 pos_max_d,
/* /*
Check if player is in liquid (the stable value) Check if player is in liquid (the stable value)
*/ */
pp = floatToInt(position + v3f(0,0,0), BS); pp = floatToInt(position + v3f(0.0f), BS);
node = map->getNode(pp, &is_valid_position); node = map->getNode(pp, &is_valid_position);
if (is_valid_position) { if (is_valid_position) {
in_liquid_stable = nodemgr->get(node.getContent()).isLiquid(); in_liquid_stable = nodemgr->get(node.getContent()).isLiquid();
@ -259,12 +256,11 @@ void LocalPlayer::move(f32 dtime, Environment *env, f32 pos_max_d,
} }
/* /*
Check if player is climbing Check if player is climbing
*/ */
pp = floatToInt(position + v3f(0.0f, 0.5f * BS, 0.0f), BS);
pp = floatToInt(position + v3f(0,0.5*BS,0), BS); v3s16 pp2 = floatToInt(position + v3f(0.0f, -0.2f * BS, 0.0f), BS);
v3s16 pp2 = floatToInt(position + v3f(0,-0.2*BS,0), BS);
node = map->getNode(pp, &is_valid_position); node = map->getNode(pp, &is_valid_position);
bool is_valid_position2; bool is_valid_position2;
MapNode node2 = map->getNode(pp2, &is_valid_position2); MapNode node2 = map->getNode(pp2, &is_valid_position2);
@ -272,8 +268,8 @@ void LocalPlayer::move(f32 dtime, Environment *env, f32 pos_max_d,
if (!(is_valid_position && is_valid_position2)) { if (!(is_valid_position && is_valid_position2)) {
is_climbing = false; is_climbing = false;
} else { } else {
is_climbing = (nodemgr->get(node.getContent()).climbable is_climbing = (nodemgr->get(node.getContent()).climbable ||
|| nodemgr->get(node2.getContent()).climbable) && !free_move; nodemgr->get(node2.getContent()).climbable) && !free_move;
} }
/* /*
@ -282,7 +278,7 @@ void LocalPlayer::move(f32 dtime, Environment *env, f32 pos_max_d,
*/ */
//f32 d = pos_max_d * 1.1; //f32 d = pos_max_d * 1.1;
// A fairly large value in here makes moving smoother // A fairly large value in here makes moving smoother
f32 d = 0.15*BS; f32 d = 0.15f * BS;
// This should always apply, otherwise there are glitches // This should always apply, otherwise there are glitches
sanity_check(d > pos_max_d); sanity_check(d > pos_max_d);
@ -292,7 +288,7 @@ void LocalPlayer::move(f32 dtime, Environment *env, f32 pos_max_d,
float player_stepheight = (m_cao == nullptr) ? 0.0f : float player_stepheight = (m_cao == nullptr) ? 0.0f :
(touching_ground ? m_cao->getStepHeight() : (0.2f * BS)); (touching_ground ? m_cao->getStepHeight() : (0.2f * BS));
v3f accel_f = v3f(0,0,0); v3f accel_f;
const v3f initial_position = position; const v3f initial_position = position;
const v3f initial_speed = m_speed; const v3f initial_speed = m_speed;
@ -346,7 +342,7 @@ void LocalPlayer::move(f32 dtime, Environment *env, f32 pos_max_d,
if (m_sneak_ladder_detected) { if (m_sneak_ladder_detected) {
// restore legacy behaviour (this makes the m_speed.Y hack necessary) // restore legacy behaviour (this makes the m_speed.Y hack necessary)
sneak_max = v3f(0.4 * BS, 0, 0.4 * BS); sneak_max = v3f(0.4f * BS, 0.0f, 0.4f * BS);
} }
/* /*
@ -370,12 +366,12 @@ void LocalPlayer::move(f32 dtime, Environment *env, f32 pos_max_d,
bmin.Z - sneak_max.Z, bmax.Z + sneak_max.Z); bmin.Z - sneak_max.Z, bmax.Z + sneak_max.Z);
if (position.X != old_pos.X) if (position.X != old_pos.X)
m_speed.X = 0; m_speed.X = 0.0f;
if (position.Z != old_pos.Z) if (position.Z != old_pos.Z)
m_speed.Z = 0; m_speed.Z = 0.0f;
} }
if (y_diff > 0 && m_speed.Y <= 0 && if (y_diff > 0 && m_speed.Y <= 0.0f &&
(physics_override_sneak_glitch || y_diff < BS * 0.6f)) { (physics_override_sneak_glitch || y_diff < BS * 0.6f)) {
// Move player to the maximal height when falling or when // Move player to the maximal height when falling or when
// the ledge is climbed on the next step. // the ledge is climbed on the next step.
@ -383,11 +379,11 @@ void LocalPlayer::move(f32 dtime, Environment *env, f32 pos_max_d,
// Smoothen the movement (based on 'position.Y = bmax.Y') // Smoothen the movement (based on 'position.Y = bmax.Y')
position.Y += y_diff * dtime * 22.0f + BS * 0.01f; position.Y += y_diff * dtime * 22.0f + BS * 0.01f;
position.Y = std::min(position.Y, bmax.Y); position.Y = std::min(position.Y, bmax.Y);
m_speed.Y = 0; m_speed.Y = 0.0f;
} }
// Allow jumping on node edges while sneaking // Allow jumping on node edges while sneaking
if (m_speed.Y == 0 || m_sneak_ladder_detected) if (m_speed.Y == 0.0f || m_sneak_ladder_detected)
sneak_can_jump = true; sneak_can_jump = true;
if (collision_info && if (collision_info &&
@ -419,7 +415,7 @@ void LocalPlayer::move(f32 dtime, Environment *env, f32 pos_max_d,
Report collisions Report collisions
*/ */
if(!result.standing_on_object && !touching_ground_was && touching_ground) { if (!result.standing_on_object && !touching_ground_was && touching_ground) {
m_client->getEventManager()->put(new SimpleTriggerEvent(MtEvent::PLAYER_REGAIN_GROUND)); m_client->getEventManager()->put(new SimpleTriggerEvent(MtEvent::PLAYER_REGAIN_GROUND));
// Set camera impact value to be used for view bobbing // Set camera impact value to be used for view bobbing
@ -430,10 +426,9 @@ void LocalPlayer::move(f32 dtime, Environment *env, f32 pos_max_d,
camera_barely_in_ceiling = false; camera_barely_in_ceiling = false;
v3s16 camera_np = floatToInt(getEyePosition(), BS); v3s16 camera_np = floatToInt(getEyePosition(), BS);
MapNode n = map->getNode(camera_np); MapNode n = map->getNode(camera_np);
if(n.getContent() != CONTENT_IGNORE){ if (n.getContent() != CONTENT_IGNORE) {
if(nodemgr->get(n).walkable && nodemgr->get(n).solidness == 2){ if (nodemgr->get(n).walkable && nodemgr->get(n).solidness == 2)
camera_barely_in_ceiling = true; camera_barely_in_ceiling = true;
}
} }
} }
@ -444,16 +439,15 @@ void LocalPlayer::move(f32 dtime, Environment *env, f32 pos_max_d,
// Determine if jumping is possible // Determine if jumping is possible
m_disable_jump = itemgroup_get(f.groups, "disable_jump"); m_disable_jump = itemgroup_get(f.groups, "disable_jump");
m_can_jump = ((touching_ground && !is_climbing) m_can_jump = ((touching_ground && !is_climbing) || sneak_can_jump) && !m_disable_jump;
|| sneak_can_jump) && !m_disable_jump;
// Jump key pressed while jumping off from a bouncy block // Jump key pressed while jumping off from a bouncy block
if (m_can_jump && control.jump && itemgroup_get(f.groups, "bouncy") && if (m_can_jump && control.jump && itemgroup_get(f.groups, "bouncy") &&
m_speed.Y >= -0.5 * BS) { m_speed.Y >= -0.5f * BS) {
float jumpspeed = movement_speed_jump * physics_override_jump; float jumpspeed = movement_speed_jump * physics_override_jump;
if (m_speed.Y > 1) { if (m_speed.Y > 1.0f) {
// Reduce boost when speed already is high // Reduce boost when speed already is high
m_speed.Y += jumpspeed / (1 + (m_speed.Y / 16 )); m_speed.Y += jumpspeed / (1.0f + (m_speed.Y / 16.0f));
} else { } else {
m_speed.Y += jumpspeed; m_speed.Y += jumpspeed;
} }
@ -480,9 +474,8 @@ void LocalPlayer::applyControl(float dtime, Environment *env)
setYaw(control.yaw); setYaw(control.yaw);
// Nullify speed and don't run positioning code if the player is attached // Nullify speed and don't run positioning code if the player is attached
if(isAttached) if (isAttached) {
{ setSpeed(v3f(0.0f));
setSpeed(v3f(0,0,0));
return; return;
} }
@ -491,8 +484,7 @@ void LocalPlayer::applyControl(float dtime, Environment *env)
// All vectors are relative to the player's yaw, // All vectors are relative to the player's yaw,
// (and pitch if pitch move mode enabled), // (and pitch if pitch move mode enabled),
// and will be rotated at the end // and will be rotated at the end
v3f speedH = v3f(0,0,0); // Horizontal (X, Z) v3f speedH, speedV; // Horizontal (X, Z) and Vertical (Y)
v3f speedV = v3f(0,0,0); // Vertical (Y)
bool fly_allowed = m_client->checkLocalPrivilege("fly"); bool fly_allowed = m_client->checkLocalPrivilege("fly");
bool fast_allowed = m_client->checkLocalPrivilege("fast"); bool fast_allowed = m_client->checkLocalPrivilege("fast");
@ -511,76 +503,58 @@ void LocalPlayer::applyControl(float dtime, Environment *env)
superspeed = true; superspeed = true;
// Old descend control // Old descend control
if (player_settings.aux1_descends) if (player_settings.aux1_descends) {
{
// If free movement and fast movement, always move fast // If free movement and fast movement, always move fast
if(free_move && fast_move) if (free_move && fast_move)
superspeed = true; superspeed = true;
// Auxiliary button 1 (E) // Auxiliary button 1 (E)
if(control.aux1) if (control.aux1) {
{ if (free_move) {
if(free_move)
{
// In free movement mode, aux1 descends // In free movement mode, aux1 descends
if(fast_move) if (fast_move)
speedV.Y = -movement_speed_fast; speedV.Y = -movement_speed_fast;
else else
speedV.Y = -movement_speed_walk; speedV.Y = -movement_speed_walk;
} } else if (in_liquid || in_liquid_stable) {
else if(in_liquid || in_liquid_stable)
{
speedV.Y = -movement_speed_walk; speedV.Y = -movement_speed_walk;
swimming_vertical = true; swimming_vertical = true;
} } else if (is_climbing) {
else if(is_climbing)
{
speedV.Y = -movement_speed_climb; speedV.Y = -movement_speed_climb;
} } else {
else
{
// If not free movement but fast is allowed, aux1 is // If not free movement but fast is allowed, aux1 is
// "Turbo button" // "Turbo button"
if(fast_move) if (fast_move)
superspeed = true; superspeed = true;
} }
} }
} } else {
// New minecraft-like descend control // New minecraft-like descend control
else
{
// Auxiliary button 1 (E) // Auxiliary button 1 (E)
if(control.aux1) if (control.aux1) {
{ if (!is_climbing) {
if(!is_climbing)
{
// aux1 is "Turbo button" // aux1 is "Turbo button"
if(fast_move) if (fast_move)
superspeed = true; superspeed = true;
} }
} }
if(control.sneak) if (control.sneak) {
{ if (free_move) {
if(free_move)
{
// In free movement mode, sneak descends // In free movement mode, sneak descends
if (fast_move && (control.aux1 || always_fly_fast)) if (fast_move && (control.aux1 || always_fly_fast))
speedV.Y = -movement_speed_fast; speedV.Y = -movement_speed_fast;
else else
speedV.Y = -movement_speed_walk; speedV.Y = -movement_speed_walk;
} } else if (in_liquid || in_liquid_stable) {
else if(in_liquid || in_liquid_stable) if (fast_climb)
{
if(fast_climb)
speedV.Y = -movement_speed_fast; speedV.Y = -movement_speed_fast;
else else
speedV.Y = -movement_speed_walk; speedV.Y = -movement_speed_walk;
swimming_vertical = true; swimming_vertical = true;
} } else if (is_climbing) {
else if(is_climbing) if (fast_climb)
{
if(fast_climb)
speedV.Y = -movement_speed_fast; speedV.Y = -movement_speed_fast;
else else
speedV.Y = -movement_speed_climb; speedV.Y = -movement_speed_climb;
@ -588,34 +562,32 @@ void LocalPlayer::applyControl(float dtime, Environment *env)
} }
} }
if (control.up) { if (control.up)
speedH += v3f(0,0,1); speedH += v3f(0.0f, 0.0f, 1.0f);
}
if (control.down) { if (control.down)
speedH -= v3f(0,0,1); speedH -= v3f(0.0f, 0.0f, 1.0f);
}
if (!control.up && !control.down) { if (!control.up && !control.down)
speedH -= v3f(0,0,1) * speedH -= v3f(0.0f, 0.0f, 1.0f) * (control.forw_move_joystick_axis / 32767.f);
(control.forw_move_joystick_axis / 32767.f);
} if (control.left)
if (control.left) { speedH += v3f(-1.0f, 0.0f, 0.0f);
speedH += v3f(-1,0,0);
} if (control.right)
if (control.right) { speedH += v3f(1.0f, 0.0f, 0.0f);
speedH += v3f(1,0,0);
} if (!control.left && !control.right)
if (!control.left && !control.right) { speedH += v3f(1.0f, 0.0f, 0.0f) * (control.sidew_move_joystick_axis / 32767.f);
speedH += v3f(1,0,0) *
(control.sidew_move_joystick_axis / 32767.f);
}
if (m_autojump) { if (m_autojump) {
// release autojump after a given time // release autojump after a given time
m_autojump_time -= dtime; m_autojump_time -= dtime;
if (m_autojump_time <= 0.0f) if (m_autojump_time <= 0.0f)
m_autojump = false; m_autojump = false;
} }
if(control.jump)
{ if (control.jump) {
if (free_move) { if (free_move) {
if (player_settings.aux1_descends || always_fly_fast) { if (player_settings.aux1_descends || always_fly_fast) {
if (fast_move) if (fast_move)
@ -623,21 +595,19 @@ void LocalPlayer::applyControl(float dtime, Environment *env)
else else
speedV.Y = movement_speed_walk; speedV.Y = movement_speed_walk;
} else { } else {
if(fast_move && control.aux1) if (fast_move && control.aux1)
speedV.Y = movement_speed_fast; speedV.Y = movement_speed_fast;
else else
speedV.Y = movement_speed_walk; speedV.Y = movement_speed_walk;
} }
} } else if (m_can_jump) {
else if(m_can_jump)
{
/* /*
NOTE: The d value in move() affects jump height by NOTE: The d value in move() affects jump height by
raising the height at which the jump speed is kept raising the height at which the jump speed is kept
at its starting value at its starting value
*/ */
v3f speedJ = getSpeed(); v3f speedJ = getSpeed();
if(speedJ.Y >= -0.5 * BS) { if (speedJ.Y >= -0.5f * BS) {
speedJ.Y = movement_speed_jump * physics_override_jump; speedJ.Y = movement_speed_jump * physics_override_jump;
setSpeed(speedJ); setSpeed(speedJ);
m_client->getEventManager()->put(new SimpleTriggerEvent(MtEvent::PLAYER_JUMP)); m_client->getEventManager()->put(new SimpleTriggerEvent(MtEvent::PLAYER_JUMP));
@ -657,29 +627,31 @@ void LocalPlayer::applyControl(float dtime, Environment *env)
} }
// The speed of the player (Y is ignored) // The speed of the player (Y is ignored)
if(superspeed || (is_climbing && fast_climb) || ((in_liquid || in_liquid_stable) && fast_climb)) if (superspeed || (is_climbing && fast_climb) ||
((in_liquid || in_liquid_stable) && fast_climb))
speedH = speedH.normalize() * movement_speed_fast; speedH = speedH.normalize() * movement_speed_fast;
else if(control.sneak && !free_move && !in_liquid && !in_liquid_stable) else if (control.sneak && !free_move && !in_liquid && !in_liquid_stable)
speedH = speedH.normalize() * movement_speed_crouch; speedH = speedH.normalize() * movement_speed_crouch;
else else
speedH = speedH.normalize() * movement_speed_walk; speedH = speedH.normalize() * movement_speed_walk;
// Acceleration increase // Acceleration increase
f32 incH = 0; // Horizontal (X, Z) f32 incH = 0.0f; // Horizontal (X, Z)
f32 incV = 0; // Vertical (Y) f32 incV = 0.0f; // Vertical (Y)
if((!touching_ground && !free_move && !is_climbing && !in_liquid) || (!free_move && m_can_jump && control.jump)) if ((!touching_ground && !free_move && !is_climbing && !in_liquid) ||
{ (!free_move && m_can_jump && control.jump)) {
// Jumping and falling // Jumping and falling
if(superspeed || (fast_move && control.aux1)) if (superspeed || (fast_move && control.aux1))
incH = movement_acceleration_fast * BS * dtime; incH = movement_acceleration_fast * BS * dtime;
else else
incH = movement_acceleration_air * BS * dtime; incH = movement_acceleration_air * BS * dtime;
incV = 0; // No vertical acceleration in air incV = 0.0f; // No vertical acceleration in air
} } else if (superspeed || (is_climbing && fast_climb) ||
else if (superspeed || (is_climbing && fast_climb) || ((in_liquid || in_liquid_stable) && fast_climb)) ((in_liquid || in_liquid_stable) && fast_climb)) {
incH = incV = movement_acceleration_fast * BS * dtime; incH = incV = movement_acceleration_fast * BS * dtime;
else } else {
incH = incV = movement_acceleration_default * BS * dtime; incH = incV = movement_acceleration_default * BS * dtime;
}
float slip_factor = 1.0f; float slip_factor = 1.0f;
if (!free_move && !in_liquid && !in_liquid_stable) if (!free_move && !in_liquid && !in_liquid_stable)
@ -694,52 +666,55 @@ void LocalPlayer::applyControl(float dtime, Environment *env)
// Accelerate to target speed with maximum increment // Accelerate to target speed with maximum increment
accelerate((speedH + speedV) * physics_override_speed, accelerate((speedH + speedV) * physics_override_speed,
incH * physics_override_speed * slip_factor, incV * physics_override_speed, incH * physics_override_speed * slip_factor, incV * physics_override_speed,
pitch_move); pitch_move);
} }
v3s16 LocalPlayer::getStandingNodePos() v3s16 LocalPlayer::getStandingNodePos()
{ {
if(m_sneak_node_exists) if (m_sneak_node_exists)
return m_sneak_node; return m_sneak_node;
return m_standing_node; return m_standing_node;
} }
v3s16 LocalPlayer::getFootstepNodePos() v3s16 LocalPlayer::getFootstepNodePos()
{ {
// Emit swimming sound if the player is in liquid
if (in_liquid_stable) if (in_liquid_stable)
// Emit swimming sound if the player is in liquid
return floatToInt(getPosition(), BS); return floatToInt(getPosition(), BS);
// 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) if (touching_ground)
// BS * 0.05 below the player's feet ensures a 1/16th height return floatToInt(getPosition() - v3f(0.0f, BS * 0.05f, 0.0f), BS);
// nodebox is detected instead of the node below it.
return floatToInt(getPosition() - v3f(0, BS * 0.05f, 0), BS);
// A larger distance below is necessary for a footstep sound // A larger distance below is necessary for a footstep sound
// when landing after a jump or fall. BS * 0.5 ensures water // when landing after a jump or fall. BS * 0.5 ensures water
// sounds when swimming in 1 node deep water. // sounds when swimming in 1 node deep water.
return floatToInt(getPosition() - v3f(0, BS * 0.5f, 0), BS); return floatToInt(getPosition() - v3f(0.0f, BS * 0.5f, 0.0f), BS);
} }
v3s16 LocalPlayer::getLightPosition() const v3s16 LocalPlayer::getLightPosition() const
{ {
return floatToInt(m_position + v3f(0,BS+BS/2,0), BS); return floatToInt(m_position + v3f(0.0f, BS * 1.5f, 0.0f), BS);
} }
v3f LocalPlayer::getEyeOffset() const v3f LocalPlayer::getEyeOffset() const
{ {
float eye_height = camera_barely_in_ceiling ? float eye_height = camera_barely_in_ceiling ? m_eye_height - 0.125f : m_eye_height;
m_eye_height - 0.125f : m_eye_height; return v3f(0.0f, BS * eye_height, 0.0f);
return v3f(0, BS * eye_height, 0);
} }
bool LocalPlayer::isDead() const bool LocalPlayer::isDead() const
{ {
FATAL_ERROR_IF(!getCAO(), "LocalPlayer's CAO isn't initialized");
return !getCAO()->isImmortal() && hp == 0; return !getCAO()->isImmortal() && hp == 0;
} }
// 3D acceleration // 3D acceleration
void LocalPlayer::accelerate(const v3f &target_speed, const f32 max_increase_H, void LocalPlayer::accelerate(const v3f &target_speed, const f32 max_increase_H,
const f32 max_increase_V, const bool use_pitch) const f32 max_increase_V, const bool use_pitch)
{ {
const f32 yaw = getYaw(); const f32 yaw = getYaw();
const f32 pitch = getPitch(); const f32 pitch = getPitch();
@ -750,18 +725,18 @@ void LocalPlayer::accelerate(const v3f &target_speed, const f32 max_increase_H,
flat_speed.rotateYZBy(-pitch); flat_speed.rotateYZBy(-pitch);
v3f d_wanted = target_speed - flat_speed; v3f d_wanted = target_speed - flat_speed;
v3f d = v3f(0,0,0); v3f d;
// Then compare the horizontal and vertical components with the wanted speed // Then compare the horizontal and vertical components with the wanted speed
if (max_increase_H > 0) { if (max_increase_H > 0.0f) {
v3f d_wanted_H = d_wanted * v3f(1,0,1); v3f d_wanted_H = d_wanted * v3f(1.0f, 0.0f, 1.0f);
if (d_wanted_H.getLength() > max_increase_H) if (d_wanted_H.getLength() > max_increase_H)
d += d_wanted_H.normalize() * max_increase_H; d += d_wanted_H.normalize() * max_increase_H;
else else
d += d_wanted_H; d += d_wanted_H;
} }
if (max_increase_V > 0) { if (max_increase_V > 0.0f) {
f32 d_wanted_V = d_wanted.Y; f32 d_wanted_V = d_wanted.Y;
if (d_wanted_V > max_increase_V) if (d_wanted_V > max_increase_V)
d.Y += max_increase_V; d.Y += max_increase_V;
@ -781,7 +756,7 @@ void LocalPlayer::accelerate(const v3f &target_speed, const f32 max_increase_H,
// Temporary option for old move code // Temporary option for old move code
void LocalPlayer::old_move(f32 dtime, Environment *env, f32 pos_max_d, void LocalPlayer::old_move(f32 dtime, Environment *env, f32 pos_max_d,
std::vector<CollisionInfo> *collision_info) std::vector<CollisionInfo> *collision_info)
{ {
Map *map = &env->getMap(); Map *map = &env->getMap();
const NodeDefManager *nodemgr = m_client->ndef(); const NodeDefManager *nodemgr = m_client->ndef();
@ -792,7 +767,7 @@ void LocalPlayer::old_move(f32 dtime, Environment *env, f32 pos_max_d,
if (isAttached) { if (isAttached) {
setPosition(overridePosition); setPosition(overridePosition);
m_sneak_node_exists = false; m_sneak_node_exists = false;
added_velocity = v3f(); added_velocity = v3f(0.0f);
return; return;
} }
@ -806,12 +781,12 @@ void LocalPlayer::old_move(f32 dtime, Environment *env, f32 pos_max_d,
position += m_speed * dtime; position += m_speed * dtime;
setPosition(position); setPosition(position);
m_sneak_node_exists = false; m_sneak_node_exists = false;
added_velocity = v3f(); added_velocity = v3f(0.0f);
return; return;
} }
m_speed += added_velocity; m_speed += added_velocity;
added_velocity = v3f(); added_velocity = v3f(0.0f);
/* /*
Collision detection Collision detection
@ -825,7 +800,7 @@ void LocalPlayer::old_move(f32 dtime, Environment *env, f32 pos_max_d,
*/ */
if (in_liquid) { if (in_liquid) {
// If in liquid, the threshold of coming out is at higher y // If in liquid, the threshold of coming out is at higher y
pp = floatToInt(position + v3f(0, BS * 0.1, 0), BS); pp = floatToInt(position + v3f(0.0f, BS * 0.1f, 0.0f), BS);
node = map->getNode(pp, &is_valid_position); node = map->getNode(pp, &is_valid_position);
if (is_valid_position) { if (is_valid_position) {
in_liquid = nodemgr->get(node.getContent()).isLiquid(); in_liquid = nodemgr->get(node.getContent()).isLiquid();
@ -835,7 +810,7 @@ void LocalPlayer::old_move(f32 dtime, Environment *env, f32 pos_max_d,
} }
} else { } else {
// If not in liquid, the threshold of going in is at lower y // If not in liquid, the threshold of going in is at lower y
pp = floatToInt(position + v3f(0, BS * 0.5, 0), BS); pp = floatToInt(position + v3f(0.0f, BS * 0.5f, 0.0f), BS);
node = map->getNode(pp, &is_valid_position); node = map->getNode(pp, &is_valid_position);
if (is_valid_position) { if (is_valid_position) {
in_liquid = nodemgr->get(node.getContent()).isLiquid(); in_liquid = nodemgr->get(node.getContent()).isLiquid();
@ -848,7 +823,7 @@ void LocalPlayer::old_move(f32 dtime, Environment *env, f32 pos_max_d,
/* /*
Check if player is in liquid (the stable value) Check if player is in liquid (the stable value)
*/ */
pp = floatToInt(position + v3f(0, 0, 0), BS); pp = floatToInt(position + v3f(0.0f), BS);
node = map->getNode(pp, &is_valid_position); node = map->getNode(pp, &is_valid_position);
if (is_valid_position) if (is_valid_position)
in_liquid_stable = nodemgr->get(node.getContent()).isLiquid(); in_liquid_stable = nodemgr->get(node.getContent()).isLiquid();
@ -858,8 +833,8 @@ void LocalPlayer::old_move(f32 dtime, Environment *env, f32 pos_max_d,
/* /*
Check if player is climbing Check if player is climbing
*/ */
pp = floatToInt(position + v3f(0, 0.5 * BS, 0), BS); pp = floatToInt(position + v3f(0.0f, 0.5f * BS, 0.0f), BS);
v3s16 pp2 = floatToInt(position + v3f(0, -0.2 * BS, 0), BS); v3s16 pp2 = floatToInt(position + v3f(0.0f, -0.2f * BS, 0.0f), BS);
node = map->getNode(pp, &is_valid_position); node = map->getNode(pp, &is_valid_position);
bool is_valid_position2; bool is_valid_position2;
MapNode node2 = map->getNode(pp2, &is_valid_position2); MapNode node2 = map->getNode(pp2, &is_valid_position2);
@ -868,7 +843,7 @@ void LocalPlayer::old_move(f32 dtime, Environment *env, f32 pos_max_d,
is_climbing = false; is_climbing = false;
else else
is_climbing = (nodemgr->get(node.getContent()).climbable || is_climbing = (nodemgr->get(node.getContent()).climbable ||
nodemgr->get(node2.getContent()).climbable) && !free_move; nodemgr->get(node2.getContent()).climbable) && !free_move;
/* /*
Collision uncertainty radius Collision uncertainty radius
@ -876,11 +851,11 @@ void LocalPlayer::old_move(f32 dtime, Environment *env, f32 pos_max_d,
*/ */
//f32 d = pos_max_d * 1.1; //f32 d = pos_max_d * 1.1;
// A fairly large value in here makes moving smoother // A fairly large value in here makes moving smoother
f32 d = 0.15 * BS; f32 d = 0.15f * BS;
// This should always apply, otherwise there are glitches // This should always apply, otherwise there are glitches
sanity_check(d > pos_max_d); sanity_check(d > pos_max_d);
// Maximum distance over border for sneaking // Maximum distance over border for sneaking
f32 sneak_max = BS * 0.4; f32 sneak_max = BS * 0.4f;
/* /*
If sneaking, keep in range from the last walked node and don't If sneaking, keep in range from the last walked node and don't
@ -889,14 +864,14 @@ void LocalPlayer::old_move(f32 dtime, Environment *env, f32 pos_max_d,
if (control.sneak && m_sneak_node_exists && if (control.sneak && m_sneak_node_exists &&
!(fly_allowed && player_settings.free_move) && !in_liquid && !(fly_allowed && player_settings.free_move) && !in_liquid &&
physics_override_sneak) { physics_override_sneak) {
f32 maxd = 0.5 * BS + sneak_max; f32 maxd = 0.5f * BS + sneak_max;
v3f lwn_f = intToFloat(m_sneak_node, BS); v3f lwn_f = intToFloat(m_sneak_node, BS);
position.X = rangelim(position.X, lwn_f.X - maxd, lwn_f.X + maxd); 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); position.Z = rangelim(position.Z, lwn_f.Z - maxd, lwn_f.Z + maxd);
if (!is_climbing) { if (!is_climbing) {
// Move up if necessary // Move up if necessary
f32 new_y = (lwn_f.Y - 0.5 * BS) + m_sneak_node_bb_ymax; f32 new_y = (lwn_f.Y - 0.5f * BS) + m_sneak_node_bb_ymax;
if (position.Y < new_y) if (position.Y < new_y)
position.Y = new_y; position.Y = new_y;
/* /*
@ -904,15 +879,15 @@ void LocalPlayer::old_move(f32 dtime, Environment *env, f32 pos_max_d,
sneaking over the edges of current sneaking_node. sneaking over the edges of current sneaking_node.
TODO (when fixed): Set Y-speed only to 0 when position.Y < new_y. TODO (when fixed): Set Y-speed only to 0 when position.Y < new_y.
*/ */
if (m_speed.Y < 0) if (m_speed.Y < 0.0f)
m_speed.Y = 0; m_speed.Y = 0.0f;
} }
} }
// this shouldn't be hardcoded but transmitted from server // TODO: This shouldn't be hardcoded but decided by the server
float player_stepheight = touching_ground ? (BS * 0.6) : (BS * 0.2); float player_stepheight = touching_ground ? (BS * 0.6f) : (BS * 0.2f);
v3f accel_f = v3f(0, 0, 0); v3f accel_f;
const v3f initial_position = position; const v3f initial_position = position;
const v3f initial_speed = m_speed; const v3f initial_speed = m_speed;
@ -922,7 +897,7 @@ void LocalPlayer::old_move(f32 dtime, Environment *env, f32 pos_max_d,
// Positition was slightly changed; update standing node pos // Positition was slightly changed; update standing node pos
if (touching_ground) if (touching_ground)
m_standing_node = floatToInt(m_position - v3f(0, 0.1f * BS, 0), BS); m_standing_node = floatToInt(m_position - v3f(0.0f, 0.1f * BS, 0.0f), BS);
else else
m_standing_node = floatToInt(m_position, BS); m_standing_node = floatToInt(m_position, BS);
@ -942,10 +917,10 @@ void LocalPlayer::old_move(f32 dtime, Environment *env, f32 pos_max_d,
player is sneaking from, if any. If the node from under player is sneaking from, if any. If the node from under
the player has been removed, the player falls. the player has been removed, the player falls.
*/ */
f32 position_y_mod = 0.05 * BS; f32 position_y_mod = 0.05f * BS;
if (m_sneak_node_bb_ymax > 0) if (m_sneak_node_bb_ymax > 0.0f)
position_y_mod = m_sneak_node_bb_ymax - position_y_mod; position_y_mod = m_sneak_node_bb_ymax - position_y_mod;
v3s16 current_node = floatToInt(position - v3f(0, position_y_mod, 0), BS); v3s16 current_node = floatToInt(position - v3f(0.0f, position_y_mod, 0.0f), BS);
if (m_sneak_node_exists && if (m_sneak_node_exists &&
nodemgr->get(map->getNode(m_old_node_below)).name == "air" && nodemgr->get(map->getNode(m_old_node_below)).name == "air" &&
m_old_node_below_type != "air") { m_old_node_below_type != "air") {
@ -960,10 +935,10 @@ void LocalPlayer::old_move(f32 dtime, Environment *env, f32 pos_max_d,
} }
if (m_need_to_get_new_sneak_node && physics_override_sneak) { if (m_need_to_get_new_sneak_node && physics_override_sneak) {
m_sneak_node_bb_ymax = 0; m_sneak_node_bb_ymax = 0.0f;
v3s16 pos_i_bottom = floatToInt(position - v3f(0, position_y_mod, 0), BS); v3s16 pos_i_bottom = floatToInt(position - v3f(0.0f, position_y_mod, 0.0f), BS);
v2f player_p2df(position.X, position.Z); v2f player_p2df(position.X, position.Z);
f32 min_distance_f = 100000.0 * BS; f32 min_distance_f = 100000.0f * BS;
// If already seeking from some node, compare to it. // If already seeking from some node, compare to it.
v3s16 new_sneak_node = m_sneak_node; v3s16 new_sneak_node = m_sneak_node;
for (s16 x= -1; x <= 1; x++) for (s16 x= -1; x <= 1; x++)
@ -973,11 +948,11 @@ void LocalPlayer::old_move(f32 dtime, Environment *env, f32 pos_max_d,
v2f node_p2df(pf.X, pf.Z); v2f node_p2df(pf.X, pf.Z);
f32 distance_f = player_p2df.getDistanceFrom(node_p2df); f32 distance_f = player_p2df.getDistanceFrom(node_p2df);
f32 max_axis_distance_f = MYMAX( f32 max_axis_distance_f = MYMAX(
std::fabs(player_p2df.X - node_p2df.X), std::fabs(player_p2df.X - node_p2df.X),
std::fabs(player_p2df.Y - node_p2df.Y)); std::fabs(player_p2df.Y - node_p2df.Y));
if (distance_f > min_distance_f || if (distance_f > min_distance_f ||
max_axis_distance_f > 0.5 * BS + sneak_max + 0.1 * BS) max_axis_distance_f > 0.5f * BS + sneak_max + 0.1f * BS)
continue; continue;
// The node to be sneaked on has to be walkable // The node to be sneaked on has to be walkable
@ -990,7 +965,7 @@ void LocalPlayer::old_move(f32 dtime, Environment *env, f32 pos_max_d,
continue; continue;
// If not 'sneak_glitch' the node 2 nodes above it has to be nonwalkable // If not 'sneak_glitch' the node 2 nodes above it has to be nonwalkable
if (!physics_override_sneak_glitch) { if (!physics_override_sneak_glitch) {
node =map->getNode(p + v3s16(0, 2, 0), &is_valid_position); node = map->getNode(p + v3s16(0, 2, 0), &is_valid_position);
if (!is_valid_position || nodemgr->get(node).walkable) if (!is_valid_position || nodemgr->get(node).walkable)
continue; continue;
} }
@ -999,13 +974,13 @@ void LocalPlayer::old_move(f32 dtime, Environment *env, f32 pos_max_d,
new_sneak_node = p; new_sneak_node = p;
} }
bool sneak_node_found = (min_distance_f < 100000.0 * BS * 0.9); bool sneak_node_found = (min_distance_f < 100000.0f * BS * 0.9f);
m_sneak_node = new_sneak_node; m_sneak_node = new_sneak_node;
m_sneak_node_exists = sneak_node_found; m_sneak_node_exists = sneak_node_found;
if (sneak_node_found) { if (sneak_node_found) {
f32 cb_max = 0; f32 cb_max = 0.0f;
MapNode n = map->getNode(m_sneak_node); MapNode n = map->getNode(m_sneak_node);
std::vector<aabb3f> nodeboxes; std::vector<aabb3f> nodeboxes;
n.getCollisionBoxes(nodemgr, &nodeboxes); n.getCollisionBoxes(nodemgr, &nodeboxes);
@ -1034,7 +1009,7 @@ void LocalPlayer::old_move(f32 dtime, Environment *env, f32 pos_max_d,
/* /*
Report collisions Report collisions
*/ */
// Dont report if flying // Don't report if flying
if (collision_info && !(player_settings.free_move && fly_allowed)) { if (collision_info && !(player_settings.free_move && fly_allowed)) {
for (const auto &info : result.collisions) { for (const auto &info : result.collisions) {
collision_info->push_back(info); collision_info->push_back(info);
@ -1044,7 +1019,7 @@ void LocalPlayer::old_move(f32 dtime, Environment *env, f32 pos_max_d,
if (!result.standing_on_object && !touching_ground_was && touching_ground) { if (!result.standing_on_object && !touching_ground_was && touching_ground) {
m_client->getEventManager()->put(new SimpleTriggerEvent(MtEvent::PLAYER_REGAIN_GROUND)); m_client->getEventManager()->put(new SimpleTriggerEvent(MtEvent::PLAYER_REGAIN_GROUND));
// Set camera impact value to be used for view bobbing // Set camera impact value to be used for view bobbing
camera_impact = getSpeed().Y * -1; camera_impact = getSpeed().Y * -1.0f;
} }
{ {
@ -1060,14 +1035,13 @@ void LocalPlayer::old_move(f32 dtime, Environment *env, f32 pos_max_d,
/* /*
Update the node last under the player Update the node last under the player
*/ */
m_old_node_below = floatToInt(position - v3f(0, BS / 2, 0), BS); 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; 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 Check properties of the node on which the player is standing
*/ */
const ContentFeatures &f = nodemgr->get(map->getNode( const ContentFeatures &f = nodemgr->get(map->getNode(getStandingNodePos()));
getStandingNodePos()));
// Determine if jumping is possible // Determine if jumping is possible
m_disable_jump = itemgroup_get(f.groups, "disable_jump"); m_disable_jump = itemgroup_get(f.groups, "disable_jump");
@ -1075,11 +1049,11 @@ void LocalPlayer::old_move(f32 dtime, Environment *env, f32 pos_max_d,
// Jump key pressed while jumping off from a bouncy block // Jump key pressed while jumping off from a bouncy block
if (m_can_jump && control.jump && itemgroup_get(f.groups, "bouncy") && if (m_can_jump && control.jump && itemgroup_get(f.groups, "bouncy") &&
m_speed.Y >= -0.5 * BS) { m_speed.Y >= -0.5f * BS) {
float jumpspeed = movement_speed_jump * physics_override_jump; float jumpspeed = movement_speed_jump * physics_override_jump;
if (m_speed.Y > 1) { if (m_speed.Y > 1.0f) {
// Reduce boost when speed already is high // Reduce boost when speed already is high
m_speed.Y += jumpspeed / (1 + (m_speed.Y / 16 )); m_speed.Y += jumpspeed / (1.0f + (m_speed.Y / 16.0f));
} else { } else {
m_speed.Y += jumpspeed; m_speed.Y += jumpspeed;
} }
@ -1096,24 +1070,23 @@ float LocalPlayer::getSlipFactor(Environment *env, const v3f &speedH)
// Slip on slippery nodes // Slip on slippery nodes
const NodeDefManager *nodemgr = env->getGameDef()->ndef(); const NodeDefManager *nodemgr = env->getGameDef()->ndef();
Map *map = &env->getMap(); Map *map = &env->getMap();
const ContentFeatures &f = nodemgr->get(map->getNode( const ContentFeatures &f = nodemgr->get(map->getNode(getStandingNodePos()));
getStandingNodePos()));
int slippery = 0; int slippery = 0;
if (f.walkable) if (f.walkable)
slippery = itemgroup_get(f.groups, "slippery"); slippery = itemgroup_get(f.groups, "slippery");
if (slippery >= 1) { if (slippery >= 1) {
if (speedH == v3f(0.0f)) { if (speedH == v3f(0.0f))
slippery = slippery * 2; slippery *= 2;
}
return core::clamp(1.0f / (slippery + 1), 0.001f, 1.0f); return core::clamp(1.0f / (slippery + 1), 0.001f, 1.0f);
} }
return 1.0f; return 1.0f;
} }
void LocalPlayer::handleAutojump(f32 dtime, Environment *env, void LocalPlayer::handleAutojump(f32 dtime, Environment *env,
const collisionMoveResult &result, const v3f &initial_position, const collisionMoveResult &result, const v3f &initial_position,
const v3f &initial_speed, f32 pos_max_d) const v3f &initial_speed, f32 pos_max_d)
{ {
PlayerSettings &player_settings = getPlayerSettings(); PlayerSettings &player_settings = getPlayerSettings();
if (!player_settings.autojump) if (!player_settings.autojump)
@ -1123,10 +1096,12 @@ void LocalPlayer::handleAutojump(f32 dtime, Environment *env,
return; return;
bool control_forward = control.up || bool control_forward = control.up ||
(!control.up && !control.down && (!control.up && !control.down &&
control.forw_move_joystick_axis < -0.05); control.forw_move_joystick_axis < -0.05f);
bool could_autojump = bool could_autojump =
m_can_jump && !control.jump && !control.sneak && control_forward; m_can_jump && !control.jump && !control.sneak && control_forward;
if (!could_autojump) if (!could_autojump)
return; return;
@ -1150,8 +1125,8 @@ void LocalPlayer::handleAutojump(f32 dtime, Environment *env,
v3s16 ceilpos_max = floatToInt(headpos_max, BS) + v3s16(0, 1, 0); v3s16 ceilpos_max = floatToInt(headpos_max, BS) + v3s16(0, 1, 0);
const NodeDefManager *ndef = env->getGameDef()->ndef(); const NodeDefManager *ndef = env->getGameDef()->ndef();
bool is_position_valid; bool is_position_valid;
for (s16 z = ceilpos_min.Z; z <= ceilpos_max.Z; z++) { for (s16 z = ceilpos_min.Z; z <= ceilpos_max.Z; ++z) {
for (s16 x = ceilpos_min.X; x <= ceilpos_max.X; x++) { 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); MapNode n = env->getMap().getNode(v3s16(x, ceilpos_max.Y, z), &is_position_valid);
if (!is_position_valid) if (!is_position_valid)
@ -1170,8 +1145,7 @@ void LocalPlayer::handleAutojump(f32 dtime, Environment *env,
// try at peak of jump, zero step height // try at peak of jump, zero step height
collisionMoveResult jump_result = collisionMoveSimple(env, m_client, pos_max_d, collisionMoveResult jump_result = collisionMoveSimple(env, m_client, pos_max_d,
m_collisionbox, 0.0f, dtime, &jump_pos, &jump_speed, m_collisionbox, 0.0f, dtime, &jump_pos, &jump_speed, v3f(0.0f));
v3f(0, 0, 0));
// see if we can get a little bit farther horizontally if we had // see if we can get a little bit farther horizontally if we had
// jumped // jumped

14
src/client/localplayer.h
View File

@ -158,13 +158,13 @@ public:
private: private:
void accelerate(const v3f &target_speed, const f32 max_increase_H, void accelerate(const v3f &target_speed, const f32 max_increase_H,
const f32 max_increase_V, const bool use_pitch); const f32 max_increase_V, const bool use_pitch);
bool updateSneakNode(Map *map, const v3f &position, const v3f &sneak_max); bool updateSneakNode(Map *map, const v3f &position, const v3f &sneak_max);
float getSlipFactor(Environment *env, const v3f &speedH); float getSlipFactor(Environment *env, const v3f &speedH);
void handleAutojump(f32 dtime, Environment *env, void handleAutojump(f32 dtime, Environment *env,
const collisionMoveResult &result, const collisionMoveResult &result,
const v3f &position_before_move, const v3f &speed_before_move, const v3f &position_before_move, const v3f &speed_before_move,
f32 pos_max_d); f32 pos_max_d);
v3f m_position; v3f m_position;
v3s16 m_standing_node; v3s16 m_standing_node;
@ -196,12 +196,14 @@ private:
f32 m_pitch = 0.0f; f32 m_pitch = 0.0f;
bool camera_barely_in_ceiling = false; bool camera_barely_in_ceiling = false;
aabb3f m_collisionbox = aabb3f(-BS * 0.30f, 0.0f, -BS * 0.30f, BS * 0.30f, aabb3f m_collisionbox = aabb3f(-BS * 0.30f, 0.0f, -BS * 0.30f, BS * 0.30f,
BS * 1.75f, BS * 0.30f); BS * 1.75f, BS * 0.30f);
float m_eye_height = 1.625f; float m_eye_height = 1.625f;
float m_zoom_fov = 0.0f; float m_zoom_fov = 0.0f;
bool m_autojump = false; bool m_autojump = false;
float m_autojump_time = 0.0f; float m_autojump_time = 0.0f;
v3f added_velocity = v3f(0.0f, 0.0f, 0.0f); // cleared on each move()
v3f added_velocity = v3f(0.0f); // cleared on each move()
// TODO: Rename to adhere to convention: added_velocity --> m_added_velocity
GenericCAO *m_cao = nullptr; GenericCAO *m_cao = nullptr;
Client *m_client; Client *m_client;