Starcraft 2 functions/libraries here

[MisterTea]

TactZergAI.galaxy < suite

Code Select Expand


//--------------------------------------------------------------------------------------------------
//  Limit the number of enemies we check since AIPathCost could be expensive over
//  too many units.
const int c_maxEnemyCount = 5;

order Changeling (int player, unit aiUnit, unitgroup scanGroup, fixed range) {
    int enemyPlayer = -1;
    point here;
    order ord;
    point camPoint;
    fixed camDistance;

    ord = AICreateOrder(player, c_AB_Changeling, 0);
    if (!UnitOrderIsValid(aiUnit, ord)) {
        return null;
    }

    enemyPlayer = AIGetPlayerGroup(scanGroup);
    if (enemyPlayer == -1) {
        return null;
    }

    //  A good player should be able to tell when the enemy isn't paying attention
    //  and then cast changeling.  To simulate this, the computer looks for an enemy
    //  player's camera on hard and insanse.
    //
    if (AICampSkirDiffTest(player, c_campExpert, c_skirVeryHard)) {
        camPoint = CameraGetTarget(enemyPlayer);
        here = UnitGetPosition(aiUnit);
        camDistance = DistanceBetweenPoints(camPoint, here);
       
        if (camDistance < 20) {
            return null;
        }
    }

    //  Check to see if we already have a changeling.
    if (AINearbyUnits(player, c_ZU_Changeling, here, range, 1) ||
        AINearbyUnits(player, c_ZU_ChangelingZealot, here, range, 1) ||
        AINearbyUnits(player, c_ZU_ChangelingZergling, here, range, 1) ||
        AINearbyUnits(player, c_ZU_ChangelingMarine, here, range, 1) ||
        AINearbyUnits(player, c_ZU_ChangelingZerglingWings, here, range, 1)) {
        return null;
    }

    //  Check to see if there are enough basic units around to follow.
    if ((UnitGroupCount(AIFilterPathable(AIFindUnits(enemyPlayer, c_PU_Zealot, here, range, c_maxEnemyCount), here), c_unitCountAlive) >= 2) ||
        (UnitGroupCount(AIFilterPathable(AIFindUnits(enemyPlayer, c_ZU_Zergling, here, range, c_maxEnemyCount), here), c_unitCountAlive) >= 2) ||
        (UnitGroupCount(AIFilterPathable(AIFindUnits(enemyPlayer, c_TU_Marine, here, range, c_maxEnemyCount), here), c_unitCountAlive) >= 2)) {
        return ord;
    }

    return null;
}

bool MakeChangeling (int player, unit aiUnit, unitgroup scanGroup) {
    order ord;
    unitgroup allyGroup;
    region r;
    aifilter filter;
    point position;
    bool groundEnemies;
    bool airEnemies;
    fixed range;

    if (AIIsCampaign(player)) {
        // don't auto make changlings on campaign
        return false;
    }

    //  If we already have a changeling order, ignore new orders so that
    //  we don't cast again
    if (UnitOrderHasAbil(aiUnit, c_AB_Changeling)) {
        return false;
    }

    //  Test to see whether the overseer is scouting or fighting.
    //  For now, just test to see if there are nearby allied units that can fight the enemy.
    r = RegionCircle(UnitGetPosition(aiUnit), AIRangeOverseer(player, aiUnit));
    allyGroup = UnitGroupAlliance(player, c_unitAllianceAlly, r, null, c_noMaxCount);
   
    position = UnitGetPosition(aiUnit);
    range = AIRangeOverseer(player, aiUnit);
    groundEnemies = AINearbyPlaneTest(position, player, range, c_planeGround, c_unitAllianceEnemy);
    airEnemies = AINearbyPlaneTest(position, player, range, c_planeAir, c_unitAllianceEnemy);

    filter = AIFilter(player);
    AISetFilterCanAttackAlly(filter, groundEnemies, airEnemies);
    allyGroup = AIGetFilterGroup(filter, allyGroup);

    if (UnitGroupCount(allyGroup, c_unitCountAll) == 0) {
        ord = Changeling(player, aiUnit, scanGroup, range);
        if (ord != null) {
            AICast(aiUnit, ord, c_noMarker, c_castRetreat);
            return true;
        }
    }

    return false;
}

//--------------------------------------------------------------------------------------------------
void AIThinkOverseer (int player, unit aiUnit, unitgroup scanGroup) {
    order ord;
    marker mark;
    marker gameMark;

    if (MakeChangeling(player, aiUnit, scanGroup)) {
        return;
    }

    //gameMark = AIMarker(aiUnit, c_MK_GameFungalGrowth);
    //mark = AIMarker(aiUnit, c_MK_FungalGrowth);
    //ord = FungalGrowth(player, aiUnit, mark, gameMark, scanGroup);
    //if (ord != null) {
    //    AICast(aiUnit, ord, mark, c_castHold);
    //    return;
    //}

    //ord = AcidSpores(player, aiUnit, scanGroup);
    //if (ord != null) {
    //    AICast(aiUnit, ord, c_noMarker, c_castHold);
    //    return;
    //}

}

//--------------------------------------------------------------------------------------------------
//  *** CHANGELING ***
//--------------------------------------------------------------------------------------------------
fixed AIRangeChangeling (int player, unit aiUnit) {
    return AIUnitFixed(player, c_ZU_Overlord, c_fieldSightDawn);
}

void AIThinkChangelingUnit (int player, unit aiUnit, unitgroup scanGroup, string followUnit) {
    unitgroup followGroup;
    order ord;
    int enemyPlayer;
    region r;
    unitgroup allyGroup;
    unitgroup enemyGroup;

    if (AIIsFollowingUnit(aiUnit, followUnit)) {
        return;
    }

    //  Create a move order, and check validity
    ord = AICreateOrder(player, c_AB_Follow, 0);
    if (!UnitOrderIsValid(aiUnit, ord)) {
        return;
    }

    r = RegionCircle(UnitGetPosition(aiUnit), AIRangeOverseer(player, aiUnit));
    enemyGroup = UnitGroupAlliance(player, c_unitAllianceEnemy, r, null, c_noMaxCount);

    enemyPlayer = AIGetPlayerGroup(enemyGroup);
    if (enemyPlayer == -1) {
        return;
    }

    //  By default, follow the provided unit type.
    followGroup = AIFindUnits(enemyPlayer, followUnit, UnitGetPosition(aiUnit), AIRangeChangeling(player, aiUnit), c_noMaxCount);
    ord = AIUnitGroupGetValidOrder(followGroup, ord, aiUnit, c_forwards);

    if (ord != null) {
        AICast(aiUnit, ord, c_noMarker, c_castHold);
        return;
    }

    //  Otherwise, find any enemy to follow.
    ord = AICreateOrder(player, c_AB_Follow, 0);
    if (!UnitOrderIsValid(aiUnit, ord)) {
        return;
    }
   
    ord = AIUnitGroupGetValidOrder(scanGroup, ord, aiUnit, c_forwards);
    if (ord != null) {
        AICast(aiUnit, ord, c_noMarker, c_castHold);
        return;
    }

    return;
}

//--------------------------------------------------------------------------------------------------
void AIThinkChangelingZergling (int player, unit aiUnit, unitgroup scanGroup) {
    AIThinkChangelingUnit(player, aiUnit, scanGroup, c_ZU_Zergling);
}

void AIThinkChangelingMarine (int player, unit aiUnit, unitgroup scanGroup) {
    AIThinkChangelingUnit(player, aiUnit, scanGroup, c_TU_Marine);
}

void AIThinkChangelingZealot (int player, unit aiUnit, unitgroup scanGroup) {
    AIThinkChangelingUnit(player, aiUnit, scanGroup, c_PU_Zealot);
}


[MisterTea]

Terran0.galaxy

Code Select Expand

//==================================================================================================
//  Terran Melee Very Easy
//==================================================================================================

static void RandomInfantry (int player);
static void LateGround (int player);

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

    AISetStock( player, 1, c_TB_CommandCenter_Alias );
    AISetStock( player, 8, c_TU_SCV );
   
    // around 100 resources in about 2 units
    AISetStock( player, 2, c_TU_Marine );
    TerranTechUp(player, 1);
   
    if (AIEnableVeryEasyStockOpen(player, c_TU_SCV)) {
        return;
    }

    // around 300 resources in about 3 unit
    RandomInfantry(player);
}

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

    AIDefaultEconomy(player, c_TB_CommandCenter_Alias, c_TB_Refinery, c_TB_SupplyDepot, c_TU_SCV, 8, c_stockAlways);

    if (AISawCloakedUnit(player)) {
        AISetStock( player, 2, c_TB_MissileTurret );
        AISetStock( player, 1, c_TB_OrbitalCommand );
    }

    AISetStockUserData(player);
    TerranTechUp(player, 2);

    if (AIEnableVeryEasyStockMidA(player, c_TU_SCV, 4)) {
        return;
    }
   
    // around 600 resources in about 4 unit
    AIAddStringInt(player, AIPickFrom2(c_TU_Ghost, c_TU_SiegeTank), 1);
    RandomInfantry(player);
}

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

    AIDefaultEconomy(player, c_TB_CommandCenter_Alias, c_TB_Refinery, c_TB_SupplyDepot, c_TU_SCV, 8, c_stockAlways);

    if (AISawCloakedUnit(player)) {
        AISetStock( player, 2, c_TB_MissileTurret );
        AISetStock( player, 1, c_TB_OrbitalCommand );
    }

    AISetStockUserData(player);
    TerranTechUp(player, 3);

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

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

