up

[code]
// -----------------
// aiBoostScript.slo // add_by_speedy - aiBoost1.8beta2 - 2003.11.16
// -----------------
//
// autor: speedy aka Andre Ruckdeschel
// with help, ideas and script parts taken from NEWST/Pumpkin-2 members 
// Troman (TurtleAI, GhengisAI), Prometheus (WaterAI/H2O), Kevin (Gate idea, reactor cooling script),
// Stratadrake (WZCK use, Mine idea), Kage (Gate model), assassin (blackhole body model)
// and of course Pumpkin and others
//
// Description: full aiBoosting !!! ;-)
//
// initForAIBoost(CALL_GAMEINIT) : initialising (structure limits, auto researches, alliances)
// checkForCheatSettings(every, 10) : check what cheat functions should be taken
// checkForAlliances(every, 10) : checking for alliances: PL?PL, AI+AI, AI-PL
// powerFromSources(every, 15) : modifying power generation (power gens), adding reactor (cooling, falldown, GAU)
// buildNewAIspcStructs(every, 9000): AIs *will* build up to 10 Lassats and 3 Chronospheres
// fireAIspcWeapons(every, 9011) : AIs *will* fire his lassats/chronospheres on defined player targets (if not jammed!)
// activateGAVA(every, 4000) : Guided AI VTOL Attacks: AI will gets some *free* VTOLs (first activated after 42000)
// activateGAVAX(every, 200) : Guided AI VTOL Attacks: AI *will* attack with THESE VTOLs defined player targets
// checkForNewMines(every, 10) : initialise Mines: get new built mines
// checkMines(every, 10) : check if enemy activates mines
// starGateTransport(every, 100) : activate star gate and transport all units standing nearby to second gate
// checkForDebug(every, 5) : debug-initialising
// checkBlackholeBodies(every, 100) : BlackHole-Bodies are very unstable and can implode after a few minutes!!
// event checkStasisfield(every, 30): activate stasis field projector


private INT count,count2,count3,tcount1,tcount2,tcount3,tcount4,player,tplayer1,tplayer2;
private INT buildX,buildY,baseX[8],baseY[8],CheatCount[3],aiDiffy[8];
private INT humanCount,human[8],targetPlayer,targetCount,gateCount,jammerRange,numAIUnits,numAIBonusStructs,numPLBonusStructs;
private INT towerCount,towerPool,towerRegCount,power,maxPower,minusPower,actPower;
private INT checkedAInr,buildAIChecknr,buildAItryanz,buildAIrealanz,totalHumans,totalAIs,chronosUnits;
private INT GAVAnr,SPCAInr,firedAnz,colorOK,gavaUnits,numGateBodies; //,numTemplatesX;
private INT numAIResearches,numResearches,numPLDisables,numEnables,maxLassat,targetAnz,CheatTestvarAnz;
private INT PLpowerModifier,reactorPower,coolingPower,strengthRatio,reactorGAU,reactorCheck;
private INT numAiSpcStructs,maxAiSpcStructs[2],AIcolor,numWeapons,gateActiRange,gateFireRange,gateRange;
private INT numMines,mineAnz,mineActiRange,mineVisiRange,minePlayer[101],mineX[101],mineY[101],mineTyp[101]; // es können nur 100 Minen INSGESAMT gebaut werden
private INT bhBodiesAnz,bhBodyID[101],bhBodyTime[101],bhBodyPlayer[101],bhBodyStabletime,bhBodyMaxlifetime; // es sollten 100 Black holes reichen...
private INT firedOnStrucX[70],firedOnStrucY[70]; // 70 = 7 AI * maxLassats
private BOOL boolResult,playerOK[8],isPlayer[8],isAI[8],chronosFired,debug,targetsOK[41],jammerEnabled,jammerMakeEnable,mineEnabled,gateFired,gateChanged;
private BOOL towerReg[13],towerReg2[13]; // eins mehr wegen enumStruct !!
private BOOL useSpcCheats,bhBodyChecked[101];
private STRUCTURESTAT powGen,reactor,coolingTow,cyborgFac,research,oilDerrick,factory,headquarter,stasisfield,stasiscontr;
private STRUCTURESTAT disablePLStruc[10],enableStruc[20],targetStruc[25],aiSpcStructs[2],mine[5];
private STRUCTURESTAT CheatTestvar[3],gate,gateActivated,gateControl,gateStruc,jammer,vtolFac,vtolPad,satellite,aiBonusStructs[5],plBonusStructs[5];
private RESEARCHSTAT RcyborgFac,jammerResearch;
private RESEARCHSTAT researchesAI[10],researches[10];
private STRUCTURE structure,gateA,gateB;
private STRUCTURE towers[13],gates[3]; // eins mehr wegen enumStruct !!
private STRUCTURE targetStructure,targets[31];
private WEAPON nuke,nukeEmp,reactorBurn,chronosEmp,weapon[10],plasmiteWeapon,truckweapon,carBomb,stasisWeapon;
private GROUP buildGroupForCheck,gavaGroup[8],SG1,BHG;
private DROID droid,droid2;
private SENSOR defaultSensor;
private ECM defaultECM;
private TEMPLATE constructor,template,tmplChoice[10]; //,tmplX[5];
private CONSTRUCT constructorConstr;
private PROPULSION vtolprop;
private BODY gateBody[5],bhBody;

// debug: evtl. trigger anpassen ?

trigger buildNewAIspcStructsTr (every, 9000);
trigger buildNewAIspcStructsTrDebug (every, 6900); // 6900
trigger fireAIspcWeaponsTrA (every, 9011);
trigger fireAIspcWeaponsTrB (every, 6011);
trigger fireAIspcWeaponsTrC (every, 3011);
trigger fireAIspcWeaponsTrDebug (every, 6911); // 6911
trigger fireAIspcWeaponsTrY (every, 100);
trigger activateGAVATrA (every, 4000);
trigger activateGAVATrB (every, 3000);
trigger activateGAVATrC (every, 2000);
trigger activateGAVATrDebug (every, 1200); // 1200
trigger activateGAVAYTrAA (every, 53000); // 1.BS = playerAnzahl, 2.BS = Level01/23
trigger activateGAVAYTrAB (every, 45000);
trigger activateGAVAYTrBA (every, 47000);
trigger activateGAVAYTrBB (every, 43000);
trigger activateGAVAYTrCA (every, 43000);
trigger activateGAVAYTrCB (every, 38000);
trigger activateGAVAYTrDebug (every, 12000); // 12000
trigger activateGAVAXTr (every, 200);
trigger activateGAVAYYTr (every, 100);
trigger enableLassatsAIXTrAA (every, 67000);
trigger enableLassatsAIXTrAB (every, 58000);
trigger enableLassatsAIXTrBA (every, 60000);
trigger enableLassatsAIXTrBB (every, 55000);
trigger enableLassatsAIXTrCA (every, 55000);
trigger enableLassatsAIXTrCB (every, 50000);
trigger cheatLikeHellTr (every, 15);
trigger updateSPCAppearenceTr (every, 100);

