ai4D3D7702.galaxy

//==================================================================================================
// 
// Generated AI Script
// 
// AI Name: P03 Amon Zerg TAL
// 
//==================================================================================================
include "TriggerLibs/natives"
include "TriggerLibs/AI"
include "TriggerLibs/Computer"

//--------------------------------------------------------------------------------------------------
// Globals
//--------------------------------------------------------------------------------------------------
point[17] ai4D3D7702_defGather;
string[17] ai4D3D7702_customData;
wave[17] ai4D3D7702_lastWave;

//--------------------------------------------------------------------------------------------------
// Attack Wave: Wave 1 - Initial Attack Q
//--------------------------------------------------------------------------------------------------
bool[17] ai4D3D7702_wave1_enabled;
unitgroup[17] ai4D3D7702_wave1_lastUnits;
wave[17] ai4D3D7702_wave1_lastWave;
trigger ai4D3D7702_wave1_trigger = null;
int ai4D3D7702_wave1_runPlayer;
playergroup ai4D3D7702_wave1_runTarget;

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

    for (init_i = 0; init_i <= 16; init_i += 1) {
        ai4D3D7702_wave1_enabled[init_i] = true;
        ai4D3D7702_wave1_lastUnits[init_i] = null;
        ai4D3D7702_wave1_lastWave[init_i] = null;
    }

    ai4D3D7702_wave1_trigger = TriggerCreate("ai4D3D7702_wave1_runFunc");
}

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

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

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

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

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

    ai4D3D7702_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 160; }
    if (d == 2) { ta = 160; }
    if (d == 3) { ta = 160; }
    if (d == 4) { ta = 160; }
    tg = 0;
    if (d == 1) { tg = 50; }
    if (d == 2) { tg = 50; }
    if (d == 3) { tg = 50; }
    if (d == 4) { tg = 50; }
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    TriggerExecute(TriggerFind("gt_AlarakInitialAttack01Q_Func"), true, false);
    AIAttackWaveSetTargetPlayer(p, target);
    AIAttackWaveSetTargetPoint(p, PointFromId(275));

    gatherPoint = ai4D3D7702_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);
    gatherPoint = PointFromId(245);
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    createPoint = gatherPoint;
    createPoint = PointFromId(513);

    ai4D3D7702_wave1_lastUnits[p] = UnitGroupEmpty();
    createCount = 0;
    if (d == 1) { createCount = 24; }
    if (d == 2) { createCount = 24; }
    if (d == 3) { createCount = 24; }
    if (d == 4) { createCount = 24; }
    if (createCount > 0) {
        UnitCreate(createCount, "Zergling", 0, p, createPoint, PointGetFacing(createPoint));
        AIAttackWaveUseGroup(p, UnitLastCreatedGroup());
        UnitGroupAddUnitGroup(ai4D3D7702_wave1_lastUnits[p], UnitLastCreatedGroup());
    }

    createCount = 0;
    if (d == 1) { createCount = 2; }
    if (d == 2) { createCount = 2; }
    if (d == 3) { createCount = 3; }
    if (d == 4) { createCount = 3; }
    if (createCount > 0) {
        UnitCreate(createCount, "Ultralisk", 0, p, createPoint, PointGetFacing(createPoint));
        AIAttackWaveUseGroup(p, UnitLastCreatedGroup());
        UnitGroupAddUnitGroup(ai4D3D7702_wave1_lastUnits[p], UnitLastCreatedGroup());
    }

    createCount = 0;
    if (d == 1) { createCount = 8; }
    if (d == 2) { createCount = 8; }
    if (d == 3) { createCount = 8; }
    if (d == 4) { createCount = 10; }
    if (createCount > 0) {
        UnitCreate(createCount, "Hydralisk", 0, p, createPoint, PointGetFacing(createPoint));
        AIAttackWaveUseGroup(p, UnitLastCreatedGroup());
        UnitGroupAddUnitGroup(ai4D3D7702_wave1_lastUnits[p], UnitLastCreatedGroup());
    }

    AIAttackWaveSend(p, ts, false);
    ai4D3D7702_wave1_lastWave[p] = WaveLastCreated();
    ai4D3D7702_lastWave[p] = ai4D3D7702_wave1_lastWave[p];
    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai4D3D7702_wave1_run (int p, playergroup target, bool wait) {
    ai4D3D7702_wave1_runPlayer = p;
    ai4D3D7702_wave1_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai4D3D7702_wave1_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Wave 2 - Streaming Wave 1 Q
//--------------------------------------------------------------------------------------------------
bool[17] ai4D3D7702_wave4_enabled;
wave[17] ai4D3D7702_wave4_lastWave;
trigger ai4D3D7702_wave4_trigger = null;
int ai4D3D7702_wave4_runPlayer;
playergroup ai4D3D7702_wave4_runTarget;

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

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

    ai4D3D7702_wave4_trigger = TriggerCreate("ai4D3D7702_wave4_runFunc");
}

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

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

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

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

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

    AIAttackWaveClearWaypoints(p);

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

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai4D3D7702_wave4_run (int p, playergroup target, bool wait) {
    ai4D3D7702_wave4_runPlayer = p;
    ai4D3D7702_wave4_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai4D3D7702_wave4_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Wave 4 - Streaming Wave 2 Q
//--------------------------------------------------------------------------------------------------
bool[17] ai4D3D7702_wave8_enabled;
unitgroup[17] ai4D3D7702_wave8_lastUnits;
wave[17] ai4D3D7702_wave8_lastWave;
trigger ai4D3D7702_wave8_trigger = null;
int ai4D3D7702_wave8_runPlayer;
playergroup ai4D3D7702_wave8_runTarget;

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

    for (init_i = 0; init_i <= 16; init_i += 1) {
        ai4D3D7702_wave8_enabled[init_i] = true;
        ai4D3D7702_wave8_lastUnits[init_i] = null;
        ai4D3D7702_wave8_lastWave[init_i] = null;
    }

    ai4D3D7702_wave8_trigger = TriggerCreate("ai4D3D7702_wave8_runFunc");
}

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

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

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

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

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

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

    AIAttackWaveClearWaypoints(p);

    createPoint = gatherPoint;

    ai4D3D7702_wave8_lastUnits[p] = UnitGroupEmpty();

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

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai4D3D7702_wave8_run (int p, playergroup target, bool wait) {
    ai4D3D7702_wave8_runPlayer = p;
    ai4D3D7702_wave8_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai4D3D7702_wave8_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: 
//--------------------------------------------------------------------------------------------------
bool[17] ai4D3D7702_wave3_enabled;
unitgroup[17] ai4D3D7702_wave3_lastUnits;
wave[17] ai4D3D7702_wave3_lastWave;
trigger ai4D3D7702_wave3_trigger = null;
int ai4D3D7702_wave3_runPlayer;
playergroup ai4D3D7702_wave3_runTarget;

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

    for (init_i = 0; init_i <= 16; init_i += 1) {
        ai4D3D7702_wave3_enabled[init_i] = true;
        ai4D3D7702_wave3_lastUnits[init_i] = null;
        ai4D3D7702_wave3_lastWave[init_i] = null;
    }

    ai4D3D7702_wave3_trigger = TriggerCreate("ai4D3D7702_wave3_runFunc");
}

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

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

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

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

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

    ai4D3D7702_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;
    if (d == 1) { tg = 50; }
    if (d == 2) { tg = 50; }
    if (d == 3) { tg = 50; }
    if (d == 4) { tg = 50; }
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    AIAttackWaveSetTargetPlayer(p, target);
    AIAttackWaveSetTargetPoint(p, PointFromId(275));

    gatherPoint = ai4D3D7702_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);
    gatherPoint = PointFromId(245);
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    createPoint = gatherPoint;
    createPoint = PointFromId(513);

    ai4D3D7702_wave3_lastUnits[p] = UnitGroupEmpty();
    createCount = 0;
    if (d == 1) { createCount = 30; }
    if (d == 2) { createCount = 30; }
    if (d == 3) { createCount = 30; }
    if (d == 4) { createCount = 30; }
    if (createCount > 0) {
        UnitCreate(createCount, "Zergling", 0, p, createPoint, PointGetFacing(createPoint));
        AIAttackWaveUseGroup(p, UnitLastCreatedGroup());
        UnitGroupAddUnitGroup(ai4D3D7702_wave3_lastUnits[p], UnitLastCreatedGroup());
    }

    createCount = 0;
    if (d == 1) { createCount = 16; }
    if (d == 2) { createCount = 16; }
    if (d == 3) { createCount = 16; }
    if (d == 4) { createCount = 16; }
    if (createCount > 0) {
        UnitCreate(createCount, "Hydralisk", 0, p, createPoint, PointGetFacing(createPoint));
        AIAttackWaveUseGroup(p, UnitLastCreatedGroup());
        UnitGroupAddUnitGroup(ai4D3D7702_wave3_lastUnits[p], UnitLastCreatedGroup());
    }

    createCount = 0;
    if (d == 1) { createCount = 3; }
    if (d == 2) { createCount = 3; }
    if (d == 3) { createCount = 4; }
    if (d == 4) { createCount = 4; }
    if (createCount > 0) {
        UnitCreate(createCount, "Ultralisk", 0, p, createPoint, PointGetFacing(createPoint));
        AIAttackWaveUseGroup(p, UnitLastCreatedGroup());
        UnitGroupAddUnitGroup(ai4D3D7702_wave3_lastUnits[p], UnitLastCreatedGroup());
    }

    AIAttackWaveSend(p, ts, false);
    ai4D3D7702_wave3_lastWave[p] = WaveLastCreated();
    ai4D3D7702_lastWave[p] = ai4D3D7702_wave3_lastWave[p];
    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai4D3D7702_wave3_run (int p, playergroup target, bool wait) {
    ai4D3D7702_wave3_runPlayer = p;
    ai4D3D7702_wave3_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai4D3D7702_wave3_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: 
//--------------------------------------------------------------------------------------------------
bool[17] ai4D3D7702_wave5_enabled;
unitgroup[17] ai4D3D7702_wave5_lastUnits;
wave[17] ai4D3D7702_wave5_lastWave;
trigger ai4D3D7702_wave5_trigger = null;
int ai4D3D7702_wave5_runPlayer;
playergroup ai4D3D7702_wave5_runTarget;

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

    for (init_i = 0; init_i <= 16; init_i += 1) {
        ai4D3D7702_wave5_enabled[init_i] = true;
        ai4D3D7702_wave5_lastUnits[init_i] = null;
        ai4D3D7702_wave5_lastWave[init_i] = null;
    }

    ai4D3D7702_wave5_trigger = TriggerCreate("ai4D3D7702_wave5_runFunc");
}

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

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

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

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

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

    ai4D3D7702_customData[p] = "";

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

    gatherPoint = ai4D3D7702_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);
    gatherPoint = PointFromId(245);
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    createPoint = gatherPoint;
    createPoint = PointFromId(513);

    ai4D3D7702_wave5_lastUnits[p] = UnitGroupEmpty();
    createCount = 0;
    if (d == 1) { createCount = 18; }
    if (d == 2) { createCount = 18; }
    if (d == 3) { createCount = 18; }
    if (d == 4) { createCount = 18; }
    if (createCount > 0) {
        UnitCreate(createCount, "Zergling", 0, p, createPoint, PointGetFacing(createPoint));
        AIAttackWaveUseGroup(p, UnitLastCreatedGroup());
        UnitGroupAddUnitGroup(ai4D3D7702_wave5_lastUnits[p], UnitLastCreatedGroup());
    }

    createCount = 0;
    if (d == 1) { createCount = 9; }
    if (d == 2) { createCount = 9; }
    if (d == 3) { createCount = 12; }
    if (d == 4) { createCount = 12; }
    if (createCount > 0) {
        UnitCreate(createCount, "Roach", 0, p, createPoint, PointGetFacing(createPoint));
        AIAttackWaveUseGroup(p, UnitLastCreatedGroup());
        UnitGroupAddUnitGroup(ai4D3D7702_wave5_lastUnits[p], UnitLastCreatedGroup());
    }

    createCount = 0;
    if (d == 1) { createCount = 3; }
    if (d == 2) { createCount = 3; }
    if (d == 3) { createCount = 3; }
    if (d == 4) { createCount = 3; }
    if (createCount > 0) {
        UnitCreate(createCount, "Ultralisk", 0, p, createPoint, PointGetFacing(createPoint));
        AIAttackWaveUseGroup(p, UnitLastCreatedGroup());
        UnitGroupAddUnitGroup(ai4D3D7702_wave5_lastUnits[p], UnitLastCreatedGroup());
    }

    createCount = 0;
    if (d == 1) { createCount = 9; }
    if (d == 2) { createCount = 9; }
    if (d == 3) { createCount = 9; }
    if (d == 4) { createCount = 12; }
    if (createCount > 0) {
        UnitCreate(createCount, "Mutalisk", 0, p, createPoint, PointGetFacing(createPoint));
        AIAttackWaveUseGroup(p, UnitLastCreatedGroup());
        UnitGroupAddUnitGroup(ai4D3D7702_wave5_lastUnits[p], UnitLastCreatedGroup());
    }

    createCount = 0;
    if (d == 1) { createCount = 1; }
    if (d == 2) { createCount = 1; }
    if (d == 3) { createCount = 1; }
    if (d == 4) { createCount = 1; }
    if (createCount > 0) {
        UnitCreate(createCount, "Overseer", 0, p, createPoint, PointGetFacing(createPoint));
        AIAttackWaveUseGroup(p, UnitLastCreatedGroup());
        UnitGroupAddUnitGroup(ai4D3D7702_wave5_lastUnits[p], UnitLastCreatedGroup());
    }

    AIAttackWaveSend(p, ts, false);
    ai4D3D7702_wave5_lastWave[p] = WaveLastCreated();
    ai4D3D7702_lastWave[p] = ai4D3D7702_wave5_lastWave[p];
    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai4D3D7702_wave5_run (int p, playergroup target, bool wait) {
    ai4D3D7702_wave5_runPlayer = p;
    ai4D3D7702_wave5_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai4D3D7702_wave5_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Wave 7 - Streaming Wave 7
//--------------------------------------------------------------------------------------------------
bool[17] ai4D3D7702_wave15_enabled;
unitgroup[17] ai4D3D7702_wave15_lastUnits;
wave[17] ai4D3D7702_wave15_lastWave;
trigger ai4D3D7702_wave15_trigger = null;
int ai4D3D7702_wave15_runPlayer;
playergroup ai4D3D7702_wave15_runTarget;

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

    for (init_i = 0; init_i <= 16; init_i += 1) {
        ai4D3D7702_wave15_enabled[init_i] = true;
        ai4D3D7702_wave15_lastUnits[init_i] = null;
        ai4D3D7702_wave15_lastWave[init_i] = null;
    }

    ai4D3D7702_wave15_trigger = TriggerCreate("ai4D3D7702_wave15_runFunc");
}

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

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

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

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

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

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

    AIAttackWaveClearWaypoints(p);

    createPoint = gatherPoint;

    ai4D3D7702_wave15_lastUnits[p] = UnitGroupEmpty();

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

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai4D3D7702_wave15_run (int p, playergroup target, bool wait) {
    ai4D3D7702_wave15_runPlayer = p;
    ai4D3D7702_wave15_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai4D3D7702_wave15_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: 
//--------------------------------------------------------------------------------------------------
bool[17] ai4D3D7702_wave6_enabled;
unitgroup[17] ai4D3D7702_wave6_lastUnits;
wave[17] ai4D3D7702_wave6_lastWave;
trigger ai4D3D7702_wave6_trigger = null;
int ai4D3D7702_wave6_runPlayer;
playergroup ai4D3D7702_wave6_runTarget;

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

    for (init_i = 0; init_i <= 16; init_i += 1) {
        ai4D3D7702_wave6_enabled[init_i] = true;
        ai4D3D7702_wave6_lastUnits[init_i] = null;
        ai4D3D7702_wave6_lastWave[init_i] = null;
    }

    ai4D3D7702_wave6_trigger = TriggerCreate("ai4D3D7702_wave6_runFunc");
}

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

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

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

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

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

    ai4D3D7702_customData[p] = "";

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

    gatherPoint = ai4D3D7702_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);
    gatherPoint = PointFromId(245);
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    createPoint = gatherPoint;
    createPoint = PointFromId(513);

    ai4D3D7702_wave6_lastUnits[p] = UnitGroupEmpty();
    createCount = 0;
    if (d == 1) { createCount = 18; }
    if (d == 2) { createCount = 18; }
    if (d == 3) { createCount = 18; }
    if (d == 4) { createCount = 18; }
    if (createCount > 0) {
        UnitCreate(createCount, "Zergling", 0, p, createPoint, PointGetFacing(createPoint));
        AIAttackWaveUseGroup(p, UnitLastCreatedGroup());
        UnitGroupAddUnitGroup(ai4D3D7702_wave6_lastUnits[p], UnitLastCreatedGroup());
    }

    createCount = 0;
    if (d == 1) { createCount = 4; }
    if (d == 2) { createCount = 4; }
    if (d == 3) { createCount = 5; }
    if (d == 4) { createCount = 6; }
    if (createCount > 0) {
        UnitCreate(createCount, "InfestedAbomination", 0, p, createPoint, PointGetFacing(createPoint));
        AIAttackWaveUseGroup(p, UnitLastCreatedGroup());
        UnitGroupAddUnitGroup(ai4D3D7702_wave6_lastUnits[p], UnitLastCreatedGroup());
    }

    createCount = 0;
    if (d == 1) { createCount = 4; }
    if (d == 2) { createCount = 4; }
    if (d == 3) { createCount = 5; }
    if (d == 4) { createCount = 6; }
    if (createCount > 0) {
        UnitCreate(createCount, "Guardian", 0, p, createPoint, PointGetFacing(createPoint));
        AIAttackWaveUseGroup(p, UnitLastCreatedGroup());
        UnitGroupAddUnitGroup(ai4D3D7702_wave6_lastUnits[p], UnitLastCreatedGroup());
    }

    createCount = 0;
    if (d == 1) { createCount = 6; }
    if (d == 2) { createCount = 6; }
    if (d == 3) { createCount = 8; }
    if (d == 4) { createCount = 8; }
    if (createCount > 0) {
        UnitCreate(createCount, "Mutalisk", 0, p, createPoint, PointGetFacing(createPoint));
        AIAttackWaveUseGroup(p, UnitLastCreatedGroup());
        UnitGroupAddUnitGroup(ai4D3D7702_wave6_lastUnits[p], UnitLastCreatedGroup());
    }

    AIAttackWaveSend(p, ts, false);
    ai4D3D7702_wave6_lastWave[p] = WaveLastCreated();
    ai4D3D7702_lastWave[p] = ai4D3D7702_wave6_lastWave[p];
    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai4D3D7702_wave6_run (int p, playergroup target, bool wait) {
    ai4D3D7702_wave6_runPlayer = p;
    ai4D3D7702_wave6_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai4D3D7702_wave6_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: 
//--------------------------------------------------------------------------------------------------
bool[17] ai4D3D7702_wave7_enabled;
unitgroup[17] ai4D3D7702_wave7_lastUnits;
wave[17] ai4D3D7702_wave7_lastWave;
trigger ai4D3D7702_wave7_trigger = null;
int ai4D3D7702_wave7_runPlayer;
playergroup ai4D3D7702_wave7_runTarget;

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

    for (init_i = 0; init_i <= 16; init_i += 1) {
        ai4D3D7702_wave7_enabled[init_i] = true;
        ai4D3D7702_wave7_lastUnits[init_i] = null;
        ai4D3D7702_wave7_lastWave[init_i] = null;
    }

    ai4D3D7702_wave7_trigger = TriggerCreate("ai4D3D7702_wave7_runFunc");
}

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

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

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

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

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

    ai4D3D7702_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;
    if (d == 1) { tg = 45; }
    if (d == 2) { tg = 45; }
    if (d == 3) { tg = 45; }
    if (d == 4) { tg = 45; }
    ts = ta;
    if (tg > 0 && tg < ta) {
        Wait(ta - tg, c_timeAI);
        ts = tg;
    }
    AIAttackWaveSetTargetPlayer(p, target);
    AIAttackWaveSetTargetPoint(p, PointFromId(275));

    gatherPoint = ai4D3D7702_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);
    gatherPoint = PointFromId(245);
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    createPoint = gatherPoint;
    createPoint = PointFromId(513);

    ai4D3D7702_wave7_lastUnits[p] = UnitGroupEmpty();
    createCount = 0;
    if (d == 1) { createCount = 24; }
    if (d == 2) { createCount = 24; }
    if (d == 3) { createCount = 24; }
    if (d == 4) { createCount = 24; }
    if (createCount > 0) {
        UnitCreate(createCount, "Zergling", 0, p, createPoint, PointGetFacing(createPoint));
        AIAttackWaveUseGroup(p, UnitLastCreatedGroup());
        UnitGroupAddUnitGroup(ai4D3D7702_wave7_lastUnits[p], UnitLastCreatedGroup());
    }

    createCount = 0;
    if (d == 1) { createCount = 3; }
    if (d == 2) { createCount = 3; }
    if (d == 3) { createCount = 4; }
    if (d == 4) { createCount = 4; }
    if (createCount > 0) {
        UnitCreate(createCount, "Ultralisk", 0, p, createPoint, PointGetFacing(createPoint));
        AIAttackWaveUseGroup(p, UnitLastCreatedGroup());
        UnitGroupAddUnitGroup(ai4D3D7702_wave7_lastUnits[p], UnitLastCreatedGroup());
    }

    createCount = 0;
    if (d == 1) { createCount = 7; }
    if (d == 2) { createCount = 7; }
    if (d == 3) { createCount = 7; }
    if (d == 4) { createCount = 9; }
    if (createCount > 0) {
        UnitCreate(createCount, "Hydralisk", 0, p, createPoint, PointGetFacing(createPoint));
        AIAttackWaveUseGroup(p, UnitLastCreatedGroup());
        UnitGroupAddUnitGroup(ai4D3D7702_wave7_lastUnits[p], UnitLastCreatedGroup());
    }

    createCount = 0;
    if (d == 1) { createCount = 7; }
    if (d == 2) { createCount = 7; }
    if (d == 3) { createCount = 7; }
    if (d == 4) { createCount = 9; }
    if (createCount > 0) {
        UnitCreate(createCount, "Roach", 0, p, createPoint, PointGetFacing(createPoint));
        AIAttackWaveUseGroup(p, UnitLastCreatedGroup());
        UnitGroupAddUnitGroup(ai4D3D7702_wave7_lastUnits[p], UnitLastCreatedGroup());
    }

    createCount = 0;
    if (d == 1) { createCount = 1; }
    if (d == 2) { createCount = 1; }
    if (d == 3) { createCount = 1; }
    if (d == 4) { createCount = 1; }
    if (createCount > 0) {
        UnitCreate(createCount, "Overseer", 0, p, createPoint, PointGetFacing(createPoint));
        AIAttackWaveUseGroup(p, UnitLastCreatedGroup());
        UnitGroupAddUnitGroup(ai4D3D7702_wave7_lastUnits[p], UnitLastCreatedGroup());
    }

    AIAttackWaveSend(p, ts, false);
    ai4D3D7702_wave7_lastWave[p] = WaveLastCreated();
    ai4D3D7702_lastWave[p] = ai4D3D7702_wave7_lastWave[p];
    Wait(ts, c_timeAI);
    tf = 0;
    if (tf > 0) {
        Wait(tf, c_timeAI);
    }

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai4D3D7702_wave7_run (int p, playergroup target, bool wait) {
    ai4D3D7702_wave7_runPlayer = p;
    ai4D3D7702_wave7_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai4D3D7702_wave7_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave Wrappers
//--------------------------------------------------------------------------------------------------
void ai4D3D7702_wave_enable (int w, int p, bool val) {
    if (w == 1) { ai4D3D7702_wave1_enable(p, val); }
    if (w == 4) { ai4D3D7702_wave4_enable(p, val); }
    if (w == 8) { ai4D3D7702_wave8_enable(p, val); }
    if (w == 3) { ai4D3D7702_wave3_enable(p, val); }
    if (w == 5) { ai4D3D7702_wave5_enable(p, val); }
    if (w == 15) { ai4D3D7702_wave15_enable(p, val); }
    if (w == 6) { ai4D3D7702_wave6_enable(p, val); }
    if (w == 7) { ai4D3D7702_wave7_enable(p, val); }
}

//--------------------------------------------------------------------------------------------------
bool ai4D3D7702_wave_isEnabled (int w, int p) {
    if (w == 1) { return ai4D3D7702_wave1_isEnabled(p); }
    if (w == 4) { return ai4D3D7702_wave4_isEnabled(p); }
    if (w == 8) { return ai4D3D7702_wave8_isEnabled(p); }
    if (w == 3) { return ai4D3D7702_wave3_isEnabled(p); }
    if (w == 5) { return ai4D3D7702_wave5_isEnabled(p); }
    if (w == 15) { return ai4D3D7702_wave15_isEnabled(p); }
    if (w == 6) { return ai4D3D7702_wave6_isEnabled(p); }
    if (w == 7) { return ai4D3D7702_wave7_isEnabled(p); }
    return false;
}

//--------------------------------------------------------------------------------------------------
unitgroup ai4D3D7702_wave_createdUnits (int w, int p) {
    if (w == 1) { return ai4D3D7702_wave1_createdUnits(p); }
    if (w == 8) { return ai4D3D7702_wave8_createdUnits(p); }
    if (w == 3) { return ai4D3D7702_wave3_createdUnits(p); }
    if (w == 5) { return ai4D3D7702_wave5_createdUnits(p); }
    if (w == 15) { return ai4D3D7702_wave15_createdUnits(p); }
    if (w == 6) { return ai4D3D7702_wave6_createdUnits(p); }
    if (w == 7) { return ai4D3D7702_wave7_createdUnits(p); }
    return null;
}

//--------------------------------------------------------------------------------------------------
wave ai4D3D7702_wave_createdWave (int w, int p) {
    if (w == 1) { return ai4D3D7702_wave1_createdWave(p); }
    if (w == 4) { return ai4D3D7702_wave4_createdWave(p); }
    if (w == 8) { return ai4D3D7702_wave8_createdWave(p); }
    if (w == 3) { return ai4D3D7702_wave3_createdWave(p); }
    if (w == 5) { return ai4D3D7702_wave5_createdWave(p); }
    if (w == 15) { return ai4D3D7702_wave15_createdWave(p); }
    if (w == 6) { return ai4D3D7702_wave6_createdWave(p); }
    if (w == 7) { return ai4D3D7702_wave7_createdWave(p); }
    return null;
}

//--------------------------------------------------------------------------------------------------
void ai4D3D7702_wave_run (int w, int p, playergroup target, bool wait) {
    if (w == 1) { ai4D3D7702_wave1_run(p, target, wait); }
    if (w == 4) { ai4D3D7702_wave4_run(p, target, wait); }
    if (w == 8) { ai4D3D7702_wave8_run(p, target, wait); }
    if (w == 3) { ai4D3D7702_wave3_run(p, target, wait); }
    if (w == 5) { ai4D3D7702_wave5_run(p, target, wait); }
    if (w == 15) { ai4D3D7702_wave15_run(p, target, wait); }
    if (w == 6) { ai4D3D7702_wave6_run(p, target, wait); }
    if (w == 7) { ai4D3D7702_wave7_run(p, target, wait); }
}

//--------------------------------------------------------------------------------------------------
// Attack Wave Sequence
//--------------------------------------------------------------------------------------------------
trigger ai4D3D7702_waves_trigger = null;
int ai4D3D7702_waves_runPlayer;
playergroup ai4D3D7702_waves_runTarget;

//--------------------------------------------------------------------------------------------------
void ai4D3D7702_waves_init () {
    ai4D3D7702_waves_trigger = TriggerCreate("ai4D3D7702_waves_runFunc");
}

//--------------------------------------------------------------------------------------------------
bool ai4D3D7702_waves_runFunc (bool c, bool a) {
    int p = ai4D3D7702_waves_runPlayer;
    playergroup target = ai4D3D7702_waves_runTarget;

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

    ai4D3D7702_wave1_run(p, target, true);
    ai4D3D7702_wave4_run(p, target, true);
    ai4D3D7702_wave8_run(p, target, true);
    ai4D3D7702_wave3_run(p, target, true);
    ai4D3D7702_wave5_run(p, target, true);
    ai4D3D7702_wave15_run(p, target, true);
    ai4D3D7702_wave6_run(p, target, true);
    ai4D3D7702_wave7_run(p, target, true);

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai4D3D7702_waves_run (int p, playergroup target) {
    ai4D3D7702_waves_runPlayer = p;
    ai4D3D7702_waves_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai4D3D7702_waves_trigger, false, false);
}

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

    ai4D3D7702_wave1_enable(p, val);
    ai4D3D7702_wave4_enable(p, val);
    ai4D3D7702_wave8_enable(p, val);
    ai4D3D7702_wave3_enable(p, val);
    ai4D3D7702_wave5_enable(p, val);
    ai4D3D7702_wave15_enable(p, val);
    ai4D3D7702_wave6_enable(p, val);
    ai4D3D7702_wave7_enable(p, val);
}

