public void Update(DDDServerConnection serverConnection, DMView dmView)
        {
            SimObject me = dmView.AllObjects[m_thisID];
            SimActiveRegion zone = dmView.ActiveRegions[m_zoneID];

            LocationValue otherLocation = null;
            Polygon2D azPoly = new Polygon2D();
            foreach (PolygonValue.PolygonPoint p in zone.Shape.points)
            {
                azPoly.AddVertex(new Vec2D(p.X, p.Y));
            }
            bool clear = true;

            foreach (String id in dmView.AllObjects.Keys)
            {
                if (id == m_thisID)
                {
                    continue;
                }
                otherLocation = dmView.AllObjects[id].Location;
                if (Polygon2D.IsPointInside(azPoly, new Vec2D(otherLocation)))
                {
                    clear = false;
                    break;
                }

            }

            if (clear)
            {
                m_done = true;
            }
        }
Example #2
0
        /// <summary>
        /// Returns the distance to the nearest point of a polygon.  If the point is in the Poly, should return 0
        /// </summary>
        /// <param name="poly"></param>
        /// <param name="point"></param>
        /// <returns></returns>
        public static double ScalarDistanceToPolygon(Polygon2D poly, Vec2D point)
        {
            if (IsPointInside(poly, point))
            {
                return(0.0);
            }

            double result = 999999;
            double curResult = 999999;
            Vec2D  one, two, zero;

            zero = new Vec2D(point);
            for (int i = 0; i < poly.xPoints.Count - 1; i++)
            {
                //calculate [i]:[1+1]
                one = new Vec2D(poly.xPoints[i], poly.yPoints[i]);
                two = new Vec2D(poly.xPoints[i + 1], poly.yPoints[i + 1]);
                //curResult = Math.Abs((two.X-one.X)*(one.Y-zero.Y)-(one.X-zero.X)*(two.Y-one.Y))/Math.Sqrt(Math.Pow(two.X-one.X,2)+Math.Pow(two.Y-one.Y,2));
                curResult = DistanceFromPointToSegment(zero, one, two);
                //curResult = (poly.yPoints[i + 1] - poly.yPoints[i]) * (point.X - poly.xPoints[i]) - (poly.xPoints[i + 1] - poly.xPoints[i]) * (point.Y - poly.yPoints[i]);
                //Math.Sqrt(Math.Pow((two.Y-one.Y)*(zero.X-one.X)+(two.X-one.X)*(zero.Y-one.Y),2)/(Math.Pow(two.X-one.X,2)+Math.Pow(two.Y-one.Y,2)));
                if (result > curResult)
                {
                    result = curResult; //do we save the point where they intersect?
                }
            }
            //then [Count-1]:[0]
            //curResult = (poly.yPoints[0] - poly.yPoints[poly.xPoints.Count - 1]) * (point.X - poly.xPoints[poly.xPoints.Count - 1]) - (poly.xPoints[0] - poly.xPoints[poly.xPoints.Count - 1]) * (point.Y - poly.yPoints[poly.xPoints.Count - 1]);
            one       = new Vec2D(poly.xPoints[poly.xPoints.Count - 1], poly.yPoints[poly.xPoints.Count - 1]);
            two       = new Vec2D(poly.xPoints[0], poly.yPoints[0]);
            curResult = DistanceFromPointToSegment(zero, one, two);
            if (result > curResult)
            {
                result = curResult; //do we save the point where they intersect?
            }

            return(result);
        }
Example #3
0
        public static Vec2D FindIntersect(PolygonValue poly1, PolygonValue poly2)
        {
            List <Vec2D> intersections = new List <Vec2D>(); //with polys, we might have 2 intersections, should we find the middle of the two?
            List <PolygonValue.PolygonPoint> p2Points = poly2.points;
            Vec2D     intersect = null;
            Polygon2D p2d       = new Polygon2D();

            PolygonValue.PolygonPoint p0;
            PolygonValue.PolygonPoint p1;
            p2d.FromPolygon(poly1);
            for (int i = 0; i < p2Points.Count - 1; i++)
            {
                p0        = p2Points[i];
                p1        = p2Points[i + 1];
                intersect = FindIntersect(p2d, new Vec2D(p0.X, p0.Y), new Vec2D(p1.X, p1.Y));
                if (intersect != null)
                {
                    intersections.Add(intersect);
                }
            }
            //then once more from len-1 to 0
            p0        = p2Points[p2Points.Count - 1];
            p1        = p2Points[0];
            intersect = FindIntersect(p2d, new Vec2D(p0.X, p0.Y), new Vec2D(p1.X, p1.Y));
            //intersect = FindIntersect(poly1, p2Points[p2Points.Count - 1], p2Points[0]);
            if (intersect != null)
            {
                intersections.Add(intersect);
            }

            if (intersections.Count > 0)
            {
                return(AverageVectors(intersections));
            }

            return(null);
        }
Example #4
0
 private Vec2D MakeLocationInEntryRegions(List<PolygonValue> acceptableEntryRegions)
 {
     PolygonValue entryRegion = acceptableEntryRegions.ElementAt(random.Next(acceptableEntryRegions.Count));
     Vec2D location = new Polygon2D(entryRegion).PointInside();
     return location;
 }
Example #5
0
 private List<Vec2D> MakeLocationsInEntryRegions(int numPirates, List<PolygonValue> acceptableEntryRegions)
 {
     List<Vec2D> locations = new List<Vec2D>();
     for (int i = 0; i < numPirates; i++)
     {
         PolygonValue entryRegion = acceptableEntryRegions.ElementAt(random.Next(acceptableEntryRegions.Count));
         Vec2D location = new Polygon2D(entryRegion).PointInside();
         locations.Add(location);
     }
     return locations;
 }
Example #6
0
        /// <summary>
        /// Calculates the absolute polygon of a region given a new location,
        /// using the region's reference point and relative polygon
        /// </summary>
        /// <param name="location"></param>
        /// <param name="region"></param>
        /// <returns></returns>
        private Polygon3D GetAbsolutePolygon(Vec2D refPoint, Polygon2D relativePolygon)
        {
            //Vec2D difference = refPoint.VectorDistanceTo(location);
            Polygon3D absolute = new Polygon3D(0,0);

            foreach (Vec2D vertex in relativePolygon.getVertices())
            {
                absolute.AddVertex(vertex.Add(refPoint));
            }
            return absolute;
        }
Example #7
0
        public static bool IsPointInside(Polygon2D poly, Vec2D p)
        {

            // Check bounding box first

            if (p.X < poly.bboxXMin || p.X > poly.bboxXMax)
            {
                return false;
            }
            if (p.Y < poly.bboxYMin || p.Y > poly.bboxYMax)
            {
                return false;
            }

            // cast ray to random location to avoid casting through a vertex.
            Vec2D p2 = new Vec2D(p);
            p2.X = (random.NextDouble() * 1000) + poly.bboxXMax;
            p2.Y = (random.NextDouble() * 1000) + poly.bboxYMax;

            Line line = new Line(p, p2);

            int k, j;
            Line line2 = new Line();

            int count = 0;

            for (k = 0; k < poly.xPoints.Count; k++)
            {
                j = k - 1;
                if (j < 0)
                {
                    j = poly.xPoints.Count - 1;
                }

                line2.p1 = new Vec2D(poly.xPoints[k], poly.yPoints[k]);
                line2.p2 = new Vec2D(poly.xPoints[j], poly.yPoints[j]);

                if (DoLinesIntersect(line.p1, line.p2, line2.p1, line2.p2))
                {
                    count++;
                }
            }

            if ((count % 2) == 1)
            {
                return true;
            }
            else
            {
                return false;
            }


        }
