Initial commit
This commit is contained in:
650
engines/saga2/target.h
Normal file
650
engines/saga2/target.h
Normal file
@@ -0,0 +1,650 @@
|
||||
/* 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 <) const {
|
||||
return _loc == lt._loc;
|
||||
}
|
||||
bool operator != (const LocationTarget <) 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
|
||||
Reference in New Issue
Block a user