Exemple #1
0
 public Node(Node prev, Vector2 index)
 {
     this.prev = prev;
     this.tile = TileMap.getTileByIndex((int)index.X, (int)index.Y);
 }
Exemple #2
0
 private bool HasNode(List<Node> list, Node node)
 {
     foreach (Node listNode in list)
     {
         if (listNode.tile == node.tile)
         {
             return true;
         }
     }
     return false;
 }
Exemple #3
0
        public Node(Node prev, int x, int y)
        {
            this.prev = prev;
            this.dist = prev == null ? 0 : this.prev.dist + 1;

            this.tile = TileMap.getTileByIndex(x, y);
        }
Exemple #4
0
        public bool Path(List<Tile> targetTiles)
        {
            Node startNode = new Node(null, this.tile.index);

            Node finalNode = null;

            List<Node> targetNodes = new List<Node>();
            foreach (Tile tile in targetTiles)
            {
                Node targetNode = new Node(null, tile.index);

                targetNodes.Add(targetNode);

                if (targetNode.x == startNode.x && targetNode.y == startNode.y)
                {
                    this.targetTile = targetNode.tile;
                    this.path = new List<Tile>();
                    path.Insert(0, tile);
                    return true;
                }

            }

            int radius = 32;

            bool pathed = false;

            List<Node> visited = new List<Node>();
            List<Node> edge = new List<Node>();

            edge.Add(startNode);

            Node left, right, up, down;

            while (edge.Count() > 0 && !pathed)
            {
                Node curr = edge.First();
                edge.Remove(curr);
                visited.Add(curr);

                up = down = right = left = null;
                List<Node> nexts = new List<Node>();

                if (curr.x - 1 > this.tile.index.X - radius)
                {
                    left = new Node(curr, curr.x - 1, curr.y);
                    nexts.Add(left);
                }
                if (curr.y - 1 > this.tile.index.Y - radius)
                {
                    up = new Node(curr, curr.x, curr.y - 1);
                    nexts.Add(up);
                }
                if (curr.x < this.tile.index.X + radius)
                {
                    right = new Node(curr, curr.x + 1, curr.y);
                    nexts.Add(right);
                }
                if (curr.y < this.tile.index.Y + radius)
                {
                    down = new Node(curr, curr.x, curr.y + 1);
                    nexts.Add(down);
                }

                //add the diagonals
                if (up != null && left != null && up.passable && left.passable)
                {
                //    nexts.Add(new Node(curr, curr.x - 1, curr.y - 1));
                }
                if (up != null && right != null && up.passable && right.passable)
                {
                  //  nexts.Add(new Node(curr, curr.x + 1, curr.y - 1));
                }
                if (down != null && left != null && down.passable && left.passable)
                {
                  //  nexts.Add(new Node(curr, curr.x - 1, curr.y + 1));
                }
                if (down != null && right != null && down.passable && right.passable)
                {
                //    nexts.Add(new Node(curr, curr.x + 1, curr.y + 1));
                }

                    foreach(Node n in nexts)
                    {
                        if(HasNode(edge,n) || HasNode(visited, n))
                        {
                            //done
                        }
                        else if((n.passable || (n.tile.block != null && n.tile.block == pickupBlock) )&& n.dist < 64)
                        {
                            edge.Add(n);

                            foreach (Node targetNode in targetNodes)
                            {
                                if (n.x == targetNode.x && n.y == targetNode.y)
                                {
                                    finalNode = n;
                                    pathed = true;
                                    break;
                                }
                            }
                        }

                    }
                   // edge.Sort((s1,s2) => s1.dist.CompareTo(s2.dist));
                }

            if (pathed && finalNode != null)
            {
                Node curr = finalNode;
                this.path = new List<Tile>();
                do
                {
                    this.path.Insert(0, curr.tile);

                    curr = curr.prev;
                } while (curr != null);
                this.targetTile = path.First();
                return true;
            }
            return false;
        }