Example #8
0
        public static Vec2D FindIntersect(PolygonValue poly1, PolygonValue poly2)
        {
            List<Vec2D> intersections = new List<Vec2D>(); //with polys, we might have 2 intersections, should we find the middle of the two?
            List<PolygonValue.PolygonPoint> p2Points = poly2.points;
            Vec2D intersect = null;
            Polygon2D p2d = new Polygon2D();
            PolygonValue.PolygonPoint p0;
            PolygonValue.PolygonPoint p1;
            p2d.FromPolygon(poly1);
            for (int i = 0; i < p2Points.Count - 1; i++)
            {

                p0 = p2Points[i];
                p1 = p2Points[i + 1];
                intersect = FindIntersect(p2d, new Vec2D(p0.X, p0.Y), new Vec2D(p1.X, p1.Y));
                if (intersect != null)
                    intersections.Add(intersect);
            }
            //then once more from len-1 to 0
            p0 = p2Points[p2Points.Count - 1];
            p1 = p2Points[0];
            intersect = FindIntersect(p2d, new Vec2D(p0.X, p0.Y), new Vec2D(p1.X, p1.Y));
            //intersect = FindIntersect(poly1, p2Points[p2Points.Count - 1], p2Points[0]);
            if (intersect != null)
                intersections.Add(intersect);

            if (intersections.Count > 0)
                return AverageVectors(intersections);

            return null;
        }
        //Vec2D SmallestX(List<Vec2D> l)
        //{
        //    Vec2D r = l[0];
        //    for (int i = 1; i < l.Count; i++)
        //    {
        //        if (l[i].X < r.X)
        //        {
        //            r = l[i];
        //        }
        //    }
        //    return r;
        //}
        //Vec2D SmallestY(List<Vec2D> l)
        //{
        //    Vec2D r = l[0];
        //    for (int i = 1; i < l.Count; i++)
        //    {
        //        if (l[i].Y < r.Y)
        //        {
        //            r = l[i];
        //        }
        //    }
        //    return r;
        //}
        //Vec2D BiggestY(List<Vec2D> l)
        //{
        //    Vec2D r = l[0];
        //    for (int i = 1; i < l.Count; i++)
        //    {
        //        if (l[i].Y > r.Y)
        //        {
        //            r = l[i];
        //        }
        //    }
        //    return r;
        //}

        //Polygon2D GetPoly2(Vec2D p1, Vec2D p2)
        //{
        //    double halfwidth = m_avoidPathWidth / 2;
        //    Polygon2D poly = new Polygon2D();

        //    List<Vec2D> vertices = new List<Vec2D>();
            
        //    Vec2D v1 = GetPerpendicularPoint(p1, p2, -1* halfwidth);
        //    Vec2D v2 = GetPerpendicularPoint(p1, p2, 1 * halfwidth);
        //    Vec2D v3 = GetPerpendicularPoint(p2, p1, 1 * halfwidth);
        //    Vec2D v4 = GetPerpendicularPoint(p2, p1, -1 * halfwidth);

        //    if (v1 == null || v2 == null || v3 == null || v4 == null)
        //    {
        //        return null;
        //    }
        //    else
        //    {
        //        vertices.Add(v1);
        //        vertices.Add(v2);
        //        vertices.Add(v3);
        //        vertices.Add(v4);

        //        Vec2D first = SmallestX(vertices);
        //        vertices.Remove(first);
        //        Vec2D second = SmallestX(vertices);
        //        vertices.Remove(second);
        //        Vec2D third;

        //        if (second.Y > first.Y)
        //        {
        //            third = BiggestY(vertices);
        //            vertices.Remove(third);
        //        }
        //        else
        //        {
        //            third = SmallestY(vertices);
        //            vertices.Remove(third);
        //        }
        //        Vec2D fourth = vertices[0];

        //        poly.AddVertex(first);
        //        poly.AddVertex(second);
        //        poly.AddVertex(third);
        //        poly.AddVertex(fourth);
        //        return poly;
        //    }

        //}

        //Vec2D GetPerpendicularPoint(Vec2D p1, Vec2D p2, double d)
        //{
        //    Vec2D p3 = new Vec2D(0, 0);

        //    p3.X = p2.X + 1;
        //    double m = -1 * ((p2.Y - p1.Y) / (p2.X - p1.X));
        //    double b = p2.Y + ((p2.Y - p1.Y) / (p2.X - p1.X));
        //    p3.Y = (m * p3.X) + b;

        //    return ProjectPointOnLine(p2, p3, d);
        //}


        Polygon2D GetPoly(Vec2D p1, Vec2D p2)
        {
            double halfwidth = m_avoidPathWidth/2;
            Polygon2D poly = new Polygon2D();

            double dx = p2.X - p1.X >= 0 ? halfwidth : halfwidth * -1;
            double dy = p2.Y - p1.Y >= 0 ? halfwidth : halfwidth * -1;

            if (Math.Abs(p2.X - p1.X) > Math.Abs(p2.Y - p1.Y))
            {
                poly.AddVertex(new Vec2D(p1.X, p1.Y - halfwidth));
                poly.AddVertex(new Vec2D(p1.X, p1.Y + halfwidth));
                poly.AddVertex(new Vec2D(p2.X+dx, p2.Y + halfwidth));
                poly.AddVertex(new Vec2D(p2.X+dx, p2.Y - halfwidth));
                return poly;
            }
            else
            {
                poly.AddVertex(new Vec2D(p1.X - halfwidth, p1.Y));
                poly.AddVertex(new Vec2D(p1.X + halfwidth, p1.Y));
                poly.AddVertex(new Vec2D(p2.X + halfwidth, p2.Y+dy));
                poly.AddVertex(new Vec2D(p2.X - halfwidth, p2.Y+dy));
                return poly;
            }
        }
Example #10
0
 public LandRegion(string id, Polygon2D poly)
 {
     this.id = id;
     this.poly = poly;
 }
Example #11
0
        /// <summary>
        /// Makes a point which is in the closest entry region to the group of pirates, 
        /// TODO: but not in the same entry region as any of them.
        /// </summary>
        /// <param name="pirates">The move events representing pirates</param>
        /// <param name="entryRegions">All entry regions</param>
        /// <returns>A random point in the closest entry region to the group of pirates</returns>
        private Vec2D GetPointInClosestEntryRegion(Dictionary<T_Move,T_Reveal> pirates, List<PolygonValue> entryRegions) {
            Vec2D point = new Vec2D(0,0);
            double closestDistance = 100000000;
            PolygonValue closestRegion = null;
            Shuffle(entryRegions);
            T_Move randomPirate = pirates.Keys.ToList().ElementAt(0);
            LocationValue location = GetLocation(randomPirate, pirates[randomPirate]);
            foreach (PolygonValue entryRegion in entryRegions)
            {
                Polygon2D entry2D = new Polygon2D(entryRegion);
                double distance = Polygon2D.ScalarDistanceToPolygon(entry2D, new Vec2D(location));

                if (distance < oneGroupingDistance)
                {
                    point = entry2D.PointInside();
                    break;
                }
                else
                {
                    if (distance < closestDistance)
                    {
                        closestDistance = distance;
                        closestRegion = entryRegion;
                    }
                }
            }
            if (point == null)
            {
                point = new Polygon2D(closestRegion).PointInside();
            }
            return point;
        }
