//SLO file for setting up the Transporter to return and re-fill
//Also handles VTOL attacks with no visibility
//cam2EndX.SLO
//uses copy of genbet.slo plus some modifications!

/* ********************	*/
/* Declared Variables 	*/
/* ********************	*/

/* Next Level stuff */
public		LEVEL		NextLev;

/* Structure Limits */
public		int		numStrucStats, strucLimit[6];
public		STRUCTURESTAT	strucStat[6];

/* Initialisation */
public		int		centreX, centreY;
public		int		scrollX1, scrollX2, scrollY1, scrollY2;
public		int		zoomLevel;
public		int		numLZ, LZX[8], LZY[8];
public		int		transX[2], transY[2];	//done in arrays so don't need to define for non submaps
									//transX[0] = entryX, transX[1] = exitX

/* Briefings */
public		int		numBriefs, briefVal[5];
public		INTMESSAGE	brief[5];
public		INTMESSAGE	endMsg;

/* Time Limit */
public		INT		ReinforceTime, timeLimit;

/* 'Globals' */
public		int		player, enemy[1];
public		SOUND		lostSnd;				//mission lost
public		TEMPLATE	transporter;


/* General variables */
private		int		count, count2;				//for while loops
private		int		countBriefs, temp, temp1, temp2, tempX, tempY;
private		BOOL		winFlag;

//Starting Tech for Enemy
public		int		numTechs;
public		RESEARCHSTAT	startTech[37];



/* VTOLS */
private		int		group;
private		BASEOBJ		viewerObj, targetObj;
private		DROID		droid;
private		int		clusterID;

public		int		padPlayer;

//VTOL groups and targets
public		int		numVTOL;
public		int		VTOLsize[2], groupX[5], groupY[5];
public		TEMPLATE	templatesVTOL[2][2];
public		int		targetObjType[2], startTime[2], everyTime[2];
private		GROUP		VTOLgroup[2];
private		BASEOBJ		attackObj[2];
private		int		attackCluster[2], countTime[2];

// where the vtols return to and vanish
public		int		vanishX,vanishY;
public		int		baseX1, baseY1, baseX2, baseY2;


/* Ground forces */
/* Groups */
//these can be for any player!
public		int		numGroups;
public		int		grpType[10], grpPlayer[10], grpRegion[10], grpTimeGo[10], grpRegionGo[10], grpWhoGo[10];
public		int		grpMorale[10], grpLeadership[10], grpRetreatXY[10], grpIdealSize[10];
public		int		grpPosStart[10], grpPosMin[10], grpPosMax[10], grpPosStep[10], grpPosType[10];
public		int		grpFactory[10];
private		BOOL		grpFlagGo[10];		//keep track of already triggered groups
private		GROUP		grpGroup[10], grpReinforce[10];		//the actual groups are stored in this, based on region.
private		int		grpPosCurrent[10];	//keep track of current waypoint
private		BOOL		grpBusy[10];		//keep track of already ordered
private		int		timeGroup;		//keeps track of time since started level, for triggering groups

/* Factories */
//these can be for any player!
public		int		numFactories;
public		int		factID[11], factAssXY[11], factTimeGo[11];
public		int		factRegionGo[11], factTempMin[11], factTempMax[11];
public		int		factEvery[11];
private		BOOL		factFlagGo[11];	//stores whether producing or not
private		int		factTime[11];	//store count for next production
private		DROID		testDroid, newDroid;
private		STRUCTURE	newDroidFactory;			//new droid built
private		int		newDroidFactoryIndex;		//for phantom factories

/*lists */
public		TEMPLATE	templates[20];
public		int		coordsX[20], coordsY[20];

/*transports */
public		int		entryX[2], entryY[2], exitX[2], exitY[2];	//enemy transport entry, exit
public		SOUND		transSnd;			//enemy transport landing
private		DROID		transportDroid[2];
private		BOOL		transOnMap[2], playerTransOnMap, reinfOff;
private		GROUP		transGroup;
private		INT		transGroupIndex[2], transGroupPlayer, enemyLZX, enemyLZY;	//used for enemy transports landing

/* ********************	*/
/* Triggers	 	*/
/* ********************	*/
trigger gameLostTrig(every, 20);
trigger winLoseTrig(every, 5);
trigger vidTrig(CALL_VIDEO_QUIT);

