ai_local.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 2000-2005 by Lutz Sammer and Antonis Chaniotis.
//
//      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 __AI_LOCAL_H__
#define __AI_LOCAL_H__
 
 
/*----------------------------------------------------------------------------
--  Includes
----------------------------------------------------------------------------*/
 
#include <vector>
 
#include "upgrade_structs.h" // MaxCost
#include "unit_cache.h"
#include "vec2i.h"
 
/*----------------------------------------------------------------------------
--  Declarations
----------------------------------------------------------------------------*/
 
class CUnit;
class CUnitType;
class CUpgrade;
class CPlayer;
 
class CAiType
{
public:
        CAiType() {}
 
        std::string Name;     
        std::string Race;     
        std::string Class;    
        std::string Script;   
};
 
class AiRequestType
{
public:
        AiRequestType() : Count(0), Type(NULL) {}
 
        unsigned int Count;  
        CUnitType *Type;     
};
 
class AiUnitType
{
public:
        AiUnitType() : Want(0), Type(NULL) {}
 
        unsigned int Want; 
        CUnitType *Type;   
};
 
enum AiForceRole {
        AiForceRoleDefault = 0, 
        AiForceRoleAttack = 0, 
        AiForceRoleDefend      
};
 
enum AiForceAttackingState {
        AiForceAttackingState_Free = -1,
        AiForceAttackingState_Waiting = 0,
        AiForceAttackingState_Boarding,
        AiForceAttackingState_GoingToRallyPoint,
        AiForceAttackingState_AttackingWithTransporter,
        AiForceAttackingState_Attacking,
};
 
#define AI_WAIT_ON_RALLY_POINT 60          
 
 
class AiForce
{
        friend class AiForceManager;
public:
        AiForce() :
                Completed(false), Defending(false), Attacking(false),
                Role(AiForceRoleDefault), FormerForce(-1), State(AiForceAttackingState_Free),
                WaitOnRallyPoint(AI_WAIT_ON_RALLY_POINT)
        {
                HomePos.x = HomePos.y = GoalPos.x = GoalPos.y = -1;
        }
 
        void Remove(CUnit &unit)
        {
                if (Units.Remove(&unit)) {
                        InternalRemoveUnit(&unit);
                }
        }
 
        void Reset(bool types = false)
        {
                FormerForce = -1;
                Completed = false;
                Defending = false;
                Attacking = false;
                WaitOnRallyPoint = AI_WAIT_ON_RALLY_POINT;
                if (types) {
                        UnitTypes.clear();
                        State = AiForceAttackingState_Free;
                } else {
                        State = AiForceAttackingState_Waiting;
                }
                Units.for_each(InternalRemoveUnit);
                Units.clear();
                HomePos.x = HomePos.y = GoalPos.x = GoalPos.y = -1;
        }
        inline size_t Size() const { return Units.size(); }
 
        inline bool IsAttacking() const { return (!Defending && Attacking); }
 
        void Attack(const Vec2i &pos);
        void RemoveDeadUnit();
        int PlanAttack();
 
        void ReturnToHome();
        bool NewRallyPoint(const Vec2i &startPos, Vec2i *resultPos);
        void Insert(CUnit &unit);
 
private:
        void CountTypes(unsigned int *counter, const size_t len);
        bool IsBelongsTo(const CUnitType &type);
 
        void Update();
 
        static void InternalRemoveUnit(CUnit *unit);
 
public:
        bool Completed;    
        bool Defending;    
        bool Attacking;    
        AiForceRole Role;  
 
        std::vector<AiUnitType> UnitTypes; 
        CUnitCache Units;  
 
        // If attacking
        int FormerForce;             
        AiForceAttackingState State; 
        Vec2i GoalPos; 
        Vec2i HomePos; 
        int WaitOnRallyPoint; 
};
 
// forces
#define AI_MAX_FORCES 50                           
#define AI_MAX_FORCE_INTERNAL (AI_MAX_FORCES / 2)  
 
 
class AiForceManager
{
public:
        AiForceManager();
 
        inline size_t Size() const { return forces.size(); }
 
        const AiForce &operator[](unsigned int index) const { return forces[index]; }
        AiForce &operator[](unsigned int index) { return forces[index]; }
 
        int getIndex(AiForce *force) const
        {
                for (unsigned int i = 0; i < forces.size(); ++i) {
                        if (force == &forces[i]) {
                                return i;
                        }
                }
                return -1;
        }
 
        unsigned int getScriptForce(unsigned int index)
        {
                if (script[index] == -1) {
                        script[index] = FindFreeForce();
                }
                return script[index];
        }
 
        int GetForce(const CUnit &unit);
        void RemoveDeadUnit();
        bool Assign(CUnit &unit, int force = -1);
        void Update();
        unsigned int FindFreeForce(AiForceRole role = AiForceRoleDefault, int begin = 0);
        void CheckUnits(int *counter);
private:
        std::vector<AiForce> forces;
        char script[AI_MAX_FORCES];
};
 
