コード例 #1
0
ファイル: Path_AStar.cs プロジェクト: Jamesc554/ProjectApollo
        private float Heuristic_cost_estimate(Path_Node <Tile> a, Path_Node <Tile> b)
        {
            if (b == null)
            {
                return(0f);
            }

            return((float)Math.Sqrt(Math.Pow(a.data.position.X - b.data.position.X, 2) + Math.Pow(a.data.position.Y - b.data.position.Y, 2)));
        }
コード例 #2
0
        public Path_TileGraph(World world)
        {
            nodes = new Dictionary <Tile, Path_Node <Tile> >();

            for (int x = 0; x < world.size.X; x++)
            {
                for (int y = 0; y < world.size.Y; y++)
                {
                    Tile t = world.GetTileAt(x, y);

                    if (t.movementCost > 0)
                    {
                        Path_Node <Tile> n = new Path_Node <Tile>();
                        n.data = t;
                        nodes.Add(t, n);
                    }
                }
            }

            // Debug.WriteLine("Path_TileGraph: Created " + nodes.Count + " nodes.");

            int edgeCount = 0;

            foreach (Tile t in nodes.Keys)
            {
                Path_Node <Tile> n = nodes[t];

                List <Path_Edge <Tile> > edges = new List <Path_Edge <Tile> >();

                Tile[] neighbours = t.GetNeighbours();

                for (int i = 0; i < neighbours.Length; i++)
                {
                    if (neighbours[i] != null && neighbours[i].movementCost > 0 && IsClippingCorner(t, neighbours[i]) == false)
                    {
                        Path_Edge <Tile> e = new Path_Edge <Tile>();
                        e.cost = neighbours[i].movementCost;
                        e.node = nodes[neighbours[i]];

                        edges.Add(e);
                        edgeCount++;
                    }
                }

                n.edges = edges.ToArray();
            }

            //Debug.WriteLine("Path_TileGraph: Created " + edgeCount + " edges.");
        }
コード例 #3
0
        private void GenerateEdgesByTile(Tile t)
        {
            Path_Node <Tile>         n     = nodes[t];
            List <Path_Edge <Tile> > edges = new List <Path_Edge <Tile> >();

            Tile[] neighbours = t.GetNeighbours();

            for (int i = 0; i < neighbours.Length; i++)
            {
                if (neighbours[i] != null && neighbours[i].movementCost > 0 && IsClippingCorner(t, neighbours[i]) == false)
                {
                    Path_Edge <Tile> e = new Path_Edge <Tile>();
                    e.cost = neighbours[i].movementCost;
                    e.node = nodes[neighbours[i]];

                    edges.Add(e);
                }
            }
            n.edges = edges.ToArray();
        }
コード例 #4
0
ファイル: Path_AStar.cs プロジェクト: Jamesc554/ProjectApollo
        private float Dist_between(Path_Node <Tile> a, Path_Node <Tile> b)
        {
            // We can make assumptions because we know we're working
            // on a grid at this point.

            // Hori/Vert neighbours have a distance of 1
            if (Math.Abs(a.data.position.X - b.data.position.X) + Math.Abs(a.data.position.Y - b.data.position.Y) == 1)
            {
                return(1f);
            }

            // Diag neighbours have a distance of 1.41421356237
            if (Math.Abs(a.data.position.X - b.data.position.X) == 1 && Math.Abs(a.data.position.Y - b.data.position.Y) == 1)
            {
                return(1.4f);
            }

            // Otherwise, do the actual math.
            return((float)Math.Sqrt(
                       Math.Pow(a.data.position.X - b.data.position.X, 2) +
                       Math.Pow(a.data.position.Y - b.data.position.Y, 2)));
        }
コード例 #5
0
ファイル: Path_AStar.cs プロジェクト: Jamesc554/ProjectApollo
        public Path_AStar(World world, Tile tileStart, Tile tileEnd)
        {
            if (world.tileGraph == null)
            {
                world.tileGraph = new Path_TileGraph(world);
            }

            Dictionary <Tile, Path_Node <Tile> > nodes = world.tileGraph.nodes;

            if (nodes.ContainsKey(tileStart) == false)
            {
                Debug.WriteLine("Path_AStar: The starting tile isn't in the list of nodes!");
                return;
            }

            Path_Node <Tile> start = nodes[tileStart];
            Path_Node <Tile> goal  = null;

            if (tileEnd != null)
            {
                if (nodes.ContainsKey(tileEnd) == false)
                {
                    Debug.WriteLine("Path_AStar: The ending tile isn't in the list of nodes!");
                    return;
                }

                goal = nodes[tileEnd];
            }

            HashSet <Path_Node <Tile> >             closedSet = new HashSet <Path_Node <Tile> >();
            SimplePriorityQueue <Path_Node <Tile> > openSet   = new SimplePriorityQueue <Path_Node <Tile> >();

            openSet.Enqueue(start, 0);

            Dictionary <Path_Node <Tile>, Path_Node <Tile> > cameFrom = new Dictionary <Path_Node <Tile>, Path_Node <Tile> >();

            Dictionary <Path_Node <Tile>, float> gScore = new Dictionary <Path_Node <Tile>, float>();

            gScore[start] = 0;

            Dictionary <Path_Node <Tile>, float> fScore = new Dictionary <Path_Node <Tile>, float>();

            fScore[start] = Heuristic_cost_estimate(start, goal);

            while (openSet.Count > 0)
            {
                Path_Node <Tile> current = openSet.Dequeue();
                // Debug.WriteLine("Next Node: X:" + current.data.position.X + " Y:" + current.data.position.Y);

                if (goal != null)
                {
                    if (current == goal)
                    {
                        reconstructPath(cameFrom, current);
                        return;
                    }
                }

                closedSet.Add(current);

                foreach (Path_Edge <Tile> edgeNeighbour in current.edges)
                {
                    Path_Node <Tile> neighbour = edgeNeighbour.node;

                    if (closedSet.Contains(neighbour))
                    {
                        continue;
                    }

                    float movementCostToNeighbour = neighbour.data.movementCost * Dist_between(current, neighbour);
                    float tentativeGScore         = gScore[current] + movementCostToNeighbour;

                    if (openSet.Contains(neighbour) && tentativeGScore >= gScore[neighbour])
                    {
                        continue;
                    }

                    cameFrom[neighbour] = current;
                    gScore[neighbour]   = tentativeGScore;
                    fScore[neighbour]   = gScore[neighbour] + Heuristic_cost_estimate(neighbour, goal);

                    if (openSet.Contains(neighbour) == false)
                    {
                        openSet.Enqueue(neighbour, fScore[neighbour]);
                    }
                    else
                    {
                        openSet.UpdatePriority(neighbour, fScore[neighbour]);
                    }
                }
            }
        }
コード例 #6
0
ファイル: Path_AStar.cs プロジェクト: Jamesc554/ProjectApollo
        private void reconstructPath(Dictionary <Path_Node <Tile>, Path_Node <Tile> > cameFrom, Path_Node <Tile> current)
        {
            Queue <Tile> totalPath = new Queue <Tile>();

            totalPath.Enqueue(current.data);

            while (cameFrom.ContainsKey(current))
            {
                current = cameFrom[current];
                totalPath.Enqueue(current.data);
                //Debug.WriteLine("Moving to new tile, X: " + current.data.position.X + " Y: " + current.data.position.Y);
            }


            path = new Queue <Tile>(totalPath.Reverse());
            //Debug.WriteLine("Path size: " + path.Count);
        }