Пример #1
0
        protected override int CalculateEstimatedCosts()
        {
            TreeNode_Base_Board endNode = (TreeNode_Base_Board)A_Star_Class_Reference.EndNode;
            int estimatedCosts          = (Math.Abs(endNode.X - X) + Math.Abs(endNode.Y - Y));

            return(estimatedCosts);
        }
Пример #2
0
        public void Update(GameTime gameTime)
        {
            gameTime_TotalSekonds_SinceLastGameStep += gameTime.ElapsedGameTime.TotalSeconds;

            if (isInitialized)
            {
                if (run)
                {
                    if (gameTime_TotalSekonds_SinceLastGameStep >= UpdateIntervalInSeconds)
                    {
                        gameTime_TotalSekonds_SinceLastGameStep = 0;

                        if (!endReached)
                        {
                            A_Star.Result result = a_Star.RunStep();

                            switch (result)
                            {
                            case A_Star.Result.NoSolution:
                                endReached = true;
                                break;

                            case A_Star.Result.SolutionFound:
                                endReached    = true;
                                solutionFound = true;

                                bool startfound = false;
                                TreeNode_Base_Board actualNode = (TreeNode_Base_Board)a_Star.EndNode;

                                while (!startfound)
                                {
                                    SolutionLength++;
                                    actualNode = (TreeNode_Base_Board)actualNode.PreviousNode;

                                    if (actualNode == a_Star.StartNode)
                                    {
                                        startfound = true;
                                    }
                                    else
                                    {
                                        tileMap[actualNode.X, actualNode.Y].Type = Tile.TileType.Blue;
                                    }
                                }

                                break;

                            case A_Star.Result.StepDone:
                                break;
                            }
                        }
                        else
                        {
                            run = false;
                            OnFinished(this, new EventArgs());
                        }
                    }
                }
            }
        }
Пример #3
0
        public static void TileTypeChanged(object sender, EventArgs e)
        {
            TreeNode_Base_Board node = (TreeNode_Base_Board)sender;

            if (node != node.A_Star_Class_Reference.EndNode)
            {
                if (node.ActualState == TreeNode_Base.State.Open)
                {
                    tileMap[node.X, node.Y].Type = Tile.TileType.Red;
                }
                else if (node.ActualState == TreeNode_Base.State.Closed)
                {
                    tileMap[node.X, node.Y].Type = Tile.TileType.Green;
                }
            }
        }
Пример #4
0
        public static List <TreeNode_Base> GetAllConnectedWhiteTiles(TreeNode_Base_Board tile)
        {
            List <TreeNode_Base> nodeList = new List <TreeNode_Base>();

            if (tile.X > 0)
            {
                if (tileMap[tile.X - 1, tile.Y].Type == Tile.TileType.White)
                {
                    nodeList.Add(CreateTreeNode(tile.X - 1, tile.Y, tile.A_Star_Class_Reference));
                }

                if (tileMap[tile.X - 1, tile.Y].Type == Tile.TileType.End)
                {
                    nodeList.Add(tile.A_Star_Class_Reference.EndNode);
                }
            }

            if (tile.X < (TileCountWidth - 1))
            {
                if (tileMap[tile.X + 1, tile.Y].Type == Tile.TileType.White)
                {
                    nodeList.Add(CreateTreeNode(tile.X + 1, tile.Y, tile.A_Star_Class_Reference));
                }

                if (tileMap[tile.X + 1, tile.Y].Type == Tile.TileType.End)
                {
                    nodeList.Add(tile.A_Star_Class_Reference.EndNode);
                }
            }

            if (tile.Y > 0)
            {
                if (tileMap[tile.X, tile.Y - 1].Type == Tile.TileType.White)
                {
                    nodeList.Add(CreateTreeNode(tile.X, tile.Y - 1, tile.A_Star_Class_Reference));
                }

                if (tileMap[tile.X, tile.Y - 1].Type == Tile.TileType.End)
                {
                    nodeList.Add(tile.A_Star_Class_Reference.EndNode);
                }
            }

            if (tile.Y < (TileCountHeigth - 1))
            {
                if (tileMap[tile.X, tile.Y + 1].Type == Tile.TileType.White)
                {
                    nodeList.Add(CreateTreeNode(tile.X, tile.Y + 1, tile.A_Star_Class_Reference));
                }

                if (tileMap[tile.X, tile.Y + 1].Type == Tile.TileType.End)
                {
                    nodeList.Add(tile.A_Star_Class_Reference.EndNode);
                }
            }

            foreach (TreeNode_Base_Board node in nodeList)
            {
                node.ActualStateChanged += new EventHandler(TileTypeChanged);
            }

            return(nodeList);
        }