//--------------------------------------------------------------------------------------------------
//  LateGround
//--------------------------------------------------------------------------------------------------
static void LateGround (int player) {
    AIAddStringInt(player, c_TU_Marine, 1);
    AIAddStringInt(player, AIPickFrom2(c_TU_Hellion, c_TU_Marauder), 1);
    AIAddStringInt(player, AIPickFrom2(c_TU_Hellion, c_TU_Marine), 1);
    AIAddStringInt(player, AIPickFrom2(c_TU_Marauder, c_TU_Marine), 1);
    AIAddStringInt(player, AIPickFrom2(c_TU_SiegeTank, c_TU_Ghost), 1);
    AIAddStringInt(player, AIPickFrom2(c_TU_SiegeTank, c_TU_Ghost), 1);
}

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

    AIDefaultEconomy(player, c_TB_CommandCenter_Alias, c_TB_Refinery, c_TB_SupplyDepot, c_TU_SCV, 8, c_stockAlways);
    AIDefaultExpansion(player, c_TB_CommandCenter_Alias, 6000, 0, c_expandDefault);

    AISetStockUserData(player);
    AISetStock( player, 1, c_TB_OrbitalCommand );
    AISetStock( player, 3, c_TU_Medivac );
    AISetStock( player, 1, c_TU_Raven );
    TerranTechUp(player, 4);

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

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

    AISetStock( player, 1, c_TB_CommandCenter_Alias );
    AISetStock( player, 8, c_TU_SCV );
    AISetStock( player, 1, c_TB_Refinery );
    AISetStock( player, 1, c_TB_Barracks );
    AISetStock( player, 1, c_TB_Factory );
    AISetStock( player, 1, c_TB_Starport );
    AISetStock( player, 1, c_TU_Viking );
    AISetStock( player, 1, c_TB_BarracksReactor );
    AISetStock( player, 1, c_TB_SupplyDepot );
    AISetStock( player, 1, c_TU_Marine );

    AIEnableStock(player);

//    SetGasPeons(player, 3);

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

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

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

    AIDefaultEconomy(player, c_TB_CommandCenter_Alias, c_TB_Refinery, c_TB_SupplyDepot, c_TU_SCV, 8, c_stockAlways);

    AISetStockUnitNext( player, 4, c_TU_Marine, c_stockAlways );

    AISetStock( player, 1, c_TU_Viking );
    AISetStock( player, 1, c_TB_StarportTechLab );

    AISetStock( player, 2, c_TU_Viking );
    AISetStock( player, 1, c_TU_Raven );
    AISetStock( player, 1, c_TU_Banshee );
    AISetStock( player, 1, c_TU_Medivac );

    AISetStock( player, 1, c_TB_OrbitalCommand );

    AIEnableStock(player);

//    SetGasPeons(player, 3);

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

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

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

    AIDefaultEconomy(player, c_TB_CommandCenter_Alias, c_TB_Refinery, c_TB_SupplyDepot, c_TU_SCV, 8, c_stockAlways);
    AIDefaultExpansion(player, c_TB_CommandCenter_Alias, 6000, 1000, c_expandDefault);

    AISetStockUnitNext( player, 4, c_TU_Marine, c_stockAlways );
    AISetStockUnitNext( player, 3, c_TU_Viking, c_stockAlways );
    AISetStockUnitNext( player, 1, c_TU_Raven, c_stockAlways );
    AISetStockUnitNext( player, 1, c_TU_Medivac, c_stockAlways );
    AISetStock( player, 1, c_TB_OrbitalCommand );
    AISetStockUnitNext( player, 3, c_TB_MissileTurret, c_stockIdle );
    AISetStockUnitNext( player, 2, c_TU_Banshee, c_stockAlways );
    AISetStockUnitNext( player, 1, c_TU_Battlecruiser, c_stockAlways );

    AIEnableStock(player);

//    SetGasPeons(player, 4);

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

    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_TB_CommandCenter_Alias, c_TB_Refinery, c_TB_SupplyDepot, c_TU_SCV, 8, c_stockAlways);
    AIDefaultExpansion(player, c_TB_CommandCenter_Alias, 6000, 1000, c_expandDefault);

    AISetStockUnitNext( player, 4, c_TU_Marine, c_stockAlways );
    AISetStockUnitNext( player, 5, c_TU_Viking, c_stockAlways );
    AISetStockUnitNext( player, 1, c_TU_Raven, c_stockAlways );
    AISetStockUnitNext( player, 1, c_TU_Medivac, c_stockAlways );
    AISetStock( player, 1, c_TB_OrbitalCommand );
    AISetStockUnitNext( player, 3, c_TB_MissileTurret, c_stockIdle );
    AISetStockUnitNext( player, 4, c_TU_Banshee, c_stockAlways );
    AISetStockUnitNext( player, 1, c_TU_Battlecruiser, c_stockAlways );

    AIEnableStock(player);

//    SetGasPeons(player, 4);

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

    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);
}

//--------------------------------------------------------------------------------------------------
//    RandomInfantry
//--------------------------------------------------------------------------------------------------
static void RandomInfantry (int player) {
    AIAddStringInt(player, c_TU_Marine, 1);
    AIAddStringInt(player, AIPickFrom2(c_TU_Hellion, c_TU_Marauder), 1);
    AIAddStringInt(player, AIPickFrom2(c_TU_Hellion, c_TU_Marauder), 1);
}

//--------------------------------------------------------------------------------------------------
//  TerranMid0
//--------------------------------------------------------------------------------------------------
void TerranMid0 (int player) {
    int mainSubState = AIState(player, e_mainSubState);
    if (mainSubState == e_mainSubState_GndA)          { TerranMidGndA(player);  }
    else if (mainSubState == e_mainSubState_GndB)     { TerranMidGndB(player);  }
    else if (mainSubState == e_mainSubState_AirA)     { TerranMidAirA(player);  }
    else if (mainSubState == e_mainSubState_AirB)     { TerranMidAirB(player);  }
    else { ErrorMeleeScript(player, "Invalid Mid mainSubState"); }
}

//--------------------------------------------------------------------------------------------------
//  TerranLate0
//--------------------------------------------------------------------------------------------------
void TerranLate0 (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"); }
}


Terran.galaxy

Code Select Expand

//==================================================================================================
//  Terran Melee AI
//==================================================================================================

include "TriggerLibs/Terran0"

//--------------------------------------------------------------------------------------------------
//  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.50, c_TU_SiegeTank);
    AICounterUnit(player, c_PU_Zealot,              1.00, c_TU_Hellion);
    AICounterUnit(player, c_PU_Stalker,             1.00, c_TU_Marauder);
    AICounterUnit(player, c_PU_Immortal,            2.00, c_TU_Marauder);
    AICounterUnit(player, c_PU_Disruptor,           1.00, c_TU_Ghost);
    AICounterUnit(player, c_PU_HighTemplar,         1.00, c_TU_Ghost);
    AICounterUnit(player, c_PU_DarkTemplar,         1.00, c_TU_Hellion);
    AICounterUnit(player, c_PU_Archon,              0.33, c_TU_Hellion);
    AICounterUnit(player, c_PU_Colossus,            1.00, c_TU_Thor);
    AICounterUnit(player, c_PU_VoidRay,             0.50, c_TU_Battlecruiser);
    AICounterUnit(player, c_PU_Phoenix,             0.50, c_TU_BattlecruiserMissile);
    AICounterUnit(player, c_PU_Carrier,             0.75, c_TU_BattlecruiserYamato);

    // versus Terran
    AICounterUnit(player, c_TB_Bunker,              0.33, c_TU_SiegeTank);
    AICounterUnit(player, c_TU_Marine,              0.50, c_TU_Hellion);
    AICounterUnit(player, c_TU_Reaper,              0.70, c_TU_Hellion);
    AICounterUnit(player, c_TU_Marauder,            0.50, c_TU_SiegeTank);
    AICounterUnit(player, c_TU_Ghost,               2.00, c_TU_Hellion);
    AICounterUnit(player, c_TU_Hellion,             0.25, c_TU_Thor);
    AICounterUnit(player, c_TU_SiegeTank_Alias,     0.50, c_TU_Thor);
    AICounterUnit(player, c_TU_Thor,                3.00, c_TU_Marauder);
    AICounterUnit(player, c_TU_Viking_Alias,        1.00, c_TU_Viking);
    AICounterUnit(player, c_TU_Banshee,             1.00, c_TU_Viking);
    AICounterUnit(player, c_TU_BattlecruiserClass,  1.00, c_TU_BattlecruiserYamato);

    // versus Zerg
    AICounterUnit(player, c_ZB_SpineCrawler,        0.33, c_TU_SiegeTank);
    AICounterUnit(player, c_ZU_Zergling,            0.25, c_TU_Hellion);
    AICounterUnit(player, c_ZU_Roach,               0.80, c_TU_Marauder);
    AICounterUnit(player, c_ZU_Hydralisk,           0.50, c_TU_Ghost);
    AICounterUnit(player, c_ZU_Lurker,              1.00, c_TU_Marauder);
    AICounterUnit(player, c_ZU_Infestor,            0.50, c_TU_Ghost);
    AICounterUnit(player, c_ZU_Ultralisk,           1.00, c_TU_Thor);
    AICounterUnit(player, c_ZU_Mutalisk,            0.80, c_TU_Viking);
    AICounterUnit(player, c_ZU_Corruptor,           0.50, c_TU_Battlecruiser);
    AICounterUnit(player, c_ZU_BroodLord,           0.50, c_TU_Viking);
}

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

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

