unittype.h

Go to the documentation of this file.

//       _________ __                 __
//      /   _____//  |_____________ _/  |______     ____  __ __  ______
//      \_____  \\   __\_  __ \__  \\   __\__  \   / ___\|  |  \/  ___/
//      /        \|  |  |  | \// __ \|  |  / __ \_/ /_/  >  |  /\___ |
//     /_______  /|__|  |__|  (____  /__| (____  /\___  /|____//____  >
//             \/                  \/          \//_____/            \/
//  ______________________                           ______________________
//                        T H E   W A R   B E G I N S
//         Stratagus - A free fantasy real time strategy game engine
//
//
//      (c) Copyright 1998-2015 by Lutz Sammer, Jimmy Salmon and Andrettin
//
//      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__
 
 
/*----------------------------------------------------------------------------
--  Includes
----------------------------------------------------------------------------*/
 
#ifndef __UPGRADE_STRUCTS_H__
#include "upgrade_structs.h"
#endif
 
#ifndef __UNITSOUND_H__
#include "unitsound.h"
#endif
 
#ifndef __ICONS_H__
#include "icons.h"
#endif
 
#include "color.h"
#include "missileconfig.h"
#include "vec2i.h"
 
#include <climits>
#include <vector>
#include <algorithm>
#include <map>
 
/*----------------------------------------------------------------------------
--  Declarations
----------------------------------------------------------------------------*/
 
class CAnimations;
class CPlayerColorGraphic;
class CConstruction;
class MissileType;
class CFile;
struct lua_State;
#ifdef USE_MNG
class Mng;
#endif
class LuaCallback;
 
#define UnitSides 8
#define MaxAttackPos 5
 
CUnitType *UnitTypeByIdent(const std::string &ident);
 
enum GroupSelectionMode {
        SELECTABLE_BY_RECTANGLE_ONLY = 0,
        NON_SELECTABLE_BY_RECTANGLE_ONLY,
        SELECT_ALL
};
 
class ResourceInfo
{
public:
        ResourceInfo() : WaitAtResource(0), ResourceStep(0),
                ResourceCapacity(0), WaitAtDepot(0), ResourceId(0), FinalResource(0),
                TerrainHarvester(0), LoseResources(0), HarvestFromOutside(0),
                SpriteWhenLoaded(NULL), SpriteWhenEmpty(NULL)
        {}
 
        std::string FileWhenLoaded;     
        std::string FileWhenEmpty;      
        unsigned WaitAtResource;        
        unsigned ResourceStep;          
        int      ResourceCapacity;      
        unsigned WaitAtDepot;           
        unsigned ResourceId;            
        unsigned FinalResource;         
        unsigned char TerrainHarvester;    
        unsigned char LoseResources;       
        unsigned char HarvestFromOutside;  
        unsigned char RefineryHarvester;   
        //  Runtime info:
        CPlayerColorGraphic *SpriteWhenLoaded; 
        CPlayerColorGraphic *SpriteWhenEmpty;  
};
 
class CVariable
{
public:
        CVariable() : Max(0), Value(0), Increase(0), IncreaseFrequency(0), Enable(0) {}
 
        bool operator ==(const CVariable &rhs) const
        {
                return this->Max == rhs.Max
                           && this->Value == rhs.Value
                           && this->Increase == rhs.Increase
                           && this->IncreaseFrequency == rhs.IncreaseFrequency
                           && this->Enable == rhs.Enable;
        }
        bool operator !=(const CVariable &rhs) const { return !(*this == rhs); }
 
public:
        int Max;        
        int Value;      
        char Increase;  
        unsigned char IncreaseFrequency:7;    
        unsigned char Enable:1;    
};
 
