public void RemoveAttackTest1()
{
AttackCollectionValue target = new AttackCollectionValue();
target.FromXML(LoadableXML);
AttackCollectionValue.AttackValue attack = null;
bool expected = true;
bool actual;
int remainingCapabilityPercentage = 40;
attack = target.GetCurrentAttacks()[1];
actual = target.RemoveAttack(attack);
Assert.AreEqual(expected, actual);
Assert.AreEqual(remainingCapabilityPercentage, target.GetCurrentAttacks()[1].percentageApplied);
}
private void CancelCapabilityAttack(string capabilityName, string attackingObjectID)
{
SimulationObjectProxy attacker = objectProxies[attackingObjectID];
if (attacker == null)
{
return;
}
List <AttackCollectionValue.AttackValue> attacksToRemove = new List <AttackCollectionValue.AttackValue>();
AttackCollectionValue currentAttacks = attacker["CurrentAttacks"].GetDataValue() as AttackCollectionValue;
foreach (AttackCollectionValue.AttackValue av in currentAttacks.GetCurrentAttacks())
{
if (av.capabilityName == capabilityName && attackingObjectID == av.attackingObjectId)
{
attacksToRemove.Add(av);
}
}
foreach (AttackCollectionValue.AttackValue av in attacksToRemove)
{
RemoveIntensityFromTargetsVulnerability(av.targetObjectId, av.capabilityName, av.appliedIntensity);
currentAttacks.RemoveAttack(av);
}
attacker["CurrentAttacks"].SetDataValue(currentAttacks);
attacksToRemove.Clear();
}
public void FromXMLTest()
{
AttackCollectionValue target = new AttackCollectionValue();
bool caughtException = false;
try
{
target.FromXML(LoadableXML);
}
catch (System.Exception ex)
{
caughtException = true;
}
Assert.IsTrue(!caughtException, "Error creating FromXML");
Assert.IsTrue(target.GetCurrentAttacks().Count == 3, "Incorrect Amount of attacks populated");
Assert.IsTrue(target.GetCurrentPercentageApplied("Missile") == 100, "Incorrect Percentage Applied for Missile");
target.FromXML("");
Assert.IsTrue(target.GetCurrentAttacks().Count == 0, "Incorrect Amount of attacks populated");
Assert.IsTrue(target.GetCurrentPercentageApplied("Missile") == 0, "Incorrect Percentage Applied for Missile");
}
public void RemoveAttackTest()
{
AttackCollectionValue target = new AttackCollectionValue();
target.FromXML(LoadableXML);
string capabilityName = "Missile";
string targetObjectId = "MyTarget";
string attackingObjectId = "MyAttacker";
int attackStartTime = 8;
int remainingCapabilityPercentage = 40;
bool expected = true;
bool actual;
actual = target.RemoveAttack(capabilityName, targetObjectId, attackingObjectId, attackStartTime);
Assert.AreEqual(expected, actual);
Assert.AreEqual(remainingCapabilityPercentage, target.GetCurrentAttacks()[1].percentageApplied);
}
private void CompareNewDMViewWithPrevious(string dm, Dictionary <string, AttributeCollectionValue> singleDMView, ref List <string> recentDiscoveries)
{
if (!dmViews.ContainsKey(dm))
{
return;
}
ObjectsAttributeCollection prevDMView = dmViews[dm];
List <string> objectsToRemove = new List <string>();
List <string> objectsToAdd = new List <string>();
List <string> previouslyNotVisibleObjects = new List <string>();
foreach (string obj in prevDMView.GetObjectKeys())
{
if (!singleDMView.ContainsKey(obj))
{
objectsToRemove.Add(obj);
}
if (prevDMView[obj].attributes.ContainsKey("Location"))
{
if (!((LocationValue)((DetectedAttributeValue)prevDMView[obj]["Location"]).value).exists)
{
previouslyNotVisibleObjects.Add(obj);
}
}
}
foreach (string obj in singleDMView.Keys)
{
if (!prevDMView.ContainsObject(obj) && singleDMView[obj].attributes.ContainsKey("Location"))
{
objectsToAdd.Add(obj);
}
}
AttributeCollectionValue acv = new AttributeCollectionValue();
//acv.attributes.Add("ID", new StringValue() as DataValue);
foreach (string obj in objectsToAdd.ToArray())
{
//
acv = singleDMView[obj]; //singleDMView stores DetectedValues, which need to be
//stripped before sending to SendVPIO
if (acv.attributes.ContainsKey("Location"))
{
if (!((LocationValue)((DetectedAttributeValue)acv["Location"]).value).exists)
{
objectsToRemove.Add(obj);
objectsToAdd.Remove(obj);
continue;
}
else
{
//if (!previouslyNotVisibleObjects.Contains(obj))
// continue;
//objectsToAdd.Add(obj);
//objectsToRemove.Remove(obj);
}
}
if (!acv.attributes.ContainsKey("ID"))
{
acv["ID"] = DataValueFactory.BuildDetectedValue(DataValueFactory.BuildString(obj), 100);
}
if (!acv.attributes.ContainsKey("OwnerID"))
{
acv["OwnerID"] = DataValueFactory.BuildDetectedValue(objectProxies[obj]["OwnerID"].GetDataValue(), 100);
}
SendViewProInitializeObject(dm, ExtractDetectedValuesFromACV(acv));
}
foreach (string obj in objectsToRemove)
{
SendRemoveObjectEvent(obj, dm);
prevDMView.RemoveObject(obj);
}
bool anyAttributeChanged = false;
acv = null;
foreach (string obj in objectsToAdd)
{
//AttributeCollectionValue atts = new AttributeCollectionValue(); //prevDMView.UpdateObject(obj, singleDMView[obj]);
//SendViewProAttributeUpdate(dm, atts);
prevDMView.UpdateObject(obj, new AttributeCollectionValue());
if (!movingObjects.Contains(obj))
{
continue;
}
if (!activeDMs.Contains(dm))
{
continue;
}
if (!recentDiscoveries.Contains(obj))
{
recentDiscoveries.Add(obj);
}
//atts["ObjectID"] = DataValueFactory.BuildString(obj);//this is needed as the
// //above Update call will
// //add "ID", not "ObjectID"
//SendViewProMotionUpdate(atts);
}
foreach (string obj in prevDMView.GetObjectKeys())
{
acv = prevDMView.UpdateObject(obj, singleDMView[obj]);
//add recent tags
if (recentUnitTags != null)
{
if (recentUnitTags.ContainsKey(obj))
{
if (recentUnitTags[obj].ContainsKey(dm))
{
if (acv == null)
{
acv = new AttributeCollectionValue();
}
acv.attributes["InitialTag"] = DataValueFactory.BuildString(recentUnitTags[obj][dm]);
recentUnitTags[obj].Remove(dm); //remove once the DM has been notified.
acv.attributes["ID"] = DataValueFactory.BuildString(obj);
acv.attributes["OwnerID"] = prevDMView[obj]["OwnerID"];
}
}
}
String classification = GetChangedClassificationForDM(obj, dm);
if (classification != null)
{
if (acv == null)
{
acv = new AttributeCollectionValue();
acv.attributes["ID"] = DataValueFactory.BuildString(obj);
acv.attributes["OwnerID"] = prevDMView[obj]["OwnerID"];
}
acv.attributes["CurrentClassification"] = DataValueFactory.BuildString(classification);
}
if (acv == null)
{
continue;
}
if (acv.attributes.ContainsKey("Location"))
{
if (((LocationValue)((DetectedAttributeValue)acv["Location"]).value).exists)
{
//SendViewProInitializeObject(dm, ExtractDetectedValuesFromACV(prevDMView[obj]));
}
}
SendViewProAttributeUpdate(dm, acv);
if (acv.attributes.ContainsKey("OwnerID") && acv.attributes.ContainsKey("CurrentAttacks"))
{
if (((StringValue)((DetectedAttributeValue)acv.attributes["OwnerID"]).value).value == dm)
{
AttackCollectionValue attacks = (AttackCollectionValue)((DetectedAttributeValue)acv.attributes["CurrentAttacks"]).value;
foreach (AttackCollectionValue.AttackValue av in attacks.GetCurrentAttacks())
{
foreach (Attack a in currentAttacks)
{
if (a.attacker == av.attackingObjectId && a.target == av.targetObjectId && a.capabilityName == av.capabilityName)
{
a.SetTimes(av.attackStartTime, av.attackTimeWindow);
}
}
}
}
}
if (acv.attributes.ContainsKey("DestinationLocation") ||
acv.attributes.ContainsKey("Throttle"))
{
if (!recentDiscoveries.Contains(obj))
{
recentDiscoveries.Add(obj);
}
//acv["ObjectID"] = acv["ID"];
//SendViewProMotionUpdate(ExtractDetectedValuesFromACV(acv));
}
acv = null;
}
}
private void TimeTick(SimulationEvent e)
{
time = ((IntegerValue)e["Time"]).value;
DataValue dv = null;
SimulationObjectProxy targetProx = null;
Vec3D targetLoc = new Vec3D(0, 0, 0);
SimulationObjectProxy obProx = null;
bool selfDefenseStartAttack;
string selfDefenseCapability;
string selfDefenseTargetID;
Dictionary <string, Dictionary <string, List <AttackCollectionValue.AttackValue> > > currentAttackCollection = new Dictionary <string, Dictionary <string, List <AttackCollectionValue.AttackValue> > >();
//[ [TargetID]/[ CapabilityUsed]/[List of Attacks] ]
Dictionary <string, List <AttackCollectionValue.AttackValue> > attacksToRemove = new Dictionary <string, List <AttackCollectionValue.AttackValue> >();
// [AttackerID]/[List of attacks to remove]
//as you clean up attacks, add them to this list. once done iterating over targets, go through this list and update the attacks in the keys.
foreach (string id in objectProxies.Keys)
{
obProx = objectProxies[id];
//Generate Attack dictionary
AttackCollectionValue attacks = (AttackCollectionValue)obProx["CurrentAttacks"].GetDataValue();
foreach (AttackCollectionValue.AttackValue av in attacks.GetCurrentAttacks())
{
if (!currentAttackCollection.ContainsKey(av.targetObjectId))
{
currentAttackCollection.Add(av.targetObjectId, new Dictionary <string, List <AttackCollectionValue.AttackValue> >());
}
if (!currentAttackCollection[av.targetObjectId].ContainsKey(av.capabilityName))
{
currentAttackCollection[av.targetObjectId].Add(av.capabilityName, new List <AttackCollectionValue.AttackValue>());
}
currentAttackCollection[av.targetObjectId][av.capabilityName].Add(av); //store pointer
}
selfDefenseStartAttack = ((BooleanValue)obProx["SelfDefenseStartAttack"].GetDataValue()).value;
if (selfDefenseStartAttack)
{
selfDefenseCapability = ((StringValue)obProx["SelfDefenseCapability"].GetDataValue()).value;
selfDefenseTargetID = ((StringValue)obProx["SelfDefenseTargetID"].GetDataValue()).value;
targetProx = objectProxies[selfDefenseTargetID];
if (((AttackCollectionValue)obProx["CurrentAttacks"].GetDataValue()).GetCurrentAttacks().Count == 0 &&
((StringValue)obProx["State"].GetDataValue()).value != "Dead" &&
((StringValue)targetProx["State"].GetDataValue()).value != "Dead")
{
AttackObject(id, selfDefenseTargetID, selfDefenseCapability, 100, true);
if (((StringValue)obProx["AttackState"].GetDataValue()).value == "")
{
SendSelfDefenseAttackStarted(id, selfDefenseTargetID);
}
}
}
}
foreach (string targetID in objectProxies.Keys)
{
targetProx = objectProxies[targetID];
string currentState = ((StringValue)objectProxies[targetID]["State"].GetDataValue()).value;
dv = targetProx["AttackState"].GetDataValue();
if (((StringValue)dv).value == "BEING_ATTACKED")
{
if (!currentAttackCollection.ContainsKey(targetID))
{
currentAttackCollection.Add(targetID, new Dictionary <string, List <AttackCollectionValue.AttackValue> >());
//this should not happen, or we're in trouble
}
int capabilitiesCompleted = 0; //this gets incremented as you add to attacksToRemove
foreach (String capability in currentAttackCollection[targetID].Keys)
{
//update attack windows for each attack object?
int attackEndTime = -1;
foreach (AttackCollectionValue.AttackValue av in currentAttackCollection[targetID][capability])
{
if (attackEndTime == -1)
{
attackEndTime = av.attackStartTime + av.attackTimeWindow;
}
else
{
attackEndTime = Math.Min(attackEndTime, av.attackStartTime + av.attackTimeWindow);
}
}
int newDuration = attackEndTime - time;
foreach (AttackCollectionValue.AttackValue av in currentAttackCollection[targetID][capability])
{
av.attackTimeWindow = attackEndTime - av.attackStartTime;// newDuration;
}
//check attack window vs current time
if (time >= attackEndTime)
{
//cleanup if needed
//add attacks to remove list
foreach (AttackCollectionValue.AttackValue av in currentAttackCollection[targetID][capability])
{
if (!attacksToRemove.ContainsKey(av.attackingObjectId))
{
attacksToRemove.Add(av.attackingObjectId, new List <AttackCollectionValue.AttackValue>());
}
attacksToRemove[av.attackingObjectId].Add(av);
}
//check vulnerabilities
VulnerabilityValue targetVul = (VulnerabilityValue)targetProx["Vulnerability"].GetDataValue();
bool attackSuccess = false;
List <string> capabilitiesApplied;
List <string> attackers = new List <string>();
foreach (VulnerabilityValue.Transition t in targetVul.transitions)
{
foreach (String cap in t.GetAppliedCapabilities())
{
if (!currentAttackCollection[targetID].ContainsKey(cap))
{
continue; //workaround for issue at USF; for some reason capability was not added to current attack collection.
}
foreach (AttackCollectionValue.AttackValue val in currentAttackCollection[targetID][cap])
{
string attackerID = val.attackingObjectId;
if (!attackers.Contains(attackerID))
{
attackers.Add(attackerID);
}
}
}
if (t.ConditionsMet())
{
capabilitiesApplied = t.GetAppliedCapabilities();
// Send state change
string newState = t.state;
SimulationEvent sc = SimulationEventFactory.BuildEvent(ref simModel, "StateChange");
((StringValue)sc["ObjectID"]).value = targetID;
((StringValue)sc["NewState"]).value = newState;
((IntegerValue)sc["Time"]).value = time;
distClient.PutEvent(sc);
foreach (string attackerID in attackers)
{
distClient.PutEvent(SimUtility.BuildSystemMessageEvent(ref simModel,
time,
((StringValue)(objectProxies[attackerID]["OwnerID"].GetDataValue())).value,
attackerID + " has succesfully engaged " + targetID));
distClient.PutEvent(SimUtility.BuildSystemMessageEvent(ref simModel,
time,
((StringValue)(targetProx["OwnerID"].GetDataValue())).value,
targetID + " has been succesfully engaged by " + attackerID));
ScoringDB.UpdateScore_StateChange(new ScoringDB.ActorFrame(attackerID,
StateDB.physicalObjects[attackerID].speciesName,
StateDB.physicalObjects[attackerID].ownerID,
StateDB.physicalObjects[attackerID].activeRegions),
currentState,
t.state,
new ScoringDB.ActorFrame(targetID,
StateDB.physicalObjects[targetID].speciesName,
StateDB.physicalObjects[targetID].ownerID,
StateDB.physicalObjects[targetID].activeRegions));
}
t.ClearAppliedEffects();
distClient.PutEvent(SimUtility.BuildHistory_AttackedObjectReportEvent(ref simModel,
time,
targetID,
targetLoc,
true,
t.state));
distClient.PutEvent(SimUtility.BuildAttackSucceededEvent(ref simModel, time, attackers[0], targetID, newState, capabilitiesApplied));
attackSuccess = true;
break;
}
}
//send messages
if (!attackSuccess)
{
foreach (String attackerID in attackers)
{
distClient.PutEvent(SimUtility.BuildSystemMessageEvent(ref simModel,
time,
((StringValue)(objectProxies[attackerID]["OwnerID"].GetDataValue())).value,
attackerID + " has failed in engagement of " + targetID));
distClient.PutEvent(SimUtility.BuildSystemMessageEvent(ref simModel,
time,
((StringValue)(targetProx["OwnerID"].GetDataValue())).value,
targetID + " has been unsuccesfully engaged by " + attackerID));
}
foreach (VulnerabilityValue.Transition t in targetVul.transitions)
{
t.ClearAppliedEffects();
}
distClient.PutEvent(SimUtility.BuildHistory_AttackedObjectReportEvent(ref simModel,
time,
targetID,
targetLoc,
false,
""));
}
capabilitiesCompleted++;
//if there are more capabilities being applied than this one, don't remove target's attack state.
if (currentAttackCollection[targetID].Count - capabilitiesCompleted == 0)
{// this occurs when all attacks will be removed in this loop
dv = targetProx["AttackState"].GetDataValue();
((StringValue)dv).value = "";
targetProx["AttackState"].SetDataValue(dv);
}
}
}
foreach (string attackerID in attacksToRemove.Keys)
{
SimulationObjectProxy attackerProxy = objectProxies[attackerID];
if (attackerProxy != null)
{
AttackCollectionValue acv = attackerProxy["CurrentAttacks"].GetDataValue() as AttackCollectionValue;
foreach (AttackCollectionValue.AttackValue attackVal in attacksToRemove[attackerID])
{
if (!acv.RemoveAttack(attackVal))
{
acv.RemoveAttack(attackVal.capabilityName, attackVal.targetObjectId, attackVal.attackingObjectId, attackVal.attackStartTime);
}
}
attackerProxy["CurrentAttacks"].SetDataValue(acv);
if (((BooleanValue)attackerProxy["IsWeapon"].GetDataValue()).value)
{
distClient.PutEvent(SimUtility.BuildStateChangeEvent(ref simModel, time, attackerID, "Dead"));
}
}
}
if (capabilitiesCompleted > 0)
{//some attacks were removed, actually remove them from the currentAttackCollection, update attacker list.
//update attack lists (this will require some iteration over the attacks.
List <string> attackers = null;
dv = targetProx["AttackerList"].GetDataValue();
attackers = ((StringListValue)dv).strings;
attackers.Clear();
foreach (String capability in currentAttackCollection[targetID].Keys)
{
foreach (AttackCollectionValue.AttackValue av in currentAttackCollection[targetID][capability])
{
if (!attackers.Contains(av.attackingObjectId))
{
attackers.Add(av.attackingObjectId);
}
}
}
((StringListValue)dv).strings = attackers;
targetProx["AttackerList"].SetDataValue(dv);
}
}
}
}
private void ChangeObjectVulnerability(VulnerabilityValue newVulnerabilitySet, string objectID)
{
SimulationObjectProxy obj = objectProxies[objectID];
if (obj == null)
{
return;
}
VulnerabilityValue previousVulnerabilityValue = obj["Vulnerability"].GetDataValue() as VulnerabilityValue;
List <string> previousVulnerabilityNames = new List <string>();
foreach (VulnerabilityValue.Transition tr in previousVulnerabilityValue.transitions)
{
foreach (VulnerabilityValue.TransitionCondition tc in tr.conditions)
{
if (!previousVulnerabilityNames.Contains(tc.capability))
{
previousVulnerabilityNames.Add(tc.capability);
}
}
}
List <string> newVulnerabilityNames = new List <string>();
foreach (VulnerabilityValue.Transition tr in newVulnerabilitySet.transitions)
{
foreach (VulnerabilityValue.TransitionCondition tc in tr.conditions)
{
if (!newVulnerabilityNames.Contains(tc.capability))
{
newVulnerabilityNames.Add(tc.capability);
}
}
}
List <string> missingVulnerabilityNames = new List <string>();
foreach (string capName in previousVulnerabilityNames)
{
if (!newVulnerabilityNames.Contains(capName))
{
if (!missingVulnerabilityNames.Contains(capName))
{
missingVulnerabilityNames.Add(capName);
}
}
}
List <string> attackerList = ((StringListValue)obj["AttackerList"].GetDataValue()).strings;
List <string> updatedAttackerList = new List <string>();
foreach (string attacker in attackerList)
{
//get attacker's current attacks
AttackCollectionValue currentAttacks = objectProxies[attacker]["CurrentAttacks"].GetDataValue() as AttackCollectionValue;
List <AttackCollectionValue.AttackValue> attacksOnTarget = currentAttacks.GetCurrentAttacksOnTarget(objectID);
List <AttackCollectionValue.AttackValue> allAttacks = currentAttacks.GetCurrentAttacks();
//foreach attack
foreach (AttackCollectionValue.AttackValue av in attacksOnTarget)
{
if (missingVulnerabilityNames.Contains(av.capabilityName))
{
//if this attack is targetting my object with a capability that's in missingVulnerabilities, cancel the attack
CancelAttack(attacker, objectID, av.capabilityName);
}
}
if (allAttacks.Count > attacksOnTarget.Count)
{
updatedAttackerList.Add(attacker);
}
}
obj["AttackerList"].SetDataValue(DataValueFactory.BuildStringList(updatedAttackerList));
obj["Vulnerability"].SetDataValue(newVulnerabilitySet);
previousVulnerabilityNames.Clear();
newVulnerabilityNames.Clear();
}