//--------------------------------------------------------------------------------------------------
//  AINewUnitTerr
//--------------------------------------------------------------------------------------------------
void AINewUnitTerr (int player, unit u) {
    wave w;
    string type = UnitGetType(u);

    // ignored units
    //
    if (UnitTypeTestAttribute(type, c_unitAttributeStructure)) {
        return;
    }
    if (UnitTypeTestFlag(type, c_unitFlagWorker)) {
        return;
    }
   
    if (type == c_TU_Medivac) {
        // TODO after normal scouting claims the ones it wants give the rest to the
        //      attack wave instead of the extra scout group
        AIAddToExtraScoutGroup(player, u);
        return;
    }

    // detector
    //
    if (type == c_TU_Raven) {
        AINewDetector(player, u, false);
        return;
    }

    // clear obstacle units
    //
    if (AIWaveNeedClearObsUnits(player)) {
        if (type == c_TU_Marine || type == c_TU_Reaper || type == c_TU_Marauder) {
            AIMergeUnit(player, u, AIWaveGet(player, c_waveClearObs));
            return;
        }
    }

    // diversion units
    if (AIGetFlag(player, e_flagsDiversion)) {
        if (type == c_TU_Reaper) {
            AIMergeUnit(player, u, AIWaveGet(player, c_waveDivert1));
            return;
        }
        if (type == c_TU_Banshee) {
            AIMergeUnit(player, u, AIWaveGet(player, c_waveDivert2));
            return;
        }
    }

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

//--------------------------------------------------------------------------------------------------
//  AIGetScoutTerr
//--------------------------------------------------------------------------------------------------
unit AIGetScoutTerr (int player, int index, unit prev) {
    unit medivac;
   
    if (!AIGetFlag(player, e_flagsScouting)) {
        return c_nullUnit;
    }
    if (UnitGetType(prev) == c_TU_Medivac) {
        return prev;
    }
    medivac = AIGrabUnit(player, c_TU_Medivac, c_prioScout, null);
    if (medivac) {
        return medivac;
    }
    if (prev) {
        return prev;
    }
    if (AIGetFlag(player, e_flagsLateScout)) {
        return c_nullUnit;
    }
    return AIGrabUnit(player, c_TU_SCV, c_prioScout, null);
}

//--------------------------------------------------------------------------------------------------
//  AIEarlyDefScoutTerr
//--------------------------------------------------------------------------------------------------
unit AIEarlyDefScoutTerr (int player, unit prev) {
    unit obs;
   
    if (!AIGetFlag(player, e_flagsEarlyDefScout)) {
        return c_nullUnit;
    }
    if (UnitGetType(prev) == c_TU_Medivac) {
        return prev;
    }
    obs = AIGrabUnit(player, c_TU_Medivac, c_prioScout, null);
    if (obs) {
        return obs;
    }
    if (UnitGetType(prev) == c_TU_Marine) {
        return prev;
    }
    obs = AIGrabUnit(player, c_TU_Marine, c_prioScout, null);
    if (obs) {
        return obs;
    }
    if (prev) {
        return prev;
    }
    return AIGrabUnit(player, c_TU_SCV, c_prioScout, null);
}


[MisterTea]

Terran.galaxy < suite

Code Select Expand


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

//--------------------------------------------------------------------------------------------------
//  Terran Init
//--------------------------------------------------------------------------------------------------
static void TerranInit (int player) {
    int state;

    InitCounters(player);
    AISetNumScouts(player, 1);
    AISetFlag(player, e_flagsScouting, false);
    AISetFlag(player, e_flagsEarlyDefScout, false);
    AITechCountFixupEither(player, c_TB_CommandCenter, c_TB_OrbitalCommand, c_TB_PlanetaryFortress);

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

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

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

    else if (mainState == e_mainState_OpenGnd0)     { TerranOpenGnd0(player); }
    //else if (mainState == e_mainState_OpenGnd1)     { TerranOpenGnd1(player); }
    //else if (mainState == e_mainState_OpenGnd2)     { TerranOpenGnd2(player); }
    //else if (mainState == e_mainState_OpenGnd3)     { TerranOpenGnd3(player); }
    //else if (mainState == e_mainState_OpenGnd4)     { TerranOpenGnd4(player); }
    //else if (mainState == e_mainState_OpenGnd5)     { TerranOpenGnd5(player); }

    else if (mainState == e_mainState_OpenAir0)     { TerranOpenAir0(player); }
    //else if (mainState == e_mainState_OpenAir1)     { TerranOpenAir1(player); }
    //else if (mainState == e_mainState_OpenAir2)     { TerranOpenAir2(player); }
    //else if (mainState == e_mainState_OpenAir3)     { TerranOpenAir3(player); }
    //else if (mainState == e_mainState_OpenAir4)     { TerranOpenAir4(player); }
    //else if (mainState == e_mainState_OpenAir5)     { TerranOpenAir5(player); }

    else if (mainState == e_mainState_Mid0)         { TerranMid0(player);     }
    //else if (mainState == e_mainState_Mid1)         { TerranMid1(player);     }
    //else if (mainState == e_mainState_Mid2)         { TerranMid2(player);     }
    //else if (mainState == e_mainState_Mid3)         { TerranMid3(player);     }
    //else if (mainState == e_mainState_Mid4)         { TerranMid4(player);     }
    //else if (mainState == e_mainState_Mid5)         { TerranMid5(player);     }

    else if (mainState == e_mainState_Late0)        { TerranLate0(player);    }
    //else if (mainState == e_mainState_Late1)        { TerranLate1(player);    }
    //else if (mainState == e_mainState_Late2)        { TerranLate2(player);    }
    //else if (mainState == e_mainState_Late3)        { TerranLate3(player);    }
    //else if (mainState == e_mainState_Late4)        { TerranLate4(player);    }
    //else if (mainState == e_mainState_Late5)        { TerranLate5(player);    }

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


Zerg0.galaxy

Code Select Expand

//==================================================================================================
//  Zerg Melee Very Easy
//==================================================================================================

static void RandomInfantry (int player);
static void LateGround (int player);

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

    AISetStock( player, 1, c_ZB_Hatchery_Alias );
    AISetStock( player, 2, c_ZU_Drone );
    AISetStock( player, 1, c_ZU_Overlord );
    AISetStock( player, 8, c_ZU_Drone );
    AISetStock( player, 1, c_ZB_Extractor );

    AISetStock( player, 1, c_ZU_Queen );
    AISetStock( player, 2, c_ZU_Overlord_Alias );   

    // around 100 resources in about 2 units
    AISetStock( player, 1, c_ZU_Hydralisk );
    ZergTechUp(player, 1);

    if (AIEnableVeryEasyStockOpen(player, c_ZU_Drone)) {
        return;
    }

    // around 300 resources in about 3 unit
    RandomInfantry(player);
}

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

    AIDefaultEconomy(player, c_ZB_Hatchery_Alias, c_ZB_Extractor, c_ZU_Overlord_Alias, c_ZU_Drone, 8, c_stockIdle);

    if (AISawCloakedUnit(player)) {
        AISetStock( player, 1, c_ZU_Overseer );
    }

    AISetStockUserData(player);
    AISetStock( player, 1, c_ZU_Queen );
    ZergTechUp(player, 2);

    if (AIEnableVeryEasyStockMidA(player, c_ZU_Drone, 3)) {
        return;
    }

    // around 600 resources in about 4 unit
    RandomInfantry(player);
    AIAddStringInt(player, c_ZU_Infestor, 1);
}

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

    AIDefaultEconomy(player, c_ZB_Hatchery_Alias, c_ZB_Extractor, c_ZU_Overlord_Alias, c_ZU_Drone, 8, c_stockIdle);

    if (AISawCloakedUnit(player)) {
        AISetStock( player, 1, c_ZU_Overseer );
        AISetStock( player, 2, c_ZB_SporeCrawler );
    }

    AISetStockUserData(player);
    AISetStock( player, 1, c_ZU_Queen );
    ZergTechUp(player, 3);

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

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

//--------------------------------------------------------------------------------------------------
//  LateGround
//--------------------------------------------------------------------------------------------------
static void LateGround (int player) {
    int roll = RandomInt(0,2); // infestors
    if (roll == 0) {
        AIAddStringInt(player, c_ZU_Zergling, 1);
        roll = RandomInt(2,6);
        AIAddStringInt(player, c_ZU_Hydralisk, roll);
        AIAddStringInt(player, c_ZU_Roach, 8 - roll);
    }
    else if (roll == 1) {
        AIAddStringInt(player, c_ZU_Zergling, 1);
        roll = RandomInt(2,3);
        AIAddStringInt(player, c_ZU_Hydralisk, roll);
        AIAddStringInt(player, c_ZU_Roach, 5 - roll);
        AIAddStringInt(player, c_ZU_Infestor, 1);
    }
    else { // infestors == 2
        AIAddStringInt(player, AIPickFrom2(c_ZU_Zergling, c_ZU_Roach), 1);
        AIAddStringInt(player, c_ZU_Hydralisk, 2);
        AIAddStringInt(player, c_ZU_Infestor, 2);
    }
}

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

    AIDefaultEconomy(player, c_ZB_Hatchery_Alias, c_ZB_Extractor, c_ZU_Overlord, c_ZU_Drone, 8, c_stockIdle);
    AIDefaultExpansion(player, c_ZB_Hatchery_Alias, 6000, 0, c_expandDefault);

    AISetStockUserData(player);
    AISetStock( player, 1, c_ZR_OverlordTransport );
    AISetStock( player, 3, c_ZU_Overseer );
    ZergTechUp(player, 4);

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

