From 3ad5388c6d3894e2f4aa7158cc2b62b626f0f967 Mon Sep 17 00:00:00 2001 From: TheTermos <55103816+TheTermos@users.noreply.github.com> Date: Wed, 8 Apr 2020 22:45:05 +0200 Subject: [PATCH] Collision various fixes (#9343) --- src/client/localplayer.h | 2 + src/collision.cpp | 222 +++++++++++++++----------------- src/collision.h | 2 +- src/unittest/test_collision.cpp | 64 ++++----- 4 files changed, 141 insertions(+), 149 deletions(-) diff --git a/src/client/localplayer.h b/src/client/localplayer.h index 95dceb1f4..d88ae17ac 100644 --- a/src/client/localplayer.h +++ b/src/client/localplayer.h @@ -141,6 +141,8 @@ public: void setCollisionbox(const aabb3f &box) { m_collisionbox = box; } + const aabb3f& getCollisionbox() const { return m_collisionbox; } + float getZoomFOV() const { return m_zoom_fov; } void setZoomFOV(float zoom_fov) { m_zoom_fov = zoom_fov; } diff --git a/src/collision.cpp b/src/collision.cpp index a443be7ab..0d37ea436 100644 --- a/src/collision.cpp +++ b/src/collision.cpp @@ -25,16 +25,13 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "gamedef.h" #ifndef SERVER #include "client/clientenvironment.h" +#include "client/localplayer.h" #endif #include "serverenvironment.h" #include "serverobject.h" #include "util/timetaker.h" #include "profiler.h" -// float error is 10 - 9.96875 = 0.03125 -//#define COLL_ZERO 0.032 // broken unit tests -#define COLL_ZERO 0 - struct NearbyCollisionInfo { NearbyCollisionInfo(bool is_ul, bool is_obj, int bouncy, @@ -61,118 +58,102 @@ struct NearbyCollisionInfo { // The time after which the collision occurs is stored in dtime. CollisionAxis axisAlignedCollision( const aabb3f &staticbox, const aabb3f &movingbox, - const v3f &speed, f32 d, f32 *dtime) + const v3f &speed, f32 *dtime) { //TimeTaker tt("axisAlignedCollision"); - f32 xsize = (staticbox.MaxEdge.X - staticbox.MinEdge.X) - COLL_ZERO; // reduce box size for solve collision stuck (flying sand) - f32 ysize = (staticbox.MaxEdge.Y - staticbox.MinEdge.Y); // - COLL_ZERO; // Y - no sense for falling, but maybe try later - f32 zsize = (staticbox.MaxEdge.Z - staticbox.MinEdge.Z) - COLL_ZERO; - aabb3f relbox( - movingbox.MinEdge.X - staticbox.MinEdge.X, - movingbox.MinEdge.Y - staticbox.MinEdge.Y, - movingbox.MinEdge.Z - staticbox.MinEdge.Z, - movingbox.MaxEdge.X - staticbox.MinEdge.X, - movingbox.MaxEdge.Y - staticbox.MinEdge.Y, - movingbox.MaxEdge.Z - staticbox.MinEdge.Z + movingbox.MaxEdge.X - movingbox.MinEdge.X + staticbox.MaxEdge.X - staticbox.MinEdge.X, // sum of the widths + movingbox.MaxEdge.Y - movingbox.MinEdge.Y + staticbox.MaxEdge.Y - staticbox.MinEdge.Y, + movingbox.MaxEdge.Z - movingbox.MinEdge.Z + staticbox.MaxEdge.Z - staticbox.MinEdge.Z, + std::max(movingbox.MaxEdge.X, staticbox.MaxEdge.X) - std::min(movingbox.MinEdge.X, staticbox.MinEdge.X), //outer bounding 'box' dimensions + std::max(movingbox.MaxEdge.Y, staticbox.MaxEdge.Y) - std::min(movingbox.MinEdge.Y, staticbox.MinEdge.Y), + std::max(movingbox.MaxEdge.Z, staticbox.MaxEdge.Z) - std::min(movingbox.MinEdge.Z, staticbox.MinEdge.Z) ); - if(speed.X > 0) // Check for collision with X- plane - { - if (relbox.MaxEdge.X <= d) { - *dtime = -relbox.MaxEdge.X / speed.X; - if ((relbox.MinEdge.Y + speed.Y * (*dtime) < ysize) && - (relbox.MaxEdge.Y + speed.Y * (*dtime) > COLL_ZERO) && - (relbox.MinEdge.Z + speed.Z * (*dtime) < zsize) && - (relbox.MaxEdge.Z + speed.Z * (*dtime) > COLL_ZERO)) - return COLLISION_AXIS_X; - } - else if(relbox.MinEdge.X > xsize) - { - return COLLISION_AXIS_NONE; - } - } - else if(speed.X < 0) // Check for collision with X+ plane - { - if (relbox.MinEdge.X >= xsize - d) { - *dtime = (xsize - relbox.MinEdge.X) / speed.X; - if ((relbox.MinEdge.Y + speed.Y * (*dtime) < ysize) && - (relbox.MaxEdge.Y + speed.Y * (*dtime) > COLL_ZERO) && - (relbox.MinEdge.Z + speed.Z * (*dtime) < zsize) && - (relbox.MaxEdge.Z + speed.Z * (*dtime) > COLL_ZERO)) - return COLLISION_AXIS_X; - } - else if(relbox.MaxEdge.X < 0) - { - return COLLISION_AXIS_NONE; + const f32 dtime_max = *dtime; + const f32 inner_margin = -1.5f; + f32 distance; + f32 time; + + if (speed.X) { + distance = relbox.MaxEdge.X - relbox.MinEdge.X; + + *dtime = distance >= 0 ? std::abs(distance / speed.X) : -std::abs(distance / speed.X); + time = std::max(*dtime, 0.0f); + + if (distance > inner_margin) { + if (*dtime <= dtime_max) { + if ((speed.X > 0 && staticbox.MaxEdge.X > movingbox.MaxEdge.X) || + (speed.X < 0 && staticbox.MinEdge.X < movingbox.MinEdge.X)) { + if ( + (std::max(movingbox.MaxEdge.Y + speed.Y * time, staticbox.MaxEdge.Y) + - std::min(movingbox.MinEdge.Y + speed.Y * time, staticbox.MinEdge.Y) + - relbox.MinEdge.Y < 0) && + (std::max(movingbox.MaxEdge.Z + speed.Z * time, staticbox.MaxEdge.Z) + - std::min(movingbox.MinEdge.Z + speed.Z * time, staticbox.MinEdge.Z) + - relbox.MinEdge.Z < 0) + ) + return COLLISION_AXIS_X; + } + } else { + return COLLISION_AXIS_NONE; + } } } // NO else if here - if(speed.Y > 0) // Check for collision with Y- plane - { - if (relbox.MaxEdge.Y <= d) { - *dtime = -relbox.MaxEdge.Y / speed.Y; - if ((relbox.MinEdge.X + speed.X * (*dtime) < xsize) && - (relbox.MaxEdge.X + speed.X * (*dtime) > COLL_ZERO) && - (relbox.MinEdge.Z + speed.Z * (*dtime) < zsize) && - (relbox.MaxEdge.Z + speed.Z * (*dtime) > COLL_ZERO)) - return COLLISION_AXIS_Y; - } - else if(relbox.MinEdge.Y > ysize) - { - return COLLISION_AXIS_NONE; - } - } - else if(speed.Y < 0) // Check for collision with Y+ plane - { - if (relbox.MinEdge.Y >= ysize - d) { - *dtime = (ysize - relbox.MinEdge.Y) / speed.Y; - if ((relbox.MinEdge.X + speed.X * (*dtime) < xsize) && - (relbox.MaxEdge.X + speed.X * (*dtime) > COLL_ZERO) && - (relbox.MinEdge.Z + speed.Z * (*dtime) < zsize) && - (relbox.MaxEdge.Z + speed.Z * (*dtime) > COLL_ZERO)) - return COLLISION_AXIS_Y; - } - else if(relbox.MaxEdge.Y < 0) - { - return COLLISION_AXIS_NONE; + if (speed.Y) { + distance = relbox.MaxEdge.Y - relbox.MinEdge.Y; + + *dtime = distance >= 0 ? std::abs(distance / speed.Y) : -std::abs(distance / speed.Y); + time = std::max(*dtime, 0.0f); + + if (distance > inner_margin) { + if (*dtime <= dtime_max) { + if ((speed.Y > 0 && staticbox.MaxEdge.Y > movingbox.MaxEdge.Y) || + (speed.Y < 0 && staticbox.MinEdge.Y < movingbox.MinEdge.Y)) { + if ( + (std::max(movingbox.MaxEdge.X + speed.X * time, staticbox.MaxEdge.X) + - std::min(movingbox.MinEdge.X + speed.X * time, staticbox.MinEdge.X) + - relbox.MinEdge.X < 0) && + (std::max(movingbox.MaxEdge.Z + speed.Z * time, staticbox.MaxEdge.Z) + - std::min(movingbox.MinEdge.Z + speed.Z * time, staticbox.MinEdge.Z) + - relbox.MinEdge.Z < 0) + ) + return COLLISION_AXIS_Y; + } + } else { + return COLLISION_AXIS_NONE; + } } } // NO else if here - if(speed.Z > 0) // Check for collision with Z- plane - { - if (relbox.MaxEdge.Z <= d) { - *dtime = -relbox.MaxEdge.Z / speed.Z; - if ((relbox.MinEdge.X + speed.X * (*dtime) < xsize) && - (relbox.MaxEdge.X + speed.X * (*dtime) > COLL_ZERO) && - (relbox.MinEdge.Y + speed.Y * (*dtime) < ysize) && - (relbox.MaxEdge.Y + speed.Y * (*dtime) > COLL_ZERO)) - return COLLISION_AXIS_Z; - } - //else if(relbox.MinEdge.Z > zsize) - //{ - // return COLLISION_AXIS_NONE; - //} - } - else if(speed.Z < 0) // Check for collision with Z+ plane - { - if (relbox.MinEdge.Z >= zsize - d) { - *dtime = (zsize - relbox.MinEdge.Z) / speed.Z; - if ((relbox.MinEdge.X + speed.X * (*dtime) < xsize) && - (relbox.MaxEdge.X + speed.X * (*dtime) > COLL_ZERO) && - (relbox.MinEdge.Y + speed.Y * (*dtime) < ysize) && - (relbox.MaxEdge.Y + speed.Y * (*dtime) > COLL_ZERO)) - return COLLISION_AXIS_Z; + if (speed.Z) { + distance = relbox.MaxEdge.Z - relbox.MinEdge.Z; + + *dtime = distance >= 0 ? std::abs(distance / speed.Z) : -std::abs(distance / speed.Z); + time = std::max(*dtime, 0.0f); + + if (distance > inner_margin) { + if (*dtime <= dtime_max) { + if ((speed.Z > 0 && staticbox.MaxEdge.Z > movingbox.MaxEdge.Z) || + (speed.Z < 0 && staticbox.MinEdge.Z < movingbox.MinEdge.Z)) { + if ( + (std::max(movingbox.MaxEdge.X + speed.X * time, staticbox.MaxEdge.X) + - std::min(movingbox.MinEdge.X + speed.X * time, staticbox.MinEdge.X) + - relbox.MinEdge.X < 0) && + (std::max(movingbox.MaxEdge.Y + speed.Y * time, staticbox.MaxEdge.Y) + - std::min(movingbox.MinEdge.Y + speed.Y * time, staticbox.MinEdge.Y) + - relbox.MinEdge.Y < 0) + ) + return COLLISION_AXIS_Z; + } + } } - //else if(relbox.MaxEdge.Z < 0) - //{ - // return COLLISION_AXIS_NONE; - //} } return COLLISION_AXIS_NONE; @@ -405,22 +386,25 @@ collisionMoveResult collisionMoveSimple(Environment *env, IGameDef *gamedef, } } } +#ifndef SERVER + if (self && c_env) { + LocalPlayer *lplayer = c_env->getLocalPlayer(); + if (lplayer->getParent() == nullptr) { + aabb3f lplayer_collisionbox = lplayer->getCollisionbox(); + v3f lplayer_pos = lplayer->getPosition(); + lplayer_collisionbox.MinEdge += lplayer_pos; + lplayer_collisionbox.MaxEdge += lplayer_pos; + cinfo.emplace_back(false, true, 0, v3s16(), lplayer_collisionbox); + } + } +#endif } //tt3 /* Collision detection */ - /* - Collision uncertainty radius - Make it a bit larger than the maximum distance of movement - */ - f32 d = pos_max_d * 1.1f; - // A fairly large value in here makes moving smoother - //f32 d = 0.15*BS; - - // This should always apply, otherwise there are glitches - assert(d > pos_max_d); // invariant + f32 d = 0.0f; int loopcount = 0; @@ -450,9 +434,9 @@ collisionMoveResult collisionMoveSimple(Environment *env, IGameDef *gamedef, continue; // Find nearest collision of the two boxes (raytracing-like) - f32 dtime_tmp; + f32 dtime_tmp = nearest_dtime; CollisionAxis collided = axisAlignedCollision(box_info.box, - movingbox, *speed_f, d, &dtime_tmp); + movingbox, *speed_f, &dtime_tmp); if (collided == -1 || dtime_tmp >= nearest_dtime) continue; @@ -470,11 +454,18 @@ collisionMoveResult collisionMoveSimple(Environment *env, IGameDef *gamedef, // Otherwise, a collision occurred. NearbyCollisionInfo &nearest_info = cinfo[nearest_boxindex]; const aabb3f& cbox = nearest_info.box; + + //movingbox except moved to the horizontal position it would be after step up + aabb3f stepbox = movingbox; + stepbox.MinEdge.X += speed_f->X * dtime; + stepbox.MinEdge.Z += speed_f->Z * dtime; + stepbox.MaxEdge.X += speed_f->X * dtime; + stepbox.MaxEdge.Z += speed_f->Z * dtime; // Check for stairs. bool step_up = (nearest_collided != COLLISION_AXIS_Y) && // must not be Y direction (movingbox.MinEdge.Y < cbox.MaxEdge.Y) && (movingbox.MinEdge.Y + stepheight > cbox.MaxEdge.Y) && - (!wouldCollideWithCeiling(cinfo, movingbox, + (!wouldCollideWithCeiling(cinfo, stepbox, cbox.MaxEdge.Y - movingbox.MinEdge.Y, d)); @@ -483,7 +474,7 @@ collisionMoveResult collisionMoveSimple(Environment *env, IGameDef *gamedef, // Move to the point of collision and reduce dtime by nearest_dtime if (nearest_dtime < 0) { - // Handle negative nearest_dtime (can be caused by the d allowance) + // Handle negative nearest_dtime if (!step_up) { if (nearest_collided == COLLISION_AXIS_X) pos_f->X += speed_f->X * nearest_dtime; @@ -562,9 +553,8 @@ collisionMoveResult collisionMoveSimple(Environment *env, IGameDef *gamedef, Object touches ground if object's minimum Y is near node's maximum Y and object'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 (cbox.MaxEdge.X - d > box.MinEdge.X && cbox.MinEdge.X + d < box.MaxEdge.X && cbox.MaxEdge.Z - d > box.MinEdge.Z && cbox.MinEdge.Z + d < box.MaxEdge.Z) { @@ -574,7 +564,7 @@ collisionMoveResult collisionMoveSimple(Environment *env, IGameDef *gamedef, box.MinEdge += *pos_f; box.MaxEdge += *pos_f; } - if (std::fabs(cbox.MaxEdge.Y - box.MinEdge.Y) < 0.15f * BS) { + if (std::fabs(cbox.MaxEdge.Y - box.MinEdge.Y) < 0.05f) { result.touching_ground = true; if (box_info.is_object) diff --git a/src/collision.h b/src/collision.h index 85df02c96..fa47cccc1 100644 --- a/src/collision.h +++ b/src/collision.h @@ -77,7 +77,7 @@ collisionMoveResult collisionMoveSimple(Environment *env,IGameDef *gamedef, // dtime receives time until first collision, invalid if -1 is returned CollisionAxis axisAlignedCollision( const aabb3f &staticbox, const aabb3f &movingbox, - const v3f &speed, f32 d, f32 *dtime); + const v3f &speed, f32 *dtime); // Helper function: // Checks if moving the movingbox up by the given distance would hit a ceiling. diff --git a/src/unittest/test_collision.cpp b/src/unittest/test_collision.cpp index 332d3fa13..2f39c2489 100644 --- a/src/unittest/test_collision.cpp +++ b/src/unittest/test_collision.cpp @@ -50,38 +50,38 @@ void TestCollision::testAxisAlignedCollision() aabb3f s(bx, by, bz, bx+1, by+1, bz+1); aabb3f m(bx-2, by, bz, bx-1, by+1, bz+1); v3f v(1, 0, 0); - f32 dtime = 0; - UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == 0); + f32 dtime = 1.0f; + UASSERT(axisAlignedCollision(s, m, v, &dtime) == 0); UASSERT(fabs(dtime - 1.000) < 0.001); } { aabb3f s(bx, by, bz, bx+1, by+1, bz+1); aabb3f m(bx-2, by, bz, bx-1, by+1, bz+1); v3f v(-1, 0, 0); - f32 dtime = 0; - UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == -1); + f32 dtime = 1.0f; + UASSERT(axisAlignedCollision(s, m, v, &dtime) == -1); } { aabb3f s(bx, by, bz, bx+1, by+1, bz+1); aabb3f m(bx-2, by+1.5, bz, bx-1, by+2.5, bz-1); v3f v(1, 0, 0); - f32 dtime; - UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == -1); + f32 dtime = 1.0f; + UASSERT(axisAlignedCollision(s, m, v, &dtime) == -1); } { aabb3f s(bx, by, bz, bx+1, by+1, bz+1); aabb3f m(bx-2, by-1.5, bz, bx-1.5, by+0.5, bz+1); v3f v(0.5, 0.1, 0); - f32 dtime; - UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == 0); + f32 dtime = 3.0f; + UASSERT(axisAlignedCollision(s, m, v, &dtime) == 0); UASSERT(fabs(dtime - 3.000) < 0.001); } { aabb3f s(bx, by, bz, bx+1, by+1, bz+1); aabb3f m(bx-2, by-1.5, bz, bx-1.5, by+0.5, bz+1); v3f v(0.5, 0.1, 0); - f32 dtime; - UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == 0); + f32 dtime = 3.0f; + UASSERT(axisAlignedCollision(s, m, v, &dtime) == 0); UASSERT(fabs(dtime - 3.000) < 0.001); } @@ -90,38 +90,38 @@ void TestCollision::testAxisAlignedCollision() aabb3f s(bx, by, bz, bx+1, by+1, bz+1); aabb3f m(bx+2, by, bz, bx+3, by+1, bz+1); v3f v(-1, 0, 0); - f32 dtime; - UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == 0); + f32 dtime = 1.0f; + UASSERT(axisAlignedCollision(s, m, v, &dtime) == 0); UASSERT(fabs(dtime - 1.000) < 0.001); } { aabb3f s(bx, by, bz, bx+1, by+1, bz+1); aabb3f m(bx+2, by, bz, bx+3, by+1, bz+1); v3f v(1, 0, 0); - f32 dtime; - UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == -1); + f32 dtime = 1.0f; + UASSERT(axisAlignedCollision(s, m, v, &dtime) == -1); } { aabb3f s(bx, by, bz, bx+1, by+1, bz+1); aabb3f m(bx+2, by, bz+1.5, bx+3, by+1, bz+3.5); v3f v(-1, 0, 0); - f32 dtime; - UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == -1); + f32 dtime = 1.0f; + UASSERT(axisAlignedCollision(s, m, v, &dtime) == -1); } { aabb3f s(bx, by, bz, bx+1, by+1, bz+1); aabb3f m(bx+2, by-1.5, bz, bx+2.5, by-0.5, bz+1); v3f v(-0.5, 0.2, 0); - f32 dtime; - UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == 1); // Y, not X! + f32 dtime = 2.5f; + UASSERT(axisAlignedCollision(s, m, v, &dtime) == 1); // Y, not X! UASSERT(fabs(dtime - 2.500) < 0.001); } { aabb3f s(bx, by, bz, bx+1, by+1, bz+1); aabb3f m(bx+2, by-1.5, bz, bx+2.5, by-0.5, bz+1); v3f v(-0.5, 0.3, 0); - f32 dtime; - UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == 0); + f32 dtime = 2.0f; + UASSERT(axisAlignedCollision(s, m, v, &dtime) == 0); UASSERT(fabs(dtime - 2.000) < 0.001); } @@ -132,48 +132,48 @@ void TestCollision::testAxisAlignedCollision() aabb3f s(bx, by, bz, bx+2, by+2, bz+2); aabb3f m(bx+2.3, by+2.29, bz+2.29, bx+4.2, by+4.2, bz+4.2); v3f v(-1./3, -1./3, -1./3); - f32 dtime; - UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == 0); + f32 dtime = 1.0f; + UASSERT(axisAlignedCollision(s, m, v, &dtime) == 0); UASSERT(fabs(dtime - 0.9) < 0.001); } { aabb3f s(bx, by, bz, bx+2, by+2, bz+2); aabb3f m(bx+2.29, by+2.3, bz+2.29, bx+4.2, by+4.2, bz+4.2); v3f v(-1./3, -1./3, -1./3); - f32 dtime; - UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == 1); + f32 dtime = 1.0f; + UASSERT(axisAlignedCollision(s, m, v, &dtime) == 1); UASSERT(fabs(dtime - 0.9) < 0.001); } { aabb3f s(bx, by, bz, bx+2, by+2, bz+2); aabb3f m(bx+2.29, by+2.29, bz+2.3, bx+4.2, by+4.2, bz+4.2); v3f v(-1./3, -1./3, -1./3); - f32 dtime; - UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == 2); + f32 dtime = 1.0f; + UASSERT(axisAlignedCollision(s, m, v, &dtime) == 2); UASSERT(fabs(dtime - 0.9) < 0.001); } { aabb3f s(bx, by, bz, bx+2, by+2, bz+2); aabb3f m(bx-4.2, by-4.2, bz-4.2, bx-2.3, by-2.29, bz-2.29); v3f v(1./7, 1./7, 1./7); - f32 dtime; - UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == 0); + f32 dtime = 17.0f; + UASSERT(axisAlignedCollision(s, m, v, &dtime) == 0); UASSERT(fabs(dtime - 16.1) < 0.001); } { aabb3f s(bx, by, bz, bx+2, by+2, bz+2); aabb3f m(bx-4.2, by-4.2, bz-4.2, bx-2.29, by-2.3, bz-2.29); v3f v(1./7, 1./7, 1./7); - f32 dtime; - UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == 1); + f32 dtime = 17.0f; + UASSERT(axisAlignedCollision(s, m, v, &dtime) == 1); UASSERT(fabs(dtime - 16.1) < 0.001); } { aabb3f s(bx, by, bz, bx+2, by+2, bz+2); aabb3f m(bx-4.2, by-4.2, bz-4.2, bx-2.29, by-2.29, bz-2.3); v3f v(1./7, 1./7, 1./7); - f32 dtime; - UASSERT(axisAlignedCollision(s, m, v, 0, &dtime) == 2); + f32 dtime = 17.0f; + UASSERT(axisAlignedCollision(s, m, v, &dtime) == 2); UASSERT(fabs(dtime - 16.1) < 0.001); } } -- 2.25.1