private void DijkstraChart_MouseClick(object sender, MouseEventArgs e)
        {
            if (isWalking)
            {
                return;
            }

            var results = dijkstraChart.HitTest(
                e.X, e.Y, false, ChartElementType.PlottingArea);

            foreach (var result in results)
            {
                if (result.ChartElementType == ChartElementType.PlottingArea)
                {
                    var xVal = result.ChartArea.AxisX.PixelPositionToValue(e.X);
                    var yVal = result.ChartArea.AxisY.PixelPositionToValue(e.Y);
                    var dest = map.Points[(int)yVal, (int)xVal];
                    if (DijkstraPoint.IsPassable(dest))
                    {
                        isWalking = true;
                        Task.Run(() => DoDijkstra(dest))
                        .ContinueWith((_) => isWalking = false);
                    }
                }
            }
        }
Example #2
0
        public void RedrawRoute()
        {
            Stopwatch sw;

            sw = Stopwatch.StartNew();
            Point3D       start  = new Point3D(beginx, beginy, beginz);
            Point3D       target = new Point3D(endx, endy, endz);
            var           res    = Pathfinder.FindRoute(start, target, new Bitmap(mapImages[start.Z]));
            DijkstraPoint point  = res.Item1;
            var           rects  = res.Item2;

            sw.Stop();
            Console.WriteLine("Find Route: {0}ms", sw.Elapsed.TotalMilliseconds);


            Bitmap bitmap = new Bitmap(mapImages[beginz]);

            DijkstraPoint tempPoint = point;

            while (point != null)
            {
                if (point.point.X < mapX)
                {
                    mapX = point.point.X - 20;
                }
                if (point.point.X > mapX + mapWidth)
                {
                    mapWidth = point.point.X - mapX + 20;
                }
                if (point.point.Y < mapY)
                {
                    mapY = point.point.Y - 20;
                }
                if (point.point.Y > mapY + mapHeight)
                {
                    mapHeight = point.point.Y - mapY + 20;
                }
                point = point.previous;
            }
            point = tempPoint;
            using (Graphics gr = Graphics.FromImage(bitmap)) {
                while (point.previous != null)
                {
                    gr.DrawLine(Pens.Black, new Point((int)point.point.X, (int)point.point.Y), new Point((int)point.previous.point.X, (int)point.previous.point.Y));
                    point = point.previous;
                }

                foreach (Rectangle3D rect in rects)
                {
                    gr.DrawRectangle(Pens.Yellow, rect.Rect);
                }
            }
            bigMap = bitmap;
            UpdateMap();
        }
        private void UpdatePointColor(DijkstraPoint p, Color color)
        {
            int index = (p.Y * map.Width) + p.X;

            void UpdatePointColor()
            {
                dijkstraChart.Series[0].Points[index].Color = color;
            };

            ExecuteInUI(UpdatePointColor);
        }
        private void DoDijkstra(DijkstraPoint dest)
        {
            var route = Dijsktra.FindShortestPath(
                map, map.CurrentPosition, dest, UpdateColor);

            route = route.Reverse();
            DisplayRoute(route.Skip(1));
            WalkRoute(route.Take(route.Count() - 1));
            UpdatePointColor(route.Last(), Color.Red);
            map.CurrentPosition = route.Last();
            ResetMap();
        }
        private void UpdateColor(DijkstraPoint point, Color color)
        {
            void UpdateColor()
            {
                dijkstraChart.Series[0].Points[point.Y * map.Width + point.X].Color =
                    color;
            }

            ExecuteInUI(UpdateColor);

            //RefreshChart(dijkstraChart);
        }
        public void FillSeries()
        {
            dijkstraSeries["PointWidth"] = "0.2";

            foreach (var point in map.Points)
            {
                var p = new DataPoint(point.X, point.Y)
                {
                    Color       = DijkstraPoint.TypeToColor(point.Type),
                    MarkerSize  = 7,
                    MarkerStyle = MarkerStyle.Square,
                };
                dijkstraSeries.Points.Add(p);
            }

            int index = (map.CurrentPosition.Y * map.Width) +
                        map.CurrentPosition.X;

            dijkstraSeries.Points[index].Color = Color.Red;
        }
        private Color GetDijkstraPointColor(DijkstraPoint p)
        {
            int index = (p.Y * map.Width) + p.X;

            return(dijkstraChart.Series[0].Points[index].Color);
        }