ai5D126363.galaxy

//==================================================================================================
// 
// Generated AI Script
// 
// AI Name: P02 Amon Zerg NER
// 
//==================================================================================================
include "TriggerLibs/natives"
include "TriggerLibs/AI"
include "TriggerLibs/Computer"

//--------------------------------------------------------------------------------------------------
// Globals
//--------------------------------------------------------------------------------------------------
point[17] ai5D126363_defGather;
string[17] ai5D126363_customData;
wave[17] ai5D126363_lastWave;

//--------------------------------------------------------------------------------------------------
// Attack Wave: Wave 1 - Initial Attack Q
//--------------------------------------------------------------------------------------------------
bool[17] ai5D126363_wave2_enabled;
unitgroup[17] ai5D126363_wave2_lastUnits;
wave[17] ai5D126363_wave2_lastWave;
trigger ai5D126363_wave2_trigger = null;
int ai5D126363_wave2_runPlayer;
playergroup ai5D126363_wave2_runTarget;

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

    for (init_i = 0; init_i <= 16; init_i += 1) {
        ai5D126363_wave2_enabled[init_i] = true;
        ai5D126363_wave2_lastUnits[init_i] = null;
        ai5D126363_wave2_lastWave[init_i] = null;
    }

    ai5D126363_wave2_trigger = TriggerCreate("ai5D126363_wave2_runFunc");
}

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

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

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

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

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

    ai5D126363_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;
    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_VorazunInitialAttack01Q_Func"), true, false);
    AIAttackWaveSetTargetPlayer(p, target);
    AIAttackWaveSetTargetPoint(p, PointFromId(293));

    gatherPoint = ai5D126363_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);
    gatherPoint = PointFromId(244);
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    createPoint = gatherPoint;
    createPoint = PointFromId(512);

    ai5D126363_wave2_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(ai5D126363_wave2_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, "Roach", 0, p, createPoint, PointGetFacing(createPoint));
        AIAttackWaveUseGroup(p, UnitLastCreatedGroup());
        UnitGroupAddUnitGroup(ai5D126363_wave2_lastUnits[p], UnitLastCreatedGroup());
    }

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

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

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai5D126363_wave2_run (int p, playergroup target, bool wait) {
    ai5D126363_wave2_runPlayer = p;
    ai5D126363_wave2_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai5D126363_wave2_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: 
//--------------------------------------------------------------------------------------------------
bool[17] ai5D126363_wave6_enabled;
unitgroup[17] ai5D126363_wave6_lastUnits;
wave[17] ai5D126363_wave6_lastWave;
trigger ai5D126363_wave6_trigger = null;
int ai5D126363_wave6_runPlayer;
playergroup ai5D126363_wave6_runTarget;

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

    for (init_i = 0; init_i <= 16; init_i += 1) {
        ai5D126363_wave6_enabled[init_i] = true;
        ai5D126363_wave6_lastUnits[init_i] = null;
        ai5D126363_wave6_lastWave[init_i] = null;
    }

    ai5D126363_wave6_trigger = TriggerCreate("ai5D126363_wave6_runFunc");
}

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

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

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

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

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

    ai5D126363_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 = 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(293));

    gatherPoint = ai5D126363_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);
    gatherPoint = PointFromId(244);
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    createPoint = gatherPoint;
    createPoint = PointFromId(512);

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

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

    createCount = 0;
    if (d == 1) { createCount = 2; }
    if (d == 2) { createCount = 2; }
    if (d == 3) { createCount = 3; }
    if (d == 4) { createCount = 4; }
    if (createCount > 0) {
        UnitCreate(createCount, "InfestedAbomination", 0, p, createPoint, PointGetFacing(createPoint));
        AIAttackWaveUseGroup(p, UnitLastCreatedGroup());
        UnitGroupAddUnitGroup(ai5D126363_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 = 5; }
    if (createCount > 0) {
        UnitCreate(createCount, "Mutalisk", 0, p, createPoint, PointGetFacing(createPoint));
        AIAttackWaveUseGroup(p, UnitLastCreatedGroup());
        UnitGroupAddUnitGroup(ai5D126363_wave6_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(ai5D126363_wave6_lastUnits[p], UnitLastCreatedGroup());
    }

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

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai5D126363_wave6_run (int p, playergroup target, bool wait) {
    ai5D126363_wave6_runPlayer = p;
    ai5D126363_wave6_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai5D126363_wave6_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: 
//--------------------------------------------------------------------------------------------------
bool[17] ai5D126363_wave7_enabled;
unitgroup[17] ai5D126363_wave7_lastUnits;
wave[17] ai5D126363_wave7_lastWave;
trigger ai5D126363_wave7_trigger = null;
int ai5D126363_wave7_runPlayer;
playergroup ai5D126363_wave7_runTarget;

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

    for (init_i = 0; init_i <= 16; init_i += 1) {
        ai5D126363_wave7_enabled[init_i] = true;
        ai5D126363_wave7_lastUnits[init_i] = null;
        ai5D126363_wave7_lastWave[init_i] = null;
    }

    ai5D126363_wave7_trigger = TriggerCreate("ai5D126363_wave7_runFunc");
}

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

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

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

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

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

    ai5D126363_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 360; }
    if (d == 2) { ta = 360; }
    if (d == 3) { ta = 360; }
    if (d == 4) { ta = 360; }
    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(293));

    gatherPoint = ai5D126363_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);
    gatherPoint = PointFromId(244);
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    createPoint = gatherPoint;
    createPoint = PointFromId(512);

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

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

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

    createCount = 0;
    if (d == 1) { createCount = 6; }
    if (d == 2) { createCount = 6; }
    if (d == 3) { createCount = 7; }
    if (d == 4) { createCount = 8; }
    if (createCount > 0) {
        UnitCreate(createCount, "Mutalisk", 0, p, createPoint, PointGetFacing(createPoint));
        AIAttackWaveUseGroup(p, UnitLastCreatedGroup());
        UnitGroupAddUnitGroup(ai5D126363_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(ai5D126363_wave7_lastUnits[p], UnitLastCreatedGroup());
    }

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

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai5D126363_wave7_run (int p, playergroup target, bool wait) {
    ai5D126363_wave7_runPlayer = p;
    ai5D126363_wave7_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai5D126363_wave7_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: 
//--------------------------------------------------------------------------------------------------
bool[17] ai5D126363_wave5_enabled;
unitgroup[17] ai5D126363_wave5_lastUnits;
wave[17] ai5D126363_wave5_lastWave;
trigger ai5D126363_wave5_trigger = null;
int ai5D126363_wave5_runPlayer;
playergroup ai5D126363_wave5_runTarget;

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

    for (init_i = 0; init_i <= 16; init_i += 1) {
        ai5D126363_wave5_enabled[init_i] = true;
        ai5D126363_wave5_lastUnits[init_i] = null;
        ai5D126363_wave5_lastWave[init_i] = null;
    }

    ai5D126363_wave5_trigger = TriggerCreate("ai5D126363_wave5_runFunc");
}

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

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

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

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

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

    ai5D126363_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;
    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(293));

    gatherPoint = ai5D126363_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);
    gatherPoint = PointFromId(244);
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    createPoint = gatherPoint;
    createPoint = PointFromId(512);

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

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

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

    createCount = 0;
    if (d == 1) { createCount = 5; }
    if (d == 2) { createCount = 5; }
    if (d == 3) { createCount = 6; }
    if (d == 4) { createCount = 6; }
    if (createCount > 0) {
        UnitCreate(createCount, "Guardian", 0, p, createPoint, PointGetFacing(createPoint));
        AIAttackWaveUseGroup(p, UnitLastCreatedGroup());
        UnitGroupAddUnitGroup(ai5D126363_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(ai5D126363_wave5_lastUnits[p], UnitLastCreatedGroup());
    }

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

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai5D126363_wave5_run (int p, playergroup target, bool wait) {
    ai5D126363_wave5_runPlayer = p;
    ai5D126363_wave5_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai5D126363_wave5_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Wave 3 - Streaming Wave 3 Q
//--------------------------------------------------------------------------------------------------
bool[17] ai5D126363_wave8_enabled;
unitgroup[17] ai5D126363_wave8_lastUnits;
wave[17] ai5D126363_wave8_lastWave;
trigger ai5D126363_wave8_trigger = null;
int ai5D126363_wave8_runPlayer;
playergroup ai5D126363_wave8_runTarget;

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

    for (init_i = 0; init_i <= 16; init_i += 1) {
        ai5D126363_wave8_enabled[init_i] = true;
        ai5D126363_wave8_lastUnits[init_i] = null;
        ai5D126363_wave8_lastWave[init_i] = null;
    }

    ai5D126363_wave8_trigger = TriggerCreate("ai5D126363_wave8_runFunc");
}

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

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

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

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

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

    ai5D126363_customData[p] = "";

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

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

    AIAttackWaveClearWaypoints(p);

    createPoint = gatherPoint;

    ai5D126363_wave8_lastUnits[p] = UnitGroupEmpty();

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

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai5D126363_wave8_run (int p, playergroup target, bool wait) {
    ai5D126363_wave8_runPlayer = p;
    ai5D126363_wave8_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai5D126363_wave8_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: 
//--------------------------------------------------------------------------------------------------
bool[17] ai5D126363_wave1_enabled;
unitgroup[17] ai5D126363_wave1_lastUnits;
wave[17] ai5D126363_wave1_lastWave;
trigger ai5D126363_wave1_trigger = null;
int ai5D126363_wave1_runPlayer;
playergroup ai5D126363_wave1_runTarget;

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

    for (init_i = 0; init_i <= 16; init_i += 1) {
        ai5D126363_wave1_enabled[init_i] = true;
        ai5D126363_wave1_lastUnits[init_i] = null;
        ai5D126363_wave1_lastWave[init_i] = null;
    }

    ai5D126363_wave1_trigger = TriggerCreate("ai5D126363_wave1_runFunc");
}

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

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

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

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

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

    ai5D126363_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 90; }
    if (d == 2) { ta = 90; }
    if (d == 3) { ta = 90; }
    if (d == 4) { ta = 90; }
    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(293));

    gatherPoint = ai5D126363_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);
    gatherPoint = PointFromId(244);
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    createPoint = gatherPoint;
    createPoint = PointFromId(512);

    ai5D126363_wave1_lastUnits[p] = UnitGroupEmpty();
    createCount = 0;
    if (d == 1) { createCount = 20; }
    if (d == 2) { createCount = 20; }
    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(ai5D126363_wave1_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, "InfestedAbomination", 0, p, createPoint, PointGetFacing(createPoint));
        AIAttackWaveUseGroup(p, UnitLastCreatedGroup());
        UnitGroupAddUnitGroup(ai5D126363_wave1_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(ai5D126363_wave1_lastUnits[p], UnitLastCreatedGroup());
    }

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

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

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai5D126363_wave1_run (int p, playergroup target, bool wait) {
    ai5D126363_wave1_runPlayer = p;
    ai5D126363_wave1_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai5D126363_wave1_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: Wave 5 - Streaming Wave 6
//--------------------------------------------------------------------------------------------------
bool[17] ai5D126363_wave64_enabled;
unitgroup[17] ai5D126363_wave64_lastUnits;
wave[17] ai5D126363_wave64_lastWave;
trigger ai5D126363_wave64_trigger = null;
int ai5D126363_wave64_runPlayer;
playergroup ai5D126363_wave64_runTarget;

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

    for (init_i = 0; init_i <= 16; init_i += 1) {
        ai5D126363_wave64_enabled[init_i] = true;
        ai5D126363_wave64_lastUnits[init_i] = null;
        ai5D126363_wave64_lastWave[init_i] = null;
    }

    ai5D126363_wave64_trigger = TriggerCreate("ai5D126363_wave64_runFunc");
}

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

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

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

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

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

    ai5D126363_customData[p] = "";

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

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

    AIAttackWaveClearWaypoints(p);

    createPoint = gatherPoint;

    ai5D126363_wave64_lastUnits[p] = UnitGroupEmpty();

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

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai5D126363_wave64_run (int p, playergroup target, bool wait) {
    ai5D126363_wave64_runPlayer = p;
    ai5D126363_wave64_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai5D126363_wave64_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: 
//--------------------------------------------------------------------------------------------------
bool[17] ai5D126363_wave3_enabled;
unitgroup[17] ai5D126363_wave3_lastUnits;
wave[17] ai5D126363_wave3_lastWave;
trigger ai5D126363_wave3_trigger = null;
int ai5D126363_wave3_runPlayer;
playergroup ai5D126363_wave3_runTarget;

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

    for (init_i = 0; init_i <= 16; init_i += 1) {
        ai5D126363_wave3_enabled[init_i] = true;
        ai5D126363_wave3_lastUnits[init_i] = null;
        ai5D126363_wave3_lastWave[init_i] = null;
    }

    ai5D126363_wave3_trigger = TriggerCreate("ai5D126363_wave3_runFunc");
}

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

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

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

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

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

    ai5D126363_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 110; }
    if (d == 2) { ta = 110; }
    if (d == 3) { ta = 110; }
    if (d == 4) { ta = 110; }
    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(293));

    gatherPoint = ai5D126363_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);
    gatherPoint = PointFromId(244);
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    createPoint = gatherPoint;
    createPoint = PointFromId(512);

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

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

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

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

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

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai5D126363_wave3_run (int p, playergroup target, bool wait) {
    ai5D126363_wave3_runPlayer = p;
    ai5D126363_wave3_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai5D126363_wave3_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave: 
//--------------------------------------------------------------------------------------------------
bool[17] ai5D126363_wave4_enabled;
unitgroup[17] ai5D126363_wave4_lastUnits;
wave[17] ai5D126363_wave4_lastWave;
trigger ai5D126363_wave4_trigger = null;
int ai5D126363_wave4_runPlayer;
playergroup ai5D126363_wave4_runTarget;

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

    for (init_i = 0; init_i <= 16; init_i += 1) {
        ai5D126363_wave4_enabled[init_i] = true;
        ai5D126363_wave4_lastUnits[init_i] = null;
        ai5D126363_wave4_lastWave[init_i] = null;
    }

    ai5D126363_wave4_trigger = TriggerCreate("ai5D126363_wave4_runFunc");
}

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

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

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

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

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

    ai5D126363_customData[p] = "";

    ta = 0;
    if (d == 1) { ta = 130; }
    if (d == 2) { ta = 130; }
    if (d == 3) { ta = 130; }
    if (d == 4) { ta = 130; }
    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(293));

    gatherPoint = ai5D126363_defGather[p];
    AIAttackWaveSetGatherPoint(p, gatherPoint);
    gatherPoint = PointFromId(244);
    AIAttackWaveSetGatherPoint(p, gatherPoint);

    AIAttackWaveClearWaypoints(p);

    createPoint = gatherPoint;
    createPoint = PointFromId(512);

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

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

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

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

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

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai5D126363_wave4_run (int p, playergroup target, bool wait) {
    ai5D126363_wave4_runPlayer = p;
    ai5D126363_wave4_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai5D126363_wave4_trigger, false, wait);
}

