aboutsummaryrefslogtreecommitdiff
path: root/engines/hugo/object_v3d.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'engines/hugo/object_v3d.cpp')
-rw-r--r--engines/hugo/object_v3d.cpp164
1 files changed, 82 insertions, 82 deletions
diff --git a/engines/hugo/object_v3d.cpp b/engines/hugo/object_v3d.cpp
index cde7f5fd62..15d5fcd936 100644
--- a/engines/hugo/object_v3d.cpp
+++ b/engines/hugo/object_v3d.cpp
@@ -65,175 +65,175 @@ void ObjectHandler_v3d::moveObjects() {
// Don't store foreground or background objects
for (int i = 0; i < _numObj; i++) {
object_t *obj = &_objects[i]; // Get pointer to object
- seq_t *currImage = obj->currImagePtr; // Get ptr to current image
- if (obj->screenIndex == *_vm->_screen_p) {
- switch (obj->pathType) {
+ seq_t *currImage = obj->_currImagePtr; // Get ptr to current image
+ if (obj->_screenIndex == *_vm->_screen_p) {
+ switch (obj->_pathType) {
case kPathChase:
case kPathChase2: {
- int8 radius = obj->radius; // Default to object's radius
+ int8 radius = obj->_radius; // Default to object's radius
if (radius < 0) // If radius infinity, use closer value
radius = kStepDx;
// Allowable motion wrt boundary
- int dx = _vm->_hero->x + _vm->_hero->currImagePtr->x1 - obj->x - currImage->x1;
- int dy = _vm->_hero->y + _vm->_hero->currImagePtr->y2 - obj->y - currImage->y2 - 1;
+ int dx = _vm->_hero->_x + _vm->_hero->_currImagePtr->_x1 - obj->_x - currImage->_x1;
+ int dy = _vm->_hero->_y + _vm->_hero->_currImagePtr->_y2 - obj->_y - currImage->_y2 - 1;
if (abs(dx) <= radius)
- obj->vx = 0;
+ obj->_vx = 0;
else
- obj->vx = (dx > 0) ? MIN(dx, obj->vxPath) : MAX(dx, -obj->vxPath);
+ obj->_vx = (dx > 0) ? MIN(dx, obj->_vxPath) : MAX(dx, -obj->_vxPath);
if (abs(dy) <= radius)
- obj->vy = 0;
+ obj->_vy = 0;
else
- obj->vy = (dy > 0) ? MIN(dy, obj->vyPath) : MAX(dy, -obj->vyPath);
+ obj->_vy = (dy > 0) ? MIN(dy, obj->_vyPath) : MAX(dy, -obj->_vyPath);
// Set first image in sequence (if multi-seq object)
- switch (obj->seqNumb) {
+ switch (obj->_seqNumb) {
case 4:
- if (!obj->vx) { // Got 4 directions
- if (obj->vx != obj->oldvx) { // vx just stopped
+ if (!obj->_vx) { // Got 4 directions
+ if (obj->_vx != obj->_oldvx) { // vx just stopped
if (dy >= 0)
- obj->currImagePtr = obj->seqList[SEQ_DOWN].seqPtr;
+ obj->_currImagePtr = obj->_seqList[SEQ_DOWN]._seqPtr;
else
- obj->currImagePtr = obj->seqList[SEQ_UP].seqPtr;
+ obj->_currImagePtr = obj->_seqList[SEQ_UP]._seqPtr;
}
- } else if (obj->vx != obj->oldvx) {
+ } else if (obj->_vx != obj->_oldvx) {
if (dx > 0)
- obj->currImagePtr = obj->seqList[SEQ_RIGHT].seqPtr;
+ obj->_currImagePtr = obj->_seqList[SEQ_RIGHT]._seqPtr;
else
- obj->currImagePtr = obj->seqList[SEQ_LEFT].seqPtr;
+ obj->_currImagePtr = obj->_seqList[SEQ_LEFT]._seqPtr;
}
break;
case 3:
case 2:
- if (obj->vx != obj->oldvx) { // vx just stopped
+ if (obj->_vx != obj->_oldvx) { // vx just stopped
if (dx > 0) // Left & right only
- obj->currImagePtr = obj->seqList[SEQ_RIGHT].seqPtr;
+ obj->_currImagePtr = obj->_seqList[SEQ_RIGHT]._seqPtr;
else
- obj->currImagePtr = obj->seqList[SEQ_LEFT].seqPtr;
+ obj->_currImagePtr = obj->_seqList[SEQ_LEFT]._seqPtr;
}
break;
}
- if (obj->vx || obj->vy) {
- obj->cycling = kCycleForward;
+ if (obj->_vx || obj->_vy) {
+ obj->_cycling = kCycleForward;
} else {
- obj->cycling = kCycleNotCycling;
+ obj->_cycling = kCycleNotCycling;
boundaryCollision(obj); // Must have got hero!
}
- obj->oldvx = obj->vx;
- obj->oldvy = obj->vy;
- currImage = obj->currImagePtr; // Get (new) ptr to current image
+ obj->_oldvx = obj->_vx;
+ obj->_oldvy = obj->_vy;
+ currImage = obj->_currImagePtr; // Get (new) ptr to current image
break;
}
case kPathWander2:
case kPathWander:
if (!_vm->_rnd->getRandomNumber(3 * _vm->_normalTPS)) { // Kick on random interval
- obj->vx = _vm->_rnd->getRandomNumber(obj->vxPath << 1) - obj->vxPath;
- obj->vy = _vm->_rnd->getRandomNumber(obj->vyPath << 1) - obj->vyPath;
+ obj->_vx = _vm->_rnd->getRandomNumber(obj->_vxPath << 1) - obj->_vxPath;
+ obj->_vy = _vm->_rnd->getRandomNumber(obj->_vyPath << 1) - obj->_vyPath;
// Set first image in sequence (if multi-seq object)
- if (obj->seqNumb > 1) {
- if (!obj->vx && (obj->seqNumb >= 4)) {
- if (obj->vx != obj->oldvx) { // vx just stopped
- if (obj->vy > 0)
- obj->currImagePtr = obj->seqList[SEQ_DOWN].seqPtr;
+ if (obj->_seqNumb > 1) {
+ if (!obj->_vx && (obj->_seqNumb >= 4)) {
+ if (obj->_vx != obj->_oldvx) { // vx just stopped
+ if (obj->_vy > 0)
+ obj->_currImagePtr = obj->_seqList[SEQ_DOWN]._seqPtr;
else
- obj->currImagePtr = obj->seqList[SEQ_UP].seqPtr;
+ obj->_currImagePtr = obj->_seqList[SEQ_UP]._seqPtr;
}
- } else if (obj->vx != obj->oldvx) {
- if (obj->vx > 0)
- obj->currImagePtr = obj->seqList[SEQ_RIGHT].seqPtr;
+ } else if (obj->_vx != obj->_oldvx) {
+ if (obj->_vx > 0)
+ obj->_currImagePtr = obj->_seqList[SEQ_RIGHT]._seqPtr;
else
- obj->currImagePtr = obj->seqList[SEQ_LEFT].seqPtr;
+ obj->_currImagePtr = obj->_seqList[SEQ_LEFT]._seqPtr;
}
}
- obj->oldvx = obj->vx;
- obj->oldvy = obj->vy;
- currImage = obj->currImagePtr; // Get (new) ptr to current image
+ obj->_oldvx = obj->_vx;
+ obj->_oldvy = obj->_vy;
+ currImage = obj->_currImagePtr; // Get (new) ptr to current image
}
- if (obj->vx || obj->vy)
- obj->cycling = kCycleForward;
+ if (obj->_vx || obj->_vy)
+ obj->_cycling = kCycleForward;
break;
default:
; // Really, nothing
}
// Store boundaries
- if ((obj->cycling > kCycleAlmostInvisible) && (obj->priority == kPriorityFloating))
- storeBoundary(obj->x + currImage->x1, obj->x + currImage->x2, obj->y + currImage->y2);
+ if ((obj->_cycling > kCycleAlmostInvisible) && (obj->_priority == kPriorityFloating))
+ storeBoundary(obj->_x + currImage->_x1, obj->_x + currImage->_x2, obj->_y + currImage->_y2);
}
}
// Move objects, allowing for boundaries
for (int i = 0; i < _numObj; i++) {
object_t *obj = &_objects[i]; // Get pointer to object
- if ((obj->screenIndex == *_vm->_screen_p) && (obj->vx || obj->vy)) {
+ if ((obj->_screenIndex == *_vm->_screen_p) && (obj->_vx || obj->_vy)) {
// Only process if it's moving
// Do object movement. Delta_x,y return allowed movement in x,y
// to move as close to a boundary as possible without crossing it.
- seq_t *currImage = obj->currImagePtr; // Get ptr to current image
+ seq_t *currImage = obj->_currImagePtr; // Get ptr to current image
// object coordinates
- int x1 = obj->x + currImage->x1; // Left edge of object
- int x2 = obj->x + currImage->x2; // Right edge
- int y1 = obj->y + currImage->y1; // Top edge
- int y2 = obj->y + currImage->y2; // Bottom edge
+ int x1 = obj->_x + currImage->_x1; // Left edge of object
+ int x2 = obj->_x + currImage->_x2; // Right edge
+ int y1 = obj->_y + currImage->_y1; // Top edge
+ int y2 = obj->_y + currImage->_y2; // Bottom edge
- if ((obj->cycling > kCycleAlmostInvisible) && (obj->priority == kPriorityFloating))
+ if ((obj->_cycling > kCycleAlmostInvisible) && (obj->_priority == kPriorityFloating))
clearBoundary(x1, x2, y2); // Clear our own boundary
// Allowable motion wrt boundary
- int dx = deltaX(x1, x2, obj->vx, y2);
- if (dx != obj->vx) {
+ int dx = deltaX(x1, x2, obj->_vx, y2);
+ if (dx != obj->_vx) {
// An object boundary collision!
boundaryCollision(obj);
- obj->vx = 0;
+ obj->_vx = 0;
}
- int dy = deltaY(x1, x2, obj->vy, y2);
- if (dy != obj->vy) {
+ int dy = deltaY(x1, x2, obj->_vy, y2);
+ if (dy != obj->_vy) {
// An object boundary collision!
boundaryCollision(obj);
- obj->vy = 0;
+ obj->_vy = 0;
}
- if ((obj->cycling > kCycleAlmostInvisible) && (obj->priority == kPriorityFloating))
+ if ((obj->_cycling > kCycleAlmostInvisible) && (obj->_priority == kPriorityFloating))
storeBoundary(x1, x2, y2); // Re-store our own boundary
- obj->x += dx; // Update object position
- obj->y += dy;
+ obj->_x += dx; // Update object position
+ obj->_y += dy;
// Don't let object go outside screen
if (x1 < kEdge)
- obj->x = kEdge2;
+ obj->_x = kEdge2;
if (x2 > (kXPix - kEdge))
- obj->x = kXPix - kEdge2 - (x2 - x1);
+ obj->_x = kXPix - kEdge2 - (x2 - x1);
if (y1 < kEdge)
- obj->y = kEdge2;
+ obj->_y = kEdge2;
if (y2 > (kYPix - kEdge))
- obj->y = kYPix - kEdge2 - (y2 - y1);
+ obj->_y = kYPix - kEdge2 - (y2 - y1);
- if ((obj->vx == 0) && (obj->vy == 0) && (obj->pathType != kPathWander2) && (obj->pathType != kPathChase2))
- obj->cycling = kCycleNotCycling;
+ if ((obj->_vx == 0) && (obj->_vy == 0) && (obj->_pathType != kPathWander2) && (obj->_pathType != kPathChase2))
+ obj->_cycling = kCycleNotCycling;
}
}
// Clear all object baselines from the boundary file.
for (int i = 0; i < _numObj; i++) {
object_t *obj = &_objects[i]; // Get pointer to object
- seq_t *currImage = obj->currImagePtr; // Get ptr to current image
- if ((obj->screenIndex == *_vm->_screen_p) && (obj->cycling > kCycleAlmostInvisible) && (obj->priority == kPriorityFloating))
- clearBoundary(obj->oldx + currImage->x1, obj->oldx + currImage->x2, obj->oldy + currImage->y2);
+ seq_t *currImage = obj->_currImagePtr; // Get ptr to current image
+ if ((obj->_screenIndex == *_vm->_screen_p) && (obj->_cycling > kCycleAlmostInvisible) && (obj->_priority == kPriorityFloating))
+ clearBoundary(obj->_oldx + currImage->_x1, obj->_oldx + currImage->_x2, obj->_oldy + currImage->_y2);
}
// If maze mode is enabled, do special maze processing
- if (_vm->_maze.enabledFl) {
- seq_t *currImage = _vm->_hero->currImagePtr;// Get ptr to current image
+ if (_vm->_maze._enabledFl) {
+ seq_t *currImage = _vm->_hero->_currImagePtr;// Get ptr to current image
// hero coordinates
- int x1 = _vm->_hero->x + currImage->x1; // Left edge of object
- int x2 = _vm->_hero->x + currImage->x2; // Right edge
- int y1 = _vm->_hero->y + currImage->y1; // Top edge
- int y2 = _vm->_hero->y + currImage->y2; // Bottom edge
+ int x1 = _vm->_hero->_x + currImage->_x1; // Left edge of object
+ int x2 = _vm->_hero->_x + currImage->_x2; // Right edge
+ int y1 = _vm->_hero->_y + currImage->_y1; // Top edge
+ int y2 = _vm->_hero->_y + currImage->_y2; // Bottom edge
_vm->_scheduler->processMaze(x1, x2, y1, y2);
}
@@ -252,15 +252,15 @@ void ObjectHandler_v3d::swapImages(int objIndex1, int objIndex2) {
seqList_t tmpSeqList[kMaxSeqNumb];
int seqListSize = sizeof(seqList_t) * kMaxSeqNumb;
- memmove(tmpSeqList, _objects[objIndex1].seqList, seqListSize);
- memmove(_objects[objIndex1].seqList, _objects[objIndex2].seqList, seqListSize);
- memmove(_objects[objIndex2].seqList, tmpSeqList, seqListSize);
+ memmove(tmpSeqList, _objects[objIndex1]._seqList, seqListSize);
+ memmove(_objects[objIndex1]._seqList, _objects[objIndex2]._seqList, seqListSize);
+ memmove(_objects[objIndex2]._seqList, tmpSeqList, seqListSize);
restoreSeq(&_objects[objIndex1]);
- _objects[objIndex2].currImagePtr = _objects[objIndex2].seqList[0].seqPtr;
+ _objects[objIndex2]._currImagePtr = _objects[objIndex2]._seqList[0]._seqPtr;
_vm->_heroImage = (_vm->_heroImage == kHeroIndex) ? objIndex2 : kHeroIndex;
// Make sure baseline stays constant
- _objects[objIndex1].y += _objects[objIndex2].currImagePtr->y2 - _objects[objIndex1].currImagePtr->y2;
+ _objects[objIndex1]._y += _objects[objIndex2]._currImagePtr->_y2 - _objects[objIndex1]._currImagePtr->_y2;
}
} // End of namespace Hugo
generated by cgit v1.2.3 (git 2.25.1) at 2024-08-03 16:56:26 +0000