/* ground forces */
trigger wayGroupsTrig	(every, 107);	//every 10ish secs seconds (so don't get clogging!)
trigger timeGroupsTrig	(every, 100);	//every 10 seconds (made different so don't get clogging!)
trigger factoryProdTrig	(every, 97);	//every 10 seconds (uses factTime to count this period and factEvery to trigger)
trigger droidBuiltTrig	(wait, 1);		//very quickly
trigger transLandedTrig	(CALL_TRANSPORTER_LANDED, transGroup, enemy[transGroupPlayer]);
trigger transGone1Trig	(CALL_TRANSPORTER_OFFMAP, enemy[transGroupPlayer]);

/* ********************	*/
/* Events	 	*/
/* ********************	*/

/* Declared Events */
event briefings;
event timeUp;
event droidBuilt;
event transLanded;
event transGone1;

/* Initialisation */
event	start(CALL_GAMEINIT)
{
	//set up so that when Transporter gets to the edge of the map, it will empty and return
	setDroidsToSafetyFlag(true);
	randomiseSeed();
//centre view
	centreViewPos(centreX, centreY);

//set scroll limits
//	setScrollParams(scrollX1, scrollY1, scrollX2, scrollY2);

//set radar zoom level
	setRadarZoom(zoomLevel);

//set Mission time limit
	setMissionTime(timeLimit);

//set LZ and no go areas - shouldn't need to do this any more - it is until all NoGoAreas are saved in the save game info
//The LZ can now be set up just before FlyTransporterIn()
	initAllNoGoAreas();
	count = 0;
	while (count < numLZ)
	{
		setNoGoArea(LZX[count] - 1, LZY[count] - 1, LZX[count] + 1, LZY[count] + 1, count);
		count = count + 1;
	}

//set structure limits
	count = 0;
	while (count < numStrucStats)
	{
		setStructureLimits (strucStat[count], strucLimit[count], player);
		enableStructure(strucStat[count], player);
		count = count + 1;
	}
//give Enemy Starting Tech
	count = 0;
	while (count < numTechs)
	{
		completeResearch(startTech[count], enemy[0]);
		count = count + 1;
	}

//place transport
	addDroid(transporter,(LZX[0] * 128) + 64, (LZY[0] * 128) + 64,player);
	setTransporterExit(player, transX[1], transY[1]);

	setReinforcementTime(ReinforceTime);

/* VTOLS */
	setVTOLReturnPos(padPlayer, vanishX,vanishY);
	count = 0;
	while (count < numVTOL)
	{
		countTime[count] = startTime[count];
		count = count + 1;
	}

/* Ground Forces */
//setup groups
	count = 0;
	while (count < numGroups)
	{
		grpPosCurrent[count] = grpPosStart[count];

		//set time = 0 groups going
		if (grpTimeGo[count] == timeGroup)
		{
			grpFlagGo[count] = TRUE;
			if (grpType[count] < 2)		//use coords for patrol/ambush/defence
			{
				if (grpPosStart[count] >= 0)	//cope with no start position defined
				{
					orderGroupLoc(grpGroup[count], DORDER_SCOUT, coordsX[grpPosStart[count]], coordsY[grpPosStart[count]]);
				}
			}
		}
		count = count + 1;
	}
	//set time = 0 factories going
	count = 0;
	while (count < numFactories)
	{
		if ((factTimeGo[count] == timeGroup) and (not factFlagGo[count]))
		{
			factFlagGo[count] = TRUE;	//set factory to produce
		}
		count = count + 1;
	}


//play mission brief(s)
	if (numBriefs > 0)
	{
		if (briefVal[0] < 2)	//cope with don't play immediately
		{
			addMessage(brief[0], MISS_MSG, 0, true);
		}
		else
		{
			addMessage(brief[0], MISS_MSG, 0, false);
			if (countBriefs >= numBriefs)	//last briefing?
			{
				setEventTrigger(briefings, inactive);
			}
		}
		countBriefs = 1;
	}


}

