aboutsummaryrefslogtreecommitdiff
path: root/engines/hugo/route.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'engines/hugo/route.cpp')
-rw-r--r--engines/hugo/route.cpp150
1 files changed, 75 insertions, 75 deletions
diff --git a/engines/hugo/route.cpp b/engines/hugo/route.cpp
index 281aacf031..54dae88c28 100644
--- a/engines/hugo/route.cpp
+++ b/engines/hugo/route.cpp
@@ -61,41 +61,41 @@ int16 Route::getRouteIndex() const {
void Route::setDirection(const uint16 keyCode) {
debugC(1, kDebugRoute, "setDirection(%d)", keyCode);
- object_t *obj = _vm->_hero; // Pointer to hero object
+ Object *obj = _vm->_hero; // Pointer to hero object
// Set first image in sequence
switch (keyCode) {
case Common::KEYCODE_UP:
case Common::KEYCODE_KP8:
- obj->currImagePtr = obj->seqList[SEQ_UP].seqPtr;
+ obj->_currImagePtr = obj->_seqList[SEQ_UP]._seqPtr;
break;
case Common::KEYCODE_DOWN:
case Common::KEYCODE_KP2:
- obj->currImagePtr = obj->seqList[SEQ_DOWN].seqPtr;
+ obj->_currImagePtr = obj->_seqList[SEQ_DOWN]._seqPtr;
break;
case Common::KEYCODE_LEFT:
case Common::KEYCODE_KP4:
- obj->currImagePtr = obj->seqList[SEQ_LEFT].seqPtr;
+ obj->_currImagePtr = obj->_seqList[SEQ_LEFT]._seqPtr;
break;
case Common::KEYCODE_RIGHT:
case Common::KEYCODE_KP6:
- obj->currImagePtr = obj->seqList[SEQ_RIGHT].seqPtr;
+ obj->_currImagePtr = obj->_seqList[SEQ_RIGHT]._seqPtr;
break;
case Common::KEYCODE_HOME:
case Common::KEYCODE_KP7:
- obj->currImagePtr = obj->seqList[SEQ_LEFT].seqPtr;
+ obj->_currImagePtr = obj->_seqList[SEQ_LEFT]._seqPtr;
break;
case Common::KEYCODE_END:
case Common::KEYCODE_KP1:
- obj->currImagePtr = obj->seqList[SEQ_LEFT].seqPtr;
+ obj->_currImagePtr = obj->_seqList[SEQ_LEFT]._seqPtr;
break;
case Common::KEYCODE_PAGEUP:
case Common::KEYCODE_KP9:
- obj->currImagePtr = obj->seqList[SEQ_RIGHT].seqPtr;
+ obj->_currImagePtr = obj->_seqList[SEQ_RIGHT]._seqPtr;
break;
case Common::KEYCODE_PAGEDOWN:
case Common::KEYCODE_KP3:
- obj->currImagePtr = obj->seqList[SEQ_RIGHT].seqPtr;
+ obj->_currImagePtr = obj->_seqList[SEQ_RIGHT]._seqPtr;
break;
}
}
@@ -107,68 +107,68 @@ void Route::setDirection(const uint16 keyCode) {
void Route::setWalk(const uint16 direction) {
debugC(1, kDebugRoute, "setWalk(%d)", direction);
- object_t *obj = _vm->_hero; // Pointer to hero object
+ Object *obj = _vm->_hero; // Pointer to hero object
- if (_vm->getGameStatus().storyModeFl || obj->pathType != kPathUser) // Make sure user has control
+ if (_vm->getGameStatus()._storyModeFl || obj->_pathType != kPathUser) // Make sure user has control
return;
- if (!obj->vx && !obj->vy)
+ if (!obj->_vx && !obj->_vy)
_oldWalkDirection = 0; // Fix for consistant restarts
if (direction != _oldWalkDirection) {
// Direction has changed
setDirection(direction); // Face new direction
- obj->vx = obj->vy = 0;
+ obj->_vx = obj->_vy = 0;
switch (direction) { // And set correct velocity
case Common::KEYCODE_UP:
case Common::KEYCODE_KP8:
- obj->vy = -kStepDy;
+ obj->_vy = -kStepDy;
break;
case Common::KEYCODE_DOWN:
case Common::KEYCODE_KP2:
- obj->vy = kStepDy;
+ obj->_vy = kStepDy;
break;
case Common::KEYCODE_LEFT:
case Common::KEYCODE_KP4:
- obj->vx = -kStepDx;
+ obj->_vx = -kStepDx;
break;
case Common::KEYCODE_RIGHT:
case Common::KEYCODE_KP6:
- obj->vx = kStepDx;
+ obj->_vx = kStepDx;
break;
case Common::KEYCODE_HOME:
case Common::KEYCODE_KP7:
- obj->vx = -kStepDx;
+ obj->_vx = -kStepDx;
// Note: in v1 Dos and v2 Dos, obj->vy is set to DY
- obj->vy = -kStepDy / 2;
+ obj->_vy = -kStepDy / 2;
break;
case Common::KEYCODE_END:
case Common::KEYCODE_KP1:
- obj->vx = -kStepDx;
+ obj->_vx = -kStepDx;
// Note: in v1 Dos and v2 Dos, obj->vy is set to -DY
- obj->vy = kStepDy / 2;
+ obj->_vy = kStepDy / 2;
break;
case Common::KEYCODE_PAGEUP:
case Common::KEYCODE_KP9:
- obj->vx = kStepDx;
+ obj->_vx = kStepDx;
// Note: in v1 Dos and v2 Dos, obj->vy is set to -DY
- obj->vy = -kStepDy / 2;
+ obj->_vy = -kStepDy / 2;
break;
case Common::KEYCODE_PAGEDOWN:
case Common::KEYCODE_KP3:
- obj->vx = kStepDx;
+ obj->_vx = kStepDx;
// Note: in v1 Dos and v2 Dos, obj->vy is set to DY
- obj->vy = kStepDy / 2;
+ obj->_vy = kStepDy / 2;
break;
}
_oldWalkDirection = direction;
- obj->cycling = kCycleForward;
+ obj->_cycling = kCycleForward;
} else {
// Same key twice - halt hero
- obj->vy = 0;
- obj->vx = 0;
+ obj->_vy = 0;
+ obj->_vx = 0;
_oldWalkDirection = 0;
- obj->cycling = kCycleNotCycling;
+ obj->_cycling = kCycleNotCycling;
}
}
@@ -188,8 +188,8 @@ void Route::segment(int16 x, int16 y) {
debugC(1, kDebugRoute, "segment(%d, %d)", x, y);
// Note: use of static - can't waste stack
- static image_pt p; // Ptr to _boundaryMap[y]
- static segment_t *seg_p; // Ptr to segment
+ static ImagePtr p; // Ptr to _boundaryMap[y]
+ static Segment *segPtr; // Ptr to segment
// Bomb out if stack exhausted
// Vinterstum: Is this just a safeguard, or actually used?
@@ -228,7 +228,7 @@ void Route::segment(int16 x, int16 y) {
if (y <= 0 || y >= kYPix - 1)
return;
- if (_vm->_hero->x < x1) {
+ if (_vm->_hero->_x < x1) {
// Hero x not in segment, search x1..x2
// Find all segments above current
for (x = x1; !(_routeFoundFl || _fullStackFl || _fullSegmentFl) && x <= x2; x++) {
@@ -241,7 +241,7 @@ void Route::segment(int16 x, int16 y) {
if (_boundaryMap[y + 1][x] == 0)
segment(x, y + 1);
}
- } else if (_vm->_hero->x + kHeroMaxWidth > x2) {
+ } else if (_vm->_hero->_x + kHeroMaxWidth > x2) {
// Hero x not in segment, search x1..x2
// Find all segments above current
for (x = x2; !(_routeFoundFl || _fullStackFl || _fullSegmentFl) && x >= x1; x--) {
@@ -257,22 +257,22 @@ void Route::segment(int16 x, int16 y) {
} else {
// Organize search around hero x position - this gives
// better chance for more direct route.
- for (x = _vm->_hero->x; !(_routeFoundFl || _fullStackFl || _fullSegmentFl) && x <= x2; x++) {
+ for (x = _vm->_hero->_x; !(_routeFoundFl || _fullStackFl || _fullSegmentFl) && x <= x2; x++) {
if (_boundaryMap[y - 1][x] == 0)
segment(x, y - 1);
}
- for (x = x1; !(_routeFoundFl || _fullStackFl || _fullSegmentFl) && x < _vm->_hero->x; x++) {
+ for (x = x1; !(_routeFoundFl || _fullStackFl || _fullSegmentFl) && x < _vm->_hero->_x; x++) {
if (_boundaryMap[y - 1][x] == 0)
segment(x, y - 1);
}
- for (x = _vm->_hero->x; !(_routeFoundFl || _fullStackFl || _fullSegmentFl) && x <= x2; x++) {
+ for (x = _vm->_hero->_x; !(_routeFoundFl || _fullStackFl || _fullSegmentFl) && x <= x2; x++) {
if (_boundaryMap[y + 1][x] == 0)
segment(x, y + 1);
}
- for (x = x1; !(_routeFoundFl || _fullStackFl || _fullSegmentFl) && x < _vm->_hero->x; x++) {
+ for (x = x1; !(_routeFoundFl || _fullStackFl || _fullSegmentFl) && x < _vm->_hero->_x; x++) {
if (_boundaryMap[y + 1][x] == 0)
segment(x, y + 1);
}
@@ -285,10 +285,10 @@ void Route::segment(int16 x, int16 y) {
_fullSegmentFl = true;
} else {
// Create segment
- seg_p = &_segment[_segmentNumb];
- seg_p->y = y;
- seg_p->x1 = x1;
- seg_p->x2 = x2;
+ segPtr = &_segment[_segmentNumb];
+ segPtr->_y = y;
+ segPtr->_x1 = x1;
+ segPtr->_x2 = x2;
_segmentNumb++;
}
}
@@ -298,7 +298,7 @@ void Route::segment(int16 x, int16 y) {
* Create and return ptr to new node. Initialize with previous node.
* Returns 0 if MAX_NODES exceeded
*/
-Point *Route::newNode() {
+Common::Point *Route::newNode() {
debugC(1, kDebugRoute, "newNode");
_routeListIndex++;
@@ -327,16 +327,16 @@ bool Route::findRoute(const int16 cx, const int16 cy) {
_destY = cy; // Destination coords
_destX = cx; // Destination coords
- int16 herox1 = _vm->_hero->x + _vm->_hero->currImagePtr->x1; // Hero baseline
- int16 herox2 = _vm->_hero->x + _vm->_hero->currImagePtr->x2; // Hero baseline
- int16 heroy = _vm->_hero->y + _vm->_hero->currImagePtr->y2; // Hero baseline
+ int16 herox1 = _vm->_hero->_x + _vm->_hero->_currImagePtr->_x1; // Hero baseline
+ int16 herox2 = _vm->_hero->_x + _vm->_hero->_currImagePtr->_x2; // Hero baseline
+ int16 heroy = _vm->_hero->_y + _vm->_hero->_currImagePtr->_y2; // Hero baseline
// Store all object baselines into objbound (except hero's = [0])
- object_t *obj; // Ptr to object
+ Object *obj; // Ptr to object
int i;
for (i = 1, obj = &_vm->_object->_objects[i]; i < _vm->_object->_numObj; i++, obj++) {
- if ((obj->screenIndex == *_vm->_screen_p) && (obj->cycling != kCycleInvisible) && (obj->priority == kPriorityFloating))
- _vm->_object->storeBoundary(obj->oldx + obj->currImagePtr->x1, obj->oldx + obj->currImagePtr->x2, obj->oldy + obj->currImagePtr->y2);
+ if ((obj->_screenIndex == *_vm->_screenPtr) && (obj->_cycling != kCycleInvisible) && (obj->_priority == kPriorityFloating))
+ _vm->_object->storeBoundary(obj->_oldx + obj->_currImagePtr->_x1, obj->_oldx + obj->_currImagePtr->_x2, obj->_oldy + obj->_currImagePtr->_y2);
}
// Combine objbound and boundary bitmaps to local byte map
@@ -350,8 +350,8 @@ bool Route::findRoute(const int16 cx, const int16 cy) {
// Clear all object baselines from objbound
for (i = 0, obj = _vm->_object->_objects; i < _vm->_object->_numObj; i++, obj++) {
- if ((obj->screenIndex == *_vm->_screen_p) && (obj->cycling != kCycleInvisible) && (obj->priority == kPriorityFloating))
- _vm->_object->clearBoundary(obj->oldx + obj->currImagePtr->x1, obj->oldx + obj->currImagePtr->x2, obj->oldy + obj->currImagePtr->y2);
+ if ((obj->_screenIndex == *_vm->_screenPtr) && (obj->_cycling != kCycleInvisible) && (obj->_priority == kPriorityFloating))
+ _vm->_object->clearBoundary(obj->_oldx + obj->_currImagePtr->_x1, obj->_oldx + obj->_currImagePtr->_x2, obj->_oldy + obj->_currImagePtr->_y2);
}
// Search from hero to destination
@@ -368,32 +368,32 @@ bool Route::findRoute(const int16 cx, const int16 cy) {
_route[0].y = _destY;
// Make a final segment for hero's base (we left a spare)
- _segment[_segmentNumb].y = heroy;
- _segment[_segmentNumb].x1 = herox1;
- _segment[_segmentNumb].x2 = herox2;
+ _segment[_segmentNumb]._y = heroy;
+ _segment[_segmentNumb]._x1 = herox1;
+ _segment[_segmentNumb]._x2 = herox2;
_segmentNumb++;
- Point *routeNode; // Ptr to route node
+ Common::Point *routeNode; // Ptr to route node
// Look in segments[] for straight lines from destination to hero
for (i = 0, _routeListIndex = 0; i < _segmentNumb - 1; i++) {
if ((routeNode = newNode()) == 0) // New node for new segment
return false; // Too many nodes
- routeNode->y = _segment[i].y;
+ routeNode->y = _segment[i]._y;
// Look ahead for furthest straight line
for (int16 j = i + 1; j < _segmentNumb; j++) {
- segment_t *seg_p = &_segment[j];
+ Segment *segPtr = &_segment[j];
// Can we get to this segment from previous node?
- if (seg_p->x1 <= routeNode->x && seg_p->x2 >= routeNode->x + _heroWidth - 1) {
- routeNode->y = seg_p->y; // Yes, keep updating node
+ if (segPtr->_x1 <= routeNode->x && segPtr->_x2 >= routeNode->x + _heroWidth - 1) {
+ routeNode->y = segPtr->_y; // Yes, keep updating node
} else {
// No, create another node on previous segment to reach it
if ((routeNode = newNode()) == 0) // Add new route node
return false; // Too many nodes
// Find overlap between old and new segments
- int16 x1 = MAX(_segment[j - 1].x1, seg_p->x1);
- int16 x2 = MIN(_segment[j - 1].x2, seg_p->x2);
+ int16 x1 = MAX(_segment[j - 1]._x1, segPtr->_x1);
+ int16 x2 = MIN(_segment[j - 1]._x2, segPtr->_x2);
// If room, add a little offset to reduce staircase effect
int16 dx = kHeroMaxWidth >> 1;
@@ -433,18 +433,18 @@ void Route::processRoute() {
return;
// Current hero position
- int16 herox = _vm->_hero->x + _vm->_hero->currImagePtr->x1;
- int16 heroy = _vm->_hero->y + _vm->_hero->currImagePtr->y2;
- Point *routeNode = &_route[_routeIndex];
+ int16 herox = _vm->_hero->_x + _vm->_hero->_currImagePtr->_x1;
+ int16 heroy = _vm->_hero->_y + _vm->_hero->_currImagePtr->_y2;
+ Common::Point *routeNode = &_route[_routeIndex];
// Arrived at node?
if (abs(herox - routeNode->x) < kStepDx + 1 && abs(heroy - routeNode->y) < kStepDy) {
// kStepDx too low
// Close enough - position hero exactly
- _vm->_hero->x = _vm->_hero->oldx = routeNode->x - _vm->_hero->currImagePtr->x1;
- _vm->_hero->y = _vm->_hero->oldy = routeNode->y - _vm->_hero->currImagePtr->y2;
- _vm->_hero->vx = _vm->_hero->vy = 0;
- _vm->_hero->cycling = kCycleNotCycling;
+ _vm->_hero->_x = _vm->_hero->_oldx = routeNode->x - _vm->_hero->_currImagePtr->_x1;
+ _vm->_hero->_y = _vm->_hero->_oldy = routeNode->y - _vm->_hero->_currImagePtr->_y2;
+ _vm->_hero->_vx = _vm->_hero->_vy = 0;
+ _vm->_hero->_cycling = kCycleNotCycling;
// Arrived at final node?
if (--_routeIndex < 0) {
@@ -458,7 +458,7 @@ void Route::processRoute() {
_vm->_object->lookObject(&_vm->_object->_objects[_routeObjId]);
turnedFl = false;
} else {
- setDirection(_vm->_object->_objects[_routeObjId].direction);
+ setDirection(_vm->_object->_objects[_routeObjId]._direction);
_routeIndex++; // Come round again
turnedFl = true;
}
@@ -468,7 +468,7 @@ void Route::processRoute() {
_vm->_object->useObject(_routeObjId);
turnedFl = false;
} else {
- setDirection(_vm->_object->_objects[_routeObjId].direction);
+ setDirection(_vm->_object->_objects[_routeObjId]._direction);
_routeIndex++; // Come round again
turnedFl = true;
}
@@ -477,7 +477,7 @@ void Route::processRoute() {
break;
}
}
- } else if (_vm->_hero->vx == 0 && _vm->_hero->vy == 0) {
+ } else if (_vm->_hero->_vx == 0 && _vm->_hero->_vy == 0) {
// Set direction of travel if at a node
// Note realignment when changing to (thinner) up/down sprite,
// otherwise hero could bump into boundaries along route.
@@ -487,10 +487,10 @@ void Route::processRoute() {
setWalk(Common::KEYCODE_LEFT);
} else if (heroy < routeNode->y) {
setWalk(Common::KEYCODE_DOWN);
- _vm->_hero->x = _vm->_hero->oldx = routeNode->x - _vm->_hero->currImagePtr->x1;
+ _vm->_hero->_x = _vm->_hero->_oldx = routeNode->x - _vm->_hero->_currImagePtr->_x1;
} else if (heroy > routeNode->y) {
setWalk(Common::KEYCODE_UP);
- _vm->_hero->x = _vm->_hero->oldx = routeNode->x - _vm->_hero->currImagePtr->x1;
+ _vm->_hero->_x = _vm->_hero->_oldx = routeNode->x - _vm->_hero->_currImagePtr->_x1;
}
}
}
@@ -500,11 +500,11 @@ void Route::processRoute() {
* go_for is the purpose, id indexes the exit or object to walk to
* Returns FALSE if route not found
*/
-bool Route::startRoute(const go_t routeType, const int16 objId, int16 cx, int16 cy) {
+bool Route::startRoute(const RouteType routeType, const int16 objId, int16 cx, int16 cy) {
debugC(1, kDebugRoute, "startRoute(%d, %d, %d, %d)", routeType, objId, cx, cy);
// Don't attempt to walk if user does not have control
- if (_vm->_hero->pathType != kPathUser)
+ if (_vm->_hero->_pathType != kPathUser)
return false;
// if inventory showing, make it go away
@@ -521,7 +521,7 @@ bool Route::startRoute(const go_t routeType, const int16 objId, int16 cx, int16
bool foundFl = false; // TRUE if route found ok
if ((foundFl = findRoute(cx, cy))) { // Found a route?
_routeIndex = _routeListIndex; // Node index
- _vm->_hero->vx = _vm->_hero->vy = 0; // Stop manual motion
+ _vm->_hero->_vx = _vm->_hero->_vy = 0; // Stop manual motion
}
return foundFl;
generated by cgit v1.2.3 (git 2.25.1) at 2025-02-21 08:15:37 +0000