unit.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 __UNIT_H__
#define __UNIT_H__
 
 
/*----------------------------------------------------------------------------
--  Includes
----------------------------------------------------------------------------*/
 
#include "settings.h"
#include <vector>
 
#ifndef __UNITTYPE_H__
#include "unittype.h"
#endif
 
#ifndef __PLAYER_H__
#include "player.h"
#endif
 
#include "vec2i.h"
 
/*----------------------------------------------------------------------------
--  Declarations
----------------------------------------------------------------------------*/
 
class CAnimation;
class CBuildRestrictionOnTop;
class CConstructionFrame;
class CFile;
class Missile;
class CMapField;
class COrder;
class CPlayer;
class CUnit;
class CUnitColors;
class CUnitPtr;
class CUnitStats;
class CUnitType;
class CUpgrade;
class CVariable;
class CViewport;
class PathFinderData;
class SpellType;
struct lua_State;
 
typedef COrder *COrderPtr;
 
/*
** Configuration of the small (unit) AI.
** sPPP PPdd dddd dddd 0000 0000 0hhh hhhh
** s... .ppp pppp p... .... .... .... ....
** s... ...I .... .... iiii i... .... ....
** s... .... .... c... .... .... .... ....
*/
#define PRIORITY_FACTOR   0x00080000   
#define HEALTH_FACTOR     0x00000001   
#define DISTANCE_FACTOR   0x00010000   
#define INRANGE_FACTOR    0x00008000   
#define INRANGE_BONUS     0x01000000   
#define CANATTACK_BONUS   0x00080000   
#define AIPRIORITY_BONUS  0x04000000   
 
/*
** Same for alternate (simplified) implementation of the small (unit) AI.
** sAT0 0000  0ppp pppp  pddd dddd  dhhh hhhh
*/
#define AT_ATTACKED_BY_FACTOR 0x40000000 
#define AT_THREAT_FACTOR      0x20000000 
#define AT_PRIORITY_OFFSET    15         
#define AT_DISTANCE_OFFSET    7          
#define AT_PRIORITY_MASK_HI   0xFFFF8000 
 
#define AT_FARAWAY_REDUCE_OFFSET 14      
 
extern void SelectedUnitChanged();
 
extern int MapDistanceBetweenTypes(const CUnitType &src, const Vec2i &pos1,
                                                                   const CUnitType &dst, const Vec2i &pos2);
 
enum _directions_ {
        LookingN  = 0 * 32,      
        LookingNE = 1 * 32,      
        LookingE  = 2 * 32,      
        LookingSE = 3 * 32,      
        LookingS  = 4 * 32,      
        LookingSW = 5 * 32,      
        LookingW  = 6 * 32,      
        LookingNW = 7 * 32       
};
 
#define NextDirection 32        
#define UnitNotSeen 0x7fffffff  
 
class CUnit
{
public:
        CUnit() : tilePos(-1, -1), pathFinderData(NULL), SavedOrder(NULL), NewOrder(NULL), CriticalOrder(NULL), Colors(-1),
                                AutoCastSpell(NULL), SpellCoolDownTimers(NULL), Variable(NULL) { Init(); }
        ~CUnit();
 
        void Init();
 
        COrder *CurrentOrder() const { return Orders[0]; }
 
        unsigned int CurrentAction() const;
 
        bool IsIdle() const;
 
        void ClearAction();
 
        void RefsIncrease();
        void RefsDecrease();
 
        void Init(const CUnitType &type);
        void AssignToPlayer(CPlayer &player);
 
        void Draw(const CViewport &vp) const;
        void Place(const Vec2i &pos);
 
        void MoveToXY(const Vec2i &pos);
        void AddInContainer(CUnit &host);
        void ChangeOwner(CPlayer &newplayer);
 
        void Remove(CUnit *host);
 
        void AssignWorkerToMine(CUnit &mine);
        void DeAssignWorkerFromMine(CUnit &mine);
 
        void Release(bool final = false);
 
        bool RestoreOrder();
        bool CanStoreOrder(COrder *order);
 
        // Cowards and invisible units don't attack unless ordered.
        bool IsAgressive() const
        {
                return (Type->BoolFlag[CANATTACK_INDEX].value && !Type->BoolFlag[COWARD_INDEX].value
                                && Variable[INVISIBLE_INDEX].Value == 0);
        }
 