// Index for boolflag already defined
enum {
        COWARD_INDEX = 0,                               
        BUILDING_INDEX,
        FLIP_INDEX,
        REVEALER_INDEX,                                 
        LANDUNIT_INDEX,
        AIRUNIT_INDEX,
        SEAUNIT_INDEX,
        EXPLODEWHENKILLED_INDEX,
        VISIBLEUNDERFOG_INDEX,                  
        PERMANENTCLOAK_INDEX,                   
        DETECTCLOAK_INDEX,                              
        ATTACKFROMTRANSPORTER_INDEX,    
        VANISHES_INDEX,                                 
        GROUNDATTACK_INDEX,                             
        SHOREBUILDING_INDEX,                    
        CANATTACK_INDEX,
        BUILDEROUTSIDE_INDEX,                   
        BUILDERLOST_INDEX,                              
        CANHARVEST_INDEX,                               
        HARVESTER_INDEX,                                
        SELECTABLEBYRECTANGLE_INDEX,    
        ISNOTSELECTABLE_INDEX,
        DECORATION_INDEX,                               
        INDESTRUCTIBLE_INDEX,                   
        TELEPORTER_INDEX,                               
        SHIELDPIERCE_INDEX,
        SAVECARGO_INDEX,                                
        NONSOLID_INDEX,                                 
        WALL_INDEX,                                             
        NORANDOMPLACING_INDEX,                  
        ORGANIC_INDEX,                                  
        SIDEATTACK_INDEX,
        SKIRMISHER_INDEX,
        ALWAYSTHREAT_INDEX,                             
        ELEVATED_INDEX,                                 
        NOFRIENDLYFIRE_INDEX,           
        MAINFACILITY_INDEX,                             
        NBARALREADYDEFINED
};
 
// Index for variable already defined.
enum {
        HP_INDEX = 0,
        BUILD_INDEX,
        MANA_INDEX,
        TRANSPORT_INDEX,
        RESEARCH_INDEX,
        TRAINING_INDEX,
        UPGRADINGTO_INDEX,
        GIVERESOURCE_INDEX,
        CARRYRESOURCE_INDEX,
        XP_INDEX,
        KILL_INDEX,
        SUPPLY_INDEX,                                   
        DEMAND_INDEX,                                   
        ARMOR_INDEX,
        SIGHTRANGE_INDEX,
        ATTACKRANGE_INDEX,
        PIERCINGDAMAGE_INDEX,
        BASICDAMAGE_INDEX,
        POSX_INDEX,
        POSY_INDEX,
        POS_RIGHT_INDEX,
        POS_BOTTOM_INDEX,
        TARGETPOSX_INDEX,
        TARGETPOSY_INDEX,
        RADAR_INDEX,
        RADARJAMMER_INDEX,
        AUTOREPAIRRANGE_INDEX,
        BLOODLUST_INDEX,
        HASTE_INDEX,
        SLOW_INDEX,
        INVISIBLE_INDEX,
        UNHOLYARMOR_INDEX,
        SLOT_INDEX,
        SHIELD_INDEX,
        POINTS_INDEX,
        MAXHARVESTERS_INDEX,
        POISON_INDEX,
        SHIELDPERMEABILITY_INDEX,
        SHIELDPIERCING_INDEX,
        ISALIVE_INDEX,
        PLAYER_INDEX,
        PRIORITY_INDEX,
        NVARALREADYDEFINED
};
 
class CUnit;
class CUnitType;
class CFont;
 
class CDecoVar
{
public:
 
        CDecoVar() {};
        virtual ~CDecoVar()
        {
        };
 
        virtual void Draw(int x, int y, const CUnitType &type, const CVariable &var) const = 0;
 
        bool BoolFlagMatches(const CUnitType &type) const;
 
        unsigned int Index;     
 
        int OffsetX;            
        int OffsetY;            
 
        int OffsetXPercent;     
        int OffsetYPercent;     
 
        bool IsCenteredInX;     
        bool IsCenteredInY;     
 
        bool ShowIfNotEnable;   
        bool ShowWhenNull;      
        bool HideHalf;          
        bool ShowWhenMax;       
        bool ShowOnlySelected;  
 
        bool HideNeutral;       
        bool HideAllied;        
        bool ShowOpponent;      
 
        bool BoolFlagInvert;    
        int BoolFlag;           
};
 
