task.h

/* 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_TASK_H
#define SAGA2_TASK_H

#include "saga2/target.h"
#include "saga2/patrol.h"

namespace Saga2 {

const   int     kDefaultEvalRate = 10;

const   size_t  kMaxTaskSize = 48;

//  Integers representing task types
enum TaskType {
    kWanderTask,
    kTetheredWanderTask,
    kGotoLocationTask,
    kGotoRegionTask,
    kGotoObjectTask,
    kGotoActorTask,
    kGoAwayFromObjectTask,
    kGoAwayFromActorTask,
    kHuntToBeNearLocationTask,
    kHuntToBeNearObjectTask,
    kHuntToPossessTask,
    kHuntToBeNearActorTask,
    kHuntToKillTask,
    kHuntToGiveTask,
    kBandTask,
    kBandAndAvoidEnemiesTask,
    kFollowPatrolRouteTask,
    kAttendTask
};

/* ===================================================================== *
   Function prototypes
 * ===================================================================== */

class Task;
class TaskStack;

//  Run through the active task stacks, updating each
void updateActorTasks();

void pauseActorTasks();
void resumeActorTasks();

//  Allocate a new task stack
TaskStack *newTaskStack(Actor *a);
void newTaskStack(TaskStack *p);

//  Dispose of a previously allocated task stack
void deleteTaskStack(TaskStack *p);

//  Return the ID number of a specified task stack
TaskStackID getTaskStackID(TaskStack *ts);

//  Return a pointer to a TaskStack given a TaskStackID
TaskStack *getTaskStackAddress(TaskStackID id);

//  Initialize the task stack list
void initTaskStacks();

void saveTaskStacks(Common::OutSaveFile *outS);
void loadTaskStacks(Common::InSaveFile *in, int32 chunkSize);

//  Cleanup the task stacks
void cleanupTaskStacks();


void newTask(Task *t);
void newTask(Task *t, TaskID id);

//  Dispose of a previously allocated task
void deleteTask(Task *p);

//  Return a task's ID number
TaskID getTaskID(Task *t);

//  Return a pointer to a Task given a TaskID
Task *getTaskAddress(TaskID id);

//  Initialize the task list
void initTasks();

void saveTasks(Common::OutSaveFile *outS);
void loadTasks(Common::InSaveFile *in, int32 chunkSize);

//  Cleanup the task list
void cleanupTasks();

/* ===================================================================== *
   Task Class
 * ===================================================================== */

//  This is the base class for all Task classes
class Task {
    friend class TaskStack;

protected:
    //  A pointer to this task's stack
    TaskStack   *_stack;
    TaskStackID _stackID;

public:
    Common::String _type;

    //  Constructor -- initial construction
    Task(TaskStack *ts) : _stack(ts), _stackID(NoTaskStack) {
        newTask(this);
    }

    Task(TaskStack *ts, TaskID id) : _stack(ts) {
        newTask(this, id);
    }

    Task(Common::InSaveFile *in, TaskID id);

    //  Virtual destructor -- do nothing
    virtual ~Task() {
        deleteTask(this);
    }

    //  Fixup any subtask pointers
    virtual void fixup();

    //  Return the number of bytes necessary to archive this Task
    //  in a buffer
    virtual int32 archiveSize() const;

    virtual void write(Common::MemoryWriteStreamDynamic *out) const;

    //  Return an integer representing the type of this task
    virtual int16 getType() const = 0;

    virtual void abortTask() = 0;
    virtual TaskResult evaluate() = 0;
    virtual TaskResult update() = 0;

    //  Determine if the specified task is equivalent to this task
    virtual bool operator == (const Task &t) const = 0;
    bool operator != (const Task &t) const {
        return !operator == (t);
    }
};

/* ===================================================================== *
   WanderTask Class
 * ===================================================================== */

//  This class is basically a shell around the wander motion task
class WanderTask : public Task {
protected:
    bool            _paused;         //  Flag indicating "paused"ness of this task
    int16           _counter;        //  Counter for tracking pause length

public:
    //  Constructor
    WanderTask(TaskStack *ts) : Task(ts) {
        debugC(2, kDebugTasks, " - WanderTask");
        _type = "WanderTask";
        wander();
    }

    WanderTask(Common::InSaveFile *in, TaskID id);

    //  Return the number of bytes needed to archive this object in
    //  a buffer
    int32 archiveSize() const;

    void write(Common::MemoryWriteStreamDynamic *out) const;

    //  Return an integer representing the type of this task
    int16 getType() const;

    void abortTask();
    TaskResult evaluate();
    TaskResult update();

    //  Determine if the specified task is equivalent to this task
    bool operator == (const Task &t) const;

protected:
    //  Update function used while task is not paused
    virtual TaskResult handleWander();

    //  Update function used while task is paused
    TaskResult handlePaused() {
        return kTaskNotDone;
    }

    //  Set this task into the paused state
    void pause();

    //  Set this task into the wander state
    void wander();
};

/* ===================================================================== *
   TetheredWanderTask Class
 * ===================================================================== */

class GotoRegionTask;

//  This class is basically a shell around the tethered wander
//  motion task
class TetheredWanderTask : public WanderTask {
    //  Tether coordinates
    int16           _minU,
                    _minV,
                    _maxU,
                    _maxV;