Example #12
0
        /// <summary>
        /// Returns the distance to the nearest point of a polygon.  If the point is in the Poly, should return 0
        /// </summary>
        /// <param name="poly"></param>
        /// <param name="point"></param>
        /// <returns></returns>
        public static double ScalarDistanceToPolygon(Polygon2D poly, Vec2D point)
        {
            if (IsPointInside(poly, point))
            {
                return 0.0;
            }

            double result = 999999;
            double curResult = 999999;
            Vec2D one, two, zero;
            zero = new Vec2D(point);
            for (int i = 0; i < poly.xPoints.Count - 1; i++)
            {
                //calculate [i]:[1+1]
                one = new Vec2D(poly.xPoints[i], poly.yPoints[i]);
                two = new Vec2D(poly.xPoints[i + 1], poly.yPoints[i + 1]);
                //curResult = Math.Abs((two.X-one.X)*(one.Y-zero.Y)-(one.X-zero.X)*(two.Y-one.Y))/Math.Sqrt(Math.Pow(two.X-one.X,2)+Math.Pow(two.Y-one.Y,2));
                curResult = DistanceFromPointToSegment(zero, one, two);
                //curResult = (poly.yPoints[i + 1] - poly.yPoints[i]) * (point.X - poly.xPoints[i]) - (poly.xPoints[i + 1] - poly.xPoints[i]) * (point.Y - poly.yPoints[i]);
                //Math.Sqrt(Math.Pow((two.Y-one.Y)*(zero.X-one.X)+(two.X-one.X)*(zero.Y-one.Y),2)/(Math.Pow(two.X-one.X,2)+Math.Pow(two.Y-one.Y,2)));
                if (result > curResult)
                {
                    result = curResult; //do we save the point where they intersect?
                }
            }
            //then [Count-1]:[0]
            //curResult = (poly.yPoints[0] - poly.yPoints[poly.xPoints.Count - 1]) * (point.X - poly.xPoints[poly.xPoints.Count - 1]) - (poly.xPoints[0] - poly.xPoints[poly.xPoints.Count - 1]) * (point.Y - poly.yPoints[poly.xPoints.Count - 1]);
            one = new Vec2D(poly.xPoints[poly.xPoints.Count - 1], poly.yPoints[poly.xPoints.Count - 1]);
            two = new Vec2D(poly.xPoints[0], poly.yPoints[0]);
            curResult = DistanceFromPointToSegment(zero, one, two);
            if (result > curResult)
            {
                result = curResult; //do we save the point where they intersect?
            }

            return result;
        }
Example #13
0
        //Threat generator -- generates or chooses ONE pirate or friendly vessel in DM domain
        //So either creates a RevealEvent or chooses existing vessel for MoveEvent
        public List<DDDAdapter.SeamateObject> GenerateWithTriedItems(T_Item currentItem, String dmID, List<DDDAdapter.SeamateObject> triedVessels)
        {
            //make a copy of the input which we'll modify and return at the end
            List<DDDAdapter.SeamateObject> returnTriedVessels = new List<DDDAdapter.SeamateObject>(triedVessels);

            String owner;
            bool isPirate;

            if (currentItem.Parameters.Threat == T_Threat.None)
            {
                isPirate = false;
                owner = "Merchant DM";
            }
            else
            {
                isPirate = true;
                owner = "Pirate DM";
            }


            PolygonValue domainPV = this.ddd.GetDecisionMakersAreaOfResponsibility(dmID);
            Polygon2D domain = new Polygon2D(domainPV);
            
            List<Object> actions = new List<object>();

            if (shouldAddNewVessel(revealedSeaVessels)) 
            {
                Console.WriteLine("ThreatGenerator: I'm trying to reuse a vessel because there are " + revealedSeaVessels.Count + " in play already and/or probability told me to.");
                List<DDDAdapter.SeamateObject> vessels = new List<DDDAdapter.SeamateObject>();
                //Find all vessels of the appropriate type (pirate or merchant) within the BAMS/Firescout's range.
                foreach (DDDAdapter.SeamateObject vessel in revealedSeaVessels) 
                {
                    if (vessel.Owner == owner && Polygon2D.IsPointInside(domain, new Vec2D(vessel.Location)))
                        vessels.Add(vessel);
                }
                Console.WriteLine("ThreatGenerator: Found " + vessels.Count + " to reuse");
                
                if (vessels.Count > 0)
                {
                    //manage the list of previously tried objects
                    if (triedVessels.Count == vessels.Count) returnTriedVessels = new List<DDDAdapter.SeamateObject>();
                    foreach (DDDAdapter.SeamateObject alreadyTried in returnTriedVessels) vessels.Remove(alreadyTried);

                    Shuffle(vessels);
                    DDDAdapter.SeamateObject vessel = null;
                    //see if any eligible vessels are stopped, if so, use one of them
                    foreach (DDDAdapter.SeamateObject possiblyStoppedVessel in vessels)
                    {
                        if (possiblyStoppedVessel.Throttle == 0) //yes, it is stopped
                        {
                            Console.WriteLine("ThreatGenerator: Picking a stopped vessel " + possiblyStoppedVessel.ID + " to reuse.");
                            vessel = possiblyStoppedVessel;
                            break;
                        }
                    }
                    //we didn't find any stopped vessels, so pick a random eligible one.
                    if (vessel == null)
                        vessel = vessels[random.Next(vessels.Count)];
                    returnTriedVessels.Add(vessel);
                    T_Move move = new T_Move();
                    move.ID = vessel.ID;
                    move.Location = new T_Location();

                    actions.Add(move);

                }
            }

            if (actions.Count() == 0) //we couldn't find a ship or need more vessels
            { //reveal a random new one

                Console.WriteLine("ThreatGenerator: I'm revealing a new vessel, either couldn't find a ship or need more vessels.");
                List<string> unrevealedObjectIDs = ddd.GetAllUnrevealedObjectIds(isPirate,true,null);
               
                T_Reveal reveal = new T_Reveal();
                reveal.ID = unrevealedObjectIDs[random.Next(unrevealedObjectIDs.Count())];
                reveal.Owner = owner;
                reveal.State = "FullyFunctional";
                reveal.Location = new T_Location();
                reveal.StartupParameters = new T_StartupParameters();
                reveal.StartupParameters.Items = new string[0];
            
                T_Move move = new T_Move();
                move.ID = reveal.ID;
                move.Location = new T_Location();
                Vec2D point;
                List<PolygonValue> entryRegions = ddd.GetAllEntryRegions();
                //TODO: Write a safe PointInsideMultipleDomains() function.  This could theoretically loop forever with a terrible scenario
                while (true)
                {
                    point = new Polygon2D(entryRegions[random.Next(entryRegions.Count)]).PointInside();
                    if (Polygon2D.IsPointInside(domain,point)) {
                        break;
                    }
                }
                reveal.Location.Item = point.ToLocationValue();
 
                actions.Add(reveal);
                actions.Add(move);
                Console.WriteLine("ThreatGenerator: Just revealed a pirate " + reveal.ID);
            }


            currentItem.Action = actions.ToArray();
            return returnTriedVessels;
            
        }