        bool IsVisible(const CPlayer &player) const;
 
        inline bool IsInvisibile(const CPlayer &player) const
        {
                return (&player != Player && Variable[INVISIBLE_INDEX].Value > 0
                                && !Player->HasSharedVisionWith(player));
        }
 
        bool IsAlive() const;
 
        inline bool IsAliveOnMap() const
        {
                return !Removed && IsAlive();
        }
 
        inline bool IsVisibleAsGoal(const CPlayer &player) const
        {
                // Invisibility
                if (IsInvisibile(player)) {
                        return false;
                }
                // Don't attack revealers
                if (this->Type->BoolFlag[REVEALER_INDEX].value) {
                        return false;
                }
                if ((player.Type == PlayerTypes::PlayerComputer && !this->Type->BoolFlag[PERMANENTCLOAK_INDEX].value)
                        || IsVisible(player) || IsVisibleOnRadar(player)) {
                        return IsAliveOnMap();
                } else {
                        return Type->BoolFlag[VISIBLEUNDERFOG_INDEX].value
                                   && (Seen.ByPlayer & (1 << player.Index))
                                   && !(Seen.Destroyed & (1 << player.Index));
                }
        }
 
        inline bool IsVisibleOnMap(const CPlayer &player) const
        {
                return IsAliveOnMap() && !IsInvisibile(player) && IsVisible(player);
        }
 
        bool IsVisibleOnMinimap() const;
 
        // Returns true if unit is visible under radar (By player, or by shared vision)
        bool IsVisibleOnRadar(const CPlayer &pradar) const;
 
        bool IsVisibleInViewport(const CViewport &vp) const;
 
        bool IsEnemy(const CPlayer &player) const;
        bool IsEnemy(const CUnit &unit) const;
        bool IsAllied(const CPlayer &player) const;
        bool IsAllied(const CUnit &unit) const;
        bool IsTeamed(const CPlayer &player) const;
        bool IsTeamed(const CUnit &unit) const;
 
        bool IsUnusable(bool ignore_built_state = false) const;
 
        int MapDistanceTo(const CUnit &dst) const
        {
                return MapDistanceBetweenTypes(*Type, tilePos, *dst.Type, dst.tilePos);
        }
 
        int MapDistanceTo(const Vec2i &pos) const;
 
        bool CanMove() const { return Type->CanMove(); }
 
        int GetDrawLevel() const;
 
        bool IsAttackRanged(CUnit *goal, const Vec2i &goalPos);
 
        PixelPos GetMapPixelPosTopLeft() const;
        PixelPos GetMapPixelPosCenter() const;
 
public:
        class CUnitManagerData
        {
                friend class CUnitManager;
        public:
                CUnitManagerData() : slot(-1), unitSlot(-1) {}
 
                int GetUnitId() const { return slot; }
        private:
                int slot;           
                int unitSlot;       
        };
public:
        // @note int is faster than shorts
        unsigned int     Refs;         
        unsigned int     ReleaseCycle; 
        CUnitManagerData UnitManagerData;
        size_t PlayerSlot;  
 
        int    InsideCount;   
        int    BoardCount;    
        CUnit *UnitInside;    
        CUnit *Container;     
        CUnit *NextContained; 
        CUnit *PrevContained; 
 
        CUnit *NextWorker; //pointer to next assigned worker to "Goal" resource.
        struct {
                CUnit *Workers; 
                int Assigned; 
                int Active; 
        } Resource; 
 
        Vec2i tilePos; 
 
        unsigned int Offset;
 
        const CUnitType  *Type;        
        CPlayer    *Player;            
        const CUnitStats *Stats;       
        int         CurrentSightRange; 
 
        // Pathfinding stuff:
        PathFinderData *pathFinderData;
 
        // DISPLAY:
        int         Frame;      
        int  Colors;            
        bool IndividualUpgrades[UpgradeMax];      
 
        signed char IX;         
        signed char IY;         
        unsigned char Direction; //: 8; /// angle (0-255) unit looking
        unsigned char CurrentResource;
        int ResourcesHeld;      
 
        unsigned char DamagedType;   
        unsigned long Attacked;      
        unsigned long Summoned;      
        unsigned Blink : 3;          
        unsigned Moving : 1;         
        unsigned ReCast : 1;         
        unsigned AutoRepair : 1;     
 
