public static string PrintGrid(int[,] grid, IEnumerable<Point> path = null, IEnumerable<Point> pawns = null)
        {
            string str = string.Empty;
            HashSet<Point> pathPoints = new HashSet<Point>(path);

            for (int j = 0; j < grid.GetLength(0); j++) {
                for (int i = 0; i < grid.GetLength(1); i++) {
                    Point point = new Point(i, j);
                    if (pawns != null && pawns.Contains(point)) {
                        str += "╬";
                    } else if (path != null && pathPoints.Contains(point)) {
                        str += "┼";
                    } else {
                        switch (grid[j, i]) {
                            case Board.WALL_TILE:
                                str += "█";
                                break;
                            case Board.FLOOR_TILE:
                                str += "░";
                                break;
                        }
                    }
                }
                str += "\n";
            }

            return str;
        }
Example #2
1
        public Point GetDestination(Point destination, FixedObject destObject, Hero hero)
        {
            var cell = Map.PointToCell(destination);
            var obj = Game.Map.GetObjectFromCell(cell);

            var largeObjectOuter = obj as LargeObjectOuterAbstract;

            if(largeObjectOuter == null)
                return destination;

            var startingPoint = new Point(cell.X - largeObjectOuter.PlaceInObject.X, cell.Y - largeObjectOuter.PlaceInObject.Y);

            var innerObject = largeObjectOuter.InnerObject as Wickiup;
            var totDist = Int32.MaxValue;
            Point p = null;
            var heroPos = Map.PointToCell(hero.Position);

            for (int i = 0; i < (int)innerObject.Size.Width + 2; i++ )
            {
                for (int j = 0; j < (int) innerObject.Size.Height + 2; j++)
                {
                    if (i > 0 && i < (int) innerObject.Size.Width + 1 && j > 0 && j < (int) innerObject.Size.Height + 1)
                        continue;

                    var curPoint = new Point(i - 1, j - 1);
                    bool isPassable;

                    if (j == 0 || j == (int) innerObject.Size.Height + 1)
                    {
                        isPassable = innerObject.HorizontalBorder[i, j == 0 ? 0 : 1];
                    }
                    else
                    {
                        isPassable = innerObject.VerticalBorder[j - 1, i == 0 ? 0 : 1];
                    }

                    if (!isPassable)
                        continue;

                    int totdistX = Math.Abs(heroPos.X - startingPoint.X - curPoint.X);
                    int totdistY = Math.Abs(heroPos.Y - startingPoint.Y - curPoint.Y);

                    var curtotDist = totdistX*totdistX + totdistY*totdistY;

                    if (curtotDist < totDist)
                    {
                        totDist = curtotDist;
                        p = curPoint;
                    }
                }
            }

            var newCenterPoint = Map.CellToPoint(new Point(startingPoint.X + p.X, startingPoint.Y + p.Y));
            var x = newCenterPoint.X + Map.CELL_MEASURE / 2 + (p.X > -1 && p.X < innerObject.Size.Width ? 0 :  p.X == -1 ? Map.CELL_MEASURE / 2 + 2 : -Map.CELL_MEASURE / 2 - 2);
            var y = newCenterPoint.Y + Map.CELL_MEASURE / 2 + (p.Y > -1 && p.Y < innerObject.Size.Height ? 0 : p.Y == -1 ? Map.CELL_MEASURE / 2 + 2 : -Map.CELL_MEASURE / 2 - 2);

            innerPoint = startingPoint;

            return new Point(x, y);
        }
 public static Point GetInsidePoint(IReadOnlyList<Point> points, Box boundingBox)
 {
     var y = (boundingBox.MinY + boundingBox.MaxY) / 2;
     var xIntersections = new List<double>();
     var point1 = points.Last();
     foreach (var point2 in points)
     {
         if ((y > point1.Y) != (y > point2.Y))
         {
             xIntersections.Add((y - point2.Y) * (point1.X - point2.X) / (point1.Y - point2.Y) + point2.X);
         }
         point1 = point2;
     }
     xIntersections.Sort();
     Debugger.BreakWhen(xIntersections.Count == 0 || xIntersections.Count % 2 != 0);
     var x = (boundingBox.MinX + boundingBox.MaxX) / 2;
     var maxDelta = double.NegativeInfinity;
     for (var i = 0; i < xIntersections.Count - 1; i += 2)
     {
         var delta = Math.Abs(xIntersections[i] - xIntersections[i + 1]);
         if (delta > maxDelta)
         {
             x = (xIntersections[i] + xIntersections[i + 1]) / 2;
             maxDelta = delta;
         }
     }
     var point = new Point(x, y);
     #if DEBUG
     Debugger.BreakWhen(!PointInPolygonTest.Contains(points, point));
     #endif
     return point;
 }