event	briefings(CALL_VIDEO_QUIT)		//need to rework this better!!
{
	if (briefVal[countBriefs - 1] == 0)	//check to see if needs removing
	{
		removeMessage(brief[countBriefs - 1], MISS_MSG, 0);
	}

	if (countBriefs >= numBriefs)	//last briefing?
	{
		setEventTrigger(briefings, inactive);
	}

	if (countBriefs < numBriefs)		//add next brief
	{
		if (briefVal[countBriefs] < 2)		//cope with don't play immediately
		{
			addMessage(brief[countBriefs], MISS_MSG, 0, true);
		}
		else
		{
			addMessage(brief[countBriefs], MISS_MSG, 0, false);
		}
		countBriefs = countBriefs + 1;
	}
}

event launched(CALL_LAUNCH_TRANSPORTER)
{
	//allow win if player has launched transport
	winFlag = TRUE;
	setEventTrigger(launched, inactive);
}

//need an event to check all player stuff isn't dead, once got transport taken off CALLBACK
//for losing
event gameLost(inactive)
{
//	addMessage(endMsg, MISS_MSG, 0, true);
//	pause(10);
//	gameOver(false);
	gameOverMessage(endMsg, MISS_MSG, 0, false);
	setEventTrigger(gameLost, inactive);
}

event nextLevEvnt(CALL_START_NEXT_LEVEL)
{
	//need to check if the player has got any transporter's out since this callback will
	//be called from the code if the transporter is sitting idle and all the player's units are destroyed
	if (winFlag)
	{
		//play outro
		addMessage(brief[2], MISS_MSG, 0, true);
		//pause(1);
		startMission(OFF_KEEP, NextLev);
	}
	else
	{
		setEventTrigger(gameLost, gameLostTrig);
	}
	setEventTrigger(nextLevEvnt, inactive);
}

//out of time?
event timeUp(CALL_MISSION_TIME)
{
	//see if player has 'won'
	if (winFlag)
	{
		//play outro
		addMessage(brief[2], MISS_MSG, 0, true);
		//pause(1);
		//go to next mission
		//setEventTrigger(nextLevEvnt, winLoseTrig);	//this causes it to crash!
		startMission(OFF_KEEP, NextLev);
	}
	else
	{
		setEventTrigger(gameLost, gameLostTrig);
	}
	setEventTrigger(timeUp, inactive);
}

event lostYetEvnt(every, 53)
{
	if (not anyDroidsLeft(player))
	{
		if (not anyStructButWallsLeft(player))
		{
			//won or lost?
			setEventTrigger(lostYetEvnt, inactive);
			if (winFlag)
			{
				//setEventTrigger(nextLevEvnt, winLoseTrig);	//this causes it to crash!
				startMission(OFF_KEEP, NextLev);
			}
			else
			{
				setEventTrigger(launched,inactive);
				setEventTrigger(gameLost, gameLostTrig);	//waits 2 seconds before ending
			}
		}

	}
}




/* VTOLS ATTACK */

