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

       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"

---

unittype.h

Go to the documentation of this file.

//     ____                _       __               
//    / __ )____  _____   | |     / /___ ___________
//   / __  / __ \/ ___/   | | /| / / __ `/ ___/ ___/
//  / /_/ / /_/ (__  )    | |/ |/ / /_/ / /  (__  ) 
// /_____/\____/____/     |__/|__/\__,_/_/  /____/  
//                                              
//       A futuristic real-time strategy game.
//          This file is part of Bos Wars.
//
//
//      (c) Copyright 1998-2008 by Lutz Sammer 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 __UNITTYPE_H__
#define __UNITTYPE_H__


/*----------------------------------------------------------------------------
-- Documentation
----------------------------------------------------------------------------*/

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

#include "SDL.h"

#include <vector>
#include "upgrade_structs.h"
#include "unitsound.h"
#include "icons.h"

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

class CUnit;
class CUnitType;
class CPlayerColorGraphic;
class CConstruction;
class CAnimations;
class MissileType;
class CFile;
struct lua_State;
class LuaCallback;

CUnitType *UnitTypeByIdent(const std::string &ident);

class MissileConfig {
public:
    MissileConfig() : Missile(NULL) {}

    std::string Name;        
    MissileType *Missile;    
};

class CVariable {
public:
    CVariable() : Max(0), Value(0), Increase(0), Enable(0) {}

    int Max;           
    int Value;         
    char Increase;     
    char Enable;       
};

// Index for variable already defined.
enum {
    HP_INDEX,
    BUILD_INDEX,
    MANA_INDEX,
    TRANSPORT_INDEX,
    TRAINING_INDEX,
    GIVERESOURCE_INDEX,
    KILL_INDEX,
    ARMOR_INDEX,
    SIGHTRANGE_INDEX,
    ATTACKRANGE_INDEX,
    PIERCINGDAMAGE_INDEX,
    BASICDAMAGE_INDEX,
    POSX_INDEX,
    POSY_INDEX,
    RADAR_INDEX,
    RADARJAMMER_INDEX,
    AUTOREPAIRRANGE_INDEX,
    SLOT_INDEX,
    NVARALREADYDEFINED,
};


class CDecoVar {
public:

    CDecoVar() {};
    virtual ~CDecoVar() {};

    virtual void Draw(int x, int y, const CUnit *unit) const = 0;

    int Index;                  

    int OffsetX;                
    int OffsetY;                

    int OffsetXPercent;         
    int OffsetYPercent;         

    bool IsCenteredInX;         
    bool IsCenteredInY;         

    bool ShowIfNotEnable;       
    bool ShowWhenMax;           
    bool ShowOnlySelected;      

    bool HideNeutral;           
    bool HideAllied;            
    bool ShowOpponent;          
};

class CDecoVarSpriteBar : public CDecoVar
{
public:
    CDecoVarSpriteBar() : SpriteIndex(-1) {};
    virtual void Draw(int x, int y, const CUnit *unit) const;

    char SpriteIndex; 
// FIXME Sprite info. better way ?
};

enum UnitTypeType {
    UnitTypeLand,               
    UnitTypeFly,                
    UnitTypeNaval,              
};

enum DistanceTypeType {
    Equal,
    NotEqual,
    LessThan,
    LessThanEqual,
    GreaterThan,
    GreaterThanEqual,
};


class CBuildRestriction {
public:

    virtual ~CBuildRestriction() {} ;
    virtual void Init() {};
    virtual bool Check(const CUnitType *type, int x, int y, CUnit *&ontoptarget) const = 0;
};


class CBuildRestrictionAnd : public CBuildRestriction {
public:

    virtual ~CBuildRestrictionAnd() {
        for (std::vector<CBuildRestriction*>::const_iterator i = _or_list.begin();
                i != _or_list.end(); ++i) {
            delete *i;
        }
        _or_list.clear();
    } ;
    virtual void Init() {
        for (std::vector<CBuildRestriction*>::const_iterator i = _or_list.begin();
                i != _or_list.end(); ++i) {
            (*i)->Init();
        }
    };
    virtual bool Check(const CUnitType *type, int x, int y, CUnit *&ontoptarget) const;

    void push_back(CBuildRestriction *restriction) {
        _or_list.push_back(restriction);
    }

