target.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_TARGET_H
#define SAGA2_TARGET_H

namespace Saga2 {

struct StandingTileInfo;

const   int     kMaxObjDist = kPlatformWidth * kTileUVSize * 8;
const   int     kMaxTileDist = kPlatformWidth * kTileUVSize * 2;
const   int     kMaxMetaDist = kPlatformWidth * kTileUVSize * 8;

enum TargetType {
    kLocationTarget,
    kSpecificTileTarget,
    kTilePropertyTarget,
    kSpecificMetaTileTarget,
    kMetaTilePropertyTarget,
    kSpecificObjectTarget,
    kObjectPropertyTarget,
    kSpecificActorTarget,
    kActorPropertyTarget
};

/* ===================================================================== *
   Misc. function prototypes
 * ===================================================================== */

class Target;

//  Deletes targets allocated on the heap using new
void deleteTarget(Target *t);

void readTarget(void *mem, Common::InSaveFile *in);
void writeTarget(const Target *t, Common::MemoryWriteStreamDynamic *out);
int32 targetArchiveSize(const Target *t);

/* ===================================================================== *
   TargetLocationArray structure
 * ===================================================================== */

//  This structure is used to query the target class for multiple target
//  locations
struct TargetLocationArray {
    const int16         size;   //  number of allocated elements in array
    int16               locs;   //  number of array elements with valid data

    //  These arrays must be allocated by calling function
    TilePoint *const   locArray;    //  pointer to location array
    int16 *const       distArray;   //  pointer to distance array

    //  Constructor
    TargetLocationArray(int16 s, TilePoint *arr, int16 *dArr) :
        size(s),
        locs(0),
        locArray(arr),
        distArray(dArr) {
    }
};

/* ===================================================================== *
   TargetObjectArray structure
 * ===================================================================== */

//  This structure is used to query the target class for multiple target
//  objects
struct TargetObjectArray {
    const int16         size;   //  number of allocated elements in array
    int16               objs;   //  number of array elements with valid data

    //  These arrays must be allocated by calling function
    GameObject **const objArray;    //  pointer to object pointer array
    int16 *const       distArray;   //  pointer to distance array

    //  Constructor
    TargetObjectArray(int16 s, GameObject **arr, int16 *dArr) :
        size(s),
        objs(0),
        objArray(arr),
        distArray(dArr) {
    }
};

/* ===================================================================== *
   TargetActorArray structure
 * ===================================================================== */

//  This structure is used to query the target class for multiple target
//  actors
struct TargetActorArray {
    const int16     size;       //  number of allocated elements in array
    int16           actors;     //  number of array elements with valid data

    //  These arrays must be allocated by calling function
    Actor **const  actorArray;  //  pointer to actor pointer array
    int16 *const   distArray;   //  pointer to distance array

    //  Constructor
    TargetActorArray(int16 s, Actor **arr, int16 *dArr) :
        size(s),
        actors(0),
        actorArray(arr),
        distArray(dArr) {
    }
};

/* ===================================================================== *
   Target class
 * ===================================================================== */

class Target {
public:
    //  virtual destructor
    virtual ~Target() {}

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

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

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

    //  Virtual function returning the sizeof this target
    virtual size_t size() const = 0;

    //  Create a copy of this target at the specified address
    virtual void clone(void *mem) const = 0;

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

    //  Overloaded memory management functions for constructing and
    //  destructing Targets in place.
    void *operator new (size_t, void *p) {
        return p;
    }

    virtual bool isObjectTarget() const;
    virtual bool isActorTarget() const;

    //  Return location of closest instance of target
    virtual TilePoint where(GameWorld *world, const TilePoint &tp) const = 0;
    //  Fill array with locations of closest instances of target
    virtual int16 where(
        GameWorld *world,
        const TilePoint &tp,
        TargetLocationArray &tla) const = 0;
};

/* ===================================================================== *
   LocationTarget class
 * ===================================================================== */

class LocationTarget : public Target {
    TilePoint   _loc;

public:
    //  Constructor -- initial construction
    LocationTarget(const TilePoint &tp) : _loc(tp) {}

    LocationTarget(Common::SeekableReadStream *stream);

    //  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 target
    int16 getType() const;

    //  Virtual function returning the sizeof this target
    size_t size() const;

    //  Create a copy of this target at the specified address
    void clone(void *mem) const;

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

    //  Determine if the specified location target is equivalent to this
    //  location target
    bool operator == (const LocationTarget &lt) const {
        return _loc == lt._loc;
    }
    bool operator != (const LocationTarget &lt) const {
        return _loc != lt._loc;
    }