//--------------------------------------------------------------------------------------------------
//  ZergOpenAir0
//--------------------------------------------------------------------------------------------------
void ZergOpenAir0 (int player) {
    fixed time = AIGetTime();

    AIClearStock(player);
    AISetGasPeons(player, 3, c_ZU_Drone, c_ZB_Extractor );

    AISetStock( player, 1, c_ZB_Hatchery_Alias );
    AISetStock( player, 1, c_ZU_Overlord );
    AISetStock( player, 10, c_ZU_Drone );
    AISetStock( player, 1, c_ZB_Extractor );
    AISetStock( player, 1, c_ZB_SpawningPool );

    if (time >= 150) {
        AISetStock( player, 2, c_ZB_Extractor );
        AISetStock( player, 1, c_ZB_Lair );

        if (time >= 200) {
            AISetStock( player, 2, c_ZU_Overlord );
            AISetStock( player, 1, c_ZB_Spire );
            AISetStock( player, 1, c_ZU_Queen );
            AISetStock( player, 1, c_ZB_HydraliskDen );
            AISetStock( player, 1, c_ZU_Mutalisk );
            AISetStock( player, 2, c_ZU_Hydralisk );

            AISetGasPeons(player, 4, c_ZU_Drone, c_ZB_Extractor );
        }
    }
    AIEnableStock(player);

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

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

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

    AIDefaultEconomy(player, c_ZB_Hatchery_Alias, c_ZB_Extractor, c_ZU_Overlord, c_ZU_Drone, 8, c_stockIdle);

    AISetStock( player, 1, c_ZU_Queen );
    AISetStock( player, 1, c_ZB_Lair );
    AISetStock( player, 1, c_ZU_Mutalisk );
    AISetStock( player, 2, c_ZU_Hydralisk );

    AISetStock( player, 1, c_ZR_OverlordTransport );
    AISetStock( player, 1, c_ZU_Overseer );

    AISetStock( player, 1, c_ZB_EvolutionChamber );
    AISetStock( player, 2, c_ZU_Mutalisk );
    AISetStock( player, 3, c_ZB_SporeCrawler );
    AISetStock( player, 1, c_ZU_Corruptor );

    AIEnableStock(player);

    AISetGasPeons(player, 4, c_ZU_Drone, c_ZB_Extractor );

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

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

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

    AIDefaultEconomy(player, c_ZB_Hatchery_Alias, c_ZB_Extractor, c_ZU_Overlord, c_ZU_Drone, 8, c_stockIdle);
    AIDefaultExpansion(player, c_ZB_Hatchery_Alias, 6000, 1000, c_expandDefault);

    AISetStock( player, 1, c_ZU_Queen );
    AISetStock( player, 2, c_ZU_Mutalisk );
    AISetStock( player, 2, c_ZU_Hydralisk );

    AISetStock( player, 1, c_ZR_OverlordTransport );
    AISetStock( player, 1, c_ZR_OverseerSpeed );
    AISetStock( player, 1, c_ZU_Overseer );

    AISetStock( player, 3, c_ZB_SporeCrawler );
    AISetStock( player, 1, c_ZU_Corruptor );

    AISetStock( player, 3, c_ZU_Mutalisk );
    AISetStock( player, 2, c_ZU_Corruptor );

    AIEnableStock(player);

    AISetGasPeons(player, 4, c_ZU_Drone, c_ZB_Extractor );

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

    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_ZB_Hatchery_Alias, c_ZB_Extractor, c_ZU_Overlord, c_ZU_Drone, 8, c_stockIdle);
    AIDefaultExpansion(player, c_ZB_Hatchery_Alias, 6000, 1000, c_expandDefault);

    AISetStock( player, 1, c_ZU_Queen );
    AISetStock( player, 2, c_ZU_Mutalisk );
    AISetStock( player, 2, c_ZU_Hydralisk );

    AISetStock( player, 1, c_ZR_OverlordTransport );
    AISetStock( player, 1, c_ZR_OverseerSpeed );
    AISetStock( player, 2, c_ZU_Overseer );

    AISetStock( player, 3, c_ZB_SporeCrawler );
    AISetStock( player, 1, c_ZU_Corruptor );

    AISetStock( player, 4, c_ZU_Mutalisk );
    AISetStock( player, 3, c_ZU_Corruptor );
    AISetStock( player, 1, c_ZU_BroodLord );
    AISetStock( player, 4, c_ZU_Overseer );

    AISetStock( player, 1, c_ZR_CorruptorAttack );

    AIEnableStock(player);

    AISetGasPeons(player, 4, c_ZU_Drone, c_ZB_Extractor );

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

    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);
}

//--------------------------------------------------------------------------------------------------
//    RandomInfantry
//--------------------------------------------------------------------------------------------------
static void RandomInfantry (int player) {
    AIAddStringInt(player, c_ZU_Hydralisk, 1);
    AIAddStringInt(player, AIPickFrom2(c_ZU_Hydralisk, c_ZU_Roach), 1);
    AIAddStringInt(player, AIPickFrom2(c_ZU_Zergling, c_ZU_Roach), 1);
}

//--------------------------------------------------------------------------------------------------
//  ZergMid0
//--------------------------------------------------------------------------------------------------
void ZergMid0 (int player) {
    int mainSubState = AIState(player, e_mainSubState);
    if (mainSubState == e_mainSubState_GndA)          { ZergMidGndA(player);  }
    else if (mainSubState == e_mainSubState_GndB)     { ZergMidGndB(player);  }
    else if (mainSubState == e_mainSubState_AirA)     { ZergMidAirA(player);  }
    else if (mainSubState == e_mainSubState_AirB)     { ZergMidAirB(player);  }
    else { ErrorMeleeScript(player, "Invalid Mid mainSubState"); }
}

//--------------------------------------------------------------------------------------------------
//  ZergLate0
//--------------------------------------------------------------------------------------------------
void ZergLate0 (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"); }
}


[MisterTea]

Zerg.galaxy

Code Select Expand

//==================================================================================================
//  Zerg Melee AI
//==================================================================================================

include "TriggerLibs/Zerg0"

//--------------------------------------------------------------------------------------------------
//  Counter-Attack Units
//--------------------------------------------------------------------------------------------------
static void InitCounters (int player) {
//xxx lots of old data -- needs to be totally redone
    // versus Protoss
    AICounterUnit(player, c_PU_Zealot,              1.00, c_ZU_Baneling);
    AICounterUnit(player, c_PU_Stalker,             1.00, c_ZU_Roach);
    AICounterUnit(player, c_PU_Immortal,            8.00, c_ZU_Zergling);
    AICounterUnit(player, c_PU_HighTemplar,         2.00, c_ZU_Roach);
    AICounterUnit(player, c_PU_Disruptor,           4.00, c_ZU_Zergling);
    AICounterUnit(player, c_PU_Archon,              4.00, c_ZU_Zergling);
    AICounterUnit(player, c_PU_Archon,              2.00, c_ZU_Hydralisk);
    AICounterUnit(player, c_PU_Archon,              2.00, c_ZU_Roach);
    AICounterUnit(player, c_PU_Colossus,            1.00, c_ZU_Mutalisk);
    AICounterUnit(player, c_PU_VoidRay,             2.00, c_ZU_Corruptor);
    AICounterUnit(player, c_PU_VoidRay,             1.00, c_ZU_Mutalisk);
    AICounterUnit(player, c_PU_Phoenix,             2.00, c_ZU_Hydralisk);
    AICounterUnit(player, c_PU_Carrier,             2.00, c_ZU_Hydralisk);
    AICounterUnit(player, c_PU_Carrier,             2.00, c_ZU_Corruptor);

    // versus Terran
    AICounterUnit(player, c_TU_Marine,              0.60, c_ZU_Baneling);
    AICounterUnit(player, c_TU_Marauder,            3.00, c_ZU_Zergling);
    AICounterUnit(player, c_TU_Hellion,             0.60, c_ZU_Roach);
    AICounterUnit(player, c_TU_Ghost,               6.00, c_ZU_Zergling);
    AICounterUnit(player, c_TU_SiegeTank_Alias,     6.00, c_ZU_Zergling);
    AICounterUnit(player, c_TU_Reaper,              0.30, c_ZU_Mutalisk);
    AICounterUnit(player, c_TU_Thor,               12.00, c_ZU_Zergling);
    AICounterUnit(player, c_TU_Banshee,             0.50, c_ZU_Mutalisk);
    AICounterUnit(player, c_TU_BattlecruiserClass,  2.00, c_ZU_Corruptor);
    AICounterUnit(player, c_TU_BattlecruiserClass,  2.00, c_ZU_Hydralisk);

    // versus Zerg
    AICounterUnit(player, c_ZU_Zergling,            0.25, c_ZU_Baneling);
    AICounterUnit(player, c_ZU_Baneling,            0.25, c_ZU_Lurker);
    AICounterUnit(player, c_ZU_Roach,               3.00, c_ZU_Zergling);
    AICounterUnit(player, c_ZU_Hydralisk,           1.00, c_ZU_Hydralisk);
    AICounterUnit(player, c_ZU_Lurker,              1.50, c_ZU_Hydralisk);
    AICounterUnit(player, c_ZU_Mutalisk,            0.50, c_ZU_Mutalisk);
    AICounterUnit(player, c_ZU_Mutalisk,            0.50, c_ZU_Corruptor);
    AICounterUnit(player, c_ZU_Corruptor,           1.00, c_ZU_Corruptor);
    AICounterUnit(player, c_ZU_BroodLord,       0.50, c_ZU_Corruptor);
}

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

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