class CDecoVarBar : public CDecoVar
{
public:
        CDecoVarBar() : MinValue(0), MaxValue(100), Invert(false) {};
        virtual void Draw(int x, int y, const CUnitType &type, const CVariable &var) const;
 
        bool IsVertical;            
        bool SEToNW;                
        int Height;                 
        int Width;                  
        bool ShowFullBackground;    
        bool Invert;                
        int MinValue;               
        int MaxValue;               
        char BorderSize;            
        // FIXME color depend of percent (red, Orange, Yellow, Green...)
        IntColor Color;             
        IntColor BColor;            
};
 
class CDecoVarFrame : public CDecoVar
{
public:
        CDecoVarFrame() : Thickness(0), ColorIndex(-1) {};
        virtual void Draw(int x, int y, const CUnitType &type, const CVariable &var) const;
 
        int Thickness;
        int ColorIndex;
};
 
class CDecoVarText : public CDecoVar
{
public:
        CDecoVarText() : Font(NULL) {};
        virtual void Draw(int x, int y, const CUnitType &type, const CVariable &var) const;
 
        CFont *Font;  
        // FIXME : Add Color, format
};
 
class CDecoVarSpriteBar : public CDecoVar
{
public:
        CDecoVarSpriteBar() : NSprite(-1) {};
        virtual void Draw(int x, int y,
                                          const CUnitType &type, const CVariable &var) const;
 
        char NSprite; 
        // FIXME Sprite info. better way ?
};
 
class CDecoVarStaticSprite : public CDecoVar
{
public:
        CDecoVarStaticSprite() : NSprite(-1), n(0), FadeValue(0) {}
        virtual void Draw(int x, int y, const CUnitType &type, const CVariable &var) const;
 
        // FIXME Sprite info. and Replace n with more appropriate var.
        char NSprite;  
        int n;         
        int FadeValue; 
};
 
class CDecoVarAnimatedSprite : public CDecoVar
{
public:
        CDecoVarAnimatedSprite() : NSprite(-1), n(0), WaitFrames(0) {}
        virtual void Draw(int x, int y, const CUnitType &type, const CVariable &var) const;
 
        char NSprite;    
        char WaitFrames; 
private:
        char lastFrame; 
        int n;         
};
 
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 CUnit *builder, const CUnitType &type, const Vec2i &pos, 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 CUnit *builder, const CUnitType &type, const Vec2i &pos, CUnit *&ontoptarget) const;
 
        void push_back(CBuildRestriction *restriction) { _or_list.push_back(restriction); }
public:
        std::vector<CBuildRestriction *> _or_list;
};
 
class CBuildRestrictionAddOn : public CBuildRestriction
{
        class functor
        {
        public:
                functor(const CUnitType *type, const Vec2i &_pos): Parent(type), pos(_pos) {}
                inline bool operator()(const CUnit *const unit) const;
        private:
                const CUnitType *const Parent;   
                const Vec2i pos; //functor work position
        };
public:
        CBuildRestrictionAddOn() : Offset(0, 0), Parent(NULL) {}
        virtual ~CBuildRestrictionAddOn() {}
        virtual void Init() {this->Parent = UnitTypeByIdent(this->ParentName);}
        virtual bool Check(const CUnit *builder, const CUnitType &type, const Vec2i &pos, CUnit *&ontoptarget) const;
 
        Vec2i Offset;           
        std::string ParentName; 
        CUnitType *Parent;      
};
 
class CBuildRestrictionOnTop : public CBuildRestriction
{
        class functor
        {
        public:
                functor(const CUnitType *type, const Vec2i &_pos): ontop(0), Parent(type), pos(_pos) {}
                inline bool operator()(CUnit *const unit);
                CUnit *ontop;   
        private:
                const CUnitType *const Parent;  
                const Vec2i pos;  //functor work position
        };
public:
        CBuildRestrictionOnTop() : Parent(NULL), ReplaceOnDie(0), ReplaceOnBuild(0) {};
        virtual ~CBuildRestrictionOnTop() {};
        virtual void Init() {this->Parent = UnitTypeByIdent(this->ParentName);};
        virtual bool Check(const CUnit *builder, const CUnitType &type, const Vec2i &pos, CUnit *&ontoptarget) const;
 