    //  Pointer to subtask for going to the tether region
    GotoRegionTask  *_gotoTether;
    TaskID _gotoTetherID;

public:
    //  Constructor
    TetheredWanderTask(
        TaskStack *ts,
        int16 uMin,
        int16 vMin,
        int16 uMax,
        int16 vMax) :
        WanderTask(ts),
        _minU(uMin),
        _minV(vMin),
        _maxU(uMax),
        _maxV(vMax),
        _gotoTether(NULL),
        _gotoTetherID(NoTask) {
        debugC(2, kDebugTasks, " - TetheredWanderTask");
        _type = "TetheredWanderTask";
    }

    TetheredWanderTask(Common::InSaveFile *in, TaskID id);

    //  Fixup the subtask pointers
    void fixup();

    //  Return the number of bytes needed to archive this object in
    //  a buffer
    int32 archiveSize() const;

    void write(Common::MemoryWriteStreamDynamic *out) const;

    //  Return an integer representing the type of this task
    int16 getType() const;

    void abortTask();

    //  Determine if the specified task is equivalent to this task
    bool operator == (const Task &t) const;

    //  Update function used while task is not paused
    TaskResult handleWander();
};

/* ===================================================================== *
   GotoTask Class
 * ===================================================================== */

class GotoTask : public Task {
    WanderTask  *_wander;
    TaskID _wanderID;
    bool        _prevRunState;

public:
    //  Constructor -- initial construction
    GotoTask(TaskStack *ts) :
        Task(ts),
        _wander(NULL),
        _wanderID(NoTask),
        _prevRunState(false) {
        debugC(2, kDebugTasks, " - GotoTask");
        _type = "GotoTask";
    }

    GotoTask(Common::InSaveFile *in, TaskID id);

    //  Fixup the subtask pointer
    void fixup();

    //  Return the number of bytes needed to archive this object in
    //  a buffer
    int32 archiveSize() const;

    void write(Common::MemoryWriteStreamDynamic *out) const;

    void abortTask();
    TaskResult evaluate();
    TaskResult update();

private:
    virtual TilePoint destination() = 0;
    virtual TilePoint intermediateDest() = 0;
    virtual bool lineOfSight() = 0;
    virtual bool run() = 0;
};

/* ===================================================================== *
   GotoLocationTask Class
 * ===================================================================== */

class GotoLocationTask : public GotoTask {
    TilePoint   _targetLoc;
    uint8       _runThreshold;

public:
    //  Constructor -- initial construction
    GotoLocationTask(
        TaskStack       *ts,
        const TilePoint &tp,
        uint8           runDist = maxuint8) :
        GotoTask(ts),
        _targetLoc(tp),
        _runThreshold(runDist) {
        debugC(2, kDebugTasks, " - GotoLocationTask");
        _type = "GotoLocationTask";
    }

    GotoLocationTask(Common::InSaveFile *in, TaskID id);

    //  Return the number of bytes needed to archive this object in
    //  a buffer
    int32 archiveSize() const;

    void write(Common::MemoryWriteStreamDynamic *out) const;

    //  Return an integer representing the type of this task
    int16 getType() const;

    //  Determine if the specified task is equivalent to this task
    bool operator == (const Task &t) const;

    const TilePoint getTarget() const {
        return _targetLoc;
    }

    void changeTarget(const TilePoint &newTarget) {
        _targetLoc = newTarget;
    }

private:
    TilePoint destination();
    TilePoint intermediateDest();
    bool lineOfSight();
    bool run();
};

/* ===================================================================== *
   GotoRegionTask Class
 * ===================================================================== */

class GotoRegionTask : public GotoTask {
    int16       _regionMinU,
                _regionMinV,
                _regionMaxU,
                _regionMaxV;

public:
    //  Constructor -- initial construction
    GotoRegionTask(
        TaskStack *ts,
        int16 minU,
        int16 minV,
        int16 maxU,
        int16 maxV) :
        GotoTask(ts),
        _regionMinU(minU),
        _regionMinV(minV),
        _regionMaxU(maxU),
        _regionMaxV(maxV) {
        debugC(2, kDebugTasks, " - GotoRegionTask");
        _type = "GotoRegionTask";
    }

    GotoRegionTask(Common::InSaveFile *in, TaskID id);

    //  Return the number of bytes needed to archive this object in
    //  a buffer
    int32 archiveSize() const;

    void write(Common::MemoryWriteStreamDynamic *out) const;

    //  Return an integer representing the type of this task
    int16 getType() const;

    //  Determine if the specified task is equivalent to this task
    bool operator == (const Task &t) const;

private:
    TilePoint destination();
    TilePoint intermediateDest();
    bool lineOfSight();
    bool run();
};

/* ===================================================================== *
   GotoObjectTargetTask Class
 * ===================================================================== */

class GotoObjectTargetTask : public GotoTask {
    TilePoint           _lastTestedLoc;
    int16               _sightCtr;

    uint8               _flags;

    enum {
        kTrack       = (1 << 0),
        kInSight     = (1 << 1)
    };

