[Scummvm-cvs-logs] CVS: scummvm/saga actor.cpp,1.56,1.57 actor.h,1.28,1.29 events.cpp,1.36,1.37 game.cpp,1.41,1.42 saga.h,1.57,1.58 scene.cpp,1.63,1.64 script.h,1.37,1.38 sfuncs.cpp,1.55,1.56 sprite.cpp,1.32,1.33
Andrew Kurushin
h00ligan at users.sourceforge.net
Tue Dec 28 13:28:03 CET 2004
Update of /cvsroot/scummvm/scummvm/saga
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv8535
Modified Files:
actor.cpp actor.h events.cpp game.cpp saga.h scene.cpp
script.h sfuncs.cpp sprite.cpp
Log Message:
- many actor walk related functions added
- implemented script functions for scriptDoors (except iso mode)
- introduced getDisplayWidth() getDisplayHeight() getStatusYOffset getPathYOffset()
Index: actor.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/saga/actor.cpp,v
retrieving revision 1.56
retrieving revision 1.57
diff -u -d -r1.56 -r1.57
--- actor.cpp 27 Dec 2004 16:46:24 -0000 1.56
+++ actor.cpp 28 Dec 2004 21:27:17 -0000 1.57
@@ -53,9 +53,8 @@
}
}
-
// Lookup table to convert 8 cardinal directions to 4
-int ActorDirectectionsLUT[8] = {
+int actorDirectectionsLUT[8] = {
ACTOR_DIRECTION_BACK, // kDirUp
ACTOR_DIRECTION_RIGHT, // kkDirUpRight
ACTOR_DIRECTION_RIGHT, // kDirRight
@@ -66,6 +65,18 @@
ACTOR_DIRECTION_LEFT, // kDirUpLeft
};
+PathDirectionData pathDirectionLUT[8][4] = {
+ {{0, 0, -1}, {7, -1, -1}, {4, 1, -1}},
+ {{1, 1, 0}, {4, 1, -1}, {5, 1, 1}},
+ {{2, 0, 1}, {5, 1, 1}, {6, -1, 1}},
+ {{3, -1, 0}, {6, -1, 1}, {7, -1, -1}},
+ {{0, 0, -1}, {1, 1, 0}, {4, 1, -1}},
+ {{1, 1, 0}, {2, 0, 1}, {5, 1, 1}},
+ {{2, 0, 1}, {3, -1, 0}, {6, -1, 1}},
+ {{3, -1, 0}, {0, 0, -1}, {7, -1, -1}}
+};
+
+
Actor::Actor(SagaEngine *vm) : _vm(vm) {
int i;
ActorData *actor;
@@ -73,6 +84,18 @@
_centerActor = _protagonist = NULL;
_lastTickMsec = 0;
+
+ _yCellCount = _vm->getStatusYOffset() - _vm->getPathYOffset();
+ _xCellCount = _vm->getDisplayWidth() / 2;
+
+ _pathCellCount = _yCellCount * _xCellCount;
+ _pathCell = (byte*)malloc(_pathCellCount);
+
+ _pathRect.left = 0;
+ _pathRect.right = _vm->getDisplayWidth();
+ _pathRect.top = _vm->getPathYOffset();
+ _pathRect.bottom = _vm->getStatusYOffset() - _vm->getPathYOffset();
+
// Get actor resource file context
_actorContext = _vm->getFileContext(GAME_RESOURCEFILE, 0);
if (_actorContext == NULL) {
@@ -112,6 +135,7 @@
ActorData *actor;
debug(9, "Actor::~Actor()");
+ free(_pathCell);
//release resources
for (i = 0; i < ACTORCOUNT; i++) {
actor = &_actors[i];
@@ -175,7 +199,7 @@
i = _vm->_sprite->getListLen(actor->spriteList);
- if ( (lastFrame >= i)) {
+ if (lastFrame >= i) {
debug(9, "Appending to sprite list 0x%X", actor->spriteListResourceId);
if (_vm->_sprite->appendList(actor->spriteListResourceId + 1, actor->spriteList) != SUCCESS) {
warning("Unable append sprite list");
@@ -244,7 +268,7 @@
if ((actor->facingDirection < kDirUp) || (actor->facingDirection > kDirUpLeft))
error("Actor::getActorFrameRange Wrong direction 0x%X actorId 0x%X", actor->facingDirection, actorId);
- fourDirection = ActorDirectectionsLUT[actor->facingDirection];
+ fourDirection = actorDirectectionsLUT[actor->facingDirection];
return &actor->frames[frameType].directions[fourDirection];
}
@@ -343,7 +367,10 @@
ActorData *actor;
ActorFrameRange *frameRange;
int state;
-
+ int speed;
+ ActorLocation delta;
+ ActorLocation addDelta;
+
for (i = 0; i < ACTORCOUNT; i++) {
actor = &_actors[i];
if (actor->disabled) continue;
@@ -354,7 +381,7 @@
switch(actor->currentAction) {
case kActionWait: {
if (!setup && (actor->flags & kFollower)) {
- //todo: followProtagonist
+ followProtagonist(actor);
if (actor->currentAction != kActionWait)
break;
}
@@ -364,7 +391,7 @@
}
if (actor->flags & kCycle) {
- frameRange = getActorFrameRange( actor->actorId, kFrameStand);
+ frameRange = getActorFrameRange(actor->actorId, kFrameStand);
if (frameRange->frameCount > 0) {
actor->actionCycle++;
actor->actionCycle = (actor->actionCycle) % frameRange->frameCount;
@@ -378,9 +405,9 @@
if ((actor->actionCycle & 3) == 0) {
actor->cycleWrap(100);
- frameRange = getActorFrameRange( actor->actorId, kFrameWait);
+ frameRange = getActorFrameRange(actor->actorId, kFrameWait);
if ((frameRange->frameCount < 1 || actor->actionCycle > 33))
- frameRange = getActorFrameRange( actor->actorId, kFrameStand);
+ frameRange = getActorFrameRange(actor->actorId, kFrameStand);
if (frameRange->frameCount) {
actor->frameNumber = frameRange->frameIndex + (uint16)rand() % frameRange->frameCount;
@@ -392,8 +419,87 @@
} break;
case kActionWalkToPoint:
case kActionWalkToLink: {
- //todo: do it
- debug(9,"kActionWalk* not implemented");
+ // tiled stuff
+ if (_vm->_scene->getMode() == SCENE_MODE_ISO) {
+ //todo: it
+ } else {
+ actor->partialTarget.delta(actor->location, delta);
+
+ while ((delta.x == 0) && (delta.y == 0)) {
+ int xstep;
+
+ if (actor->walkStepIndex >= actor->walkStepsCount) {
+ actorEndWalk(actor->actorId, true);
+ break;
+ }
+
+ xstep = actor->walkPath[actor->walkStepIndex++];
+ if (xstep > 256-32) {
+ xstep -= 256;
+ }
+
+ actor->partialTarget.x = xstep * 2 * ACTOR_LMULT;
+ actor->partialTarget.y = actor->walkPath[actor->walkStepIndex++] * ACTOR_LMULT;
+ actor->partialTarget.z = 0;
+
+ actor->partialTarget.delta(actor->location, delta);
+
+ if (ABS(delta.y) > ABS(delta.x)) {
+ actor->actionDirection = delta.y > 0 ? kDirDown : kDirUp;
+ } else {
+ actor->actionDirection = delta.x > 0 ? kDirRight : kDirLeft;
+ }
+ }
+
+ speed = (ACTOR_LMULT * 2 * actor->screenScale + 63) / 256;
+ if (speed < 1) {
+ speed = 1;
+ }
+
+ if ((actor->actionDirection == kDirUp) || (actor->actionDirection == kDirDown)) { // move by 2's in vertical dimension
+ addDelta.y = clamp(-speed, delta.y, speed);
+ if (addDelta.y == delta.y) {
+ addDelta.x = delta.x;
+ } else {
+ addDelta.x = delta.x * addDelta.y;
+ addDelta.x += (addDelta.x > 0) ? (delta.y / 2) : (-delta.y / 2);
+ addDelta.x /= delta.y;
+ actor->facingDirection = actor->actionDirection;
+ }
+ } else {
+ addDelta.x = clamp(-2 * speed, delta.x, 2 * speed);
+ if (addDelta.x == delta.x) {
+ addDelta.y = delta.y;
+ } else {
+ addDelta.y = delta.y * addDelta.x;
+ addDelta.y += (addDelta.y > 0) ? (delta.x / 2) : (-delta.x / 2);
+ addDelta.y /= delta.x;
+ actor->facingDirection = actor->actionDirection;
+ }
+ }
+
+ actor->location.add(addDelta);
+ }
+
+
+ if (actor->actorFlags & kActorBackwards) {
+ actor->facingDirection = (actor->actionDirection + 4) & 7;
+ actor->actionCycle--;
+ } else {
+ actor->actionCycle++;
+ }
+
+ frameRange = getActorFrameRange(actor->actorId, actor->walkFrameSequence);
+
+ if (actor->actionCycle < 0) {
+ actor->actionCycle = frameRange->frameCount - 1;
+ } else {
+ if (actor->actionCycle >= frameRange->frameCount) {
+ actor->actionCycle = 0;
+ }
+ }
+
+ actor->frameNumber = frameRange->frameIndex + actor->actionCycle;
} break;
case kActionWalkDir: {
debug(9,"kActionWalkDir not implemented");
@@ -403,15 +509,15 @@
actor->actionCycle++;
actor->cycleWrap(64);
- frameRange = getActorFrameRange( actor->actorId, kFrameGesture);
+ frameRange = getActorFrameRange(actor->actorId, kFrameGesture);
if (actor->actionCycle >= frameRange->frameCount) {
if (actor->actionCycle & 1) break;
- frameRange = getActorFrameRange( actor->actorId, kFrameSpeak);
+ frameRange = getActorFrameRange(actor->actorId, kFrameSpeak);
state = (uint16)rand() % (frameRange->frameCount + 1);
if (state == 0) {
- frameRange = getActorFrameRange( actor->actorId, kFrameStand);
+ frameRange = getActorFrameRange(actor->actorId, kFrameStand);
} else {
state--;
}
@@ -436,7 +542,7 @@
actor->cycleTimeCount = actor->cycleDelay;
actor->actionCycle++;
- frameRange = getActorFrameRange( actor->actorId, actor->cycleFrameSequence);
+ frameRange = getActorFrameRange(actor->actorId, actor->cycleFrameSequence);
if (actor->currentAction == kActionPongFrames) {
if (actor->actionCycle >= frameRange->frameCount * 2 - 2) {
@@ -507,11 +613,10 @@
void Actor::calcActorScreenPosition(ActorData * actor) {
int beginSlope, endSlope, middle;
- // tiled stuff
- {
- }
- {
- middle = ITE_STATUS_Y - actor->location.y / ACTOR_LMULT;
+ if (_vm->_scene->getMode() == SCENE_MODE_ISO) {
+ //todo: it
+ } else {
+ middle = _vm->getStatusYOffset() - actor->location.y / ACTOR_LMULT;
_vm->_scene->getSlopes(beginSlope, endSlope);
@@ -582,10 +687,11 @@
continue;
}
- // tiled stuff
- {
+ if (_vm->_scene->getMode() == SCENE_MODE_ISO) {
+ //todo: it
+ } else {
+ _vm->_sprite->drawOccluded(back_buf, spriteList, frameNumber, actor->screenPosition, actor->screenScale, actor->screenDepth);
}
- _vm->_sprite->drawOccluded(back_buf, spriteList, frameNumber, actor->screenPosition, actor->screenScale, actor->screenDepth);
}
// draw speeches
@@ -640,6 +746,85 @@
}
bool Actor::followProtagonist(ActorData * actor) {
+ ActorLocation protagonistLocation;
+ ActorLocation newLocation;
+ ActorLocation delta;
+ int protagonistBGMaskType;
+ Point prefer1;
+ Point prefer2;
+ Point prefer3;
+
+ assert(_protagonist);
+
+ actor->flags &= ~(kFaster | kFastest);
+ protagonistLocation = _protagonist->location;
+
+ if (_vm->_scene->getMode() == SCENE_MODE_ISO) {
+ //todo: it
+ } else {
+ prefer1.x = (100 * _protagonist->screenScale) >> 8;
+ prefer1.y = (50 * _protagonist->screenScale) >> 8;
+
+ if (_protagonist->currentAction == kActionWalkDir) {
+ prefer1.x /= 2;
+ }
+
+ if (prefer1.x < 8) {
+ prefer1.x = 8;
+ }
+
+ if (prefer1.y < 8) {
+ prefer1.y = 8;
+ }
+
+ prefer2.x = prefer1.x * 2;
+ prefer2.y = prefer1.y * 2;
+ prefer3.x = prefer1.x + prefer1.x / 2;
+ prefer3.y = prefer1.y + prefer1.y / 2;
+
+ actor->location.delta(protagonistLocation, delta);
+
+ calcActorScreenPosition(_protagonist);
+ protagonistBGMaskType = _vm->_scene->getBGMaskType(_protagonist->screenPosition);
+
+
+ if ((rand() & 0x7) == 0)
+ actor->actorFlags &= ~kActorNoFollow;
+
+ if (actor->actorFlags & kActorNoFollow) {
+ return false;
+ }
+
+ if ((delta.x > prefer2.x) || (delta.x < -prefer2.x) ||
+ (delta.y > prefer2.y) || (delta.y < -prefer2.y) ||
+ ((_protagonist->currentAction == kActionWait) &&
+ (delta.x * 2 < prefer1.x) && (delta.x * 2 > -prefer1.x) &&
+ (delta.y < prefer1.y) && (delta.y > -prefer1.y))) {
+
+ if (ABS(delta.x) > ABS(delta.y)) {
+
+ delta.x = (delta.x > 0) ? prefer3.x : -prefer3.x;
+
+ newLocation.x = delta.x + protagonistLocation.x;
+ newLocation.y = clamp(-prefer2.y, delta.y, prefer2.y) + protagonistLocation.y;
+ } else {
+ delta.y = (delta.y > 0) ? prefer3.y : -prefer3.y;
+
+ newLocation.x = clamp(-prefer2.x, delta.x, prefer2.x) + protagonistLocation.x;
+ newLocation.y = delta.y + protagonistLocation.y;
+ }
+ newLocation.z = 0;
+
+ if (protagonistBGMaskType != 3) {
+ newLocation.x += (rand() % prefer1.x) - prefer1.x / 2;
+ newLocation.y += (rand() % prefer1.y) - prefer1.y / 2;
+ }
+
+ newLocation.x = clamp(-31*4, newLocation.x, (_vm->getDisplayWidth() + 31) * 4); //fixme
+
+ return actorWalkTo(actor->actorId, newLocation);
+ }
+ }
return false;
}
@@ -680,27 +865,154 @@
bool Actor::actorWalkTo(uint16 actorId, const ActorLocation &toLocation) {
ActorData *actor;
+ ActorData *anotherActor;
+ int i;
+
+ Rect testBox;
+ Rect testBox2;
+ Point anotherActorScreenPosition;
+ Point collision;
+ Point pointFrom, pointTo, pointBest, pointAdd;
+ Point delta, bestDelta;
+ bool extraStartNode;
+ bool extraEndNode;
actor = getActor(actorId);
+ if (actor == _protagonist) {
+ _vm->_scene->setDoorState(2, 0xff);
+ _vm->_scene->setDoorState(3, 0);
+ } else {
+ _vm->_scene->setDoorState(2, 0);
+ _vm->_scene->setDoorState(3, 0xff);
+ }
- // tiled stuff
- {
+ if (_vm->_scene->getMode() == SCENE_MODE_ISO) {
//todo: it
- }
- {
- Point pointFrom, pointTo;
+ } else {
pointFrom.x = actor->location.x / ACTOR_LMULT;
pointFrom.y = actor->location.y / ACTOR_LMULT;
+ extraStartNode = _vm->_scene->offscreenPath(pointFrom);
pointTo.x = toLocation.x / ACTOR_LMULT;
pointTo.y = toLocation.y / ACTOR_LMULT;
+ extraEndNode = _vm->_scene->offscreenPath(pointTo);
if (_vm->_scene->isBGMaskPresent()) {
- //todo: it
+
+ if ((((actor->currentAction >= kActionWalkToPoint) &&
+ (actor->currentAction <= kActionWalkDir)) || (actor == _protagonist)) &&
+ !_vm->_scene->canWalk(pointFrom)) {
+ for (i = 1; i < 8; i++) {
+ pointAdd = pointFrom;
+ pointAdd.y += i;
+ if (_vm->_scene->canWalk(pointAdd)) {
+ pointFrom = pointAdd;
+ break;
+ }
+ pointAdd = pointFrom;
+ pointAdd.y -= i;
+ if (_vm->_scene->canWalk(pointAdd)) {
+ pointFrom = pointAdd;
+ break;
+ }
+ pointAdd = pointFrom;
+ pointAdd.x += i;
+ if (_vm->_scene->canWalk(pointAdd)) {
+ pointFrom = pointAdd;
+ break;
+ }
+ pointAdd = pointFrom;
+ pointAdd.x -= i;
+ if (_vm->_scene->canWalk(pointAdd)) {
+ pointFrom = pointAdd;
+ break;
+ }
+ }
+ }
+
+ if (!(actor->actorFlags & kActorNoCollide)) {
+ collision.x = ACTOR_COLLISION_WIDTH * actor->screenScale / (256 * 2);
+ collision.y = ACTOR_COLLISION_HEIGHT * actor->screenScale / (256 * 2);
+
+ _barrierCount = 0;
+
+ for (i = 0; (i < ACTORCOUNT) && (_barrierCount < ACTOR_BARRIERS_MAX); i++) {
+ anotherActor = &_actors[i];
+ if (anotherActor->disabled) continue;
+ if (anotherActor->sceneNumber != _vm->_scene->currentSceneNumber()) continue;
+ if (anotherActor == actor ) continue;
+
+
+ anotherActorScreenPosition = anotherActor->screenPosition;
+ testBox.left = (anotherActorScreenPosition.x - collision.x) & ~1;
+ testBox.right = (anotherActorScreenPosition.x + collision.x) & ~1;
+ testBox.top = anotherActorScreenPosition.y - collision.y;
+ testBox.bottom = anotherActorScreenPosition.y + collision.y;
+ testBox2 = testBox;
+ testBox2.right += 2;
+ testBox2.left -= 1;
+ testBox2.bottom += 1;
+
+ if (testBox2.contains(pointFrom)) {
+ if (pointFrom.x > anotherActorScreenPosition.x + 4) {
+ testBox.right = pointFrom.x - 2;
+ } else {
+ if (pointFrom.x < anotherActorScreenPosition.x - 4) {
+ testBox.left = pointFrom.x + 2;
+ } else {
+ if (pointFrom.y > anotherActorScreenPosition.y) {
+ testBox.bottom = pointFrom.y - 1;
+ } else {
+ testBox.top = pointFrom.y + 1 ;
+ }
+ }
+ }
+ }
+
+ if ((testBox.left <= testBox.right) && (testBox.top <= testBox.bottom)) {
+ _barrierList[_barrierCount++] = testBox;
+ }
+ }
+ }
+
+
+ pointBest = pointTo;
+ actor->walkStepsCount = 0;
+ findActorPath(actor, pointFrom, pointTo);
+
+ if (extraStartNode) {
+ actor->walkStepIndex = 0;
+ } else {
+ actor->walkStepIndex = 2;
+ }
+
+ if (extraEndNode) {
+ actor->walkPath[actor->walkStepsCount - 2] = pointTo.x / (ACTOR_LMULT * 2);
+ actor->walkPath[actor->walkStepsCount - 1] = pointTo.y / ACTOR_LMULT;
+ }
+
+ pointBest.x = actor->walkPath[actor->walkStepsCount - 2] * 2;
+ pointBest.y = actor->walkPath[actor->walkStepsCount - 1];
+
+ pointFrom.x &= ~1;
+ delta.x = ABS(pointFrom.x - pointTo.x);
+ delta.y = ABS(pointFrom.y - pointTo.y);
+
+ bestDelta.x = ABS(pointBest.x - pointTo.x);
+ bestDelta.y = ABS(pointBest.y - pointTo.y);
+
+ if (delta.x + delta.y <= bestDelta.x + bestDelta.y) {
+ if (actor->flags & kFollower)
+ actor->actorFlags |= kActorNoFollow;
+ }
+
+ if (pointBest == pointFrom) {
+ actor->walkStepsCount = 0;
+ }
} else {
actor->walkPath[0] = pointTo.x / 2;
actor->walkPath[1] = pointTo.y;
@@ -717,8 +1029,7 @@
if (actor->flags & kProtagonist) {
_actors[1].actorFlags &= ~kActorNoFollow;
_actors[2].actorFlags &= ~kActorNoFollow;
- }
-
+ }
actor->currentAction = (actor->walkStepsCount == ACTOR_STEPS_COUNT) ? kActionWalkToLink : kActionWalkToPoint;
actor->walkFrameSequence = kFrameWalk;
}
@@ -798,6 +1109,206 @@
_activeSpeech.playingTime = 0;
}
+void Actor::findActorPath(ActorData * actor, const Point &pointFrom, const Point &pointTo) {
+ Point tempPoint;
+ Point iteratorPoint;
+ Point bestPoint;
+ Point maskPoint;
+ int maskType1, maskType2;
+ byte cellValue;
+ int i;
+ Rect intersect;
+
+ tempPoint.y = pointTo.y;
+ tempPoint.x = pointTo.x >> 1;
+
+ actor->walkStepsCount = 0;
+ if (pointFrom == pointTo) {
+ actor->addWalkPath(tempPoint.x, tempPoint.y);
+ return;
+ }
+
+ for (iteratorPoint.y = 0; iteratorPoint.y < _yCellCount; iteratorPoint.y++) {
+ maskPoint.y = iteratorPoint.y + _vm->getPathYOffset();
+ for (iteratorPoint.x = 0; iteratorPoint.x < _xCellCount; iteratorPoint.x++) {
+ maskPoint.x = iteratorPoint.x * 2;
+ maskType1 = _vm->_scene->getBGMaskType(maskPoint);
+ maskPoint.x += 1;
+ maskType2 = _vm->_scene->getBGMaskType(maskPoint);
+ cellValue = (maskType1 | maskType2) ? 'W' : -1;
+ setPathCell(iteratorPoint, cellValue);
+ }
+ }
+
+ for (i = 0; i < _barrierCount; i++) {
+ intersect.left = MAX(_pathRect.left, _barrierList[i].left);
+ intersect.top = MAX(_pathRect.top, _barrierList[i].top);
+ intersect.right = MIN(_pathRect.right, _barrierList[i].right);
+ intersect.bottom = MIN(_pathRect.bottom, _barrierList[i].bottom);
+
+ intersect.left >>= 1;
+ intersect.top -= _vm->getPathYOffset();
+ intersect.right >>= 1;
+ intersect.bottom -= _vm->getPathYOffset();
+
+ for (iteratorPoint.y = intersect.top; iteratorPoint.y < intersect.bottom; iteratorPoint.y++) {
+ for (iteratorPoint.x = 0; iteratorPoint.x < _xCellCount; iteratorPoint.x++) {
+ setPathCell(iteratorPoint, 'W');
+ }
+ }
+ }
+
+
+
+ if (scanPathLine(pointFrom, pointTo)) {
+ iteratorPoint.y = pointFrom.y;
+ iteratorPoint.x = pointFrom.x >> 1;
+ actor->addWalkPath(iteratorPoint.x, iteratorPoint.y);
+ actor->addWalkPath(tempPoint.x, tempPoint.y);
+ return;
+ }
+
+
+ i = fillPathArray(pointFrom, pointTo, bestPoint);
+
+ if (pointFrom == bestPoint) {
+ iteratorPoint.y = bestPoint.y;
+ iteratorPoint.x = bestPoint.x >> 1;
+ actor->addWalkPath(iteratorPoint.x, iteratorPoint.y);
+ return;
+ }
+/*
+ if (i != 0)
+ result = SetPath(pcell, from, &bestpoint, nodelist);
+*/
+}
+
+bool Actor::scanPathLine(const Point &point1, const Point &point2) {
+ Point point;
+ Point delta;
+ bool interchange = false;
+ Point fDelta;
+ Point iteratorPoint;
+ int errterm;
+ int s1;
+ int s2;
+ int i;
+
+ point = point1;
+ delta.x = ABS(point1.x - point2.x);
+ delta.y = ABS(point1.y - point2.y);
+ s1 = integerCompare(point2.x, point1.x);
+ s2 = integerCompare(point2.y, point1.y);
+
+ if (delta.y > delta.x) {
+ SWAP(delta.y, delta.x);
+ interchange = true;
+ }
+
+ fDelta.x = delta.x * 2;
+ fDelta.y = delta.y * 2;
+
+ errterm = fDelta.y - delta.x;
+
+ for (i = 0; i < delta.x; i++) {
+ while (errterm >= 0) {
+ if (interchange) {
+ point.x += s1;
+ } else {
+ point.y += s2;
+ }
+ errterm -= fDelta.x;
+ }
+
+ if (interchange)
+ point.y += s2;
+ else
+ point.x += s1;
+
+ errterm += fDelta.y;
+
+ iteratorPoint.x = point.x >> 1;
+ iteratorPoint.y = point.y - _vm->getPathYOffset();
+ if (getPathCell(iteratorPoint) == 'W')
+ return false;
+ }
+ return true;
+}
+
+int Actor::fillPathArray(const Point &pointFrom, const Point &pointTo, Point &bestPoint) {
+ Point pathFrom;
+ Point pathTo;
+ int bestRating;
+ int currentRating;
+ Point bestPath;
+ int pointCounter;
+ int startDirection;
+ PathDirectionList pathDirectionList;
+ PathDirectionData *pathDirection;
+ PathDirectionData *samplePathDirection;
+ PathDirectionList::iterator pathDirectionIterator;
+ PathDirectionList::iterator newPathDirectionIterator;
+ int directionCount;
+
+
+ pathFrom.x = pointFrom.x >> 1;
+ pathFrom.y = pointFrom.y - _vm->getPathYOffset();
+
+ pathTo.x = pointTo.x >> 1;
+ pathTo.y = pointTo.y - _vm->getPathYOffset();
+
+ pointCounter = 0;
+ bestRating = quickDistance(pathFrom, pathTo);
+ bestPath = pathFrom;
+
+ for (startDirection = 0; startDirection < 4; startDirection++) {
+ newPathDirectionIterator = pathDirectionList.pushBack();
+ pathDirection = newPathDirectionIterator.operator->();
+ pathDirection->x = pathFrom.x;
+ pathDirection->y = pathFrom.y;
+ pathDirection->direction = startDirection;
+ }
+ setPathCell(pathFrom, 0);
+
+ pathDirectionIterator = pathDirectionList.begin();
+
+ do {
+ pathDirection = pathDirectionIterator.operator->();
+ for (directionCount = 0; directionCount < 4; directionCount++) {
+ samplePathDirection = &pathDirectionLUT[pathDirection->direction][directionCount];
+ Point nextPoint;
+ nextPoint.x = samplePathDirection->x + pathDirection->x;
+ nextPoint.y = samplePathDirection->y + pathDirection->y;
+ if ((nextPoint.x >= 0) && (nextPoint.y >= 0) && (nextPoint.x < _xCellCount) && (nextPoint.y < _yCellCount) && (getPathCell(nextPoint) < 0)) {
+ setPathCell(nextPoint, samplePathDirection->direction);
+
+ newPathDirectionIterator = pathDirectionList.pushBack();
+ pathDirection = newPathDirectionIterator.operator->();
+ pathDirection->x = nextPoint.x;
+ pathDirection->y = nextPoint.y;
+ pathDirection->direction = samplePathDirection->direction;
+ ++pointCounter;
+ if (nextPoint == pathTo) {
+ bestPoint.x = pointTo.x & ~1;
+ bestPoint.y = pointTo.y;
+ return pointCounter;
+ }
+ currentRating = quickDistance(nextPoint, pathTo);
+ if (currentRating < bestRating) {
+ bestRating = currentRating;
+ bestPath = nextPoint;
+ }
+ }
+ }
+ ++pathDirectionIterator;
+ } while (pathDirectionIterator != pathDirectionList.end());
+
+ bestPoint.x = bestPath.x * 2;
+ bestPoint.y = bestPath.y + _vm->getPathYOffset();
+
+ return pointCounter;
+}
+
/*
// Console wrappers - must be safe to run
// TODO - checkup ALL arguments, cause wrong arguments may fall function with "error"
Index: actor.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/saga/actor.h,v
retrieving revision 1.28
retrieving revision 1.29
diff -u -d -r1.28 -r1.29
--- actor.h 25 Dec 2004 13:19:45 -0000 1.28
+++ actor.h 28 Dec 2004 21:27:17 -0000 1.29
@@ -32,18 +32,18 @@
namespace Saga {
-#define ACTOR_BASE_SPEED 0.25
-#define ACTOR_BASE_ZMOD 0.5
+#define ACTOR_BARRIERS_MAX 16
#define ACTOR_STEPS_COUNT 32
#define ACTOR_STEPS_MAX (ACTOR_STEPS_COUNT*2)
-#define ACTOR_ACTIONTIME 80
-
#define ACTOR_DIALOGUE_HEIGHT 100
#define ACTOR_LMULT 4
+#define ACTOR_COLLISION_WIDTH 32
+#define ACTOR_COLLISION_HEIGHT 8
+
#define ACTOR_DIRECTIONS_COUNT 4 // for ActorFrameSequence
#define ACTOR_DIRECTION_RIGHT 0
#define ACTOR_DIRECTION_LEFT 1
@@ -112,6 +112,14 @@
};
+struct PathDirectionData {
+ int direction;
+ int x;
+ int y;
+};
+
+typedef SortedList<PathDirectionData> PathDirectionList;
+
struct ActorFrameRange {
int frameIndex;
int frameCount;
@@ -125,10 +133,24 @@
int x; // Actor's logical coordinates
int y; //
int z; //
+ ActorLocation() {
+ x = y = z = 0;
+ }
int distance(const ActorLocation &location) {
- return MAX(abs(x - location.x), abs(y - location.y));
+ return MAX(ABS(x - location.x), ABS(y - location.y));
+ }
+ void delta(const ActorLocation &location, ActorLocation &result) {
+ result.x = x - location.x;
+ result.y = x - location.y;
+ result.z = z - location.z;
+ }
+ void add(const ActorLocation &location) {
+ x += location.x;
+ y += location.y;
+ z += location.z;
}
};
+
struct ActorData {
bool disabled; // Actor disabled in init section
int index; // Actor index
@@ -176,6 +198,12 @@
if (actionCycle >= cycleLimit)
actionCycle = 0;
}
+ void addWalkPath(int x, int y) {
+ if (walkStepsCount + 2 > ACTOR_STEPS_MAX)
+ error("walkStepsCount exceeds");
+ walkPath[walkStepsCount++] = x;
+ walkPath[walkStepsCount++] = y;
+ }
ActorData() {
memset(this, 0xFE, sizeof(*this));
@@ -248,17 +276,40 @@
void createDrawOrderList();
void calcActorScreenPosition(ActorData * actor);
bool followProtagonist(ActorData * actor);
+ void findActorPath(ActorData * actor, const Point &pointFrom, const Point &pointTo);
void handleSpeech(int msec);
void handleActions(int msec, bool setup);
-
+ void setPathCell(const Point &testPoint, byte value) {
+ _pathCell[testPoint.x + testPoint.y * _xCellCount] = value;
+ }
+ byte getPathCell(const Point &testPoint) {
+ return _pathCell[testPoint.x + testPoint.y * _xCellCount];
+ }
+ bool scanPathLine(const Point &point1, const Point &point2);
+ int fillPathArray(const Point &pointFrom, const Point &pointTo, Point &bestPoint);
+
int _lastTickMsec;
SagaEngine *_vm;
RSCFILE_CONTEXT *_actorContext;
ActorOrderList _drawOrderList;
ActorData _actors[ACTORCOUNT];
SpeechData _activeSpeech;
+ Rect _barrierList[ACTOR_BARRIERS_MAX];
+ int _barrierCount;
+ byte *_pathCell;
+ int _pathCellCount;
+ int _xCellCount;
+ int _yCellCount;
+ Rect _pathRect;
+
};
+inline int16 quickDistance(const Point &point1, const Point &point2) {
+ Point delta;
+ delta.x = ABS(point1.x - point2.x);
+ delta.y = ABS(point1.y - point2.y);
+ return ((delta.x < delta.y) ? (delta.y + delta.x / 2) : (delta.x + delta.y / 2));
+}
} // End of namespace Saga
#endif
Index: events.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/saga/events.cpp,v
retrieving revision 1.36
retrieving revision 1.37
diff -u -d -r1.36 -r1.37
--- events.cpp 28 Dec 2004 04:09:10 -0000 1.36
+++ events.cpp 28 Dec 2004 21:27:17 -0000 1.37
@@ -178,7 +178,7 @@
size_t len;
_vm->_render->getBufferInfo(&buf_info);
- _vm->_scene->getBGMaskInfo(&w, &h, &mask_buf, &len);
+ _vm->_scene->getBGMaskInfo(w, h, mask_buf, len);
_vm->transitionDissolve(buf_info.bg_buf, buf_info.bg_buf_w,
buf_info.bg_buf_h, buf_info.bg_buf_w, mask_buf, w, h, 0, 1,
(320 - w) / 2, (200 - h) / 2, event_pc);
Index: game.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/saga/game.cpp,v
retrieving revision 1.41
retrieving revision 1.42
diff -u -d -r1.41 -r1.42
--- game.cpp 28 Dec 2004 17:43:23 -0000 1.41
+++ game.cpp 28 Dec 2004 21:27:17 -0000 1.42
@@ -790,6 +790,30 @@
return *GameModule.gamedesc->gd_soundinfo;
}
+int SagaEngine::getDisplayWidth() {
+ return GameDescs[GameModule.game_number].gd_logical_w;
+}
+
+int SagaEngine::getDisplayHeight() {
+ return GameDescs[GameModule.game_number].gd_logical_h;
+}
+
+int SagaEngine::getPathYOffset() { //fixme: should be in GameDesc
+ if (_gameType == GType_ITE) {
+ return 35;
+ } else {
+ return 35; //fixme i don't know exact value
+ }
+}
+
+int SagaEngine::getStatusYOffset() { //fixme: should be in GameDesc
+ if (_gameType == GType_ITE) {
+ return ITE_STATUS_Y;
+ } else {
+ return IHNM_STATUS_Y;
+ }
+}
+
int SagaEngine::getDisplayInfo(GAME_DISPLAYINFO *disp_info) {
int game_n;
Index: saga.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/saga/saga.h,v
retrieving revision 1.57
retrieving revision 1.58
diff -u -d -r1.57 -r1.58
--- saga.h 28 Dec 2004 03:44:07 -0000 1.57
+++ saga.h 28 Dec 2004 21:27:17 -0000 1.58
@@ -215,6 +215,22 @@
return tick * 1000 / kScriptTimeTicksPerSecond;
}
+inline int clamp(int minValue, int value, int maxValue) {
+ if (value <= minValue) {
+ return minValue;
+ } else {
+ if (value >= maxValue) {
+ return maxValue;
+ } else {
+ return value;
+ }
+ }
+}
+
+inline int integerCompare(int i1, int i2) {
+ return ((i1) > (i2) ? 1 : ((i1) < (i2) ? -1 : 0));
+}
+
class SagaEngine : public Engine {
void errorString(const char *buf_input, char *buf_output);
@@ -298,7 +314,10 @@
const GAME_SOUNDINFO getSoundInfo(void);
int getDisplayInfo(GAME_DISPLAYINFO *disp_info);
int getSceneInfo(GAME_SCENEDESC *);
-
+ int getDisplayWidth();
+ int getDisplayHeight();
+ int getStatusYOffset();
+ int getPathYOffset();
private:
int loadLanguage(void);
int loadGame(int game_n_p);
Index: scene.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/saga/scene.cpp,v
retrieving revision 1.63
retrieving revision 1.64
diff -u -d -r1.63 -r1.64
--- scene.cpp 28 Dec 2004 03:44:07 -0000 1.63
+++ scene.cpp 28 Dec 2004 21:27:17 -0000 1.64
@@ -318,8 +318,8 @@
}
void Scene::getSlopes(int &beginSlope, int &endSlope) {
- beginSlope = ITE_STATUS_Y - _desc.beginSlope; // fixme: implement also IHNM_STATUS_Y
- endSlope = ITE_STATUS_Y - _desc.endSlope;
+ beginSlope = _vm->getStatusYOffset() - _desc.beginSlope;
+ endSlope = _vm->getStatusYOffset() - _desc.endSlope;
}
int Scene::getBGInfo(SCENE_BGINFO *bginfo) {
@@ -359,25 +359,132 @@
return SUCCESS;
}
-int Scene::getBGMaskInfo(int *w, int *h, byte **buf, size_t *buf_len) {
- assert(_initialized);
+int Scene::getBGMaskType(const Point &testPoint) {
+ uint offset;
+ if (!_bgMask.loaded) {
+ return 0;
+ }
+ offset = testPoint.x + testPoint.y * _vm->getDisplayWidth();
+ if (offset >= _bgMask.buf_len) {
+ error("Scene::getBGMaskType offset 0x%X exceed bufferLength 0x%X", offset, _bgMask.buf_len);
+ }
+
+ return (_bgMask.buf[offset] >> 4) & 0x0f;
+}
+bool Scene::canWalk(const Point &testPoint) {
+ int maskType;
if (!_bgMask.loaded) {
- return FAILURE;
+ return true;
}
+ if ((testPoint.x < 0) || (testPoint.x > _bgMask.w) ||
+ (testPoint.y < 0) || (testPoint.y > _bgMask.h)) {
+ return true;
+ }
+ maskType = getBGMaskType(testPoint);
+ return getDoorState(maskType) == 0;
+}
- *w = _bgMask.w;
- *h = _bgMask.h;
- *buf = _bgMask.buf;
- *buf_len = _bgMask.buf_len;
+bool Scene::offscreenPath(Point &testPoint) {
+ Point first;
+ Point second;
+ Point third;
+ int maskType;
- return SUCCESS;
+ if (!_bgMask.loaded) {
+ return false;
+ }
+
+
+ first.x = clamp( 0, testPoint.x, _vm->getDisplayWidth() - 1 );
+ first.y = clamp( 0, testPoint.y, _vm->getDisplayHeight() - 1 );
+ if (first == testPoint) {
+ return false;
+ }
+
+ if (first.y >= _vm->getDisplayHeight() - 1) {
+ first.y = 200 -1 - 1;
+ }
+ testPoint = first;
+
+ if (testPoint.y != first.y) {
+ second.x = third.x = testPoint.x;
+ second.y = third.y = first.y;
+ for (;; second.x--, third.x++ ) {
+ if (second.x > 1) {
+ maskType = getBGMaskType(second);
+ if (getDoorState(maskType) == 0) {
+ testPoint.x = second.x - 1;
+ break;
+ }
+ } else {
+ if (third.x >= _vm->getDisplayWidth()) {
+ return false;
+ }
+ }
+
+ if (third.x < _vm->getDisplayWidth()) {
+ maskType = getBGMaskType(third);
+ if (getDoorState(maskType) == 0) {
+ testPoint.x = third.x + 1;
+ break;
+ }
+ }
+ }
+ }
+
+ if (testPoint.x != first.x) {
+ second.y = third.y = testPoint.y;
+ second.x = third.x = first.x;
+ for (;; second.y--, third.y++ ) {
+ if (second.y > 1) {
+ maskType = getBGMaskType(second);
+ if (getDoorState(maskType) == 0) {
+ testPoint.y = second.y - 1;
+ break;
+ }
+ } else {
+ if (third.y > _vm->getDisplayHeight() - 1) {
+ return false;
+ }
+ }
+
+ if (third.y <= _vm->getDisplayHeight() - 1) {
+ maskType = getBGMaskType(third);
+ if (getDoorState(maskType) == 0) {
+ testPoint.y = third.y + 1;
+ break;
+ }
+ }
+ }
+ }
+ return true;
}
-int Scene::isBGMaskPresent() {
- assert(_initialized);
- return _bgMask.loaded;
+void Scene::getBGMaskInfo(int &width, int &height, byte *&buffer, size_t &bufferLength) {
+ if (!_bgMask.loaded) {
+ error("Scene::getBGMaskInfo _bgMask not loaded");
+ }
+
+ width = _bgMask.w;
+ height = _bgMask.h;
+ buffer = _bgMask.buf;
+ bufferLength = _bgMask.buf_len;
+}
+
+void Scene::setDoorState(int doorNumber, int doorState) {
+ if ((doorNumber < 0) || (doorNumber >= SCENE_DOORS_MAX))
+ error("Scene::setDoorState wrong doorNumber");
+
+ _sceneDoors[doorNumber] = doorState;
+}
+
+int Scene::getDoorState(int doorNumber) {
+ if ((doorNumber < 0) || (doorNumber >= SCENE_DOORS_MAX))
+ error("Scene::getDoorState wrong doorNumber");
+
+ return _sceneDoors[doorNumber];
}
int Scene::getInfo(SCENE_INFO *si) {
Index: script.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/saga/script.h,v
retrieving revision 1.37
retrieving revision 1.38
diff -u -d -r1.37 -r1.38
--- script.h 28 Dec 2004 04:09:10 -0000 1.37
+++ script.h 28 Dec 2004 21:27:17 -0000 1.38
@@ -319,11 +319,11 @@
int SF_setObjName(SCRIPTFUNC_PARAMS);
int SF_getObjImage(SCRIPTFUNC_PARAMS);
int SF_getNumber(SCRIPTFUNC_PARAMS);
- int SF_openDoor(SCRIPTFUNC_PARAMS);
- int SF_closeDoor(SCRIPTFUNC_PARAMS);
+ int sfScriptOpenDoor(SCRIPTFUNC_PARAMS);
+ int sfScriptCloseDoor(SCRIPTFUNC_PARAMS);
int sfSetBgdAnimSpeed(SCRIPTFUNC_PARAMS);
int SF_cycleColors(SCRIPTFUNC_PARAMS);
- int SF_centerActor(SCRIPTFUNC_PARAMS);
+ int sfDoCenterActor(SCRIPTFUNC_PARAMS);
int sfStartBgdAnimSpeed(SCRIPTFUNC_PARAMS);
int SF_actorWalkToAsync(SCRIPTFUNC_PARAMS);
int SF_enableZone(SCRIPTFUNC_PARAMS);
@@ -355,7 +355,7 @@
int SF_sceneID(SCRIPTFUNC_PARAMS);
int SF_changeActorScene(SCRIPTFUNC_PARAMS);
int SF_climb(SCRIPTFUNC_PARAMS);
- int SF_setDoorState(SCRIPTFUNC_PARAMS);
+ int sfSetDoorState(SCRIPTFUNC_PARAMS);
int SF_setActorZ(SCRIPTFUNC_PARAMS);
int SF_text(SCRIPTFUNC_PARAMS);
int SF_getActorX(SCRIPTFUNC_PARAMS);
Index: sfuncs.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/saga/sfuncs.cpp,v
retrieving revision 1.55
retrieving revision 1.56
diff -u -d -r1.55 -r1.56
--- sfuncs.cpp 28 Dec 2004 04:09:10 -0000 1.55
+++ sfuncs.cpp 28 Dec 2004 21:27:18 -0000 1.56
@@ -66,11 +66,11 @@
OPCODE(SF_setObjName),
OPCODE(SF_getObjImage),
OPCODE(SF_getNumber),
- OPCODE(SF_openDoor),
- OPCODE(SF_closeDoor),
+ OPCODE(sfScriptOpenDoor),
+ OPCODE(sfScriptCloseDoor),
OPCODE(sfSetBgdAnimSpeed),
OPCODE(SF_cycleColors),
- OPCODE(SF_centerActor),
+ OPCODE(sfDoCenterActor),
OPCODE(sfStartBgdAnimSpeed),
OPCODE(SF_actorWalkToAsync),
OPCODE(SF_enableZone),
@@ -102,7 +102,7 @@
OPCODE(SF_sceneID),
OPCODE(SF_changeActorScene),
OPCODE(SF_climb),
- OPCODE(SF_setDoorState),
+ OPCODE(sfSetDoorState),
OPCODE(SF_setActorZ),
OPCODE(SF_text),
OPCODE(SF_getActorX),
@@ -404,20 +404,30 @@
}
// Script function #21 (0x15)
-int Script::SF_openDoor(SCRIPTFUNC_PARAMS) {
- for (int i = 0; i < nArgs; i++)
- thread->pop();
+// Param1: door #
+int Script::sfScriptOpenDoor(SCRIPTFUNC_PARAMS) {
+ int doorNumber;
+ doorNumber = getUWord(thread->pop());
- debug(1, "stub: SF_openDoor(), %d args", nArgs);
+ if (_vm->_scene->getMode() == SCENE_MODE_ISO) {
+ //todo: it
+ } else {
+ _vm->_scene->setDoorState(doorNumber, 0);
+ }
return SUCCESS;
}
// Script function #22 (0x16)
-int Script::SF_closeDoor(SCRIPTFUNC_PARAMS) {
- for (int i = 0; i < nArgs; i++)
- thread->pop();
+// Param1: door #
+int Script::sfScriptCloseDoor(SCRIPTFUNC_PARAMS) {
+ int doorNumber;
+ doorNumber = getUWord(thread->pop());
- debug(1, "stub: SF_closeDoor(), %d args", nArgs);
+ if (_vm->_scene->getMode() == SCENE_MODE_ISO) {
+ //todo: it
+ } else {
+ _vm->_scene->setDoorState(doorNumber, 0xff);
+ }
return SUCCESS;
}
@@ -442,10 +452,12 @@
}
// Script function #25 (0x19)
-int Script::SF_centerActor(SCRIPTFUNC_PARAMS) {
- ScriptDataWord param = thread->pop();
+// Param1: actor id
+int Script::sfDoCenterActor(SCRIPTFUNC_PARAMS) {
+ uint16 actorId;
+ actorId = getSWord(thread->pop());
- debug(1, "stub: SF_centerActor(%d)", param);
+ _vm->_actor->_centerActor = _vm->_actor->getActor(actorId);
return SUCCESS;
}
@@ -986,11 +998,19 @@
}
// Script function #57 (0x39)
-int Script::SF_setDoorState(SCRIPTFUNC_PARAMS) {
- for (int i = 0; i < nArgs; i++)
- thread->pop();
+// Param1: door #
+// Param2: door state
+int Script::sfSetDoorState(SCRIPTFUNC_PARAMS) {
+ int doorNumber;
+ int doorState;
+ doorNumber = getUWord(thread->pop());
+ doorState = getUWord(thread->pop());
- debug(1, "stub: SF_setDoorState(), %d args", nArgs);
+ if (_vm->_scene->getMode() == SCENE_MODE_ISO) {
+ //todo: it
+ } else {
+ _vm->_scene->setDoorState(doorNumber, doorState);
+ }
return SUCCESS;
}
Index: sprite.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/saga/sprite.cpp,v
retrieving revision 1.32
retrieving revision 1.33
diff -u -d -r1.32 -r1.33
--- sprite.cpp 28 Dec 2004 21:04:58 -0000 1.32
+++ sprite.cpp 28 Dec 2004 21:27:18 -0000 1.33
@@ -286,10 +286,10 @@
CLIPINFO ci;
// BG mask variables
- int mask_w;
- int mask_h;
- byte *mask_buf;
- size_t mask_buf_len;
+ int maskWidth;
+ int maskHeight;
+ byte *maskBuffer;
+ size_t maskBufferLength;
byte *mask_row_p;
int mask_z;
@@ -326,7 +326,7 @@
sprite_data_p = sprite_p + readS.pos();
- _vm->_scene->getBGMaskInfo(&mask_w, &mask_h, &mask_buf, &mask_buf_len);
+ _vm->_scene->getBGMaskInfo(maskWidth, maskHeight, maskBuffer, maskBufferLength);
if (scale < 256)
scaleSpriteCoords(scale, &s_width, &s_height, &x_align, &y_align);
@@ -339,7 +339,7 @@
spr_dst_rect.left = 0;
spr_dst_rect.top = 0;
spr_dst_rect.right = ds->clip_rect.right;
- spr_dst_rect.bottom = MIN(ds->clip_rect.bottom, (int16)mask_h);
+ spr_dst_rect.bottom = MIN(ds->clip_rect.bottom, (int16)maskHeight);
spr_pt.x = screenCoord.x + x_align;
spr_pt.y = screenCoord.y + y_align;
@@ -363,7 +363,7 @@
src_row_p = _decodeBuf + ci.src_draw_x + (ci.src_draw_y * s_width);
dst_row_p = (byte *)ds->pixels + ci.dst_draw_x + (ci.dst_draw_y * ds->pitch);
- mask_row_p = mask_buf + ci.dst_draw_x + (ci.dst_draw_y * mask_w);
+ mask_row_p = maskBuffer + ci.dst_draw_x + (ci.dst_draw_y * maskWidth);
for (y = 0; y < ci.draw_h; y++) {
src_p = src_row_p;
@@ -381,7 +381,7 @@
mask_p++;
}
dst_row_p += ds->pitch;
- mask_row_p += mask_w;
+ mask_row_p += maskWidth;
src_row_p += s_width;
}
/*
More information about the Scummvm-git-logs
mailing list