ai62C4CA14.galaxy

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

//--------------------------------------------------------------------------------------------------
// Globals
//--------------------------------------------------------------------------------------------------
point[17] ai62C4CA14_defGather;
string[17] ai62C4CA14_customData;
wave[17] ai62C4CA14_lastWave;

//--------------------------------------------------------------------------------------------------
// Attack Wave: Drop 1
//--------------------------------------------------------------------------------------------------
bool[17] ai62C4CA14_wave1_enabled;
wave[17] ai62C4CA14_wave1_lastWave;
trigger ai62C4CA14_wave1_trigger = null;
int ai62C4CA14_wave1_runPlayer;
playergroup ai62C4CA14_wave1_runTarget;

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

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

    ai62C4CA14_wave1_trigger = TriggerCreate("ai62C4CA14_wave1_runFunc");
}

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

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

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

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

    ai62C4CA14_customData[p] = "";

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

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

    AIAttackWaveClearWaypoints(p);

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

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai62C4CA14_wave1_run (int p, playergroup target, bool wait) {
    ai62C4CA14_wave1_runPlayer = p;
    ai62C4CA14_wave1_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai62C4CA14_wave1_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Drop 2
//--------------------------------------------------------------------------------------------------
bool[17] ai62C4CA14_wave2_enabled;
wave[17] ai62C4CA14_wave2_lastWave;
trigger ai62C4CA14_wave2_trigger = null;
int ai62C4CA14_wave2_runPlayer;
playergroup ai62C4CA14_wave2_runTarget;

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

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

    ai62C4CA14_wave2_trigger = TriggerCreate("ai62C4CA14_wave2_runFunc");
}

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

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

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

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

    ai62C4CA14_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 = ai62C4CA14_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

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

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai62C4CA14_wave2_run (int p, playergroup target, bool wait) {
    ai62C4CA14_wave2_runPlayer = p;
    ai62C4CA14_wave2_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai62C4CA14_wave2_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Drop 3
//--------------------------------------------------------------------------------------------------
bool[17] ai62C4CA14_wave3_enabled;
wave[17] ai62C4CA14_wave3_lastWave;
trigger ai62C4CA14_wave3_trigger = null;
int ai62C4CA14_wave3_runPlayer;
playergroup ai62C4CA14_wave3_runTarget;

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

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

    ai62C4CA14_wave3_trigger = TriggerCreate("ai62C4CA14_wave3_runFunc");
}

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

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

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

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

    ai62C4CA14_customData[p] = "";

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

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

    AIAttackWaveClearWaypoints(p);

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

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai62C4CA14_wave3_run (int p, playergroup target, bool wait) {
    ai62C4CA14_wave3_runPlayer = p;
    ai62C4CA14_wave3_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai62C4CA14_wave3_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Drop 4
//--------------------------------------------------------------------------------------------------
bool[17] ai62C4CA14_wave4_enabled;
wave[17] ai62C4CA14_wave4_lastWave;
trigger ai62C4CA14_wave4_trigger = null;
int ai62C4CA14_wave4_runPlayer;
playergroup ai62C4CA14_wave4_runTarget;

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

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

    ai62C4CA14_wave4_trigger = TriggerCreate("ai62C4CA14_wave4_runFunc");
}

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

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

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

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

    ai62C4CA14_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 = ai62C4CA14_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

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

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai62C4CA14_wave4_run (int p, playergroup target, bool wait) {
    ai62C4CA14_wave4_runPlayer = p;
    ai62C4CA14_wave4_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai62C4CA14_wave4_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Drop 5
//--------------------------------------------------------------------------------------------------
bool[17] ai62C4CA14_wave5_enabled;
wave[17] ai62C4CA14_wave5_lastWave;
trigger ai62C4CA14_wave5_trigger = null;
int ai62C4CA14_wave5_runPlayer;
playergroup ai62C4CA14_wave5_runTarget;

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

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

    ai62C4CA14_wave5_trigger = TriggerCreate("ai62C4CA14_wave5_runFunc");
}

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

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

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

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

    ai62C4CA14_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 = ai62C4CA14_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

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

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai62C4CA14_wave5_run (int p, playergroup target, bool wait) {
    ai62C4CA14_wave5_runPlayer = p;
    ai62C4CA14_wave5_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai62C4CA14_wave5_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Repeating Drops
//--------------------------------------------------------------------------------------------------
bool[17] ai62C4CA14_wave6_enabled;
wave[17] ai62C4CA14_wave6_lastWave;
trigger ai62C4CA14_wave6_trigger = null;
int ai62C4CA14_wave6_runPlayer;
playergroup ai62C4CA14_wave6_runTarget;

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

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

    ai62C4CA14_wave6_trigger = TriggerCreate("ai62C4CA14_wave6_runFunc");
}

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

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

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

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

    ai62C4CA14_customData[p] = "";

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

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

    AIAttackWaveClearWaypoints(p);

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

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai62C4CA14_wave6_run (int p, playergroup target, bool wait) {
    ai62C4CA14_wave6_runPlayer = p;
    ai62C4CA14_wave6_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai62C4CA14_wave6_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave Wrappers
//--------------------------------------------------------------------------------------------------
void ai62C4CA14_wave_enable (int w, int p, bool val) {
    if (w == 1) { ai62C4CA14_wave1_enable(p, val); }
    if (w == 2) { ai62C4CA14_wave2_enable(p, val); }
    if (w == 3) { ai62C4CA14_wave3_enable(p, val); }
    if (w == 4) { ai62C4CA14_wave4_enable(p, val); }
    if (w == 5) { ai62C4CA14_wave5_enable(p, val); }
    if (w == 6) { ai62C4CA14_wave6_enable(p, val); }
}

//--------------------------------------------------------------------------------------------------
bool ai62C4CA14_wave_isEnabled (int w, int p) {
    if (w == 1) { return ai62C4CA14_wave1_isEnabled(p); }
    if (w == 2) { return ai62C4CA14_wave2_isEnabled(p); }
    if (w == 3) { return ai62C4CA14_wave3_isEnabled(p); }
    if (w == 4) { return ai62C4CA14_wave4_isEnabled(p); }
    if (w == 5) { return ai62C4CA14_wave5_isEnabled(p); }
    if (w == 6) { return ai62C4CA14_wave6_isEnabled(p); }
    return false;
}

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

//--------------------------------------------------------------------------------------------------
wave ai62C4CA14_wave_createdWave (int w, int p) {
    if (w == 1) { return ai62C4CA14_wave1_createdWave(p); }
    if (w == 2) { return ai62C4CA14_wave2_createdWave(p); }
    if (w == 3) { return ai62C4CA14_wave3_createdWave(p); }
    if (w == 4) { return ai62C4CA14_wave4_createdWave(p); }
    if (w == 5) { return ai62C4CA14_wave5_createdWave(p); }
    if (w == 6) { return ai62C4CA14_wave6_createdWave(p); }
    return null;
}

//--------------------------------------------------------------------------------------------------
void ai62C4CA14_wave_run (int w, int p, playergroup target, bool wait) {
    if (w == 1) { ai62C4CA14_wave1_run(p, target, wait); }
    if (w == 2) { ai62C4CA14_wave2_run(p, target, wait); }
    if (w == 3) { ai62C4CA14_wave3_run(p, target, wait); }
    if (w == 4) { ai62C4CA14_wave4_run(p, target, wait); }
    if (w == 5) { ai62C4CA14_wave5_run(p, target, wait); }
    if (w == 6) { ai62C4CA14_wave6_run(p, target, wait); }
}

//--------------------------------------------------------------------------------------------------
// Attack Wave Sequence
//--------------------------------------------------------------------------------------------------
trigger ai62C4CA14_waves_trigger = null;
int ai62C4CA14_waves_runPlayer;
playergroup ai62C4CA14_waves_runTarget;

//--------------------------------------------------------------------------------------------------
void ai62C4CA14_waves_init () {
    ai62C4CA14_waves_trigger = TriggerCreate("ai62C4CA14_waves_runFunc");
}

//--------------------------------------------------------------------------------------------------
bool ai62C4CA14_waves_runFunc (bool c, bool a) {
    int p = ai62C4CA14_waves_runPlayer;
    playergroup target = ai62C4CA14_waves_runTarget;

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

    ai62C4CA14_wave1_run(p, target, true);
    ai62C4CA14_wave2_run(p, target, true);
    ai62C4CA14_wave3_run(p, target, true);
    ai62C4CA14_wave4_run(p, target, true);
    ai62C4CA14_wave5_run(p, target, true);
    ai62C4CA14_wave6_run(p, target, true);

    while (true) {
        ai62C4CA14_wave6_run(p, target, true);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai62C4CA14_waves_run (int p, playergroup target) {
    ai62C4CA14_waves_runPlayer = p;
    ai62C4CA14_waves_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai62C4CA14_waves_trigger, false, false);
}

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

    ai62C4CA14_wave1_enable(p, val);
    ai62C4CA14_wave2_enable(p, val);
    ai62C4CA14_wave3_enable(p, val);
    ai62C4CA14_wave4_enable(p, val);
    ai62C4CA14_wave5_enable(p, val);
    ai62C4CA14_wave6_enable(p, val);
}

//--------------------------------------------------------------------------------------------------
void ai62C4CA14_waves_stop () {
    TriggerStop(ai62C4CA14_waves_trigger);

    TriggerStop(ai62C4CA14_wave1_trigger);
    TriggerStop(ai62C4CA14_wave2_trigger);
    TriggerStop(ai62C4CA14_wave3_trigger);
    TriggerStop(ai62C4CA14_wave4_trigger);
    TriggerStop(ai62C4CA14_wave5_trigger);
    TriggerStop(ai62C4CA14_wave6_trigger);
}

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

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

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

//--------------------------------------------------------------------------------------------------
// Start
//--------------------------------------------------------------------------------------------------
bool ai62C4CA14_initialized = false;

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

    if (p < 0 || p >= 16) {
        return;
    }
    if (!ai62C4CA14_initialized) {
        ai62C4CA14_wave1_init();
        ai62C4CA14_wave2_init();
        ai62C4CA14_wave3_init();
        ai62C4CA14_wave4_init();
        ai62C4CA14_wave5_init();
        ai62C4CA14_wave6_init();
        ai62C4CA14_waves_init();

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

        ai62C4CA14_initialized = true;
    }

    AICampaignStart(p);
}