        unsigned Burning : 1;        
        unsigned Destroyed : 1;      
        unsigned Removed : 1;        
        unsigned Selected : 1;       
 
        unsigned Constructed : 1;    
        unsigned Active : 1;         
        unsigned Boarded : 1;        
        unsigned CacheLock : 1;      
 
        unsigned Waiting : 1;        
        unsigned MineLow : 1;        
 
        unsigned TeamSelected;  
        CPlayer *RescuedFrom;        
        /* Seen stuff. */
        int VisCount[PlayerMax];     
        struct _seen_stuff_ {
                _seen_stuff_() : CFrame(NULL), Type(NULL), tilePos(-1, -1) {}
                const CConstructionFrame  *CFrame;  
                int         Frame;                  
                const CUnitType  *Type;             
                Vec2i       tilePos;                
                signed char IX;                     
                signed char IY;                     
                unsigned    Constructed : 1;        
                unsigned    State : 3;              
unsigned    Destroyed : PlayerMax;  
unsigned    ByPlayer : PlayerMax;   
        } Seen;
 
        CVariable *Variable; 
 
        unsigned long TTL;  
 
        unsigned int GroupId;       
        unsigned int LastGroup;     
 
        unsigned int Wait;          
        int Threshold;              
        int UnderAttack;                        
 
        struct _unit_anim_ {
                const CAnimation *Anim;      
                const CAnimation *CurrAnim;  
                int Wait;                    
                int Unbreakable;             
        } Anim, WaitBackup;
 
 
        std::vector<COrder *> Orders; 
        COrder *SavedOrder;         
        COrder *NewOrder;           
        COrder *CriticalOrder;      
 
        char *AutoCastSpell;        
        int *SpellCoolDownTimers;   
 
        CUnit *Goal; 
};
 
#define NoUnitP (CUnit *)0        
 
 
#define UnitNumber(unit) ((unit).UnitManagerData.GetUnitId())
 
class CPreference
{
public:
        CPreference() : ShowSightRange(false), ShowReactionRange(false),
                ShowAttackRange(false), ShowMessages(true), ShowNoSelectionStats(true), BigScreen(false),
                PauseOnLeave(true), GrayscaleIcons(false),
                IconsShift(false), StereoSound(true), MineNotifications(false),
                DeselectInMine(false), NoStatusLineTooltips(false),
                SelectionRectangleIndicatesDamage(false),
                IconFrameG(NULL), PressedIconFrameG(NULL), HardwareCursor(false),
                ShowOrders(0), ShowNameDelay(0), ShowNameTime(0), AutosaveMinutes(5) {};
 
        bool ShowSightRange;       
        bool ShowReactionRange;    
        bool ShowAttackRange;      
        bool ShowMessages;                 
        bool ShowNoSelectionStats; 
        bool BigScreen;                    
        bool PauseOnLeave;         
        bool GrayscaleIcons;       
        bool IconsShift;           
        bool StereoSound;          
        bool MineNotifications;    
        bool DeselectInMine;       
        bool NoStatusLineTooltips; 
        bool HardwareCursor;    
        bool SelectionRectangleIndicatesDamage; 
 
        int FrameSkip;          
 
        int ShowOrders;                 
        int ShowNameDelay;              
        int ShowNameTime;               
        int AutosaveMinutes;    
        CGraphic *IconFrameG;
        CGraphic *PressedIconFrameG;
 
        // these are "preferences" in the sense that the user wants to set these
        // persistently across launches for single player games. However, they are
        // relevant for network sync and replays, so the actually relevant storage
        // is in GameSettings, and we just have properties for the lua code here and
        // to initialize GameSettings to the user preferred defaults
        void InitializeSettingsFromPreferences(Settings &s) {
                s.AiExplores = AiExplores;
                s.SimplifiedAutoTargeting = SimplifiedAutoTargeting;
                s.AiChecksDependencies = AiChecksDependencies;
        }
private:
        bool AiExplores = true;
        bool SimplifiedAutoTargeting = false;
        bool AiChecksDependencies = false;
 
#if USING_TOLUAPP
public:
        bool get_AiExplores() { return AiExplores; }
        void set_AiExplores(bool v) { AiExplores = GameSettings.AiExplores = v; }
        bool get_SimplifiedAutoTargeting() { return SimplifiedAutoTargeting; }
        void set_SimplifiedAutoTargeting(bool v) { SimplifiedAutoTargeting = GameSettings.SimplifiedAutoTargeting = v; }
        bool get_AiChecksDependencies() { return AiChecksDependencies; }
        void set_AiChecksDependencies(bool v) { AiChecksDependencies = GameSettings.AiChecksDependencies = v; }
#endif
};
 
