private void TransferObject(SimulationEvent e)
{
string objectID = ((StringValue)e["ObjectID"]).value;
SimulationObjectProxy prox = objectProxies[objectID];
string userID = ((StringValue)e["UserID"]).value;
string donerUserID = ((StringValue)e["DonorUserID"]).value;
prox["OwnerID"].SetDataValue(DataValueFactory.BuildString(userID));
StateDB.physicalObjects[objectID].ownerID = userID;
distClient.PutEvent(SimUtility.BuildSystemMessageEvent(ref simModel,
time,
userID,
String.Format("Ownership of {0} has been transferred from {1} to {2}", objectID, donerUserID, userID)));
distClient.PutEvent(SimUtility.BuildSystemMessageEvent(ref simModel,
time,
donerUserID,
String.Format("Ownership of {0} has been transferred from {1} to {2}", objectID, donerUserID, userID)));
}
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 AttackObject(string attackerID, string targetID, string capabilityName, int percentageApplied, bool isSelfDefense)
{
DataValue dv = null;
//AD Note: on 9/23/09, we decided that Vulnerabilities would now have an "EngagementDuration", which is the Vulnerability
// version of Capability's "AttackDuration". If an EngagementDuration exists, it will override a Capability's AttackDuration.
SimulationObjectProxy attackerProx = objectProxies[attackerID];
SimulationObjectProxy targetProx = objectProxies[targetID];
CapabilityValue attackerCap = (CapabilityValue)attackerProx["Capability"].GetDataValue();
VulnerabilityValue targetVul = (VulnerabilityValue)targetProx["Vulnerability"].GetDataValue();
// Check to see if this attack can start
if (((StringValue)attackerProx["AttackState"].GetDataValue()).value == "BEING_ATTACKED")
{
distClient.PutEvent(SimUtility.BuildSystemMessageEvent(ref simModel,
time,
((StringValue)(attackerProx["OwnerID"].GetDataValue())).value,
attackerID + " is being engaged -- it can't initiate an engagement."));
return;
}
if (targetVul.transitions.Count == 0)
{
distClient.PutEvent(SimUtility.BuildSystemMessageEvent(ref simModel,
time,
((StringValue)(attackerProx["OwnerID"].GetDataValue())).value,
attackerID + " can't engage " + targetID + " -- object has no vulnerabilities."));
return;
}
//AD 11/16/2009: New Attack Logic: Allow for partial capabilities to be applied to attacks.
AttackCollectionValue attackCollection = (AttackCollectionValue)attackerProx["CurrentAttacks"].GetDataValue();
int attackDuration = -1;
AttackCollectionValue.AttackValue newAttack = new AttackCollectionValue.AttackValue(time, attackDuration, targetID, attackerID, capabilityName, percentageApplied, isSelfDefense);
string errMsg = String.Empty;
attackDuration = ((IntegerValue)attackerProx["AttackDuration"].GetDataValue()).value;
int defenseDuration = ((IntegerValue)targetProx["EngagementDuration"].GetDataValue()).value;
int attackTimeWindow = attackDuration;
bool attackSuccess = true;
if (defenseDuration > 0)
{
attackTimeWindow = defenseDuration;
}
Console.WriteLine("AttackObject: Attack duration for " + attackerID + " is " + attackDuration.ToString());
Console.WriteLine("AttackObject: Attack duration for attack is " + attackTimeWindow.ToString());
newAttack.attackTimeWindow = attackTimeWindow;
if (attackCollection.AddAttack(newAttack, out errMsg) == false)
{
string msg = "The attack between " + attackerID + " and " + targetID + " encountered the following problem: " + errMsg;
distClient.PutEvent(SimUtility.BuildSystemMessageEvent(ref simModel,
time,
((StringValue)(attackerProx["OwnerID"].GetDataValue())).value,
msg));
attackSuccess = false;
}
else if (errMsg != String.Empty)
{
string msg = "The attack between " + attackerID + " and " + targetID + " encountered the following problem: " + errMsg;
distClient.PutEvent(SimUtility.BuildSystemMessageEvent(ref simModel,
time,
((StringValue)(attackerProx["OwnerID"].GetDataValue())).value,
msg));
}
else //success
{
dv = targetProx["AttackState"].GetDataValue();
((StringValue)dv).value = "BEING_ATTACKED";
targetProx["AttackState"].SetDataValue(dv);
dv = targetProx["AttackerList"].GetDataValue();
((StringListValue)dv).strings.Add(attackerID);
targetProx["AttackerList"].SetDataValue(dv);
}
if (!attackSuccess)
{
attackerProx["CurrentAttacks"].SetDataValue(attackCollection); //set below if attackSuccess is true
return;
}
//End new attack logic.
//
Vec3D attackerPosition = new Vec3D((LocationValue)attackerProx["Location"].GetDataValue());
Vec3D targetPosition = new Vec3D((LocationValue)targetProx["Location"].GetDataValue());
double distance = attackerPosition.ScalerDistanceTo(targetPosition); //FIX find actual diatance
int appliedIntensity = -1;
List <CapabilityValue.Effect> capabilities = attackerCap.GetOrderedEffectsByCapability(capabilityName);
foreach (CapabilityValue.Effect eff in capabilities)
{
if (eff.name == capabilityName && distance <= eff.range)
{
int r = random.Next(0, 100);
if (r <= ((int)(eff.probability * 100)))
{
appliedIntensity = Convert.ToInt32(Math.Round(((double)eff.intensity * (double)newAttack.percentageApplied / 100), MidpointRounding.AwayFromZero));
newAttack.appliedIntensity = appliedIntensity;
targetVul.ApplyEffect(eff.name, appliedIntensity, distance, ref random);
}
//break outside of the if because if the probability failed, you dont want a second chance with a different range.
break; //break because we only want to apply the first range found that satisfied the distance restraint
}
}
attackerProx["CurrentAttacks"].SetDataValue(attackCollection);
targetProx["Vulnerability"].SetDataValue((DataValue)targetVul);
distClient.PutEvent(SimUtility.BuildSystemMessageEvent(ref simModel,
time,
((StringValue)(attackerProx["OwnerID"].GetDataValue())).value,
attackerID + " has engaged " + targetID));
distClient.PutEvent(SimUtility.BuildSystemMessageEvent(ref simModel,
time,
((StringValue)(targetProx["OwnerID"].GetDataValue())).value,
targetID + " has been engaged by " + attackerID));
distClient.PutEvent(SimUtility.BuildHistory_AttackerObjectReportEvent(ref simModel,
time,
attackerID,
attackerPosition,
targetID,
targetPosition,
capabilityName,
appliedIntensity));
}