416 lines
9.3 KiB
Plaintext
416 lines
9.3 KiB
Plaintext
/*
|
|
* Control VTOL attacks
|
|
*
|
|
*/
|
|
|
|
|
|
/* ******************** */
|
|
/* Declared Variables */
|
|
/* ******************** */
|
|
|
|
private int count, group, temp;
|
|
private BASEOBJ viewerObj, targetObj, targetObj2;
|
|
private DROID droid;
|
|
private int clusterID;
|
|
|
|
//VTOL Pads
|
|
public STRUCTURESTAT pad;
|
|
public int padX[8], padY[8], numPads, padPlayer;
|
|
public STRUCTUREID HQbuilding;
|
|
public BOOL dontStopFlag;
|
|
private STRUCTURE pads[8];
|
|
|
|
// control whether vtols use rearm pads or appear at the edge of the map
|
|
private bool noPads;
|
|
|
|
//VTOL groups and targets
|
|
public int numGroups;
|
|
public int VTOLsize[4], groupX[4], groupY[4];
|
|
public TEMPLATE templates[4];
|
|
public int targetObjType[4], startTime[4], everyTime[4];
|
|
public int numPrefStruc, prefStruc[4], numPrefDroid, prefDroid[4];
|
|
private GROUP VTOLgroup[4];
|
|
private BASEOBJ attackObj[4];
|
|
private int attackCluster[4], countTime[4];
|
|
|
|
// area within which vtols can be killed
|
|
public int killX1,killY1, killX2,killY2;
|
|
|
|
// where the vtols return to and vanish
|
|
public int vanishX,vanishY;
|
|
|
|
// which player is the human player
|
|
public int player;
|
|
|
|
// whether to use the no visibility target system
|
|
public bool noVisTargetting;
|
|
|
|
trigger addVTOLTrig(every, 3000); //every 5 mins to get reinforcements
|
|
trigger killVTOLSTrig(every, 43);
|
|
//trigger vtolStartTrig(wait, 600);
|
|
trigger vtolOffMapStartTrig(every, 23);
|
|
|
|
trigger nextTargetTrig(every, 80);
|
|
|
|
|
|
// declare events
|
|
event targetFound;
|
|
event clusterReset;
|
|
event nextTarget;
|
|
event resetVis;
|
|
event nextTargetNoVis;
|
|
|
|
event start(CALL_GAMEINIT)
|
|
{
|
|
//add a VTOL rearming pad
|
|
count = 0;
|
|
while (count < numPads)
|
|
{
|
|
pads[count] = addStructure(pad, padPlayer, padX[count], padY[count]);
|
|
count = count + 1;
|
|
}
|
|
|
|
// if there are no rearm pads vtols come from the edge of the map
|
|
noPads = (numPads == 0);
|
|
|
|
//eventTraceLevel(1); //dbWin32 stuff
|
|
|
|
// set the target system preferences
|
|
resetStructTargets();
|
|
setStructTarIgnore(ST_WALL); //ignore walls
|
|
count = 0;
|
|
while (count < numPrefStruc)
|
|
{
|
|
setStructTarPref(prefStruc[count]);
|
|
count = count + 1;
|
|
}
|
|
resetDroidTargets();
|
|
setDroidTarIgnore(DT_SUPER_HEAVY); //ignore transport
|
|
count = 0;
|
|
while (count < numPrefDroid)
|
|
{
|
|
setDroidTarPref(prefDroid[count]);
|
|
count = count + 1;
|
|
}
|
|
|
|
setVTOLReturnPos(padPlayer, vanishX,vanishY);
|
|
count = 0;
|
|
while (count < numGroups)
|
|
{
|
|
countTime[count] = startTime[count];
|
|
count = count + 1;
|
|
}
|
|
|
|
// turn off the visibility targetting system
|
|
if (noVisTargetting)
|
|
{
|
|
// turn off the normal system
|
|
setEventTrigger(targetFound, inactive);
|
|
setEventTrigger(clusterReset, inactive);
|
|
setEventTrigger(nextTarget, inactive);
|
|
setEventTrigger(resetVis, inactive);
|
|
|
|
// turn on the no visibility system
|
|
setEventTrigger(nextTargetNoVis, nextTargetTrig);
|
|
}
|
|
}
|
|
|
|
// do VTOL reinforcements (startTime, everyTime)
|
|
event addVTOL(every, 107) //every 10secs
|
|
{
|
|
group = 0;
|
|
while (group < numGroups)
|
|
{
|
|
countTime[group] = countTime[group] - 1;
|
|
if (countTime[group] <= 0)
|
|
{
|
|
countTime[group] = everyTime[group]; //set back to every
|
|
|
|
temp = VTOLgroup[group].members;
|
|
if (((not noPads) and (temp < VTOLsize[group])) or // reinforcing a group using rearm pads
|
|
(noPads and (temp == 0) and (attackObj[group] != NULLOBJECT))) // creating a group at the edge of the map
|
|
{
|
|
debugBox(100);
|
|
count = 0;
|
|
temp = VTOLsize[group] - VTOLgroup[group].members;
|
|
while (count < temp)
|
|
{
|
|
droid = addDroid(templates[group], groupX[group], groupY[group], padPlayer);
|
|
if (droid != NULLOBJECT)
|
|
{
|
|
groupAddDroid(VTOLgroup[group], droid);
|
|
}
|
|
count = count + 1;
|
|
}
|
|
if (attackObj[group] != NULLOBJECT)
|
|
{
|
|
debugBox(101);
|
|
orderGroupObj(VTOLgroup[group], DORDER_ATTACK, attackObj[group]);
|
|
}
|
|
}
|
|
}
|
|
group = group + 1;
|
|
}
|
|
/*
|
|
// only reset this event if using pads
|
|
if (not noPads)
|
|
{
|
|
setEventTrigger (addVTOL, addVTOLTrig);
|
|
}
|
|
*/
|
|
}
|
|
|
|
event vtolOffMap(CALL_VTOL_OFF_MAP, padPlayer, ref droid)
|
|
{
|
|
// vtol has reached the edge of the map - vanish them
|
|
vanishUnit(droid);
|
|
}
|
|
|
|
// set up a target for the vtol groups
|
|
event targetFound(CALL_OBJ_SEEN, padPlayer, ref targetObj, ref viewerObj)
|
|
{
|
|
if (targetObj != NULLOBJECT )
|
|
{
|
|
group = 0;
|
|
if (targetObj.type == OBJ_DROID)
|
|
{
|
|
if (objToDroid(targetObj).droidType == DROID_TRANSPORTER)
|
|
{
|
|
// skip transporters
|
|
group = numGroups;
|
|
}
|
|
}
|
|
while(group < numGroups)
|
|
{
|
|
//clarify target type here!
|
|
if (targetObj.type == targetObjType[group])
|
|
{
|
|
//store only if new one req'd
|
|
if ((attackObj[group] == NULLOBJECT) and (attackCluster[group] == 0))
|
|
{
|
|
attackCluster[group] = targetObj.clusterID;
|
|
// clusterID can be 0 for droids - especially near start
|
|
// when they havn't moved yet
|
|
if (attackCluster[group] != 0)
|
|
{
|
|
targetObj2 = targetInCluster(targetObj.clusterID, padPlayer);
|
|
}
|
|
else
|
|
{
|
|
targetObj2 = NULLOBJECT;
|
|
}
|
|
|
|
// if we've found a target, store it
|
|
if (targetObj2 != NULLOBJECT)
|
|
{
|
|
attackObj[group] = targetObj2;
|
|
attackCluster[group] = targetObj2.clusterID;
|
|
debugBox(0);
|
|
debugBox(attackObj[group].id);
|
|
debugBox(attackObj[group].clusterID);
|
|
}
|
|
}
|
|
}
|
|
|
|
group = group + 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// remove a cluster from the system if there isn't anything in it
|
|
event clusterReset(CALL_CLUSTER_EMPTY, ref clusterID)
|
|
{
|
|
group = 0;
|
|
while (group < numGroups)
|
|
{
|
|
if (attackCluster[group] == clusterID)
|
|
{
|
|
debugBox(200);
|
|
debugBox(clusterID);
|
|
attackObj[group] = NULLOBJECT;
|
|
attackCluster[group] = 0;
|
|
group = numGroups;
|
|
}
|
|
group = group + 1;
|
|
}
|
|
}
|
|
|
|
|
|
/* Newer System! Iterates clusters and keeps 5 targets! */
|
|
event nextTarget(every, 80)
|
|
{
|
|
group = 0;
|
|
while (group < numGroups)
|
|
{
|
|
// if the current target has died find the next in the cluster
|
|
if ((attackObj[group] == NULLOBJECT) and (attackCluster[group] != 0))
|
|
{
|
|
debugBox(2);
|
|
attackObj[group] = targetInCluster(attackCluster[group], padPlayer);
|
|
if (attackObj[group] == NULLOBJECT)
|
|
{
|
|
attackCluster[group] = 0;
|
|
}
|
|
else
|
|
{
|
|
debugBox(attackObj[group].id);
|
|
}
|
|
}
|
|
|
|
//order VTOL group to target (if it exists and not already busy)
|
|
if ((attackObj[group] != NULLOBJECT) and (idleGroup(VTOLgroup[group]) > (VTOLgroup[group].members / 2)))
|
|
{
|
|
debugBox(3);
|
|
debugBox(attackObj[group].id);
|
|
orderGroupObj(VTOLgroup[group], DORDER_ATTACK, attackObj[group]);
|
|
}
|
|
|
|
group = group + 1;
|
|
}
|
|
}
|
|
|
|
// give targets to vtols without using visibility
|
|
event nextTargetNoVis(inactive)
|
|
{
|
|
group = 0;
|
|
while (group < numGroups)
|
|
{
|
|
// find a target for the group
|
|
if (targetObjType[group] == OBJ_DROID)
|
|
{
|
|
attackObj[group] = droidTargetOnMap(player, -1);
|
|
}
|
|
else
|
|
{
|
|
attackObj[group] = structTargetOnMap(player, -1);
|
|
}
|
|
|
|
//order VTOL group to target (if not already busy)
|
|
if ((attackObj[group] != NULLOBJECT) and (idleGroup(VTOLgroup[group]) > (VTOLgroup[group].members / 2)))
|
|
{
|
|
debugBox(3);
|
|
debugBox(attackObj[group].id);
|
|
orderGroupObj(VTOLgroup[group], DORDER_ATTACK, attackObj[group]);
|
|
}
|
|
|
|
group = group + 1;
|
|
}
|
|
}
|
|
|
|
// reset player visibility if no targets
|
|
event resetVis(every, 333)
|
|
{
|
|
// see if there are any stored targets
|
|
temp = -1;
|
|
count = 0;
|
|
while (count < numGroups)
|
|
{
|
|
if ((attackObj[count] == NULLOBJECT) and (attackCluster[count] == 0))
|
|
{
|
|
// no targets stored for this group - reset visibility
|
|
// other groups will keep their current target clusters
|
|
temp = count;
|
|
count = numGroups;
|
|
}
|
|
count = count + 1;
|
|
}
|
|
|
|
if (temp != -1)
|
|
{
|
|
// no targets stored, reset visibility
|
|
debugBox(4);
|
|
resetPlayerVisibility(padPlayer);
|
|
}
|
|
}
|
|
|
|
event killVTOLS(inactive)
|
|
{
|
|
// see if all the vtols are dead
|
|
temp = -1;
|
|
group = 0;
|
|
while (group < numGroups)
|
|
{
|
|
if (VTOLgroup[group].members != 0)
|
|
{
|
|
temp = group;
|
|
group = numGroups;
|
|
}
|
|
group = group + 1;
|
|
}
|
|
|
|
if (temp == -1)
|
|
{
|
|
// all the vtols are dead
|
|
count = 0;
|
|
while (count < numPads)
|
|
{
|
|
if (pads[count] != NULLOBJECT)
|
|
{
|
|
destroyStructure(pads[count]); //get rid of rearming pads
|
|
}
|
|
count = count + 1;
|
|
}
|
|
setEventTrigger(killVTOLS, inactive);
|
|
}
|
|
else
|
|
{
|
|
// some vtols left see if we can kill them off
|
|
group = 0;
|
|
while (group < numGroups)
|
|
{
|
|
initIterateGroup(VTOLgroup[group]);
|
|
droid = iterateGroup(VTOLgroup[group]);
|
|
while (droid != NULLOBJECT)
|
|
{
|
|
if ((droid.x >= killX1 * 128) and (droid.x <= killX2 * 128) and
|
|
(droid.y >= killY1 * 128) and (droid.y <= killY2 * 128))
|
|
{
|
|
vanishUnit(droid);
|
|
}
|
|
droid = iterateGroup(VTOLgroup[group]);
|
|
}
|
|
group = group + 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
event stopVTOL(buildingDestroyed(HQbuilding, padPlayer), 45)
|
|
{
|
|
//turn off VTOL attacks if command centre dead
|
|
if (not dontStopFlag)
|
|
{
|
|
setEventTrigger(killVTOLS, killVTOLSTrig);
|
|
setEventTrigger(nextTarget, inactive);
|
|
setEventTrigger(targetFound, inactive);
|
|
setEventTrigger(addVTOL, inactive);
|
|
}
|
|
setEventTrigger(stopVTOL, inactive);
|
|
}
|
|
|
|
event cheatEvnt(CALL_MISSION_START) //cheat button ctrl M
|
|
{
|
|
//get rid of pads and vtols if cheat!
|
|
count = 0;
|
|
while (count < numPads)
|
|
{
|
|
if (pads[count] != NULLOBJECT)
|
|
{
|
|
destroyStructure(pads[count]); //get rid of rearming pads
|
|
}
|
|
count = count + 1;
|
|
}
|
|
group = 0;
|
|
while (group < numGroups)
|
|
{
|
|
initIterateGroup(VTOLgroup[group]);
|
|
droid = iterateGroup(VTOLgroup[group]);
|
|
while (droid != NULLOBJECT)
|
|
{
|
|
vanishUnit(droid);
|
|
droid = iterateGroup(VTOLgroup[group]);
|
|
}
|
|
group = group + 1;
|
|
}
|
|
}
|