/* 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/>.
 *
 *
 * Based on the original sources
 *   Faery Tale II -- The Halls of the Dead
 *   (c) 1993-1996 The Wyrmkeep Entertainment Co.
 */

#ifndef SAGA2_ACTOR_H
#define SAGA2_ACTOR_H

#include "saga2/objects.h"
#include "saga2/saveload.h"

namespace Saga2 {

class ActorAssignment;
class Band;
class MotionTask;
class TaskStack;

const int   kBandingDist = kSectorSize * 2;
const int   kActorScriptVars = 4;

/* ===================================================================== *
   Actor character attributes
 * ===================================================================== */

//  Defines the colors of MANA

enum ActorSkillID {
	kSkillIDArchery      =  0,
	kSkillIDSwordcraft,
	kSkillIDShieldcraft,
	kSkillIDBludgeon,
	kSkillIDThrowing,    //  gone
	kSkillIDSpellcraft,
	kSkillIDStealth,     //  gone
	kSkillIDAgility,
	kSkillIDBrawn,
	kSkillIDLockpick,    //  gone
	kSkillIDPilfer,      //  gone
	kSkillIDFirstAid,    //  gone
	kSkillIDSpotHidden,  //  gone
	kNumSkills
};

enum ArmorObjectTypes {
	SHIRT_ARMOR = 0,
	BOOT_ARMOR,
	BRACER_ARMOR,
	HELM_ARMOR,
	NECKLACE_ARMOR,
	CLOAK_ARMOR,
	RING_ARMOR,

	ARMOR_COUNT
};

/* ===================================================================== *
   ArmorAttributes struct
 * ===================================================================== */

struct ArmorAttributes {
	uint8       damageAbsorbtion,
	            damageDivider,
	            defenseBonus;
};

/* ===================================================================== *
   ActorAttributes structure
 * ===================================================================== */

// this enum acts as a layer of indirection for the unioned allSkills
// array.


//  This defines the basic skills possessed by an actor
struct ActorAttributes {
	enum skillInfo {
		kSkillBasePercent            = 100,
		kSkillFracPointsPerLevel     = 5,    // this being twenty and levels at 5
		kSkillLevels                 = 20,   // will make the advancement calc quick & easy
		kSkillMaxLevel               = kSkillFracPointsPerLevel * kSkillLevels
	};

	enum vitalityInfo {
		kVitalityLimit               = 256
	};

	//  Automatic skills
	uint8       archery,        //  Accuracy of missile weapons
				swordcraft,     //  Accuracy of bladed melee weapons
				shieldcraft,    //  Actor's ability to use a shield
				bludgeon,       //  Accuracy of non-bladed melee weapons
				throwing,       //  Ability to throw objects accurately
				spellcraft,     //  Accuracy of spell combat
				stealth,        //  Ability to remain unnoticed
				agility,        //  Ability to dodge
				brawn,          //  Ability to lift, and damage of weapons
				lockpick;       //  Ability to pick locks

	//  Manual skills
	uint8       pilfer,         //  Ability to "lift" an item
				firstAid,       //  Ability to heal recent injuries
				spotHidden;     //  Ability to spot hidden objects

	//  Pad byte for alignment
	int8 pad;

	//  Hit-points
	int16 vitality;

	//  Magic energy
	int16       redMana,
				orangeMana,
				yellowMana,
				greenMana,
				blueMana,
				violetMana;

	uint8 &skill(int16 id) {
		switch (id) {
		case kSkillIDArchery: return archery;
		case kSkillIDSwordcraft: return swordcraft;
		case kSkillIDShieldcraft: return shieldcraft;
		case kSkillIDBludgeon: return bludgeon;
		case kSkillIDThrowing: return throwing;
		case kSkillIDSpellcraft: return spellcraft;
		case kSkillIDStealth: return stealth;
		case kSkillIDAgility: return agility;
		case kSkillIDBrawn: return brawn;
		case kSkillIDLockpick: return lockpick;
		case kSkillIDPilfer: return pilfer;
		case kSkillIDFirstAid: return firstAid;
		case kSkillIDSpotHidden: return spotHidden;
		}
		error("Incorrect skill id: %d", id);
	}
	int16 &mana(int16 id) {
		switch (id) {
		case kManaIDRed: return redMana;
		case kManaIDOrange: return orangeMana;
		case kManaIDYellow: return yellowMana;
		case kManaIDGreen: return greenMana;
		case kManaIDBlue: return blueMana;
		case kManaIDViolet: return violetMana;
		}
		error("Incorrect mana id: %d", id);
	}

