X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Flocalplayer.cpp;h=e501fac1bbc2a93fc74e82c27c5e2ff776caf584;hb=20a85d76d94c9c5c7fbe198c3d0e1fbee97a485f;hp=0554302e0496a7b4c9fb742a107ec3736ef00b95;hpb=22e186b4aa88b585e71500c4e9a03bf69b0b6191;p=minetest.git diff --git a/src/localplayer.cpp b/src/localplayer.cpp index 0554302e0..e501fac1b 100644 --- a/src/localplayer.cpp +++ b/src/localplayer.cpp @@ -19,68 +19,186 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "localplayer.h" -#include "main.h" // For g_settings #include "event.h" #include "collision.h" -#include "gamedef.h" #include "nodedef.h" #include "settings.h" +#include "environment.h" #include "map.h" -#include "util/numeric.h" +#include "client.h" +#include "content_cao.h" /* LocalPlayer */ -LocalPlayer::LocalPlayer(IGameDef *gamedef): - Player(gamedef), - 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), - m_sneak_node(32767,32767,32767), - 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) +LocalPlayer::LocalPlayer(Client *client, const char *name): + Player(name, client->idef()), + m_client(client) { - // Initialize hp to 0, so that no hearts will be shown if server - // doesn't support health points - hp = 0; } -LocalPlayer::~LocalPlayer() +static aabb3f getNodeBoundingBox(const std::vector &nodeboxes) { + if (nodeboxes.empty()) + return aabb3f(0, 0, 0, 0, 0, 0); + + aabb3f b_max; + + std::vector::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; } -void LocalPlayer::move(f32 dtime, Map &map, f32 pos_max_d, - core::list *collision_info) +bool LocalPlayer::updateSneakNode(Map *map, const v3f &position, + const v3f &sneak_max) { - INodeDefManager *nodemgr = m_gamedef->ndef(); + 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) + }; - v3f position = getPosition(); + INodeDefManager *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.05 * 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 + const v3s16 current_node = floatToInt(position - v3f(0, position_y_mod, 0), BS); + + if (current_node != m_sneak_node) { + new_sneak_node_exists = false; + } else { + node = map->getNodeNoEx(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_f = 100000.0 * BS; + + for (const auto &d : dir9_center) { + const v3s16 p = current_node + d; + const v3f pf = intToFloat(p, BS); + const v2f diff(position.X - pf.X, position.Z - pf.Z); + f32 distance_f = diff.getLength(); - v3f old_speed = m_speed; + if (distance_f > min_distance_f || + fabs(diff.X) > (.5 + .1) * BS + sneak_max.X || + fabs(diff.Y) > (.5 + .1) * BS + sneak_max.Z) + continue; + + + // The node to be sneaked on has to be walkable + node = map->getNodeNoEx(p, &is_valid_position); + if (!is_valid_position || !nodemgr->get(node).walkable) + continue; + // And the node(s) above have to be nonwalkable + bool ok = true; + if (!physics_override_sneak_glitch) { + u16 height = ceilf( + (m_collisionbox.MaxEdge.Y - m_collisionbox.MinEdge.Y) / BS + ); + for (u16 y = 1; y <= height; y++) { + node = map->getNodeNoEx(p + v3s16(0, y, 0), &is_valid_position); + if (!is_valid_position || nodemgr->get(node).walkable) { + ok = false; + break; + } + } + } else { + // legacy behaviour: check just one node + node = map->getNodeNoEx(p + v3s16(0, 1, 0), &is_valid_position); + ok = is_valid_position && !nodemgr->get(node).walkable; + } + if (!ok) + continue; + + min_distance_f = distance_f; + 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->getNodeNoEx(m_sneak_node); + std::vector 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->getNodeNoEx(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->getNodeNoEx(m_sneak_node + v3s16(0, 3, 0), + &is_valid_position); + m_sneak_ladder_detected = is_valid_position && + !nodemgr->get(node).walkable; + } + } + return true; +} + +void LocalPlayer::move(f32 dtime, Environment *env, f32 pos_max_d, + std::vector *collision_info) +{ + if (!collision_info || collision_info->empty()) { + // Node below the feet, update each ClientEnvironment::step() + m_standing_node = floatToInt(m_position, BS) - v3s16(0, 1, 0); + } + + // 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(); + INodeDefManager *nodemgr = m_client->ndef(); + + v3f position = getPosition(); // Copy parent position if local player is attached - if(isAttached) - { + if (isAttached) { setPosition(overridePosition); return; } // Skip collision detection if noclip mode is used - bool fly_allowed = m_gamedef->checkLocalPrivilege("fly"); - bool noclip = m_gamedef->checkLocalPrivilege("noclip") && + bool fly_allowed = m_client->checkLocalPrivilege("fly"); + bool noclip = m_client->checkLocalPrivilege("noclip") && g_settings->getBool("noclip"); - bool free_move = noclip && fly_allowed && g_settings->getBool("free_move"); - if(free_move) - { - position += m_speed * dtime; + bool free_move = g_settings->getBool("free_move") && fly_allowed; + + if (noclip && free_move) { + position += m_speed * dtime; setPosition(position); return; } @@ -88,40 +206,49 @@ void LocalPlayer::move(f32 dtime, Map &map, f32 pos_max_d, /* Collision detection */ - + + bool is_valid_position; + MapNode node; + v3s16 pp; + /* Check if player is in liquid (the oscillating value) */ - try{ - // 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_liquid = nodemgr->get(map.getNode(pp).getContent()).isLiquid(); - liquid_viscosity = nodemgr->get(map.getNode(pp).getContent()).liquid_viscosity; - } - // 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_liquid = nodemgr->get(map.getNode(pp).getContent()).isLiquid(); - liquid_viscosity = nodemgr->get(map.getNode(pp).getContent()).liquid_viscosity; + + // If in liquid, the threshold of coming out is at higher y + if (in_liquid) + { + pp = floatToInt(position + v3f(0,BS*0.1,0), BS); + node = map->getNodeNoEx(pp, &is_valid_position); + if (is_valid_position) { + in_liquid = nodemgr->get(node.getContent()).isLiquid(); + liquid_viscosity = nodemgr->get(node.getContent()).liquid_viscosity; + } else { + in_liquid = false; } } - catch(InvalidPositionException &e) + // If not in liquid, the threshold of going in is at lower y + else { - in_liquid = false; + pp = floatToInt(position + v3f(0,BS*0.5,0), BS); + node = map->getNodeNoEx(pp, &is_valid_position); + if (is_valid_position) { + in_liquid = nodemgr->get(node.getContent()).isLiquid(); + liquid_viscosity = nodemgr->get(node.getContent()).liquid_viscosity; + } else { + in_liquid = false; + } } + /* Check if player is in liquid (the stable value) */ - try{ - v3s16 pp = floatToInt(position + v3f(0,0,0), BS); - in_liquid_stable = nodemgr->get(map.getNode(pp).getContent()).isLiquid(); - } - catch(InvalidPositionException &e) - { + pp = floatToInt(position + v3f(0,0,0), BS); + node = map->getNodeNoEx(pp, &is_valid_position); + if (is_valid_position) { + in_liquid_stable = nodemgr->get(node.getContent()).isLiquid(); + } else { in_liquid_stable = false; } @@ -129,15 +256,18 @@ void LocalPlayer::move(f32 dtime, Map &map, f32 pos_max_d, Check if player is climbing */ - 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); - } - catch(InvalidPositionException &e) - { + + pp = floatToInt(position + v3f(0,0.5*BS,0), BS); + v3s16 pp2 = floatToInt(position + v3f(0,-0.2*BS,0), BS); + node = map->getNodeNoEx(pp, &is_valid_position); + bool is_valid_position2; + MapNode node2 = map->getNodeNoEx(pp2, &is_valid_position2); + + if (!(is_valid_position && is_valid_position2)) { is_climbing = false; + } else { + is_climbing = (nodemgr->get(node.getContent()).climbable + || nodemgr->get(node2.getContent()).climbable) && !free_move; } /* @@ -149,57 +279,56 @@ void LocalPlayer::move(f32 dtime, Map &map, f32 pos_max_d, f32 d = 0.15*BS; // This should always apply, otherwise there are glitches - assert(d > pos_max_d); + sanity_check(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; + // 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)); - /* - 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 && 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); - - if(!is_climbing) - { - f32 min_y = lwn_f.Y + 0.5*BS; - if(position.Y < min_y) - { - position.Y = min_y; + // TODO this is a problematic hack. + // Use a better implementation for autojump, or apply a custom stepheight + // to all players, as this currently creates unintended special movement + // abilities and advantages for Android players on a server. +#ifdef __ANDROID__ + if (touching_ground) + player_stepheight += (0.6f * BS); +#endif - if(m_speed.Y < 0) - m_speed.Y = 0; - } - } - } + v3f accel_f = v3f(0,0,0); - /* - Calculate player collision box (new and old) - */ - core::aabbox3d playerbox( - -player_radius, - 0.0, - -player_radius, - player_radius, - player_height, - player_radius - ); + collisionMoveResult result = collisionMoveSimple(env, m_client, + pos_max_d, m_collisionbox, player_stepheight, dtime, + &position, &m_speed, accel_f); - float player_stepheight = touching_ground ? (BS*0.6) : (BS*0.2); + bool could_sneak = control.sneak && !free_move && !in_liquid && + !is_climbing && physics_override_sneak; - v3f accel_f = v3f(0,0,0); + // Add new collisions to the vector + if (collision_info && !free_move) { + v3f diff = intToFloat(m_standing_node, BS) - position; + f32 distance = diff.getLength(); + // Force update each ClientEnvironment::step() + bool is_first = collision_info->empty(); + + for (const auto &colinfo : result.collisions) { + collision_info->push_back(colinfo); - collisionMoveResult result = collisionMoveSimple(&map, m_gamedef, - pos_max_d, playerbox, player_stepheight, dtime, - position, m_speed, accel_f); + if (colinfo.type != COLLISION_NODE || + colinfo.new_speed.Y != 0 || + (could_sneak && m_sneak_node_exists)) + continue; + + diff = intToFloat(colinfo.node_p, BS) - position; + + // Find nearest colliding node + f32 len = diff.getLength(); + if (is_first || len < distance) { + m_standing_node = colinfo.node_p; + distance = len; + } + } + } /* If the player's feet touch the topside of any node, this is @@ -209,129 +338,96 @@ void LocalPlayer::move(f32 dtime, Map &map, f32 pos_max_d, */ bool touching_ground_was = touching_ground; touching_ground = result.touching_ground; - - //bool standing_on_unloaded = result.standing_on_unloaded; + 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.49; + + if (m_sneak_ladder_detected) { + // restore legacy behaviour (this makes the m_speed.Y hack necessary) + sneak_max = v3f(0.4 * BS, 0, 0.4 * BS); + } /* - Check the nodes under the player to see from which node the - player is sneaking from, if any. If the node from under - the player has been removed, the player falls. + If sneaking, keep on top of last walked node and don't fall off */ - 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); - f32 min_distance_f = 100000.0*BS; - // If already seeking from some node, compare to it. - /*if(m_sneak_node_exists) - { - v3f sneaknode_pf = intToFloat(m_sneak_node, BS); - v2f sneaknode_p2df(sneaknode_pf.X, sneaknode_pf.Z); - f32 d_horiz_f = player_p2df.getDistanceFrom(sneaknode_p2df); - f32 d_vert_f = fabs(sneaknode_pf.Y + BS*0.5 - position.Y); - // Ignore if player is not on the same level (likely dropped) - if(d_vert_f < 0.15*BS) - min_distance_f = d_horiz_f; - }*/ - v3s16 new_sneak_node = m_sneak_node; - for(s16 x=-1; x<=1; x++) - for(s16 z=-1; z<=1; z++) - { - v3s16 p = pos_i_bottom + v3s16(x,0,z); - v3f pf = intToFloat(p, BS); - v2f node_p2df(pf.X, pf.Z); - f32 distance_f = player_p2df.getDistanceFrom(node_p2df); - f32 max_axis_distance_f = MYMAX( - fabs(player_p2df.X-node_p2df.X), - fabs(player_p2df.Y-node_p2df.Y)); - - if(distance_f > min_distance_f || - max_axis_distance_f > 0.5*BS + sneak_max + 0.1*BS) - continue; + 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; - try{ - // The node to be sneaked on has to be walkable - 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) - continue; - } - catch(InvalidPositionException &e) - { - continue; - } + // (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); - min_distance_f = distance_f; - new_sneak_node = p; + if (position.X != old_pos.X) + m_speed.X = 0; + if (position.Z != old_pos.Z) + m_speed.Z = 0; } - - bool sneak_node_found = (min_distance_f < 100000.0*BS*0.9); - m_sneak_node = new_sneak_node; - m_sneak_node_exists = sneak_node_found; + if (y_diff > 0 && m_speed.Y < 0 && + (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. + position.Y = bmax.Y; + m_speed.Y = 0; + } - /* - 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; + // Allow jumping on node edges while sneaking + if (m_speed.Y == 0 || 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); + } } - + /* - Set new position + 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 */ - bool bouncy_jump = false; - // Dont report if flying - if(collision_info && !(g_settings->getBool("free_move") && fly_allowed)) - { - for(size_t i=0; ipush_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){ + if(!result.standing_on_object && !touching_ground_was && touching_ground) { MtEvent *e = new SimpleTriggerEvent("PlayerRegainGround"); - m_gamedef->event()->put(e); + m_client->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 && nodemgr->get(n).solidness == 2){ camera_barely_in_ceiling = true; @@ -339,28 +435,37 @@ void LocalPlayer::move(f32 dtime, Map &map, f32 pos_max_d, } } - /* - 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())); + const ContentFeatures &f = nodemgr->get(map->getNodeNoEx(m_standing_node)); // Determine if jumping is possible - m_can_jump = touching_ground && !in_liquid; - if(itemgroup_get(f.groups, "disable_jump")) + m_can_jump = (touching_ground && !in_liquid && !is_climbing) + || sneak_can_jump; + if (itemgroup_get(f.groups, "disable_jump")) m_can_jump = false; + + // Jump key pressed while jumping off from a bouncy block + if (m_can_jump && control.jump && itemgroup_get(f.groups, "bouncy") && + m_speed.Y >= -0.5 * BS) { + float jumpspeed = movement_speed_jump * physics_override_jump; + if (m_speed.Y > 1) { + // Reduce boost when speed already is high + m_speed.Y += jumpspeed / (1 + (m_speed.Y / 16 )); + } else { + m_speed.Y += jumpspeed; + } + setSpeed(m_speed); + m_can_jump = false; + } } -void LocalPlayer::move(f32 dtime, Map &map, f32 pos_max_d) +void LocalPlayer::move(f32 dtime, Environment *env, f32 pos_max_d) { - move(dtime, map, pos_max_d, NULL); + move(dtime, env, pos_max_d, NULL); } -void LocalPlayer::applyControl(float dtime) +void LocalPlayer::applyControl(float dtime, Environment *env) { // Clear stuff swimming_vertical = false; @@ -377,22 +482,24 @@ void LocalPlayer::applyControl(float dtime) v3f move_direction = v3f(0,0,1); move_direction.rotateXZBy(getYaw()); - + 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 fly_allowed = m_client->checkLocalPrivilege("fly"); + bool fast_allowed = m_client->checkLocalPrivilege("fast"); bool free_move = fly_allowed && g_settings->getBool("free_move"); bool fast_move = fast_allowed && g_settings->getBool("fast_move"); - bool fast_or_aux1_descends = (fast_move && control.aux1) || (fast_move && g_settings->getBool("aux1_descends")); + // 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"); + bool always_fly_fast = g_settings->getBool("always_fly_fast"); // Whether superspeed mode is used or not bool superspeed = false; - - if(g_settings->getBool("always_fly_fast") && free_move && fast_move) + + if (always_fly_fast && free_move && fast_move) superspeed = true; // Old descend control @@ -401,7 +508,7 @@ void LocalPlayer::applyControl(float dtime) // If free movement and fast movement, always move fast if(free_move && fast_move) superspeed = true; - + // Auxiliary button 1 (E) if(control.aux1) { @@ -415,14 +522,12 @@ void LocalPlayer::applyControl(float dtime) } else if(in_liquid || in_liquid_stable) { - // Always use fast when aux1_descends & fast_move are enabled in liquid, since the aux1 button would mean both turbo and "swim down" causing a conflict - speedV.Y = -movement_speed_fast; + speedV.Y = -movement_speed_walk; swimming_vertical = true; } else if(is_climbing) { - // Always use fast when aux1_descends & fast_move are enabled when climbing, since the aux1 button would mean both turbo and "descend" causing a conflict - speedV.Y = -movement_speed_fast; + speedV.Y = -movement_speed_climb; } else { @@ -452,15 +557,14 @@ void LocalPlayer::applyControl(float dtime) if(free_move) { // In free movement mode, sneak descends - if(fast_move && (control.aux1 || g_settings->getBool("always_fly_fast"))) + if (fast_move && (control.aux1 || always_fly_fast)) speedV.Y = -movement_speed_fast; else speedV.Y = -movement_speed_walk; } else if(in_liquid || in_liquid_stable) { - if(fast_or_aux1_descends) - // Always use fast when aux1_descends & fast_move are enabled in liquid, since the aux1 button would mean both turbo and "swim down" causing a conflict + if(fast_climb) speedV.Y = -movement_speed_fast; else speedV.Y = -movement_speed_walk; @@ -468,8 +572,7 @@ void LocalPlayer::applyControl(float dtime) } else if(is_climbing) { - if(fast_or_aux1_descends) - // Always use fast when aux1_descends & fast_move are enabled when climbing, since the aux1 button would mean both turbo and "descend" causing a conflict + if(fast_climb) speedV.Y = -movement_speed_fast; else speedV.Y = -movement_speed_climb; @@ -477,35 +580,39 @@ void LocalPlayer::applyControl(float dtime) } } - if(continuous_forward) + if (continuous_forward) speedH += move_direction; - if(control.up) - { - if(continuous_forward) - superspeed = true; - else + if (control.up) { + if (continuous_forward) { + if (fast_move) + superspeed = true; + } else { speedH += move_direction; + } } - if(control.down) - { + if (control.down) { speedH -= move_direction; } - if(control.left) - { + if (!control.up && !control.down) { + speedH -= move_direction * + (control.forw_move_joystick_axis / 32767.f); + } + if (control.left) { speedH += move_direction.crossProduct(v3f(0,1,0)); } - if(control.right) - { + if (control.right) { speedH += move_direction.crossProduct(v3f(0,-1,0)); } + if (!control.left && !control.right) { + speedH -= move_direction.crossProduct(v3f(0,1,0)) * + (control.sidew_move_joystick_axis / 32767.f); + } if(control.jump) { - if(free_move) - { - if(g_settings->getBool("aux1_descends") || g_settings->getBool("always_fly_fast")) - { - if(fast_move) + if (free_move) { + if (g_settings->getBool("aux1_descends") || always_fly_fast) { + if (fast_move) speedV.Y = movement_speed_fast; else speedV.Y = movement_speed_walk; @@ -524,19 +631,17 @@ void LocalPlayer::applyControl(float dtime) at its starting value */ v3f speedJ = getSpeed(); - if(speedJ.Y >= -0.5 * BS) - { - speedJ.Y = movement_speed_jump; + if(speedJ.Y >= -0.5 * BS) { + speedJ.Y = movement_speed_jump * physics_override_jump; setSpeed(speedJ); - + MtEvent *e = new SimpleTriggerEvent("PlayerJump"); - m_gamedef->event()->put(e); + m_client->event()->put(e); } } else if(in_liquid) { - if(fast_or_aux1_descends) - // Always use fast when aux1_descends & fast_move are enabled in liquid, since the aux1 button would mean both turbo and "swim down" causing a conflict + if(fast_climb) speedV.Y = movement_speed_fast; else speedV.Y = movement_speed_walk; @@ -544,8 +649,7 @@ void LocalPlayer::applyControl(float dtime) } else if(is_climbing) { - if(fast_or_aux1_descends) - // Always use fast when aux1_descends & fast_move are enabled when climbing, since the aux1 button would mean both turbo and "descend" causing a conflict + if(fast_climb) speedV.Y = movement_speed_fast; else speedV.Y = movement_speed_climb; @@ -553,7 +657,7 @@ void LocalPlayer::applyControl(float dtime) } // The speed of the player (Y is ignored) - if(superspeed || (is_climbing && fast_or_aux1_descends) || ((in_liquid || in_liquid_stable) && fast_or_aux1_descends)) + 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; @@ -572,23 +676,430 @@ void LocalPlayer::applyControl(float dtime) incH = movement_acceleration_air * BS * dtime; incV = 0; // No vertical acceleration in air } - else if(superspeed || (fast_move && control.aux1)) - incH = incV = movement_acceleration_fast * BS * dtime; - else if ((in_liquid || in_liquid_stable) && fast_or_aux1_descends) - // Always use fast when aux1_descends & fast_move are enabled in liquid, since the aux1 button would mean both turbo and "swim down" causing a conflict + 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; + float slip_factor = getSlipFactor(env, speedH); // Accelerate to target speed with maximum increment - accelerateHorizontal(speedH, incH); - accelerateVertical(speedV, incV); + accelerateHorizontal(speedH * physics_override_speed, + incH * physics_override_speed * slip_factor); + accelerateVertical(speedV * physics_override_speed, + incV * physics_override_speed); } v3s16 LocalPlayer::getStandingNodePos() { if(m_sneak_node_exists) return m_sneak_node; - return floatToInt(getPosition(), BS); + return m_standing_node; +} + +v3s16 LocalPlayer::getFootstepNodePos() +{ + if (in_liquid_stable) + // Emit swimming sound if the player is in liquid + return floatToInt(getPosition(), BS); + if (touching_ground) + // BS * 0.05 below the player's feet ensures a 1/16th height + // 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 + // when landing after a jump or fall. BS * 0.5 ensures water + // sounds when swimming in 1 node deep water. + return floatToInt(getPosition() - v3f(0, BS * 0.5f, 0), BS); +} + +v3s16 LocalPlayer::getLightPosition() const +{ + return floatToInt(m_position + v3f(0,BS+BS/2,0), BS); } +v3f LocalPlayer::getEyeOffset() const +{ + float eye_height = camera_barely_in_ceiling ? + m_eye_height - 0.125f : m_eye_height; + return v3f(0, BS * eye_height, 0); +} + +// Horizontal acceleration (X and Z), Y direction is ignored +void LocalPlayer::accelerateHorizontal(const v3f &target_speed, + const f32 max_increase) +{ + if (max_increase == 0) + return; + + v3f d_wanted = target_speed - m_speed; + d_wanted.Y = 0.0f; + f32 dl = d_wanted.getLength(); + if (dl > max_increase) + dl = max_increase; + + v3f d = d_wanted.normalize() * dl; + + m_speed.X += d.X; + m_speed.Z += d.Z; +} + +// Vertical acceleration (Y), X and Z directions are ignored +void LocalPlayer::accelerateVertical(const v3f &target_speed, const f32 max_increase) +{ + if (max_increase == 0) + return; + + f32 d_wanted = target_speed.Y - m_speed.Y; + if (d_wanted > max_increase) + d_wanted = max_increase; + else if (d_wanted < -max_increase) + d_wanted = -max_increase; + + m_speed.Y += d_wanted; +} + +// Temporary option for old move code +void LocalPlayer::old_move(f32 dtime, Environment *env, f32 pos_max_d, + std::vector *collision_info) +{ + Map *map = &env->getMap(); + INodeDefManager *nodemgr = m_client->ndef(); + + v3f position = getPosition(); + + // Copy parent position if local player is attached + if (isAttached) { + setPosition(overridePosition); + m_sneak_node_exists = false; + return; + } + + // Skip collision detection if noclip mode is used + bool fly_allowed = m_client->checkLocalPrivilege("fly"); + bool noclip = m_client->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 + */ + 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 + pp = floatToInt(position + v3f(0, BS * 0.1, 0), BS); + node = map->getNodeNoEx(pp, &is_valid_position); + if (is_valid_position) { + in_liquid = nodemgr->get(node.getContent()).isLiquid(); + liquid_viscosity = nodemgr->get(node.getContent()).liquid_viscosity; + } else { + in_liquid = false; + } + } else { + // If not in liquid, the threshold of going in is at lower y + pp = floatToInt(position + v3f(0, BS * 0.5, 0), BS); + node = map->getNodeNoEx(pp, &is_valid_position); + if (is_valid_position) { + in_liquid = nodemgr->get(node.getContent()).isLiquid(); + liquid_viscosity = nodemgr->get(node.getContent()).liquid_viscosity; + } else { + in_liquid = false; + } + } + + /* + Check if player is in liquid (the stable value) + */ + pp = floatToInt(position + v3f(0, 0, 0), BS); + node = map->getNodeNoEx(pp, &is_valid_position); + if (is_valid_position) + in_liquid_stable = nodemgr->get(node.getContent()).isLiquid(); + else + in_liquid_stable = false; + + /* + Check if player is climbing + */ + pp = floatToInt(position + v3f(0, 0.5 * BS, 0), BS); + v3s16 pp2 = floatToInt(position + v3f(0, -0.2 * BS, 0), BS); + node = map->getNodeNoEx(pp, &is_valid_position); + bool is_valid_position2; + MapNode node2 = map->getNodeNoEx(pp2, &is_valid_position2); + + if (!(is_valid_position && is_valid_position2)) + is_climbing = false; + else + 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 + f32 d = 0.15 * BS; + // This should always apply, otherwise there are glitches + sanity_check(d > pos_max_d); + // Maximum distance over border for sneaking + f32 sneak_max = BS * 0.4; + + /* + 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 && g_settings->getBool("free_move")) && !in_liquid && + physics_override_sneak) { + 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); + + if (!is_climbing) { + // Move up if necessary + f32 new_y = (lwn_f.Y - 0.5 * 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. + */ + if (m_speed.Y < 0) + m_speed.Y = 0; + } + } + + // this shouldn't be hardcoded but transmitted from server + float player_stepheight = touching_ground ? (BS * 0.6) : (BS * 0.2); + +#ifdef __ANDROID__ + player_stepheight += (0.6 * BS); +#endif + + v3f accel_f = v3f(0, 0, 0); + + collisionMoveResult result = collisionMoveSimple(env, m_client, + 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 + set to true. + + Player is allowed to jump when this is true. + */ + bool touching_ground_was = touching_ground; + 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. If the node from under + the player has been removed, the player falls. + */ + f32 position_y_mod = 0.05 * BS; + if (m_sneak_node_bb_ymax > 0) + position_y_mod = m_sneak_node_bb_ymax - position_y_mod; + v3s16 current_node = floatToInt(position - v3f(0, position_y_mod, 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 && physics_override_sneak) { + m_sneak_node_bb_ymax = 0; + v3s16 pos_i_bottom = floatToInt(position - v3f(0, position_y_mod, 0), BS); + v2f player_p2df(position.X, position.Z); + f32 min_distance_f = 100000.0 * BS; + // If already seeking from some node, compare to it. + v3s16 new_sneak_node = m_sneak_node; + for (s16 x= -1; x <= 1; x++) + for (s16 z= -1; z <= 1; z++) { + v3s16 p = pos_i_bottom + v3s16(x, 0, z); + v3f pf = intToFloat(p, BS); + v2f node_p2df(pf.X, pf.Z); + f32 distance_f = player_p2df.getDistanceFrom(node_p2df); + f32 max_axis_distance_f = MYMAX( + fabs(player_p2df.X - node_p2df.X), + fabs(player_p2df.Y - node_p2df.Y)); + + if (distance_f > min_distance_f || + max_axis_distance_f > 0.5 * BS + sneak_max + 0.1 * BS) + continue; + + // The node to be sneaked on has to be walkable + node = map->getNodeNoEx(p, &is_valid_position); + if (!is_valid_position || !nodemgr->get(node).walkable) + continue; + // And the node above it has to be nonwalkable + node = map->getNodeNoEx(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) { + node =map->getNodeNoEx(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; + } + + bool sneak_node_found = (min_distance_f < 100000.0 * BS * 0.9); + + m_sneak_node = new_sneak_node; + m_sneak_node_exists = sneak_node_found; + + if (sneak_node_found) { + f32 cb_max = 0; + MapNode n = map->getNodeNoEx(m_sneak_node); + std::vector 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 + */ + // Dont report if flying + if (collision_info && !(g_settings->getBool("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) { + MtEvent *e = new SimpleTriggerEvent("PlayerRegainGround"); + m_client->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); + if (n.getContent() != CONTENT_IGNORE) { + 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; + // Jump key pressed while jumping off from a bouncy block + if (m_can_jump && control.jump && itemgroup_get(f.groups, "bouncy") && + m_speed.Y >= -0.5 * BS) { + float jumpspeed = movement_speed_jump * physics_override_jump; + if (m_speed.Y > 1) { + // Reduce boost when speed already is high + m_speed.Y += jumpspeed / (1 + (m_speed.Y / 16 )); + } else { + m_speed.Y += jumpspeed; + } + setSpeed(m_speed); + m_can_jump = false; + } +} + +float LocalPlayer::getSlipFactor(Environment *env, const v3f &speedH) +{ + + if (!touching_ground) + return 1.0f; + + float slip_factor = 1.0f; + // Slip on slippery nodes + const INodeDefManager *nodemgr = env->getGameDef()->ndef(); + Map *map = &env->getMap(); + const ContentFeatures &f = nodemgr->get(map->getNodeNoEx( + floatToInt(getPosition() - v3f(0, 0.05f * BS, 0), BS))); + int slippery = 0; + if (f.walkable) { + slippery = itemgroup_get(f.groups, "slippery"); + } else if (is_slipping) { + // slipping over an edge? Check surroundings for slippery nodes + slippery = 2 << 16; // guard value, bigger than all realistic ones + for (int z = 0; z <= 1; z++) { + for (int x = 0; x <= 1; x++) { + // this should cover all nodes surrounding player position + v3f offset((x - 0.5f) * BS, 0.05f * BS, (z - 0.5f) * BS); + const ContentFeatures &f2 = nodemgr->get(map->getNodeNoEx( + floatToInt(getPosition() - offset, BS))); + if (f2.walkable) { + // find least slippery node we might be standing on + int s = itemgroup_get(f2.groups, "slippery"); + if (s < slippery) + slippery = s; + } + } + } + // without any hits, ignore slippery + if (slippery >= (2 << 16)) + slippery = 0; + } + if (slippery >= 1) { + if (speedH == v3f(0.0f)) { + slippery = slippery * 2; + } + slip_factor = core::clamp(1.0f / (slippery + 1), 0.001f, 1.0f); + is_slipping = true; + } else { + // remember this to avoid checking the edge case above too often + is_slipping = false; + } + return slip_factor; +}