        std::string ParentName;  
        CUnitType *Parent;       
        int ReplaceOnDie: 1;     
        int ReplaceOnBuild: 1;   
};
 
class CBuildRestrictionDistance : public CBuildRestriction
{
public:
        CBuildRestrictionDistance() : Distance(0), CheckBuilder(false), RestrictType(NULL), Diagonal(true) {};
        virtual ~CBuildRestrictionDistance() {};
        virtual void Init() {this->RestrictType = UnitTypeByIdent(this->RestrictTypeName);};
        virtual bool Check(const CUnit *builder, const CUnitType &type, const Vec2i &pos, CUnit *&ontoptarget) const;
 
        int Distance;        
        DistanceTypeType DistanceType;
        std::string RestrictTypeName;
        std::string RestrictTypeOwner;
        CUnitType *RestrictType;
        bool CheckBuilder;
        bool Diagonal;
};
 
class CBuildRestrictionHasUnit : public CBuildRestriction
{
public:
        CBuildRestrictionHasUnit() : Count(0), RestrictType(NULL) {};
        virtual ~CBuildRestrictionHasUnit() {};
        virtual void Init() { this->RestrictType = UnitTypeByIdent(this->RestrictTypeName); };
        virtual bool Check(const CUnit *builder, const CUnitType &type, const Vec2i &pos, CUnit *&ontoptarget) const;
 
        int Count;
        DistanceTypeType CountType;
        std::string RestrictTypeName;
        CUnitType *RestrictType;
        std::string RestrictTypeOwner;
};
 
class CBuildRestrictionSurroundedBy : public CBuildRestriction
{
public:
        CBuildRestrictionSurroundedBy() : Count(0), Distance(0), DistanceType(Equal), CountType(Equal), RestrictType(NULL), CheckBuilder(false) {};
        virtual ~CBuildRestrictionSurroundedBy() {};
        virtual void Init() { this->RestrictType = UnitTypeByIdent(this->RestrictTypeName); };
        virtual bool Check(const CUnit *builder, const CUnitType &type, const Vec2i &pos, CUnit *&ontoptarget) const;
 
        int Distance;
        DistanceTypeType DistanceType;
        int Count;
        DistanceTypeType CountType;
        std::string RestrictTypeName;
        std::string RestrictTypeOwner;
        CUnitType *RestrictType;
        bool CheckBuilder;
};
 
class CUnitType
{
public:
        CUnitType();
        ~CUnitType();
 
        Vec2i GetHalfTileSize() const { return Vec2i(TileWidth / 2, TileHeight / 2); }
        PixelSize GetPixelSize() const;
 
        bool CheckUserBoolFlags(const char *BoolFlags) const;
        bool CanTransport() const { return MaxOnBoard > 0 && !GivesResource; }
        bool CanMove() const;
 
        bool CanSelect(GroupSelectionMode mode = SELECTABLE_BY_RECTANGLE_ONLY) const;
 
public:
        std::string Ident;              
        std::string Name;               
        int Slot;                       
        std::string File;               
        std::string AltFile;            
        std::string ShadowFile;         
 
        int Width;                                            
        int Height;                                           
        int OffsetX;                                          
        int OffsetY;                                          
        int DrawLevel;                                        
        int ShadowWidth;                                      
        int ShadowHeight;                                     
        int ShadowOffsetX;                                    
        int ShadowOffsetY;                                    
        char ShadowScale;                                     
        char ShadowSpriteFrame;                               
        PixelPos MissileOffsets[UnitSides][MaxAttackPos];     
 
        CAnimations *Animations;        
        int StillFrame;                 
 
        IconConfig Icon;                
#ifdef USE_MNG
        struct _portrait_ {
                std::string *Files;
                int Num;
                int Talking; 
                Mng **Mngs;
                mutable int CurrMng;
                mutable int NumIterations;
        } Portrait;
#endif
        MissileConfig Missile;                           
        MissileConfig Explosion;                         
        MissileConfig Impact[ANIMATIONS_DEATHTYPES + 2]; 
 
