[Scummvm-cvs-logs] SF.net SVN: scummvm:[45598] scummvm/trunk/engines/draci
spalek at users.sourceforge.net
spalek at users.sourceforge.net
Sun Nov 1 20:22:41 CET 2009
Revision: 45598
http://scummvm.svn.sourceforge.net/scummvm/?rev=45598&view=rev
Author: spalek
Date: 2009-11-01 19:22:41 +0000 (Sun, 01 Nov 2009)
Log Message:
-----------
Cleaned up the walking code.
PathVertex replaced by Common::Point. Do not update the path sprites if
not in the debugging mode.
Modified Paths:
--------------
scummvm/trunk/engines/draci/game.cpp
scummvm/trunk/engines/draci/walking.cpp
scummvm/trunk/engines/draci/walking.h
Modified: scummvm/trunk/engines/draci/game.cpp
===================================================================
--- scummvm/trunk/engines/draci/game.cpp 2009-11-01 12:57:06 UTC (rev 45597)
+++ scummvm/trunk/engines/draci/game.cpp 2009-11-01 19:22:41 UTC (rev 45598)
@@ -961,12 +961,13 @@
// Compute the shortest and obliqued path.
WalkingMap::Path shortestPath, obliquePath;
- _walkingMap.findShortestPath(oldHero.x, oldHero.y, _hero.x, _hero.y, &shortestPath);
+ _walkingMap.findShortestPath(oldHero, _hero, &shortestPath);
_walkingMap.obliquePath(shortestPath, &obliquePath);
+ if (_vm->_showWalkingMap) {
+ redrawWalkingPath(kWalkingShortestPathOverlay, kWalkingShortestPathOverlayColour, shortestPath);
+ redrawWalkingPath(kWalkingObliquePathOverlay, kWalkingObliquePathOverlayColour, obliquePath);
+ }
- redrawWalkingPath(kWalkingShortestPathOverlay, kWalkingShortestPathOverlayColour, shortestPath);
- redrawWalkingPath(kWalkingObliquePathOverlay, kWalkingObliquePathOverlayColour, obliquePath);
-
Movement movement = kStopRight;
switch (dir) {
case kDirectionLeft:
Modified: scummvm/trunk/engines/draci/walking.cpp
===================================================================
--- scummvm/trunk/engines/draci/walking.cpp 2009-11-01 12:57:06 UTC (rev 45597)
+++ scummvm/trunk/engines/draci/walking.cpp 2009-11-01 19:22:41 UTC (rev 45598)
@@ -182,33 +182,34 @@
}
}
+// We don't use Common::Point due to using static initialization.
int WalkingMap::kDirections[][2] = { {0, -1}, {0, +1}, {-1, 0}, {+1, 0} };
-bool WalkingMap::findShortestPath(int x1, int y1, int x2, int y2, WalkingMap::Path *path) const {
+bool WalkingMap::findShortestPath(Common::Point p1, Common::Point p2, Path *path) const {
// Round the positions to map squares.
- x1 /= _deltaX;
- x2 /= _deltaX;
- y1 /= _deltaY;
- y2 /= _deltaY;
+ p1.x /= _deltaX;
+ p2.x /= _deltaX;
+ p1.y /= _deltaY;
+ p2.y /= _deltaY;
// Allocate buffers for breadth-first search. The buffer of points for
// exploration should be large enough.
int8 *cameFrom = new int8[_mapWidth * _mapHeight];
const int bufSize = 4 * _realHeight;
- PathVertex *toSearch = new PathVertex[bufSize];
+ Common::Point *toSearch = new Common::Point[bufSize];
// Insert the starting point as a single seed.
int toRead = 0, toWrite = 0;
memset(cameFrom, -1, _mapWidth * _mapHeight); // -1 = not found yet
- cameFrom[y1 * _mapWidth + x1] = 0;
- toSearch[toWrite++] = PathVertex(x1, y1);
+ cameFrom[p1.y * _mapWidth + p1.x] = 0;
+ toSearch[toWrite++] = p1;
// Search until we empty the whole buffer (not found) or find the
// destination point.
while (toRead != toWrite) {
- const PathVertex &here = toSearch[toRead];
+ const Common::Point &here = toSearch[toRead];
const int from = cameFrom[here.y * _mapWidth + here.x];
- if (here.x == x2 && here.y == y2) {
+ if (here == p2) {
break;
}
// Look into all 4 directions in a particular order depending
@@ -217,17 +218,16 @@
// with the smallest number of turns is preferred.
for (int addDir = 0; addDir < 4; ++addDir) {
const int probeDirection = (from + addDir) % 4;
- const int x = here.x + kDirections[probeDirection][0];
- const int y = here.y + kDirections[probeDirection][1];
- if (x < 0 || x >= _mapWidth || y < 0 || y >= _mapHeight) {
+ const Common::Point p(here.x + kDirections[probeDirection][0], here.y + kDirections[probeDirection][1]);
+ if (p.x < 0 || p.x >= _mapWidth || p.y < 0 || p.y >= _mapHeight) {
continue;
}
// If this point is walkable and we haven't seen it
// yet, record how we have reached it and insert it
// into the round buffer for exploration.
- if (getPixel(x, y) && cameFrom[y * _mapWidth + x] == -1) {
- cameFrom[y * _mapWidth + x] = probeDirection;
- toSearch[toWrite++] = PathVertex(x, y);
+ if (getPixel(p.x, p.y) && cameFrom[p.y * _mapWidth + p.x] == -1) {
+ cameFrom[p.y * _mapWidth + p.x] = probeDirection;
+ toSearch[toWrite++] = p;
toWrite %= bufSize;
}
}
@@ -245,19 +245,19 @@
path->clear();
int length = 0;
for (int pass = 0; pass < 2; ++pass) {
- int x = x2, y = y2;
+ Common::Point p = p2;
int index = 0;
while (1) {
++index;
if (pass == 1) {
- (*path)[length - index] = PathVertex(x, y);
+ (*path)[length - index] = p;
}
- if (x == x1 && y == y1) {
+ if (p == p1) {
break;
}
- const int from = cameFrom[y * _mapWidth + x];
- x -= kDirections[from][0];
- y -= kDirections[from][1];
+ const int from = cameFrom[p.y * _mapWidth + p.x];
+ p.x -= kDirections[from][0];
+ p.y -= kDirections[from][1];
}
if (pass == 0) {
length = index;
@@ -312,8 +312,8 @@
// first edge (going from the 1st vertex to the 2nd one) as is, move
// the index to the 2nd vertex, and continue.
for (uint head = 2; head < obliquedPath->size(); ++head) {
- const PathVertex &v1 = (*obliquedPath)[head-2];
- const PathVertex &v3 = (*obliquedPath)[head];
+ const Common::Point &v1 = (*obliquedPath)[head-2];
+ const Common::Point &v3 = (*obliquedPath)[head];
const int steps = MAX(abs(v3.x - v1.x), abs(v3.y - v1.y));
bool allPointsOk = true;
// Testing only points between (i.e., without the end-points) is OK.
@@ -337,8 +337,8 @@
memset(wlk, 255, _realWidth * _realHeight);
for (uint segment = 1; segment < path.size(); ++segment) {
- const PathVertex &v1 = path[segment-1];
- const PathVertex &v2 = path[segment];
+ const Common::Point &v1 = path[segment-1];
+ const Common::Point &v2 = path[segment];
const int steps = MAX(abs(v2.x - v1.x), abs(v2.y - v1.y));
// Draw only points in the interval [v1, v2). These half-open
// half-closed intervals connect all the way to the last point.
@@ -351,7 +351,7 @@
// Draw the last point. This works also when the path has no segment,
// but just one point.
if (path.size() > 0) {
- const PathVertex &vLast = path[path.size()-1];
+ const Common::Point &vLast = path[path.size()-1];
drawOverlayRectangle(vLast.x, vLast.y, colour, wlk);
}
Modified: scummvm/trunk/engines/draci/walking.h
===================================================================
--- scummvm/trunk/engines/draci/walking.h 2009-11-01 12:57:06 UTC (rev 45597)
+++ scummvm/trunk/engines/draci/walking.h 2009-11-01 19:22:41 UTC (rev 45598)
@@ -33,12 +33,6 @@
class Sprite;
-struct PathVertex {
- PathVertex() {}
- PathVertex(int xx, int yy) : x(xx), y(yy) {}
- int x, y;
-};
-
class WalkingMap {
public:
WalkingMap() : _realWidth(0), _realHeight(0), _deltaX(1), _deltaY(1),
@@ -52,8 +46,8 @@
Sprite *newOverlayFromMap(byte colour) const;
Common::Point findNearestWalkable(int x, int y, Common::Rect searchRect) const;
- typedef Common::Array<PathVertex> Path;
- bool findShortestPath(int x1, int y1, int x2, int y2, Path *path) const;
+ typedef Common::Array<Common::Point> Path;
+ bool findShortestPath(Common::Point p1, Common::Point p2, Path *path) const;
void obliquePath(const Path& path, Path *obliquedPath) const;
Sprite *newOverlayFromPath(const Path &path, byte colour) const;
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
More information about the Scummvm-git-logs
mailing list