/* 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 Vulnerability object. /// This is a very complicated data structure. It contains a list of states to transition to. /// The index of these states should be used to index into the dictionaries for Capabilities, Ranges, Intensities, and Probabilities. /// Within each state, there are 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 transition. 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="states">Simple list of state names to transition to</param> /// <param name="capabilities">Dictionary whose index is related to the index of it's corresponding state. The value list index relates to the other Dictionary/List collections passed in as parameters.</param> /// <param name="ranges">Dictionary whose index is related to the index of it's corresponding state. The value list index relates to the other Dictionary/List collections passed in as parameters.</param> /// <param name="intensities">Dictionary whose index is related to the index of it's corresponding state. The value list index relates to the other Dictionary/List collections passed in as parameters.</param> /// <param name="probabilities">Dictionary whose index is related to the index of it's corresponding state. The value list index relates to the other Dictionary/List collections passed in as parameters.</param> public void UpdateObjectVulnerabilities(String objectID, List<String> states, Dictionary<int, List<String>> capabilities, Dictionary<int, List<Double>> ranges, Dictionary<int, List<int>> intensities, Dictionary<int, List<Double>> probabilities) { VulnerabilityValue dv = new VulnerabilityValue(); //construct list of conditions -> CapName/Range/Effect/Probability; //conditions map to a state to change to. state index in "states" corresponds to key of dictionary in other dictionaries try { for (int x = 0; x < states.Count; x++) { if ((capabilities[x].Count == ranges[x].Count) && (ranges[x].Count == intensities[x].Count) && (intensities[x].Count == probabilities[x].Count)) { VulnerabilityValue.Transition tr = new VulnerabilityValue.Transition(states[x]); for (int y = 0; y < capabilities[x].Count; y++) { VulnerabilityValue.TransitionCondition tc = new VulnerabilityValue.TransitionCondition(capabilities[x][y], intensities[x][y], ranges[x][y], probabilities[x][y]); tr.conditions.Add(tc); } if (tr.conditions.Count > 0) { dv.transitions.Add(tr); } } else { Console.WriteLine("In UpdateObjectVulnerabilities: Lists of Capabilities, Ranges, Intensities and Probabilities for state "+states[x]+" have different counts"); } } } catch (Exception e) { return; } if(dv.transitions.Count > 0) SendObjectAttributeUpdateEvent(objectID, "Vulnerability", dv); }
private void ChangeObjectVulnerability(VulnerabilityValue newVulnerabilitySet, string objectID) { SimulationObjectProxy obj = objectProxies[objectID]; if (obj == null) return; VulnerabilityValue previousVulnerabilityValue = obj["Vulnerability"].GetDataValue() as VulnerabilityValue; List<string> previousVulnerabilityNames = new List<string>(); foreach (VulnerabilityValue.Transition tr in previousVulnerabilityValue.transitions) { foreach (VulnerabilityValue.TransitionCondition tc in tr.conditions) { if (!previousVulnerabilityNames.Contains(tc.capability)) { previousVulnerabilityNames.Add(tc.capability); } } } List<string> newVulnerabilityNames = new List<string>(); foreach (VulnerabilityValue.Transition tr in newVulnerabilitySet.transitions) { foreach (VulnerabilityValue.TransitionCondition tc in tr.conditions) { if (!newVulnerabilityNames.Contains(tc.capability)) { newVulnerabilityNames.Add(tc.capability); } } } List<string> missingVulnerabilityNames = new List<string>(); foreach (string capName in previousVulnerabilityNames) { if (!newVulnerabilityNames.Contains(capName)) { if (!missingVulnerabilityNames.Contains(capName)) { missingVulnerabilityNames.Add(capName); } } } List<string> attackerList = ((StringListValue)obj["AttackerList"].GetDataValue()).strings; List<string> updatedAttackerList = new List<string>(); foreach (string attacker in attackerList) { //get attacker's current attacks AttackCollectionValue currentAttacks = objectProxies[attacker]["CurrentAttacks"].GetDataValue() as AttackCollectionValue; List<AttackCollectionValue.AttackValue> attacksOnTarget = currentAttacks.GetCurrentAttacksOnTarget(objectID); List<AttackCollectionValue.AttackValue> allAttacks = currentAttacks.GetCurrentAttacks(); //foreach attack foreach (AttackCollectionValue.AttackValue av in attacksOnTarget) { if (missingVulnerabilityNames.Contains(av.capabilityName)) { //if this attack is targetting my object with a capability that's in missingVulnerabilities, cancel the attack CancelAttack(attacker, objectID, av.capabilityName); } } if (allAttacks.Count > attacksOnTarget.Count) { updatedAttackerList.Add(attacker); } } obj["AttackerList"].SetDataValue(DataValueFactory.BuildStringList(updatedAttackerList)); obj["Vulnerability"].SetDataValue(newVulnerabilitySet); previousVulnerabilityNames.Clear(); newVulnerabilityNames.Clear(); }
/// <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> /// 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); }