/*
-Minetest-c55
-Copyright (C) 2010-2012 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+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
#include "gamedef.h"
#include "nodedef.h"
#include "settings.h"
+#include "environment.h"
#include "map.h"
#include "util/numeric.h"
LocalPlayer::LocalPlayer(IGameDef *gamedef):
Player(gamedef),
+ parent(0),
+ isAttached(false),
+ overridePosition(v3f(0,0,0)),
+ last_position(v3f(0,0,0)),
+ last_speed(v3f(0,0,0)),
+ last_pitch(0),
+ last_yaw(0),
+ last_keyPressed(0),
+ hotbar_image(""),
+ hotbar_selected_image(""),
m_sneak_node(32767,32767,32767),
- m_sneak_node_exists(false)
+ m_sneak_node_exists(false),
+ m_old_node_below(32767,32767,32767),
+ m_old_node_below_type("air"),
+ m_need_to_get_new_sneak_node(true),
+ m_can_jump(false)
{
// Initialize hp to 0, so that no hearts will be shown if server
// doesn't support health points
{
}
-void LocalPlayer::move(f32 dtime, Map &map, f32 pos_max_d,
- core::list<CollisionInfo> *collision_info)
+void LocalPlayer::move(f32 dtime, ClientEnvironment *env, f32 pos_max_d,
+ std::list<CollisionInfo> *collision_info)
{
+ Map *map = &env->getMap();
INodeDefManager *nodemgr = m_gamedef->ndef();
v3f position = getPosition();
- v3f oldpos = position;
- v3s16 oldpos_i = floatToInt(oldpos, BS);
v3f old_speed = m_speed;
- /*std::cout<<"oldpos_i=("<<oldpos_i.X<<","<<oldpos_i.Y<<","
- <<oldpos_i.Z<<")"<<std::endl;*/
+ // Copy parent position if local player is attached
+ if(isAttached)
+ {
+ setPosition(overridePosition);
+ m_sneak_node_exists = false;
+ return;
+ }
- /*
- Calculate new position
- */
- position += m_speed * dtime;
-
- // Skip collision detection if a special movement mode is used
+ // Skip collision detection if noclip mode is used
bool fly_allowed = m_gamedef->checkLocalPrivilege("fly");
- bool free_move = fly_allowed && g_settings->getBool("free_move");
+ bool noclip = m_gamedef->checkLocalPrivilege("noclip") &&
+ g_settings->getBool("noclip");
+ bool free_move = noclip && fly_allowed && g_settings->getBool("free_move");
if(free_move)
{
+ position += m_speed * dtime;
setPosition(position);
+ m_sneak_node_exists = false;
return;
}
Collision detection
*/
- // Player position in nodes
- v3s16 pos_i = floatToInt(position, BS);
-
/*
- Check if player is in water (the oscillating value)
+ Check if player is in liquid (the oscillating value)
*/
try{
- // If in water, the threshold of coming out is at higher y
- if(in_water)
+ // If in liquid, the threshold of coming out is at higher y
+ if(in_liquid)
{
v3s16 pp = floatToInt(position + v3f(0,BS*0.1,0), BS);
- in_water = nodemgr->get(map.getNode(pp).getContent()).isLiquid();
+ in_liquid = nodemgr->get(map->getNode(pp).getContent()).isLiquid();
+ liquid_viscosity = nodemgr->get(map->getNode(pp).getContent()).liquid_viscosity;
}
- // If not in water, the threshold of going in is at lower y
+ // If not in liquid, the threshold of going in is at lower y
else
{
v3s16 pp = floatToInt(position + v3f(0,BS*0.5,0), BS);
- in_water = nodemgr->get(map.getNode(pp).getContent()).isLiquid();
+ in_liquid = nodemgr->get(map->getNode(pp).getContent()).isLiquid();
+ liquid_viscosity = nodemgr->get(map->getNode(pp).getContent()).liquid_viscosity;
}
}
catch(InvalidPositionException &e)
{
- in_water = false;
+ in_liquid = false;
}
/*
- Check if player is in water (the stable value)
+ Check if player is in liquid (the stable value)
*/
try{
v3s16 pp = floatToInt(position + v3f(0,0,0), BS);
- in_water_stable = nodemgr->get(map.getNode(pp).getContent()).isLiquid();
+ in_liquid_stable = nodemgr->get(map->getNode(pp).getContent()).isLiquid();
}
catch(InvalidPositionException &e)
{
- in_water_stable = false;
+ in_liquid_stable = false;
}
/*
try {
v3s16 pp = floatToInt(position + v3f(0,0.5*BS,0), BS);
v3s16 pp2 = floatToInt(position + v3f(0,-0.2*BS,0), BS);
- is_climbing = ((nodemgr->get(map.getNode(pp).getContent()).climbable ||
- nodemgr->get(map.getNode(pp2).getContent()).climbable) && !free_move);
+ is_climbing = ((nodemgr->get(map->getNode(pp).getContent()).climbable ||
+ nodemgr->get(map->getNode(pp2).getContent()).climbable) && !free_move);
}
catch(InvalidPositionException &e)
{
// This should always apply, otherwise there are glitches
assert(d > pos_max_d);
- float player_radius = BS*0.30;
- float player_height = BS*1.55;
-
// 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)
+ if(control.sneak && m_sneak_node_exists && !(fly_allowed && g_settings->getBool("free_move")) && !in_liquid)
{
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)
+ if(!is_climbing)
{
- position.Y = min_y;
-
- //v3f old_speed = m_speed;
-
- if(m_speed.Y < 0)
- m_speed.Y = 0;
-
- /*if(collision_info)
+ f32 min_y = lwn_f.Y + 0.5*BS;
+ if(position.Y < min_y)
{
- // Report fall collision
- if(old_speed.Y < m_speed.Y - 0.1)
- {
- CollisionInfo info;
- info.t = COLLISION_FALL;
- info.speed = m_speed.Y - old_speed.Y;
- collision_info->push_back(info);
- }
- }*/
+ 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.Y - 0.0,
- 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.Y - 0.0,
- oldpos.Z - player_radius,
- oldpos.X + player_radius,
- oldpos.Y + player_height,
- oldpos.Z + player_radius
- );
+ float player_stepheight = touching_ground ? (BS*0.6) : (BS*0.2);
+
+ v3f accel_f = v3f(0,0,0);
+
+ collisionMoveResult result = collisionMoveSimple(env, m_gamedef,
+ pos_max_d, m_collisionbox, player_stepheight, dtime,
+ position, m_speed, accel_f);
/*
If the player's feet touch the topside of any node, this is
Player is allowed to jump when this is true.
*/
bool touching_ground_was = touching_ground;
- touching_ground = false;
-
- /*std::cout<<"Checking collisions for ("
- <<oldpos_i.X<<","<<oldpos_i.Y<<","<<oldpos_i.Z
- <<") -> ("
- <<pos_i.X<<","<<pos_i.Y<<","<<pos_i.Z
- <<"):"<<std::endl;*/
-
- bool standing_on_unloaded = false;
-
- /*
- 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++)
- {
- bool is_unloaded = false;
- try{
- // Player collides into walkable nodes
- if(nodemgr->get(map.getNode(v3s16(x,y,z))).walkable == false)
- continue;
- }
- catch(InvalidPositionException &e)
- {
- is_unloaded = true;
- // Doing nothing here will block the player from
- // walking over map borders
- }
-
- 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(is_unloaded)
- standing_on_unloaded = 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))
- {
- other_axes_overlap = false;
- break;
- }
- }
-
- /*
- If this is a collision, revert the position in the main
- direction.
- */
- if(other_axes_overlap && main_axis_collides)
- {
- //v3f old_speed = m_speed;
-
- m_speed -= m_speed.dotProduct(dirs[i]) * dirs[i];
- position -= position.dotProduct(dirs[i]) * dirs[i];
- position += oldpos.dotProduct(dirs[i]) * dirs[i];
-
- /*if(collision_info)
- {
- // Report fall collision
- if(old_speed.Y < m_speed.Y - 0.1)
- {
- CollisionInfo info;
- info.t = COLLISION_FALL;
- info.speed = m_speed.Y - old_speed.Y;
- collision_info->push_back(info);
- }
- }*/
- }
-
- }
- } // xyz
+ touching_ground = result.touching_ground;
+
+ //bool standing_on_unloaded = result.standing_on_unloaded;
/*
Check the nodes under the player to see from which node the
- player is sneaking from, if any.
+ player is sneaking from, if any. If the node from under
+ the player has been removed, the player falls.
*/
+ v3s16 current_node = floatToInt(position - v3f(0,BS/2,0), BS);
+ if(m_sneak_node_exists &&
+ nodemgr->get(map->getNodeNoEx(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->getNodeNoEx(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)
{
v3s16 pos_i_bottom = floatToInt(position - v3f(0,BS/2,0), BS);
v2f player_p2df(position.X, position.Z);
try{
// The node to be sneaked on has to be walkable
- if(nodemgr->get(map.getNode(p)).walkable == false)
+ if(nodemgr->get(map->getNode(p)).walkable == false)
continue;
// And the node above it has to be nonwalkable
- if(nodemgr->get(map.getNode(p+v3s16(0,1,0))).walkable == true)
+ if(nodemgr->get(map->getNode(p+v3s16(0,1,0))).walkable == true)
continue;
}
catch(InvalidPositionException &e)
}
bool sneak_node_found = (min_distance_f < 100000.0*BS*0.9);
-
- if(control.sneak && m_sneak_node_exists)
- {
- if(sneak_node_found)
- m_sneak_node = new_sneak_node;
- }
- else
- {
- m_sneak_node = new_sneak_node;
- m_sneak_node_exists = sneak_node_found;
- }
+
+ m_sneak_node = new_sneak_node;
+ m_sneak_node_exists = sneak_node_found;
/*
If sneaking, the player's collision box can be in air, so
/*
Report collisions
*/
- if(collision_info)
+ bool bouncy_jump = false;
+ // Dont report if flying
+ if(collision_info && !(g_settings->getBool("free_move") && fly_allowed))
{
- // Report fall collision
- if(old_speed.Y < m_speed.Y - 0.1 && !standing_on_unloaded)
- {
- CollisionInfo info;
- info.t = COLLISION_FALL;
- info.speed = m_speed.Y - old_speed.Y;
+ for(size_t i=0; i<result.collisions.size(); i++){
+ const CollisionInfo &info = result.collisions[i];
collision_info->push_back(info);
+ if(info.new_speed.Y - info.old_speed.Y > 0.1*BS &&
+ info.bouncy)
+ bouncy_jump = true;
}
}
+ if(bouncy_jump && control.jump){
+ m_speed.Y += movement_speed_jump*BS;
+ touching_ground = false;
+ MtEvent *e = new SimpleTriggerEvent("PlayerJump");
+ m_gamedef->event()->put(e);
+ }
+
if(!touching_ground_was && touching_ground){
MtEvent *e = new SimpleTriggerEvent("PlayerRegainGround");
m_gamedef->event()->put(e);
+
+ // Set camera impact value to be used for view bobbing
+ camera_impact = getSpeed().Y * -1;
}
{
camera_barely_in_ceiling = false;
v3s16 camera_np = floatToInt(getEyePosition(), BS);
- MapNode n = map.getNodeNoEx(camera_np);
+ MapNode n = map->getNodeNoEx(camera_np);
if(n.getContent() != CONTENT_IGNORE){
- if(nodemgr->get(n).walkable){
+ if(nodemgr->get(n).walkable && nodemgr->get(n).solidness == 2){
camera_barely_in_ceiling = true;
}
}
}
+
+ /*
+ Update the node last under the player
+ */
+ m_old_node_below = floatToInt(position - v3f(0,BS/2,0), BS);
+ m_old_node_below_type = nodemgr->get(map->getNodeNoEx(m_old_node_below)).name;
+
+ /*
+ Check properties of the node on which the player is standing
+ */
+ const ContentFeatures &f = nodemgr->get(map->getNodeNoEx(getStandingNodePos()));
+ // Determine if jumping is possible
+ m_can_jump = touching_ground && !in_liquid;
+ if(itemgroup_get(f.groups, "disable_jump"))
+ m_can_jump = false;
}
-void LocalPlayer::move(f32 dtime, Map &map, f32 pos_max_d)
+void LocalPlayer::move(f32 dtime, ClientEnvironment *env, f32 pos_max_d)
{
- move(dtime, map, pos_max_d, NULL);
+ move(dtime, env, pos_max_d, NULL);
}
void LocalPlayer::applyControl(float dtime)
{
// Clear stuff
- swimming_up = false;
+ swimming_vertical = false;
- // Random constants
- f32 walk_acceleration = 4.0 * BS;
- f32 walkspeed_max = 4.0 * BS;
-
setPitch(control.pitch);
setYaw(control.yaw);
-
+
+ // Nullify speed and don't run positioning code if the player is attached
+ if(isAttached)
+ {
+ setSpeed(v3f(0,0,0));
+ return;
+ }
+
v3f move_direction = v3f(0,0,1);
move_direction.rotateXZBy(getYaw());
- v3f speed = v3f(0,0,0);
+ v3f speedH = v3f(0,0,0); // Horizontal (X, Z)
+ v3f speedV = v3f(0,0,0); // Vertical (Y)
bool fly_allowed = m_gamedef->checkLocalPrivilege("fly");
bool fast_allowed = m_gamedef->checkLocalPrivilege("fast");
bool free_move = fly_allowed && g_settings->getBool("free_move");
bool fast_move = fast_allowed && g_settings->getBool("fast_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 && !g_settings->getBool("aux1_descends");
bool continuous_forward = g_settings->getBool("continuous_forward");
- if(free_move || is_climbing)
- {
- v3f speed = getSpeed();
- speed.Y = 0;
- setSpeed(speed);
- }
-
// Whether superspeed mode is used or not
bool superspeed = false;
- // If free movement and fast movement, always move fast
- if(free_move && fast_move)
+ if(g_settings->getBool("always_fly_fast") && free_move && fast_move)
superspeed = true;
-
- // Auxiliary button 1 (E)
- if(control.aux1)
+
+ // Old descend control
+ if(g_settings->getBool("aux1_descends"))
{
- if(free_move)
+ // If free movement and fast movement, always move fast
+ if(free_move && fast_move)
+ superspeed = true;
+
+ // Auxiliary button 1 (E)
+ if(control.aux1)
{
- // In free movement mode, aux1 descends
- v3f speed = getSpeed();
- if(fast_move)
- speed.Y = -20*BS;
+ if(free_move)
+ {
+ // In free movement mode, aux1 descends
+ if(fast_move)
+ speedV.Y = -movement_speed_fast;
+ else
+ speedV.Y = -movement_speed_walk;
+ }
+ else if(in_liquid || in_liquid_stable)
+ {
+ speedV.Y = -movement_speed_walk;
+ swimming_vertical = true;
+ }
+ else if(is_climbing)
+ {
+ speedV.Y = -movement_speed_climb;
+ }
else
- speed.Y = -walkspeed_max;
- setSpeed(speed);
+ {
+ // If not free movement but fast is allowed, aux1 is
+ // "Turbo button"
+ if(fast_move)
+ superspeed = true;
+ }
}
- else if(is_climbing)
+ }
+ // New minecraft-like descend control
+ else
+ {
+ // Auxiliary button 1 (E)
+ if(control.aux1)
{
- v3f speed = getSpeed();
- speed.Y = -3*BS;
- setSpeed(speed);
+ if(!is_climbing)
+ {
+ // aux1 is "Turbo button"
+ if(fast_move)
+ superspeed = true;
+ }
}
- else
+
+ if(control.sneak)
{
- // If not free movement but fast is allowed, aux1 is
- // "Turbo button"
- if(fast_move)
- superspeed = true;
+ if(free_move)
+ {
+ // In free movement mode, sneak descends
+ if(fast_move && (control.aux1 || g_settings->getBool("always_fly_fast")))
+ speedV.Y = -movement_speed_fast;
+ else
+ speedV.Y = -movement_speed_walk;
+ }
+ else if(in_liquid || in_liquid_stable)
+ {
+ if(fast_climb)
+ speedV.Y = -movement_speed_fast;
+ else
+ speedV.Y = -movement_speed_walk;
+ swimming_vertical = true;
+ }
+ else if(is_climbing)
+ {
+ if(fast_climb)
+ speedV.Y = -movement_speed_fast;
+ else
+ speedV.Y = -movement_speed_climb;
+ }
}
}
if(continuous_forward)
- speed += move_direction;
+ speedH += move_direction;
if(control.up)
{
if(continuous_forward)
superspeed = true;
else
- speed += move_direction;
+ speedH += move_direction;
}
if(control.down)
{
- speed -= move_direction;
+ speedH -= move_direction;
}
if(control.left)
{
- speed += move_direction.crossProduct(v3f(0,1,0));
+ speedH += move_direction.crossProduct(v3f(0,1,0));
}
if(control.right)
{
- speed += move_direction.crossProduct(v3f(0,-1,0));
+ speedH += move_direction.crossProduct(v3f(0,-1,0));
}
if(control.jump)
{
if(free_move)
- {
- v3f speed = getSpeed();
- if(fast_move)
- speed.Y = 20*BS;
- else
- speed.Y = walkspeed_max;
- setSpeed(speed);
+ {
+ if(g_settings->getBool("aux1_descends") || g_settings->getBool("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;
+ }
}
- else if(touching_ground)
+ 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
*/
- v3f speed = getSpeed();
- if(speed.Y >= -0.5*BS)
+ v3f speedJ = getSpeed();
+ if(speedJ.Y >= -0.5 * BS)
{
- speed.Y = 6.5*BS;
- setSpeed(speed);
+ speedJ.Y = movement_speed_jump * physics_override_jump;
+ setSpeed(speedJ);
MtEvent *e = new SimpleTriggerEvent("PlayerJump");
m_gamedef->event()->put(e);
}
}
- // Use the oscillating value for getting out of water
- // (so that the player doesn't fly on the surface)
- else if(in_water)
+ else if(in_liquid)
{
- v3f speed = getSpeed();
- speed.Y = 1.5*BS;
- setSpeed(speed);
- swimming_up = true;
+ if(fast_climb)
+ speedV.Y = movement_speed_fast;
+ else
+ speedV.Y = movement_speed_walk;
+ swimming_vertical = true;
}
else if(is_climbing)
{
- v3f speed = getSpeed();
- speed.Y = 3*BS;
- setSpeed(speed);
+ if(fast_climb)
+ speedV.Y = movement_speed_fast;
+ else
+ speedV.Y = movement_speed_climb;
}
}
// The speed of the player (Y is ignored)
- if(superspeed)
- speed = speed.normalize() * walkspeed_max * 5.0;
- else if(control.sneak)
- speed = speed.normalize() * walkspeed_max / 3.0;
+ if(superspeed || (is_climbing && fast_climb) || ((in_liquid || in_liquid_stable) && fast_climb))
+ speedH = speedH.normalize() * movement_speed_fast;
+ else if(control.sneak && !free_move && !in_liquid && !in_liquid_stable)
+ speedH = speedH.normalize() * movement_speed_crouch;
else
- speed = speed.normalize() * walkspeed_max;
-
- f32 inc = walk_acceleration * BS * dtime;
-
- // Faster acceleration if fast and free movement
- if(free_move && fast_move)
- inc = walk_acceleration * BS * dtime * 10;
-
+ speedH = speedH.normalize() * movement_speed_walk;
+
+ // Acceleration increase
+ f32 incH = 0; // Horizontal (X, Z)
+ f32 incV = 0; // Vertical (Y)
+ if((!touching_ground && !free_move && !is_climbing && !in_liquid) || (!free_move && m_can_jump && control.jump))
+ {
+ // Jumping and falling
+ if(superspeed || (fast_move && control.aux1))
+ incH = movement_acceleration_fast * BS * dtime;
+ else
+ incH = movement_acceleration_air * BS * dtime;
+ incV = 0; // No vertical acceleration in air
+ }
+ else if (superspeed || (is_climbing && fast_climb) || ((in_liquid || in_liquid_stable) && fast_climb))
+ incH = incV = movement_acceleration_fast * BS * dtime;
+ else
+ incH = incV = movement_acceleration_default * BS * dtime;
+
// Accelerate to target speed with maximum increment
- accelerate(speed, inc);
+ accelerateHorizontal(speedH * physics_override_speed, incH * physics_override_speed);
+ accelerateVertical(speedV * physics_override_speed, incV * physics_override_speed);
}
v3s16 LocalPlayer::getStandingNodePos()