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();
}
private bool CancelAttack(string attackingObjectID, string targetObjectID, string capabilityName)
{
//get attacker proxy
SimulationObjectProxy attacker = objectProxies[attackingObjectID];
//find engagement between attacker and target
AttackCollectionValue attacks = attacker["CurrentAttacks"].GetDataValue() as AttackCollectionValue;
List <AttackCollectionValue.AttackValue> attacksToRemove = new List <AttackCollectionValue.AttackValue>();
foreach (AttackCollectionValue.AttackValue att in attacks.GetCurrentAttacksOnTarget(targetObjectID))
{
if (att.capabilityName == capabilityName && att.attackingObjectId == attackingObjectID && att.targetObjectId == targetObjectID)
{
//cancel out Transition amount applied for this attack
RemoveIntensityFromTargetsVulnerability(targetObjectID, capabilityName, att.appliedIntensity);
attacksToRemove.Add(att);
}
}
//for attacker, cancel the attack.
foreach (AttackCollectionValue.AttackValue atv in attacksToRemove)
{
attacks.RemoveAttack(atv);
}
attacker["CurrentAttacks"].SetDataValue(attacks);
return(true);
}
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);
}
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 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);
}
}
}
}