Example #1
0
        static void Main(string[] args)
        {


            Polygon2D poly = new Polygon2D();
            poly.AddVertex(new Vec2D(1,1));
            poly.AddVertex(new Vec2D(4, 1));
            poly.AddVertex(new Vec2D(2.5, 3));
            poly.AddVertex(new Vec2D(4, 3));
            poly.AddVertex(new Vec2D(4, 4));
            poly.AddVertex(new Vec2D(2, 3.5));

            bool r;
            r = Polygon2D.IsPointInside(poly,new Vec2D(5, 3)); //false
            r = Polygon2D.IsPointInside(poly, new Vec2D(2, 2)); //true
            r = Polygon2D.IsPointInside(poly, new Vec2D(3.5, 3.5)); //true
            r = Polygon2D.IsPointInside(poly, new Vec2D(1, 3.5)); //false
            r = Polygon2D.IsPointInside(poly, new Vec2D(3, 2.5)); //false

            r = Polygon2D.DoLinesIntersect(new Vec2D(0, 2), new Vec2D(3, 0), new Vec2D(1, 1), new Vec2D(3, 3)); //true
            r = Polygon2D.DoLinesIntersect(new Vec2D(0, 2), new Vec2D(3, 0), new Vec2D(2, 1), new Vec2D(3, 3)); //false

            DataValue dv = DataValueFactory.BuildValue("CapabilityType");
            ((CapabilityValue)dv).effects.Add(new CapabilityValue.Effect("foo",45,10,.50));
            ((CapabilityValue)dv).effects.Add(new CapabilityValue.Effect("foo", 100, 5, .25));

            string s = DataValueFactory.XMLSerialize(dv);

            DataValue dv2 = DataValueFactory.XMLDeserialize(s);

            DataValue dv3 = DataValueFactory.BuildValue("VulnerabilityType");

            VulnerabilityValue.Transition t = new VulnerabilityValue.Transition("dead");
            t.conditions.Add(new VulnerabilityValue.TransitionCondition("foo",50,0,0));
            t.conditions.Add(new VulnerabilityValue.TransitionCondition("bar", 20,0,0));

            ((VulnerabilityValue)dv3).transitions.Add(t);

            t = new VulnerabilityValue.Transition("hurt");
            t.conditions.Add(new VulnerabilityValue.TransitionCondition("foo", 25,0,0));
            ((VulnerabilityValue)dv3).transitions.Add(t);

            s = DataValueFactory.XMLSerialize(dv3);

            DataValue dv4 = DataValueFactory.XMLDeserialize(s);
            System.Console.WriteLine(s == DataValueFactory.XMLSerialize(dv4));

            DataValue dv5 = DataValueFactory.BuildValue("StateTableType");
            DataValue dv6 = DataValueFactory.BuildValue("AttributeCollectionType");
            ((StateTableValue)dv5).states["foo"] = DataValueFactory.BuildValue("DoubleType");
            ((AttributeCollectionValue)dv6).attributes["foo2"] = DataValueFactory.BuildValue("DoubleType");
            ((StateTableValue)dv5).states["bar"] = dv6;

            s = DataValueFactory.XMLSerialize(dv5);

            DataValue dv7 = DataValueFactory.XMLDeserialize(s);

            DataValue dv8 = DataValueFactory.BuildValue("StringListType");
            ((StringListValue)dv8).strings.Add("Foo");
            ((StringListValue)dv8).strings.Add("Bar");

            s = DataValueFactory.XMLSerialize(dv8);

            dv8 = DataValueFactory.XMLDeserialize(s);

            DataValue dv9 = DataValueFactory.BuildValue("PolygonType");
            ((PolygonValue)dv9).points.Add(new PolygonValue.PolygonPoint(0, 0));
            ((PolygonValue)dv9).points.Add(new PolygonValue.PolygonPoint(10.234, 34.097));
            ((PolygonValue)dv9).points.Add(new PolygonValue.PolygonPoint(10.234, 1.2));

            s = DataValueFactory.XMLSerialize(dv9);

            DataValue dv10 = DataValueFactory.XMLDeserialize(s);

        }
Example #2
0
 /// <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);
 }
Example #3
0
        private static DataValue DefineVulnerabilityValue(Dictionary<string, SingletonVulnerabilityType> singletons,
            List<ComboVulnerabilityType> combo)
        {
            DataValue returnVulnerabilityValue =
                (VulnerabilityValue)DataValueFactory.BuildValue("VulnerabilityType");
            VulnerabilityValue.Transition t;
            VulnerabilityValue.TransitionCondition tc;

            string state;
            int effect;
            double range;
            double probability;

            foreach (ComboVulnerabilityType c in combo)
            {
                state = c.NewState;
                t = new VulnerabilityValue.Transition(state);
                foreach (ContributionType cont in c.Contributions)
                {
                    effect = cont.Effect;
                    string capability = cont.Capability;
                    range = cont.Range;
                    probability = cont.Probability;
                    tc = new VulnerabilityValue.TransitionCondition(capability, effect, range, probability);
                    t.conditions.Add(tc);
                }
                ((VulnerabilityValue)returnVulnerabilityValue).transitions.Add(t);
            }

            foreach (string capability in singletons.Keys)
            {
                singletons[capability].Transitions.Sort();
                foreach (TransitionType transType in singletons[capability].Transitions)
                {
                    effect = transType.Effect;
                    state = transType.State;
                    range = transType.Range;
                    probability = transType.Probability;
                    tc = new VulnerabilityValue.TransitionCondition(capability, effect, range, probability);

                    t = new VulnerabilityValue.Transition(state);
                    t.conditions.Add(tc);
                    ((VulnerabilityValue)returnVulnerabilityValue).transitions.Add(t);
                }
            }


            return returnVulnerabilityValue;
        }