	uint8 getSkillLevel(int16 id) {
		return skill(id) / kSkillFracPointsPerLevel + 1;
	}

	void read(Common::InSaveFile *in) {
		archery = in->readByte();
		swordcraft = in->readByte();
		shieldcraft = in->readByte();
		bludgeon = in->readByte();
		throwing = in->readByte();
		spellcraft = in->readByte();
		stealth = in->readByte();
		agility = in->readByte();
		brawn = in->readByte();
		lockpick = in->readByte();
		pilfer = in->readByte();
		firstAid = in->readByte();
		spotHidden = in->readByte();
		pad = in->readSByte();
		vitality = in->readSint16LE();
		redMana = in->readSint16LE();
		orangeMana = in->readSint16LE();
		yellowMana = in->readSint16LE();
		greenMana = in->readSint16LE();
		blueMana = in->readSint16LE();
		violetMana = in->readSint16LE();
	}

	void write(Common::MemoryWriteStreamDynamic *out) {
		out->writeByte(archery);
		out->writeByte(swordcraft);
		out->writeByte(shieldcraft);
		out->writeByte(bludgeon);
		out->writeByte(throwing);
		out->writeByte(spellcraft);
		out->writeByte(stealth);
		out->writeByte(agility);
		out->writeByte(brawn);
		out->writeByte(lockpick);
		out->writeByte(pilfer);
		out->writeByte(firstAid);
		out->writeByte(spotHidden);
		out->writeSByte(pad);
		out->writeSint16LE(vitality);
		out->writeSint16LE(redMana);
		out->writeSint16LE(orangeMana);
		out->writeSint16LE(yellowMana);
		out->writeSint16LE(greenMana);
		out->writeSint16LE(blueMana);
		out->writeSint16LE(violetMana);
	}
};  // 28 bytes


const int kBaseCarryingCapacity = 100;
const int kCarryingCapacityBonusPerBrawn = 200 / ActorAttributes::kSkillLevels;

/* ===================================================================== *
   ResourceActorProtoExtension structure
 * ===================================================================== */

enum combatBehaviorTypes {
	kBehaviorHungry,
	kBehaviorCowardly,
	kBehaviorBerserk,
	kBehaviorSmart
};

//  This defines the additional data fields needed for actor prototypes
struct ResourceActorProtoExtension {

	ActorAttributes     baseStats;  //  Base stats for non-player actors

	//  Defines behavior for combat tactics.
	uint8               combatBehavior;
	uint8               gruntStyle;

	uint32              baseEffectFlags;    // special effects, see EFFECTS.H

	//  Default constructor -- do nothing
	ResourceActorProtoExtension() {
		memset(&baseStats, 0, sizeof(baseStats));

		combatBehavior = 0;
		gruntStyle = 0;
		baseEffectFlags = 0;
	}

	//  Copy constructor
	ResourceActorProtoExtension(ResourceActorProtoExtension &ext) {
		memcpy(this, &ext, sizeof(ResourceActorProtoExtension));
	}

	void load(Common::SeekableReadStream *stream) {
		baseStats.read(stream);
		combatBehavior = stream->readByte();
		gruntStyle = stream->readByte();
		baseEffectFlags = stream->readUint32LE();
	}
};  // 28 bytes

/* ===================================================================== *
   ResourceActorPrototype structure
 * ===================================================================== */

//  Defines the actor prototype data as read from the resource file
struct ResourceActorPrototype {
	ResourceObjectPrototype         proto;  //  Standard prototype data
	ResourceActorProtoExtension     ext;    //  Extended actor data

	void load(Common::SeekableReadStream *stream) {
		proto.load(stream);
		ext.load(stream);
	}
};

/* ===================================================================== *
   ActorProto prototype behavior for Actors
 * ===================================================================== */

class ActorProto : public ProtoObj, public ResourceActorProtoExtension {

private:
	enum {
		kViewableRows    = 3,
		kViewableCols    = 3,
		kMaxRows         = 3,
		kMaxCols         = 3
	};

public:
	ActorProto(ResourceActorPrototype &a) :
		ProtoObj(a.proto),
		ResourceActorProtoExtension(a.ext) {
	}

