Initial commit

engines/saga/actor.h

@@ -0,0 +1,688 @@
+/* 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/>.
+ *
+ */
+
+// Actor management module header file
+
+#ifndef SAGA_ACTOR_H
+#define SAGA_ACTOR_H
+
+#include "common/savefile.h"
+
+#include "saga/sprite.h"
+#include "saga/itedata.h"
+#include "saga/saga.h"
+#include "saga/font.h"
+
+namespace Saga {
+
+class HitZone;
+
+
+//#define ACTOR_DEBUG 1 //only for actor pathfinding debug!
+
+#define ACTOR_BARRIERS_MAX 16
+
+#define ACTOR_MAX_STEPS_COUNT 32
+
+#define ACTOR_DIALOGUE_HEIGHT 100
+
+#define ACTOR_LMULT 4
+
+#define ACTOR_SPEED 72
+
+#define ACTOR_CLIMB_SPEED 8
+
+#define ACTOR_COLLISION_WIDTH       32
+#define ACTOR_COLLISION_HEIGHT       8
+
+#define ACTOR_DIRECTIONS_COUNT	4	// for ActorFrameSequence
+
+#define ACTOR_SPEECH_STRING_MAX 16	// speech const
+#define ACTOR_SPEECH_ACTORS_MAX 8
+
+#define ACTOR_DRAGON_TURN_MOVES 4
+#define ACTOR_DRAGON_INDEX 133
+
+#define ACTOR_NO_ENTRANCE -1
+
+#define ACTOR_EXP_KNOCK_RIF 24
+
+#define PATH_NODE_EMPTY -1
+
+#define ACTOR_INHM_SIZE 228
+
+enum ActorDirections {
+	kDirectionRight = 0,
+	kDirectionLeft = 1,
+	kDirectionUp = 2,
+	kDirectionDown = 3
+};
+
+enum ActorActions {
+	kActionWait = 0,
+	kActionWalkToPoint = 1,
+	kActionWalkToLink = 2,
+	kActionWalkDir = 3,
+	kActionSpeak = 4,
+	kActionAccept = 5,
+	kActionStoop = 6,
+	kActionLook = 7,
+	kActionCycleFrames = 8,
+	kActionPongFrames = 9,
+	kActionFreeze = 10,
+	kActionFall = 11,
+	kActionClimb = 12
+};
+
+enum ActorFrameIds {
+//ITE
+	kFrameITEStand = 0,
+	kFrameITEWalk = 1,
+	kFrameITESpeak = 2,
+	kFrameITEGive = 3,
+	kFrameITEGesture = 4,
+	kFrameITEWait = 5,
+	kFrameITEPickUp = 6,
+	kFrameITELook = 7,
+//IHNM
+	kFrameIHNMStand = 0,
+	kFrameIHNMSpeak = 1,
+	kFrameIHNMWait = 2,
+	kFrameIHNMGesture = 3,
+	kFrameIHNMWalk = 4
+};
+
+enum SpeechFlags {
+	kSpeakNoAnimate = 1,
+	kSpeakAsync = 2,
+	kSpeakSlow = 4,
+	kSpeakForceText = 8
+};
+
+enum ActorFrameTypes {
+	kFrameStand,
+	kFrameWalk,
+	kFrameSpeak,
+	kFrameGive,
+	kFrameGesture,
+	kFrameWait,
+	kFramePickUp,
+	kFrameLook
+};
+
+// Lookup table to convert 8 cardinal directions to 4
+static const int actorDirectionsLUT[8] = {
+	kDirectionUp,       // kDirUp
+	kDirectionRight,    // kDirUpRight
+	kDirectionRight,    // kDirRight
+	kDirectionRight,    // kDirDownRight
+	kDirectionDown,     // kDirDown
+	kDirectionLeft,     // kDirDownLeft
+	kDirectionLeft,     // kDirLeft
+	kDirectionLeft      // kDirUpLeft
+};
+
+enum ActorFlagsEx {
+	kActorNoCollide = (1 << 0),
+	kActorNoFollow = (1 << 1),
+	kActorCollided = (1 << 2),
+	kActorBackwards = (1 << 3),
+	kActorContinuous = (1 << 4),
+	kActorFinalFace = (1 << 5),
+	kActorFinishLeft = ((1 << 5) | (kDirLeft << 6)),
+	kActorFinishRight = ((1 << 5) | (kDirRight << 6)),
+	kActorFinishUp = ((1 << 5) | (kDirUp << 6)),
+	kActorFinishDown = ((1 << 5) | (kDirDown << 6)),
+	kActorFacingMask = (0xf << 5),
+	kActorRandom = (1 << 10)
+};
+
+enum PathCellType {
+	kPathCellEmpty = -1,
+	//kDirUp = 0 .... kDirUpLeft = 7
+	kPathCellBarrier = 0x57
+};
+
+enum DragonMoveTypes {
+	kDragonMoveUpLeft			=	0,
+	kDragonMoveUpRight			=	1,
+	kDragonMoveDownLeft			=	2,
+	kDragonMoveDownRight		=	3,
+	kDragonMoveUpLeft_Left		=	4,
+	kDragonMoveUpLeft_Right		=	5,
+	kDragonMoveUpRight_Left		=	6,
+	kDragonMoveUpRight_Right	=	7,
+	kDragonMoveDownLeft_Left	=	8,
+	kDragonMoveDownLeft_Right	=	9,
+	kDragonMoveDownRight_Left	=	10,
+	kDragonMoveDownRight_Right	=	11,
+	kDragonMoveInvalid			=	12
+};
+
+struct PathDirectionData {
+	int8 direction;
+	int32 x;
+	int32 y;
+};
+
+struct ActorFrameRange {
+	int frameIndex;
+	int frameCount;
+};
+
+struct ActorFrameSequence {
+	ActorFrameRange directions[ACTOR_DIRECTIONS_COUNT];
+};
+
+typedef Common::Array<ActorFrameSequence> ActorFrameSequences;
+
+uint pathLine(PointList &pointList, uint idx, const Point &point1, const Point &point2);
+
+struct Location {
+	int32 x;					// logical coordinates
+	int32 y;					//
+	int32 z;					//
+	Location() {
+		x = y = z = 0;
+	}
+	void saveState(Common::OutSaveFile *out) {
+		out->writeSint32LE(x);
+		out->writeSint32LE(y);
+		out->writeSint32LE(z);
+	}
+	void loadState(Common::InSaveFile *in) {
+		x = in->readSint32LE();
+		y = in->readSint32LE();
+		z = in->readSint32LE();
+	}
+
+	int distance(const Location &location) const {
+		return MAX(ABS(x - location.x), ABS(y - location.y));
+	}
+	int32 &u() {
+		return x;
+	}
+	int32 &v() {
+		return y;
+	}
+	int32 u() const {
+		return x;
+	}
+	int32 v() const {
+		return y;
+	}
+	int32 uv() const {
+		return u() + v();
+	}
+	void delta(const Location &location, Location &result) const {
+		result.x = x - location.x;
+		result.y = y - location.y;
+		result.z = z - location.z;
+	}
+	void addXY(const Location &location) {
+		x += location.x;
+		y += location.y;
+	}
+	void add(const Location &location) {
+		x += location.x;
+		y += location.y;
+		z += location.z;
+	}
+	void fromScreenPoint(const Point &screenPoint) {
+		x = (screenPoint.x * ACTOR_LMULT);
+		y = (screenPoint.y * ACTOR_LMULT);
+		z = 0;
+	}
+	void toScreenPointXY(Point &screenPoint) const {
+		screenPoint.x = x / ACTOR_LMULT;
+		screenPoint.y = y / ACTOR_LMULT;
+	}
+	void toScreenPointUV(Point &screenPoint) const {
+		screenPoint.x = u();
+		screenPoint.y = v();
+	}
+	void toScreenPointXYZ(Point &screenPoint) const {
+		screenPoint.x = x / ACTOR_LMULT;
+		screenPoint.y = y / ACTOR_LMULT - z;
+	}
+	void fromStream(Common::ReadStream &stream) {
+		x = stream.readUint16LE();
+		y = stream.readUint16LE();
+		z = stream.readUint16LE();
+	}
+};
+
+class CommonObjectData {
+public:
+//constant
+	int32 _index;					// index in local array
+	uint16 _id;						// object id
+	int32 _scriptEntrypointNumber;	// script entrypoint number
+
+//variables
+	uint16 _flags;				// initial flags
+	int32 _nameIndex;			// index in name string list
+	int32 _sceneNumber;			// scene
+	int32 _spriteListResourceId;	// sprite list resource id
+
+	Location _location;			// logical coordinates
+	Point _screenPosition;		// screen coordinates
+	int32 _screenDepth;			//
+	int32 _screenScale;			//
+
+	void saveState(Common::OutSaveFile *out) {
+		out->writeUint16LE(_flags);
+		out->writeSint32LE(_nameIndex);
+		out->writeSint32LE(_sceneNumber);
+		out->writeSint32LE(_spriteListResourceId);
+		_location.saveState(out);
+		out->writeSint16LE(_screenPosition.x);
+		out->writeSint16LE(_screenPosition.y);
+		out->writeSint32LE(_screenDepth);
+		out->writeSint32LE(_screenScale);
+	}
+	void loadState(Common::InSaveFile *in) {
+		_flags = in->readUint16LE();
+		_nameIndex = in->readSint32LE();
+		_sceneNumber = in->readSint32LE();
+		_spriteListResourceId = in->readSint32LE();
+		_location.loadState(in);
+		_screenPosition.x = in->readSint16LE();
+		_screenPosition.y = in->readSint16LE();
+		_screenDepth = in->readSint32LE();
+		_screenScale = in->readSint32LE();
+	}
+
+	CommonObjectData() {
+		_index = 0;
+		_id = 0;
+		_scriptEntrypointNumber = 0;
+
+		_flags = 0;
+		_nameIndex = 0;
+		_sceneNumber = 0;
+		_spriteListResourceId = 0;
+
+		_screenDepth = 0;
+		_screenScale = 0;
+	}
+};
+
+typedef CommonObjectData *CommonObjectDataPointer;
+
+typedef Common::List<CommonObjectDataPointer> CommonObjectOrderList;
+
+class ObjectData: public CommonObjectData {
+public:
+	//constant
+	uint16 _interactBits;
+
+	ObjectData() {
+		_interactBits = 0;
+	}
+};
+
+typedef Common::Array<ObjectData> ObjectDataArray;
+
+class ActorData: public CommonObjectData {
+public:
+	//constant
+	SpriteList _spriteList;		// sprite list data
+
+	ActorFrameSequences *_frames;	// Actor's frames
+	ActorFrameSequences _framesContainer;	// Actor's frames
+	int _frameListResourceId;	// Actor's frame list resource id
+
+	byte _speechColor;			// Actor dialogue color
+	//
+	bool _inScene;
+
+	//variables
+	uint16 _actorFlags;			// dynamic flags
+	int32 _currentAction;			// ActorActions type
+	int32 _facingDirection;		// orientation
+	int32 _actionDirection;
+	int32 _actionCycle;
+	uint16 _targetObject;
+	const HitZone *_lastZone;
+
+	int32 _cycleFrameSequence;
+	uint8 _cycleDelay;
+	uint8 _cycleTimeCount;
+	uint8 _cycleFlags;
+
+	int16 _fallVelocity;
+	int16 _fallAcceleration;
+	int16 _fallPosition;
+
+	uint8 _dragonBaseFrame;
+	uint8 _dragonStepCycle;
+	uint8 _dragonMoveType;
+
+	int32 _frameNumber;			// current frame number
+
+	ByteArray _tileDirections;
+
+	Common::Array<Point> _walkStepsPoints;
+
+	int32 _walkStepsCount;
+	int32 _walkStepIndex;
+
+	Location _finalTarget;
+	Location _partialTarget;
+	int32 _walkFrameSequence;
+
+public:
+	ActorData();
+
+	void saveState(Common::OutSaveFile *out);
+	void loadState(uint32 version, Common::InSaveFile *in);
+
+	void cycleWrap(int cycleLimit);
+	void addWalkStepPoint(const Point &point);
+	bool shareFrames() {
+		return ((_frames != NULL) && (_frames != &_framesContainer));
+	}
+};
+
+typedef Common::Array<ActorData> ActorDataArray;
+
+struct ProtagStateData {
+	ActorFrameSequences _frames;	// Actor's frames
+};
+
+
+struct SpeechData {
+	int speechColor[ACTOR_SPEECH_ACTORS_MAX];
+	int outlineColor[ACTOR_SPEECH_ACTORS_MAX];
+	int speechFlags;
+	const char *strings[ACTOR_SPEECH_STRING_MAX];
+	Rect speechBox;
+	Rect drawRect;
+	int stringsCount;
+	int slowModeCharIndex;
+	uint16 actorIds[ACTOR_SPEECH_ACTORS_MAX];
+	int actorsCount;
+	int sampleResourceId;
+	bool playing;
+	int playingTime;
+
+	SpeechData() {
+		for (uint i = 0; i < ACTOR_SPEECH_ACTORS_MAX; i++) {
+			speechColor[i] = 0;
+			outlineColor[i] = 0;
+		}
+		speechFlags = 0;
+		for (uint i = 0; i < ACTOR_SPEECH_ACTORS_MAX; i++) {
+			strings[i] = nullptr;
+		}
+		// speechBox is initialized by Rect constructor
+		// drawRect is initialized by Rect constructor
+		stringsCount = 0;
+		slowModeCharIndex = 0;
+		for (uint i = 0; i < ACTOR_SPEECH_ACTORS_MAX; i++) {
+			actorIds[i] = 0;
+		}
+		actorsCount = 0;
+		sampleResourceId = 0;
+		playing = false;
+		playingTime = 0;
+	}
+
+	FontEffectFlags getFontFlags(int i) {
+		if (outlineColor[i] != 0) {
+			return kFontOutline;
+		} else {
+			return kFontNormal;
+		}
+	}
+};
+
+typedef int (*CompareFunction) (const CommonObjectDataPointer& a, const CommonObjectDataPointer& b);
+
+class Actor {
+	friend class IsoMap;
+	friend class SagaEngine;
+	friend class Puzzle;
+public:
+
+	Actor(SagaEngine *vm);
+	~Actor();
+
+	void cmdActorWalkTo(int argc, const char **argv);
+
+	bool validActorId(uint16 id) {
+		return (id == ID_PROTAG) || ((id >= objectIndexToId(kGameObjectActor, 0)) && (id < objectIndexToId(kGameObjectActor, _actors.size())));
+	}
+	int actorIdToIndex(uint16 id) { return (id == ID_PROTAG) ? 0 : objectIdToIndex(id); }
+	uint16 actorIndexToId(int index) { return (index == 0) ? ID_PROTAG : objectIndexToId(kGameObjectActor, index); }
+	ActorData *getActor(uint16 actorId);
+
+// clarification: Obj - means game object, such Hat, Spoon etc,  Object - means Actor,Obj,HitZone,StepZone
+
+	bool validObjId(uint16 id) { return (id >= objectIndexToId(kGameObjectObject, 0)) && (id < objectIndexToId(kGameObjectObject, _objs.size())); }
+	int objIdToIndex(uint16 id) { return objectIdToIndex(id); }
+	uint16 objIndexToId(int index) { return objectIndexToId(kGameObjectObject, index); }
+	ObjectData *getObj(uint16 objId);
+
+	int getObjectScriptEntrypointNumber(uint16 id) {
+		int objectType;
+		objectType = objectTypeId(id);
+		if (!(objectType & (kGameObjectObject | kGameObjectActor))) {
+			error("Actor::getObjectScriptEntrypointNumber wrong id 0x%X", id);
+		}
+		return (objectType == kGameObjectObject) ? getObj(id)->_scriptEntrypointNumber : getActor(id)->_scriptEntrypointNumber;
+	}
+	int getObjectFlags(uint16 id) {
+		int objectType;
+		objectType = objectTypeId(id);
+		if (!(objectType & (kGameObjectObject | kGameObjectActor))) {
+			error("Actor::getObjectFlags wrong id 0x%X", id);
+		}
+		return (objectType == kGameObjectObject) ? getObj(id)->_flags : getActor(id)->_flags;
+	}
+
+	void direct(int msec);
+	void drawActors();
+	void updateActorsScene(int actorsEntrance);			// calls from scene loading to update Actors info
+
+	void drawSpeech();
+
+#ifdef ACTOR_DEBUG
+	void drawPathTest();
+#endif
+
+	uint16 hitTest(const Point &testPoint, bool skipProtagonist);
+	void takeExit(uint16 actorId, const HitZone *hitZone);
+	bool actorEndWalk(uint16 actorId, bool recurse);
+	bool actorWalkTo(uint16 actorId, const Location &toLocation);
+	int getFrameType(ActorFrameTypes frameType);
+	ActorFrameRange *getActorFrameRange(uint16 actorId, int frameType);
+	void actorFaceTowardsPoint(uint16 actorId, const Location &toLocation);
+	void actorFaceTowardsObject(uint16 actorId, uint16 objectId);
+
+	void realLocation(Location &location, uint16 objectId, uint16 walkFlags);
+
+//	speech
+	void actorSpeech(uint16 actorId, const char **strings, int stringsCount, int sampleResourceId, int speechFlags);
+	void nonActorSpeech(const Common::Rect &box, const char **strings, int stringsCount, int sampleResourceId, int speechFlags);
+	void simulSpeech(const char *string, uint16 *actorIds, int actorIdsCount, int speechFlags, int sampleResourceId);
+	void setSpeechColor(int speechColor, int outlineColor) {
+		_activeSpeech.speechColor[0] = speechColor;
+		_activeSpeech.outlineColor[0] = outlineColor;
+	}
+	void abortAllSpeeches();
+	void abortSpeech();
+	bool isSpeaking() {
+		return _activeSpeech.stringsCount > 0;
+	}
+
+	int isForcedTextShown() {
+		return _activeSpeech.speechFlags & kSpeakForceText;
+	}
+
+	void saveState(Common::OutSaveFile *out);
+	void loadState(Common::InSaveFile *in);
+
+	void setProtagState(int state);
+	int getProtagState() { return _protagState; }
+
+	void loadActorList(int protagonistIdx, int actorCount, int actorsResourceID,
+				  int protagStatesCount, int protagStatesResourceID);
+	void loadObjList(int objectCount, int objectsResourceID);
+
+protected:
+	friend class Script;
+	void loadActorResources(ActorData *actor);
+	void loadFrameList(int frameListResourceId, ActorFrameSequences &frames);
+private:
+	void stepZoneAction(ActorData *actor, const HitZone *hitZone, bool exit, bool stopped);
+	void loadActorSpriteList(ActorData *actor);
+
+	void drawOrderListAdd(const CommonObjectDataPointer& element, CompareFunction compareFunction);
+	void createDrawOrderList();
+	bool calcScreenPosition(CommonObjectData *commonObjectData);
+	bool getSpriteParams(CommonObjectData *commonObjectData, int &frameNumber, SpriteList *&spriteList);
+
+	bool followProtagonist(ActorData *actor);
+	void findActorPath(ActorData *actor, const Point &fromPoint, const Point &toPoint);
+	void handleSpeech(int msec);
+	void handleActions(int msec, bool setup);
+	bool validPathCellPoint(const Point &testPoint) {
+		return !((testPoint.x < 0) || (testPoint.x >= _xCellCount) ||
+			(testPoint.y < 0) || (testPoint.y >= _yCellCount));
+	}
+	void setPathCell(const Point &testPoint, int8 value) {
+#ifdef ACTOR_DEBUG
+		if (!validPathCellPoint(testPoint)) {
+			error("Actor::setPathCell wrong point");
+		}
+#endif
+		_pathCell[testPoint.x + testPoint.y * _xCellCount] = value;
+	}
+	int8 getPathCell(const Point &testPoint) {
+#ifdef ACTOR_DEBUG
+		if (!validPathCellPoint(testPoint)) {
+			error("Actor::getPathCell wrong point");
+		}
+#endif
+		return _pathCell[testPoint.x + testPoint.y * _xCellCount];
+	}
+	bool scanPathLine(const Point &point1, const Point &point2);
+	int fillPathArray(const Point &fromPoint, const Point &toPoint, Point &bestPoint);
+	void setActorPath(ActorData *actor, const Point &fromPoint, const Point &toPoint);
+	void pathToNode();
+	void condenseNodeList();
+	void removeNodes();
+	void nodeToPath();
+	void removePathPoints();
+	bool validFollowerLocation(const Location &location);
+	void moveDragon(ActorData *actor);
+
+
+protected:
+//constants
+	ActorDataArray _actors;
+
+	ObjectDataArray _objs;
+
+	SagaEngine *_vm;
+	ResourceContext *_actorContext;
+
+	int _lastTickMsec;
+	CommonObjectOrderList _drawOrderList;
+
+//variables
+public:
+	ActorData *_centerActor;
+	ActorData *_protagonist;
+	int _handleActionDiv;
+
+	Rect _speechBoxScript;
+
+	StringsTable _objectsStrings;
+	StringsTable _actorsStrings;
+
+protected:
+	SpeechData _activeSpeech;
+	int _protagState;
+	bool _dragonHunt;
+
+private:
+	Common::Array<ProtagStateData> _protagStates;
+
+//path stuff
+	struct PathNode {
+		Point point;
+		int link;
+
+		PathNode() : link(0) {}
+		PathNode(const Point &p) : point(p), link(0) {}
+		PathNode(const Point &p, int l) : point(p), link(l) {}
+	};
+	typedef Common::Array<PathNode> PathNodeList;
+
+	Rect _barrierList[ACTOR_BARRIERS_MAX];
+	int _barrierCount;
+	Common::Array<int8> _pathCell;
+
+	int _xCellCount;
+	int _yCellCount;
+	Rect _pathRect;
+
+	PointList _pathList;
+	uint _pathListIndex;
+
+	PathNodeList _pathNodeList;
+
+public:
+#ifdef ACTOR_DEBUG
+#ifndef SAGA_DEBUG
+	#error You must also define SAGA_DEBUG
+#endif
+//path debug - use with care
+	struct DebugPoint {
+		Point point;
+		byte color;
+
+		DebugPoint() : color(0) {}
+
+		DebugPoint(const Point &p, byte c): point(p), color(c) {}
+	};
+
+	Common::Array<DebugPoint> _debugPoints;
+	uint _debugPointsCount;
+	// we still need this trick to speedup debug points addition
+	void addDebugPoint(const Point &point, byte color) {
+		if (_debugPointsCount < _debugPoints.size()) {
+			_debugPoints[_debugPointsCount].point = point;
+			_debugPoints[_debugPointsCount].color = color;
+		} else {
+			_debugPoints.push_back(DebugPoint(point, color));
+		}
+		++_debugPointsCount;
+	}
+#endif
+};
+
+} // End of namespace Saga
+
+#endif