aiFFA30158.galaxy

//==================================================================================================
// 
// Generated AI Script
// 
// AI Name: P07 Events
// 
//==================================================================================================
include "TriggerLibs/natives"
include "TriggerLibs/AI"
include "TriggerLibs/Computer"

//--------------------------------------------------------------------------------------------------
// Globals
//--------------------------------------------------------------------------------------------------
point[17] aiFFA30158_defGather;
string[17] aiFFA30158_customData;
wave[17] aiFFA30158_lastWave;

//--------------------------------------------------------------------------------------------------
// Attack Wave: Attack Waves Warning
//--------------------------------------------------------------------------------------------------
bool[17] aiFFA30158_wave7_enabled;
wave[17] aiFFA30158_wave7_lastWave;
trigger aiFFA30158_wave7_trigger = null;
int aiFFA30158_wave7_runPlayer;
playergroup aiFFA30158_wave7_runTarget;

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave7_init () {
    int init_i;

    for (init_i = 0; init_i <= 16; init_i += 1) {
        aiFFA30158_wave7_enabled[init_i] = true;
        aiFFA30158_wave7_lastWave[init_i] = null;
    }

    aiFFA30158_wave7_trigger = TriggerCreate("aiFFA30158_wave7_runFunc");
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave7_enable (int p, bool val) {
    if (p < 0 || p >= 16) {
        return;
    }
    aiFFA30158_wave7_enabled[p] = val;
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave7_isEnabled (int p) {
    if (p < 0 || p >= 16) {
        return false;
    }
    return aiFFA30158_wave7_enabled[p];
}

//--------------------------------------------------------------------------------------------------
wave aiFFA30158_wave7_createdWave (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return aiFFA30158_wave7_lastWave[p];
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave7_runFunc (bool c, bool a) {
    int p = aiFFA30158_wave7_runPlayer;
    playergroup target = aiFFA30158_wave7_runTarget;
    int d;
    point gatherPoint = null;
    int ta = 0;
    int tg = 0;
    int ts = 0;
    int tf = 0;
    int td = 0;

    if (p < 0 || p >= 16) {
        return false;
    }
    d = PlayerDifficulty(p);
    if (!aiFFA30158_wave7_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    aiFFA30158_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 195; }
    if (d == 2) { ta = 195; }
    if (d == 3) { ta = 195; }
    if (d == 4) { ta = 195; }
    tg = 0;
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    AIAttackWaveSetTargetPlayer(p, target);

    gatherPoint = aiFFA30158_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    Wait(ts, c_timeAI);
    TriggerExecute(TriggerFind("gt_TransmissionDominionAttackWavesOnlineQ_Func"), true, false);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave7_run (int p, playergroup target, bool wait) {
    aiFFA30158_wave7_runPlayer = p;
    aiFFA30158_wave7_runTarget = PlayerGroupCopy(target);

    TriggerExecute(aiFFA30158_wave7_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Hybrid 02 Release A
//--------------------------------------------------------------------------------------------------
bool[17] aiFFA30158_wave3_enabled;
wave[17] aiFFA30158_wave3_lastWave;
trigger aiFFA30158_wave3_trigger = null;
int aiFFA30158_wave3_runPlayer;
playergroup aiFFA30158_wave3_runTarget;

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave3_init () {
    int init_i;

    for (init_i = 0; init_i <= 16; init_i += 1) {
        aiFFA30158_wave3_enabled[init_i] = true;
        aiFFA30158_wave3_lastWave[init_i] = null;
    }

    aiFFA30158_wave3_trigger = TriggerCreate("aiFFA30158_wave3_runFunc");
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave3_enable (int p, bool val) {
    if (p < 0 || p >= 16) {
        return;
    }
    aiFFA30158_wave3_enabled[p] = val;
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave3_isEnabled (int p) {
    if (p < 0 || p >= 16) {
        return false;
    }
    return aiFFA30158_wave3_enabled[p];
}

//--------------------------------------------------------------------------------------------------
wave aiFFA30158_wave3_createdWave (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return aiFFA30158_wave3_lastWave[p];
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave3_runFunc (bool c, bool a) {
    int p = aiFFA30158_wave3_runPlayer;
    playergroup target = aiFFA30158_wave3_runTarget;
    int d;
    point gatherPoint = null;
    int ta = 0;
    int tg = 0;
    int ts = 0;
    int tf = 0;
    int td = 0;

    if (p < 0 || p >= 16) {
        return false;
    }
    d = PlayerDifficulty(p);
    if (!aiFFA30158_wave3_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    aiFFA30158_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 50; }
    if (d == 2) { ta = 50; }
    if (d == 3) { ta = 50; }
    if (d == 4) { ta = 50; }
    tg = 0;
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    AIAttackWaveSetTargetPlayer(p, target);

    gatherPoint = aiFFA30158_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave3_run (int p, playergroup target, bool wait) {
    aiFFA30158_wave3_runPlayer = p;
    aiFFA30158_wave3_runTarget = PlayerGroupCopy(target);

    TriggerExecute(aiFFA30158_wave3_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Hybrid 02 Release B
//--------------------------------------------------------------------------------------------------
bool[17] aiFFA30158_wave1_enabled;
wave[17] aiFFA30158_wave1_lastWave;
trigger aiFFA30158_wave1_trigger = null;
int aiFFA30158_wave1_runPlayer;
playergroup aiFFA30158_wave1_runTarget;

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave1_init () {
    int init_i;

    for (init_i = 0; init_i <= 16; init_i += 1) {
        aiFFA30158_wave1_enabled[init_i] = true;
        aiFFA30158_wave1_lastWave[init_i] = null;
    }

    aiFFA30158_wave1_trigger = TriggerCreate("aiFFA30158_wave1_runFunc");
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave1_enable (int p, bool val) {
    if (p < 0 || p >= 16) {
        return;
    }
    aiFFA30158_wave1_enabled[p] = val;
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave1_isEnabled (int p) {
    if (p < 0 || p >= 16) {
        return false;
    }
    return aiFFA30158_wave1_enabled[p];
}

//--------------------------------------------------------------------------------------------------
wave aiFFA30158_wave1_createdWave (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return aiFFA30158_wave1_lastWave[p];
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave1_runFunc (bool c, bool a) {
    int p = aiFFA30158_wave1_runPlayer;
    playergroup target = aiFFA30158_wave1_runTarget;
    int d;
    point gatherPoint = null;
    int ta = 0;
    int tg = 0;
    int ts = 0;
    int tf = 0;
    int td = 0;

    if (p < 0 || p >= 16) {
        return false;
    }
    d = PlayerDifficulty(p);
    if (!aiFFA30158_wave1_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    aiFFA30158_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 60; }
    if (d == 2) { ta = 60; }
    if (d == 3) { ta = 60; }
    if (d == 4) { ta = 60; }
    tg = 0;
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    AIAttackWaveSetTargetPlayer(p, target);

    gatherPoint = aiFFA30158_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave1_run (int p, playergroup target, bool wait) {
    aiFFA30158_wave1_runPlayer = p;
    aiFFA30158_wave1_runTarget = PlayerGroupCopy(target);

    TriggerExecute(aiFFA30158_wave1_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Show Bonus Objective
//--------------------------------------------------------------------------------------------------
bool[17] aiFFA30158_wave2_enabled;
wave[17] aiFFA30158_wave2_lastWave;
trigger aiFFA30158_wave2_trigger = null;
int aiFFA30158_wave2_runPlayer;
playergroup aiFFA30158_wave2_runTarget;

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave2_init () {
    int init_i;

    for (init_i = 0; init_i <= 16; init_i += 1) {
        aiFFA30158_wave2_enabled[init_i] = true;
        aiFFA30158_wave2_lastWave[init_i] = null;
    }

    aiFFA30158_wave2_trigger = TriggerCreate("aiFFA30158_wave2_runFunc");
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave2_enable (int p, bool val) {
    if (p < 0 || p >= 16) {
        return;
    }
    aiFFA30158_wave2_enabled[p] = val;
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave2_isEnabled (int p) {
    if (p < 0 || p >= 16) {
        return false;
    }
    return aiFFA30158_wave2_enabled[p];
}

//--------------------------------------------------------------------------------------------------
wave aiFFA30158_wave2_createdWave (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return aiFFA30158_wave2_lastWave[p];
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave2_runFunc (bool c, bool a) {
    int p = aiFFA30158_wave2_runPlayer;
    playergroup target = aiFFA30158_wave2_runTarget;
    int d;
    point gatherPoint = null;
    int ta = 0;
    int tg = 0;
    int ts = 0;
    int tf = 0;
    int td = 0;

    if (p < 0 || p >= 16) {
        return false;
    }
    d = PlayerDifficulty(p);
    if (!aiFFA30158_wave2_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    aiFFA30158_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 150; }
    if (d == 2) { ta = 150; }
    if (d == 3) { ta = 150; }
    if (d == 4) { ta = 150; }
    tg = 0;
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    AIAttackWaveSetTargetPlayer(p, target);

    gatherPoint = aiFFA30158_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    Wait(ts, c_timeAI);
    TriggerExecute(TriggerFind("gt_IntroBrutaliskObjective_Func"), true, false);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave2_run (int p, playergroup target, bool wait) {
    aiFFA30158_wave2_runPlayer = p;
    aiFFA30158_wave2_runTarget = PlayerGroupCopy(target);

    TriggerExecute(aiFFA30158_wave2_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Hybrid 03 Release A
//--------------------------------------------------------------------------------------------------
bool[17] aiFFA30158_wave4_enabled;
wave[17] aiFFA30158_wave4_lastWave;
trigger aiFFA30158_wave4_trigger = null;
int aiFFA30158_wave4_runPlayer;
playergroup aiFFA30158_wave4_runTarget;

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave4_init () {
    int init_i;

    for (init_i = 0; init_i <= 16; init_i += 1) {
        aiFFA30158_wave4_enabled[init_i] = true;
        aiFFA30158_wave4_lastWave[init_i] = null;
    }

    aiFFA30158_wave4_trigger = TriggerCreate("aiFFA30158_wave4_runFunc");
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave4_enable (int p, bool val) {
    if (p < 0 || p >= 16) {
        return;
    }
    aiFFA30158_wave4_enabled[p] = val;
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave4_isEnabled (int p) {
    if (p < 0 || p >= 16) {
        return false;
    }
    return aiFFA30158_wave4_enabled[p];
}

//--------------------------------------------------------------------------------------------------
wave aiFFA30158_wave4_createdWave (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return aiFFA30158_wave4_lastWave[p];
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave4_runFunc (bool c, bool a) {
    int p = aiFFA30158_wave4_runPlayer;
    playergroup target = aiFFA30158_wave4_runTarget;
    int d;
    point gatherPoint = null;
    int ta = 0;
    int tg = 0;
    int ts = 0;
    int tf = 0;
    int td = 0;

    if (p < 0 || p >= 16) {
        return false;
    }
    d = PlayerDifficulty(p);
    if (!aiFFA30158_wave4_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    aiFFA30158_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 35; }
    if (d == 2) { ta = 35; }
    if (d == 3) { ta = 35; }
    if (d == 4) { ta = 35; }
    tg = 0;
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    AIAttackWaveSetTargetPlayer(p, target);

    gatherPoint = aiFFA30158_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave4_run (int p, playergroup target, bool wait) {
    aiFFA30158_wave4_runPlayer = p;
    aiFFA30158_wave4_runTarget = PlayerGroupCopy(target);

    TriggerExecute(aiFFA30158_wave4_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Hybrid 03 Release B
//--------------------------------------------------------------------------------------------------
bool[17] aiFFA30158_wave12_enabled;
wave[17] aiFFA30158_wave12_lastWave;
trigger aiFFA30158_wave12_trigger = null;
int aiFFA30158_wave12_runPlayer;
playergroup aiFFA30158_wave12_runTarget;

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave12_init () {
    int init_i;

    for (init_i = 0; init_i <= 16; init_i += 1) {
        aiFFA30158_wave12_enabled[init_i] = true;
        aiFFA30158_wave12_lastWave[init_i] = null;
    }

    aiFFA30158_wave12_trigger = TriggerCreate("aiFFA30158_wave12_runFunc");
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave12_enable (int p, bool val) {
    if (p < 0 || p >= 16) {
        return;
    }
    aiFFA30158_wave12_enabled[p] = val;
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave12_isEnabled (int p) {
    if (p < 0 || p >= 16) {
        return false;
    }
    return aiFFA30158_wave12_enabled[p];
}

//--------------------------------------------------------------------------------------------------
wave aiFFA30158_wave12_createdWave (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return aiFFA30158_wave12_lastWave[p];
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave12_runFunc (bool c, bool a) {
    int p = aiFFA30158_wave12_runPlayer;
    playergroup target = aiFFA30158_wave12_runTarget;
    int d;
    point gatherPoint = null;
    int ta = 0;
    int tg = 0;
    int ts = 0;
    int tf = 0;
    int td = 0;

    if (p < 0 || p >= 16) {
        return false;
    }
    d = PlayerDifficulty(p);
    if (!aiFFA30158_wave12_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    aiFFA30158_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 60; }
    if (d == 2) { ta = 60; }
    if (d == 3) { ta = 60; }
    if (d == 4) { ta = 60; }
    tg = 0;
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    AIAttackWaveSetTargetPlayer(p, target);

    gatherPoint = aiFFA30158_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave12_run (int p, playergroup target, bool wait) {
    aiFFA30158_wave12_runPlayer = p;
    aiFFA30158_wave12_runTarget = PlayerGroupCopy(target);

    TriggerExecute(aiFFA30158_wave12_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Hybrid 03 Release C
//--------------------------------------------------------------------------------------------------
bool[17] aiFFA30158_wave13_enabled;
wave[17] aiFFA30158_wave13_lastWave;
trigger aiFFA30158_wave13_trigger = null;
int aiFFA30158_wave13_runPlayer;
playergroup aiFFA30158_wave13_runTarget;

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave13_init () {
    int init_i;

    for (init_i = 0; init_i <= 16; init_i += 1) {
        aiFFA30158_wave13_enabled[init_i] = true;
        aiFFA30158_wave13_lastWave[init_i] = null;
    }

    aiFFA30158_wave13_trigger = TriggerCreate("aiFFA30158_wave13_runFunc");
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave13_enable (int p, bool val) {
    if (p < 0 || p >= 16) {
        return;
    }
    aiFFA30158_wave13_enabled[p] = val;
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave13_isEnabled (int p) {
    if (p < 0 || p >= 16) {
        return false;
    }
    return aiFFA30158_wave13_enabled[p];
}

//--------------------------------------------------------------------------------------------------
wave aiFFA30158_wave13_createdWave (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return aiFFA30158_wave13_lastWave[p];
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave13_runFunc (bool c, bool a) {
    int p = aiFFA30158_wave13_runPlayer;
    playergroup target = aiFFA30158_wave13_runTarget;
    int d;
    point gatherPoint = null;
    int ta = 0;
    int tg = 0;
    int ts = 0;
    int tf = 0;
    int td = 0;

    if (p < 0 || p >= 16) {
        return false;
    }
    d = PlayerDifficulty(p);
    if (!aiFFA30158_wave13_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    aiFFA30158_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 60; }
    if (d == 2) { ta = 60; }
    if (d == 3) { ta = 60; }
    if (d == 4) { ta = 60; }
    tg = 0;
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    AIAttackWaveSetTargetPlayer(p, target);

    gatherPoint = aiFFA30158_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave13_run (int p, playergroup target, bool wait) {
    aiFFA30158_wave13_runPlayer = p;
    aiFFA30158_wave13_runTarget = PlayerGroupCopy(target);

    TriggerExecute(aiFFA30158_wave13_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Hybrid 04 Release A
//--------------------------------------------------------------------------------------------------
bool[17] aiFFA30158_wave5_enabled;
wave[17] aiFFA30158_wave5_lastWave;
trigger aiFFA30158_wave5_trigger = null;
int aiFFA30158_wave5_runPlayer;
playergroup aiFFA30158_wave5_runTarget;

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave5_init () {
    int init_i;

    for (init_i = 0; init_i <= 16; init_i += 1) {
        aiFFA30158_wave5_enabled[init_i] = true;
        aiFFA30158_wave5_lastWave[init_i] = null;
    }

    aiFFA30158_wave5_trigger = TriggerCreate("aiFFA30158_wave5_runFunc");
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave5_enable (int p, bool val) {
    if (p < 0 || p >= 16) {
        return;
    }
    aiFFA30158_wave5_enabled[p] = val;
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave5_isEnabled (int p) {
    if (p < 0 || p >= 16) {
        return false;
    }
    return aiFFA30158_wave5_enabled[p];
}

//--------------------------------------------------------------------------------------------------
wave aiFFA30158_wave5_createdWave (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return aiFFA30158_wave5_lastWave[p];
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave5_runFunc (bool c, bool a) {
    int p = aiFFA30158_wave5_runPlayer;
    playergroup target = aiFFA30158_wave5_runTarget;
    int d;
    point gatherPoint = null;
    int ta = 0;
    int tg = 0;
    int ts = 0;
    int tf = 0;
    int td = 0;

    if (p < 0 || p >= 16) {
        return false;
    }
    d = PlayerDifficulty(p);
    if (!aiFFA30158_wave5_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    aiFFA30158_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 125; }
    if (d == 2) { ta = 125; }
    if (d == 3) { ta = 125; }
    if (d == 4) { ta = 125; }
    tg = 0;
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    AIAttackWaveSetTargetPlayer(p, target);

    gatherPoint = aiFFA30158_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave5_run (int p, playergroup target, bool wait) {
    aiFFA30158_wave5_runPlayer = p;
    aiFFA30158_wave5_runTarget = PlayerGroupCopy(target);

    TriggerExecute(aiFFA30158_wave5_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Hybrid 04 Release B
//--------------------------------------------------------------------------------------------------
bool[17] aiFFA30158_wave14_enabled;
wave[17] aiFFA30158_wave14_lastWave;
trigger aiFFA30158_wave14_trigger = null;
int aiFFA30158_wave14_runPlayer;
playergroup aiFFA30158_wave14_runTarget;

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave14_init () {
    int init_i;

    for (init_i = 0; init_i <= 16; init_i += 1) {
        aiFFA30158_wave14_enabled[init_i] = true;
        aiFFA30158_wave14_lastWave[init_i] = null;
    }

    aiFFA30158_wave14_trigger = TriggerCreate("aiFFA30158_wave14_runFunc");
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave14_enable (int p, bool val) {
    if (p < 0 || p >= 16) {
        return;
    }
    aiFFA30158_wave14_enabled[p] = val;
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave14_isEnabled (int p) {
    if (p < 0 || p >= 16) {
        return false;
    }
    return aiFFA30158_wave14_enabled[p];
}

//--------------------------------------------------------------------------------------------------
wave aiFFA30158_wave14_createdWave (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return aiFFA30158_wave14_lastWave[p];
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave14_runFunc (bool c, bool a) {
    int p = aiFFA30158_wave14_runPlayer;
    playergroup target = aiFFA30158_wave14_runTarget;
    int d;
    point gatherPoint = null;
    int ta = 0;
    int tg = 0;
    int ts = 0;
    int tf = 0;
    int td = 0;

    if (p < 0 || p >= 16) {
        return false;
    }
    d = PlayerDifficulty(p);
    if (!aiFFA30158_wave14_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    aiFFA30158_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 60; }
    if (d == 2) { ta = 60; }
    if (d == 3) { ta = 60; }
    if (d == 4) { ta = 60; }
    tg = 0;
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    AIAttackWaveSetTargetPlayer(p, target);

    gatherPoint = aiFFA30158_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave14_run (int p, playergroup target, bool wait) {
    aiFFA30158_wave14_runPlayer = p;
    aiFFA30158_wave14_runTarget = PlayerGroupCopy(target);

    TriggerExecute(aiFFA30158_wave14_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Hybrid 04 Release C
//--------------------------------------------------------------------------------------------------
bool[17] aiFFA30158_wave15_enabled;
wave[17] aiFFA30158_wave15_lastWave;
trigger aiFFA30158_wave15_trigger = null;
int aiFFA30158_wave15_runPlayer;
playergroup aiFFA30158_wave15_runTarget;

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave15_init () {
    int init_i;

    for (init_i = 0; init_i <= 16; init_i += 1) {
        aiFFA30158_wave15_enabled[init_i] = true;
        aiFFA30158_wave15_lastWave[init_i] = null;
    }

    aiFFA30158_wave15_trigger = TriggerCreate("aiFFA30158_wave15_runFunc");
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave15_enable (int p, bool val) {
    if (p < 0 || p >= 16) {
        return;
    }
    aiFFA30158_wave15_enabled[p] = val;
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave15_isEnabled (int p) {
    if (p < 0 || p >= 16) {
        return false;
    }
    return aiFFA30158_wave15_enabled[p];
}

//--------------------------------------------------------------------------------------------------
wave aiFFA30158_wave15_createdWave (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return aiFFA30158_wave15_lastWave[p];
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave15_runFunc (bool c, bool a) {
    int p = aiFFA30158_wave15_runPlayer;
    playergroup target = aiFFA30158_wave15_runTarget;
    int d;
    point gatherPoint = null;
    int ta = 0;
    int tg = 0;
    int ts = 0;
    int tf = 0;
    int td = 0;

    if (p < 0 || p >= 16) {
        return false;
    }
    d = PlayerDifficulty(p);
    if (!aiFFA30158_wave15_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    aiFFA30158_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 60; }
    if (d == 2) { ta = 60; }
    if (d == 3) { ta = 60; }
    if (d == 4) { ta = 60; }
    tg = 0;
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    AIAttackWaveSetTargetPlayer(p, target);

    gatherPoint = aiFFA30158_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave15_run (int p, playergroup target, bool wait) {
    aiFFA30158_wave15_runPlayer = p;
    aiFFA30158_wave15_runTarget = PlayerGroupCopy(target);

    TriggerExecute(aiFFA30158_wave15_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Hybrid 04 Release D
//--------------------------------------------------------------------------------------------------
bool[17] aiFFA30158_wave16_enabled;
wave[17] aiFFA30158_wave16_lastWave;
trigger aiFFA30158_wave16_trigger = null;
int aiFFA30158_wave16_runPlayer;
playergroup aiFFA30158_wave16_runTarget;

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave16_init () {
    int init_i;

    for (init_i = 0; init_i <= 16; init_i += 1) {
        aiFFA30158_wave16_enabled[init_i] = true;
        aiFFA30158_wave16_lastWave[init_i] = null;
    }

    aiFFA30158_wave16_trigger = TriggerCreate("aiFFA30158_wave16_runFunc");
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave16_enable (int p, bool val) {
    if (p < 0 || p >= 16) {
        return;
    }
    aiFFA30158_wave16_enabled[p] = val;
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave16_isEnabled (int p) {
    if (p < 0 || p >= 16) {
        return false;
    }
    return aiFFA30158_wave16_enabled[p];
}

//--------------------------------------------------------------------------------------------------
wave aiFFA30158_wave16_createdWave (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return aiFFA30158_wave16_lastWave[p];
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave16_runFunc (bool c, bool a) {
    int p = aiFFA30158_wave16_runPlayer;
    playergroup target = aiFFA30158_wave16_runTarget;
    int d;
    point gatherPoint = null;
    int ta = 0;
    int tg = 0;
    int ts = 0;
    int tf = 0;
    int td = 0;

    if (p < 0 || p >= 16) {
        return false;
    }
    d = PlayerDifficulty(p);
    if (!aiFFA30158_wave16_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    aiFFA30158_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 60; }
    if (d == 2) { ta = 60; }
    if (d == 3) { ta = 60; }
    if (d == 4) { ta = 60; }
    tg = 0;
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    AIAttackWaveSetTargetPlayer(p, target);

    gatherPoint = aiFFA30158_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave16_run (int p, playergroup target, bool wait) {
    aiFFA30158_wave16_runPlayer = p;
    aiFFA30158_wave16_runTarget = PlayerGroupCopy(target);

    TriggerExecute(aiFFA30158_wave16_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Hybrid 05 Release A
//--------------------------------------------------------------------------------------------------
bool[17] aiFFA30158_wave17_enabled;
wave[17] aiFFA30158_wave17_lastWave;
trigger aiFFA30158_wave17_trigger = null;
int aiFFA30158_wave17_runPlayer;
playergroup aiFFA30158_wave17_runTarget;

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave17_init () {
    int init_i;

    for (init_i = 0; init_i <= 16; init_i += 1) {
        aiFFA30158_wave17_enabled[init_i] = true;
        aiFFA30158_wave17_lastWave[init_i] = null;
    }

    aiFFA30158_wave17_trigger = TriggerCreate("aiFFA30158_wave17_runFunc");
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave17_enable (int p, bool val) {
    if (p < 0 || p >= 16) {
        return;
    }
    aiFFA30158_wave17_enabled[p] = val;
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave17_isEnabled (int p) {
    if (p < 0 || p >= 16) {
        return false;
    }
    return aiFFA30158_wave17_enabled[p];
}

//--------------------------------------------------------------------------------------------------
wave aiFFA30158_wave17_createdWave (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return aiFFA30158_wave17_lastWave[p];
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave17_runFunc (bool c, bool a) {
    int p = aiFFA30158_wave17_runPlayer;
    playergroup target = aiFFA30158_wave17_runTarget;
    int d;
    point gatherPoint = null;
    int ta = 0;
    int tg = 0;
    int ts = 0;
    int tf = 0;
    int td = 0;

    if (p < 0 || p >= 16) {
        return false;
    }
    d = PlayerDifficulty(p);
    if (!aiFFA30158_wave17_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    aiFFA30158_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 60; }
    if (d == 2) { ta = 60; }
    if (d == 3) { ta = 60; }
    if (d == 4) { ta = 60; }
    tg = 0;
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    AIAttackWaveSetTargetPlayer(p, target);

    gatherPoint = aiFFA30158_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave17_run (int p, playergroup target, bool wait) {
    aiFFA30158_wave17_runPlayer = p;
    aiFFA30158_wave17_runTarget = PlayerGroupCopy(target);

    TriggerExecute(aiFFA30158_wave17_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Hybrid 05 Release B
//--------------------------------------------------------------------------------------------------
bool[17] aiFFA30158_wave8_enabled;
wave[17] aiFFA30158_wave8_lastWave;
trigger aiFFA30158_wave8_trigger = null;
int aiFFA30158_wave8_runPlayer;
playergroup aiFFA30158_wave8_runTarget;

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave8_init () {
    int init_i;

    for (init_i = 0; init_i <= 16; init_i += 1) {
        aiFFA30158_wave8_enabled[init_i] = true;
        aiFFA30158_wave8_lastWave[init_i] = null;
    }

    aiFFA30158_wave8_trigger = TriggerCreate("aiFFA30158_wave8_runFunc");
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave8_enable (int p, bool val) {
    if (p < 0 || p >= 16) {
        return;
    }
    aiFFA30158_wave8_enabled[p] = val;
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave8_isEnabled (int p) {
    if (p < 0 || p >= 16) {
        return false;
    }
    return aiFFA30158_wave8_enabled[p];
}

//--------------------------------------------------------------------------------------------------
wave aiFFA30158_wave8_createdWave (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return aiFFA30158_wave8_lastWave[p];
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave8_runFunc (bool c, bool a) {
    int p = aiFFA30158_wave8_runPlayer;
    playergroup target = aiFFA30158_wave8_runTarget;
    int d;
    point gatherPoint = null;
    int ta = 0;
    int tg = 0;
    int ts = 0;
    int tf = 0;
    int td = 0;

    if (p < 0 || p >= 16) {
        return false;
    }
    d = PlayerDifficulty(p);
    if (!aiFFA30158_wave8_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    aiFFA30158_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 60; }
    if (d == 2) { ta = 60; }
    if (d == 3) { ta = 60; }
    if (d == 4) { ta = 60; }
    tg = 0;
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    AIAttackWaveSetTargetPlayer(p, target);

    gatherPoint = aiFFA30158_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave8_run (int p, playergroup target, bool wait) {
    aiFFA30158_wave8_runPlayer = p;
    aiFFA30158_wave8_runTarget = PlayerGroupCopy(target);

    TriggerExecute(aiFFA30158_wave8_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Hybrid 05 Release C
//--------------------------------------------------------------------------------------------------
bool[17] aiFFA30158_wave18_enabled;
wave[17] aiFFA30158_wave18_lastWave;
trigger aiFFA30158_wave18_trigger = null;
int aiFFA30158_wave18_runPlayer;
playergroup aiFFA30158_wave18_runTarget;

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave18_init () {
    int init_i;

    for (init_i = 0; init_i <= 16; init_i += 1) {
        aiFFA30158_wave18_enabled[init_i] = true;
        aiFFA30158_wave18_lastWave[init_i] = null;
    }

    aiFFA30158_wave18_trigger = TriggerCreate("aiFFA30158_wave18_runFunc");
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave18_enable (int p, bool val) {
    if (p < 0 || p >= 16) {
        return;
    }
    aiFFA30158_wave18_enabled[p] = val;
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave18_isEnabled (int p) {
    if (p < 0 || p >= 16) {
        return false;
    }
    return aiFFA30158_wave18_enabled[p];
}

//--------------------------------------------------------------------------------------------------
wave aiFFA30158_wave18_createdWave (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return aiFFA30158_wave18_lastWave[p];
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave18_runFunc (bool c, bool a) {
    int p = aiFFA30158_wave18_runPlayer;
    playergroup target = aiFFA30158_wave18_runTarget;
    int d;
    point gatherPoint = null;
    int ta = 0;
    int tg = 0;
    int ts = 0;
    int tf = 0;
    int td = 0;

    if (p < 0 || p >= 16) {
        return false;
    }
    d = PlayerDifficulty(p);
    if (!aiFFA30158_wave18_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    aiFFA30158_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 60; }
    if (d == 2) { ta = 60; }
    if (d == 3) { ta = 60; }
    if (d == 4) { ta = 60; }
    tg = 0;
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    AIAttackWaveSetTargetPlayer(p, target);

    gatherPoint = aiFFA30158_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave18_run (int p, playergroup target, bool wait) {
    aiFFA30158_wave18_runPlayer = p;
    aiFFA30158_wave18_runTarget = PlayerGroupCopy(target);

    TriggerExecute(aiFFA30158_wave18_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Hybrid 05 Release D
//--------------------------------------------------------------------------------------------------
bool[17] aiFFA30158_wave19_enabled;
wave[17] aiFFA30158_wave19_lastWave;
trigger aiFFA30158_wave19_trigger = null;
int aiFFA30158_wave19_runPlayer;
playergroup aiFFA30158_wave19_runTarget;

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave19_init () {
    int init_i;

    for (init_i = 0; init_i <= 16; init_i += 1) {
        aiFFA30158_wave19_enabled[init_i] = true;
        aiFFA30158_wave19_lastWave[init_i] = null;
    }

    aiFFA30158_wave19_trigger = TriggerCreate("aiFFA30158_wave19_runFunc");
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave19_enable (int p, bool val) {
    if (p < 0 || p >= 16) {
        return;
    }
    aiFFA30158_wave19_enabled[p] = val;
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave19_isEnabled (int p) {
    if (p < 0 || p >= 16) {
        return false;
    }
    return aiFFA30158_wave19_enabled[p];
}

//--------------------------------------------------------------------------------------------------
wave aiFFA30158_wave19_createdWave (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return aiFFA30158_wave19_lastWave[p];
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave19_runFunc (bool c, bool a) {
    int p = aiFFA30158_wave19_runPlayer;
    playergroup target = aiFFA30158_wave19_runTarget;
    int d;
    point gatherPoint = null;
    int ta = 0;
    int tg = 0;
    int ts = 0;
    int tf = 0;
    int td = 0;

    if (p < 0 || p >= 16) {
        return false;
    }
    d = PlayerDifficulty(p);
    if (!aiFFA30158_wave19_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    aiFFA30158_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 60; }
    if (d == 2) { ta = 60; }
    if (d == 3) { ta = 60; }
    if (d == 4) { ta = 60; }
    tg = 0;
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    AIAttackWaveSetTargetPlayer(p, target);

    gatherPoint = aiFFA30158_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave19_run (int p, playergroup target, bool wait) {
    aiFFA30158_wave19_runPlayer = p;
    aiFFA30158_wave19_runTarget = PlayerGroupCopy(target);

    TriggerExecute(aiFFA30158_wave19_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Hybrid 05 E/Hybrid 06 A
//--------------------------------------------------------------------------------------------------
bool[17] aiFFA30158_wave20_enabled;
wave[17] aiFFA30158_wave20_lastWave;
trigger aiFFA30158_wave20_trigger = null;
int aiFFA30158_wave20_runPlayer;
playergroup aiFFA30158_wave20_runTarget;

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave20_init () {
    int init_i;

    for (init_i = 0; init_i <= 16; init_i += 1) {
        aiFFA30158_wave20_enabled[init_i] = true;
        aiFFA30158_wave20_lastWave[init_i] = null;
    }

    aiFFA30158_wave20_trigger = TriggerCreate("aiFFA30158_wave20_runFunc");
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave20_enable (int p, bool val) {
    if (p < 0 || p >= 16) {
        return;
    }
    aiFFA30158_wave20_enabled[p] = val;
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave20_isEnabled (int p) {
    if (p < 0 || p >= 16) {
        return false;
    }
    return aiFFA30158_wave20_enabled[p];
}

//--------------------------------------------------------------------------------------------------
wave aiFFA30158_wave20_createdWave (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return aiFFA30158_wave20_lastWave[p];
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave20_runFunc (bool c, bool a) {
    int p = aiFFA30158_wave20_runPlayer;
    playergroup target = aiFFA30158_wave20_runTarget;
    int d;
    point gatherPoint = null;
    int ta = 0;
    int tg = 0;
    int ts = 0;
    int tf = 0;
    int td = 0;

    if (p < 0 || p >= 16) {
        return false;
    }
    d = PlayerDifficulty(p);
    if (!aiFFA30158_wave20_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    aiFFA30158_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 60; }
    if (d == 2) { ta = 60; }
    if (d == 3) { ta = 60; }
    if (d == 4) { ta = 60; }
    tg = 0;
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    AIAttackWaveSetTargetPlayer(p, target);

    gatherPoint = aiFFA30158_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave20_run (int p, playergroup target, bool wait) {
    aiFFA30158_wave20_runPlayer = p;
    aiFFA30158_wave20_runTarget = PlayerGroupCopy(target);

    TriggerExecute(aiFFA30158_wave20_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Hybrid 06 B
//--------------------------------------------------------------------------------------------------
bool[17] aiFFA30158_wave21_enabled;
wave[17] aiFFA30158_wave21_lastWave;
trigger aiFFA30158_wave21_trigger = null;
int aiFFA30158_wave21_runPlayer;
playergroup aiFFA30158_wave21_runTarget;

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave21_init () {
    int init_i;

    for (init_i = 0; init_i <= 16; init_i += 1) {
        aiFFA30158_wave21_enabled[init_i] = true;
        aiFFA30158_wave21_lastWave[init_i] = null;
    }

    aiFFA30158_wave21_trigger = TriggerCreate("aiFFA30158_wave21_runFunc");
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave21_enable (int p, bool val) {
    if (p < 0 || p >= 16) {
        return;
    }
    aiFFA30158_wave21_enabled[p] = val;
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave21_isEnabled (int p) {
    if (p < 0 || p >= 16) {
        return false;
    }
    return aiFFA30158_wave21_enabled[p];
}

//--------------------------------------------------------------------------------------------------
wave aiFFA30158_wave21_createdWave (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return aiFFA30158_wave21_lastWave[p];
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave21_runFunc (bool c, bool a) {
    int p = aiFFA30158_wave21_runPlayer;
    playergroup target = aiFFA30158_wave21_runTarget;
    int d;
    point gatherPoint = null;
    int ta = 0;
    int tg = 0;
    int ts = 0;
    int tf = 0;
    int td = 0;

    if (p < 0 || p >= 16) {
        return false;
    }
    d = PlayerDifficulty(p);
    if (!aiFFA30158_wave21_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    aiFFA30158_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 60; }
    if (d == 2) { ta = 60; }
    if (d == 3) { ta = 60; }
    if (d == 4) { ta = 60; }
    tg = 0;
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    AIAttackWaveSetTargetPlayer(p, target);

    gatherPoint = aiFFA30158_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave21_run (int p, playergroup target, bool wait) {
    aiFFA30158_wave21_runPlayer = p;
    aiFFA30158_wave21_runTarget = PlayerGroupCopy(target);

    TriggerExecute(aiFFA30158_wave21_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Hybrid 06 C
//--------------------------------------------------------------------------------------------------
bool[17] aiFFA30158_wave22_enabled;
wave[17] aiFFA30158_wave22_lastWave;
trigger aiFFA30158_wave22_trigger = null;
int aiFFA30158_wave22_runPlayer;
playergroup aiFFA30158_wave22_runTarget;

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave22_init () {
    int init_i;

    for (init_i = 0; init_i <= 16; init_i += 1) {
        aiFFA30158_wave22_enabled[init_i] = true;
        aiFFA30158_wave22_lastWave[init_i] = null;
    }

    aiFFA30158_wave22_trigger = TriggerCreate("aiFFA30158_wave22_runFunc");
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave22_enable (int p, bool val) {
    if (p < 0 || p >= 16) {
        return;
    }
    aiFFA30158_wave22_enabled[p] = val;
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave22_isEnabled (int p) {
    if (p < 0 || p >= 16) {
        return false;
    }
    return aiFFA30158_wave22_enabled[p];
}

//--------------------------------------------------------------------------------------------------
wave aiFFA30158_wave22_createdWave (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return aiFFA30158_wave22_lastWave[p];
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave22_runFunc (bool c, bool a) {
    int p = aiFFA30158_wave22_runPlayer;
    playergroup target = aiFFA30158_wave22_runTarget;
    int d;
    point gatherPoint = null;
    int ta = 0;
    int tg = 0;
    int ts = 0;
    int tf = 0;
    int td = 0;

    if (p < 0 || p >= 16) {
        return false;
    }
    d = PlayerDifficulty(p);
    if (!aiFFA30158_wave22_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    aiFFA30158_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 60; }
    if (d == 2) { ta = 60; }
    if (d == 3) { ta = 60; }
    if (d == 4) { ta = 60; }
    tg = 0;
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    AIAttackWaveSetTargetPlayer(p, target);

    gatherPoint = aiFFA30158_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave22_run (int p, playergroup target, bool wait) {
    aiFFA30158_wave22_runPlayer = p;
    aiFFA30158_wave22_runTarget = PlayerGroupCopy(target);

    TriggerExecute(aiFFA30158_wave22_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Hybrid 06 D
//--------------------------------------------------------------------------------------------------
bool[17] aiFFA30158_wave23_enabled;
wave[17] aiFFA30158_wave23_lastWave;
trigger aiFFA30158_wave23_trigger = null;
int aiFFA30158_wave23_runPlayer;
playergroup aiFFA30158_wave23_runTarget;

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave23_init () {
    int init_i;

    for (init_i = 0; init_i <= 16; init_i += 1) {
        aiFFA30158_wave23_enabled[init_i] = true;
        aiFFA30158_wave23_lastWave[init_i] = null;
    }

    aiFFA30158_wave23_trigger = TriggerCreate("aiFFA30158_wave23_runFunc");
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave23_enable (int p, bool val) {
    if (p < 0 || p >= 16) {
        return;
    }
    aiFFA30158_wave23_enabled[p] = val;
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave23_isEnabled (int p) {
    if (p < 0 || p >= 16) {
        return false;
    }
    return aiFFA30158_wave23_enabled[p];
}

//--------------------------------------------------------------------------------------------------
wave aiFFA30158_wave23_createdWave (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return aiFFA30158_wave23_lastWave[p];
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave23_runFunc (bool c, bool a) {
    int p = aiFFA30158_wave23_runPlayer;
    playergroup target = aiFFA30158_wave23_runTarget;
    int d;
    point gatherPoint = null;
    int ta = 0;
    int tg = 0;
    int ts = 0;
    int tf = 0;
    int td = 0;

    if (p < 0 || p >= 16) {
        return false;
    }
    d = PlayerDifficulty(p);
    if (!aiFFA30158_wave23_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    aiFFA30158_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 60; }
    if (d == 2) { ta = 60; }
    if (d == 3) { ta = 60; }
    if (d == 4) { ta = 60; }
    tg = 0;
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    AIAttackWaveSetTargetPlayer(p, target);

    gatherPoint = aiFFA30158_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave23_run (int p, playergroup target, bool wait) {
    aiFFA30158_wave23_runPlayer = p;
    aiFFA30158_wave23_runTarget = PlayerGroupCopy(target);

    TriggerExecute(aiFFA30158_wave23_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Hybrid 06 E/Hybrid 07&08 A
//--------------------------------------------------------------------------------------------------
bool[17] aiFFA30158_wave24_enabled;
wave[17] aiFFA30158_wave24_lastWave;
trigger aiFFA30158_wave24_trigger = null;
int aiFFA30158_wave24_runPlayer;
playergroup aiFFA30158_wave24_runTarget;

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave24_init () {
    int init_i;

    for (init_i = 0; init_i <= 16; init_i += 1) {
        aiFFA30158_wave24_enabled[init_i] = true;
        aiFFA30158_wave24_lastWave[init_i] = null;
    }

    aiFFA30158_wave24_trigger = TriggerCreate("aiFFA30158_wave24_runFunc");
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave24_enable (int p, bool val) {
    if (p < 0 || p >= 16) {
        return;
    }
    aiFFA30158_wave24_enabled[p] = val;
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave24_isEnabled (int p) {
    if (p < 0 || p >= 16) {
        return false;
    }
    return aiFFA30158_wave24_enabled[p];
}

//--------------------------------------------------------------------------------------------------
wave aiFFA30158_wave24_createdWave (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return aiFFA30158_wave24_lastWave[p];
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave24_runFunc (bool c, bool a) {
    int p = aiFFA30158_wave24_runPlayer;
    playergroup target = aiFFA30158_wave24_runTarget;
    int d;
    point gatherPoint = null;
    int ta = 0;
    int tg = 0;
    int ts = 0;
    int tf = 0;
    int td = 0;

    if (p < 0 || p >= 16) {
        return false;
    }
    d = PlayerDifficulty(p);
    if (!aiFFA30158_wave24_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    aiFFA30158_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 60; }
    if (d == 2) { ta = 60; }
    if (d == 3) { ta = 60; }
    if (d == 4) { ta = 60; }
    tg = 0;
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    AIAttackWaveSetTargetPlayer(p, target);

    gatherPoint = aiFFA30158_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave24_run (int p, playergroup target, bool wait) {
    aiFFA30158_wave24_runPlayer = p;
    aiFFA30158_wave24_runTarget = PlayerGroupCopy(target);

    TriggerExecute(aiFFA30158_wave24_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Hybrid 06 F/Hybrid 07&08 B
//--------------------------------------------------------------------------------------------------
bool[17] aiFFA30158_wave10_enabled;
wave[17] aiFFA30158_wave10_lastWave;
trigger aiFFA30158_wave10_trigger = null;
int aiFFA30158_wave10_runPlayer;
playergroup aiFFA30158_wave10_runTarget;

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave10_init () {
    int init_i;

    for (init_i = 0; init_i <= 16; init_i += 1) {
        aiFFA30158_wave10_enabled[init_i] = true;
        aiFFA30158_wave10_lastWave[init_i] = null;
    }

    aiFFA30158_wave10_trigger = TriggerCreate("aiFFA30158_wave10_runFunc");
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave10_enable (int p, bool val) {
    if (p < 0 || p >= 16) {
        return;
    }
    aiFFA30158_wave10_enabled[p] = val;
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave10_isEnabled (int p) {
    if (p < 0 || p >= 16) {
        return false;
    }
    return aiFFA30158_wave10_enabled[p];
}

//--------------------------------------------------------------------------------------------------
wave aiFFA30158_wave10_createdWave (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return aiFFA30158_wave10_lastWave[p];
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave10_runFunc (bool c, bool a) {
    int p = aiFFA30158_wave10_runPlayer;
    playergroup target = aiFFA30158_wave10_runTarget;
    int d;
    point gatherPoint = null;
    int ta = 0;
    int tg = 0;
    int ts = 0;
    int tf = 0;
    int td = 0;

    if (p < 0 || p >= 16) {
        return false;
    }
    d = PlayerDifficulty(p);
    if (!aiFFA30158_wave10_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    aiFFA30158_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 60; }
    if (d == 2) { ta = 60; }
    if (d == 3) { ta = 60; }
    if (d == 4) { ta = 60; }
    tg = 0;
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    AIAttackWaveSetTargetPlayer(p, target);

    gatherPoint = aiFFA30158_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave10_run (int p, playergroup target, bool wait) {
    aiFFA30158_wave10_runPlayer = p;
    aiFFA30158_wave10_runTarget = PlayerGroupCopy(target);

    TriggerExecute(aiFFA30158_wave10_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Hybrid 07&08 C
//--------------------------------------------------------------------------------------------------
bool[17] aiFFA30158_wave25_enabled;
wave[17] aiFFA30158_wave25_lastWave;
trigger aiFFA30158_wave25_trigger = null;
int aiFFA30158_wave25_runPlayer;
playergroup aiFFA30158_wave25_runTarget;

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave25_init () {
    int init_i;

    for (init_i = 0; init_i <= 16; init_i += 1) {
        aiFFA30158_wave25_enabled[init_i] = true;
        aiFFA30158_wave25_lastWave[init_i] = null;
    }

    aiFFA30158_wave25_trigger = TriggerCreate("aiFFA30158_wave25_runFunc");
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave25_enable (int p, bool val) {
    if (p < 0 || p >= 16) {
        return;
    }
    aiFFA30158_wave25_enabled[p] = val;
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave25_isEnabled (int p) {
    if (p < 0 || p >= 16) {
        return false;
    }
    return aiFFA30158_wave25_enabled[p];
}

//--------------------------------------------------------------------------------------------------
wave aiFFA30158_wave25_createdWave (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return aiFFA30158_wave25_lastWave[p];
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave25_runFunc (bool c, bool a) {
    int p = aiFFA30158_wave25_runPlayer;
    playergroup target = aiFFA30158_wave25_runTarget;
    int d;
    point gatherPoint = null;
    int ta = 0;
    int tg = 0;
    int ts = 0;
    int tf = 0;
    int td = 0;

    if (p < 0 || p >= 16) {
        return false;
    }
    d = PlayerDifficulty(p);
    if (!aiFFA30158_wave25_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    aiFFA30158_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 60; }
    if (d == 2) { ta = 60; }
    if (d == 3) { ta = 60; }
    if (d == 4) { ta = 60; }
    tg = 0;
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    AIAttackWaveSetTargetPlayer(p, target);

    gatherPoint = aiFFA30158_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave25_run (int p, playergroup target, bool wait) {
    aiFFA30158_wave25_runPlayer = p;
    aiFFA30158_wave25_runTarget = PlayerGroupCopy(target);

    TriggerExecute(aiFFA30158_wave25_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Hybrid 07&08 D
//--------------------------------------------------------------------------------------------------
bool[17] aiFFA30158_wave26_enabled;
wave[17] aiFFA30158_wave26_lastWave;
trigger aiFFA30158_wave26_trigger = null;
int aiFFA30158_wave26_runPlayer;
playergroup aiFFA30158_wave26_runTarget;

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave26_init () {
    int init_i;

    for (init_i = 0; init_i <= 16; init_i += 1) {
        aiFFA30158_wave26_enabled[init_i] = true;
        aiFFA30158_wave26_lastWave[init_i] = null;
    }

    aiFFA30158_wave26_trigger = TriggerCreate("aiFFA30158_wave26_runFunc");
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave26_enable (int p, bool val) {
    if (p < 0 || p >= 16) {
        return;
    }
    aiFFA30158_wave26_enabled[p] = val;
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave26_isEnabled (int p) {
    if (p < 0 || p >= 16) {
        return false;
    }
    return aiFFA30158_wave26_enabled[p];
}

//--------------------------------------------------------------------------------------------------
wave aiFFA30158_wave26_createdWave (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return aiFFA30158_wave26_lastWave[p];
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave26_runFunc (bool c, bool a) {
    int p = aiFFA30158_wave26_runPlayer;
    playergroup target = aiFFA30158_wave26_runTarget;
    int d;
    point gatherPoint = null;
    int ta = 0;
    int tg = 0;
    int ts = 0;
    int tf = 0;
    int td = 0;

    if (p < 0 || p >= 16) {
        return false;
    }
    d = PlayerDifficulty(p);
    if (!aiFFA30158_wave26_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    aiFFA30158_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 60; }
    if (d == 2) { ta = 60; }
    if (d == 3) { ta = 60; }
    if (d == 4) { ta = 60; }
    tg = 0;
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    AIAttackWaveSetTargetPlayer(p, target);

    gatherPoint = aiFFA30158_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave26_run (int p, playergroup target, bool wait) {
    aiFFA30158_wave26_runPlayer = p;
    aiFFA30158_wave26_runTarget = PlayerGroupCopy(target);

    TriggerExecute(aiFFA30158_wave26_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Hybrid 07&08 E
//--------------------------------------------------------------------------------------------------
bool[17] aiFFA30158_wave27_enabled;
wave[17] aiFFA30158_wave27_lastWave;
trigger aiFFA30158_wave27_trigger = null;
int aiFFA30158_wave27_runPlayer;
playergroup aiFFA30158_wave27_runTarget;

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave27_init () {
    int init_i;

    for (init_i = 0; init_i <= 16; init_i += 1) {
        aiFFA30158_wave27_enabled[init_i] = true;
        aiFFA30158_wave27_lastWave[init_i] = null;
    }

    aiFFA30158_wave27_trigger = TriggerCreate("aiFFA30158_wave27_runFunc");
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave27_enable (int p, bool val) {
    if (p < 0 || p >= 16) {
        return;
    }
    aiFFA30158_wave27_enabled[p] = val;
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave27_isEnabled (int p) {
    if (p < 0 || p >= 16) {
        return false;
    }
    return aiFFA30158_wave27_enabled[p];
}

//--------------------------------------------------------------------------------------------------
wave aiFFA30158_wave27_createdWave (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return aiFFA30158_wave27_lastWave[p];
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave27_runFunc (bool c, bool a) {
    int p = aiFFA30158_wave27_runPlayer;
    playergroup target = aiFFA30158_wave27_runTarget;
    int d;
    point gatherPoint = null;
    int ta = 0;
    int tg = 0;
    int ts = 0;
    int tf = 0;
    int td = 0;

    if (p < 0 || p >= 16) {
        return false;
    }
    d = PlayerDifficulty(p);
    if (!aiFFA30158_wave27_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    aiFFA30158_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 60; }
    if (d == 2) { ta = 60; }
    if (d == 3) { ta = 60; }
    if (d == 4) { ta = 60; }
    tg = 0;
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    AIAttackWaveSetTargetPlayer(p, target);

    gatherPoint = aiFFA30158_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave27_run (int p, playergroup target, bool wait) {
    aiFFA30158_wave27_runPlayer = p;
    aiFFA30158_wave27_runTarget = PlayerGroupCopy(target);

    TriggerExecute(aiFFA30158_wave27_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Hybrid 07&08 F
//--------------------------------------------------------------------------------------------------
bool[17] aiFFA30158_wave28_enabled;
wave[17] aiFFA30158_wave28_lastWave;
trigger aiFFA30158_wave28_trigger = null;
int aiFFA30158_wave28_runPlayer;
playergroup aiFFA30158_wave28_runTarget;

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave28_init () {
    int init_i;

    for (init_i = 0; init_i <= 16; init_i += 1) {
        aiFFA30158_wave28_enabled[init_i] = true;
        aiFFA30158_wave28_lastWave[init_i] = null;
    }

    aiFFA30158_wave28_trigger = TriggerCreate("aiFFA30158_wave28_runFunc");
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave28_enable (int p, bool val) {
    if (p < 0 || p >= 16) {
        return;
    }
    aiFFA30158_wave28_enabled[p] = val;
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave28_isEnabled (int p) {
    if (p < 0 || p >= 16) {
        return false;
    }
    return aiFFA30158_wave28_enabled[p];
}

//--------------------------------------------------------------------------------------------------
wave aiFFA30158_wave28_createdWave (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return aiFFA30158_wave28_lastWave[p];
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave28_runFunc (bool c, bool a) {
    int p = aiFFA30158_wave28_runPlayer;
    playergroup target = aiFFA30158_wave28_runTarget;
    int d;
    point gatherPoint = null;
    int ta = 0;
    int tg = 0;
    int ts = 0;
    int tf = 0;
    int td = 0;

    if (p < 0 || p >= 16) {
        return false;
    }
    d = PlayerDifficulty(p);
    if (!aiFFA30158_wave28_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    aiFFA30158_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 60; }
    if (d == 2) { ta = 60; }
    if (d == 3) { ta = 60; }
    if (d == 4) { ta = 60; }
    tg = 0;
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    AIAttackWaveSetTargetPlayer(p, target);

    gatherPoint = aiFFA30158_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave28_run (int p, playergroup target, bool wait) {
    aiFFA30158_wave28_runPlayer = p;
    aiFFA30158_wave28_runTarget = PlayerGroupCopy(target);

    TriggerExecute(aiFFA30158_wave28_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Hybrid 07&08 G
//--------------------------------------------------------------------------------------------------
bool[17] aiFFA30158_wave29_enabled;
wave[17] aiFFA30158_wave29_lastWave;
trigger aiFFA30158_wave29_trigger = null;
int aiFFA30158_wave29_runPlayer;
playergroup aiFFA30158_wave29_runTarget;

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave29_init () {
    int init_i;

    for (init_i = 0; init_i <= 16; init_i += 1) {
        aiFFA30158_wave29_enabled[init_i] = true;
        aiFFA30158_wave29_lastWave[init_i] = null;
    }

    aiFFA30158_wave29_trigger = TriggerCreate("aiFFA30158_wave29_runFunc");
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave29_enable (int p, bool val) {
    if (p < 0 || p >= 16) {
        return;
    }
    aiFFA30158_wave29_enabled[p] = val;
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave29_isEnabled (int p) {
    if (p < 0 || p >= 16) {
        return false;
    }
    return aiFFA30158_wave29_enabled[p];
}

//--------------------------------------------------------------------------------------------------
wave aiFFA30158_wave29_createdWave (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return aiFFA30158_wave29_lastWave[p];
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave29_runFunc (bool c, bool a) {
    int p = aiFFA30158_wave29_runPlayer;
    playergroup target = aiFFA30158_wave29_runTarget;
    int d;
    point gatherPoint = null;
    int ta = 0;
    int tg = 0;
    int ts = 0;
    int tf = 0;
    int td = 0;

    if (p < 0 || p >= 16) {
        return false;
    }
    d = PlayerDifficulty(p);
    if (!aiFFA30158_wave29_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    aiFFA30158_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 60; }
    if (d == 2) { ta = 60; }
    if (d == 3) { ta = 60; }
    if (d == 4) { ta = 60; }
    tg = 0;
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    AIAttackWaveSetTargetPlayer(p, target);

    gatherPoint = aiFFA30158_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave29_run (int p, playergroup target, bool wait) {
    aiFFA30158_wave29_runPlayer = p;
    aiFFA30158_wave29_runTarget = PlayerGroupCopy(target);

    TriggerExecute(aiFFA30158_wave29_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave Wrappers
//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave_enable (int w, int p, bool val) {
    if (w == 7) { aiFFA30158_wave7_enable(p, val); }
    if (w == 3) { aiFFA30158_wave3_enable(p, val); }
    if (w == 1) { aiFFA30158_wave1_enable(p, val); }
    if (w == 2) { aiFFA30158_wave2_enable(p, val); }
    if (w == 4) { aiFFA30158_wave4_enable(p, val); }
    if (w == 12) { aiFFA30158_wave12_enable(p, val); }
    if (w == 13) { aiFFA30158_wave13_enable(p, val); }
    if (w == 5) { aiFFA30158_wave5_enable(p, val); }
    if (w == 14) { aiFFA30158_wave14_enable(p, val); }
    if (w == 15) { aiFFA30158_wave15_enable(p, val); }
    if (w == 16) { aiFFA30158_wave16_enable(p, val); }
    if (w == 17) { aiFFA30158_wave17_enable(p, val); }
    if (w == 8) { aiFFA30158_wave8_enable(p, val); }
    if (w == 18) { aiFFA30158_wave18_enable(p, val); }
    if (w == 19) { aiFFA30158_wave19_enable(p, val); }
    if (w == 20) { aiFFA30158_wave20_enable(p, val); }
    if (w == 21) { aiFFA30158_wave21_enable(p, val); }
    if (w == 22) { aiFFA30158_wave22_enable(p, val); }
    if (w == 23) { aiFFA30158_wave23_enable(p, val); }
    if (w == 24) { aiFFA30158_wave24_enable(p, val); }
    if (w == 10) { aiFFA30158_wave10_enable(p, val); }
    if (w == 25) { aiFFA30158_wave25_enable(p, val); }
    if (w == 26) { aiFFA30158_wave26_enable(p, val); }
    if (w == 27) { aiFFA30158_wave27_enable(p, val); }
    if (w == 28) { aiFFA30158_wave28_enable(p, val); }
    if (w == 29) { aiFFA30158_wave29_enable(p, val); }
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_wave_isEnabled (int w, int p) {
    if (w == 7) { return aiFFA30158_wave7_isEnabled(p); }
    if (w == 3) { return aiFFA30158_wave3_isEnabled(p); }
    if (w == 1) { return aiFFA30158_wave1_isEnabled(p); }
    if (w == 2) { return aiFFA30158_wave2_isEnabled(p); }
    if (w == 4) { return aiFFA30158_wave4_isEnabled(p); }
    if (w == 12) { return aiFFA30158_wave12_isEnabled(p); }
    if (w == 13) { return aiFFA30158_wave13_isEnabled(p); }
    if (w == 5) { return aiFFA30158_wave5_isEnabled(p); }
    if (w == 14) { return aiFFA30158_wave14_isEnabled(p); }
    if (w == 15) { return aiFFA30158_wave15_isEnabled(p); }
    if (w == 16) { return aiFFA30158_wave16_isEnabled(p); }
    if (w == 17) { return aiFFA30158_wave17_isEnabled(p); }
    if (w == 8) { return aiFFA30158_wave8_isEnabled(p); }
    if (w == 18) { return aiFFA30158_wave18_isEnabled(p); }
    if (w == 19) { return aiFFA30158_wave19_isEnabled(p); }
    if (w == 20) { return aiFFA30158_wave20_isEnabled(p); }
    if (w == 21) { return aiFFA30158_wave21_isEnabled(p); }
    if (w == 22) { return aiFFA30158_wave22_isEnabled(p); }
    if (w == 23) { return aiFFA30158_wave23_isEnabled(p); }
    if (w == 24) { return aiFFA30158_wave24_isEnabled(p); }
    if (w == 10) { return aiFFA30158_wave10_isEnabled(p); }
    if (w == 25) { return aiFFA30158_wave25_isEnabled(p); }
    if (w == 26) { return aiFFA30158_wave26_isEnabled(p); }
    if (w == 27) { return aiFFA30158_wave27_isEnabled(p); }
    if (w == 28) { return aiFFA30158_wave28_isEnabled(p); }
    if (w == 29) { return aiFFA30158_wave29_isEnabled(p); }
    return false;
}

//--------------------------------------------------------------------------------------------------
unitgroup aiFFA30158_wave_createdUnits (int w, int p) {
    return null;
}

//--------------------------------------------------------------------------------------------------
wave aiFFA30158_wave_createdWave (int w, int p) {
    if (w == 7) { return aiFFA30158_wave7_createdWave(p); }
    if (w == 3) { return aiFFA30158_wave3_createdWave(p); }
    if (w == 1) { return aiFFA30158_wave1_createdWave(p); }
    if (w == 2) { return aiFFA30158_wave2_createdWave(p); }
    if (w == 4) { return aiFFA30158_wave4_createdWave(p); }
    if (w == 12) { return aiFFA30158_wave12_createdWave(p); }
    if (w == 13) { return aiFFA30158_wave13_createdWave(p); }
    if (w == 5) { return aiFFA30158_wave5_createdWave(p); }
    if (w == 14) { return aiFFA30158_wave14_createdWave(p); }
    if (w == 15) { return aiFFA30158_wave15_createdWave(p); }
    if (w == 16) { return aiFFA30158_wave16_createdWave(p); }
    if (w == 17) { return aiFFA30158_wave17_createdWave(p); }
    if (w == 8) { return aiFFA30158_wave8_createdWave(p); }
    if (w == 18) { return aiFFA30158_wave18_createdWave(p); }
    if (w == 19) { return aiFFA30158_wave19_createdWave(p); }
    if (w == 20) { return aiFFA30158_wave20_createdWave(p); }
    if (w == 21) { return aiFFA30158_wave21_createdWave(p); }
    if (w == 22) { return aiFFA30158_wave22_createdWave(p); }
    if (w == 23) { return aiFFA30158_wave23_createdWave(p); }
    if (w == 24) { return aiFFA30158_wave24_createdWave(p); }
    if (w == 10) { return aiFFA30158_wave10_createdWave(p); }
    if (w == 25) { return aiFFA30158_wave25_createdWave(p); }
    if (w == 26) { return aiFFA30158_wave26_createdWave(p); }
    if (w == 27) { return aiFFA30158_wave27_createdWave(p); }
    if (w == 28) { return aiFFA30158_wave28_createdWave(p); }
    if (w == 29) { return aiFFA30158_wave29_createdWave(p); }
    return null;
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_wave_run (int w, int p, playergroup target, bool wait) {
    if (w == 7) { aiFFA30158_wave7_run(p, target, wait); }
    if (w == 3) { aiFFA30158_wave3_run(p, target, wait); }
    if (w == 1) { aiFFA30158_wave1_run(p, target, wait); }
    if (w == 2) { aiFFA30158_wave2_run(p, target, wait); }
    if (w == 4) { aiFFA30158_wave4_run(p, target, wait); }
    if (w == 12) { aiFFA30158_wave12_run(p, target, wait); }
    if (w == 13) { aiFFA30158_wave13_run(p, target, wait); }
    if (w == 5) { aiFFA30158_wave5_run(p, target, wait); }
    if (w == 14) { aiFFA30158_wave14_run(p, target, wait); }
    if (w == 15) { aiFFA30158_wave15_run(p, target, wait); }
    if (w == 16) { aiFFA30158_wave16_run(p, target, wait); }
    if (w == 17) { aiFFA30158_wave17_run(p, target, wait); }
    if (w == 8) { aiFFA30158_wave8_run(p, target, wait); }
    if (w == 18) { aiFFA30158_wave18_run(p, target, wait); }
    if (w == 19) { aiFFA30158_wave19_run(p, target, wait); }
    if (w == 20) { aiFFA30158_wave20_run(p, target, wait); }
    if (w == 21) { aiFFA30158_wave21_run(p, target, wait); }
    if (w == 22) { aiFFA30158_wave22_run(p, target, wait); }
    if (w == 23) { aiFFA30158_wave23_run(p, target, wait); }
    if (w == 24) { aiFFA30158_wave24_run(p, target, wait); }
    if (w == 10) { aiFFA30158_wave10_run(p, target, wait); }
    if (w == 25) { aiFFA30158_wave25_run(p, target, wait); }
    if (w == 26) { aiFFA30158_wave26_run(p, target, wait); }
    if (w == 27) { aiFFA30158_wave27_run(p, target, wait); }
    if (w == 28) { aiFFA30158_wave28_run(p, target, wait); }
    if (w == 29) { aiFFA30158_wave29_run(p, target, wait); }
}

//--------------------------------------------------------------------------------------------------
// Attack Wave Sequence
//--------------------------------------------------------------------------------------------------
trigger aiFFA30158_waves_trigger = null;
int aiFFA30158_waves_runPlayer;
playergroup aiFFA30158_waves_runTarget;

//--------------------------------------------------------------------------------------------------
void aiFFA30158_waves_init () {
    aiFFA30158_waves_trigger = TriggerCreate("aiFFA30158_waves_runFunc");
}

//--------------------------------------------------------------------------------------------------
bool aiFFA30158_waves_runFunc (bool c, bool a) {
    int p = aiFFA30158_waves_runPlayer;
    playergroup target = aiFFA30158_waves_runTarget;

    if (p < 0 || p >= 16) {
        return false;
    }

    aiFFA30158_wave7_run(p, target, true);
    aiFFA30158_wave3_run(p, target, true);
    aiFFA30158_wave1_run(p, target, true);
    aiFFA30158_wave2_run(p, target, true);
    aiFFA30158_wave4_run(p, target, true);
    aiFFA30158_wave12_run(p, target, true);
    aiFFA30158_wave13_run(p, target, true);
    aiFFA30158_wave5_run(p, target, true);
    aiFFA30158_wave14_run(p, target, true);
    aiFFA30158_wave15_run(p, target, true);
    aiFFA30158_wave16_run(p, target, true);
    aiFFA30158_wave17_run(p, target, true);
    aiFFA30158_wave8_run(p, target, true);
    aiFFA30158_wave18_run(p, target, true);
    aiFFA30158_wave19_run(p, target, true);
    aiFFA30158_wave20_run(p, target, true);
    aiFFA30158_wave21_run(p, target, true);
    aiFFA30158_wave22_run(p, target, true);
    aiFFA30158_wave23_run(p, target, true);
    aiFFA30158_wave24_run(p, target, true);
    aiFFA30158_wave10_run(p, target, true);
    aiFFA30158_wave25_run(p, target, true);
    aiFFA30158_wave26_run(p, target, true);
    aiFFA30158_wave27_run(p, target, true);
    aiFFA30158_wave28_run(p, target, true);
    aiFFA30158_wave29_run(p, target, true);

    return true;
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_waves_run (int p, playergroup target) {
    aiFFA30158_waves_runPlayer = p;
    aiFFA30158_waves_runTarget = PlayerGroupCopy(target);

    TriggerExecute(aiFFA30158_waves_trigger, false, false);
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_waves_enable (int p, bool val) {
    if (p < 0 || p >= 16) {
        return;
    }

    aiFFA30158_wave7_enable(p, val);
    aiFFA30158_wave3_enable(p, val);
    aiFFA30158_wave1_enable(p, val);
    aiFFA30158_wave2_enable(p, val);
    aiFFA30158_wave4_enable(p, val);
    aiFFA30158_wave12_enable(p, val);
    aiFFA30158_wave13_enable(p, val);
    aiFFA30158_wave5_enable(p, val);
    aiFFA30158_wave14_enable(p, val);
    aiFFA30158_wave15_enable(p, val);
    aiFFA30158_wave16_enable(p, val);
    aiFFA30158_wave17_enable(p, val);
    aiFFA30158_wave8_enable(p, val);
    aiFFA30158_wave18_enable(p, val);
    aiFFA30158_wave19_enable(p, val);
    aiFFA30158_wave20_enable(p, val);
    aiFFA30158_wave21_enable(p, val);
    aiFFA30158_wave22_enable(p, val);
    aiFFA30158_wave23_enable(p, val);
    aiFFA30158_wave24_enable(p, val);
    aiFFA30158_wave10_enable(p, val);
    aiFFA30158_wave25_enable(p, val);
    aiFFA30158_wave26_enable(p, val);
    aiFFA30158_wave27_enable(p, val);
    aiFFA30158_wave28_enable(p, val);
    aiFFA30158_wave29_enable(p, val);
}

//--------------------------------------------------------------------------------------------------
void aiFFA30158_waves_stop () {
    TriggerStop(aiFFA30158_waves_trigger);

    TriggerStop(aiFFA30158_wave7_trigger);
    TriggerStop(aiFFA30158_wave3_trigger);
    TriggerStop(aiFFA30158_wave1_trigger);
    TriggerStop(aiFFA30158_wave2_trigger);
    TriggerStop(aiFFA30158_wave4_trigger);
    TriggerStop(aiFFA30158_wave12_trigger);
    TriggerStop(aiFFA30158_wave13_trigger);
    TriggerStop(aiFFA30158_wave5_trigger);
    TriggerStop(aiFFA30158_wave14_trigger);
    TriggerStop(aiFFA30158_wave15_trigger);
    TriggerStop(aiFFA30158_wave16_trigger);
    TriggerStop(aiFFA30158_wave17_trigger);
    TriggerStop(aiFFA30158_wave8_trigger);
    TriggerStop(aiFFA30158_wave18_trigger);
    TriggerStop(aiFFA30158_wave19_trigger);
    TriggerStop(aiFFA30158_wave20_trigger);
    TriggerStop(aiFFA30158_wave21_trigger);
    TriggerStop(aiFFA30158_wave22_trigger);
    TriggerStop(aiFFA30158_wave23_trigger);
    TriggerStop(aiFFA30158_wave24_trigger);
    TriggerStop(aiFFA30158_wave10_trigger);
    TriggerStop(aiFFA30158_wave25_trigger);
    TriggerStop(aiFFA30158_wave26_trigger);
    TriggerStop(aiFFA30158_wave27_trigger);
    TriggerStop(aiFFA30158_wave28_trigger);
    TriggerStop(aiFFA30158_wave29_trigger);
}

//--------------------------------------------------------------------------------------------------
// Configuration
//--------------------------------------------------------------------------------------------------
void aiFFA30158_setDefGather (int p, point val) {
    if (p < 0 || p >= 16) {
        return;
    }
    aiFFA30158_defGather[p] = val;
}

//--------------------------------------------------------------------------------------------------
string aiFFA30158_getCustomData (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return aiFFA30158_customData[p];
}

//--------------------------------------------------------------------------------------------------
wave aiFFA30158_getLastWave (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return aiFFA30158_lastWave[p];
}

//--------------------------------------------------------------------------------------------------
// Start
//--------------------------------------------------------------------------------------------------
bool aiFFA30158_initialized = false;

//--------------------------------------------------------------------------------------------------
void aiFFA30158_start (int p) {
    int init_i;

    if (p < 0 || p >= 16) {
        return;
    }
    if (!aiFFA30158_initialized) {
        aiFFA30158_wave7_init();
        aiFFA30158_wave3_init();
        aiFFA30158_wave1_init();
        aiFFA30158_wave2_init();
        aiFFA30158_wave4_init();
        aiFFA30158_wave12_init();
        aiFFA30158_wave13_init();
        aiFFA30158_wave5_init();
        aiFFA30158_wave14_init();
        aiFFA30158_wave15_init();
        aiFFA30158_wave16_init();
        aiFFA30158_wave17_init();
        aiFFA30158_wave8_init();
        aiFFA30158_wave18_init();
        aiFFA30158_wave19_init();
        aiFFA30158_wave20_init();
        aiFFA30158_wave21_init();
        aiFFA30158_wave22_init();
        aiFFA30158_wave23_init();
        aiFFA30158_wave24_init();
        aiFFA30158_wave10_init();
        aiFFA30158_wave25_init();
        aiFFA30158_wave26_init();
        aiFFA30158_wave27_init();
        aiFFA30158_wave28_init();
        aiFFA30158_wave29_init();
        aiFFA30158_waves_init();

        for (init_i = 0; init_i <= 16; init_i += 1) {
            aiFFA30158_defGather[init_i] = PointFromId(0);
        }

        aiFFA30158_initialized = true;
    }

    AICampaignStart(p);
}