event initForAIBoost(CALL_GAMEINIT)
{ 
useSpcCheats = TRUE; 
totalHumans = 0;
totalAIs = 0;
checkedAInr = -1;
player = 0;
while(player < 8)
{ 
// Limits überschreiben!!

setStructureLimits(reactor, 3, player); // das hier ERSETZT die Building limits (screen) !!
setStructureLimits(research, 7, player);
setStructureLimits(powGen, 12, player);
setStructureLimits(oilDerrick, 48, player);
setStructureLimits(coolingTow, 12, player);
setStructureLimits(jammer, 10, player);
setStructureLimits(stasisfield, 5, player);
setStructureLimits(stasiscontr, 1, player);

count = 0;
while (count < numMines)
{
setStructureLimits(mine[count], 3, player);
count = count + 1;
}

// gewisse Gebäude baubar machen

count = 0;
while (count < numEnables)
{
enableStructure(enableStruc[count], player);
count = count + 1;
} 

// gewisse Researches komplettitieren

count = 0;
while (count < numResearches)
{
completeResearch(researches[count], player);
count = count + 1;
}

if(isHumanPlayer(player) )
{
// Menschen dürfen keine Cyborgfabriken haben!

structure = getStructure(cyborgFac,player); 
while(structure != NULLOBJECT) 
{ 
destroyStructure(structure);
structure = getStructure(cyborgFac,player); 
}
setStructureLimits(cyborgFac, 0, player);

// diese Gebäude sind nix für Menschen!

count = 0;
while (count < numPLDisables)
{
setStructureLimits(disablePLStruc[count], 0, player);
count = count + 1;
} 

setStructureLimits(aiSpcStructs[0], 1, player); // lassat
setStructureLimits(aiSpcStructs[1], 0, player); // chronos
setStructureLimits(gate, 2, player);
setStructureLimits(gateControl, 1, player);
}
else
{
// AI darf einiges mehr: Erforschungen für die AI

setDefaultSensor(defaultSensor, player);
//setDefaultECM(defaultECM, player);

completeResearch(RcyborgFac, player);
enableStructure(cyborgFac, player);
setStructureLimits(cyborgFac, 20, player);

count = 0;
while (count < numAIResearches)
{
completeResearch(researchesAI[count], player);
count = count + 1;
}

setStructureLimits(aiSpcStructs[0], maxAiSpcStructs[0], player); // lassat
setStructureLimits(aiSpcStructs[1], maxAiSpcStructs[1], player); // chronos
setStructureLimits(gate, 0, player);
setStructureLimits(gateControl, 0, player);
}

// Allianzen zwischen Menschen, und zwischen AIs setzen

count = 0;
while(count < 8)
{
if(count != player)
{
if((isHumanPlayer(player)) and (isHumanPlayer(count)))
{
createAlliance(player, count);
}

if((not isHumanPlayer(player)) and (not isHumanPlayer(count)))
{
createAlliance(player, count);
}
}
count = count + 1;
}

// note where our base is.

count = 0;
structure = getStructure(factory,player);

if(structure != NULLOBJECT) 
{
baseX[player] = structure.x;
baseY[player] = structure.y;
playerOK[player] = TRUE;

if(isHumanPlayer(player))
{
isPlayer[player] = TRUE;
isAI[player] = FALSE;
totalHumans = totalHumans + 1;

// Bonusgebäude für den Player

if(debug)
{
count = 0;
while (count < numPLBonusStructs)
{
buildX = baseX[player]; // pick a location 
buildY = baseY[player];
boolResult = pickStructLocation(plBonusStructs[count], ref buildX, ref buildY, player);

if(boolResult == TRUE)
{
addStructure(plBonusStructs[count],player,buildX,buildY);
}

count = count + 1;
}
}
}
else
{
if (player > checkedAInr) 
{ 
checkedAInr = player; 
}

isPlayer[player] = FALSE;
isAI[player] = TRUE;
totalAIs = totalAIs + 1;

// Bonusgebäude für die AI

count = 0;
while (count < numAIBonusStructs)
{
buildX = baseX[player]; // pick a location 
buildY = baseY[player];
boolResult = pickStructLocation(aiBonusStructs[count], ref buildX, ref buildY, player);

if(boolResult == TRUE)
{
addStructure(aiBonusStructs[count],player,buildX,buildY);
}

count = count + 1;
}
}
}
else
{
baseX[player] = (128*mapWidth)/2;
baseY[player] = (128*mapHeight)/2;
playerOK[player] = FALSE;
isPlayer[player] = FALSE;
isAI[player] = FALSE;
}

aiDiffy[player] = 0;

player = player + 1;
}

applyLimitSet(); // set limit options

buildAIChecknr = 0;
buildAItryanz = 0;
buildAIrealanz = 0;
firedAnz = 0;
chronosFired = FALSE;
jammerEnabled = FALSE;
jammerMakeEnable = FALSE;
mineAnz = 0;
mineEnabled = TRUE;
bhBodiesAnz = 0;
GAVAnr = 0;
SPCAInr = 0;

// Anzahl Start-Units, die aus Chronosphere kommen bzw. bei einem GAVA Strike auftauen...

if(totalHumans==1) { chronosUnits = 1; gavaUnits = 1; }
else if(totalHumans==2) { chronosUnits = 2; gavaUnits = 2; }
else { chronosUnits = 3; gavaUnits = 3; }
}

event setColors(every, 5)
{
if (useSpcCheats)
{
//checkedAInr = 0; // <- für Debug für Player==0 für CheatCheck...

// benötigen zwei zusätzliche Droids (temporär, werden dann wieder gekillt!!)

structure = getStructure(headquarter,checkedAInr);
if(structure != NULLOBJECT) // was machen wir, wenn's das tatsächlich nicht gibt ?????
{
buildX = structure.x;
buildY = structure.y;

boolResult = pickStructLocation(CheatTestvar[0], ref buildX, ref buildY, checkedAInr);
if (boolResult) 
{ 
template = getTemplate(constructorConstr, checkedAInr);
addDroid(template,buildX,buildY,checkedAInr); 
}
boolResult = pickStructLocation(CheatTestvar[0], ref buildX, ref buildY, checkedAInr);
if (boolResult) 
{ 
template = getTemplate(constructorConstr, checkedAInr);
addDroid(template,buildX,buildY,checkedAInr); 
}

groupAddArea(buildGroupForCheck, checkedAInr, buildX - 320, buildY - 320, buildX + 320, buildY + 320); 
}

count = 0;
while(count < CheatTestvarAnz)
{
enableStructure(CheatTestvar[count],checkedAInr);
CheatCount[count] = 0;
count = count + 1;
}
}

colorOK = 0;
player = 0;
while(player < 8)
{
if(isAI[player])
{ 
if(getPlayerColour(player) != AIcolor) { colorOK = getPlayerColour(player); }
}

player = player + 1;
}

player = 0;
count3 = 0;
while(player < 8)
{
if(isAI[player])
{
addPower(3500, player);

if(AIcolor > -1) { setPlayerColour(AIcolor, player); }

count = playerPower(player);
skDifficultyModifier(player);
count2 = playerPower(player) - count;
setPowerLevel(count, player);

if(count2 < 250) { aiDiffy[player] = 1; }
else if(count2 < 550) { aiDiffy[player] = 2; }
else { aiDiffy[player] = 3; }

count3 = count3 + aiDiffy[player];
}
else if(isPlayer[player])
{
addPower(500, player);

if((AIcolor > -1) and (getPlayerColour(player) == AIcolor)) { setPlayerColour(colorOK, player); } // rot ist für AI !!
}

player = player + 1;
}
setEventTrigger(setColors, inactive);
}