Example #14
0
        /// <summary>
        /// Returns the distance to the nearest point of a polygon.  If the point is in the Poly, should return 0
        /// </summary>
        /// <param name="poly"></param>
        /// <param name="point"></param>
        /// <returns></returns>
        public static Vec2D ClosestPointOnPolygon(Polygon2D poly, Vec2D point)
        {
            double result = 999999;
            double curResult = 999999;
            Vec2D BestPoint = null, curPoint;
            Vec2D one, two, zero;
            zero = new Vec2D(point);
            for (int i = 0; i < poly.xPoints.Count - 1; i++)
            {
                //calculate [i]:[1+1]
                one = new Vec2D(poly.xPoints[i], poly.yPoints[i]);
                two = new Vec2D(poly.xPoints[i + 1], poly.yPoints[i + 1]);
                curPoint = ClosestPointOnLineSegment(zero, one, two);
                curResult = zero.ScalerDistanceTo(curPoint);
                if (result > curResult)
                {
                    result = curResult; //do we save the point where they intersect?
                    BestPoint = curPoint;
                }
            }
            //then [Count-1]:[0]
            one = new Vec2D(poly.xPoints[poly.xPoints.Count - 1], poly.yPoints[poly.xPoints.Count - 1]);
            two = new Vec2D(poly.xPoints[0], poly.yPoints[0]);
            curPoint = ClosestPointOnLineSegment(zero, one, two);
            curResult = zero.ScalerDistanceTo(curPoint);
            if (result > curResult)
            {
                result = curResult; //do we save the point where they intersect?
                BestPoint = curPoint;
            }

            return BestPoint;
        }
Example #15
0
        public static bool SensorDoesLineCross(Polygon2D poly, Vec2D fromP, Vec2D toP)
        {

            Line line = new Line(fromP, toP);

            int k, j;
            Line line2 = new Line();


            for (k = 0; k < poly.xPoints.Count; k++)
            {
                j = k - 1;
                if (j < 0)
                {
                    j = poly.xPoints.Count - 1;
                }

                line2.p1 = new Vec2D(poly.xPoints[k], poly.yPoints[k]);
                line2.p2 = new Vec2D(poly.xPoints[j], poly.yPoints[j]);

                if (DoLinesIntersect(line.p1, line.p2, line2.p1, line2.p2))
                {
                    return true;
                }
            }

            return false;
        }
Example #16
0
        public static bool DoesLineCross(Polygon2D poly, Vec2D fromP, Vec2D toP)
        {

            // Check bounding box first
            /*
            if (toP.X < poly.bboxXMin || toP.X > poly.bboxXMax)
            {
                return false;
            }
            if (toP.Y < poly.bboxYMin || toP.Y > poly.bboxYMax)
            {
                return false;
            }
            */


            Line line = new Line(fromP, toP);

            int k, j;
            Line line2 = new Line();


            for (k = 0; k < poly.xPoints.Count; k++)
            {
                j = k - 1;
                if (j < 0)
                {
                    j = poly.xPoints.Count - 1;
                }

                line2.p1 = new Vec2D(poly.xPoints[k], poly.yPoints[k]);
                line2.p2 = new Vec2D(poly.xPoints[j], poly.yPoints[j]);

                if (DoLinesIntersect(line.p1, line.p2, line2.p1, line2.p2))
                {
                    return true;
                }
            }

            return false;
        }
Example #17
0
        //Pirate generator -- generates or chooses several pirates or friendly vessels in DM domain 
        //So either creates a RevealEvent or chooses existing vessel for MoveEvent
        
        public override void Generate(T_Item currentItem, String dmID)
        {
            if (currentItem.Parameters.Threat == T_Threat.None) return;


            actions = currentItem.Action.ToList();

            // Do some setup
            bool isPirate = !(currentItem.Parameters.Threat == T_Threat.None);
            if (isPirate) owner = "Pirate DM";
            else owner = "Merchant DM";

            PolygonValue domainPV = this.ddd.GetDecisionMakersAreaOfResponsibility(dmID);
            domain = new Polygon2D(domainPV);
            List<string> unrevealedObjectIDs = ddd.GetAllUnrevealedObjectIds(isPirate, true, null);


            //How many pirates should we generate?  These numbers may need tweaking
            int minPirates = Properties.Settings.Default.minPirates;
            int maxPirates = Properties.Settings.Default.maxPirates;
            int numPirates = random.Next(minPirates, maxPirates);


            //Are there any pirates we can reuse, already in play?
            List<DDDAdapter.SeamateObject> reusableVessels = revealedSeaVessels.FindAll(IsReusable);

            if (reusableVessels.Count > 0 && Properties.Settings.Default.reusePirates)
            {
                for (int i = 0; i < numPirates; i++)
                {
                    if (reusableVessels.Count > 0)
                    {
                        DDDAdapter.SeamateObject vessel = reusableVessels[0];
                        reusableVessels.Remove(vessel);
                        CreateEmptyMove(vessel);
                    }
                    else
                    {
                        Vec2D location = MakeLocationInEntryRegions(entryRegions);
                        string id = unrevealedObjectIDs[random.Next(unrevealedObjectIDs.Count())];
                        unrevealedObjectIDs.Remove(id);
                        CreateRevealAndEmptyMove(id, owner, location);
                    }
                }


                ////See if any existing pirates can be paired under "grouping" distance constraints
                //List<List<DDDAdapter.SeamateObject>> groupedPirates = GroupVessels(currentItem.Parameters.Groupings, numPirates, reusableVessels);
                //List<List<DDDAdapter.SeamateObject>> groupsOfNumPirateSize = groupedPirates.FindAll(delegate(List<DDDAdapter.SeamateObject> g) { return g.Count >= numPirates; });

                ////Any groups of numPirates?
                //if (groupsOfNumPirateSize.Count > 0)
                //{
                //    //if yes, make dummy move events for them and add to actions list.  done.
                //    foreach (DDDAdapter.SeamateObject pirate in groupsOfNumPirateSize.ElementAt(0))
                //        CreateEmptyMove(pirate);
                //}
                //else
                //{
                //    //Can any of these smaller groupings include an entry region too, so we can add new pirates? 
                //    groupedPirates.Sort(delegate(List<DDDAdapter.SeamateObject> g1, List<DDDAdapter.SeamateObject> g2) { return g1.Count.CompareTo(g2.Count); }); //sort by size, largest first
                //    foreach (List<DDDAdapter.SeamateObject> group in groupedPirates)
                //    {
                //        List<PolygonValue> matchingEntryRegions = GetMatchingEntryRegions(currentItem.Parameters.Groupings, group, entryRegions);
                //        if (matchingEntryRegions.Count > 0)
                //        {
                //            //if yes, then make dummy move events for the pirates in grouping, then
                //            foreach (DDDAdapter.SeamateObject pirate in groupsOfNumPirateSize.ElementAt(0))
                //                CreateEmptyMove(pirate);
                //            //Create as many remaining pirates as we need distributed randomly among suitable entry regions.
                //            List<Vec2D> locations = MakeLocationsInEntryRegions(numPirates - group.Count, matchingEntryRegions);
                //            foreach (Vec2D location in locations)
                //            {
                //                string id = unrevealedObjectIDs[random.Next(unrevealedObjectIDs.Count())];
                //                unrevealedObjectIDs.Remove(id);
                //                CreateRevealAndEmptyMove(id, owner, location);
                //            }
                //            break;
                //        }
                //    }

                //    //if no, we couldn't include an entry region (where new pirates would be created) with any existing pirates
                //    if (actions.Count == 0)
                //        //TODO: maybe should make smaller num of pirates if above min rather than making all new?
                //        MakeAllNewPirates(currentItem.Parameters.Groupings,numPirates,entryRegions,unrevealedObjectIDs);
                //}
            }
            //no reusable vessels, we have to create all new pirates 
            else
            {
                MakeAllNewPirates(currentItem.Parameters.Groupings,numPirates,entryRegions,unrevealedObjectIDs);
            }

            currentItem.Action = actions.ToArray();

        }