extern CPreference Preference;
 
/*----------------------------------------------------------------------------
-- Variables
----------------------------------------------------------------------------*/
 
// in unit_draw.c
extern unsigned long ShowOrdersCount;   
extern unsigned long ShowNameDelay;     
extern unsigned long ShowNameTime;      
extern bool EnableTrainingQueue;               
extern bool EnableBuildingCapture;             
extern bool RevealAttacker;                    
extern int ResourcesMultiBuildersMultiplier;   
extern const CViewport *CurrentViewport; 
extern void DrawUnitSelection(const CViewport &vp, const CUnit &unit);
extern void (*DrawSelection)(IntColor, int, int, int, int);
 
extern unsigned int MaxSelectable;    
extern std::vector<CUnit *> Selected; 
 
/*----------------------------------------------------------------------------
-- Functions
----------------------------------------------------------------------------*/
 
void MarkUnitFieldFlags(const CUnit &unit);
void UnmarkUnitFieldFlags(const CUnit &unit);
void UpdateUnitSightRange(CUnit &unit);
extern CUnit *MakeUnit(const CUnitType &type, CPlayer *player);
extern CUnit *MakeUnitAndPlace(const Vec2i &pos, const CUnitType &type, CPlayer *player);
void FindNearestDrop(const CUnitType &type, const Vec2i &goalPos, Vec2i &resPos, int heading);
extern void UnitLost(CUnit &unit);
extern void UnitClearOrders(CUnit &unit);
extern void UpdateForNewUnit(const CUnit &unit, int upgrade);
extern void NearestOfUnit(const CUnit &unit, const Vec2i &pos, Vec2i *dpos);
 
extern CUnit *GetFirstContainer(const CUnit &unit);
 
extern void UnitGoesUnderFog(CUnit &unit, const CPlayer &player);
extern void UnitGoesOutOfFog(CUnit &unit, const CPlayer &player);
 
extern void UnitCountSeen(CUnit &unit);
 
extern void RescueUnits();
 
extern int DirectionToHeading(const Vec2i &dir);
extern int DirectionToHeading(const PixelDiff &dir);
 
extern void CorrectWallDirections(CUnit &unit);
extern void CorrectWallNeighBours(CUnit &unit);
 
extern void UnitUpdateHeading(CUnit &unit);
extern void UnitHeadingFromDeltaXY(CUnit &unit, const Vec2i &delta);
 
 
extern void DropOutOnSide(CUnit &unit, int heading, const CUnit *container);
extern void DropOutNearest(CUnit &unit, const Vec2i &goalPos, const CUnit *container);
 
extern void DropOutAll(const CUnit &unit);
 
extern CBuildRestrictionOnTop *OnTopDetails(const CUnit &unit, const CUnitType *parent);
extern CUnit *CanBuildHere(const CUnit *unit, const CUnitType &type, const Vec2i &pos);
extern bool CanBuildOn(const Vec2i &pos, int mask);
extern CUnit *CanBuildUnitType(const CUnit *unit, const CUnitType &type, const Vec2i &pos, int real);
extern int ExtraDeathIndex(const char *death);
 
extern CUnit *UnitOnScreen(int x, int y);
 
extern void LetUnitDie(CUnit &unit, bool suicide = false);
extern void DestroyAllInside(CUnit &source);
extern int ThreatCalculate(const CUnit &unit, const CUnit &dest);
extern int TargetPriorityCalculate(const CUnit *const attacker, const CUnit *const dest);
 
