Initial commit
This commit is contained in:
871
engines/mads/player.cpp
Normal file
871
engines/mads/player.cpp
Normal file
@@ -0,0 +1,871 @@
|
||||
/* ScummVM - Graphic Adventure Engine
|
||||
*
|
||||
* ScummVM is the legal property of its developers, whose names
|
||||
* are too numerous to list here. Please refer to the COPYRIGHT
|
||||
* file distributed with this source distribution.
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "common/scummsys.h"
|
||||
#include "mads/mads.h"
|
||||
#include "mads/player.h"
|
||||
|
||||
namespace MADS {
|
||||
|
||||
#define PLAYER_SEQ_INDEX -2
|
||||
|
||||
const int Player::_directionListIndexes[32] = {
|
||||
0, 7, 4, 3, 6, 0, 2, 5, 0, 1, 9, 4, 1, 2, 7, 9, 3, 8, 9, 6, 7, 2, 3, 6, 1, 7, 9, 4, 7, 8, 0, 0
|
||||
};
|
||||
|
||||
/*------------------------------------------------------------------------*/
|
||||
|
||||
void StopWalkerEntry::synchronize(Common::Serializer &s) {
|
||||
s.syncAsSint16LE(_stack);
|
||||
s.syncAsSint16LE(_trigger);
|
||||
}
|
||||
|
||||
/*------------------------------------------------------------------------*/
|
||||
|
||||
void StopWalkers::synchronize(Common::Serializer &s) {
|
||||
StopWalkerEntry rec;
|
||||
int count = size();
|
||||
s.syncAsUint16LE(count);
|
||||
|
||||
if (s.isLoading()) {
|
||||
clear();
|
||||
for (int idx = 0; idx < count; ++idx) {
|
||||
rec.synchronize(s);
|
||||
push(rec);
|
||||
}
|
||||
} else {
|
||||
for (int idx = 0; idx < count; ++idx)
|
||||
(*this)[idx].synchronize(s);
|
||||
}
|
||||
}
|
||||
|
||||
/*------------------------------------------------------------------------*/
|
||||
|
||||
Player::Player(MADSEngine *vm)
|
||||
: _vm(vm) {
|
||||
_action = nullptr;
|
||||
_facing = FACING_NORTH;
|
||||
_turnToFacing = FACING_NORTH;
|
||||
_targetFacing = FACING_NORTH;
|
||||
_prepareWalkFacing = FACING_NONE;
|
||||
_mirror = false;
|
||||
_spritesLoaded = false;
|
||||
_spritesStart = 0;
|
||||
_spritesIdx = 0;
|
||||
_numSprites = 0;
|
||||
_stepEnabled = false;
|
||||
_visible = false;
|
||||
_priorVisible = false;
|
||||
_needToWalk = false;
|
||||
_readyToWalk = false;
|
||||
_beenVisible = false;
|
||||
_loadsFirst = false;
|
||||
_loadedFirst = false;
|
||||
_walkAnywhere = false;
|
||||
_special = 0;
|
||||
_ticksAmount = 0;
|
||||
_priorTimer = 0;
|
||||
_scalingVelocity = false;
|
||||
_spritesChanged = false;
|
||||
_forceRefresh = false;
|
||||
_highSprites = false;
|
||||
_currentDepth = 0;
|
||||
_currentScale = 0;
|
||||
_frameNumber = 0;
|
||||
_centerOfGravity = 0;
|
||||
_frameCount = 0;
|
||||
_velocity = 0;
|
||||
_upcomingTrigger = 0;
|
||||
_trigger = 0;
|
||||
_frameListIndex = 0;
|
||||
_totalDistance = 0;
|
||||
_distAccum = 0;
|
||||
_pixelAccum = 0;
|
||||
_deltaDistance = 0;
|
||||
_xDirection = 0;
|
||||
_yDirection = 0;
|
||||
_moving = false;
|
||||
_walkOffScreen = 0;
|
||||
_walkOffScreenSceneId = -1;
|
||||
_forcePrefix = false;
|
||||
_commandsAllowed = false;
|
||||
_enableAtTarget = false;
|
||||
|
||||
Common::fill(&_spriteSetsPresent[0], &_spriteSetsPresent[PLAYER_SPRITES_FILE_COUNT], false);
|
||||
|
||||
_walkTrigger = 0;
|
||||
_walkTriggerDest = SEQUENCE_TRIGGER_NONE;
|
||||
_walkTriggerAction._verbId = VERB_NONE;
|
||||
_walkTriggerAction._objectNameId = 0;
|
||||
_walkTriggerAction._indirectObjectId = 0;
|
||||
}
|
||||
|
||||
void Player::cancelWalk() {
|
||||
Scene &scene = _vm->_game->_scene;
|
||||
_action = &scene._action;
|
||||
_targetPos = _playerPos;
|
||||
_targetFacing = FACING_NONE;
|
||||
_turnToFacing = _facing;
|
||||
_moving = false;
|
||||
_walkOffScreen = _walkOffScreenSceneId = 0;
|
||||
scene._rails.resetRoute();
|
||||
_walkAnywhere = false;
|
||||
|
||||
_needToWalk = false;
|
||||
_readyToWalk = false;
|
||||
}
|
||||
|
||||
bool Player::loadSprites(const Common::String &prefix) {
|
||||
Common::String suffixList = "89632741";
|
||||
|
||||
Common::String newPrefix;
|
||||
if (prefix.empty()) {
|
||||
newPrefix = _spritesPrefix;
|
||||
} else {
|
||||
_spritesPrefix = prefix;
|
||||
newPrefix = prefix;
|
||||
}
|
||||
|
||||
_numSprites = 0;
|
||||
if (!_spritesPrefix.empty()) {
|
||||
for (int fileIndex = 0; fileIndex < PLAYER_SPRITES_FILE_COUNT; ++fileIndex) {
|
||||
Common::Path setName(Common::String::format("*%s_%c.SS",
|
||||
newPrefix.c_str(), suffixList[fileIndex]));
|
||||
if (fileIndex >= 5)
|
||||
_highSprites = true;
|
||||
|
||||
_spriteSetsPresent[fileIndex] = true;
|
||||
|
||||
int setIndex = -1;
|
||||
if (Common::File::exists(setName)) {
|
||||
setIndex = _vm->_game->_scene._sprites.addSprites(setName, 4);
|
||||
++_numSprites;
|
||||
} else if (fileIndex < 5) {
|
||||
_highSprites = false;
|
||||
return true;
|
||||
} else {
|
||||
_spriteSetsPresent[fileIndex] = false;
|
||||
}
|
||||
|
||||
if (fileIndex == 0)
|
||||
_spritesStart = setIndex;
|
||||
}
|
||||
|
||||
_spritesLoaded = true;
|
||||
_spritesChanged = false;
|
||||
} else {
|
||||
Common::fill(&_spriteSetsPresent[0], &_spriteSetsPresent[PLAYER_SPRITES_FILE_COUNT], false);
|
||||
_visible = false;
|
||||
}
|
||||
|
||||
_highSprites = false;
|
||||
return false;
|
||||
}
|
||||
|
||||
void Player::setFinalFacing() {
|
||||
if (_targetFacing != FACING_NONE)
|
||||
_turnToFacing = _targetFacing;
|
||||
}
|
||||
|
||||
void Player::changeFacing() {
|
||||
int dirIndex = 0, dirIndex2 = 0;
|
||||
int newDir = 0, newDir2 = 0;
|
||||
|
||||
if (_facing != _turnToFacing) {
|
||||
// Find the index for the given direction in the player direction list
|
||||
int tempDir = _facing;
|
||||
do {
|
||||
++dirIndex;
|
||||
newDir += tempDir;
|
||||
tempDir = _directionListIndexes[tempDir + 10];
|
||||
} while (tempDir != _turnToFacing);
|
||||
}
|
||||
|
||||
|
||||
if (_facing != _turnToFacing) {
|
||||
// Find the index for the given direction in the player direction list
|
||||
int tempDir = _facing;
|
||||
do {
|
||||
++dirIndex2;
|
||||
newDir2 += tempDir;
|
||||
tempDir = _directionListIndexes[tempDir + 20];
|
||||
} while (tempDir != _turnToFacing);
|
||||
}
|
||||
|
||||
int diff = dirIndex - dirIndex2;
|
||||
if (diff == 0)
|
||||
diff = newDir - newDir2;
|
||||
|
||||
_facing = (diff >= 0) ? (Facing)_directionListIndexes[_facing + 20] :
|
||||
(Facing)_directionListIndexes[_facing + 10];
|
||||
selectSeries();
|
||||
|
||||
if ((_facing == _turnToFacing) && !_moving) {
|
||||
updateFrame();
|
||||
activateTrigger();
|
||||
}
|
||||
|
||||
_priorTimer += 1;
|
||||
}
|
||||
|
||||
void Player::cancelCommand() {
|
||||
cancelWalk();
|
||||
_action->_inProgress = false;
|
||||
}
|
||||
|
||||
void Player::selectSeries() {
|
||||
Scene &scene = _vm->_game->_scene;
|
||||
|
||||
clearStopList();
|
||||
_mirror = false;
|
||||
|
||||
_spritesIdx = _directionListIndexes[_facing];
|
||||
if (!_spriteSetsPresent[_spritesIdx]) {
|
||||
// Direction isn't present, so use alternate direction, with entries flipped
|
||||
_spritesIdx -= 4;
|
||||
_mirror = true;
|
||||
}
|
||||
|
||||
// If the user isn't to be present (such as for a cutscene), exit immediately
|
||||
// WORKAROUND: Original didn't do a secondary check for the sprite set being
|
||||
// present, but it's needed to prevent invalid reads during cutscenes
|
||||
if ((_spritesStart + _spritesIdx) < 0 || !_spriteSetsPresent[_spritesIdx])
|
||||
return;
|
||||
|
||||
SpriteAsset &spriteSet = *scene._sprites[_spritesStart + _spritesIdx];
|
||||
assert(spriteSet._charInfo);
|
||||
_velocity = MAX(spriteSet._charInfo->_velocity, 100);
|
||||
setBaseFrameRate();
|
||||
|
||||
_frameCount = spriteSet._charInfo->_totalFrames;
|
||||
if (_frameCount == 0)
|
||||
_frameCount = spriteSet.getCount();
|
||||
|
||||
_centerOfGravity = spriteSet._charInfo->_centerOfGravity;
|
||||
|
||||
if ((_frameNumber <= 0) || (_frameNumber > _frameCount))
|
||||
_frameNumber = 1;
|
||||
|
||||
_forceRefresh = true;
|
||||
}
|
||||
|
||||
void Player::updateFrame() {
|
||||
// WORKAROUND: Prevent character info being referenced when not present
|
||||
int idx = _spritesStart + _spritesIdx;
|
||||
if (idx < 0 || (idx < PLAYER_SPRITES_FILE_COUNT && !_spriteSetsPresent[idx]))
|
||||
return;
|
||||
|
||||
Scene &scene = _vm->_game->_scene;
|
||||
assert(scene._sprites[idx] != nullptr);
|
||||
SpriteAsset &spriteSet = *scene._sprites[idx];
|
||||
|
||||
// WORKAROUND: Certain cutscenes set up player sprites that don't have any
|
||||
// character info. In such cases, simply ignore player updates
|
||||
if (!spriteSet._charInfo)
|
||||
return;
|
||||
|
||||
if (!spriteSet._charInfo->_numEntries) {
|
||||
_frameNumber = 1;
|
||||
} else {
|
||||
_frameListIndex = _stopWalkers.empty() ? 0 : _stopWalkers.top()._stack;
|
||||
|
||||
if (!_visible) {
|
||||
_upcomingTrigger = 0;
|
||||
} else {
|
||||
if (_stopWalkers.empty()) {
|
||||
_upcomingTrigger = 0;
|
||||
} else {
|
||||
_upcomingTrigger = _stopWalkers.pop()._trigger;
|
||||
}
|
||||
}
|
||||
|
||||
// Set the player frame number
|
||||
int listIndex = ABS(_frameListIndex);
|
||||
_frameNumber = (_frameListIndex >= 0) ? spriteSet._charInfo->_startFrames[listIndex] :
|
||||
spriteSet._charInfo->_stopFrames[listIndex];
|
||||
|
||||
// Set next waiting period in ticks
|
||||
if (listIndex == 0) {
|
||||
setBaseFrameRate();
|
||||
} else {
|
||||
_ticksAmount = spriteSet._charInfo->_ticksList[listIndex];
|
||||
}
|
||||
}
|
||||
|
||||
_forceRefresh = true;
|
||||
}
|
||||
|
||||
void Player::activateTrigger() {
|
||||
Game &game = *_vm->_game;
|
||||
MADSAction &action = game._scene._action;
|
||||
|
||||
_commandsAllowed |= _enableAtTarget;
|
||||
_enableAtTarget = false;
|
||||
|
||||
if (_walkTrigger) {
|
||||
game._trigger = _walkTrigger;
|
||||
game._triggerMode = SEQUENCE_TRIGGER_DAEMON;
|
||||
|
||||
if (game._triggerMode != SEQUENCE_TRIGGER_DAEMON) {
|
||||
action._activeAction = _walkTriggerAction;
|
||||
}
|
||||
|
||||
_walkTrigger = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void Player::update() {
|
||||
Scene &scene = _vm->_game->_scene;
|
||||
|
||||
if (_forceRefresh || (_visible != _priorVisible)) {
|
||||
int slotIndex = getSpriteSlot();
|
||||
if (slotIndex >= 0)
|
||||
scene._spriteSlots[slotIndex]._flags = IMG_ERASE;
|
||||
|
||||
int newDepth = 1;
|
||||
int yp = MIN(_playerPos.y, (int16)(MADS_SCENE_HEIGHT - 1));
|
||||
|
||||
for (int idx = 1; idx < DEPTH_BANDS_SIZE; ++idx) {
|
||||
if (scene._sceneInfo->_depthList[newDepth] >= yp)
|
||||
newDepth = idx + 1;
|
||||
}
|
||||
_currentDepth = newDepth;
|
||||
|
||||
// Get the scale
|
||||
int newScale = getScale(_playerPos.y);
|
||||
_currentScale = MIN(newScale, 100);
|
||||
|
||||
if (_visible) {
|
||||
// Player sprite needs to be rendered
|
||||
SpriteSlot slot;
|
||||
slot._flags = IMG_UPDATE;
|
||||
slot._seqIndex = PLAYER_SEQ_INDEX;
|
||||
slot._spritesIndex = _spritesStart + _spritesIdx;
|
||||
slot._frameNumber = _mirror ? -_frameNumber : _frameNumber;
|
||||
slot._position.x = _playerPos.x;
|
||||
slot._position.y = _playerPos.y + (_centerOfGravity * newScale) / 100;
|
||||
slot._depth = newDepth;
|
||||
slot._scale = newScale;
|
||||
|
||||
if (slotIndex >= 0) {
|
||||
// Check if the existing player slot has the same details, and can be re-used
|
||||
SpriteSlot &s2 = scene._spriteSlots[slotIndex];
|
||||
bool equal = (s2._seqIndex == slot._seqIndex)
|
||||
&& (s2._spritesIndex == slot._spritesIndex)
|
||||
&& (s2._frameNumber == slot._frameNumber)
|
||||
&& (s2._position == slot._position)
|
||||
&& (s2._depth == slot._depth)
|
||||
&& (s2._scale == slot._scale);
|
||||
|
||||
if (equal)
|
||||
// Undo the prior expiry of the player sprite
|
||||
s2._flags = IMG_STATIC;
|
||||
else
|
||||
slotIndex = -1;
|
||||
}
|
||||
|
||||
if (slotIndex < 0) {
|
||||
// New slot needed, so allocate one and copy the slot data
|
||||
slotIndex = scene._spriteSlots.add();
|
||||
scene._spriteSlots[slotIndex] = slot;
|
||||
}
|
||||
|
||||
// If changing a scene, check to change the scene when the player
|
||||
// has moved off-screen
|
||||
if (_walkOffScreen) {
|
||||
SpriteAsset *asset = scene._sprites[slot._spritesIndex];
|
||||
MSprite *frame = asset->getFrame(_frameNumber - 1);
|
||||
int xScale = frame->w * newScale / 200;
|
||||
int yScale = frame->h * newScale / 100;
|
||||
int playerX = slot._position.x;
|
||||
int playerY = slot._position.y;
|
||||
|
||||
if ((playerX + xScale) < 0 || (playerX + xScale) >= MADS_SCREEN_WIDTH ||
|
||||
playerY < 0 || (playerY + yScale) >= MADS_SCENE_HEIGHT) {
|
||||
scene._nextSceneId = _walkOffScreen;
|
||||
_walkOffScreen = 0;
|
||||
_walkAnywhere = false;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
_beenVisible |= _visible;
|
||||
_priorVisible = _visible;
|
||||
_forceRefresh = false;
|
||||
}
|
||||
|
||||
void Player::clearStopList() {
|
||||
_stopWalkers.clear();
|
||||
_upcomingTrigger = 0;
|
||||
_trigger = 0;
|
||||
}
|
||||
|
||||
void Player::startWalking(const Common::Point &pt, Facing facing) {
|
||||
Scene &scene = _vm->_game->_scene;
|
||||
|
||||
clearStopList();
|
||||
setBaseFrameRate();
|
||||
_moving = true;
|
||||
_targetFacing = facing;
|
||||
|
||||
bool v = scene._depthSurface.getDepthHighBit(pt);
|
||||
|
||||
scene._rails.setupRoute(v, _playerPos, pt);
|
||||
}
|
||||
|
||||
void Player::walk(const Common::Point &pos, Facing facing) {
|
||||
cancelWalk();
|
||||
_needToWalk = true;
|
||||
_readyToWalk = true;
|
||||
_prepareWalkPos = pos;
|
||||
_prepareWalkFacing = facing;
|
||||
}
|
||||
|
||||
void Player::nextFrame() {
|
||||
Scene &scene = _vm->_game->_scene;
|
||||
|
||||
uint32 newTime = _priorTimer + _ticksAmount;
|
||||
if (scene._frameStartTime >= newTime) {
|
||||
_priorTimer = scene._frameStartTime;
|
||||
if (_moving) {
|
||||
move();
|
||||
} else {
|
||||
idle();
|
||||
}
|
||||
|
||||
setFrame();
|
||||
update();
|
||||
}
|
||||
}
|
||||
|
||||
void Player::move() {
|
||||
Scene &scene = _vm->_game->_scene;
|
||||
Rails &rails = scene._rails;
|
||||
bool newFacing = false;
|
||||
|
||||
if (_moving) {
|
||||
while (!_walkOffScreen && _playerPos == _targetPos) {
|
||||
bool isRouteEmpty = rails.empty();
|
||||
if (!isRouteEmpty) {
|
||||
const WalkNode &node = rails.popNode();
|
||||
|
||||
_targetPos = node._walkPos;
|
||||
newFacing = true;
|
||||
} else if (!_walkOffScreenSceneId) {
|
||||
// End of walking path
|
||||
rails.resetRoute();
|
||||
_moving = false;
|
||||
setFinalFacing();
|
||||
newFacing = true;
|
||||
} else {
|
||||
_walkOffScreen = _walkOffScreenSceneId;
|
||||
_walkAnywhere = true;
|
||||
_walkOffScreenSceneId = 0;
|
||||
_stepEnabled = false;
|
||||
newFacing = false;
|
||||
}
|
||||
|
||||
if (!_moving)
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (newFacing && _moving)
|
||||
startMovement();
|
||||
|
||||
if (_turnToFacing != _facing) {
|
||||
changeFacing();
|
||||
} else if (!_moving) {
|
||||
updateFrame();
|
||||
activateTrigger();
|
||||
}
|
||||
|
||||
int velocity = _velocity;
|
||||
if (_scalingVelocity && (_totalDistance > 0)) {
|
||||
int angleRange = 100 - _currentScale;
|
||||
int angleScale = angleRange * (_posDiff.x - 1) / _totalDistance + _currentScale;
|
||||
velocity = MAX(1L, (angleScale * _currentScale * velocity) / 10000L);
|
||||
}
|
||||
|
||||
if (!_moving || (_facing != _turnToFacing))
|
||||
return;
|
||||
|
||||
Common::Point newPos = _playerPos;
|
||||
newFacing = false;
|
||||
_special = 0;
|
||||
|
||||
if (_distAccum < velocity) {
|
||||
do {
|
||||
if (_pixelAccum < _posDiff.x)
|
||||
_pixelAccum += _posDiff.y;
|
||||
if (_pixelAccum >= _posDiff.x) {
|
||||
if ((_posChange.y > 0) || _walkOffScreen)
|
||||
newPos.y += _yDirection;
|
||||
--_posChange.y;
|
||||
_pixelAccum -= _posDiff.x;
|
||||
}
|
||||
|
||||
if (_pixelAccum < _posDiff.x) {
|
||||
if ((_posChange.x > 0) || _walkOffScreen)
|
||||
newPos.x += _xDirection;
|
||||
--_posChange.x;
|
||||
}
|
||||
|
||||
if (!_walkAnywhere && !_walkOffScreen && (_walkOffScreenSceneId == 0)) {
|
||||
newFacing = scene._depthSurface.getDepthHighBit(newPos);
|
||||
|
||||
if (_special == 0)
|
||||
_special = scene.getDepthHighBits(newPos);
|
||||
}
|
||||
|
||||
_distAccum += _deltaDistance;
|
||||
|
||||
} while ((_distAccum < velocity) && !newFacing && ((_posChange.x > 0) || (_posChange.y > 0) || (_walkOffScreen != 0)));
|
||||
}
|
||||
|
||||
_distAccum -= velocity;
|
||||
|
||||
if (newFacing) {
|
||||
cancelCommand();
|
||||
} else {
|
||||
if (!_walkOffScreen) {
|
||||
// If the move is complete, make sure the position is exactly on the given destination
|
||||
if (_posChange.x == 0)
|
||||
newPos.x = _targetPos.x;
|
||||
if (_posChange.y == 0)
|
||||
newPos.y = _targetPos.y;
|
||||
}
|
||||
|
||||
_playerPos = newPos;
|
||||
}
|
||||
}
|
||||
|
||||
void Player::idle() {
|
||||
Scene &scene = _vm->_game->_scene;
|
||||
|
||||
if (_facing != _turnToFacing) {
|
||||
// The direction has changed, so reset for new direction
|
||||
changeFacing();
|
||||
return;
|
||||
}
|
||||
|
||||
int idx = _spritesStart + _spritesIdx;
|
||||
if (idx < 0 || (idx < PLAYER_SPRITES_FILE_COUNT && !_spriteSetsPresent[idx]))
|
||||
return;
|
||||
|
||||
SpriteAsset &spriteSet = *scene._sprites[idx];
|
||||
if (spriteSet._charInfo == nullptr || spriteSet._charInfo->_numEntries == 0)
|
||||
// No entries, so exit immediately
|
||||
return;
|
||||
|
||||
int frameIndex = ABS(_frameListIndex);
|
||||
int direction = (_frameListIndex < 0) ? -1 : 1;
|
||||
|
||||
if (frameIndex >= spriteSet._charInfo->_numEntries) {
|
||||
// Reset back to the start of the list
|
||||
_frameListIndex = 0;
|
||||
} else {
|
||||
_frameNumber += direction;
|
||||
_forceRefresh = true;
|
||||
|
||||
if (_frameNumber > spriteSet._charInfo->_stopFrames[frameIndex]) {
|
||||
_trigger = _upcomingTrigger;
|
||||
updateFrame();
|
||||
}
|
||||
if (_frameNumber < spriteSet._charInfo->_startFrames[frameIndex]) {
|
||||
_trigger = _upcomingTrigger;
|
||||
updateFrame();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Player::setFrame() {
|
||||
if (_moving) {
|
||||
if (++_frameNumber > _frameCount)
|
||||
_frameNumber = 1;
|
||||
_forceRefresh = true;
|
||||
} else {
|
||||
if (!_forceRefresh)
|
||||
idle();
|
||||
}
|
||||
}
|
||||
|
||||
int Player::getSpriteSlot() {
|
||||
SpriteSlots &spriteSlots = _vm->_game->_scene._spriteSlots;
|
||||
|
||||
for (uint idx = 0; idx < spriteSlots.size(); ++idx) {
|
||||
if (spriteSlots[idx]._seqIndex == PLAYER_SEQ_INDEX &&
|
||||
spriteSlots[idx]._flags >= IMG_STATIC)
|
||||
return idx;
|
||||
}
|
||||
|
||||
return - 1;
|
||||
}
|
||||
|
||||
int Player::getScale(int yp) {
|
||||
Scene &scene = _vm->_game->_scene;
|
||||
|
||||
int scale = (scene._bandsRange == 0) ? scene._sceneInfo->_maxScale :
|
||||
(yp - scene._sceneInfo->_yBandsStart) * scene._scaleRange / scene._bandsRange +
|
||||
scene._sceneInfo->_minScale;
|
||||
|
||||
return MIN(scale, 100);
|
||||
}
|
||||
|
||||
void Player::setBaseFrameRate() {
|
||||
Scene &scene = _vm->_game->_scene;
|
||||
|
||||
SpriteAsset &spriteSet = *scene._sprites[_spritesStart + _spritesIdx];
|
||||
assert(spriteSet._charInfo);
|
||||
|
||||
_ticksAmount = spriteSet._charInfo->_ticksAmount;
|
||||
if (_ticksAmount == 0)
|
||||
_ticksAmount = 6;
|
||||
}
|
||||
|
||||
void Player::startMovement() {
|
||||
int xDiff = _targetPos.x - _playerPos.x;
|
||||
int yDiff = _targetPos.y - _playerPos.y;
|
||||
int srcScale = getScale(_playerPos.y);
|
||||
int destScale = getScale(_targetPos.y);
|
||||
|
||||
// Sets the X direction
|
||||
if (xDiff > 0)
|
||||
_xDirection = 1;
|
||||
else if (xDiff < 0)
|
||||
_xDirection = -1;
|
||||
else
|
||||
_xDirection = 0;
|
||||
|
||||
// Sets the Y direction
|
||||
if (yDiff > 0)
|
||||
_yDirection = 1;
|
||||
else if (yDiff < 0)
|
||||
_yDirection = -1;
|
||||
else
|
||||
_yDirection = 0;
|
||||
|
||||
xDiff = ABS(xDiff);
|
||||
yDiff = ABS(yDiff);
|
||||
int scaleDiff = ABS(srcScale - destScale);
|
||||
|
||||
int xAmt100 = xDiff * 100;
|
||||
int yAmt100 = yDiff * 100;
|
||||
int xAmt33 = xDiff * 33;
|
||||
|
||||
int scaleAmount = (_scalingVelocity ? scaleDiff * 3 : 0) + 100 * yDiff / 100;
|
||||
int scaleAmount100 = scaleAmount * 100;
|
||||
|
||||
// Figure out direction that will need to be moved in
|
||||
int majorDir;
|
||||
if (xDiff == 0) {
|
||||
majorDir = 1;
|
||||
} else if (yDiff == 0) {
|
||||
majorDir = 3;
|
||||
} else {
|
||||
if ((scaleAmount < xDiff) && ((xAmt33 / scaleAmount) >= 141))
|
||||
majorDir = 3;
|
||||
else if (yDiff <= xDiff)
|
||||
majorDir = 2;
|
||||
else if ((scaleAmount100 / xDiff) >= 141)
|
||||
majorDir = 1;
|
||||
else
|
||||
majorDir = 2;
|
||||
}
|
||||
|
||||
switch (majorDir) {
|
||||
case 1:
|
||||
_turnToFacing = (_yDirection <= 0) ? FACING_NORTH : FACING_SOUTH;
|
||||
break;
|
||||
case 2: {
|
||||
_turnToFacing = (Facing)(((_yDirection <= 0) ? 9 : 3) - ((_xDirection <= 0) ? 2 : 0));
|
||||
break;
|
||||
}
|
||||
case 3:
|
||||
_turnToFacing = (_xDirection <= 0) ? FACING_WEST : FACING_EAST;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
_totalDistance = (int)sqrt((double)(xAmt100 * xAmt100 + yAmt100 * yAmt100));
|
||||
_posDiff.x = xDiff + 1;
|
||||
_posDiff.y = yDiff + 1;
|
||||
_posChange.x = xDiff;
|
||||
_posChange.y = yDiff;
|
||||
|
||||
int majorChange = MAX(xDiff, yDiff);
|
||||
_deltaDistance = (majorChange == 0) ? 0 : _totalDistance / majorChange;
|
||||
|
||||
if (_playerPos.x > _targetPos.x)
|
||||
_pixelAccum = MIN(_posChange.x, _posChange.y);
|
||||
else
|
||||
_pixelAccum = 0;
|
||||
|
||||
_totalDistance /= 100;
|
||||
_distAccum = -_deltaDistance;
|
||||
}
|
||||
|
||||
void Player::newWalk() {
|
||||
if (_needToWalk && _readyToWalk) {
|
||||
startWalking(_prepareWalkPos, _prepareWalkFacing);
|
||||
_needToWalk = false;
|
||||
}
|
||||
}
|
||||
|
||||
void Player::addWalker(int walker, int trigger) {
|
||||
Scene &scene = _vm->_game->_scene;
|
||||
SpriteAsset &spriteSet = *scene._sprites[_spritesStart + _spritesIdx];
|
||||
assert(spriteSet._charInfo);
|
||||
|
||||
if (walker < spriteSet._charInfo->_numEntries)
|
||||
_stopWalkers.push(StopWalkerEntry(walker, trigger));
|
||||
}
|
||||
|
||||
/**
|
||||
* Releases any sprites used by the player
|
||||
*/
|
||||
void Player::releasePlayerSprites() {
|
||||
Scene &scene = _vm->_game->_scene;
|
||||
|
||||
if (_spritesLoaded && _numSprites > 0) {
|
||||
int spriteEnd = _spritesStart + _numSprites - 1;
|
||||
do {
|
||||
scene._sprites.remove(spriteEnd);
|
||||
} while (--spriteEnd >= _spritesStart);
|
||||
}
|
||||
|
||||
_numSprites = 0;
|
||||
_spritesLoaded = false;
|
||||
_spritesChanged = true;
|
||||
|
||||
if (scene._sprites.size() > 0) {
|
||||
warning("Player::releasePlayerSprites(): leftover sprites remain, clearing list");
|
||||
scene._sprites.clear();
|
||||
}
|
||||
}
|
||||
|
||||
void Player::synchronize(Common::Serializer &s) {
|
||||
s.syncAsByte(_moving);
|
||||
s.syncAsSint16LE(_playerPos.x);
|
||||
s.syncAsSint16LE(_playerPos.y);
|
||||
s.syncAsSint16LE(_targetPos.x);
|
||||
s.syncAsSint16LE(_targetPos.y);
|
||||
s.syncAsSint16LE(_xDirection);
|
||||
s.syncAsSint16LE(_yDirection);
|
||||
s.syncAsSint16LE(_posDiff.x);
|
||||
s.syncAsSint16LE(_posDiff.y);
|
||||
s.syncAsSint16LE(_posChange.x);
|
||||
s.syncAsSint16LE(_posChange.y);
|
||||
s.syncAsUint16LE(_targetFacing);
|
||||
s.syncAsSint16LE(_special);
|
||||
s.syncAsByte(_forceRefresh);
|
||||
s.syncAsSint16LE(_ticksAmount);
|
||||
s.syncAsByte(_walkAnywhere);
|
||||
s.syncAsUint16LE(_walkOffScreenSceneId);
|
||||
s.syncAsByte(_walkOffScreen);
|
||||
s.syncAsByte(_needToWalk);
|
||||
s.syncAsByte(_readyToWalk);
|
||||
s.syncAsUint16LE(_prepareWalkFacing);
|
||||
s.syncAsSint16LE(_prepareWalkPos.x);
|
||||
s.syncAsSint16LE(_prepareWalkPos.y);
|
||||
s.syncAsByte(_stepEnabled);
|
||||
s.syncAsByte(_visible);
|
||||
s.syncAsByte(_priorVisible);
|
||||
|
||||
for (int i = 0; i < 8; ++i)
|
||||
s.syncAsByte(_spriteSetsPresent[i]);
|
||||
|
||||
s.syncAsByte(_facing);
|
||||
s.syncAsByte(_turnToFacing);
|
||||
s.syncAsSint16LE(_spritesIdx);
|
||||
s.syncAsSint16LE(_frameNumber);
|
||||
s.syncAsSint16LE(_currentDepth);
|
||||
s.syncAsSint16LE(_currentScale);
|
||||
s.syncAsSint16LE(_frameListIndex);
|
||||
_stopWalkers.synchronize(s);
|
||||
_walkTriggerAction.synchronize(s);
|
||||
s.syncAsUint16LE(_walkTriggerDest);
|
||||
|
||||
s.syncAsSint16LE(_upcomingTrigger);
|
||||
s.syncAsSint16LE(_trigger);
|
||||
s.syncAsSint16LE(_scalingVelocity);
|
||||
s.syncAsSint16LE(_pixelAccum);
|
||||
s.syncAsSint16LE(_distAccum);
|
||||
s.syncAsSint16LE(_deltaDistance);
|
||||
s.syncAsSint16LE(_totalDistance);
|
||||
s.syncAsSint16LE(_velocity);
|
||||
s.syncAsUint16LE(_frameCount);
|
||||
s.syncString(_spritesPrefix);
|
||||
s.syncAsUint32LE(_priorTimer);
|
||||
s.syncAsByte(_loadsFirst);
|
||||
s.syncAsByte(_loadedFirst);
|
||||
s.syncAsByte(_spritesLoaded);
|
||||
s.syncAsByte(_spritesChanged);
|
||||
s.syncAsByte(_beenVisible);
|
||||
s.syncAsSint16LE(_centerOfGravity);
|
||||
s.syncAsByte(_mirror);
|
||||
}
|
||||
|
||||
void Player::removePlayerSprites() {
|
||||
Scene &scene = _vm->_game->_scene;
|
||||
int heroSpriteId = _spritesStart;
|
||||
for (int i = 0; i < 8; i++) {
|
||||
if (_spriteSetsPresent[i]) {
|
||||
delete scene._sprites[heroSpriteId];
|
||||
scene._sprites[heroSpriteId] = nullptr;
|
||||
_spriteSetsPresent[i] = false;
|
||||
++heroSpriteId;
|
||||
}
|
||||
}
|
||||
|
||||
scene._spriteSlots.clear();
|
||||
scene._spriteSlots.fullRefresh();
|
||||
_visible = false;
|
||||
}
|
||||
|
||||
void Player::firstWalk(Common::Point fromPos, Facing fromFacing, Common::Point destPos, Facing destFacing, bool enableFl) {
|
||||
_playerPos = fromPos;
|
||||
_facing = fromFacing;
|
||||
|
||||
walk(destPos, destFacing);
|
||||
_walkAnywhere = true;
|
||||
|
||||
_commandsAllowed = false;
|
||||
_enableAtTarget = enableFl;
|
||||
}
|
||||
|
||||
void Player::setWalkTrigger(int val) {
|
||||
Scene &scene = _vm->_game->_scene;
|
||||
_walkTrigger = val;
|
||||
_walkTriggerDest = _vm->_game->_triggerSetupMode;
|
||||
_walkTriggerAction = scene._action._activeAction;
|
||||
}
|
||||
|
||||
void Player::resetFacing(Facing facing) {
|
||||
_facing = facing;
|
||||
_turnToFacing = facing;
|
||||
selectSeries();
|
||||
}
|
||||
|
||||
} // End of namespace MADS
|
||||
Reference in New Issue
Block a user