Initial commit

engines/saga2/sensor.h

@@ -0,0 +1,444 @@
+/* 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_SENSOR_H
+#define SAGA2_SENSOR_H
+
+namespace Saga2 {
+
+const uint32 kNonActorSenseFlags = kActorSeeInvis;
+
+//const size_t maxSensorSize = 24;
+const size_t kMaxSensorSize = 48;
+
+//  This constant represents the maximum sense range for an object.
+//  Zero means an infinite range.
+const int16 kMaxSenseRange = 0;
+
+//  Integers representing sensor types
+enum SensorType {
+	kProtaganistSensor,
+	kSpecificObjectSensor,
+	kObjectPropertySensor,
+	kSpecificActorSensor,
+	kActorPropertySensor,
+	kEventSensor
+};
+
+//  Sensors will be checked every 5 frames
+const int16 kSensorCheckRate = 5;
+
+/* ===================================================================== *
+   Function prototypes
+ * ===================================================================== */
+
+struct GameEvent;
+
+//  Allocate a new SensorList
+void newSensorList(SensorList *s);
+//  Deallocate a SensorList
+void deleteSensorList(SensorList *p);
+
+//  Fetch a specified object's SensorList
+SensorList *fetchSensorList(GameObject *obj);
+
+//  Allocate a new Sensor
+void newSensor(Sensor *s);
+//  Allocate a new Sensor with a specified starting check counter
+void newSensor(Sensor *s, int16 ctr);
+//  Deallocate a Sensor
+void deleteSensor(Sensor *p);
+
+//  Check all active sensors
+void checkSensors();
+//  Evaluate an event for all active sensors
+void assertEvent(const GameEvent &ev);
+
+//  Initialize the sensors
+void initSensors();
+void saveSensors(Common::OutSaveFile *outS);
+void loadSensors(Common::InSaveFile *in);
+//  Cleanup the active sensors
+void cleanupSensors();
+
+/* ===================================================================== *
+   GameEvent struct
+ * ===================================================================== */
+
+struct GameEvent {
+	int16           type;
+	GameObject      *directObject,
+	                *indirectObject;
+};
+
+/* ===================================================================== *
+   SenseInfo struct
+ * ===================================================================== */
+
+struct SenseInfo {
+	GameObject      *sensedObject;
+};
+
+/* ===================================================================== *
+   SensorList Class
+ * ===================================================================== */
+
+class SensorList {
+	GameObject      *_obj;
+
+public:
+	Common::List<Sensor *> _list;
+
+public:
+	//  Constructor -- initial construction
+	SensorList(GameObject *o) : _obj(o) {
+		newSensorList(this);
+		debugC(1, kDebugSensors, "Adding SensorList %p to %d (%s) (total %d)",
+		       (void *)this, o->thisID(), o->objName(), _list.size());
+	}
+
+	~SensorList() {
+		deleteSensorList(this);
+		debugC(1, kDebugSensors, "Deleting SensorList %p of %d (%s) (total %d)",
+		       (void *)this, _obj->thisID(), _obj->objName(), _list.size());
+	}
+
+	SensorList(Common::InSaveFile *in);
+
+	//  Return the number of bytes needed to archive this object in
+	//  a buffer
+	static int32 archiveSize() {
+		return sizeof(ObjectID);
+	}
+
+	void write(Common::MemoryWriteStreamDynamic *out);
+
+	GameObject *getObject() {
+		return _obj;
+	}
+};
+
+/* ===================================================================== *
+   Sensor Class
+ * ===================================================================== */
+
+class Sensor {
+public:
+	GameObject      *_obj;
+	SensorID        _id;
+	int16           _range;
+
+	int16       _checkCtr;
+	bool _active;
+
+public:
+	//  Constructor -- initial construction
+	Sensor(GameObject *o, SensorID sensorID, int16 rng) : _obj(o), _id(sensorID), _range(rng), _active(true) {
+		newSensor(this);
+		SensorList *sl = fetchSensorList(o);
+		debugC(1, kDebugSensors, "Adding Sensor %p to %d (%s) (list = %p, total = %d)",
+		       (void *)this, o->thisID(), o->objName(), (void *)sl, (sl != nullptr) ? sl->_list.size() : -1);
+	}
+
+	Sensor(Common::InSaveFile *in, int16 ctr);
+
+	//  Virtural destructor
+	virtual ~Sensor() {
+		deleteSensor(this);
+		SensorList *sl = fetchSensorList(_obj);
+		debugC(1, kDebugSensors, "Deleting Sensor %p of %d (%s) (list = %p, total = %d)",
+		       (void *)this, _obj->thisID(), _obj->objName(), (void *)sl, (sl != nullptr) ? sl->_list.size() : -1);
+	}
+
+	virtual void write(Common::MemoryWriteStreamDynamic *out);
+
+	//  Return an integer representing the type of this sensor
+	virtual int16 getType() = 0;
+
+	GameObject *getObject() {
+		return _obj;
+	}
+	SensorID thisID() {
+		return _id;
+	}
+	int16 getRange() {
+		return _range;
+	}
+
+	//  Determine if the object can sense what it's looking for
+	virtual bool check(SenseInfo &info, uint32 senseFlags) = 0;
+
+	//  Evaluate an event to determine if the object is waiting for it
+	virtual bool evaluateEvent(const GameEvent &event) = 0;
+};
+
+/* ===================================================================== *
+   ProtaganistSensor Class
+ * ===================================================================== */
+
+class ProtaganistSensor : public Sensor {
+public:
+	//  Constructor -- initial construction
+	ProtaganistSensor(GameObject *o, SensorID sensorID, int16 rng) :
+		Sensor(o, sensorID, rng) {
+	}
+
+	ProtaganistSensor(Common::InSaveFile *in, int16 ctr) : Sensor(in, ctr) {
+		debugC(3, kDebugSaveload, "Loading ProtagonistSensor");
+	}
+
+	//  Return an integer representing the type of this sensor
+	int16 getType();
+
+	//  Determine if the object can sense what it's looking for
+	bool check(SenseInfo &info, uint32 senseFlags);
+
+	//  Evaluate an event to determine if the object is waiting for it
+	bool evaluateEvent(const GameEvent &event);
+};
+
+/* ===================================================================== *
+   ObjectSensor Class
+ * ===================================================================== */
+
+class ObjectSensor : public Sensor {
+public:
+	//  Constructor -- initial construction
+	ObjectSensor(GameObject *o, SensorID sensorID, int16 rng) :
+		Sensor(o, sensorID, rng) {
+	}
+
+	ObjectSensor(Common::InSaveFile *in, int16 ctr) : Sensor(in, ctr) {}
+
+	//  Determine if the object can sense what it's looking for
+	bool check(SenseInfo &info, uint32 senseFlags);
+
+	//  Evaluate an event to determine if the object is waiting for it
+	bool evaluateEvent(const GameEvent &event);
+
+private:
+	//  Determine if an object meets the search criteria
+	virtual bool isObjectSought(GameObject *obj) = 0;
+};
+
+/* ===================================================================== *
+   SpecificObjectSensor Class
+ * ===================================================================== */
+
+class SpecificObjectSensor : public ObjectSensor {
+	ObjectID        _soughtObjID;
+
+public:
+	//  Constructor -- initial construction
+	SpecificObjectSensor(
+	    GameObject  *o,
+	    SensorID    sensorID,
+	    int16       rng,
+	    ObjectID    objToSense) :
+		ObjectSensor(o, sensorID, rng),
+		_soughtObjID(objToSense) {
+	}
+
+	SpecificObjectSensor(Common::InSaveFile *in, int16 ctr);
+
+	//  Return the number of bytes needed to archive this object in
+	//  a buffer
+	int32 archiveSize();
+
+	void write(Common::MemoryWriteStreamDynamic *out);
+
+	//  Return an integer representing the type of this sensor
+	int16 getType();
+
+	//  Determine if the object can sense what it's looking for
+	bool check(SenseInfo &info, uint32 senseFlags);
+
+private:
+	//  Determine if an object meets the search criteria
+	bool isObjectSought(GameObject *obj);
+};
+
+/* ===================================================================== *
+   ObjectPropertySensor Class
+ * ===================================================================== */
+
+class ObjectPropertySensor : public ObjectSensor {
+	ObjectPropertyID    _objectProperty;
+
+public:
+	//  Constructor -- initial construction
+	ObjectPropertySensor(
+	    GameObject          *o,
+	    SensorID            sensorID,
+	    int16               rng,
+	    ObjectPropertyID    propToSense) :
+		ObjectSensor(o, sensorID, rng),
+		_objectProperty(propToSense) {
+	}
+
+	ObjectPropertySensor(Common::InSaveFile *in, int16 ctr);
+
+	//  Return the number of bytes needed to archive this object in
+	//  a buffer
+	int32 archiveSize();
+
+	void write(Common::MemoryWriteStreamDynamic *out);
+
+	//  Return an integer representing the type of this sensor
+	int16 getType();
+
+private:
+	//  Determine if an object meets the search criteria
+	bool isObjectSought(GameObject *obj);
+};
+
+/* ===================================================================== *
+   ActorSensor Class
+ * ===================================================================== */
+
+class ActorSensor : public ObjectSensor {
+public:
+	//  Constructor -- initial construction
+	ActorSensor(GameObject *o, SensorID sensorID, int16 rng) :
+		ObjectSensor(o, sensorID, rng) {
+	}
+
+	ActorSensor(Common::InSaveFile *in, int16 ctr) : ObjectSensor(in, ctr) {}
+
+private:
+	//  Determine if an object meets the search criteria
+	bool isObjectSought(GameObject *obj);
+
+	//  Determine if an actor meets the search criteria
+	virtual bool isActorSought(Actor *a) = 0;
+};
+
+/* ===================================================================== *
+   SpecificActorSensor Class
+ * ===================================================================== */
+
+class SpecificActorSensor : public ActorSensor {
+	Actor       *_soughtActor;
+
+public:
+	//  Constructor -- initial construction
+	SpecificActorSensor(
+	    GameObject  *o,
+	    SensorID    sensorID,
+	    int16       rng,
+	    Actor       *actorToSense) :
+		ActorSensor(o, sensorID, rng),
+		_soughtActor(actorToSense) {
+	}
+
+	SpecificActorSensor(Common::InSaveFile *in, int16 ctr);
+
+	//  Return the number of bytes needed to archive this object in
+	//  a buffer
+	int32 archiveSize();
+
+	void write(Common::MemoryWriteStreamDynamic *out);
+
+	//  Return an integer representing the type of this sensor
+	int16 getType();
+
+	//  Determine if the object can sense what it's looking for
+	bool check(SenseInfo &info, uint32 senseFlags);
+
+private:
+	//  Determine if an actor meets the search criteria
+	bool isActorSought(Actor *a);
+};
+
+/* ===================================================================== *
+   ActorPropertySensor Class
+ * ===================================================================== */
+
+class ActorPropertySensor : public ActorSensor {
+	ActorPropertyID     _actorProperty;
+
+public:
+	//  Constructor -- initial construction
+	ActorPropertySensor(
+	    GameObject          *o,
+	    SensorID            sensorID,
+	    int16               rng,
+	    ActorPropertyID     propToSense) :
+		ActorSensor(o, sensorID, rng),
+		_actorProperty(propToSense) {
+	}
+
+	ActorPropertySensor(Common::InSaveFile *in, int16 ctr);
+
+	//  Return the number of bytes needed to archive this object in
+	//  a buffer
+	int32 archiveSize();
+
+	void write(Common::MemoryWriteStreamDynamic *out);
+
+	//  Return an integer representing the type of this sensor
+	int16 getType();
+
+private:
+	//  Determine if an actor meets the search criteria
+	bool isActorSought(Actor *a);
+};
+
+/* ===================================================================== *
+   EventSensor Class
+ * ===================================================================== */
+
+class EventSensor : public Sensor {
+	int16               _eventType;
+
+public:
+	//  Constructor -- initial construction
+	EventSensor(
+	    GameObject      *o,
+	    SensorID        sensorID,
+	    int16           rng,
+	    int16           type);
+
+	EventSensor(Common::InSaveFile *in, int16 ctr);
+
+	//  Return the number of bytes needed to archive this object in
+	//  a buffer
+	int32 archiveSize();
+
+	void write(Common::MemoryWriteStreamDynamic *out);
+
+	//  Return an integer representing the type of this sensor
+	int16 getType();
+
+	//  Determine if the object can sense what it's looking for
+	bool check(SenseInfo &info, uint32 senseFlags);
+
+	//  Evaluate an event to determine if the object is waiting for it
+	bool evaluateEvent(const GameEvent &event);
+};
+
+} // end of namespace Saga2
+
+#endif