DarkBlizz

RequirementsAI.galaxy < suite


//--------------------------------------------------------------------------------------------------
//  Markers
//--------------------------------------------------------------------------------------------------
const string c_MK_Danger                    = "AI/Tactical/Danger";
const string c_MK_EMP                       = "Abil/EMP/AI";
const string c_MK_PhaseShift                = "Abil/PhaseShift/AI";
const string c_MK_ForceField                = "Abil/ForceField/AI";
const string c_MK_FungalGrowth              = "Abil/FungalGrowth/AI";
const string c_MK_GameFungalGrowth          = "Abil/FungalGrowth";
const string c_MK_GameNeuralParasite        = "Abil/NeuralParasite";
const string c_MK_InfestorDisease           = "Abil/InfestorDisease/AI";
const string c_MK_Lockdown                  = "Abil/Lockdown/AI";
const string c_MK_D8Charge                  = "Abil/D8Charge/AI";
const string c_MK_D8ChargeFlee              = "Abil/D8ChargeFlee/AI";
const string c_MK_MissilePods               = "Abil/MissilePods/AI";
const string c_MK_LeviathanCharge           = "Abil/LeviathanCharge/AI";
const string c_MK_NeuralParasite            = "Abil/NeuralParsite/AI";
const string c_MK_PsiStorm                  = "Abil/PsiStorm/AI";
const string c_MK_GravitonBeam              = "Abil/GravitonBeam/AI";
const string c_MK_SapStructure              = "Abil/SapStructure/AI";
const string c_MK_Snipe                     = "Abil/Snipe/AI";
const string c_MK_SeekerMissile             = "Abil/HunterSeekerMissile/AI";
const string c_MK_250mmStrikeCannons        = "Abil/250mmStrikeCannons/AI";
const string c_MK_UnstableMutation          = "Abil/UnstableMutation/AI";
const string c_MK_Yamato                    = "Abil/Yamato/AI";

//--------------------------------------------------------------------------------------------------
//  Buffs
//--------------------------------------------------------------------------------------------------
const string c_BF_FungalGrowth              = "FungalGrowth";
const string c_BF_GravitonBeam              = "GravitonPrison";
const string c_BF_Lockdown                  = "LockdownB";
const string c_BF_MutantLarvaTimer          = "SpawnMutantLarvaTimer";
const string c_BF_PersonalCloaking          = "PersonalCloaking";
const string c_BF_ProbeBuff                 = "ProtonCharge";
const string c_BF_PsionicShockwave          = "PsionicShockwaveBehaviorController";
const string c_BF_Stim                      = "stim";
const string c_BF_SupplyDrop                = "SupplyDrop";
const string c_BF_SwarmInfestation          = "SwarmInfestation";
const string c_BF_TemporalBuff              = "TemporalRiftUnit";
const string c_BF_UnstableMutation          = "UnstableMutation";

//--------------------------------------------------------------------------------------------------
//  Effects
//--------------------------------------------------------------------------------------------------
const string c_EF_AcidSporesArea            = "AcidSporesSearch";
const string c_EF_BaneBuilding              = "BanelingU2";
const string c_EF_BaneUnit                  = "BanelingU";
const string c_EF_ConsumeDNADamage          = "ConsumeDNADamage";
const string c_EF_ConsumeDNAPersistent      = "ConsumeDNACP";
const string c_EF_EMPArea                   = "EMP2A";
const string c_EF_HybridStunArea            = "HybridFAoESearch";
const string c_EF_InfestorDiseaseArea       = "InfestorDiseaseSearch";
const string c_EF_D8ChargeDmg               = "D8ChargeExplodeDamage";
const string c_EF_MissilePodArea            = "HurricaneMissileDamage";
const string c_EF_Nuke                      = "nuke";
const string c_EF_NukeDamage                = "nukeDamage";
const string c_EF_OdinBarrageArea           = "BarrageSearchArea";
const string c_EF_OmegaStormArea            = "OmegaStormSearchArea";
const string c_EF_PlasmaBlastDamage         = "HybridCPlasmaBlastDamage";
const string c_EF_ProbeBuffArea             = "ProbeBuffSearchArea";
const string c_EF_ProtonChargeSearchArea    = "ProtonChargeSearchArea";
const string c_EF_PsionicShockWaveArea      = "PsionicShockwaveSearchArea";
const string c_EF_PsiStormArea              = "PsiStormSearch";
const string c_EF_SeekerDamage              = "HunterSeekerDamage";
const string c_EF_ShockWavePersistent       = "PsionicShockwaveCreatePersistent";
const string c_EF_SnipeDamage               = "snipeDamage";
const string c_EF_TemporalRiftSearchArea    = "TemporalRiftUnitSearchArea";
const string c_EF_250mmStrikeCannonsDamage  = "250mmStrikeCannonsDamage";
const string c_EF_250mmStrikeCannonsPersistent= "250mmStrikeCannonsCreatePersistent";
const string c_EF_Transfusion               = "Transfusion";
const string c_EF_YamatoDamage              = "YamatoU";
const string c_EF_VortexArea                = "VortexSearchArea";
const string c_EF_LeviathanChargeDamage     = "LeviathanChargeU";
const string c_EF_LeviathanCharge           = "LeviathanCharge";
const string c_EF_ZergVortexArea            = "ZergVortexSearchArea";

//--------------------------------------------------------------------------------------------------
//  Weapons
//--------------------------------------------------------------------------------------------------
const string c_WE_AutoTurret                = "AutoTurret";
const string c_WE_Reaper                    = "Reaper";
const string c_WE_SiegeTankSieged           = "SiegeTankSieged";
const string c_WE_SpineCrawler              = "SpineCrawler";
const string c_WE_VikingFighter             = "VikingFighter";
const string c_WE_InfestedTerran            = "InfestedTerran";

//--------------------------------------------------------------------------------------------------
//  Abilities
//--------------------------------------------------------------------------------------------------
const string c_AB_Move                      = "move";
const string c_AB_Follow                    = "move";

const string c_AB_AcidSpores                = "AcidSpores";
const string c_AB_AssaultMode               = "AssaultMode";
const string c_AB_Attack                    = "attack";
const string c_AB_AutoTurret                = "AutoTurret";
const string c_AB_Blink                     = "Blink";
const string c_AB_BuildFighter              = "CarrierHangar";
const string c_AB_BansheeCloak              = "BansheeCloak";
const string c_AB_BurrowBanelingDown        = "BurrowBanelingDown";
const string c_AB_BurrowBanelingUp          = "BurrowBanelingUp";
const string c_AB_BurrowDroneDown           = "BurrowDroneDown";
const string c_AB_BurrowDroneUp             = "BurrowDroneUp";
const string c_AB_BurrowHydraliskDown       = "BurrowHydraliskDown";
const string c_AB_BurrowHydraliskUp         = "BurrowHydraliskUp";
const string c_AB_BurrowInfestorDown        = "BurrowInfestorDown";
const string c_AB_BurrowInfestorUp          = "BurrowInfestorUp";
const string c_AB_BurrowLurkerDown          = "BurrowLurkerDown";
const string c_AB_BurrowLurkerUp            = "BurrowLurkerUp";
const string c_AB_BurrowRoachDown           = "BurrowRoachDown";
const string c_AB_BurrowRoachUp             = "BurrowRoachUp";
const string c_AB_BurrowQoBDown             = "Val03QueenOfBladesBurrow";
const string c_AB_BurrowQoBUp               = "Val03QueenOfBladesUnburrow";
const string c_AB_BurrowQueenDown           = "BurrowQueenDown";
const string c_AB_BurrowQueenUp             = "BurrowQueenUp";
const string c_AB_BurrowUltraliskDown       = "BurrowUltraliskDown";
const string c_AB_BurrowUltraliskUp         = "BurrowUltraliskUp";
const string c_AB_BurrowZerglingDown        = "BurrowZerglingDown";
const string c_AB_BurrowZerglingUp          = "BurrowZerglingUp";
const string c_AB_Changeling                = "SpawnChangeling";
const string c_AB_ConsumeDNA                = "ConsumeDNA";
const string c_AB_DefensiveMatrix           = "DefensiveMatrix";
const string c_AB_DepotLower                = "SupplyDepotLower";
const string c_AB_DepotRaise                = "SupplyDepotRaise";
const string c_AB_Drill                     = "RestoreResources";
const string c_AB_EMP                       = "EMP";
const string c_AB_ArgusLink                 = "ArgusLink";
const string c_AB_PhaseShift                = "PhaseShift";
const string c_AB_FighterMode               = "FighterMode";
const string c_AB_ForceField                = "ForceField";
const string c_AB_FungalGrowth              = "FungalGrowth";
const string c_AB_GenerateCreep             = "GenerateCreep";
const string c_AB_GhostCloak                = "PersonalCloaking";
const string c_AB_GravitonPrison            = "GravitonPrison";
const string c_AB_HybridAoEStun             = "HybridFAoEStun";
const string c_AB_HybridBlink               = "HybridBlink";
const string c_AB_InfestorDisease           = "InfestorDisease";
const string c_AB_InfestedTerrans           = "InfestedTerrans";
const string c_AB_Lockdown                  = "Lockdown";
const string c_AB_D8Charge                  = "D8Charge";
const string c_AB_MissilePods               = "MissilePods";
const string c_AB_NeuralParasite            = "NeuralParasite";
const string c_AB_Nuke                      = "nuke";
const string c_AB_OdinBarrage               = "OdinBarrage";
const string c_AB_Overload                  = "Overload";
const string c_AB_CalldownMULE              = "CalldownMULE";
const string c_AB_GravitonBeam              = "GravitonBeam";
const string c_AB_PlasmaBlast               = "HybridCPlasmaBlast";
const string c_AB_ProbeBuff                 = "ProtonCharge";
const string c_AB_PsionicShockwave          = "PsionicShockwave";
const string c_AB_PsiStorm                  = "PsiStorm";
const string c_AB_QoBIndignation            = "Indignation";
const string c_AB_QoBImplosion              = "Implosion";
const string c_AB_QoBOmegaStorm             = "OmegaStorm";
const string c_AB_QueenBuild                = "QueenBuild";
const string c_AB_Rally                     = "Rally";
const string c_AB_SapStructure              = "SapStructure";
const string c_AB_ScannerSweep              = "ScannerSweep";
const string c_AB_SeekerMissile             = "HunterSeekerMissile";
const string c_AB_ShieldBattery             = "ShieldBattery";
const string c_AB_SiegeMode                 = "SiegeMode";
const string c_AB_SiegeUnmode               = "Unsiege";
const string c_AB_Snipe                     = "Snipe";
const string c_AB_SpawnMutantLarva          = "SpawnMutantLarva";
const string c_AB_SpiderMine                = "SpiderMine";
const string c_AB_Stim                      = "StimPack";
const string c_AB_SupplyDrop                = "SupplyDrop";
const string c_AB_SpineCrawlerRoot          = "SpineCrawlerRoot";
const string c_AB_SporeCrawlerRoot          = "SporeCrawlerRoot";
const string c_AB_SpineCrawlerUproot        = "SpineCrawlerUproot";
const string c_AB_SporeCrawlerUproot        = "SporeCrawlerUproot";
const string c_AB_SwarmInfestation          = "SwarmInfestation";
const string c_AB_TemporalRift              = "TemporalRift";
const string c_AB_ThorRebirth               = "ThorReborn";
const string c_AB_250mmStrikeCannons        = "250mmStrikeCannons";
const string c_AB_Transfusion               = "Transfusion";
const string c_AB_UnstableMutation          = "UnstableMutation";
const string c_AB_Vortex                    = "Vortex";
const string c_AB_UpgradeToWarpGate         = "UpgradeToWarpGate";
const string c_AB_WormholeTransit           = "WormholeTransit";
const string c_AB_WPPhasingMode             = "PhasingMode";
const string c_AB_WPTransportMode           = "TransportMode";
const string c_AB_WraithCloak               = "WraithCloak";
const string c_AB_Yamato                    = "Yamato";
const string c_AB_LeviathanCharge           = "LeviathanCharge";
const string c_AB_ZergVortex                = "ZergVortex";

const string c_AB_BunkerChange              = "BunkerTransport";
const string c_AB_CommandCenterChange       = "CommandCenterTransport";
const int    e_AB_TransportLoadUnit         = 0;
const int    e_AB_TransportUnloadAll        = 1;
const int    e_AB_TransportUnloadUnit       = 3;
const int    e_AB_TransportLoadAll          = 4;

const string c_AB_Hallucinate               = "HighTemplarTrain";
const int    e_AB_Hallucinate_Probe         = 0;
const int    e_AB_Hallucinate_Zealot        = 1;
const int    e_AB_Hallucinate_Stalker       = 2;
const int    e_AB_Hallucinate_Immortal      = 3;
const int    e_AB_Hallucinate_HighTemplar   = 4;
const int    e_AB_Hallucinate_Archon        = 5;
const int    e_AB_Hallucinate_VoidRay       = 6;
const int    e_AB_Hallucinate_Phoenix       = 7;
const int    e_AB_Hallucinate_WarpPrism     = 8;
const int    e_AB_Hallucinate_Colossus      = 9;

//--------------------------------------------------------------------------------------------------
// Unit Attributes
//--------------------------------------------------------------------------------------------------

const int e_unitAttributeNone           = -1;
const int e_unitAttributeLight          =  0;
const int e_unitAttributeArmored        =  1;
const int e_unitAttributeBiological     =  2;
const int e_unitAttributeMechanical     =  3;
const int e_unitAttributeRobotic        =  4;
const int e_unitAttributePsionic        =  5;
const int e_unitAttributeMassive        =  6;
const int e_unitAttributeStructure      =  7;
const int e_unitAttributeHover          =  8;
const int e_unitAttributeHeroic         =  9;

//--------------------------------------------------------------------------------------------------
//  Object Types
//--------------------------------------------------------------------------------------------------
const int c_objTypeIsInvalid          = -1;
const int c_objTypeIsUnit             = 0;
const int c_objTypeIsBuilding         = 1;
const int c_objTypeIsResearch         = 2;


//--------------------------------------------------------------------------------------------------
//  AI Get Object Type
//--------------------------------------------------------------------------------------------------
int AIGetObjectType (int player, string objType) {

    // override any special cases here

    return AIDefaultGetObjectType(player, objType);
}

//--------------------------------------------------------------------------------------------------
//  AI Get Maker
//--------------------------------------------------------------------------------------------------
string AIGetMaker (int player, string objType) {

    // override any special cases here

    return AIDefaultGetMaker(player, objType);
}

//--------------------------------------------------------------------------------------------------
//  AI Get First Missing Req
//--------------------------------------------------------------------------------------------------
string AIGetFirstMissingReq (int player, string objType) {

    // override any special cases here

    return AIDefaultGetFirstMissingReq(player, objType);
}