//--------------------------------------------------------------------------------------------------
// Attack Wave Wrappers
//--------------------------------------------------------------------------------------------------
void ai5D126363_wave_enable (int w, int p, bool val) {
    if (w == 2) { ai5D126363_wave2_enable(p, val); }
    if (w == 6) { ai5D126363_wave6_enable(p, val); }
    if (w == 7) { ai5D126363_wave7_enable(p, val); }
    if (w == 5) { ai5D126363_wave5_enable(p, val); }
    if (w == 8) { ai5D126363_wave8_enable(p, val); }
    if (w == 1) { ai5D126363_wave1_enable(p, val); }
    if (w == 64) { ai5D126363_wave64_enable(p, val); }
    if (w == 3) { ai5D126363_wave3_enable(p, val); }
    if (w == 4) { ai5D126363_wave4_enable(p, val); }
}

//--------------------------------------------------------------------------------------------------
bool ai5D126363_wave_isEnabled (int w, int p) {
    if (w == 2) { return ai5D126363_wave2_isEnabled(p); }
    if (w == 6) { return ai5D126363_wave6_isEnabled(p); }
    if (w == 7) { return ai5D126363_wave7_isEnabled(p); }
    if (w == 5) { return ai5D126363_wave5_isEnabled(p); }
    if (w == 8) { return ai5D126363_wave8_isEnabled(p); }
    if (w == 1) { return ai5D126363_wave1_isEnabled(p); }
    if (w == 64) { return ai5D126363_wave64_isEnabled(p); }
    if (w == 3) { return ai5D126363_wave3_isEnabled(p); }
    if (w == 4) { return ai5D126363_wave4_isEnabled(p); }
    return false;
}

