assign.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_ASSIGN_H
#define SAGA2_ASSIGN_H

#include "saga2/target.h"

namespace Saga2 {

class Actor;
class Task;
class TaskStack;

//  Constants representing the non-virtual ActorAssignment classes
enum AssignmentTypes {
    kPatrolRouteAssignment,
    kHuntToBeNearLocationAssignment,
    kHuntToBeNearActorAssignment,
    kHuntToKillAssignment,
    kTetheredWanderAssignment,
    kAttendAssignment
};

/* ===================================================================== *
   ActorAssignment class
 * ===================================================================== */

class ActorAssignment {

    enum {
        kAFHasAssignment   = (1 << 3)
    };

    uint16  _startFrame,     //  Time in day when this was constructed
            _endFrame;       //  End time of the assignment

    Actor *_actor;

public:
    //  Constructor
    ActorAssignment(Actor *a, uint16 until);

    ActorAssignment(Actor *a, Common::SeekableReadStream *stream);

    //  Destructor
    virtual ~ActorAssignment();

    //  Return the number of bytes need to archive the data in this
    //  assignment
    virtual int32 archiveSize() const;

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

    //  Construct a TaskStack for this assignment
    TaskStack *createTask();

    //  This function is called to notify the assignment of the
    //  completion of a task which the assignment had created.
    virtual void handleTaskCompletion(TaskResult result);

    //  Determine if assignment's time limit is up
    virtual bool isValid();

    //  Return a pointer to the actor to which this assignment belongs
    Actor *getActor() const;

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

protected:
    void startTask();

    //  Determine if this assignment needs to create a task at this time
    virtual bool taskNeeded();

    //  Create a Task for this assignment
    virtual Task *getTask(TaskStack *ts) = 0;
};

/* ===================================================================== *
   PatrolRouteAssignment class
 * ===================================================================== */

class PatrolRouteAssignment : public ActorAssignment {
    int16   _routeNo,            //  Patrol route number
            _startingWayPoint,   //  Way point at which to start (-1 = default)
            _endingWayPoint;     //  Way point at which to end (-1 = default)
    uint8   _routeFlags,         //  Flags indicating how patrol route should
            //  be followed
            _flags;              //  Flags representing the state of this
    //  assignment

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

public:
    //  Constructor -- initial object construction
    PatrolRouteAssignment(
        Actor *a,
        uint16 until,
        int16 rteNo,
        uint8 patrolFlags,
        int16 start = -1,
        int16 end = -1);

    PatrolRouteAssignment(Actor *a, Common::SeekableReadStream *stream);

    //  Return the number of bytes need to archive the data in this
    //  assignment
    int32 archiveSize() const;

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

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

    //  This function is called to notify the assignment of the
    //  completion of a task which the assignment had created.
    void handleTaskCompletion(TaskResult result);

    //  Determine if assignment is still valid
    bool isValid();

protected:
    //  Determine if this assignment needs to create a task at this time
    bool taskNeeded();

    //  Construct a Task for this assignment
    Task *getTask(TaskStack *ts);
};

/* ===================================================================== *
   HuntToBeNearLocationAssignment class
 * ===================================================================== */

class HuntToBeNearLocationAssignment : public ActorAssignment {
    TargetPlaceHolder   _targetMem;
    uint16              _range;

    //  An initialization function which provides a common ground for
    //  the initial constructors.
    void initialize(const Target &targ, uint16 r);

public:
    //  Constructors -- initial assignment construction

    //  Construct with no time limit and a specific TilePoint
    HuntToBeNearLocationAssignment(Actor *a, const TilePoint &tp, uint16 r);

    //  Construct with time limit and a specific TilePoint
    HuntToBeNearLocationAssignment(
        Actor *a,
        uint16          until,
        const TilePoint &tp,
        uint16          r) :
        ActorAssignment(a, until) {
        initialize(LocationTarget(tp), r);
    }

    //  Construct with no time limit and an abstract target
    HuntToBeNearLocationAssignment(Actor *a, const Target &targ, uint16 r);

    //  Construct with time limit and an abstract target
    HuntToBeNearLocationAssignment(
        Actor *a,
        uint16          until,
        const Target    &targ,
        uint16          r) :
        ActorAssignment(a, until) {
        initialize(targ, r);
    }


    HuntToBeNearLocationAssignment(Actor *a, Common::SeekableReadStream *stream);

    //  Return the number of bytes need to archive the data in this
    //  assignment
    int32 archiveSize() const;

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

    int16 type() const;

protected:
    bool taskNeeded();

    Task *getTask(TaskStack *ts);

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

/* ===================================================================== *
   HuntToBeNearActorAssignment class
 * ===================================================================== */

class HuntToBeNearActorAssignment : public ActorAssignment {
    TargetPlaceHolder   _targetMem;
    uint16              _range;
    uint8               _flags;

    enum {
        kTrack           = (1 << 0)  //  This hunt is a track.
    };

    //  An initialization function which provides a common ground for
    //  the initial constructors.
    void initialize(
        const ActorTarget   &at,
        uint16              r,
        bool                trackFlag);

public:
    //  Constructors -- initial assignment construction

    //  Construct with no time limit and specific actor
    HuntToBeNearActorAssignment(
        Actor               *a,
        uint16              r,
        bool                trackFlag = false);