//--------------------------------------------------------------------------------------------------
//  AI Any Unbuilt Reqs
//--------------------------------------------------------------------------------------------------
string AIGetFirstUnfinishedReq (int player, string objType) {

    // override any special cases here

    return AIDefaultGetFirstUnfinishedReq(player, objType);
}

//--------------------------------------------------------------------------------------------------
//  AI Get Full Make Time
//--------------------------------------------------------------------------------------------------
int AIGetFullMakeTime (int player, string objType) {

    // override any special cases here

    return AIDefaultGetFullMakeTime(player, objType);
}

//--------------------------------------------------------------------------------------------------
//  AI Specified Makers
//--------------------------------------------------------------------------------------------------
void AISpecifiedMakers () {
    AIReqAddSpecialMaker(c_TU_BattlecruiserDefensive, c_TU_Battlecruiser, "BattlecruiserSpecialize", 0);
    AIReqAddSpecialMaker(c_TU_BattlecruiserMissile, c_TU_Battlecruiser, "BattlecruiserSpecialize", 1);
    AIReqAddSpecialMaker(c_TU_BattlecruiserYamato, c_TU_Battlecruiser, "BattlecruiserSpecialize", 3);
}

//--------------------------------------------------------------------------------------------------
//  Declare the Nuke Constant Setting here
//--------------------------------------------------------------------------------------------------
void AISetNukeConstants (int player);

RequirementsAI.galaxy
//--------------------------------------------------------------------------------------------------
//  AI Requirements Functions
//--------------------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------------------
//  Neutral Units
//--------------------------------------------------------------------------------------------------
const string c_NU_Minerals                = "MineralField";
const string c_NU_HighYieldMinerals       = "HighYieldMineralField";
const string c_NU_VespeneGeyser           = "VespeneGeyser";

//--------------------------------------------------------------------------------------------------
//  Protoss Units
//--------------------------------------------------------------------------------------------------
const string c_PU_Archon                  = "Archon";
const string c_PU_Carrier                 = "Carrier";
const string c_PU_Colossus                = "Colossus";
const string c_PU_DarkTemplar             = "DarkTemplar";
const string c_PU_HighTemplar             = "HighTemplar";
const string c_PU_Immortal                = "Immortal";
const string c_PU_Mothership              = "Mothership";
const string c_PU_Disruptor               = "Disruptor";
const string c_PU_Observer                = "Observer";
const string c_PU_Phoenix                 = "Phoenix";
const string c_PU_Probe                   = "Probe";
const string c_PU_Stalker                 = "Stalker";
const string c_PU_VoidRay                 = "VoidRay";
const string c_PU_WarpPrism               = "WarpPrism";
const string c_PU_WarpPrismPhasing        = "WarpPrismPhasing";
const string c_PU_Zealot                  = "Zealot";

//--------------------------------------------------------------------------------------------------
//  Protoss Buildings
//--------------------------------------------------------------------------------------------------
const string c_PB_Assimilator             = "Assimilator";
const string c_PB_CyberneticsCore         = "CyberneticsCore";
const string c_PB_DarkShrine              = "DarkShrine";
const string c_PB_Obelisk                 = "Obelisk";
const string c_PB_FleetBeacon             = "FleetBeacon";
const string c_PB_Forge                   = "Forge";
const string c_PB_Gateway                 = "Gateway";
const string c_PB_Nexus                   = "Nexus";
const string c_PB_PhotonCannon            = "PhotonCannon";
const string c_PB_Pylon                   = "Pylon";
const string c_PB_RoboticsBay             = "RoboticsBay";
const string c_PB_RoboticsFacility        = "RoboticsFacility";
const string c_PB_Stargate                = "Stargate";
const string c_PB_WarpGate                = "WarpGate";
const string c_PB_TemplarArchives         = "TemplarArchive";
const string c_PB_TwilightCouncil         = "TwilightCouncil";

//--------------------------------------------------------------------------------------------------
//  Protoss Research Upgrades
//--------------------------------------------------------------------------------------------------
const string c_PR_AirArmor1               = "ProtossAirArmorsLevel1";
const string c_PR_AirArmor2               = "ProtossAirArmorsLevel2";
const string c_PR_AirArmor3               = "ProtossAirArmorsLevel3";
const string c_PR_AirWeapons1             = "ProtossAirWeaponsLevel1";
const string c_PR_AirWeapons2             = "ProtossAirWeaponsLevel2";
const string c_PR_AirWeapons3             = "ProtossAirWeaponsLevel3";
const string c_PR_ColossusRange           = "ExtendedThermalLance";         // ExtendedThermalLance
const string c_PR_GroundArmor1            = "ProtossGroundArmorsLevel1";
const string c_PR_GroundArmor2            = "ProtossGroundArmorsLevel2";
const string c_PR_GroundArmor3            = "ProtossGroundArmorsLevel3";
const string c_PR_GroundWeapons1          = "ProtossGroundWeaponsLevel1";
const string c_PR_GroundWeapons2          = "ProtossGroundWeaponsLevel2";
const string c_PR_GroundWeapons3          = "ProtossGroundWeaponsLevel3";
const string c_PR_HighTemplarEnergy       = "HighTemplarKhaydarinAmulet";   // KhaydarinAmulet
const string c_PR_HighTemplarPsiStorm     = "PsiStormTech";                 // PsiStorm
const string c_PR_DisruptorHallucination  = "haltech";                      // Hallucination
const string c_PR_ObserverSpeed           = "ObserverGraviticBooster";      // GraviticBoosters
const string c_PR_Shields1                = "ProtossShieldsLevel1";
const string c_PR_Shields2                = "ProtossShieldsLevel2";
const string c_PR_Shields3                = "ProtossShieldsLevel3";
const string c_PR_StalkerBlink            = "BlinkTech";                    // Blink
const string c_PR_WarpGateResearch        = "WarpGateResearch";             // gateway -> warp gate
const string c_PR_WarpPrismSpeed          = "GraviticDrive";                // GraviticDrive
const string c_PR_ZealotCharge            = "Charge";                       // Charge

//--------------------------------------------------------------------------------------------------
//  Terran Units
//--------------------------------------------------------------------------------------------------
const string c_TU_AutoTurret              = "AutoTurret";
const string c_TU_Banshee                 = "Banshee";
const string c_TU_Battlecruiser           = "Battlecruiser";
const string c_TU_BattlecruiserClass      = "Alias_BattlecruiserClass";
const string c_TU_BattlecruiserDefensive  = "BattlecruiserDefensiveMatrix";
const string c_TU_BattlecruiserMissile    = "BattlecruiserHurricane";
const string c_TU_BattlecruiserYamato     = "BattlecruiserYamato";
const string c_TU_D8Charge                = "MagneticMine";
const string c_TU_Ghost                   = "Ghost";
const string c_TU_Hellion                 = "Hellion";
const string c_TU_Marauder                = "Marauder";
const string c_TU_Marine                  = "Marine";
const string c_TU_Medivac                 = "Medivac";
const string c_TU_Raven                   = "Raven";
const string c_TU_Reaper                  = "Reaper";
const string c_TU_SCV                     = "SCV";
const string c_TU_SiegeTank               = "SiegeTank";
const string c_TU_SiegeTankSieged         = "SiegeTankSieged";
const string c_TU_SiegeTank_Alias         = "Alias_SiegeTank";
const string c_TU_Thor                    = "Thor";
const string c_TU_Viking                  = "VikingFighter";
const string c_TU_VikingAir               = "VikingFighter";
const string c_TU_VikingGnd               = "VikingAssault";
const string c_TU_Viking_Alias            = "Alias_Viking";

//--------------------------------------------------------------------------------------------------
//  Terran Buildings
//--------------------------------------------------------------------------------------------------
const string c_TB_Armory                  = "Armory";
const string c_TB_Barracks                = "Barracks";
const string c_TB_BarracksReactor         = "BarracksNuclearReactor";
const string c_TB_BarracksTechLab         = "BarracksTechLab";
const string c_TB_Bunker                  = "Bunker";
const string c_TB_CommandCenter           = "CommandCenter";
const string c_TB_CommandCenter_Alias     = "Alias_CommandCenter";
const string c_TB_EngineeringBay          = "EngineeringBay";
const string c_TB_Factory                 = "Factory";
const string c_TB_FactoryReactor          = "FactoryNuclearReactor";
const string c_TB_FactoryTechLab          = "FactoryTechLab";
const string c_TB_FusionCore              = "FusionCore";
const string c_TB_GenericTechLab          = "TechLab";
const string c_TB_GhostAcademy            = "GhostAcademy";
const string c_TB_MercCompound            = "MercCompound";
const string c_TB_MissileTurret           = "MissileTurret";
const string c_TB_NuclearReactor          = "NuclearReactor";
const string c_TB_OrbitalCommand          = "OrbitalCommand";
const string c_TB_PlanetaryFortress       = "PlanetaryFortress";
const string c_TB_Refinery                = "Refinery";
const string c_TB_SensorTower             = "SensorTower";
const string c_TB_Starport                = "Starport";
const string c_TB_StarportReactor         = "StarportNuclearReactor";
const string c_TB_StarportTechLab         = "StarportTechLab";
const string c_TB_SupplyDepot             = "SupplyDepot";
const string c_TB_SupplyDepot_Alias       = "Alias_SupplyDepot";

//--------------------------------------------------------------------------------------------------
//  Terran Research Upgrades
//--------------------------------------------------------------------------------------------------
const string c_TR_BansheeCloak          = "BansheeCloak";                   // CloakingField
const string c_TR_BattlecruiserEnergy   = "ColossalReactor";                // ColossalReactor
const string c_TR_BuildingArmor         = "TerranBuildingArmor";
const string c_TR_BunkerSpace           = "NeosteelFrame";                  // NeosteelFrame
const string c_TR_GhostCloak            = "PersonalCloaking";               // PersonalCloaking
const string c_TR_GhostEnergy           = "GhostMoebiusReactor";            // MoebiusReactor
const string c_TR_HellionDamage         = "HighCapacityBarrels";            // InfernalPreIgniter
const string c_TR_InfantryArmor1        = "TerranInfantryArmorsLevel1";
const string c_TR_InfantryArmor2        = "TerranInfantryArmorsLevel2";
const string c_TR_InfantryArmor3        = "TerranInfantryArmorsLevel3";
const string c_TR_InfantryWeapons1      = "TerranInfantryWeaponsLevel1";
const string c_TR_InfantryWeapons2      = "TerranInfantryWeaponsLevel2";
const string c_TR_InfantryWeapons3      = "TerranInfantryWeaponsLevel3";
const string c_TR_MarineShield          = "ShieldWall";                     // ShieldWall
const string c_TR_MarineStimPack        = "StimPack";                       // StimPack
const string c_TR_MedivacEnergy         = "MedivacCaduceusReactor";         // CaduceusReactor
const string c_TR_MissileTurretRange    = "TerranDefenseRangeBonus";        // DefenseRangeBonus
const string c_TR_RavenEnergy           = "TitanReactor";                   // TitanReactor
const string c_TR_RavenMissiles         = "HunterSeeker";                   // HunterSeekerMissiles
const string c_TR_ReaperSpeed           = "ReaperSpeed";                    // Reaper Speed Upgrade
const string c_TR_ShipPlating1          = "TerranShipArmorsLevel1";
const string c_TR_ShipPlating2          = "TerranShipArmorsLevel2";
const string c_TR_ShipPlating3          = "TerranShipArmorsLevel3";
const string c_TR_ShipWeapons1          = "TerranShipWeaponsLevel1";
const string c_TR_ShipWeapons2          = "TerranShipWeaponsLevel2";
const string c_TR_ShipWeapons3          = "TerranShipWeaponsLevel3";
const string c_TR_SiegeTankSiege        = "SiegeTech";                      // SiegeTech
const string c_TR_VehiclePlating1       = "TerranVehicleArmorsLevel1";
const string c_TR_VehiclePlating2       = "TerranVehicleArmorsLevel2";
const string c_TR_VehiclePlating3       = "TerranVehicleArmorsLevel3";
const string c_TR_VehicleWeapons1       = "TerranVehicleWeaponsLevel1";
const string c_TR_VehicleWeapons2       = "TerranVehicleWeaponsLevel2";
const string c_TR_VehicleWeapons3       = "TerranVehicleWeaponsLevel3";

//--------------------------------------------------------------------------------------------------
//  Zerg Units
//--------------------------------------------------------------------------------------------------

const string c_ZU_Baneling                = "Baneling";
const string c_ZU_BanelingEgg             = "BanelingEgg";
const string c_ZU_Broodling               = "Broodling";
const string c_ZU_Changeling              = "Changeling";
const string c_ZU_ChangelingZealot        = "ChangelingZealot";
const string c_ZU_ChangelingZergling      = "ChangelingZergling";
const string c_ZU_ChangelingZerglingWings = "ChangelingZerglingWings";
const string c_ZU_ChangelingMarineShield  = "ChangelingMarineShield";
const string c_ZU_ChangelingMarine        = "ChangelingMarine";
const string c_ZU_Cocoon                  = "MutaliskCocoon";
const string c_ZU_Corruptor               = "Corruptor";
const string c_ZU_CreepTumor              = "CreepTumor";
const string c_ZU_Drone                   = "Drone";
const string c_ZU_Hydralisk               = "Hydralisk";
const string c_ZU_Infestor                = "Infestor";
const string c_ZU_InfestedTerran          = "InfestedTerran";
const string c_ZU_InfestedTerranEgg      = "InfestedTerransEggPlacement";
const string c_ZU_Larva                   = "Larva";
const string c_ZU_Lurker                  = "Lurker";
const string c_ZU_LurkerEgg               = "LurkerEgg";
const string c_ZU_Mantaling               = "SwarmGuardianSpawn";
const string c_ZU_Mutalisk                = "Mutalisk";
const string c_ZU_Overlord                = "Overlord";
const string c_ZU_Overlord_Alias          = "Alias_Overlord";
const string c_ZU_OverlordCocoon          = "OverlordCocoon";
const string c_ZU_Overseer                = "Overseer";
const string c_ZU_Queen                   = "Queen";
const string c_ZU_Roach                   = "Roach";
const string c_ZU_BroodLord               = "BroodLord";
const string c_ZU_Ultralisk               = "Ultralisk";
const string c_ZU_Zergling                = "Zergling";

//----------------------------------------------------------------------------------------------------
//  Zerg Buildings
//--------------------------------------------------------------------------------------------------