//--------------------------------------------------------------------------------------------------
unitgroup ai5D126363_wave_createdUnits (int w, int p) {
    if (w == 2) { return ai5D126363_wave2_createdUnits(p); }
    if (w == 6) { return ai5D126363_wave6_createdUnits(p); }
    if (w == 7) { return ai5D126363_wave7_createdUnits(p); }
    if (w == 5) { return ai5D126363_wave5_createdUnits(p); }
    if (w == 8) { return ai5D126363_wave8_createdUnits(p); }
    if (w == 1) { return ai5D126363_wave1_createdUnits(p); }
    if (w == 64) { return ai5D126363_wave64_createdUnits(p); }
    if (w == 3) { return ai5D126363_wave3_createdUnits(p); }
    if (w == 4) { return ai5D126363_wave4_createdUnits(p); }
    return null;
}

//--------------------------------------------------------------------------------------------------
wave ai5D126363_wave_createdWave (int w, int p) {
    if (w == 2) { return ai5D126363_wave2_createdWave(p); }
    if (w == 6) { return ai5D126363_wave6_createdWave(p); }
    if (w == 7) { return ai5D126363_wave7_createdWave(p); }
    if (w == 5) { return ai5D126363_wave5_createdWave(p); }
    if (w == 8) { return ai5D126363_wave8_createdWave(p); }
    if (w == 1) { return ai5D126363_wave1_createdWave(p); }
    if (w == 64) { return ai5D126363_wave64_createdWave(p); }
    if (w == 3) { return ai5D126363_wave3_createdWave(p); }
    if (w == 4) { return ai5D126363_wave4_createdWave(p); }
    return null;
}

