aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--engines/sherlock/objects.cpp38
-rw-r--r--engines/sherlock/objects.h25
-rw-r--r--engines/sherlock/people.cpp12
-rw-r--r--engines/sherlock/people.h3
-rw-r--r--engines/sherlock/scalpel/scalpel.cpp18
-rw-r--r--engines/sherlock/scalpel/scalpel_map.cpp60
-rw-r--r--engines/sherlock/scalpel/scalpel_people.cpp30
-rw-r--r--engines/sherlock/scalpel/scalpel_scene.cpp74
-rw-r--r--engines/sherlock/scalpel/scalpel_talk.cpp2
-rw-r--r--engines/sherlock/scalpel/scalpel_user_interface.cpp14
-rw-r--r--engines/sherlock/scene.cpp22
-rw-r--r--engines/sherlock/talk.cpp14
-rw-r--r--engines/sherlock/tattoo/tattoo.cpp2
-rw-r--r--engines/sherlock/tattoo/tattoo.h1
-rw-r--r--engines/sherlock/tattoo/tattoo_people.cpp14
-rw-r--r--engines/sherlock/tattoo/tattoo_scene.cpp126
-rw-r--r--engines/sherlock/tattoo/tattoo_talk.cpp2
17 files changed, 310 insertions, 147 deletions
diff --git a/engines/sherlock/objects.cpp b/engines/sherlock/objects.cpp
index ee04644a9e..954dcc7884 100644
--- a/engines/sherlock/objects.cpp
+++ b/engines/sherlock/objects.cpp
@@ -328,7 +328,7 @@ void Sprite::checkSprite() {
break;
case WALK_AROUND:
- if (objBounds.contains(people[PLAYER]._walkTo.front())) {
+ if (objBounds.contains(people[HOLMES]._walkTo.front())) {
// Reached zone
gotoStand();
} else {
@@ -374,10 +374,10 @@ void Sprite::checkSprite() {
objBounds.right + CLEAR_DIST_X;
}
- walkPos.x += people[PLAYER]._imageFrame->_frame.w / 2;
+ walkPos.x += people[HOLMES]._imageFrame->_frame.w / 2;
people._walkDest = walkPos;
- people[PLAYER]._walkTo.push(walkPos);
- people[PLAYER].setWalking();
+ people[HOLMES]._walkTo.push(walkPos);
+ people[HOLMES].setWalking();
}
break;
@@ -1313,7 +1313,7 @@ int Object::checkNameForCodes(const Common::String &name, const char *const mess
scene._goToScene = 100;
}
- people[PLAYER]._position = Point32(0, 0);
+ people[HOLMES]._position = Point32(0, 0);
break;
}
} else if (name.hasPrefix("!")) {
@@ -1451,7 +1451,7 @@ int Object::pickUpObject(const char *const messages[]) {
} else {
// Play generic pickup sequence
// Original moved cursor position here
- people[PLAYER].goAllTheWay();
+ people[HOLMES].goAllTheWay();
ui._menuCounter = 25;
ui._temp1 = 1;
}
@@ -1596,17 +1596,37 @@ void CAnim::load3DO(Common::SeekableReadStream &s) {
/*----------------------------------------------------------------*/
CAnimStream::CAnimStream() {
- _stream = nullptr;
- _frameSize = 0;
_images = nullptr;
_imageFrame = nullptr;
+ _frameNumber = 0;
_flags = 0;
_scaleVal = 0;
_zPlacement = 0;
}
+CAnimStream::~CAnimStream() {
+ delete _images;
+}
+
+void CAnimStream::load(Common::SeekableReadStream *stream) {
+ delete _images;
+ _images = new ImageFile(*stream, false);
+ _imageFrame = &(*_images)[0];
+ _frameNumber = 0;
+}
+
+void CAnimStream::close() {
+ delete _images;
+ _images = nullptr;
+ _imageFrame = nullptr;
+ _frameNumber = 0;
+}
+
void CAnimStream::getNextFrame() {
- // TODO
+ if (++_frameNumber < (int)_images->size())
+ _imageFrame = &(*_images)[_frameNumber];
+ else
+ _imageFrame = nullptr;
}
/*----------------------------------------------------------------*/
diff --git a/engines/sherlock/objects.h b/engines/sherlock/objects.h
index 6035bb4ee6..935b4b3cb2 100644
--- a/engines/sherlock/objects.h
+++ b/engines/sherlock/objects.h
@@ -464,10 +464,8 @@ struct CAnim {
};
class CAnimStream {
- Common::SeekableReadStream *_stream; // Stream to read frames from
- int _frameSize; // Temporary used to store the frame size
-
- void *_images; // TOOD: FIgure out hwo to hook up ImageFile with streaming support
+ ImageFile *_images;
+ int _frameNumber;
public:
ImageFrame *_imageFrame;
@@ -480,8 +478,27 @@ public:
int _zPlacement; // Used by doBgAnim for determining Z order
public:
CAnimStream();
+ ~CAnimStream();
+
+ /**
+ * Load the animation's images
+ */
+ void load(Common::SeekableReadStream *stream);
+
+ /**
+ * Close any currently active animation
+ */
+ void close();
+ /**
+ * Get the next frame of the animation
+ */
void getNextFrame();
+
+ /**
+ * Returns whether the animation is active
+ */
+ bool active() const { return _imageFrame != nullptr; }
};
struct SceneImage {
diff --git a/engines/sherlock/people.cpp b/engines/sherlock/people.cpp
index 00d77d9f43..9f1d22b5a8 100644
--- a/engines/sherlock/people.cpp
+++ b/engines/sherlock/people.cpp
@@ -232,7 +232,7 @@ People::~People() {
}
void People::reset() {
- _data[PLAYER]->_description = "Sherlock Holmes!";
+ _data[HOLMES]->_description = "Sherlock Holmes!";
// Note: Serrated Scalpel only uses a single Person slot for Sherlock.. Watson is handled by scene sprites
int count = IS_SERRATED_SCALPEL ? 1 : MAX_CHARACTERS;
@@ -356,9 +356,9 @@ void People::synchronize(Serializer &s) {
s.syncAsByte(_holmesOn);
if (IS_SERRATED_SCALPEL) {
- s.syncAsSint16LE(_data[PLAYER]->_position.x);
- s.syncAsSint16LE(_data[PLAYER]->_position.y);
- s.syncAsSint16LE(_data[PLAYER]->_sequenceNumber);
+ s.syncAsSint16LE(_data[HOLMES]->_position.x);
+ s.syncAsSint16LE(_data[HOLMES]->_position.y);
+ s.syncAsSint16LE(_data[HOLMES]->_sequenceNumber);
} else {
for (uint idx = 0; idx < _data.size(); ++idx) {
Person &p = *_data[idx];
@@ -375,8 +375,8 @@ void People::synchronize(Serializer &s) {
s.syncAsSint16LE(_holmesQuotient);
if (s.isLoading()) {
- _hSavedPos = _data[PLAYER]->_position;
- _hSavedFacing = _data[PLAYER]->_sequenceNumber;
+ _hSavedPos = _data[HOLMES]->_position;
+ _hSavedFacing = _data[HOLMES]->_sequenceNumber;
}
}
diff --git a/engines/sherlock/people.h b/engines/sherlock/people.h
index 3d035b6b7b..19e050ead1 100644
--- a/engines/sherlock/people.h
+++ b/engines/sherlock/people.h
@@ -31,7 +31,8 @@
namespace Sherlock {
enum PeopleId {
- PLAYER = 0,
+ HOLMES = 0,
+ WATSON = 1,
MAX_NPC_PATH = 200
};
diff --git a/engines/sherlock/scalpel/scalpel.cpp b/engines/sherlock/scalpel/scalpel.cpp
index 4fe3b0327c..33f8c6b7a2 100644
--- a/engines/sherlock/scalpel/scalpel.cpp
+++ b/engines/sherlock/scalpel/scalpel.cpp
@@ -961,7 +961,7 @@ void ScalpelEngine::startScene() {
}
void ScalpelEngine::eraseMirror12() {
- Common::Point pt((*_people)[PLAYER]._position.x / FIXED_INT_MULTIPLIER, (*_people)[PLAYER]._position.y / FIXED_INT_MULTIPLIER);
+ Common::Point pt((*_people)[HOLMES]._position.x / FIXED_INT_MULTIPLIER, (*_people)[HOLMES]._position.y / FIXED_INT_MULTIPLIER);
// If player is in range of the mirror, then restore background from the secondary back buffer
if (Common::Rect(70, 100, 200, 200).contains(pt)) {
@@ -972,13 +972,13 @@ void ScalpelEngine::eraseMirror12() {
void ScalpelEngine::doMirror12() {
People &people = *_people;
- Person &player = people[PLAYER];
+ Person &player = people[HOLMES];
- Common::Point pt((*_people)[PLAYER]._position.x / FIXED_INT_MULTIPLIER, (*_people)[PLAYER]._position.y / FIXED_INT_MULTIPLIER);
+ Common::Point pt((*_people)[HOLMES]._position.x / FIXED_INT_MULTIPLIER, (*_people)[HOLMES]._position.y / FIXED_INT_MULTIPLIER);
int frameNum = player._walkSequences[player._sequenceNumber][player._frameNumber] +
player._walkSequences[player._sequenceNumber][0] - 2;
- switch ((*_people)[PLAYER]._sequenceNumber) {
+ switch ((*_people)[HOLMES]._sequenceNumber) {
case WALK_DOWN:
frameNum -= 7;
break;
@@ -1021,12 +1021,12 @@ void ScalpelEngine::doMirror12() {
if (Common::Rect(80, 100, 145, 138).contains(pt)) {
// Get the frame of Sherlock to draw
- ImageFrame &imageFrame = (*people[PLAYER]._images)[frameNum];
+ ImageFrame &imageFrame = (*people[HOLMES]._images)[frameNum];
// Draw the mirror image of Holmes
- bool flipped = people[PLAYER]._sequenceNumber == WALK_LEFT || people[PLAYER]._sequenceNumber == STOP_LEFT
- || people[PLAYER]._sequenceNumber == WALK_UPRIGHT || people[PLAYER]._sequenceNumber == STOP_UPRIGHT
- || people[PLAYER]._sequenceNumber == WALK_DOWNLEFT || people[PLAYER]._sequenceNumber == STOP_DOWNLEFT;
+ bool flipped = people[HOLMES]._sequenceNumber == WALK_LEFT || people[HOLMES]._sequenceNumber == STOP_LEFT
+ || people[HOLMES]._sequenceNumber == WALK_UPRIGHT || people[HOLMES]._sequenceNumber == STOP_UPRIGHT
+ || people[HOLMES]._sequenceNumber == WALK_DOWNLEFT || people[HOLMES]._sequenceNumber == STOP_DOWNLEFT;
_screen->_backBuffer1.transBlitFrom(imageFrame, pt + Common::Point(38, -imageFrame._frame.h - 25), flipped);
// Redraw the mirror borders to prevent the drawn image of Holmes from appearing outside of the mirror
@@ -1046,7 +1046,7 @@ void ScalpelEngine::doMirror12() {
}
void ScalpelEngine::flushMirror12() {
- Common::Point pt((*_people)[PLAYER]._position.x / FIXED_INT_MULTIPLIER, (*_people)[PLAYER]._position.y / FIXED_INT_MULTIPLIER);
+ Common::Point pt((*_people)[HOLMES]._position.x / FIXED_INT_MULTIPLIER, (*_people)[HOLMES]._position.y / FIXED_INT_MULTIPLIER);
// If player is in range of the mirror, then draw the entire mirror area to the screen
if (Common::Rect(70, 100, 200, 200).contains(pt))
diff --git a/engines/sherlock/scalpel/scalpel_map.cpp b/engines/sherlock/scalpel/scalpel_map.cpp
index a9e566f73c..63cb4a342c 100644
--- a/engines/sherlock/scalpel/scalpel_map.cpp
+++ b/engines/sherlock/scalpel/scalpel_map.cpp
@@ -155,7 +155,7 @@ int ScalpelMap::show() {
_drawMap = true;
_charPoint = -1;
_point = -1;
- people[PLAYER]._position = _lDrawnPos = _overPos;
+ people[HOLMES]._position = _lDrawnPos = _overPos;
// Show place icons
showPlaces();
@@ -233,7 +233,7 @@ int ScalpelMap::show() {
}
if ((events._released || events._rightReleased) && _point != -1) {
- if (people[PLAYER]._walkCount == 0) {
+ if (people[HOLMES]._walkCount == 0) {
people._walkDest = _points[_point] + Common::Point(4, 9);
_charPoint = _point;
@@ -247,7 +247,7 @@ int ScalpelMap::show() {
}
// Check if a scene has beeen selected and we've finished "moving" to it
- if (people[PLAYER]._walkCount == 0) {
+ if (people[HOLMES]._walkCount == 0) {
if (_charPoint >= 1 && _charPoint < (int)_points.size())
exitFlag = true;
}
@@ -266,7 +266,7 @@ int ScalpelMap::show() {
}
freeSprites();
- _overPos = people[PLAYER]._position;
+ _overPos = people[HOLMES]._position;
// Reset font
screen.setFont(oldFont);
@@ -288,7 +288,7 @@ void ScalpelMap::setupSprites() {
_shapes = new ImageFile("mapicon.vgs");
_iconShapes = new ImageFile("overicon.vgs");
_iconSave.create((*_shapes)[4]._width, (*_shapes)[4]._height, _vm->getPlatform());
- Person &p = people[PLAYER];
+ Person &p = people[HOLMES];
p._description = " ";
p._type = CHARACTER;
p._position = Common::Point(12400, 5000);
@@ -353,11 +353,11 @@ void ScalpelMap::showPlaceName(int idx, bool highlighted) {
int width = screen.stringWidth(name);
if (!_cursorIndex) {
- saveIcon(people[PLAYER]._imageFrame, _lDrawnPos);
+ saveIcon(people[HOLMES]._imageFrame, _lDrawnPos);
- bool flipped = people[PLAYER]._sequenceNumber == MAP_DOWNLEFT || people[PLAYER]._sequenceNumber == MAP_LEFT
- || people[PLAYER]._sequenceNumber == MAP_UPLEFT;
- screen._backBuffer1.transBlitFrom(*people[PLAYER]._imageFrame, _lDrawnPos, flipped);
+ bool flipped = people[HOLMES]._sequenceNumber == MAP_DOWNLEFT || people[HOLMES]._sequenceNumber == MAP_LEFT
+ || people[HOLMES]._sequenceNumber == MAP_UPLEFT;
+ screen._backBuffer1.transBlitFrom(*people[HOLMES]._imageFrame, _lDrawnPos, flipped);
}
if (highlighted) {
@@ -390,26 +390,26 @@ void ScalpelMap::updateMap(bool flushScreen) {
else
_savedPos.x = -1;
- people[PLAYER].adjustSprite();
+ people[HOLMES].adjustSprite();
- _lDrawnPos.x = hPos.x = people[PLAYER]._position.x / FIXED_INT_MULTIPLIER - _bigPos.x;
- _lDrawnPos.y = hPos.y = people[PLAYER]._position.y / FIXED_INT_MULTIPLIER - people[PLAYER].frameHeight() - _bigPos.y;
+ _lDrawnPos.x = hPos.x = people[HOLMES]._position.x / FIXED_INT_MULTIPLIER - _bigPos.x;
+ _lDrawnPos.y = hPos.y = people[HOLMES]._position.y / FIXED_INT_MULTIPLIER - people[HOLMES].frameHeight() - _bigPos.y;
// Draw the person icon
- saveIcon(people[PLAYER]._imageFrame, hPos);
- if (people[PLAYER]._sequenceNumber == MAP_DOWNLEFT || people[PLAYER]._sequenceNumber == MAP_LEFT
- || people[PLAYER]._sequenceNumber == MAP_UPLEFT)
- screen._backBuffer1.transBlitFrom(*people[PLAYER]._imageFrame, hPos, true);
+ saveIcon(people[HOLMES]._imageFrame, hPos);
+ if (people[HOLMES]._sequenceNumber == MAP_DOWNLEFT || people[HOLMES]._sequenceNumber == MAP_LEFT
+ || people[HOLMES]._sequenceNumber == MAP_UPLEFT)
+ screen._backBuffer1.transBlitFrom(*people[HOLMES]._imageFrame, hPos, true);
else
- screen._backBuffer1.transBlitFrom(*people[PLAYER]._imageFrame, hPos, false);
+ screen._backBuffer1.transBlitFrom(*people[HOLMES]._imageFrame, hPos, false);
if (flushScreen) {
screen.slamArea(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCREEN_HEIGHT);
} else if (!_drawMap) {
if (hPos.x > 0 && hPos.y >= 0 && hPos.x < SHERLOCK_SCREEN_WIDTH && hPos.y < SHERLOCK_SCREEN_HEIGHT)
- screen.flushImage(people[PLAYER]._imageFrame, Common::Point(people[PLAYER]._position.x / FIXED_INT_MULTIPLIER - _bigPos.x,
- people[PLAYER]._position.y / FIXED_INT_MULTIPLIER - people[PLAYER].frameHeight() - _bigPos.y),
- &people[PLAYER]._oldPosition.x, &people[PLAYER]._oldPosition.y, &people[PLAYER]._oldSize.x, &people[PLAYER]._oldSize.y);
+ screen.flushImage(people[HOLMES]._imageFrame, Common::Point(people[HOLMES]._position.x / FIXED_INT_MULTIPLIER - _bigPos.x,
+ people[HOLMES]._position.y / FIXED_INT_MULTIPLIER - people[HOLMES].frameHeight() - _bigPos.y),
+ &people[HOLMES]._oldPosition.x, &people[HOLMES]._oldPosition.y, &people[HOLMES]._oldSize.x, &people[HOLMES]._oldSize.y);
if (osPos.x != -1)
screen.slamArea(osPos.x, osPos.y, osSize.x, osSize.y);
@@ -428,15 +428,15 @@ void ScalpelMap::walkTheStreets() {
const byte *path = _paths.getPath(start, dest);
// Add in destination position
- people[PLAYER]._walkTo.clear();
+ people[HOLMES]._walkTo.clear();
Common::Point destPos = people._walkDest;
// Check for any intermediate points between the two locations
if (path[0] || _charPoint > 50 || _oldCharPoint > 50) {
- people[PLAYER]._sequenceNumber = -1;
+ people[HOLMES]._sequenceNumber = -1;
if (_charPoint == 51 || _oldCharPoint == 51) {
- people[PLAYER].setWalking();
+ people[HOLMES].setWalking();
} else {
bool reversePath = false;
@@ -453,25 +453,25 @@ void ScalpelMap::walkTheStreets() {
} while (*path != 254);
// Load up the path to use
- people[PLAYER]._walkTo.clear();
+ people[HOLMES]._walkTo.clear();
if (reversePath) {
for (int idx = (int)tempPath.size() - 1; idx >= 0; --idx)
- people[PLAYER]._walkTo.push(tempPath[idx]);
+ people[HOLMES]._walkTo.push(tempPath[idx]);
} else {
for (int idx = 0; idx < (int)tempPath.size(); ++idx)
- people[PLAYER]._walkTo.push(tempPath[idx]);
+ people[HOLMES]._walkTo.push(tempPath[idx]);
}
- people._walkDest = people[PLAYER]._walkTo.pop() + Common::Point(12, 6);
- people[PLAYER].setWalking();
+ people._walkDest = people[HOLMES]._walkTo.pop() + Common::Point(12, 6);
+ people[HOLMES].setWalking();
}
} else {
- people[PLAYER]._walkCount = 0;
+ people[HOLMES]._walkCount = 0;
}
// Store the final destination icon position
- people[PLAYER]._walkTo.push(destPos);
+ people[HOLMES]._walkTo.push(destPos);
}
void ScalpelMap::saveIcon(ImageFrame *src, const Common::Point &pt) {
diff --git a/engines/sherlock/scalpel/scalpel_people.cpp b/engines/sherlock/scalpel/scalpel_people.cpp
index b2aa4dcbb1..31be9b4cbc 100644
--- a/engines/sherlock/scalpel/scalpel_people.cpp
+++ b/engines/sherlock/scalpel/scalpel_people.cpp
@@ -52,8 +52,8 @@ void ScalpelPerson::adjustSprite() {
if (!_walkCount) {
// If there any points left for the character to walk to along the
// route to a destination, then move to the next point
- if (!people[PLAYER]._walkTo.empty()) {
- people._walkDest = people[PLAYER]._walkTo.pop();
+ if (!people[HOLMES]._walkTo.empty()) {
+ people._walkDest = people[HOLMES]._walkTo.pop();
setWalking();
} else {
gotoStand();
@@ -179,8 +179,8 @@ void ScalpelPerson::gotoStand() {
if (map._active) {
_sequenceNumber = 0;
- people[PLAYER]._position.x = (map[map._charPoint].x - 6) * FIXED_INT_MULTIPLIER;
- people[PLAYER]._position.y = (map[map._charPoint].y + 10) * FIXED_INT_MULTIPLIER;
+ people[HOLMES]._position.x = (map[map._charPoint].x - 6) * FIXED_INT_MULTIPLIER;
+ people[HOLMES]._position.y = (map[map._charPoint].y + 10) * FIXED_INT_MULTIPLIER;
}
_oldWalkSequence = -1;
@@ -401,14 +401,14 @@ void ScalpelPeople::setTalking(int speaker) {
void ScalpelPeople::synchronize(Serializer &s) {
s.syncAsByte(_holmesOn);
- s.syncAsSint32LE(_data[PLAYER]->_position.x);
- s.syncAsSint32LE(_data[PLAYER]->_position.y);
- s.syncAsSint16LE(_data[PLAYER]->_sequenceNumber);
+ s.syncAsSint32LE(_data[HOLMES]->_position.x);
+ s.syncAsSint32LE(_data[HOLMES]->_position.y);
+ s.syncAsSint16LE(_data[HOLMES]->_sequenceNumber);
s.syncAsSint16LE(_holmesQuotient);
if (s.isLoading()) {
- _hSavedPos = _data[PLAYER]->_position;
- _hSavedFacing = _data[PLAYER]->_sequenceNumber;
+ _hSavedPos = _data[HOLMES]->_position;
+ _hSavedFacing = _data[HOLMES]->_sequenceNumber;
}
}
@@ -442,22 +442,20 @@ void ScalpelPeople::setTalkSequence(int speaker, int sequenceNum) {
}
}
-
bool ScalpelPeople::loadWalk() {
- Resources &res = *_vm->_res;
bool result = false;
- if (_data[PLAYER]->_walkLoaded) {
+ if (_data[HOLMES]->_walkLoaded) {
return false;
} else {
if (_vm->getPlatform() != Common::kPlatform3DO) {
- _data[PLAYER]->_images = new ImageFile("walk.vgs");
+ _data[HOLMES]->_images = new ImageFile("walk.vgs");
} else {
// Load walk.anim on 3DO, which is a cel animation file
- _data[PLAYER]->_images = new ImageFile3DO("walk.anim", kImageFile3DOType_CelAnimation);
+ _data[HOLMES]->_images = new ImageFile3DO("walk.anim", kImageFile3DOType_CelAnimation);
}
- _data[PLAYER]->setImageFrame();
- _data[PLAYER]->_walkLoaded = true;
+ _data[HOLMES]->setImageFrame();
+ _data[HOLMES]->_walkLoaded = true;
result = true;
}
diff --git a/engines/sherlock/scalpel/scalpel_scene.cpp b/engines/sherlock/scalpel/scalpel_scene.cpp
index f053747a56..87fe208520 100644
--- a/engines/sherlock/scalpel/scalpel_scene.cpp
+++ b/engines/sherlock/scalpel/scalpel_scene.cpp
@@ -138,7 +138,7 @@ void ScalpelScene::drawAllShapes() {
void ScalpelScene::checkBgShapes() {
People &people = *_vm->_people;
- Person &holmes = people[PLAYER];
+ Person &holmes = people[HOLMES];
Common::Point pt(holmes._position.x / FIXED_INT_MULTIPLIER, holmes._position.y / FIXED_INT_MULTIPLIER);
// Call the base scene method to handle bg shapes
@@ -229,14 +229,14 @@ void ScalpelScene::doBgAnim() {
vm.eraseMirror12();
// Restore the back buffer from the back buffer 2 in the changed area
- Common::Rect bounds(people[PLAYER]._oldPosition.x, people[PLAYER]._oldPosition.y,
- people[PLAYER]._oldPosition.x + people[PLAYER]._oldSize.x,
- people[PLAYER]._oldPosition.y + people[PLAYER]._oldSize.y);
+ Common::Rect bounds(people[HOLMES]._oldPosition.x, people[HOLMES]._oldPosition.y,
+ people[HOLMES]._oldPosition.x + people[HOLMES]._oldSize.x,
+ people[HOLMES]._oldPosition.y + people[HOLMES]._oldSize.y);
Common::Point pt(bounds.left, bounds.top);
- if (people[PLAYER]._type == CHARACTER)
+ if (people[HOLMES]._type == CHARACTER)
screen.restoreBackground(bounds);
- else if (people[PLAYER]._type == REMOVE)
+ else if (people[HOLMES]._type == REMOVE)
screen._backBuffer->blitFrom(screen._backBuffer2, pt, bounds);
for (uint idx = 0; idx < _bgShapes.size(); ++idx) {
@@ -291,8 +291,8 @@ void ScalpelScene::doBgAnim() {
_canimShapes[idx].adjustObject();
}
- if (people[PLAYER]._type == CHARACTER && people._holmesOn)
- people[PLAYER].adjustSprite();
+ if (people[HOLMES]._type == CHARACTER && people._holmesOn)
+ people[HOLMES].adjustSprite();
// Flag the bg shapes which need to be redrawn
checkBgShapes();
@@ -331,16 +331,16 @@ void ScalpelScene::doBgAnim() {
}
// Draw the person if not animating
- if (people[PLAYER]._type == CHARACTER && people[PLAYER]._walkLoaded) {
+ if (people[HOLMES]._type == CHARACTER && people[HOLMES]._walkLoaded) {
// If Holmes is too far to the right, move him back so he's on-screen
- int xRight = SHERLOCK_SCREEN_WIDTH - 2 - people[PLAYER]._imageFrame->_frame.w;
- int tempX = MIN(people[PLAYER]._position.x / FIXED_INT_MULTIPLIER, xRight);
+ int xRight = SHERLOCK_SCREEN_WIDTH - 2 - people[HOLMES]._imageFrame->_frame.w;
+ int tempX = MIN(people[HOLMES]._position.x / FIXED_INT_MULTIPLIER, xRight);
- bool flipped = people[PLAYER]._sequenceNumber == WALK_LEFT || people[PLAYER]._sequenceNumber == STOP_LEFT ||
- people[PLAYER]._sequenceNumber == WALK_UPLEFT || people[PLAYER]._sequenceNumber == STOP_UPLEFT ||
- people[PLAYER]._sequenceNumber == WALK_DOWNRIGHT || people[PLAYER]._sequenceNumber == STOP_DOWNRIGHT;
- screen._backBuffer->transBlitFrom(*people[PLAYER]._imageFrame,
- Common::Point(tempX, people[PLAYER]._position.y / FIXED_INT_MULTIPLIER - people[PLAYER]._imageFrame->_frame.h), flipped);
+ bool flipped = people[HOLMES]._sequenceNumber == WALK_LEFT || people[HOLMES]._sequenceNumber == STOP_LEFT ||
+ people[HOLMES]._sequenceNumber == WALK_UPLEFT || people[HOLMES]._sequenceNumber == STOP_UPLEFT ||
+ people[HOLMES]._sequenceNumber == WALK_DOWNRIGHT || people[HOLMES]._sequenceNumber == STOP_DOWNRIGHT;
+ screen._backBuffer->transBlitFrom(*people[HOLMES]._imageFrame,
+ Common::Point(tempX, people[HOLMES]._position.y / FIXED_INT_MULTIPLIER - people[HOLMES]._imageFrame->_frame.h), flipped);
}
// Draw all static and active shapes are NORMAL and are in front of the person
@@ -390,20 +390,20 @@ void ScalpelScene::doBgAnim() {
_animating = 0;
screen.slamRect(Common::Rect(0, 0, SHERLOCK_SCREEN_WIDTH, SHERLOCK_SCENE_HEIGHT));
} else {
- if (people[PLAYER]._type != INVALID && ((_goToScene == -1 || _canimShapes.empty()))) {
- if (people[PLAYER]._type == REMOVE) {
+ if (people[HOLMES]._type != INVALID && ((_goToScene == -1 || _canimShapes.empty()))) {
+ if (people[HOLMES]._type == REMOVE) {
screen.slamRect(Common::Rect(
- people[PLAYER]._oldPosition.x, people[PLAYER]._oldPosition.y,
- people[PLAYER]._oldPosition.x + people[PLAYER]._oldSize.x,
- people[PLAYER]._oldPosition.y + people[PLAYER]._oldSize.y
+ people[HOLMES]._oldPosition.x, people[HOLMES]._oldPosition.y,
+ people[HOLMES]._oldPosition.x + people[HOLMES]._oldSize.x,
+ people[HOLMES]._oldPosition.y + people[HOLMES]._oldSize.y
));
- people[PLAYER]._type = INVALID;
+ people[HOLMES]._type = INVALID;
} else {
- screen.flushImage(people[PLAYER]._imageFrame,
- Common::Point(people[PLAYER]._position.x / FIXED_INT_MULTIPLIER,
- people[PLAYER]._position.y / FIXED_INT_MULTIPLIER - people[PLAYER].frameHeight()),
- &people[PLAYER]._oldPosition.x, &people[PLAYER]._oldPosition.y,
- &people[PLAYER]._oldSize.x, &people[PLAYER]._oldSize.y);
+ screen.flushImage(people[HOLMES]._imageFrame,
+ Common::Point(people[HOLMES]._position.x / FIXED_INT_MULTIPLIER,
+ people[HOLMES]._position.y / FIXED_INT_MULTIPLIER - people[HOLMES].frameHeight()),
+ &people[HOLMES]._oldPosition.x, &people[HOLMES]._oldPosition.y,
+ &people[HOLMES]._oldSize.x, &people[HOLMES]._oldSize.y);
}
}
@@ -525,8 +525,8 @@ int ScalpelScene::startCAnim(int cAnimNum, int playRate) {
if (walkPos.x != -1) {
// Holmes must walk to the walk point before the cAnimation is started
- if (people[PLAYER]._position != walkPos)
- people[PLAYER].walkToCoords(walkPos, walkDir);
+ if (people[HOLMES]._position != walkPos)
+ people[HOLMES].walkToCoords(walkPos, walkDir);
}
if (talk._talkToAbort)
@@ -563,7 +563,7 @@ int ScalpelScene::startCAnim(int cAnimNum, int playRate) {
if (cAnim._name.size() > 0 && cAnim._type != NO_SHAPE) {
if (tpPos.x != -1)
- people[PLAYER]._type = REMOVE;
+ people[HOLMES]._type = REMOVE;
Common::String fname = cAnim._name + ".vgs";
if (!res.isInCache(fname)) {
@@ -653,14 +653,14 @@ int ScalpelScene::startCAnim(int cAnimNum, int playRate) {
cObj._frameNumber += dir;
}
- people[PLAYER]._type = CHARACTER;
+ people[HOLMES]._type = CHARACTER;
}
// Teleport to ending coordinates if necessary
if (tpPos.x != -1) {
- people[PLAYER]._position = tpPos; // Place the player
- people[PLAYER]._sequenceNumber = tpDir;
- people[PLAYER].gotoStand();
+ people[HOLMES]._position = tpPos; // Place the player
+ people[HOLMES]._sequenceNumber = tpDir;
+ people[HOLMES].gotoStand();
}
if (playRate < 0)
@@ -686,10 +686,10 @@ int ScalpelScene::startCAnim(int cAnimNum, int playRate) {
if (tpPos.x != -1 && !talk._talkToAbort) {
// Teleport to ending coordinates
- people[PLAYER]._position = tpPos;
- people[PLAYER]._sequenceNumber = tpDir;
+ people[HOLMES]._position = tpPos;
+ people[HOLMES]._sequenceNumber = tpDir;
- people[PLAYER].gotoStand();
+ people[HOLMES].gotoStand();
}
events.setCursor(oldCursor);
diff --git a/engines/sherlock/scalpel/scalpel_talk.cpp b/engines/sherlock/scalpel/scalpel_talk.cpp
index 5d2ece611b..ea5a0fb713 100644
--- a/engines/sherlock/scalpel/scalpel_talk.cpp
+++ b/engines/sherlock/scalpel/scalpel_talk.cpp
@@ -456,7 +456,7 @@ OpcodeReturn ScalpelTalk::cmdWalkToCoords(const byte *&str) {
People &people = *_vm->_people;
++str;
- people[PLAYER].walkToCoords(Point32(((str[0] - 1) * 256 + str[1] - 1) * FIXED_INT_MULTIPLIER,
+ people[HOLMES].walkToCoords(Point32(((str[0] - 1) * 256 + str[1] - 1) * FIXED_INT_MULTIPLIER,
str[2] * FIXED_INT_MULTIPLIER), str[3] - 1);
if (_talkToAbort)
return RET_EXIT;
diff --git a/engines/sherlock/scalpel/scalpel_user_interface.cpp b/engines/sherlock/scalpel/scalpel_user_interface.cpp
index cb2bf65342..8dd15e5827 100644
--- a/engines/sherlock/scalpel/scalpel_user_interface.cpp
+++ b/engines/sherlock/scalpel/scalpel_user_interface.cpp
@@ -326,7 +326,7 @@ void ScalpelUserInterface::handleInput() {
} else {
people._walkDest = pt;
people._allowWalkAbort = false;
- people[PLAYER].goAllTheWay();
+ people[HOLMES].goAllTheWay();
}
if (_oldKey != -1) {
@@ -511,7 +511,7 @@ void ScalpelUserInterface::examine() {
scene.startCAnim(_cNum, canimSpeed);
} else if (obj._lookPosition.y != 0) {
// Need to walk to the object to be examined
- people[PLAYER].walkToCoords(obj._lookPosition, obj._lookFacing);
+ people[HOLMES].walkToCoords(obj._lookPosition, obj._lookFacing);
}
if (!talk._talkToAbort) {
@@ -2236,13 +2236,13 @@ void ScalpelUserInterface::checkAction(ActionType &action, const char *const mes
printed = true;
if (pt.x != -1)
// Holmes needs to walk to object before the action is done
- people[PLAYER].walkToCoords(pt, dir);
+ people[HOLMES].walkToCoords(pt, dir);
if (!talk._talkToAbort) {
// Ensure Holmes is on the exact intended location
- people[PLAYER]._position = pt;
- people[PLAYER]._sequenceNumber = dir;
- people[PLAYER].gotoStand();
+ people[HOLMES]._position = pt;
+ people[HOLMES]._sequenceNumber = dir;
+ people[HOLMES].gotoStand();
talk.talkTo(action._names[nameIdx].c_str() + 2);
if (ch == 'T')
@@ -2255,7 +2255,7 @@ void ScalpelUserInterface::checkAction(ActionType &action, const char *const mes
if (doCAnim && !talk._talkToAbort) {
if (pt.x != -1)
// Holmes needs to walk to object before the action is done
- people[PLAYER].walkToCoords(pt, dir);
+ people[HOLMES].walkToCoords(pt, dir);
}
for (int nameIdx = 0; nameIdx < NAMES_COUNT; ++nameIdx) {
diff --git a/engines/sherlock/scene.cpp b/engines/sherlock/scene.cpp
index 2e80f0789e..da7f088a06 100644
--- a/engines/sherlock/scene.cpp
+++ b/engines/sherlock/scene.cpp
@@ -240,8 +240,8 @@ void Scene::selectScene() {
_tempFadeStyle = 0;
}
- people._walkDest = Common::Point(people[PLAYER]._position.x / FIXED_INT_MULTIPLIER,
- people[PLAYER]._position.y / FIXED_INT_MULTIPLIER);
+ people._walkDest = Common::Point(people[HOLMES]._position.x / FIXED_INT_MULTIPLIER,
+ people[HOLMES]._position.y / FIXED_INT_MULTIPLIER);
_restoreFlag = true;
events.clearEvents();
@@ -964,8 +964,8 @@ void Scene::transitionToScene() {
hSavedPos = Point32(160 * FIXED_INT_MULTIPLIER, 100 * FIXED_INT_MULTIPLIER);
hSavedFacing = 4;
} else {
- hSavedPos = people[PLAYER]._position;
- hSavedFacing = people[PLAYER]._sequenceNumber;
+ hSavedPos = people[HOLMES]._position;
+ hSavedFacing = people[HOLMES]._sequenceNumber;
}
} else {
// setup entrance info
@@ -988,8 +988,8 @@ void Scene::transitionToScene() {
if (hSavedFacing < 101) {
// Standard info, so set it
- people[PLAYER]._position = hSavedPos;
- people[PLAYER]._sequenceNumber = hSavedFacing;
+ people[HOLMES]._position = hSavedPos;
+ people[HOLMES]._sequenceNumber = hSavedFacing;
} else {
// It's canimation information
cAnimNum = hSavedFacing - 101;
@@ -1001,7 +1001,7 @@ void Scene::transitionToScene() {
if (cAnimNum != -1) {
// Prevent Holmes from being drawn
- people[PLAYER]._position = Common::Point(0, 0);
+ people[HOLMES]._position = Common::Point(0, 0);
}
for (uint objIdx = 0; objIdx < _bgShapes.size(); ++objIdx) {
@@ -1020,8 +1020,8 @@ void Scene::transitionToScene() {
}
if (Common::Rect(topLeft.x, topLeft.y, bottomRight.x, bottomRight.y).contains(
- Common::Point(people[PLAYER]._position.x / FIXED_INT_MULTIPLIER,
- people[PLAYER]._position.y / FIXED_INT_MULTIPLIER))) {
+ Common::Point(people[HOLMES]._position.x / FIXED_INT_MULTIPLIER,
+ people[HOLMES]._position.y / FIXED_INT_MULTIPLIER))) {
// Current point is already inside box - impact occurred on
// a previous call. So simply do nothing except talk until the
// player is clear of the box
@@ -1073,7 +1073,7 @@ void Scene::transitionToScene() {
PositionFacing pt = c._goto[0];
c._goto[0].x = c._goto[0].y = -1;
- people[PLAYER]._position = Common::Point(0, 0);
+ people[HOLMES]._position = Common::Point(0, 0);
startCAnim(cAnimNum, 1);
c._goto[0] = pt;
@@ -1205,7 +1205,7 @@ void Scene::synchronize(Serializer &s) {
void Scene::checkBgShapes() {
People &people = *_vm->_people;
- Person &holmes = people[PLAYER];
+ Person &holmes = people[HOLMES];
Common::Point pt(holmes._position.x / FIXED_INT_MULTIPLIER, holmes._position.y / FIXED_INT_MULTIPLIER);
// Iterate through the shapes
diff --git a/engines/sherlock/talk.cpp b/engines/sherlock/talk.cpp
index 0e9feedd87..bb8a059d34 100644
--- a/engines/sherlock/talk.cpp
+++ b/engines/sherlock/talk.cpp
@@ -169,13 +169,13 @@ void Talk::talkTo(const Common::String &filename) {
// Turn on the Exit option
ui._endKeyActive = true;
- if (people[PLAYER]._walkCount || people[PLAYER]._walkTo.size() > 0) {
+ if (people[HOLMES]._walkCount || people[HOLMES]._walkTo.size() > 0) {
// Only interrupt if an action if trying to do an action, and not just
// if the player is walking around the scene
if (people._allowWalkAbort)
abortFlag = true;
- people[PLAYER].gotoStand();
+ people[HOLMES].gotoStand();
}
if (_talkToAbort)
@@ -501,7 +501,7 @@ void Talk::talk(int objNum) {
events.setCursor(WAIT);
if (obj._lookPosition.y != 0)
// Need to walk to character first
- people[PLAYER].walkToCoords(obj._lookPosition, obj._lookFacing);
+ people[HOLMES].walkToCoords(obj._lookPosition, obj._lookFacing);
events.setCursor(ARROW);
if (!_talkToAbort)
@@ -516,7 +516,7 @@ void Talk::talk(int objNum) {
events.setCursor(WAIT);
if (obj._lookPosition.y != 0)
// Walk over to person to talk to
- people[PLAYER].walkToCoords(obj._lookPosition, obj._lookFacing);
+ people[HOLMES].walkToCoords(obj._lookPosition, obj._lookFacing);
events.setCursor(ARROW);
if (!_talkToAbort) {
@@ -1318,14 +1318,14 @@ OpcodeReturn Talk::cmdEnableEndKey(const byte *&str) {
OpcodeReturn Talk::cmdHolmesOff(const byte *&str) {
People &people = *_vm->_people;
- people[PLAYER]._type = REMOVE;
+ people[HOLMES]._type = REMOVE;
return RET_SUCCESS;
}
OpcodeReturn Talk::cmdHolmesOn(const byte *&str) {
People &people = *_vm->_people;
- people[PLAYER]._type = CHARACTER;
+ people[HOLMES]._type = CHARACTER;
return RET_SUCCESS;
}
@@ -1452,7 +1452,7 @@ OpcodeReturn Talk::cmdWalkToCAnimation(const byte *&str) {
++str;
CAnim &animation = scene._cAnim[str[0] - 1];
- people[PLAYER].walkToCoords(animation._goto[0], animation._goto[0]._facing);
+ people[HOLMES].walkToCoords(animation._goto[0], animation._goto[0]._facing);
return _talkToAbort ? RET_EXIT : RET_SUCCESS;
}
diff --git a/engines/sherlock/tattoo/tattoo.cpp b/engines/sherlock/tattoo/tattoo.cpp
index 0961601487..60803c7fbb 100644
--- a/engines/sherlock/tattoo/tattoo.cpp
+++ b/engines/sherlock/tattoo/tattoo.cpp
@@ -33,6 +33,7 @@ namespace Tattoo {
TattooEngine::TattooEngine(OSystem *syst, const SherlockGameDescription *gameDesc) :
SherlockEngine(syst, gameDesc) {
_creditsActive = false;
+ _runningProlog = false;
}
void TattooEngine::showOpening() {
@@ -48,6 +49,7 @@ void TattooEngine::initialize() {
// Initialise the global flags
_flags.resize(3200);
_flags[1] = _flags[4] = _flags[76] = true;
+ _runningProlog = true;
// Add some more files to the cache
_res->addToCache("walk.lib");
diff --git a/engines/sherlock/tattoo/tattoo.h b/engines/sherlock/tattoo/tattoo.h
index 28fa77f409..6cafc3fe52 100644
--- a/engines/sherlock/tattoo/tattoo.h
+++ b/engines/sherlock/tattoo/tattoo.h
@@ -49,6 +49,7 @@ protected:
virtual void startScene();
public:
bool _creditsActive;
+ bool _runningProlog;
public:
TattooEngine(OSystem *syst, const SherlockGameDescription *gameDesc);
virtual ~TattooEngine() {}
diff --git a/engines/sherlock/tattoo/tattoo_people.cpp b/engines/sherlock/tattoo/tattoo_people.cpp
index f70b079760..7560ca1593 100644
--- a/engines/sherlock/tattoo/tattoo_people.cpp
+++ b/engines/sherlock/tattoo/tattoo_people.cpp
@@ -108,7 +108,7 @@ void TattooPerson::adjustSprite() {
// See if the player has come to a stop after clicking on an Arrow zone to leave the scene.
// If so, this will set up the exit information for the scene transition
if (!_walkCount && scene._exitZone != -1 && scene._walkedInScene && scene._goToScene != -1 &&
- !_description.compareToIgnoreCase(people[PLAYER]._description)) {
+ !_description.compareToIgnoreCase(people[HOLMES]._description)) {
people._hSavedPos = scene._exits[scene._exitZone]._newPosition;
people._hSavedFacing = scene._exits[scene._exitZone]._newFacing;
@@ -187,20 +187,20 @@ void TattooPerson::gotoStand() {
if (npc != -1 && people[npc]._npcFacing != -1) {
if (people[npc]._npcFacing == FACING_PLAYER) {
// See where Holmes is with respect to the NPC (x coords)
- if (people[PLAYER]._position.x < people[npc]._position.x)
+ if (people[HOLMES]._position.x < people[npc]._position.x)
people[npc]._npcFacing = STOP_LEFT;
else
people[npc]._npcFacing = STOP_RIGHT;
// See where Holmes is with respect to the NPC (y coords)
- if (people[PLAYER]._position.y < people[npc]._position.y - (10 * FIXED_INT_MULTIPLIER)) {
+ if (people[HOLMES]._position.y < people[npc]._position.y - (10 * FIXED_INT_MULTIPLIER)) {
// Holmes is above the NPC so reset the facing to the diagonal ups
if (people[npc]._npcFacing == STOP_RIGHT)
people[npc]._npcFacing = STOP_UPRIGHT;
else
people[npc]._npcFacing = STOP_UPLEFT;
} else {
- if (people[PLAYER]._position.y > people[npc]._position.y + (10 * FIXED_INT_MULTIPLIER)) {
+ if (people[HOLMES]._position.y > people[npc]._position.y + (10 * FIXED_INT_MULTIPLIER)) {
// Holmes is below the NPC so reset the facing to the diagonal downs
if (people[npc]._npcFacing == STOP_RIGHT)
people[npc]._npcFacing = STOP_DOWNRIGHT;
@@ -446,7 +446,7 @@ int TattooPeople::findSpeaker(int speaker) {
if (result == -1) {
bool flag = _vm->readFlags(76);
- if (_data[PLAYER]->_type == CHARACTER && ((speaker == 0 && flag) || (speaker == 1 && !flag)))
+ if (_data[HOLMES]->_type == CHARACTER && ((speaker == 0 && flag) || (speaker == 1 && !flag)))
return -1;
for (uint idx = 1; idx < _data.size(); ++idx) {
@@ -481,8 +481,8 @@ void TattooPeople::synchronize(Serializer &s) {
s.syncAsSint16LE(_holmesQuotient);
if (s.isLoading()) {
- _hSavedPos = _data[PLAYER]->_position;
- _hSavedFacing = _data[PLAYER]->_sequenceNumber;
+ _hSavedPos = _data[HOLMES]->_position;
+ _hSavedFacing = _data[HOLMES]->_sequenceNumber;
}
}
diff --git a/engines/sherlock/tattoo/tattoo_scene.cpp b/engines/sherlock/tattoo/tattoo_scene.cpp
index ce20f17730..a64c86b24b 100644
--- a/engines/sherlock/tattoo/tattoo_scene.cpp
+++ b/engines/sherlock/tattoo/tattoo_scene.cpp
@@ -803,10 +803,134 @@ void TattooScene::setupBGArea(const byte cMap[PALETTE_SIZE]) {
}
}
+#define ADJUST_COORD(COORD) if (COORD != -1) COORD *= FIXED_INT_MULTIPLIER
+
int TattooScene::startCAnim(int cAnimNum, int playRate) {
- error("TODO: startCAnim");
+ TattooEngine &vm = *(TattooEngine *)_vm;
+ Events &events = *_vm->_events;
+ TattooPeople &people = *(TattooPeople *)_vm->_people;
+ Resources &res = *_vm->_res;
+ Talk &talk = *_vm->_talk;
+ UserInterface &ui = *_vm->_ui;
+
+ // Exit immediately if the anim number is out of range, or the anim doesn't have a position specified
+ if (cAnimNum < 0 || cAnimNum >= (int)_cAnim.size() || _cAnim[cAnimNum]._position.x == -1)
+ // Return out of range error
+ return -1;
+
+ // Get the co-ordinates that the Player & NPC #1 must walk to and end on
+ CAnim &cAnim = _cAnim[cAnimNum];
+ PositionFacing goto1 = cAnim._goto[0];
+ PositionFacing goto2 = cAnim._goto[1];
+ PositionFacing teleport1 = cAnim._teleport[0];
+ PositionFacing teleport2 = cAnim._teleport[1];
+
+ // If the co-ordinates are valid (not -1), adjust them by the fixed int multiplier
+ ADJUST_COORD(goto1.x);
+ ADJUST_COORD(goto1.y);
+ ADJUST_COORD(goto2.x);
+ ADJUST_COORD(goto2.y);
+ ADJUST_COORD(teleport1.x);
+ ADJUST_COORD(teleport1.y);
+ ADJUST_COORD(teleport2.x);
+ ADJUST_COORD(teleport2.y);
+
+ // See if the Player must walk to a position before the animation starts
+ SpriteType savedPlayerType = people[HOLMES]._type;
+ if (goto1.x != -1 && people[HOLMES]._type == CHARACTER) {
+ if (people[HOLMES]._position != goto1)
+ people[HOLMES].walkToCoords(goto1, goto1._facing);
+ }
+
+ if (talk._talkToAbort)
+ return 1;
+
+ // See if NPC #1 must walk to a position before the animation starts
+ SpriteType savedNPCType = people[WATSON]._type;
+ if (goto2.x != -1 && people[WATSON]._type == CHARACTER) {
+ if (people[WATSON]._position != goto2)
+ people[WATSON].walkToCoords(goto2, goto2._facing);
+ }
+
+ if (talk._talkToAbort)
+ return 1;
+
+ // Turn the player (and NPC #1 if neccessary) off before running the canimation
+ if (teleport1.x != -1 && savedPlayerType == CHARACTER)
+ people[HOLMES]._type = REMOVE;
+
+ if (teleport2.x != -1 && savedNPCType == CHARACTER)
+ people[WATSON]._type = REMOVE;
+
+ if (ui._windowOpen)
+ ui.banishWindow();
+
+ //_activeCAnim._filesize = cAnim._size;
+
+ // Open up the room resource file and get the data for the animation
+ Common::SeekableReadStream *stream = res.load(_rrmName);
+ stream->seek(44 + cAnimNum * 4);
+ stream->seek(stream->readUint32LE());
+ Common::SeekableReadStream *animStream = stream->readStream(cAnim._size);
+ delete stream;
+
+ // Set up the active animation
+ _activeCAnim._position = cAnim._position;
+ _activeCAnim._oldBounds = Common::Rect(0, 0, 0, 0);
+ _activeCAnim._flags = cAnim._flags;
+ _activeCAnim._scaleVal = cAnim._scaleVal;
+ _activeCAnim._zPlacement = 0;
+
+ _activeCAnim.load(animStream);
+
+ while (_activeCAnim.active() && !_vm->shouldQuit()) {
+ doBgAnim();
+
+ events.pollEvents();
+ if (events.kbHit()) {
+ Common::KeyState keyState = events.getKey();
+
+ if (keyState.keycode == Common::KEYCODE_ESCAPE && vm._runningProlog) {
+ _vm->setFlags(-76);
+ _vm->setFlags(396);
+ _goToScene = 1;
+ talk._talkToAbort = true;
+ _activeCAnim.close();
+ }
+ }
+ }
+
+ // Turn the people back on
+ people[HOLMES]._type = savedPlayerType;
+ if (teleport2.x != -1)
+ people[WATSON]._type = savedNPCType;
+
+ // Teleport the Player to the ending coordinates if necessary
+ if (teleport1.x != -1 && savedPlayerType == CHARACTER) {
+ people[HOLMES]._position = teleport1;
+ people[HOLMES]._sequenceNumber = teleport1._facing;
+ people[HOLMES].gotoStand();
+ }
+
+ // Teleport Watson to the ending coordinates if necessary
+ if (teleport2.x != -1 && savedNPCType == CHARACTER) {
+ people[WATSON]._position = teleport2;
+ people[WATSON]._sequenceNumber = teleport2._facing;
+ people[WATSON].gotoStand();
+ }
+
+ // Flag the Canimation to be cleared
+ _activeCAnim._zPlacement = REMOVE;
+ _activeCAnim._removeBounds = _activeCAnim._oldBounds;
+
+ // Free up the animation
+ _activeCAnim.close();
+
+ return 1;
}
+#undef ADJUST_COORD
+
void TattooScene::setNPCPath(int npc) {
TattooPeople &people = *(TattooPeople *)_vm->_people;
Talk &talk = *_vm->_talk;
diff --git a/engines/sherlock/tattoo/tattoo_talk.cpp b/engines/sherlock/tattoo/tattoo_talk.cpp
index 28c0132dd9..3768d12497 100644
--- a/engines/sherlock/tattoo/tattoo_talk.cpp
+++ b/engines/sherlock/tattoo/tattoo_talk.cpp
@@ -243,7 +243,7 @@ OpcodeReturn TattooTalk::cmdWalkHolmesToCoords(const byte *&str) {
x = -1 * (x - 16384);
// TODO: The RT walkToCoords call has an extra parameter, person, which is 0 (Holmes) here
warning("TODO: cmdWalkHolmesToCoords - call RT walkToCoords variant");
- people[PLAYER].walkToCoords(Point32(x * FIXED_INT_MULTIPLIER,
+ people[HOLMES].walkToCoords(Point32(x * FIXED_INT_MULTIPLIER,
((str[2] - 1) * 256 + str[3] - 1) * FIXED_INT_MULTIPLIER), DIRECTION_CONVERSION[str[4] - 1]);
if (_talkToAbort)
return RET_EXIT;
generated by cgit v1.2.3 (git 2.25.1) at 2025-02-22 16:45:21 +0000