Example #4
1
        // p1: đối thủ
        // p2: 
        private Point TimKiemNuocDi(int p1, int p2)
        {
            Point oCoResult = new Point();
            long DiemMax = 0;
            for (int i = 0; i < cell_quantity; i++)
            {
                for (int j = 0; j < cell_quantity; j++)
                {
                    if (matrix[i, j] == 0)
                    {
                        long DiemTanCong = DiemTanCong_DuyetDoc(i, j, p1, p2) + DiemTanCong_DuyetNgang(i, j, p1, p2) + DiemTanCong_DuyetCheoNguoc(i, j, p1, p2) + DiemTanCong_DuyetCheoXuoi(i, j, p1, p2);
                        long DiemPhongNgu = DiemPhongNgu_DuyetDoc(i, j, p1, p2) + DiemPhongNgu_DuyetNgang(i, j, p1, p2) + DiemPhongNgu_DuyetCheoNguoc(i, j, p1, p2) + DiemPhongNgu_DuyetCheoXuoi(i, j, p1, p2);
                        long DiemTam = DiemTanCong > DiemPhongNgu ? DiemTanCong : DiemPhongNgu;
                        if (DiemMax < DiemTam)
                        {
                            DiemMax = DiemTam;
                            oCoResult = new Point(i, j);

                        }
                    }
                }
            }

            return oCoResult;
        }
Example #5
1
            /// <summary>
            /// Blocking unary call example.  Calls GetFeature and prints the response.
            /// </summary>
            public void GetFeature(int lat, int lon)
            {
                try
                {
                    Log("*** GetFeature: lat={0} lon={1}", lat, lon);

                    Point request = new Point { Latitude = lat, Longitude = lon };
                    
                    Feature feature = client.GetFeature(request);
                    if (feature.Exists())
                    {
                        Log("Found feature called \"{0}\" at {1}, {2}",
                            feature.Name, feature.Location.GetLatitude(), feature.Location.GetLongitude());
                    }
                    else
                    {
                        Log("Found no feature at {0}, {1}",
                            feature.Location.GetLatitude(), feature.Location.GetLongitude());
                    }
                }
                catch (RpcException e)
                {
                    Log("RPC failed " + e);
                    throw;
                }
            }
Example #6
1
 public void AddMap(RobotMap map, Point offset)
 {
     foreach (var item in map.Map)
     {
         Map.Add(item.Key + offset, item.Value);
     }
 }
Example #7
1
 public RectangleImpl(Point lowerLeft, Point upperRight)
 {
     this.minX = lowerLeft.GetX();
     this.maxX = upperRight.GetX();
     this.minY = lowerLeft.GetY();
     this.maxY = upperRight.GetY();
 }
Example #8
1
        public IList<Point> Filter(IList<Point> points)
        {
            IList<Point> result = new List<Point>();
            if (points.Count == 0)
            {
                return result;
            }

            var point = new Point(points.First());
            result.Add(point);

            foreach (var currentSourcePoint in points.Skip(1))
            {
                if (!this.DistanceIsTooSmall(currentSourcePoint, point))
                {
                    point = new Point(currentSourcePoint);
                    result.Add(point);
                }
            }

            if (this.checkBoundary && result.Count > 1)
            {
                CheckFirstAndLastPoint(result);
            }

            return result;
        }
Example #9
1
 public void TestDistance()
 {
     Point p1 = new Point(-2, -3);
     Point p2 = new Point(-4, 4);
     double distance = Trigonometry.Distance(p1, p2);
     Assert.AreEqual(7.28, distance, 0.01);
 }
Example #10
1
 public Vertex(Point p)
 {
     Self = p;
     Num = Low = 0;
     Visited = false;
     Parent = null;
 }
Example #11
1
 public Pathfinding(Map ma, Point m, Point t, int r)
 {
     map = ma;
     me = m;
     target = t;
     range = r;
 }