	// returns the containment type flags for this object
	virtual uint16 containmentSet();

	//  returns true if this object can contain another object
	virtual bool canContain(ObjectID dObj, ObjectID item);

	//  Determine if this object can contain another object at a
	//  specified slot
	virtual bool canContainAt(
	    ObjectID dObj,
	    ObjectID item,
	    const TilePoint &where);

	weaponID getWeaponID();

	//  use this actor
	bool useAction(ObjectID dObj, ObjectID enactor);

	//  open this actor
	bool canOpen(ObjectID dObj, ObjectID enactor);
	bool openAction(ObjectID dObj, ObjectID enactor);

	//  close this actor
	bool closeAction(ObjectID dObj, ObjectID enactor);

	bool strikeAction(
	    ObjectID dObj,
	    ObjectID enactor,
	    ObjectID item);

	bool damageAction(
	    ObjectID dObj,
	    ObjectID enactor,
	    ObjectID target);

	//  drop another object onto this actor.
	bool acceptDropAction(
	    ObjectID dObj,
	    ObjectID enactor,
	    ObjectID droppedObj,
	    int count);

	//  cause damage directly
	bool acceptDamageAction(
	    ObjectID            dObj,
	    ObjectID            enactor,
	    int8                absDamage,
	    effectDamageTypes   dType,
	    int8                dice,
	    uint8               sides,
	    int8                perDieMod);

	//  cause healing directly
	bool acceptHealingAction(ObjectID dObj, ObjectID enactor, int8 healing);

	//  Accept strike from an object (allows this actor to cause
	//  damage to the striking object).
	bool acceptStrikeAction(
	    ObjectID            dObj,
	    ObjectID            enactor,
	    ObjectID            strikingObj,
	    uint8               skillIndex);

	//  Handle the results of an object being inserted into this object
	//  at the specified slot
	bool acceptInsertionAtAction(
	    ObjectID        dObj,
	    ObjectID        enactor,
	    ObjectID        item,
	    const TilePoint &where,
	    int16           num = 1);

	//  Initiate an attack using this type of object
	virtual void initiateAttack(ObjectID attacker, ObjectID target);

	//  Given an object sound effect record, which sound should be made
	//  when this object is damaged
	virtual uint8 getDamageSound(const ObjectSoundFXs &soundFXs);

	//  Do the background processing, if needed, for this object.
	void doBackgroundUpdate(GameObject *obj);

	//  Cause the user's associated skill to grow
	void applySkillGrowth(ObjectID enactor, uint8 points = 1);

	bool greetActor(
	    ObjectID        dObj,                   // object dropped on
	    ObjectID        enactor);               // person doing dropping

public:
	virtual uint16 getViewableRows() {
		return kViewableRows;
	}
	virtual uint16 getViewableCols() {
		return kViewableCols;
	}
	virtual uint16 getMaxRows() {
		return kMaxRows;
	}
	virtual uint16 getMaxCols() {
		return kMaxCols;
	}

	virtual bool canFitBulkwise(GameObject *container, GameObject *obj);
	virtual bool canFitMasswise(GameObject *container, GameObject *obj);

	virtual uint16 massCapacity(GameObject *container);
	virtual uint16 bulkCapacity(GameObject *container);
};

/* ============================================================================ *
   Actor: Describes an instance of a character
 * ============================================================================ */

enum actorCreationFlags {
	kActorPermanent = (1 << 0)
};

enum DispositionType {
	kDispositionFriendly,
	kDispositionEnemy,

	kDispositionPlayer
};

enum actionSequenceOptions {

	//  Flags set by call to setAction
	kAnimateRepeat    = (1 << 0),            // repeat animation when done
	kAnimateReverse   = (1 << 1),            // animate in reverse direction
	kAnimateAlternate = (1 << 2),            // both directions, back & forth
	kAnimateRandom    = (1 << 3),            // pick a random frame
	kAnimateNoRestart = (1 << 4),            // don't reset from start

	//  This flag is set if the animation has been put on hold until
	//  the actor's appearance is reloaded.
	kAnimateOnHold   = (1 << 5),