    //  static const doesn't work in Visual C++
    enum {
        kSightRate = 16
    };
//  static const int16  sightRate = 16;

protected:
    TilePoint           _lastKnownLoc;

public:
    //  Constructor -- initial construction
    GotoObjectTargetTask(TaskStack *ts, bool trackFlag) :
        GotoTask(ts),
        _lastTestedLoc(Nowhere),
        _sightCtr(0),
        _flags(trackFlag ? kTrack : 0),
        _lastKnownLoc(Nowhere) {
        debugC(2, kDebugTasks, " - GotoObjectTargetTask");
        _type = "GotoObjectTargetTask";
    }

    GotoObjectTargetTask(Common::InSaveFile *in, TaskID id);

    //  Return the number of bytes needed to archive this object in
    //  a buffer
    int32 archiveSize() const;

    void write(Common::MemoryWriteStreamDynamic *out) const;

private:
    TilePoint destination();
    TilePoint intermediateDest();
    bool lineOfSight();

    virtual GameObject *getObject() = 0;

protected:
    bool tracking() const {
        return (_flags & kTrack) != 0;
    }
    bool isInSight() const {
        return (_flags & kInSight) != 0;
    }
};

//const int16 GotoObjectTargetTask::sightRate = 16;

/* ===================================================================== *
   GotoObjectTask Class
 * ===================================================================== */

class GotoObjectTask : public GotoObjectTargetTask {
    GameObject  *_targetObj;

public:
    //  Constructor -- initial construction
    GotoObjectTask(
        TaskStack   *ts,
        GameObject  *obj,
        bool        trackFlag = false) :
        GotoObjectTargetTask(ts, trackFlag),
        _targetObj(obj) {
        debugC(2, kDebugTasks, " - GotoObjectTask");
        _type = "GotoObjectTask";
    }

    GotoObjectTask(Common::InSaveFile *in, TaskID id);

    //  Return the number of bytes needed to archive this object in
    //  a buffer
    int32 archiveSize() const;

    void write(Common::MemoryWriteStreamDynamic *out) const;

    //  Return an integer representing the type of this task
    int16 getType() const;

    //  Determine if the specified task is equivalent to this task
    bool operator == (const Task &t) const;

    const GameObject *getTarget() const {
        return _targetObj;
    }

private:
    bool run();
    GameObject *getObject();
};

/* ===================================================================== *
   GotoActorTask Class
 * ===================================================================== */

class GotoActorTask : public GotoObjectTargetTask {
    Actor       *_targetActor;

public:
    //  Constructor -- initial construction
    GotoActorTask(TaskStack *ts, Actor *a, bool trackFlag = false) :
        GotoObjectTargetTask(ts, trackFlag),
        _targetActor(a) {
        debugC(2, kDebugTasks, " - GotoActorTask");
        _type = "GotoActorTask";
    }
    GotoActorTask(Common::InSaveFile *in, TaskID id);

    //  Return the number of bytes needed to archive this object in
    //  a buffer
    int32 archiveSize() const;

    void write(Common::MemoryWriteStreamDynamic *out) const;

    //  Return an integer representing the type of this task
    int16 getType() const;

    //  Determine if the specified task is equivalent to this task
    bool operator == (const Task &t) const;

    const Actor *getTarget() const {
        return _targetActor;
    }

private:
    bool run();
    GameObject *getObject();
};

/* ===================================================================== *
   GoAwayFromTask Class
 * ===================================================================== */

class GoAwayFromTask : public Task {
    GotoLocationTask        *_goTask;
    TaskID _goTaskID;

    uint8                   _flags;

    enum {
        kRun = (1 << 0)
    };

public:
    //  Constructor -- initial construction
    GoAwayFromTask(TaskStack *ts) :
        Task(ts),
        _goTask(NULL),
        _goTaskID(NoTask),
        _flags(0) {
        debugC(2, kDebugTasks, " - GoAwayFromTask1");
        _type = "GoAwayFromTask";
    }

    GoAwayFromTask(TaskStack *ts, bool runFlag) :
        Task(ts),
        _goTask(NULL),
        _goTaskID(NoTask),
        _flags(runFlag ? kRun : 0) {
        debugC(2, kDebugTasks, " - GoAwayFromTask2");
        _type = "GoAwayFromTask";
    }

    GoAwayFromTask(Common::InSaveFile *in, TaskID id);

    //  Fixup the subtask pointer
    void fixup();

    //  Return the number of bytes needed to archive this object in
    //  a buffer
    int32 archiveSize() const;

    void write(Common::MemoryWriteStreamDynamic *out) const;

    void abortTask();
    TaskResult evaluate();
    TaskResult update();

private:
    virtual TilePoint getRepulsionVector() = 0;
};

/* ===================================================================== *
   GoAwayFromObjectTask Class
 * ===================================================================== */

class GoAwayFromObjectTask : public GoAwayFromTask {
    GameObject      *_obj;

public:
    //  Constructor -- initial construction
    GoAwayFromObjectTask(TaskStack *ts, GameObject *object) :
        GoAwayFromTask(ts),
        _obj(object) {
        debugC(2, kDebugTasks, " - GoAwayFromObjectTask");
        _type = "GoAwayFromObjectTask";
    }

    GoAwayFromObjectTask(Common::InSaveFile *in, TaskID id);

