/// <summary>
/// Adds an event to this node
/// </summary>
/// <param name="e"></param>
public void AddEvent(ScenarioEventType e)
{
theseEvents.Add(e);
if (e is ScenarioEventType)
{
if (!(theseUnits.ContainsKey(e.UnitID)))
{
theseUnits.Add(e.UnitID, 1);
}
else
{
theseUnits[e.UnitID] += 1;
}
List <string> allUnits = e.AllUnits;
for (int other = 0; other < allUnits.Count; other++)
{
if (!(TheseUnits.ContainsKey(allUnits[other])))
{
theseUnits.Add(allUnits[other], 1);
}
else
{
theseUnits[allUnits[other]] += 1;
}
}
}
}
/// <summary>
/// Adds an item to the Incoming event list
/// </summary>
/// <param name="e">An event (published by a lower level)</param>
public static void Add(ScenarioEventType e)
{
lock (syncObject)
{
incoming.Add(e);
}
}
/// <summary>
/// Add an event to the time queue
/// </summary>
/// <param name="time">The time at which this event fires</param>
/// <param name="newEvent">The event to add</param>
public static void Add(int time, ScenarioEventType newEvent)
{
time = Math.Max(_lastRetrievedTime + 1, time); //AD: put in place so you don't enqueue an event in the past
//that should be sent out on the next time tick.
if (!queue.ContainsKey(time))
{
queue.Add(time, new TimeNodeClass(time));
}
queue[time].AddEvent(newEvent);
}
/// <summary>
/// Removes an event from this node
/// </summary>
/// <param name="index"></param>
public void DropEvent(int index)
{
ScenarioEventType e = theseEvents[(int)index];
theseUnits[e.UnitID] -= 1;
if (theseUnits[e.UnitID] <= 0)
{
theseUnits.Remove(e.UnitID);
}
theseEvents.RemoveAt((int)index);
}
public static void SeekSpeciesHappening(ScenarioEventType thisItem, string dataToTest)
{
for (int sce = SpeciesHappeningList.Happenings.Count - 1; sce >= 0; sce--)
{
if (SpeciesHappeningList.Happenings[sce].Matches(thisItem, dataToTest))
{
SpeciesHappeningList.Happenings[sce].EnqueueEvents(thisItem.UnitID);
break;
}
}
}
public static Boolean AttackApproved(ScenarioEventType s)
{
Boolean returnValue = false;
/*
* Approval algorithm;
* If there are no matches on list, return check default condition
* If there are any matches then any one that gives permission is enough
* */
Boolean denied = false;
if ("Aptima.Asim.DDD.ScenarioController.AttackObjectRequestType" != s.GetType().ToString())
{
return(returnValue);
}
AttackObjectRequestType alias = (AttackObjectRequestType)s;
for (int i = 0; i < approvals.Count; i++)
{
ScenarioEventType candidate = approvals[i];
if ("Aptima.Asim.DDD.ScenarioController.AttackRequestApprovalType" != candidate.GetType().ToString())
{
continue;
}
AttackRequestApprovalType rule = (AttackRequestApprovalType)candidate;
if (rule.Capability != alias.CapabilityName)
{
continue;
}
if (rule.Actor != "")
{
if ((!rule.ActorIsSpecies) && (rule.Actor != alias.UnitID))
{
continue;
}
if (rule.ActorIsSpecies && !Genealogy.UnderSpecies(alias.UnitID, rule.Actor))
{
continue;
}
}
if (rule.Target != "")
{
if ((!rule.TargetIsSpecies) && (rule.Target != alias.TargetObjectID))
{
continue;
}
if (rule.TargetIsSpecies && !Genealogy.UnderSpecies(alias.TargetObjectID, rule.Target))
{
continue;
}
}
if (rule.TargetStates.Count != 0)
{
if (!rule.TargetStates.Contains(UnitFacts.CurrentUnitStates[alias.TargetObjectID]))
{
continue;
}
}
// At this point we can say that the rule legitimaly refers to alias.UnitID
if (!rule.EngramValid(alias.UnitID, alias.TargetObjectID))
{
denied = true;
continue;
}
if ((rule.UseDefault) && (alias.DecisionMaker != UnitFacts.GetDM(alias.UnitID)))
{
denied = true;
continue;
}
//Wow. This rule was passed
returnValue = true;
break;
}
if (!returnValue && !denied)
{// Now use the default rule
DecisionMakerType unitDM = DecisionMakerType.GetDM(UnitFacts.GetDM(alias.UnitID));
if (
(alias.DecisionMaker == unitDM.Identifier)
// &&
//(UnitFacts.HostileTo(unitDM.Team, DecisionMakerType.GetDM(UnitFacts.GetDM(alias.TargetObjectID)).Team))
//AD: Changed to allow for non-hostiles to be engaged, as they are requested by live players.
)
{
returnValue = true;
}
}
return(returnValue);
}
public static void Add(ScenarioEventType s)
{
approvals.Add(s);
}
/// <summary>
/// Coordinates all the processing for each time slice
/// </summary>
/// <param name="updateIncrement"></param>
public static void NextTimeSlice()
{
/*
* Initially the only items that would be named in events would be actual units.
* Now that other things (ActiveRegions,for example) can also appear in events
* it is necessary to allow UnitFActs to know those names too, to keep various checks on
* object name legality from failing
*/
/* 1. Process the incoming list of events from below */
// Which units are currently on the incoming list?
List <string> unitList = IncomingList.AffectedUnits();
for (int i = 0; i < unitList.Count; i++)
{
List <IncomingItemType> eventList = IncomingList.Retrieve(unitList[i]);
/* do things with these events */
for (int j = 0; j < eventList.Count; j++)
{
ScenarioEventType thisItem = eventList[j].TheEvent;
Coordinator.debugLogger.Writeline("Timer", "Time: " + timer + " Unit " + unitList[i] + " has incoming " + thisItem.GetType().ToString(), "test");
if (UnitFacts.AnyDead(thisItem.AllUnits))
{
continue;
}
Boolean launchedByOwner;
switch (thisItem.GetType().ToString())
{
case name_Space + "MoveComplete_Event":
{
Coordinator.debugLogger.Writeline("Timer", "Unit " + thisItem.UnitID + " MoveComplete discovered at t=" + timer.ToString(), "test");
// scan happenings list for matches
VerifyMatch = ActionMatch;
SeekHappening(thisItem.UnitID, "MoveComplete_Event");
SeekSpeciesHappening(thisItem, "MoveComplete_Event");
}
break;
case name_Space + "StateChangeNotice":
string newState = ((StateChangeNotice)thisItem).NewState;
Coordinator.debugLogger.Writeline("Timer", "Unit " + thisItem.UnitID + " StateChange to " + newState + " discovered at t=" + timer.ToString(), "test");
VerifyMatch = StateMatch;
List <string> affectedUnitList = new List <string>();
if ("Dead" != newState)
{
affectedUnitList.Add(thisItem.UnitID);
UnitFacts.CurrentUnitStates[thisItem.UnitID] = newState; // newState;
}
else // Purge queues if the new state is "Dead"
{
affectedUnitList = SubplatformRecords.DeepDockedList(thisItem.UnitID);
}
for (int someUnit = 0; someUnit < affectedUnitList.Count; someUnit++)
{
if ("Dead" == newState)
{
UnitFacts.CurrentUnitStates[affectedUnitList[someUnit]] = "Dead"; // newState;
//first drop all timer events involving this unit
TimerQueueClass.FlushOneUnit(affectedUnitList[someUnit]);
}
SeekHappening(affectedUnitList[someUnit], newState);
//Then if dead, remove all happening events involving this unit
if ("Dead" == newState)
{
HappeningList.FlushOneUnit(affectedUnitList[someUnit]);
Coordinator.debugLogger.Writeline("Timer", " stateChangeEvent for " + affectedUnitList[someUnit], "test");
}
SeekSpeciesHappening(thisItem, newState);
}
break;
case name_Space + "AttackSuccessfulNotice":
AttackSuccessfulNotice asn = (AttackSuccessfulNotice)thisItem;
for (int asi = 0; asi < AttackSuccessfulList.Happenings.Count; asi++)
{
AttackSuccessfulCompletionType tryThisEvent = AttackSuccessfulList.Happenings[asi];
if (tryThisEvent.Matches(asn))
{
if (tryThisEvent.DoThisList.Count > 0)
{
AttackSuccessfulCompletionType.EnqueueEvents(asn.UnitID, asn.Target, tryThisEvent.DoThisList);
}
break;
}
}
break;
case name_Space + "AttackObjectRequestType":
Coordinator.debugLogger.Writeline("Timer", "Attack request for " + thisItem.UnitID + "attack Request discovered at t=" + timer.ToString(), "test");
AttackObjectRequestType recastAOR = (AttackObjectRequestType)thisItem;
if (ApprovalsList.AttackApproved(recastAOR))
{
string attacker = recastAOR.UnitID;
string target = recastAOR.TargetObjectID;
AttackObjectEvent attack = new AttackObjectEvent(attacker, target, recastAOR.CapabilityName);
attack.AddOtherUnit(target);
TimerQueueClass.Add(1 + (int)(TimerTicker.Timer / 1000 /*Coordinator.UpdateIncrement*/), attack);
}
else
{
TimerQueueClass.Add(1 + (int)(TimerTicker.Timer / 1000), new SystemMessage(1, recastAOR.UnitID, "Attack against " + recastAOR.TargetObjectID + " failed."));
}
break;
case name_Space + "WeaponLaunchRequestType":
WeaponLaunchRequestType recastWL = (WeaponLaunchRequestType)thisItem;
string unitID = recastWL.UnitID;
string weaponID = recastWL.WeaponID;
string targetID = recastWL.TargetObjectID;
Coordinator.debugLogger.Writeline("Timer", "Weapon Launch request for " + unitID + " using " + weaponID + " Attack Request discovered at t=" + timer.ToString(), "test");
string platformOwner = UnitFacts.Data[unitID].Owner;
string weaponOwner = UnitFacts.Data[weaponID].Owner;
launchedByOwner = SpeciesType.GetSpecies(UnitFacts.Data[weaponID].Species).LaunchedByOwner;
// )
if (
SubplatformRecords.IsLaunchableWeapon(unitID, weaponID)
&&
(
(platformOwner == recastWL.DecisionMaker)
||
(weaponOwner == recastWL.DecisionMaker) && launchedByOwner
)
)
{
// validate attack
DecisionMakerType targetDM = DecisionMakerType.GetDM(UnitFacts.GetDM(targetID));
if (
(launchedByOwner && UnitFacts.HostileTo(DecisionMakerType.GetDM(platformOwner).Team, targetDM.Team))
||
(UnitFacts.HostileTo(DecisionMakerType.GetDM(weaponOwner).Team, targetDM.Team))
//Removed !launchedByOwner from second statement
)
{
//NB. THe code that builds and sends the event was missing from here. It was last seen in rev 232.
// its removeal was probably an accident?
// build event to send down
WeaponLaunch_EventType wEvent = new WeaponLaunch_EventType(unitID, targetID, weaponID);
TimerQueueClass.Add(1 + (int)(timer / 1000), wEvent);
// replace by new platform handling
}
}
else
{
//need to throw an event back to ViewPro to re-allocate weapon
String reason = "";
if (!UnitFacts.Data.ContainsKey(unitID))
{
reason = "Platform object is unknown by the system.";
}
else if (UnitFacts.Data[unitID].Owner != recastWL.DecisionMaker)
{
reason = "Requesting DM does not own the Platform object.";
}
WeaponLaunchFailure_EventType failEvent = new WeaponLaunchFailure_EventType(weaponID, unitID, reason);
failEvent.Time = (int)(timer / 1000 /*Coordinator.UpdateIncrement*/);
TimerQueueClass.Add(1 + (int)(timer / 1000 /*Coordinator.UpdateIncrement*/), failEvent);
}
break;
case name_Space + "SubplatformLaunchRequestType":
SubplatformLaunchRequestType recastSL = (SubplatformLaunchRequestType)thisItem;
string childID = recastSL.UnitID;
string requestor = recastSL.Requestor;
string parentID = recastSL.ParentUnit;
LocationType destination = recastSL.Destination;
Coordinator.debugLogger.Writeline("Timer", "Subplatform Launch request for " + childID + " from " + parentID + " discovered at t=" + timer.ToString(), "test");
launchedByOwner = SpeciesType.GetSpecies(UnitFacts.Data[childID].Species).LaunchedByOwner;
if (
(UnitFacts.Data[parentID].Owner == requestor)
||
(UnitFacts.Data[childID].Owner == requestor) && launchedByOwner
)
{
// build event to send down
SubplatformLaunchType slEvent = new SubplatformLaunchType(childID, parentID, destination);
TimerQueueClass.Add(1 + (int)(timer / 1000), slEvent);
}
/**/
break;
case name_Space + "SubplatformDockRequestType":
SubplatformDockRequestType recastSD = (SubplatformDockRequestType)thisItem;
string orphanID = recastSD.UnitID;
string dockRequestor = recastSD.Requestor;
string adopterID = recastSD.ParentUnit;
Coordinator.debugLogger.Writeline("Timer", "Subplatform Dock request for " + orphanID + " from " + adopterID + " discovered at t=" + timer.ToString(), "test");
if ("" != adopterID)
{
if (UnitFacts.Data.ContainsKey(orphanID) &&
UnitFacts.Data.ContainsKey(adopterID) &&
((UnitFacts.Data[orphanID].Owner == dockRequestor)
// && (UnitFacts.Data[adopterID].Owner == dockRequestor)
) &&
SpeciesType.GetSpecies(UnitFacts.GetSpecies(adopterID)).CanHaveSubplatform(UnitFacts.GetSpecies(orphanID))
)
{
/* for dock to any object*/
SubplatformDockType sdEvent = new SubplatformDockType(orphanID, adopterID);
TimerQueueClass.Add(1 + (int)(timer / 1000), sdEvent);
}
} // if the parent is "" just ignore the request
public static void Add(ScenarioEventType e)
{
incoming.Add(e);
}
public IncomingItemType(ScenarioEventType theEvent, int theIndex)
{
this.theEvent = theEvent;
this.theIndex = theIndex;
}
/// <summary>
/// Constructs an item being returned from the Incoming list
/// This is a container for the actual event
/// </summary>
/// <param name="theEvent">The event fas ound on the list</param>
/// <param name="theIndex">The sequential position of the event</param>
public IncomingItemType(ScenarioEventType theEvent, int theIndex)
{
this.theEvent = theEvent;
this.theIndex = theIndex;
}
public static void Add(ScenarioEventType e)
{
incoming.Add(e);
}