	//  This flag is set if the final frame of the animation has
	//  been reached.
	kAnimateFinished = (1 << 6),

	//  This flag gets set if the sprite could not be displayed
	//  because it's bank hasn't been loaded yet.
	kAnimateNotLoaded = (1 << 7)
};

//  Various types of action sequences


enum ActorAnimationTypes {

	//  Various types of stands
	kActionStand = 0,                        // standing still
	kActionWaitAgressive,                    // an agigressive wait cycle
	kActionWaitImpatient,                    // an impatient wait cycle
	kActionWaitFriendly,                     // a a friendly wait cycle

	//  Walking and running
	kActionWalk,                             // walking motion
	kActionRun,                              // running motion

	//  Squatting
	kActionDuck,                             // stoop to dodge sword
	kActionStoop,                            // stoop to pick up object

	//  Jumping
	kActionFreeFall,                         // how he looks in ballistic
	kActionFreeFallRunning,                  // a running leap (free fall)
	kActionJumpUp,                           // begin jump straight up
	kActionJumpFwd,                          // begin jump forward
	kActionJumpBack,                         // begin jump back in surprise
	kActionLand,                             // land after jump
	kActionFallBadly,                        // after a very long fall

	//  Climbing
	kActionClimbLadder,                      // climb a ladder (2 directions)

	//  Talking & interacting
	kActionTalk,                             // talking
	kActionGesture,                          // gesture with hands or body
	kActionGiveItem,                         // give or take item

	//  Two-handed weapon use
	kActionTwoHandSwingHigh,                 // full overhead swing aim high
	kActionTwoHandSwingLow,                  // full overhead swing aim low
	kActionTwoHandSwingLeftHigh,             // partial swing on left (high)
	kActionTwoHandSwingLeftLow,              // partial swing on left (low)
	kActionTwoHandSwingRightHigh,            // partial swing on rgt (high)
	kActionTwoHandSwingRightLow,             // partial swing on rgt (low)
	kActionTwoHandParry,                     // hold sword up to parry

	//  One-handed weapon use
	kActionSwingHigh,                        // one-handed swing (high)
	kActionSwingLow,                         // one-handed swing (low)
	kActionParryHigh,                        // one-handed parry (high)
	kActionParryLow,                         // one-handed parry (low)
	kActionShieldParry,                      // parry with shield

	kActionThrowObject,                      // throw

	//  Other combat actions
	kActionFireBow,                          // fire an arrow
	kActionCastSpell,                        // cast a magic spell
	kActionUseWand,                          // cast a magic spell w/wand
	kActionUseStaff,                         // cast a magic spell w/staff
	kActionHit,                              // show impact of blow
	kActionKnockedDown,                      // knocked down by opponent
	kActionDie,                              // death agony

	//  Passive actions
	kActionSleep,                            // sleeping
	kActionDead,                             // dead body on ground
	kActionSit,                              // sitting at table

	//  Misc actions built from other frames
	kActionListenAtDoor,                     // listening at doors
	kActionShoveDoor,                        // try to force a door open
	kActionSpecial1,                         // special Action
	kActionSpecial2,                         // special Action
	kActionSpecial3,                         // special Action
	kActionSpecial4,                         // special Action
	kActionSpecial5,                         // special Action
	kActionSpecial6,                         // special Action
	kActionSpecial7,                         // special Action
	kActionSpecial8                          // special Action
};

enum ActorGoalTypes {
	kActorGoalFollowAssignment,
	kActorGoalPreserveSelf,
	kActorGoalAttackEnemy,
	kActorGoalFollowLeader,
	kActorGoalAvoidEnemies
};

//  The actor structure will be divided into two parts.  The
//  ResourceActor structure defines the data as it is stored in the
//  resource file.  The Actor structure has a copy of all of the
//  ResourceActor data members, plus data members which will be
//  initialized and used during run time.

struct ResourceActor : public ResourceGameObject {

	//  Social loyalty
	uint8           faction;                // actor's faction

	//  Appearance attribute
	uint8           colorScheme;            // indirect color map

	int32           appearanceID;           // appearnce of this actor