extern bool InReactRange(const CUnit &unit, const CUnit &target);
extern bool InAttackRange(const CUnit &unit, const CUnit &target);
extern bool InAttackRange(const CUnit &unit, const Vec2i &tilePos);
extern Vec2i GetRndPosInDirection(const Vec2i &srcPos, const CUnit &dirUnit, const bool dirFrom, const int minRange, const int devRadius, const int rangeDev = 3);
extern Vec2i GetRndPosInDirection(const Vec2i &srcPos, const Vec2i &dirPos, const bool dirFrom, const int minRange, const int devRadius, const int rangeDev = 3);
 
 
extern void HitUnit(CUnit *attacker, CUnit &target, int damage, const Missile *missile = NULL);
 
extern int ViewPointDistance(const Vec2i &pos);
extern int ViewPointDistanceToUnit(const CUnit &dest);
 
extern int CanTarget(const CUnitType &type, const CUnitType &dest);
extern int CanTransport(const CUnit &transporter, const CUnit &unit);
 
extern std::string UnitReference(const CUnit &unit);
extern std::string UnitReference(const CUnitPtr &unit);
 
extern void SaveUnit(const CUnit &unit, CFile &file);
 
extern void InitUnits();
extern void CleanUnits();
 
// in unit_draw.c
//--------------------
extern void DrawSelectionNone(IntColor, int, int, int, int);
extern void DrawSelectionCircle(IntColor, int, int, int, int);
extern void DrawSelectionCircleWithTrans(IntColor, int, int, int, int);
extern void DrawSelectionRectangle(IntColor, int, int, int, int);
extern void DrawSelectionRectangleWithTrans(IntColor, int, int, int, int);
extern void DrawSelectionCorners(IntColor, int, int, int, int);
extern void (*DrawSelectionEllipse(float factor))(IntColor, int, int, int, int);
 
extern void DecorationCclRegister();
extern void LoadDecorations();
extern void CleanDecorations();
 
extern void DrawShadow(const CUnitType &type, int frame, const PixelPos &screenPos);
extern int FindAndSortUnits(const CViewport &vp, std::vector<CUnit *> &table);
 
extern void ShowOrder(const CUnit &unit);
 
// in groups.c
 
extern void SaveGroups(CFile &file);
extern void CleanGroups();
extern const std::vector<CUnit *> &GetUnitsOfGroup(int num);
 
extern void ClearGroup(int num);
extern void AddToGroup(CUnit **units, unsigned int nunits, int num);
extern void SetGroup(CUnit **units, unsigned int nunits, int num);
extern void RemoveUnitFromGroups(CUnit &unit);
extern void GroupCclRegister();
extern bool IsGroupTainted(int num);
 
// in selection.c
 
extern bool IsOnlySelected(const CUnit &unit);
 
extern void SaveSelection();
extern void RestoreSelection();
extern void UnSelectAll();
extern void ChangeTeamSelectedUnits(CPlayer &player, const std::vector<CUnit *> &units);
extern int SelectUnit(CUnit &unit);
extern void SelectSingleUnit(CUnit &unit);
extern void UnSelectUnit(CUnit &unit);
extern int ToggleSelectUnit(CUnit &unit);
extern int SelectUnitsByType(CUnit &base);
extern int ToggleUnitsByType(CUnit &base);
extern int SelectGroup(int group_number, GroupSelectionMode mode = SELECTABLE_BY_RECTANGLE_ONLY);
extern int AddGroupFromUnitToSelection(CUnit &unit);
extern int SelectGroupFromUnit(CUnit &unit);
extern int SelectUnitsInRectangle(const PixelPos &corner_topleft, const PixelPos &corner_bottomright);
extern int SelectGroundUnitsInRectangle(const PixelPos &corner_topleft, const PixelPos &corner_bottomright);
extern int SelectAirUnitsInRectangle(const PixelPos &corner_topleft, const PixelPos &corner_bottomright);
extern int AddSelectedUnitsInRectangle(const PixelPos &corner_topleft, const PixelPos &corner_bottomright);
extern int AddSelectedGroundUnitsInRectangle(const PixelPos &corner_topleft, const PixelPos &corner_bottomright);
extern int AddSelectedAirUnitsInRectangle(const PixelPos &corner_topleft, const PixelPos &corner_bottomright);
 
extern void SaveSelections(CFile &file);
extern void CleanSelections();
extern void SelectionCclRegister();
 
// in ccl_unit.c
 
extern void UnitCclRegister();
 
 
#endif // !__UNIT_H__