        LuaCallback *OnDeath;           
        LuaCallback *OnHit;             
        LuaCallback *OnEachCycle;       
        LuaCallback *OnEachSecond;      
        LuaCallback *OnInit;            
        LuaCallback *OnReady;           
 
        int TeleportCost;               
        LuaCallback *TeleportEffectIn;   
        LuaCallback *TeleportEffectOut;  
 
        mutable std::string DamageType; 
 
        std::string CorpseName;         
        CUnitType *CorpseType;          
 
        CConstruction *Construction;    
 
        int RepairHP;                   
        int RepairCosts[MaxCosts];      
 
        int TileWidth;                  
        int TileHeight;                 
        int BoxWidth;                   
        int BoxHeight;                  
        int BoxOffsetX;                 
        int BoxOffsetY;                 
        int NumDirections;              
        int MinAttackRange;             
        int ReactRangeComputer;         
        int ReactRangePerson;           
        int BurnPercent;                
        int BurnDamageRate;             
        int RepairRange;                
#define InfiniteRepairRange INT_MAX
        char *CanCastSpell;             
        char *AutoCastActive;           
        int AutoBuildRate;              
        int RandomMovementProbability;  
        int RandomMovementDistance;     
        int ClicksToExplode;            
        int MaxOnBoard;                 
        int BoardSize;                  
        int ButtonLevelForTransporter;  
        int StartingResources;          
        UnitTypeType UnitType;          
        int DecayRate;                  
        // TODO: not used
        int AnnoyComputerFactor;        
        int AiAdjacentRange;            
        int MouseAction;                
#define MouseActionNone      0      
#define MouseActionAttack    1      
#define MouseActionMove      2      
#define MouseActionHarvest   3      
#define MouseActionSpellCast 5      
#define MouseActionSail      6      
        int CanTarget;                  
#define CanTargetLand 1             
#define CanTargetSea  2             
#define CanTargetAir  4             
 
        unsigned Flip : 1;              
        unsigned LandUnit : 1;          
        unsigned AirUnit : 1;           
        unsigned SeaUnit : 1;           
        unsigned ExplodeWhenKilled : 1; 
        unsigned Building : 1;          
        unsigned CanAttack : 1;         
        unsigned Neutral : 1;           
 
        unsigned SideAttack : 1;            
        unsigned Skirmisher : 1;            
 
        CUnitStats DefaultStat;
        CUnitStats MapDefaultStat;
        struct BoolFlags {
                bool value;             
                char CanTransport;      
                char CanTargetFlag;     
                char AiPriorityTarget;  
        };
        std::vector<BoolFlags> BoolFlag;
 
        int CanStore[MaxCosts];             
        int GivesResource;                  
        ResourceInfo *ResInfo[MaxCosts];    
        std::vector<CBuildRestriction *> BuildingRules;   
        std::vector<CBuildRestriction *> AiBuildingRules; 
        CColor NeutralMinimapColorRGB;   
 
        CUnitSound Sound;               
        CUnitSound MapSound;                    
 
        int PoisonDrain;                
 
        // --- FILLED UP ---
 
        unsigned FieldFlags;            
        unsigned MovementMask;          
 
        CUnitStats Stats[PlayerMax];     
 
        CPlayerColorGraphic *Sprite;     
        CPlayerColorGraphic *AltSprite;  
        CGraphic *ShadowSprite;          
};
 
/*----------------------------------------------------------------------------
--  Variables
----------------------------------------------------------------------------*/
 
extern std::vector<CUnitType *> UnitTypes;   
 
extern CUnitType *UnitTypeHumanWall;  
extern CUnitType *UnitTypeOrcWall;    
 
class CUnitTypeVar
{
public:
 
        template <const unsigned int SIZE>
        struct CKeys {
 
                struct DataKey {
                        static bool key_pred(const DataKey &lhs,
                                                                 const DataKey &rhs)
                        {
                                return ((lhs.keylen == rhs.keylen) ?
                                                (strcmp(lhs.key, rhs.key) < 0) : (lhs.keylen < rhs.keylen));
                        }
                        int offset;
                        unsigned int keylen;
                        const char *key;
                };
 