	//  Personality attributes
	int8            attitude,               // cooperativeness
	                mood;                   // happiness
	uint8           disposition;            // actor disposition
	// 0 = friendly, 1 = enemy,
	// 2 = Julian, 3 = Philip,
	// 4 = Kevin

	//  Character orientation
	Direction       currentFacing;          // current facing direction

	//  Tether info
	int16           tetherLocU;             // tether U coordinate
	int16           tetherLocV;             // tether V coordinate
	int16           tetherDist;             // length of tether

	//  Held objects
	ObjectID        leftHandObject,         // object held in left hand.
	                rightHandObject;        // object held in right hand.

	//  Knowledge packets
	uint16          knowledge[16];

	//  Schedule script ID
	uint16          schedule;

	//  Pad bytes
	uint8           reserved[18];

	ResourceActor(Common::SeekableReadStream *stream);
};

class Actor : public GameObject {
	friend class    ActorProto;
	friend class    MotionTask;
	friend class    Task;
	friend class    TaskStack;

public:

	//  Resource fields

	//  Social loyalty
	uint8           _faction;                // actor's faction

	//  Appearance attribute
	uint8           _colorScheme;            // indirect color map

	int32           _appearanceID;           // appearnce of this actor

	//  Personality attributes
	int8            _attitude,               // cooperativeness
	                _mood;                   // happiness
	uint8           _disposition;            // actor disposition
	// 0 = friendly, 1 = enemy,
	// 2 = Julian, 3 = Philip,
	// 4 = Kevin

	//  Character orientation
	Direction       _currentFacing;          // current facing direction

	//  Tether info
	int16           _tetherLocU;             // tether U coordinate
	int16           _tetherLocV;             // tether V coordinate
	int16           _tetherDist;             // length of tether

	//  Held objects
	ObjectID        _leftHandObject,         // object held in left hand.
	                _rightHandObject;        // object held in right hand.

	//  Knowledge packets
	uint16          _knowledge[16];

	//  Schedule script ID
	uint16          _schedule;

	//  Run-time fields

	uint8           _conversationMemory[4];// last things talked about

	//  Sprite animation variables
	uint8           _currentAnimation,       // current action sequence
	                _currentPose,            // current pose in sequence
	                _animationFlags;         // current posing flags

	//  Various actor flags
	enum {
		kAFLobotomized     = (1 << 0),
		kAFTemporary       = (1 << 1),
		kAFAfraid          = (1 << 2),
		kAFHasAssignment   = (1 << 3),
		kAFSpecialAttack   = (1 << 4),
		kAFFightStance     = (1 << 5)
	};

	uint8           _flags;

	//  Contains sprite index and positioning info for the current
	//  actor state.
	ActorPose       _poseInfo;               // current animation state

	//  Pointer to the appearance record (sprite array) for this actor.
	ActorAppearance *_appearance;            // appearance structs

	int16           _cycleCount;             // misc counter for actions
	int16           _kludgeCount;            // another misc counter

	uint32          _enchantmentFlags;       // flags indicating racial
	// abilities and enchantments

	//  Movement attributes
	MotionTask      *_moveTask;

	//  Current task
	TaskStack       *_curTask;

	//  Current goal type
	uint8           _currentGoal;

	//  Used for deltayed deactivation (and also to word-align struct)
	uint8           _deactivationCounter;

	//  Assignment
	ActorAssignment *_assignment;
	// assignments

	//  Current effective stats
	ActorAttributes _effectiveStats;

	uint8           _actionCounter;          //  coordinate moves in combat

	uint16          _effectiveResistance;    // resistances (see EFFECTS.H)
	uint16          _effectiveImmunity;      // immunities  (see EFFECTS.H)

	int16           _recPointsPerUpdate;     // fractional vitality recovery

	int16           _currentRecoveryPoints;  // fraction left from last recovery

	enum vitalityRecovery {
		kRecPointsPerVitality        = 10
	};


	Actor           *_leader;                // This actor's leader
	ObjectID        _leaderID;
	Band            *_followers;             // This actor's band of followers
	BandID          _followersID;

	ObjectID        _armorObjects[ARMOR_COUNT];    //  armor objects being worn

	GameObject      *_currentTarget;
	ObjectID        _currentTargetID;

	int16           _scriptVar[kActorScriptVars];   //  scratch variables for scripter use

