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

       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"

---

ai_local.h

Go to the documentation of this file.

//     ____                _       __               
//    / __ )____  _____   | |     / /___ ___________
//   / __  / __ \/ ___/   | | /| / / __ `/ ___/ ___/
//  / /_/ / /_/ (__  )    | |/ |/ / /_/ / /  (__  ) 
// /_____/\____/____/     |__/|__/\__,_/_/  /____/  
//                                              
//       A futuristic real-time strategy game.
//          This file is part of Bos Wars.
//
//
//      (c) Copyright 2000-2007 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"
#include "unit.h"

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

class CUnit;
class CUnitType;
class CPlayer;

class CAiType {
public:
    CAiType() {}

    std::string Name;     
    std::string Class;    

#if 0
    // nice flags
    unsigned char AllExplored : 1; 
    unsigned char AllVisbile : 1;  
#endif

    std::string Script;       
};

class AiRequestType {
public:
    AiRequestType() : Count(0), Type(NULL) {}

    int Count;           
    CUnitType *Type;     
};

class AiUnitType {
public:
    AiUnitType() : Want(0), Type(NULL) {}

    int Want;        
    CUnitType *Type; 
};

enum AiForceRole {
    AiForceRoleAttack, 
    AiForceRoleDefend, 
};


class AiForce {
public:
    AiForce() : Completed(false), Defending(false), Attacking(false), Role(0),
        State(0), GoalX(0), GoalY(0), MustTransport(false) {}

    void Reset() {
        Completed = false;
        Defending = false;
        Attacking = false;
        Role = 0;
        UnitTypes.clear();
        Units.clear();
        State = 0;
        GoalX = GoalY = 0;
        MustTransport = false;
    }

    bool Completed;     
    bool Defending;     
    bool Attacking;     
    char Role;          

    std::vector<AiUnitType> UnitTypes; 
    std::vector<CUnit *> Units;        

    //
    // If attacking
    //
    int State;         
    int GoalX;         
    int GoalY;         
    bool MustTransport;
};

class AiBuildQueue {
public:
    AiBuildQueue() : Want(0), Made(0), Type(NULL), Wait(0) {}

    int Want;           
    int Made;           
    CUnitType *Type;    
    unsigned long Wait; 
};

class AiExplorationRequest {
public:
    AiExplorationRequest() : X(0), Y(0), Mask(0) {}

    int X;              
    int Y;              
    int Mask;           
};

class AiTransportRequest {
public:
    AiTransportRequest() : Unit(NULL) {}

    CUnit *Unit;
    COrder Order;
};

class PlayerAi {
public:
    PlayerAi() : Player(NULL), AiType(NULL), ScriptDebug(false),
        SleepCycles(0), NeededMask(0), NeedSupply(false),
        LastExplorationGameCycle(0), LastCanNotMoveGameCycle(0),
        LastRepairBuilding(0)
    {
        memset(Needed, 0, sizeof(Needed));
        memset(TriedRepairWorkers, 0, sizeof(TriedRepairWorkers));
    }

    CPlayer *Player;               
    CAiType *AiType;               
    // controller
    std::string Script;            
    bool ScriptDebug;              
    unsigned long SleepCycles;     

    // forces
#define AI_MAX_FORCES 10                    
#define AI_MAX_ATTACKING_FORCES 30          
    AiForce Force[AI_MAX_ATTACKING_FORCES]; 

    // resource manager
    int Needed[MaxCosts];  
    int NeededMask;        
    bool NeedSupply;       

    std::vector<AiExplorationRequest> FirstExplorationRequest;
    unsigned long LastExplorationGameCycle;         
    std::vector<AiTransportRequest> TransportRequests;
    unsigned long LastCanNotMoveGameCycle;          
    std::vector<AiRequestType> UnitTypeRequests;    
    std::vector<AiBuildQueue> UnitTypeBuilt;        
    int LastRepairBuilding;                         
    unsigned TriedRepairWorkers[UnitMax];           
};

class AiHelper {
public:
    std::vector<std::vector<CUnitType *> > Train;
    std::vector<std::vector<CUnitType *> > Build;
    std::vector<std::vector<CUnitType *> > Repair;
    std::vector<std::vector<CUnitType *> > UnitLimit;
    std::vector<std::vector<CUnitType *> > Equiv;
};

/*----------------------------------------------------------------------------
--  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 AiResourceManager(void);
extern void AiExplore(int x, int y, int exploreMask);
extern void AiNewUnitTypeEquiv(CUnitType *a, CUnitType *b);
extern void AiResetUnitTypeEquiv(void);
extern int AiFindUnitTypeEquiv(const CUnitType *i, int *result);
extern int AiFindAvailableUnitTypeEquiv(const CUnitType *i,
    int *result);

//
// Buildings
//
extern int AiFindBuildingPlace(const CUnit *worker,
    const CUnitType *type, int *dx, int *dy);

//
// Forces
//
extern void AiCleanForces(void);
extern void AiAssignToForce(CUnit *unit);
extern void AiAssignFreeUnitsToForce(void);
extern void AiAttackWithForceAt(int force, int x, int y);
extern void AiAttackWithForce(int force);
extern void AiForceManager(void);

//
// Plans
//
extern int AiPlanAttack(AiForce *force);
extern void AiSendExplorers(void);
extern int AiEnemyUnitsInDistance(const CPlayer *player, const CUnitType *type,
    int x, int y, unsigned range);

//
// Magic
//
extern void AiCheckMagic(void);


#endif // !__AI_LOCAL_H__

---