____                _       __
    / __ )____  _____   | |     / /___ ___________
   / __  / __ \/ ___/   | | /| / / __ `/ ___/ ___/
  / /_/ / /_/ (__  )    | |/ |/ / /_/ / /  (__  )
 /_____/\____/____/     |__/|__/\__,_/_/  /____/

       A futuristic real-time strategy game.
          This file is part of Bos Wars.

(C) Copyright 2001-2007 by the Bos Wars and Stratagus Project. Distributed under the "GNU General Public License"

---

spells.h

Go to the documentation of this file.

//     ____                _       __               
//    / __ )____  _____   | |     / /___ ___________
//   / __  / __ \/ ___/   | | /| / / __ `/ ___/ ___/
//  / /_/ / /_/ (__  )    | |/ |/ / /_/ / /  (__  ) 
// /_____/\____/____/     |__/|__/\__,_/_/  /____/  
//                                              
//       A futuristic real-time strategy game.
//          This file is part of Bos Wars.
//
//
//      (c) Copyright 1999-2007 by Vladi Belperchinov-Shabanski,
//                                 Joris DAUPHIN, and Jimmy Salmon
//
//      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; only version 2 of the License.
//
//      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, write to the Free Software
//      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
//      02111-1307, USA.

#ifndef __SPELLS_H__
#define __SPELLS_H__


/*----------------------------------------------------------------------------
--  Includes
----------------------------------------------------------------------------*/

#include <string>
#include <vector>
#include "unitsound.h"

/*----------------------------------------------------------------------------
--  Declarations
----------------------------------------------------------------------------*/

class CUnit;
class CUnitType;
class CPlayer;
struct lua_State;
class SpellType;
class MissileType;

/*----------------------------------------------------------------------------
--  Definitons
----------------------------------------------------------------------------*/

enum TargetType {
    TargetSelf,
    TargetPosition,
    TargetUnit
};

enum LocBaseType {
    LocBaseCaster,
    LocBaseTarget
};

class SpellActionMissileLocation {
public:
    SpellActionMissileLocation(LocBaseType base) : Base(base), AddX(0), AddY(0),
        AddRandX(0), AddRandY(0) {} ;

    LocBaseType Base;   
    int AddX;           
    int AddY;           
    int AddRandX;       
    int AddRandY;       
};

class SpellActionTypeAdjustVariable {
public:
    SpellActionTypeAdjustVariable() : Enable(0), Value(0), Max(0), Increase(0),
        ModifEnable(0), ModifValue(0), ModifMax(0), ModifIncrease(0),
        InvertEnable(0), AddValue(0), AddMax(0), AddIncrease(0), IncreaseTime(0),
        TargetIsCaster(0) {};

    int Enable;                 
    int Value;                  
    int Max;                    
    int Increase;               

    char ModifEnable;           
    char ModifValue;            
    char ModifMax;              
    char ModifIncrease;         

    char InvertEnable;          
    int AddValue;               
    int AddMax;                 
    int AddIncrease;            
    int IncreaseTime;           
    char TargetIsCaster;        
};


class SpellActionType {
public:
    SpellActionType(int mod = 0) : ModifyManaCaster(mod) {};
    virtual ~SpellActionType() {};

    virtual int Cast(CUnit *caster, const SpellType *spell,
        CUnit *target, int x, int y) = 0;

    const int ModifyManaCaster;
};

//
//  Specific spells.
//

class AreaAdjustVitals : public SpellActionType
{
public:
    AreaAdjustVitals() : HP(0), Mana(0) {};
    virtual int Cast(CUnit *caster, const SpellType *spell,
        CUnit *target, int x, int y);

    int HP;         
    int Mana;       
} ;

class SpawnMissile : public SpellActionType {
public:
    SpawnMissile() : Damage(0), TTL(-1), Delay(0),
        StartPoint(LocBaseCaster), EndPoint(LocBaseTarget), Missile(0) {};
    virtual int Cast(CUnit *caster, const SpellType *spell,
        CUnit *target, int x, int y);

    int Damage;                             
    int TTL;                                
    int Delay;                              
    SpellActionMissileLocation StartPoint;  
    SpellActionMissileLocation EndPoint;    
    MissileType *Missile;                   
};

class Demolish : public SpellActionType {
public:
    Demolish() : Damage(0), Range(0) {};
    virtual int Cast(CUnit *caster, const SpellType *spell,
        CUnit *target, int x, int y);

    int Damage; 
    int Range;  
};

class AreaBombardment : public SpellActionType {
public:
    AreaBombardment() : Fields(0), Shards(0), Damage(0),
        StartOffsetX(0), StartOffsetY(0), Missile(NULL) {};
    virtual int Cast(CUnit *caster, const SpellType *spell,
        CUnit *target, int x, int y);

    int Fields;             
    int Shards;             
    int Damage;             
    int StartOffsetX;       
    int StartOffsetY;       
    MissileType *Missile;   
};

class SpawnPortal : public SpellActionType {
public:
    SpawnPortal() : PortalType(0) {};
    virtual int Cast(CUnit *caster, const SpellType *spell,
        CUnit *target, int x, int y);

    CUnitType *PortalType;   
};