Example #18
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 #19
0
        public static bool DeriveReferenceFromVertexList(String currentReferencePoint, String vertexList, out String referencePoint, out String updatedVertexList)
        {
            referencePoint = "0 0";
            updatedVertexList = vertexList;

            if (vertexList.Trim().Length == 0)
                return false;
            //list is formed as (x, y), (x2, y2), etc
            char[] del = { ' ' };
            string[] pairDel = { ")," };
            String[] refPt = currentReferencePoint.Split(del);
            Vec2D curRefPt = new Vec2D(0, 0);
            if (refPt.Length == 2)
            {
                curRefPt = new Vec2D(Double.Parse(refPt[0].Trim()), Double.Parse(refPt[1].Trim()));
            }
            String[] pair = vertexList.Split(pairDel, StringSplitOptions.RemoveEmptyEntries);
            PolygonValue poly = new PolygonValue();

            double minX = 0, maxX = 0, minY = 0, maxY = 0;
            bool set = false;

            foreach (String p in pair)
            {
                String[] pp = p.Replace('(', ' ').Replace(')', ' ').Split(del, StringSplitOptions.RemoveEmptyEntries);
                double x = Double.Parse(pp[0].Replace(",","").Replace("\r\n","").Trim());
                double y = Double.Parse(pp[1].Replace("\r\n", "").Trim());
                if (pp.Length == 2)
                {
                    if (!set)
                    {
                        minX = maxX = x;
                        minY = maxY = y;
                        set = true;
                    }
                    else
                    {
                        if (x < minX)
                        {
                            minX = x;
                        }
                        else if (x > maxX)
                        {
                            maxX = x;
                        }
                        if (y < minY)
                        {
                            minY = y;
                        }
                        else if (y > maxY)
                        {
                            maxY = y;
                        }
                    }
                    poly.points.Add(new PolygonValue.PolygonPoint(x, y));
                }
                else
                {
                    Console.WriteLine("Something's wrong!");
                }
            }
            Polygon2D p2d = new Polygon2D();
            p2d.FromPolygon(poly);
            if (!Polygon2D.IsPointInside(p2d, curRefPt))
            {
                //find new ref point
                Vec2D tempPt = new Vec2D((maxX + minX) / 2, (maxY + minY) / 2);
                Random r = new Random(DateTime.Now.Millisecond);
                while (!Polygon2D.IsPointInside(p2d, tempPt))
                {
                    double newX = r.NextDouble() * (maxX - minX) + minX;
                    double newY = r.NextDouble() * (maxY - minY) + minY;
                    tempPt = new Vec2D(newX, newY);
                }
                curRefPt = tempPt;
            }
            referencePoint = String.Format("{0} {1}", curRefPt.X, curRefPt.Y);
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < poly.points.Count - 1; i++)
            {
                sb.AppendFormat("({0}, {1}), ", poly.points[i].X - curRefPt.X, poly.points[i].Y - curRefPt.Y);
            }
            //then once more for count -1 
            sb.AppendFormat("({0}, {1})", poly.points[poly.points.Count - 1].X - curRefPt.X, poly.points[poly.points.Count - 1].Y - curRefPt.Y);
            updatedVertexList = sb.ToString();

            return true;
        }
Example #20
0
        public override void Generate(T_Item currentItem, String dmID)
        {
            //Identify what's already in actions list.
            foreach (Object action in currentItem.Action)
            {
                if (action as T_Move != null)
                    primaryMove = (T_Move)action;
                if (action as T_Reveal != null)
                    primaryReveal = (T_Reveal)action;
            }
            LocationValue location = GetLocation(primaryMove, primaryReveal);
            bool isPirate = GetOwner(primaryMove, primaryReveal)=="Pirate DM";
            PolygonValue pirateEntryRegion = null;
            if (isPirate)
            {
                foreach (PolygonValue region in entryRegions)
                {
                    if (Polygon2D.IsPointInside(new Polygon2D(region), new Vec2D(location)))
                    {
                        pirateEntryRegion = region;
                        break;
                    }
                }
            }


            List<Object> list = currentItem.Action.ToList();

            List<string> unrevealedObjectIDs = ddd.GetAllUnrevealedObjectIds(false, true, null);
            if (primaryReveal != null)
                unrevealedObjectIDs.Remove(primaryReveal.ID);

           
            int minStimuli = 0;

            //If threat type is imminent, we need to guarantee there will be a merchant for the pirate to attack.
            if (currentItem.Parameters.ThreatType == T_ThreatType.Imminent)
                minStimuli = 1;


            int maxStimuli;
            //If resources need to be available, then two is maximum of stimulus events.
            if (T_ResourceAvailability.Available == currentItem.Parameters.PlayerResources)
                maxStimuli = 2;
            //If resources are unavailable, there must be at least 3 total stimulus events, and max can be higher.
            else
            {
                minStimuli = 3;
                maxStimuli = 5;
            }

            int numStimuliToGenerate = this.changingNumber(minStimuli, 60, minStimuli, maxStimuli); //probably minStimuli but could be up to maxStimuli


            //If our probability criteria says we should add vessels, try and populate reusable objects list 
            List<DDDAdapter.SeamateObject> reuseableObjects = new List<DDDAdapter.SeamateObject>();
            if (shouldAddNewVessel(revealedSeaVessels))
                reuseableObjects = findObjectsInPlay(location, pirateEntryRegion, currentItem.Parameters.Groupings, false);

            for (int i = 0; i < numStimuliToGenerate; i++)
            {

                T_Move move = new T_Move();

                //Try and recycle objects to create stimulus.
                if (reuseableObjects.Count != 0)
                {
                    Shuffle(reuseableObjects);
                    DDDAdapter.SeamateObject objectForReuse = null;
                    //see if any eligible vessels are stopped, if so, use one of them
                    foreach (DDDAdapter.SeamateObject possiblyStoppedVessel in reuseableObjects)
                    {
                        if (possiblyStoppedVessel.Throttle == 0) //yes, it is stopped
                        {
                            //Console.WriteLine("GRoupingGenerator: Picking a stopped vessel " + possiblyStoppedVessel.ID + " to reuse.");
                            objectForReuse = possiblyStoppedVessel;
                            break;
                        }
                    }
                    //randomly pick one of the suitable objects to create a stimulus
                    if (objectForReuse == null)
                        objectForReuse = reuseableObjects[random.Next(reuseableObjects.Count)];

                    move.ID = objectForReuse.ID;
                    reuseableObjects.Remove(objectForReuse);
                    //Console.WriteLine("GroupingGenerator: Moving existing merchant " + objectForReuse.ID);

                }
                else //Reveal and move new merchant.
                {
                    T_Reveal reveal = new T_Reveal();
                    reveal.Owner = "Merchant DM";
                    reveal.State = "FullyFunctional";
                    reveal.StartupParameters = new T_StartupParameters();
                    reveal.StartupParameters.Items = new string[0];
                    reveal.ID = unrevealedObjectIDs[random.Next(unrevealedObjectIDs.Count)]; //pick a random new object
                    unrevealedObjectIDs.Remove(reveal.ID); //take it out of the available list

                    //ADDED 11/10/11:  To make sure that the merchants don't end up in the same entry region as a newly created pirate, 
                    //if there's a new pirate, instead of iterating over all entry regions we'll remove the pirate's region from the list first.
                    if (pirateEntryRegion != null)
                        entryRegions.Remove(pirateEntryRegion);

                    Vec2D point = null;

                    //If two grouping, pick points in entry regions until one is > 100 away
                    if (currentItem.Parameters.Groupings == T_Groupings.Two)
                    {
                        while (true)
                        {
                            point = new Polygon2D(entryRegions[random.Next(entryRegions.Count)]).PointInside();
                            if (point.ScalerDistanceTo(new Vec2D(location)) > twoGroupingDistance)
                            {
                                break;
                            }
                        }
                    }
                    //If one grouping, see if any entry region is within 50km.  If so, pick a point in that entry region.  
                    //It's possible that no entry region may be within 50km.  In that case, pick a point in the closest one.

                    if (currentItem.Parameters.Groupings == T_Groupings.One)
                    {
                        double closestDistance = 100000000;
                        PolygonValue closestRegion = null;
                        Shuffle(entryRegions);

                        foreach (PolygonValue entryRegion in entryRegions)
                        {
                            Polygon2D entry2D = new Polygon2D(entryRegion);
                            double distance = Polygon2D.ScalarDistanceToPolygon(entry2D, new Vec2D(location));

                            if (distance < oneGroupingDistance)
                            {
                                point = entry2D.PointInside();
                                break;
                            }
                            else
                            {
                                if (distance < closestDistance)
                                {
                                    closestDistance = distance;
                                    closestRegion = entryRegion;
                                }
                            }
                        }
                        if (point == null)
                        {
                            //Console.WriteLine("GroupingGenerator: Unable to place vessel in an entry region AND <100km away.  Placing in closest entry region " + closestDistance + " away.");
                            point = new Polygon2D(closestRegion).PointInside();
                        }
                    }
                    reveal.Location = new T_Location();
                    reveal.Location.Item = point.ToLocationValue();
                    list.Add(reveal);

                    move.ID = reveal.ID;
                    //Console.WriteLine("GroupingGenerator: Revealing new merchant " + reveal.ID + " and moving it");
                }

                move.Location = new T_Location();
                list.Add(move);
            }               

            currentItem.Action = list.ToArray();
        }