Example #12
1
 public Point ToPixelSpace(Point quadraticPos)
 {
     var pixelPos = new Point(
         quadraticToPixelScale.Width * quadraticPos.X + quadraticToPixelOffset.X,
         quadraticToPixelScale.Height * quadraticPos.Y + quadraticToPixelOffset.Y);
     return new Point((float)Math.Round(pixelPos.X, 2), (float)Math.Round(pixelPos.Y, 2));
 }
Example #13
1
 public override void SubmitForm(Form form)
 {
     base.SubmitForm(form);
     BlockWidth = (int)form.Datas["BlockWidth"];
     BlockHeight = (int)form.Datas["BlockHeight"];
     BlockCenter = (Point)form.Datas["BlockCenter"];
 }
Example #14
1
 public string[] PrintMap(int xMin, int yMin, int width, int heigth, Point robotPosition)
 {
     var robotX = robotPosition.X - xMin;
     var robotY = robotPosition.Y - yMin;
     var result = new string[heigth];
     for (int y = 0; y < heigth; y++)
     {
         var ch = new char[width];
         for (int x = 0; x < width; x++)
         {
             var p = new Point(xMin + x, yMin + y);
             if(robotX == x && robotY == y)
             {
                 ch[x] = '&';
             }
             else if (Map.ContainsKey(p))
             {
                 ch[x] = (char)Map[p];
             }
             else ch[x] = ' ';
         }
         result[y] = new string(ch);
     }
     Array.Reverse(result);
     return result;
 }
        public Point GetPointAtFractionLength(double t, out Point tangent)
        {
            // Calculate point on curve.
            double x = (1 - t) * (1 - t) * (1 - t) * Point0.X +
                       3 * t * (1 - t) * (1 - t) * Point1.X +
                       3 * t * t * (1 - t) * Point2.X +
                       t * t * t * Point3.X;

            double y = (1 - t) * (1 - t) * (1 - t) * Point0.Y +
                       3 * t * (1 - t) * (1 - t) * Point1.Y +
                       3 * t * t * (1 - t) * Point2.Y +
                       t * t * t * Point3.Y;

            Point point = new Point(x, y);

            // Calculate tangent to curve.
            x = 3 * (1 - t) * (1 - t) * (Point1.X - Point0.X) +
                6 * t * (1 - t) * (Point2.X - Point1.X) +
                3 * t * t * (Point3.X - Point2.X);

            y = 3 * (1 - t) * (1 - t) * (Point1.Y - Point0.Y) +
                6 * t * (1 - t) * (Point2.Y - Point1.Y) +
                3 * t * t * (Point3.Y - Point2.Y);

            tangent = new Point(x, y);
            return point;
        }
Example #16
1
 public void Func1()
 {
     Point a = new Point(10, 10);
     Point b = a;
     a.x = 100;
     System.Console.WriteLine(b.x);
 }
 public void DrawLine(Pen pen, Point p1, Point p2)
 {
     using (var paint = CreatePaint(pen, new Size(Math.Abs(p2.X - p1.X), Math.Abs(p2.Y - p1.Y))))
     {
         Canvas.DrawLine((float)p1.X, (float)p1.Y, (float)p2.X, (float)p2.Y, paint.Paint);
     }
 }
Example #18
0
        private static System.String _GetGeoCoordinateString(System.Point GeoLocation)
        {
            var Longitude = System.Windows.Forms.Map.GetLongitudeCoordinatesFromLongitudeLocation(GeoLocation.X);
            var Latitude  = System.Windows.Forms.Map.GetLongitudeCoordinatesFromLongitudeLocation(GeoLocation.Y);

            return(Latitude.GetTruncatedAsInt32() + "° " + System.Math.Abs(Latitude.GetFraction() * 600000.0).GetTruncatedAsInt32() + "’ " + ((Latitude > 0) ? ("N") : ("S")) + ", " + Longitude.GetTruncatedAsInt32() + "° " + System.Math.Abs(Longitude.GetFraction() * 600000.0).GetTruncatedAsInt32() + "’ " + ((Longitude > 0) ? ("O") : ("W")));
        }
Example #19
0
 public ScSign(string text, TSPlayer registrar, Point point)
 {
     _point = point;
     cooldown = 0;
     _cooldownGroup = string.Empty;
     RegisterCommands(text, registrar);
 }