    //  Return the number of bytes needed to archive this object in
    //  a buffer
    int32 archiveSize() const;

    void write(Common::MemoryWriteStreamDynamic *out) const;

    //  Return an integer representing the type of this task
    int16 getType() const;

    //  Determine if the specified task is equivalent to this task
    bool operator == (const Task &t) const;

private:
    TilePoint getRepulsionVector();
};

/* ===================================================================== *
   GoAwayFromActorTask Class
 * ===================================================================== */

class GoAwayFromActorTask : public GoAwayFromTask {
    TargetPlaceHolder   _targetMem;

public:
    //  Constructor -- initial construction
    GoAwayFromActorTask(TaskStack *ts, Actor *a, bool runFlag = false);
    GoAwayFromActorTask(TaskStack *ts, const ActorTarget &at, bool runFlag = false);

    GoAwayFromActorTask(Common::InSaveFile *in, TaskID id);

    //  Return the number of bytes needed to archive this object in
    //  a buffer
    int32 archiveSize() const;

    void write(Common::MemoryWriteStreamDynamic *out) const;

    //  Return an integer representing the type of this task
    int16 getType() const;

    //  Determine if the specified task is equivalent to this task
    bool operator == (const Task &t) const;

private:
    TilePoint getRepulsionVector();

    const ActorTarget *getTarget() const {
        return (const ActorTarget *)_targetMem;
    }
};

/* ===================================================================== *
   HuntTask Class
 * ===================================================================== */

class HuntTask : public Task {
    Task            *_subTask;   //  This will either be a wander task of a
    TaskID _subTaskID;
    //  goto task
    uint8           _huntFlags;

    enum HuntFlags {
        kHuntWander  = (1 << 0), //  Indicates that subtask is a wander task
        kHuntGoto    = (1 << 1)  //  Indicates that subtask is a goto task
    };

public:
    //  Constructor -- initial construction
    HuntTask(TaskStack *ts) : Task(ts), _huntFlags(0), _subTask(nullptr), _subTaskID(NoTask) {
        debugC(2, kDebugTasks, " - HuntTask");
        _type = "HuntTask";
    }

    HuntTask(Common::InSaveFile *in, TaskID id);

    //  Fixup the subtask pointer
    void fixup();

    //  Return the number of bytes needed to archive this object in
    //  a buffer
    int32 archiveSize() const;

    void write(Common::MemoryWriteStreamDynamic *out) const;

    void abortTask();
    TaskResult evaluate();
    TaskResult update();

private:
    void removeWanderTask();
    void removeGotoTask();

protected:
    virtual void evaluateTarget() = 0;

    virtual bool targetHasChanged(GotoTask *gotoTarget) = 0;
    virtual GotoTask *setupGoto() = 0;
    virtual TilePoint currentTargetLoc() = 0;

    virtual bool atTarget() = 0;
    virtual void atTargetabortTask() = 0;
    virtual TaskResult atTargetEvaluate() = 0;
    virtual TaskResult atTargetUpdate() = 0;
};

/* ===================================================================== *
   HuntLocationTask Class
 * ===================================================================== */

class HuntLocationTask : public HuntTask {
    TargetPlaceHolder   _targetMem;

protected:
    TilePoint           _currentTarget;

public:
    //  Constructor -- initial construction
    HuntLocationTask(TaskStack *ts, const Target &t);

    HuntLocationTask(Common::InSaveFile *in, TaskID id);

    //  Return the number of bytes needed to archive this object in
    //  a buffer
    int32 archiveSize() const;

    void write(Common::MemoryWriteStreamDynamic *out) const;

protected:
    bool targetHasChanged(GotoTask *gotoTarget);
    GotoTask *setupGoto();
    TilePoint currentTargetLoc();

    const Target *getTarget() const {
        return (const Target *)_targetMem;
    }
};

/* ===================================================================== *
   HuntToBeNearLocationTask Class
 * ===================================================================== */

class HuntToBeNearLocationTask : public HuntLocationTask {
    uint16              _range;

    uint8               _targetEvaluateCtr;

    //  static const doesn't work in Visual C++
    enum {
        kTargetEvaluateRate = 64
    };
//  static const uint8  kTargetEvaluateRate;

public:
    //  Constructor -- initial construction
    HuntToBeNearLocationTask(TaskStack *ts, const Target &t, uint16 r) :
        HuntLocationTask(ts, t),
        _range(r),
        _targetEvaluateCtr(0) {
        debugC(2, kDebugTasks, " - HuntToBeNearLocationTask");
        _type = "HuntToBeNearLocationTask";
    }

    HuntToBeNearLocationTask(Common::InSaveFile *in, TaskID id);

    //  Return the number of bytes needed to archive this object in
    //  a buffer
    int32 archiveSize() const;

    void write(Common::MemoryWriteStreamDynamic *out) const;

    //  Return an integer representing the type of this task
    int16 getType() const;

    //  Determine if the specified task is equivalent to this task
    bool operator == (const Task &t) const;

protected:
    void evaluateTarget();

    bool atTarget();

    void atTargetabortTask();
    TaskResult atTargetEvaluate();
    TaskResult atTargetUpdate();

    uint16 getRange() const {
        return _range;
    }
};

//const uint8 HuntToBeNearLocationTask::kTargetEvaluateRate = 64;