    //  Construct with time limit and specific actor
    HuntToBeNearActorAssignment(
        Actor *ac,
        uint16              until,
        Actor               *a,
        uint16              r,
        bool                trackFlag = false) :
        ActorAssignment(ac, until) {
        assert(isActor(a) && a != getActor());
        initialize(SpecificActorTarget(a), r, trackFlag);
    }

    //  Construct with no time limit and abstract actor target
    HuntToBeNearActorAssignment(
        Actor *a,
        const ActorTarget   &at,
        uint16              r,
        bool                trackFlag = false);

    //  Construct with time limit and abstract actor target
    HuntToBeNearActorAssignment(
        Actor *a,
        uint16              until,
        const ActorTarget   &at,
        uint16              r,
        bool                trackFlag = false) :
        ActorAssignment(a, until) {
        initialize(at, r, trackFlag);
    }

    HuntToBeNearActorAssignment(Actor *a, Common::SeekableReadStream *stream);

    //  Return the number of bytes need to archive the data in this
    //  assignment
    int32 archiveSize() const;

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

    int16 type() const;

protected:
    bool taskNeeded();

    Task *getTask(TaskStack *ts);

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

/* ===================================================================== *
   HuntToKillAssignment class
 * ===================================================================== */

class HuntToKillAssignment : public ActorAssignment {
    TargetPlaceHolder   _targetMem;
    uint8               _flags;

    enum {
        kTrack           = (1 << 0), //  This hunt is a track.
        kSpecificActor   = (1 << 1)  //  The actor target is a specific actor
    };

    //  An initialization function which provides a common ground for
    //  the initial constructors.
    void initialize(
        const ActorTarget   &at,
        bool                trackFlag,
        bool                specificActorFlag);

public:
    //  Constructors -- initial assignment construction

    //  Construct with no time limit and specific actor
    HuntToKillAssignment(Actor *a, bool trackFlag = false);

    //  Construct with time limit and specific actor
    HuntToKillAssignment(
        Actor *ac,
        uint16              until,
        Actor               *a,
        bool                trackFlag = false) :
        ActorAssignment(ac, until) {
        assert(isActor(a) && a != getActor());
        initialize(SpecificActorTarget(a), trackFlag, true);
    }

    //  Construct with no time limit and abstract actor target
    HuntToKillAssignment(
        Actor *a,
        const ActorTarget   &at,
        bool                trackFlag = false);

    //  Construct with time limit and abstract actor target
    HuntToKillAssignment(
        Actor *a,
        uint16              until,
        const ActorTarget   &at,
        bool                trackFlag = false) :
        ActorAssignment(a, until) {
        initialize(at, trackFlag, false);
    }

    //  Return the number of bytes need to archive the data in this
    //  assignment
    int32 archiveSize() const;

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

    //  Determine if assignment's time limit is up or if the actor is
    //  already dead
    bool isValid();

    int16 type() const;

protected:
    bool taskNeeded();

    Task *getTask(TaskStack *ts);

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

/* ===================================================================== *
   TetheredAssignment class
 * ===================================================================== */

class TetheredAssignment : public ActorAssignment {
protected:
    //  Tether region
    int16       _minU,   //  Minimum U coordinate in tether
                _minV,   //  Minimum V coordinate in tether
                _maxU,   //  Maximum U coordinate in tether
                _maxV;   //  Maximum V coordinate in tether

public:
    //  Constructor -- initial assignment construction
    TetheredAssignment(Actor *a, uint16 until, const TileRegion &reg) :
        ActorAssignment(a, until),
        _minU(reg.min.u),
        _minV(reg.min.v),
        _maxU(reg.max.u),
        _maxV(reg.max.v) {
    }

    TetheredAssignment(Actor *a, Common::SeekableReadStream *stream);

    //  Return the number of bytes need to archive the data in this
    //  assignment
    int32 archiveSize() const;

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

/* ===================================================================== *
   TetheredWanderAssignment class
 * ===================================================================== */

class TetheredWanderAssignment : public TetheredAssignment {
public:
    //  Constructor -- initial assignment construction
    TetheredWanderAssignment(Actor *a, uint16 until, const TileRegion &reg);

    TetheredWanderAssignment(Actor *a, Common::SeekableReadStream *stream) : TetheredAssignment(a, stream) {}

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

protected:
    //  Construct a Task for this assignment
    Task *getTask(TaskStack *ts);
};

/* ===================================================================== *
   AttendAssignment class
 * ===================================================================== */

class AttendAssignment : public ActorAssignment {
    GameObject      *_obj;   //  Object to which to attend

public:
    //  Constructor -- initial assignment construction
    AttendAssignment(Actor *a, uint16 until, GameObject *o);

    AttendAssignment(Actor *a, Common::SeekableReadStream *stream);

    //  Return the number of bytes need to archive the data in this
    //  assignment
    int32 archiveSize() const;

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

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

protected:
    //  Construct a Task for this assignment
    Task *getTask(TaskStack *ts);
};

/* ===================================================================== *
   Prototypes
 * ===================================================================== */

//  Return the number of bytes necessary to archive this actor's
//  assignment in an archive buffer
int32 assignmentArchiveSize(Actor *a);

void writeAssignment(Actor *a, Common::MemoryWriteStreamDynamic *out);
void readAssignment(Actor *a, Common::InSaveFile *in);

}

#endif