public override SimulationEvent ToSimulationEvent(ref SimulationModelInfo simModel)
{
SimulationEvent ev = SimulationEventFactory.BuildEvent(ref simModel, EVENTTYPE);
AttributeCollectionValue attributes = new AttributeCollectionValue();
attributes.attributes.Add("Location", this.Location);
attributes.attributes.Add("State", DataValueFactory.BuildString(this.State));
if(ObjectType != null && ObjectType != String.Empty)
{
attributes.attributes.Add("ClassName", DataValueFactory.BuildString(ObjectType));
}
if(OwnerID != null && OwnerID != String.Empty)
{
attributes.attributes.Add("OwnerID", DataValueFactory.BuildString(OwnerID));
}
if(StartupParameters != null)
{
foreach(String s in StartupParameters.Keys)
{
attributes.attributes.Add(s, StartupParameters[s]);
}
}
//do stuff
((StringValue)ev["ObjectID"]).value = this.ObjectID;
ev["Attributes"] = attributes;
return ev;
}
/// <summary>
/// Given a detected value and an attribute collection, the detected value will be added to the collection only
/// if the attribute is already not-existant within the collection, or if its confidence is higher.
/// </summary>
/// <param name="ACV"></param>
/// <param name="attributeName"></param>
/// <param name="dav"></param>
private void AddAttributeToACV(ref AttributeCollectionValue ACV, string attributeName, DetectedAttributeValue dav)
{
if (ACV.attributes.ContainsKey(attributeName))
{
if (((DetectedAttributeValue)dav).stdDev > ((DetectedAttributeValue)ACV[attributeName]).stdDev)
{
ACV[attributeName] = dav;
}
}
else
{
ACV.attributes.Add(attributeName, dav);
}
}
/// <summary>
/// Given two attribute collections, they will merge into one based on confidence values.
/// </summary>
/// <param name="startingACV"></param>
/// <param name="incomingACV"></param>
private void MergeTwoAttributeCollections(ref AttributeCollectionValue startingACV, AttributeCollectionValue incomingACV)
{
foreach (string attName in incomingACV.attributes.Keys)
{
if (startingACV.attributes.ContainsKey(attName))
{
if (((DetectedAttributeValue)startingACV[attName]).stdDev < ((DetectedAttributeValue)incomingACV[attName]).stdDev)
{
startingACV[attName] = incomingACV[attName];
}
}
else
{ //add attribute
startingACV.attributes.Add(attName, incomingACV[attName]);
}
}
}
private RangeRingLevels selectedRangeRingLevel = RangeRingLevels.FULL; //DEFAULT
#endregion
#region sensory methods
/// <summary>
/// This method will run through each object and determine what those objects can sense.
/// </summary>
private void CalculateSensoryAlgorithm()
{
//objectProxies = bbClient.GetObjectProxies();
Dictionary<string, Dictionary<string, AttributeCollectionValue>> allObjectsViews = new Dictionary<string, Dictionary<string, AttributeCollectionValue>>();
Dictionary<string, Dictionary<string, AttributeCollectionValue>> allSensorNetworksViews = new Dictionary<string, Dictionary<string, AttributeCollectionValue>>();
Dictionary<string, Dictionary<string, AttributeCollectionValue>> allDMsViews = new Dictionary<string, Dictionary<string, AttributeCollectionValue>>();
//each object senses each other object, and the allObjectsViews is populated and returned.
SenseAllObjects(ref allObjectsViews);
//each sensor network goes through the views of objects contained within that network, and
//creates its best view for all its members.
RetrieveSensorNetworkView(ref allSensorNetworksViews, ref allObjectsViews);
//Go through each sensor network, and create the best DM view for each active DM.
RetrieveAllDMViews(ref allDMsViews, ref allSensorNetworksViews);
//Send out view pro updates.
List<string> recentlyDiscoveredObjects = new List<string>();
bool sendAttUpdate = true;
foreach (string dm in dmOwnedObjects.Keys)
{
if (!allDMsViews.ContainsKey(dm))
continue;
CompareNewDMViewWithPrevious(dm, allDMsViews[dm], ref recentlyDiscoveredObjects);
}
foreach (string obj in recentlyDiscoveredObjects)
{
if (!movingObjects.Contains(obj))
continue;
AttributeCollectionValue atts = new AttributeCollectionValue();
atts.attributes.Add("ObjectID", DataValueFactory.BuildString(obj));
SendViewProMotionUpdate(atts);
}
}
internal void SetAttributes(AttributeCollectionValue atts)
{
if (atts.attributes.ContainsKey("GroundTruthIFF"))
{
this.GroundTruthIFF = ((StringValue)atts.attributes["GroundTruthIFF"]).value;
}
if (atts.attributes.ContainsKey("Heading"))
{
this.Heading = ((DoubleValue)atts.attributes["Heading"]).value;
}
if (atts.attributes.ContainsKey("ClassName"))
{
this.ClassName = ((StringValue)atts.attributes["ClassName"]).value;
}
if (atts.attributes.ContainsKey("State"))
{
this.State = ((StringValue)atts.attributes["State"]).value;
}
if (atts.attributes.ContainsKey("Location"))
{
this.Location = ((LocationValue)atts.attributes["Location"]);
}
if (atts.attributes.ContainsKey("Throttle"))
{
this.Throttle = ((DoubleValue)atts.attributes["Throttle"]).value;
}
if (atts.attributes.ContainsKey("MaximumSpeed"))
{
this.MaximumSpeed = ((DoubleValue)atts.attributes["MaximumSpeed"]).value;
}
if (atts.attributes.ContainsKey("DestinationLocation"))
{
this.DestinationLocation = ((LocationValue)atts.attributes["DestinationLocation"]);
}
if (atts.attributes.ContainsKey("TeamName"))
{
this.TeamName = ((StringValue)atts.attributes["TeamName"]).value;
}
if (atts.attributes.ContainsKey("OwnerID"))
{
this.Owner = ((StringValue)atts.attributes["OwnerID"]).value;
}
if (atts.attributes.ContainsKey("Heading"))
{
this.Heading = ((DoubleValue)atts.attributes["Heading"]).value;
}
if (atts.attributes.ContainsKey("ObjectName"))
{
this.ObjectName = ((StringValue)atts.attributes["ObjectName"]).value;
}
}
protected void MoveDone(SimulationEvent ev)
{//ObjectID, Reason
String id = ((StringValue)ev["ObjectID"]).value;
if (!_revealedObjects.ContainsKey(id))
return;
AttributeCollectionValue atts = new AttributeCollectionValue();
atts.attributes.Add("DestinationLocation", new LocationValue());
atts.attributes.Add("Throttle", DataValueFactory.BuildDouble(0));
String owner = _revealedObjects[id].Owner;
foreach (PolygonValue region in GetAllEntryRegions())
{
if (Polygon2D.IsPointInside(new Polygon2D(region), new Vec2D(GetSeamateObject(id).Location))
&& owner == "Merchant DM")
{
Console.WriteLine("Detected vessel " + id + " ending move in entry region, turning state to Dead.");
//atts.attributes.Add("State", DataValueFactory.BuildString("Dead"));
_dddConnection.SendStateChange(id, "Dead");
}
}
//LocationValue destLoc = as LocationValue;
_revealedObjects[id].SetAttributes(atts);
}
protected void MoveObject(SimulationEvent ev)
{ //ObjectID, DestinationLocation, Throttle,
String id = ((StringValue)ev["ObjectID"]).value;
if (!_revealedObjects.ContainsKey(id))
return;
AttributeCollectionValue atts = new AttributeCollectionValue();
atts.attributes.Add("DestinationLocation", ev["DestinationLocation"]);
atts.attributes.Add("Throttle", ev["Throttle"]);
//LocationValue destLoc = as LocationValue;
_revealedObjects[id].SetAttributes(atts);
}
protected void MoveDone(SimulationEvent ev)
{//ObjectID, Reason
String id = ((StringValue)ev["ObjectID"]).value;
if (!_revealedObjects.ContainsKey(id))
return;
AttributeCollectionValue atts = new AttributeCollectionValue();
atts.attributes.Add("DestinationLocation", new LocationValue());
atts.attributes.Add("Throttle", DataValueFactory.BuildDouble(0));
if (_revealedObjects.ContainsKey(id))
{
SeamateObject ob = _revealedObjects[id];
String owner = ob.Owner;
if (isInEntryRegion(ob) && owner == "Merchant DM")
{
Console.WriteLine("Detected vessel " + id + " ending move in entry region, turning state to Dead.");
_dddConnection.SendStateChange(id, "Dead");
}
}
_revealedObjects[id].SetAttributes(atts);
}
/// <summary>
/// Send an ExternalApp_Message event to communicate with another external application.
/// </summary>
/// <param name="appName"></param>
/// <param name="message"></param>
public void SendExternalAppMessage(String appName, AttributeCollectionValue message)
{
SimulationEvent e = SimulationEventFactory.BuildEvent(ref m_simModel, "ExternalApp_Message");
((StringValue)(e["AppName"])).value = appName;
e["Message"] = message;
m_netClient.PutEvent(e);
}
/// <summary>
/// Similar to CalculateRangeRings, this is done with ABSOLUTE data, not detected values.
/// This method is called in a ViewProAttributeUpdate call, which only contains attributes
/// which have CHANGED, and will determine if either the sensors, vulnerabilties, or capabilities (including docked weapons) has
/// changed. If so, then new attributes will be added to the attribute collection value.
/// </summary>
/// <param name="acv"></param>
/// <param name="fullObjectView"></param>
/// <returns></returns>
private void AddRangeRings(ref AttributeCollectionValue acv, ref SimulationObjectProxy fullObjectView)
{
if (acv.attributes.ContainsKey("Sensors"))
{
//detected contains a sensor array type
CustomAttributesValue sensorCollection = DataValueFactory.BuildCustomAttributes(new Dictionary<string, DataValue>()) as CustomAttributesValue;
RangeRingDisplayValue sensorRing;
SensorArrayValue detectedSensors = acv["Sensors"] as SensorArrayValue;
foreach (SensorValue sv in detectedSensors.sensors)
{
sensorRing = DataValueFactory.BuildRangeRingDisplayValue(sv.sensorName, "Sensors", false, new Dictionary<int, int>()) as RangeRingDisplayValue;
sensorRing.rangeIntensities.Add(Convert.ToInt32(sv.maxRange), -1);
sensorCollection.attributes.Add(sv.sensorName, sensorRing);
}
if (sensorCollection.attributes.Count > 0)
{
acv.attributes.Add("SensorRangeRings", sensorCollection);
}
else
{
Console.WriteLine("No SensorRangeRings added to ACV");
}
}
if (acv.attributes.ContainsKey("Vulnerability"))
{
//gets detected values, containing a vulnerability type
CustomAttributesValue vulnerabilityCollection = DataValueFactory.BuildCustomAttributes(new Dictionary<string, DataValue>()) as CustomAttributesValue;
RangeRingDisplayValue vulnerabilityRing;
VulnerabilityValue detectedVulnerability = acv["Vulnerability"] as VulnerabilityValue;
Dictionary<string, int> longestRange = new Dictionary<string,int>();//[Capability],[Range]
foreach (VulnerabilityValue.Transition tr in detectedVulnerability.transitions)
{
foreach(VulnerabilityValue.TransitionCondition tc in tr.conditions)
{
if(!longestRange.ContainsKey(tc.capability))
{
longestRange.Add(tc.capability, -1);
}
if (longestRange[tc.capability] < Convert.ToInt32(tc.range))
{
longestRange[tc.capability] = Convert.ToInt32(tc.range);
}
}
}
foreach (KeyValuePair<string, int> kvp in longestRange)
{
vulnerabilityRing = DataValueFactory.BuildRangeRingDisplayValue(kvp.Key, "Vulnerability", false, new Dictionary<int, int>()) as RangeRingDisplayValue;
vulnerabilityRing.rangeIntensities.Add(kvp.Value, -1);
vulnerabilityCollection.attributes.Add(kvp.Key, vulnerabilityRing);
}
if (vulnerabilityCollection.attributes.Count > 0)
{
acv.attributes.Add("VulnerabilityRangeRings", vulnerabilityCollection);
}
else
{
Console.WriteLine("No VulnerabilityRangeRings added to ACV");
}
}
if (acv.attributes.ContainsKey("Capability") || acv.attributes.ContainsKey("DockedWeapons"))
{
CustomAttributesValue capabilityCollection = DataValueFactory.BuildCustomAttributes(new Dictionary<string, DataValue>()) as CustomAttributesValue;
RangeRingDisplayValue capabilityRing;
Dictionary<string, int> longestWeaponRange = new Dictionary<string, int>();//[Capability],[Range]
//docked weapons gets string list of IDs
if (acv.attributes.ContainsKey("DockedWeapons"))
{
StringListValue dockedWeapons = acv["DockedWeapons"] as StringListValue;
foreach (String weaponID in dockedWeapons.strings)
{
//get weapon id
//get proxy info for weapon
SimulationObjectProxy weapon = objectProxies[weaponID];
string species = ((StringValue)weapon["ClassName"].GetDataValue()).value;
if (longestWeaponRange.ContainsKey(species))
{
continue;
//For now, assume that all weapons of the same species type have the same ranges.
//this will cut back on unneccessary loops, and for the most part is 100% true.
}
//get max speed, maxfuel or current fuel, get fuel consumption rate, get SHORTEST capability range
double maxSpeed = ((DoubleValue)weapon["MaximumSpeed"].GetDataValue()).value;
double maxFuel = ((DoubleValue)weapon["FuelCapacity"].GetDataValue()).value;
double fuelConsumptionRate = ((DoubleValue)weapon["FuelConsumptionRate"].GetDataValue()).value;
double shortCapabilityRange = -1;
CapabilityValue weaponCV = (CapabilityValue)weapon["Capability"].GetDataValue();
Dictionary<string, double> capRanges = new Dictionary<string, double>();
foreach (CapabilityValue.Effect ef in weaponCV.effects)
{
if (!capRanges.ContainsKey(ef.name))
{
capRanges.Add(ef.name, ef.range);
}
else
{
if (capRanges[ef.name] > ef.range)
{//You want the smaller range here because that's how weapons work. Auto-attacks use the SHORTEST range to trigger.
capRanges[ef.name] = ef.range;
}
}
}
//but here, you want the LONGEST of the ranges that could trigger an auto-attack.
foreach (KeyValuePair<string, double> kvp in capRanges)
{
if (kvp.Value > shortCapabilityRange)
{
shortCapabilityRange = kvp.Value;
}
}
double thisRange = maxSpeed * maxFuel * fuelConsumptionRate + shortCapabilityRange;
longestWeaponRange.Add(species, Convert.ToInt32(thisRange));
}
//
}
Dictionary<string, Dictionary<double, double>> capabilityRanges = new Dictionary<string, Dictionary<double, double>>();
if (acv.attributes.ContainsKey("Capability"))
{
CapabilityValue detectedCapability = acv["Capability"] as CapabilityValue;
foreach (CapabilityValue.Effect ef in detectedCapability.effects)
{
if (!capabilityRanges.ContainsKey(ef.name))
{
capabilityRanges.Add(ef.name, new Dictionary<double, double>());
}
capabilityRanges[ef.name].Add(ef.range, ef.intensity);
}
}
//add all capabilities to ring collection
foreach (string capName in capabilityRanges.Keys)
{
if (!capabilityCollection.attributes.ContainsKey(capName))
{
capabilityRing = DataValueFactory.BuildRangeRingDisplayValue(capName, "Capability", false, new Dictionary<int, int>()) as RangeRingDisplayValue;
Dictionary<int, int> convertedRanges = new Dictionary<int, int>();
foreach (KeyValuePair<double, double> kvp in capabilityRanges[capName])
{
convertedRanges.Add(Convert.ToInt32(kvp.Key), Convert.ToInt32(kvp.Value));
}
capabilityRing.AddAndSortRanges(convertedRanges); //this sorts as well
capabilityCollection.attributes.Add(capName, capabilityRing);
}
else
{
Console.WriteLine("Failed to add duplicate capability to collection, {0}", capName);
}
}
foreach (string weaponSpeciesName in longestWeaponRange.Keys)
{
if (!capabilityCollection.attributes.ContainsKey(weaponSpeciesName))
{
capabilityRing = DataValueFactory.BuildRangeRingDisplayValue(weaponSpeciesName, "Capability", true, new Dictionary<int, int>()) as RangeRingDisplayValue;
capabilityRing.rangeIntensities.Add(longestWeaponRange[weaponSpeciesName], -1); //TODO: Maybe add intensity above?
capabilityCollection.attributes.Add(weaponSpeciesName, capabilityRing);
}
else
{
Console.WriteLine("Failed to add duplicate capability(Weapon species) to collection, {0}", weaponSpeciesName);
}
}
if (capabilityCollection.attributes.Count > 0)
{
acv.attributes.Add("CapabilityRangeRings", capabilityCollection);
}
else
{
Console.WriteLine("No CapabilityRangeRings added to ACV");
}
}
}
/// <summary>
/// This is used as a normalizer, in which every client's view is reset to the server's view
/// for that client. Foreach object in each player's view, send out a ViewProInitializeObject
/// event, and then foreach object on the motion list, send out motion updates.
/// </summary>
private void ResumeScenario()
{
if (initialReplaySpeed != null)
{
distClient.PutEvent(initialReplaySpeed);
}
else
{
SimulationEvent ev = SimulationEventFactory.BuildEvent(ref simModel, "GameSpeed");
ev["SpeedFactor"] = DataValueFactory.BuildDouble(1); //default speed of 1
ev["Time"] = DataValueFactory.BuildInteger(currentTick);
distClient.PutEvent(ev);
}
//initialize views:
foreach (string dm in dmViews.Keys)
{
foreach (string objID in dmViews[dm].GetObjectKeys())
{
if (!dmViews[dm][objID].attributes.ContainsKey("Location"))
{//if a dm doesn't know an object's location, then that object
//is not visible to the dm.
continue;
}
AttributeCollectionValue acv = new AttributeCollectionValue();
acv["ID"] = DataValueFactory.BuildString(objID);
SendViewProInitializeObject(dm, acv);
}
}
//send motion updates:
AttributeCollectionValue tempACV = new AttributeCollectionValue();
tempACV.attributes.Add("ObjectID", DataValueFactory.BuildString(string.Empty));
foreach (string objectID in movingObjects)
{
tempACV["ObjectID"] = DataValueFactory.BuildString(objectID);
//SendViewProStopObjectUpdate(objectID);
SendViewProMotionUpdate(tempACV);
}
foreach (StateDB.ActiveRegion reg in StateDB.activeRegions.Values)
{
SendViewProActiveRegionUpdate(reg.id, reg.isVisible, reg.displayColor, reg.currentAbsolutePolygon);
}
}
/// <summary>
/// This method takes in a Create_EventType (ScenCon defined object), and retrieves
/// the data from the object, packages up the data into a SimulationEvent (SimCore defined
/// object), and then sends the event to the network server. This method was pulled out of
/// the main block of code to simplify sending the event and code readability.
/// </summary>
/// <param name="incoming">The Create_EventType object whose data is packaged
/// into an outgoing SimulationEvent.</param>
private static void SendCreateEvent(Create_EventType incoming)
{
SimulationEvent e = SimulationEventFactory.BuildEvent(ref simModelInfo, "NewObject");
Dictionary<string, DataValue> myAtt = new Dictionary<string, DataValue>();
Dictionary<string, object> DictionaryOfStates;
DataValue dv;
ObjectInfo myObject;
string objectType = incoming.Genus.ToString();
myObject = simModelInfo.objectModel.objects[objectType];
dv = new StateTableValue();
try
{
e["Time"] = DataValueFactory.BuildInteger(incoming.Time);//ConvertInteger(incoming.Timer);
e["ObjectType"] = DataValueFactory.BuildString(objectType); //ConvertString(objectType);
e["ID"] = DataValueFactory.BuildString(incoming.UnitID);//ConvertString(incoming.UnitID);
/*********** Define the State Table ***********************/
DictionaryOfStates = incoming.Parameters.GetDictionary();
}
catch
{
throw new Exception("Missing Required Data for Create Event");
}
Dictionary<string, DataValue> SimCoreStateTable = new Dictionary<string, DataValue>();
foreach (KeyValuePair<string, object> kvp in DictionaryOfStates)
{
DataValue capabilities,
vulnerabilities,
currentSimCoreState;
capabilities = new CapabilityValue();
vulnerabilities = new VulnerabilityValue();
currentSimCoreState = new AttributeCollectionValue();
ExtendedStateBody currentScenConState = new ExtendedStateBody();
currentScenConState = (ExtendedStateBody)incoming.Parameters[kvp.Key];
capabilities = DefineCapabilityValue(currentScenConState.Capabilities);
((AttributeCollectionValue)currentSimCoreState).attributes.Add("Capability", capabilities);
vulnerabilities = DefineVulnerabilityValue(currentScenConState.Vulnerabilities, currentScenConState.Combinations);
((AttributeCollectionValue)currentSimCoreState).attributes.Add("Vulnerability", vulnerabilities);
DataValue sensorArray = DataValueFactory.BuildValue("SensorArrayType");
DataValue sensor;
Dictionary<string, SensorType> sensors = new Dictionary<string, SensorType>();
Dictionary<string, List<ConeValue>> ranges;
sensors = currentScenConState.Sensors;
foreach (string sensorKind in sensors.Keys)
{
ranges = new Dictionary<string, List<ConeValue>>();
sensor = DataValueFactory.BuildValue("SensorType");
SensorType typeOfSensor = sensors[sensorKind];
string attributeSensed = typeOfSensor.Attribute;
List<Cone> cones = typeOfSensor.Cones;
double maxRange = 0.0;
((SensorValue)sensor).attIsEngram[attributeSensed] = sensors[sensorKind].IsEngram;
List<ConeValue> simCoreCones = new List<ConeValue>();
foreach (Cone aCone in sensors[sensorKind].Cones)
{
LocationValue direction = new LocationValue();
direction.X = aCone.Direction.X;
direction.Y = aCone.Direction.Y;
direction.Z = aCone.Direction.Z;
direction.exists = true;
ConeValue cv = new ConeValue();
cv.direction = direction;
cv.extent = aCone.Extent;
if (aCone.Extent > maxRange)
maxRange = aCone.Extent;
cv.level = aCone.Level;
cv.spread = aCone.Spread;
simCoreCones.Add(cv);
}
ranges.Add(attributeSensed, simCoreCones);
((SensorValue)sensor).ranges = ranges;
((SensorValue)sensor).sensorName = sensorKind;
if (((SensorValue)sensor).maxRange < maxRange)
{
((SensorValue)sensor).maxRange = maxRange;
}
((SensorArrayValue)sensorArray).sensors.Add((SensorValue)sensor);
}
((AttributeCollectionValue)currentSimCoreState).attributes.Add("Sensors", sensorArray);
//Emitters
DataValue emitter = DataValueFactory.BuildValue("EmitterType");
Dictionary<string, EmitterType> scenConEmitters = currentScenConState.Emitters;
EmitterType emission;
foreach (string s in scenConEmitters.Keys)
{
emission = scenConEmitters[s].DeepCopy();
string attributeName = s;
((EmitterValue)emitter).attIsEngram[s] = emission.IsEngram;
// string level;
// double variance;
Dictionary<string, double> levels = new Dictionary<string, double>();
foreach (string level in emission.Levels.Keys)
{
// levels.Add(level, (double)(emission[level]));
double dublet = Double.Parse((emission.Levels[level].ToString()));
levels.Add(level, dublet);
}
((EmitterValue)emitter).emitters.Add(attributeName, levels);
}
((AttributeCollectionValue)currentSimCoreState).attributes.Add("Emitters", emitter);
foreach (AttributeInfo attr in myObject.attributes.Values)
{
string attrType = attr.dataType;
string simCoreName = attr.name;
string scenConKey = convertSimCoreToScenCon(simCoreName);
if (currentScenConState.Parameters.ContainsKey(scenConKey))
{
switch (attrType)
{
case "StringType":
((AttributeCollectionValue)currentSimCoreState).attributes.Add(simCoreName, DataValueFactory.BuildString(Convert.ToString(currentScenConState.Parameters[scenConKey])));
break;/*ConvertString(Convert.ToString(currentScenConState.Parameters[scenConKey])*/
case "IntegerType":
((AttributeCollectionValue)currentSimCoreState).attributes.Add(simCoreName, DataValueFactory.BuildInteger(Convert.ToInt32(currentScenConState.Parameters[scenConKey])));
break;/*ConvertInteger(Convert.ToInt32(currentScenConState.Parameters[scenConKey])*/
case "DoubleType":
((AttributeCollectionValue)currentSimCoreState).attributes.Add(simCoreName, DataValueFactory.BuildDouble(Convert.ToDouble(currentScenConState.Parameters[scenConKey])));
break;/*ConvertDouble(Convert.ToDouble(currentScenConState.Parameters[scenConKey])*/
case "LocationType":
LocationType lt = currentScenConState.Parameters[scenConKey] as LocationType;
((AttributeCollectionValue)currentSimCoreState).attributes.Add(simCoreName, DataValueFactory.BuildLocation(lt.X, lt.Y, lt.Z, false));
break;/*ConvertLocation((LocationType)currentScenConState.Parameters[scenConKey])*/
case "VelocityType":
VelocityType vt = currentScenConState.Parameters[scenConKey] as VelocityType;
((AttributeCollectionValue)currentSimCoreState).attributes.Add(simCoreName, DataValueFactory.BuildVelocity(vt.VX, vt.VY, vt.VZ));
break;/*ConvertVelocity((VelocityType)currentScenConState.Parameters[scenConKey])*/
case "BooleanType":
if (currentScenConState.Parameters.ContainsKey(attr.name))
{
string booleanVal = currentScenConState.Parameters[attr.name].ToString();
bool value = false;
if (booleanVal == "true" || booleanVal == "True" || booleanVal == "TRUE")
{
value = true;
}
((AttributeCollectionValue)currentSimCoreState).attributes.Add(simCoreName, DataValueFactory.BuildBoolean(value));
}/*ConvertBoolean(value)*/
break;
case "StringListType":
((AttributeCollectionValue)currentSimCoreState).attributes.Add(simCoreName, DataValueFactory.BuildStringList((List<String>)currentScenConState.Parameters[scenConKey]));
break;
case "ClassificationDisplayRulesType":
((AttributeCollectionValue)currentSimCoreState).attributes.Add(simCoreName, (DataValue)currentScenConState.Parameters[scenConKey]);
break;
default:
break;
}
}
}
SimCoreStateTable.Add(kvp.Key, currentSimCoreState);
}
dv = new StateTableValue();
((StateTableValue)dv).states = SimCoreStateTable;
e["StateTable"] = dv;
((AttributeCollectionValue)e["Attributes"]).attributes.Add("OwnerID", DataValueFactory.BuildString(incoming.Owner));/*ConvertString( .Owner)*/
((AttributeCollectionValue)e["Attributes"]).attributes.Add("ClassName", DataValueFactory.BuildString(incoming.UnitBase));/*ConvertString(incoming.UnitBase)*/
server.PutEvent(e);
}
/// <summary>
/// This method takes in a capabilities list, and a docked weapons list, and quantifies the weapons and
/// combines those results with the capabilities list for a returned "CapabilitiesList", which the
/// client displays to its user.
/// </summary>
/// <param name="atts"></param>
private void AddCapabilitiesAndWeaponsList(ref AttributeCollectionValue atts)
{
List<string> capabilities = new List<string>();
Dictionary<string, int> weaponsAndQuantities = new Dictionary<string, int>();
string objectID = ((StringValue)atts["ID"]).value;
SimulationObjectProxy obj = objectProxies[objectID];
CapabilityValue cv;
if (atts.attributes.ContainsKey("Capability"))
{
cv = atts["Capability"] as CapabilityValue;
// atts.attributes.Remove("Capability");
}
else
{
cv = obj["Capability"].GetDataValue() as CapabilityValue;
}
foreach (CapabilityValue.Effect ef in ((CapabilityValue)cv).effects)
{
if (!capabilities.Contains(ef.name))
{
capabilities.Add(ef.name);
}
}
StringListValue sl;
SimulationObjectProxy wep;
string className;
if (atts.attributes.ContainsKey("DockedWeapons"))
{
sl = atts["DockedWeapons"] as StringListValue;
}
else
{
sl = obj["DockedWeapons"].GetDataValue() as StringListValue;
}
foreach (string weapon in sl.strings)
{
wep = objectProxies[weapon];
className = ((StringValue)wep["ClassName"].GetDataValue()).value;
if (!weaponsAndQuantities.ContainsKey(className))
{
weaponsAndQuantities.Add(className, 0);
}
weaponsAndQuantities[className]++;
}
List<string> CapabilitiesAndWeaponsList = new List<string>();
foreach (string c in capabilities)
{
CapabilitiesAndWeaponsList.Add(c);
}
foreach (string w in weaponsAndQuantities.Keys)
{
CapabilitiesAndWeaponsList.Add(String.Format("{0} ({1}x)", w, weaponsAndQuantities[w]));
}
DataValue retDV = DataValueFactory.BuildValue("StringListType");
((StringListValue)retDV).strings = CapabilitiesAndWeaponsList;
atts.attributes.Add("CapabilitiesList", retDV);
}
/// <summary>
/// When a move done event is received, then a normalizing ViewProMotionUpdate is sent out,
/// and that object is removed from the MovingObjects list. The VPMU that is sent out gives
/// a destination location that is equal to its current location, and a throttle of 0.
/// </summary>
/// <param name="e">Incoming event</param>
private void MoveDone(SimulationEvent e)
{
string id = ((StringValue)e["ObjectID"]).value;
double throttle = ((DoubleValue)objectProxies[id]["Throttle"].GetDataValue() as DoubleValue).value;
//LocationValue location = objectProxies[id]["DestinationLocation"].GetDataValue() as LocationValue;
LocationValue location = objectProxies[id]["Location"].GetDataValue() as LocationValue;
AttributeCollectionValue newACV = new AttributeCollectionValue();
newACV.attributes.Add("ObjectID", DataValueFactory.BuildString(id));
newACV.attributes.Add("Throttle", DataValueFactory.BuildDouble(throttle));
newACV.attributes.Add("Time", DataValueFactory.BuildInteger(currentTick));
newACV.attributes.Add("Location", location);
newACV.attributes.Add("DestinationLocation", location);
if (movingObjects.Contains(id))
{
movingObjects.Remove(id);
}
SendViewProStopObjectUpdate(id);
SendViewProMotionUpdate(newACV);
}
/// <summary>
/// When a weapon is launched, a ViewProInitializeObject event must be first sent out to its
/// owner, and then a ViewProMotionUpdate must be sent out. A weapon launch event only contains
/// an ObjectID (of weapon), a ParentObjectID (the object launching the weapon), and a
/// TargetObjectID (object being attacked by weapon. We'll need to extract the target's
/// location, the ParentObjectID's location for the initial Location, and the weapon's
/// MaximumSpeed and icon for the VPMU event. IsWeapon is set to true, and throttle is 1.
/// Other objects will become aware of this weapon on the next time tick when the sensing
/// algorithm occurs.
/// </summary>
/// <param name="e">Incoming event</param>
private void WeaponLaunch(SimulationEvent e)
{
string weaponID = ((StringValue)e["ObjectID"]).value;
string parentID = ((StringValue)e["ParentObjectID"]).value;
string targetID = ((StringValue)e["TargetObjectID"]).value;
string errorAt = "OwnerID";
string errorAtOwner = weaponID;
string ownerID;
string iconName;
LocationValue initialLocation;
LocationValue destinationLocation;
double throttle = 1;
double maxSpeed = 0.0;
bool isWeapon = true;
AttributeCollectionValue newACV = new AttributeCollectionValue();
newACV.attributes.Add("ObjectID", DataValueFactory.BuildString(weaponID));
newACV.attributes.Add("Throttle", DataValueFactory.BuildDouble(throttle));
newACV.attributes.Add("IsWeapon", DataValueFactory.BuildBoolean(isWeapon));
SimulationObjectProxy obj;
try
{
errorAtOwner = weaponID;
obj = objectProxies[weaponID];
errorAt = "OwnerID";
ownerID = ((StringValue)obj["OwnerID"].GetDataValue()).value;
newACV.attributes.Add("OwnerID", DataValueFactory.BuildString(ownerID));
errorAt = "IconName";
iconName = ((StringValue)obj["IconName"].GetDataValue()).value;
newACV.attributes.Add("IconName", DataValueFactory.BuildString(iconName));
errorAt = "MaximumSpeed";
maxSpeed = ((DoubleValue)obj["MaximumSpeed"].GetDataValue()).value;
newACV.attributes.Add("MaximumSpeed", DataValueFactory.BuildDouble(maxSpeed));
errorAtOwner = parentID;
obj = objectProxies[parentID];
errorAt = "Location";
initialLocation = obj["Location"].GetDataValue() as LocationValue;
newACV.attributes.Add("Location", initialLocation as DataValue);
errorAtOwner = targetID;
obj = objectProxies[targetID];
errorAt = "DestinationLocation";
destinationLocation = obj["Location"].GetDataValue() as LocationValue;
newACV.attributes.Add("DestinationLocation", destinationLocation as DataValue);
}
catch
{
throw new Exception(String.Format("Error in ViewPro: Error retrieving {0} attribute from the object {1}.", errorAt, errorAtOwner));
}
SendViewProInitializeObject(ownerID, weaponID, initialLocation, iconName, ownerID, true);
SendViewProMotionUpdate(newACV);
}
private void ActiveRegionSpeedMultiplierUpdate(SimulationEvent e)
{
AttributeCollectionValue atts;
atts = new AttributeCollectionValue();
string id = ((StringValue)e["ObjectID"]).value;
atts.attributes.Add("ObjectID", DataValueFactory.BuildString(id));
SendViewProStopObjectUpdate(id);
SendViewProMotionUpdate(atts);
}
/// <summary>
///
/// </summary>
/// <param name="e"></param>
private void GameSpeed(SimulationEvent e)
{
initialReplaySpeed = e;
AttributeCollectionValue atts;
List<string> myObjects = new List<string>(movingObjects);
foreach (string obID in myObjects)
{
atts = new AttributeCollectionValue();
atts.attributes.Add("ObjectID", DataValueFactory.BuildString(obID));
SendViewProStopObjectUpdate(obID);
SendViewProMotionUpdate(atts);
}
}
private void ForceUpdateObjectAttribute(SimulationEvent e)
{
//if location send location/movement update
string attributeName = ((StringValue)e["AttributeName"]).value;
DataValue val = ((WrapperValue)e["AttributeValue"]).value;
string objectID = ((StringValue)e["ObjectID"]).value;
if (!objectProxies.ContainsKey(objectID))
{
return;
}
if (attributeName == "Location")
{
LocationValue origLocation = objectProxies[objectID]["Location"].GetDataValue() as LocationValue;
LocationValue origDestination = objectProxies[objectID]["DestinationLocation"].GetDataValue() as LocationValue;
AttributeCollectionValue acv = new AttributeCollectionValue();
acv.attributes.Add(attributeName, val);
acv.attributes.Add("ObjectID", DataValueFactory.BuildString(objectID));
if (DataValueFactory.CompareDataValues(origDestination, origLocation))
{
acv.attributes.Add("DestinationLocation", val); // if object wasn't moving, keep it that way.
}
SendViewProMotionUpdate(acv);
}
return;
}
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;
}
}
/// <summary>
/// This method extracts an objects attributes from DetectedValues in an ACV, and then sends
/// out the appropriate info to a specified player.
/// </summary>
/// <param name="destinationPlayerID"></param>
/// <param name="objectsAttributes"></param>
/// <param name="time"></param>
private void SendViewProAttributeUpdate(string destinationPlayerID, AttributeCollectionValue objectsAttributes)
{
if (!activeDMs.Contains(destinationPlayerID))
return;
SimulationEvent vpu = null;
objectsAttributes = ExtractDetectedValuesFromACV(objectsAttributes);
AddCapabilitiesAndWeaponsList(ref objectsAttributes);
if (objectsAttributes.attributes.ContainsKey("Vulnerability"))
{
List<string> vulnerabilityList = new List<string>();
foreach (VulnerabilityValue.Transition t in ((VulnerabilityValue)objectsAttributes["Vulnerability"]).transitions)
{
foreach (VulnerabilityValue.TransitionCondition tc in t.conditions)
{
if (!vulnerabilityList.Contains(tc.capability))
{
vulnerabilityList.Add(tc.capability);
}
}
}
// objectsAttributes.attributes.Remove("Vulnerability");
StringListValue sl = new StringListValue();
sl.strings = vulnerabilityList;
objectsAttributes.attributes.Add("VulnerabilityList", sl as DataValue);
}
if (objectsAttributes.attributes.ContainsKey("Sensors"))
{
List<string> sensorList = new List<string>();
foreach (SensorValue sv in ((SensorArrayValue)objectsAttributes["Sensors"]).sensors)
{
if (!sensorList.Contains(sv.sensorName))
{
sensorList.Add(sv.sensorName);
}
}
// objectsAttributes.attributes.Remove("Sensors");
StringListValue sl = new StringListValue();
sl.strings = sensorList;
objectsAttributes.attributes.Add("SensorList", sl as DataValue);
}
objectsAttributes["DockedObjects"] = new StringListValue();
List<string> strList = new List<string>();
//if (((StringValue)objectProxies[((StringValue)objectsAttributes["ID"]).value]["ParentObjectID"].GetDataValue()).value != string.Empty)
//{
// strList.Add("Dock To Parent");
//}
strList.AddRange(((StringListValue)objectProxies[((StringValue)objectsAttributes["ID"]).value]["DockedObjects"].GetDataValue()).strings);
((StringListValue)objectsAttributes["DockedObjects"]).strings = strList;
vpu = SimulationEventFactory.BuildEvent(ref simModel, "ViewProAttributeUpdate");
if (!objectsAttributes.attributes.ContainsKey("MaximumSpeed"))
{
DoubleValue dv = new DoubleValue();
dv.value = ((DoubleValue)objectProxies[((StringValue)objectsAttributes["ID"]).value]["MaximumSpeed"].GetDataValue()).value *
((DoubleValue)objectProxies[((StringValue)objectsAttributes["ID"]).value]["ActiveRegionSpeedMultiplier"].GetDataValue()).value;
objectsAttributes.attributes.Add("MaximumSpeed", dv as DataValue);
}
String classification = GetClassificationForDM(((StringValue)objectsAttributes["ID"]).value, destinationPlayerID);
objectsAttributes["CurrentClassification"] = DataValueFactory.BuildString(classification);
String overrideIcon = GetClassificationBasedIcon(((StringValue)objectsAttributes["ID"]).value, classification);
if (overrideIcon != String.Empty)
{
objectsAttributes["IconName"] = DataValueFactory.BuildString(overrideIcon);
}
else
{
SimulationObjectProxy ob = objectProxies[((StringValue)objectsAttributes["ID"]).value];
objectsAttributes["IconName"] = DataValueFactory.BuildString(((StringValue)ob["IconName"].GetDataValue()).value);
}
vpu["TargetPlayer"] = DataValueFactory.BuildString(destinationPlayerID);
vpu["ObjectID"] = objectsAttributes["ID"];
vpu["OwnerID"] = objectsAttributes["OwnerID"];
//RANGE RING LOGIC
string ownerId = ((StringValue)objectsAttributes["OwnerID"]).value;
if (( (destinationPlayerID == ownerId || selectedRangeRingLevel == RangeRingLevels.FULL) ||
(selectedRangeRingLevel == RangeRingLevels.SENSORNETWORK && AreDecisionMakersInSharedNetwork(destinationPlayerID, ownerId)) ) &&
selectedRangeRingLevel != RangeRingLevels.DISABLED) //this needs to be based on ownership, etc.
{
SimulationObjectProxy objProxy = null;
if (objectProxies.ContainsKey(((StringValue)objectsAttributes["ID"]).value))
{
objProxy = objectProxies[((StringValue)objectsAttributes["ID"]).value];
AddRangeRings(ref objectsAttributes, ref objProxy);
}
else
{
//if not, something's wrong
Console.WriteLine("HELP");
}
}
else
{
objectsAttributes.attributes.Remove("Vulnerability");
objectsAttributes.attributes.Remove("Sensors");
objectsAttributes.attributes.Remove("Capability");
}
//
//if (objectsAttributes.attributes.ContainsKey("MaximumSpeed"))
//{
// Console.Out.Write(String.Format("{0} moving at {1}", ((StringValue)objectsAttributes["ID"]).value, ((DoubleValue)objectsAttributes["MaximumSpeed"]).value));
// //foreach (string s in objectsAttributes.attributes.Keys)
// //{
// // Console.Out.Write(String.Format("{0}, ", s));
// //}
// Console.Out.WriteLine();
//}
vpu["Attributes"] = objectsAttributes;
vpu["Time"] = DataValueFactory.BuildInteger(currentTick);
string xml = DataValueFactory.XMLSerialize(objectsAttributes);
AttributeCollectionValue temp = new AttributeCollectionValue();
temp.FromXML(xml);
distClient.PutEvent(vpu);
}
/// <summary>
/// Given a dictionary of [string, datavalue], a new DataValue is created, and assigned as an
/// Attribute Collection Value. This AttributeCollectionValue's attribute setting is set to the input
/// dictionary, and then the AttributeCollectionValue is returned as a DataValue.
/// </summary>
/// <param name="input">
/// A dictionary of [string, DataValue] to be assigned to an AttributeCollectionValue.
/// </param>
/// <returns></returns>
private static DataValue ConvertAttributeCollection(Dictionary<string, DataValue> input)
{//Replaced by method in DataValueFactory...
DataValue dv = new AttributeCollectionValue();
((AttributeCollectionValue)dv).attributes = input;
return dv;
}
private void SendViewProInitializeObject(string targetPlayerID, AttributeCollectionValue acv)
{
if (!activeDMs.Contains(targetPlayerID))
return;
string objectID = ((StringValue)acv["ID"]).value;
string ownerID;
string iconName;
SimulationObjectProxy objectProxy = objectProxies[objectID];
LocationValue location;
bool isWeapon = false;
AttributeCollectionValue playersView = new AttributeCollectionValue();
if (!dmViews.ContainsKey(targetPlayerID))
{
dmViews.Add(targetPlayerID, new Aptima.Asim.DDD.CommonComponents.ObjectsAttributeCollection.ObjectsAttributeCollection());
}
if (!dmViews[targetPlayerID].ContainsObject(objectID))
{
dmViews[targetPlayerID].UpdateObject(objectID, new AttributeCollectionValue());
}
playersView = dmViews[targetPlayerID][objectID];
if (acv.attributes.ContainsKey("Location"))
{
location = acv["Location"] as LocationValue;
}
else if (playersView.attributes.ContainsKey("Location"))
{
location = ((DetectedAttributeValue)playersView["Location"]).value as LocationValue;
}
else
{
location = objectProxy["Location"].GetDataValue() as LocationValue;
}
if (acv.attributes.ContainsKey("OwnerID"))
{
ownerID = ((StringValue)acv["OwnerID"]).value;
}
else if (playersView.attributes.ContainsKey("OwnerID"))
{
ownerID = ((StringValue)((DetectedAttributeValue)playersView["OwnerID"]).value).value;
}
else
{
ownerID = ((StringValue)objectProxy["OwnerID"].GetDataValue()).value;
}
if (acv.attributes.ContainsKey("IconName"))
{
iconName = ((StringValue)acv["IconName"]).value;
}
else if (playersView.attributes.ContainsKey("IconName"))
{
iconName = ((StringValue)((DetectedAttributeValue)playersView["IconName"]).value).value;
}
else
{
iconName = "ImageLib.Unknown.png";// ((StringValue)objectProxy["IconName"].GetDataValue()).value;
}
if (acv.attributes.ContainsKey("IsWeapon"))
{
isWeapon = ((BooleanValue)acv["IsWeapon"]).value;
}
else if (playersView.attributes.ContainsKey("IsWeapon"))
{
isWeapon = ((BooleanValue)((DetectedAttributeValue)playersView["IsWeapon"]).value).value;
}
else
{
isWeapon = ((BooleanValue)objectProxy["IsWeapon"].GetDataValue()).value;
}
SendViewProInitializeObject(targetPlayerID, objectID, location, iconName, ownerID, isWeapon);
}
/// <summary>
/// Takes an xml string, and returns a DataValue object.
/// Returns null if the xml doesn't represent a DataValue.
/// </summary>
/// <param name="xml"></param>
/// <returns></returns>
public static DataValue XMLDeserialize(string xml)
{
Match m = typeregex.Match(xml);
if (m.Success)
{
Group g = m.Groups[1];
string dataType = g.ToString();
switch (dataType)
{
case "StringType":
StringValue sv = new StringValue();
sv.FromXML(xml);
return sv;
case "DoubleType":
DoubleValue dv = new DoubleValue();
dv.FromXML(xml);
return dv;
case "IntegerType":
IntegerValue iv = new IntegerValue();
iv.FromXML(xml);
return iv;
case "BooleanType":
BooleanValue bv = new BooleanValue();
bv.FromXML(xml);
return bv;
case "LocationType":
LocationValue lv = new LocationValue();
lv.FromXML(xml);
return lv;
case "VelocityType":
VelocityValue vv = new VelocityValue();
vv.FromXML(xml);
return vv;
case "AttributeCollectionType":
AttributeCollectionValue av = new AttributeCollectionValue();
av.FromXML(xml);
return av;
case "CustomAttributesType":
CustomAttributesValue cav = new CustomAttributesValue();
cav.FromXML(xml);
return cav;
case "StringListType":
StringListValue slv = new StringListValue();
slv.FromXML(xml);
return slv;
case "PolygonType":
PolygonValue polyv = new PolygonValue();
polyv.FromXML(xml);
return polyv;
case "StateTableType":
StateTableValue stv = new StateTableValue();
stv.FromXML(xml);
return stv;
case "CapabilityType":
CapabilityValue cv = new CapabilityValue();
cv.FromXML(xml);
return cv;
case "VulnerabilityType":
VulnerabilityValue vv2 = new VulnerabilityValue();
vv2.FromXML(xml);
return vv2;
case "ConeType":
ConeValue cv2 = new ConeValue();
cv2.FromXML(xml);
return cv2;
case "SensorType":
SensorValue sv2 = new SensorValue();
sv2.FromXML(xml);
return sv2;
case "SensorArrayType":
SensorArrayValue sav = new SensorArrayValue();
sav.FromXML(xml);
return sav;
case "EmitterType":
EmitterValue ev = new EmitterValue();
ev.FromXML(xml);
return ev;
case "RangeRingDisplayType":
RangeRingDisplayValue rrdv = new RangeRingDisplayValue();
rrdv.FromXML(xml);
return rrdv;
case "AttackCollectionType":
AttackCollectionValue attCV = new AttackCollectionValue();
attCV.FromXML(xml);
return attCV;
case "WrapperType":
WrapperValue wrapper = new WrapperValue();
wrapper.FromXML(xml);
return wrapper;
case "ClassificationDisplayRulesType":
ClassificationDisplayRulesValue cdrv = new ClassificationDisplayRulesValue();
cdrv.FromXML(xml);
return cdrv;
default:
return null;
}
}
else
{
return null;
}
}
/// <summary>
/// When a pause event is received, foreach object in the movement list, a ViewProMotionUpdate
/// must be sent out with a throttle of 0 (all the rest of the values can remain the same from
/// an object proxy).
/// </summary>
private void PauseScenario()
{
AttributeCollectionValue tempACV = new AttributeCollectionValue();
tempACV.attributes.Add("Throttle", DataValueFactory.BuildDouble(0));
tempACV.attributes.Add("ObjectID", DataValueFactory.BuildString(string.Empty));
foreach (string objectID in movingObjects)
{
tempACV["ObjectID"] = DataValueFactory.BuildString(objectID);
SendViewProMotionUpdate(tempACV);
}
}
/// <summary>
/// Given an attribute collection containing DetectedValues, this method will strip the
/// detected value wrapper from the data values, and return the nested DV's. This will
/// NOT return any non-DetectedValue entries.
/// </summary>
/// <param name="ACV"></param>
/// <returns></returns>
private AttributeCollectionValue ExtractDetectedValuesFromACV(AttributeCollectionValue ACV)
{
AttributeCollectionValue returnACV = new AttributeCollectionValue();
foreach (KeyValuePair<string, DataValue> kvp in ACV.attributes)
{
if (kvp.Value is DetectedAttributeValue)
{
returnACV.attributes.Add(kvp.Key, ((DetectedAttributeValue)kvp.Value).value);
}
else if (!(kvp.Value is DetectedAttributeValue))
{
returnACV.attributes.Add(kvp.Key, kvp.Value);
}
}
return returnACV;
}
/// <summary>
/// This method retrieves all sensable attributes from the target proxy into the referenced attribute collection value.
/// </summary>
/// <param name="ACV">Current collection to add attributes into.</param>
/// <param name="targetProxy">SimulationProxy to retrieve attributes from.</param>
private void SenseAllAttributes(ref AttributeCollectionValue singleObjectACV, SimulationObjectProxy targetProxy)
{
//for the target object, go through each observable attribute, and add to the view with full confidence.
string targetObjectID = ((StringValue)targetProxy["ID"].GetDataValue()).value;
string objectType = targetProxy.GetObjectType();
DetectedAttributeValue dav;
List<string> keys = targetProxy.GetKeys();
foreach (string att in simModel.objectModel.objects[objectType].attributes.Keys)
{
if (simModel.objectModel.objects[objectType].attributes[att].otherObservable)
{
if (keys.Contains(att))
{
dav = new DetectedAttributeValue();
if (att == "CustomAttributes")
{
DataValue t = targetProxy[att].GetDataValue();
if (t.dataType == "CustomAttributesType")
{
Dictionary<string, DataValue> copiedDict = CopyFromCustomAttributes(((CustomAttributesValue)t).attributes);
t = new CustomAttributesValue();
((CustomAttributesValue)t).attributes = copiedDict;
}
dav = new DetectedAttributeValue();
dav.stdDev = 100;
dav.value = DataValueFactory.BuildFromDataValue(t);
//AddAttributeToACV(ref singleAttributeCollection, simModelAtt.Key, detectedAttribute);
}
else
{
dav.value = DataValueFactory.BuildFromDataValue(targetProxy[att].GetDataValue());
dav.stdDev = 100;
}
if (((AttributeCollectionValue)singleObjectACV).attributes.ContainsKey(att))
{
((AttributeCollectionValue)singleObjectACV)[att] = dav;
}
else
{
((AttributeCollectionValue)singleObjectACV).attributes.Add(att, dav);
}
}
}
}
}
/// <summary>
/// This event is broadcast out to each client. The client will attempt to put the object in motion, but
/// will only succeed if the object already exists in its playfield.
/// </summary>
/// <param name="attributes">This is a collection of object attributes. If any necessary attributes for
/// a ViewProMotionUpdate are missing from this collection, the appropriate attribute values will be
/// retrieved from that object's blackboard proxy.</param>
private void SendViewProMotionUpdate(AttributeCollectionValue attributes)
{
string objectID = ((StringValue)attributes["ObjectID"]).value;
string ownerID;
string iconName;
SimulationObjectProxy objectProxy = objectProxies[objectID];
LocationValue location;
LocationValue destLocation;
double maxSpeed;
double throttle;
bool isWeapon = false;
double activeRegionSpeedMultiplier;
activeRegionSpeedMultiplier = ((DoubleValue)objectProxy["ActiveRegionSpeedMultiplier"].GetDataValue()).value;
if (attributes.attributes.ContainsKey("Location"))
{
location = attributes["Location"] as LocationValue;
}
else
{
location = objectProxy["Location"].GetDataValue() as LocationValue;
}
if (attributes.attributes.ContainsKey("DestinationLocation"))
{
destLocation = attributes["DestinationLocation"] as LocationValue;
}
else
{
destLocation = objectProxy["DestinationLocation"].GetDataValue() as LocationValue;
}
if (attributes.attributes.ContainsKey("OwnerID"))
{
ownerID = ((StringValue)attributes["OwnerID"]).value;
}
else
{
ownerID = ((StringValue)objectProxy["OwnerID"].GetDataValue()).value;
}
if (attributes.attributes.ContainsKey("MaximumSpeed"))
{
maxSpeed = ((DoubleValue)attributes["MaximumSpeed"]).value;
}
else
{
maxSpeed = ((DoubleValue)objectProxy["MaximumSpeed"].GetDataValue()).value;
}
if (attributes.attributes.ContainsKey("Throttle"))
{
throttle = ((DoubleValue)attributes["Throttle"]).value;
}
else
{
throttle = ((DoubleValue)objectProxy["Throttle"].GetDataValue()).value;
}
if (attributes.attributes.ContainsKey("IconName"))
{
iconName = ((StringValue)attributes["IconName"]).value;
}
else
{
iconName = ((StringValue)objectProxy["IconName"].GetDataValue()).value;
}
if (attributes.attributes.ContainsKey("IsWeapon"))
{
isWeapon = ((BooleanValue)attributes["IsWeapon"]).value;
}
else
{
isWeapon = ((BooleanValue)objectProxy["IsWeapon"].GetDataValue()).value;
}
SendViewProMotionUpdate(objectID, ownerID, location, destLocation, maxSpeed, throttle, iconName, isWeapon, activeRegionSpeedMultiplier);
}
/// <summary>
///
/// </summary>
/// <param name="allObjectViews"></param>
private void SenseAllObjects(ref Dictionary<string, Dictionary<string, AttributeCollectionValue>> allObjectsViews)
{
SimulationObjectProxy sensingProxy = null;
SimulationObjectProxy targetProxy = null;
Vec3D sensingLocation = null;
Vec3D targetsLocation = null;
LocationValue senLocation = null;
LocationValue tarLocation = null;
double distance = 0.0;
SensorArrayValue sav = null;
DataValue targetsAttribute = null;
string ownerID = null;
string objectType = null;
DetectedAttributeValue detectedAttribute;
AttributeCollectionValue singleAttributeCollection = null;
bool isSensed = false;
// The dictionary is constantly created in this method //
Dictionary<string, AttributeCollectionValue> singleObjectView;
//AD to improve this later:
// for each object in the visible ObjectDistances collection
// for each object after the current index
// check for the index object's view of the nested object
// check for the nested object's view of the index object
//Possible hangup is the "All" emitter.
int x = 0;
//Each object senses each other object
//foreach (string sensorObjectID in listOfObjectIDs)
foreach (KeyValuePair<string, List<string>> networks in networkRosters)
{
if (!activeSensorNetworks[networks.Key])
continue;
foreach (string sensorObjectID in networkObjects[networks.Key])
{
sensingProxy = objectProxies[sensorObjectID];
objectType = sensingProxy.GetObjectType();
senLocation = sensingProxy["Location"].GetDataValue() as LocationValue;
if (senLocation.exists)
{
ownerID = ((StringValue)sensingProxy["OwnerID"].GetDataValue()).value;
singleObjectView = new Dictionary<string, AttributeCollectionValue>();
x++;
//foreach (string targetObjectID in listOfObjectIDs)
foreach (List<string> objects in networkObjects.Values)
{
if (objects.Contains(sensorObjectID))
{
if (((EmitterValue)sensingProxy["Emitters"].GetDataValue()).emitters.ContainsKey("Invisible"))
{
continue;
}
string target = sensorObjectID;
singleAttributeCollection = new AttributeCollectionValue();
foreach (KeyValuePair<string, AttributeInfo> simModelAtt in simModel.objectModel.objects[objectType].attributes)
{
if (!simModelAtt.Value.ownerObservable == true)
continue;
//if (!sensingProxy.GetKeys().Contains(simModelAtt.Key))
// continue;
DataValue t = sensingProxy[simModelAtt.Key].GetDataValue();
if (t.dataType == "CustomAttributesType")
{
Dictionary<string, DataValue> copiedDict = CopyFromCustomAttributes(((CustomAttributesValue)t).attributes);
t = new CustomAttributesValue();
((CustomAttributesValue)t).attributes = copiedDict;
}
detectedAttribute = new DetectedAttributeValue();
detectedAttribute.stdDev = 100;
detectedAttribute.value = DataValueFactory.BuildFromDataValue(t);
AddAttributeToACV(ref singleAttributeCollection, simModelAtt.Key, detectedAttribute);
}//end foreach sensable attribute
if (!allObjectsViews.ContainsKey(sensorObjectID))
{
allObjectsViews.Add(sensorObjectID, new Dictionary<string, AttributeCollectionValue>());
}
if (!objectViews.ContainsKey(sensorObjectID))
{
objectViews.Add(sensorObjectID, new ObjectsAttributeCollection());
}
//update the global "allObjectViews". The return from UpdateObject is the collection of attributes
//that have changed. These attributes are stored in allObjectsViews and then sent out
//to users.
AttributeCollectionValue changedAttributes = objectViews[sensorObjectID].UpdateObject(target, singleAttributeCollection);
//if (changedAttributes != null && selectedRangeRingLevel != RangeRingLevels.DISABLED)
//{
// CalculateRangeRings(ref changedAttributes, ref sensingProxy);
//}
if (changedAttributes != null)
{
allObjectsViews[sensorObjectID].Add(target, changedAttributes);
}
else//this is so there is at least the empty entry for the detected object so
//you still know it is detected.
{
if (!allObjectsViews[sensorObjectID].ContainsKey(target))
{
allObjectsViews[sensorObjectID].Add(target, new AttributeCollectionValue());
}
}
}
else
{
foreach (string targetObjectID in objects)
{//sensing and target objects are not the same
targetProxy = objectProxies[targetObjectID];
tarLocation = targetProxy["Location"].GetDataValue() as LocationValue;
if (tarLocation.exists)
{
EmitterValue emitters = targetProxy["Emitters"].GetDataValue() as EmitterValue;
if (emitters.emitters.ContainsKey("All"))
{
//if an object has an all emitter, retrieve all attributes without sensing algorithm
AttributeCollectionValue atts = new AttributeCollectionValue();
if (singleObjectView.ContainsKey(targetObjectID))
{
atts = singleObjectView[targetObjectID];
}
SenseAllAttributes(ref atts, targetProxy);
singleObjectView[targetObjectID] = atts;
isSensed = true;
if (!allObjectsViews.ContainsKey(sensorObjectID))
{
allObjectsViews.Add(sensorObjectID, new Dictionary<string, AttributeCollectionValue>());
}
if (!objectViews.ContainsKey(sensorObjectID))
{
objectViews.Add(sensorObjectID, new ObjectsAttributeCollection());
}
//update the global "allObjectViews". The return from UpdateObject is the collection of attributes
//that have changed. These attributes are stored in allObjectsViews and then sent out
//to users.
AttributeCollectionValue changedAttributes = objectViews[sensorObjectID].UpdateObject(targetObjectID, atts);
//if (changedAttributes != null && selectedRangeRingLevel == RangeRingLevels.FULL)
//{//the only way to sense a "target" here is for FULL ring display
// CalculateRangeRings(ref changedAttributes, ref targetProxy);
//}
if (changedAttributes != null)
{
allObjectsViews[sensorObjectID].Add(targetObjectID, changedAttributes);
}
else//this is so there is at least the empty entry for the detected object so
//you still know it is detected.
{
if (!allObjectsViews[sensorObjectID].ContainsKey(targetObjectID))
{
allObjectsViews[sensorObjectID].Add(targetObjectID, new AttributeCollectionValue());
}
}
}
else if (emitters.emitters.ContainsKey("Invisible"))
{
continue;
}
else
{//object does not have an all emitter, continue to check each emitter value
AttributeCollectionValue atts = new AttributeCollectionValue();
if (Omniscience)
{
if (singleObjectView.ContainsKey(targetObjectID))
{
atts = singleObjectView[targetObjectID];
}
SenseAllAttributes(ref atts, targetProxy);
singleObjectView[targetObjectID] = atts;
isSensed = true;
if (!allObjectsViews.ContainsKey(sensorObjectID))
{
allObjectsViews.Add(sensorObjectID, new Dictionary<string, AttributeCollectionValue>());
}
if (!objectViews.ContainsKey(sensorObjectID))
{
objectViews.Add(sensorObjectID, new ObjectsAttributeCollection());
}
//update the global "allObjectViews". The return from UpdateObject is the collection of attributes
//that have changed. These attributes are stored in allObjectsViews and then sent out
//to users.
AttributeCollectionValue changedAttributes = objectViews[sensorObjectID].UpdateObject(targetObjectID, atts);
//if (changedAttributes != null && selectedRangeRingLevel == RangeRingLevels.FULL)
//{//the only way to sense a "target" here is for FULL ring display
// CalculateRangeRings(ref changedAttributes, ref targetProxy);
//}
if (changedAttributes != null)
{
allObjectsViews[sensorObjectID].Add(targetObjectID, changedAttributes);
}
else//this is so there is at least the empty entry for the detected object so
//you still know it is detected.
{
if (!allObjectsViews[sensorObjectID].ContainsKey(targetObjectID))
{
allObjectsViews[sensorObjectID].Add(targetObjectID, new AttributeCollectionValue());
}
}
continue;
}
sensingLocation = new Vec3D(senLocation);
targetsLocation = new Vec3D(tarLocation);
isSensed = false;
distance = sensingLocation.ScalerDistanceTo(targetsLocation);
sav = sensingProxy["Sensors"].GetDataValue() as SensorArrayValue;
foreach (SensorValue sv in sav.sensors)
{
if (distance < sv.maxRange)
{
//Find obstructions
List<SimulationObjectProxy> obstructions = FindObstructions(sensingLocation, targetsLocation);
foreach (KeyValuePair<string, List<ConeValue>> kvp in sv.ranges)
{ //Key is the attribute being sensed, value is a list of cones
if (kvp.Key == "All")
{
atts = new AttributeCollectionValue();
if (singleObjectView.ContainsKey(targetObjectID))
{
atts = singleObjectView[targetObjectID];
}
SenseAllAttributes(ref atts, targetProxy);
singleObjectView[targetObjectID] = atts;
isSensed = true;
}
else //not an All sensor, so run detection algorithm
{//Added in main-line
if (!emitters.emitters.ContainsKey(kvp.Key))
{
continue;
}
//Custom attributes fix:
DataValue currentDataValue;
try
{
currentDataValue = targetProxy[kvp.Key].GetDataValue();
}
catch
{
currentDataValue = targetProxy["CustomAttributes"].GetDataValue();
currentDataValue = ((CustomAttributesValue)currentDataValue)[kvp.Key];
//will throw an error here if object doesn't contain custom atts, or
//if it doesnt contain the specified custom att.
}
bool isObstructed = false;
foreach (SimulationObjectProxy reg in obstructions)
{
foreach (string attributeBlocked in ((StringListValue)reg["BlocksSensorTypes"].GetDataValue()).strings)
{
if (kvp.Key == attributeBlocked)
{
isObstructed = true;
}
}
}
if (isObstructed)
{
detectedAttribute = new DetectedAttributeValue();
detectedAttribute.value = DataValueFactory.BuildValue(currentDataValue.dataType);
detectedAttribute.confidence = 0;
//continue;
}
else
{
targetsAttribute = DataValueFactory.BuildFromDataValue(currentDataValue);
//ev is emitters
Dictionary<string, double> emitterCollection = emitters.emitters[kvp.Key];
detectedAttribute = new DetectedAttributeValue();
detectedAttribute = ObjectMath.Detection(senLocation, tarLocation, targetsAttribute, kvp.Value, emitterCollection, obstructions, ref randomGenerator);
}
if (detectedAttribute != null)
{
singleAttributeCollection = new AttributeCollectionValue();
if (singleObjectView.ContainsKey(targetObjectID))
{
singleAttributeCollection = singleObjectView[targetObjectID];
}
AddAttributeToACV(ref singleAttributeCollection, kvp.Key, detectedAttribute);
isSensed = true;
}
}
}//end foreach attribute in sensor
//if the object has any attributes sensed, fill in some other info for the object's view.
if (isSensed)
{
detectedAttribute = new DetectedAttributeValue();
detectedAttribute.stdDev = 100;
detectedAttribute.value = targetProxy["ID"].GetDataValue();
if (singleAttributeCollection == null)
{
singleAttributeCollection = new AttributeCollectionValue();
}
if (!singleObjectView.ContainsKey(targetObjectID))
{
singleObjectView.Add(targetObjectID, singleAttributeCollection);
}
singleAttributeCollection = singleObjectView[targetObjectID];
AddAttributeToACV(ref singleAttributeCollection, "ID", detectedAttribute);
detectedAttribute = new DetectedAttributeValue();
detectedAttribute.stdDev = 100;
detectedAttribute.value = targetProxy["OwnerID"].GetDataValue();
AddAttributeToACV(ref singleAttributeCollection, "OwnerID", detectedAttribute);
}//end if isSensed.
}
}//end foreach sensor in sensor array
if (singleObjectView.ContainsKey(targetObjectID))
{
AttributeCollectionValue attr = singleObjectView[targetObjectID];
if (!allObjectsViews.ContainsKey(sensorObjectID))
{
allObjectsViews.Add(sensorObjectID, new Dictionary<string, AttributeCollectionValue>());
}
if (!objectViews.ContainsKey(sensorObjectID))
{
objectViews.Add(sensorObjectID, new ObjectsAttributeCollection());
}
if (attr.attributes.ContainsKey("CustomAttributes"))
{
DataValue t = ((DetectedAttributeValue)attr["CustomAttributes"]).value;
double conf = ((DetectedAttributeValue)attr["CustomAttributes"]).confidence;
Dictionary<string, DataValue> copiedDict = CopyFromCustomAttributes(((CustomAttributesValue)t).attributes);
t = new CustomAttributesValue();
((CustomAttributesValue)t).attributes = copiedDict;
attr.attributes.Remove("CustomAttributes");
attr.attributes.Add("CustomAttributes", DataValueFactory.BuildDetectedValue(t, Convert.ToInt32(conf)));
}
//update the global "allObjectViews". The return from UpdateObject is the collection of attributes
//that have changed. These attributes are stored in allObjectsViews and then sent out
//to users.
AttributeCollectionValue changedAttributes = objectViews[sensorObjectID].UpdateObject(targetObjectID, attr);
//if (changedAttributes != null && selectedRangeRingLevel == RangeRingLevels.FULL)
//{//the only way to sense a "target" here is for FULL ring display
// CalculateRangeRings(ref changedAttributes, ref targetProxy);
//}
if (changedAttributes != null)
{
allObjectsViews[sensorObjectID].Add(targetObjectID, changedAttributes);
}
else//this is so there is at least the empty entry for the detected object so
//you still know it is detected.
{
if (!allObjectsViews[sensorObjectID].ContainsKey(targetObjectID))
{
allObjectsViews[sensorObjectID].Add(targetObjectID, new AttributeCollectionValue());
}
}
}
else
{
if (objectViews.ContainsKey(sensorObjectID))
{
if (objectViews[sensorObjectID].ContainsObject(targetObjectID))
{
objectViews[sensorObjectID].RemoveObject(targetObjectID);
//if you once knew of this object, and now don't, remove it from object's view.
}
}
}
}//end emitter detection
}//end if target is visible
}
}
}//end foreach target object
}//end if sensor is visible
}//end of foreach sensing object
}//end of Foreach sensor network
//if (x > 0)
// Console.Out.WriteLine("ViewPro: {0} objects were sensing at time {1}.", x, currentTick / 1000);
}
private void AttackSucceeded(SimulationEvent e)
{
if (objectProxies.Count == 0)
return; //another weird edge case
try
{
String objectID = ((StringValue)e["ObjectID"]).value;
SimulationObjectProxy proxy = objectProxies[objectID];
String targetID = ((StringValue)e["TargetID"]).value;
SimulationObjectProxy targetProxy = objectProxies[targetID];
String transitionState = ((StringValue)e["NewState"]).value;
// It's a sea vessel if it's not a BAMS or Firescout
String targetClassName = ((StringValue)targetProxy["ClassName"].GetDataValue()).value;
if (targetClassName != "BAMS" && targetClassName != "Firescout" && transitionState == "Dead")
{
targetProxy["DestroyedTime"].SetDataValue(DataValueFactory.BuildInteger(time));
targetProxy["DestroyedBy"].SetDataValue(DataValueFactory.BuildString(objectID));
//AD: TODO Send view pro attribute event for these objects.
SimulationEvent ev = SimulationEventFactory.BuildEvent(ref simModel, "ViewProAttributeUpdate");
AttributeCollectionValue acv = new AttributeCollectionValue();
// acv.attributes.Add("DestroyedTime", DataValueFactory.BuildDetectedValue(DataValueFactory.BuildInteger(time), 100));
// acv.attributes.Add("DestroyedBy", DataValueFactory.BuildDetectedValue(DataValueFactory.BuildString(objectID), 100));
acv.attributes.Add("DestroyedTime", DataValueFactory.BuildInteger(time));
acv.attributes.Add("DestroyedBy", DataValueFactory.BuildString(objectID));
((StringValue)ev["TargetPlayer"]).value = "BAMS DM";
((StringValue)ev["ObjectID"]).value = ((StringValue)targetProxy["ID"].GetDataValue()).value;
((StringValue)ev["OwnerID"]).value = ((StringValue)targetProxy["OwnerID"].GetDataValue()).value;
((IntegerValue)ev["Time"]).value = time*1000;
ev["Attributes"] = acv;
distClient.PutEvent(ev);
((StringValue)ev["TargetPlayer"]).value = "Firescout DM";
distClient.PutEvent(ev);
((StringValue)ev["TargetPlayer"]).value = "Individual DM";
distClient.PutEvent(ev);
}
String targetOwnerID = ((StringValue)targetProxy["OwnerID"].GetDataValue()).value;
String attackerOwnerID = ((StringValue)proxy["OwnerID"].GetDataValue()).value;
if (transitionState == "Dead")
{
//Clear the intent of any other vessel mentioned in target's intent (pursued or pursuee).
String targetIntent = ((StringValue)targetProxy["Intent"].GetDataValue()).value;
if (targetIntent != "")
{
String[] intentArray = targetIntent.Split(":".ToCharArray());
if (intentArray.Length >1) {
SimulationObjectProxy vesselProxyToClear = objectProxies[intentArray[1]];
vesselProxyToClear["Intent"].SetDataValue(DataValueFactory.BuildString(""));
}
}
//IF friendly, increment counter
if (!targetOwnerID.ToLower().Contains("pirate"))
{
IncrementFriendliesLost(1);
String attackClassName = ((StringValue)proxy["ClassName"].GetDataValue()).value;
if (attackClassName == "BAMS" || attackClassName == "Firescout")
{
//IF friendly, and attacker was BAMS/FS
IncrementFriendliesDestroyedByPlayers(1);
}
}
else
{
//if hostile increment counter
IncrementHostileTargetsDestroyed(1);
}
}
//if (targetClassName == "BAMS" || targetClassName == "Firescout")
//{
// //if bams/firescout, increment counter
// IncrementHitsTakenByAssets(1);
//}
if (!attackerOwnerID.Contains("BAMS") && !attackerOwnerID.Contains("Firescout") && !attackerOwnerID.Contains("Individual"))
return; //the following section is only for YOUR attacks, so return if its not BAMS or FS
String attackClass = ((StringValue)proxy["ClassName"].GetDataValue()).value;
String targetClassification = "";
try
{
targetClassification = classifications[targetID];
}
catch (Exception exc)
{ }
if (targetClassification != "Hostile" && (targetClassName != "BAMS" || targetClassName != "Firescout"))
{
//if asset was not classified as hostile, violated ROE
IncrementRulesOfEngagementViolations(1);
}
}
catch (Exception ex)
{
}
}
/// <summary>
/// Called by the GUI, updates attributes for a specified object without returning a new ACV, or
/// creating more memory objects.
/// </summary>
/// <param name="ACV"></param>
/// <param name="objectID"></param>
public void UpdateObjectsAttributes(ref AttributeCollectionValue ACV, string objectID)
{
if (!objectsList.ContainsKey(objectID))
{
objectsList.Add(objectID, new AttributeCollectionValue());
}
foreach (KeyValuePair<string, DataValue> kvp in ACV.attributes)
{
if (objectsList[objectID].attributes.ContainsKey(kvp.Key))
{//this object already contains the attribute
objectsList[objectID][kvp.Key] = ACV[kvp.Key];
}
else
{ //this object does not already contain the attribute
objectsList[objectID].attributes.Add(kvp.Key, kvp.Value);
}
}
}
