[Scummvm-cvs-logs] scummvm master -> 3d0e2cb5b000bfa9ff731fc6a83ec402bd9f7aad
dreammaster
dreammaster at scummvm.org
Fri Jun 12 04:05:17 CEST 2015
This automated email contains information about 1 new commit which have been
pushed to the 'scummvm' repo located at https://github.com/scummvm/scummvm .
Summary:
3d0e2cb5b0 SHERLOCK: Beginning of descendent Person classes
Commit: 3d0e2cb5b000bfa9ff731fc6a83ec402bd9f7aad
https://github.com/scummvm/scummvm/commit/3d0e2cb5b000bfa9ff731fc6a83ec402bd9f7aad
Author: Paul Gilbert (dreammaster at scummvm.org)
Date: 2015-06-11T22:02:33-04:00
Commit Message:
SHERLOCK: Beginning of descendent Person classes
Tattoo has some different Sprite methods, and since Person descends
from Sprite, need to create descendents from it. And this has also
necessitated some refactoring of People class's _data array
Changed paths:
engines/sherlock/objects.cpp
engines/sherlock/objects.h
engines/sherlock/people.cpp
engines/sherlock/people.h
engines/sherlock/scalpel/scalpel.cpp
engines/sherlock/scalpel/scalpel_map.cpp
engines/sherlock/scalpel/scalpel_people.cpp
engines/sherlock/scalpel/scalpel_people.h
engines/sherlock/scalpel/scalpel_scene.cpp
engines/sherlock/scalpel/scalpel_user_interface.cpp
engines/sherlock/scene.cpp
engines/sherlock/talk.cpp
engines/sherlock/tattoo/tattoo_people.cpp
engines/sherlock/tattoo/tattoo_people.h
engines/sherlock/tattoo/tattoo_scene.cpp
diff --git a/engines/sherlock/objects.cpp b/engines/sherlock/objects.cpp
index 80712cf..6a0aa5b 100644
--- a/engines/sherlock/objects.cpp
+++ b/engines/sherlock/objects.cpp
@@ -32,10 +32,6 @@ namespace Sherlock {
#define START_FRAME 0
-#define UPPER_LIMIT 0
-#define LOWER_LIMIT (IS_SERRATED_SCALPEL ? CONTROLS_Y : SHERLOCK_SCREEN_HEIGHT)
-#define LEFT_LIMIT 0
-#define RIGHT_LIMIT SHERLOCK_SCREEN_WIDTH
#define NUM_ADJUSTED_WALKS 21
// Distance to walk around WALK_AROUND boxes
@@ -207,107 +203,6 @@ void Sprite::setImageFrame() {
_imageFrame = &(*images)[imageNumber];
}
-void Sprite::adjustSprite() {
- Map &map = *_vm->_map;
- People &people = *_vm->_people;
- Scene &scene = *_vm->_scene;
- Talk &talk = *_vm->_talk;
-
- if (_type == INVALID || (_type == CHARACTER && scene._animating))
- return;
-
- if (!talk._talkCounter && _type == CHARACTER && _walkCount) {
- // Handle active movement for the sprite
- _position += _delta;
- --_walkCount;
-
- 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._walkTo.empty()) {
- people._walkDest = people._walkTo.pop();
- people.setWalking();
- } else {
- people.gotoStand(*this);
- }
- }
- }
-
- if (_type == CHARACTER && !map._active) {
- if ((_position.y / FIXED_INT_MULTIPLIER) > LOWER_LIMIT) {
- _position.y = LOWER_LIMIT * FIXED_INT_MULTIPLIER;
- people.gotoStand(*this);
- }
-
- if ((_position.y / FIXED_INT_MULTIPLIER) < UPPER_LIMIT) {
- _position.y = UPPER_LIMIT * FIXED_INT_MULTIPLIER;
- people.gotoStand(*this);
- }
-
- if ((_position.x / FIXED_INT_MULTIPLIER) < LEFT_LIMIT) {
- _position.x = LEFT_LIMIT * FIXED_INT_MULTIPLIER;
- people.gotoStand(*this);
- }
-
- if ((_position.x / FIXED_INT_MULTIPLIER) > RIGHT_LIMIT) {
- _position.x = RIGHT_LIMIT * FIXED_INT_MULTIPLIER;
- people.gotoStand(*this);
- }
- } else if (!map._active) {
- _position.y = CLIP((int)_position.y, (int)UPPER_LIMIT, (int)LOWER_LIMIT);
- _position.x = CLIP((int)_position.x, (int)LEFT_LIMIT, (int)RIGHT_LIMIT);
- }
-
- if (!map._active || (map._frameChangeFlag = !map._frameChangeFlag))
- ++_frameNumber;
-
- if (_frameNumber >= (int)_walkSequences[_sequenceNumber]._sequences.size() ||
- _walkSequences[_sequenceNumber][_frameNumber] == 0) {
- switch (_sequenceNumber) {
- case Scalpel::STOP_UP:
- case Scalpel::STOP_DOWN:
- case Scalpel::STOP_LEFT:
- case Scalpel::STOP_RIGHT:
- case Scalpel::STOP_UPRIGHT:
- case Scalpel::STOP_UPLEFT:
- case Scalpel::STOP_DOWNRIGHT:
- case Scalpel::STOP_DOWNLEFT:
- // We're in a stop sequence, so reset back to the last frame, so
- // the character is shown as standing still
- --_frameNumber;
- break;
-
- default:
- // Move 1 past the first frame - we need to compensate, since we
- // already passed the frame increment
- _frameNumber = 1;
- break;
- }
- }
-
- // Update the _imageFrame to point to the new frame's image
- setImageFrame();
-
- // Check to see if character has entered an exit zone
- if (!_walkCount && scene._walkedInScene && scene._goToScene == -1) {
- Common::Rect charRect(_position.x / FIXED_INT_MULTIPLIER - 5, _position.y / FIXED_INT_MULTIPLIER - 2,
- _position.x / FIXED_INT_MULTIPLIER + 5, _position.y / FIXED_INT_MULTIPLIER + 2);
- Exit *exit = scene.checkForExit(charRect);
-
- if (exit) {
- scene._goToScene = exit->_scene;
-
- if (exit->_people.x != 0) {
- people._hSavedPos = exit->_people;
- people._hSavedFacing = exit->_peopleDir;
-
- if (people._hSavedFacing > 100 && people._hSavedPos.x < 1)
- people._hSavedPos.x = 100;
- }
- }
- }
-}
-
void Sprite::checkSprite() {
Events &events = *_vm->_events;
People &people = *_vm->_people;
@@ -472,7 +367,7 @@ void Sprite::checkSprite() {
objBounds.right + CLEAR_DIST_X;
}
- walkPos.x += people[AL]._imageFrame->_frame.w / 2;
+ walkPos.x += people[PLAYER]._imageFrame->_frame.w / 2;
people._walkDest = walkPos;
people._walkTo.push(walkPos);
people.setWalking();
@@ -1400,7 +1295,7 @@ int Object::checkNameForCodes(const Common::String &name, const char *const mess
scene._goToScene = 100;
}
- people[AL]._position = Point32(0, 0);
+ people[PLAYER]._position = Point32(0, 0);
break;
}
} else if (name.hasPrefix("!")) {
diff --git a/engines/sherlock/objects.h b/engines/sherlock/objects.h
index 6561a37..3c690e9 100644
--- a/engines/sherlock/objects.h
+++ b/engines/sherlock/objects.h
@@ -92,6 +92,11 @@ enum {
#define TALK_LISTEN_CODE 251 // Code specifying start of talk listen frames in a Sequence
#define ALLOW_TALK_CODE 250
+#define UPPER_LIMIT 0
+#define LOWER_LIMIT (IS_SERRATED_SCALPEL ? CONTROLS_Y : SHERLOCK_SCREEN_HEIGHT)
+#define LEFT_LIMIT 0
+#define RIGHT_LIMIT SHERLOCK_SCREEN_WIDTH
+
class Point32 {
public:
int x;
@@ -217,7 +222,7 @@ public:
};
class Sprite: public BaseObject {
-private:
+protected:
static SherlockEngine *_vm;
/**
@@ -261,11 +266,6 @@ public:
void setImageFrame();
/**
- * This adjusts the sprites position, as well as it's animation sequence:
- */
- void adjustSprite();
-
- /**
* Checks the sprite's position to see if it's collided with any special objects
*/
void checkSprite();
@@ -299,6 +299,11 @@ public:
* in the sequence number uses alternate graphics, and if so if they need to be loaded
*/
void checkWalkGraphics();
+
+ /**
+ * This adjusts the sprites position, as well as it's animation sequence:
+ */
+ virtual void adjustSprite() = 0;
};
enum { OBJ_BEHIND = 1, OBJ_FLIPPED = 2, OBJ_FORWARD = 4, TURNON_OBJ = 0x20, TURNOFF_OBJ = 0x40 };
diff --git a/engines/sherlock/people.cpp b/engines/sherlock/people.cpp
index e4892b7..a7434ae 100644
--- a/engines/sherlock/people.cpp
+++ b/engines/sherlock/people.cpp
@@ -101,7 +101,7 @@ People *People::init(SherlockEngine *vm) {
return new Tattoo::TattooPeople(vm);
}
-People::People(SherlockEngine *vm) : _vm(vm), _player(_data[0]) {
+People::People(SherlockEngine *vm) : _vm(vm) {
_holmesOn = true;
_oldWalkSequence = -1;
_allowWalkAbort = false;
@@ -124,9 +124,10 @@ People::People(SherlockEngine *vm) : _vm(vm), _player(_data[0]) {
}
People::~People() {
- for (int idx = 0; idx < MAX_CHARACTERS; ++idx) {
- if (_data[idx]._walkLoaded)
- delete _data[PLAYER]._images;
+ for (uint idx = 0; idx < _data.size(); ++idx) {
+ if (_data[idx]->_walkLoaded)
+ delete _data[idx]->_images;
+ delete _data[idx];
}
delete _talkPics;
@@ -134,12 +135,12 @@ People::~People() {
}
void People::reset() {
- _data[0]._description = "Sherlock Holmes!";
+ _data[PLAYER]->_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;
for (int idx = 0; idx < count; ++idx) {
- Sprite &p = _data[idx];
+ Sprite &p = *_data[idx];
p._type = (idx == 0) ? CHARACTER : INVALID;
if (IS_SERRATED_SCALPEL)
@@ -196,71 +197,71 @@ bool People::loadWalk() {
bool result = false;
if (IS_SERRATED_SCALPEL) {
- if (_data[PLAYER]._walkLoaded) {
+ if (_data[PLAYER]->_walkLoaded) {
return false;
} else {
if (_vm->getPlatform() != Common::kPlatform3DO) {
- _data[PLAYER]._images = new ImageFile("walk.vgs");
+ _data[PLAYER]->_images = new ImageFile("walk.vgs");
} else {
// Load walk.anim on 3DO, which is a cel animation file
- _data[PLAYER]._images = new ImageFile3DO("walk.anim");
+ _data[PLAYER]->_images = new ImageFile3DO("walk.anim");
}
- _data[PLAYER].setImageFrame();
- _data[PLAYER]._walkLoaded = true;
+ _data[PLAYER]->setImageFrame();
+ _data[PLAYER]->_walkLoaded = true;
result = true;
}
} else {
for (int idx = 0; idx < MAX_CHARACTERS; ++idx) {
- if (!_data[idx]._walkLoaded && (_data[idx]._type == CHARACTER || _data[idx]._type == HIDDEN_CHARACTER)) {
- if (_data[idx]._type == HIDDEN_CHARACTER)
- _data[idx]._type = INVALID;
+ if (!_data[idx]->_walkLoaded && (_data[idx]->_type == CHARACTER || _data[idx]->_type == HIDDEN_CHARACTER)) {
+ if (_data[idx]->_type == HIDDEN_CHARACTER)
+ _data[idx]->_type = INVALID;
// See if this is one of the more used Walk Graphics stored in WALK.LIB
for (int libNum = 0; libNum < NUM_IN_WALK_LIB; ++libNum) {
- if (!_data[idx]._walkVGSName.compareToIgnoreCase(WALK_LIB_NAMES[libNum])) {
+ if (!_data[idx]->_walkVGSName.compareToIgnoreCase(WALK_LIB_NAMES[libNum])) {
_useWalkLib = true;
break;
}
}
// Load the images for the character
- _data[idx]._images = new ImageFile(_data[idx]._walkVGSName, false);
- _data[idx]._numFrames = _data[idx]._images->size();
+ _data[idx]->_images = new ImageFile(_data[idx]->_walkVGSName, false);
+ _data[idx]->_numFrames = _data[idx]->_images->size();
// Load walk sequence data
- Common::String fname = Common::String(_data[idx]._walkVGSName.c_str(), strchr(_data[idx]._walkVGSName.c_str(), '.'));
+ Common::String fname = Common::String(_data[idx]->_walkVGSName.c_str(), strchr(_data[idx]->_walkVGSName.c_str(), '.'));
fname += ".SEQ";
// Load the walk sequence data
Common::SeekableReadStream *stream = res.load(fname, _useWalkLib ? "walk.lib" : "vgs.lib");
- _data[idx]._walkSequences.resize(stream->readByte());
+ _data[idx]->_walkSequences.resize(stream->readByte());
- for (uint seqNum = 0; seqNum < _data[idx]._walkSequences.size(); ++seqNum)
- _data[idx]._walkSequences[seqNum].load(*stream);
+ for (uint seqNum = 0; seqNum < _data[idx]->_walkSequences.size(); ++seqNum)
+ _data[idx]->_walkSequences[seqNum].load(*stream);
// Close the sequences resource
delete stream;
_useWalkLib = false;
- _data[idx]._frameNumber = 0;
- _data[idx].setImageFrame();
+ _data[idx]->_frameNumber = 0;
+ _data[idx]->setImageFrame();
// Set the stop Frames pointers
for (int dirNum = 0; dirNum < 8; ++dirNum) {
int count = 0;
- while (_data[idx]._walkSequences[dirNum + 8][count] != 0)
+ while (_data[idx]->_walkSequences[dirNum + 8][count] != 0)
++count;
count += 2;
- count = _data[idx]._walkSequences[dirNum + 8][count] - 1;
- _data[idx]._stopFrames[dirNum] = &(*_data[idx]._images)[count];
+ count = _data[idx]->_walkSequences[dirNum + 8][count] - 1;
+ _data[idx]->_stopFrames[dirNum] = &(*_data[idx]->_images)[count];
}
result = true;
- _data[idx]._walkLoaded = true;
- } else if (_data[idx]._type != CHARACTER) {
- _data[idx]._walkLoaded = false;
+ _data[idx]->_walkLoaded = true;
+ } else if (_data[idx]->_type != CHARACTER) {
+ _data[idx]->_walkLoaded = false;
}
}
}
@@ -273,11 +274,11 @@ bool People::freeWalk() {
bool result = false;
for (int idx = 0; idx < MAX_CHARACTERS; ++idx) {
- if (_data[idx]._walkLoaded) {
- delete _data[idx]._images;
- _data[idx]._images = nullptr;
+ if (_data[idx]->_walkLoaded) {
+ delete _data[idx]->_images;
+ _data[idx]->_images = nullptr;
- _data[idx]._walkLoaded = false;
+ _data[idx]->_walkLoaded = false;
result = true;
}
}
@@ -295,9 +296,9 @@ void People::setWalking() {
scene._walkedInScene = true;
// Stop any previous walking, since a new dest is being set
- _player._walkCount = 0;
- oldDirection = _player._sequenceNumber;
- oldFrame = _player._frameNumber;
+ _data[PLAYER]->_walkCount = 0;
+ oldDirection = _data[PLAYER]->_sequenceNumber;
+ oldFrame = _data[PLAYER]->_frameNumber;
// Set speed to use horizontal and vertical movement
if (map._active) {
@@ -314,12 +315,12 @@ void People::setWalking() {
// clicked, but characters draw positions start at their left, move
// the destination half the character width to draw him centered
int temp;
- if (_walkDest.x >= (temp = _player._imageFrame->_frame.w / 2))
+ if (_walkDest.x >= (temp = _data[PLAYER]->_imageFrame->_frame.w / 2))
_walkDest.x -= temp;
delta = Common::Point(
- ABS(_player._position.x / FIXED_INT_MULTIPLIER - _walkDest.x),
- ABS(_player._position.y / FIXED_INT_MULTIPLIER - _walkDest.y)
+ ABS(_data[PLAYER]->_position.x / FIXED_INT_MULTIPLIER - _walkDest.x),
+ ABS(_data[PLAYER]->_position.y / FIXED_INT_MULTIPLIER - _walkDest.y)
);
// If we're ready to move a sufficient distance, that's it. Otherwise,
@@ -337,53 +338,53 @@ void People::setWalking() {
if (delta.x >= delta.y) {
// Set the initial frame sequence for the left and right, as well
// as setting the delta x depending on direction
- if (_walkDest.x < (_player._position.x / FIXED_INT_MULTIPLIER)) {
- _player._sequenceNumber = (map._active ? (int)MAP_LEFT : (int)Scalpel::WALK_LEFT);
- _player._delta.x = speed.x * -FIXED_INT_MULTIPLIER;
+ if (_walkDest.x < (_data[PLAYER]->_position.x / FIXED_INT_MULTIPLIER)) {
+ _data[PLAYER]->_sequenceNumber = (map._active ? (int)MAP_LEFT : (int)Scalpel::WALK_LEFT);
+ _data[PLAYER]->_delta.x = speed.x * -FIXED_INT_MULTIPLIER;
} else {
- _player._sequenceNumber = (map._active ? (int)MAP_RIGHT : (int)Scalpel::WALK_RIGHT);
- _player._delta.x = speed.x * FIXED_INT_MULTIPLIER;
+ _data[PLAYER]->_sequenceNumber = (map._active ? (int)MAP_RIGHT : (int)Scalpel::WALK_RIGHT);
+ _data[PLAYER]->_delta.x = speed.x * FIXED_INT_MULTIPLIER;
}
// See if the x delta is too small to be divided by the speed, since
// this would cause a divide by zero error
if (delta.x >= speed.x) {
// Det the delta y
- _player._delta.y = (delta.y * FIXED_INT_MULTIPLIER) / (delta.x / speed.x);
- if (_walkDest.y < (_player._position.y / FIXED_INT_MULTIPLIER))
- _player._delta.y = -_player._delta.y;
+ _data[PLAYER]->_delta.y = (delta.y * FIXED_INT_MULTIPLIER) / (delta.x / speed.x);
+ if (_walkDest.y < (_data[PLAYER]->_position.y / FIXED_INT_MULTIPLIER))
+ _data[PLAYER]->_delta.y = -_data[PLAYER]->_delta.y;
// Set how many times we should add the delta to the player's position
- _player._walkCount = delta.x / speed.x;
+ _data[PLAYER]->_walkCount = delta.x / speed.x;
} else {
// The delta x was less than the speed (ie. we're really close to
// the destination). So set delta to 0 so the player won't move
- _player._delta = Point32(0, 0);
- _player._position = Point32(_walkDest.x * FIXED_INT_MULTIPLIER, _walkDest.y * FIXED_INT_MULTIPLIER);
-assert(_player._position.y >= 10000);/***DEBUG****/
- _player._walkCount = 1;
+ _data[PLAYER]->_delta = Point32(0, 0);
+ _data[PLAYER]->_position = Point32(_walkDest.x * FIXED_INT_MULTIPLIER, _walkDest.y * FIXED_INT_MULTIPLIER);
+assert(_data[PLAYER]->_position.y >= 10000);/***DEBUG****/
+ _data[PLAYER]->_walkCount = 1;
}
// See if the sequence needs to be changed for diagonal walking
- if (_player._delta.y > 150) {
+ if (_data[PLAYER]->_delta.y > 150) {
if (!map._active) {
- switch (_player._sequenceNumber) {
+ switch (_data[PLAYER]->_sequenceNumber) {
case Scalpel::WALK_LEFT:
- _player._sequenceNumber = Scalpel::WALK_DOWNLEFT;
+ _data[PLAYER]->_sequenceNumber = Scalpel::WALK_DOWNLEFT;
break;
case Scalpel::WALK_RIGHT:
- _player._sequenceNumber = Scalpel::WALK_DOWNRIGHT;
+ _data[PLAYER]->_sequenceNumber = Scalpel::WALK_DOWNRIGHT;
break;
}
}
- } else if (_player._delta.y < -150) {
+ } else if (_data[PLAYER]->_delta.y < -150) {
if (!map._active) {
- switch (_player._sequenceNumber) {
+ switch (_data[PLAYER]->_sequenceNumber) {
case Scalpel::WALK_LEFT:
- _player._sequenceNumber = Scalpel::WALK_UPLEFT;
+ _data[PLAYER]->_sequenceNumber = Scalpel::WALK_UPLEFT;
break;
case Scalpel::WALK_RIGHT:
- _player._sequenceNumber = Scalpel::WALK_UPRIGHT;
+ _data[PLAYER]->_sequenceNumber = Scalpel::WALK_UPRIGHT;
break;
}
}
@@ -391,25 +392,25 @@ assert(_player._position.y >= 10000);/***DEBUG****/
} else {
// Major movement is vertical, so set the sequence for up and down,
// and set the delta Y depending on the direction
- if (_walkDest.y < (_player._position.y / FIXED_INT_MULTIPLIER)) {
- _player._sequenceNumber = Scalpel::WALK_UP;
- _player._delta.y = speed.y * -FIXED_INT_MULTIPLIER;
+ if (_walkDest.y < (_data[PLAYER]->_position.y / FIXED_INT_MULTIPLIER)) {
+ _data[PLAYER]->_sequenceNumber = Scalpel::WALK_UP;
+ _data[PLAYER]->_delta.y = speed.y * -FIXED_INT_MULTIPLIER;
} else {
- _player._sequenceNumber = Scalpel::WALK_DOWN;
- _player._delta.y = speed.y * FIXED_INT_MULTIPLIER;
+ _data[PLAYER]->_sequenceNumber = Scalpel::WALK_DOWN;
+ _data[PLAYER]->_delta.y = speed.y * FIXED_INT_MULTIPLIER;
}
// If we're on the overhead map, set the sequence so we keep moving
// in the same direction
if (map._active)
- _player._sequenceNumber = (oldDirection == -1) ? MAP_RIGHT : oldDirection;
+ _data[PLAYER]->_sequenceNumber = (oldDirection == -1) ? MAP_RIGHT : oldDirection;
// Set the delta x
- _player._delta.x = (delta.x * FIXED_INT_MULTIPLIER) / (delta.y / speed.y);
- if (_walkDest.x < (_player._position.x / FIXED_INT_MULTIPLIER))
- _player._delta.x = -_player._delta.x;
+ _data[PLAYER]->_delta.x = (delta.x * FIXED_INT_MULTIPLIER) / (delta.y / speed.y);
+ if (_walkDest.x < (_data[PLAYER]->_position.x / FIXED_INT_MULTIPLIER))
+ _data[PLAYER]->_delta.x = -_data[PLAYER]->_delta.x;
- _player._walkCount = delta.y / speed.y;
+ _data[PLAYER]->_walkCount = delta.y / speed.y;
}
}
@@ -417,18 +418,18 @@ assert(_player._position.y >= 10000);/***DEBUG****/
// we need to reset the frame number to zero so it's animation starts at
// it's beginning. Otherwise, if it's the same sequence, we can leave it
// as is, so it keeps the animation going at wherever it was up to
- if (_player._sequenceNumber != _oldWalkSequence)
- _player._frameNumber = 0;
- _oldWalkSequence = _player._sequenceNumber;
+ if (_data[PLAYER]->_sequenceNumber != _oldWalkSequence)
+ _data[PLAYER]->_frameNumber = 0;
+ _oldWalkSequence = _data[PLAYER]->_sequenceNumber;
- if (!_player._walkCount)
- gotoStand(_player);
+ if (!_data[PLAYER]->_walkCount)
+ gotoStand(*_data[PLAYER]);
// If the sequence is the same as when we started, then Holmes was
// standing still and we're trying to re-stand him, so reset Holmes'
// rame to the old frame number from before it was reset to 0
- if (_player._sequenceNumber == oldDirection)
- _player._frameNumber = oldFrame;
+ if (_data[PLAYER]->_sequenceNumber == oldDirection)
+ _data[PLAYER]->_frameNumber = oldFrame;
}
void People::walkToCoords(const Point32 &destPos, int destDir) {
@@ -447,15 +448,15 @@ void People::walkToCoords(const Point32 &destPos, int destDir) {
do {
events.pollEventsAndWait();
scene.doBgAnim();
- } while (!_vm->shouldQuit() && _player._walkCount);
+ } while (!_vm->shouldQuit() && _data[PLAYER]->_walkCount);
if (!talk._talkToAbort) {
// Put player exactly on destination position, and set direction
- _player._position = destPos;
-assert(_player._position.y >= 10000);/***DEBUG****/
+ _data[PLAYER]->_position = destPos;
+assert(_data[PLAYER]->_position.y >= 10000);/***DEBUG****/
- _player._sequenceNumber = destDir;
- gotoStand(_player);
+ _data[PLAYER]->_sequenceNumber = destDir;
+ gotoStand(*_data[PLAYER]);
// Draw Holmes facing the new direction
scene.doBgAnim();
@@ -467,8 +468,8 @@ assert(_player._position.y >= 10000);/***DEBUG****/
void People::goAllTheWay() {
Scene &scene = *_vm->_scene;
- Common::Point srcPt(_player._position.x / FIXED_INT_MULTIPLIER + _player.frameWidth() / 2,
- _player._position.y / FIXED_INT_MULTIPLIER);
+ Common::Point srcPt(_data[PLAYER]->_position.x / FIXED_INT_MULTIPLIER + _data[PLAYER]->frameWidth() / 2,
+ _data[PLAYER]->_position.y / FIXED_INT_MULTIPLIER);
// Get the zone the player is currently in
_srcZone = scene.whichZone(srcPt);
@@ -572,14 +573,14 @@ int People::findSpeaker(int speaker) {
if (IS_ROSE_TATTOO) {
bool flag = _vm->readFlags(76);
- if (_data[0]._type == CHARACTER && ((speaker == 0 && flag) || (speaker == 1 && !flag)))
+ if (_data[PLAYER]->_type == CHARACTER && ((speaker == 0 && flag) || (speaker == 1 && !flag)))
return -1;
- for (uint idx = 1; idx < MAX_CHARACTERS; ++idx) {
- if (_data[idx]._type == CHARACTER) {
- Common::String name(_data[idx]._name.c_str(), _data[idx]._name.c_str() + 4);
+ for (uint idx = 1; idx < _data.size(); ++idx) {
+ if (_data[idx]->_type == CHARACTER) {
+ Common::String name(_data[idx]->_name.c_str(), _data[idx]->_name.c_str() + 4);
- if (name.equalsIgnoreCase(portrait) && _data[idx]._npcName[4] >= '0' && _data[idx]._npcName[4] <= '9')
+ if (name.equalsIgnoreCase(portrait) && _data[idx]->_npcName[4] >= '0' && _data[idx]->_npcName[4] <= '9')
return idx + 256;
}
}
@@ -622,12 +623,12 @@ void People::synchronize(Serializer &s) {
s.syncAsByte(_holmesOn);
if (IS_SERRATED_SCALPEL) {
- s.syncAsSint16LE(_player._position.x);
- s.syncAsSint16LE(_player._position.y);
- s.syncAsSint16LE(_player._sequenceNumber);
+ s.syncAsSint16LE(_data[PLAYER]->_position.x);
+ s.syncAsSint16LE(_data[PLAYER]->_position.y);
+ s.syncAsSint16LE(_data[PLAYER]->_sequenceNumber);
} else {
- for (int idx = 0; idx < MAX_CHARACTERS; ++idx) {
- Person &p = _data[idx];
+ for (uint idx = 0; idx < _data.size(); ++idx) {
+ Person &p = *_data[idx];
s.syncAsSint16LE(p._position.x);
s.syncAsSint16LE(p._position.y);
s.syncAsSint16LE(p._sequenceNumber);
@@ -641,8 +642,8 @@ void People::synchronize(Serializer &s) {
s.syncAsSint16LE(_holmesQuotient);
if (s.isLoading()) {
- _hSavedPos = _player._position;
- _hSavedFacing = _player._sequenceNumber;
+ _hSavedPos = _data[PLAYER]->_position;
+ _hSavedFacing = _data[PLAYER]->_sequenceNumber;
}
}
diff --git a/engines/sherlock/people.h b/engines/sherlock/people.h
index cd790ea..b45f7b4 100644
--- a/engines/sherlock/people.h
+++ b/engines/sherlock/people.h
@@ -32,9 +32,6 @@ namespace Sherlock {
enum PeopleId {
PLAYER = 0,
- AL = 0,
- PEG = 1,
- MAX_CHARACTERS = 6,
MAX_NPC = 5,
MAX_NPC_PATH = 200
};
@@ -47,6 +44,7 @@ enum {
#define NUM_IN_WALK_LIB 10
extern const char *const WALK_LIB_NAMES[10];
+#define MAX_CHARACTERS (IS_SERRATED_SCALPEL ? 1 : 6)
struct PersonData {
const char *_name;
@@ -81,6 +79,7 @@ public:
Common::String _walkVGSName; // Name of walk library person is using
public:
Person();
+ virtual ~Person() {}
/**
* Clear the NPC related data
@@ -98,7 +97,7 @@ class SherlockEngine;
class People {
protected:
SherlockEngine *_vm;
- Person _data[MAX_CHARACTERS];
+ Common::Array<Person *> _data;
int _oldWalkSequence;
int _srcZone, _destZone;
@@ -110,7 +109,6 @@ public:
Point32 _hSavedPos;
int _hSavedFacing;
Common::Queue<Common::Point> _walkTo;
- Person &_player;
bool _holmesOn;
bool _portraitLoaded;
bool _portraitsOn;
@@ -129,14 +127,8 @@ public:
static People *init(SherlockEngine *vm);
virtual ~People();
- Person &operator[](PeopleId id) {
- assert(id < MAX_CHARACTERS);
- return _data[id];
- }
- Person &operator[](int idx) {
- assert(idx < MAX_CHARACTERS);
- return _data[idx];
- }
+ Person &operator[](PeopleId id) { return *_data[id]; }
+ Person &operator[](int idx) { return *_data[idx]; }
/**
* Reset the player data
diff --git a/engines/sherlock/scalpel/scalpel.cpp b/engines/sherlock/scalpel/scalpel.cpp
index e0c91ee..a3ada42 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)[AL]._position.x / FIXED_INT_MULTIPLIER, (*_people)[AL]._position.y / FIXED_INT_MULTIPLIER);
+ Common::Point pt((*_people)[PLAYER]._position.x / FIXED_INT_MULTIPLIER, (*_people)[PLAYER]._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[PLAYER];
- Common::Point pt((*_people)[AL]._position.x / FIXED_INT_MULTIPLIER, (*_people)[AL]._position.y / FIXED_INT_MULTIPLIER);
+ Common::Point pt((*_people)[PLAYER]._position.x / FIXED_INT_MULTIPLIER, (*_people)[PLAYER]._position.y / FIXED_INT_MULTIPLIER);
int frameNum = player._walkSequences[player._sequenceNumber][player._frameNumber] +
player._walkSequences[player._sequenceNumber][0] - 2;
- switch ((*_people)[AL]._sequenceNumber) {
+ switch ((*_people)[PLAYER]._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[AL]._images)[frameNum];
+ ImageFrame &imageFrame = (*people[PLAYER]._images)[frameNum];
// Draw the mirror image of Holmes
- bool flipped = people[AL]._sequenceNumber == WALK_LEFT || people[AL]._sequenceNumber == STOP_LEFT
- || people[AL]._sequenceNumber == WALK_UPRIGHT || people[AL]._sequenceNumber == STOP_UPRIGHT
- || people[AL]._sequenceNumber == WALK_DOWNLEFT || people[AL]._sequenceNumber == STOP_DOWNLEFT;
+ 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;
_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)[AL]._position.x / FIXED_INT_MULTIPLIER, (*_people)[AL]._position.y / FIXED_INT_MULTIPLIER);
+ Common::Point pt((*_people)[PLAYER]._position.x / FIXED_INT_MULTIPLIER, (*_people)[PLAYER]._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 bcb41ab..3957f27 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[AL]._position = _lDrawnPos = _overPos;
+ people[PLAYER]._position = _lDrawnPos = _overPos;
// Show place icons
showPlaces();
@@ -233,7 +233,7 @@ int ScalpelMap::show() {
}
if ((events._released || events._rightReleased) && _point != -1) {
- if (people[AL]._walkCount == 0) {
+ if (people[PLAYER]._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[AL]._walkCount == 0) {
+ if (people[PLAYER]._walkCount == 0) {
if (_charPoint >= 1 && _charPoint < (int)_points.size())
exitFlag = true;
}
@@ -266,7 +266,7 @@ int ScalpelMap::show() {
}
freeSprites();
- _overPos = people[AL]._position;
+ _overPos = people[PLAYER]._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[AL];
+ Person &p = people[PLAYER];
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[AL]._imageFrame, _lDrawnPos);
+ saveIcon(people[PLAYER]._imageFrame, _lDrawnPos);
- bool flipped = people[AL]._sequenceNumber == MAP_DOWNLEFT || people[AL]._sequenceNumber == MAP_LEFT
- || people[AL]._sequenceNumber == MAP_UPLEFT;
- screen._backBuffer1.transBlitFrom(*people[AL]._imageFrame, _lDrawnPos, flipped);
+ 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);
}
if (highlighted) {
@@ -390,26 +390,26 @@ void ScalpelMap::updateMap(bool flushScreen) {
else
_savedPos.x = -1;
- people[AL].adjustSprite();
+ people[PLAYER].adjustSprite();
- _lDrawnPos.x = hPos.x = people[AL]._position.x / FIXED_INT_MULTIPLIER - _bigPos.x;
- _lDrawnPos.y = hPos.y = people[AL]._position.y / FIXED_INT_MULTIPLIER - people[AL].frameHeight() - _bigPos.y;
+ _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;
// Draw the person icon
- saveIcon(people[AL]._imageFrame, hPos);
- if (people[AL]._sequenceNumber == MAP_DOWNLEFT || people[AL]._sequenceNumber == MAP_LEFT
- || people[AL]._sequenceNumber == MAP_UPLEFT)
- screen._backBuffer1.transBlitFrom(*people[AL]._imageFrame, hPos, true);
+ 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);
else
- screen._backBuffer1.transBlitFrom(*people[AL]._imageFrame, hPos, false);
+ screen._backBuffer1.transBlitFrom(*people[PLAYER]._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[AL]._imageFrame, Common::Point(people[AL]._position.x / FIXED_INT_MULTIPLIER - _bigPos.x,
- people[AL]._position.y / FIXED_INT_MULTIPLIER - people[AL].frameHeight() - _bigPos.y),
- &people[AL]._oldPosition.x, &people[AL]._oldPosition.y, &people[AL]._oldSize.x, &people[AL]._oldSize.y);
+ 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);
if (osPos.x != -1)
screen.slamArea(osPos.x, osPos.y, osSize.x, osSize.y);
@@ -433,7 +433,7 @@ void ScalpelMap::walkTheStreets() {
// Check for any intermediate points between the two locations
if (path[0] || _charPoint > 50 || _oldCharPoint > 50) {
- people[AL]._sequenceNumber = -1;
+ people[PLAYER]._sequenceNumber = -1;
if (_charPoint == 51 || _oldCharPoint == 51) {
people.setWalking();
@@ -467,7 +467,7 @@ void ScalpelMap::walkTheStreets() {
people.setWalking();
}
} else {
- people[AL]._walkCount = 0;
+ people[PLAYER]._walkCount = 0;
}
// Store the final destination icon position
diff --git a/engines/sherlock/scalpel/scalpel_people.cpp b/engines/sherlock/scalpel/scalpel_people.cpp
index 80e6061..e0abd72 100644
--- a/engines/sherlock/scalpel/scalpel_people.cpp
+++ b/engines/sherlock/scalpel/scalpel_people.cpp
@@ -28,6 +28,113 @@ namespace Sherlock {
namespace Scalpel {
+void ScalpelPerson::adjustSprite() {
+ Map &map = *_vm->_map;
+ People &people = *_vm->_people;
+ Scene &scene = *_vm->_scene;
+ Talk &talk = *_vm->_talk;
+
+ if (_type == INVALID || (_type == CHARACTER && scene._animating))
+ return;
+
+ if (!talk._talkCounter && _type == CHARACTER && _walkCount) {
+ // Handle active movement for the sprite
+ _position += _delta;
+ --_walkCount;
+
+ 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._walkTo.empty()) {
+ people._walkDest = people._walkTo.pop();
+ people.setWalking();
+ } else {
+ people.gotoStand(*this);
+ }
+ }
+ }
+
+ if (_type == CHARACTER && !map._active) {
+ if ((_position.y / FIXED_INT_MULTIPLIER) > LOWER_LIMIT) {
+ _position.y = LOWER_LIMIT * FIXED_INT_MULTIPLIER;
+ people.gotoStand(*this);
+ }
+
+ if ((_position.y / FIXED_INT_MULTIPLIER) < UPPER_LIMIT) {
+ _position.y = UPPER_LIMIT * FIXED_INT_MULTIPLIER;
+ people.gotoStand(*this);
+ }
+
+ if ((_position.x / FIXED_INT_MULTIPLIER) < LEFT_LIMIT) {
+ _position.x = LEFT_LIMIT * FIXED_INT_MULTIPLIER;
+ people.gotoStand(*this);
+ }
+
+ if ((_position.x / FIXED_INT_MULTIPLIER) > RIGHT_LIMIT) {
+ _position.x = RIGHT_LIMIT * FIXED_INT_MULTIPLIER;
+ people.gotoStand(*this);
+ }
+ } else if (!map._active) {
+ _position.y = CLIP((int)_position.y, (int)UPPER_LIMIT, (int)LOWER_LIMIT);
+ _position.x = CLIP((int)_position.x, (int)LEFT_LIMIT, (int)RIGHT_LIMIT);
+ }
+
+ if (!map._active || (map._frameChangeFlag = !map._frameChangeFlag))
+ ++_frameNumber;
+
+ if (_frameNumber >= (int)_walkSequences[_sequenceNumber]._sequences.size() ||
+ _walkSequences[_sequenceNumber][_frameNumber] == 0) {
+ switch (_sequenceNumber) {
+ case Scalpel::STOP_UP:
+ case Scalpel::STOP_DOWN:
+ case Scalpel::STOP_LEFT:
+ case Scalpel::STOP_RIGHT:
+ case Scalpel::STOP_UPRIGHT:
+ case Scalpel::STOP_UPLEFT:
+ case Scalpel::STOP_DOWNRIGHT:
+ case Scalpel::STOP_DOWNLEFT:
+ // We're in a stop sequence, so reset back to the last frame, so
+ // the character is shown as standing still
+ --_frameNumber;
+ break;
+
+ default:
+ // Move 1 past the first frame - we need to compensate, since we
+ // already passed the frame increment
+ _frameNumber = 1;
+ break;
+ }
+ }
+
+ // Update the _imageFrame to point to the new frame's image
+ setImageFrame();
+
+ // Check to see if character has entered an exit zone
+ if (!_walkCount && scene._walkedInScene && scene._goToScene == -1) {
+ Common::Rect charRect(_position.x / FIXED_INT_MULTIPLIER - 5, _position.y / FIXED_INT_MULTIPLIER - 2,
+ _position.x / FIXED_INT_MULTIPLIER + 5, _position.y / FIXED_INT_MULTIPLIER + 2);
+ Exit *exit = scene.checkForExit(charRect);
+
+ if (exit) {
+ scene._goToScene = exit->_scene;
+
+ if (exit->_people.x != 0) {
+ people._hSavedPos = exit->_people;
+ people._hSavedFacing = exit->_peopleDir;
+
+ if (people._hSavedFacing > 100 && people._hSavedPos.x < 1)
+ people._hSavedPos.x = 100;
+ }
+ }
+ }
+}
+
+/*----------------------------------------------------------------*/
+
+ScalpelPeople::ScalpelPeople(SherlockEngine *vm) : People(vm) {
+ _data.push_back(new ScalpelPerson());
+}
+
void ScalpelPeople::setTalking(int speaker) {
Resources &res = *_vm->_res;
@@ -89,14 +196,14 @@ void ScalpelPeople::setTalking(int speaker) {
void ScalpelPeople::synchronize(Serializer &s) {
s.syncAsByte(_holmesOn);
- s.syncAsSint32LE(_player._position.x);
- s.syncAsSint32LE(_player._position.y);
- s.syncAsSint16LE(_player._sequenceNumber);
+ s.syncAsSint32LE(_data[PLAYER]->_position.x);
+ s.syncAsSint32LE(_data[PLAYER]->_position.y);
+ s.syncAsSint16LE(_data[PLAYER]->_sequenceNumber);
s.syncAsSint16LE(_holmesQuotient);
if (s.isLoading()) {
- _hSavedPos = _player._position;
- _hSavedFacing = _player._sequenceNumber;
+ _hSavedPos = _data[PLAYER]->_position;
+ _hSavedFacing = _data[PLAYER]->_sequenceNumber;
}
}
@@ -172,8 +279,8 @@ void ScalpelPeople::gotoStand(Sprite &sprite) {
if (map._active) {
sprite._sequenceNumber = 0;
- _player._position.x = (map[map._charPoint].x - 6) * FIXED_INT_MULTIPLIER;
- _player._position.y = (map[map._charPoint].y + 10) * FIXED_INT_MULTIPLIER;
+ _data[PLAYER]->_position.x = (map[map._charPoint].x - 6) * FIXED_INT_MULTIPLIER;
+ _data[PLAYER]->_position.y = (map[map._charPoint].y + 10) * FIXED_INT_MULTIPLIER;
}
_oldWalkSequence = -1;
diff --git a/engines/sherlock/scalpel/scalpel_people.h b/engines/sherlock/scalpel/scalpel_people.h
index 1f14cee..dac685b 100644
--- a/engines/sherlock/scalpel/scalpel_people.h
+++ b/engines/sherlock/scalpel/scalpel_people.h
@@ -41,9 +41,20 @@ enum ScalpelSequences {
STOP_DOWNLEFT = 15, TALK_RIGHT = 6, TALK_LEFT = 4
};
+class ScalpelPerson : public Person {
+public:
+ ScalpelPerson() : Person() {}
+ virtual ~ScalpelPerson() {}
+
+ /**
+ * This adjusts the sprites position, as well as it's animation sequence:
+ */
+ virtual void adjustSprite();
+};
+
class ScalpelPeople : public People {
public:
- ScalpelPeople(SherlockEngine *vm) : People(vm) {}
+ ScalpelPeople(SherlockEngine *vm);
virtual ~ScalpelPeople() {}
/**
diff --git a/engines/sherlock/scalpel/scalpel_scene.cpp b/engines/sherlock/scalpel/scalpel_scene.cpp
index 95a58be..e3bc648 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[PLAYER];
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[AL]._oldPosition.x, people[AL]._oldPosition.y,
- people[AL]._oldPosition.x + people[AL]._oldSize.x,
- people[AL]._oldPosition.y + people[AL]._oldSize.y);
+ 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::Point pt(bounds.left, bounds.top);
- if (people[AL]._type == CHARACTER)
+ if (people[PLAYER]._type == CHARACTER)
screen.restoreBackground(bounds);
- else if (people[AL]._type == REMOVE)
+ else if (people[PLAYER]._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[AL]._type == CHARACTER && people._holmesOn)
- people[AL].adjustSprite();
+ if (people[PLAYER]._type == CHARACTER && people._holmesOn)
+ people[PLAYER].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[AL]._type == CHARACTER && people[AL]._walkLoaded) {
+ if (people[PLAYER]._type == CHARACTER && people[PLAYER]._walkLoaded) {
// If Holmes is too far to the right, move him back so he's on-screen
- int xRight = SHERLOCK_SCREEN_WIDTH - 2 - people[AL]._imageFrame->_frame.w;
- int tempX = MIN(people[AL]._position.x / FIXED_INT_MULTIPLIER, xRight);
+ int xRight = SHERLOCK_SCREEN_WIDTH - 2 - people[PLAYER]._imageFrame->_frame.w;
+ int tempX = MIN(people[PLAYER]._position.x / FIXED_INT_MULTIPLIER, xRight);
- bool flipped = people[AL]._sequenceNumber == WALK_LEFT || people[AL]._sequenceNumber == STOP_LEFT ||
- people[AL]._sequenceNumber == WALK_UPLEFT || people[AL]._sequenceNumber == STOP_UPLEFT ||
- people[AL]._sequenceNumber == WALK_DOWNRIGHT || people[AL]._sequenceNumber == STOP_DOWNRIGHT;
- screen._backBuffer->transBlitFrom(*people[AL]._imageFrame,
- Common::Point(tempX, people[AL]._position.y / FIXED_INT_MULTIPLIER - people[AL]._imageFrame->_frame.h), flipped);
+ 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);
}
// 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[AL]._type != INVALID && ((_goToScene == -1 || _canimShapes.empty()))) {
- if (people[AL]._type == REMOVE) {
+ if (people[PLAYER]._type != INVALID && ((_goToScene == -1 || _canimShapes.empty()))) {
+ if (people[PLAYER]._type == REMOVE) {
screen.slamRect(Common::Rect(
- people[AL]._oldPosition.x, people[AL]._oldPosition.y,
- people[AL]._oldPosition.x + people[AL]._oldSize.x,
- people[AL]._oldPosition.y + people[AL]._oldSize.y
+ 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[AL]._type = INVALID;
+ people[PLAYER]._type = INVALID;
} else {
- screen.flushImage(people[AL]._imageFrame,
- Common::Point(people[AL]._position.x / FIXED_INT_MULTIPLIER,
- people[AL]._position.y / FIXED_INT_MULTIPLIER - people[AL].frameHeight()),
- &people[AL]._oldPosition.x, &people[AL]._oldPosition.y,
- &people[AL]._oldSize.x, &people[AL]._oldSize.y);
+ 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);
}
}
@@ -525,7 +525,7 @@ 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[AL]._position != walkPos)
+ if (people[PLAYER]._position != walkPos)
people.walkToCoords(walkPos, walkDir);
}
@@ -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[AL]._type = REMOVE;
+ people[PLAYER]._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[AL]._type = CHARACTER;
+ people[PLAYER]._type = CHARACTER;
}
// Teleport to ending coordinates if necessary
if (tpPos.x != -1) {
- people[AL]._position = tpPos; // Place the player
- people[AL]._sequenceNumber = tpDir;
- people.gotoStand(people[AL]);
+ people[PLAYER]._position = tpPos; // Place the player
+ people[PLAYER]._sequenceNumber = tpDir;
+ people.gotoStand(people[PLAYER]);
}
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[AL]._position = tpPos;
- people[AL]._sequenceNumber = tpDir;
+ people[PLAYER]._position = tpPos;
+ people[PLAYER]._sequenceNumber = tpDir;
- people.gotoStand(people[AL]);
+ people.gotoStand(people[PLAYER]);
}
events.setCursor(oldCursor);
diff --git a/engines/sherlock/scalpel/scalpel_user_interface.cpp b/engines/sherlock/scalpel/scalpel_user_interface.cpp
index a89ebb6..31399b0 100644
--- a/engines/sherlock/scalpel/scalpel_user_interface.cpp
+++ b/engines/sherlock/scalpel/scalpel_user_interface.cpp
@@ -2230,9 +2230,9 @@ void ScalpelUserInterface::checkAction(ActionType &action, const char *const mes
if (!talk._talkToAbort) {
// Ensure Holmes is on the exact intended location
- people[AL]._position = pt;
- people[AL]._sequenceNumber = dir;
- people.gotoStand(people[AL]);
+ people[PLAYER]._position = pt;
+ people[PLAYER]._sequenceNumber = dir;
+ people.gotoStand(people[PLAYER]);
talk.talkTo(action._names[nameIdx].c_str() + 2);
if (ch == 'T')
diff --git a/engines/sherlock/scene.cpp b/engines/sherlock/scene.cpp
index 441862c..b52dfc1 100644
--- a/engines/sherlock/scene.cpp
+++ b/engines/sherlock/scene.cpp
@@ -239,8 +239,8 @@ void Scene::selectScene() {
_tempFadeStyle = 0;
}
- people._walkDest = Common::Point(people[AL]._position.x / FIXED_INT_MULTIPLIER,
- people[AL]._position.y / FIXED_INT_MULTIPLIER);
+ people._walkDest = Common::Point(people[PLAYER]._position.x / FIXED_INT_MULTIPLIER,
+ people[PLAYER]._position.y / FIXED_INT_MULTIPLIER);
_restoreFlag = true;
events.clearEvents();
@@ -1065,7 +1065,7 @@ void Scene::transitionToScene() {
Common::Point pt = c._goto;
c._goto = Common::Point(-1, -1);
- people[AL]._position = Common::Point(0, 0);
+ people[PLAYER]._position = Common::Point(0, 0);
startCAnim(cAnimNum, 1);
c._goto = pt;
@@ -1218,7 +1218,7 @@ void Scene::setNPCPath(int npc) {
void Scene::checkBgShapes() {
People &people = *_vm->_people;
- Person &holmes = people._player;
+ Person &holmes = people[PLAYER];
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 db4bcd8..a968f9f 100644
--- a/engines/sherlock/talk.cpp
+++ b/engines/sherlock/talk.cpp
@@ -167,13 +167,13 @@ void Talk::talkTo(const Common::String &filename) {
// Turn on the Exit option
ui._endKeyActive = true;
- if (people[AL]._walkCount || people._walkTo.size() > 0) {
+ if (people[PLAYER]._walkCount || people._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.gotoStand(people._player);
+ people.gotoStand(people[PLAYER]);
}
if (_talkToAbort)
diff --git a/engines/sherlock/tattoo/tattoo_people.cpp b/engines/sherlock/tattoo/tattoo_people.cpp
index 61f79c4..cc50a32 100644
--- a/engines/sherlock/tattoo/tattoo_people.cpp
+++ b/engines/sherlock/tattoo/tattoo_people.cpp
@@ -28,6 +28,20 @@ namespace Sherlock {
namespace Tattoo {
+void TattooPerson::adjustSprite() {
+ // TODO
+ warning("TODO: TattooPerson::adjustSprite");
+}
+
+/*----------------------------------------------------------------*/
+
+TattooPeople::TattooPeople(SherlockEngine *vm) : People(vm) {
+ for (int idx = 0; idx < 6; ++idx)
+ _data.push_back(new TattooPerson());
+}
+
+
+
void TattooPeople::setListenSequence(int speaker, int sequenceNum) {
Scene &scene = *_vm->_scene;
@@ -45,7 +59,7 @@ void TattooPeople::setListenSequence(int speaker, int sequenceNum) {
obj.setObjTalkSequence(sequenceNum);
} else if (objNum != -1) {
objNum -= 256;
- Person &person = _data[objNum];
+ Person &person = *_data[objNum];
int newDir = person._sequenceNumber;
switch (person._sequenceNumber) {
@@ -203,8 +217,8 @@ void TattooPeople::setTalkSequence(int speaker, int sequenceNum) {
void TattooPeople::synchronize(Serializer &s) {
s.syncAsByte(_holmesOn);
- for (int idx = 0; idx < MAX_CHARACTERS; ++idx) {
- Person &p = _data[idx];
+ for (uint idx = 0; idx < _data.size(); ++idx) {
+ Person &p = *_data[idx];
s.syncAsSint32LE(p._position.x);
s.syncAsSint32LE(p._position.y);
s.syncAsSint16LE(p._sequenceNumber);
@@ -217,8 +231,8 @@ void TattooPeople::synchronize(Serializer &s) {
s.syncAsSint16LE(_holmesQuotient);
if (s.isLoading()) {
- _hSavedPos = _player._position;
- _hSavedFacing = _player._sequenceNumber;
+ _hSavedPos = _data[PLAYER]->_position;
+ _hSavedFacing = _data[PLAYER]->_sequenceNumber;
}
}
diff --git a/engines/sherlock/tattoo/tattoo_people.h b/engines/sherlock/tattoo/tattoo_people.h
index e4216d0..455b948 100644
--- a/engines/sherlock/tattoo/tattoo_people.h
+++ b/engines/sherlock/tattoo/tattoo_people.h
@@ -71,9 +71,20 @@ enum TattooSequences {
LISTEN_UPLEFT = 27
};
+class TattooPerson: public Person {
+public:
+ TattooPerson() : Person() {}
+ virtual ~TattooPerson() {}
+
+ /**
+ * This adjusts the sprites position, as well as it's animation sequence:
+ */
+ virtual void adjustSprite();
+};
+
class TattooPeople : public People {
public:
- TattooPeople(SherlockEngine *vm) : People(vm) {}
+ TattooPeople(SherlockEngine *vm);
virtual ~TattooPeople() {}
/**
diff --git a/engines/sherlock/tattoo/tattoo_scene.cpp b/engines/sherlock/tattoo/tattoo_scene.cpp
index fa37f67..20b690f 100644
--- a/engines/sherlock/tattoo/tattoo_scene.cpp
+++ b/engines/sherlock/tattoo/tattoo_scene.cpp
@@ -572,7 +572,7 @@ void TattooScene::updateBackground() {
screen._flushScreen = true;
- for (int idx = 0; idx < MAX_CHARACTERS; ++idx) {
+ for (uint idx = 0; idx < MAX_CHARACTERS; ++idx) {
Person &p = people[idx];
if (p._type != INVALID) {
More information about the Scummvm-git-logs
mailing list