//--------------------------------------------------------------------------------------------------
void ai5D126363_wave_run (int w, int p, playergroup target, bool wait) {
    if (w == 2) { ai5D126363_wave2_run(p, target, wait); }
    if (w == 6) { ai5D126363_wave6_run(p, target, wait); }
    if (w == 7) { ai5D126363_wave7_run(p, target, wait); }
    if (w == 5) { ai5D126363_wave5_run(p, target, wait); }
    if (w == 8) { ai5D126363_wave8_run(p, target, wait); }
    if (w == 1) { ai5D126363_wave1_run(p, target, wait); }
    if (w == 64) { ai5D126363_wave64_run(p, target, wait); }
    if (w == 3) { ai5D126363_wave3_run(p, target, wait); }
    if (w == 4) { ai5D126363_wave4_run(p, target, wait); }
}

//--------------------------------------------------------------------------------------------------
// Attack Wave Sequence
//--------------------------------------------------------------------------------------------------
trigger ai5D126363_waves_trigger = null;
int ai5D126363_waves_runPlayer;
playergroup ai5D126363_waves_runTarget;

//--------------------------------------------------------------------------------------------------
void ai5D126363_waves_init () {
    ai5D126363_waves_trigger = TriggerCreate("ai5D126363_waves_runFunc");
}