class AdjustVariable : public SpellActionType {
public:
    AdjustVariable() : Var (NULL) {};
    ~AdjustVariable() { delete [] (this->Var); };
    virtual int Cast(CUnit *caster, const SpellType *spell,
        CUnit *target, int x, int y);

    SpellActionTypeAdjustVariable *Var;
};

class AdjustVitals : public SpellActionType {
public:
    AdjustVitals() : SpellActionType(1), HP(0), Mana(0), MaxMultiCast(0) {};
    virtual int Cast(CUnit *caster, const SpellType *spell,
        CUnit *target, int x, int y);

    int HP;         
    int Mana;       


    int MaxMultiCast;
};

class Polymorph : public SpellActionType {
public:
    Polymorph() : SpellActionType(1), NewForm(NULL), PlayerNeutral(0) {};
    virtual int Cast(CUnit *caster, const SpellType *spell,
        CUnit *target, int x, int y);

    CUnitType *NewForm;         
    int PlayerNeutral;          
    // TODO: temporary polymorphs would be awesome, but hard to implement
};

class Summon : public SpellActionType {
public:
    Summon() : SpellActionType(1), UnitType(NULL), TTL(0), RequireCorpse(0) {};
    virtual int Cast(CUnit *caster, const SpellType *spell,
        CUnit *target, int x, int y);

    CUnitType *UnitType;    
    int TTL;                
    int RequireCorpse;      
};

class Capture : public SpellActionType {
public:
    Capture() : SacrificeEnable(0), Damage(0), DamagePercent(0) {};
    virtual int Cast(CUnit *caster, const SpellType *spell,
        CUnit *target, int x, int y);

    char SacrificeEnable; 
    int Damage;           
    int DamagePercent;    

};

/*
** *******************
** Target definition.
** *******************
*/

class Target {
public:
    Target(TargetType type, CUnit *unit, int x, int y) :
        Type(type), Unit(unit), X(x), Y(y) {}

    TargetType Type;                  
    CUnit *Unit;                      
    int X;                            
    int Y;                            
};

/*
** *******************
** Conditions definition.
** *******************
*/

class ConditionInfoVariable {
public:
    ConditionInfoVariable() : Enable(0), MinValue(0), MaxValue(0),
        MinMax(0), MinValuePercent(0), MaxValuePercent(0),
        ConditionApplyOnCaster(0) {};

    char Enable;                

    int MinValue;               
    int MaxValue;               
    int MinMax;                 
    int MinValuePercent;        
    int MaxValuePercent;        

    char ConditionApplyOnCaster; 
    // FIXME : More (increase, MaxMax) ?
};

class ConditionInfo {
public:
    ConditionInfo() : Alliance(0), Opponent(0), TargetSelf(0),
        Building(0), Organic(0), Variable(NULL) {};
    ~ConditionInfo() {
        delete[] Variable;
    };

    //
    //  Conditions that check specific flags. Possible values are the defines below.
    //
#define CONDITION_FALSE 1
#define CONDITION_TRUE  0
#define CONDITION_ONLY  2
    char Alliance;          
    char Opponent;          
    char TargetSelf;        

    char Building;          
    char Organic;           

    ConditionInfoVariable *Variable;
    //
    //  @todo more? feel free to add, here and to
    //  @todo PassCondition, CclSpellParseCondition, SaveSpells
    //
};

class AutoCastInfo {
public:
    AutoCastInfo() : Range(0), Condition(0), Combat(0) {};
    ~AutoCastInfo() { delete Condition; };
    int Range;                   

    ConditionInfo *Condition;    

    int Combat;                  

};

class SpellType {
public:
    SpellType(int slot, const std::string &ident);
    ~SpellType();

    // Identification stuff
    std::string Ident;    
    std::string Name;     
    int Slot;             

    // Spell Specifications
    TargetType Target;          
    std::vector<SpellActionType *> Action; 

    int Range;                  
#define INFINITE_RANGE 0xFFFFFFF
    int ManaCost;               
    int RepeatCast;             

    int DependencyId;           
    ConditionInfo *Condition;   

    // Autocast informations. No AICast means the AI use AutoCast.
    AutoCastInfo *AutoCast;     
    AutoCastInfo *AICast;       

    // Graphics and sounds. Add something else here?
    SoundConfig SoundWhenCast;  
};

/*----------------------------------------------------------------------------
--  Variables
----------------------------------------------------------------------------*/

extern std::vector<SpellType *> SpellTypeTable;


/*----------------------------------------------------------------------------
--  Functions
----------------------------------------------------------------------------*/

extern void SpellCclRegister(void);

extern void InitSpells(void);

extern void CleanSpells(void);

extern bool SpellIsAvailable(const CPlayer *player, int SpellId);

extern bool CanCastSpell(const CUnit *caster, const SpellType *spell,
    const CUnit *target, int x, int y);

extern int SpellCast(CUnit *caster, const SpellType *spell,
    CUnit *target, int x, int y);

extern int AutoCastSpell(CUnit *caster, const SpellType *spell);

extern SpellType *SpellTypeByIdent(const std::string &ident);

extern char Ccl2Condition(lua_State *l, const char *value);


#endif // !__SPELLS_H__

---