	//  Member functions

private:
	//  Initialize actor record
	void init(
	    int16   protoIndex,
	    uint16  nameIndex,
	    uint16  scriptIndex,
	    int32   appearanceNum,
	    uint8   colorSchemeIndex,
	    uint8   factionNum,
	    uint8   initFlags);

public:
	//  Default constructor
	Actor();

	//  Constructor - initial actor construction
	Actor(const ResourceActor &res);

	Actor(Common::InSaveFile *in);

	//  Destructor
	~Actor();

	//  Return the number of bytes needed to archive this actor
	int32 archiveSize();

	void write(Common::MemoryWriteStreamDynamic *out);

	static Actor *newActor(
	    int16   protoNum,
	    uint16  nameIndex,
	    uint16  scriptIndex,
	    int32   appearanceNum,
	    uint8   colorSchemeIndex,
	    uint8   factionNum,
	    uint8   initFlags);

	//  Delete this actor
	void deleteActor();

private:
	//  Turn incrementally
	void turn(Direction targetDir) {
		Direction   relativeDir = (targetDir - _currentFacing) & 0x7;

		_currentFacing =
		    (relativeDir < 4
		     ?   _currentFacing + 1
		     :   _currentFacing - 1)
		    &   0x7;
	}
public:

	//  Cause the actor to stop his current motion task is he is
	//  interruptable
	void stopMoving();

	//  Cause this actor to die
	void die();

	//  Cause this actor to return from the dead
	void imNotQuiteDead();

	// makes the actor do a vitality change test
	void vitalityUpdate();

	//  Perform actor specific activation tasks
	void activateActor();

	//  Perform actor specific deactivation tasks
	void deactivateActor();

	//  De-lobotomize this actor
	void delobotomize();

	//  Lobotomize this actor
	void lobotomize();

	//  Return a pointer to the actor's current assignment
	ActorAssignment *getAssignment() {
		return  _flags & kAFHasAssignment
		        ? _assignment
		        : nullptr;
	}

	//  determine whether this actor has a specified property
	bool hasProperty(const ActorProperty &actorProp) {
		//  The function call operator is used explicitly because
		//  Visual C++ 4.0 doesn't like it otherwise.
		return actorProp.operator()(this);
	}

	//  Determine if specified point is within actor's arms' reach
	bool inReach(const TilePoint &tp);

	//  Determine if specified point is within an objects use range
	bool inUseRange(const TilePoint &tp, GameObject *obj);

	//  Determine if actor is dead
	bool isDead() {
		return _effectiveStats.vitality <= 0;
	}

	//  Determine if actor is immobile (i.e. can't walk)
	bool isImmobile();

	//  Return a pointer to this actor's currently readied offensive
	//  object
	GameObject *offensiveObject();

	//  Returns pointers to this actor's readied primary defensive object
	//  and optionally their scondary defensive object
	void defensiveObject(GameObject **priPtr, GameObject **secPtr = NULL);

	//  Returns a pointer to the object with which this actor is
	//  currently blocking, if any
	GameObject *blockingObject(Actor *attacker);

	//  Return the total used armor attributes
	void totalArmorAttributes(ArmorAttributes &armorAttribs);

	//  Determine if specified point is within actor's attack range
	bool inAttackRange(const TilePoint &tp);

	//  Attack the specified object with the currently selected weapon
	void attack(GameObject *obj);

	//  Stop any attack on the specified object
	void stopAttack(GameObject *obj);

	//  Determine if this actor can block an attack with objects
	//  currently being held
	bool canDefend();

	//  Return a numeric value which roughly estimates this actor's
	//  offensive strength
	int16 offenseScore();

	//  Return a numeric value which roughly estimates this actor's
	//  defensive strength
	int16 defenseScore();

	//  Handle the effect of a successful hit on an opponent in combat
	void handleSuccessfulStrike(GameObject *weapon) {
		weapon->proto()->applySkillGrowth(thisID());
	}

	//  Return the value of this actor's disposition
	int16 getDisposition() {
		return _disposition;
	}

	//  Give the actor a new disposition
	int16 setDisposition(int16 newDisp) {
		int16   oldDisp = _disposition;
		if (newDisp < kDispositionPlayer)
			_disposition = newDisp;
		return oldDisp;
	}

