/* 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/debug.h"
#include "dragons/dragons.h"
#include "dragons/dragonini.h"
#include "dragons/actorresource.h"
#include "dragons/actor.h"
#include "dragons/scene.h"
#include "dragons/screen.h"

namespace Dragons {

static const int kPathPointsCount = 32;

ActorManager::ActorManager(ActorResourceLoader *actorResourceLoader) : _actorResourceLoader(actorResourceLoader) {
	for (uint16 i = 0; i < DRAGONS_ENGINE_NUM_ACTORS; i++) {
		_actors.push_back(Actor(i));
	}
	resetDisplayOrder();
}


Actor *ActorManager::loadActor(uint32 resourceId, uint32 sequenceId, int16 x, int16 y, uint16 priorityLayer) {
	Actor *actor = loadActor(resourceId, sequenceId, x, y);
	if (actor) {
		actor->_priorityLayer = priorityLayer;
	}
	return actor;
}

Actor *ActorManager::loadActor(uint32 resourceId, uint32 sequenceId, int16 x, int16 y) {
	debug(1, "Load actor: resourceId: %d, SequenceId: %d, position: (%d,%d)", resourceId, sequenceId, x, y);
	ActorResource *resource = _actorResourceLoader->load(resourceId);
	//Actor *actor = new Actor(_actorResourceLoader->load(resourceId), x, y, sequenceId);
	Actor *actor = findFreeActor((int16)resourceId);
	if (actor) {
		actor->init(resource, x, y, sequenceId);
	} else {
		//TODO run find by resource and remove from mem logic here. @0x800358c8
		debug("Unable to find free actor slot!!");
		delete resource;
	}
	resetDisplayOrder();
	return actor;
}

Actor *ActorManager::findFreeActor(int16 resourceId) {
	int i = 0;
	for (ActorsIterator it = _actors.begin(); it != _actors.end() && i < 23; ++it, i++) {
		Actor *actor = it;
		if (!(actor->_flags & ACTOR_FLAG_40)) {
			actor->_resourceID = resourceId;
			actor->_walkSpeed = 0x100000;
			return actor;
		}
	}
	return nullptr;
}

Actor *ActorManager::getActor(uint16 actorId) {
	assert(actorId < DRAGONS_ENGINE_NUM_ACTORS);
	return &_actors[actorId];
}

void ActorManager::clearActorFlags(uint16 startingActorId) {
	assert(startingActorId < DRAGONS_ENGINE_NUM_ACTORS);
	for (uint16 i = startingActorId; i < DRAGONS_ENGINE_NUM_ACTORS; i++) {
		_actors[i]._flags = 0;
	}
}

Actor *ActorManager::loadActor(uint32 resourceId, uint16 actorId) { //TODO should we rename this. loadActorResource or updateActorResource
	Actor *actor = getActor(actorId);
	actor->_actorResource = _actorResourceLoader->load(resourceId);
	return actor;
}

ActorResource *ActorManager::getActorResource(uint32 resourceId) {
	return _actorResourceLoader->load(resourceId);
}

void ActorManager::updateActorDisplayOrder() {
	bool shouldContinue = true;

	while (shouldContinue) {
		shouldContinue = false;
		for (int i = 0; i < DRAGONS_ENGINE_NUM_ACTORS - 1; i++) {
			Actor *curActor = getActor(_displayOrder[i]);
			Actor *nextActor = getActor(_displayOrder[i + 1]);
			int16 curY = curActor->_y_pos > 0 ? curActor->_y_pos : 0;
			int16 nextY = nextActor->_y_pos > 0 ? nextActor->_y_pos : 0;
			if (nextActor->_priorityLayer * 0x1000000 + nextY * 0x100 + nextActor->_actorID <
					curActor->_priorityLayer * 0x1000000 + curY * 0x100 + curActor->_actorID) {
				_displayOrder[i] = nextActor->_actorID;
				_displayOrder[i + 1] = curActor->_actorID;
				shouldContinue = true;
			}
		}
	}
}

void ActorManager::resetDisplayOrder() {
	for (uint16 i = 0; i < DRAGONS_ENGINE_NUM_ACTORS; i++) {
		Actor *actor = getActor(i);
		_displayOrder[i] = i;
		if (!actor->isFlagSet(ACTOR_FLAG_40)) {
			actor->_priorityLayer = 0;
		}
	}
}

Actor *ActorManager::getActorByDisplayOrder(uint16 position) {
	return getActor(_displayOrder[position]);
}

Actor::Actor(uint16 id) : _actorID(id) {
	_actorResource = nullptr;
	_resourceID = -1;
	_seqCodeIp = nullptr;
	_priorityLayer = 3;
	_x_pos = 160;
	_y_pos = 110;
	_walkDestX = 0;
	_walkDestY = 0;
	_walkSpeed = 0;
	_flags = 0;
	_frame_flags = 0;
	_frame = nullptr;
	_surface = nullptr;

	_actorFileDictionaryIndex = 0;
	_sequenceTimerMaxValue = 0;
	_scale = 0x100;
	_sequenceTimer = 0;
	_sequenceID = 0;
	_direction = 0;
	_xShl16 = 0;
	_yShl16 = 0;
	_walkSlopeX = 0;
	_walkSlopeY = 0;
	_walkPointsIndex = 0;
	_finalWalkDestX = 0;
	_finalWalkDestY = 0;
	_field_7a = 0;
}

void Actor::init(ActorResource *resource, int16 x, int16 y, uint32 sequenceID) {
	debug(3, "actor %d Init", _actorID);
	delete _actorResource;
	_actorResource = resource;
	_x_pos = x;
	_y_pos = y;
	_sequenceTimer = 0;
	_walkDestX = x;
	_walkDestY = y;
	_scale = DRAGONS_ENGINE_SPRITE_100_PERCENT_SCALE;
	_direction = 0;
	_flags = (ACTOR_FLAG_40 | Dragons::ACTOR_FLAG_4);
	_frame_flags = 4;
	//TODO sub_80017010();
	freeFrame();

	updateSequence((uint16)sequenceID);
}

void Actor::updateSequence(uint16 newSequenceID) {
	_sequenceID = newSequenceID;
	_flags &= 0xfbf1;
	_flags |= ACTOR_FLAG_1;
}

void Actor::resetSequenceIP() {
	_seqCodeIp = _actorResource->getSequenceData(_sequenceID);
}

void Actor::loadFrame(uint16 frameOffset) {
	freeFrame();

	_frame = _actorResource->loadFrameHeader(frameOffset);

	if (_frame->flags & 0x800) {
		_frame_flags |= ACTOR_FRAME_FLAG_2;
	} else {
		_frame_flags &= ~ACTOR_FRAME_FLAG_2;
	}

	_surface = _actorResource->loadFrame(*_frame, nullptr); // TODO paletteId == 0xf1 ? getEngine()->getBackgroundPalette() : nullptr);

	debug(5, "ActorId: %d load frame header: (%d,%d)", _actorID, _frame->width, _frame->height);

	_flags |= ACTOR_FLAG_8; //TODO check if this is the right spot. engine sets it at 0x800185b0

}

void Actor::freeFrame() {
	delete _frame;
	delete _surface;
	_frame = nullptr;
	_surface = nullptr;
}

byte *Actor::getSeqIpAtOffset(uint32 offset) {
	return _actorResource->getSequenceDataAtOffset(offset);
}

void Actor::reset_maybe() {
	_flags = 0;
	//TODO actor_find_by_resourceId_and_remove_resource_from_mem_maybe(resourceID);
	freeFrame();
	delete _actorResource;
	_actorResource = nullptr;
}

uint32 calcDistance(int32 x1, int32 y1, int32 x2, int32 y2) {
	return ABS(x2 - x1) * ABS(x2 - x1) + ABS(y2 - y1) * ABS(y2 - y1);
}

bool Actor::startWalk(int16 destX, int16 destY, uint16 flags) {
	static const int kCosTbl[40] = {
		// cos table
		256, 251, 236, 212, 181, 142, 97, 49,
		0, -49, -97, -142, -181, -212, -236, -251,
		-255, -251, -236, -212, -181, -142, -97, -49,
		0, 49, 97, 142, 181, 212, 236, 251,
		11, 0, 0, 0, 0, 0, 0, 0
	};
	static const int kAdjustXTbl[8] = {
		1, -1, 0, 0, 1, -1, 1, -1
	};
	static const int kAdjustYTbl[8] = {
		0, 0, 1, -1, 1, 1, -1, -1
	};

	debug(1, "startWalk(%d, %d, %d)", _actorID, destX, destY);
	bool wasAlreadyWalking = isFlagSet(ACTOR_FLAG_10);

	clearFlag(ACTOR_FLAG_10);

	// Check if the actor already is at the destination
	if (_x_pos == destX && _y_pos == destY) {
		if (wasAlreadyWalking) {
			stopWalk();
		}
		return true;
	}

	int xorflagsl = 0;
	int flag4 = 0;
	int origDestX = 0, origDestY = 0;

	int destPriority = 0;
	if (flags < 2) {
		destPriority = getEngine()->_scene->getPriorityAtPosition(Common::Point(destX, destY));
		if (destPriority < 0)
			destPriority = 1;
	}

	if ((flags == 0 && destPriority - 1 >= 8) || (flags == 1 && destPriority - 1 >= 16)) {
		// Destination point is not walkable so it has to be adjusted
		// Try to find a walkable destination point by testing the 32 corner points of a circle
		// in increasing radius steps.
		bool foundDestPos = false;
		xorflagsl = 1;
		origDestX = destX;
		origDestY = destY;
		for (int testRadius = 1; testRadius < 320 && !foundDestPos; ++testRadius) {
			for (int octant = 0; octant < 32; ++octant) {
				int testDestX = destX + ((testRadius * kCosTbl[octant % 32]) >> 8);
				int testDestY = destY + ((testRadius * kCosTbl[(octant + 8) % 32]) >> 8);
				if (testDestX >= 0 && testDestY >= 0) {
					int testDestPriority = getEngine()->_scene->getPriorityAtPosition(Common::Point(testDestX, testDestY));
					if ((flags == 0 && testDestPriority - 1 < 8) || (flags == 1 && testDestPriority - 1 < 16)) {
						destX = testDestX;
						destY = testDestY;
						foundDestPos = true;
						break;
					}
				}
			}
		}
		if (!foundDestPos) {
			if (wasAlreadyWalking) {
				stopWalk();
			}
			return false;
		}
	} else {
		// TODO Clean up
		xorflagsl = (flags ^ 2) < 1 ? 1 : 0;
	}

	// Check if the actor already is at the adjusted destination
	if (_x_pos == destX && _y_pos == destY) {
		if (wasAlreadyWalking) {
			stopWalk();
		}
		return true;
	}

	int tempDestX1 = destX, tempDestY1 = destY;
	int actorX1 = _x_pos, actorY1 = _y_pos;
	bool pathPointProcessed[kPathPointsCount];

	for (int pointIndex = 0; pointIndex < kPathPointsCount; ++pointIndex) {
		pathPointProcessed[pointIndex] = false;
	}

	_finalWalkDestX = destX;
	_finalWalkDestY = destY;

	if (!canWalkLine(actorX1, actorY1, tempDestX1, tempDestY1, flags)) {
		// Adjust source/dest positions
		for (int sxd = -1; sxd <= 1; ++sxd) {
			for (int syd = -1; syd <= 1; ++syd) {
				for (int dxd = -1; dxd <= 1; ++dxd) {
					for (int dyd = -1; dyd <= 1; ++dyd) {
						if (canWalkLine(actorX1 + sxd, actorY1 + syd, tempDestX1 + dxd, tempDestY1 + dyd, flags | 0x8000)) {
							sxd = 2;
							syd = 2;
							dxd = 2;
							dyd = 2;
							actorX1 += sxd;
							actorY1 += syd;
							tempDestX1 += dxd;
							tempDestY1 += dyd;
							_x_pos += sxd;
							_y_pos += syd;
						}
					}
				}
			}
		}
	}

	if (flag4 == 0) {
		// More adjusting of the source position
		bool needAdjustSourcePoint = true;
		for (int pointIndex = 0; pointIndex < kPathPointsCount; ++pointIndex) {
			const Common::Point pt = getEngine()->_scene->getPoint(pointIndex);
			if (pt.x != -1 && canWalkLine(actorX1, actorY1, pt.x, pt.y, flags)) {
				needAdjustSourcePoint = false;
				break;
			}
		}
		if (needAdjustSourcePoint) {
			for (int pointIndex = 0; needAdjustSourcePoint && pointIndex < kPathPointsCount; ++pointIndex) {
				const Common::Point pt = getEngine()->_scene->getPoint(pointIndex);
				for (int deltaIndex = 0; needAdjustSourcePoint && deltaIndex < 8; ++deltaIndex) {
					const int deltaX = kAdjustXTbl[deltaIndex];
					const int deltaY = kAdjustYTbl[deltaIndex];
					if (canWalkLine(actorX1 + deltaX, actorY1 + deltaY, pt.x, pt.y, flags)) {
						actorX1 += deltaX;
						actorY1 += deltaY;
						_x_pos += deltaX;
						_y_pos += deltaY;
						needAdjustSourcePoint = false;
					}
				}
			}
		}
		// More adjusting of the destination position
		bool needAdjustDestPoint = true;
		for (int pointIndex = 0; pointIndex < kPathPointsCount; ++pointIndex) {
			const Common::Point pt = getEngine()->_scene->getPoint(pointIndex);
			if (pt.x != -1 && canWalkLine(destX, destY, pt.x, pt.y, flags)) {
				needAdjustDestPoint = false;
				break;
			}
		}
		if (needAdjustDestPoint) {
			for (int pointIndex = 0; needAdjustDestPoint && pointIndex < kPathPointsCount; ++pointIndex) {
				const Common::Point pt = getEngine()->_scene->getPoint(pointIndex);
				for (int deltaIndex = 0; needAdjustDestPoint && deltaIndex < 8; ++deltaIndex) {
					const int deltaX = kAdjustXTbl[deltaIndex];
					const int deltaY = kAdjustYTbl[deltaIndex];
					if (canWalkLine(destX + deltaX, destY + deltaY, pt.x, pt.y, flags)) {
						destX += deltaX;
						destY += deltaY;
						needAdjustDestPoint = false;
					}
				}
			}
		}
	}

	// Build the actual path. The path is constructed backwards from the destination to the source.
	int pathPointsIndex = 0;
	while (!canWalkLine(actorX1, actorY1, tempDestX1, tempDestY1, flags) && pathPointsIndex < kPathPointsCount) {
		int foundPointIndex = pathfindingFindClosestPoint(actorX1, actorY1, tempDestX1, tempDestY1, flags, pathPointProcessed);
		if (foundPointIndex < 0) {
			if (wasAlreadyWalking) {
				stopWalk();
			}
			return false;
		}
		pathPointProcessed[foundPointIndex] = true;
		const Common::Point pt = getEngine()->_scene->getPoint(foundPointIndex);
		tempDestX1 = pt.x;
		tempDestY1 = pt.y;
		if (pathPointsIndex >= 2) {
			const Common::Point prevPt = getEngine()->_scene->getPoint(_walkPointsTbl[pathPointsIndex - 2]);
			if (canWalkLine(pt.x, pt.y, prevPt.x, prevPt.y, flags)) {
				--pathPointsIndex;
			}
		} else if (pathPointsIndex == 1) {
			if (canWalkLine(pt.x, pt.y, destX, destY, flags)) {
				--pathPointsIndex;
			}
		}
		_walkPointsTbl[pathPointsIndex] = foundPointIndex;
		++pathPointsIndex;
	}

	// Direction/post-processing
	if (xorflagsl != 0) {
		uint destDistance = calcDistance(destX, destY, tempDestX1, tempDestY1);
		uint sourceDistance = calcDistance(actorX1, actorY1, destX, destY);
		if (sourceDistance < 625 && ((actorX1 == destX && actorY1 == destY) || (sourceDistance < destDistance))) {
			int newDirection;
			int dx = origDestX - actorX1;
			int dy = origDestY - actorY1;
			if (dx != 0) {
				int slope = dy / dx;
				if (slope == 0) {
					newDirection = (dx < 1) ? 4 : 0;
				} else if (slope > 0) {
					newDirection = (dx <= 0) ? 3 : 7;
				} else {
					newDirection = (dx <= 0) ? 5 : 1;
				}
			} else {
				newDirection = (dy <= 0)  ? 2 : 6;
			}
			_direction = newDirection;
			if (wasAlreadyWalking) {
				stopWalk();
			}
			return false;
		}
	}

	_walkPointsIndex = pathPointsIndex - 1;
	if (pathPointsIndex == 0) {
		_walkDestX = tempDestX1;
		_walkDestY = tempDestY1;
		_finalWalkDestX = -1;
		_finalWalkDestY = -1;
	} else {
		const Common::Point pt = getEngine()->_scene->getPoint(_walkPointsTbl[_walkPointsIndex]);
		_walkDestX = pt.x;
		_walkDestY = pt.y;
	}
	int direction = startMoveToPoint(_walkDestX, _walkDestY);
	if (direction != -1 && !isFlagSet(ACTOR_FLAG_800)) {
		_direction = direction;
	}
	if (_sequenceID != _direction + 8 && !isFlagSet(ACTOR_FLAG_800)) {
		updateSequence(_direction + 8);
	}
	setFlag(ACTOR_FLAG_10);
	return true;
}

void Actor::stopWalk() {
	clearFlag(ACTOR_FLAG_10);
	_walkPointsIndex = 0;
	_walkDestX = _x_pos;
	_walkDestY = _y_pos;
	_finalWalkDestX = -1;
	_finalWalkDestY = -1;
	setFlag(ACTOR_FLAG_4);

	if (_flags & ACTOR_FLAG_200) {
		clearFlag(ACTOR_FLAG_800);
	}
}

void Actor::waitUntilFlag4IsSet() {
	while (!isFlagSet(ACTOR_FLAG_4) && !Engine::shouldQuit()) {
		getEngine()->waitForFrames(1);
	}
}

void Actor::waitUntilFlag8IsSet() {
	if (_flags & ACTOR_FLAG_8) {
		return;
	}

	while (!(_flags & ACTOR_FLAG_8) && !Engine::shouldQuit()) {
		getEngine()->waitForFrames(1);
	}
}

void Actor::waitUntilFlag8And4AreSet() {
	waitUntilFlag8IsSet();
	waitUntilFlag4IsSet();
}

void Actor::waitUntilFlag8SetThenSet1000() {
	waitUntilFlag8IsSet();
	setFlag(ACTOR_FLAG_1000);
}

void Actor::waitUntilFlag8SetThenSet1000AndWaitFor4() {
	waitUntilFlag8SetThenSet1000();
	waitUntilFlag4IsSet();
}

void Actor::clearFlag(uint32 flag) {
	_flags &= ~flag;
}

void Actor::setFlag(uint32 flag) {
	_flags |= flag;
}

bool Actor::isFlagSet(uint32 flag) {
	return (_flags & flag) == flag;
}

uint16 Actor::canWalkLine(int16 actor_x, int16 actor_y, int16 target_x, int16 target_y, uint16 walkFlags) {
	debug(1, "canWalkLine. (%X,%X) -> (%X,%X) %d", _x_pos, _y_pos, target_x, target_y, walkFlags);

	if (walkFlags == 2) {
		return 1;
	}
	uint16 width = getEngine()->_scene->getStageWidth();
	uint16 height = getEngine()->_scene->getStageHeight();

	if (walkFlags & 0x8000) {
		if (actor_x < 0
			|| width - 1 < actor_x
			|| actor_y < 0
			|| height - 1 < actor_y
			|| target_x < 0
			|| width - 1 < target_x
			|| target_y < 0
			|| height - 1 < target_y) {
			return 0;
		}
	}

	int32 x_increment = 0;
	int32 y_increment = 0;
	if (target_y == actor_y && target_x == target_y) {
		return 1;
	}

	int16 deltaX = target_x - actor_x;
	int16 deltaY = target_y - actor_y;

	if (target_y != actor_y && target_x == actor_x) {
		y_increment = deltaY > 0 ? 0x10000 : -0x10000;
	} else {
		if (target_y == actor_y) {
			if (target_x == actor_x) {
				x_increment = 0;
				y_increment = deltaY > 0 ? 0x10000 : -0x10000;
			} else {
				x_increment = deltaX > 0 ? 0x10000 : -0x10000;
				y_increment = 0;
			}
		} else {
			if (ABS(deltaY) < ABS(deltaX)) {
				x_increment = deltaX > 0 ? 0x10000 : -0x10000;
				y_increment = ((deltaY) << 0x10) / (deltaX);
				if ((deltaY > 0 && y_increment < 0) || (deltaY < 0 && y_increment > 0)) {
					y_increment = -y_increment;
				}
			} else {
				y_increment = deltaY > 0 ? 0x10000 : -0x10000;
				x_increment = ((deltaX) << 0x10) / (deltaY);
				if ((deltaX > 0 && x_increment < 0) || (deltaX < 0 && x_increment > 0)) {
					x_increment = -x_increment;
				}
			}
		}
	}

	// 0x80034d28
	int32 x = actor_x << 0x10;
	int32 y = actor_y << 0x10;
	for (;;) {
		if ((x+0x8000) >> 0x10 == target_x && (y+0x8000) >> 0x10 == target_y) {
			return 1;
		}
		int16 priority = getEngine()->_scene->getPriorityAtPosition(Common::Point(x>>0x10, y>>0x10));
		if (priority < 0) {
			priority = 1;
		}
		if (!(walkFlags & 0x7fff) && (priority == 0 || priority >= 8)) {
			return 0;
		}

		if ((walkFlags & 0x7fff) == 1) {
			if (priority == 0 || priority >= 0x10) {
				return 0;
			}
		}
		x += x_increment;
		y += y_increment;
	}
}

int Actor::startMoveToPoint(int destX, int destY) {
	int direction = 0;
	int quadrant = 0;
	int deltaX = destX - _x_pos;
	int deltaY = (destY - _y_pos) * 2;
	int absDeltaX = ABS(deltaX);
	int absDeltaY = ABS(deltaY);
	// debug("from: (%d, %d); to: (%d, %d); d: (%d, %d); actor._walkSpeed: %08X", _x_pos, actor._y, destX, destY, deltaX, deltaY, actor._walkSpeed);

	_xShl16 = _x_pos << 16;
	_yShl16 = _y_pos << 16;

	// Walk slope is a fixed point value, where the upper 16 bits are the integral part,
	// and the lower 16 bits the fractional part. 0x10000 is 1.0.

	if (deltaX != 0 && deltaY != 0) {
		// Walk along both X and Y axis
		if (absDeltaX < absDeltaY) {
			_walkSlopeX = (absDeltaX << 16) / absDeltaY;
			_walkSlopeY = 0x10000;
		} else {
			_walkSlopeX = 0x10000;
			_walkSlopeY = (absDeltaY << 16) / absDeltaX;
		}
	} else if (deltaX != 0) {
		// Walk along X only
		_walkSlopeX = 0x10000;
		_walkSlopeY = 0;
	} else if (deltaY != 0) {
		// Walk along Y only
		_walkSlopeX = 0;
		_walkSlopeY = 0x10000;
	} else {
		// Already at dest
		return -1;
	}

	_walkSlopeX = (_walkSlopeX / 32) * (_walkSpeed / 0x800);
	_walkSlopeY = (_walkSlopeY / 32) * (_walkSpeed / 0x800);

	if (deltaX < 0) {
		_walkSlopeX = -_walkSlopeX;
		quadrant += 2;
	}

	if (deltaY < 0) {
		_walkSlopeY = -_walkSlopeY;
		quadrant += 1;
	}

	switch (quadrant) {
	case 0:
		direction = (absDeltaX < absDeltaY) ? 2 : 0;
		break;
	case 1:
		direction = (absDeltaX < absDeltaY) ? 6 : 0;
		break;
	case 2:
		direction = (absDeltaX < absDeltaY) ? 2 : 4;
		break;
	case 3:
		direction = (absDeltaX < absDeltaY) ? 6 : 4;
		break;
	default:
		break;
	}

	_walkSlopeY /= 2;
	_walkDestX = destX;
	_walkDestY = destY;

	if (getEngine()->_dragonINIResource->isFlicker(_actorID)) {
		// Adjust walk slope for the main actor
		_walkSlopeX = _walkSlopeX * 3 / 2;
		_walkSlopeY = _walkSlopeY * 3 / 2;
	}

	return direction;
}

void Actor::walkPath() {
	if (isFlagClear(ACTOR_FLAG_400) && isFlagSet(Dragons::ACTOR_FLAG_40) && isFlagSet(Dragons::ACTOR_FLAG_10)) {
		_xShl16 += (((_scale * _walkSlopeX) / DRAGONS_ENGINE_SPRITE_100_PERCENT_SCALE) * 5) / 4;
		_yShl16 += (((_scale * _walkSlopeY) / DRAGONS_ENGINE_SPRITE_100_PERCENT_SCALE) * 5) / 4;

		if ((_walkSlopeX >= 0 && _walkDestX < (_xShl16 >> 0x10))
				|| (_walkSlopeX < 0 && (_xShl16 >> 0x10) < _walkDestX)) {
			_xShl16 = _walkDestX << 0x10;
		}

		if ((_walkSlopeY >= 0 && _walkDestY < (_yShl16 >> 0x10))
				|| (_walkSlopeY < 0 && (_yShl16 >> 0x10) < _walkDestY)) {
			_yShl16 = _walkDestY << 0x10;
		}

		_x_pos = _xShl16 >> 0x10;
		_y_pos = _yShl16 >> 0x10;

		if (_x_pos == _walkDestX && _y_pos == _walkDestY) {
			if (_walkPointsIndex <= 0) {
				if (_finalWalkDestX < 0) {
					clearFlag(ACTOR_FLAG_10);
					if (isFlagClear(ACTOR_FLAG_200)) {
						clearFlag(ACTOR_FLAG_800);
					}
					setFlag(ACTOR_FLAG_4);
					clearFlag(ACTOR_FLAG_1);
					return;
				} else {
					_walkDestX = _finalWalkDestX;
					_walkDestY = _finalWalkDestY;
					_finalWalkDestX = -1;
					_finalWalkDestY = -1;
				}
			} else {
				_walkPointsIndex--;
				Common::Point point = getEngine()->_scene->getPoint(_walkPointsTbl[_walkPointsIndex]);
				_walkDestX = point.x;
				_walkDestY = point.y;
			}
			// 0x8001bcc8
			int direction = startMoveToPoint(_walkDestX, _walkDestY);
			if (direction != -1 && !isFlagSet(ACTOR_FLAG_800)) {
				_direction = direction;
			}
			if (_sequenceID != _direction + 8 && _direction != -1 && !isFlagSet(ACTOR_FLAG_800)) {
				updateSequence(_direction + 8);
			}
			setFlag(ACTOR_FLAG_10);
		}
	}
}

// 0x80034930
int16 Actor::pathfindingFindClosestPoint(int16 actor_x, int16 actor_y, int16 target_x, int16 target_y,
										 int16 unkType, bool *pointsInUseTbl) {
	int16 pointId = -1;
	uint32 minDist = 0xffffffff;

	for (int i = 0; i < kPathPointsCount; i++) {
		Common::Point point = getEngine()->_scene->getPoint(i);
		if (point.x != -1 && !pointsInUseTbl[i]) {
			if (canWalkLine(point.x, point.y, target_x, target_y, unkType)) {
				uint32 dist = abs(point.x - actor_x) * abs(point.x - actor_x) + abs(point.y - actor_y) * abs(point.y - actor_y);
				if (dist < minDist) {
					minDist = dist;
					pointId = i;
				}
			}
		}
	}
	return pointId;
}

bool Actor::actorSetSequenceAndWaitAllowSkip(uint16 newSequenceID) {
	updateSequence(newSequenceID);
	waitUntilFlag8IsSet();
	return waitUntilFlag4IsSetAllowSkip();
}

bool Actor::waitUntilFlag4IsSetAllowSkip() {
	while (!isFlagSet(ACTOR_FLAG_4) && !Engine::shouldQuit()) {
		getEngine()->waitForFrames(1);
		if (getEngine()->checkForActionButtonRelease()) {
			return true;
		}
	}

	return false;
}

byte *Actor::getPalette() {
	if (!isFlagSet(ACTOR_FLAG_4000)) {
		if (!isFlagSet(ACTOR_FLAG_8000)) {
			if ((_frame_flags & 0x30) != 0) {
				return _actorResource->getPalette();
			}
			return getEngine()->_screen->getPalette(1);
		} else {
			return getEngine()->_screen->getPalette(0);
		}
	}
	return getEngine()->_screen->getPalette(4);
}

int16 Actor::getFrameYOffset() {
	return _frame ? _frame->yOffset : 0;
}

void Actor::waitForWalkToFinish() {
	DragonsEngine *vm = getEngine();
	do {
		vm->waitForFrames(1);
	} while (!Engine::shouldQuit() && isFlagSet(ACTOR_FLAG_10));
}

} // End of namespace Dragons