event cheatLikeHell(inactive)
{
player = 0;
while(player < 8)
{
if(isAI[player])
{
if (CheatCount[0] == 1) { addPower(10 * aiDiffy[player], player); }
if (CheatCount[0] == 2) { addPower(100 * aiDiffy[player], player); }
if (CheatCount[0] == 3) { addPower(1000 * aiDiffy[player], player); }
}
else if(isPlayer[player])
{
if (CheatCount[1] == 2) { addPower(5, player); }
if (CheatCount[1] == 1) { addPower(20, player); }
if (CheatCount[1] == 0) { addPower(50, player); }
}

player = player + 1;
}
}

event checkForCheatSettings(every, 10) // only when (useSpcCheats==TRUE)
{
// wieviele Cheatings sollen's denn sein ?
// a bisserl wirr das Script hier, aber anders scheints nicht zu gehen :-(

player = checkedAInr;
count3 = buildAIChecknr;

if(isStructureAvailable(CheatTestvar[count3],player)) // Anzahl 0:AICheat, 1:PlayerCheat, usw.
{ 
buildX = baseX[player]; // pick a location 
buildY = baseY[player];
boolResult = pickStructLocation(CheatTestvar[count3], ref buildX, ref buildY, player);

if(boolResult == TRUE)
{
initIterateGroup(buildGroupForCheck); // find idle droids in build group.
droid = iterateGroup(buildGroupForCheck);
while(droid != NULLOBJECT)
{
if( (droid.order == DORDER_NONE) or (droid.order == DORDER_RTB))
{
buildAItryanz = buildAItryanz + 1;
orderDroidStatsLoc(droid, DORDER_BUILD, CheatTestvar[count3], buildX,buildY); // build the testStruc
}
droid = iterateGroup(buildGroupForCheck);
}
}
}

buildAIrealanz = 0;
initEnumStruct(FALSE,CheatTestvar[count3],player,player); 
structure = enumStruct(); 
while(structure != NULLOBJECT) 
{ 
buildAIrealanz = buildAIrealanz + 1;
structure = enumStruct();
}

if ((buildAItryanz > (buildAIrealanz + 8)) or (buildAIrealanz > 2)) // dann kann kein Gebäude mehr gebaut werden -> fertig!
{
CheatCount[count3] = 0;
structure = getStructure(CheatTestvar[count3],player);
while(structure != NULLOBJECT)
{
CheatCount[count3] = CheatCount[count3] + 1;
destroyStructure(structure);
structure = getStructure(CheatTestvar[count3],player);
}
CheatCount[count3] = buildAIrealanz; // der obige Code hat Problems im Multiplayer!!

buildAItryanz = 0;
buildAIrealanz = 0;

setStructureLimits(CheatTestvar[count3], 0, player);

buildAIChecknr = buildAIChecknr + 1;

if (buildAIChecknr == CheatTestvarAnz)
{
setEventTrigger(checkForCheatSettings, inactive); // Nach Vollständiger Prüfung deaktivieren

initIterateGroup(buildGroupForCheck);
droid = iterateGroup(buildGroupForCheck);
while(droid!=NULLOBJECT)
{
vanishUnit(droid);
droid = iterateGroup(buildGroupForCheck);
}

if (debug==TRUE) { setPowerLevel(CheatCount[0]*10000 + CheatCount[1]*1000, 0); }

setEventTrigger(cheatLikeHell, cheatLikeHellTr);
}
}

// Problem im Multiplayer... still to do !!!!!!!!!!!!!!!!!!

if(totalHumans>1)
{
CheatCount[0] = 3; // AIs
CheatCount[1] = 3; // player
}
}

event checkForAlliances(every, 10)
{
player = 0;
while(player < 8)
{ 
count = 0;
while(count < 8)
{
// dafür sorgen, dass Allianzen zwischen AIs bleiben, und zwischen AIs und Menschen NICHT!

if(count != player)
{
if((not isHumanPlayer(player)) and (not isHumanPlayer(count)))
{
createAlliance(player, count);
}
else if((isHumanPlayer(player)) and (isHumanPlayer(count)))
{
count2 = count2; // do nothing
}
else
{
breakAlliance(player, count);
}
}
count = count + 1;
}

player = player + 1;
}
}