Example #20
0
        static void Main(string[] args)
        {
            Point p1 = new Point();
            p1.x = 1;
            p1.y = 3;
            p1.sym = '*';
            p1.Draw();

            /*int x1 = 1;
              int y1 = 3;
                  char sym1 = '*';
              Draw(x1, x1, sym1); */

            Point p2 = new Point();
            p2.x =4;
            p2.y = 5;
            p2.sym = '#';
            p2.Draw();

            /*
            int x2 = 4;
            int y2 = 5;
            char sym2 = '#';
            Draw(x2, y2, sym2); */

            Console.ReadLine();
        }
Example #21
0
 public VoronoiRegion(Vertex generator)
 {
     this.id = generator.id;
     this.generator = generator;
     this.vertices = new List<Point>();
     this.bounded = true;
 }
Example #22
0
        internal static void Solve_Part2()
        {
            Console.WriteLine("Solving Day 01, Part 2...");

              var directions = System.IO.File.ReadAllText("01.txt").Split(',');
              var pt = new Point();
              var hist = new List<string>();

              foreach (var direction in directions)
              {
            if (string.IsNullOrWhiteSpace(direction))
              continue;

            var beenThere = pt.Walk(
              direction.Trim().Substring(0, 1),
              int.Parse(direction.Trim().Substring(1)),
              true);
            if (beenThere)
              break;
              }

              // wrong:
              //   297 (high)
              // correct:
              //   163

              return;
        }
        public override void NowPrimaried(object request)
        {
            TargettingKeystrokeRequest targettingRequest = (TargettingKeystrokeRequest)request;
            m_targetablePoints = targettingRequest.TargetablePoints;
            m_selectionDelegate = targettingRequest.SelectionDelegate;

            if (m_selectionDelegate == null)
                throw new ArgumentNullException("Selection delegate for targetting must not be null");
            
            m_alternateSelectionKey = targettingRequest.AlternateSelectionKey;

            m_targettingType = targettingRequest.TargettingType;

            SelectionPoint = SetTargettingInitialSpot(m_engine);

            EnablePlayerTargeting enableRequest = new EnablePlayerTargeting(true, m_targetablePoints);
            if (targettingRequest.HaloDelegate != null)
                enableRequest.HaloDelegate = x => targettingRequest.HaloDelegate(x);

            m_gameInstance.SendPaintersRequest(enableRequest);
            m_gameInstance.SendPaintersRequest(new EnableMapCursor(true, SelectionPoint));

            // If we have no targetable points, just exit now
            if (m_targetablePoints.Count == 0)
                Escape();

            m_gameInstance.UpdatePainters();
        }
Example #24
0
        internal static void Solve_Part1()
        {
            Console.WriteLine("Solving Day 01, Part 1...");

              var directions = System.IO.File.ReadAllText("01.txt").Split(',');
              var pt = new Point();

              foreach (var direction in directions)
              {
            if (string.IsNullOrWhiteSpace(direction))
              continue;

            pt.Walk(
              direction.Trim().Substring(0, 1),
              int.Parse(direction.Trim().Substring(1)),
              false);
              }

              Console.WriteLine($"You are at {pt}; which is {Math.Abs(pt.X) + Math.Abs(pt.Y)} blocks away...");

              // correct:
              //   279

              return;
        }
 private void drawLine(Point p1, Point p2, ViewBase view)
 {
     TSD.Line newLine = new TSD.Line(view, p1, p2);
     LineTypeAttributes lineParams = new LineTypeAttributes(LineTypes.SolidLine, DrawingColors.Black);
     newLine.Attributes.Line = lineParams;
     newLine.Insert();
 }
Example #26
0
 public Figure(Point p1, Point p2, Point p3)
 {
     this.p1 = new Point(p1.X, p1.Y, p1.Name);
     this.p2 = new Point(p2.X, p2.Y, p3.Name);
     this.p3 = new Point(p3.X, p3.Y, p3.Name);
     name = "Triangle";
 }