	//  Return a pointer to the effective stats
	ActorAttributes *getStats() {
		return &_effectiveStats;
	}

	//  Return a pointer to this actor's base stats
	ActorAttributes *getBaseStats();

	//  Return the color remapping table
	void getColorTranslation(ColorTable map);

	//  Determine if this actor is interruptable
	bool isInterruptable() {
		return _actionCounter == 0;
	}

	//  Determine if this actor is permanently uninterruptable
	bool isPermanentlyUninterruptable() {
		return _actionCounter == maxuint8;
	}

	//  Set the inturruptability for this actor
	void setInterruptablity(bool val) {
		_actionCounter = val ? 0 : maxuint8;
	}

	//  Set action time counter for this actor
	//  REM: the action points will eventually need to be scaled based
	//  upon enchantments and abilities
	void setActionPoints(uint8 points) {
		_actionCounter = points;
	}

	//  Drop the all of the actor's inventory
	void dropInventory();

	//  Place an object into this actor's right or left hand
	void holdInRightHand(ObjectID objID);
	void holdInLeftHand(ObjectID objID);

	//  Wear a piece of armor
	void wear(ObjectID objID, uint8 where);

	//  Update the appearance of an actor with no motion task.
	void updateAppearance(int32 deltaTime);

	//  Used To Find Wait State When Preffered Not Available
	bool setAvailableAction(int16 action1, int16 action2, int16 action3, int16 actiondefault);

	//  Set the current animation sequence that the actor is doing.
	//  Returns the number of poses in the sequence, or 0 if there
	//  are no poses in the sequence.
	int16 setAction(int16 newState, int16 flags);

	//  returns true if the action is available in the current
	//  direction.
	bool isActionAvailable(int16 newState, bool anyDir = false);

	//  Return the number of animation frames in the specified action
	//  for the specified direction
	int16 animationFrames(int16 actionType, Direction dir);

	//  Update the current animation sequence to the next frame
	bool nextAnimationFrame();

	//  calculate which sprite frames to show. Return false if
	//  sprite frames are not loaded.
	bool calcSpriteFrames();

	//  Calculate the frame list entry, given the current actor's
	//  body state, and facing direction.
//	FrameListEntry   *calcFrameState( int16 bodyState );

	//  Returns 0 if not moving, 1 if path being calculated,
	//  2 if path being followed.
	int pathFindState();

	//  High level actor behavior functions
private:
	void setGoal(uint8 newGoal);

public:
	void evaluateNeeds();

	//  Called every frame to update the state of this actor
	void updateState();

	void handleTaskCompletion(TaskResult result);
	void handleOffensiveAct(Actor *attacker);
	void handleDamageTaken(uint8 damage);
	void handleSuccessfulStrike(Actor *target, int8 damage);
	void handleSuccessfulKill(Actor *target);

private:
	static bool canBlockWith(GameObject *defenseObj, Direction relativeDir);
public:
	void evaluateMeleeAttack(Actor *attacker);

	//  Banding related functions
	void bandWith(Actor *newLeader);
	void disband();

	bool inBandingRange() {
		assert(_leader != NULL);

		return      _leader->IDParent() == IDParent()
		            && (_leader->getLocation() - getLocation()).quickHDistance()
		            <=  kBandingDist;
	}

private:
	bool addFollower(Actor *newBandMember);
	void removeFollower(Actor *bandMember);

	TaskStack *createFollowerTask(Actor *bandMember);
	uint8 evaluateFollowerNeeds(Actor *follower);

public:
	//  Knowledge-related member functions
	bool addKnowledge(uint16 kID);
	bool removeKnowledge(uint16 kID);
	void clearKnowledge();
	void useKnowledge(scriptCallFrame &scf);

	bool canSenseProtaganistIndirectly(SenseInfo &info, int16 range);
	bool canSenseSpecificActorIndirectly(
	    SenseInfo           &info,
	    int16               range,
	    Actor               *a);
	bool canSenseSpecificObjectIndirectly(
	    SenseInfo           &info,
	    int16               range,
	    ObjectID            obj);
	bool canSenseActorPropertyIndirectly(
	    SenseInfo           &info,
	    int16               range,
	    ActorPropertyID     prop);
	bool canSenseObjectPropertyIndirectly(
	    SenseInfo           &info,
	    int16               range,
	    ObjectPropertyID    prop);