Example #21
0
        public override void Generate(T_Item currentItem, String dmID)
        {
            actions = currentItem.Action.ToList();
            dict = GetActionsAsDictionary(currentItem.Action);
            grouping = currentItem.Parameters.Groupings;


            List<string> unrevealedMerchantIDs = ddd.GetAllUnrevealedObjectIds(false, true, null); //Gets only merchants

           
            int minStimuli = 1;
            int maxStimuli;
            //If resources need to be available, then two is maximum of stimulus events.
            if (T_ResourceAvailability.Available == currentItem.Parameters.PlayerResources)
                maxStimuli = Properties.Settings.Default.resourceThreshold-1;
            //If resources are unavailable, there must be at least 3 total stimulus events, and max can be higher.
            else
            {
                minStimuli = Properties.Settings.Default.resourceThreshold;
                maxStimuli = Properties.Settings.Default.resourceThreshold*2-1;
            }

            int numPirates = dict.Keys.Count;
            int numMerchants = Math.Max(0, random.Next(minStimuli, maxStimuli) - numPirates);
            if (numMerchants == 0)
                return;


            //If our probability criteria says we should add vessels, let's see if we can reuse any existing vessels 
            List<DDDAdapter.SeamateObject> reuseableVessels = new List<DDDAdapter.SeamateObject>();
            List<DDDAdapter.SeamateObject> allExistingMerchants = revealedSeaVessels.FindAll(IsMerchant);
            if (shouldAddNewVessel(revealedSeaVessels))
                reuseableVessels = allExistingMerchants.FindAll(MatchesGroupingConstraints);

            for (int i = 0; i < numMerchants; i++)  //Do once for each merchant we need to create.
            {
                //Try and recycle objects to create stimulus.
                if (reuseableVessels.Count > 0)
                {
                    DDDAdapter.SeamateObject objectForReuse = null;
                    //Make sure we reuse any stopped objects first
                    List<DDDAdapter.SeamateObject> stoppedObjects = reuseableVessels.FindAll(IsStopped);
                    if (stoppedObjects.Count > 0) objectForReuse = stoppedObjects[random.Next(stoppedObjects.Count)];
                    else objectForReuse = reuseableVessels[random.Next(reuseableVessels.Count)];

                    CreateEmptyMove(objectForReuse);
                    reuseableVessels.Remove(objectForReuse);

                }
                else //Reveal and move new merchant starting at an appropriate point for grouping constraints.
                {
                    Vec2D location = null;
                    if (currentItem.Parameters.Groupings == T_Groupings.One) //Get point in closest entry region
                    {
                        location = GetPointInClosestEntryRegion(dict, entryRegions);
                    }
                    else if (currentItem.Parameters.Groupings == T_Groupings.Two) //Get point in any entry region
                    {
                        location = new Polygon2D(entryRegions[random.Next(entryRegions.Count)]).PointInside();
                    }

                    string id = unrevealedMerchantIDs[random.Next(unrevealedMerchantIDs.Count)];
                    CreateRevealAndEmptyMove(id, "Merchant DM", location);
                    unrevealedMerchantIDs.Remove(id); 
                }
         
            }               
            currentItem.Action = actions.ToArray();
        }
Example #22
0
 void UpdateInActiveRegions(ref SimObject ob)
 {
     ob.InActiveRegions.Clear();
     foreach (SimActiveRegion sar in m_activeRegions.Values)
     {
         Polygon2D azPoly = new Polygon2D();
         foreach (PolygonValue.PolygonPoint p in sar.Shape.points)
         {
             azPoly.AddVertex(new Vec2D(p.X, p.Y));
         }
         if (Polygon2D.IsPointInside(azPoly, new Vec2D(ob.Location)))
         {
             ob.InActiveRegions.Add(sar.ID);
         }
     }
 }
Example #23
0
        private void NewObject(SimulationEvent e)
        {
            //objectProxies = bbClient.GetObjectProxies();

            string id = ((StringValue)e["ID"]).value;
            string type = ((StringValue)e["ObjectType"]).value;

            if (objectProxies == null)
            {
                objectProxies = new Dictionary<string, SimulationObjectProxy>();
            }
            SimulationObjectProxy prox = bbClient.GetObjectProxy(id);
            if (prox != null)
            {
                if (!objectProxies.ContainsKey(id))
                {
                    objectProxies.Add(id, prox);
                }
                else
                {
                    objectProxies[id] = prox;
                }
            }

            if (((StringValue)e["ObjectType"]).value == "LandRegion")
            {
                StateDB.LandRegion l = new StateDB.LandRegion(((StringValue)e["ID"]).value, null);
                Polygon2D poly = new Polygon2D();
                foreach (PolygonValue.PolygonPoint pp in ((PolygonValue)((AttributeCollectionValue)e["Attributes"]).attributes["Polygon"]).points)
                {
                    poly.AddVertex(new Vec2D(pp.X, pp.Y));
                }
                l.poly = poly;
                StateDB.landRegions[l.id] = l;
            }
            else if (((StringValue)e["ObjectType"]).value == "ActiveRegion")
            {
                StateDB.ActiveRegion b = new StateDB.ActiveRegion(((StringValue)e["ID"]).value, null);
                double start = ((DoubleValue)((AttributeCollectionValue)e["Attributes"]).attributes["StartHeight"]).value;
                double end = ((DoubleValue)((AttributeCollectionValue)e["Attributes"]).attributes["EndHeight"]).value;
                Polygon3D poly2 = new Polygon3D(start, end);
                foreach (PolygonValue.PolygonPoint pp in ((PolygonValue)((AttributeCollectionValue)e["Attributes"]).attributes["Polygon"]).points)
                {
                    poly2.AddVertex(new Vec2D(pp.X, pp.Y));
                }
                b.poly = poly2;
                b.currentAbsolutePolygon = poly2;
                if (((BooleanValue)((AttributeCollectionValue)e["Attributes"]).attributes["BlocksMovement"]).value)
                {
                    b.blockingRegion = true;
                }
                else
                {
                    b.blockingRegion = false;
                }
                if (((AttributeCollectionValue)e["Attributes"]).attributes.ContainsKey("SpeedMultiplier"))
                {
                    b.speedMultiplier = ((DoubleValue)((AttributeCollectionValue)e["Attributes"]).attributes["SpeedMultiplier"]).value;
                }
                else
                {
                    b.speedMultiplier = 1;
                }

                if (((AttributeCollectionValue)e["Attributes"]).attributes.ContainsKey("IsVisible"))
                {
                    b.isVisible = ((BooleanValue)((AttributeCollectionValue)e["Attributes"]).attributes["IsVisible"]).value;
                }
                else
                {
                    b.isVisible = false;
                }

                if (((AttributeCollectionValue)e["Attributes"]).attributes.ContainsKey("DisplayColor"))
                {
                    b.displayColor = ((IntegerValue)((AttributeCollectionValue)e["Attributes"]).attributes["DisplayColor"]).value;
                }
                else
                {
                    b.displayColor = -10185235;
                }

                if (((AttributeCollectionValue)e["Attributes"]).attributes.ContainsKey("IsDynamicRegion"))
                {
                    b.isDynamicRegion = ((BooleanValue)((AttributeCollectionValue)e["Attributes"]).attributes["IsDynamicRegion"]).value;
                } else {
                    b.isDynamicRegion = false;
                }
                if (((AttributeCollectionValue)e["Attributes"]).attributes.ContainsKey("ReferencePoint") && !b.isDynamicRegion) //if isDynamic, will use its LinkedObject as Ref.
                {
                    b.referencePoint = new Vec2D(((LocationValue)((AttributeCollectionValue)e["Attributes"]).attributes["ReferencePoint"]));
                    b.currentAbsolutePolygon = GetAbsolutePolygon(b.referencePoint, poly2.Footprint);
                } else {
                    b.referencePoint = new Vec2D(0,0);
                }


                //Make separate lists for dynamic and active regions in StateDB
                if (b.isDynamicRegion) {
                    StateDB.dynamicRegions[b.id] = b;
                } else {
                    StateDB.activeRegions[b.id] = b;
                }

            }
        }