const string c_ZB_BanelingNest            = "BanelingNest";
const string c_ZB_CreepTumor              = "CreepTumorBurrowed";
const string c_ZB_EvolutionChamber        = "EvolutionChamber";
const string c_ZB_Extractor               = "Extractor";
const string c_ZB_GreaterSpire            = "GreaterSpire";
const string c_ZB_Hatchery                = "Hatchery";
const string c_ZB_Hatchery_Alias          = "Alias_Hatchery";
const string c_ZB_Hive                    = "Hive";
const string c_ZB_HydraliskDen            = "HydraliskDen";
const string c_ZB_HydraliskDen_Alias      = "Alias_HydraliskDen";
const string c_ZB_InfestationPit          = "InfestationPit";
const string c_ZB_Lair                    = "Lair";
const string c_ZB_Lair_Alias              = "Alias_Lair";
const string c_ZB_LurkerDen               = "LurkerDen";
const string c_ZB_NydusNetwork            = "NydusNetwork";
const string c_ZB_NydusWorm               = "NydusCanal";
const string c_ZB_RoachWarren             = "RoachWarren";
const string c_ZB_SpawningPool            = "SpawningPool";
const string c_ZB_SpineCrawler            = "SpineCrawler";
const string c_ZB_SpineCrawlerUp          = "SpineCrawlerUprooted";
const string c_ZB_Spire                   = "Spire";
const string c_ZB_Spire_Alias             = "Alias_Spire";
const string c_ZB_SporeCrawler            = "SporeCrawler";
const string c_ZB_SporeCrawlerUp          = "SporeCrawlerUprooted";
const string c_ZB_UltraliskCavern         = "UltraliskCavern";

//--------------------------------------------------------------------------------------------------
//  Zerg Research Upgrades
//--------------------------------------------------------------------------------------------------

const string c_ZR_Burrow                  = "Burrow";                       // Burrow
const string c_ZR_BanelingSpeed           = "CentrificalHooks";             // CentrificalHooks
const string c_ZR_CorruptorAttack         = "EnduringCorruption";           // EnduringCorruption
const string c_ZR_FlyerAttacks1           = "ZergFlyerWeaponsLevel1";
const string c_ZR_FlyerAttacks2           = "ZergFlyerWeaponsLevel2";
const string c_ZR_FlyerAttacks3           = "ZergFlyerWeaponsLevel3";
const string c_ZR_FlyerCarapace1          = "ZergFlyerArmorsLevel1";
const string c_ZR_FlyerCarapace2          = "ZergFlyerArmorsLevel2";
const string c_ZR_FlyerCarapace3          = "ZergFlyerArmorsLevel3";
const string c_ZR_GroundCarapace1         = "ZergGroundArmorsLevel1";
const string c_ZR_GroundCarapace2         = "ZergGroundArmorsLevel2";
const string c_ZR_GroundCarapace3         = "ZergGroundArmorsLevel3";
const string c_ZR_HydraliskSpeed          = "hydraliskspeed";               // MuscularAugments
const string c_ZR_InfestorEnergy          = "MetasynapticNode";             // MetasynapticNode
const string c_ZR_InfestorSpell           = "Disease";                      // FungalInfestation
const string c_ZR_MeleeAttacks1           = "ZergMeleeWeaponsLevel1";
const string c_ZR_MeleeAttacks2           = "ZergMeleeWeaponsLevel2";
const string c_ZR_MeleeAttacks3           = "ZergMeleeWeaponsLevel3";
const string c_ZR_MissileAttacks1         = "ZergMissileWeaponsLevel1";
const string c_ZR_MissileAttacks2         = "ZergMissileWeaponsLevel2";
const string c_ZR_MissileAttacks3         = "ZergMissileWeaponsLevel3";
const string c_ZR_OverseerSpeed           = "overlordspeed";                // PneumatizedCarapace
const string c_ZR_OverlordTransport       = "overlordtransport";            // VentralSacks
const string c_ZR_QueenDamagePlague       = "RazorTech";                    // RazorPlague
const string c_ZR_RoachRegen              = "OrganicCarapace";              // OrganicCarapace
const string c_ZR_RoachSpeed              = "GlialReconstitution";          // GlialReconstitution
const string c_ZR_ZerglingHaste           = "zerglingattackspeed";          // AdrenalGlands
const string c_ZR_ZerglingSpeed           = "zerglingmovementspeed";        // MetabolicBoost


Protoss.galaxy
//==================================================================================================
//  Protoss Melee AI
//==================================================================================================

include "TriggerLibs/Protoss0"

//--------------------------------------------------------------------------------------------------
//  Counter-Attack Units
//--------------------------------------------------------------------------------------------------
static void InitCounters (int player) {
//xxx lots of old data -- needs to be totally redone
    // versus Protoss
    AICounterUnit(player, c_PB_PhotonCannon,         0.40, c_PU_Immortal );
    AICounterUnit(player, c_PU_Zealot,              1.00, c_PU_Zealot   );
    AICounterUnit(player, c_PU_Stalker,             1.00, c_PU_Zealot   );
    AICounterUnit(player, c_PU_Immortal,            2.00, c_PU_Zealot   );
    AICounterUnit(player, c_PU_Disruptor,           0.75, c_PU_Zealot   );
    AICounterUnit(player, c_PU_HighTemplar,         1.00, c_PU_Stalker  );
    AICounterUnit(player, c_PU_DarkTemplar,         2.00, c_PU_Zealot   );
    AICounterUnit(player, c_PU_Archon,              1.00, c_PU_Immortal );
    AICounterUnit(player, c_PU_Colossus,            1.00, c_PU_Immortal );
    AICounterUnit(player, c_PU_VoidRay,             1.50, c_PU_Phoenix  );
    AICounterUnit(player, c_PU_Phoenix,             0.40, c_PU_Carrier  );
    AICounterUnit(player, c_PU_Carrier,             1.67, c_PU_VoidRay  );

    // versus Terran
    AICounterUnit(player, c_TB_Bunker,              0.40, c_PU_Immortal );
    AICounterUnit(player, c_TU_Marine,              0.50, c_PU_Zealot   );
    AICounterUnit(player, c_TU_Reaper,              1.00, c_PU_Zealot   );
    AICounterUnit(player, c_TU_Marauder,            1.00, c_PU_Zealot   );
    AICounterUnit(player, c_TU_Ghost,               1.00, c_PU_Stalker  );
    AICounterUnit(player, c_TU_Hellion,             0.25, c_PU_Immortal );
    AICounterUnit(player, c_TU_SiegeTank_Alias,     2.00, c_PU_Zealot   );
    AICounterUnit(player, c_TU_Thor,                3.00, c_PU_Zealot   );
    AICounterUnit(player, c_TU_Viking_Alias,        1.00, c_PU_Zealot   );
    AICounterUnit(player, c_TU_Viking_Alias,        0.50, c_PU_Phoenix  );
    AICounterUnit(player, c_TU_Banshee,             0.50, c_PU_Phoenix  );
    AICounterUnit(player, c_TU_BattlecruiserClass,  2.00, c_PU_VoidRay  );

    // versus Zerg
    AICounterUnit(player, c_ZB_SpineCrawler,        0.33, c_PU_Immortal );
    AICounterUnit(player, c_ZU_Zergling,            0.25, c_PU_Zealot   );
    AICounterUnit(player, c_ZU_Roach,               0.80, c_PU_Stalker  );
    AICounterUnit(player, c_ZU_Hydralisk,           0.50, c_PU_Stalker  );
    AICounterUnit(player, c_ZU_Lurker,              1.00, c_PU_Immortal );
    AICounterUnit(player, c_ZU_Infestor,            0.50, c_PU_Stalker  );
    AICounterUnit(player, c_ZU_Ultralisk,           1.00, c_PU_Stalker  );
    AICounterUnit(player, c_ZU_Mutalisk,            0.80, c_PU_Stalker  );
    AICounterUnit(player, c_ZU_Corruptor,           0.50, c_PU_Stalker  );
    AICounterUnit(player, c_ZU_BroodLord,       0.50, c_PU_Phoenix  );
}

//--------------------------------------------------------------------------------------------------
//  ProtossSubStateName
//--------------------------------------------------------------------------------------------------
string ProtossSubStateName (int state) {
    // TODO Call the individual difficulties to return a real substate name
    return "-" + IntToString(state) + "-";
}

//--------------------------------------------------------------------------------------------------
//  DebugCallbackProt
//--------------------------------------------------------------------------------------------------
void DebugCallbackProt (int player) {
    DebugAI("=====PROTOSS=====\n");
    DebugMelee(player);
    DebugAI("e_mainState = "        + MainStateName(AIState(player, e_mainState))           +
            ", e_mainSubState = "   + ProtossSubStateName(AIState(player, e_mainSubState))  +
            ", e_attackState = "    + AttackStateName(AIState(player, e_attackState))
    );
}

//--------------------------------------------------------------------------------------------------
//  AINewUnitProt
//--------------------------------------------------------------------------------------------------
void AINewUnitProt (int player, unit u) {
    int obs;
    string type = UnitGetType(u);

    // ignored units
    //
    if (UnitTypeTestAttribute(type, c_unitAttributeStructure)) {
        return;
    }
    if (UnitTypeTestFlag(type, c_unitFlagWorker)) {
        return;
    }
   
    if (type == c_PU_WarpPrism) {
        AIAddToExtraScoutGroup(player, u);
        return;
    }
   
    // detector
    //
    if (type == c_PU_Observer) {
        AINewDetector(player, u, true);
        return;
    }

    // clear obstacle units
    //
    if (AIWaveNeedClearObsUnits(player)) {
        if (type == c_PU_Zealot || type == c_PU_Stalker || type == c_PU_DarkTemplar) {
            AIMergeUnit(player, u, AIWaveGet(player, c_waveClearObs));
            return;
        }
    }

    // main wave units
    //
    AINewUnitDefault(player, u);
}

//--------------------------------------------------------------------------------------------------
//  AIGetScoutProt
//--------------------------------------------------------------------------------------------------
unit AIGetScoutProt (int player, int index, unit prev) {
    unit obs;
   
    if (!AIGetFlag(player, e_flagsScouting)) {
        return c_nullUnit;
    }
    if (UnitGetType(prev) == c_PU_Observer) {
        return prev;
    } 
    obs = AIGrabUnit(player, c_PU_Observer, c_prioScout, null);
    if (obs) {
        return obs;
    }
    if (prev) {
        return prev;
    }
    if (AIGetFlag(player, e_flagsLateScout)) {
        return c_nullUnit;
    }
    return AIGrabUnit(player, c_PU_Probe, c_prioScout, null);
}

//--------------------------------------------------------------------------------------------------
//  AIEarlyDefScoutProt
//--------------------------------------------------------------------------------------------------
unit AIEarlyDefScoutProt (int player, unit prev) {
    unit obs;
   
    if (!AIGetFlag(player, e_flagsEarlyDefScout)) {
        return c_nullUnit;
    }
    if (UnitGetType(prev) == c_PU_Observer) {
        return prev;
    }
    obs = AIGrabUnit(player, c_PU_Observer, c_prioScout, null);
    if (obs) {
        return obs;
    }
    if (UnitGetType(prev) == c_PU_Zealot) {
        return prev;
    }
    obs = AIGrabUnit(player, c_PU_Zealot, c_prioScout, null);
    if (obs) {
        return obs;
    }
    if (prev) {
        return prev;
    }
    return AIGrabUnit(player, c_PU_Probe, c_prioScout, null);
}

//--------------------------------------------------------------------------------------------------
//  AIWaveThinkProt
//--------------------------------------------------------------------------------------------------
void AIWaveThinkProt (int player, wave w, int type) {
    AIWaveThinkDefault(player, w, type);
}

//--------------------------------------------------------------------------------------------------
//  Protoss Init
//--------------------------------------------------------------------------------------------------
static void ProtossInit (int player) {
    int state;

    InitCounters(player);
    AISetNumScouts(player, 1);
    AISetFlag(player, e_flagsScouting, false);
    AISetFlag(player, e_flagsEarlyDefScout, false);
    AISetPowerBuilding(player, c_PB_Pylon);
    AITransportSetPanic(player, 0.27); // just below max shield threshold

    if (AIGetGroundStartLocs(PlayerStartLocation(player)) > 0) {
        state = AIDiffEnum(player, e_mainState_OpenGnd0);
    }
    else {
        state = AIDiffEnum(player, e_mainState_OpenAir0);
    }
    AISetMainState(player, state, e_mainSubState_Unset);
}

//--------------------------------------------------------------------------------------------------
//  AIMeleeProt
//--------------------------------------------------------------------------------------------------
void AIMeleeProt (int player) {   
    int mainState = AIState(player, e_mainState);

    if (mainState == e_mainState_Init)              { ProtossInit(player);     }

    else if (mainState == e_mainState_OpenGnd0)     { ProtossOpenGnd0(player); }
    //else if (mainState == e_mainState_OpenGnd1)     { ProtossOpenGnd1(player); }
    //else if (mainState == e_mainState_OpenGnd2)     { ProtossOpenGnd2(player); }
    //else if (mainState == e_mainState_OpenGnd3)     { ProtossOpenGnd3(player); }
    //else if (mainState == e_mainState_OpenGnd4)     { ProtossOpenGnd4(player); }
    //else if (mainState == e_mainState_OpenGnd5)     { ProtossOpenGnd5(player); }

    else if (mainState == e_mainState_OpenAir0)     { ProtossOpenAir0(player); }
    //else if (mainState == e_mainState_OpenAir1)     { ProtossOpenAir1(player); }
    //else if (mainState == e_mainState_OpenAir2)     { ProtossOpenAir2(player); }
    //else if (mainState == e_mainState_OpenAir3)     { ProtossOpenAir3(player); }
    //else if (mainState == e_mainState_OpenAir4)     { ProtossOpenAir4(player); }
    //else if (mainState == e_mainState_OpenAir5)     { ProtossOpenAir5(player); }

    else if (mainState == e_mainState_Mid0)         { ProtossMid0(player);     }
    //else if (mainState == e_mainState_Mid1)         { ProtossMid1(player);     }
    //else if (mainState == e_mainState_Mid2)         { ProtossMid2(player);     }
    //else if (mainState == e_mainState_Mid3)         { ProtossMid3(player);     }
    //else if (mainState == e_mainState_Mid4)         { ProtossMid4(player);     }
    //else if (mainState == e_mainState_Mid5)         { ProtossMid5(player);     }

    else if (mainState == e_mainState_Late0)        { ProtossLate0(player);    }
    //else if (mainState == e_mainState_Late1)        { ProtossLate1(player);    }
    //else if (mainState == e_mainState_Late2)        { ProtossLate2(player);    }
    //else if (mainState == e_mainState_Late3)        { ProtossLate3(player);    }
    //else if (mainState == e_mainState_Late4)        { ProtossLate4(player);    }
    //else if (mainState == e_mainState_Late5)        { ProtossLate5(player);    }

    else if (mainState == e_mainState_Off)          { EndMeleeScript(player);  }
    else if (mainState == e_mainState_Disabled)     {                          }
   
    else { ErrorMeleeScript(player, "Invalid mainState"); }
}