Example #27
0
        public Normal ComputeVerticeNormal(int vInd, ref Point[] meshVertices) {
            Point v_0, v_1, v_2;

            switch (vInd) {
                case 0:
                    v_0 = meshVertices[v0];
                    v_1 = meshVertices[v1];
                    v_2 = meshVertices[v2];
                    break;
                case 1:
                    v_0 = meshVertices[v1];
                    v_1 = meshVertices[v0];
                    v_2 = meshVertices[v2];
                    break;
                case 2:
                    v_0 = meshVertices[v2];
                    v_1 = meshVertices[v1];
                    v_2 = meshVertices[v0];
                    break;
                default:
                    throw new ArgumentException();
            }
            var Normal = (Normal)((v_1 - v_0) ^ (v_2 - v_0)).Normalize();
            //var Normal = (Normal)((v_0 - v_1) ^ (v_0 - v_2)).Normalize();

            return Normal;
        }
 public void RTreeQuery_PointIntersectionTest()
 {
     for (int seed = 0; seed < 1; ++seed)
     {
         int n = 100000;
         var points = new Point[n];
         var rand = new Random(seed);
         double scale = 1000;
         for (int i = 0; i < n; ++i)
         {
             points[i] = new Point(rand.NextDouble() * scale, rand.NextDouble() * scale);
         }
         var bsptree = new RTree<Point>(
             from p in points
             select new KeyValuePair<Rectangle, Point>(new Rectangle(p), p));
         Assert.AreEqual(bsptree.GetAllLeaves().Count(), n);
         Assert.AreEqual(bsptree.GetAllIntersecting(new Rectangle(-2, -2, -1, -1)).Count(), 0);
         Assert.AreEqual(bsptree.GetAllIntersecting(new Rectangle(0, 0, scale, scale)).Count(), n);
         int intersecting = 0;
         for (int i = 0; i < 10000; ++i)
         {
             double s = scale / 100;
             var query = new Rectangle(rand.NextDouble() * s, rand.NextDouble() * s, rand.NextDouble() * s, rand.NextDouble() * s);
             if (bsptree.IsIntersecting(query))
             {
                 ++intersecting;
             }
         }
         System.Console.WriteLine(intersecting);
     }
 }
Example #29
0
 public static Point ConvertDirectionToDestinationPoint(Point initial, Direction direction)
 {
     Point destPoint;
     switch (direction)
     {
         case Direction.North:
             destPoint = new Point(initial.X, initial.Y - 1);
             break;
         case Direction.South:
             destPoint = new Point(initial.X, initial.Y + 1);
             break;
         case Direction.West:
             destPoint = new Point(initial.X - 1, initial.Y);
             break;
         case Direction.East:
             destPoint = new Point(initial.X + 1, initial.Y);
             break;
         case Direction.Northeast:
             destPoint = new Point(initial.X + 1, initial.Y - 1);
             break;
         case Direction.Northwest:
             destPoint = new Point(initial.X - 1, initial.Y - 1);
             break;
         case Direction.Southeast:
             destPoint = new Point(initial.X + 1, initial.Y + 1);
             break;
         case Direction.Southwest:
             destPoint = new Point(initial.X - 1, initial.Y + 1);
             break;
         default:
             throw new ArgumentException("ConvertDirectionToDestinationPoint - Invalid Direction");
     }
     return destPoint;
 }
Example #30
0
 public Point GetNextPoint()
 {
     Point head = pList.Last();
     Point nextPoint = new Point(head);
     nextPoint.Move(1, direction);
     return nextPoint;
 }
Example #31
0
        public void RunOnce(IRenderGDI aPort)
        {
            int i;
            int cxClient = fSize.cx;
            int cyClient = fSize.cy;
            Point[] points = new Point[fNumSegments];

            aPort.SaveState();

            aPort.SetDefaultPenColor(RGBColor.Red);
            aPort.MoveTo(0, cyClient / 2);
            aPort.LineTo(cxClient, cyClient / 2);

            aPort.SetDefaultPenColor(RGBColor.Black);
            for (i = 0; i < fNumSegments; i++)
            {
                points[i].x = i * cxClient / fNumSegments;
                points[i].y = (int)(((double)cyClient/2.0f)*(1.0f-Math.Sin(Math.PI*2.0f*(double)i/(double)fNumSegments)));
            }

            aPort.PolyLine(points);


            aPort.RestoreState();
        }
Example #32
0
 private void _UpdateCoordinatesLabel(System.Point GeoLocation)
 {
     _CoordinatesLabel.Text = _GetGeoCoordinateString(GeoLocation);
 }