Example #24
0
 public Polygon3D(double z1,double z2)
 {
     footprint = new Polygon2D();
     bottom = z1;
     top = z2;
 }
Example #25
0
        private void NewObject(SimulationEvent e)
        {
            //objectProxies = bbClient.GetObjectProxies();

            string id = ((StringValue)e["ID"]).value;
            string type = ((StringValue)e["ObjectType"]).value;

            if (objectProxies == null)
            {
                objectProxies = new Dictionary<string, SimulationObjectProxy>();
            }
            SimulationObjectProxy prox = bbClient.GetObjectProxy(id);
            if (prox != null)
            {
                if (!objectProxies.ContainsKey(id))
                {
                    objectProxies.Add(id, prox);
                }
                else
                {
                    objectProxies[id] = prox;
                }
            }

            if (((StringValue)e["ObjectType"]).value == "LandRegion")
            {
                StateDB.LandRegion l = new StateDB.LandRegion(((StringValue)e["ID"]).value, null);
                Polygon2D poly = new Polygon2D();
                foreach (PolygonValue.PolygonPoint pp in ((PolygonValue)((AttributeCollectionValue)e["Attributes"]).attributes["Polygon"]).points)
                {
                    poly.AddVertex(new Vec2D(pp.X, pp.Y));
                }
                l.poly = poly;
                StateDB.landRegions[l.id] = l;
            }
            else if (((StringValue)e["ObjectType"]).value == "ActiveRegion")
            {
                StateDB.ActiveRegion b = new StateDB.ActiveRegion(((StringValue)e["ID"]).value, null);
                double start = ((DoubleValue)((AttributeCollectionValue)e["Attributes"]).attributes["StartHeight"]).value;
                double end = ((DoubleValue)((AttributeCollectionValue)e["Attributes"]).attributes["EndHeight"]).value;
                Polygon3D poly2 = new Polygon3D(start, end);
                foreach (PolygonValue.PolygonPoint pp in ((PolygonValue)((AttributeCollectionValue)e["Attributes"]).attributes["Polygon"]).points)
                {
                    poly2.AddVertex(new Vec2D(pp.X, pp.Y));
                }
                b.poly = poly2;
                if (((BooleanValue)((AttributeCollectionValue)e["Attributes"]).attributes["BlocksMovement"]).value)
                {
                    b.blockingRegion = true;
                }
                else
                {
                    b.blockingRegion = false;
                }
                if (((AttributeCollectionValue)e["Attributes"]).attributes.ContainsKey("SpeedMultiplier"))
                {
                    b.speedMultiplier = ((DoubleValue)((AttributeCollectionValue)e["Attributes"]).attributes["SpeedMultiplier"]).value;
                }
                else
                {
                    b.speedMultiplier = 1;
                }

                if (((AttributeCollectionValue)e["Attributes"]).attributes.ContainsKey("IsVisible"))
                {
                    b.isVisible = ((BooleanValue)((AttributeCollectionValue)e["Attributes"]).attributes["IsVisible"]).value;
                }
                else
                {
                    b.isVisible = false;
                }

                if (((AttributeCollectionValue)e["Attributes"]).attributes.ContainsKey("DisplayColor"))
                {
                    b.displayColor = ((IntegerValue)((AttributeCollectionValue)e["Attributes"]).attributes["DisplayColor"]).value;
                }
                else
                {
                    b.displayColor = -10185235;
                }


                //b.displayColor = -10185235;
                //b.isVisible = true;
                StateDB.activeRegions[b.id] = b;
            }
        }
Example #26
0
        public static Vec2D FindIntersect(Polygon2D poly1, Polygon2D poly2)
        {
            List<Vec2D> intersections = new List<Vec2D>(); //with polys, we might have 2 intersections, should we find the middle of the two?
            List<Vec2D> p2Points = poly2.getVertices();
            Vec2D intersect = null;
            for (int i = 0; i < p2Points.Count - 1; i++)
            {
                intersect = FindIntersect(poly1, p2Points[i], p2Points[i + 1]);
                if (intersect != null)
                    intersections.Add(intersect);
            }
            //then once more from len-1 to 0
            intersect = FindIntersect(poly1, p2Points[p2Points.Count - 1], p2Points[0]);
            if (intersect != null)
                intersections.Add(intersect);

            if (intersections.Count > 0)
                return AverageVectors(intersections);

            return null;
        }
Example #27
0
        private void TimeTick(SimulationEvent e)
        {
            //update time
            if (((IntegerValue)e["Time"]).value % 1000 == 0)
                time = ((IntegerValue)e["Time"]).value / 1000; // time is in ms, we want seconds
            /*
             * "Time" is an attribute of all events.  The SimulationModel.xml file lists all of the top-level attributes for each event.
             * Certain events have an additional "Attribute" attribute, which contains a key-value pair collection of additional attributes.
             * See RevealObject for an example of this.
             */
            if (((IntegerValue)e["Time"]).value == 1000)
            {
                InitializeAllScores();
            }
            SimulationObjectProxy obProx;
            foreach (string id in objectProxies.Keys)
            {
                obProx = objectProxies[id];
                bool isInSealane = false;
                bool movingTowardsPort = false;
                StringListValue slv = obProx["InActiveRegions"].GetDataValue() as StringListValue;
                LocationValue dest = obProx["DestinationLocation"].GetDataValue() as LocationValue;
                if(dest.exists)
                {
                    Vec2D destVec = new Vec2D(dest);
                    Polygon2D p;
                    foreach(Aptima.Asim.DDD.CommonComponents.SimulatorTools.StateDB.ActiveRegion a in StateDB.activeRegions.Values)
                    {
                        if (!a.id.Contains("Entry-"))
                            continue;
                        p = new Polygon2D(); 
                        p = a.poly.Footprint;

                        if (Aptima.Asim.DDD.CommonComponents.SimMathTools.Polygon2D.IsPointInside(p, destVec))
                        {
                            movingTowardsPort = true;
                        }
                    }
                }
                
                

                if (slv.strings.Count > 0)
                    isInSealane = true;                

                obProx["IsInSeaLane"].SetDataValue(DataValueFactory.BuildBoolean(isInSealane));
                obProx["IsGoingTowardsPort"].SetDataValue(DataValueFactory.BuildBoolean(movingTowardsPort));
            }
        }
