spell.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/>.
 *
 */
 
#ifndef ULTIMA4_GAME_SPELL_H
#define ULTIMA4_GAME_SPELL_H
 
#include "ultima/ultima4/game/context.h"
#include "ultima/ultima4/map/location.h"
#include "ultima/ultima4/map/map.h"
#include "ultima/ultima4/filesys/savegame.h"
#include "ultima/ultima4/sound/sound.h"
 
namespace Ultima {
namespace Ultima4 {
 
enum SpellCastError {
    CASTERR_NOERROR,            /* success */
    CASTERR_NOMIX,              /* no mixture available */
    CASTERR_MPTOOLOW,           /* caster doesn't have enough mp */
    CASTERR_FAILED,             /* the spell failed */
    CASTERR_WRONGCONTEXT,       /* generic 'wrong-context' error (generrally finds the correct
                                   context error message on its own) */
    CASTERR_COMBATONLY,         /* e.g. spell must be cast in combat */
    CASTERR_DUNGEONONLY,        /* e.g. spell must be cast in dungeons */
    CASTERR_WORLDMAPONLY       /* e.g. spell must be cast on the world map */
};
 
enum EnergyFieldType {
    ENERGYFIELD_NONE,
    ENERGYFIELD_FIRE,
    ENERGYFIELD_LIGHTNING,
    ENERGYFIELD_POISON,
    ENERGYFIELD_SLEEP
};
 
class Ingredients {
public:
    Ingredients();
    bool addReagent(Reagent reagent);
    bool removeReagent(Reagent reagent);
    int getReagent(Reagent reagent) const;
    void revert();
    bool checkMultiple(int mixes) const;
    void multiply(int mixes);
 
private:
    unsigned short _reagents[REAG_MAX];
};
 
class Spells;
typedef int (Spells::*SpellProc)(int);
 
struct Spell {
    enum Param {
        PARAM_NONE,             
        PARAM_PLAYER,           
        PARAM_DIR,              
        PARAM_TYPEDIR,          
        PARAM_PHASE,            
        PARAM_FROMDIR           
    };
 
    enum SpecialEffects {
        SFX_NONE,               
        SFX_INVERT,             
        SFX_TREMOR              
    };
 
    const char *_name;
    int _components;
    LocationContext _context;
    TransportContext _transportContext;
    SpellProc _spellFunc;
    Param _paramType;
    int _mp;
};
 
typedef void (*SpellEffectCallback)(int spell, int player, Sound sound);
#define N_SPELLS 26
 
class Spells {
private:
    static const Spell SPELL_LIST[N_SPELLS];
    SpellEffectCallback spellEffectCallback;
private:
    int spellAwaken(int player);
    int spellBlink(int dir);
    int spellCure(int player);
    int spellDispel(int dir);
    int spellEField(int param);
    int spellFireball(int dir);
    int spellGate(int phase);
    int spellHeal(int player);
    int spellIceball(int dir);
    int spellJinx(int unused);
    int spellKill(int dir);
    int spellLight(int unused);
    int spellMMissle(int dir);
    int spellNegate(int unused);
    int spellOpen(int unused);
    int spellProtect(int unused);
    int spellRez(int player);
    int spellQuick(int unused);
    int spellSleep(int unused);
    int spellTremor(int unused);
    int spellUndead(int unused);
    int spellView(int unsued);
    int spellWinds(int fromdir);
    int spellXit(int unused);
    int spellYup(int unused);
    int spellZdown(int unused);
private:
    CombatController *spellCombatController();
 
    void spellMagicAttack(const Common::String &tilename, Direction dir, int minDamage, int maxDamage);
    bool spellMagicAttackAt(const Coords &coords, MapTile attackTile, int attackDamage);
 
    LocationContext spellGetContext(uint spell) const;
    TransportContext spellGetTransportContext(uint spell) const;
 
    bool isDebuggerActive() const;
public:
    Spells();
 
    ~Spells();
 
    void spellSetEffectCallback(SpellEffectCallback callback);
 
    void spellEffect(int spell, int player, Sound sound) {
        (spellEffectCallback)(spell, player, sound);
    }
 
    int spellMix(uint spell, const Ingredients *ingredients);
 
    bool spellCast(uint spell, int character, int param, SpellCastError *error, bool spellEffect);
 
    Common::String spellGetErrorMessage(uint spell, SpellCastError error);
 
    const char *spellGetName(uint spell) const;
 
    SpellCastError spellCheckPrerequisites(uint spell, int character);
    Spell::Param spellGetParamType(uint spell) const;
    int spellGetRequiredMP(uint spell) const;
    const Spell *getSpell(int i) const;
};
 
extern Spells *g_spells;
 
} // End of namespace Ultima4
} // End of namespace Ultima
 
#endif