class AiBuildQueue
{
public:
        AiBuildQueue() : Want(0), Made(0), Type(NULL), Wait(0)
        {
                Pos.x = Pos.y = -1;
        }
 
public:
        unsigned int Want;  
        unsigned int Made;  
        CUnitType *Type;    
        unsigned long Wait; 
        Vec2i Pos;          
};
 
class AiExplorationRequest
{
public:
        AiExplorationRequest(const Vec2i &pos, int mask) : pos(pos), Mask(mask) {}
 
public:
        Vec2i pos;          
        int Mask;           
};
 
class PlayerAi
{
public:
        PlayerAi() : Player(NULL), AiType(NULL),
                SleepCycles(0), NeededMask(0), NeedSupply(false),
                ScriptDebug(false), BuildDepots(true), LastExplorationGameCycle(0),
                LastCanNotMoveGameCycle(0), LastRepairBuilding(0)
        {
                memset(Reserve, 0, sizeof(Reserve));
                memset(Used, 0, sizeof(Used));
                memset(Needed, 0, sizeof(Needed));
                memset(Collect, 0, sizeof(Collect));
        }
 
public:
        CPlayer *Player;            
        CAiType *AiType;            
        // controller
        std::string Script;         
        unsigned long SleepCycles;  
 
        AiForceManager Force;  
 
        // resource manager
        int Reserve[MaxCosts]; 
        int Used[MaxCosts];    
        int Needed[MaxCosts];  
        int Collect[MaxCosts]; 
        int NeededMask;        
        bool NeedSupply;       
        bool ScriptDebug;      
        bool BuildDepots;      
 
        std::vector<AiExplorationRequest> FirstExplorationRequest;
        unsigned long LastExplorationGameCycle;       
        unsigned long LastCanNotMoveGameCycle;        
        std::vector<AiRequestType> UnitTypeRequests;  
        std::vector<CUnitType *> UpgradeToRequests;   
        std::vector<CUpgrade *> ResearchRequests;     
        std::vector<AiBuildQueue> UnitTypeBuilt;      
        int LastRepairBuilding;                       
};
 
class AiHelper
{
public:
        std::vector<std::vector<CUnitType *> > &Train();
        std::vector<std::vector<CUnitType *> > &Build();
        std::vector<std::vector<CUnitType *> > &Upgrade();
        std::vector<std::vector<CUnitType *> > &Research();
        std::vector<std::vector<CUnitType *> > &SingleResearch();
        std::vector<std::vector<CUnitType *> > &Repair();
        std::vector<std::vector<CUnitType *> > &UnitLimit();
        std::vector<std::vector<CUnitType *> > &Equiv();
 
        std::vector<std::vector<CUnitType *> > &Refinery();
 
        std::vector<std::vector<CUnitType *> > &Depots();
};
 
/*----------------------------------------------------------------------------
--  Variables
----------------------------------------------------------------------------*/
 
extern std::vector<CAiType *> AiTypes;   
extern AiHelper AiHelpers; 
 
extern int UnitTypeEquivs[UnitTypeMax + 1]; 
extern PlayerAi *AiPlayer; 
 
/*----------------------------------------------------------------------------
--  Functions
----------------------------------------------------------------------------*/
 
//
// Resource manager
//
extern void AiAddUnitTypeRequest(CUnitType &type, int count);
extern void AiAddUpgradeToRequest(CUnitType &type);
extern void AiAddResearchRequest(CUpgrade *upgrade);
extern void AiResourceManager();
extern void AiExplore(const Vec2i &pos, int exploreMask);
extern void AiNewUnitTypeEquiv(const CUnitType &a, const CUnitType &b);
extern void AiResetUnitTypeEquiv();
extern int AiFindUnitTypeEquiv(const CUnitType &type, int *result);
extern int AiFindAvailableUnitTypeEquiv(const CUnitType &type, int *result);
extern int AiGetBuildRequestsCount(const PlayerAi &pai, int (&counter)[UnitTypeMax]);
 
extern void AiNewDepotRequest(CUnit &worker);
extern CUnit *AiGetSuitableDepot(const CUnit &worker, const CUnit &oldDepot, CUnit **resUnit);
 
//
// Buildings
//
extern bool AiFindBuildingPlace(const CUnit &worker, const CUnitType &type, const Vec2i &nearPos, Vec2i *resultPos);
 
//
// Forces
//
extern void AiRemoveDeadUnitInForces();
extern bool AiAssignToForce(CUnit &unit);
extern void AiAssignFreeUnitsToForce(int force = -1);
extern void AiAttackWithForceAt(unsigned int force, int x, int y);
extern void AiAttackWithForce(unsigned int force);
extern void AiAttackWithForces(int *forces);
 
extern void AiForceManager();
 
//
// Plans
//
extern int AiFindWall(AiForce *force);
extern void AiSendExplorers();
extern bool AiEnemyUnitsInDistance(const CPlayer &player, const CUnitType *type,
                                                                  const Vec2i &pos, unsigned range);
 
//
// Magic
//
extern void AiCheckMagic();
 
 
#endif // !__AI_LOCAL_H__