                CKeys(): TotalKeys(SIZE) {}
 
                DataKey buildin[SIZE];
                std::map<std::string, int> user;
                unsigned int TotalKeys;
 
                void Init()
                {
                        std::sort(buildin, buildin + SIZE, DataKey::key_pred);
                }
 
                const char *operator[](int index)
                {
                        for (unsigned int i = 0; i < SIZE; ++i) {
                                if (buildin[i].offset == index) {
                                        return buildin[i].key;
                                }
                        }
                        for (std::map<std::string, int>::iterator
                                 it(user.begin()), end(user.end());
                                 it != end; ++it) {
                                if ((*it).second == index) {
                                        return ((*it).first).c_str();
                                }
                        }
                        return NULL;
                }
 
                int operator[](const char *const key)
                {
                        DataKey k;
                        k.key = key;
                        k.keylen = strlen(key);
                        const DataKey *p = std::lower_bound(buildin, buildin + SIZE,
                                                                                                k, DataKey::key_pred);
                        if ((p != buildin + SIZE) && p->keylen == k.keylen &&
                                0 == strcmp(p->key, key)) {
                                return p->offset;
                        } else {
                                std::map<std::string, int>::iterator
                                ret(user.find(key));
                                if (ret != user.end()) {
                                        return (*ret).second;
                                }
                        }
                        return -1;
                }
 
                int AddKey(const char *const key)
                {
                        int index = this->operator[](key);
                        if (index != -1) {
                                DebugPrint("Warning, Key '%s' already defined\n" _C_ key);
                                return index;
                        }
                        user[key] = TotalKeys++;
                        return TotalKeys - 1;
                }
 
        };
 
        struct CBoolKeys : public CKeys<NBARALREADYDEFINED> {
                CBoolKeys();
        };
 
        struct CVariableKeys : public CKeys<NVARALREADYDEFINED> {
                CVariableKeys();
        };
 
        CUnitTypeVar() {}
 
        void Init();
        void Clear();
 
        CBoolKeys BoolFlagNameLookup;      
        CVariableKeys VariableNameLookup;  
 
        //EventType *Event;                  /// Array of functions sets to call when en event occurs.
        std::vector<CVariable> Variable;   
        std::vector<CDecoVar *> DecoVar;   
 
        unsigned int GetNumberBoolFlag() const
        {
                return BoolFlagNameLookup.TotalKeys;
        }
 
        unsigned int GetNumberVariable() const
        {
                return VariableNameLookup.TotalKeys;
        }
};
 
extern CUnitTypeVar UnitTypeVar;
 
/*----------------------------------------------------------------------------
--  Functions
----------------------------------------------------------------------------*/
extern CUnitType *CclGetUnitType(lua_State *l);  
extern void UnitTypeCclRegister();               
 
extern void UpdateUnitStats(CUnitType &type, int reset_to_default);       
extern void UpdateStats(int reset_to_default);       
extern CUnitType *UnitTypeByIdent(const std::string &ident);
 
extern void SaveUnitTypes(CFile &file);              
extern CUnitType *NewUnitTypeSlot(const std::string &ident);
extern void DrawUnitType(const CUnitType &type, CPlayerColorGraphic *sprite,
                                                 int colorIndex, int frame, const PixelPos &screenPos);
 
extern void InitUnitTypes(int reset_player_stats);   
extern void LoadUnitTypeSprite(CUnitType &unittype); 
extern void LoadUnitTypes();                     
extern void CleanUnitTypes();                    
 
// in script_unittype.c
 
extern void DefineVariableField(lua_State *l, CVariable *var, int lua_index);
 
extern void UpdateUnitVariables(CUnit &unit);
 
extern void SetMapStat(std::string ident, std::string variable_key, int value, std::string variable_type);
extern void SetMapSound(std::string ident, std::string sound, std::string sound_type, std::string sound_subtype = "");
 
#endif // !__UNITTYPE_H__