    std::vector<CBuildRestriction*> _or_list;
};



class CBuildRestrictionAddOn : public CBuildRestriction {
public:
    CBuildRestrictionAddOn() : OffsetX(0), OffsetY(0), Parent(NULL) {};
    virtual ~CBuildRestrictionAddOn() {};
    virtual void Init() {this->Parent = UnitTypeByIdent(this->ParentName);};
    virtual bool Check(const CUnitType *type, int x, int y, CUnit *&ontoptarget) const;

    int OffsetX;            
    int OffsetY;            
    std::string ParentName; 
    CUnitType *Parent;      
};

class CBuildRestrictionOnTop : public CBuildRestriction {
public:
    CBuildRestrictionOnTop() : Parent(NULL), ReplaceOnDie(0), ReplaceOnBuild(0) {};
    virtual ~CBuildRestrictionOnTop() {};
    virtual void Init() {this->Parent = UnitTypeByIdent(this->ParentName);};
    virtual bool Check(const CUnitType *type, int x, int y, CUnit *&ontoptarget) const;

    std::string ParentName; 
    CUnitType *Parent;      
    int ReplaceOnDie;       
    int ReplaceOnBuild;     
};

class CBuildRestrictionDistance : public CBuildRestriction {
public:
    CBuildRestrictionDistance() : Distance(0), RestrictType(NULL) {};
    virtual ~CBuildRestrictionDistance() {};
    virtual void Init() {this->RestrictType = UnitTypeByIdent(this->RestrictTypeName);};
    virtual bool Check(const CUnitType *type, int x, int y, CUnit *&ontoptarget) const;

    int Distance;        
    DistanceTypeType DistanceType;
    std::string RestrictTypeName;
    CUnitType *RestrictType;
};

class CUnitType {
public:
    CUnitType();
    ~CUnitType();

    std::string Ident;              
    std::string Name;               
    int Slot;                       
    std::string File;               
    std::string ShadowFile;         

    int Width;                      
    int Height;                     
    int OffsetX;                    
    int OffsetY;                    
    int DrawLevel;                  
    int ShadowWidth;                
    int ShadowHeight;               
    int ShadowOffsetX;              
    int ShadowOffsetY;              

    CAnimations *Animations;        
    int StillFrame;                 

    IconConfig Icon;                

    MissileConfig Missile;          
    MissileConfig Explosion;        

    LuaCallback *DeathExplosion;

    std::string CorpseName;         
    CUnitType *CorpseType;          

    CConstruction *Construction;    

    int RepairHP;                   

    int TileWidth;                  
    int TileHeight;                 
    int BoxWidth;                   
    int BoxHeight;                  
    int NumDirections;              
    int MinAttackRange;             
    int ReactRangeComputer;         
    int ReactRangePerson;           
    int Priority;                   
    int BurnPercent;                
    int BurnDamageRate;             
    int RepairRange;                
    char *CanCastSpell;             
    char *AutoCastActive;           
    bool CanTransport;              
    int MaxOnBoard;                 

    UnitTypeType UnitType;          
    int DecayRate;                  
    // TODO: not used
    int AnnoyComputerFactor;        
    int MouseAction;                
#define MouseActionNone      0      
#define MouseActionAttack    1      
#define MouseActionMove      2      
#define MouseActionHarvest   3      
#define MouseActionSpellCast 5      
#define MouseActionSail      6      
    int Points;                     
    int CanTarget;                  
#define CanTargetLand 1             
#define CanTargetSea  2             
#define CanTargetAir  4             

    unsigned Flip : 1;              
    unsigned Revealer : 1;          
    unsigned LandUnit : 1;          
    unsigned AirUnit : 1;           
    unsigned SeaUnit : 1;           
    unsigned ExplodeWhenKilled : 1; 
    unsigned Building : 1;          
    unsigned VisibleUnderFog : 1;   
    unsigned Coward : 1;            
    unsigned AttackFromTransporter : 1;  
    unsigned Vanishes : 1;          
    unsigned GroundAttack : 1;      
    unsigned ShoreBuilding : 1;     
    unsigned CanAttack : 1;         
    unsigned BuilderOutside : 1;    
    unsigned BuilderLost : 1;       
    unsigned CanHarvestFrom : 1;    
    unsigned Harvester : 1;         
    unsigned Neutral : 1;           

