public INT player; // player for this instance.
public INT tileExpand; // rate of exploration
public RESEARCHSTAT camTech[4],CybProd[11];
public INT numScouts; // aim for...
public INT numDefenders;
public INT numAttackers;
private INT playnum;
// structures
private INT baseX,baseY,minx,miny,maxx,maxy,minxLast,minyLast,maxxLast,maxyLast;
public INT numStructs,numIncendrys,numDefStructs,numExtraStructs,numWallWeaps;
public STRUCTURESTAT incendrys[8],structs[13],defStructs[21],extraStructs[24],structChoice[5],wallWeaps[9];
public STRUCTURESTAT sensorTower,wallStruct,resLab,powGen,playerHQ,lassat,factory,pillBox6,derrick,cybFactory,vtolDefStruct[5],vtolPad,vtolFactory,repairFacility;
public STRUCTURESTAT powModule,facModule,resModule,vtolModule,LSensor;
private STRUCTURESTAT WallToBuild;
public INT extraStruct;
// unit templates
public INT numTemplates;
public TEMPLATE tmpl[80];
private TEMPLATE tmplChoice[5];
private STRUCTURE oilLocation[30]; //MAX 30 oilDerricks (0 -29)
private BASEOBJ threatArea; //threat area
private INT threatX;
private INT threatY;
private BASEOBJ vtolDerrick; //Derricks for VTOL attacks
private INT numOilLocation;
//Cyborgs
public TEMPLATE cybTempl[4],superCyb[4],cybRepair;
private DROID Mechanic;
public TEMPLATE vtols[18];
public INT numVtolTemplates;
public TEMPLATE sense[11];
public INT numSenseTemplates;
public TEMPLATE constructor,repairUnit,HvyTruck,transporter;
public INT numCyborgs,numRepairUnits;
private INT currentCyborgs,currentCyborgTemplate;
//defend
private GROUP defendGroup,tempGroup,threatGroup;
private BOOL defendbusy,onPatrol,selfDestruction;
private BASEOBJ defendObj;
public RESEARCHSTAT nexusDefence;
//build
private GROUP buildGroup;
private INT buildX,buildY,buildX2,buildY2;
public FEATURESTAT oilRes;
// scout
private GROUP scoutGroup;
private INT scoutX,scoutY;
private INT curWallPos,curWallSide;
private INT scoutTLX,scoutTLY,scoutW,scoutH;
// attack
private GROUP attackGroup;
private BASEOBJ attackObj,allOutAttack,artyObj;
// vtols
private GROUP vtolGroup;
// generic
private STRUCTURE structure,structure2,structure3;
private DROID droid,droid2,transportDroid,loadDroid,lineDroid,wallDroid,wallDroid2,repDroid;
private FEATURE feature;
private BASEOBJ baseobj,baseobj2;
private INT count,count2,count3,result,result2,tempx,tempy,temp1,temp2;
private BOOL boolResult,boolResult2;
private INT BuildW_failedCount, buildHardpoint;
private BOOL powerSave;
private BOOL aiDebugMode;
private INT allianceTime[8];
//Arty weapons
public WEAPON artyWeapon[8];
public STRUCTURESTAT artyStruct[8];
public BODY MechanicBody; //No other way to detect is Mechanic was built
/////////////////////////////////////////////////////////////////////
// triggers.
trigger buildExpandTr (every, 110); //140
trigger fortifyTr (every,150);
trigger upgradeStructuresTr (every, 500 );
trigger conDroidsTr (every, 180);
trigger repairDroidsTr (every, 5600);
trigger managePowerTr (every, 4000);
trigger basedetailsTr (every, 170 );
trigger buildDerrickTr (every, 60 ); //70
trigger buildOilDefenseOrRetreatTr (every, 80 ); //70
trigger buildPowerGeneratorsTr (every, 80 ); //80
trigger buildBaseTr (every, 110);
trigger droidBuiltTr (CALL_NEWDROID,player, ref droid,ref structure);
trigger droidDestroyedTr (CALL_DROID_DESTROYED, player, ref droid);
trigger cyborgFactoryEventTr (every, 100 );
trigger scoutMainTr (every, 150 );
//trigger newObjectReportTr (CALL_OBJ_SEEN, player, ref baseobj, ref baseobj2);
trigger attackStuffTr (every, 180); //300
//trigger allOutAttackTr (every, 1000);
trigger defendWatchTr (CALL_STRUCT_ATTACKED, player, ref structure, ref baseobj);
trigger defendReturnTr (every,40);
trigger doResearchTr (every, 400 );
trigger vtolDefendTr (CALL_STRUCT_ATTACKED, player, ref structure, ref baseobj);
trigger vtolStructsTr (every, 1100);
trigger buildVtolsTr (every, 200);
trigger vtolAttackTr (every, 150);
trigger vtolEnablerTr (every, 300);
trigger takeoverTr (CALL_UNITTAKEOVER, ref droid);
trigger useLassatTr (every, 3000);
trigger reassignTr (CALL_PLAYERLEFT,count);
trigger formAllianceEventTr (every,400);
trigger breakAllianceEventTr (every,5700);
trigger difficultyModifierTr (every,600);
trigger humanAllianceTr (CALL_ALLIANCEOFFER,ref count, ref count2);
trigger givehelp2Tr (every,40);
trigger buildSensorsTr (every,1300);
trigger defendDerricksTr (every,150);
trigger helpBuildTr (every,400);
trigger threatReturnTr (every,600);
trigger buildWallsAroundTr (every, 80); //build walls around the base
trigger repairStructuresTr (every, 50); //repair demaged structures using repDroid
/////////////////////////////////////////////////////////////////////
// HouseKeeping
event initialisedEvent(CALL_GAMEINIT)
{
// initialise
//WallToBuild = wallStruct;
buildHardpoint = -1;
curWallSide = 0;
curWallPos = -1;
maxyLast = -1;
maxxLast = -1;
minyLast = -1;
minxLast = -1;
threatArea = NULLOBJECT;
numOilLocation = 0;
extraStruct = 0;
numRepairUnits = 0;
allOutAttack = NULLOBJECT;
wallDroid = NULLOBJECT;
wallDroid2 = NULLOBJECT;
lineDroid = NULLOBJECT;
repDroid = NULLOBJECT;
artyObj = NULLOBJECT;
currentCyborgTemplate = 0;
powerSave = FALSE;
selfDestruction = FALSE;
Mechanic = NULLOBJECT;
aiDebugMode = FALSE;
onPatrol = FALSE;
// setup build group
//all initial droids are in buildgroup!
groupAddArea(buildGroup, player, 0, 0, (mapWidth*128), (mapHeight*128));
initGetFeature(oilRes,player,player); // use bucket = player
feature = getFeature(player);
// note where our base is.
initIterateGroup(buildGroup); // find idle droids in build group.
droid = iterateGroup(buildGroup);
if(droid != NULLOBJECT)
{
baseX = droid.x;
baseY = droid.y;
//feature = getFeature(player);
if(feature != NULLOBJECT)
{
buildX = feature.x;
buildY = feature.y;
orderDroidStatsLoc(droid, DORDER_BUILD,derrick, buildX,buildY); //build a derick
}
}
else
{
baseX = (128*mapWidth)/2;
baseY = (128*mapHeight)/2;
}
// defence.
defendbusy = FALSE;
// setup scouts
structure = getStructure(factory, player);
if(structure != NULLOBJECT)
{
scoutTLX = structure.x;
scoutTLY = structure.y;
}
else
{
scoutTLX = baseX;
scoutTLY = baseY;
}
scoutW = 256;
scoutH = 256;
scoutX = scoutTLX;
scoutY = scoutTLY;
// clear the alliance array...
allianceTime[0] = 0;
allianceTime[1] = 0;
allianceTime[2] = 0;
allianceTime[3] = 0;
allianceTime[4] = 0;
allianceTime[5] = 0;
allianceTime[6] = 0;
allianceTime[7] = 0;
//if((mapWidth > 170) or (mapHeight > 170))
//{
if(not isHumanPlayer(player) ) //only for ai players
{
enableResearch(camTech [0], player);
enableResearch(camTech [1], player);
completeResearch(camTech [0], player);
completeResearch(camTech [1], player);
//speed up cyborg research
count = 0;
while(count < 10)
{
completeResearch(CybProd[count], player);
count = count + 1;
}
}
//}
//make sure the build group only contains of constructors
initIterateGroup(buildGroup);
droid = iterateGroup(buildGroup);
while(droid != NULLOBJECT)
{
if ( droid.droidType != DROID_CONSTRUCT )
{
droidLeaveGroup(droid);
groupAddDroid(defendGroup, droid);
}
droid = iterateGroup(buildGroup);
}
//transportDroid = addDroidToMissionList(transporter, player);
}
//Build walls around the base (TEST)
event buildWallsAround(buildWallsAroundTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(buildWallsAround, inactive);
}
else
{
if(wallDroid != NULLOBJECT)
{
if(wallDroid.order == DORDER_NONE)
{
BuildW_failedCount = 0;
//First time
if(maxyLast == -1)
{maxyLast = maxy + (mapHeight*128)/29;
maxxLast = maxx + (mapWidth*128)/29;
minyLast = miny - (mapHeight*128)/29;
minxLast = minx - (mapWidth*128)/29;}
//Move wall border
if((curWallSide == 0) and (curWallPos == -1))
{count = (mapHeight*128)/29; //y, base walls, depend op mapsize
count2 = (mapWidth*128)/29; //x
if((maxx >= maxxLast) and (maxy >= maxyLast)) //If base border moved far enough, move wall border too
{maxyLast = maxy + count; //Else rebuild walls on last position
maxxLast = maxx + count2;}
if((minx <= minxLast) and (miny <= minyLast))
{minyLast = miny - count;
minxLast = minx - count2;}}
//Check if everything's ok
if(maxxLast >mapWidth*128 - (128 * 4)){maxxLast = mapWidth*128 - (128 * 4);}
if(maxyLast >mapHeight*128 - (128 * 4)){maxyLast = mapHeight*128 - (128 * 4);}
if(minyLast < (128 * 4)){minyLast = (128 * 4);}
if(minxLast < (128 * 5)){minxLast = (128 * 5);}
//Leave 1/3 of the line in the center for exit
curWallPos = curWallPos + 1; count = (curWallPos * 128);
if((curWallSide == 0) or (curWallSide == 2)) //Bottom, top
{
if((count > ( (maxxLast - minxLast) / 3)) and (count < ( 2 * (maxxLast - minxLast) / 3)) ) //if > 1/3 of line lenght (leave space for exit)
{
curWallPos = (2 * (maxxLast - minxLast)/369); //Go on with third part of the line
buildHardpoint = -1; //Build HP as first structure
}
}
else
{
if((count > ( (maxyLast - minyLast) / 3)) and (count < (2 * (maxyLast - minyLast) / 3)) ) //if > 1/3 of line lenght (leave space for exit)
{
curWallPos = (2 * (maxyLast - minyLast)/369); //Go on with third part of the line
buildHardpoint = -1; //Build HP as first structure
}
}
/***************** SIDES ****************/
boolResult = FALSE;
if(curWallSide == 0) //Bottom
{
buildX = maxxLast - (curWallPos*128);
buildY = maxyLast;
if(buildX >= minxLast)
{boolResult = TRUE;}
//if(curWallPos == 0) //Nogo in the center of the line
//{setNoGoArea((2 * (maxxLast - minxLast)/369) - 128, maxyLast, ((maxxLast - minxLast) / 3), maxyLast, player);}
}
else if(curWallSide == 1) //Right
{
buildX = maxxLast;
buildY = maxyLast - (curWallPos*128);
if(buildY >= minyLast)
{boolResult = TRUE;}
//if(curWallPos == 0) //Nogo in the center of the line
//{setNoGoArea((2 * (maxyLast - minyLast)/369) - 128, maxxLast, ((maxyLast - minyLast) / 3), maxxLast, player);}
}
else if(curWallSide == 2) //Top
{
buildX = maxxLast - (curWallPos*128);
buildY = minyLast;
if(buildX >= minxLast)
{boolResult = TRUE;}
//if(curWallPos == 0) //Nogo in the center of the line
//{setNoGoArea((2 * (maxxLast - minxLast)/369) - 128, minyLast, ((maxxLast - minxLast) / 3), minyLast, player);}
}
else if(curWallSide == 3) //Left
{
buildX = minxLast;
buildY = maxyLast - (curWallPos*128);
if(buildY >= minyLast)
{boolResult = TRUE;}
//if(curWallPos == 0) //Nogo in the center of the line
//{setNoGoArea((2 * (maxyLast - minyLast)/369) - 128, minxLast, ((maxyLast - minyLast) / 3), minxLast, player);}
}
/****************************************/
boolResult2 = TRUE;
if((wallDroid.x > buildX - 50) and (wallDroid.x < buildX + 50) and (wallDroid.y > buildY - 50) and (wallDroid.y < buildY + 50))
{
orderDroid(wallDroid, DORDER_RUN);
boolResult2 = FALSE;
}
if(wallDroid2 != NULLOBJECT)
{
if((wallDroid2.x > buildX - 50) and (wallDroid2.x < buildX + 50) and (wallDroid2.y > buildY - 50) and (wallDroid2.y < buildY + 50))
{
orderDroid(wallDroid2, DORDER_RUN);
boolResult2 = FALSE;
}
}
if(boolResult and boolResult2)
{
WallToBuild = wallStruct;
buildHardpoint = buildHardpoint + 1;
if(buildHardpoint >= 3)
{buildHardpoint = 0; WallToBuild = wallWeaps[2];}
if((curWallPos == 0) or (buildHardpoint == 0))
{WallToBuild = wallWeaps[2];}
orderDroidStatsLoc(wallDroid,DORDER_BUILD,WallToBuild, buildX ,buildY);
//Help building, it takes forever with one truck....
if(wallDroid2 != NULLOBJECT)
{
orderDroidStatsLoc(wallDroid2,DORDER_BUILD,WallToBuild, buildX ,buildY);
}
}
else if(boolResult and not boolResult2) //Can't build here, skip
{
//buildHardpoint = buildHardpoint - 1;
curWallPos = curWallPos - 1;
BuildW_failedCount = 1;
}
else if(not boolResult) //Done!
{
buildHardpoint = -1;
curWallPos = -1;
curWallSide = curWallSide + 1;
if(curWallSide >= 4)
{
curWallSide = 0;
//groupAddDroid(buildGroup, wallDroid);
//groupAddDroid(buildGroup, wallDroid2);
}
}
}
else //count how many times failed (can't build here)
{
BuildW_failedCount = BuildW_failedCount + 1;
if(BuildW_failedCount > 8)
{
orderDroid(wallDroid, DORDER_STOP);
orderDroid(wallDroid2, DORDER_STOP);
buildHardpoint = -1; //Build HP next time
}
}
}
}
}
//Repair demaged structures
event repairStructures(repairStructuresTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(repairStructures, inactive);
}
else
{
if(repDroid != NULLOBJECT)
{
//count3 = distBetweenTwoPoints(droid.x , droid.y , buildX , buildY);
structure = NULLOBJECT;
structure2 = NULLOBJECT;
structure3 = NULLOBJECT;
boolResult = FALSE;
count = 260 * 128;
initEnumStruct(TRUE,factory,player,player);
structure = enumStruct();
while(structure != NULLOBJECT) //Find closest structure
{
if(structure.health < 90)
{
count2 = distBetweenTwoPoints(repDroid.x , repDroid.y , structure.x, structure.y);
if(count2 < count)
{
structure2 = structure;
}
}
//Unfinished structure
if(structure3 == NULLOBJECT) //only 1 time
{
if(not structureComplete(structure))
{
if(not droidInRange(player, structure.x,structure.y, 5 * 128)) //no builders around it
{
structure3 = structure;
}
}
}
structure = enumStruct();
}
//Repair
if(structure2 != NULLOBJECT)
{
if((repDroid.order == DORDER_NONE) or (repDroid.order == DORDER_RTB) or (repDroid.order == DORDER_HELPBUILD))
{
orderDroidObj(repDroid, DORDER_REPAIR, structure2); //repair it
}
}
else if(structure3 != NULLOBJECT) //Finish building structure
{
if((repDroid.order == DORDER_NONE) or (repDroid.order == DORDER_RTB))
{
orderDroidObj(repDroid,DORDER_HELPBUILD,structure3);
//setFogColour(random(255),random(255),random(255));
}
}
}
}
}
//Watch out for the enemy trying to capture out oil derrick
event defendDerricks(defendDerricksTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(defendDerricks,inactive);
}
else
{
numOilLocation = 0;
initEnumStruct(FALSE,derrick,player,player);
structure= enumStruct();
while(structure != NULLOBJECT)
{
//derrick not in the base
if((structure.x < minx) or (structure.x > maxx) or (structure.y < miny) or (structure.y > maxy))
{
oilLocation[numOilLocation] = structure; //remember coordinates of each derrick
numOilLocation = numOilLocation + 1; //count stored oil derricks
}
structure= enumStruct(); //next oil derrick
}
//patrol
if( (idleGroup(defendGroup) >= (defendGroup.members)/2) and (not defendbusy))
{
if(numOilLocation > 0) //more than 1 derrick stored
{
count = random(numOilLocation); //choose random oil derrick1!
orderGroupLoc(defendGroup, DORDER_SCOUT,oilLocation[count].x,oilLocation[count].y); //patrol
onPatrol = TRUE;
}
}
}
}
//Use threat group for HELPBUILD if idle
event helpBuild(helpBuildTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(helpBuild, inactive);
}
else
{
count = 0;
boolResult2 = FALSE;
while((count < numStructs) and (not boolResult2))
{
initEnumStruct(FALSE,structs[count],player,player);
structure= enumStruct();
while(structure != NULLOBJECT)
{
if(not structureComplete(structure))
{
initIterateGroup(threatGroup);
droid = iterateGroup(threatGroup);
while(droid != NULLOBJECT)
{
if((droid.order == DORDER_NONE) or (droid.order == DORDER_RTB))
{
orderDroidObj(droid,DORDER_HELPBUILD,structure);
boolResult2 = TRUE;
}
droid = iterateGroup(threatGroup);
}
}
structure= enumStruct();
}
count = count + 1;
}
}
}
//Threat Group Return to Base If Idle
event threatReturn(threatReturnTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(threatReturn, inactive);
}
else
{
initIterateGroup(threatGroup);
droid = iterateGroup(threatGroup);
while(droid != NULLOBJECT)
{
if(droid.order == DORDER_NONE)
{
orderDroid(droid,DORDER_RTB);
}
droid = iterateGroup(threatGroup);
}
}
}
/////////////////////////////////////////////////////////////////////
// initial force setup thing. plonk down a force.
event givehelp(every, 10)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(givehelp, inactive);
}
else
{
if(multiPlayerBaseType == CAMP_WALLS)
{
// free power
addPower(3000, player);
// free droids.
structure = getStructure(factory, player);
if(structure != NULLOBJECT)
{
count = 0;
while(count<7)
{
tempx = baseX;
tempy = baseY;
boolResult = pickStructLocation(factory, ref tempx, ref tempy,player);
if(boolResult == TRUE)
{
//droid = addDroid(tmpl[ random(16) ] , tempx, tempy, player);
//orderDroidLoc(droid, DORDER_MOVE, random(128*mapWidth),random(128*mapHeight));
//groupAddDroid(defendGroup,droid);
addStructure(wallWeaps[ random(9) ] , player, tempx, tempy);
}
count = count + 1;
}
}
}
setEventTrigger(givehelp, inactive);
}
}
/////////////////////////////////////////////////////////////////////
// keep details about the size and postion of the ai players base
event basedetails(basedetailsTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(basedetails, inactive);
}
else
{
// clear old extremities.
maxy = 0;
maxx = 0;
miny = (mapHeight*128);
minx = (mapWidth*128);
// now find the extremities of our vital structures.
count = 0;
while(count < numStructs)
{
initEnumStruct(FALSE,structs[count],player,player);
structure= enumStruct();
while(structure != NULLOBJECT)
{
if(structure.x < minx)
{
minx = structure.x;
}
if(structure.x > maxx)
{
maxx = structure.x;
}
if(structure.y < miny)
{
miny = structure.y;
}
if(structure.y > maxy)
{
maxy = structure.y;
}
structure = enumStruct();
}
count = count + 1;
}
}
}
/////////////////////////////////////////////////////////////////////824
// structure building rules
// build derricks on oil.
event buildDerrick(buildDerrickTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(buildDerrick, inactive);
}
else
{
initGetFeature(oilRes, player, player);
feature = getFeature(player); // find unoccupied oil resource
while(feature != NULLOBJECT)
{
buildX = feature.x;
buildY = feature.y;
droid2 = NULLOBJECT;
count2 = 251 * 128; //Biggest map size, value to compare with other values
// if no more than 2 units already trying to build
initIterateGroup(buildGroup); // find all units in build group
droid = iterateGroup(buildGroup);
count = 0;
while(droid != NULLOBJECT)
{
if((droid.orderx == buildX) and (droid.ordery == buildY))
{
count = count + 1;
}
droid = iterateGroup(buildGroup);
}
if(count == 0) //If not too many trucks already trying to build on that oil res
{
initIterateGroup(buildGroup); // find all units in build group
droid = iterateGroup(buildGroup);
while( droid != NULLOBJECT )
{
if((droid.order == DORDER_NONE) or (droid.order == DORDER_RTB))
{
//Find truck which is closer to this oil derricks (part of Promethues' H2O AI)
count3 = distBetweenTwoPoints(droid.x , droid.y , buildX , buildY);
if(count3 < count2) //We found a truck which is closer to the derrick
{
count2 = count3;
droid2 = droid; //Save this droid
}
}
droid = iterateGroup(buildGroup);
}
}
//Build oil derrick if we found an idle truck and oil resource
if (droid2 != NULLOBJECT)
{
orderDroidStatsLoc(droid2, DORDER_BUILD,derrick, buildX ,buildY); //build a derick
}
feature = getFeature(player); //Next oil derrick
}
}
}
/////////////////////////////////////////////////////////////////////
// if idle and derrick in range and no defense then build defense, else ret to base .
event buildOilDefenseOrRetreat(buildOilDefenseOrRetreatTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(buildOilDefenseOrRetreat, inactive);
}
else
{
// check idle.
initIterateGroup(buildGroup); // find idle droids in build group.
droid = iterateGroup(buildGroup);
while(droid != NULLOBJECT)
{
if((droid.order == DORDER_NONE) or (droid.order == DORDER_RTB))
{
// if in range of a derrick
structure = structureBuiltInRange(derrick, droid.x, droid.y, (8*128), player);
// if inside base limits then presume ok..
if( structure != NULLOBJECT)
{
if((structure.x > minxLast) and (structure.y > minyLast) and (structure.x < maxxLast) and (structure.y <maxyLast))
{
structure = NULLOBJECT;
}
}
if(structure != NULLOBJECT)
{
buildX = structure.x;
buildY = structure.y;
count = 0; // if derrick has no defense near it.
result = 0;
while(count < numDefStructs)
{
structure = structureBuiltInRange(defStructs[count], buildX, buildX,(8*128), player);
if(structure != NULLOBJECT)
{
result = result + 1; // found a defense.
}
count = count + 1;
}
// not many defenses nearby
if(result < 6)
{
count = numDefStructs - 1; //pick a struct to build..
count2 = 0;
while( (count2 < 5) and (count >= 0) )
{
if( isStructureAvailable(defStructs[count],player))
{
// don't build multiple sensors together.
if(count == 3)
{
structure = structureBuiltInRange(defStructs[count], buildX, buildY,(10*128), player);
if(structure != NULLOBJECT)
{
count = 11;
}
}
structChoice[count2] = defStructs[count];
count2 = count2 + 1;
}
count = count - 1;
}
count = 0;
if(count2 > 0)
{
count = random(count2); //count = choice!
boolResult = pickStructLocation(structChoice[count], ref buildX, ref buildY,player);
if(boolResult)
{
orderDroidStatsLoc(droid, DORDER_BUILD,structChoice[count], buildX,buildY);
}
}
else
{
boolResult = pickStructLocation(pillBox6, ref buildX, ref buildY,player);
if(boolResult)
{
orderDroidStatsLoc(droid, DORDER_BUILD,pillBox6, buildX,buildY);
}
}
}
else
{
structure = structureBuiltInRange(playerHQ, droid.x, droid.y, (5*128), player);
if(structure == NULLOBJECT)
{
orderDroid(droid,DORDER_RTB); // return to base;
}
}
}
else
{
structure = structureBuiltInRange(playerHQ, droid.x, droid.y, (5*128), player);
if(structure == NULLOBJECT)
{
orderDroid(droid,DORDER_RTB); // return to base;
}
}
}
droid = iterateGroup(buildGroup);
}
}
}
/////////////////////////////////////////////////////////////////////
// build a power gen for every 4 derricks. VITAL!
event buildPowerGenerators(buildPowerGeneratorsTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(buildPowerGenerators, inactive);
}
else
{
initEnumStruct(FALSE,derrick,player,player); // count = numderricks
structure= enumStruct();
count = 0;
while(structure != NULLOBJECT)
{
count = count + 1;
structure= enumStruct();
}
initEnumStruct(FALSE,powGen,player,player); // count2 = numpowgens
structure= enumStruct();
count2 = 0;
while(structure != NULLOBJECT)
{
count2 = count2 + 1;
structure= enumStruct();
}
if( (count2 * 4) < count ) // if we need powergen
{
buildX = baseX; // try build powergen.
buildY = baseY;
boolResult = pickStructLocation(powGen, ref buildX, ref buildY,player);
if(boolResult == TRUE)
{
initIterateGroup(buildGroup);
droid = iterateGroup(buildGroup);
while(droid != NULLOBJECT)
{
if((droid.order == DORDER_NONE or droid.order == DORDER_RTB) and (droid.order != DORDER_HELPBUILD) and (droid.order != DORDER_REPAIR))
{
orderDroidStatsLoc(droid, DORDER_BUILD,powGen, buildX,buildY);
}
droid = iterateGroup(buildGroup);
}
}
}
}
}
/////////////////////////////////////////////////////////////////////
// ensure we have everything in the vital structs list.
event buildBase(buildBaseTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(buildBase, inactive);
}
else
{
//if( idleGroup(buildGroup) >= (buildGroup.members/2) )
//{
count = 0;
while(count < numStructs)
{
// check that struct.
structure = getStructure(structs[count],player);
if(structure == NULLOBJECT) // if missing build it.
{
if(isStructureAvailable(structs[count],player))
{
buildX = baseX; // pick a location
buildY = baseY;
boolResult = pickStructLocation(structs[count], ref buildX, ref buildY,player);
if(boolResult == TRUE)
{
boolResult2 = FALSE;
initIterateGroup(buildGroup); // find idle droids in build group.
droid = iterateGroup(buildGroup);
while((droid != NULLOBJECT) and (not boolResult2))
{
if(droid.order == DORDER_NONE or droid.order == DORDER_RTB)
{
orderDroidStatsLoc(droid, DORDER_BUILD,structs[count], buildX,buildY); // build it
boolResult2 = TRUE;
}
droid = iterateGroup(buildGroup);
}
}
}
}
count = count + 1;
}
//}
}
}
/////////////////////////////////////////////////////////////////////
// build other stuff, grow the base slowly...
event buildExpand(buildExpandTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(buildExpand,inactive);
}
else
{
if(extraStruct >= numExtraStructs) // loop around
{extraStruct = 0;}
buildX = baseX; // pick a location
buildY = baseY;
boolResult = pickStructLocation(extraStructs[extraStruct], ref buildX, ref buildY,player);
if(boolResult == TRUE)
{
count = 0;
initIterateGroup(buildGroup); // find idle droids in build group.
droid = iterateGroup(buildGroup);
while((droid != NULLOBJECT) and (count < 2)) //2 trucks max
{
if((droid.order != DORDER_BUILD) and (droid.order != DORDER_LINEBUILD) and (droid.order != DORDER_HELPBUILD) and (droid.order != DORDER_REPAIR))
{
orderDroidStatsLoc(droid, DORDER_BUILD,extraStructs[extraStruct], buildX,buildY);// build it.
count = count + 1;
}
droid = iterateGroup(buildGroup);
}
extraStruct = extraStruct + 1;
}
}
}
/////////////////////////////////////////////////////////////////////
// Structure (fac/res/pow) upgrades
event upgradeStructures(upgradeStructuresTr )
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(upgradeStructures,inactive);
}
else
{
initIterateGroup(buildGroup); // find idle droids in build group.
droid = iterateGroup(buildGroup);
while(droid != NULLOBJECT)
{
if((droid.order != DORDER_BUILD) and (droid.order != DORDER_LINEBUILD) and (droid.order != DORDER_HELPBUILD) and (droid.order != DORDER_REPAIR))
{
// got an idle constructor vehicle.
//powergen
initEnumStruct(FALSE,powGen,player,player);
structure= enumStruct();
while(structure != NULLOBJECT)
{
// if upgrade is available && struct is not upgraded
if( isStructureAvailable(powModule,player) and (not testStructureModule(player, structure, 0)))
{
orderDroidStatsLoc(droid,DORDER_BUILD,powModule, structure.x,structure.y);// upgrade it.
}
structure= enumStruct();
}
//factory
if((droid.order != DORDER_BUILD) and (droid.order != DORDER_REPAIR))
{
initEnumStruct(FALSE,factory,player,player);
structure= enumStruct();
while(structure != NULLOBJECT)
{
// if upgrade is available && struct is not upgraded
if( isStructureAvailable(facModule,player) and (skGetFactoryCapacity(structure) < 2 ))
{
orderDroidStatsLoc(droid, DORDER_BUILD,facModule, structure.x,structure.y); // upgrade it.
}
structure= enumStruct();
}
}
//research
if((droid.order != DORDER_BUILD) and (droid.order != DORDER_REPAIR))
{
initEnumStruct(FALSE,resLab,player,player);
structure= enumStruct();
while(structure != NULLOBJECT)
{
// if upgrade is available && struct is not upgraded
if( isStructureAvailable(resModule,player) and (not testStructureModule(player, structure, 0)))
{
orderDroidStatsLoc(droid, DORDER_BUILD,resModule, structure.x,structure.y); // upgrade it.
}
structure= enumStruct();
}
}
//vtol Factory
if((droid.order != DORDER_BUILD) and (droid.order != DORDER_REPAIR))
{
initEnumStruct(FALSE,vtolFactory,player,player);
structure= enumStruct();
while(structure != NULLOBJECT)
{
// if upgrade is available && struct is not upgraded
if( isStructureAvailable(facModule,player) and (not testStructureModule(player, structure, 0)))
{
orderDroidStatsLoc(droid, DORDER_BUILD,facModule, structure.x,structure.y); // upgrade it.
}
structure= enumStruct();
}
}
}
droid = iterateGroup(buildGroup);
}
}
}
/////////////////////////////////////////////////////////////////////
// fortify base by builiding defensive structs on the edge of the base.
// rewrote fortify to use scrSkDefenseLocation(baseX,baseY,player);
event newfortify(fortifyTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(newfortify, inactive);
}
else
{
if(lineDroid != NULLOBJECT)
{
if(lineDroid.order == DORDER_NONE)
{
tempx = baseX;
tempy = baseY;
count = numWallWeaps - 1;
count2 = 0;
while( (count2 < 3) and (count >= 0) )
{
if( isStructureAvailable(wallWeaps[count],player))
{
structChoice[count2] = wallWeaps[count];
count2 = count2 + 1;
}
count = count - 1;
}
count = 0;
if(count2 > 0)
{
count = random(count2);
skDefenseLocation(ref tempx,ref tempy,wallStruct,structChoice[count],lineDroid,player);
}
else
{
skDefenseLocation(ref tempx,ref tempy,wallStruct,wallWeaps[2],lineDroid,player);
}
if((lineDroid.order == DORDER_NONE) or (gameTime > 36000))
{
groupAddDroid(buildGroup, lineDroid);
} //Everything's done
}
}
}
}
/////////////////////////////////////////////////////////////////////
// droid building rules
/////////////////////////////////////////////////////////////////////
// deal with a droid being built
event droidBuilt(droidBuiltTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(droidBuilt, inactive);
}
else
{
if(isVtol(droid))
{
groupAddDroid(vtolGroup, droid);
}
else
{
if(droid.droidType == DROID_REPAIR)
{
numRepairUnits = numRepairUnits + 1;
}
if(droid.droidType == DROID_SENSOR)
{
groupAddDroid(scoutGroup, droid);
}
if(droid.droidType == DROID_CONSTRUCT) // if not constructor droid
{
if(threatGroup.members < 3) //4 MAX
{
groupAddDroid(threatGroup, droid);
setGroupSecondary(threatGroup, DSO_REPAIR_LEVEL, DSS_REPLEV_NEVER);
}
else
{
boolResult = FALSE;
if(buildGroup.members > 3) //> 2
{
if(wallDroid == NULLOBJECT)
{
wallDroid = droid;
boolResult = TRUE;
}
else if(wallDroid2 == NULLOBJECT)
{
wallDroid2 = droid;
boolResult = TRUE;
}
else if(repDroid == NULLOBJECT)
{
repDroid = droid;
boolResult = TRUE;
}
else if(lineDroid == NULLOBJECT)
{
lineDroid = droid;
boolResult = TRUE;
}
}
if(not boolResult)
{
groupAddDroid(buildGroup, droid);
setGroupSecondary(buildGroup, DSO_REPAIR_LEVEL, DSS_REPLEV_NEVER);
}
}
}
else
{
if(droid.droidType == DROID_CYBORG) //setFogColour(1,150,1);
{
groupAddDroid(defendGroup, droid);
setGroupSecondary(defendGroup, DSO_REPAIR_LEVEL, DSS_REPLEV_NEVER);
}
else if(droid.body == MechanicBody) //If mechanic (not DROID_CYBORG)
{
Mechanic = droid;
groupAddDroid(defendGroup, droid);
setGroupSecondary(defendGroup, DSO_REPAIR_LEVEL, DSS_REPLEV_NEVER);
}
else
{
if(scoutGroup.members < numScouts)
{
groupAddDroid(scoutGroup, droid);
}
else if( defendGroup.members < numDefenders)
{
groupAddDroid(defendGroup, droid);
setGroupSecondary(attackGroup, DSO_REPAIR_LEVEL, DSS_REPLEV_NEVER);
}
else // just make them scouts.
{
if(attackGroup.members > scoutGroup.members)
{
groupAddDroid(scoutGroup, droid);
}
else
{
groupAddDroid(attackGroup, droid);
}
}
}
}
structure = getStructure(repairFacility,player);
if(structure == NULLOBJECT)
{
setDroidSecondary(droid,DSO_REPAIR_LEVEL, DSS_REPLEV_NEVER);
}
else
{
setDroidSecondary(droid,DSO_REPAIR_LEVEL, DSS_REPLEV_NEVER);
}
}
}
}
/////////////////////////////////////////////////////////////////////
// deal with attacks.
event droidDestroyed(droidDestroyedTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(droidDestroyed,inactive);
}
else
{
if(droid.droidType == DROID_REPAIR)
{
numRepairUnits = numRepairUnits - 1;
}
if(droid.droidType == DROID_CONSTRUCT) // if constructor droid
{
initEnumStruct(FALSE,factory,player,player);
structure= enumStruct(); // find factory.
if( (structure != NULLOBJECT) and (getDroidCount(player) < 80) )
{
if(structureIdle(structure))
{
buildDroid(constructor, structure, player, 1); // build constructor
}
}
}
}
}
/////////////////////////////////////////////////////////////////////
// build repair droids.
event repairDroids(repairDroidsTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(repairDroids,inactive);
}
else
{
// if we're running low on repair droids, build some..
if(numRepairUnits < 1)
{
initEnumStruct(FALSE,factory,player,player);
structure= enumStruct(); // find factory.
if( (structure != NULLOBJECT) and (getDroidCount(player) < 100) )
{
if( structureIdle(structure) == TRUE)
{
buildDroid(repairUnit, structure, player, 1); // build repairunit.
}
}
}
}
}
/////////////////////////////////////////////////////////////////////
// build more con droids.
event conDroids(conDroidsTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(conDroids,inactive);
}
else
{
initEnumStruct(FALSE,factory,player,player);
structure = enumStruct(); // find factory.
while(structure != NULLOBJECT)
{
if(structureIdle(structure))
{
if(buildGroup.members < 40)
{
count = random(4);
if((count == 1) or (count == 2) or (count == 3)) //HeavyTruck
{
buildDroid(HvyTruck, structure, player, 1);
}
else
{
buildDroid(constructor, structure, player, 1); // build constructor
}
}
}
structure= enumStruct();
}
}
}
/////////////////////////////////////////////////////////////////////
// put cyborg factories to work
event cyborgFactoryEvent(cyborgFactoryEventTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(cyborgFactoryEvent, inactive);
}
else
{
boolResult2 = TRUE;
boolResult = TRUE;
initEnumStruct(FALSE,cybFactory,player,player);
structure= enumStruct(); // find factory.
while(structure != NULLOBJECT)
{
if( structureIdle(structure) == TRUE)
{
if(defendGroup.members < numCyborgs)
{
boolResult2 = TRUE;
if((Mechanic == NULLOBJECT) and (boolResult)) //No mechanic, build it
{
boolResult2 = FALSE;
buildDroid(cybRepair, structure, player, 1);
boolResult = FALSE;
}
if((boolResult2) or (Mechanic != NULLOBJECT))
{
if(gameTime < 36000) //>1 hour
{
buildDroid(cybTempl[currentCyborgTemplate], structure, player, 1);
}
else
{
buildDroid(superCyb[currentCyborgTemplate], structure, player, 1);
}
}
}
}
structure= enumStruct(); // find factory.
}
// increment cyborg template counter, wrapping if required.
currentCyborgTemplate = currentCyborgTemplate + 1;
if( currentCyborgTemplate > 3)
{
currentCyborgTemplate = 0;
}
}
}
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
// scouting rules
// order scouts
event scoutMain(scoutMainTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(scoutMain, inactive);
}
else
{
// find any new scouts
// if scouts aren't busy, send them to a new spot.
if( idleGroup(scoutGroup) >= (scoutGroup.members /2) )
{
//orderGroupLoc(scoutGroup, DORDER_MOVE,scoutX,scoutY);
orderGroupLoc(scoutGroup, DORDER_MOVE,random(128 * (mapWidth - 6)) + (3 * 128),random(128 * (mapHeight - 6)) + (3 * 128));
}
}
}
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
// spy technologies
//event takeover( CALL_UNITTAKEOVER, ref droid)
event takeover(takeoverTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(takeover, inactive);
}
else
{
if(droid.player == player )
{
groupAddDroid(attackGroup, droid );
}
}
}
event takeoverDefend(takeoverTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(takeoverDefend, inactive);
}
else
{
if(droid.player != player )
{
completeResearch(nexusDefence,player);
setEventTrigger(takeoverDefend, inactive);
}
}
}
event useLassat(useLassatTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(useLassat, inactive);
}
else
{
// find my lassat
// fire it at my attack objective.
if(allOutAttack != NULLOBJECT)
{
initEnumStruct(FALSE,lassat,player,player);
structure= enumStruct();
while(structure != NULLOBJECT)
{
if(structureComplete(structure) == TRUE)
{
skFireLassat(player,allOutAttack);
structure= enumStruct();
}
}
}
}
}
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
// attack rules
// send attack team out to cause trouble near enemy derricks.
event attackStuff(attackStuffTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(attackStuff, inactive);
}
else
{
if( (idleGroup(defendGroup) >= (defendGroup.members / 2)) and (not defendbusy))
{
//FIND STRUCTURE WE ARE GOING TO ATTACK
//Find closest derrick
structure2 = NULLOBJECT;
structure = NULLOBJECT;
count = 0;
count2 = 260 * 128;
while(count < 8)
{
if(count != player) //not me
{
if(not allianceExistsBetween(player,count)) //not ally
{
initEnumStruct(FALSE,derrick,count,count);
structure2 = enumStruct();
while(structure2 != NULLOBJECT)
{
count3 = distBetweenTwoPoints(structure2.x , structure2.y , defendGroup.x, defendGroup.y);
if(count3 < count2)
{
structure = structure2;
count2 = count3;
//setFogColour(random(255),random(255),random(255));
}
structure2 = enumStruct();
}
}
}
count = count + 1;
}
if(structure == NULLOBJECT) //Couldn't find a derrick
{
count = random(multiPlayerMaxPlayers);
if(not isHumanPlayer(count)) //if not human try again
{
count = random(multiPlayerMaxPlayers);
}
if(isHumanPlayer (count)) //If human found
{
structure = getStructure(factory, count); //try to destroy player's factory
if(structure == NULLOBJECT)
{
structure = getStructure(playerHQ, count);
}
}
else
{
structure = getStructure(factory, count); //HQ is not vital to AI
}
}
else //if(structure != NULLOBJECT)
{
if ((not allianceExistsBetween(player, structure.player)) and (structure.player != player))
{
if(defendGroup.members > (6 + random(5)) )
{
orderGroupObj(defendGroup, DORDER_ATTACK,structure);
//Don't use us for any other stuff now
onPatrol = TRUE;
defendbusy = TRUE;
}
}
}
}
}
}
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
// defending rules
// defend attacked objects.
event defendWatch(defendWatchTr)
{
if((not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(defendWatch, inactive);
}
else
{
if(baseobj != NULLOBJECT)
{
if(not allianceExistsBetween(player, baseobj.player))
{
if(baseobj.player != player)
{
//If we were attacked by a structure
//Was it an arty weapon we can't reach?
if(artyObj == NULLOBJECT) //if we are not already hunting one...
{
if(baseobj.type == OBJ_DROID) //If we were attacked by a unit
{
droid = objToDroid(baseobj);
count = 0;
while(count < 8)
{
if(droid.weapon == artyWeapon[count])
{
artyObj = baseobj; //you have just became cannon fodder baby!!!
count = 20; //Break loop
}
count = count + 1;
}
}
else if(baseobj.type == OBJ_STRUCTURE) //if structure
{
structure2 = objToStructure(baseobj);
count = 0;
while(count < 8)
{
if(structure2.stat == artyStruct[count])
{
artyObj = baseobj; //you have just became cannon fodder baby!!!
count = 20; //Break loop
}
count = count + 1;
}
}
}
//Cyborgs
if(not defendbusy)
{
defendObj = baseobj;
defendbusy = TRUE;
onPatrol = FALSE;
if((artyObj == NULLOBJECT) or (artyObj == defendObj)) //If no arty to attack or we just found it
{
orderGroupLoc(defendGroup, DORDER_MOVE,defendObj.x,defendObj.y);
}
else //Attack arty (more important)
{
orderGroupLoc(defendGroup, DORDER_MOVE,defendObj.x,artyObj.y);
}
}
//THEY ARE IN OUR BASE!!!! forget about everything and come back to help
else if((baseobj.x > minx) and (baseobj.y > miny) and (baseobj.x < maxx) and (baseobj.y <maxy))
{
defendbusy = TRUE;
onPatrol = FALSE;
orderGroupLoc(defendGroup, DORDER_MOVE,baseobj.x,baseobj.y);
}
//Defend this area with structures
if(structure != NULLOBJECT) //if structure which was attacked still exists
{
threatX = (baseobj.x + structure.x)/2; //store coords.
threatY = (baseobj.y + structure.y)/2; //store coords.
}
else
{
threatX = baseobj.x; //store coords.
threatY = baseobj.y; //store coords.
}
if(threatX != 0)
{
count2 = random(9);
boolResult = pickStructLocation(wallWeaps[count2], ref threatX, ref threatY,player);
if(boolResult)
{
if(numStructsInArea(player, threatX - (2 * 128),threatY - (2 * 128), threatX + (2 * 128),threatY + (2 * 128)) <= 4)
{
//threat group
initIterateGroup(threatGroup); // find all units in threat group.
droid = iterateGroup(threatGroup);
count = 0;
while(droid != NULLOBJECT)
{
if(droid.order != DORDER_BUILD)
{
if(count == 0) //first truck
{
orderDroidStatsLoc(droid, DORDER_BUILD,wallWeaps[count2], threatX,threatY);
count = count + 1;
}
}
droid = iterateGroup(threatGroup);
}
}
}
}
}
}
}
}
}
/////////////////////////////////////////////////////////////////////
// defenders return after they are finished.
event defendReturn(defendReturnTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(defendReturn, inactive);
}
else
{
//if(idleGroup(defendGroup) == defendGroup.members)
if(idleGroup(defendGroup) >= (defendGroup.members - 2)) // "- 2" if someone stuck...
{
//You can use us now
defendbusy = FALSE;
onPatrol = FALSE;
}
}
}
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
// Research Rules Now does true research.
// do research
event doResearch(doResearchTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(doResearch, inactive);
}
else
{
// for every research lab do this..
initEnumStruct(FALSE,resLab,player,player);
structure= enumStruct();
count = 0;
while(structure != NULLOBJECT)
{
skDoResearch(structure,player,0);
structure= enumStruct();
}
}
}
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
// Alliance Rules
// form alliances
event formAllianceEvent(formAllianceEventTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(formAllianceEvent, inactive);
}
else
{
count = 0;
while(count<8)
{
if( count != player ) // if not the only other player and rand2
{
if((getDroidCount(player) > 1) and (getDroidCount(count) > 1) ) // not dead
{
if(random(28) == 1) // bit random
{
if(not isHumanPlayer(count)) // not human
{
createAlliance(player,count);
allianceTime[count] = gameTime;
}
}
}
}
count = count + 1;
}
}
}
/////////////////////////////////////////////////////////////////////
// break the alliance too.
event breakAllianceEvent(breakAllianceEventTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(breakAllianceEvent, inactive);
}
else
{
count = 0;
while(count<multiPlayerMaxPlayers)
{
if( count != player)
{
if((getDroidCount(player) > 1) and (getDroidCount(count) > 1) ) // not dead
{
if(allianceExistsBetween(player,count) )
{
// check if we're in alliance with any other players.
if( (random(30) == 1) and ( (gameTime - allianceTime[count]) > 9000) ) // rand and more than 10 minutes.
{
allianceTime[count] = gameTime;
breakAlliance(player,count);
}
// rules for breaking alliances with humans.
// built within my base
if(numStructsInArea(count,minx,miny,maxx,maxy) > 1)
{
allianceTime[count] = gameTime;
breakAlliance(player,count);
}
// you've got lots of units in my area.
if(numDroidsInArea(count,minx,miny,maxx,maxy) > 3)
{
allianceTime[count] = gameTime;
breakAlliance(player,count);
}
// you've wiped out one of my allies ??.
}
}
}
count = count + 1;
}
}
}
/////////////////////////////////////////////////////////////////////
event formHumanAlliances(humanAllianceTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(formHumanAlliances, inactive);
}
else
{
if(count2 == player) // offered to me.
{
result = 0;
result2 = 0;
while(result < multiPlayerMaxPlayers)
{
if(allianceExistsBetween(count,result))
{
result2 = result2 + 1;
}
result = result + 1;
}
if( result2 < ((multiPlayerMaxPlayers / 2) - 1) ) // not too many already
{
//not too soon.
if((allianceTime[count] == 0) or (gameTime - allianceTime[count] > 7200))
{
result = 0; // check forming wont end the game
result2 = 0;
while(result < multiPlayerMaxPlayers)
{
while(result2 < multiPlayerMaxPlayers)
{
if((not allianceExistsBetween(result,result2)) and (getDroidCount(result) > 0) and (getDroidCount(result2) > 0) and (result != result2) )
{
if( not ((result == count and result2 == count2) or (result2 == count2 and result == count)) ) // ignore the outcome of this alliance
{
createAlliance(player,count);
allianceTime[count] = gameTime;
}
}
result2 = result2 + 1;
}
result = result + 1;
}
}
}
}
}
}
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
// power management.
// if running low on power put some power eating stuff on hold for a while.
event managePower(managePowerTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(managePower, inactive);
}
else
{
if( playerPower(player) == 0 ) // turn off some events.
{
powerSave = TRUE;
// setEventTrigger(fortify, inactive); // stop building defenses.
setEventTrigger(upgradeStructures, inactive); // stop building oil defenses.
// setEventTrigger(buildExpand, inactive); // stop building extra buildings.
setEventTrigger(conDroids, inactive); // stop building more construct droids.
}
else
{
if(powerSave == TRUE) // turn events back on.
{
powerSave = FALSE;
// setEventTrigger(fortify, fortifyTr); // building defenses.
setEventTrigger(upgradeStructures, upgradeStructuresTr);// building oil defenses.
// setEventTrigger(buildExpand, buildExpandTr); // building extra buildings.
setEventTrigger(conDroids, conDroidsTr); // building more construct droids.
}
}
}
}
/////////////////////////////////////////////////////////////////////
event difficultyModifier(difficultyModifierTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(difficultyModifier, inactive);
}
else
{
skDifficultyModifier(player);
}
}
/////////////////////////////////////////////////////////////////////
// vtols.
/////////////////////////////////////////////////////////////////////
// build vtol strucutures.
event vtolStructs(vtolStructsTr) //event vtolStructs(inactive)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(vtolStructs,inactive);
}
else
{
structure = getStructure(vtolFactory,player); // if we dont have vtol factory
if(structure == NULLOBJECT) // if missing build it.
{
// build factory
buildX = baseX; // pick a location
buildY = baseY;
boolResult = pickStructLocation(vtolFactory, ref buildX, ref buildY,player);
if(boolResult == TRUE)
{
initIterateGroup(buildGroup); // find idle droids in build group.
droid = iterateGroup(buildGroup);
boolResult = FALSE; // only send 1 droid to do the job
while( (boolResult == FALSE) and (droid != NULLOBJECT))
{
if((droid.order == DORDER_NONE or droid.order == DORDER_RTB) and (droid.order != DORDER_HELPBUILD) and (droid.order != DORDER_REPAIR))
{
orderDroidStatsLoc(droid, DORDER_BUILD,vtolFactory, buildX,buildY);
boolResult = TRUE;
}
droid = iterateGroup(buildGroup);
}
}
}
else // we have a factory..
{
// count rearm pads
initEnumStruct(FALSE,vtolPad,player,player);
structure= enumStruct();
count = 0;
while(structure != NULLOBJECT)
{
count = count + 1;
structure= enumStruct();
}
// do we have 7 or more rearm pads?
if(count < 7) //was 2
{
// build vtol rearm pads.
buildX = baseX; // pick a location
buildY = baseY;
boolResult = pickStructLocation(vtolPad, ref buildX, ref buildY,player);
if(boolResult == TRUE)
{
initIterateGroup(buildGroup); // find idle droids in build group.
droid = iterateGroup(buildGroup);
while( droid != NULLOBJECT)
{
if((droid.order != DORDER_BUILD) and (droid.order != DORDER_LINEBUILD) and (droid.order != DORDER_REPAIR))
{
orderDroidStatsLoc(droid, DORDER_BUILD,vtolPad, buildX,buildY);
}
droid = iterateGroup(buildGroup);
}
}
}
}
}
}
/////////////////////////////////////////////////////////////////////
// build vtols.
event buildVtols(buildVtolsTr) //event buildVtols(inactive)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(buildVtols,inactive);
}
else
{
structure = getStructure(vtolPad,player); // got vtol pads?
if(structure != NULLOBJECT)
{
structure = getStructure(vtolFactory,player); // got a vtolfac?
if(structure != NULLOBJECT)
{
if(vtolGroup.members < 12) //was 4 // got enough vtols?
{
if(structureIdle(structure) == TRUE) // if factory idle
{
count = numVtolTemplates - 1;
count2 = 0;
while( (count2 < 3) and (count >= 0) )
{
if( skCanBuildTemplate(player,structure, vtols[count]) )
{
tmplChoice[count2] = vtols[count];
count2 = count2 + 1;
}
count = count - 1;
}
if(count2 == 0)
{
buildDroid(vtols[1],structure,player,1);
}
else
{
buildDroid(tmplChoice[random(count2)],structure,player,1);
}
}
}
}
}
}
}
/////////////////////////////////////////////////////////////////////
// attack with vtols.
event vtolAttack(vtolAttackTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(vtolAttack,inactive);
}
else
{
if( (idleGroup(vtolGroup) >= (vtolGroup.members /2)) and (vtolGroup.members > 2) )
{
//No arty to attack, find something else to have fun with...
if(artyObj == NULLOBJECT)
{
count = random(8);
if(isHumanPlayer (count)) //If human found
{
structure = getStructure(derrick, count); //try to destroy player's derrick
if(structure == NULLOBJECT)
{
structure = getStructure(playerHQ, count);
if(structure == NULLOBJECT)
{
structure = getStructure(factory, count);
}
}
}
else
{
structure = getStructure(derrick, count);
if(structure == NULLOBJECT)
{
structure = getStructure(factory, count);
if(structure == NULLOBJECT)
{
structure = getStructure(playerHQ, count);
}
}
}
if(structure != NULLOBJECT)
{
if(not allianceExistsBetween(player, structure.player))
{
if(structure.player != player)
{
orderGroupObj(vtolGroup, DORDER_ATTACK,structure); // get the attack target.
}
}
}
else
{
if(defendObj != NULLOBJECT)
{
orderGroupObj(vtolGroup, DORDER_ATTACK,defendObj); // get the defend target
}
}
}
else //Attack enemy arty
{
orderGroupObj(vtolGroup, DORDER_ATTACK,artyObj);
}
}
}
}
/////////////////////////////////////////////////////////////////////
// watch for incoming vtols
event vtolDefend(vtolDefendTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(vtolDefend,inactive);
}
else
{
if(baseobj != NULLOBJECT)
{
if(baseobj.type == OBJ_DROID)
{
if(isVtol(objToDroid(baseobj)))
{
boolResult2 = FALSE;
initIterateGroup(buildGroup); // find idle droids in build group
droid = iterateGroup(buildGroup);
while((droid != NULLOBJECT) and (not boolResult2))
{
if((structure != NULLOBJECT) and (droid.order != DORDER_BUILD))
{
buildX = structure.x;
buildY = structure.y;
count = random(5);
boolResult = pickStructLocation(vtolDefStruct[count], ref buildX, ref buildY,player);
if(boolResult == TRUE) // build a vtol defense near the attacked struct...
{
orderDroidStatsLoc(droid, DORDER_BUILD,vtolDefStruct[count],buildX,buildY);
boolResult2 = TRUE;
}
}
droid = iterateGroup(buildGroup);
}
/* THREAT GROUP */
initIterateGroup(threatGroup); // find idle droids in build group.
droid = iterateGroup(threatGroup);
result = 0; //count droids
while((droid != NULLOBJECT) and (not boolResult2))
{
if((structure != NULLOBJECT) and (droid.order != DORDER_BUILD))
{
buildX = structure.x;
buildY = structure.y;
count = random(5);
boolResult = pickStructLocation(vtolDefStruct[count], ref buildX, ref buildY,player);
if(boolResult) // build a vtol defense near the attacked struct...
{
if(result == 0)
{
//not too many VTOL defenses
result2 = 0;
count3 = 0;
while(result2 < 5)
{
structure2 = structureBuiltInRange(vtolDefStruct[result2], buildX, buildX,(5*128), player);
if(structure2 != NULLOBJECT)
{
count3 = count3 + 1;
}
result2 = result2 + 1;
}
if(count3 < 5)
{
orderDroidStatsLoc(droid, DORDER_BUILD,vtolDefStruct[count],buildX,buildY);
}
else //if already enough defenses, repair attacked structure
{
orderDroidObj(droid, DORDER_REPAIR, structure);
}
}
}
//}
result = result + 1;
}
droid = iterateGroup(threatGroup);
}
}
}
}
}
}
/////////////////////////////////////////////////////////////////////
event vtolEnabler(vtolEnablerTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(vtolEnabler,inactive);
}
else
{
if( skVtolEnableCheck(player) ) // check to see if we have vtol technologies.
{
setEventTrigger(vtolStructs,vtolStructsTr); // activate other vtol functions..
setEventTrigger(buildVtols, buildVtolsTr);
setEventTrigger(vtolAttack, vtolAttackTr);
setEventTrigger(vtolEnabler,inactive); // turn off this event.
}
}
}
//give help2
event givehelp2(givehelp2Tr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(givehelp2,inactive);
}
else
{
structure3 = getStructure(derrick, player);
if (structure3 != NULLOBJECT)
{
addPower(40, player);
}
}
}
//BUILD SENSORS
event buildSensors(buildSensorsTr)
{
if( (not aiDebugMode) and ((player == selectedPlayer) or (not myResponsibility(player))) )
{
setEventTrigger(buildSensors,inactive);
}
else
{
count = 0;
initEnumStruct(FALSE,factory,player,player);
structure= enumStruct(); // find factory.
while(structure != NULLOBJECT)
{
if(count < 2)
{
if(scoutGroup.members < 2)
{
buildDroid(sense[3], structure, player, 1); // build sensor
count = count + 1;
}
}
structure= enumStruct();
}
}
}
/////////////////////////////////////////////////////////////////////
// HouseKeeping
event reassignPlayers(reassignTr)
{
// setEventTrigger(useDroids,useDroidsTr);
setEventTrigger(defendDerricks,defendDerricksTr); //buildDefenses
// setEventTrigger(buildDefenses,buildDefensesTr); //helpBuildTr
setEventTrigger(helpBuild,helpBuildTr); //threatReturn
setEventTrigger(threatReturn,threatReturnTr);
setEventTrigger(buildWallsAround,buildWallsAroundTr);
setEventTrigger(repairStructures,repairStructuresTr);
setEventTrigger(givehelp2,givehelp2Tr);
setEventTrigger(buildSensors,buildSensorsTr);
setEventTrigger(basedetails,basedetailsTr);
setEventTrigger(buildDerrick,buildDerrickTr);
setEventTrigger(buildOilDefenseOrRetreat,buildOilDefenseOrRetreatTr);
setEventTrigger(buildPowerGenerators,buildPowerGeneratorsTr);
setEventTrigger(buildBase,buildBaseTr );
setEventTrigger(buildExpand,buildExpandTr );
setEventTrigger(upgradeStructures,upgradeStructuresTr );
setEventTrigger(newfortify,fortifyTr );
setEventTrigger(droidBuilt,droidBuiltTr);
setEventTrigger(droidDestroyed,droidDestroyedTr);
setEventTrigger(conDroids,conDroidsTr);
setEventTrigger(repairDroids,repairDroidsTr);
setEventTrigger(cyborgFactoryEvent,cyborgFactoryEventTr);
setEventTrigger(scoutMain,scoutMainTr);
//setEventTrigger(newObjectReport,newObjectReportTr);
setEventTrigger(takeover,takeoverTr);
setEventTrigger(useLassat,useLassatTr);
//setEventTrigger(findEnemy,attackStuffTr);
setEventTrigger(attackStuff,attackStuffTr);
//setEventTrigger(doAllOutAttack,allOutAttackTr);
setEventTrigger(defendWatch,defendWatchTr);
setEventTrigger(defendReturn,defendReturnTr);
setEventTrigger(doResearch,doResearchTr);
setEventTrigger(formAllianceEvent,formAllianceEventTr);
setEventTrigger(breakAllianceEvent,breakAllianceEventTr);
setEventTrigger(managePower,managePowerTr);
setEventTrigger(difficultyModifier,difficultyModifierTr);
setEventTrigger(vtolStructs,vtolStructsTr); //was inactive
setEventTrigger(buildVtols,buildVtolsTr); //was inactive
setEventTrigger(vtolAttack,vtolAttackTr); //was inactive
setEventTrigger(vtolDefend,vtolDefendTr);
setEventTrigger(vtolEnabler,vtolEnablerTr);
setEventTrigger(formHumanAlliances,humanAllianceTr);
}
/////////////////////////////////////////////////////////////////////
//Arty weapons
//Howitzers
artyWeapon[0] WEAPON "Howitzer105Mk1"
artyWeapon[1] WEAPON "Howitzer150Mk1"
artyWeapon[2] WEAPON "Howitzer03-Rot"
artyWeapon[3] WEAPON "Howitzer-Incenediary"
//Heavy mortars
artyWeapon[4] WEAPON "Mortar2Mk1"
artyWeapon[5] WEAPON "Mortar3ROTARYMk1"
artyWeapon[6] WEAPON "Mortar-Incenediary"
artyWeapon[7] WEAPON "MortarEMP"
//Arty structures
//Howitzers
artyStruct[0] STRUCTURESTAT "Emplacement-Howitzer105"
artyStruct[1] STRUCTURESTAT "Emplacement-Howitzer150"
artyStruct[2] STRUCTURESTAT "Emplacement-RotHow"
artyStruct[3] STRUCTURESTAT "Emplacement-Howitzer-Incenediary"
//Mortars
artyStruct[4] STRUCTURESTAT "Emplacement-MortarPit02"
artyStruct[5] STRUCTURESTAT "Emplacement-RotMor"
artyStruct[6] STRUCTURESTAT "Emplacement-MortarPit-Incenediary"
artyStruct[7] STRUCTURESTAT "Emplacement-MortarEMP"
numScouts INT 12 // min number of droids in group to aim for.
numDefenders INT 20
numAttackers INT 12
numCyborgs INT 50 // build cyborgs until scouts contains x droids
tileExpand INT 25 // approx minutes to expand over the map.
camTech [0] RESEARCHSTAT "R-Cyborg-Wpn-Rocket"
camTech [1] RESEARCHSTAT "R-Defense-Pillbox06"
camTech [2] RESEARCHSTAT "R-Wpn-MortarEMP"
camTech [3] RESEARCHSTAT "R-Defense-EMPMortar"
//cyborgs
CybProd[0] RESEARCHSTAT "R-Struc-Factory-Cyborg-Upgrade01"
CybProd[1] RESEARCHSTAT "R-Struc-Factory-Cyborg-Upgrade02"
CybProd[2] RESEARCHSTAT "R-Struc-Factory-Cyborg-Upgrade03"
CybProd[3] RESEARCHSTAT "R-Struc-Factory-Cyborg-Upgrade04"
CybProd[4] RESEARCHSTAT "R-Struc-Factory-Cyborg-Upgrade05"
CybProd[5] RESEARCHSTAT "R-Struc-Factory-Cyborg-Upgrade06"
CybProd[6] RESEARCHSTAT "R-Struc-Factory-Cyborg-Upgrade07"
CybProd[7] RESEARCHSTAT "R-Struc-Factory-Cyborg-Upgrade08"
CybProd[8] RESEARCHSTAT "R-Struc-Factory-Cyborg-Upgrade09"
CybProd[9] RESEARCHSTAT "R-Sys-Engineering01"
CybProd[10] RESEARCHSTAT "R-Sys-Engineering02"
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
// structures
// generic names, often used.
oilRes FEATURESTAT "OilResource"
resLab STRUCTURESTAT "A0ResearchFacility"
powGen STRUCTURESTAT "A0PowerGenerator"
factory STRUCTURESTAT "A0LightFactory"
pillBox6 STRUCTURESTAT "PillBox6"
derrick STRUCTURESTAT "A0ResourceExtractor"
cybFactory STRUCTURESTAT "A0CyborgFactory"
playerHQ STRUCTURESTAT "A0CommandCentre"
vtolPad STRUCTURESTAT "A0VtolPad"
vtolFactory STRUCTURESTAT "A0VTolFactory1"
repairFacility STRUCTURESTAT "A0RepairCentre3"
sensorTower STRUCTURESTAT "Sys-SensoTower02"
lassat STRUCTURESTAT "A0LasSatCommand"
nexusDefence RESEARCHSTAT "R-Sys-Resistance-Circuits"
// incendry emplacements.
numIncendrys INT 8
incendrys[0] STRUCTURESTAT "Emplacement-Howitzer150"
incendrys[1] STRUCTURESTAT "Emplacement-Howitzer150"
incendrys[2] STRUCTURESTAT "Emplacement-Howitzer150"
incendrys[3] STRUCTURESTAT "Emplacement-Howitzer150"
incendrys[4] STRUCTURESTAT "Emplacement-Howitzer150"
incendrys[5] STRUCTURESTAT "Emplacement-Howitzer150"
incendrys[6] STRUCTURESTAT "Emplacement-Howitzer150"
incendrys[7] STRUCTURESTAT "Emplacement-Howitzer150"
//anti a.
vtolDefStruct[0] STRUCTURESTAT "WallTower-DoubleAAGun" //1
vtolDefStruct[1] STRUCTURESTAT "WallTower-DoubleAAGun" //2
vtolDefStruct[2] STRUCTURESTAT "WallTower-DoubleAAGun" //"AASite-QuadRotMg"
vtolDefStruct[3] STRUCTURESTAT "P0-AASite-Laser" //"P0-AASite-SAM1" //3
vtolDefStruct[4] STRUCTURESTAT "WallTower-DoubleAAGun" //"P0-AASite-SAM2"
// upgrade structures
powModule STRUCTURESTAT "A0PowMod1"
facModule STRUCTURESTAT "A0FacMod1"
resModule STRUCTURESTAT "A0ResearchModule1"
// Essential structs.
numStructs INT 13
structs[0] STRUCTURESTAT "A0PowerGenerator"
structs[1] STRUCTURESTAT "A0LightFactory"
structs[2] STRUCTURESTAT "A0CyborgFactory"
structs[3] STRUCTURESTAT "A0CommandCentre"
structs[4] STRUCTURESTAT "A0ResearchFacility"
structs[5] STRUCTURESTAT "A0RepairCentre3"
structs[6] STRUCTURESTAT "A0LightFactory"
structs[7] STRUCTURESTAT "A0LasSatCommand"
structs[8] STRUCTURESTAT "A0Sat-linkCentre"
structs[9] STRUCTURESTAT "A0VTolFactory1"
structs[10] STRUCTURESTAT "X-Super-Cannon"
structs[11] STRUCTURESTAT "X-Super-MassDriver"
structs[12] STRUCTURESTAT "X-Super-Missile"
// defensive structs.
numDefStructs INT 21
defStructs[0] STRUCTURESTAT "PillBox6"
defStructs[1] STRUCTURESTAT "Emplacement-HPVcannon"
defStructs[2] STRUCTURESTAT "WallTower03" //"WallTower-PulseLas"
defStructs[3] STRUCTURESTAT "Sys-SensoTower02"
defStructs[4] STRUCTURESTAT "Emplacement-PulseLaser"
defStructs[5] STRUCTURESTAT "WallTower-PulseLas" // Campaign 2 Defensive Structures
defStructs[6] STRUCTURESTAT "Emplacement-HvyATrocket"
defStructs[7] STRUCTURESTAT "Emplacement-PrisLas"
defStructs[8] STRUCTURESTAT "WallTower-Rail3"
defStructs[9] STRUCTURESTAT "Emplacement-MortarEMP"
defStructs[10] STRUCTURESTAT "WallTower-Atmiss"
defStructs[11] STRUCTURESTAT "Emplacement-Rail3"
defStructs[12] STRUCTURESTAT "Emplacement-PulseLaser" // Campaign 3 Defensive Structures
defStructs[13] STRUCTURESTAT "Emplacement-Rail3"
defStructs[14] STRUCTURESTAT "Emplacement-PulseLaser"
defStructs[15] STRUCTURESTAT "Emplacement-PrisLas"
defStructs[16] STRUCTURESTAT "WallTower-DoubleAAGun"
defStructs[17] STRUCTURESTAT "Emplacement-MortarEMP"
defStructs[18] STRUCTURESTAT "Emplacement-HeavyLaser"
defStructs[19] STRUCTURESTAT "Emplacement-PlasmaCannon"
defStructs[20] STRUCTURESTAT "Emplacement-PlasmaCannon"
// wall structs (4)
numWallWeaps INT 9
wallStruct STRUCTURESTAT "A0HardcreteMk1Wall"
wallWeaps[0] STRUCTURESTAT "WallTower-HPVcannon"
wallWeaps[1] STRUCTURESTAT "WallTower-PulseLas"
wallWeaps[2] STRUCTURESTAT "WallTower04"
wallWeaps[3] STRUCTURESTAT "WallTower04"
wallWeaps[4] STRUCTURESTAT "WallTower06"
wallWeaps[5] STRUCTURESTAT "WallTower-Rail2"
wallWeaps[6] STRUCTURESTAT "WallTower-HvATrocket"
wallWeaps[7] STRUCTURESTAT "WallTower-Atmiss"
wallWeaps[8] STRUCTURESTAT "WallTower-Rail3"
// extra structs
numExtraStructs INT 24
extraStructs[0] STRUCTURESTAT "A0LightFactory"
extraStructs[1] STRUCTURESTAT "A0ResearchFacility"
extraStructs[2] STRUCTURESTAT "A0ResearchFacility"
extraStructs[3] STRUCTURESTAT "A0LightFactory" //WallTower03
extraStructs[4] STRUCTURESTAT "A0CyborgFactory"
extraStructs[5] STRUCTURESTAT "A0CyborgFactory"
extraStructs[6] STRUCTURESTAT "Emplacement-MortarEMP"
extraStructs[7] STRUCTURESTAT "WallTower-SamHvy"
extraStructs[8] STRUCTURESTAT "Emplacement-MortarEMP"
extraStructs[9] STRUCTURESTAT "A0CyborgFactory"
extraStructs[10] STRUCTURESTAT "A0CyborgFactory"
extraStructs[11] STRUCTURESTAT "A0ResearchFacility"
extraStructs[12] STRUCTURESTAT "A0LightFactory"
extraStructs[13] STRUCTURESTAT "A0LightFactory"
extraStructs[14] STRUCTURESTAT "X-Super-MassDriver"
extraStructs[15] STRUCTURESTAT "Emplacement-Howitzer150"
extraStructs[16] STRUCTURESTAT "Emplacement-HeavyLaser"
extraStructs[17] STRUCTURESTAT "WallTower-DoubleAAGun"
extraStructs[18] STRUCTURESTAT "A0ResearchFacility"
extraStructs[19] STRUCTURESTAT "X-Super-Cannon"
extraStructs[20] STRUCTURESTAT "X-Super-MassDriver"
extraStructs[21] STRUCTURESTAT "X-Super-Missile"
extraStructs[22] STRUCTURESTAT "X-Super-Missile"
extraStructs[23] STRUCTURESTAT "X-Super-Cannon"
LSensor STRUCTURESTAT "Sys-SpyTower"
/////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////
// SKIRMISH TEMPLATES
// COMBAT TEMPLATES
numTemplates INT 73
tmpl[0] TEMPLATE "ViperMG01Wheels"
tmpl[1] TEMPLATE "ViperMG02Wheels"
tmpl[2] TEMPLATE "ViperMRLWheels"
tmpl[3] TEMPLATE "ViperMG02Halftrack"
tmpl[4] TEMPLATE "ViperHMGHalftrack"
tmpl[5] TEMPLATE "ViperHMGTracks"
tmpl[6] TEMPLATE "ViperLtA-Twheels"
tmpl[7] TEMPLATE "ViperMedCnTrks"
tmpl[8] TEMPLATE "SK-Cobra-Hover-Lancer"
tmpl[9] TEMPLATE "SK-Cobra-Hover-Lancer"
tmpl[10] TEMPLATE "SK-Cobra-Hover-Lancer"
tmpl[11] TEMPLATE "SK-Cobra-Hover-Lancer"
tmpl[12] TEMPLATE "CobraLtA-Thalftrack"
tmpl[13] TEMPLATE "SK-Cobra-Hover-Lancer"
tmpl[14] TEMPLATE "CobraHvyMortarHalftrack"
tmpl[15] TEMPLATE "Sk-CobraBBHover"
tmpl[16] TEMPLATE "SK-Cobra-Hover-Lancer"
tmpl[17] TEMPLATE "SK-Cobra-Hover-Lancer"
tmpl[18] TEMPLATE "CobraMedCnTrks"
tmpl[19] TEMPLATE "SK-Cobra-Hover-HMG"
tmpl[20] TEMPLATE "CobraHvyCnTrks"
tmpl[21] TEMPLATE "SK-Cobra-Hover-BB"
tmpl[22] TEMPLATE "PythonLtCnTrks"
tmpl[23] TEMPLATE "SK-Python-Hover-Mcannon"
tmpl[24] TEMPLATE "PythonMedCnTrks"
tmpl[25] TEMPLATE "SK-Python-Hover-Hcannon"
tmpl[26] TEMPLATE "SK-Python-Hover-Lancer"
//Campaign 2
tmpl[27] TEMPLATE "SK-Python-Hover-Hcannon"
tmpl[28] TEMPLATE "SK-Cobra-Track-HVC"
tmpl[29] TEMPLATE "SK-Cobra-Track-TK"
tmpl[30] TEMPLATE "SK-Python-Track-Hcannon"
tmpl[31] TEMPLATE "Sk-PythonHvCanTrack"
tmpl[32] TEMPLATE "SK-Leopard-Track-Lancer"
tmpl[33] TEMPLATE "SK-Leopard-HTrk-ASGun"
tmpl[34] TEMPLATE "SK-Panther-Track-HVC"
tmpl[35] TEMPLATE "SK-Panther-Hover-HVC"
tmpl[36] TEMPLATE "SK-Panther-Track-TK"
tmpl[37] TEMPLATE "SK-Panther-Hover-TK"
tmpl[38] TEMPLATE "SK-Panther-Htrk-ASGun"
tmpl[39] TEMPLATE "SK-Panther-Htrk-BB"
tmpl[40] TEMPLATE "SK-Tiger-Track-Hcannon"
tmpl[41] TEMPLATE "SK-Tiger-Hover-Hcannon"
tmpl[42] TEMPLATE "SK-Tiger-Track-HVC"
tmpl[43] TEMPLATE "SK-Tiger-Hover-HVC"
tmpl[44] TEMPLATE "SK-Tiger-Track-TK"
tmpl[45] TEMPLATE "SK-Tiger-Hover-TK"
tmpl[46] TEMPLATE "SK-Tiger-Track-ASCannon"
tmpl[47] TEMPLATE "SK-Tiger-Hover-ASCannon"
//Campaign 3
tmpl[48] TEMPLATE "SK-Leopard-Htrk-Needle"
tmpl[49] TEMPLATE "SK-Leopard-Hover-Needle"
tmpl[50] TEMPLATE "SK-Panther-Track-RailGun"
tmpl[51] TEMPLATE "SK-Panther-Track-TK"
tmpl[52] TEMPLATE "SK-Panther-Hover-TK"
tmpl[53] TEMPLATE "SK-Tiger-Track-Scourge"
tmpl[54] TEMPLATE "SK-Tiger-Hover-Scourge"
tmpl[55] TEMPLATE "SK-Tiger-Track-Gauss"
tmpl[56] TEMPLATE "SK-Tiger-Hover-Gauss"
tmpl[57] TEMPLATE "SK-Retal-Track-Needle"
tmpl[58] TEMPLATE "SK-Retre-Track-PulseLsr"
tmpl[59] TEMPLATE "SK-Retre-Track-FlashLight"
tmpl[60] TEMPLATE "SK-Retre-Htrk-Pepper"
tmpl[61] TEMPLATE "SK-Retre-Track-RailGun"
tmpl[62] TEMPLATE "SK-Veng-Track-Scourge"
tmpl[63] TEMPLATE "SK-Retre-Hover-RailGun"
tmpl[64] TEMPLATE "SK-Retre-Track-Scourge"
tmpl[65] TEMPLATE "SK-Retre-Hover-Scourge"
tmpl[66] TEMPLATE "SK-Veng-Track-Gauss"
tmpl[67] TEMPLATE "SK-Veng-Hover-Gauss"
tmpl[68] TEMPLATE "SK-Veng-Track-PulseLsr"
tmpl[69] TEMPLATE "SK-Veng-Hover-PulseLsr"
tmpl[70] TEMPLATE "SK-Veng-Hover-Scourge"
tmpl[71] TEMPLATE "SK-Veng-Track-C6TwinAslt"
tmpl[72] TEMPLATE "SK-Veng-Track-HvyLaser"
/////////////////////////////////////////////////////////////////////
// SENSORS / REPAIR TEMPLATES
constructor TEMPLATE "ConstructorDroid"
repairUnit TEMPLATE "ViperRepairHalftrack"
numSenseTemplates INT 10
//Campaign 1
sense[0] TEMPLATE "ViperRepairWheels"
sense[1] TEMPLATE "ViperRepairHalftrack"
sense[2] TEMPLATE "CobraSensorHalftrack"
//Campaign 2
sense[3] TEMPLATE "SK-Bug-Hover-Sensor"
sense[4] TEMPLATE "SK-Bug-Hover-Repair"
sense[5] TEMPLATE "SK-Leopard-Hover-Sensor"
sense[6] TEMPLATE "SK-Leopard-Hover-Repair"
sense[7] TEMPLATE "SK-Panther-Track-Repair"
//Campaign 3
sense[8] TEMPLATE "SK-Retal-Hover-Sensor"
sense[9] TEMPLATE "SK-Retal-Hover-Repair"
//commander TEMPLATE "CobraComHalftrack"
HvyTruck TEMPLATE "CobraSpadeTracks"
transporter TEMPLATE "Transporter"
/////////////////////////////////////////////////////////////////////
// cyborg templates
cybTempl[0] TEMPLATE "CyborgCannon01Grd" //
cybTempl[1] TEMPLATE "CyborgRotMgGround" //
cybTempl[2] TEMPLATE "Cyb-Thermite" //CyborgFlamer01Grd
cybTempl[3] TEMPLATE "Cyb-Gren" //
superCyb[0] TEMPLATE "Cyb-Hvy-RailGunner"
superCyb[1] TEMPLATE "Cyb-Hvy-PulseLsr"
superCyb[2] TEMPLATE "Cyb-Hvy-RailGunner"
superCyb[3] TEMPLATE "Cyb-Hvy-PulseLsr"
cybRepair TEMPLATE "Cyb-Mechanic"
MechanicBody BODY "Cyb-Bod-Mechanic"
/////////////////////////////////////////////////////////////////////
// VTOL TEMPLATES
numVtolTemplates INT 17
//Campaign 1
vtols[0] TEMPLATE "SK-Bug-VTOL-BB"
vtols[1] TEMPLATE "P6-L-LTAT-V"
//Campaign 2
vtols[2] TEMPLATE "SK-Bug-VTOL-BB"
vtols[3] TEMPLATE "SK-Bug-VTOL-BB"
vtols[4] TEMPLATE "SK-Scorpion-VTOL-BB"
vtols[5] TEMPLATE "SK-Scorpion-VTOL-Hbomb"
vtols[6] TEMPLATE "SK-Mantis-VTOL-BB"
vtols[7] TEMPLATE "SK-Leopard-VTOL-BB"
vtols[8] TEMPLATE "SK-Leopard-VTOL-PhosBomb"
vtols[9] TEMPLATE "SK-Panther-VTOL-Thermite"
vtols[10] TEMPLATE "SK-Panther-VTOL-BB"
vtols[11] TEMPLATE "SK-Panther-VTOL-Phosbomb"
vtols[12] TEMPLATE "SK-Panther-VTOL-TK"
//Campaign 3
vtols[13] TEMPLATE "SK-Retal-VTOL-Phosbomb"
vtols[14] TEMPLATE "SK-Retre-VTOL-Thermite"
vtols[15] TEMPLATE "SK-Retre-VTOL-PulseLsr"
vtols[16] TEMPLATE "SK-Retre-VTOL-Scourge"
}
|
|