Protoss0.galaxy
//==================================================================================================
//  Protoss Melee Very Easy
//==================================================================================================

static void LateGround (int player);

//--------------------------------------------------------------------------------------------------
//  ProtossOpenGnd0
//--------------------------------------------------------------------------------------------------
void ProtossOpenGnd0 (int player) {
    AIClearStock(player);

    AISetStock( player, 1, c_PB_Nexus );
    AISetStock( player, 8, c_PU_Probe );
    AISetStock( player, 1, c_PB_Pylon );
   
    // around 100 resources in about 2 units
    AISetStock( player, 1, c_PU_Zealot );
    ProtossTechUp(player, 1);
   
    if (AIEnableVeryEasyStockOpen(player, c_PU_Probe)) {
        return;
    }

    // around 300 resources in about 3 unit
    AIAddStringInt(player, c_PU_Stalker, 1);
    AIAddStringInt(player, AIPickFrom2(c_PU_Zealot, c_PU_Disruptor), 1);
}

//--------------------------------------------------------------------------------------------------
//  ProtossMidGndA
//--------------------------------------------------------------------------------------------------
static void ProtossMidGndA (int player) {
    AIClearStock(player);

    AIDefaultEconomy(player, c_PB_Nexus, c_PB_Assimilator, c_PB_Pylon, c_PU_Probe, 8, c_stockAlways);

    if (AISawCloakedUnit(player)) {
        AISetStock( player, 2, c_PB_PhotonCannon );
        AISetStock( player, 1, c_PU_Observer );
    }

    AISetStockUserData(player);
    ProtossTechUp(player, 2);

    if (AIEnableVeryEasyStockMidA(player, c_PU_Probe, 4)) {
        return;
    }

    // around 600 resources in about 4 unit
    AIAddStringInt(player, c_PU_Stalker, 1);
    AIAddStringInt(player, AIPickFrom2(c_PU_Zealot, c_PU_Disruptor), 1);
}

//--------------------------------------------------------------------------------------------------
//  ProtossMidGndB
//--------------------------------------------------------------------------------------------------
static void ProtossMidGndB (int player) {
    AIClearStock(player);

    AIDefaultEconomy(player, c_PB_Nexus, c_PB_Assimilator, c_PB_Pylon, c_PU_Probe, 8, c_stockAlways);

    if (AISawCloakedUnit(player)) {
        AISetStock( player, 2, c_PB_PhotonCannon );
        AISetStock( player, 1, c_PU_Observer );
    }

    AISetStockUserData(player);
    ProtossTechUp(player, 3);

    if (AIEnableVeryEasyStockMidB(player, c_PU_Probe, 4)) {
        return;
    }

    // around 900 resources in about 5 unit
    LateGround(player);
}

//--------------------------------------------------------------------------------------------------
//  LateGround
//--------------------------------------------------------------------------------------------------
static void LateGround (int player) {
    AIAddStringInt(player, c_PU_Stalker, 1);
    AIAddStringInt(player, c_PU_Disruptor, 1);
    AIAddStringInt(player, AIPickFrom2(c_PU_Zealot, c_PU_Stalker), 1);
    AIAddStringInt(player, AIPickFrom2(c_PU_Zealot, c_PU_Disruptor), 1);
}

//--------------------------------------------------------------------------------------------------
//  LateGnd
//--------------------------------------------------------------------------------------------------
static void LateGnd (int player) {
    AIClearStock(player);

    AIDefaultEconomy(player, c_PB_Nexus, c_PB_Assimilator, c_PB_Pylon, c_PU_Probe, 8, c_stockAlways);
    AIDefaultExpansion(player, c_PB_Nexus, 6000, 0, c_expandDefault);

    AISetStockUserData(player);
    AISetStock( player, 4, c_PU_Observer );
    AISetStock( player, 1, c_PU_WarpPrism );
    ProtossTechUp(player, 4);
    AISetStock( player, 4, c_PU_Observer );

    if (AIEnableVeryEasyStockLate(player, c_TU_SCV, 4)) {
        return;
    }
    LateGround(player);
}

//--------------------------------------------------------------------------------------------------
//  ProtossOpenAir0
//--------------------------------------------------------------------------------------------------
void ProtossOpenAir0 (int player) {
    AIClearStock(player);

    AISetStock( player, 1, c_PB_Nexus );
    AISetStock( player, 8, c_PU_Probe );
    AISetStock( player, 1, c_PB_Pylon );
    AISetStock( player, 1, c_PB_Assimilator );
    AISetStock( player, 1, c_PB_Gateway );
    AISetStock( player, 1, c_PB_CyberneticsCore );
    AISetStock( player, 1, c_PB_Stargate );
    AISetStock( player, 1, c_PU_VoidRay );
    AISetStock( player, 2, c_PU_Stalker );

    AIEnableStock(player);
//stock 3

    //---------------------------------------------------------

    if (AITechCount(player, c_PU_VoidRay, c_techCountCompleteOnly) < 1) {
        return;
    }
    AIWaveMerge(player, c_waveMain, c_waveAttack);
    AISetAttackState(player, e_attackState_Attack);
    AISetMainState(player, e_mainState_Mid1, e_mainSubState_AirA);
}

//--------------------------------------------------------------------------------------------------
//  ProtossMidAirA
//--------------------------------------------------------------------------------------------------
static void ProtossMidAirA (int player) {
    AIClearStock(player);

    AIDefaultEconomy(player, c_PB_Nexus, c_PB_Assimilator, c_PB_Pylon, c_PU_Probe, 8, c_stockAlways);

    AISetStock( player, 2, c_PU_Stalker );
    AISetStock( player, 1, c_PU_VoidRay );

    AISetStock( player, 2, c_PB_Pylon );
    AISetStock( player, 1, c_PB_RoboticsFacility );

    AISetStock( player, 1, c_PU_Phoenix );
    AISetStock( player, 1, c_PU_Observer );
    AISetStock( player, 1, c_PU_WarpPrism );
    AISetStock( player, 2, c_PU_VoidRay );

    AISetStock( player, 1, c_PB_Forge );

    AIEnableStock(player);

    //---------------------------------------------------------

    if (AIGetTime() < 700) {
        return;
    }
    AIWaveMerge(player, c_waveMain, c_waveAttack);
    AISetAttackState(player, e_attackState_Attack);
    AISetMainState(player, e_mainState_Mid1, e_mainSubState_AirB);
}

//--------------------------------------------------------------------------------------------------
//  ProtossMidAirB
//--------------------------------------------------------------------------------------------------
static void ProtossMidAirB (int player) {
    AIClearStock(player);

    AIDefaultEconomy(player, c_PB_Nexus, c_PB_Assimilator, c_PB_Pylon, c_PU_Probe, 8, c_stockAlways);
    AIDefaultExpansion(player, c_PB_Nexus, 6000, 1000, c_expandDefault);

    AISetStock( player, 2, c_PU_Stalker );
    AISetStock( player, 1, c_PU_VoidRay );
    AISetStock( player, 2, c_PB_Pylon );
    AISetStock( player, 1, c_PU_Phoenix );
    AISetStock( player, 1, c_PU_Observer );
    AISetStock( player, 1, c_PU_WarpPrism );
    AISetStock( player, 3, c_PU_VoidRay );
    AISetStock( player, 2, c_PU_Observer );
    AISetStock( player, 2, c_PU_Phoenix );

    AISetStock( player, 3, c_PB_PhotonCannon );

    AIEnableStock(player);

    //---------------------------------------------------------

    if (AIGetTime() < 1200) {
        return;
    }
    AIWaveMerge(player, c_waveMain, c_waveAttack);
    AISetAttackState(player, e_attackState_Attack);
    AISetMainState(player, e_mainState_Late1, e_mainSubState_AirA);

    AISetFlag(player, e_flagsScouting, true);
    AISetFlag(player, e_flagsClearObs, true);
}

//--------------------------------------------------------------------------------------------------
//  LateAir
//--------------------------------------------------------------------------------------------------
static void LateAir (int player) {
    AIClearStock(player);

    AIDefaultEconomy(player, c_PB_Nexus, c_PB_Assimilator, c_PB_Pylon, c_PU_Probe, 8, c_stockAlways);
    AIDefaultExpansion(player, c_PB_Nexus, 6000, 1000, c_expandDefault);

    AISetStock( player, 2, c_PU_Stalker );
    AISetStock( player, 1, c_PU_VoidRay );
    AISetStock( player, 2, c_PB_Pylon );
    AISetStock( player, 1, c_PU_Phoenix );
    AISetStock( player, 1, c_PU_Observer );
    AISetStock( player, 1, c_PU_WarpPrism );
    AISetStock( player, 3, c_PU_VoidRay );
    AISetStock( player, 2, c_PU_Observer );
    AISetStock( player, 2, c_PU_Phoenix );
    AISetStock( player, 1, c_PU_Carrier );
    AISetStock( player, 4, c_PU_Observer );

    AIEnableStock(player);

    //---------------------------------------------------------

    if (AIGetTime() % 300 > 5) {
        return;
    }
    AIWaveMerge(player, c_waveMain, c_waveAttack);
    AISetAttackState(player, e_attackState_Attack);

    AISetFlag(player, e_flagsScouting, true);
    AISetFlag(player, e_flagsClearObs, true);
}

//--------------------------------------------------------------------------------------------------
//  ProtossMid0
//--------------------------------------------------------------------------------------------------
void ProtossMid0 (int player) {
    int mainSubState = AIState(player, e_mainSubState);
    if (mainSubState == e_mainSubState_GndA)          { ProtossMidGndA(player);  }
    else if (mainSubState == e_mainSubState_GndB)     { ProtossMidGndB(player);  }
    else if (mainSubState == e_mainSubState_AirA)     { ProtossMidAirA(player);  }
    else if (mainSubState == e_mainSubState_AirB)     { ProtossMidAirB(player);  }
    else { ErrorMeleeScript(player, "Invalid Mid mainSubState"); }
}

//--------------------------------------------------------------------------------------------------
//  ProtossLate0
//--------------------------------------------------------------------------------------------------
void ProtossLate0 (int player) {
    int mainSubState = AIState(player, e_mainSubState);
    if (mainSubState == e_mainSubState_GndA)          { LateGnd(player);  }
    else if (mainSubState == e_mainSubState_AirA)     { LateAir(player);  }
    else { ErrorMeleeScript(player, "Invalid Late mainSubState"); }
}


MeleeNotHardAI.galaxy
//==================================================================================================
//  Melee AI Functions only used by beginner/easy/medium.
//--------------------------------------------------------------------------------------------------
// Very Easy
//  APM: 100
//  scouts: starts late game
//  detect: late game or after being attacked by cloakers
//  wave 1: 100 resources, ~2 units, 480 seconds
//  wave 2: 300 resources, ~3 units, +360 seconds (840)
//  wave 3: 600 resources, ~4 units, +360 seconds (1200)
//  wave X: 900 resources, ~5 units, +300 seconds
//--------------------------------------------------------------------------------------------------
// Easy
//  APM: 200
//  scouts: starts late game
//  detect: late game or after being attacked by cloakers
//  wave 1: 300 resources, ~4 units, 450 seconds
//  wave 2: 800 resources, ~6 units, +340 seconds (790)
//  wave 3: 1500 resources, ~8 units, +340 seconds (1130)
//  wave X: xxx resources, ~10 units, +280 seconds
//--------------------------------------------------------------------------------------------------
// Medium
//  APM: 300
//  scouts: starts middle game
//  detect: middle game or after being attacked by cloakers
//  wave 1: 500 resources, ~6 units, 420 seconds
//  wave 2: 1000 resources, ~9 units, +320 seconds (740)
//  wave 3: 1800 resources, ~12 units, +320 seconds (1060)
//  wave X: xxx resources, ~15 units, +260 seconds
//--------------------------------------------------------------------------------------------------
// Hard
//  APM: 400
//  scouts: starts early game
//  detect: middle game or after being attacked by cloakers
//  wave 1: 700 resources, ~8 units, 390 seconds
//  wave 2: 1200 resources, ~12 units, +300 seconds (690)
//  wave 3: 2100 resources, ~16 units, +300 seconds (990)
//  wave X: xxx resources, ~20 units, +240 seconds
//==================================================================================================

//==================================================================================================
//  OPEN
//==================================================================================================

//--------------------------------------------------------------------------------------------------
//  AIGenericStock
//--------------------------------------------------------------------------------------------------
static void AIGenericStock (int player, int state1, int state2) {
    AIWaveMerge(player, c_waveMain, c_waveAttack);
    AISetAttackState(player, e_attackState_Attack);
    AISetMainState(player, state1, state2);
    AIResetUserData(player);
}

//--------------------------------------------------------------------------------------------------
//  AIEnableStockOpen
//--------------------------------------------------------------------------------------------------
static bool AIEnableStockOpen (int player, string peonType, int time, bool veryEasy, int nextState) {
    AIEnableStock(player);
    if (veryEasy) {
        if (AITechCount(player, peonType, c_techCountCompleteOnly) >= 8) {
            AISetGasPeonCountOverride(player, c_townMain, 2);
        }
        else {
            AISetGasPeonCountOverride(player, c_townMain, 0);
        }
    }
    if (AIGetTime() < time) {
        return true;
    }
    AIGenericStock(player, nextState, e_mainSubState_GndA);
    return false;
}

bool AIEnableVeryEasyStockOpen (int player, string peonType) {
    return AIEnableStockOpen(player, peonType, 480, true, e_mainState_Mid0);
}
bool AIEnableEasyStockOpen (int player, string peonType) {
    return AIEnableStockOpen(player, peonType, 450, false, e_mainState_Mid1);
}
bool AIEnableMediumStockOpen (int player, string peonType) {
    return AIEnableStockOpen(player, peonType, 420, false, e_mainState_Mid2);
}
bool AIEnableHardStockOpen (int player, string peonType) {
    return AIEnableStockOpen(player, peonType, 390, false, e_mainState_Mid3);
}

//==================================================================================================
//  MID A
//==================================================================================================

//--------------------------------------------------------------------------------------------------
//  AIVeryEasyHarvest
//--------------------------------------------------------------------------------------------------
void AIVeryEasyHarvest (int player, string peonType, int count) {
    if (AIHasRes(player, 0, 200) || AITechCount(player, peonType, c_techCountCompleteOnly) < 8) {
        AISetGasPeonCountOverride(player, c_townMain, c_defaultGasPeonCount);
    }
    else {
        AISetGasPeonCountOverride(player, c_townMain, count);
    }
}