Example #28
0
        public static Vec2D FindIntersect(Polygon2D poly, Vec2D fromP, Vec2D toP)
        {
            Line line = new Line(fromP, toP);

            int k, j;
            Line line2 = new Line();

            int count = 0;

            Vec2D intersect = null;

            for (k = 0; k < poly.xPoints.Count; k++)
            {
                j = k - 1;
                if (j < 0)
                {
                    j = poly.xPoints.Count - 1;
                }

                line2.p1 = new Vec2D(poly.xPoints[k], poly.yPoints[k]);
                line2.p2 = new Vec2D(poly.xPoints[j], poly.yPoints[j]);


                intersect = FindIntersect2(fromP, toP, line2.p1, line2.p2); //AD: Changed to new method for now.
                if (intersect != null)
                {
                    return intersect;
                }

            }

            return null;

        }
Example #29
0
        public bool SpecialGenerate(T_Item currentItem, String dmID)
        {

            Dictionary<T_Move,T_Reveal> dict = GetActionsAsDictionary(currentItem.Action);
            Dictionary<T_Move, T_Reveal> newDict = new Dictionary<T_Move,T_Reveal>();
            
            List<PolygonValue> seaLanes = ddd.GetAllSeaLanes();
            PolygonValue domain = this.ddd.GetDecisionMakersAreaOfResponsibility(dmID);


            foreach (T_Move key in dict.Keys)
            {
                T_Move move = key;
                T_Reveal reveal = dict[key];
                

                //Is this vessel a pirate?
                bool isPirate = false;
                if (reveal!=null) //there's a reveal event
                {
                    if (reveal.Owner == "Pirate DM")
                        isPirate = true;
                } 
                else if (ddd.GetSeamateObject(move.ID).Owner == "Pirate DM")
                    isPirate = true;


                //Vessel's desired perceived ambiguity
                bool ambiguity = true;
                if (currentItem.Parameters.Threat == T_Threat.Unambiguous)
                    ambiguity = false;
                //If it's a merchant and resources aren't unavailable, always make merchants UNambiguous (so IFF is likely to be on)
                if (!isPirate && currentItem.Parameters.PlayerResources == T_ResourceAvailability.Available)
                    ambiguity = false;


                //Is it in a sea lane?  If it is already in play check, Yes if it is being revealed in an entry region
                bool locationInSeaLane = false;
                LocationValue location;
                if (reveal == null) //already in play
                    location = ddd.GetSeamateObject(move.ID).Location;
                else
                    location = (LocationValue)reveal.Location.Item;

                foreach (PolygonValue seaLane in seaLanes)
                {
                    Polygon2D seaLane2D = new Polygon2D(seaLane);
                    if (Polygon2D.IsPointInside(seaLane2D, new Vec2D(location)))
                    {
                        locationInSeaLane = true;
                        break;
                    }
                }

                //Intercept course
               bool onInterceptCourse = false;
               if (currentItem.Parameters.ThreatType == T_ThreatType.Imminent && isPirate)
                    onInterceptCourse = true;

                //IFF
               bool hasIFFon = false;

                //Is its IFF already on?
                if (move == null) //Object already exists in play
                {
                    String displayName = ddd.GetSeamateObject(move.ID).ObjectName; 
                    if (!displayName.StartsWith("unknown")) //Object has IFF set on
                        hasIFFon = true;
                }


                //Pick row from ambiguity table using existing constraints.
                Shuffle(ambiguityTable);
                bool[] selectedRow = null;
                foreach (bool[] row in ambiguityTable)
                {
                    if ((!onInterceptCourse || row[2])          //if onInterceptCourse is true, only allow course to be "on"/true ... if onInterceptCourse is false, either value is OK
                         && (!hasIFFon || row[0])                //same as above for hasIFFon and IFF
                        && (!locationInSeaLane || row[3])       //same as above for inSeaLane and location
                        && ambiguity == row[4])                 // ambiguity must match

                        selectedRow = row;
                }
                if (selectedRow == null)
                {
                    return false;
                    //Console.WriteLine("Impossible scenario");
                    //selectedRow = ambiguityTable[random.Next(ambiguityTable.Length)];
                    //TODO: Wipe out actions, go back to Threat Generator and make a new object
                }
               // Console.WriteLine("AmbiguityGenerator: Making settings for an " + currentItem.Parameters.ThreatType.ToString() + " vessel.  IFF should be on?" + selectedRow[0]);

                //Create scenario described in ambiguity table

                //IFF =================================
                //If we're revealing a new vessel, we can set its IFF on if we need to.  Default is off so we don't 
                // have to do anything.  We can't change existing ships.
                if (reveal != null)
                {
                    if (selectedRow[0] && !isPirate)
                        SetIFF(isPirate, reveal);

                    //If it's a pirate, ignore what it says in the ambiguity table.  
                    //Unambiguous == IFF ON always.  Ambiguous = IFF OFF always
                    if (isPirate && currentItem.Parameters.Threat == T_Threat.Unambiguous)
                        SetIFF(isPirate, reveal);
                    
                }

                //SPEED ===============================   
                double maxSpeed = GetMaxSpeed(move);

                double newSpeed;
                if (selectedRow[1])  //speed 69-84 m/s
                    newSpeed = random.Next(69, Math.Max((int)maxSpeed,84));
                else
                {  //speed <69 or >84 m/s
                    if (maxSpeed > 84)
                        newSpeed = random.Next(84, (int)maxSpeed);
                    else
                        newSpeed = random.Next(20, 68);
                }
                move.Throttle = ((double)newSpeed / (double)maxSpeed);



                //COURSE =================================
                if (selectedRow[2])
                {
                    if (onInterceptCourse) // we will take care of this later
                    {
                        
                    }
                    else //if (locationInSeaLane)
                    {
                        //pick any entry region and send it there.
                        Polygon2D entryRegion2D = new Polygon2D(entryRegions[random.Next(entryRegions.Count)]);
                        Vec2D point = entryRegion2D.PointInside();
                        move.Location = new T_Location();
                        move.Location.Item = point.ToLocationValue();
                    }
                }
                else
                {
                    //just send it anywhere ... probably won't be in a sea lane
                    Vec2D point = new Polygon2D(domain).PointInside(); //TODO: this should be in whole scenario boundaries, not just DM domain
                    move.Location = new T_Location();
                    move.Location.Item = point.ToLocationValue();

                    //TODO:  Send it to the edge of the universe.  Just kidding ... to edge of sea region.
                    ddd.GetDecisionMakersAreaOfResponsibility("BAMS DM");
                    ddd.GetDecisionMakersAreaOfResponsibility("Firescout DM");

                }
                //Add modified move and reveal back to dictionary.
                newDict[move] = reveal;
            }
            currentItem.Action = GetActionsFromDictionary(newDict);
            return true;
        }
Example #30
0
 public Polygon3D(double z1, double z2)
 {
     footprint = new Polygon2D();
     bottom    = z1;
     top       = z2;
 }