/* ===================================================================== *
   HuntObjectTask Class
 * ===================================================================== */

class HuntObjectTask : public HuntTask {
    TargetPlaceHolder   _targetMem;

protected:
    GameObject          *_currentTarget;

public:
    //  Constructor -- initial construction
    HuntObjectTask(TaskStack *ts, const ObjectTarget &ot);

    HuntObjectTask(Common::InSaveFile *in, TaskID id);

    //  Return the number of bytes needed to archive this object in
    //  a buffer
    int32 archiveSize() const;

    void write(Common::MemoryWriteStreamDynamic *out) const;

protected:
    bool targetHasChanged(GotoTask *gotoTarget);
    GotoTask *setupGoto();
    TilePoint currentTargetLoc();

    const ObjectTarget *getTarget() const {
        return (const ObjectTarget *)_targetMem;
    }
};

/* ===================================================================== *
   HuntToBeNearObjectTask Class
 * ===================================================================== */

class HuntToBeNearObjectTask : public HuntObjectTask {
    uint16              _range;

    uint8               _targetEvaluateCtr;

    enum {
        kTargetEvaluateRate = 64
    };
//  static const uint8  kTargetEvaluateRate;

public:
    //  Constructor -- initial construction
    HuntToBeNearObjectTask(
        TaskStack *ts,
        const ObjectTarget &ot,
        uint16 r) :
        HuntObjectTask(ts, ot),
        _range(r),
        _targetEvaluateCtr(0) {
        debugC(2, kDebugTasks, " - HuntToBeNearObjectTask");
        _type = "HuntToBeNearObjectTask";
    }

    HuntToBeNearObjectTask(Common::InSaveFile *in, TaskID id);

    //  Return the number of bytes needed to archive this object in
    //  a buffer
    int32 archiveSize() const;

    void write(Common::MemoryWriteStreamDynamic *out) const;

    //  Return an integer representing the type of this task
    int16 getType() const;

    //  Determine if the specified task is equivalent to this task
    bool operator == (const Task &t) const;

protected:
    void evaluateTarget();

    bool atTarget();

    void atTargetabortTask();
    TaskResult atTargetEvaluate();
    TaskResult atTargetUpdate();

    uint16 getRange() const {
        return _range;
    }
};

//const uint8   HuntToBeNearObjectTask::kTargetEvaluateRate = 64;

/* ===================================================================== *
   HuntToPossessTask Class
 * ===================================================================== */

class HuntToPossessTask : public HuntObjectTask {
    uint8               _targetEvaluateCtr;

    enum {
        kTargetEvaluateRate = 64
    };
//  static const uint8  kTargetEvaluateRate;

    bool                _grabFlag;

public:
    //  Constructor -- initial construction
    HuntToPossessTask(TaskStack *ts, const ObjectTarget &ot) :
        HuntObjectTask(ts, ot),
        _targetEvaluateCtr(0),
        _grabFlag(false) {
        debugC(2, kDebugTasks, " - HuntToPossessTask");
        _type = "HuntToPossessTask";
    }

    HuntToPossessTask(Common::InSaveFile *in, TaskID id);

    //  Return the number of bytes needed to archive this object in
    //  a buffer
    int32 archiveSize() const;

    void write(Common::MemoryWriteStreamDynamic *out) const;

    //  Return an integer representing the type of this task
    int16 getType() const;

    //  Determine if the specified task is equivalent to this task
    bool operator == (const Task &t) const;

protected:
    void evaluateTarget();
    bool atTarget();

    void atTargetabortTask();
    TaskResult atTargetEvaluate();
    TaskResult atTargetUpdate();
};

//const uint8 HuntToPossessTask::kTargetEvaluateRate = 16;

/* ===================================================================== *
   HuntActorTask Class
 * ===================================================================== */

class HuntActorTask : public HuntTask {
    TargetPlaceHolder   _targetMem;
    uint8               _flags;

    enum {
        kTrack   = (1 << 0)
    };

protected:
    Actor               *_currentTarget;

public:
    //  Constructor -- initial construction
    HuntActorTask(
        TaskStack           *ts,
        const ActorTarget   &at,
        bool                trackFlag);

    HuntActorTask(Common::InSaveFile *in, TaskID id);

    //  Return the number of bytes needed to archive this object in
    //  a buffer
    int32 archiveSize() const;

    void write(Common::MemoryWriteStreamDynamic *out) const;

protected:
    bool targetHasChanged(GotoTask *gotoTarget);
    GotoTask *setupGoto();
    TilePoint currentTargetLoc();

    const ActorTarget *getTarget() const {
        return (const ActorTarget *)_targetMem;
    }

    bool tracking() const {
        return (_flags & kTrack) != 0;
    }
};

/* ===================================================================== *
   HuntToBeNearActorTask Class
 * ===================================================================== */

class HuntToBeNearActorTask : public HuntActorTask {
    GoAwayFromObjectTask    *_goAway;    //  The 'go away' sub task pointer
    TaskID _goAwayID;
    uint16                  _range;      //  Maximum range

    uint8                   _targetEvaluateCtr;

    enum {
        kTargetEvaluateRate = 16
    };
//  static const uint8  kTargetEvaluateRate;

public:

