aboutsummaryrefslogtreecommitdiff
path: root/engines/gnap/grid.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'engines/gnap/grid.cpp')
-rw-r--r--engines/gnap/grid.cpp1561
1 files changed, 562 insertions, 999 deletions
diff --git a/engines/gnap/grid.cpp b/engines/gnap/grid.cpp
index 568fe2520e..d4aed8dbc0 100644
--- a/engines/gnap/grid.cpp
+++ b/engines/gnap/grid.cpp
@@ -81,176 +81,81 @@ bool GnapEngine::isPointBlocked(int gridX, int gridY) {
}
return false;
-
}
-bool GnapEngine::gnapFindPath4(int gridX, int gridY) {
- bool result = false;
-
- _gnapWalkNodesCount = 0;
- _gnapWalkDirXIncr = 0;
- _gnapWalkDirYIncr = 0;
- _gnapWalkDeltaX = ABS(_gnapWalkDestX - gridX);
- _gnapWalkDeltaY = ABS(_gnapWalkDestY - gridY);
-
- if (_gnapWalkDeltaX)
- _gnapWalkDirX = (_gnapWalkDestX - gridX) / _gnapWalkDeltaX;
- else
- _gnapWalkDirX = 0;
-
- if (_gnapWalkDeltaY)
- _gnapWalkDirY = (_gnapWalkDestY - gridY) / _gnapWalkDeltaY;
- else
- _gnapWalkDirY = 0;
-
- while (_gnapWalkDirXIncr < _gnapWalkDeltaX && _gnapWalkDirYIncr < _gnapWalkDeltaY) {
- _gnapWalkNodes[_gnapWalkNodesCount]._gridX1 = gridX + _gnapWalkDirX * _gnapWalkDirXIncr;
- _gnapWalkNodes[_gnapWalkNodesCount]._gridY1 = gridY + _gnapWalkDirY * _gnapWalkDirYIncr;
- if (!isPointBlocked(_gnapWalkDirX + _gnapWalkNodes[_gnapWalkNodesCount]._gridX1, _gnapWalkDirY + _gnapWalkNodes[_gnapWalkNodesCount]._gridY1)) {
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaX = _gnapWalkDirX;
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaY = _gnapWalkDirY;
- ++_gnapWalkDirXIncr;
- ++_gnapWalkDirYIncr;
- } else if (_gnapWalkDeltaY - _gnapWalkDirYIncr > _gnapWalkDeltaX - _gnapWalkDirXIncr) {
- if (!isPointBlocked(_gnapWalkNodes[_gnapWalkNodesCount]._gridX1, _gnapWalkDirY + _gnapWalkNodes[_gnapWalkNodesCount]._gridY1)) {
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaX = 0;
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaY = _gnapWalkDirY;
- ++_gnapWalkDirYIncr;
- } else if (!isPointBlocked(_gnapWalkDirX + _gnapWalkNodes[_gnapWalkNodesCount]._gridX1, _gnapWalkNodes[_gnapWalkNodesCount]._gridY1)) {
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaX = _gnapWalkDirX;
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaY = 0;
- ++_gnapWalkDirXIncr;
- } else {
- _gnapWalkDeltaX = _gnapWalkDirXIncr;
- _gnapWalkDeltaY = _gnapWalkDirYIncr;
- --_gnapWalkNodesCount;
- }
- } else {
- if (!isPointBlocked(_gnapWalkDirX + _gnapWalkNodes[_gnapWalkNodesCount]._gridX1, _gnapWalkNodes[_gnapWalkNodesCount]._gridY1)) {
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaX = _gnapWalkDirX;
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaY = 0;
- ++_gnapWalkDirXIncr;
- } else if (!isPointBlocked(_gnapWalkNodes[_gnapWalkNodesCount]._gridX1, _gnapWalkDirY + _gnapWalkNodes[_gnapWalkNodesCount]._gridY1)) {
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaX = 0;
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaY = _gnapWalkDirY;
- ++_gnapWalkDirYIncr;
- } else {
- _gnapWalkDeltaX = _gnapWalkDirXIncr;
- _gnapWalkDeltaY = _gnapWalkDirYIncr;
- --_gnapWalkNodesCount;
- }
- }
- ++_gnapWalkNodesCount;
- }
-
- while (_gnapWalkDirXIncr < _gnapWalkDeltaX) {
- _gnapWalkNodes[_gnapWalkNodesCount]._gridX1 = gridX + _gnapWalkDirX * _gnapWalkDirXIncr;
- _gnapWalkNodes[_gnapWalkNodesCount]._gridY1 = _gnapWalkDestY;
- if (!isPointBlocked(_gnapWalkDirX + _gnapWalkNodes[_gnapWalkNodesCount]._gridX1, _gnapWalkDestY)) {
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaX = _gnapWalkDirX;
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaY = 0;
- ++_gnapWalkDirXIncr;
- ++_gnapWalkNodesCount;
- } else {
- _gnapWalkDeltaX = _gnapWalkDirXIncr;
- }
- }
-
- while (_gnapWalkDirYIncr < _gnapWalkDeltaY) {
- _gnapWalkNodes[_gnapWalkNodesCount]._gridX1 = _gnapWalkDestX;
- _gnapWalkNodes[_gnapWalkNodesCount]._gridY1 = gridY + _gnapWalkDirY * _gnapWalkDirYIncr;
- if (!isPointBlocked(_gnapWalkDestX, _gnapWalkDirY + _gnapWalkNodes[_gnapWalkNodesCount]._gridY1)) {
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaX = 0;
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaY = _gnapWalkDirY;
- ++_gnapWalkDirYIncr;
- ++_gnapWalkNodesCount;
- } else {
- _gnapWalkDeltaY = _gnapWalkDirYIncr;
- }
- }
-
- if (gridX + _gnapWalkDirX * _gnapWalkDirXIncr != _gnapWalkDestX || gridY + _gnapWalkDirY * _gnapWalkDirYIncr != _gnapWalkDestY) {
- _gnapWalkDestX = gridX + _gnapWalkDirX * _gnapWalkDirXIncr;
- _gnapWalkDestY = gridY + _gnapWalkDirY * _gnapWalkDirYIncr;
- result = false;
- } else {
- result = true;
- }
+/******************************************************************************/
- return result;
-}
+bool PlayerGnap::findPath1(int gridX, int gridY, int index) {
+ _walkNodesCount = index;
+ _walkDirXIncr = 0;
+ _walkDirYIncr = 0;
+ _walkDeltaX = ABS(_walkDestX - gridX);
+ _walkDeltaY = ABS(_walkDestY - gridY);
-bool GnapEngine::gnapFindPath1(int gridX, int gridY, int index) {
- _gnapWalkNodesCount = index;
- _gnapWalkDirXIncr = 0;
- _gnapWalkDirYIncr = 0;
- _gnapWalkDeltaX = ABS(_gnapWalkDestX - gridX);
- _gnapWalkDeltaY = ABS(_gnapWalkDestY - gridY);
-
- if (_gnapWalkDeltaX)
- _gnapWalkDirX = (_gnapWalkDestX - gridX) / _gnapWalkDeltaX;
+ if (_walkDeltaX)
+ _walkDirX = (_walkDestX - gridX) / _walkDeltaX;
else
- _gnapWalkDirX = 0;
+ _walkDirX = 0;
- if (_gnapWalkDeltaY)
- _gnapWalkDirY = (_gnapWalkDestY - gridY) / _gnapWalkDeltaY;
+ if (_walkDeltaY)
+ _walkDirY = (_walkDestY - gridY) / _walkDeltaY;
else
- _gnapWalkDirY = 0;
-
- while (_gnapWalkDirXIncr < _gnapWalkDeltaX && _gnapWalkDirYIncr < _gnapWalkDeltaY) {
- _gnapWalkNodes[_gnapWalkNodesCount]._gridX1 = gridX + _gnapWalkDirX * _gnapWalkDirXIncr;
- _gnapWalkNodes[_gnapWalkNodesCount]._gridY1 = gridY + _gnapWalkDirY * _gnapWalkDirYIncr;
- if (!isPointBlocked(_gnapWalkDirX + _gnapWalkNodes[_gnapWalkNodesCount]._gridX1, _gnapWalkDirY + _gnapWalkNodes[_gnapWalkNodesCount]._gridY1)) {
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaX = _gnapWalkDirX;
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaY = _gnapWalkDirY;
- ++_gnapWalkDirXIncr;
- ++_gnapWalkDirYIncr;
- } else if (_gnapWalkDeltaY - _gnapWalkDirYIncr > _gnapWalkDeltaX - _gnapWalkDirXIncr) {
- if (!isPointBlocked(_gnapWalkNodes[_gnapWalkNodesCount]._gridX1, _gnapWalkDirY + _gnapWalkNodes[_gnapWalkNodesCount]._gridY1)) {
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaX = 0;
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaY = _gnapWalkDirY;
- ++_gnapWalkDirYIncr;
- } else if (!isPointBlocked(_gnapWalkDirX + _gnapWalkNodes[_gnapWalkNodesCount]._gridX1, _gnapWalkNodes[_gnapWalkNodesCount]._gridY1)) {
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaX = _gnapWalkDirX;
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaY = 0;
- ++_gnapWalkDirXIncr;
+ _walkDirY = 0;
+
+ while (_walkDirXIncr < _walkDeltaX && _walkDirYIncr < _walkDeltaY) {
+ _walkNodes[_walkNodesCount]._gridX1 = gridX + _walkDirX * _walkDirXIncr;
+ _walkNodes[_walkNodesCount]._gridY1 = gridY + _walkDirY * _walkDirYIncr;
+ if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
+ _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
+ ++_walkDirXIncr;
+ ++_walkDirYIncr;
+ } else if (_walkDeltaY - _walkDirYIncr > _walkDeltaX - _walkDirXIncr) {
+ if (!_vm->isPointBlocked(_walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = 0;
+ _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
+ ++_walkDirYIncr;
+ } else if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
+ _walkNodes[_walkNodesCount]._deltaY = 0;
+ ++_walkDirXIncr;
} else
return false;
} else {
- if (!isPointBlocked(_gnapWalkDirX + _gnapWalkNodes[_gnapWalkNodesCount]._gridX1, _gnapWalkNodes[_gnapWalkNodesCount]._gridY1)) {
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaX = _gnapWalkDirX;
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaY = 0;
- ++_gnapWalkDirXIncr;
- } else if (!isPointBlocked(_gnapWalkNodes[_gnapWalkNodesCount]._gridX1, _gnapWalkDirY + _gnapWalkNodes[_gnapWalkNodesCount]._gridY1)) {
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaX = 0;
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaY = _gnapWalkDirY;
- ++_gnapWalkDirYIncr;
+ if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
+ _walkNodes[_walkNodesCount]._deltaY = 0;
+ ++_walkDirXIncr;
+ } else if (!_vm->isPointBlocked(_walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = 0;
+ _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
+ ++_walkDirYIncr;
} else
return false;
}
- ++_gnapWalkNodesCount;
+ ++_walkNodesCount;
}
- while (_gnapWalkDirXIncr < _gnapWalkDeltaX) {
- _gnapWalkNodes[_gnapWalkNodesCount]._gridX1 = gridX + _gnapWalkDirX * _gnapWalkDirXIncr;
- _gnapWalkNodes[_gnapWalkNodesCount]._gridY1 = _gnapWalkDestY;
- if (!isPointBlocked(_gnapWalkDirX + _gnapWalkNodes[_gnapWalkNodesCount]._gridX1, _gnapWalkDestY)) {
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaX = _gnapWalkDirX;
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaY = 0;
- ++_gnapWalkDirXIncr;
- ++_gnapWalkNodesCount;
+ while (_walkDirXIncr < _walkDeltaX) {
+ _walkNodes[_walkNodesCount]._gridX1 = gridX + _walkDirX * _walkDirXIncr;
+ _walkNodes[_walkNodesCount]._gridY1 = _walkDestY;
+ if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkDestY)) {
+ _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
+ _walkNodes[_walkNodesCount]._deltaY = 0;
+ ++_walkDirXIncr;
+ ++_walkNodesCount;
} else
return false;
}
- while (_gnapWalkDirYIncr < _gnapWalkDeltaY) {
- _gnapWalkNodes[_gnapWalkNodesCount]._gridX1 = _gnapWalkDestX;
- _gnapWalkNodes[_gnapWalkNodesCount]._gridY1 = gridY + _gnapWalkDirY * _gnapWalkDirYIncr;
- if (!isPointBlocked(_gnapWalkDestX, _gnapWalkDirY + _gnapWalkNodes[_gnapWalkNodesCount]._gridY1)) {
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaX = 0;
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaY = _gnapWalkDirY;
- ++_gnapWalkDirYIncr;
- ++_gnapWalkNodesCount;
+ while (_walkDirYIncr < _walkDeltaY) {
+ _walkNodes[_walkNodesCount]._gridX1 = _walkDestX;
+ _walkNodes[_walkNodesCount]._gridY1 = gridY + _walkDirY * _walkDirYIncr;
+ if (!_vm->isPointBlocked(_walkDestX, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = 0;
+ _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
+ ++_walkDirYIncr;
+ ++_walkNodesCount;
} else
return false;
}
@@ -258,101 +163,101 @@ bool GnapEngine::gnapFindPath1(int gridX, int gridY, int index) {
return true;
}
-bool GnapEngine::gnapFindPath2(int gridX, int gridY, int index) {
- _gnapWalkNodesCount = index;
- _gnapWalkDirXIncr = 0;
- _gnapWalkDirYIncr = 0;
- _gnapWalkDeltaX = ABS(_gnapWalkDestX - gridX);
- _gnapWalkDeltaY = ABS(_gnapWalkDestY - gridY);
+bool PlayerGnap::findPath2(int gridX, int gridY, int index) {
+ _walkNodesCount = index;
+ _walkDirXIncr = 0;
+ _walkDirYIncr = 0;
+ _walkDeltaX = ABS(_walkDestX - gridX);
+ _walkDeltaY = ABS(_walkDestY - gridY);
- if (_gnapWalkDeltaX)
- _gnapWalkDirX = (_gnapWalkDestX - gridX) / _gnapWalkDeltaX;
+ if (_walkDeltaX)
+ _walkDirX = (_walkDestX - gridX) / _walkDeltaX;
else
- _gnapWalkDirX = 0;
+ _walkDirX = 0;
- if (_gnapWalkDeltaY)
- _gnapWalkDirY = (_gnapWalkDestY - gridY) / _gnapWalkDeltaY;
+ if (_walkDeltaY)
+ _walkDirY = (_walkDestY - gridY) / _walkDeltaY;
else
- _gnapWalkDirY = 0;
-
- while (_gnapWalkDeltaY < _gnapWalkDeltaX - _gnapWalkDirXIncr) {
- _gnapWalkNodes[_gnapWalkNodesCount]._gridX1 = gridX + _gnapWalkDirX * _gnapWalkDirXIncr;
- _gnapWalkNodes[_gnapWalkNodesCount]._gridY1 = gridY;
- if (!isPointBlocked(_gnapWalkDirX + _gnapWalkNodes[_gnapWalkNodesCount]._gridX1, gridY)) {
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaX = _gnapWalkDirX;
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaY = 0;
- ++_gnapWalkDirXIncr;
- ++_gnapWalkNodesCount;
+ _walkDirY = 0;
+
+ while (_walkDeltaY < _walkDeltaX - _walkDirXIncr) {
+ _walkNodes[_walkNodesCount]._gridX1 = gridX + _walkDirX * _walkDirXIncr;
+ _walkNodes[_walkNodesCount]._gridY1 = gridY;
+ if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, gridY)) {
+ _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
+ _walkNodes[_walkNodesCount]._deltaY = 0;
+ ++_walkDirXIncr;
+ ++_walkNodesCount;
} else
return false;
}
- while (_gnapWalkDeltaX < _gnapWalkDeltaY - _gnapWalkDirYIncr) {
- _gnapWalkNodes[_gnapWalkNodesCount]._gridX1 = gridX;
- _gnapWalkNodes[_gnapWalkNodesCount]._gridY1 = gridY + _gnapWalkDirY * _gnapWalkDirYIncr;
- if (!isPointBlocked(gridX, _gnapWalkDirY + _gnapWalkNodes[_gnapWalkNodesCount]._gridY1)) {
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaX = 0;
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaY = _gnapWalkDirY;
- ++_gnapWalkDirYIncr;
- ++_gnapWalkNodesCount;
+ while (_walkDeltaX < _walkDeltaY - _walkDirYIncr) {
+ _walkNodes[_walkNodesCount]._gridX1 = gridX;
+ _walkNodes[_walkNodesCount]._gridY1 = gridY + _walkDirY * _walkDirYIncr;
+ if (!_vm->isPointBlocked(gridX, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = 0;
+ _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
+ ++_walkDirYIncr;
+ ++_walkNodesCount;
} else
return false;
}
- while (_gnapWalkDirXIncr < _gnapWalkDeltaX && _gnapWalkDirYIncr < _gnapWalkDeltaY) {
- _gnapWalkNodes[_gnapWalkNodesCount]._gridX1 = gridX + _gnapWalkDirX * _gnapWalkDirXIncr;
- _gnapWalkNodes[_gnapWalkNodesCount]._gridY1 = gridY + _gnapWalkDirY * _gnapWalkDirYIncr;
- if (!isPointBlocked(_gnapWalkDirX + _gnapWalkNodes[_gnapWalkNodesCount]._gridX1, _gnapWalkDirY + _gnapWalkNodes[_gnapWalkNodesCount]._gridY1)) {
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaX = _gnapWalkDirX;
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaY = _gnapWalkDirY;
- ++_gnapWalkDirXIncr;
- ++_gnapWalkDirYIncr;
- } else if (_gnapWalkDeltaY - _gnapWalkDirYIncr > _gnapWalkDeltaX - _gnapWalkDirXIncr) {
- if (!isPointBlocked(_gnapWalkNodes[_gnapWalkNodesCount]._gridX1, _gnapWalkDirY + _gnapWalkNodes[_gnapWalkNodesCount]._gridY1)) {
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaX = 0;
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaY = _gnapWalkDirY;
- ++_gnapWalkDirYIncr;
- } else if (!isPointBlocked(_gnapWalkDirX + _gnapWalkNodes[_gnapWalkNodesCount]._gridX1, _gnapWalkNodes[_gnapWalkNodesCount]._gridY1)) {
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaX = _gnapWalkDirX;
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaY = 0;
- ++_gnapWalkDirXIncr;
+ while (_walkDirXIncr < _walkDeltaX && _walkDirYIncr < _walkDeltaY) {
+ _walkNodes[_walkNodesCount]._gridX1 = gridX + _walkDirX * _walkDirXIncr;
+ _walkNodes[_walkNodesCount]._gridY1 = gridY + _walkDirY * _walkDirYIncr;
+ if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
+ _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
+ ++_walkDirXIncr;
+ ++_walkDirYIncr;
+ } else if (_walkDeltaY - _walkDirYIncr > _walkDeltaX - _walkDirXIncr) {
+ if (!_vm->isPointBlocked(_walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = 0;
+ _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
+ ++_walkDirYIncr;
+ } else if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
+ _walkNodes[_walkNodesCount]._deltaY = 0;
+ ++_walkDirXIncr;
} else
return false;
} else {
- if (!isPointBlocked(_gnapWalkDirX + _gnapWalkNodes[_gnapWalkNodesCount]._gridX1, _gnapWalkNodes[_gnapWalkNodesCount]._gridY1)) {
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaX = _gnapWalkDirX;
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaY = 0;
- ++_gnapWalkDirXIncr;
- } else if (!isPointBlocked(_gnapWalkNodes[_gnapWalkNodesCount]._gridX1, _gnapWalkDirY + _gnapWalkNodes[_gnapWalkNodesCount]._gridY1)) {
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaX = 0;
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaY = _gnapWalkDirY;
- ++_gnapWalkDirYIncr;
+ if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
+ _walkNodes[_walkNodesCount]._deltaY = 0;
+ ++_walkDirXIncr;
+ } else if (!_vm->isPointBlocked(_walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = 0;
+ _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
+ ++_walkDirYIncr;
} else
return false;
}
- ++_gnapWalkNodesCount;
+ ++_walkNodesCount;
}
- while (_gnapWalkDirXIncr < _gnapWalkDeltaX) {
- _gnapWalkNodes[_gnapWalkNodesCount]._gridX1 = gridX + _gnapWalkDirX * _gnapWalkDirXIncr;
- _gnapWalkNodes[_gnapWalkNodesCount]._gridY1 = _gnapWalkDestY;
- if (!isPointBlocked(_gnapWalkDirX + _gnapWalkNodes[_gnapWalkNodesCount]._gridX1, _gnapWalkDestY)) {
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaX = _gnapWalkDirX;
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaY = 0;
- ++_gnapWalkDirXIncr;
- ++_gnapWalkNodesCount;
+ while (_walkDirXIncr < _walkDeltaX) {
+ _walkNodes[_walkNodesCount]._gridX1 = gridX + _walkDirX * _walkDirXIncr;
+ _walkNodes[_walkNodesCount]._gridY1 = _walkDestY;
+ if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkDestY)) {
+ _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
+ _walkNodes[_walkNodesCount]._deltaY = 0;
+ ++_walkDirXIncr;
+ ++_walkNodesCount;
} else
return false;
}
- while (_gnapWalkDirYIncr < _gnapWalkDeltaY) {
- _gnapWalkNodes[_gnapWalkNodesCount]._gridX1 = _gnapWalkDestX;
- _gnapWalkNodes[_gnapWalkNodesCount]._gridY1 = gridY + _gnapWalkDirY * _gnapWalkDirYIncr;
- if (!isPointBlocked(_gnapWalkDestX, _gnapWalkDirY + _gnapWalkNodes[_gnapWalkNodesCount]._gridY1)) {
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaX = 0;
- _gnapWalkNodes[_gnapWalkNodesCount]._deltaY = _gnapWalkDirY;
- ++_gnapWalkDirYIncr;
- ++_gnapWalkNodesCount;
+ while (_walkDirYIncr < _walkDeltaY) {
+ _walkNodes[_walkNodesCount]._gridX1 = _walkDestX;
+ _walkNodes[_walkNodesCount]._gridY1 = gridY + _walkDirY * _walkDirYIncr;
+ if (!_vm->isPointBlocked(_walkDestX, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = 0;
+ _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
+ ++_walkDirYIncr;
+ ++_walkNodesCount;
} else
return false;
}
@@ -360,167 +265,167 @@ bool GnapEngine::gnapFindPath2(int gridX, int gridY, int index) {
return true;
}
-bool GnapEngine::gnapFindPath3(int gridX, int gridY) {
+bool PlayerGnap::findPath3(int gridX, int gridY) {
int gridIncr = 1;
bool done = false;
- while (!done && gridIncr < _gridMaxX) {
- if (!isPointBlocked(gridX + gridIncr, gridY) && gnapFindPath1(gridX + gridIncr, gridY, gridIncr)) {
+ while (!done && gridIncr < _vm->_gridMaxX) {
+ if (!_vm->isPointBlocked(gridX + gridIncr, gridY) && findPath1(gridX + gridIncr, gridY, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _gnapWalkNodes[i]._gridX1 = gridX + i;
- _gnapWalkNodes[i]._gridY1 = gridY;
- _gnapWalkNodes[i]._deltaX = 1;
- _gnapWalkNodes[i]._deltaY = 0;
+ _walkNodes[i]._gridX1 = gridX + i;
+ _walkNodes[i]._gridY1 = gridY;
+ _walkNodes[i]._deltaX = 1;
+ _walkNodes[i]._deltaY = 0;
}
done = true;
break;
}
- if (!isPointBlocked(gridX - gridIncr, gridY) && gnapFindPath1(gridX - gridIncr, gridY, gridIncr)) {
+ if (!_vm->isPointBlocked(gridX - gridIncr, gridY) && findPath1(gridX - gridIncr, gridY, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _gnapWalkNodes[i]._gridX1 = gridX - i;
- _gnapWalkNodes[i]._gridY1 = gridY;
- _gnapWalkNodes[i]._deltaX = -1;
- _gnapWalkNodes[i]._deltaY = 0;
+ _walkNodes[i]._gridX1 = gridX - i;
+ _walkNodes[i]._gridY1 = gridY;
+ _walkNodes[i]._deltaX = -1;
+ _walkNodes[i]._deltaY = 0;
}
done = true;
break;
}
- if (!isPointBlocked(gridX, gridY + gridIncr) && gnapFindPath1(gridX, gridY + gridIncr, gridIncr)) {
+ if (!_vm->isPointBlocked(gridX, gridY + gridIncr) && findPath1(gridX, gridY + gridIncr, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _gnapWalkNodes[i]._gridX1 = gridX;
- _gnapWalkNodes[i]._gridY1 = gridY + i;
- _gnapWalkNodes[i]._deltaX = 0;
- _gnapWalkNodes[i]._deltaY = 1;
+ _walkNodes[i]._gridX1 = gridX;
+ _walkNodes[i]._gridY1 = gridY + i;
+ _walkNodes[i]._deltaX = 0;
+ _walkNodes[i]._deltaY = 1;
}
done = true;
break;
}
- if (!isPointBlocked(gridX, gridY - gridIncr) && gnapFindPath1(gridX, gridY - gridIncr, gridIncr)) {
+ if (!_vm->isPointBlocked(gridX, gridY - gridIncr) && findPath1(gridX, gridY - gridIncr, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _gnapWalkNodes[i]._gridX1 = gridX;
- _gnapWalkNodes[i]._gridY1 = gridY - i;
- _gnapWalkNodes[i]._deltaX = 0;
- _gnapWalkNodes[i]._deltaY = -1;
+ _walkNodes[i]._gridX1 = gridX;
+ _walkNodes[i]._gridY1 = gridY - i;
+ _walkNodes[i]._deltaX = 0;
+ _walkNodes[i]._deltaY = -1;
}
done = true;
break;
}
- if (!isPointBlocked(gridX + gridIncr, gridY + gridIncr) && gnapFindPath1(gridX + gridIncr, gridY + gridIncr, gridIncr)) {
+ if (!_vm->isPointBlocked(gridX + gridIncr, gridY + gridIncr) && findPath1(gridX + gridIncr, gridY + gridIncr, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _gnapWalkNodes[i]._gridX1 = gridX + i;
- _gnapWalkNodes[i]._gridY1 = gridY + i;
- _gnapWalkNodes[i]._deltaX = 1;
- _gnapWalkNodes[i]._deltaY = 1;
+ _walkNodes[i]._gridX1 = gridX + i;
+ _walkNodes[i]._gridY1 = gridY + i;
+ _walkNodes[i]._deltaX = 1;
+ _walkNodes[i]._deltaY = 1;
}
done = true;
break;
}
- if (!isPointBlocked(gridX - gridIncr, gridY + gridIncr) && gnapFindPath1(gridX - gridIncr, gridY + gridIncr, gridIncr)) {
+ if (!_vm->isPointBlocked(gridX - gridIncr, gridY + gridIncr) && findPath1(gridX - gridIncr, gridY + gridIncr, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _gnapWalkNodes[i]._gridX1 = gridX - i;
- _gnapWalkNodes[i]._gridY1 = gridY + i;
- _gnapWalkNodes[i]._deltaX = -1;
- _gnapWalkNodes[i]._deltaY = 1;
+ _walkNodes[i]._gridX1 = gridX - i;
+ _walkNodes[i]._gridY1 = gridY + i;
+ _walkNodes[i]._deltaX = -1;
+ _walkNodes[i]._deltaY = 1;
}
done = true;
break;
}
- if (!isPointBlocked(gridX + gridIncr, gridY - gridIncr) && gnapFindPath1(gridX + gridIncr, gridY - gridIncr, gridIncr)) {
+ if (!_vm->isPointBlocked(gridX + gridIncr, gridY - gridIncr) && findPath1(gridX + gridIncr, gridY - gridIncr, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _gnapWalkNodes[i]._gridX1 = gridX + i;
- _gnapWalkNodes[i]._gridY1 = gridY - i;
- _gnapWalkNodes[i]._deltaX = 1;
- _gnapWalkNodes[i]._deltaY = -1;
+ _walkNodes[i]._gridX1 = gridX + i;
+ _walkNodes[i]._gridY1 = gridY - i;
+ _walkNodes[i]._deltaX = 1;
+ _walkNodes[i]._deltaY = -1;
}
done = true;
break;
}
- if (!isPointBlocked(gridX - gridIncr, gridY - gridIncr) && gnapFindPath1(gridX - gridIncr, gridY - gridIncr, gridIncr)) {
+ if (!_vm->isPointBlocked(gridX - gridIncr, gridY - gridIncr) && findPath1(gridX - gridIncr, gridY - gridIncr, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _gnapWalkNodes[i]._gridX1 = gridX - i;
- _gnapWalkNodes[i]._gridY1 = gridY - i;
- _gnapWalkNodes[i]._deltaX = -1;
- _gnapWalkNodes[i]._deltaY = -1;
+ _walkNodes[i]._gridX1 = gridX - i;
+ _walkNodes[i]._gridY1 = gridY - i;
+ _walkNodes[i]._deltaX = -1;
+ _walkNodes[i]._deltaY = -1;
}
done = true;
break;
}
- if (!isPointBlocked(gridX + gridIncr, gridY) && gnapFindPath2(gridX + gridIncr, gridY, gridIncr)) {
+ if (!_vm->isPointBlocked(gridX + gridIncr, gridY) && findPath2(gridX + gridIncr, gridY, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _gnapWalkNodes[i]._gridX1 = gridX + i;
- _gnapWalkNodes[i]._gridY1 = gridY;
- _gnapWalkNodes[i]._deltaX = 1;
- _gnapWalkNodes[i]._deltaY = 0;
+ _walkNodes[i]._gridX1 = gridX + i;
+ _walkNodes[i]._gridY1 = gridY;
+ _walkNodes[i]._deltaX = 1;
+ _walkNodes[i]._deltaY = 0;
}
done = true;
break;
}
- if (!isPointBlocked(gridX - gridIncr, gridY) && gnapFindPath2(gridX - gridIncr, gridY, gridIncr)) {
+ if (!_vm->isPointBlocked(gridX - gridIncr, gridY) && findPath2(gridX - gridIncr, gridY, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _gnapWalkNodes[i]._gridX1 = gridX - i;
- _gnapWalkNodes[i]._gridY1 = gridY;
- _gnapWalkNodes[i]._deltaX = -1;
- _gnapWalkNodes[i]._deltaY = 0;
+ _walkNodes[i]._gridX1 = gridX - i;
+ _walkNodes[i]._gridY1 = gridY;
+ _walkNodes[i]._deltaX = -1;
+ _walkNodes[i]._deltaY = 0;
}
done = true;
break;
}
- if (!isPointBlocked(gridX, gridY + gridIncr) && gnapFindPath2(gridX, gridY + gridIncr, gridIncr)) {
+ if (!_vm->isPointBlocked(gridX, gridY + gridIncr) && findPath2(gridX, gridY + gridIncr, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _gnapWalkNodes[i]._gridX1 = gridX;
- _gnapWalkNodes[i]._gridY1 = gridY + i;
- _gnapWalkNodes[i]._deltaX = 0;
- _gnapWalkNodes[i]._deltaY = 1;
+ _walkNodes[i]._gridX1 = gridX;
+ _walkNodes[i]._gridY1 = gridY + i;
+ _walkNodes[i]._deltaX = 0;
+ _walkNodes[i]._deltaY = 1;
}
done = true;
break;
}
- if (!isPointBlocked(gridX, gridY - gridIncr) && gnapFindPath2(gridX, gridY - gridIncr, gridIncr)) {
+ if (!_vm->isPointBlocked(gridX, gridY - gridIncr) && findPath2(gridX, gridY - gridIncr, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _gnapWalkNodes[i]._gridX1 = gridX;
- _gnapWalkNodes[i]._gridY1 = gridY - i;
- _gnapWalkNodes[i]._deltaX = 0;
- _gnapWalkNodes[i]._deltaY = -1;
+ _walkNodes[i]._gridX1 = gridX;
+ _walkNodes[i]._gridY1 = gridY - i;
+ _walkNodes[i]._deltaX = 0;
+ _walkNodes[i]._deltaY = -1;
}
done = true;
break;
}
- if (!isPointBlocked(gridX + gridIncr, gridY + gridIncr) && gnapFindPath2(gridX + gridIncr, gridY + gridIncr, gridIncr)) {
+ if (!_vm->isPointBlocked(gridX + gridIncr, gridY + gridIncr) && findPath2(gridX + gridIncr, gridY + gridIncr, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _gnapWalkNodes[i]._gridX1 = gridX + i;
- _gnapWalkNodes[i]._gridY1 = gridY + i;
- _gnapWalkNodes[i]._deltaX = 1;
- _gnapWalkNodes[i]._deltaY = 1;
+ _walkNodes[i]._gridX1 = gridX + i;
+ _walkNodes[i]._gridY1 = gridY + i;
+ _walkNodes[i]._deltaX = 1;
+ _walkNodes[i]._deltaY = 1;
}
done = true;
break;
}
- if (!isPointBlocked(gridX - gridIncr, gridY + gridIncr) && gnapFindPath2(gridX - gridIncr, gridY + gridIncr, gridIncr)) {
+ if (!_vm->isPointBlocked(gridX - gridIncr, gridY + gridIncr) && findPath2(gridX - gridIncr, gridY + gridIncr, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _gnapWalkNodes[i]._gridX1 = gridX - i;
- _gnapWalkNodes[i]._gridY1 = gridY + i;
- _gnapWalkNodes[i]._deltaX = -1;
- _gnapWalkNodes[i]._deltaY = 1;
+ _walkNodes[i]._gridX1 = gridX - i;
+ _walkNodes[i]._gridY1 = gridY + i;
+ _walkNodes[i]._deltaX = -1;
+ _walkNodes[i]._deltaY = 1;
}
done = true;
break;
}
- if (!isPointBlocked(gridX + gridIncr, gridY - gridIncr) && gnapFindPath2(gridX + gridIncr, gridY - gridIncr, gridIncr)) {
+ if (!_vm->isPointBlocked(gridX + gridIncr, gridY - gridIncr) && findPath2(gridX + gridIncr, gridY - gridIncr, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _gnapWalkNodes[i]._gridX1 = gridX + i;
- _gnapWalkNodes[i]._gridY1 = gridY - i;
- _gnapWalkNodes[i]._deltaX = 1;
- _gnapWalkNodes[i]._deltaY = -1;
+ _walkNodes[i]._gridX1 = gridX + i;
+ _walkNodes[i]._gridY1 = gridY - i;
+ _walkNodes[i]._deltaX = 1;
+ _walkNodes[i]._deltaY = -1;
}
done = true;
break;
}
- if (!isPointBlocked(gridX - gridIncr, gridY - gridIncr) && gnapFindPath2(gridX - gridIncr, gridY - gridIncr, gridIncr)) {
+ if (!_vm->isPointBlocked(gridX - gridIncr, gridY - gridIncr) && findPath2(gridX - gridIncr, gridY - gridIncr, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _gnapWalkNodes[i]._gridX1 = gridX - i;
- _gnapWalkNodes[i]._gridY1 = gridY - i;
- _gnapWalkNodes[i]._deltaX = -1;
- _gnapWalkNodes[i]._deltaY = -1;
+ _walkNodes[i]._gridX1 = gridX - i;
+ _walkNodes[i]._gridY1 = gridY - i;
+ _walkNodes[i]._deltaX = -1;
+ _walkNodes[i]._deltaY = -1;
}
done = true;
break;
@@ -531,323 +436,94 @@ bool GnapEngine::gnapFindPath3(int gridX, int gridY) {
return done;
}
-bool GnapEngine::gnapWalkTo(Common::Point gridPos, int animationIndex, int sequenceId, int flags) {
- int datNum = flags & 3;
- bool done = false;
-
- _timers[2] = 200;
- _timers[3] = 300;
-
- int gridX = gridPos.x;
- if (gridX < 0)
- gridX = (_leftClickMouseX - _gridMinX + 37) / 75;
-
- int gridY = gridPos.y;
- if (gridY < 0)
- gridY = (_leftClickMouseY - _gridMinY + 24) / 48;
-
- _gnapWalkDestX = CLIP(gridX, 0, _gridMaxX - 1);
- _gnapWalkDestY = CLIP(gridY, 0, _gridMaxY - 1);
-
- if (animationIndex >= 0 && _gnapWalkDestX == _plat->_pos.x && _gnapWalkDestY == _plat->_pos.y)
- platypusMakeRoom();
-
- // TODO: Simplify the cascade of Ifs
- if (gnapFindPath1(_gnap->_pos.x, _gnap->_pos.y, 0))
- done = true;
-
- if (!done && gnapFindPath2(_gnap->_pos.x, _gnap->_pos.y, 0))
- done = true;
-
- if (!done && gnapFindPath3(_gnap->_pos.x, _gnap->_pos.y))
- done = true;
-
- if (!done && gnapFindPath4(_gnap->_pos.x, _gnap->_pos.y))
- done = true;
-
- gnapIdle();
-
- int gnapSequenceId = _gnap->_sequenceId;
- int gnapId = _gnap->_id;
- int gnapSequenceDatNum = _gnap->_sequenceDatNum;
-
- debugC(kDebugBasic, "_gnapWalkNodesCount: %d", _gnapWalkNodesCount);
-
- for (int index = 0; index < _gnapWalkNodesCount; ++index) {
- _gnapWalkNodes[index]._id = index + 20 * _gnapWalkNodes[index]._gridY1;
- if (_gnapWalkNodes[index]._deltaX == 1 && _gnapWalkNodes[index]._deltaY == 0) {
- if (index % 2) {
- _gameSys->insertSequence(makeRid(datNum, 0x7AB), _gnapWalkNodes[index]._id,
- makeRid(gnapSequenceDatNum, gnapSequenceId), gnapId,
- kSeqScale | kSeqSyncWait, 0, 75 * _gnapWalkNodes[index]._gridX1 - _gnap->_gridX, 48 * _gnapWalkNodes[index]._gridY1 - _gnap->_gridY);
- _gnapWalkNodes[index]._sequenceId = 0x7AB;
- gnapSequenceId = 0x7AB;
- } else {
- _gameSys->insertSequence(makeRid(datNum, 0x7AC), _gnapWalkNodes[index]._id,
- makeRid(gnapSequenceDatNum, gnapSequenceId), gnapId,
- kSeqScale | kSeqSyncWait, 0, 75 * _gnapWalkNodes[index]._gridX1 - _gnap->_gridX, 48 * _gnapWalkNodes[index]._gridY1 - _gnap->_gridY);
- _gnapWalkNodes[index]._sequenceId = 0x7AC;
- gnapSequenceId = 0x7AC;
- }
- } else if (_gnapWalkNodes[index]._deltaX == -1 && _gnapWalkNodes[index]._deltaY == 0) {
- if (index % 2) {
- _gameSys->insertSequence(makeRid(datNum, 0x7AF), _gnapWalkNodes[index]._id,
- makeRid(gnapSequenceDatNum, gnapSequenceId), gnapId,
- kSeqScale | kSeqSyncWait, 0, 75 * _gnapWalkNodes[index]._gridX1 - _gnap->_gridX, 48 * _gnapWalkNodes[index]._gridY1 - _gnap->_gridY);
- _gnapWalkNodes[index]._sequenceId = 0x7AF;
- gnapSequenceId = 0x7AF;
- } else {
- _gameSys->insertSequence(makeRid(datNum, 0x7B0), _gnapWalkNodes[index]._id,
- makeRid(gnapSequenceDatNum, gnapSequenceId), gnapId,
- kSeqScale | kSeqSyncWait, 0, 75 * _gnapWalkNodes[index]._gridX1 - _gnap->_gridX, 48 * _gnapWalkNodes[index]._gridY1 - _gnap->_gridY);
- _gnapWalkNodes[index]._sequenceId = 0x7B0;
- gnapSequenceId = 0x7B0;
- }
- } else {
- if (_gnapWalkNodes[index]._deltaY == -1)
- _gnapWalkNodes[index]._id -= 10;
- else
- _gnapWalkNodes[index]._id += 10;
- int newSequenceId = _gnap->getWalkSequenceId(_gnapWalkNodes[index]._deltaX, _gnapWalkNodes[index]._deltaY);
- _gameSys->insertSequence(makeRid(datNum, newSequenceId), _gnapWalkNodes[index]._id,
- makeRid(gnapSequenceDatNum, gnapSequenceId), gnapId,
- kSeqScale | kSeqSyncWait, 0, 75 * _gnapWalkNodes[index]._gridX1 - _gnap->_gridX, 48 * _gnapWalkNodes[index]._gridY1 - _gnap->_gridY);
- _gnapWalkNodes[index]._sequenceId = newSequenceId;
- gnapSequenceId = newSequenceId;
- }
- gnapId = _gnapWalkNodes[index]._id;
- gnapSequenceDatNum = datNum;
- }
-
- if (flags & 8) {
- if (_gnapWalkNodesCount > 0) {
- _gnap->_sequenceId = gnapSequenceId;
- _gnap->_id = gnapId;
- _gnap->_idleFacing = getGnapWalkFacing(_gnapWalkNodes[_gnapWalkNodesCount - 1]._deltaX, _gnapWalkNodes[_gnapWalkNodesCount - 1]._deltaY);
- _gnap->_sequenceDatNum = datNum;
- if (animationIndex >= 0)
- _gameSys->setAnimation(makeRid(_gnap->_sequenceDatNum, _gnap->_sequenceId), _gnap->_id, animationIndex);
- } else if (animationIndex >= 0) {
- _gameSys->setAnimation(0x107D3, 1, animationIndex);
- _gameSys->insertSequence(0x107D3, 1, 0, 0, kSeqNone, 0, 0, 0);
- }
- } else {
- if (sequenceId >= 0 && sequenceId != -1) {
- _gnap->_sequenceId = ridToEntryIndex(sequenceId);
- _gnap->_sequenceDatNum = ridToDatIndex(sequenceId);
- if (_gnap->_sequenceId == 0x7B9) {
- _gnap->_idleFacing = kDirBottomRight;
- } else {
- switch (_gnap->_sequenceId) {
- case 0x7BA:
- _gnap->_idleFacing = kDirBottomLeft;
- break;
- case 0x7BB:
- _gnap->_idleFacing = kDirUpRight;
- break;
- case 0x7BC:
- _gnap->_idleFacing = kDirUpLeft;
- break;
- }
- }
- } else {
- if (_gnapWalkNodesCount > 0) {
- _gnap->_sequenceId = getGnapWalkStopSequenceId(_gnapWalkNodes[_gnapWalkNodesCount - 1]._deltaX, _gnapWalkNodes[_gnapWalkNodesCount - 1]._deltaY);
- _gnap->_idleFacing = getGnapWalkFacing(_gnapWalkNodes[_gnapWalkNodesCount - 1]._deltaX, _gnapWalkNodes[_gnapWalkNodesCount - 1]._deltaY);
- } else if (gridX >= 0 || gridY >= 0) {
- switch (_gnap->_idleFacing) {
- case kDirBottomRight:
- _gnap->_sequenceId = 0x7B9;
- break;
- case kDirBottomLeft:
- _gnap->_sequenceId = 0x7BA;
- break;
- case kDirUpRight:
- _gnap->_sequenceId = 0x7BB;
- break;
- default:
- _gnap->_sequenceId = 0x7BC;
- break;
- }
- } else {
- //TODO: simplify the checks by using v10 and v11
- int v10 = _leftClickMouseX - (_gridMinX + 75 * _gnap->_pos.x);
- int v11 = _leftClickMouseY - (_gridMinY + 48 * _gnap->_pos.y);
- if (_leftClickMouseX == _gridMinX + 75 * _gnap->_pos.x)
- ++v10;
- if (_leftClickMouseY == _gridMinY + 48 * _gnap->_pos.y)
- v11 = 1;
- _gnap->_sequenceId = getGnapWalkStopSequenceId(v10 / abs(v10), v11 / abs(v11));
- _gnap->_idleFacing = getGnapWalkFacing(v10 / abs(v10), v11 / abs(v11));
- }
- _gnap->_sequenceDatNum = datNum;
- }
-
- if (animationIndex < 0) {
- _gnap->_id = 20 * _gnapWalkDestY + 1;
- } else {
- _gnap->_id = _gnapWalkNodesCount + animationIndex + 20 * _gnapWalkDestY;
- _gameSys->setAnimation(makeRid(_gnap->_sequenceDatNum, _gnap->_sequenceId), _gnapWalkNodesCount + animationIndex + 20 * _gnapWalkDestY, animationIndex);
- }
-
- if (flags & 4) {
- _gameSys->insertSequence(makeRid(_gnap->_sequenceDatNum, _gnap->_sequenceId), _gnap->_id,
- makeRid(gnapSequenceDatNum, gnapSequenceId), gnapId,
- kSeqScale | kSeqSyncWait, 0, 0, 0);
- } else {
- _gameSys->insertSequence(makeRid(_gnap->_sequenceDatNum, _gnap->_sequenceId), _gnap->_id,
- makeRid(gnapSequenceDatNum, gnapSequenceId), gnapId,
- kSeqScale | kSeqSyncWait, 0, 75 * _gnapWalkDestX - _gnap->_gridX, 48 * _gnapWalkDestY - _gnap->_gridY);
- }
- }
-
- _gnap->_pos = Common::Point(_gnapWalkDestX, _gnapWalkDestY);
-
- return done;
-}
-
-void GnapEngine::gnapWalkStep() {
- for (int i = 1; i < _gridMaxX; ++i) {
- Common::Point checkPt = Common::Point(_gnap->_pos.x + i, _gnap->_pos.y);
- if (!isPointBlocked(checkPt)) {
- gnapWalkTo(checkPt, -1, -1, 1);
- break;
- }
-
- checkPt = Common::Point(_gnap->_pos.x - i, _gnap->_pos.y);
- if (!isPointBlocked(checkPt)) {
- gnapWalkTo(checkPt, -1, -1, 1);
- break;
- }
-
- checkPt = Common::Point(_gnap->_pos.x, _gnap->_pos.y + 1);
- if (!isPointBlocked(checkPt)) {
- gnapWalkTo(checkPt, -1, -1, 1);
- break;
- }
-
- checkPt = Common::Point(_gnap->_pos.x, _gnap->_pos.y - 1);
- if (!isPointBlocked(checkPt)) {
- gnapWalkTo(checkPt, -1, -1, 1);
- break;
- }
-
- checkPt = Common::Point(_gnap->_pos.x + 1, _gnap->_pos.y + 1);
- if (!isPointBlocked(checkPt)) {
- gnapWalkTo(checkPt, -1, -1, 1);
- break;
- }
-
- checkPt = Common::Point(_gnap->_pos.x - 1, _gnap->_pos.y + 1);
- if (!isPointBlocked(checkPt)) {
- gnapWalkTo(checkPt, -1, -1, 1);
- break;
- }
-
- checkPt = Common::Point(_gnap->_pos.x + 1, _gnap->_pos.y - 1);
- if (!isPointBlocked(checkPt)) {
- gnapWalkTo(checkPt, -1, -1, 1);
- break;
- }
-
- checkPt = Common::Point(_gnap->_pos.x - 1, _gnap->_pos.y - 1);
- if (!isPointBlocked(checkPt)) {
- gnapWalkTo(checkPt, -1, -1, 1);
- break;
- }
- }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-bool GnapEngine::platFindPath4(int gridX, int gridY) {
+bool PlayerGnap::findPath4(int gridX, int gridY) {
bool result = false;
- _platWalkNodesCount = 0;
- _platWalkDirXIncr = 0;
- _platWalkDirYIncr = 0;
- _platWalkDeltaX = ABS(_platWalkDestX - gridX);
- _platWalkDeltaY = ABS(_platWalkDestY - gridY);
+ _walkNodesCount = 0;
+ _walkDirXIncr = 0;
+ _walkDirYIncr = 0;
+ _walkDeltaX = ABS(_walkDestX - gridX);
+ _walkDeltaY = ABS(_walkDestY - gridY);
- if (_platWalkDeltaX)
- _platWalkDirX = (_platWalkDestX - gridX) / _platWalkDeltaX;
+ if (_walkDeltaX)
+ _walkDirX = (_walkDestX - gridX) / _walkDeltaX;
else
- _platWalkDirX = 0;
+ _walkDirX = 0;
- if (_platWalkDeltaY)
- _platWalkDirY = (_platWalkDestY - gridY) / _platWalkDeltaY;
+ if (_walkDeltaY)
+ _walkDirY = (_walkDestY - gridY) / _walkDeltaY;
else
- _platWalkDirY = 0;
-
- while (_platWalkDirXIncr < _platWalkDeltaX && _platWalkDirYIncr < _platWalkDeltaY) {
- _platWalkNodes[_platWalkNodesCount]._gridX1 = gridX + _platWalkDirX * _platWalkDirXIncr;
- _platWalkNodes[_platWalkNodesCount]._gridY1 = gridY + _platWalkDirY * _platWalkDirYIncr;
- if (!isPointBlocked(_platWalkDirX + _platWalkNodes[_platWalkNodesCount]._gridX1, _platWalkDirY + _platWalkNodes[_platWalkNodesCount]._gridY1)) {
- _platWalkNodes[_platWalkNodesCount]._deltaX = _platWalkDirX;
- _platWalkNodes[_platWalkNodesCount]._deltaY = _platWalkDirY;
- ++_platWalkDirXIncr;
- ++_platWalkDirYIncr;
- } else if (_platWalkDeltaY - _platWalkDirYIncr > _platWalkDeltaX - _platWalkDirXIncr) {
- if (!isPointBlocked(_platWalkNodes[_platWalkNodesCount]._gridX1, _platWalkDirY + _platWalkNodes[_platWalkNodesCount]._gridY1)) {
- _platWalkNodes[_platWalkNodesCount]._deltaX = 0;
- _platWalkNodes[_platWalkNodesCount]._deltaY = _platWalkDirY;
- ++_platWalkDirYIncr;
- } else if (!isPointBlocked(_platWalkDirX + _platWalkNodes[_platWalkNodesCount]._gridX1, _platWalkNodes[_platWalkNodesCount]._gridY1)) {
- _platWalkNodes[_platWalkNodesCount]._deltaX = _platWalkDirX;
- _platWalkNodes[_platWalkNodesCount]._deltaY = 0;
- ++_platWalkDirXIncr;
+ _walkDirY = 0;
+
+ while (_walkDirXIncr < _walkDeltaX && _walkDirYIncr < _walkDeltaY) {
+ _walkNodes[_walkNodesCount]._gridX1 = gridX + _walkDirX * _walkDirXIncr;
+ _walkNodes[_walkNodesCount]._gridY1 = gridY + _walkDirY * _walkDirYIncr;
+ if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
+ _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
+ ++_walkDirXIncr;
+ ++_walkDirYIncr;
+ } else if (_walkDeltaY - _walkDirYIncr > _walkDeltaX - _walkDirXIncr) {
+ if (!_vm->isPointBlocked(_walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = 0;
+ _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
+ ++_walkDirYIncr;
+ } else if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
+ _walkNodes[_walkNodesCount]._deltaY = 0;
+ ++_walkDirXIncr;
} else {
- _platWalkDeltaX = _platWalkDirXIncr;
- _platWalkDeltaY = _platWalkDirYIncr;
- --_platWalkNodesCount;
+ _walkDeltaX = _walkDirXIncr;
+ _walkDeltaY = _walkDirYIncr;
+ --_walkNodesCount;
}
} else {
- if (!isPointBlocked(_platWalkDirX + _platWalkNodes[_platWalkNodesCount]._gridX1, _platWalkNodes[_platWalkNodesCount]._gridY1)) {
- _platWalkNodes[_platWalkNodesCount]._deltaX = _platWalkDirX;
- _platWalkNodes[_platWalkNodesCount]._deltaY = 0;
- ++_platWalkDirXIncr;
- } else if (!isPointBlocked(_platWalkNodes[_platWalkNodesCount]._gridX1, _platWalkDirY + _platWalkNodes[_platWalkNodesCount]._gridY1)) {
- _platWalkNodes[_platWalkNodesCount]._deltaX = 0;
- _platWalkNodes[_platWalkNodesCount]._deltaY = _platWalkDirY;
- ++_platWalkDirYIncr;
+ if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
+ _walkNodes[_walkNodesCount]._deltaY = 0;
+ ++_walkDirXIncr;
+ } else if (!_vm->isPointBlocked(_walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = 0;
+ _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
+ ++_walkDirYIncr;
} else {
- _platWalkDeltaX = _platWalkDirXIncr;
- _platWalkDeltaY = _platWalkDirYIncr;
- --_platWalkNodesCount;
+ _walkDeltaX = _walkDirXIncr;
+ _walkDeltaY = _walkDirYIncr;
+ --_walkNodesCount;
}
}
- ++_platWalkNodesCount;
+ ++_walkNodesCount;
}
- while (_platWalkDirXIncr < _platWalkDeltaX) {
- _platWalkNodes[_platWalkNodesCount]._gridX1 = gridX + _platWalkDirX * _platWalkDirXIncr;
- _platWalkNodes[_platWalkNodesCount]._gridY1 = _platWalkDestY;
- if (!isPointBlocked(_platWalkDirX + _platWalkNodes[_platWalkNodesCount]._gridX1, _platWalkDestY)) {
- _platWalkNodes[_platWalkNodesCount]._deltaX = _platWalkDirX;
- _platWalkNodes[_platWalkNodesCount]._deltaY = 0;
- ++_platWalkDirXIncr;
- ++_platWalkNodesCount;
+ while (_walkDirXIncr < _walkDeltaX) {
+ _walkNodes[_walkNodesCount]._gridX1 = gridX + _walkDirX * _walkDirXIncr;
+ _walkNodes[_walkNodesCount]._gridY1 = _walkDestY;
+ if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkDestY)) {
+ _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
+ _walkNodes[_walkNodesCount]._deltaY = 0;
+ ++_walkDirXIncr;
+ ++_walkNodesCount;
} else {
- _platWalkDeltaX = _platWalkDirXIncr;
+ _walkDeltaX = _walkDirXIncr;
}
}
- while (_platWalkDirYIncr < _platWalkDeltaY) {
- _platWalkNodes[_platWalkNodesCount]._gridX1 = _platWalkDestX;
- _platWalkNodes[_platWalkNodesCount]._gridY1 = gridY + _platWalkDirY * _platWalkDirYIncr;
- if (!isPointBlocked(_platWalkDestX, _platWalkDirY + _platWalkNodes[_platWalkNodesCount]._gridY1)) {
- _platWalkNodes[_platWalkNodesCount]._deltaX = 0;
- _platWalkNodes[_platWalkNodesCount]._deltaY = _platWalkDirY;
- ++_platWalkDirYIncr;
- ++_platWalkNodesCount;
+ while (_walkDirYIncr < _walkDeltaY) {
+ _walkNodes[_walkNodesCount]._gridX1 = _walkDestX;
+ _walkNodes[_walkNodesCount]._gridY1 = gridY + _walkDirY * _walkDirYIncr;
+ if (!_vm->isPointBlocked(_walkDestX, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = 0;
+ _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
+ ++_walkDirYIncr;
+ ++_walkNodesCount;
} else {
- _platWalkDeltaY = _platWalkDirYIncr;
+ _walkDeltaY = _walkDirYIncr;
}
}
- if (gridX + _platWalkDirX * _platWalkDirXIncr != _platWalkDestX || gridY + _platWalkDirY * _platWalkDirYIncr != _platWalkDestY) {
- _platWalkDestX = gridX + _platWalkDirX * _platWalkDirXIncr;
- _platWalkDestY = gridY + _platWalkDirY * _platWalkDirYIncr;
+ if (gridX + _walkDirX * _walkDirXIncr != _walkDestX || gridY + _walkDirY * _walkDirYIncr != _walkDestY) {
+ _walkDestX = gridX + _walkDirX * _walkDirXIncr;
+ _walkDestY = gridY + _walkDirY * _walkDirYIncr;
result = false;
} else {
result = true;
@@ -856,77 +532,79 @@ bool GnapEngine::platFindPath4(int gridX, int gridY) {
return result;
}
-bool GnapEngine::platFindPath1(int gridX, int gridY, int index) {
- _platWalkNodesCount = index;
- _platWalkDirXIncr = 0;
- _platWalkDirYIncr = 0;
- _platWalkDeltaX = ABS(_platWalkDestX - gridX);
- _platWalkDeltaY = ABS(_platWalkDestY - gridY);
+/******************************************************************************/
- if (_platWalkDeltaX)
- _platWalkDirX = (_platWalkDestX - gridX) / _platWalkDeltaX;
+bool PlayerPlat::findPath1(int gridX, int gridY, int index) {
+ _walkNodesCount = index;
+ _walkDirXIncr = 0;
+ _walkDirYIncr = 0;
+ _walkDeltaX = ABS(_walkDestX - gridX);
+ _walkDeltaY = ABS(_walkDestY - gridY);
+
+ if (_walkDeltaX)
+ _walkDirX = (_walkDestX - gridX) / _walkDeltaX;
else
- _platWalkDirX = 0;
+ _walkDirX = 0;
- if (_platWalkDeltaY)
- _platWalkDirY = (_platWalkDestY - gridY) / _platWalkDeltaY;
+ if (_walkDeltaY)
+ _walkDirY = (_walkDestY - gridY) / _walkDeltaY;
else
- _platWalkDirY = 0;
-
- while (_platWalkDirXIncr < _platWalkDeltaX && _platWalkDirYIncr < _platWalkDeltaY) {
- _platWalkNodes[_platWalkNodesCount]._gridX1 = gridX + _platWalkDirX * _platWalkDirXIncr;
- _platWalkNodes[_platWalkNodesCount]._gridY1 = gridY + _platWalkDirY * _platWalkDirYIncr;
- if (!isPointBlocked(_platWalkDirX + _platWalkNodes[_platWalkNodesCount]._gridX1, _platWalkDirY + _platWalkNodes[_platWalkNodesCount]._gridY1)) {
- _platWalkNodes[_platWalkNodesCount]._deltaX = _platWalkDirX;
- _platWalkNodes[_platWalkNodesCount]._deltaY = _platWalkDirY;
- ++_platWalkDirXIncr;
- ++_platWalkDirYIncr;
- } else if (_platWalkDeltaY - _platWalkDirYIncr > _platWalkDeltaX - _platWalkDirXIncr) {
- if (!isPointBlocked(_platWalkNodes[_platWalkNodesCount]._gridX1, _platWalkDirY + _platWalkNodes[_platWalkNodesCount]._gridY1)) {
- _platWalkNodes[_platWalkNodesCount]._deltaX = 0;
- _platWalkNodes[_platWalkNodesCount]._deltaY = _platWalkDirY;
- ++_platWalkDirYIncr;
- } else if (!isPointBlocked(_platWalkDirX + _platWalkNodes[_platWalkNodesCount]._gridX1, _platWalkNodes[_platWalkNodesCount]._gridY1)) {
- _platWalkNodes[_platWalkNodesCount]._deltaX = _platWalkDirX;
- _platWalkNodes[_platWalkNodesCount]._deltaY = 0;
- ++_platWalkDirXIncr;
+ _walkDirY = 0;
+
+ while (_walkDirXIncr < _walkDeltaX && _walkDirYIncr < _walkDeltaY) {
+ _walkNodes[_walkNodesCount]._gridX1 = gridX + _walkDirX * _walkDirXIncr;
+ _walkNodes[_walkNodesCount]._gridY1 = gridY + _walkDirY * _walkDirYIncr;
+ if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
+ _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
+ ++_walkDirXIncr;
+ ++_walkDirYIncr;
+ } else if (_walkDeltaY - _walkDirYIncr > _walkDeltaX - _walkDirXIncr) {
+ if (!_vm->isPointBlocked(_walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = 0;
+ _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
+ ++_walkDirYIncr;
+ } else if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
+ _walkNodes[_walkNodesCount]._deltaY = 0;
+ ++_walkDirXIncr;
} else
return false;
} else {
- if (!isPointBlocked(_platWalkDirX + _platWalkNodes[_platWalkNodesCount]._gridX1, _platWalkNodes[_platWalkNodesCount]._gridY1)) {
- _platWalkNodes[_platWalkNodesCount]._deltaX = _platWalkDirX;
- _platWalkNodes[_platWalkNodesCount]._deltaY = 0;
- ++_platWalkDirXIncr;
- } else if (!isPointBlocked(_platWalkNodes[_platWalkNodesCount]._gridX1, _platWalkDirY + _platWalkNodes[_platWalkNodesCount]._gridY1)) {
- _platWalkNodes[_platWalkNodesCount]._deltaX = 0;
- _platWalkNodes[_platWalkNodesCount]._deltaY = _platWalkDirY;
- ++_platWalkDirYIncr;
+ if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
+ _walkNodes[_walkNodesCount]._deltaY = 0;
+ ++_walkDirXIncr;
+ } else if (!_vm->isPointBlocked(_walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = 0;
+ _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
+ ++_walkDirYIncr;
} else
return false;
}
- ++_platWalkNodesCount;
+ ++_walkNodesCount;
}
- while (_platWalkDirXIncr < _platWalkDeltaX) {
- _platWalkNodes[_platWalkNodesCount]._gridX1 = gridX + _platWalkDirX * _platWalkDirXIncr;
- _platWalkNodes[_platWalkNodesCount]._gridY1 = _platWalkDestY;
- if (!isPointBlocked(_platWalkDirX + _platWalkNodes[_platWalkNodesCount]._gridX1, _platWalkDestY)) {
- _platWalkNodes[_platWalkNodesCount]._deltaX = _platWalkDirX;
- _platWalkNodes[_platWalkNodesCount]._deltaY = 0;
- ++_platWalkDirXIncr;
- ++_platWalkNodesCount;
+ while (_walkDirXIncr < _walkDeltaX) {
+ _walkNodes[_walkNodesCount]._gridX1 = gridX + _walkDirX * _walkDirXIncr;
+ _walkNodes[_walkNodesCount]._gridY1 = _walkDestY;
+ if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkDestY)) {
+ _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
+ _walkNodes[_walkNodesCount]._deltaY = 0;
+ ++_walkDirXIncr;
+ ++_walkNodesCount;
} else
return false;
}
- while (_platWalkDirYIncr < _platWalkDeltaY) {
- _platWalkNodes[_platWalkNodesCount]._gridX1 = _platWalkDestX;
- _platWalkNodes[_platWalkNodesCount]._gridY1 = gridY + _platWalkDirY * _platWalkDirYIncr;
- if (!isPointBlocked(_platWalkDestX, _platWalkDirY + _platWalkNodes[_platWalkNodesCount]._gridY1)) {
- _platWalkNodes[_platWalkNodesCount]._deltaX = 0;
- _platWalkNodes[_platWalkNodesCount]._deltaY = _platWalkDirY;
- ++_platWalkDirYIncr;
- ++_platWalkNodesCount;
+ while (_walkDirYIncr < _walkDeltaY) {
+ _walkNodes[_walkNodesCount]._gridX1 = _walkDestX;
+ _walkNodes[_walkNodesCount]._gridY1 = gridY + _walkDirY * _walkDirYIncr;
+ if (!_vm->isPointBlocked(_walkDestX, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = 0;
+ _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
+ ++_walkDirYIncr;
+ ++_walkNodesCount;
} else
return false;
}
@@ -934,101 +612,101 @@ bool GnapEngine::platFindPath1(int gridX, int gridY, int index) {
return true;
}
-bool GnapEngine::platFindPath2(int gridX, int gridY, int index) {
- _platWalkNodesCount = index;
- _platWalkDirXIncr = 0;
- _platWalkDirYIncr = 0;
- _platWalkDeltaX = ABS(_platWalkDestX - gridX);
- _platWalkDeltaY = ABS(_platWalkDestY - gridY);
+bool PlayerPlat::findPath2(int gridX, int gridY, int index) {
+ _walkNodesCount = index;
+ _walkDirXIncr = 0;
+ _walkDirYIncr = 0;
+ _walkDeltaX = ABS(_walkDestX - gridX);
+ _walkDeltaY = ABS(_walkDestY - gridY);
- if (_platWalkDeltaX)
- _platWalkDirX = (_platWalkDestX - gridX) / _platWalkDeltaX;
+ if (_walkDeltaX)
+ _walkDirX = (_walkDestX - gridX) / _walkDeltaX;
else
- _platWalkDirX = 0;
+ _walkDirX = 0;
- if (_platWalkDeltaY)
- _platWalkDirY = (_platWalkDestY - gridY) / _platWalkDeltaY;
+ if (_walkDeltaY)
+ _walkDirY = (_walkDestY - gridY) / _walkDeltaY;
else
- _platWalkDirY = 0;
-
- while (_platWalkDeltaY < _platWalkDeltaX - _platWalkDirXIncr) {
- _platWalkNodes[_platWalkNodesCount]._gridX1 = gridX + _platWalkDirX * _platWalkDirXIncr;
- _platWalkNodes[_platWalkNodesCount]._gridY1 = gridY;
- if (!isPointBlocked(_platWalkDirX + _platWalkNodes[_platWalkNodesCount]._gridX1, gridY)) {
- _platWalkNodes[_platWalkNodesCount]._deltaX = _platWalkDirX;
- _platWalkNodes[_platWalkNodesCount]._deltaY = 0;
- ++_platWalkDirXIncr;
- ++_platWalkNodesCount;
+ _walkDirY = 0;
+
+ while (_walkDeltaY < _walkDeltaX - _walkDirXIncr) {
+ _walkNodes[_walkNodesCount]._gridX1 = gridX + _walkDirX * _walkDirXIncr;
+ _walkNodes[_walkNodesCount]._gridY1 = gridY;
+ if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, gridY)) {
+ _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
+ _walkNodes[_walkNodesCount]._deltaY = 0;
+ ++_walkDirXIncr;
+ ++_walkNodesCount;
} else
return false;
}
- while (_platWalkDeltaX < _platWalkDeltaY - _platWalkDirYIncr) {
- _platWalkNodes[_platWalkNodesCount]._gridX1 = gridX;
- _platWalkNodes[_platWalkNodesCount]._gridY1 = gridY + _platWalkDirY * _platWalkDirYIncr;
- if (!isPointBlocked(gridX, _platWalkDirY + _platWalkNodes[_platWalkNodesCount]._gridY1)) {
- _platWalkNodes[_platWalkNodesCount]._deltaX = 0;
- _platWalkNodes[_platWalkNodesCount]._deltaY = _platWalkDirY;
- ++_platWalkDirYIncr;
- ++_platWalkNodesCount;
+ while (_walkDeltaX < _walkDeltaY - _walkDirYIncr) {
+ _walkNodes[_walkNodesCount]._gridX1 = gridX;
+ _walkNodes[_walkNodesCount]._gridY1 = gridY + _walkDirY * _walkDirYIncr;
+ if (!_vm->isPointBlocked(gridX, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = 0;
+ _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
+ ++_walkDirYIncr;
+ ++_walkNodesCount;
} else
return false;
}
- while (_platWalkDirXIncr < _platWalkDeltaX && _platWalkDirYIncr < _platWalkDeltaY) {
- _platWalkNodes[_platWalkNodesCount]._gridX1 = gridX + _platWalkDirX * _platWalkDirXIncr;
- _platWalkNodes[_platWalkNodesCount]._gridY1 = gridY + _platWalkDirY * _platWalkDirYIncr;
- if (!isPointBlocked(_platWalkDirX + _platWalkNodes[_platWalkNodesCount]._gridX1, _platWalkDirY + _platWalkNodes[_platWalkNodesCount]._gridY1)) {
- _platWalkNodes[_platWalkNodesCount]._deltaX = _platWalkDirX;
- _platWalkNodes[_platWalkNodesCount]._deltaY = _platWalkDirY;
- ++_platWalkDirXIncr;
- ++_platWalkDirYIncr;
- } else if (_platWalkDeltaY - _platWalkDirYIncr > _platWalkDeltaX - _platWalkDirXIncr) {
- if (!isPointBlocked(_platWalkNodes[_platWalkNodesCount]._gridX1, _platWalkDirY + _platWalkNodes[_platWalkNodesCount]._gridY1)) {
- _platWalkNodes[_platWalkNodesCount]._deltaX = 0;
- _platWalkNodes[_platWalkNodesCount]._deltaY = _platWalkDirY;
- ++_platWalkDirYIncr;
- } else if (!isPointBlocked(_platWalkDirX + _platWalkNodes[_platWalkNodesCount]._gridX1, _platWalkNodes[_platWalkNodesCount]._gridY1)) {
- _platWalkNodes[_platWalkNodesCount]._deltaX = _platWalkDirX;
- _platWalkNodes[_platWalkNodesCount]._deltaY = 0;
- ++_platWalkDirXIncr;
+ while (_walkDirXIncr < _walkDeltaX && _walkDirYIncr < _walkDeltaY) {
+ _walkNodes[_walkNodesCount]._gridX1 = gridX + _walkDirX * _walkDirXIncr;
+ _walkNodes[_walkNodesCount]._gridY1 = gridY + _walkDirY * _walkDirYIncr;
+ if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
+ _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
+ ++_walkDirXIncr;
+ ++_walkDirYIncr;
+ } else if (_walkDeltaY - _walkDirYIncr > _walkDeltaX - _walkDirXIncr) {
+ if (!_vm->isPointBlocked(_walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = 0;
+ _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
+ ++_walkDirYIncr;
+ } else if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
+ _walkNodes[_walkNodesCount]._deltaY = 0;
+ ++_walkDirXIncr;
} else
return false;
} else {
- if (!isPointBlocked(_platWalkDirX + _platWalkNodes[_platWalkNodesCount]._gridX1, _platWalkNodes[_platWalkNodesCount]._gridY1)) {
- _platWalkNodes[_platWalkNodesCount]._deltaX = _platWalkDirX;
- _platWalkNodes[_platWalkNodesCount]._deltaY = 0;
- ++_platWalkDirXIncr;
- } else if (!isPointBlocked(_platWalkNodes[_platWalkNodesCount]._gridX1, _platWalkDirY + _platWalkNodes[_platWalkNodesCount]._gridY1)) {
- _platWalkNodes[_platWalkNodesCount]._deltaX = 0;
- _platWalkNodes[_platWalkNodesCount]._deltaY = _platWalkDirY;
- ++_platWalkDirYIncr;
+ if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
+ _walkNodes[_walkNodesCount]._deltaY = 0;
+ ++_walkDirXIncr;
+ } else if (!_vm->isPointBlocked(_walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = 0;
+ _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
+ ++_walkDirYIncr;
} else
return false;
}
- ++_platWalkNodesCount;
+ ++_walkNodesCount;
}
- while (_platWalkDirXIncr < _platWalkDeltaX) {
- _platWalkNodes[_platWalkNodesCount]._gridX1 = gridX + _platWalkDirX * _platWalkDirXIncr;
- _platWalkNodes[_platWalkNodesCount]._gridY1 = _platWalkDestY;
- if (!isPointBlocked(_platWalkDirX + _platWalkNodes[_platWalkNodesCount]._gridX1, _platWalkDestY)) {
- _platWalkNodes[_platWalkNodesCount]._deltaX = _platWalkDirX;
- _platWalkNodes[_platWalkNodesCount]._deltaY = 0;
- ++_platWalkDirXIncr;
- ++_platWalkNodesCount;
+ while (_walkDirXIncr < _walkDeltaX) {
+ _walkNodes[_walkNodesCount]._gridX1 = gridX + _walkDirX * _walkDirXIncr;
+ _walkNodes[_walkNodesCount]._gridY1 = _walkDestY;
+ if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkDestY)) {
+ _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
+ _walkNodes[_walkNodesCount]._deltaY = 0;
+ ++_walkDirXIncr;
+ ++_walkNodesCount;
} else
return false;
}
- while (_platWalkDirYIncr < _platWalkDeltaY) {
- _platWalkNodes[_platWalkNodesCount]._gridX1 = _platWalkDestX;
- _platWalkNodes[_platWalkNodesCount]._gridY1 = gridY + _platWalkDirY * _platWalkDirYIncr;
- if (!isPointBlocked(_platWalkDestX, _platWalkDirY + _platWalkNodes[_platWalkNodesCount]._gridY1)) {
- _platWalkNodes[_platWalkNodesCount]._deltaX = 0;
- _platWalkNodes[_platWalkNodesCount]._deltaY = _platWalkDirY;
- ++_platWalkDirYIncr;
- ++_platWalkNodesCount;
+ while (_walkDirYIncr < _walkDeltaY) {
+ _walkNodes[_walkNodesCount]._gridX1 = _walkDestX;
+ _walkNodes[_walkNodesCount]._gridY1 = gridY + _walkDirY * _walkDirYIncr;
+ if (!_vm->isPointBlocked(_walkDestX, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = 0;
+ _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
+ ++_walkDirYIncr;
+ ++_walkNodesCount;
} else
return false;
}
@@ -1036,167 +714,167 @@ bool GnapEngine::platFindPath2(int gridX, int gridY, int index) {
return true;
}
-bool GnapEngine::platFindPath3(int gridX, int gridY) {
+bool PlayerPlat::findPath3(int gridX, int gridY) {
int gridIncr = 1;
bool done = false;
- while (!done && gridIncr < _gridMaxX) {
- if (!isPointBlocked(_plat->_pos.x + gridIncr, _plat->_pos.y) && platFindPath1(_plat->_pos.x + gridIncr, _plat->_pos.y, gridIncr)) {
+ while (!done && gridIncr < _vm->_gridMaxX) {
+ if (!_vm->isPointBlocked(_pos.x + gridIncr, _pos.y) && findPath1(_pos.x + gridIncr, _pos.y, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _platWalkNodes[i]._gridX1 = _plat->_pos.x + i;
- _platWalkNodes[i]._gridY1 = _plat->_pos.y;
- _platWalkNodes[i]._deltaX = 1;
- _platWalkNodes[i]._deltaY = 0;
+ _walkNodes[i]._gridX1 = _pos.x + i;
+ _walkNodes[i]._gridY1 = _pos.y;
+ _walkNodes[i]._deltaX = 1;
+ _walkNodes[i]._deltaY = 0;
}
done = true;
break;
}
- if (!isPointBlocked(_plat->_pos.x - gridIncr, _plat->_pos.y) && platFindPath1(_plat->_pos.x - gridIncr, _plat->_pos.y, gridIncr)) {
+ if (!_vm->isPointBlocked(_pos.x - gridIncr, _pos.y) && findPath1(_pos.x - gridIncr, _pos.y, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _platWalkNodes[i]._gridX1 = _plat->_pos.x - i;
- _platWalkNodes[i]._gridY1 = _plat->_pos.y;
- _platWalkNodes[i]._deltaX = -1;
- _platWalkNodes[i]._deltaY = 0;
+ _walkNodes[i]._gridX1 = _pos.x - i;
+ _walkNodes[i]._gridY1 = _pos.y;
+ _walkNodes[i]._deltaX = -1;
+ _walkNodes[i]._deltaY = 0;
}
done = true;
break;
}
- if (!isPointBlocked(_plat->_pos.x, _plat->_pos.y + gridIncr) && platFindPath1(_plat->_pos.x, _plat->_pos.y + gridIncr, gridIncr)) {
+ if (!_vm->isPointBlocked(_pos.x, _pos.y + gridIncr) && findPath1(_pos.x, _pos.y + gridIncr, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _platWalkNodes[i]._gridX1 = _plat->_pos.x;
- _platWalkNodes[i]._gridY1 = _plat->_pos.y + i;
- _platWalkNodes[i]._deltaX = 0;
- _platWalkNodes[i]._deltaY = 1;
+ _walkNodes[i]._gridX1 = _pos.x;
+ _walkNodes[i]._gridY1 = _pos.y + i;
+ _walkNodes[i]._deltaX = 0;
+ _walkNodes[i]._deltaY = 1;
}
done = true;
break;
}
- if (!isPointBlocked(_plat->_pos.x, _plat->_pos.y - gridIncr) && platFindPath1(_plat->_pos.x, _plat->_pos.y - gridIncr, gridIncr)) {
+ if (!_vm->isPointBlocked(_pos.x, _pos.y - gridIncr) && findPath1(_pos.x, _pos.y - gridIncr, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _platWalkNodes[i]._gridX1 = _plat->_pos.x;
- _platWalkNodes[i]._gridY1 = _plat->_pos.y - i;
- _platWalkNodes[i]._deltaX = 0;
- _platWalkNodes[i]._deltaY = -1;
+ _walkNodes[i]._gridX1 = _pos.x;
+ _walkNodes[i]._gridY1 = _pos.y - i;
+ _walkNodes[i]._deltaX = 0;
+ _walkNodes[i]._deltaY = -1;
}
done = true;
break;
}
- if (!isPointBlocked(_plat->_pos.x + gridIncr, _plat->_pos.y + gridIncr) && platFindPath1(_plat->_pos.x + gridIncr, _plat->_pos.y + gridIncr, gridIncr)) {
+ if (!_vm->isPointBlocked(_pos.x + gridIncr, _pos.y + gridIncr) && findPath1(_pos.x + gridIncr, _pos.y + gridIncr, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _platWalkNodes[i]._gridX1 = _plat->_pos.x + i;
- _platWalkNodes[i]._gridY1 = _plat->_pos.y + i;
- _platWalkNodes[i]._deltaX = 1;
- _platWalkNodes[i]._deltaY = 1;
+ _walkNodes[i]._gridX1 = _pos.x + i;
+ _walkNodes[i]._gridY1 = _pos.y + i;
+ _walkNodes[i]._deltaX = 1;
+ _walkNodes[i]._deltaY = 1;
}
done = true;
break;
}
- if (!isPointBlocked(_plat->_pos.x - gridIncr, _plat->_pos.y + gridIncr) && platFindPath1(_plat->_pos.x - gridIncr, _plat->_pos.y + gridIncr, gridIncr)) {
+ if (!_vm->isPointBlocked(_pos.x - gridIncr, _pos.y + gridIncr) && findPath1(_pos.x - gridIncr, _pos.y + gridIncr, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _platWalkNodes[i]._gridX1 = _plat->_pos.x - i;
- _platWalkNodes[i]._gridY1 = _plat->_pos.y + i;
- _platWalkNodes[i]._deltaX = -1;
- _platWalkNodes[i]._deltaY = 1;
+ _walkNodes[i]._gridX1 = _pos.x - i;
+ _walkNodes[i]._gridY1 = _pos.y + i;
+ _walkNodes[i]._deltaX = -1;
+ _walkNodes[i]._deltaY = 1;
}
done = true;
break;
}
- if (!isPointBlocked(_plat->_pos.x + gridIncr, _plat->_pos.y - gridIncr) && platFindPath1(_plat->_pos.x + gridIncr, _plat->_pos.y - gridIncr, gridIncr)) {
+ if (!_vm->isPointBlocked(_pos.x + gridIncr, _pos.y - gridIncr) && findPath1(_pos.x + gridIncr, _pos.y - gridIncr, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _platWalkNodes[i]._gridX1 = _plat->_pos.x + i;
- _platWalkNodes[i]._gridY1 = _plat->_pos.y - i;
- _platWalkNodes[i]._deltaX = 1;
- _platWalkNodes[i]._deltaY = -1;
+ _walkNodes[i]._gridX1 = _pos.x + i;
+ _walkNodes[i]._gridY1 = _pos.y - i;
+ _walkNodes[i]._deltaX = 1;
+ _walkNodes[i]._deltaY = -1;
}
done = true;
break;
}
- if (!isPointBlocked(_plat->_pos.x - gridIncr, _plat->_pos.y - gridIncr) && platFindPath1(_plat->_pos.x - gridIncr, _plat->_pos.y - gridIncr, gridIncr)) {
+ if (!_vm->isPointBlocked(_pos.x - gridIncr, _pos.y - gridIncr) && findPath1(_pos.x - gridIncr, _pos.y - gridIncr, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _platWalkNodes[i]._gridX1 = _plat->_pos.x - i;
- _platWalkNodes[i]._gridY1 = _plat->_pos.y - i;
- _platWalkNodes[i]._deltaX = -1;
- _platWalkNodes[i]._deltaY = -1;
+ _walkNodes[i]._gridX1 = _pos.x - i;
+ _walkNodes[i]._gridY1 = _pos.y - i;
+ _walkNodes[i]._deltaX = -1;
+ _walkNodes[i]._deltaY = -1;
}
done = true;
break;
}
- if (!isPointBlocked(_plat->_pos.x + gridIncr, _plat->_pos.y) && platFindPath2(_plat->_pos.x + gridIncr, _plat->_pos.y, gridIncr)) {
+ if (!_vm->isPointBlocked(_pos.x + gridIncr, _pos.y) && findPath2(_pos.x + gridIncr, _pos.y, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _platWalkNodes[i]._gridX1 = _plat->_pos.x + i;
- _platWalkNodes[i]._gridY1 = _plat->_pos.y;
- _platWalkNodes[i]._deltaX = 1;
- _platWalkNodes[i]._deltaY = 0;
+ _walkNodes[i]._gridX1 = _pos.x + i;
+ _walkNodes[i]._gridY1 = _pos.y;
+ _walkNodes[i]._deltaX = 1;
+ _walkNodes[i]._deltaY = 0;
}
done = true;
break;
}
- if (!isPointBlocked(_plat->_pos.x - gridIncr, _plat->_pos.y) && platFindPath2(_plat->_pos.x - gridIncr, _plat->_pos.y, gridIncr)) {
+ if (!_vm->isPointBlocked(_pos.x - gridIncr, _pos.y) && findPath2(_pos.x - gridIncr, _pos.y, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _platWalkNodes[i]._gridX1 = _plat->_pos.x - i;
- _platWalkNodes[i]._gridY1 = _plat->_pos.y;
- _platWalkNodes[i]._deltaX = -1;
- _platWalkNodes[i]._deltaY = 0;
+ _walkNodes[i]._gridX1 = _pos.x - i;
+ _walkNodes[i]._gridY1 = _pos.y;
+ _walkNodes[i]._deltaX = -1;
+ _walkNodes[i]._deltaY = 0;
}
done = true;
break;
}
- if (!isPointBlocked(_plat->_pos.x, _plat->_pos.y + gridIncr) && platFindPath2(_plat->_pos.x, _plat->_pos.y + gridIncr, gridIncr)) {
+ if (!_vm->isPointBlocked(_pos.x, _pos.y + gridIncr) && findPath2(_pos.x, _pos.y + gridIncr, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _platWalkNodes[i]._gridX1 = _plat->_pos.x;
- _platWalkNodes[i]._gridY1 = _plat->_pos.y + i;
- _platWalkNodes[i]._deltaX = 0;
- _platWalkNodes[i]._deltaY = 1;
+ _walkNodes[i]._gridX1 = _pos.x;
+ _walkNodes[i]._gridY1 = _pos.y + i;
+ _walkNodes[i]._deltaX = 0;
+ _walkNodes[i]._deltaY = 1;
}
done = true;
break;
}
- if (!isPointBlocked(_plat->_pos.x, _plat->_pos.y - gridIncr) && platFindPath2(_plat->_pos.x, _plat->_pos.y - gridIncr, gridIncr)) {
+ if (!_vm->isPointBlocked(_pos.x, _pos.y - gridIncr) && findPath2(_pos.x, _pos.y - gridIncr, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _platWalkNodes[i]._gridX1 = _plat->_pos.x;
- _platWalkNodes[i]._gridY1 = _plat->_pos.y - i;
- _platWalkNodes[i]._deltaX = 0;
- _platWalkNodes[i]._deltaY = -1;
+ _walkNodes[i]._gridX1 = _pos.x;
+ _walkNodes[i]._gridY1 = _pos.y - i;
+ _walkNodes[i]._deltaX = 0;
+ _walkNodes[i]._deltaY = -1;
}
done = true;
break;
}
- if (!isPointBlocked(_plat->_pos.x + gridIncr, _plat->_pos.y + gridIncr) && platFindPath2(_plat->_pos.x + gridIncr, _plat->_pos.y + gridIncr, gridIncr)) {
+ if (!_vm->isPointBlocked(_pos.x + gridIncr, _pos.y + gridIncr) && findPath2(_pos.x + gridIncr, _pos.y + gridIncr, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _platWalkNodes[i]._gridX1 = _plat->_pos.x + i;
- _platWalkNodes[i]._gridY1 = _plat->_pos.y + i;
- _platWalkNodes[i]._deltaX = 1;
- _platWalkNodes[i]._deltaY = 1;
+ _walkNodes[i]._gridX1 = _pos.x + i;
+ _walkNodes[i]._gridY1 = _pos.y + i;
+ _walkNodes[i]._deltaX = 1;
+ _walkNodes[i]._deltaY = 1;
}
done = true;
break;
}
- if (!isPointBlocked(_plat->_pos.x - gridIncr, _plat->_pos.y + gridIncr) && platFindPath2(_plat->_pos.x - gridIncr, _plat->_pos.y + gridIncr, gridIncr)) {
+ if (!_vm->isPointBlocked(_pos.x - gridIncr, _pos.y + gridIncr) && findPath2(_pos.x - gridIncr, _pos.y + gridIncr, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _platWalkNodes[i]._gridX1 = _plat->_pos.x - i;
- _platWalkNodes[i]._gridY1 = _plat->_pos.y + i;
- _platWalkNodes[i]._deltaX = -1;
- _platWalkNodes[i]._deltaY = 1;
+ _walkNodes[i]._gridX1 = _pos.x - i;
+ _walkNodes[i]._gridY1 = _pos.y + i;
+ _walkNodes[i]._deltaX = -1;
+ _walkNodes[i]._deltaY = 1;
}
done = true;
break;
}
- if (!isPointBlocked(_plat->_pos.x + gridIncr, _plat->_pos.y - gridIncr) && platFindPath2(_plat->_pos.x + gridIncr, _plat->_pos.y - gridIncr, gridIncr)) {
+ if (!_vm->isPointBlocked(_pos.x + gridIncr, _pos.y - gridIncr) && findPath2(_pos.x + gridIncr, _pos.y - gridIncr, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _platWalkNodes[i]._gridX1 = _plat->_pos.x + i;
- _platWalkNodes[i]._gridY1 = _plat->_pos.y - i;
- _platWalkNodes[i]._deltaX = 1;
- _platWalkNodes[i]._deltaY = -1;
+ _walkNodes[i]._gridX1 = _pos.x + i;
+ _walkNodes[i]._gridY1 = _pos.y - i;
+ _walkNodes[i]._deltaX = 1;
+ _walkNodes[i]._deltaY = -1;
}
done = true;
break;
}
- if (!isPointBlocked(_plat->_pos.x - gridIncr, _plat->_pos.y - gridIncr) && platFindPath2(_plat->_pos.x - gridIncr, _plat->_pos.y - gridIncr, gridIncr)) {
+ if (!_vm->isPointBlocked(_pos.x - gridIncr, _pos.y - gridIncr) && findPath2(_pos.x - gridIncr, _pos.y - gridIncr, gridIncr)) {
for (int i = 0; i < gridIncr; ++i) {
- _platWalkNodes[i]._gridX1 = _plat->_pos.x - i;
- _platWalkNodes[i]._gridY1 = _plat->_pos.y - i;
- _platWalkNodes[i]._deltaX = -1;
- _platWalkNodes[i]._deltaY = -1;
+ _walkNodes[i]._gridX1 = _pos.x - i;
+ _walkNodes[i]._gridY1 = _pos.y - i;
+ _walkNodes[i]._deltaX = -1;
+ _walkNodes[i]._deltaY = -1;
}
done = true;
break;
@@ -1207,215 +885,100 @@ bool GnapEngine::platFindPath3(int gridX, int gridY) {
return done;
}
-bool GnapEngine::platypusWalkTo(Common::Point gridPos, int animationIndex, int sequenceId, int flags) {
- int datNum = flags & 3;
- bool done = false;
-
- _timers[1] = 60;
-
- int gridX = gridPos.x;
- if (gridX < 0)
- gridX = (_leftClickMouseX - _gridMinX + 37) / 75;
-
- int gridY = gridPos.y;
- if (gridY < 0)
- gridY = (_leftClickMouseY - _gridMinY + 24) / 48;
-
- _platWalkDestX = CLIP(gridX, 0, _gridMaxX - 1);
- _platWalkDestY = CLIP(gridY, 0, _gridMaxY - 1);
-
- if (animationIndex >= 0 && _gnap->_pos == Common::Point(_platWalkDestX, _platWalkDestY))
- gnapWalkStep();
-
- if (platFindPath1(_plat->_pos.x, _plat->_pos.y, 0))
- done = true;
-
- if (!done && platFindPath2(_plat->_pos.x, _plat->_pos.y, 0))
- done = true;
-
- if (!done && platFindPath3(_plat->_pos.x, _plat->_pos.y))
- done = true;
+bool PlayerPlat::findPath4(int gridX, int gridY) {
+ bool result = false;
- if (!done && platFindPath4(_plat->_pos.x, _plat->_pos.y))
- done = true;
+ _walkNodesCount = 0;
+ _walkDirXIncr = 0;
+ _walkDirYIncr = 0;
+ _walkDeltaX = ABS(_walkDestX - gridX);
+ _walkDeltaY = ABS(_walkDestY - gridY);
- int platSequenceId = _plat->_sequenceId;
- int platId = _plat->_id;
- int platSequenceDatNum = _plat->_sequenceDatNum;
+ if (_walkDeltaX)
+ _walkDirX = (_walkDestX - gridX) / _walkDeltaX;
+ else
+ _walkDirX = 0;
- for (int index = 0; index < _platWalkNodesCount; ++index) {
- _platWalkNodes[index]._id = index + 20 * _platWalkNodes[index]._gridY1;
- if (_platWalkNodes[index]._deltaX == 1 && _platWalkNodes[index]._deltaY == 0) {
- if (index % 2) {
- _gameSys->insertSequence(makeRid(datNum, 0x7CD), _platWalkNodes[index]._id,
- makeRid(platSequenceDatNum, platSequenceId), platId,
- kSeqScale | kSeqSyncWait, 0, 75 * _platWalkNodes[index]._gridX1 - _plat->_gridX, 48 * _platWalkNodes[index]._gridY1 - _plat->_gridY);
- _platWalkNodes[index]._sequenceId = 0x7CD;
- platSequenceId = 0x7CD;
+ if (_walkDeltaY)
+ _walkDirY = (_walkDestY - gridY) / _walkDeltaY;
+ else
+ _walkDirY = 0;
+
+ while (_walkDirXIncr < _walkDeltaX && _walkDirYIncr < _walkDeltaY) {
+ _walkNodes[_walkNodesCount]._gridX1 = gridX + _walkDirX * _walkDirXIncr;
+ _walkNodes[_walkNodesCount]._gridY1 = gridY + _walkDirY * _walkDirYIncr;
+ if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
+ _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
+ ++_walkDirXIncr;
+ ++_walkDirYIncr;
+ } else if (_walkDeltaY - _walkDirYIncr > _walkDeltaX - _walkDirXIncr) {
+ if (!_vm->isPointBlocked(_walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = 0;
+ _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
+ ++_walkDirYIncr;
+ } else if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
+ _walkNodes[_walkNodesCount]._deltaY = 0;
+ ++_walkDirXIncr;
} else {
- _gameSys->insertSequence(makeRid(datNum, 0x7CE), _platWalkNodes[index]._id,
- makeRid(platSequenceDatNum, platSequenceId), platId,
- kSeqScale | kSeqSyncWait, 0, 75 * _platWalkNodes[index]._gridX1 - _plat->_gridX, 48 * _platWalkNodes[index]._gridY1 - _plat->_gridY);
- _platWalkNodes[index]._sequenceId = 0x7CE;
- platSequenceId = 0x7CE;
+ _walkDeltaX = _walkDirXIncr;
+ _walkDeltaY = _walkDirYIncr;
+ --_walkNodesCount;
}
- } else if (_platWalkNodes[index]._deltaX == -1 && _platWalkNodes[index]._deltaY == 0) {
- if (index % 2) {
- _gameSys->insertSequence(makeRid(datNum, 0x7CF), _platWalkNodes[index]._id,
- makeRid(platSequenceDatNum, platSequenceId), platId,
- kSeqScale | kSeqSyncWait, 0, 75 * _platWalkNodes[index]._gridX1 - _plat->_gridX, 48 * _platWalkNodes[index]._gridY1 - _plat->_gridY);
- _platWalkNodes[index]._sequenceId = 0x7CF;
- platSequenceId = 0x7CF;
+ } else {
+ if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
+ _walkNodes[_walkNodesCount]._deltaY = 0;
+ ++_walkDirXIncr;
+ } else if (!_vm->isPointBlocked(_walkNodes[_walkNodesCount]._gridX1, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = 0;
+ _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
+ ++_walkDirYIncr;
} else {
- _gameSys->insertSequence(makeRid(datNum, 0x7D0), _platWalkNodes[index]._id,
- makeRid(platSequenceDatNum, platSequenceId), platId,
- kSeqScale | kSeqSyncWait, 0, 75 * _platWalkNodes[index]._gridX1 - _plat->_gridX, 48 * _platWalkNodes[index]._gridY1 - _plat->_gridY);
- _platWalkNodes[index]._sequenceId = 0x7D0;
- platSequenceId = 0x7D0;
+ _walkDeltaX = _walkDirXIncr;
+ _walkDeltaY = _walkDirYIncr;
+ --_walkNodesCount;
}
- } else {
- if (_platWalkNodes[index]._deltaY == -1)
- _platWalkNodes[index]._id -= 10;
- else
- _platWalkNodes[index]._id += 10;
- int newSequenceId = _plat->getWalkSequenceId(_platWalkNodes[index]._deltaX, _platWalkNodes[index]._deltaY);
- _gameSys->insertSequence(makeRid(datNum, newSequenceId), _platWalkNodes[index]._id,
- makeRid(platSequenceDatNum, platSequenceId), platId,
- kSeqScale | kSeqSyncWait, 0, 75 * _platWalkNodes[index]._gridX1 - _plat->_gridX, 48 * _platWalkNodes[index]._gridY1 - _plat->_gridY);
- _platWalkNodes[index]._sequenceId = newSequenceId;
- platSequenceId = newSequenceId;
}
- platId = _platWalkNodes[index]._id;
- platSequenceDatNum = datNum;
+ ++_walkNodesCount;
}
- if (flags & 8) {
- if (_platWalkNodesCount > 0) {
- _plat->_sequenceId = platSequenceId;
- _plat->_id = platId;
- _plat->_sequenceDatNum = datNum;
- // CHECKME Not sure if this is correct...
- if (_platWalkNodes[_platWalkNodesCount - 1]._deltaX > 0)
- _plat->_idleFacing = kDirNone;
- else if (_platWalkNodes[_platWalkNodesCount - 1]._deltaX < 0)
- _plat->_idleFacing = kDirUnk4;
- else if (_platWalkNodes[_platWalkNodesCount - 1]._gridX1 % 2)
- _plat->_idleFacing = kDirUnk4;
- else
- _plat->_idleFacing = kDirNone;
- if (animationIndex >= 0)
- _gameSys->setAnimation(makeRid(_plat->_sequenceDatNum, _plat->_sequenceId), _plat->_id, animationIndex);
- } else if (animationIndex >= 0) {
- _gameSys->setAnimation(0x107D3, 1, animationIndex);
- _gameSys->insertSequence(0x107D3, 1, 0, 0, kSeqNone, 0, 0, 0);
- }
- } else {
- if (sequenceId >= 0 && sequenceId != -1) {
- _plat->_sequenceId = ridToEntryIndex(sequenceId);
- _plat->_sequenceDatNum = ridToDatIndex(sequenceId);
- if (_plat->_sequenceId == 0x7C2) {
- _plat->_idleFacing = kDirNone;
- } else if (_plat->_sequenceId == 0x7D2) {
- _plat->_idleFacing = kDirUnk4;
- }
+ while (_walkDirXIncr < _walkDeltaX) {
+ _walkNodes[_walkNodesCount]._gridX1 = gridX + _walkDirX * _walkDirXIncr;
+ _walkNodes[_walkNodesCount]._gridY1 = _walkDestY;
+ if (!_vm->isPointBlocked(_walkDirX + _walkNodes[_walkNodesCount]._gridX1, _walkDestY)) {
+ _walkNodes[_walkNodesCount]._deltaX = _walkDirX;
+ _walkNodes[_walkNodesCount]._deltaY = 0;
+ ++_walkDirXIncr;
+ ++_walkNodesCount;
} else {
- if (_platWalkNodesCount > 0) {
- if (_platWalkNodes[_platWalkNodesCount - 1]._deltaX > 0) {
- _plat->_sequenceId = 0x7C2;
- _plat->_idleFacing = kDirNone;
- } else if (_platWalkNodes[_platWalkNodesCount - 1]._deltaX < 0) {
- _plat->_sequenceId = 0x7D2;
- _plat->_idleFacing = kDirUnk4;
- } else if (_platWalkNodes[0]._deltaX > 0) {
- _plat->_sequenceId = 0x7C2;
- _plat->_idleFacing = kDirNone;
- } else if (_platWalkNodes[0]._deltaX < 0) {
- _plat->_sequenceId = 0x7D2;
- _plat->_idleFacing = kDirUnk4;
- } else {
- _plat->_sequenceId = 0x7D2;
- _plat->_idleFacing = kDirUnk4;
- }
- } else if (_plat->_idleFacing != kDirNone) {
- _plat->_sequenceId = 0x7D2;
- } else {
- _plat->_sequenceId = 0x7C2;
- }
- _plat->_sequenceDatNum = datNum;
+ _walkDeltaX = _walkDirXIncr;
}
+ }
- if (animationIndex < 0) {
- _plat->_id = 20 * _platWalkDestY;
+ while (_walkDirYIncr < _walkDeltaY) {
+ _walkNodes[_walkNodesCount]._gridX1 = _walkDestX;
+ _walkNodes[_walkNodesCount]._gridY1 = gridY + _walkDirY * _walkDirYIncr;
+ if (!_vm->isPointBlocked(_walkDestX, _walkDirY + _walkNodes[_walkNodesCount]._gridY1)) {
+ _walkNodes[_walkNodesCount]._deltaX = 0;
+ _walkNodes[_walkNodesCount]._deltaY = _walkDirY;
+ ++_walkDirYIncr;
+ ++_walkNodesCount;
} else {
- _plat->_id = animationIndex + 20 * _platWalkDestY;
- _gameSys->setAnimation(makeRid(_plat->_sequenceDatNum, _plat->_sequenceId), animationIndex + 20 * _platWalkDestY, animationIndex);
+ _walkDeltaY = _walkDirYIncr;
}
-
- if (flags & 4)
- _gameSys->insertSequence(makeRid(_plat->_sequenceDatNum, _plat->_sequenceId), _plat->_id,
- makeRid(platSequenceDatNum, platSequenceId), platId,
- 9, 0, 0, 0);
- else
- _gameSys->insertSequence(makeRid(_plat->_sequenceDatNum, _plat->_sequenceId), _plat->_id,
- makeRid(platSequenceDatNum, platSequenceId), platId,
- 9, 0, 75 * _platWalkDestX - _plat->_gridX, 48 * _platWalkDestY - _plat->_gridY);
}
- _plat->_pos = Common::Point(_platWalkDestX, _platWalkDestY);
-
- return done;
-}
-
-void GnapEngine::platypusWalkStep() {
- for (int i = 1; i < _gridMaxX; ++i) {
- Common::Point checkPt = Common::Point(_plat->_pos.x + i, _plat->_pos.y);
- if (!isPointBlocked(checkPt)) {
- platypusWalkTo(checkPt, -1, -1, 1);
- break;
- }
-
- checkPt = Common::Point(_plat->_pos.x - i, _plat->_pos.y);
- if (!isPointBlocked(checkPt)) {
- platypusWalkTo(checkPt, -1, -1, 1);
- break;
- }
-
- checkPt = Common::Point(_plat->_pos.x, _plat->_pos.y + 1);
- if (!isPointBlocked(checkPt)) {
- platypusWalkTo(checkPt, -1, -1, 1);
- break;
- }
-
- checkPt = Common::Point(_plat->_pos.x, _plat->_pos.y - 1);
- if (!isPointBlocked(checkPt)) {
- platypusWalkTo(checkPt, -1, -1, 1);
- break;
- }
-
- checkPt = Common::Point(_plat->_pos.x + 1, _plat->_pos.y + 1);
- if (!isPointBlocked(checkPt)) {
- platypusWalkTo(checkPt, -1, -1, 1);
- break;
- }
-
- checkPt = Common::Point(_plat->_pos.x - 1, _plat->_pos.y + 1);
- if (!isPointBlocked(checkPt)) {
- platypusWalkTo(checkPt, -1, -1, 1);
- break;
- }
-
- checkPt = Common::Point(_plat->_pos.x + 1, _plat->_pos.y - 1);
- if (!isPointBlocked(checkPt)) {
- platypusWalkTo(checkPt, -1, -1, 1);
- break;
- }
-
- checkPt = Common::Point(_plat->_pos.x - 1, _plat->_pos.y - 1);
- if (!isPointBlocked(checkPt)) {
- platypusWalkTo(checkPt, -1, -1, 1);
- break;
- }
+ if (gridX + _walkDirX * _walkDirXIncr != _walkDestX || gridY + _walkDirY * _walkDirYIncr != _walkDestY) {
+ _walkDestX = gridX + _walkDirX * _walkDirXIncr;
+ _walkDestY = gridY + _walkDirY * _walkDirYIncr;
+ result = false;
+ } else {
+ result = true;
}
+
+ return result;
}
void GnapEngine::platypusMakeRoom() {
@@ -1425,7 +988,7 @@ void GnapEngine::platypusMakeRoom() {
rndGridX = getRandom(_gridMaxX);
} while (ABS(rndGridX - _plat->_pos.x) > 4 || ABS(rndGridY - _plat->_pos.y) > 3 ||
isPointBlocked(rndGridX, rndGridY));
- platypusWalkTo(Common::Point(rndGridX, rndGridY), -1, -1, 1);
+ _plat->walkTo(Common::Point(rndGridX, rndGridY), -1, -1, 1);
}
} // End of namespace Gnap
generated by cgit v1.2.3 (git 2.25.1) at 2024-08-13 08:29:00 +0000