MADS: Implemented lots of Player methods

engines/mads/game.cpp

@@ -179,11 +179,18 @@ void Game::sectionLoop() {
 
 		_vm->_palette->_paletteUsage.load(3, 0xF0, 0xF1, 0xF2);
 		
+		if (!_player._spritesLoaded && _v3) {
+			if (_player.loadSprites(""))
+				_vm->quitGame();
+			_playerSpritesFlag = true;
+		}
+
 		_scene.loadScene(_scene._nextSceneId, _aaName, 0);
 		_vm->_sound->pauseNewCommands();
 
 		if (!_player._spritesLoaded) {
-			_player.loadSprites("");
+			if (_player.loadSprites(""))
+				_vm->quitGame();
 			_playerSpritesFlag = false;
 		}
 

engines/mads/msurface.cpp

@@ -521,4 +521,18 @@ int DepthSurface::getDepth(const Common::Point &pt) {
 	}
 }
 
+int DepthSurface::getDepthHighBit(const Common::Point &pt) {
+	if (_vm->_game->_scene._sceneInfo->_depthStyle == 2) {
+		int bits = (3 - (pt.x % 4)) * 2;
+		byte v = *getBasePtr(pt.x >> 2, pt.y);
+		return (v >> bits) & 2;
+	} else {
+		if (pt.x < 0 || pt.y < 0 || pt.x >= this->w || pt.y >= this->h)
+			return 0;
+
+		return *getBasePtr(pt.x, pt.y) & 0x80;
+	}
+}
+
+
 } // End of namespace MADS

engines/mads/msurface.h

@@ -223,6 +223,10 @@ public:
 	 * Returns the depth at a given position
 	 */
 	int getDepth(const Common::Point &pt);
+
+	/**
+	 */
+	int getDepthHighBit(const Common::Point &pt);
 };
 
 } // End of namespace MADS

engines/mads/nebular/game_nebular.cpp