    enum {
        kTooClose = 12
    };

    //  Constructor -- initial construction
    HuntToBeNearActorTask(
        TaskStack           *ts,
        const ActorTarget   &at,
        uint16              r,
        bool                trackFlag = false) :
        HuntActorTask(ts, at, trackFlag),
        _goAway(NULL),
        _goAwayID(NoTask),
        _range(MAX<uint16>(r, 16)),
        _targetEvaluateCtr(0) {
        debugC(2, kDebugTasks, " - HuntToBeNearActorTask");
        _type = "HuntToBeNearActorTask";
    }

    HuntToBeNearActorTask(Common::InSaveFile *in, TaskID id);

    //  Fixup the subtask pointer
    void fixup();

    //  Return the number of bytes needed to archive this object in
    //  a buffer
    int32 archiveSize() const;

    void write(Common::MemoryWriteStreamDynamic *out) const;

    //  Return an integer representing the type of this task
    int16 getType() const;

    //  Determine if the specified task is equivalent to this task
    bool operator == (const Task &t) const;

protected:
    void evaluateTarget();

    bool atTarget();

    void atTargetabortTask();
    TaskResult atTargetEvaluate();
    TaskResult atTargetUpdate();

    uint16 getRange() const {
        return _range;
    }
};

//const uint8   HuntToBeNearActorTask::kTargetEvaluateRate = 64;

/* ===================================================================== *
   HuntToKillTask Class
 * ===================================================================== */

class HuntToKillTask : public HuntActorTask {
    uint8               _targetEvaluateCtr;
    uint8               _specialAttackCtr;

    enum {
        kTargetEvaluateRate = 16
    };

    enum {
        kCurrentWeaponBonus = 1
    };

    uint8               _flags;

    enum {
        kEvalWeapon      = (1 << 0)
    };
//  static const uint8  kTargetEvaluateRate;

public:
    //  Constructor -- initial construction
    HuntToKillTask(
        TaskStack           *ts,
        const ActorTarget   &at,
        bool                trackFlag = false);

    HuntToKillTask(Common::InSaveFile *in, TaskID id);

    //  Return the number of bytes needed to archive this object in
    //  a buffer
    int32 archiveSize() const;

    void write(Common::MemoryWriteStreamDynamic *out) const;

    //  Return an integer representing the type of this task
    int16 getType() const;

    //  Determine if the specified task is equivalent to this task
    bool operator == (const Task &t) const;

    void abortTask();
    TaskResult update();

protected:
    void evaluateTarget();
    bool atTarget();

    void atTargetabortTask();
    TaskResult atTargetEvaluate();
    TaskResult atTargetUpdate();

private:
    void evaluateWeapon();
};

//const uint8 HuntToKillTask::kTargetEvaluateRate = 16;

//  Utility function used for combat target selection
inline int16 closenessScore(int16 dist) {
    return 128 / dist;
}

/* ===================================================================== *
   HuntToGiveTask Class
 * ===================================================================== */

class HuntToGiveTask : public HuntActorTask {
    GameObject      *_objToGive;

public:
    //  Constructor -- initial construction
    HuntToGiveTask(
        TaskStack           *ts,
        const ActorTarget   &at,
        GameObject          *obj,
        bool                trackFlag = false) :
        HuntActorTask(ts, at, trackFlag),
        _objToGive(obj) {
        debugC(2, kDebugTasks, " - HuntToGiveTask");
        _type = "HuntToGiveTask";
    }

    HuntToGiveTask(Common::InSaveFile *in, TaskID id);

    //  Return the number of bytes needed to archive this object in
    //  a buffer
    int32 archiveSize() const;

    void write(Common::MemoryWriteStreamDynamic *out) const;

    //  Return an integer representing the type of this task
    int16 getType() const;

    //  Determine if the specified task is equivalent to this task
    bool operator == (const Task &t) const;

protected:
    void evaluateTarget();
    bool atTarget();

    void atTargetabortTask();
    TaskResult atTargetEvaluate();
    TaskResult atTargetUpdate();
};

/* ===================================================================== *
   BandTask Class
 * ===================================================================== */

class AttendTask;

class BandTask : public HuntTask {
    AttendTask          *_attend;
    TaskID _attendID;

    TilePoint           _currentTarget;
    uint8               _targetEvaluateCtr;

    enum {
        kTargetEvaluateRate = 2
    };

public:

    class RepulsorIterator {
    public:
        virtual ~RepulsorIterator() {}

        virtual bool first(
            TilePoint   &repulsorVector,
            int16       &repulsorStrength) = 0;

        virtual bool next(
            TilePoint   &repulsorVector,
            int16       &repulsorStrength) = 0;
    };

    class BandingRepulsorIterator : public RepulsorIterator {
    protected:
        Actor           *_a;

    private:
        Band            *_band;
        int             _bandIndex;

    public:
        BandingRepulsorIterator(Actor *actor) : _a(actor), _band(nullptr), _bandIndex(0) {}

        bool first(
            TilePoint   &repulsorVector,
            int16       &repulsorStrength);

        bool next(
            TilePoint   &repulsorVector,
            int16       &repulsorStrength);
    };