//--------------------------------------------------------------------------------------------------
//  AINewUnitZerg
//--------------------------------------------------------------------------------------------------
void AINewUnitZerg (int player, unit u) {
    wave w;
    string type = UnitGetType(u);

    // ignored units
    //
    if (type == c_ZU_Larva ||
        type == c_ZU_Broodling ||
        type == c_ZU_Mantaling) {
        return;
    }
    if (UnitTypeTestAttribute(type, c_unitAttributeStructure)) {
        return;
    }
    if (UnitTypeTestFlag(type, c_unitFlagWorker)) {
        return;
    }

    // units that stay near home
    //
    if (type == c_ZB_SpineCrawler || type == c_ZB_SporeCrawler) {
        AIWaveAddUnitPriority(AIWaveGet(player, c_waveHome), u, c_prioWavePeon);
        return;
    }
    if (type == c_ZU_Queen) {
        AIWaveAddUnitPriority(AIWaveGet(player, c_waveHome), u, c_prioWavePeon);
        return;
    }
   
    // detector
    //
    if (type == c_ZU_Overseer) {
        AINewDetector(player, u, true);
        return;
    }

    // extra scout units
    //
    if (type == c_ZU_Overlord || type == c_ZU_OverlordCocoon ) {
        AIAddToExtraScoutGroup(player, u);
        return;
    }

    // clear obstacle units
    //
    if (AIWaveNeedClearObsUnits(player)) {
        if (type == c_ZU_Zergling || type == c_ZU_Roach || type == c_ZU_Hydralisk) {
            AIMergeUnit(player, u, AIWaveGet(player, c_waveClearObs));
            return;
        }
    }

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

//--------------------------------------------------------------------------------------------------
//  AIGetScoutZerg
//--------------------------------------------------------------------------------------------------
unit AIGetScoutZerg (int player, int index, unit prev) {   
    unit seer;

    if (!AIGetFlag(player, e_flagsScouting)) {
        return c_nullUnit;
    }
    if (UnitGetType(prev) == c_ZU_Overseer) {
        return prev;
    } 
    seer = AIGrabUnit(player, c_ZU_Overseer, c_prioScout, null);
    if (seer) {
        return seer;
    }
    if (prev) {
        return prev;
    }
    if (AIGetFlag(player, e_flagsLateScout)) {
        return c_nullUnit;
    }
    return AIGrabUnit(player, c_ZU_Overlord, c_prioScout, null);
}

//--------------------------------------------------------------------------------------------------
//  AIEarlyDefScoutZerg
//--------------------------------------------------------------------------------------------------
unit AIEarlyDefScoutZerg (int player, unit prev) {
    unit obs;
   
    if (!AIGetFlag(player, e_flagsEarlyDefScout)) {
        return c_nullUnit;
    }
    if (UnitGetType(prev) == c_ZU_Overseer) {
        return prev;
    }
    obs = AIGrabUnit(player, c_ZU_Overseer, c_prioScout, null);
    if (obs) {
        return obs;
    }
    if (UnitGetType(prev) == c_ZU_Zergling) {
        return prev;
    }
    obs = AIGrabUnit(player, c_ZU_Zergling, c_prioScout, null);
    if (obs) {
        return obs;
    }
    if (prev) {
        return prev;
    }
    return AIGrabUnit(player, c_ZU_Drone, c_prioScout, null);
}


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

//--------------------------------------------------------------------------------------------------
//  Zerg Init
//--------------------------------------------------------------------------------------------------
static void ZergInit (int player) {
    int state;

    InitCounters(player);
    AISetNumScouts(player, 1);
    AISetFlag(player, e_flagsScouting, true);
    AISetFlag(player, e_flagsEarlyDefScout, false);
    AIReqCountAsBuiltObject(player, c_ZU_Larva);
    AITechCountFixupSingle(player, c_ZB_HydraliskDen, c_ZB_LurkerDen);
    AITechCountFixupSingle(player, c_ZB_Spire, c_ZB_GreaterSpire);
    AITechCountFixupInOrder(player, c_ZB_Hatchery, c_ZB_Lair, c_ZB_Hive);
    AISetCreepBuilding(player, c_ZB_CreepTumor, "ZergBuildingNotOnCreep");

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

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

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

    else if (mainState == e_mainState_OpenGnd0)     { ZergOpenGnd0(player);   }
    //else if (mainState == e_mainState_OpenGnd1)     { ZergOpenGnd1(player);   }
    //else if (mainState == e_mainState_OpenGnd2)     { ZergOpenGnd2(player);   }
    //else if (mainState == e_mainState_OpenGnd3)     { ZergOpenGnd3(player);   }
    //else if (mainState == e_mainState_OpenGnd4)     { ZergOpenGnd4(player);   }
    //else if (mainState == e_mainState_OpenGnd5)     { ZergOpenGnd5(player);   }

    else if (mainState == e_mainState_OpenAir0)     { ZergOpenAir0(player);   }
    //else if (mainState == e_mainState_OpenAir1)     { ZergOpenAir1(player);   }
    //else if (mainState == e_mainState_OpenAir2)     { ZergOpenAir2(player);   }
    //else if (mainState == e_mainState_OpenAir3)     { ZergOpenAir3(player);   }
    //else if (mainState == e_mainState_OpenAir4)     { ZergOpenAir4(player);   }
    //else if (mainState == e_mainState_OpenAir5)     { ZergOpenAir5(player);   }

    else if (mainState == e_mainState_Mid0)         { ZergMid0(player);       }
    //else if (mainState == e_mainState_Mid1)         { ZergMid1(player);       }
    //else if (mainState == e_mainState_Mid2)         { ZergMid2(player);       }
    //else if (mainState == e_mainState_Mid3)         { ZergMid3(player);       }
    //else if (mainState == e_mainState_Mid4)         { ZergMid4(player);       }
    //else if (mainState == e_mainState_Mid5)         { ZergMid5(player);       }

    else if (mainState == e_mainState_Late0)        { ZergLate0(player);      }
    //else if (mainState == e_mainState_Late1)        { ZergLate1(player);      }
    //else if (mainState == e_mainState_Late2)        { ZergLate2(player);      }
    //else if (mainState == e_mainState_Late3)        { ZergLate3(player);      }
    //else if (mainState == e_mainState_Late4)        { ZergLate4(player);      }
    //else if (mainState == e_mainState_Late5)        { ZergLate5(player);      }

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


[MisterTea]

Ok I am done, you can discuss ^^ . Hope it will come to help for someone

[2g4u]

What about the protoss one ?

[Bebops]

Annoying playing a TvT. I tried multiple strats, but the only way I was able to win on burning steps (1v1 map) was to do a gay 100 gas, double barracks dual reactor marine spam rush. Very impressive AI though, the hacked resources make it a damn good challenge.

[MisterTea]

What about the protoss one ?

> page 1

[1337]

Found all the native function calls and a bunch more enums.


From Core.SC2Data\TriggerLibs\AI.galaxy:

Code Select Expand

//==================================================================================================
//  AI Native Function Prototypes
//==================================================================================================
include "TriggerLibs/RequirementsAI"
include "TriggerLibs/BuildAI"


const int c_ScoutStartLocations = 0;
const int c_ScoutBlockedPath    = 1;
const int c_ScoutMinerals       = 2;
const int c_ScoutDefault        = 3;
const int c_ScoutPlayers        = 4;


const int c_noFlags             = 0;
const point c_nullPoint         = null;
const marker c_noMarker         = null;
const string c_noTech           = null;
const abilcmd c_nullCmd         = null;
const wave c_nullWave           = null;
const unit c_nullUnit           = null;


const bool c_stockIdle          = true;
const bool c_stockAlways        = false;


const bool c_stockMinPeons      = true;
const bool c_stockMaxPeons      = false;


const bool c_stockNeededFarms   = true;
const bool c_stockNormalFarms   = false;


const int c_allEnemies          = -1;


const int c_defaultGasPeonCount = -1;


const int c_expandDefault       = 1;
const int c_expandVitalHard     = 4;
const int c_expandNormalHard    = 6;


const int c_unitAttributeNone   = -1;


//--------------------------------------------------------------------------------------------------
//  Unit Order Priorities
//--------------------------------------------------------------------------------------------------
// needs to match the order in Brain.h
const int c_prioNone              = 0;
const int c_prioExtraScout        = 1;
const int c_prioWorkerJob         = 2;
const int c_prioUseableBully      = 3;
const int c_prioStaticBully       = 4;
const int c_prioGather            = 5;
const int c_prioExpand            = 6;
const int c_prioCombat            = 7;
const int c_prioWaveIdle          = 8;
const int c_prioScout             = 9;
const int c_prioEarlyDefense      = 10;
const int c_prioWavePeon          = 11;
const int c_prioWave              = 12;
const int c_prioTransport         = 13;
const int c_prioDetect            = 14;
const int c_prioNuke              = 15;
const int c_prioScriptControlled  = 16;


//--------------------------------------------------------------------------------------------------
//  Races
//--------------------------------------------------------------------------------------------------
const int c_raceProtoss = 1;
const int c_raceTerran  = 2;
const int c_raceZerg    = 3;


//--------------------------------------------------------------------------------------------------
//  Build and Train Priorities
//--------------------------------------------------------------------------------------------------
// needs to match the values in Captain.h
const int c_makePriorityLowest     = 0;
const int c_makePriorityBully      = 1;
const int c_makePriorityTown       = 2;
const int c_makePriorityResearch   = 3;
const int c_makePriorityAttack     = 4;
const int c_makePriorityDefense    = 5;
const int c_makePriorityExpand     = 6;
const int c_makePriorityContinue   = 7;
const int c_makePriorityPowerCreep = 8;
const int c_makePriorityDropoff    = 9;
const int c_makePriorityHighest    = 10;


//--------------------------------------------------------------------------------------------------
//  Town Locations
//--------------------------------------------------------------------------------------------------
const int c_townInvalid = -2;
const int c_townMain    = -1;
const int c_townOne     = 0;
const int c_townTwo     = 1;
const int c_townThree   = 2;
const int c_townFour    = 3;
const int c_townFive    = 4;
const int c_townSix     = 5;
const int c_townSeven   = 6;
const int c_townEight   = 7;
const int c_townMax     = 32;


//--------------------------------------------------------------------------------------------------
//  Town States
//--------------------------------------------------------------------------------------------------
const int c_townStateInvalid      = -1;
const int c_townStateUnused       = 0;
const int c_townStateClaimed      = 1;
const int c_townStateEstablished  = 2;


//--------------------------------------------------------------------------------------------------
//  Wave States
//--------------------------------------------------------------------------------------------------
// needs to match CWave::EWaveType
const int c_waveStateUnknown      = 0;
const int c_waveStateIdle         = 1;
const int c_waveStateSuicide      = 2;
const int c_waveStateMerge        = 3;
const int c_waveStateAttack       = 4;
const int c_waveStateDropAttack   = 5;
const int c_waveStateDefend       = 6;
const int c_waveStateScout        = 7;
const int c_waveStateRetreat      = 8;
const int c_waveStateDropRetreat  = 9;
const int c_waveStateClearObs     = 10;
const int c_waveStateGuardHome    = 11;


//--------------------------------------------------------------------------------------------------
//  Wave Default Names
//--------------------------------------------------------------------------------------------------
const int c_waveMain        = 0;
const int c_waveDefend      = 1;
const int c_waveAttack      = 2;
const int c_waveDivert1     = 3;
const int c_waveDivert2     = 4;
const int c_waveClearObs    = 5;
const int c_waveHome        = 6;


//--------------------------------------------------------------------------------------------------
//  Defense Threat Query Flags
//--------------------------------------------------------------------------------------------------
const int c_dtAnyThreat             = 1;
const int c_dtClosestThreat         = 2;
const int c_dtRealThreat            = 4;
const int c_dtAnyRealThreat         = 5;
const int c_closestRealThreat       = 6;
const int c_dtAllowCantAttack       = 8;


const int c_dtEvalAllThreats        = 2;
const int c_dtEvalRealThreats       = 6;


//--------------------------------------------------------------------------------------------------
//  Best Target Flags
//--------------------------------------------------------------------------------------------------
// Needs to match the flags in CCaptain
const int c_btNeedsPath             = 1;
const int c_btBuildingOrNeedsPath   = 2;
const int c_btPrefersPath           = 4;
const int c_btAllowJumping          = 8;
const int c_btSortByDistance        = 16;
const int c_btSortByFullType        = 32;
const int c_btSortByLeastRecent     = 64;
const int c_btDefaultNeedsPath      = 49;
const int c_btDefaultPrefersPath    = 52;


//--------------------------------------------------------------------------------------------------
//  Breakpoint Routines
//--------------------------------------------------------------------------------------------------
native void DebugString (string value);
native void DebugUnit (unit value);
native void DebugInt (int value);
native void DebugFixed (fixed value);
native void DebugPoint (point value);


//--------------------------------------------------------------------------------------------------
//  Difficulty
//--------------------------------------------------------------------------------------------------
const int c_diffAdvanceWave         = 0;
const int c_diffRepairDamage        = 1;
const int c_diffFleeDamage          = 2;
const int c_diffOptimizeGas         = 3;
const int c_diffDefendWithPeons     = 4;
const int c_diffNormalVision        = 5;
const int c_diffLimitAPM            = 6;
const int c_diffAutoLoadBunkers     = 7;
const int c_diffEarlyGameRepair     = 8;
const int c_diffEnableDangerMap     = 9;
const int c_diffWaveAvoidDanger     = 10;
const int c_diffNormalTargetPrio    = 11;
const int c_diffEarlyDefenseScout   = 12;


native void AISetDifficulty (int player, int index, bool state);
native bool AIGetDifficulty (int player, int index);


//--------------------------------------------------------------------------------------------------
// Utility
//--------------------------------------------------------------------------------------------------
native void AIStart (int player, bool isCampaign, int apm);


native bool AIGivingUp (int player);
native void AIGoodGame (int player);


native bool AIIsCampaign (int player);
native void AISetAPM (int player, int apm);


native unit AIGrabUnit (int player, string aliasUnitType, int prio, point location);


native int  AIState (int player, int index);
native void AISetSpecificState (int player, int index, int state);
native void AISetAllStates (int player, int state);


native void AISetFlag (int player, int index, bool state);
native bool AIGetFlag (int player, int index);
native void AITechFlag (int player, int index, int count, string what, int state);


native void AIResetUserData (int player);
native void AISetUserString (int player, int index, string data);
native string AIGetUserString (int player, int index);
native void AISetUserInt (int player, int index, int data);
native int AIGetUserInt (int player, int index);
native void AIAddStringInt (int player, string data, int change);


native fixed AIGetTime ();


native int AIGetTotalStartLocs ();
native int AIGetGroundStartLocs (point loc);
native int AIGetAirStartLocs (point loc);
native int AIGetTotalTownLocs ();
native int AIGetGroundTownLocs (point loc);
native int AIGetAirTownLocs (point loc);


native int AIRandomVal (int player, int which);
native void AINewChooseSubState (int player, int which, int min, int max, int defaultSubState);
native void AISetSubStateChance (int subState, int chance);
native int AIChooseSubState ();


native bool AIWantsMultipleTransport (int player);
native void AISetWantsMultipleTransport (int player, bool enable);
native int AIGetNumMobileTransports (int player);


native point AIGetBestCreepSpot (int player, unit creator, fixed createRadius);


native void AIAddDetectionDanger (int player, string unitType);
native bool AIDefaultSuspectDetectionDanger (int player);


native bool AIAnyWorkersFleeingNearby (int player, point loc, fixed radius);


native int AIGetNumEnemies (int player);
native int AIGetNumAllies (int player);


native point AIPlacementNearbyFindTest (int player, point loc, fixed range, string unitType);


native void AIAddToExtraScoutGroup (int player, unit u);
native bool AIOfferNewScout (int player, unit u);


//--------------------------------------------------------------------------------------------------
// Misc Melee
//--------------------------------------------------------------------------------------------------


const int c_skirVeryEasy    = 0; // difficulty settings
const int c_skirEasy        = 1;
const int c_skirMedium      = 2;
const int c_skirHard        = 3;
const int c_skirVeryHard    = 4;
const int c_skirCheater     = 5;


native bool AIAnyAllyAttacking (int player);
native point AIBestAllyAttackPoint (int player, wave w);
native bool AIAnyAllyNeedsDefending (int player);
native point AIBestAllyDefendPoint (int player, wave w);


//--------------------------------------------------------------------------------------------------
// Misc Campaign
//--------------------------------------------------------------------------------------------------


const int c_campBeginner    = 0; // difficulty settings
const int c_campNormal      = 1;
const int c_campAdvanced    = 2;
const int c_campExpert      = 3;


native void AIGlobalSuicide (int player);


native wave AIUnitGetWave (unit u);
native unitgroup AIWaveGetUnits (wave w);


native unitgroup AIGetAllEscorts (unit u);
native unitgroup AIGetAllEscortsGroup (unitgroup ug);


native void AIRemoveUnitFromAnyWaves (unit u);
native void AIRemoveGroupFromAnyWaves (unitgroup ug);


native unitgroup AIGetUnitsInWavesWithTarget (int player, wavetarget target);


native bool AIIsScriptControlled (unit u);
native void AISetUnitScriptControlled (unit u, bool enable);
native void AISetGroupScriptControlled (unitgroup ug, bool enable);


native bool AIIsSuicideUnit (unit u);
native void AISetUnitSuicide (unit u, bool enable);
native void AISetGroupSuicide (unitgroup ug, bool enable);


native bool AIIsNotUsableInWaves (unit u);
native void AISetUnitNotUsableInWaves (unit u, bool enable);
native void AISetGroupNotUsableInWaves (unitgroup ug, bool enable);


native void AISetWantsToUpgrade (unit u);


native void AIInitCampaignTowns (int player);
native void AIInitCampaignHarvest (int player);




//--------------------------------------------------------------------------------------------------
//  Towns
//--------------------------------------------------------------------------------------------------
native void AIDeclareTown (int player, int town, point center);
native int AIGetMainTown (int player);
native void AISetMainTown (int player, int maintown);
native void AIUpdateMainTown (int player);


native int AIGetTownState (int player, int town);
native fixed AIGetTownEstablishedTime (int player, int town);
native point AIGetTownLocation (int player, int town);
native int AIGetClosestTown (int player, point location);
native int AIGetNextUnusedTownSlot (int player);
native int AIGetBuildingCountInTown (int player, int town, string aliasUnitType, int countMask);


native bool AIIsTownHarvestRunning (int player, int town);
native void AIHarvest (int player, int town);
native void AIHarvestRate (int player, int rate);
native void AIHarvestBonus (int player, fixed bonus);
native void AISetGasPeonCountOverride (int player, int town, int desiredGasCount);


native int AIGetCurPeonCount (int player, int town);
native int AIGetMinPeonCount (int player, int town);
native int AIGetMaxPeonCount (int player, int town);
native int AIGetMineralAmountLeft (int player, int town);
native int AIGetGasAmountLeft (int player, int town);
native int AIGetMineralNumSpots (int player, int town);
native int AIGetRawGasNumSpots (int player, int town);


native point AIGetGatherLocation (int player, int town);//xxx remove old functions
native point AIGetGatherDefLocation (int player, int town);


native int AIExpand (int player, point searchStart, string firstBuilding);
native unitgroup AIGetTownThreats (int player, int town);
native unit AIGetObstruction (int player);
native bool AIHasNearbyOpenExpansion (int player);


//-------------------------------------------------------------------------------------------------
//  Scouting
//--------------------------------------------------------------------------------------------------
native void AIScout (int player);
native void AISetNumScouts (int player, int num);
native void AISetScoutTimes (int player, int starts, int obstructed, int resources, int other);


native point AIGetNextScoutLoc (int player);
native void AIClearCampaignScout (int player);



...post too long... continued next

[1337]

Code Select Expand


//--------------------------------------------------------------------------------------------------
//  Construction
//--------------------------------------------------------------------------------------------------
native void AIBuild (int player, int priority, int town, string aliasUnitType, int count, int flags);
native void AITrain (int player, int priority, int town, string aliasUnitType, int count);
native void AIResearch (int player, int priority, int town, string aliasUpgradeType);
native void AIMakeAlways (int player, int priority, int town, string aliasType, int count);
native void AIMakeOnce (int player, int priority, int town, string aliasType, int count);


native void AIClearBuildQueue (int player);
native void AIClearTrainQueue (int player);
native void AIClearResearchQueue (int player);


native bool AIHasRes (int player, int minerals, int gas);
native int  AITechCount (int player, string aliasType, int countMask);
native void AITechCountFixupSingle (int player, string baseUnit, string upgradeOne);
native void AITechCountFixupEither (int player, string baseUnit, string upgradeOne, string upgradeTwo);
native void AITechCountFixupInOrder (int player, string baseUnit, string upgradeOne, string upgradeTwo);
native int  AIKnownUnitCount (int player, int testPlayerId, string aliasUnitType);


native void AIResetCounterUnits (int player);
native void AICounterUnit (int player, string seeWhat, fixed factor, string makeWhat);
native int AICounterUnits (int player, int testPlayerId, string makeWhat);


native point AIGetRallyPoint (unit u);


native void AISetPowerBuilding (int player, string building);
native void AISetCreepBuilding (int player, string building, string noCreepBehavior);


//--------------------------------------------------------------------------------------------------
//  Stock
//--------------------------------------------------------------------------------------------------
native void AIClearStock (int player);
native void AIEnableStock (int player);


native void AISetStockEx (int player, int town, int count, string aliasType, int buildFlags, int stockFlags);
native void AISetStock (int player, int count, string aliasType);
native void AISetStockOpt (int player, int count, string aliasType);
native void AISetStockUnitNext (int player, int count, string aliasUnitType, bool when);
native bool AISetStockTown (int player, string aliasUnitTypeTH, string aliasUnitTypeGas);
native bool AISetStockExpand (int player, string aliasUnitTypeTH, int count);
native void AISetStockExtra (int player, int count, string aliasUnitType, int minerals);
native void AISetStockFarms (int player, string aliasUnitType, bool onlyNeeded);
native void AISetStockPeons (int player, int max, string aliasUnitType, bool onlyMinPeons, bool peonMode);


native void AINewTechStock (int player);
native void AITechStockAdd (string upgradeType);
native void AISetStockTechNext (int player);


void AISetStockAlias (int player, int count, string makeType, string aliasType) {
    count = count - AITechCount(player, aliasType, c_techCountQueuedOrBetter);
    if (count > 0) {
        AISetStock(player, count + AITechCount(player, makeType, c_techCountQueuedOrBetter), makeType);
    }
}


void AISetStockFree (int player, int count, string makeType, string prereq) {
    if (AITechCount(player, prereq, c_techCountCompleteOnly) > 0) {
        AISetStock( player, count, makeType );
    }       
}


native void AIDefaultEconomy (int player, string hall, string gas, string food, string peon, int cap, bool peonMode);
native void AIDefaultExpansion (int player, string hall, int minerals, int gas, int expandFlags);


native void AIClearLimitTech (int player);
native void AILimitTech (int player, int totalMin, int totalGas, int buildingMin, int buildingGas, int upgradeMin, int upgradeGas);
native void AIImportantTech (int player, string aliasType);


native void AILimitStockLarva (int player, string aliasType);


native bool AIHasStock (int player);
native bool AIHasStockFromTown (int player, int town);
native void AIRemoveStockFromTown (int player, int town);


//--------------------------------------------------------------------------------------------------
//  AI Requirements
//--------------------------------------------------------------------------------------------------
native int AIDefaultGetObjectType (int player, string aliasType);
native string AIDefaultGetMaker (int player, string aliasType);
native string AIDefaultGetFirstMissingReq (int player, string aliasType);
native string AIDefaultGetFirstUnfinishedReq (int player, string aliasType);
native int AIDefaultGetFullMakeTime (int player, string aliasType);


native string AIGetBaseName (string aliasType);
native string AIGetBuildAtName (string aliasType);


native void AIReqCountAsBuiltObject (int player, string aliasType);
native void AIReqAddSpecialMaker (string objType, string makerType, string abilName, int abilIndex);


//--------------------------------------------------------------------------------------------------
//  Tactical
//--------------------------------------------------------------------------------------------------
native void AIBaseThink (unit who, unitgroup candidates);
native bool AIEvalTacticalData (unit who, string data);


const bool c_castRetreat = true;
const bool c_castHold    = false;
native int AICast (unit u, order o, marker m, bool retreat);
native int AICastFlee (unit who, unit from, int distance, marker mark);


native bool AINearbyUnits (int player, string unitType, point p, fixed range, int requiredCount);
native unitgroup AIFindUnits (int player, string unitType, point p, fixed range, int inMaxCount);
native bool AISameCommand (unit u1, unit u2);


native unit AILastAttacker (unit u);
native int AILastAttack (unit u);


native bool AIControlWantsToMove (unit u);
native bool AIControlForceToMove (unit u);
native bool AIControlWantsToUnburrow (unit u);
native bool AIControlWantsToBurrow (unit u);
native bool AIControlForceUnburrow (unit u);


native bool AIUnitIsInCombat (unit u);


native bool AIIsIgnoredByWave (unit u);
native void AISetIgnoredByWave (unit u, bool enable);


native point AIGetHomePosition (unit u);


native point AIGetCloakedAttacker (int p);
native void AIClearCloakedAttacker (int p, point pt);
native bool AISawCloakedUnit (int p);


native point AIRandomSpawnPoint (
    int player,
    region r,
    fixed minDistFromEnemy,
    fixed maxDistFromEnemy,
    fixed maxDistFromBuilding
);
native point AIBestTargetPoint (
    unitgroup group,
    int minHits,
    int damageBase,
    fixed minScore,
    fixed radius,
    point from,
    fixed range,
    int bonusAttri
);


native unit AIDefaultCombatPriority (unit target, unitgroup attackers, unitgroup enemies);


const int c_cloakMaxRange = 10;
native bool AICloakEvaluate (unit u, fixed minEnergy, fixed maxLife, fixed range);


//--------------------------------------------------------------------------------------------------
//  Combat
//--------------------------------------------------------------------------------------------------
const int c_combatEnable     = 1;
const int c_combatDisable    = 2;
const int c_combatRead       = 3;


void AISetDefaultCombatFlags (int player, bool isMelee);
native bool AICombatTargetProduction        (int player, int action);
native bool AICombatTargetDropOffs          (int player, int action);
native bool AICombatTargetFood              (int player, int action);
native bool AICombatTargetActiveProduction  (int player, int action);
native bool AICombatTargetWorkers           (int player, int action);
native bool AICombatTargetAllyThreats       (int player, int action);
native bool AICombatTargetSelfThreats       (int player, int action);
native bool AICombatTargetCurrent           (int player, int action);
native bool AICombatTargetAir               (int player, int action);
native bool AICombatTargetMovers            (int player, int action);
native bool AICombatTargetInjuries          (int player, int action);
native bool AICombatTargetInAttackRange     (int player, int action);
native bool AICombatTargetThreats           (int player, int action);
native bool AICombatTargetHealers           (int player, int action);
native bool AICombatTargetSiege             (int player, int action);
native bool AICombatTargetAttackers         (int player, int action);
native bool AICombatTargetSpecial           (int player, int action);
native bool AICombatAvoidTimedUnits         (int player, int action);
native bool AICombatAvoidNonThreats         (int player, int action);
native bool AICombatAvoidWeakUnits          (int player, int action);
native bool AICombatAvoidDisabledUnits      (int player, int action);


//--------------------------------------------------------------------------------------------------
//  Transports
//--------------------------------------------------------------------------------------------------
native void AITransportIgnore (int player, string unitType);
native void AITransportSetPanic (int player, fixed value);
native void AITransportSetReturn (int player, point center);


//--------------------------------------------------------------------------------------------------
//  Waves
//--------------------------------------------------------------------------------------------------
native waveinfo AIWaveInfoCreate ();
native waveinfo AIWaveInfo (wave w);


native void AIWaveInfoAdd (waveinfo info, string unitType, int count);
native int AIWaveInfoAttack (waveinfo info, int player, point from, wavetarget target, int time);
native int AIWaveInfoSuicide (waveinfo info, int player, point from, wavetarget target, int time);
native int AIWaveInfoScout (waveinfo info, int player, point from, int time);


native string AIWaveToString (wave w);
native text AIWaveToText (wave w);


native wave AIWaveCreate (waveinfo info, int player, point from);
native void AIWaveAddUnit (wave w, unit u);
native void AIWaveAddUnitPriority (wave w, unit u, int prio);
native void AIWaveRemoveUnit (wave w, unit u);
native int  AIWaveUnitCount (wave w);
native int  AIWaveDetectorCount (wave w);


native void AIWaveSetType (wave w, int type, wavetarget target);


native int AIWaveState (wave w);


native void AIWaveDelete (wave w);


native wavetarget AIWaveTargetUnit (unit u);
native wavetarget AIWaveTargetUnitGroup (unitgroup g);
native wavetarget AIWaveTargetUnitPoint (unit u);
native wavetarget AIWaveTargetPoint (point p);
native wavetarget AIWaveTargetPlayer (playergroup players);
native wavetarget AIWaveTargetMelee (int player);
native wavetarget AIWaveTargetMeleeHarass (int player);
native wavetarget AIWaveTargetMeleeDrop (int player, point dropLoc, point goalLoc);
native wavetarget AIWaveTargetMeleeDefend (int player);
native wavetarget AIWaveTargetMerge (wave w);
native wavetarget AIWaveTargetPatrol (int replaceType);
native wavetarget AIWaveTargetEscort (unitgroup g, int replaceType);
native wavetarget AIWaveTargetEscortNL (unitgroup g, int replaceType);
native wavetarget AIWaveTargetGatherO (int player, int town);
native wavetarget AIWaveTargetGatherD (int player, int town);
native wavetarget AIWaveTargetRegion (region r, int replaceType);


native point AIWaveTargetGatherOPoint (int player, int town);
native point AIWaveTargetGatherDPoint (int player, int town);


native unit         AIWaveTargetGetUnit (wavetarget wt);
native unitgroup    AIWaveTargetGetUnitGroup (wavetarget wt);


native wavetarget AIWaveHarassRetreat (int player, wave w, fixed range);


native wavetarget AIWaveGetTarget (wave w);


native bool AIWaveIsInCombat (wave w);
native int AIWaveGetTimeInCombat (wave w);
native int AIWaveGetTimeSinceCombat (wave w);
native int AIWaveGetTimeSinceOrdered (wave w);


native int AIWaveGetTimeSinceRetreat (wave w);


native bool AIDefenseThreat (int type, int player, wave w);
native int AIDefenseThreatEval (int type, int player);
native int AIWaveEval (wave w);
native int AIWaveEvalRatio (wave w, fixed range);
native int AIUnitAreaEvalRatio (unit u, fixed range);
native int AIEvalRatio (int player);
native void AIEvalSetCustomIndex (int index);
native int AILastWaveEvalStaticRatio ();


native void AIWaveTargetAddWaypoint (wavetarget wt, point waypoint, bool useTransport, int index);
native void AIWaveTargetClearWaypoints (wavetarget wt);


//--- melee games ---
native wave AIWaveGet (int player, int waveName);
native void AIWaveSet (int player, int waveName, wave waveRef);
native int  AIWaveType (wave waveRef);
//native void AIWaveSetUserData (wave waveRef, int index, int data);
//native int  AIWaveGetUserData (wave waveRef, int index);


native void AIWaveMerge (int player, int waveFrom, int waveInto);
native void AIWaveMergeMelee (int player);


native wave WaveLastCreated ();


native point AIGetBestTarget (int player, playergroup enemies, point gatherPoint, int flags);


native bool AIFindDropAttackTarget (int player, point gatherPoint);
native point AILastDropLocation ();
native point AILastDropGoal ();
native fixed AIGetNextDropTimeCheck(int player);
native void AISetNextDropTimeCheck(int player, fixed time);


native int AILastAttackRatio (wave w);
native int AILastAttackStartEval (wave w);


//--------------------------------------------------------------------------------------------------
//  Attack Wave
//--------------------------------------------------------------------------------------------------


// Note: The difficulty parameter is a one-based index into
//       the externalized difficulty levels defined in GameData.xml
//
const int c_difficultyAll = -1; // Add the same count to all difficulty levels


native void AIAttackWaveAddUnits (int difficulty, int count, string unitType);


// External utility function to add four counts to the standard four difficulties
void AIAttackWaveAddUnits4 (int n1, int n2, int n3, int n4, string unitType) {
    AIAttackWaveAddUnits(2, n1, unitType); // Easy
    AIAttackWaveAddUnits(3, n2, unitType); // Normal
    AIAttackWaveAddUnits(4, n3, unitType); // Hard
    AIAttackWaveAddUnits(5, n4, unitType); // Insane
}


// Old external utility function to add three counts to the standard three difficulties
void AIAttackWaveAddUnits3 (int n1, int n2, int n3, string unitType) {
    AIAttackWaveAddUnits4(n1,n2,n3,n3,unitType);
}


native int AIAttackWaveSend (int player, int time, bool wait);


native void AIAttackWaveCancel (wave waveRef);


native void AIAttackWaveSetGatherPoint (int player, point gather);


native void AIAttackWaveUseUnit (int player, unit u);
native void AIAttackWaveUseGroup (int player, unitgroup ug);


native void AIAttackWaveAddEscortUnit (int player, unit u, unit escort, fixed offset, fixed angle);
native void AIAttackWaveAddEscortType (int player, string unitType, unit escort, fixed offset, fixed angle);


native void AIAttackWaveSetTargetUnit (int player, unit u);
native void AIAttackWaveSetTargetUnitGroup (int player, unitgroup ug);
native void AIAttackWaveSetTargetUnitPoint (int player, unit u);
native void AIAttackWaveSetTargetPoint (int player, point p);
native void AIAttackWaveSetTargetPlayer (int player, playergroup players);
native void AIAttackWaveSetTargetMelee (int player);
native void AIAttackWaveSetTargetMeleeHarass (int player);
native void AIAttackWaveSetTargetMeleeDrop (int player, point dropLoc, point goalLoc);
native void AIAttackWaveSetTargetMeleeDefend (int player);
native void AIAttackWaveSetTargetMerge (int player, wave w);
native void AIAttackWaveSetTargetPatrol (int player, int replaceType);
native void AIAttackWaveSetTargetEscort (int player, unitgroup g, int replaceType);
native void AIAttackWaveSetTargetEscortNL (int player, unitgroup g, int replaceType);
native void AIAttackWaveSetTargetGatherO (int player, int town);
native void AIAttackWaveSetTargetGatherD (int player, int town);
native void AIAttackWaveSetTargetRegion (int player, region r, int replaceType);


native void AIAttackWaveSetGatherEarlyNoReplace (int player);
native void AIAttackWaveSetKeepAlive (int player);


native void AIAttackWaveAddWaypoint (int player, point waypoint, bool useTransport);
native void AIAttackWaveClearWaypoints (int player);


//--------------------------------------------------------------------------------------------------
//  Bully Functions
//--------------------------------------------------------------------------------------------------


native void AISetMinimumBullyCount (int count, string unitType, int player);


native void AISetGeneralRebuildCount (int count, bool building, int player);
native void AISetSpecificRebuildCount (int count, string unitType, int player);


native void AISetBullyAttackWavePercent (int percent, int player);
native void AINearestTownLimitWaveGather (int player, bool enable);


native void AINearestTownBullyRebuild (int player, bool enable);


native void AIToggleBulliesInRegion (int player, region reg, bool activate);
native void AIResetBullyRebuildCountsInRegion (int player, region reg);


native void AIClearAllBullies (int player);
native void AIAddBully (int player, string unitType, point loc, int rebuildCount);


native string AIGetBullyType (unit u);

[Heinermann]

Why are these snippets even being posted? Everyone already has them, there's no point.