event powerFromSources(every, 15)
{
player = 0;
while(player < 8)
{ 
// Kohle für jeden upgegradeten PowerGen // get money from each upgraded powergen

count = 0; 
initEnumStruct(FALSE,powGen,player,player); 
structure = enumStruct(); 
while(structure != NULLOBJECT) 
{ 
if( (structureComplete(structure)) and (testStructureModule(player, structure, 0)) ) 
{ 
count = count + 1; 
if(isHumanPlayer(player) )
{
addPower(1 * PLpowerModifier, player);
}
else
{
addPower(5 * aiDiffy[player], player); // AI baut sicherlich weniger PowerGens als der Player!!
} // AI will build less powergens as humans for sure
} 
structure = enumStruct(); 
}

// erweitertes Reaktor-scripting inkl. CoolingTowers !! // advanced reactor scriptings
// wieviele Towers ? // how many towers ?

towerCount=0;
initEnumStruct(FALSE,coolingTow,player,player);
towers[towerCount] = enumStruct();

while(towers[towerCount] != NULLOBJECT)
{
towerReg[towerCount] = FALSE; // für alle Reaktoren; welche sind "irgendwo" connected ?
// for all reactors; which towers are connected "somewhere" ?
towerReg2[towerCount] = FALSE; // das ist für den gewählten Reaktor // for the selected reactor
towerCount = towerCount + 1;
towers[towerCount] = enumStruct();
}

// Kohle für jeden Reaktor (aber auf Cooling achten *hehe*)
// money for each reactor (but check the cooling!)

count2 = 0; 
power = 0;
initEnumStruct(FALSE,reactor,player,player); 
structure = enumStruct();

while(structure != NULLOBJECT) 
{ 
if(structureComplete(structure)) 
{ 
towerPool = 0;
towerRegCount = 0; // wieviel Tower sind am gewählten Reactor ? 
// how many towers are on the selected reactor ?

count3 = 0;
while(count3 < towerCount)
{
towerReg2[count3] = FALSE;
count3 = count3 + 1;
}

count3 = 0;
while(count3 < towerCount)
{
if((structureComplete(towers[count3])) and 
(towers[count3].health > 50) and // only max half damaged towers will work!
(not towerReg[count3]) and // damit registrierte nicht mehrmals zählen
// so registert wouldn't count twice!!
(towerRegCount < 4) and // max 4 pro Reaktor!! // max 4 per reactor
(distBetweenTwoPoints(structure.x, structure.y, towers[count3].x, towers[count3].y)<320) )
{
towerRegCount = towerRegCount + 1;
towerReg[count3] = TRUE;
towerReg2[count3] = TRUE;
towerPool = towerPool + towers[count3].health;
}
count3 = count3 + 1;
}

if(towerRegCount < 1) // kein Tower -> Geldabzug! // no tower -> money drawback!
{
power = power - (coolingPower * 2);
}
else if(towerRegCount < 2) // nur ein Tower -> kein zusätzliches Geld 
// only one tower -> no additional money
{
power = power;
}
else // erst ab zwei Tower läuft der Reaktor an!! // more than two towers -> money!!
{
power = power + reactorPower + (coolingPower * towerRegCount);
}

// bei weniger als zwei Tower gibt's Schaden!!!
// reactors get punished when there are less than two towers connected!!!

reactorCheck = (100*strengthRatio + 200) - (structure.health*strengthRatio + towerPool);
if(reactorCheck < 0) { reactorCheck = 0; }
towerPool = 100 - (reactorCheck / 100);

reactorCheck = (structure.health*towerPool)/100;

if (reactorCheck < reactorGAU)
{
fireWeaponAtLoc(nuke, structure.x, structure.y);
fireWeaponAtLoc(nukeEmp, structure.x, structure.y);
destroyStructure(structure);

count3 = 0;
while(count3 < towerCount)
{
if(towerReg2[count3])
{
destroyStructure(towers[count3]);
}
count3 = count3 + 1;
}
}
else
{
forceDamageObject(structure, reactorCheck);
if(reactorCheck < 75)
{
fireWeaponAtLoc(reactorBurn, structure.x, structure.y); // lets burn the reactor (visual effect only!!)
}
count3 = 0;
while(count3 < towerCount)
{
if(towerReg2[count3])
{
forceDamageObject(towers[count3], (towers[count3].health*towerPool)/100);
}
count3 = count3 + 1;
}
}

count2 = count2 + 1; 
addPower(power*PLpowerModifier, player); 
} 
structure = enumStruct(); 
}

// Auf maximales Geld achten und evtl. kürzen
// (soft) cut down money when it's too much

actPower = playerPower(player);
maxPower = ((3000 * count)+(30000 * count2)+2000)*PLpowerModifier;
if(actPower > maxPower ) 
{ 
minusPower = (actPower - maxPower) / 100;
setPowerLevel(actPower - minusPower, player); 
}

player = player + 1;
}
}

event buildNewAIspcStructs(buildNewAIspcStructsTr) // die AI hat niemals genug Lassats oder Chronospheres *hehe*
{
humanCount = 0;
player = 0;
while(player < 8)
{ 
if(isHumanPlayer(player) and (anyDroidsLeft(player) or anyFactoriesLeft(player)))
{
human[humanCount] = player;
humanCount = humanCount + 1;
}
player = player + 1;
}

player = 0;
while(player < 8)
{ 
if(isAI[player] and anyDroidsLeft(player) and anyFactoriesLeft(player))
{
count3 = 0;
while(count3 < numAiSpcStructs)
{
if(isStructureAvailable(aiSpcStructs[count3],player))
{ 
jammerMakeEnable = TRUE;
count2 = 0;
initEnumStruct(FALSE,aiSpcStructs[count3],player,player);
structure = enumStruct();
while(structure != NULLOBJECT) 
{
if(structureComplete(structure) == TRUE)
{
count2 = count2 + 1;
}
structure = enumStruct();
}
if (count2 < maxAiSpcStructs[count3])
{
count2 = count2 * 5;
if (count2 < 1) { count2 = 1; }
count = random(count2);
if (count < humanCount * 4)
{
buildX = baseX[player]; // pick a location 
buildY = baseY[player];
boolResult = pickStructLocation(aiSpcStructs[count3], ref buildX, ref buildY, player);

while(not boolResult)
{
count = random(3) - 1;
buildX = buildX + count * 1280;
if (buildX < 1280) { buildX = 1280; }
if (buildX > 128 * mapWidth - 1280) { buildX = 128 * mapWidth - 1280; }
count = random(3) - 1;
buildY = buildY + count * 1280;
if (buildY < 1280) { buildY = 1280; }
if (buildY > 128 * mapHeight - 1280) { buildY = 128 * mapHeight - 1280; }

boolResult = pickStructLocation(aiSpcStructs[count3], ref buildX, ref buildY, player);
}

if(boolResult == TRUE)
{
addStructure(aiSpcStructs[count3],player,buildX,buildY);
}
}
}
}
count3 = count3 + 1;
}
}
player = player + 1;
}

if((jammerMakeEnable) and (jammerEnabled == FALSE))
{
player = 0;
while(player < 8)
{ 
enableResearch(jammerResearch,player);
player = player + 1;
}
jammerEnabled = TRUE;
}
}

event fireAIspcWeaponsY(inactive) // EMP auf die Stelle an der die Lassat draufgeknallt hat
{
if (firedAnz>0)
{
count = 0;
while(count < firedAnz)
{
fireWeaponAtLoc(nukeEmp, firedOnStrucX[count], firedOnStrucY[count]);
count = count + 1;
}
firedAnz = 0;
}
setEventTrigger(fireAIspcWeaponsY, inactive);
}

