Exemple #1
0
        public override int chooseMove(Board b)
        {
            int    move = -1;
            string moveString;

            while (!b.LegalMove(move))
            {
                Console.Write("Your move: ");
                moveString = Console.ReadLine();
                if (!int.TryParse(moveString, out move) || !b.LegalMove(move))
                {
                    Console.WriteLine("Illegal move. Try again.");
                }
            }
            return(move);
        }
Exemple #2
0
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        // METHOD SEPARATOR METHOD SEPARATOR METHOD SEPARATOR METHOD SEPARATOR METHOD SEPARATOR METHOD SEPARATOR METHOD SEPARATOR
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

        /// <summary>
        /// Method permits the user to choose his or her move.
        /// </summary>
        /// <param name="b">Game Board object</param>
        ///
        /// <returns>the move the user chose to make</returns>
        public override int ChooseMove(Board b)
        {
            int    move = -1;
            string moveString;

            // Continue asking for a legal move, if illegal.
            while (!b.LegalMove(move))
            {
                Console.Write("Your move: ");
                moveString = Console.ReadLine();

                // Obtain integer representation of move and store in variable.
                if (!int.TryParse(moveString, out move) || !b.LegalMove(move))
                {
                    Console.WriteLine("Illegal move. Try again.");
                }
            }
            return(move);
        }
Exemple #3
0
        public Tuple <int, double> MiniMax(Board board, int depth, double alpha, double beta)
        {
            double bestResult = 0;
            double result     = 0;
            int    bestMove   = 0;

            if (board.GameOver() || depth == 0)
            {
                return(new Tuple <int, double>(0, evaluate(board)));
            }

            int start = 0;

            if (board.WhoseMove() == Position.Top)
            {
                start = 7;
            }
            else
            {
                start = 0;
            }

            if (board.WhoseMove() == position)
            {
                bestResult = double.NegativeInfinity;
                for (int move = start; move <= start + 5; move++)
                {
                    if (board.LegalMove(move) && timer.ElapsedMilliseconds < getTimePerMove())
                    {
                        Board tempBoard = new Board(board);             //duplicate board
                        tempBoard.MakeMove(move, false);                //make the move
                        result = MiniMax(tempBoard, depth - 1, alpha, beta).Item2;
                        if (result > bestResult)                        //find its value
                        {
                            bestResult = result;                        //remember if best
                            bestMove   = move;
                        }
                        if (bestResult > alpha)
                        {
                            alpha = bestResult;
                        }
                        if (beta <= alpha)
                        {
                            break;
                        }
                    }
                }
            }
            else
            {
                bestResult = double.PositiveInfinity;
                for (int move = start; move <= start + 5; move++)
                {
                    if (board.LegalMove(move) && timer.ElapsedMilliseconds < getTimePerMove())
                    {
                        Board tempBoard = new Board(board);             //duplicate board
                        tempBoard.MakeMove(move, false);                //make the move
                        result = MiniMax(tempBoard, depth - 1, alpha, beta).Item2;
                        if (result < bestResult)                        //find its value
                        {
                            bestResult = result;                        //remember if best
                            bestMove   = move;
                        }
                        if (beta < bestResult)
                        {
                            beta = bestResult;
                        }
                        if (beta <= alpha)
                        {
                            break;
                        }
                    }
                }
            }
            return(new Tuple <int, double>(bestMove, bestResult));
        }