Avatar gets hung up on jagged walls, trees, rocks and stupid things

[daniel-santos]

This is kinda annoying. hmm, not sure how to attach patches on github....

[daniel-santos]

From b4b61c7f73a04d3cfcb7e8a703fcfa66aa1f2a16 Mon Sep 17 00:00:00 2001 From: Daniel Santos daniel.santos@pobox.com Date: Wed, 18 Apr 2012 02:27:14 -0500 Subject: Don't get stuck on jagged walls, stray rocks and sticky-outy things.

When traveling straight (not diagonally), and we hit an object, but if one step to the left or right (relative to our direction of travel) there is a valid path, then desist movement in the requested direction and travel towards the clear path on the other axis until we can proceed

forward in the requested direction.

src/MapCollision.cpp | 81 ++++++++++++++++++++++++++++++++++++++++++------- src/MapCollision.h | 4 ++ 2 files changed, 73 insertions(+), 12 deletions(-)

diff --git a/src/MapCollision.cpp b/src/MapCollision.cpp index 5809e2b..c198532 100644 --- a/src/MapCollision.cpp +++ b/src/MapCollision.cpp @@ -48,10 +48,9 @@ void MapCollision::setmap(unsigned short _colmap[256][256]) { */ bool MapCollision::move(int &x, int &y, int step_x, int step_y, int dist) {

• bool diag = false;

- if (step_x != 0 && step_y != 0) diag = true;

• for (int i=0; i<dist; i++) {
• bool diag = step_x && step_y; +
• for (int i = dist; i--;) { if (is_empty(x + step_x, y + step_y)) { x+= step_x; y+= step_y; @@ -62,8 +61,21 @@ bool MapCollision::move(int &x, int &y, int step_x, int step_y, int dist) { else if (diag && is_empty(x, y + step_y)) { // slide along wall y+= step_y; }
• else { // absolute stop
• return false;
• else { // is there a singular obstacle or corner we can step around?
• // only works if we are moving straight
• if (diag) return false; +
• int way_around = is_one_step_around(x, y, step_x, step_y); +
• if (!way_around) {
• return false;
• } +
• if (step_x) {
• y+= way_around;
• } else {
• x+= way_around;
• } } } return true; @@ -77,13 +89,58 @@ bool MapCollision::outsideMap(int tile_x, int tile_y) { bool MapCollision::is_empty(int x, int y) { int tile_x = x >> TILE_SHIFT; // fast div int tile_y = y >> TILE_SHIFT; // fast div
• // bounds check
• if (outsideMap(tile_x, tile_y)) return false;
• if (colmap[tile_x][tile_y] == 0)
• return true;
• return false;
• // check bounds, then check for collision
• return !outsideMap(tile_x, tile_y) && !colmap[tile_x][tile_y]; +} + +bool inline MapCollision::is_sidestepable(int tile_x, int tile_y, int offx1, int offy1, int offx2, int offy2) {
• return !outsideMap(tile_x + offx2, tile_y + offy2)
• && !colmap[tile_x + offx1][tile_y + offy1]
• && !colmap[tile_x + offx2][tile_y + offy2]; +} + +/**
• * If we have encountered a collision (i.e., is_empty(x, y) already said no), then see if we've
• * hit an object/wall where there is a path around it by one step. This is to avoid getting
• * "caught" on the corners of a jagged wall.
• *
• * @return if no side-step path exists, the return value is zero. Otherwise,
• * it is the coodinate modifier value for the opposite coordinate
• * (i.e., if xdir was zero and ydir was non-zero, the return value
• * should be applied to xdir)
• */ +int MapCollision::is_one_step_around(int x, int y, int xdir, int ydir) {
• int tile_x = x >> TILE_SHIFT; // fast div
• int tile_y = y >> TILE_SHIFT; // fast div
• int ret = 0; +
• if (xdir) {
• if (is_sidestepable(tile_x, tile_y, 0, -1, xdir, -1)) {
• ret = 1;
• }
• if (is_sidestepable(tile_x, tile_y, 0, 1, xdir, 1)) {
• ret |= 2;
• }
• if (ret == 3) {
• // translation: ret = y % UNITS_PER_TILE > UNITS_PER_TILE / 2 ? 1 : -1;
• // realistically, if we were using compile time constants, the compiler
• // would generate pretty much those instructions.
• ret = (y & ((1 << TILE_SHIFT) - 1)) > UNITS_PER_TILE >> 1 ? -1 : 1;
• }
• } else {
• if (is_sidestepable(tile_x, tile_y, -1, 0, -1, ydir)) {
• ret = 1;
• }
• if (is_sidestepable(tile_x, tile_y, 1, 0, 1, ydir)) {
• ret |= 2;
• }
• if (ret == 3) {
• ret = (x & ((1 << TILE_SHIFT) - 1)) > UNITS_PER_TILE >> 1 ? -1 : 1;
• }
• } +

• return !ret ? 0 : (ret == 1 ? -1 : 1); }

  bool MapCollision::is_wall(int x, int y) { diff --git a/src/MapCollision.h b/src/MapCollision.h index 897cc84..71b3db9 100644 --- a/src/MapCollision.h +++ b/src/MapCollision.h @@ -53,6 +53,7 @@ public: bool move(int &x, int &y, int step_x, int step_y, int dist); bool outsideMap(int tile_x, int tile_y); bool is_empty(int x, int y);

• int is_one_step_around(int x, int y, int xidr, int ydir); bool is_wall(int x, int y);

  bool line_of_sight(int x1, int y1, int x2, int y2); @@ -64,6 +65,9 @@ public:

  int result_x; int result_y; + +private:

• bool inline is_sidestepable(int tile_x, int tile_y, int offx1, int offy1, int offx2, int offy2); };

  endif

  1.7.3.4

[daniel-santos]

sorry, wrong project! was intended for clintbellanger/flare