    //  This class should be nested in the BandAndAvoidEnemiesTask class
    //  but Visual C++ 4.0 is lame and won't let the
    //  BandAndAvoidEnemiesTask inherit the BandingRepulsorIterator class
    //  even though it is explicitly declared protected and not private.
    //  Watcom C++, however, works correctly.
    class BandAndAvoidEnemiesRepulsorIterator : public BandingRepulsorIterator {
        Actor       *_actorArray[6];
        int         _numActors,
                    _actorIndex;
        bool        _iteratingThruEnemies;

    public:
        BandAndAvoidEnemiesRepulsorIterator(Actor *actor) :
                BandingRepulsorIterator(actor), _numActors(0), _actorIndex(0), _iteratingThruEnemies(false) {
            for (int i = 0; i < 6; i++)
                _actorArray[i] = 0;
        }

    private:
        bool firstEnemyRepulsor(
            TilePoint   &repulsorVector,
            int16       &repulsorStrength);

        bool nextEnemyRepulsor(
            TilePoint   &repulsorVector,
            int16       &repulsorStrength);

    public:
        bool first(
            TilePoint   &repulsorVector,
            int16       &repulsorStrength);

        bool next(
            TilePoint   &repulsorVector,
            int16       &repulsorStrength);
    };

public:
    //  Constructor -- initial construction
    BandTask(TaskStack *ts) :
        HuntTask(ts),
        _attend(NULL),
        _attendID(NoTask),
        _currentTarget(Nowhere),
        _targetEvaluateCtr(0) {
        debugC(2, kDebugTasks, " - BandTask");
        _type = "BandTask";
    }

    BandTask(Common::InSaveFile *in, TaskID id);

    //  Fixup the subtask pointer
    void fixup();

    //  Return the number of bytes needed to archive this object in
    //  a buffer
    int32 archiveSize() const;

    void write(Common::MemoryWriteStreamDynamic *out) const;

    //  Return an integer representing the type of this task
    int16 getType() const;

    //  Determine if the specified task is equivalent to this task
    bool operator == (const Task &t) const;

protected:
    void evaluateTarget();

    bool targetHasChanged(GotoTask *gotoTarget);
    GotoTask *setupGoto();
    TilePoint currentTargetLoc();

    bool atTarget();

    void atTargetabortTask();
    TaskResult atTargetEvaluate();
    TaskResult atTargetUpdate();

    virtual int16 getRunThreshold();
    virtual RepulsorIterator *getNewRepulsorIterator();
};

/* ===================================================================== *
   BandAndAvoidEnemiesTask Class
 * ===================================================================== */

class BandAndAvoidEnemiesTask : public BandTask {
protected:
    //  I had to move this nested class up to the BandTask class because
    //  Visual C++ is lame.
    /*  class BandAndAvoidEnemiesRepulsorIterator : public BandingRepulsorIterator {
            Actor       *_actorArray[6];
            int         _numActors,
                        _actorIndex;
            bool        _iteratingThruEnemies;

        public:
            BandAndAvoidEnemiesRepulsorIterator(Actor *actor) :
                BandingRepulsorIterator(actor) {}

        private:
            bool firstEnemyRepulsor(
                TilePoint   &repulsorVector,
                int16       &repulsorStrength);

            bool nextEnemyRepulsor(
                TilePoint   &repulsorVector,
                int16       &repulsorStrength);

        public:
            bool first(
                TilePoint   &repulsorVector,
                int16       &repulsorStrength);

            bool next(
                TilePoint   &repulsorVector,
                int16       &repulsorStrength);
        };
    */
public:
    //  Constructor -- initial constructor
    BandAndAvoidEnemiesTask(TaskStack *ts) : BandTask(ts) {}

    BandAndAvoidEnemiesTask(Common::InSaveFile *in, TaskID id) : BandTask(in, id) {}

    //  Return an integer representing the type of this task
    int16 getType() const;

    //  Determine if the specified task is equivalent to this task
    bool operator == (const Task &t) const;

protected:
    int16 getRunThreshold();
    RepulsorIterator *getNewRepulsorIterator();
};

/* ===================================================================== *
   FollowPatrolRouteTask Class
 * ===================================================================== */

class FollowPatrolRouteTask : public Task {
    GotoLocationTask        *_gotoWayPoint;  //  A goto waypoint sub task
    TaskID _gotoWayPointID;
    //  pointer.
    PatrolRouteIterator     _patrolIter;     //  The patrol route iterator.
    int16                   _lastWayPointNum;    //  Waypoint at which to end
    //  this task.
    bool                    _paused;         //  Flag indicating "paused"ness
    //  of this task
    int16                   _counter;        //  Counter for tracking pause
    //  length

public:
    //  Constructor -- initial construction
    FollowPatrolRouteTask(
        TaskStack           *ts,
        PatrolRouteIterator iter,
        int16               stopAt = -1) :
        Task(ts),
        _gotoWayPoint(NULL),
        _gotoWayPointID(NoTask),
        _patrolIter(iter),
        _lastWayPointNum(stopAt), _counter(0) {
        debugC(2, kDebugTasks, " - FollowPatrolRouteTask");
        _type = "FollowPatrolRouteTask";
        followPatrolRoute();
    }

    FollowPatrolRouteTask(Common::InSaveFile *in, TaskID id);

