scummvm/engines/saga2/spellio.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_SPELLIO_H
#define SAGA2_SPELLIO_H

namespace Saga2 {

class SpellTarget;
class Effectron;

class EffectDisplayPrototype;
class EffectDisplayPrototypeList;

class SpellDisplayPrototype;
class SpellDisplayPrototypeList;

class SpellStuff;

class SpellInstance;
class SpellDisplayList;

struct ResourceSpellItem ;
struct ResourceSpellEffect;
struct ResourceItemEffect;

struct StorageSpellTarget;
struct StorageSpellInstance;
struct StorageEffectron;

//-------------------------------------------------------------------
// ResourceSpellItem
//   Spell configuration info is loaded from the resfile in these

struct ResourceSpellItem {
	int16   spell;                  // Spell ID
	int16   effect;                 // Effect ID
	int16   effectronElasticity;    // Effectron elasticity
	int16   cm1;             // effectron count
	int16   maxAge;                 // max age
	int16   implAge;                // implementation age
	int16   baseSprite;             // sprite ID
	int16   spriteCount;            // sprite count
	int16   baseSprite2;             // sprite ID
	int16   spriteCount2;            // sprite count
	int16   cm0;                    // color map b0
	int16   soundID;                    // color map b1
	int16   targs;                  // targeting bits
	int16   applys;                 // apply bits
	int16   manaType;               // mana ID
	int16   manaAmount;             // mana count
};

//-------------------------------------------------------------------
// ResourceSpellEffect
//   Since spells can have multiple effects, they are stored
//   separately

struct ResourceSpellEffect {
	int16 spell;                // spell ID
	int16 effectGroup;                // effect group
	int16 effectType;                // effect ID
	int16 targeting;                // targeting
	int16 baseDice;                // base dice
	int16 skillDice;                // skill dice
	int16 attribModifier;                // attrib change
	int16 flagSet;                // Set/clear
	int16 enchTimeLo;                // min enchant
	int16 enchTimeHi;                // max enchant
	int16 diceSides;
};

//-------------------------------------------------------------------
// Similar struct for weapon effects

struct ResourceItemEffect {
	int16 item;                // spell ID
	int16 effectGroup;                // effect group
	int16 effectType;                // effect ID
	int16 targeting;                // targeting
	int16 baseDice;                // base dice
	int16 skillDice;                // skill dice
	int16 baseDamage;                // attrib change
	int16 skillDamage;                // attrib change
	int16 reserved0;                // min enchant
	int16 reserved1;                // min enchant
	int16 diceSides;
};

//-------------------------------------------------------------------
// Serialized spell target

struct StorageSpellTarget {
	int16           type;

	TilePoint       loc;
	ObjectID        obj;
	ActiveItemID    tag;

	StorageSpellTarget();
	StorageSpellTarget(SpellTarget &st);

	void read(Common::InSaveFile *in);
	void write(Common::MemoryWriteStreamDynamic *out);
};

//-------------------------------------------------------------------
// Serialized spell instance

struct StorageSpellInstance {
	int32                   implementAge;   // age at which to implement the spell effects
	uint16                  effect;        // effect prototype of the current effect
	SpellID                 dProto;        // effect prototype of the current effect
	ObjectID                caster;

	StorageSpellTarget      target;
	ObjectID                world;
	int32                   age;
	SpellID                 spell;
	int32                   maxAge;
	int16                   effSeq;         // which effect in a sequence is being played
	int16                   eListSize;

	StorageSpellInstance();
	StorageSpellInstance(SpellInstance &si);

	void read(Common::InSaveFile *in);
	void write(Common::MemoryWriteStreamDynamic *out);
};

//-------------------------------------------------------------------
// Serialized spell sprite

struct StorageEffectron {
	uint32                  flags;
	Extent16                size;
	Rect16                  hitBox;           // hitbox for clicking this item

	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

	int16                   hgt;              // collision detection stuff
	int16                   brd;

	int32                   pos;              // These three are part of an old way of
	int32                   spr;              // updating effectrons
	int32                   age;

	StorageEffectron();
	StorageEffectron(Effectron &e);

	void read(Common::InSaveFile *in);
	void write(Common::MemoryWriteStreamDynamic *out);
};

} // end of namespace Saga2

#endif