ai36ECF245.galaxy

//==================================================================================================
// 
// Generated AI Script
// 
// AI Name: P06 Keystone (Map Events)
// 
//==================================================================================================
include "TriggerLibs/natives"
include "TriggerLibs/AI"
include "TriggerLibs/Computer"

//--------------------------------------------------------------------------------------------------
// Globals
//--------------------------------------------------------------------------------------------------
point[17] ai36ECF245_defGather;
string[17] ai36ECF245_customData;
wave[17] ai36ECF245_lastWave;

//--------------------------------------------------------------------------------------------------
// Attack Wave: Begin Creep Expansion
//--------------------------------------------------------------------------------------------------
bool[17] ai36ECF245_wave1_enabled;
wave[17] ai36ECF245_wave1_lastWave;
trigger ai36ECF245_wave1_trigger = null;
int ai36ECF245_wave1_runPlayer;
playergroup ai36ECF245_wave1_runTarget;

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

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

    ai36ECF245_wave1_trigger = TriggerCreate("ai36ECF245_wave1_runFunc");
}

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

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

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

//--------------------------------------------------------------------------------------------------
bool ai36ECF245_wave1_runFunc (bool c, bool a) {
    int p = ai36ECF245_wave1_runPlayer;
    playergroup target = ai36ECF245_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 (!ai36ECF245_wave1_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    ai36ECF245_customData[p] = "";

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

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

    AIAttackWaveClearWaypoints(p);

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

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai36ECF245_wave1_run (int p, playergroup target, bool wait) {
    ai36ECF245_wave1_runPlayer = p;
    ai36ECF245_wave1_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai36ECF245_wave1_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Spear Offline Warning Q
//--------------------------------------------------------------------------------------------------
bool[17] ai36ECF245_wave2_enabled;
wave[17] ai36ECF245_wave2_lastWave;
trigger ai36ECF245_wave2_trigger = null;
int ai36ECF245_wave2_runPlayer;
playergroup ai36ECF245_wave2_runTarget;

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

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

    ai36ECF245_wave2_trigger = TriggerCreate("ai36ECF245_wave2_runFunc");
}

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

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

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

//--------------------------------------------------------------------------------------------------
bool ai36ECF245_wave2_runFunc (bool c, bool a) {
    int p = ai36ECF245_wave2_runPlayer;
    playergroup target = ai36ECF245_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 (!ai36ECF245_wave2_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    ai36ECF245_customData[p] = "";

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

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

    AIAttackWaveClearWaypoints(p);

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

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai36ECF245_wave2_run (int p, playergroup target, bool wait) {
    ai36ECF245_wave2_runPlayer = p;
    ai36ECF245_wave2_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai36ECF245_wave2_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Spear Offline 1 Q
//--------------------------------------------------------------------------------------------------
bool[17] ai36ECF245_wave3_enabled;
unitgroup[17] ai36ECF245_wave3_lastUnits;
wave[17] ai36ECF245_wave3_lastWave;
trigger ai36ECF245_wave3_trigger = null;
int ai36ECF245_wave3_runPlayer;
playergroup ai36ECF245_wave3_runTarget;

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

    for (init_i = 0; init_i <= 16; init_i += 1) {
        ai36ECF245_wave3_enabled[init_i] = true;
        ai36ECF245_wave3_lastUnits[init_i] = null;
        ai36ECF245_wave3_lastWave[init_i] = null;
    }

    ai36ECF245_wave3_trigger = TriggerCreate("ai36ECF245_wave3_runFunc");
}

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

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

//--------------------------------------------------------------------------------------------------
unitgroup ai36ECF245_wave3_createdUnits (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return ai36ECF245_wave3_lastUnits[p];
}

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

//--------------------------------------------------------------------------------------------------
bool ai36ECF245_wave3_runFunc (bool c, bool a) {
    int p = ai36ECF245_wave3_runPlayer;
    playergroup target = ai36ECF245_wave3_runTarget;
    int d;
    point gatherPoint = null;
    int createCount = 0;
    point createPoint = 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 (!ai36ECF245_wave3_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    ai36ECF245_customData[p] = "";

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

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

    AIAttackWaveClearWaypoints(p);

    createPoint = gatherPoint;

    ai36ECF245_wave3_lastUnits[p] = UnitGroupEmpty();

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

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai36ECF245_wave3_run (int p, playergroup target, bool wait) {
    ai36ECF245_wave3_runPlayer = p;
    ai36ECF245_wave3_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai36ECF245_wave3_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Spear Offline 2 Q
//--------------------------------------------------------------------------------------------------
bool[17] ai36ECF245_wave4_enabled;
unitgroup[17] ai36ECF245_wave4_lastUnits;
wave[17] ai36ECF245_wave4_lastWave;
trigger ai36ECF245_wave4_trigger = null;
int ai36ECF245_wave4_runPlayer;
playergroup ai36ECF245_wave4_runTarget;

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

    for (init_i = 0; init_i <= 16; init_i += 1) {
        ai36ECF245_wave4_enabled[init_i] = true;
        ai36ECF245_wave4_lastUnits[init_i] = null;
        ai36ECF245_wave4_lastWave[init_i] = null;
    }

    ai36ECF245_wave4_trigger = TriggerCreate("ai36ECF245_wave4_runFunc");
}

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

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

//--------------------------------------------------------------------------------------------------
unitgroup ai36ECF245_wave4_createdUnits (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return ai36ECF245_wave4_lastUnits[p];
}

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

//--------------------------------------------------------------------------------------------------
bool ai36ECF245_wave4_runFunc (bool c, bool a) {
    int p = ai36ECF245_wave4_runPlayer;
    playergroup target = ai36ECF245_wave4_runTarget;
    int d;
    point gatherPoint = null;
    int createCount = 0;
    point createPoint = 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 (!ai36ECF245_wave4_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    ai36ECF245_customData[p] = "";

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

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

    AIAttackWaveClearWaypoints(p);

    createPoint = gatherPoint;

    ai36ECF245_wave4_lastUnits[p] = UnitGroupEmpty();

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

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai36ECF245_wave4_run (int p, playergroup target, bool wait) {
    ai36ECF245_wave4_runPlayer = p;
    ai36ECF245_wave4_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai36ECF245_wave4_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Spear Offline 3 Q
//--------------------------------------------------------------------------------------------------
bool[17] ai36ECF245_wave5_enabled;
unitgroup[17] ai36ECF245_wave5_lastUnits;
wave[17] ai36ECF245_wave5_lastWave;
trigger ai36ECF245_wave5_trigger = null;
int ai36ECF245_wave5_runPlayer;
playergroup ai36ECF245_wave5_runTarget;

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

    for (init_i = 0; init_i <= 16; init_i += 1) {
        ai36ECF245_wave5_enabled[init_i] = true;
        ai36ECF245_wave5_lastUnits[init_i] = null;
        ai36ECF245_wave5_lastWave[init_i] = null;
    }

    ai36ECF245_wave5_trigger = TriggerCreate("ai36ECF245_wave5_runFunc");
}

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

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

//--------------------------------------------------------------------------------------------------
unitgroup ai36ECF245_wave5_createdUnits (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return ai36ECF245_wave5_lastUnits[p];
}

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

//--------------------------------------------------------------------------------------------------
bool ai36ECF245_wave5_runFunc (bool c, bool a) {
    int p = ai36ECF245_wave5_runPlayer;
    playergroup target = ai36ECF245_wave5_runTarget;
    int d;
    point gatherPoint = null;
    int createCount = 0;
    point createPoint = 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 (!ai36ECF245_wave5_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    ai36ECF245_customData[p] = "";

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

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

    AIAttackWaveClearWaypoints(p);

    createPoint = gatherPoint;

    ai36ECF245_wave5_lastUnits[p] = UnitGroupEmpty();

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

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai36ECF245_wave5_run (int p, playergroup target, bool wait) {
    ai36ECF245_wave5_runPlayer = p;
    ai36ECF245_wave5_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai36ECF245_wave5_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Spear Offline 4 Q
//--------------------------------------------------------------------------------------------------
bool[17] ai36ECF245_wave6_enabled;
unitgroup[17] ai36ECF245_wave6_lastUnits;
wave[17] ai36ECF245_wave6_lastWave;
trigger ai36ECF245_wave6_trigger = null;
int ai36ECF245_wave6_runPlayer;
playergroup ai36ECF245_wave6_runTarget;

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

    for (init_i = 0; init_i <= 16; init_i += 1) {
        ai36ECF245_wave6_enabled[init_i] = true;
        ai36ECF245_wave6_lastUnits[init_i] = null;
        ai36ECF245_wave6_lastWave[init_i] = null;
    }

    ai36ECF245_wave6_trigger = TriggerCreate("ai36ECF245_wave6_runFunc");
}

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

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

//--------------------------------------------------------------------------------------------------
unitgroup ai36ECF245_wave6_createdUnits (int p) {
    if (p < 0 || p >= 16) {
        return null;
    }
    return ai36ECF245_wave6_lastUnits[p];
}

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

//--------------------------------------------------------------------------------------------------
bool ai36ECF245_wave6_runFunc (bool c, bool a) {
    int p = ai36ECF245_wave6_runPlayer;
    playergroup target = ai36ECF245_wave6_runTarget;
    int d;
    point gatherPoint = null;
    int createCount = 0;
    point createPoint = 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 (!ai36ECF245_wave6_enabled[p]) {
        td = 0;
        if (td > 0) {
            Wait(td, c_timeAI);
        }
        return true;
    }

    ai36ECF245_customData[p] = "";

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

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

    AIAttackWaveClearWaypoints(p);

    createPoint = gatherPoint;

    ai36ECF245_wave6_lastUnits[p] = UnitGroupEmpty();

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

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai36ECF245_wave6_run (int p, playergroup target, bool wait) {
    ai36ECF245_wave6_runPlayer = p;
    ai36ECF245_wave6_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai36ECF245_wave6_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave Wrappers
//--------------------------------------------------------------------------------------------------
void ai36ECF245_wave_enable (int w, int p, bool val) {
    if (w == 1) { ai36ECF245_wave1_enable(p, val); }
    if (w == 2) { ai36ECF245_wave2_enable(p, val); }
    if (w == 3) { ai36ECF245_wave3_enable(p, val); }
    if (w == 4) { ai36ECF245_wave4_enable(p, val); }
    if (w == 5) { ai36ECF245_wave5_enable(p, val); }
    if (w == 6) { ai36ECF245_wave6_enable(p, val); }
}

//--------------------------------------------------------------------------------------------------
bool ai36ECF245_wave_isEnabled (int w, int p) {
    if (w == 1) { return ai36ECF245_wave1_isEnabled(p); }
    if (w == 2) { return ai36ECF245_wave2_isEnabled(p); }
    if (w == 3) { return ai36ECF245_wave3_isEnabled(p); }
    if (w == 4) { return ai36ECF245_wave4_isEnabled(p); }
    if (w == 5) { return ai36ECF245_wave5_isEnabled(p); }
    if (w == 6) { return ai36ECF245_wave6_isEnabled(p); }
    return false;
}

//--------------------------------------------------------------------------------------------------
unitgroup ai36ECF245_wave_createdUnits (int w, int p) {
    if (w == 3) { return ai36ECF245_wave3_createdUnits(p); }
    if (w == 4) { return ai36ECF245_wave4_createdUnits(p); }
    if (w == 5) { return ai36ECF245_wave5_createdUnits(p); }
    if (w == 6) { return ai36ECF245_wave6_createdUnits(p); }
    return null;
}

//--------------------------------------------------------------------------------------------------
wave ai36ECF245_wave_createdWave (int w, int p) {
    if (w == 1) { return ai36ECF245_wave1_createdWave(p); }
    if (w == 2) { return ai36ECF245_wave2_createdWave(p); }
    if (w == 3) { return ai36ECF245_wave3_createdWave(p); }
    if (w == 4) { return ai36ECF245_wave4_createdWave(p); }
    if (w == 5) { return ai36ECF245_wave5_createdWave(p); }
    if (w == 6) { return ai36ECF245_wave6_createdWave(p); }
    return null;
}

//--------------------------------------------------------------------------------------------------
void ai36ECF245_wave_run (int w, int p, playergroup target, bool wait) {
    if (w == 1) { ai36ECF245_wave1_run(p, target, wait); }
    if (w == 2) { ai36ECF245_wave2_run(p, target, wait); }
    if (w == 3) { ai36ECF245_wave3_run(p, target, wait); }
    if (w == 4) { ai36ECF245_wave4_run(p, target, wait); }
    if (w == 5) { ai36ECF245_wave5_run(p, target, wait); }
    if (w == 6) { ai36ECF245_wave6_run(p, target, wait); }
}

//--------------------------------------------------------------------------------------------------
// Attack Wave Sequence
//--------------------------------------------------------------------------------------------------
trigger ai36ECF245_waves_trigger = null;
int ai36ECF245_waves_runPlayer;
playergroup ai36ECF245_waves_runTarget;

//--------------------------------------------------------------------------------------------------
void ai36ECF245_waves_init () {
    ai36ECF245_waves_trigger = TriggerCreate("ai36ECF245_waves_runFunc");
}

//--------------------------------------------------------------------------------------------------
bool ai36ECF245_waves_runFunc (bool c, bool a) {
    int p = ai36ECF245_waves_runPlayer;
    playergroup target = ai36ECF245_waves_runTarget;

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

    ai36ECF245_wave1_run(p, target, true);
    ai36ECF245_wave2_run(p, target, true);
    ai36ECF245_wave3_run(p, target, true);
    ai36ECF245_wave4_run(p, target, true);
    ai36ECF245_wave5_run(p, target, true);
    ai36ECF245_wave6_run(p, target, true);

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai36ECF245_waves_run (int p, playergroup target) {
    ai36ECF245_waves_runPlayer = p;
    ai36ECF245_waves_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai36ECF245_waves_trigger, false, false);
}

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

    ai36ECF245_wave1_enable(p, val);
    ai36ECF245_wave2_enable(p, val);
    ai36ECF245_wave3_enable(p, val);
    ai36ECF245_wave4_enable(p, val);
    ai36ECF245_wave5_enable(p, val);
    ai36ECF245_wave6_enable(p, val);
}

//--------------------------------------------------------------------------------------------------
void ai36ECF245_waves_stop () {
    TriggerStop(ai36ECF245_waves_trigger);

    TriggerStop(ai36ECF245_wave1_trigger);
    TriggerStop(ai36ECF245_wave2_trigger);
    TriggerStop(ai36ECF245_wave3_trigger);
    TriggerStop(ai36ECF245_wave4_trigger);
    TriggerStop(ai36ECF245_wave5_trigger);
    TriggerStop(ai36ECF245_wave6_trigger);
}

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

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

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

//--------------------------------------------------------------------------------------------------
// Start
//--------------------------------------------------------------------------------------------------
bool ai36ECF245_initialized = false;

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

    if (p < 0 || p >= 16) {
        return;
    }
    if (!ai36ECF245_initialized) {
        ai36ECF245_wave1_init();
        ai36ECF245_wave2_init();
        ai36ECF245_wave3_init();
        ai36ECF245_wave4_init();
        ai36ECF245_wave5_init();
        ai36ECF245_wave6_init();
        ai36ECF245_waves_init();

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

        ai36ECF245_initialized = true;
    }

    AICampaignStart(p);
}