// do VTOL reinforcements (startTime, everyTime)
event addVTOL(every, 107)	//every 10secs
{
	group = 0;
	while (group < numVTOL)
	{
		countTime[group] = countTime[group] - 1;
		if (countTime[group] <= 0)
		{
			countTime[group] = everyTime[group];	//set back to every

			temp = VTOLgroup[group].members;
			if ((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;
				temp1 = random(5);	//choose random start coord
				while (count < temp)
				{
					droid = addDroid(templatesVTOL[group][random(2)], groupX[temp1], groupY[temp1], 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;
	}

}

event vtolOffMap(CALL_VTOL_OFF_MAP, padPlayer, ref droid)
{
	// vtol has reached the edge of the map - vanish them
	vanishUnit(droid);
}

event getTargets(every, 67)
{
	group = 0;
	while (group < numVTOL)
	{
		//check if a group is idle and give a new target
			if (attackObj[group] == NULLOBJECT)
			{
				//find a target in area
				if (targetObjType[group] == 1)
				{
					resetStructTargets();
					setStructTarIgnore(ST_WALL);
					setStructTarPref(ST_FACTORY);
					setStructTarPref(ST_CYBORG_FACTORY);
					setStructTarPref(ST_VTOL_FACTORY);
					setStructTarPref(ST_RESEARCH);
					setStructTarPref(ST_POWER_GEN);
					setStructTarPref(ST_HQ);
					attackObj[group] = structTargetInArea(player, padPlayer, baseX1, baseY1, baseX2, baseY2);
				}
				else if (targetObjType[group] == 0)
				{
					resetDroidTargets();
					setDroidTarIgnore(DT_SUPER_HEAVY);	//ignore transport
					attackObj[group] = droidTargetInArea(player, padPlayer, baseX1, baseY1, baseX2, baseY2);
				}
				if (attackObj[group] != NULLOBJECT)
				{
					orderGroupObj(VTOLgroup[group], DORDER_ATTACK, attackObj[group]);
				}
			}
		group = group + 1;
	}

}


/* Ground Force attacks */
event wayGroups(wayGroupsTrig)
{
	count = 0;
	while (count < numGroups)
	{
		//update groups position
		if ((grpFlagGo[count]) and  (grpType[count] < 2) and (grpPosStart[count] >= 0)) //been triggered and ambush/patrol/defence?
		{
			//simple predefined waypoints
			//has the group got to waypoint or are they mainly idle?
			if ((grpGroup[count].members > 0) and 
				(idleGroup(grpGroup[count]) >= grpGroup[count].members/2))
			{
				grpBusy[count] = FALSE;			//no longer 'busy'
				temp = grpPosCurrent[count];		//store for checking difference later
				if (grpPosType[count] == 3)		//random choice
				{
					grpPosCurrent[count] = grpPosMin[count] + grpPosStep[count] * random(grpPosMax[count] - grpPosMin[count]);
				}
				else
				{
					grpPosCurrent[count] = grpPosCurrent[count] + grpPosStep[count];	//get next waypoint
				}
				if ((grpPosCurrent[count] > grpPosMax[count]) or (grpPosCurrent[count] < grpPosMin[count]))
				{
					grpPosCurrent[count] = grpPosCurrent[count] - grpPosStep[count];	//stop at last one
					if (grpPosType[count] == 1)		//loop
					{
						if (grpPosStep[count] > 0)		//+ve loop
						{
							grpPosCurrent[count] = grpPosMin[count];
						}
						else				//-ve loop
						{
							grpPosCurrent[count] = grpPosMax[count];
						}
					}
					if (grpPosType[count] == 2)		//ping pong
					{
						grpPosStep[count] = - grpPosStep[count];
						grpPosCurrent[count] = grpPosCurrent[count] + grpPosStep[count];
					}
				}
				if (grpPosCurrent[count] != temp)	//don't order again if already there!
				{
					orderGroupLoc(grpGroup[count], DORDER_SCOUT, coordsX[grpPosCurrent[count]], coordsY[grpPosCurrent[count]]);	//Changed to SCOUT 21/01/99
					//orderGroupLoc(grpGroup[count], DORDER_MOVE, coordsX[grpPosCurrent[count]], coordsY[grpPosCurrent[count]]);
				}
			}
		}
		count = count + 1;
	}
}


event factoryProdEvnt(factoryProdTrig)
{
	count = 0;
	while (count < numFactories)
	{
		//switched on?
		if (factFlagGo[count])
		{
			factTime[count] = factTime[count] + 1;
			//time to do stuff?
			if (factTime[count] >= factEvery[count])
			{
				//phantom factory (including transports)
				if (factID[count] < 0)
				{

				//do actual adding of droids and resetting of FactTime in droidBuilt event
				//just set trigger and factory number here!
					newDroidFactoryIndex = count;
					newDroid = NULLOBJECT;
					newDroidFactory = NULLOBJECT;		//so as not to confuse with a proper factory!
					setEventTrigger(droidBuilt, droidBuiltTrig);
				}

			}
		}
		count = count + 1;
	}
}

event droidBuilt(inactive)	//triggered by later callbacks
{
	//find factory number
	temp2 = 0;		//flagged if group match found
	//temp = -1;		//in case not found
	temp = -2;		//in case not found (so doesn't use a droidfactory from another script)

	if (newDroidFactoryIndex >= 0)	//deal with phantom factory
	{
		temp = newDroidFactoryIndex;
	}
	//check thru groups to reinforce
	count = 0;

	while (count < numGroups)
	{
		if (((temp == grpFactory[count]) or ((grpFactory[count] == -1) and (temp != -2)))	//got match, or any factory in this script OK?
			and (grpGroup[count].members < grpIdealSize[count]))		//and needs reinforcing?
		{
			//add to reinforcement group
			if (newDroid != NULLOBJECT)
			{
				groupAddDroid(grpReinforce[count], newDroid);
			}
			else if (newDroidFactoryIndex >= 0)	//deal with phantom factory
			{
				//deal with off edge
				if (factID[newDroidFactoryIndex] == - 1)
				{
					factTime[newDroidFactoryIndex] = 0;	//reset time count for phantom factory
					count2 = 0;
					while	(count2 < 1 + factTempMax[newDroidFactoryIndex] - factTempMin[newDroidFactoryIndex])
					{
						temp1 = factTempMin[newDroidFactoryIndex] + count2;
						temp2 = count2;	//create more for lower template numbers, less for higher!
						while (temp2 < 1 + factTempMax[newDroidFactoryIndex] - factTempMin[newDroidFactoryIndex])
 						{
							newDroid = addDroid(templates[temp1], coordsX[factAssXY[newDroidFactoryIndex]], coordsY[factAssXY[newDroidFactoryIndex]], enemy[grpPlayer[count]]);
                            if (newDroid != NULLOBJECT)
                            {
							    groupAddDroid(grpReinforce[count], newDroid);
                            }
							temp2 = temp2 + 1;
						}
						count2 = count2 + 1;
					}
				}
				//deal with transport if not on map
				else if ((factID[newDroidFactoryIndex] == - 2) and (not transOnMap[grpPlayer[count]]))
				{
					factTime[newDroidFactoryIndex] = 0;	//reset time count for phantom factory
					//need to check LZ has defences, otherwise turn off this phantom factory
					temp1 = factAssXY[newDroidFactoryIndex];
					if (numStructsInArea(enemy[grpPlayer[count]], (LZX[temp1] - 4) * 128, (LZY[temp1] - 4) * 128,
													(LZX[temp1] + 4) * 128, (LZY[temp1] + 4) * 128) == 0)
					{
						//playSound(lostSnd, player);	//test
						factFlagGo[newDroidFactoryIndex] = FALSE;
						factEvery[newDroidFactoryIndex] = 32767;	//make next time very large ~100 hours
					}
					else
					{
						setNoGoArea(LZX[factAssXY[newDroidFactoryIndex]] - 1,
								LZY[factAssXY[newDroidFactoryIndex]] - 1,
								LZX[factAssXY[newDroidFactoryIndex]] + 1,
								LZY[factAssXY[newDroidFactoryIndex]] + 1,
								enemy[grpPlayer[newDroidFactoryIndex]]);
						//make sure got position in world coords of this LZ for playSound
						enemyLZX = LZX[factAssXY[newDroidFactoryIndex]] * 128;
						enemyLZY = LZY[factAssXY[newDroidFactoryIndex]] * 128;
						count2 = 0;
						while	(count2 < 1 + factTempMax[newDroidFactoryIndex] - factTempMin[newDroidFactoryIndex])
						{
							temp1 = factTempMin[newDroidFactoryIndex] + count2;
							temp2 = count2;	//create more for lower template numbers, less for higher!
							while (temp2 < 1 + factTempMax[newDroidFactoryIndex] - factTempMin[newDroidFactoryIndex])
	 						{
								newDroid = addDroidToMissionList(templates[temp1], enemy[grpPlayer[count]]);
                                if (newDroid != NULLOBJECT)
                                {
								    addDroidToTransporter(transportDroid[grpPlayer[count]], newDroid);
                                }
								temp2 = temp2 + 1;
							}
							count2 = count2 + 1;
						}
						//call in transport
						setTransporterExit(enemy[grpPlayer[count]], exitX[grpPlayer[count]], 									exitY[grpPlayer[count]]);
						flyTransporterIn(enemy[grpPlayer[count]], entryX[grpPlayer[count]], 									entryY[grpPlayer[count]], false);
						transOnMap[grpPlayer[count]] = TRUE;
						transGroupIndex[grpPlayer[count]] = count;	//store for when transport lands
						transGroupPlayer = grpPlayer[count];		//may mess up multiple enemies having transports?
						setEventTrigger(transLanded, transLandedTrig);
						setEventTrigger(transGone1, transGone1Trig);
					}
				}
			}
			//if group dead, add to group and reset starting sector?
			if (grpGroup[count].members == 0)
			{
				groupAddGroup(grpGroup[count], grpReinforce[count]);
				//set back to start sector...?
				grpPosCurrent[count] = grpPosMin[count];		//go back to min sector if starting group from scratch
			}
			//if ideal size, add to main group!
			else if ((grpGroup[count].members + grpReinforce[count].members) >= grpIdealSize[count])
			{
				groupAddGroup(grpGroup[count], grpReinforce[count]);
				//grpPosCurrent[count] = grpPosMin[count];		//test for now so can see if added to group
			}
			//test order only!!!
			//orderGroupLoc(grpGroup[count], DORDER_SCOUT, coordsX[grpPosCurrent[count]], coordsY[grpPosCurrent[count]]);
			count = numGroups;	//exit early
			temp2 = 1;
		}
		count = count +1;
	}
	//if temp2 != 0, ie not assigned to a group, put in a special group for that player, and pull out if a group can take from any and
	//needs reinforcing. (another event to check thru pooled group?)
	//still to be done!
		
}

event droidBuilt2(CALL_NEWDROID, 2, ref newDroid, ref newDroidFactory)
{
	newDroidFactoryIndex = - 1;	//not a phantom factory
	setEventTrigger(droidBuilt, droidBuiltTrig);
}

event transLanded(inactive)	//trigger set when transport called
{
	temp = transGroupIndex[transGroupPlayer];		//to make easier to read
	//test sound for now
	//playSound(transSnd, player);		//Enemy Transport Landing
	//need to look at enemy LZ???
	playSoundPos(transSnd, player, enemyLZX, enemyLZY, 0); 

	groupAddGroup(grpReinforce[temp], transGroup);
	//might just want to add directly to grpGroup?
	//if group dead, add to group and reset starting sector?
	if (grpGroup[temp].members == 0)
	{
		grpPosCurrent[temp] = grpPosMin[temp];	//go back to min sector if starting group from scratch
		if ((grpType[temp] < 2) and (grpPosStart[temp] >= 0))	//give first orders unless scouts, since use sectors, or no waypoints defined
		{
			orderGroupLoc(grpReinforce[temp], DORDER_SCOUT, coordsX[grpPosCurrent[temp]], coordsY[grpPosCurrent[temp]]);
		}
		groupAddGroup(grpGroup[temp], grpReinforce[temp]);
		//set back to start sector...?
	}
	//if >= ideal size add to group
	if ((grpGroup[temp].members + grpReinforce[temp].members) >= grpIdealSize[temp])
	{
		if ((grpType[temp] < 2) and (grpPosStart[temp] >= 0))	//give first orders unless scouts, since use sectors, or no waypoints defined
		{
			orderGroupLoc(grpReinforce[temp], DORDER_SCOUT, coordsX[grpPosCurrent[temp]], coordsY[grpPosCurrent[temp]]);
		}
		groupAddGroup(grpGroup[temp], grpReinforce[temp]);
	}
	setEventTrigger(transLanded, transLandedTrig);
}

//allow next transport!!
event transGone1(inactive)
{
	transOnMap[grpPlayer[transGroupPlayer]] = FALSE;
}

//update time count for triggering groups and factories...
event timeGroupsEvnt(timeGroupsTrig)
{
	timeGroup = timeGroup + 1;
	count = 0;
	//update groups
	while (count < numGroups)
	{
		if ((grpTimeGo[count] == timeGroup) and (not grpFlagGo[count]))
		{
			grpFlagGo[count] = TRUE;
			//scouts don't use coords array, so don't bother with initial order!
			if (grpType[count] < 2) 
			{
				orderGroupLoc(grpGroup[count], DORDER_SCOUT, coordsX[grpPosStart[count]], coordsY[grpPosStart[count]]);
			}
		}
		count = count + 1;
	}
	//update factories
	count = 0;
	while (count < numFactories)
	{
		if ((factTimeGo[count] == timeGroup) and (not factFlagGo[count]) and (factTime[count] == 0))
		{
			factFlagGo[count] = TRUE;	//set factory to produce
			factTime[count] = factEvery[count];	//allow to produce straight away!
		}
		count = count + 1;
	}
}