//--------------------------------------------------------------------------------------------------
//    AIEnableStockMidA
//--------------------------------------------------------------------------------------------------
static bool AIEnableStockMidA (int player, string peonType, int count, bool veryEasy, int time, int nextState) {
    AIEnableStock(player);
    if (veryEasy) {
        AIVeryEasyHarvest(player, peonType, count);
    }
    if (AIGetTime() < time) {
        return true;
    }
    AIGenericStock(player, nextState, e_mainSubState_GndB);
    return false;
}

bool AIEnableVeryEasyStockMidA (int player, string peonType, int count) {
    return AIEnableStockMidA(player, peonType, count, true, 840, e_mainState_Mid0);
}
bool AIEnableEasyStockMidA (int player) {
    return AIEnableStockMidA(player, "", 0, false, 790, e_mainState_Mid1);
}
bool AIEnableMediumStockMidA (int player) {
    return AIEnableStockMidA(player, "", 0, false, 740, e_mainState_Mid2);
}
bool AIEnableHardStockMidA (int player) {
    return AIEnableStockMidA(player, "", 0, false, 690, e_mainState_Mid3);
}

//==================================================================================================
//  MID B
//==================================================================================================

//--------------------------------------------------------------------------------------------------
//    AIEnableStockMidB
//--------------------------------------------------------------------------------------------------
bool AIEnableStockMidB (int player, string peonType, int count, bool veryEasy, int time, int nextState) {
    AIEnableStock(player);
    if (veryEasy) {
        AIVeryEasyHarvest(player, peonType, count);
    }
    if (AIGetTime() < time) {
        return true;
    }
    AIGenericStock(player, nextState, e_mainSubState_GndA);
    AISetFlag(player, e_flagsScouting, true);
    AISetFlag(player, e_flagsClearObs, true);
    return false;
}
bool AIEnableVeryEasyStockMidB (int player, string peonType, int count) {
    return AIEnableStockMidB(player, peonType, count, true, 1200, e_mainState_Late0);
}
bool AIEnableEasyStockMidB (int player, string peonType, int count) {
    return AIEnableStockMidB(player, peonType, count, false, 1130, e_mainState_Late1);
}
bool AIEnableMediumStockMidB (int player, string peonType, int count) {
    return AIEnableStockMidB(player, peonType, count, false, 1060, e_mainState_Late2);
}
bool AIEnableHardStockMidB (int player, string peonType, int count) {
    return AIEnableStockMidB(player, peonType, count, false, 990, e_mainState_Late3);
}

//==================================================================================================
//  LATE
//==================================================================================================

//--------------------------------------------------------------------------------------------------
//    AIEnableStockLate
//--------------------------------------------------------------------------------------------------
static bool AIEnableStockLate (int player, string peonType, int count, int time) {
    AIEnableStock(player);
    AIVeryEasyHarvest(player, peonType, count);
    if (AIGetTime() % time < 5) {
        return true;
    }
    AIWaveMerge(player, c_waveMain, c_waveAttack);
    AISetAttackState(player, e_attackState_Attack);
    AIResetUserData(player);
    return false;
}

bool AIEnableVeryEasyStockLate (int player, string peonType, int count) {
    return AIEnableStockLate(player, peonType, count, 300);
}
bool AIEnableEasyStockLate (int player, string peonType, int count) {
    return AIEnableStockLate(player, peonType, count, 280);
}
bool AIEnableMediumStockLate (int player, string peonType, int count) {
    return AIEnableStockLate(player, peonType, count, 260);
}
bool AIEnableHardStockLate (int player, string peonType, int count) {
    return AIEnableStockLate(player, peonType, count, 240);
}

//==================================================================================================
//  OTHER
//==================================================================================================

//--------------------------------------------------------------------------------------------------
//    AIPickFrom2
//--------------------------------------------------------------------------------------------------
string AIPickFrom2 (string a, string b) {
    int roll = RandomInt(1,2);
    if (roll == 1) {
        return a;
    }
    return b;
}

//--------------------------------------------------------------------------------------------------
//    AIPickFrom3
//--------------------------------------------------------------------------------------------------
string AIPickFrom3 (string a, string b, string c) {
    int roll = RandomInt(1,3);
    if (roll == 1) {
        return a;
    }
    if (roll == 2) {
        return b;
    }
    return c;
}

//--------------------------------------------------------------------------------------------------
//    AISetStockUserData
//--------------------------------------------------------------------------------------------------
void AISetStockUserData (int player) {
    int index = 1;   
    while (index <= 10) {
        AISetStock(player, AIGetUserInt(player, index), AIGetUserString(player, index));
        index = index + 1;
    }
}

//==================================================================================================
//  TECH
//==================================================================================================

//--------------------------------------------------------------------------------------------------
//    TerranTechUp
//--------------------------------------------------------------------------------------------------
void TerranTechUp (int player, int tier) {

    AISetStock( player, 1, c_TB_Barracks );
    AISetStock( player, 1, c_TB_Refinery );
    AISetStock( player, 1, c_TB_BarracksTechLab );
   
    if (tier >= 2) {
        AISetStock( player, 1, c_TB_Factory );
        AISetStock( player, 1, c_TB_FactoryTechLab );
       
        if (tier >= 3) {
            AISetStock( player, 1, c_TB_Starport );
            AISetStock( player, 1, c_TB_StarportTechLab );
        }
    }

    AISetStock( player, 1, c_TB_EngineeringBay );

    if (tier >= 2) {
        AISetStock( player, 1, c_TB_SensorTower );
        AISetStock( player, 1, c_TB_GhostAcademy );
        AISetStock( player, 1, c_TB_MercCompound );
       
        if (tier >= 3) {
            AISetStock( player, 1, c_TB_Armory );

            if (tier >= 4) {
                AISetStock( player, 1, c_TB_FusionCore );
            }
        }
    }
}

//--------------------------------------------------------------------------------------------------
//    ZergTechUp
//--------------------------------------------------------------------------------------------------
void ZergTechUp (int player, int tier) {

    AISetStock( player, 1, c_ZB_SpawningPool );
    AISetStock( player, 1, c_ZB_Extractor );
    AISetStock( player, 1, c_ZB_EvolutionChamber );
    AISetStock( player, 1, c_ZB_HydraliskDen );

    AISetStock( player, 1, c_ZR_HydraliskSpeed );

    if (tier >= 2) {
        AISetStock( player, 1, c_ZR_OverseerSpeed );
        AISetStock( player, 1, c_ZB_BanelingNest );

        if (tier >= 3) {
            AISetStock( player, 1, c_ZB_RoachWarren );
            AISetStock( player, 1, c_ZB_Spire );
            AISetStock( player, 1, c_ZB_InfestationPit );

            if (tier >= 4) {
                AISetStock( player, 1, c_ZR_OverlordTransport );
                AISetStock( player, 1, c_ZB_UltraliskCavern );
                AISetStock( player, 1, c_ZB_LurkerDen );
                AISetStock( player, 1, c_ZB_GreaterSpire );
            }
        }
    }
}

//--------------------------------------------------------------------------------------------------
//    ProtossTechUp
//--------------------------------------------------------------------------------------------------
void ProtossTechUp (int player, int tier) {

    AISetStock( player, 1, c_PB_Gateway );
    AISetStock( player, 1, c_PB_Forge );
    AISetStock( player, 1, c_PB_Assimilator );

    if (tier >= 3) {
        AISetStock( player, 1, c_PB_RoboticsFacility );
        AISetStock( player, 1, c_PB_Stargate );
        AISetStock( player, 1, c_PB_TwilightCouncil );

        if (tier >= 4) {
            AISetStock( player, 1, c_PB_TemplarArchives );
            AISetStock( player, 1, c_PB_RoboticsBay );
            AISetStock( player, 1, c_PB_DarkShrine );
            AISetStock( player, 1, c_PB_FleetBeacon );
        }
    }
}


MeleeAI.galaxy < suite

    //--- IDLE ---

    else if (state == e_attackState_Idle) {
        count = AIWaveUnitCount(w) + AIWaveUnitCount(AIWaveGet(player, c_waveMain));

        // wait 30 seonds at least after retreating before attacking again
        if (AIWaveGetTimeSinceRetreat(w) > 30) {
            // always support allies attacking
            if (AIAnyAllyAttacking(player)) {
                AISetAttackState(player, e_attackState_Attack);
            }
            if (PlayerDifficulty(player) >= c_skirVeryHard) {
                if (AIWaveState(w) == c_waveStateIdle) {
                    // wait until the wave is idle before considering attacking again
                    AdvancedIdleAttackLogic(player, w, count);
                }
            }
            else {
                // base logic attack any time we have more than 30 units or it's been a while
                if (count >= 30) {
                    AISetAttackState(player, e_attackState_Attack);
                }
                else if (AIGetFlag(player, e_flagsTimeout) && AIWaveGetTimeSinceCombat(w) >= 300-10*count) {
                    AISetAttackState(player, e_attackState_Attack);
                }
            }
        }
       
        if (AIState(player, e_attackState) == e_attackState_Idle) {
            if (AIWaveState(w) != c_waveStateIdle) {
                DebugAIPlayerWave(player, "attack5 set attack = idle at gather offense");
                AIWaveSetType(w, c_waveStateIdle, AIWaveTargetGatherO(player, c_townMax));
            }
        }
    }
}

//--------------------------------------------------------------------------------------------------
//  AIWaveThinkDefault
//--------------------------------------------------------------------------------------------------
void AIWaveThinkDefault (int player, wave w, int type) {
    if (AIWaveUnitCount(w) < 1) {
        return;
    }
    if (type == c_waveMain) {
        AIWaveMain(player, w);
    }
    else if (type == c_waveDefend) {
        AIWaveDefend(player, w);
    }
    else if (type == c_waveAttack) {
        AIWaveAttack(player, w);
    }
    else if (type == c_waveDivert1) {
        AIWaveDivert(player, w, e_divert1State);
    }
    else if (type == c_waveDivert2) {
        AIWaveDivert(player, w, e_divert2State);
    }
    else if (type == c_waveClearObs) {
        AIWaveClearObs(player, w);
    }
    else if (type == c_waveHome) {
        AIWaveHome(player, w);
    }
}

//--------------------------------------------------------------------------------------------------
//  AIMainStateSelect
//--------------------------------------------------------------------------------------------------
int AIMainStateSelect (int player, int roll, int range, int state, int subState) {
    if (roll >= 1 && roll <= range) {
        AISetMainState(player, state, subState);
    }
    return roll - range;
}

//--------------------------------------------------------------------------------------------------
//  AIMergeWait
//--------------------------------------------------------------------------------------------------
void AIMergeWait (int player, int count, string what, int size, int state, int subState) {
    wave atk = AIWaveGet(player, c_waveAttack);
   
    if (AIWaveState(atk) != c_waveStateRetreat) {
        if (AIWaveUnitCount(AIWaveGet(player, c_waveMain)) >= 3 ||
            AITechCount(player, what, c_techCountCompleteOnly) >= count)
        {
DebugAIPlayerWave(player, "merge1 merge main -> attack");
            AIWaveMerge(player, c_waveMain, c_waveAttack);
        }
    }
    if (AIWaveUnitCount(atk) >= size) {
        AISetAttackState(player, e_attackState_Attack);
        AISetMainState(player, state, subState);
        AISetFlag(player, e_flagsTimeout, true);
    }
    else if (AIHasRes(player, 1000, 500)) {
        AISetMainState(player, state, subState);
        AISetFlag(player, e_flagsTimeout, true);
    }
}

//--------------------------------------------------------------------------------------------------
//  AIStockAndWait
//--------------------------------------------------------------------------------------------------
bool AIStockAndWait (int player, int count, string type) {
    if (AITechCount(player, type, c_techCountInProgressOrBetter) < count) {
        AISetStock( player, count, type );   
        AIEnableStock(player);
        return true;
    }
    return false;
}

//--------------------------------------------------------------------------------------------------
//  AISuspectDetectionDanger
//--------------------------------------------------------------------------------------------------
bool AISuspectDetectionDanger (int player) {
    bool suspectDanger = false;

    suspectDanger = AIDefaultSuspectDetectionDanger(player);

    // script additions / override of the default

    return suspectDanger;
}

//--------------------------------------------------------------------------------------------------
//  AITownIsFull
//--------------------------------------------------------------------------------------------------
void AITownIsFull (int player, int town) {
    // town was unable to place a building because it ran out of room, it may still
    // be possible to place a smaller building or a different type of building
    AIUpdateMainTown(player);

    // if we only have no non-full town, we may want to expand now
}

//--------------------------------------------------------------------------------------------------
//  AITownWasLost
//--------------------------------------------------------------------------------------------------
void AITownWasLost (int player, int town) {
    // one of our towns was destroyed/lost, happens when we lose our last dropoff at the town (or all buildings).
    AIUpdateMainTown(player);
}

//--------------------------------------------------------------------------------------------------
//  AIMakeTest
//--------------------------------------------------------------------------------------------------
bool AIMakeTest (int player, int min, int max, string type, string tech,
                string base, int addons, string addon)
{
    int count = AICounterUnits(player, c_maxPlayers, type);
    if (count <= 0) {
        return false;
    }
    if (count < min) {
        count = min;
    }
    else if (count > max) {
        count = max;
    }
    if (AITechCount(player, type, c_techCountInProgressOrBetter) >= count) {
        return false;
    }
    if (count > 5) {
        AISetStockUnitNext( player, 3, base, c_stockIdle );
        AISetStockUnitNext( player, addons, addon, c_stockIdle );
    }
    else if (count > 2) {
        AISetStockUnitNext( player, 2, base, c_stockIdle );
        if (addons > 2) {
            AISetStockUnitNext( player, 2, addon, c_stockIdle );
        }
        else {
            AISetStockUnitNext( player, addons, addon, c_stockIdle );
        }
    }
    if (tech != c_noTech) {
        AISetStock( player, 1, tech );
    }
    AISetStockUnitNext( player, count, type, c_stockAlways );
    return true;
}

//--------------------------------------------------------------------------------------------------
//  AIMineralsTotal
//--------------------------------------------------------------------------------------------------
int AIMineralsTotal (int player) {
    return PlayerGetPropertyInt(player, c_playerPropMinerals) + AIGetMineralAmountLeft(player, c_townMax);
}

//--------------------------------------------------------------------------------------------------
//  AIWavePrimaryCount
//--------------------------------------------------------------------------------------------------
int AIWavePrimaryCount (int player) {
    return AIWaveUnitCount(AIWaveGet(player, c_waveMain)) + AIWaveUnitCount(AIWaveGet(player, c_waveAttack));
}