//--------------------------------------------------------------------------------------------------
void ai4D3D7702_waves_stop () {
    TriggerStop(ai4D3D7702_waves_trigger);

    TriggerStop(ai4D3D7702_wave1_trigger);
    TriggerStop(ai4D3D7702_wave4_trigger);
    TriggerStop(ai4D3D7702_wave8_trigger);
    TriggerStop(ai4D3D7702_wave3_trigger);
    TriggerStop(ai4D3D7702_wave5_trigger);
    TriggerStop(ai4D3D7702_wave15_trigger);
    TriggerStop(ai4D3D7702_wave6_trigger);
    TriggerStop(ai4D3D7702_wave7_trigger);
}

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

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

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

//--------------------------------------------------------------------------------------------------
// Start
//--------------------------------------------------------------------------------------------------
bool ai4D3D7702_initialized = false;

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

    if (p < 0 || p >= 16) {
        return;
    }
    if (!ai4D3D7702_initialized) {
        ai4D3D7702_wave1_init();
        ai4D3D7702_wave4_init();
        ai4D3D7702_wave8_init();
        ai4D3D7702_wave3_init();
        ai4D3D7702_wave5_init();
        ai4D3D7702_wave15_init();
        ai4D3D7702_wave6_init();
        ai4D3D7702_wave7_init();
        ai4D3D7702_waves_init();

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

        ai4D3D7702_initialized = true;
    }

    AICampaignStart(p);
}