event fireAIspcWeapons(fireAIspcWeaponsTrA)
{
humanCount = 0;
player = 0;
while(player < 8)
{ 
if(isHumanPlayer(player) and (anyDroidsLeft(player) or anyFactoriesLeft(player)))
{
human[humanCount] = player;
humanCount = humanCount + 1;
}
player = player + 1;
}

player = 0;
while(player < 8)
{ 
if(isAI[player])
{
// Player + Ziel suchen *hehe*

randomiseSeed();
targetPlayer = human[random(humanCount)];
targetCount = 0;

count = 0;
while(count < targetAnz)
{
count3 = 0;
initEnumStruct(FALSE,targetStruc[count],targetPlayer,targetPlayer);
structure = enumStruct();
while((structure != NULLOBJECT) and (count3 < 4))
{
if((structureComplete(structure) == TRUE) and (targetCount<30))
{
targets[targetCount] = structure;
targetsOK[targetCount] = TRUE;
targetCount = targetCount + 1;
count3 = count3 + 1;
}
structure = enumStruct();
}
count = count + 1;
}

// Ziele mit Jammer evtl. rausnehmen :-( *hehe*

count = 0;
while(count < targetCount)
{
count2 = 0;
initEnumStruct(FALSE,jammer,targetPlayer,targetPlayer);
structure = enumStruct();
while(structure != NULLOBJECT)
{
if((structureComplete(structure) == TRUE) and 
(distBetweenTwoPoints(structure.x,structure.y,targets[count].x,targets[count].y) < jammerRange))
{
count2 = count2 + 1; // Jammer in der Nähe!!
}
structure = enumStruct();
}

if(count2 > 0)
{
randomiseSeed();
count2 = count2 * 5; // * 3 : 1/9, 1/36, 1/81 // * 4 : 1/16, 1/64, 1/144 // * 5 : 1/25, 1/100, 1/225
count3 = random(count2 * count2); 

if(count3 != count2) // nur bei einer Zahl dennoch sichtbar!!
{
targetsOK[count] = FALSE;
}
}

count = count + 1;
}

// jetzt Ziele zusammenfassen

count = 0;
while(count < targetCount)
{
if(targetsOK[count] == FALSE)
{
count2 = count+1;
while(count2 < targetCount)
{
targets[count2 - 1] = targets[count2];
targetsOK[count2 - 1] = targetsOK[count2];
count2 = count2 + 1;
}
targetCount = targetCount - 1;
}
else
{
count = count + 1;
}
}

// jetzt durch alle eigenen LasSats/Chronospheres gehen...

if (targetCount > 0)
{
count = 0;
while(count < numAiSpcStructs)
{
initEnumStruct(FALSE,aiSpcStructs[count],player,player); // 0:lassat, 1:chronosphere
structure= enumStruct();
while(structure != NULLOBJECT) 
{
if(structureComplete(structure) == TRUE)
{
count2 = 0;
boolResult = TRUE;
while((count2 < 20) and (boolResult))
{
boolResult = FALSE;
count3 = 0;
randomiseSeed();
targetStructure = targets[random(targetCount)];
while((count3 < 20) and (targetStructure == NULLOBJECT))
{
randomiseSeed();
targetStructure = targets[random(targetCount)];
count3 = count3 + 1;
}
count3 = 0;
while(count3 < firedAnz)
{
if(distBetweenTwoPoints(targetStructure.x, targetStructure.y, firedOnStrucX[count3], firedOnStrucY[count3]) < 1200)
{
boolResult = TRUE;
count3 = firedAnz;
}
count3 = count3 + 1;
}
count2 = count2 + 1;
}

if(targetStructure != NULLOBJECT)
{
if(count==0) // lassats
{
skFireLassat(player,targetStructure);

firedOnStrucX[firedAnz] = targetStructure.x;
firedOnStrucY[firedAnz] = targetStructure.y;
firedAnz = firedAnz + 1;
}
else if((count==1) and (anyFactoriesLeft(player)) and (getDroidCount(player) < numAIUnits)) // chronosphere
{
buildX = targetStructure.x;
buildY = targetStructure.y;
structure = getStructure(factory,player);
boolResult = pickStructLocation(CheatTestvar[0], ref buildX, ref buildY, player);

if(boolResult)
{
count3 = numWeapons - 1;
count2 = 0;
while( (count2 < 10) and (count3 >= 0) )
{
template = getTemplate(weapon[count3], player);
if (template != NULLTEMPLATE)
{
tmplChoice[count2] = template;
count2 = count2 + 1;
}
count3 = count3 - 1;
}

if(count2 > 0)
{
count3 = 0;
while(boolResult and (count3 < (chronosUnits * aiDiffy[player])))
{
fireWeaponAtLoc(chronosEmp, buildX, buildY);
addDroid(tmplChoice[random(count2)],buildX,buildY,player);
boolResult = pickStructLocation(CheatTestvar[0], ref buildX, ref buildY, player);
count3 = count3 + 1;
chronosFired = TRUE;
}
}
}
}
}
}
structure = enumStruct();
}
count = count + 1;
}
}
}
player = player + 1;
}

if(chronosFired == TRUE)
{
chronosUnits = chronosUnits + totalHumans;
if (chronosUnits > 5) { chronosUnits = 5; }
chronosFired = FALSE;
}

if(firedAnz > 0)
{
setEventTrigger(fireAIspcWeaponsY, fireAIspcWeaponsTrY);
}
}

event activateGAVA(inactive) // Guided AI VTOL Attack ;-)
{
player = 0;
while(player < 8)
{ 
targetStructure = getStructure(vtolFac,player);
if (debug==TRUE) { targetStructure = getStructure(factory,player); }

if((isAI[player]) and (targetStructure != NULLOBJECT) and (getDroidCount(player) < numAIUnits))
{
count = 0;
initEnumStruct(FALSE,vtolPad,player,player); 
structure = enumStruct(); 
while(structure != NULLOBJECT) 
{
count = count + 1;
structure = enumStruct();
}

if(count < 5) // zu wenig Pads
{
count3 = 0;
buildX = targetStructure.x;
buildY = targetStructure.y;
boolResult = pickStructLocation(vtolPad, ref buildX, ref buildY, player);

while(boolResult and (count3 < 5))
{
addStructure(vtolPad,player,buildX,buildY);

boolResult = pickStructLocation(vtolPad, ref buildX, ref buildY, player);
count3 = count3 + 1;
}
}

template = getTemplate(plasmiteWeapon, player);
if (template != NULLTEMPLATE)
{
count3 = 0;
buildX = targetStructure.x;
buildY = targetStructure.y;
boolResult = pickStructLocation(CheatTestvar[0], ref buildX, ref buildY, player);

while(boolResult and (count3 < (gavaUnits * aiDiffy[player])))
{
addDroid(template,buildX,buildY,player);
groupAddAreaNoGroup(gavaGroup[player], player, buildX - 128,buildY - 128, buildX + 128,buildY + 128);

boolResult = pickStructLocation(CheatTestvar[0], ref buildX, ref buildY, player);
count3 = count3 + 1;
}
}

gavaUnits = gavaUnits + totalHumans;
if(gavaUnits > 10) { gavaUnits = 10; }
}
player = player + 1;
} 
}

event activateGAVAX(inactive) // Guided AI VTOL Attack ;-)
{
humanCount = 0;
player = 0;
while(player < 8)
{ 
if(isHumanPlayer(player) and (anyDroidsLeft(player) or anyFactoriesLeft(player)))
{
human[humanCount] = player;
humanCount = humanCount + 1;
}
player = player + 1;
}

player = 0;
while(player < 8)
{ 
targetStructure = getStructure(vtolFac,player);
if (debug==TRUE) { targetStructure = getStructure(factory,player); }

if((isAI[player]) and (gavaGroup[player].members > 0))
{
// Player + Ziel suchen *hehe*

randomiseSeed();
targetPlayer = human[random(humanCount)];
targetCount = 0;

count = 0;
while(count < targetAnz)
{
initEnumStruct(FALSE,targetStruc[count],targetPlayer,targetPlayer);
structure = enumStruct();
while(structure != NULLOBJECT) 
{
if((structureComplete(structure) == TRUE) and (targetCount < 30))
{
targets[targetCount] = structure;
targetCount = targetCount + 1;
}
structure = enumStruct();
}
count = count + 1;
}

if (targetCount > 0)
{
count3 = 0;
randomiseSeed();
structure = targets[random(targetCount)];
while((count3 < 10) and (structure == NULLOBJECT))
{
randomiseSeed();
structure = targets[random(targetCount)];
count3 = count3 + 1;
}
if(structure != NULLOBJECT)
{
orderGroupObj(gavaGroup[player], DORDER_ATTACK,structure);
//orderGroupLoc(gavaGroup[player], DORDER_SCOUT,structure.x,structure.y);
}
}
}
player = player + 1;
} 
}