	// Take mana from actor's mana pool (if possible)
	bool takeMana(ActorManaID i, int8 dMana);

	bool hasMana(ActorManaID i, int8 dMana);

	uint32 getBaseEnchantmentEffects();
	uint16 getBaseResistance();
	uint16 getBaseImmunity();
	uint16 getBaseRecovery();

	bool resists(effectResistTypes r) {
		return _effectiveResistance & (1 << r);
	}
	bool isImmuneTo(effectImmuneTypes r) {
		return _effectiveImmunity & (1 << r);
	}
	bool hasEffect(effectOthersTypes e) {
		return (_enchantmentFlags & (1 << e)) != 0;
	}

	void setResist(effectResistTypes r, bool on) {
		_effectiveResistance = on ?
		                      _effectiveResistance | (1 << r) :
		                      _effectiveResistance & ~(1 << r);
	}

	void setImmune(effectImmuneTypes r, bool on) {
		_effectiveImmunity = on ?
		                    _effectiveImmunity | (1 << r) :
		                    _effectiveImmunity & ~(1 << r);
	}

	void setEffect(effectOthersTypes e, bool on) {
		_enchantmentFlags = on ?
		                   _enchantmentFlags | (1 << e) :
		                   _enchantmentFlags & ~(1 << e);
	}

	bool makeSavingThrow();

	void setFightStance(bool val) {
		if (val)
			_flags |= kAFFightStance;
		else
			_flags &= ~kAFFightStance;
	}
};

inline bool isPlayerActor(Actor *a) {
	return a->_disposition >= kDispositionPlayer;
}

inline bool isPlayerActor(ObjectID obj) {
	return  isActor(obj)
	        &&  isPlayerActor((Actor *)GameObject::objectAddress(obj));
}

inline bool isEnemy(Actor *a) {
	return !a->isDead() && a->_disposition == kDispositionEnemy;
}

inline bool isEnemy(ObjectID obj) {
	return  isActor(obj)
	        &&  isEnemy((Actor *)GameObject::objectAddress(obj));
}

void updateActorStates();

void pauseActorStates();
void resumeActorStates();

void setCombatBehavior(bool enabled);

//  Determine if the actors are currently initialized
bool areActorsInitialized();

void clearEnchantments(Actor *a);
void addEnchantment(Actor *a, uint16 enchantmentID);

/* ============================================================================ *
   Actor factions table
 * ============================================================================ */

enum factionTallyTypes {
	kFactionNumKills = 0,            // # of times faction member killed by PC
	kFactionNumThefts,               // # of times PC steals from faction member
	kFactionNumFavors,               // accumulated by SAGA script.

	kFactionNumColumns
};

//  Get the attitude a particular faction has for a char.
int16 GetFactionTally(int faction, enum factionTallyTypes act);

//  Increment / Decrement faction attitude
//  Whenever an actor is killed, call:
//      AddFactionAttitude( actor.faction, kFactionNumKills, 1 );
//  Whenever an actor is robbed, call:
//      AddFactionAttitude( actor.faction, kFactionNumThefts, 1 );
int16 AddFactionTally(int faction, enum factionTallyTypes act, int amt);

//  Initialize the faction tally table
void initFactionTallies();

//  Save the faction tallies to a save file
void saveFactionTallies(Common::OutSaveFile *outS);

//  Load the faction tallies from a save file
void loadFactionTallies(Common::InSaveFile *in);

//  Cleanup the faction tally table
inline void cleanupFactionTallies() { /* Nothing to do */ }

class ActorManager {
public:

	enum {
		kEvalRate = 8,
		kEvalRateMask = kEvalRate - 1
	};

	Common::Array<Actor *> _actorList;

	int32 _updatesViaScript;
	int32 _baseActorIndex;
	int16 _factionTable[kMaxFactions][kFactionNumColumns];
	bool _actorStatesPaused;
	bool _combatBehaviorEnabled;

	ActorManager() {
		_updatesViaScript = 0;
		_baseActorIndex = kEvalRateMask;

		memset(_factionTable, 0, sizeof(_factionTable));

		_actorStatesPaused = false;
		_combatBehaviorEnabled = false;
	}
};

} // end of namespace Saga2

#endif