//--------------------------------------------------------------------------------------------------
//  AIDiffEnum
//--------------------------------------------------------------------------------------------------
int AIDiffEnum (int player, int base) {
    return base + PlayerDifficulty(player);
}

//--------------------------------------------------------------------------------------------------
//  AIDiffThreshold
//--------------------------------------------------------------------------------------------------
int AIDiffThreshold (int player, int defaultValue, int threshold, int alternateValue) {
    int diff = PlayerDifficulty(player);
    if (diff < threshold) {
        return defaultValue;
    }
    return alternateValue;
}

//--------------------------------------------------------------------------------------------------
//  AIAddDetectionDangerUnits
//--------------------------------------------------------------------------------------------------
void AIAddDetectionDangerUnits (int player) {
    AIAddDetectionDanger(player, c_TU_Ghost);
    AIAddDetectionDanger(player, c_TU_Banshee);
    AIAddDetectionDanger(player, c_ZU_Lurker);
    AIAddDetectionDanger(player, c_PU_DarkTemplar);
    AIAddDetectionDanger(player, c_PU_Mothership);
    AIAddDetectionDanger(player, c_TB_GhostAcademy);
    AIAddDetectionDanger(player, c_TB_FusionCore);
    AIAddDetectionDanger(player, c_ZB_LurkerDen);
    AIAddDetectionDanger(player, c_PB_DarkShrine);
}

//--------------------------------------------------------------------------------------------------
//  Default startup routine
//--------------------------------------------------------------------------------------------------
void AIMeleeStart (int player) {
    point targ;

    if (DEBUG) {
        DebugMeleeInit();
    }

    AIStart(player, false, DifficultyAPM(PlayerDifficulty(player)));
       
    if (PlayerDifficulty(player) >= c_skirVeryHard) {       
        if (PlayerDifficulty(player) >= c_skirCheater) {
            AIHarvestBonus(player, 2.0);
            AISetDifficulty(player, c_diffNormalVision, false);
            AISetDifficulty(player, c_diffLimitAPM, false);
        }
        AISetFlag(player, e_flagsRunScared, false); // TODO fix scared and re-add this
    }
    else {       
        AISetDifficulty(player, c_diffAdvanceWave, false);
        AISetDifficulty(player, c_diffFleeDamage, false);
        AISetDifficulty(player, c_diffWaveAvoidDanger, false);
        AISetFlag(player, e_flagsRunScared, false);
    }
    AISetDifficulty(player, c_diffAutoLoadBunkers, false);
    AISetDifficulty(player, c_diffEarlyGameRepair, false);   
    AISetDifficulty(player, c_diffEarlyDefenseScout, false);
    AISetFlag(player, e_flagsLateScout, false);
    AISetFlag(player, e_flagsClearObs, false);

    AIDeclareTown(player, c_townOne, PlayerStartLocation(player));
    AISetMainTown(player, c_townOne);
    AIHarvest(player, c_townOne);
    AISetNumScouts(player, 1);
    AIScout(player);
    AISetAllStates(player, 1);
   
    targ = AIWaveTargetGatherOPoint(player, c_townMain);
    AIWaveSet(player, c_waveMain,       AIWaveCreate(AIWaveInfoCreate(), player, targ));
    AIWaveSet(player, c_waveAttack,     AIWaveCreate(AIWaveInfoCreate(), player, targ));
    AIWaveSet(player, c_waveDivert1,    AIWaveCreate(AIWaveInfoCreate(), player, targ));
    AIWaveSet(player, c_waveDivert2,    AIWaveCreate(AIWaveInfoCreate(), player, targ));
    AIWaveSet(player, c_waveClearObs,   AIWaveCreate(AIWaveInfoCreate(), player, targ));
    AIWaveSet(player, c_waveHome,       AIWaveCreate(AIWaveInfoCreate(), player, targ));

    targ = AIWaveTargetGatherDPoint(player, c_townMain);
    AIWaveSet(player, c_waveDefend,     AIWaveCreate(AIWaveInfoCreate(), player, targ));

    AITransportIgnore(player, "VikingAssault");
    AITransportSetPanic(player, 0.6);
    AITransportSetReturn(player, targ);
 
    AISpecifiedMakers();
    AISetDefaultCombatFlags(player, true);
    AIAddDetectionDangerUnits(player);

    //AISetNukeConstants(player);
}

include "TriggerLibs/MeleeNotHardAI"


MeleeAI.galaxy < suite

//--------------------------------------------------------------------------------------------------
//  AITacticalOrder
//--------------------------------------------------------------------------------------------------
order AITacticalOrder (int player, unit aiUnit, string abilLink) {
    order ord = AICreateOrder(player, abilLink, 0);
    if (!UnitOrderIsValid(aiUnit, ord)) {
        return null;
    }
    return ord;
}

//--------------------------------------------------------------------------------------------------
//  AITacticalOrderIndex
//--------------------------------------------------------------------------------------------------
order AITacticalOrderIndex (int player, unit aiUnit, string abilLink, int abilIndex) {
    order ord = AICreateOrder(player, abilLink, abilIndex);
    if (!UnitOrderIsValid(aiUnit, ord)) {
        return null;
    }
    return ord;
}

//--------------------------------------------------------------------------------------------------
//  AICombatPriority
//--------------------------------------------------------------------------------------------------
unit AICombatPriority (unit target, unitgroup attackers, unitgroup enemies) {
    return AIDefaultCombatPriority(target, attackers, enemies);
}

//--------------------------------------------------------------------------------------------------
//  AIDefendTown
//--------------------------------------------------------------------------------------------------
void AIDefendTown (int player, wave w) {
    int eval = AIWaveEvalRatio(w, c_evalDefendRange);
    int staticPercent = AILastWaveEvalStaticRatio();
    int neededEval = 60;

    if (staticPercent > 90) {
        neededEval = 80;
    }
    else if (staticPercent > 40) {
        neededEval = 70;
    }

    if (eval < neededEval) {
        if (AIWaveState(w) != c_waveStateRetreat) {
DebugAIPlayerWave(player, "defend1 set wave = retreat to gather defense");
            AIWaveSetType(w, c_waveStateRetreat, AIWaveTargetGatherD(player, c_townMax));
        }
    }
    else if (AIWaveState(w) != c_waveStateDefend) {
        if (eval > neededEval+10) {
            if (AIWaveGetTimeSinceOrdered(w) >= 20) {
                DebugAIPlayerWave(player, "defend2 set wave = defend vs. threats");
                AIWaveSetType(w, c_waveStateDefend, AIWaveTargetMeleeDefend(player));
            }
        }
    }
}

//--------------------------------------------------------------------------------------------------
//  AIWaveDefend
//--------------------------------------------------------------------------------------------------
void AIWaveDefend (int player, wave w) {
    if (AIDefenseThreat(c_dtAnyThreat, player, w)) {
        AIDefendTown(player, w);
    }
    else if (AIWaveState(w) != c_waveStateIdle) {
DebugAIPlayerWave(player, "defend3 set defend = idle at gather defense");
        AIWaveSetType(w, c_waveStateIdle, AIWaveTargetGatherD(player, c_townMax));
    }
}

//--------------------------------------------------------------------------------------------------
//  AIWaveMain
//--------------------------------------------------------------------------------------------------
void AIWaveMain (int player, wave w) {
    unit obstruction = null;
    int count = AIWaveUnitCount(w);
    int state = AIWaveState(w);
    int attackState = AIState(player, e_attackState);

    if (AIWaveIsInCombat(w)) {
        return;
    }
    if (AIDefenseThreat(c_dtAnyThreat, player, w)) {
        AIDefendTown(player, w);
        return;
    }

    if (count >= 3 && AIGetFlag(player, e_flagsTimeout)) {
        if (attackState != e_attackState_DropAttack && attackState != e_attackState_DropRetreat) {
            AIWaveMerge(player, c_waveMain, c_waveAttack);
            return;
        }
    }

    if (state != c_waveStateIdle) {
DebugAIPlayerWave(player, "main2 set main = idle at gather offense");
        AIWaveSetType(w, c_waveStateIdle, AIWaveTargetGatherO(player, c_townMax));
    }
}

//--------------------------------------------------------------------------------------------------
//  AIWaveDivert
//--------------------------------------------------------------------------------------------------
void AIWaveDivert (int player, wave w, int stateIndex) {
    int state;
    int count;
   
    if (AIDefenseThreat(c_dtAnyThreat, player, w)) {
        AIDefendTown(player, w);
        return;
    }
   
    state = AIWaveState(w);
    if (state == c_waveStateDefend) {
DebugAIPlayerWave(player, "divert1 set divert = idle at gather defense");//xxx
        AIWaveSetType(w, c_waveStateIdle, AIWaveTargetGatherD(player, c_townMax));
        return;
    }

    if (!AIGetFlag(player, e_flagsDiversion)) {
        return;
    }

    if (AIWaveEvalRatio(w, c_evalHarassRange) < 100) {
        if (state != c_waveStateRetreat) {
DebugAIPlayerWave(player, "divert2 set divert = retreat to harass point");//xxx
            AIWaveSetType(w, c_waveStateRetreat, AIWaveHarassRetreat(player, w, c_evalHarassRange));           
        }
    }
    else if (state != c_waveStateAttack) {
        if (AIWaveGetTimeSinceOrdered(w) >= 10) {
DebugAIPlayerWave(player, "divert3 set divert = attack harass target");//xxx
            AIWaveSetType(w, c_waveStateAttack, AIWaveTargetMeleeHarass(player));
        }
    }
}

//--------------------------------------------------------------------------------------------------
//  AIWaveHome
//--------------------------------------------------------------------------------------------------
void AIWaveHome (int player, wave w) {
    int state;
   
    state = AIWaveState(w);
    if (state != c_waveStateGuardHome) {
DebugAIPlayerWave(player, "home set divert = idle at gather defense");
        AIWaveSetType(w, c_waveStateGuardHome, AIWaveTargetGatherD(player, c_townMax));
        return;
    }
}

//--------------------------------------------------------------------------------------------------
// AIWaveClearObs
//--------------------------------------------------------------------------------------------------
void AIWaveClearObs (int player, wave w) {
    unit obstruction = AIGetObstruction(player);
    unit oldTarget = null;
    int obsLife;
    int state = AIWaveState(w);

    // If there are no longer any obstructions, merge back into the main wave
    if (obstruction == null) {
DebugAIPlayerWave(player, "clearobs1 merge clear obstruction -> main");
        AIWaveMerge(player, c_waveClearObs, c_waveMain);
        return;
    }

    // Defend against threats, unless we're almost done destroying the obstruction
    obsLife = UnitGetPropertyInt(obstruction, c_unitPropLifePercent, c_unitPropCurrent);
    if (AIDefenseThreat(c_dtAnyThreat, player, w) && obsLife > 20) {
        AIDefendTown(player, w);
        return;
    }

    // Let's hunt some rock!
    oldTarget = AIWaveTargetGetUnit(AIWaveGetTarget(w));
    if (state != c_waveStateClearObs || obstruction != oldTarget) {
DebugAIPlayerWave(player, "clearobs2 set clear obstruction = clear obstruction");
        AIWaveSetType(w, c_waveStateClearObs, AIWaveTargetUnit(obstruction));
    }
}

//--------------------------------------------------------------------------------------------------
// AINewDetector
//--------------------------------------------------------------------------------------------------
void AINewDetector (int player, unit u, bool offerToScout) {
    wave defendWave = AIWaveGet(player, c_waveDefend);
    wave attackWave = AIWaveGet(player, c_waveAttack);

    // first offer it to the attack wave if that wave has some units in it
    if (AIWaveUnitCount(attackWave) >= 4) {
        if (AIWaveDetectorCount(attackWave) == 0) {
            AIWaveAddUnitPriority(attackWave, u, c_prioWavePeon);
            return;
        }
    }

    // next offer it to the defense wave
    if (AIWaveDetectorCount(defendWave) == 0) {
        AIWaveAddUnitPriority(defendWave, u, c_prioWavePeon);
        return;
    }

    // last offer it to the scout synapse
    if (offerToScout) {
        if (AIOfferNewScout(player, u)) {
            return;
        }
    }

    // let the attack wave claim a second one
    if (AIWaveUnitCount(attackWave) >= 4) {
        if (AIWaveDetectorCount(attackWave) < 2) {
            AIWaveAddUnitPriority(attackWave, u, c_prioWavePeon);
            return;
        }
    }

    // else add the detector to the extra scout group
    AIAddToExtraScoutGroup(player, u);
}

//--------------------------------------------------------------------------------------------------
// AIWaveNeedClearObsUnits
//--------------------------------------------------------------------------------------------------
bool AIWaveNeedClearObsUnits (int player) {
    unit obstruction = null;
    wave waveClob = null;
    wave waveAtck = null;
    int countClob = 0;
    int countAtck = 0;
    int evalAtck = 0;

    // Check global option
    if (AIGetFlag(player, e_flagsClearObs) == false) {
        return false;
    }

    // Don't clear obstructions in the first 10 minutes (leaves the AI too open to being rushed)
    if (AIGetTime() < 600) {
        return false;
    }

    // See if there is any obstruction
    obstruction = AIGetObstruction(player);
    if (obstruction == null) {
        return false;
    }

    // See if the clear obstruction wave is already full
    waveClob = AIWaveGet(player, c_waveClearObs);
    countClob = AIWaveUnitCount(waveClob);
    if (countClob >= 4) {
        return false;
    }

    // If the attack wave is getting weak, keep units available for it instead
    waveAtck = AIWaveGet(player, c_waveAttack);
    countAtck = AIWaveUnitCount(waveAtck);
    evalAtck = AIWaveEvalRatio(waveAtck, c_evalRange);
    if (countAtck > 0 && evalAtck < 80) {
        return false;
    }

    // Yes, units are needed for clear obstruction duty
    return true;
}

//--------------------------------------------------------------------------------------------------
//  AIWaveAttackDefend
//--------------------------------------------------------------------------------------------------
static bool AIWaveAttackDefend (int player, wave w, int state) {

    if (!AIDefenseThreat(c_dtRealThreat, player, w)) {
        return false;
    }

    if ( state == e_attackState_Idle || state == e_attackState_Wait ||
         (AIWaveEval(AIWaveGet(player, c_waveMain)) + AIWaveEval(AIWaveGet(player, c_waveDefend)) < AIDefenseThreatEval(c_dtEvalRealThreats, player)) )
    {
        return true;
    }

    return false;
}

