public void GetOrderedEffectsByCapabilityTest()
{
CapabilityValue target = new CapabilityValue(); // TODO: Initialize to an appropriate value
CapabilityValue.Effect ef = new CapabilityValue.Effect("Capability1", 1000.0, 10, 1);
target.effects.Add(ef);
ef = new CapabilityValue.Effect("Capability2", 2000.0, 20, 1);
target.effects.Add(ef);
ef = new CapabilityValue.Effect("Capability1", 2000.0, 20, 1);
target.effects.Add(ef);
ef = new CapabilityValue.Effect("Capability1", 500.0, 5, 0.5);
target.effects.Add(ef);
ef = new CapabilityValue.Effect("Capability2", 555.0, 6, 0.6);
target.effects.Add(ef);
ef = new CapabilityValue.Effect("Capability1", 5000.0, 50, 1);
target.effects.Add(ef);
//this shows that the function returns the correctly ordered list for Capability1
List<CapabilityValue.Effect> actual;
actual = target.GetOrderedEffectsByCapability("Capability1");
Assert.AreEqual(actual.Count, 4);
Assert.AreEqual(actual[0].range, 500.0);
Assert.AreEqual(actual[1].range, 1000.0);
Assert.AreEqual(actual[0].intensity, 5);
Assert.AreEqual(actual[1].intensity, 10);
//this shows that the function returns the correctly ordered list for Capability2
actual = target.GetOrderedEffectsByCapability("Capability2");
Assert.AreEqual(actual.Count, 2);
Assert.AreEqual(actual[0].range, 555.0);
Assert.AreEqual(actual[1].range, 2000.0);
Assert.AreEqual(actual[0].intensity, 6);
Assert.AreEqual(actual[1].intensity, 20);
//this shows that removal from the returned list doesn't affect the structure of the internal list.
actual.RemoveAt(1);
actual = target.effects;
Assert.AreEqual(actual.Count, 6);
Assert.AreEqual(actual[0].range, 1000.0);
Assert.AreEqual(actual[1].range, 2000.0);
Assert.AreEqual(actual[0].intensity, 10);
Assert.AreEqual(actual[1].intensity, 20);
}
/*
static public void SkipToReset(ref List<SimulationEvent> eventList)
{
bool resetFound = false;
foreach (SimulationEvent e in eventList)
{
if (e.eventType == "ResetSimulation")
{
resetFound = true;
}
}
if (resetFound)
{
while (eventList.Count > 0 && eventList[0].eventType != "ResetSimulation")
{
eventList.Remove(eventList[0]);
}
}
}
*/
static public CapabilityValue.Effect FindCapabilityEffect(CapabilityValue cap, VulnerabilityValue vuln)
{
List<string> vulnNames = new List<string>();
foreach (VulnerabilityValue.Transition t in vuln.transitions)
{
foreach (VulnerabilityValue.TransitionCondition tc in t.conditions)
{
if (!vulnNames.Contains(tc.capability))
{
vulnNames.Add(tc.capability);
}
}
}
foreach (CapabilityValue.Effect e in cap.effects)
{
if (vulnNames.Contains(e.name))
{
return e;
}
}
return null;
}
/// <summary>
/// Sends an event to the server which updates a single object's Capability object.
/// This is a complicated data structure. It contains a series of lists, whose values are related.
/// These lists contain a series of Capabilities, Ranges, Intensities, and Probabilities. The index of each of these
/// collections should correlate such that Capabilities[1], Ranges[1], Intensities[1] and Probabilities[1] are all
/// for a single capability. As these are TIGHTLY correlated, you cannot skip inserting any values into this collection.
/// </summary>
/// <param name="objectID">The object's ID</param>
/// <param name="capabilities">The value list index relates to the other List collections passed in as parameters.</param>
/// <param name="ranges">The value list index relates to the other List collections passed in as parameters.</param>
/// <param name="intensities">The value list index relates to the other List collections passed in as parameters.</param>
/// <param name="probabilities">The value list index relates to the other List collections passed in as parameters.</param>
public void UpdateObjectCapabilities(String objectID, List<String> capabilities, List<Double> ranges, List<int> intensities, List<Double> probabilities)
{
CapabilityValue dv = new CapabilityValue();
//construct list of CapName/Range/Intensity/Probability
if ((capabilities.Count == ranges.Count) && (ranges.Count == intensities.Count) && (intensities.Count == probabilities.Count))
{
for (int x = 0; x < capabilities.Count; x++)
{
CapabilityValue.Effect ef = new CapabilityValue.Effect(capabilities[x], ranges[x], intensities[x], probabilities[x]);
dv.effects.Add(ef);
}
SendObjectAttributeUpdateEvent(objectID, "Capability", dv);
}
else
{
Console.WriteLine("In UpdateObjectCapabilities: Lists of Capabilities, Ranges, Intensities and Probabilities have different counts, no event sent");
}
}
/// <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;
}
}
private void ChangeObjectCapability(CapabilityValue newCapabilitySet, string objectID)
{
SimulationObjectProxy obj = objectProxies[objectID];
if (obj == null)
return;
CapabilityValue previousCapabilityValue = obj["Capability"].GetDataValue() as CapabilityValue;
List<string> previousCapabilityNames = previousCapabilityValue.GetCapabilityNames();
List<string> newCapabilityNames = newCapabilitySet.GetCapabilityNames();
List<string> missingCapabilities = new List<string>();
foreach (string capName in previousCapabilityNames)
{
if (!newCapabilityNames.Contains(capName))
{
if (!missingCapabilities.Contains(capName))
{
missingCapabilities.Add(capName);
}
}
}
foreach (string capName in missingCapabilities)
{
CancelCapabilityAttack(capName, objectID);
}
obj["Capability"].SetDataValue(newCapabilitySet);
missingCapabilities.Clear();
newCapabilityNames.Clear();
previousCapabilityNames.Clear();
}
public void TestAttackProcessorSimAttackObjectLogic()
{
//SETUP
CapabilityValue target = new CapabilityValue();
CapabilityValue.Effect ef = new CapabilityValue.Effect("Capability1", 1000.0, 10, 1);
target.effects.Add(ef);
ef = new CapabilityValue.Effect("Capability2", 2000.0, 20, 1);
target.effects.Add(ef);
ef = new CapabilityValue.Effect("Capability1", 2000.0, 20, 1);
target.effects.Add(ef);
ef = new CapabilityValue.Effect("Capability1", 500.0, 5, 0.5);
target.effects.Add(ef);
ef = new CapabilityValue.Effect("Capability2", 555.0, 6, 0.6);
target.effects.Add(ef);
ef = new CapabilityValue.Effect("Capability1", 5000.0, 50, 1);
target.effects.Add(ef);
double[] ranges = { 200.0, 800.0, 1500.0, 5000.0 };
int[] expectedIntensities = { 5, 10, 20, 50 };
//TEST
for (int x = 0; x < ranges.Length; x++)//double distance in ranges)
{
List<CapabilityValue.Effect> capabilities = target.GetOrderedEffectsByCapability("Capability1");
bool testComplete = false;
foreach (CapabilityValue.Effect eff in capabilities)
{
if (eff.name == "Capability1" && ranges[x] <= eff.range)
{
//int r = random.Next(0, 100);
//if (r <= ((int)(eff.probability * 100)))
//{
//appliedIntensity = (int)(eff.intensity * newAttack.percentageApplied / 100);
//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.
Assert.AreEqual(eff.intensity, expectedIntensities[x]);
testComplete = true;
break; //break because we only want to apply the first range found that satisfied the distance restraint
}
}
Assert.IsTrue(testComplete, System.String.Format("Incorrect value when testing for range {0}", ranges[x]));
}
List<CapabilityValue.Effect> capability = target.GetOrderedEffectsByCapability("Capability1");
bool testCompleted = false;
foreach (CapabilityValue.Effect eff in capability)
{
if (eff.name == "Capability1" && 6000 <= eff.range)
{
//int r = random.Next(0, 100);
//if (r <= ((int)(eff.probability * 100)))
//{
//appliedIntensity = (int)(eff.intensity * newAttack.percentageApplied / 100);
//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.
testCompleted = true;
break; //break because we only want to apply the first range found that satisfied the distance restraint
}
}
Assert.IsFalse(testCompleted, System.String.Format("Incorrect value when testing for range {0}", 6000));
}
/// <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);
}