//--------------------------------------------------------------------------------------------------
bool ai5D126363_waves_runFunc (bool c, bool a) {
    int p = ai5D126363_waves_runPlayer;
    playergroup target = ai5D126363_waves_runTarget;

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

    ai5D126363_wave2_run(p, target, true);
    ai5D126363_wave6_run(p, target, true);
    ai5D126363_wave7_run(p, target, true);
    ai5D126363_wave5_run(p, target, true);
    ai5D126363_wave8_run(p, target, true);
    ai5D126363_wave1_run(p, target, true);
    ai5D126363_wave64_run(p, target, true);
    ai5D126363_wave3_run(p, target, true);
    ai5D126363_wave4_run(p, target, true);

    return true;
}

//--------------------------------------------------------------------------------------------------
void ai5D126363_waves_run (int p, playergroup target) {
    ai5D126363_waves_runPlayer = p;
    ai5D126363_waves_runTarget = PlayerGroupCopy(target);

    TriggerExecute(ai5D126363_waves_trigger, false, false);
}

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

    ai5D126363_wave2_enable(p, val);
    ai5D126363_wave6_enable(p, val);
    ai5D126363_wave7_enable(p, val);
    ai5D126363_wave5_enable(p, val);
    ai5D126363_wave8_enable(p, val);
    ai5D126363_wave1_enable(p, val);
    ai5D126363_wave64_enable(p, val);
    ai5D126363_wave3_enable(p, val);
    ai5D126363_wave4_enable(p, val);
}

//--------------------------------------------------------------------------------------------------
void ai5D126363_waves_stop () {
    TriggerStop(ai5D126363_waves_trigger);

    TriggerStop(ai5D126363_wave2_trigger);
    TriggerStop(ai5D126363_wave6_trigger);
    TriggerStop(ai5D126363_wave7_trigger);
    TriggerStop(ai5D126363_wave5_trigger);
    TriggerStop(ai5D126363_wave8_trigger);
    TriggerStop(ai5D126363_wave1_trigger);
    TriggerStop(ai5D126363_wave64_trigger);
    TriggerStop(ai5D126363_wave3_trigger);
    TriggerStop(ai5D126363_wave4_trigger);
}

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

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

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

//--------------------------------------------------------------------------------------------------
// Start
//--------------------------------------------------------------------------------------------------
bool ai5D126363_initialized = false;

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

    if (p < 0 || p >= 16) {
        return;
    }
    if (!ai5D126363_initialized) {
        ai5D126363_wave2_init();
        ai5D126363_wave6_init();
        ai5D126363_wave7_init();
        ai5D126363_wave5_init();
        ai5D126363_wave8_init();
        ai5D126363_wave1_init();
        ai5D126363_wave64_init();
        ai5D126363_wave3_init();
        ai5D126363_wave4_init();
        ai5D126363_waves_init();

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

        ai5D126363_initialized = true;
    }

    AICampaignStart(p);
}