@@ -35,7 +35,7 @@ namespace MADS {
 namespace Nebular {
 
 GameNebular::GameNebular(MADSEngine *vm): Game(vm) {
-	_surface = new MSurface(MADS_SCREEN_WIDTH, MADS_SCREEN_HEIGHT - MADS_INTERFACE_HEIGHT);
+	_surface = new MSurface(MADS_SCREEN_WIDTH, MADS_SCENE_HEIGHT);
 	_storyMode = STORYMODE_NAUGHTY;
 }
 

engines/mads/player.cpp

@@ -26,21 +26,47 @@
 
 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
+};
+
 Player::Player(MADSEngine *vm): _vm(vm) {
 	_action = nullptr;
 	_direction = 8;
 	_newDirection = 8;
 	_destFacing = 0;
 	_spritesLoaded = false;
-	_spritesStart = _numSprites = 0;
+	_spritesStart = 0;
+	_spritesIdx = 0;
+	_numSprites = 0;
 	_stepEnabled = false;
 	_visible = false;
+	_priorVisible = false;
 	_visible3 = false;
 	_special = 0;
 	_ticksAmount = 0;
 	_priorTimer = 0;
 	_unk3 = _unk4 = 0;
 	_forceRefresh = false;
+	_highSprites = false;
+	_currentDepth = 0;
+	_currentScale = 0;
+	_frameOffset = 0;
+	_frameNum = 0;
+	_yScale = 0;
+	_frameCount = 0;
+	_unk1 = 0;
+	_unk2 = 0;
+	_unk3 = 0;
+	_frameListIndex = 0;
+	_actionIndex = 0;
+	_hypotenuse = 0;
+	
+	Common::fill(&_actionList[0], &_actionList[12], 0);
+	Common::fill(&_actionList2[0], &_actionList2[12], 0);
+	Common::fill(&_spriteSetsPresent[0], &_spriteSetsPresent[PLAYER_SPRITES_FILE_COUNT], false);
 }
 
 void Player::reset() {
@@ -49,7 +75,7 @@ void Player::reset() {
 	_destFacing = 5;
 	_newDirection = _direction;
 	_moving = false;
-	_v844C0 = _v844BE = 0;
+	_newSceneId = _v844BE = 0;
 	_next = 0;
 	_routeCount = 0;
 
@@ -58,8 +84,49 @@ void Player::reset() {
 	_action->_walkFlag = false;
 }
 
-void Player::loadSprites(const Common::String &prefix) {
+bool Player::loadSprites(const Common::String &prefix) {
-	warning("TODO: Player::loadSprites");
+	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::String setName = Common::String::format("*%s_%c.SS",
+				newPrefix.c_str(), suffixList[fileIndex]);
+			if (fileIndex >= 5)
+				_highSprites = true;
+
+			_spriteSetsPresent[fileIndex] = true;
+			int setIndex = _vm->_game->_scene._sprites.addSprites(setName, 4);
+			if (setIndex >= 0) {
+				++_numSprites;
+			}  else if (fileIndex >= 5) {
+				_highSprites = 0;
+				return true;
+			} else {
+				_spriteSetsPresent[fileIndex] = false;
+			}
+
+			if (fileIndex == 0)
+				_spritesStart = setIndex;
+		}
+
+		_spritesLoaded = true;
+		_spritesChanged = false;
+		_highSprites = false;
+		return false;
+	} else {
+		Common::fill(&_spriteSetsPresent[0], &_spriteSetsPresent[PLAYER_SPRITES_FILE_COUNT], false);
+		_highSprites = false;
+		return true;
+	}
 }
 
 void Player::turnToDestFacing() {
@@ -67,30 +134,227 @@ void Player::turnToDestFacing() {
 		_newDirection = _destFacing;
 }
 
+void Player::dirChanged() {
+	int dirIndex = 0, dirIndex2 = 0;
+	int newDir = 0, newDir2 = 0;
+
+	if (_direction != _newDirection) {
+		// Find the index for the given direction in the player direction list
+		int tempDir = _direction;
+		do {
+			++dirIndex;
+			newDir += tempDir;
+			tempDir = _directionListIndexes[tempDir + 10];
+		} while (tempDir != _newDirection);
+	}
+
+
+	if (_direction != _newDirection) {
+		// Find the index for the given direction in the player direction list
+		int tempDir = _direction;
+		do {
+			++dirIndex2;
+			newDir2 += tempDir;
+			tempDir = _directionListIndexes[tempDir + 20];
+		} while (tempDir != _newDirection);
+	}
+
+	int diff = dirIndex - dirIndex2;
+	if (diff == 0)
+		diff = newDir - newDir2;
+
+	_direction = (diff >= 0) ? _directionListIndexes[_direction + 20] : _directionListIndexes[_direction + 10];
+	setupFrame();
+	if ((_direction == _newDirection) && !_moving)
+		updateFrame();
+
+	_priorTimer += 1;
+}
+
 void Player::moveComplete() {
 	reset();
 	_action->_inProgress = false;
 }
 
 void Player::setupFrame() {
+	Scene &scene = _vm->_game->_scene;
+
 	resetActionList();
-	warning("TODO: Player::setupFrame");
+	_frameOffset = 0;
+	_spritesIdx = _directionListIndexes[_direction];
+	if (!_spriteSetsPresent[_spritesIdx]) {
+		// Direction isn't present, so use alternate direction, with entries flipped
+		_spritesIdx -= 4;
+		_frameOffset = 0x8000;
+	}
+
+	SpriteAsset &spriteSet = *scene._sprites[_spritesStart + _spritesIdx];
+	assert(spriteSet._charInfo);
+	_unk1 = MAX(spriteSet._charInfo->_unk1, 100);
+	setTicksAmount();
+
+	_frameCount = spriteSet._charInfo->_totalFrames;
+	if (_frameCount == 0)
+		_frameCount = spriteSet.getCount();
+
+	_yScale = spriteSet._charInfo->_yScale;
+
+	if ((_frameNum <= 0) || (_frameNum > _frameCount))
+		_frameNum = 1;
+	_forceRefresh = true;
 }
 
 void Player::updateFrame() {
-	warning("TODO: Player::updateFrame");
+	Scene &scene = _vm->_game->_scene;
+	SpriteAsset &spriteSet = *scene._sprites[_spritesStart + _spritesIdx];
+	assert(spriteSet._charInfo);
+
+	if (!spriteSet._charInfo->_numEntries) {
+		_frameNum = 1;
+	} else {
+		_frameListIndex = _actionList[_actionIndex];
+
+		if (!_visible) {
+			_unk2 = 0;
+		}
+		else {
+			_unk2 = _actionList2[_actionIndex];
+
+			if (_actionIndex > 0)
+				--_actionIndex;
+		}
+
+		// Set the player frame number
+		int frameIndex = ABS(_frameListIndex);
+		_frameNum = (_frameListIndex <= 0) ? spriteSet._charInfo->_frameList[frameIndex] :
+			spriteSet._charInfo->_frameList2[frameIndex];
+
+		// Set next waiting period in ticks
+		if (frameIndex == 0) {
+			setTicksAmount();
+		} else {
+			_ticksAmount = spriteSet._charInfo->_ticksList[frameIndex];
+		}
+	}
 }
 
 void Player::update() {
-	warning("TODO: Player::update");
+	Scene &scene = _vm->_game->_scene;
+
+	if (_forceRefresh || (_visible != _priorVisible)) {
+		int slotIndex = getSpriteSlot();
+		if (slotIndex >= 0)
+			scene._spriteSlots[slotIndex]._spriteType = ST_EXPIRED;
+
+		int newDepth = 1;
+		int yp = MAX(_playerPos.y, (int16)(MADS_SCENE_HEIGHT - 1));
+		
+		for (int idx = 1; idx < 15; ++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._spriteType = ST_FOREGROUND;
+			slot._seqIndex = PLAYER_SEQ_INDEX;
+			slot._spritesIndex = _spritesStart + _spritesIdx;
+			slot._frameNumber = _frameOffset + _frameNum;
+			slot._position.x = _playerPos.x;
+			slot._position.y = _playerPos.y + (_yScale * 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._spriteType = ST_NONE;
+				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 (_newSceneId) {
+				SpriteAsset *asset = scene._sprites[slot._spritesIndex];
+				MSprite *frame = asset->getFrame(_frameNum - 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 = _newSceneId;
+					_newSceneId = 0;
+					_vm->_game->_v4 = 0;
+				}
+			}
+
+		}
+	}
+
+	_visible3 = _visible;
+	_priorVisible = _visible;
+	_forceRefresh = false;
 }
 
 void Player::resetActionList() {
-	warning("TODO: Player::resetActionList");
+	_actionList[0] = 0;
+	_actionList2[0] = 0;
+	_actionIndex = 0;
+	_unk2 = 0;
+	_unk3 = 0;
 }
 
 void Player::setDest(const Common::Point &pt, int facing) {
-	warning("TODO: Player::setDest");
+	Scene &scene = _vm->_game->_scene;
+
+	resetActionList();
+	setTicksAmount();
+	_moving = true;
+	_destFacing = facing;
+
+	scene._sceneInfo->setRouteNode(scene._sceneInfo->_nodes.size() - 2,
+		_playerPos, scene._depthSurface);
+	scene._sceneInfo->setRouteNode(scene._sceneInfo->_nodes.size() - 1,
+		pt, scene._depthSurface);
+
+	bool v = scene._depthSurface.getDepthHighBit(pt);
+	setupRoute(v);
+	_next = 0;
+
+	if (_routeCount > 0) {
+		Common::Point srcPos = _playerPos;
+		for (int routeCtr = _routeCount - 1; (routeCtr >= 0) && (_next == 0); --routeCtr) {
+			int idx = _routeIndexes[routeCtr];
+			const Common::Point &pt =scene._sceneInfo->_nodes[idx]._walkPos;
+
+			_next = scanPath(scene._depthSurface, srcPos, pt);
+			srcPos = pt;
+		}
+	}
 }
 
 void Player::nextFrame() {
@@ -111,15 +375,364 @@ void Player::nextFrame() {
 }
 
 void Player::move() {
-	warning("TODO: Player::move");
+	Scene &scene = _vm->_game->_scene;
+	bool routeFlag = false;
+
+	if (_moving) {
+		int idx = _routeCount;
+		while (!_newSceneId && (_destPos.x == _playerPos.x) && (_destPos.y == _playerPos.y)) {
+			if (idx != 0) {
+				--idx;
+				SceneNode &node = scene._sceneInfo->_nodes[_routeIndexes[idx]];
+				_destPos = node._walkPos;
+				routeFlag = true;
+			}
+			else if (_v844BE == idx) {
+				// End of walking path
+				_routeCount = 0;
+				_moving = false;
+				turnToDestFacing();
+				routeFlag = true;
+				idx = _routeCount;
+			}
+			else {
+				_newSceneId = _v844BE;
+				_v844BC = true;
+				_v844BE = 0;
+				_stepEnabled = true;
+				routeFlag = false;
+			}
+
+			if (!_moving)
+				break;
+		}
+		_routeCount = idx;
+	}
+
+	if (routeFlag && _moving)
+		startMovement();
+
+	if (_newDirection != _direction)
+		dirChanged();
+	else if (!_moving)
+		updateFrame();
+
+	int var1 = _unk1;
+	if (_unk4 && (_hypotenuse > 0)) {
+		int v1 = -(_currentScale - 100) * (_posDiff.x - 1) / _hypotenuse + _currentScale;
+		var1 = MAX(1, 10000 / (v1 * _currentScale * var1));
+	}
+
+	if (!_moving || (_direction != _newDirection))
+		return;
+
+	Common::Point newPos = _playerPos;
+
+	if (_v8452E < var1) {
+		do {
+			if (_v8452C < _posDiff.x)
+				_v8452C += _posDiff.y;
+			if (_v8452C >= _posDiff.x) {
+				if ((_posChange.y > 0) || (_newSceneId != 0))
+					newPos.y += _yDirection;
+				--_posChange.y;
+				_v8452C -= _posDiff.x;
+			}
+
+			if (_v8452C < _posDiff.x) {
+				if ((_posChange.x > 0) || (_newSceneId != 0))
+					newPos.x += _xDirection;
+				--_posChange.x;
+			}
+
+			if ((_v844BC == 0) && (_newSceneId == 0) && (_v844BE == 0)) {
+				routeFlag = scene._depthSurface.getDepthHighBit(newPos);
+
+				if (_special == 0)
+					_special = scene.getDepthHighBits(newPos);
+			}
+
+			_v8452E += _v84530;
+
+		} while ((_v8452E < var1) && !routeFlag && ((_posChange.x > 0) || (_posChange.y > 0) || (_newSceneId != 0)));
+	}
+
+	_v8452E -= var1;
+
+	if (routeFlag)
+		moveComplete();
+	else {
+		if (!_newSceneId) {
+			// If the move is complete, make sure the position is exactly on the given destination
+			if (_posChange.x == 0)
+				newPos.x = _destPos.x;
+			if (_posChange.y == 0)
+				newPos.y = _destPos.y;
+		}
+
+		_playerPos = newPos;
+	}
 }
 
 void Player::idle() {
-	warning("TODO: Player::idle");
+	Scene &scene = _vm->_game->_scene;
+
+	if (_direction != _newDirection) {
+		// The direction has changed, so reset for new direction
+		dirChanged();
+		return;
+	}
+
+	SpriteAsset &spriteSet = *scene._sprites[_spritesStart + _spritesIdx];
+	assert(spriteSet._charInfo);
+	if (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 {
+		_frameNum += direction;
+		_forceRefresh = true;
+
+		if (spriteSet._charInfo->_frameList2[frameIndex] < _frameNum) {
+			_unk3 = _unk2;
+			updateFrame();
+		}
+		if (spriteSet._charInfo->_frameList[frameIndex] < _frameNum) {
+			_unk3 = _unk2;
+			updateFrame();
+		}
+	}
 }
 
 void Player::postUpdate() {
-	warning("TODO: Player::postUpdate");
+	if (_moving) {
+		if (++_frameNum > _frameCount)
+			_frameNum = 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]._spriteType >= ST_NONE)
+			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::setTicksAmount() {
+	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::setupRoute(bool bitFlag) {
+	Scene &scene = _vm->_game->_scene;
+
+	// Reset the flag set of nodes in use
+	SceneNodeList &nodes = scene._sceneInfo->_nodes;
+	for (uint i = 0; i < nodes.size(); ++i)
+		nodes[i]._active = false;
+
+	// Start constructing route node list
+	_routeLength = 0x3FFF;
+	_routeCount = 0;
+
+	setupRouteNode(_tempRoute, nodes.size() - 1, bitFlag ? 0xC000 : 0x8000, 0);
+}
+
+void Player::setupRouteNode(int *routeIndexP, int nodeIndex, int flags, int routeLength) {
+	Scene &scene = _vm->_game->_scene;
+	SceneNodeList &nodes = scene._sceneInfo->_nodes;
+	SceneNode &currentNode = nodes[nodeIndex];
+	currentNode._active = true;
+
+	*routeIndexP++ = nodeIndex;
+
+	int subIndex = nodes.size() - 2;
+	int indexVal = nodes[nodeIndex]._indexes[subIndex];
+	if (indexVal & flags) {
+		routeLength += indexVal & 0x3FFF;
+		if (routeLength < _routeLength) {
+			// Found a new shorter route to destination, so set up the route with the found one
+			Common::copy(_tempRoute, routeIndexP, _routeIndexes);
+			_routeCount = routeIndexP - _tempRoute;
+			_routeLength = indexVal & 0x3FFF;
+		}
+	} else {
+		for (int idx = nodes.size() - 2; idx > 0; --idx) {
+			int nodePos = idx - 1;
+			if (!nodes[nodePos]._active && ((currentNode._indexes[nodePos] & flags) != 0))
+				setupRouteNode(routeIndexP, nodePos, 0x8000, indexVal & 0x3fff);
+		}
+	}
+
+	currentNode._active = false;
+}
+
+int Player::scanPath(MSurface &depthSurface, const Common::Point &srcPos, const Common::Point &destPos) {
+	Scene &scene = _vm->_game->_scene;
+	
+	// For compressed depth surfaces, always return 0
+	if (scene._sceneInfo->_depthStyle != 2)
+		return 0;
+
+	int yDiff = destPos.y - srcPos.y;
+	int yAmount = MADS_SCREEN_WIDTH;
+
+	if (yDiff < 0) {
+		yDiff = -yDiff;
+		yAmount = -yAmount;
+	}
+
+	int xDiff = destPos.x - srcPos.y;
+	int xDirection = 1;
+	int xAmount = 0;
+	if (xDiff < 0) {
+		xDiff = -xDiff;
+		xDirection = -xDirection;
+		xAmount = MIN(yDiff, xDiff);
+	}
+
+	++xDiff;
+	++yDiff;
+
+	const byte *srcP = depthSurface.getBasePtr(srcPos.x, srcPos.y);
+	int index = xAmount;
+
+	// Outer horizontal movement loop
+	for (int yIndex = 0; yIndex < yDiff; ++yIndex) {
+		index += yDiff;
+		int v = (*srcP & 0x7F) >> 4;
+		if (v)
+			return v;
+
+		// Inner loop for handling vertical movement
+		while (index >= xDiff) {
+			index -= xDiff;
+
+			v = (*srcP & 0x7F) >> 4;
+			if (v)
+				return v;
+
+			srcP += yAmount;
+		}
+
+		srcP += xDirection;
+	}
+
+	return 0;
+}
+
+void Player::startMovement() {
+	int xDiff = _destPos.x - _playerPos.x;
+	int yDiff = _destPos.y - _playerPos.y;
+	int srcScale = getScale(_playerPos.y);
+	int destScale = getScale(_destPos.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 = (_unk4 ? 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:
+		_newDirection = (_yDirection <= 0) ? 8 : 2;
+		break;
+	case 2: {
+				_newDirection = ((_yDirection <= 0) ? 9 : 3) - ((_xDirection <= 0) ? 2 : 0);
+				break;
+	}
+	case 3:
+		_newDirection = (_xDirection <= 0) ? 4 : 6;
+		break;
+	default:
+		break;
+	}
+
+	_hypotenuse = 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);
+	_v84530 = (majorChange == 0) ? 0 : _hypotenuse / majorChange;
+
+	if (_playerPos.x > _destPos.x)
+		_v8452C = MAX(_posChange.x, _posChange.y);
+	else
+		_v8452C = 0;
+
+	_hypotenuse /= 100;
+	_v8452E = -_v84530;
 }
 
 } // End of namespace MADS

engines/mads/player.h

@@ -31,10 +31,32 @@ namespace MADS {
 class MADSEngine;
 class Action;
 
+#define PLAYER_SPRITES_FILE_COUNT 8
+
 class Player {
+private:
+	static const int _directionListIndexes[32];
 private:
 	MADSEngine *_vm;
 	MADSAction *_action;
+	bool _highSprites;
+	bool _spriteSetsPresent[PLAYER_SPRITES_FILE_COUNT];
+	int _currentDepth;
+	int _currentScale;
+	int _frameOffset;
+	int _frameNum;
+	int _yScale;
+	int _frameCount;
+	int _frameListIndex;
+	int _actionIndex;
+	bool _v844BC;
+	int _v8452E;
+	int _v8452C;
+	int _v84530;
+	int _routeLength;
+	int _actionList[12];
+	int _actionList2[12];
+	int _hypotenuse;
 
 	void reset();
 
@@ -43,33 +65,78 @@ private:
 	void move();
 
 	void postUpdate();
+
+	/**
+	 * Get the sprite slot index for the player
+	 */
+	int getSpriteSlot();
+
+	/**
+	 * Get the scale for the player at the given Y position
+	 */
+	int getScale(int yp);
+
+	void setTicksAmount();
+
+	void setupRoute();
+
+	void setupRoute(bool bitFlag);
+
+	void setupRouteNode(int *routeIndexP, int nodeIndex, int flags, int routeLength);
+
+	/**
+	* Scans along an edge connecting two points within the depths/walk surface, and returns the information of the first
+	* pixel high nibble encountered with a non-zero value
+	*/
+	int scanPath(MSurface &depthSurface, const Common::Point &srcPos, const Common::Point &destPos);
+
+	/**
+	* Starts a player moving to a given destination
+	*/
+	void startMovement();
+
+	void dirChanged();
 public:
 	int _direction;
 	int _newDirection;
+	int _xDirection, _yDirection;
 	int _destFacing;
 	bool _spritesLoaded;
 	int _spritesStart;
+	int _spritesIdx;
 	int _numSprites;
 	bool _stepEnabled;
 	bool _spritesChanged;
 	bool _visible;
+	bool _priorVisible;
 	bool _visible3;
 	Common::Point _playerPos;
 	Common::Point _destPos;
+	Common::Point _posChange;
+	Common::Point _posDiff;
 	bool _moving;
-	int _v844C0, _v844BE;
+	int _newSceneId, _v844BE;
 	int _next;
-	int _routeCount;
 	int _special;
 	int _ticksAmount;
 	uint32 _priorTimer;
-	int _unk3, _unk4;
+	int _unk1;
+	int _unk2;
+	int _unk3;
+	bool _unk4;
 	bool _forceRefresh;
 	Common::String _spritesPrefix;
+	int _routeCount;
+	int _routeOffset;
+	int _tempRoute[MAX_ROUTE_NODES];
+	int _routeIndexes[MAX_ROUTE_NODES];
 public:
 	Player(MADSEngine *vm);
 
-	void loadSprites(const Common::String &prefix);
+	/**
+	 * Load sprites for the player
+	 */
+	bool loadSprites(const Common::String &prefix);
 
 	void turnToDestFacing();
 

engines/mads/scene_data.cpp

@@ -394,6 +394,87 @@ void SceneInfo::SpriteInfo::load(Common::SeekableReadStream *f) {
 	_scale = f->readByte();
 }
 
+void SceneInfo::setRouteNode(int nodeIndex, const Common::Point &pt, MSurface &depthSurface) {
+	int flags, hypotenuse;
+
+	_nodes[nodeIndex]._walkPos = pt;
+
+	// Recalculate inter-node lengths
+	for (uint idx = 0; idx < _nodes.size(); ++idx) {
+		int entry;
+		if (idx == (uint)nodeIndex) {
+			entry = 0x3FFF;
+		}
+		else {
+			// Process the node
+			flags = getRouteFlags(pt, _nodes[idx]._walkPos, depthSurface);
+
+			int xDiff = ABS(_nodes[idx]._walkPos.x - pt.x);
+			int yDiff = ABS(_nodes[idx]._walkPos.y - pt.y);
+			hypotenuse = sqrt((double)(xDiff * xDiff + yDiff * yDiff));
+
+			if (hypotenuse >= 0x3FFF)
+				// Shouldn't ever be this large
+				hypotenuse = 0x3FFF;
+
+			entry = hypotenuse | flags;
+			_nodes[idx]._indexes[nodeIndex] = entry;
+			_nodes[nodeIndex]._indexes[idx] = entry;
+		}
+	}
+}
+
+int SceneInfo::getRouteFlags(const Common::Point &src, const Common::Point &dest, 
+		MSurface &depthSurface) {
+	int result = 0x8000;
+	bool flag = false;
+
+	int xDiff = ABS(dest.x - src.x);
+	int yDiff = ABS(dest.y - src.y);
+	int xDirection = dest.x >= src.x ? 1 : -1;
+	int yDirection = dest.y >= src.y ? depthSurface.w : -depthSurface.w;
+	int majorDiff = 0;
+	if (dest.x < src.x)
+		majorDiff = MAX(xDiff, yDiff);
+	++xDiff;
+	++yDiff;
+
+	byte *srcP = depthSurface.getBasePtr(src.x, src.y);
+
+	int totalCtr = majorDiff;
+	for (int xCtr = 0; xCtr < xDiff; ++xCtr, srcP += xDirection) {
+		totalCtr += yDiff;
+
+		if ((*srcP & 0x80) == 0)
+			flag = false;
+		else if (!flag) {
+			flag = true;
+			result -= 0x4000;
+			if (result == 0)
+				break;
+		}
+
+		while (totalCtr >= xDiff) {
+			totalCtr -= xDiff;
+
+			if ((*srcP & 0x80) == 0)
+				flag = false;
+			else if (!flag) {
+				flag = true;
+				result -= 0x4000;
+				if (result == 0)
+					break;
+			}
+
+			srcP += yDirection;
+		}
+		if (result == 0)
+			break;
+	}
+
+	return result;
+}
+
 /*------------------------------------------------------------------------*/
 
 SceneInfo *SceneInfo::init(MADSEngine *vm) {

engines/mads/scene_data.h

@@ -251,6 +251,9 @@ class SceneInfo {
 
 		void load(Common::SeekableReadStream *f);
 	};
+
+
+	int getRouteFlags(const Common::Point &src, const Common::Point &dest, MSurface &depthSurface);
 protected:
 	MADSEngine *_vm;
 
@@ -301,6 +304,11 @@ public:
 	 */
 	void load(int sceneId, int flags, const Common::String &resName, int v3, 
 		MSurface &depthSurface, MSurface &bgSurface);
+
+	/**
+	 * Set up a route node
+	 */
+	void setRouteNode(int nodeIndex, const Common::Point &pt, MSurface &depthSurface);
 };
 
 } // End of namespace MADS

engines/mads/user_interface.cpp

@@ -42,7 +42,7 @@ UserInterface::UserInterface(MADSEngine *vm) : _vm(vm) {
 	_inventoryTopIndex = 0;
 	_objectY = 0;
 
-	byte *pData = _vm->_screen.getBasePtr(0, MADS_SCREEN_HEIGHT - MADS_INTERFACE_HEIGHT);
+	byte *pData = _vm->_screen.getBasePtr(0, MADS_SCENE_HEIGHT);
 	setPixels(pData, MADS_SCREEN_WIDTH, MADS_INTERFACE_HEIGHT);
 }
 
@@ -270,7 +270,7 @@ bool UserInterface::getBounds(ScrCategory category, int v, Common::Rect &bounds)
 }
 
 void UserInterface::moveRect(Common::Rect &bounds) {
-	bounds.translate(0, MADS_SCREEN_HEIGHT - MADS_INTERFACE_HEIGHT);
+	bounds.translate(0, MADS_SCENE_HEIGHT);
 }
 
 } // End of namespace MADS