    unsigned SelectableByRectangle : 1; 
    unsigned IsNotSelectable : 1;       
    unsigned Decoration : 1;            
    unsigned Indestructible : 1;        
    unsigned Organic : 1;               

    CVariable *Variable;            

    std::vector<CBuildRestriction *> BuildingRules;
    SDL_Color NeutralMinimapColorRGB;   

    CUnitSound Sound;                   

    int ProductionRate[MaxCosts];       
    int MaxUtilizationRate[MaxCosts];   
    int ProductionCosts[MaxCosts];      
    int StorageCapacity[MaxCosts];      
    unsigned ProductionEfficiency : 8;  

    inline void SetEnergyProductionRate(int v) { ProductionRate[EnergyCost] = v; }
    inline int GetEnergyProductionRate() { return ProductionRate[EnergyCost]; }
    inline void SetMagmaProductionRate(int v) { ProductionRate[MagmaCost] = v; }
    inline int GetMagmaProductionRate() { return ProductionRate[MagmaCost]; }

    inline void SetMaxEnergyUtilizationRate(int v) { MaxUtilizationRate[EnergyCost] = v; }
    inline int GetMaxEnergyUtilizationRate() { return MaxUtilizationRate[EnergyCost]; }
    inline void SetMaxMagmaUtilizationRate(int v) { MaxUtilizationRate[MagmaCost] = v; }
    inline int GetMaxMagmaUtilizationRate() { return MaxUtilizationRate[MagmaCost]; }

    inline void SetEnergyValue(int v) { ProductionCosts[EnergyCost] = CYCLES_PER_SECOND * v; }
    inline int GetEnergyValue() { return ProductionCosts[EnergyCost] / CYCLES_PER_SECOND; }
    inline void SetMagmaValue(int v) { ProductionCosts[MagmaCost] = CYCLES_PER_SECOND * v; }
    inline int GetMagmaValue() { return ProductionCosts[MagmaCost] / CYCLES_PER_SECOND; }

    inline void SetEnergyStorageCapacity(int v) { StorageCapacity[EnergyCost] = CYCLES_PER_SECOND * v; }
    inline int GetEnergyStorageCapacity() { return StorageCapacity[EnergyCost] / CYCLES_PER_SECOND; }
    inline void SetMagmaStorageCapacity(int v) { StorageCapacity[MagmaCost] = CYCLES_PER_SECOND * v; }
    inline int GetMagmaStorageCapacity() { return StorageCapacity[MagmaCost] / CYCLES_PER_SECOND; }

// --- FILLED UP ---

    unsigned FieldFlags;            
    unsigned MovementMask;          

    CUnitStats Stats[PlayerMax];     

    CPlayerColorGraphic *Sprite;     
    CGraphic *ShadowSprite;          
};

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

extern std::vector<CUnitType *> UnitTypes;   

class CUnitTypeVar {
public:
    CUnitTypeVar() : VariableName(NULL), Variable(NULL), NumberVariable(0) {}

    char **VariableName;                
    CVariable *Variable;                
//  EventType *Event;                   /// Array of functions sets to call when en event occurs.
    int NumberVariable;                 

    std::vector<CDecoVar *> DecoVar;    
};

extern CUnitTypeVar UnitTypeVar;

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

extern CUnitType *CclGetUnitType(lua_State *l);      
extern void UnitTypeCclRegister(void);               

extern void UpdateStats(int reset_to_default);       
extern CUnitType *UnitTypeByIdent(const std::string &ident);
extern int GetVariableIndex(const char *VarName);    

extern CUnitType *NewUnitTypeSlot(const std::string &ident);

extern void DrawUnitType(const CUnitType *type, CPlayerColorGraphic *sprite,
    int player, int frame, int x, int y);

extern void InitUnitTypes(int reset_player_stats);   
extern void LoadUnitTypeSprite(CUnitType *unittype); 
extern void LoadUnitTypes(void);                     
extern void CleanUnitTypes(void);                    

// in script_unittype.c

extern void DefineVariableField(lua_State *l, CVariable *var, int lua_index);

extern void UpdateUnitVariables(const CUnit *unit);


#endif // !__UNITTYPE_H__

---