event activateGAVAYY(inactive) // zeitgesteuert
{
setEventTrigger(activateGAVAX, activateGAVAXTr);
setEventTrigger(activateGAVAYY, inactive);
}

event activateGAVAY(activateGAVAYTrAA) // enables first activation of the GAVA-Attacks
{
if (debug==TRUE) 
{ 
setEventTrigger(activateGAVA, activateGAVATrDebug);
}
else
{
setEventTrigger(activateGAVA, activateGAVATrA);
GAVAnr = 1;
}

setEventTrigger(activateGAVAYY, activateGAVAYYTr);
setEventTrigger(activateGAVAY, inactive);
}

event enableLassatsAI(every, 1000)
{
boolResult = FALSE;
player = 0;
while(player < 8)
{
if(isPlayer[player])
{
if((isStructureAvailable(satellite,player)) and (isStructureAvailable(reactor,player)))
{
boolResult = TRUE;
}
}
player = player + 1;
}

player = 0;
if(boolResult)
{
while(player < 8)
{
if(isAI[player])
{
count = 0;
while(count<numAiSpcStructs)
{
enableStructure(aiSpcStructs[count], player);
count = count + 1;
}
}
player = player + 1;
}
//setEventTrigger(enableLassatsAIX, inactive); kann nicht zugewiesen werden
setEventTrigger(enableLassatsAI, inactive);
if (SPCAInr == 0) { SPCAInr = 1; }
}
}

event enableLassatsAIX(enableLassatsAIXTrAA)
{
player = 0;
while(player < 8)
{
if(isAI[player])
{
count = 0;
while(count<numAiSpcStructs)
{
enableStructure(aiSpcStructs[count], player);
count = count + 1;
}
}
player = player + 1;
}
setEventTrigger(enableLassatsAIX, inactive);
setEventTrigger(enableLassatsAI, inactive);
if (SPCAInr == 0) { SPCAInr = 1; }
}

event checkForNewMines(every, 10)
{
player = 0;
while(player < 8)
{
count = 0;
while(count<numMines)
{
initEnumStruct(FALSE,mine[count],player,player);
structure = enumStruct();
//structure = getStructure(mine[count],player);
while(structure != NULLOBJECT)
{
boolResult = TRUE;

// checken, ob kein eigener Constructor rumgurkt...

droid = droidTargetInArea(player, player, 
(structure.x - mineVisiRange), (structure.y - mineVisiRange), (structure.x + mineVisiRange), (structure.y + mineVisiRange));

if (droid != NULLOBJECT) // gibts mehrere Units, könnte das Genommene durchaus ein Nicht-Truck sein !!! PROB !!!
{
if (droid.weapon == truckweapon)
{
boolResult = FALSE;
}
}

if(boolResult)
{
// jetzt merken wir uns die neue Mine(n)...

// UPDATE: ACHTUNG !! Es scheint da ein Synchronisationsproblem zu geben
// bei manchen Spielern sind Minen sichtbar, bei anderen nicht !!
// d.h. wir müssen hier ZUSÄTZLICH schauen, ob's nicht schon eine Mine an
// DIESEM Platz gibt, wenn schon wird KEINE neue plaziert! (Geld verloren!)

count2 = 0;
while (count2 < mineAnz)
{
if ((mineX[count2] == structure.x) and (mineY[count2] == structure.y))
{
boolResult = FALSE;
count2 = mineAnz;
}
count2 = count2 + 1;
}

if (not boolResult)
{
destroyStructure(structure);
}

// jetzt geht "normal" weiter

else // -> if (boolResult)
{
minePlayer[mineAnz] = player;
mineTyp[mineAnz] = count;
mineX[mineAnz] = structure.x;
mineY[mineAnz] = structure.y;

mineAnz = mineAnz + 1;

destroyStructure(structure);
}
}
structure = enumStruct();
//structure = getStructure(mine[count],player); 
}
count = count + 1;
}
player = player + 1;
}

if ((mineEnabled == FALSE) and (mineAnz < 70)) // dann wieder aktivieren
{
player = 0;
while(player < 8)
{
if(isPlayer[player]) 
{
count = 0;
while(count<numMines)
{
setStructureLimits(mine[count], 3, player);
count = count + 1;
}
}
player = player + 1;
}
mineEnabled = TRUE;
}

if (mineAnz > 70) // dann deaktivieren!!!
{
mineEnabled = FALSE;
player = 0;
while(player < 8)
{
if(isPlayer[player]) 
{
count = 0;
while(count<numMines)
{
setStructureLimits(mine[count], 0, player);
count = count + 1;
}
}
player = player + 1;
}
}
}

event checkMines(every, 10)
{
if(debug==TRUE) { setPowerLevel((10000 * mineAnz + 100), 0); }

count = 0;
while(count < mineAnz)
{
player = 0;
while(player < 8)
{
boolResult = FALSE; // wenn TRUE dann Mine aus der Liste streichen

if((player == minePlayer[count]) or (allianceExistsBetween(player, minePlayer[count]) == TRUE))
{
droid = droidTargetInArea(player, player, 
(mineX[count] - mineVisiRange), (mineY[count] - mineVisiRange), (mineX[count] + mineVisiRange), (mineY[count] + mineVisiRange));

if (droid != NULLOBJECT) 
{ 
if (droid.weapon == truckweapon)
{
buildX = mineX[count];
buildY = mineY[count];
boolResult = not objectInArea(player, buildX - 64,buildY - 64, buildX + 64,buildY + 64);

if(boolResult)
{
addStructure(mine[mineTyp[count]],player,buildX,buildY);
}
}
}
}
else
{
droid = droidTargetInArea(player, player, 
(mineX[count] - mineActiRange), (mineY[count] - mineActiRange), (mineX[count] + mineActiRange), (mineY[count] + mineActiRange));

if (droid != NULLOBJECT) 
{
if (droid.propulsion != vtolprop) // um Flieger auszuschliessen!!
{
if(mineTyp[count]==0) // nuclear mine
{
fireWeaponAtLoc(nuke, mineX[count], mineY[count]);
fireWeaponAtLoc(nukeEmp, mineX[count], mineY[count]);
}
// else... andere Minen-Typen/Waffen auflisten...

boolResult = TRUE;
}
}
}

if(boolResult)
{
// jetzt noch den Merker rausnehmen

count3 = count;
while(count3 < mineAnz - 1)
{
minePlayer[count3] = minePlayer[count3 + 1];
mineX[count3] = mineX[count3 + 1];
mineY[count3] = mineY[count3 + 1];
mineTyp[count3] = mineTyp[count3 + 1];

count3 = count3 + 1;
}

count = count - 1;
mineAnz = mineAnz - 1;
player = 8;
}
player = player + 1;
}
count = count + 1;
}
}