    TilePoint where(GameWorld *world, const TilePoint &tp) const;
    int16 where(
        GameWorld *world,
        const TilePoint &tp,
        TargetLocationArray &tla) const;
};

/* ===================================================================== *
   TileTarget class
 * ===================================================================== */

class TileTarget : public Target {
public:
    virtual bool isTarget(StandingTileInfo &sti) const = 0;

    TilePoint where(GameWorld *world, const TilePoint &tp) const;
    int16 where(
        GameWorld *world,
        const TilePoint &tp,
        TargetLocationArray &tla) const;
};

/* ===================================================================== *
   SpecificTileTarget class
 * ===================================================================== */

class SpecificTileTarget : public TileTarget {
    TileID  _tile;

public:
    //  Constructor -- initial construction
    SpecificTileTarget(TileID t) : _tile(t) {}

    SpecificTileTarget(Common::SeekableReadStream *stream);

    //  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 target
    int16 getType() const;

    //  Virtual function returning the sizeof this target
    size_t size() const;

    //  Create a copy of this target at the specified address
    void clone(void *mem) const;

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

    bool isTarget(StandingTileInfo &sti) const;
};

/* ===================================================================== *
   TilePropertyTarget class
 * ===================================================================== */

class TilePropertyTarget : public TileTarget {
    TilePropertyID  _tileProp;

public:
    //  Constructor -- initial construction
    TilePropertyTarget(TilePropertyID tProp) : _tileProp(tProp) {}

    TilePropertyTarget(Common::SeekableReadStream *stream);

    //  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 target
    int16 getType() const;

    //  Virtual function returning the sizeof this target
    size_t size() const;

    //  Create a copy of this target at the specified address
    void clone(void *mem) const;

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

    bool isTarget(StandingTileInfo &sti) const;
};

/* ===================================================================== *
   MetaTileTarget class
 * ===================================================================== */

class MetaTileTarget : public Target {
public:
    virtual bool isTarget(
        MetaTile *mt,
        int16 mapNum,
        const TilePoint &tp) const = 0;

    TilePoint where(GameWorld *world, const TilePoint &tp) const;
    int16 where(
        GameWorld *world,
        const TilePoint &tp,
        TargetLocationArray &tla) const;
};

/* ===================================================================== *
   SpecificMetaTileTarget class
 * ===================================================================== */

class SpecificMetaTileTarget : public MetaTileTarget {
    MetaTileID  _meta;

public:
    //  Constructor -- initial construction
    SpecificMetaTileTarget(MetaTileID mt) : _meta(mt) {}

    SpecificMetaTileTarget(Common::SeekableReadStream *stream);

    //  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 target
    int16 getType() const;

    //  Virtual function returning the sizeof this target
    size_t size() const;

    //  Create a copy of this target at the specified address
    void clone(void *mem) const;

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

    bool isTarget(MetaTile *mt, int16 mapNum, const TilePoint &tp) const;
};

/* ===================================================================== *
   MetaTilePropertyTarget class
 * ===================================================================== */

class MetaTilePropertyTarget : public MetaTileTarget {
    MetaTilePropertyID  _metaProp;

public:
    //  Constructor -- initial construction
    MetaTilePropertyTarget(MetaTilePropertyID mtProp) :
        _metaProp(mtProp) {
    }

    MetaTilePropertyTarget(Common::SeekableReadStream *stream);

    //  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 target
    int16 getType() const;

    //  Virtual function returning the sizeof this target
    size_t size() const;

    //  Create a copy of this target at the specified address
    void clone(void *mem) const;

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

    bool isTarget(MetaTile *mt, int16 mapNum, const TilePoint &tp) const;
};

/* ===================================================================== *
   ObjectTarget class
 * ===================================================================== */

class ObjectTarget : public Target {

    //  These are recursive functions used to fill a target array
    //  by inspecting an object and all of the objects contained in
    //  that object
    void searchObject(
        GameObject *obj,
        int16 dist,
        TargetObjectArray &toa) const;
    void searchObject(
        GameObject *obj,
        const TilePoint &tp,
        int16 dist,
        TargetLocationArray &tla) const;

public:
    bool isObjectTarget() const;

    TilePoint where(GameWorld *world, const TilePoint &tp) const;
    int16 where(
        GameWorld *world,
        const TilePoint &tp,
        TargetLocationArray &tla) const;

    //  Determine if the specified object meets the target criterion
    virtual bool isTarget(GameObject *testObj) const = 0;