    //  Fixup the subtask pointer
    void fixup();

    //  Return the number of bytes needed to archive this object in
    //  a buffer
    int32 archiveSize() const;

    void write(Common::MemoryWriteStreamDynamic *out) const;

    //  Return an integer representing the type of this task
    int16 getType() const;

    void abortTask();
    TaskResult evaluate();
    TaskResult update();

    //  Determine if the specified task is equivalent to this task
    bool operator == (const Task &t) const;

    //  Update function used if this task is not paused
    TaskResult handleFollowPatrolRoute();

    //  Update function used if this task is paused
    TaskResult handlePaused();

    //  Set this task into the paused state
    void pause();

    //  Set this task into the unpaused state
    void followPatrolRoute() {
        _paused = false;
    }
};

/* ===================================================================== *
   AttendTask Class
 * ===================================================================== */

class AttendTask : public Task {
    GameObject  *_obj;

public:
    //  Constructor -- initial construction
    AttendTask(TaskStack *ts, GameObject *o) : Task(ts), _obj(o) {
        debugC(2, kDebugTasks, " - AttendTask");
        _type = "AttendTask";
    }

    AttendTask(Common::InSaveFile *in, TaskID id);

    //  Return the number of bytes needed to archive this object in
    //  a buffer
    int32 archiveSize() const;

    void write(Common::MemoryWriteStreamDynamic *out) const;

    //  Return an integer representing the type of this task
    int16 getType() const;

    void abortTask();
    TaskResult evaluate();
    TaskResult update();

    //  Determine if the specified task is equivalent to this task
    bool operator == (const Task &t) const;
};

#if 0

//  The defend task is no longer necessary

/* ===================================================================== *
   DefendTask Class
 * ===================================================================== */

class DefendTask : public Task {
    Actor       *_attacker;

    Task        *_subTask;

public:
    //  Constructor -- initial construction
    DefendTask(TaskStack *ts, Actor *a) : Task(ts), _attacker(a), _subTask(NULL) {}

    //  Fixup the subtask pointer
    void fixup();

    //  Return the number of bytes needed to archive this object in
    //  a buffer
    int32 archiveSize() const;

    //  Return an integer representing the type of this task
    int16 getType() const;

    void abortTask();
    TaskResult evaluate();
    TaskResult update();

    //  Determine if the specified task is equivalent to this task
    bool operator == (const Task &t) const;
};

/* ===================================================================== *
   ParryTask Class
 * ===================================================================== */

class ParryTask : public Task {
    Actor               *_attacker;
    GameObject          *_defenseObj;

    uint8               _flags;

    enum {
        kMotionStarted   = (1 << 0),
        kBlockStarted    = (1 << 1)
    };

public:
    //  Constructor -- initial construction
    ParryTask(TaskStack *ts, Actor *a, GameObject *obj) :
        Task(ts),
        _attacker(a),
        _defenseObj(obj),
        _flags(0) {
    }

    //  Return the number of bytes needed to archive this object in
    //  a buffer
    int32 archiveSize() const;

    //  Return an integer representing the type of this task
    int16 getType() const;

    void abortTask();
    TaskResult evaluate();
    TaskResult update();

    //  Determine if the specified task is equivalent to this task
    bool operator == (const Task &t) const;
};

#endif

/* ===================================================================== *
   TaskStack Class
 * ===================================================================== */

//  This class contains data common to all task's in an actor task
//  stack.  Also, this class manages the automatic task reevaluation.
class TaskStack {

    TaskID          _stackBottomID;  //  Bottom task in stack

    int16           _evalCount,  //  Counter for automatic task re-evaluation
                    _evalRate;   //  Rate of automatic task re-evalutation
public:
    Actor           *_actor;     //  Pointer to actor performing tasks

    //  Constructor
    TaskStack() :
        _stackBottomID(0),
        _evalCount(0),
        _evalRate(0),
        _actor(nullptr) {}

    TaskStack(Actor *a) :
        _stackBottomID(NoTask),
        _actor(a),
        _evalCount(kDefaultEvalRate),
        _evalRate(kDefaultEvalRate) {

        newTaskStack(this);
    }

    //  Destructor
    ~TaskStack() {
        if (_actor)
            _actor->_curTask = nullptr;
        deleteTaskStack(this);
    }

    //  Return the number of bytes necessary to archive this TaskStack
    //  in a buffer
    int32 archiveSize() {
        return      sizeof(ObjectID)     //  actor's id
                    +   sizeof(_stackBottomID)
                    +   sizeof(_evalCount)
                    +   sizeof(_evalRate);
    }

    void write(Common::MemoryWriteStreamDynamic *out);

    void read(Common::InSaveFile *in);

    //  Set the bottom task of this task stack
    void setTask(Task *t);

    //  Return a pointer to the bottom task in this task stack
    const Task *getTask() {
        return  _stackBottomID != NoTask
                ?   getTaskAddress(_stackBottomID)
                :   NULL;
    }

    Actor *getActor() {
        return _actor;
    }

    //  Abort all tasks in stack
    void abortTask();
    //  Re-evaluate tasks in stack
    TaskResult evaluate();
    //  Update the state of the tasks in stack
    TaskResult update();
};

} // end of namespace Saga2

#endif