event starGateTransport(every, 100)
{
if (debug==TRUE) { setPowerLevel(5000, 0); }

tplayer1 = 0;
while(tplayer1 < 8)
{ 
tcount4 = 0;
while(tcount4 < 2)
{
if(tcount4==1) { gateStruc = gate; gateRange = gateActiRange; }
else { gateStruc = gateActivated; gateRange = gateFireRange; }

gateChanged = FALSE;
gateCount=0;
initEnumStruct(FALSE,gateStruc,tplayer1,tplayer1);
gates[gateCount] = enumStruct();
while(gates[gateCount] != NULLOBJECT)
{
if(structureComplete(gates[gateCount]))
{
gateCount = gateCount + 1;
}
gates[gateCount] = enumStruct();
}

if (debug==TRUE) { setPowerLevel(gateCount*10000+1000, tplayer1); }

if (gateCount==2)
{
setStructureLimits(gate, 0, tplayer1);

gateA = NULLOBJECT;
gateB = NULLOBJECT;

initEnumStruct(FALSE,gateControl,tplayer1,tplayer1); 
structure = enumStruct(); 
if(structure != NULLOBJECT) 
{ 
if(structureComplete(structure)) 
{ 
if (debug==TRUE) { setPowerLevel(30000, tplayer1); }

tcount1 = 0;
while(tcount1 < gateCount)
{
if(distBetweenTwoPoints(structure.x, structure.y, gates[tcount1].x, gates[tcount1].y) < 400)
{
gateA = gates[tcount1];
}
else
{
gateB = gates[tcount1];
}

tcount1 = tcount1 + 1;
}

// jetzt kann es sein, dass gateA dennoch NULL ist !!!

if ((gateA != NULLOBJECT) and (gateB != NULLOBJECT))
{
if (debug==TRUE) { setPowerLevel(40000, tplayer1); }

// StartGate + ZielGate gefunden -> Einheiten markieren

tplayer2 = 0;
while(tplayer2 < 8)
{
if((tplayer2 == tplayer1) or (allianceExistsBetween(tplayer2, tplayer1) == TRUE))
{
initIterateGroup(SG1);
droid = iterateGroup(SG1);
while(droid!=NULLOBJECT)
{
droidLeaveGroup(droid); // Leeren der Gruppe SG1
droid = iterateGroup(SG1);
}

groupAddArea(SG1, tplayer2, gateA.x - gateRange, gateA.y - gateRange, gateA.x + gateRange, gateA.y + gateRange);

gateFired = FALSE;
initIterateGroup(SG1);
droid = iterateGroup(SG1);
tcount2 = 0;
while(droid!=NULLOBJECT)
{
// was ist das für ein Unit ? (nur spezielle Units werden durchgelassen!!)

tcount1 = -1;
tcount3 = 0;
while(tcount3 < numGateBodies)
{
if(droid.body == gateBody[tcount3])
{
tcount1 = tcount3;
tcount3 = numGateBodies;
}
tcount3 = tcount3 + 1;
}

if(tcount1 > -1)
{
if (debug==TRUE) { setPowerLevel(50000, tplayer2); }

if(tcount4 == 1) // gateDeactivated
{
gateChanged = TRUE;
}
else
{
template = getTemplate(gateBody[tcount1], tplayer2);
if(template!=NULLTEMPLATE)
{
buildX = gateB.x;
buildY = gateB.y;
boolResult = pickStructLocation(CheatTestvar[0], ref buildX, ref buildY, tplayer2);

if (boolResult) 
{ 
addDroid(template,buildX,buildY,tplayer2);

// Überprüfen, ob's wirklich der gleiche Typ ist

droid2 = droidTargetInArea(tplayer2, tplayer2, buildX - 64, buildY - 64, buildX + 64, buildY + 64);
if (droid2.weapon != droid.weapon) { boolResult = FALSE; }
if (droid2.propulsion != droid.propulsion) { boolResult = FALSE; }

if (boolResult==FALSE)
{
fireWeaponAtLoc(chronosEmp, droid.x, droid.y);
vanishUnit(droid);
vanishUnit(droid2);
}
else
{
tcount3 = droid.health;
vanishUnit(droid);
forceDamageObject(droid2, tcount3);
setDroidKills(droid2, 8); // 4, 8, 16, 32, 64, 128, 256, 128
gateFired = TRUE;
gateChanged = TRUE;
}
}
}
}
}

droid = iterateGroup(SG1);
}

if(gateFired)
{
fireWeaponAtLoc(chronosEmp, gateB.x, gateB.y);
}
}
tplayer2 = tplayer2 + 1;
}

if((gateChanged == TRUE) and (tcount4 == 1))
{
tcount1 = 0;
while(tcount1 < 2)
{
buildX = gates[tcount1].x;
buildY = gates[tcount1].y;

destroyStructure(gates[tcount1]);
addStructure(gateActivated,tplayer1,buildX,buildY);

tcount1 = tcount1 + 1;
}
}
else if((gateChanged == FALSE) and (tcount4 == 0))
{
tcount1 = 0;
while(tcount1 < 2)
{
buildX = gates[tcount1].x;
buildY = gates[tcount1].y;

destroyStructure(gates[tcount1]);
addStructure(gate,tplayer1,buildX,buildY);

tcount1 = tcount1 + 1;
}
}
}
}
}
}
else // -> gateCount < 2
{
if((tcount4==0) and (gateCount==1)) // dann muss dieses Gate deaktiviert werden!
{
buildX = gates[0].x;
buildY = gates[0].y;

destroyStructure(gates[0]);
addStructure(gate,tplayer1,buildX,buildY);
}
setStructureLimits(gate, 255, tplayer1); // destroy-/addStructure zählt NICHT zu den Limits!!!
// d.h. selbst wenn das Gebäude entfernt oder zerstört
// wird, ist nicht anzStructures - 1 !!!!!!
}

tcount4 = tcount4 + 1;
}

tplayer1 = tplayer1 + 1;
}
}