//--------------------------------------------------------------------------------------------------
//  AIIsAttacking
//--------------------------------------------------------------------------------------------------
bool AIIsAttacking (int player) {
    wave waveAttack = null;

    // for now I'm not counting e_attackState_DropAttack as attacking, it is a specialized attack
    // and not easy for other AI's to coordinate with it

    if (AIState(player, e_attackState) != e_attackState_Attack) {
        return false;
    }

    waveAttack = AIWaveGet(player, c_waveAttack);
    if (AIWaveUnitCount(waveAttack) == 0) {
        return false;
    }

    if (AIWaveState(waveAttack) != c_waveStateAttack) {
        return false;
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
//  AINeedsDefending
//--------------------------------------------------------------------------------------------------
bool AINeedsDefending (int player) {
    return AIWaveAttackDefend(player, c_nullWave, e_attackState_Attack);
}

//--------------------------------------------------------------------------------------------------
//  TestUseDropAttack
//--------------------------------------------------------------------------------------------------
bool TestUseDropAttack (int player, wave w) {
    int numMobileTransports;

    // see if we can and want to do a drop attack
    numMobileTransports = AIGetNumMobileTransports(player);

    if (numMobileTransports >= 1) {
        // we have a transport, so request more so we can use them to do a drop later
        AISetWantsMultipleTransport(player, true);
    }
    else {
        // don't worry about drops if we have no transports.
        return false;
    }

    if (numMobileTransports < 3) {
        // wait until we have at least 3 transports to try a drop
        return false;
    }

    if (AIGetNextDropTimeCheck(player) >= AIGetTime()) {
        // only check drop attacks every so often
        return false;
    }

    AISetNextDropTimeCheck(player, AIGetTime() + c_dropCheckRollFreq);

    if (RandomInt(1,100) > c_dropAttackChance) {
        return false;
    }

    if (!AIFindDropAttackTarget(player, AIGetGatherLocation(player, c_townMain))) {
        return false;
    }

    AISetNextDropTimeCheck(player, AIGetTime() + c_dropCheckAttackFreq);

    AISetAttackState(player, e_attackState_DropAttack);
DebugAIPlayerWave(player, "attack1drop merge main -> attack; set attack = drop attack");
    AIWaveMerge(player, c_waveMain, c_waveAttack);
    AIWaveSetType(w, c_waveStateDropAttack, AIWaveTargetMeleeDrop(player, AILastDropLocation(), AILastDropGoal()));
    return true;
}

//--------------------------------------------------------------------------------------------------
//  AdvancedIdleAttackLogic
//--------------------------------------------------------------------------------------------------
void AdvancedIdleAttackLogic (int player, wave w, int count) {
    // hard/insane logic for when to attack again
    int eval;
    bool enoughForce = false;

    if (AILastAttackRatio(w) >= 120) {
        // if the last attack was successful (we killed a good bit more than we lost)
        // then attack again as soon as we've gathered 20 units or it's been a short amount of time
        if (count >= 20) {
            AISetAttackState(player, e_attackState_Attack);
        }
        else if (count >= 10 && AIGetFlag(player, e_flagsTimeout) && AIWaveGetTimeSinceCombat(w) >= 120) {
            AISetAttackState(player, e_attackState_Attack);
        }
    }
    else if (AILastAttackRatio(w) >= 80) {
        // if the last attack was even (we did fight and we killed about as much as we lost)
        // then we to attack until we've regrouped a bit
        if (count >= 12) {
            if (TestUseDropAttack(player,w)) {
                return;
            }
        }
        if (count >= 30) {
            AISetAttackState(player, e_attackState_Attack);
        }
        else if (count >= 15 && AIGetFlag(player, e_flagsTimeout) && AIWaveGetTimeSinceCombat(w) >= 300 - 5*count) {
            AISetAttackState(player, e_attackState_Attack);
        }
    }
    else { // AILastAttackRatio(w) < 80
        // if the last attack was a failure (we either retreated right away or lost more then we killed)
        if (count >= 12) {
            if (TestUseDropAttack(player,w)) {
                return;
            }
        }
        if (count < 20) {
            return;
        }

        // force us to gather more units than last time, or use at least 160 food cap
        if (PlayerGetPropertyInt(player, c_playerPropSuppliesUsed) > 160) {
            enoughForce = true;
        }
        else {
            eval = AIWaveEval(w) + AIWaveEval(AIWaveGet(player, c_waveMain));
            if (IntToFixed(eval) > IntToFixed(AILastAttackStartEval(w)) * 1.33) {
                enoughForce = true;
            }
        }

        if (enoughForce) {
            AISetAttackState(player, e_attackState_Attack);
        }
    }
}

//--------------------------------------------------------------------------------------------------
//  AIWaveAttack
//--------------------------------------------------------------------------------------------------
void AIWaveAttack (int player, wave w) {
    int state = AIState(player, e_attackState);
    int eval;
    int time;
    int count;

    //--- DEFEND ---

    if (AIWaveAttackDefend(player, w, state)) {
        AIDefendTown(player, w);
        return;
    }

    //--- ATTACK ---

    if (state == e_attackState_Attack) {
        time = AIWaveGetTimeInCombat(w);
        eval = AIWaveEvalRatio(w, c_evalRange);
        if (eval >= 70 && eval <= 85 && time <= 3) { // when not fighting and only a little weak
            if (AIGetFlag(player, e_flagsRunScared)) { // need to add check for ranges & max eval
                AISetAttackState(player, e_attackState_Scared);
            }
            else {
                AISetAttackState(player, e_attackState_Retreat);
            }
        }
        else if (eval < 70) { // need to add check for faster/retreat blocked
            AISetAttackState(player, e_attackState_Retreat);
        }
        else if (AIWaveState(w) != c_waveStateAttack) {
DebugAIPlayerWave(player, "attack1 merge main -> attack; set attack = attack vs. melee target");
            AIWaveMerge(player, c_waveMain, c_waveAttack);
            AIWaveSetType(w, c_waveStateAttack, AIWaveTargetMelee(player));
        }
    }

    //--- DROP-ATTACK ---

    if (state == e_attackState_DropAttack) {       
        eval = AIWaveEvalRatio(w, c_evalRange);
        if (eval < 80) { // need to add check for can we retreat successfully
            AISetAttackState(player, e_attackState_DropRetreat);
        }
        if (AIWaveState(w) != c_waveStateDropAttack) {
DebugAIPlayerWave(player, "attack1a In drop attack state, but not drop attack wave state?");
            AISetAttackState(player, e_attackState_DropRetreat);
        }
    }

    //--- SCARED ---

    else if (state == e_attackState_Scared) {
        eval = AIWaveEvalRatio(w, c_evalRange);
        if (eval > 95) { // turn and fight when strong
            AISetAttackState(player, e_attackState_Attack);
        }
        else if (eval < 70) { // retreat entirely if getting picked off
            AISetAttackState(player, e_attackState_Retreat);
        }
        else if (AIWaveState(w) != c_waveStateRetreat) {
DebugAIPlayerWave(player, "attack2 merge main -> attack; set attack = retreat to gather offense");
            AIWaveMerge(player, c_waveMain, c_waveAttack);
            AIWaveSetType(w, c_waveStateRetreat, AIWaveTargetGatherO(player, c_townMain));
        }
    }

    //--- RETREAT ---

    else if (state == e_attackState_Retreat) {       
DebugAIPlayerWave(player, "attack3 set attack = retreat to gather offense");
        AIWaveSetType(w, c_waveStateRetreat, AIWaveTargetGatherO(player, c_townMain));
        AISetAttackState(player, e_attackState_InRetreat);
    }

    //--- DROP RETREAT ---

    else if (state == e_attackState_DropRetreat) {       
DebugAIPlayerWave(player, "attack3drop set attack = drop retreat to gather offense");
        AIWaveSetType(w, c_waveStateDropRetreat, AIWaveTargetGatherO(player, c_townMain));
        AISetAttackState(player, e_attackState_InRetreat);
    }

    //--- IN RETREAT ---

    else if (state == e_attackState_InRetreat) {
        if (AIWaveState(w) != c_waveStateRetreat && AIWaveState(w) != c_waveStateDropRetreat) {
DebugAIPlayerWave(player, "attack4 merge main -> attack");
            AIWaveMerge(player, c_waveMain, c_waveAttack);
            AISetAttackState(player, e_attackState_Idle);
        }
    }
   

MeleeAI.galaxy
//==================================================================================================
//  Melee AI Functions
//--------------------------------------------------------------------------------------------------
// rough rating target:
//   insane    2300
//   very hard 2000
//   hard      1700
//   medium    1400
//   easy      1100
//   very easy  800
//==================================================================================================

const bool DEBUG                = true;
const bool DEBUG_MAIN_STATE     = false;
const bool DEBUG_ATTACK_STATE   = false;
const bool DEBUG_WAVE           = false;

const int e_flagsScouting       = 1;
const int e_flagsDiversion      = 2;
const int e_flagsTimeout        = 3;
const int e_flagsRunScared      = 4;
const int e_flagsDetect         = 5;
const int e_flagsZergStock      = 6;
const int e_flagsExpanded       = 7;
const int e_flagsLateScout      = 8;
const int e_flagsClearObs       = 9;
const int e_flagsEarlyDefScout  = 10;

// limit of 16 states in CCaptain
const int e_mainState       = 1;
const int e_mainSubState    = 2;
const int e_attackState     = 3;
const int e_divert1State    = 4;
const int e_divert2State    = 5;
const int e_openRollState   = 6;
const int e_middleRollState = 7;
const int e_lateRollState   = 8;

// main states
const int e_mainState_Disabled      = -1;
const int e_mainState_Off           =  0;
const int e_mainState_Init          =  1;
const int e_mainState_OpenGnd0      =  2;
const int e_mainState_OpenGnd1      =  3;
const int e_mainState_OpenGnd2      =  4;
const int e_mainState_OpenGnd3      =  5;
const int e_mainState_OpenGnd4      =  6;
const int e_mainState_OpenGnd5      =  7;
const int e_mainState_OpenAir0      =  8;
const int e_mainState_OpenAir1      =  9;
const int e_mainState_OpenAir2      = 10;
const int e_mainState_OpenAir3      = 11;
const int e_mainState_OpenAir4      = 12;
const int e_mainState_OpenAir5      = 13;
const int e_mainState_Mid0          = 14;
const int e_mainState_Mid1          = 15;
const int e_mainState_Mid2          = 16;
const int e_mainState_Mid3          = 17;
const int e_mainState_Mid4          = 18;
const int e_mainState_Mid5          = 19;
const int e_mainState_Late0         = 20;
const int e_mainState_Late1         = 21;
const int e_mainState_Late2         = 22;
const int e_mainState_Late3         = 23;
const int e_mainState_Late4         = 24;
const int e_mainState_Late5         = 25;

// main sub states
const int e_mainSubState_Unset      = 1;
const int e_mainSubState_GndA       = 2;
const int e_mainSubState_GndB       = 3;
const int e_mainSubState_AirA       = 4;
const int e_mainSubState_AirB       = 5;

// attack states
const int e_attackState_Wait        = 1;
const int e_attackState_Idle        = 2;
const int e_attackState_Attack      = 3;
const int e_attackState_DropAttack  = 4;
const int e_attackState_Scared      = 5;
const int e_attackState_Retreat     = 6;
const int e_attackState_DropRetreat = 7;
const int e_attackState_InRetreat   = 8;

const fixed c_evalDefendRange   = 20;
const fixed c_evalRange         = 10;
const fixed c_evalHarassRange   = 8;

// drop attack variables
const fixed c_dropCheckRollFreq = 60.0;
const fixed c_dropCheckAttackFreq = 240.0;
const int c_dropAttackChance = 75;

//--------------------------------------------------------------------------------------------------
//  DebugAI
//--------------------------------------------------------------------------------------------------
void DebugAI (string s) {
    if (DEBUG) {
        TriggerDebugOutput(1, StringToText(s), true);
    }
}

//--------------------------------------------------------------------------------------------------
void DebugAIPlayer (int player, string s) {
    if (DEBUG) {
        TriggerDebugOutput(
            1,
            StringToText("[") +
            PlayerColorName(PlayerGetColorIndex(player, false)) +
            StringToText("] ") +
            StringToText(s),
            true
        );
    }
}

//--------------------------------------------------------------------------------------------------
void DebugAIPlayerWave (int player, string s) {
    if (DEBUG_WAVE) {
        DebugAIPlayer(player, s);
    }
}

//--------------------------------------------------------------------------------------------------
void DebugVarInt (string s, int value) {
    DebugAI(s + "= " + IntToString(value));
}

//--------------------------------------------------------------------------------------------------
void DebugVarString (string s, string value) {
    DebugAI(s + "= " + value);
}

//--------------------------------------------------------------------------------------------------
void DebugVarInt2 (string s1, int value1, string s2, int value2) {
    DebugAI(s1 + "= " + IntToString(value1) + ", " + s2 + "= " + IntToString(value2));
}

//--------------------------------------------------------------------------------------------------
void DebugVarInt3 (string s1, int value1, string s2, int value2, string s3, int value3) {
    DebugAI(s1 + "= " + IntToString(value1) + ", "
          + s2 + "= " + IntToString(value2) + ", "
          + s3 + "= " + IntToString(value3)
    );
}

//--------------------------------------------------------------------------------------------------
void DebugVarBool (string s, bool value) {
    if (value) {
        DebugAI(s + "= true");
    }
    else {
        DebugAI(s + "= false");
    }
}

//--------------------------------------------------------------------------------------------------
string AttackStateName (int state) {
    if (state == e_attackState_Wait)           {  return "Wait";           }
    if (state == e_attackState_Attack)         {  return "Attack";         }
    if (state == e_attackState_DropAttack)     {  return "DropAttack";     }
    if (state == e_attackState_Idle)           {  return "Idle";           }
    if (state == e_attackState_Scared)         {  return "Scared";         }
    if (state == e_attackState_Retreat)        {  return "Retreat";        }
    if (state == e_attackState_DropRetreat)    {  return "DropRetreat";    }
    if (state == e_attackState_InRetreat)      {  return "InRetreat";      }
    return "?" + IntToString(state) + "?";
}

//--------------------------------------------------------------------------------------------------
string WaveStateName (int state) {
    if (state == c_waveStateIdle)           { return "Idle";        }
    if (state == c_waveStateSuicide)        { return "Suicide";     }
    if (state == c_waveStateMerge)          { return "Merge";       }
    if (state == c_waveStateAttack)         { return "Attack";      }
    if (state == c_waveStateDefend)         { return "Defend";      }
    if (state == c_waveStateScout)          { return "Scout";       }
    if (state == c_waveStateRetreat)        { return "Retreat";     }
    if (state == c_waveStateClearObs)       { return "ClearObs";    }
    if (state == c_waveStateGuardHome)      { return "Home";        }
    return "?" + IntToString(state) + "?";
}

//--------------------------------------------------------------------------------------------------
void DebugWave (int player, string name, wave w) {
    string threat;
    if (AIDefenseThreat(c_dtAnyThreat, player, w)) {
        threat = "true";
    }
    else {
        threat = "false";
    } 
    DebugAIPlayer(
        player,
        "wave="         + name                                          +
        ", units="      + IntToString(AIWaveUnitCount(w))               +
        ", state="      + WaveStateName(AIWaveState(w))                 +
        ", ratio="      + IntToString(AIWaveEvalRatio(w, c_evalRange))  +
        ", combat="     + IntToString(AIWaveGetTimeInCombat(w))         +
        ", safe="       + IntToString(AIWaveGetTimeSinceCombat(w))      +
        ", threat="     + threat
    );
}

//--------------------------------------------------------------------------------------------------
void DebugMelee (int player) {

    DebugWave(player, "main", AIWaveGet(player, c_waveMain));
    DebugWave(player, "atck", AIWaveGet(player, c_waveAttack));
    DebugWave(player, "dfnd", AIWaveGet(player, c_waveDefend));
    DebugWave(player, "div1", AIWaveGet(player, c_waveDivert1));
    DebugWave(player, "div2", AIWaveGet(player, c_waveDivert2));
    DebugWave(player, "clob", AIWaveGet(player, c_waveClearObs));
    DebugWave(player, "home", AIWaveGet(player, c_waveHome));
   
    DebugVarInt2(
        "peons cur",    AIGetCurPeonCount(player, c_townMax),
        "max",          AIGetMaxPeonCount(player, c_townMax)
    );
    DebugVarBool("e_flagsScouting", AIGetFlag(player, e_flagsScouting));
    DebugVarBool("e_flagsTimeout", AIGetFlag(player, e_flagsTimeout));
}

//--------------------------------------------------------------------------------------------------
bool DebugMeleeTrigger (bool c, bool a) {
    if (a) {
        DebugMelee(StringToInt(StringWord(EventChatMessage(false), 2)));
    }
    return true;
}

//--------------------------------------------------------------------------------------------------
bool g_debugMeleeInit = false;
void DebugMeleeInit () {
    trigger t;

    if (!g_debugMeleeInit) {
        t = TriggerCreate("DebugMeleeTrigger");
        TriggerAddEventChatMessage(t, 1, "waves", false);

        g_debugMeleeInit = true;
    }
}

//--------------------------------------------------------------------------------------------------
string MainStateName (int state) {
    if (state == e_mainState_Init)              { return "Init";        }

    else if (state == e_mainState_OpenGnd0)     { return "OpenGnd0";    }
    else if (state == e_mainState_OpenGnd1)     { return "OpenGnd1";    }
    else if (state == e_mainState_OpenGnd2)     { return "OpenGnd2";    }
    else if (state == e_mainState_OpenGnd3)     { return "OpenGnd3";    }
    else if (state == e_mainState_OpenGnd4)     { return "OpenGnd4";    }
    else if (state == e_mainState_OpenGnd5)     { return "OpenGnd5";    }

    else if (state == e_mainState_OpenAir0)     { return "OpenAir0";    }
    else if (state == e_mainState_OpenAir1)     { return "OpenAir1";    }
    else if (state == e_mainState_OpenAir2)     { return "OpenAir2";    }
    else if (state == e_mainState_OpenAir3)     { return "OpenAir3";    }
    else if (state == e_mainState_OpenAir4)     { return "OpenAir4";    }
    else if (state == e_mainState_OpenAir5)     { return "OpenAir5";    }

    else if (state == e_mainState_Mid0)         { return "Mid0";        }
    else if (state == e_mainState_Mid1)         { return "Mid1";        }
    else if (state == e_mainState_Mid2)         { return "Mid2";        }
    else if (state == e_mainState_Mid3)         { return "Mid3";        }
    else if (state == e_mainState_Mid4)         { return "Mid4";        }
    else if (state == e_mainState_Mid5)         { return "Mid5";        }

    else if (state == e_mainState_Late0)        { return "Late0";       }
    else if (state == e_mainState_Late1)        { return "Late1";       }
    else if (state == e_mainState_Late2)        { return "Late2";       }
    else if (state == e_mainState_Late3)        { return "Late3";       }
    else if (state == e_mainState_Late4)        { return "Late4";       }
    else if (state == e_mainState_Late5)        { return "Late5";       }

    else if (state == e_mainState_Off)          { return "Off";         }

    return "?" + IntToString(state) + "?";
}

//--------------------------------------------------------------------------------------------------
//  AISetAttackState
//--------------------------------------------------------------------------------------------------
void AISetAttackState (int player, int attackState) {
    string msg;
    int oldState = AIState(player, e_attackState);

    AISetSpecificState(player, e_attackState, attackState);
   
    if (DEBUG_ATTACK_STATE) {
        msg = "Player " + IntToString(player) + "-" + PlayerRace(player) + " attack state " +
            AttackStateName(oldState) + " -> " + AttackStateName(attackState);
        DebugAI(msg);
    }
}

//--------------------------------------------------------------------------------------------------
//  AISetMainState
//--------------------------------------------------------------------------------------------------
void AISetMainState (int player, int mainState, int mainSubState) {
    string msg;
    int oldMainState = AIState(player, e_mainState);
    int oldSubState = AIState(player, e_mainSubState);

    AISetSpecificState(player, e_mainState, mainState);
    AISetSpecificState(player, e_mainSubState, mainSubState);

    if (DEBUG_MAIN_STATE) {
        msg = "Player " + IntToString(player) + "-" + PlayerRace(player) + " main state " +
            MainStateName(oldMainState) + "(" + IntToString(oldSubState) + ") --> " +
            MainStateName(mainState)  + "(" + IntToString(mainSubState) + ")";
        DebugAI(msg);
    }
}

//--------------------------------------------------------------------------------------------------
//  EndMeleeScript
//--------------------------------------------------------------------------------------------------
void EndMeleeScript (int player) {
    string msg = "Reached end of script for player " + IntToString(player) + "-" +
        PlayerRace(player) + " : More AI code coming soon.";
    UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, StringToText(msg));
    DebugAI(msg);
    AISetMainState(player, e_mainState_Disabled, e_mainSubState_Unset);
}

//--------------------------------------------------------------------------------------------------
//  ErrorMeleeScript
//--------------------------------------------------------------------------------------------------
void ErrorMeleeScript (int player, string error) {
    string msg = "A script logic error occurred for player " + IntToString(player) +
        "-" + PlayerRace(player) + " : " + error;
    UIDisplayMessage(PlayerGroupAll(), c_messageAreaSubtitle, StringToText(msg));
    DebugAI(msg);
    AISetMainState(player, e_mainState_Disabled, e_mainSubState_Unset);
}

//--------------------------------------------------------------------------------------------------
//  AISetGasPeons
//--------------------------------------------------------------------------------------------------
void AISetGasPeons (int player, int count, string type, string from) {
    int sources = AITechCount(player, from, c_techCountCompleteOnly);
    if (sources < 1
        || AIHasRes(player, 0, 200)
        || AITechCount(player, type, c_techCountCompleteOnly) < 8)
    {
        AISetGasPeonCountOverride(player, c_townMain, c_defaultGasPeonCount);
    }

    else if (sources == 1) {
        AISetGasPeonCountOverride(player, c_townMain, 3);
    }
    else { // sources == 2+
        AISetGasPeonCountOverride(player, c_townMain, count);
    }
}

//--------------------------------------------------------------------------------------------------
//  AISetStockAll
//--------------------------------------------------------------------------------------------------
void AISetStockAll (int player, string source, int max, string what) {
    int make = AITechCount(player, what, c_techCountCompleteOnly)
             + 2 * AITechCount(player, source, c_techCountCompleteOnly);
    if (make > max) {
        make = max;
    }
    AISetStock(player, make, what);
}

//--------------------------------------------------------------------------------------------------
//  AIMergeUnit
//--------------------------------------------------------------------------------------------------
void AIMergeUnit (int player, unit u, wave w) {
    wave merge = AIWaveCreate(AIWaveInfoCreate(), player, AIGetGatherLocation(player, c_townMain));
    AIWaveAddUnit(merge, u);
    AIWaveSetType(merge, c_waveStateMerge, AIWaveTargetMerge(w));
}

//--------------------------------------------------------------------------------------------------
//  AINewUnitDefault
//--------------------------------------------------------------------------------------------------
void AINewUnitDefault (int player, unit u) {
    wave w = AIWaveGet(player, c_waveMain);
    if (AIDefenseThreat(c_dtAnyThreat, player, w)) {
        AIMergeUnit(player, u, w);
    }
    else {
        AIWaveAddUnit(w, u);
    }
}

//--------------------------------------------------------------------------------------------------
//  AICreateOrder
//--------------------------------------------------------------------------------------------------
order AICreateOrder (int player, string abilLink, int abilIndex) {
    abilcmd cmd = AbilityCommand(abilLink, abilIndex);
    order ord;
    if (cmd == c_nullCmd) {
        return null;
    }
    ord = Order(cmd);
    OrderSetPlayer(ord, player);
    return ord;
}


I was seeking for it inside mpqs so here they are...

As AI doesn't work yet and editor isn't available yet we could try playing around with these
Its way to go.
I was going to check If I could add some AI using these but I thought sharing what I found would be nice so here you go ...
I know it contains a lot of useless junk too :/


BuildAI.galaxy
//--------------------------------------------------------------------------------------------------
//  AI Building Functions
//--------------------------------------------------------------------------------------------------

//--------------------------------------------------------------------------------------------------
//  Build Flags
//--------------------------------------------------------------------------------------------------

const int c_makeNoFlags             = 0x00000000;

const int c_avoidClosePowerOrCreep  = 0x00000001;
const int c_avoidCloseFactory       = 0x00000002;
const int c_avoidCloseDefense       = 0x00000004;
const int c_avoidCloseDropoff       = 0x00000008;

const int c_avoidFarPowerOrCreep    = 0x00000010;
const int c_avoidFarFactory         = 0x00000020;
const int c_avoidFarDefense         = 0x00000040;
const int c_avoidFarDropoff         = 0x00000080;

const int c_nearClosePowerOrCreep   = 0x00000100;
const int c_nearCloseFactory        = 0x00000200;
const int c_nearCloseDefense        = 0x00000400;
const int c_nearCloseDropoff        = 0x00000800;

const int c_nearFarPowerOrCreep     = 0x00001000;
const int c_nearFarFactory          = 0x00002000;
const int c_nearFarDefense          = 0x00004000;
const int c_nearFarDropoff          = 0x00008000;

const int c_avoidResource           = 0x00010000;
const int c_avoidChokePoint         = 0x00020000;
const int c_nearResource            = 0x00040000;
const int c_nearChokePoint          = 0x00080000;

const int c_valueSpaceMinor         = 0x00100000;
const int c_valueSpaceMajor         = 0x00200000;

const int c_canLower                = 0x08000000;
const int c_onVespeneGas            = 0x10000000;
const int c_onlyHere                = 0x20000000;
const int c_ignoreDanger            = 0x40000000;

const int c_avoidPowerOrCreep       = c_avoidClosePowerOrCreep | c_avoidFarPowerOrCreep;
const int c_avoidFactory            = c_avoidCloseFactory | c_avoidFarFactory;
const int c_avoidDefense            = c_avoidCloseDefense | c_avoidFarDefense;
const int c_avoidDropoff            = c_avoidCloseDropoff | c_avoidFarDropoff;

const int c_nearPowerOrCreep        = c_nearClosePowerOrCreep | c_nearFarPowerOrCreep;
const int c_nearFactory             = c_nearCloseFactory | c_nearFarFactory;
const int c_nearDefense             = c_nearCloseDefense | c_nearFarDefense;
const int c_nearDropoff             = c_nearCloseDropoff | c_nearFarDropoff;

const int c_makeStandard            = c_makeNoFlags;
const int c_makeCenter              = c_nearResource;
const int c_makeCreep               = c_valueSpaceMajor | c_avoidPowerOrCreep;
const int c_makePower               = c_valueSpaceMajor | c_avoidPowerOrCreep;
const int c_makeExpanPower          = c_nearResource | c_nearDropoff | c_avoidClosePowerOrCreep;
const int c_makeDarkPower           = c_nearResource | c_nearDropoff;
const int c_makeCollector           = c_onVespeneGas | c_nearDropoff;
const int c_makeDefense             = c_avoidCloseDefense | c_nearResource | c_nearFarDropoff | c_nearFarFactory | c_nearFarPowerOrCreep | c_nearChokePoint;
const int c_makeResourceDefense     = c_avoidCloseDefense | c_nearResource;
const int c_makeLowerable           = c_makeStandard | c_canLower;

const int c_makeDefault = -1;

//--------------------------------------------------------------------------------------------------
//  AI Get Default Build Flags Functions
//--------------------------------------------------------------------------------------------------
int AIGetDefaultBuildFlags (int player, string objType) {

    // special protoss units
    if (objType == c_PB_Nexus) {
        return c_makeCenter;
    }
    if (objType == c_PB_Pylon) {
        return c_makePower;
    }
    if (objType == c_PB_Obelisk) {
        return c_makeDarkPower;
    }
    if (objType == c_PB_PhotonCannon) {
        return c_makeDefense;
    }
    if (objType == c_PB_Assimilator) {
        return c_makeCollector;
    }
   
    // special terran units
    if (objType == c_TB_CommandCenter) {
        return c_makeCenter;
    }
    if (objType == c_TB_Bunker) {
        return c_makeDefense;
    }
    if (objType == c_TB_MissileTurret) {
        return c_makeResourceDefense;
    }
    if (objType == c_TB_SensorTower) {
        return c_nearChokePoint;
    }
    if (objType == c_TB_PlanetaryFortress) {
        return c_makeDefense;
    }
    if (objType == c_TB_Refinery) {
        return c_makeCollector;
    }
    if (objType == c_TB_SupplyDepot) {
        return c_makeLowerable;
    }
   
    // special zerg units
    if (objType == c_ZB_Hatchery) {
        return c_makeCenter;
    }
    if (objType == c_ZB_Lair) {
        return c_makeCenter;
    }
    if (objType == c_ZB_Hive) {
        return c_makeCenter;
    }
    if (objType == c_ZB_CreepTumor) {
        return c_makeCreep;
    }
    if (objType == c_ZB_SpineCrawler) {
        return c_makeDefense;
    }
    if (objType == c_ZB_SporeCrawler) {
        return c_makeResourceDefense;
    }
    if (objType == c_ZB_Extractor) {
        return c_makeCollector;
    }
   
    // default
    return c_makeStandard;
}


Computer.galaxy
include "TriggerLibs/MeleeAI"
include "TriggerLibs/Terran"
include "TriggerLibs/Protoss"
include "TriggerLibs/Zerg"