mirror of
https://github.com/libretro/scummvm.git
synced 2025-02-05 02:17:05 +00:00
360 lines
9.5 KiB
C++
360 lines
9.5 KiB
C++
/* 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
|