Initial commit

engines/saga2/speldefs.h

@@ -0,0 +1,359 @@
+/* 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_SPELDEFS_H
+#define SAGA2_SPELDEFS_H
+
+#include "saga2/tile.h"
+#include "saga2/objects.h"
+
+namespace Saga2 {
+
+struct StorageSpellTarget;
+class SpellInstance;
+struct StorageEffectron;
+class SpellDisplayPrototype;
+class EffectDisplayPrototype;
+struct ResourceSpellItem;
+struct StorageSpellInstance;
+
+/* ===================================================================== *
+   Constants
+ * ===================================================================== */
+
+// this determines the maimum nuber of spells the system can handle.
+
+#define MAX_SPELLS 128
+#define continuouslyImplemented (-1)
+
+/* ===================================================================== *
+   Types
+ * ===================================================================== */
+
+//-----------------------------------------------------------------------
+//	index into the Visual Effect list
+
+typedef uint16 EffectID;
+
+//-----------------------------------------------------------------------
+//	Spell Sprite Pose
+
+typedef uint16 SpellPoseID;
+
+//-----------------------------------------------------------------------
+//	height to use for collision detection
+
+typedef uint8 spellHeight;
+
+//-----------------------------------------------------------------------
+//	breadth to use for collision detection
+
+typedef uint8 spellBreadth;
+
+//-----------------------------------------------------------------------
+//	SpellAge type
+
+typedef int32 SpellAge;
+
+//-----------------------------------------------------------------------
+//	SpellPositionSeed type
+//    Both a location indicator and a direction indicator can be
+//    gotten from this type
+
+typedef int32 SpellPositionSeed;
+
+// Get the Position part of the seed
+inline uint16 SpellPosition(SpellPositionSeed sps) {
+	return sps & 0xFFFF;
+}
+
+// Get the Direction part of the seed (used in explosions)
+inline uint16 SpellDirection(SpellPositionSeed sps) {
+	return ((sps >> 16) & 0xFFFF);
+}
+
+//-----------------------------------------------------------------------
+//	SpellSpritationSeed type
+
+typedef int32 SpellSpritationSeed;
+
+//-----------------------------------------------------------------------
+//	SpellCaster type (identical to GameObject)
+
+typedef GameObject SpellCaster;
+
+/* ===================================================================== *
+   Misplaced
+ * ===================================================================== */
+
+// some cheesy inlines for extracting location info
+//   they should probably be member functions of other classes but
+//   I didn't want to modify those headers
+
+inline TilePoint TAGPos(ActiveItem *ai) {
+	if (ai == NULL) return Nowhere;
+	assert(ai->_data.itemType == kActiveTypeInstance);
+	return TilePoint(
+	           ai->_data.instance.u << kTileUVShift,
+	           ai->_data.instance.v << kTileUVShift,
+	           ai->_data.instance.h);
+}
+
+inline TilePoint objPos(GameObject *go) {
+	if (go == NULL) return Nowhere;
+	TilePoint t = go->getWorldLocation();
+	t.z += go->proto()->height / 2;
+	return t;
+}
+
+/* ===================================================================== *
+   another type
+ * ===================================================================== */
+
+//-----------------------------------------------------------------------
+//	SpellTarget type
+//    allows access to several types of targets with the same code
+
+class SpellTarget {
+	friend struct StorageSpellTarget;
+
+public :
+	enum spellTargetType {
+		kSpellTargetNone         = 0,        // invalid
+		kSpellTargetPoint,                   // targeted on a particular point
+		kSpellTargetObjectPoint,             // targeted on an object's location
+		kSpellTargetObject,                  // targeted on an object (tracking)
+		kSpellTargetTAG                      // targeted on an object (tracking)
+	};
+
+private:
+	spellTargetType _type;
+
+	TilePoint       _loc;
+	GameObject      *_obj;
+	ActiveItem      *_tag;
+
+public:
+	SpellTarget     *_next;
+
+	SpellTarget() {
+		_type = kSpellTargetNone;
+		_obj = nullptr;
+		_loc.u = 0;
+		_loc.v = 0;
+		_loc.z = 0;
+		_next = nullptr;
+		_tag = nullptr;
+	}
+
+	// This constructor is for non-tracking targets
+	SpellTarget(GameObject &object) {
+		_type = kSpellTargetObjectPoint;
+		_loc = object.getWorldLocation();
+		_loc.z += object.proto()->height / 2;
+		_next = nullptr;
+		_obj = &object;
+		_tag = nullptr;
+	}
+
+	// This constructor is for tracking targets
+	SpellTarget(GameObject *object) {
+		_type = kSpellTargetObject;
+		_obj = object;
+		_next = nullptr;
+		_tag = nullptr;
+	}
+	SpellTarget(TilePoint &tp) {
+		_type = kSpellTargetPoint;
+		_loc = tp;
+		_next = nullptr;
+		_tag = nullptr;
+		_obj = nullptr;
+	}
+	SpellTarget(ActiveItem *ai) {
+		_type = kSpellTargetTAG;
+		_tag = ai;
+		_next = nullptr;
+		_tag = nullptr;
+		_obj = nullptr;
+	}
+	SpellTarget(StorageSpellTarget &sst);
+
+	SpellTarget &operator=(const SpellTarget &src) {
+		_type = src._type;
+		_loc = src._loc;
+		_obj = src._obj;
+		_tag = src._tag;
+		_next = src._next;
+		return *this;
+	}
+	SpellTarget(const SpellTarget &src) {
+		_type = src._type;
+		_loc = src._loc;
+		_obj = src._obj;
+		_tag = src._tag;
+		_next = src._next;
+	}
+
+	~SpellTarget() {
+		if (_next)
+			delete _next;
+		_next = nullptr;
+	};
+
+	TilePoint getPoint() {
+		switch (_type) {
+		case kSpellTargetPoint       :
+		case kSpellTargetObjectPoint :
+			return _loc;
+		case kSpellTargetObject      :
+			return objPos(_obj);
+		case kSpellTargetTAG         :
+			return TAGPos(_tag);
+		case kSpellTargetNone        :
+		default                     :
+			return Nowhere;
+		}
+	}
+
+	spellTargetType getType() {
+		return _type;
+	}
+
+	GameObject *getObject() {
+		assert(_type == kSpellTargetObject);
+		return _obj;
+	}
+
+	ActiveItem *getTAG() {
+		assert(_type == kSpellTargetTAG);
+		return _tag;
+	}
+
+};
+
+//-----------------------------------------------------------------------
+//	Effectron flags
+
+enum EffectronFlagMasks {
+	kEffectronOK     = 0,
+	kEffectronHidden = (1 << 0),
+	kEffectronDead   = (1 << 1),
+	kEffectronBumped = (1 << 2)
+};
+
+typedef uint32 EffectronFlags;
+
+//-----------------------------------------------------------------------
+//	EffectronSize Type
+
+typedef Extent16 EffectronSize;
+
+//-----------------------------------------------------------------------
+//	Effectron
+
+class Effectron {
+	friend struct StorageEffectron;
+
+	EffectronFlags          _flags;            // this effectrons status
+	EffectronSize           _size;             // this effectrons size
+	Rect16                  _hitBox;           // hitbox for clicking this item
+	// dispnode needs the latter
+
+public:
+	SpellInstance           *_parent;          // pointer back to the spell that spawned this
+
+	int16                   _partno;           // Which effectron in a group this represents
+	Point16                 _screenCoords;     // screen coordinates last drawn at
+
+	TilePoint               _start,            // travelling from
+	                        _finish,           // travelling to
+	                        _current,          // current position
+	                        _velocity,         // current velocity
+	                        _acceleration;     // current acceleration
+	uint16                  _totalSteps,       // discrete jumps in the path
+	                        _stepNo;           // current jump
+
+	spellHeight             _hgt;              // collision detection stuff
+	spellBreadth            _brd;
+
+	SpellPositionSeed       _pos;              // These three are part of an old way of
+	SpellSpritationSeed     _spr;              // updating effectrons
+	SpellAge                _age;
+
+
+
+	Effectron();
+	Effectron(uint16 newPos, uint16 newDir);
+	Effectron(StorageEffectron &se, SpellInstance *si);
+
+	void drawEffect();
+	void updateEffect(int32 deltaTime);
+
+	inline TilePoint SpellPos() {
+		return _current;
+	}
+	inline int32 spriteID()     {
+		return _spr;
+	}
+
+	inline void hide()     {
+		_flags |= kEffectronHidden;
+	}
+	inline void unhide()   {
+		_flags &= (~kEffectronHidden);
+	}
+	inline bool isHidden() const {
+		return _flags & kEffectronHidden;
+	}
+	inline void kill()     {
+		_flags |= kEffectronDead;
+	}
+	inline int isDead() const      {
+		return _flags & kEffectronDead;
+	}
+	inline void bump();
+	inline int isBumped() const        {
+		return _flags & kEffectronBumped;
+	}
+
+	inline GameWorld *world() const;
+	inline int16 getMapNum() const;
+
+	inline EffectID                 spellID();
+	inline SpellDisplayPrototype    *spell();
+	inline EffectID                 effectID();
+	inline EffectDisplayPrototype   *effect();
+	inline EffectronFlags       staCall();
+	inline TilePoint            posCall();
+	inline SpellSpritationSeed  sprCall();
+	inline spellHeight          hgtCall();
+	inline spellBreadth         brdCall();
+	inline void                 initCall(int16);
+};
+
+} // end of namespace Saga2
+
+#endif