    //  Return closest instance of target object
    virtual GameObject *object(GameWorld *world, const TilePoint &tp) const;
    //  Fill array with closest instances of target object
    virtual int16 object(
        GameWorld *world,
        const TilePoint &tp,
        TargetObjectArray &toa) const;
};

/* ===================================================================== *
   SpecificObjectTarget class
 * ===================================================================== */

class SpecificObjectTarget : public ObjectTarget {
    ObjectID    _obj;

public:
    //  Constructors -- initial construction
    SpecificObjectTarget(ObjectID id) :
        _obj(id) {
        assert(isObject(_obj));
    }
    SpecificObjectTarget(GameObject *ptr) : _obj((assert(isObject(ptr)), ptr->thisID())) {}

    SpecificObjectTarget(Common::SeekableReadStream *stream);

    //  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 target
    int16 getType() const;

    //  Virtual function returning the sizeof this target
    size_t size() const;

    //  Create a copy of this target at the specified address
    void clone(void *mem) const;

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

    bool isTarget(GameObject *testObj) const;

    TilePoint where(GameWorld *world, const TilePoint &tp) const;
    int16 where(
        GameWorld *world,
        const TilePoint &tp,
        TargetLocationArray &tla) const;

    GameObject *object(GameWorld *world, const TilePoint &tp) const;
    int16 object(
        GameWorld *world,
        const TilePoint &tp,
        TargetObjectArray &toa) const;

    //  Return a pointer to the target object, unconditionally
    GameObject *getTargetObject() const {
        return GameObject::objectAddress(_obj);
    }
};

/* ===================================================================== *
   ObjectPropertTarget class
 * ===================================================================== */

class ObjectPropertyTarget : public ObjectTarget {
    ObjectPropertyID    _objProp;

public:
    //  Constructor -- initial construction
    ObjectPropertyTarget(ObjectPropertyID prop) : _objProp(prop) {}

    ObjectPropertyTarget(Common::SeekableReadStream *stream);

    //  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 target
    int16 getType() const;

    //  Virtual function returning the sizeof this target
    size_t size() const;

    //  Create a copy of this target at the specified address
    void clone(void *mem) const;

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

    bool isTarget(GameObject *testObj) const;
};

/* ===================================================================== *
   ActorTarget class
 * ===================================================================== */

class ActorTarget : public ObjectTarget {

public:
    bool isActorTarget() const;

    bool isTarget(GameObject *testObj) const;
    virtual bool isTarget(Actor *testActor) const = 0;

    virtual Actor *actor(GameWorld *world, const TilePoint &tp) const;
    virtual int16 actor(
        GameWorld *world,
        const TilePoint &tp,
        TargetActorArray &taa) const;
};

/* ===================================================================== *
   SpecificActorTarget class
 * ===================================================================== */

class SpecificActorTarget : public ActorTarget {
    Actor   *_a;

public:
    //  Constructor -- initial construction
    SpecificActorTarget(Actor *actor_) : _a(actor_) {}

    SpecificActorTarget(Common::SeekableReadStream *stream);

    //  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 target
    int16 getType() const;

    //  Virtual function returning the sizeof this target
    size_t size() const;

    //  Create a copy of this target at the specified address
    void clone(void *mem) const;

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

    bool isTarget(Actor *testActor) const;

    TilePoint where(GameWorld *world, const TilePoint &tp) const;
    int16 where(
        GameWorld *world,
        const TilePoint &tp,
        TargetLocationArray &tla) const;

    GameObject *object(GameWorld *world, const TilePoint &tp) const;
    int16 object(
        GameWorld *world,
        const TilePoint &tp,
        TargetObjectArray &toa) const;

    Actor *actor(GameWorld *world, const TilePoint &tp) const;
    int16 actor(
        GameWorld *world,
        const TilePoint &tp,
        TargetActorArray &taa) const;

    //  Return a pointer to the target actor, unconditionally
    Actor *getTargetActor() const {
        return _a;
    }
};

/* ===================================================================== *
   ActorPropertyTarget class
 * ===================================================================== */

class ActorPropertyTarget : public ActorTarget {
    ActorPropertyID     _actorProp;

public:
    //  Constructor -- initial construction
    ActorPropertyTarget(ActorPropertyID aProp) : _actorProp(aProp) {}

    ActorPropertyTarget(Common::SeekableReadStream *stream);

    //  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 target
    int16 getType() const;

    //  Virtual function returning the sizeof this target
    size_t size() const;

    //  Create a copy of this target at the specified address
    void clone(void *mem) const;

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

    bool isTarget(Actor *testActor) const;
};

/* ===================================================================== *
   Constants
 * ===================================================================== */

//  This const and typedef are used to define an area of memory large enough
//  to contain any target.  The sizeof( LocationTarget ) is used because
//  the LocationTarget takes the most memory.

const size_t    kTargetBytes = sizeof(LocationTarget);

typedef uint8 TargetPlaceHolder[kTargetBytes];

} // end of namespace Saga2

#endif