event checkForDebug(every, 5)
{
if (not useSpcCheats)
{
setEventTrigger(checkForCheatSettings, inactive); 
}

if (debug==TRUE) 
{ 
PLpowerModifier = 10;
setEventTrigger(buildNewAIspcStructs, buildNewAIspcStructsTrDebug);
setEventTrigger(fireAIspcWeapons, fireAIspcWeaponsTrDebug);
setEventTrigger(activateGAVAY, activateGAVAYTrDebug);
}
else
{
PLpowerModifier = 1;

if(totalHumans == 1)
{
setEventTrigger(enableLassatsAIX, enableLassatsAIXTrAA);
setEventTrigger(activateGAVAY, activateGAVAYTrAA);
}
else if(totalHumans == 2)
{
setEventTrigger(enableLassatsAIX, enableLassatsAIXTrBA);
setEventTrigger(activateGAVAY, activateGAVAYTrBA);
}
else if(totalHumans > 2)
{
setEventTrigger(enableLassatsAIX, enableLassatsAIXTrCA);
setEventTrigger(activateGAVAY, activateGAVAYTrCA);
} 
}

setEventTrigger(checkForDebug, inactive);
}

event updateSPCAppearence(inactive)
{
count = 0;
player = 0; 
event updateSPCAppearence(inactive)
{
count = 0;
player = 0;
while(player < 8)
{
if(isPlayer[player]) { count = count + playerPower(player); }
player = player + 1;
}

count2 = 10 - (CheatCount[0] * CheatCount[0]);

if((GAVAnr == 1) and (count > (5000 * totalHumans * count2)))
{
setEventTrigger(activateGAVA, activateGAVATrB);
GAVAnr = 2;
}
if((GAVAnr == 2) and (count > (20000 * totalHumans * count2)))
{
setEventTrigger(activateGAVA, activateGAVATrC);
GAVAnr = 3;
} 

if((SPCAInr == 1) and (count > (5000 * totalHumans * count2)))
{
setEventTrigger(fireAIspcWeapons, fireAIspcWeaponsTrB);
SPCAInr = 2;
}
if((SPCAInr == 2) and (count > (30000 * totalHumans * count2)))
{
setEventTrigger(fireAIspcWeapons, fireAIspcWeaponsTrC);
SPCAInr = 3;
}
}

event checkForDebuggg(every, 300)
{
if (debug==FALSE) 
{ 
if(totalHumans == 1)
{
if(CheatCount[0] < 2)
{
setEventTrigger(enableLassatsAIX, enableLassatsAIXTrAA);
setEventTrigger(activateGAVAY, activateGAVAYTrAA);
}
else
{
setEventTrigger(enableLassatsAIX, enableLassatsAIXTrAB);
setEventTrigger(activateGAVAY, activateGAVAYTrAB);
}
}
else if(totalHumans == 2)
{
if(CheatCount[0] < 2)
{
setEventTrigger(enableLassatsAIX, enableLassatsAIXTrBA);
setEventTrigger(activateGAVAY, activateGAVAYTrBA);
}
else
{
setEventTrigger(enableLassatsAIX, enableLassatsAIXTrBB);
setEventTrigger(activateGAVAY, activateGAVAYTrBB);
}
}
else if(totalHumans > 2)
{
if(CheatCount[0] < 2)
{
setEventTrigger(enableLassatsAIX, enableLassatsAIXTrCA);
setEventTrigger(activateGAVAY, activateGAVAYTrCA);
}
else
{
setEventTrigger(enableLassatsAIX, enableLassatsAIXTrCB);
setEventTrigger(activateGAVAY, activateGAVAYTrCB);
}
} 
}

setEventTrigger(checkForDebuggg, inactive);
setEventTrigger(updateSPCAppearence, updateSPCAppearenceTr);
}

event checkBlackholeBodies(every, 100) // every, 100 // inactive
{
// Checkvariablen zurücksetzen

count = 0;
while(count < bhBodiesAnz)
{
bhBodyChecked[count] = FALSE;
count = count + 1;
}

// durch alle Units aller Player gehen

player = 0;
while(player < 8)
{ 
if(isHumanPlayer(player)) // !!! AIs nicht! gibt Probleme!!
{
initIterateGroup(BHG);
droid = iterateGroup(BHG);
while(droid!=NULLOBJECT)
{
droidLeaveGroup(droid); // Leeren der Gruppe BHG
droid = iterateGroup(BHG);
}

groupAddAreaNoGroup(BHG, player, 0,0, 128*mapWidth,128*mapHeight); // mal alle holen, ai's sind evtl. in gava-group!!
initIterateGroup(BHG);
droid = iterateGroup(BHG);
while(droid!=NULLOBJECT)
{
count2 = 1;
if(droid.weapon == carBomb)
{
count2 = 3;
}
if(droid.body == bhBody)
{
boolResult = TRUE;
count = 0;
while(count < bhBodiesAnz)
{
if ((player == bhBodyPlayer[count]) and (droid.id == bhBodyID[count])) // haben was gefunden!
{
bhBodyTime[count] = bhBodyTime[count] + count2;
bhBodyChecked[count] = TRUE;
boolResult = FALSE;

// Test auf Explosion

if(bhBodyTime[count] > (bhBodyStabletime + random(bhBodyMaxlifetime)))
{
fireWeaponAtLoc(nuke, droid.x, droid.y);
fireWeaponAtLoc(nukeEmp, droid.x, droid.y);
vanishUnit(droid);
}

count = bhBodiesAnz;
}
count = count + 1;
}

if (boolResult) // dann nicht in Liste gefunden -> neuer Unit
{
if (bhBodiesAnz < 100) // sollte reichen
{
bhBodyPlayer[bhBodiesAnz] = player;
bhBodyTime[bhBodiesAnz] = 0;
bhBodyID[bhBodiesAnz] = droid.id;
bhBodyChecked[bhBodiesAnz] = TRUE;
bhBodiesAnz = bhBodiesAnz + 1;
}
}
}
droid = iterateGroup(BHG);
}

initIterateGroup(BHG);
droid = iterateGroup(BHG);
while(droid!=NULLOBJECT)
{
droidLeaveGroup(droid); // Leeren der Gruppe BHG
droid = iterateGroup(BHG);
}
}
player = player + 1;
}

// Herauslöschen der nicht mehr existierenen Units

count = 0;
while(count < bhBodiesAnz)
{
if(bhBodyChecked[count] == FALSE)
{
count2 = count;
while(count2 < bhBodiesAnz - 1)
{
bhBodyPlayer[count2] = bhBodyPlayer[count2 + 1];
bhBodyTime[count2] = bhBodyTime[count2 + 1];
bhBodyID[count2] = bhBodyID[count2 + 1];
bhBodyChecked[count2] = bhBodyChecked[count2 + 1];

count2 = count2 + 1;
}
count = count - 1;
bhBodiesAnz = bhBodiesAnz - 1;
}
count = count + 1;
}
}

event checkStasisfield(every, 30)
{
player = 0;
while(player < 8)
{ 
structure = getStructure(stasiscontr,player); 
if(structure != NULLOBJECT) 
{ 
initEnumStruct(FALSE,stasisfield,player,player); 
structure = enumStruct(); 
while(structure != NULLOBJECT) 
{ 
if(structureComplete(structure)) 
{
count2 = structure.health;
fireWeaponAtLoc(stasisWeapon, structure.x, structure.y);
forceDamageObject(structure, count2);
}
structure = enumStruct();
}
}

player = player + 1;
}
}

up