예제 #1
0
 // Simulates a game to the end (game over) based on the default policy
 // Returns the game over state
 private State SimulateGame(State state, int POLICY)
 {
     if (POLICY == RANDOM_POLICY)
     {
         while (state.GetMoves().Count != 0)
         {
             state = state.ApplyMove(state.GetRandomMove());
         }
         return state;
     }
     else if (POLICY == BEST_EVAL_POLICY)
     {
         List<Move> moves = state.GetMoves();
         while (moves.Count != 0)
         {
             // random move for computer
             if (state.Player == GameEngine.COMPUTER)
             {
                 state = state.ApplyMove(state.GetRandomMove());
             }
             else
             {
                 // find the move that results in the best child state, based on the evaluation function
                 State bestState = null;
                 double bestScore = Double.MinValue;
                 foreach (Move move in moves)
                 {
                     State result = state.ApplyMove(move);
                     double score = AI.Evaluate(result);
                     if (score > bestScore)
                     {
                         bestScore = score;
                         bestState = result;
                     }
                 }
                 state = bestState;
             }
             moves = state.GetMoves();
         }
         return state;
     }
     else if (POLICY == EXPECTIMAX_POLICY)
     {
         Expectimax expectimax = new Expectimax(gameEngine, 2);
         while (state.GetMoves().Count != 0) {
             if (state.Player == GameEngine.COMPUTER)
             {
                 state = state.ApplyMove(state.GetRandomMove());
             }
             else
             {
                 Move move = expectimax.ExpectimaxAlgorithm(state, 2, weights);
                 state = state.ApplyMove(move);
             }
         }
         return state;
     }
     else throw new Exception();
 }
예제 #2
0
파일: Test.cs 프로젝트: kstrandby/2048-AI
        public void TestMCTStree()
        {
            WeightVectorAll weights = new WeightVectorAll { Corner = 0, Empty_cells = 0, Highest_tile = 0, Monotonicity = 0, Points =0, Smoothness = 0, Snake = 1, Trapped_penalty = 0 };
             int timeLimit = 100;

            int[][] state1 = new int[][] {
                new int[]{1024,16,0,0},
                new int[]{4,32,2,0},
                new int[]{64,16,0,0},
                new int[]{16,16,2,2}
            };
            int[][] state2 = new int[][] {
                new int[]{2,0,2,0},
                new int[]{8,2,0,0},
                new int[]{16,8,4,0},
                new int[]{64,4,4,0}
            };
            int[][] state3 = new int[][] {
                new int[]{16,16,16,4},
                new int[]{64,4,0,0},
                new int[]{8,0,2,0},
                new int[]{16,0,0,0}
            };
            int[][] state4 = new int[][] {
                new int[]{0,0,0,8},
                new int[]{0,0,16,16},
                new int[]{2,0,32,32},
                new int[]{2,4,16,8}
            };
            Console.WriteLine("Testing state1:");
            GameEngine gameEngine = new GameEngine();
            Minimax minimax = new Minimax(gameEngine, 0);
            Expectimax expectimax = new Expectimax(gameEngine, 0);
            MonteCarlo mcts = new MonteCarlo(gameEngine);

            Move minimaxMove = minimax.IterativeDeepening(new State(state1, CalculateScore(state1), GameEngine.PLAYER), timeLimit);
            Move expectimaxMove = expectimax.IterativeDeepening(new State(state1, CalculateScore(state1), GameEngine.PLAYER), timeLimit, weights);
            Move mctsMove = (mcts.TimeLimitedMCTS(new State(state1, CalculateScore(state1), GameEngine.PLAYER), timeLimit)).GeneratingMove;

            Console.WriteLine("Minimax move chosen: " + ((PlayerMove)minimaxMove).Direction);
            Console.WriteLine("Expectimax move chosen: " + ((PlayerMove)expectimaxMove).Direction);
            Console.WriteLine("MCTS move chosen: " + ((PlayerMove)mctsMove).Direction);

            Console.WriteLine("Testing state2:");
            minimaxMove = minimax.IterativeDeepening(new State(state2, CalculateScore(state2), GameEngine.PLAYER), timeLimit);
            expectimaxMove = expectimax.IterativeDeepening(new State(state2, CalculateScore(state2), GameEngine.PLAYER), timeLimit, weights);
            mctsMove = (mcts.TimeLimitedMCTS(new State(state2, CalculateScore(state2), GameEngine.PLAYER), timeLimit)).GeneratingMove;

            Console.WriteLine("Minimax move chosen: " + ((PlayerMove)minimaxMove).Direction);
            Console.WriteLine("Expectimax move chosen: " + ((PlayerMove)expectimaxMove).Direction);
            Console.WriteLine("MCTS move chosen: " + ((PlayerMove)mctsMove).Direction);

            Console.WriteLine("Testing state3:");
            minimaxMove = minimax.IterativeDeepening(new State(state3, CalculateScore(state3), GameEngine.PLAYER), timeLimit);
            expectimaxMove = expectimax.IterativeDeepening(new State(state3, CalculateScore(state3), GameEngine.PLAYER), timeLimit, weights);
            mctsMove = (mcts.TimeLimitedMCTS(new State(state3, CalculateScore(state3), GameEngine.PLAYER), timeLimit)).GeneratingMove;

            Console.WriteLine("Minimax move chosen: " + ((PlayerMove)minimaxMove).Direction);
            Console.WriteLine("Expectimax move chosen: " + ((PlayerMove)expectimaxMove).Direction);
            Console.WriteLine("MCTS move chosen: " + ((PlayerMove)mctsMove).Direction);

            Console.WriteLine("Testing state4:");
            minimaxMove = minimax.IterativeDeepening(new State(state4, CalculateScore(state4), GameEngine.PLAYER), timeLimit);
            expectimaxMove = expectimax.IterativeDeepening(new State(state4, CalculateScore(state4), GameEngine.PLAYER), timeLimit, weights);
            mctsMove = (mcts.TimeLimitedMCTS(new State(state4, CalculateScore(state4), GameEngine.PLAYER), timeLimit)).GeneratingMove;

            Console.WriteLine("Minimax move chosen: " + ((PlayerMove)minimaxMove).Direction);
            Console.WriteLine("Expectimax move chosen: " + ((PlayerMove)expectimaxMove).Direction);
            Console.WriteLine("MCTS move chosen: " + ((PlayerMove)mctsMove).Direction);
        }
예제 #3
0
 // Runs an entire game using the given AI type to decide on moves
 private static State RunAIGame(AI_TYPE AItype, bool print, int depth = 0, int timeLimit = 0, int iterationLimit = 0)
 {
     GameEngine game = new GameEngine();
     State end = null;
     if (AItype == AI_TYPE.CLASSIC_MINIMAX)
     {
         Minimax minimax = new Minimax(game, depth);
         end = minimax.RunClassicMinimax(print);
                     }
     else if (AItype == AI_TYPE.ALPHA_BETA)
     {
         Minimax minimax = new Minimax(game, depth);
         end = minimax.RunAlphaBeta(print);
     }
     else if (AItype == AI_TYPE.ITERATIVE_DEEPENING_ALPHA_BETA)
     {
         Minimax minimax = new Minimax(game, depth);
         end = minimax.RunIterativeDeepeningAlphaBeta(print, timeLimit);
     }
     else if (AItype == AI_TYPE.PARALLEL_ALPHA_BETA)
     {
         Minimax minimax = new Minimax(game, depth);
         end = minimax.RunParallelAlphaBeta(print);
     }
     else if (AItype == AI_TYPE.PARALLEL_ITERATIVE_DEEPENING_ALPHA_BETA)
     {
         Minimax minimax = new Minimax(game, depth);
         end = minimax.RunParallelIterativeDeepeningAlphaBeta(print, timeLimit);
     }
     else if (AItype == AI_TYPE.CLASSIC_EXPECTIMAX)
     {
         Expectimax expectimax = new Expectimax(game, depth);
         end = expectimax.RunClassicExpectimax(print, weights);
     }
     else if (AItype == AI_TYPE.EXPECTIMAX_STAR1)
     {
         Expectimax expectimax = new Expectimax(game, depth);
         end = expectimax.RunStar1Expectimax(print, weights);
     }
     else if (AItype == AI_TYPE.EXPECTIMAX_STAR1_FW_PRUNING)
     {
         Expectimax expectimax = new Expectimax(game, depth);
         end = expectimax.RunStar1WithUnlikelyPruning(print, weights);
     }
     else if (AItype == AI_TYPE.ITERATIVE_DEEPENING_EXPECTIMAX)
     {
         Expectimax expectimax = new Expectimax(game, depth);
         end = expectimax.RunIterativeDeepeningExpectimax(print, timeLimit, weights);
     }
     else if (AItype == AI_TYPE.PARALLEL_EXPECTIMAX)
     {
         Expectimax expectimax = new Expectimax(game, depth);
         end = expectimax.RunParallelClassicExpectimax(print, weights);
     }
     else if (AItype == AI_TYPE.PARALLEL_ITERATIVE_DEEPENING_EXPECTIMAX)
     {
         Expectimax expectimax = new Expectimax(game, depth);
         end = expectimax.RunParallelIterativeDeepeningExpectimax(print, timeLimit, weights);
     }
     else if (AItype == AI_TYPE.TT_ITERATIVE_DEEPENING_EXPECTIMAX)
     {
         Expectimax exptectimax = new Expectimax(game, depth);
         end = exptectimax.RunTTExpectimax(print, timeLimit, weights);
     }
     else if (AItype == AI_TYPE.TT_ITERATIVE_DEEPENING_STAR1)
     {
         Expectimax expectimax = new Expectimax(game, depth);
         end = expectimax.RunTTStar1(print, timeLimit, weights);
     }
     else if (AItype == AI_TYPE.EXPECTIMAX_WITH_ALL_IMPROVEMENTS)
     {
         Expectimax expectimax = new Expectimax(game, depth);
         end = expectimax.RunTTIterativeDeepeningExpectimaxWithStar1andForwardPruning(print, timeLimit, weights);
     }
     else if (AItype == AI_TYPE.EXPECTIMAX_WITH_ALL_IMPROVEMENTS_NO_FORWARDPRUNING)
     {
         Expectimax expectimax = new Expectimax(game, depth);
         end = expectimax.RunTTIterativeDeepeningExpectimaxWithStar1(print, timeLimit, weights);
     }
     else if (AItype == AI_TYPE.ITERATION_LIMITED_MCTS)
     {
         MonteCarlo MCTS = new MonteCarlo(game);
         end = MCTS.RunIterationLimitedMCTS(print, iterationLimit);
     }
     else if (AItype == AI_TYPE.TIME_LIMITED_MCTS)
     {
         MonteCarlo MCTS = new MonteCarlo(game);
         end = MCTS.RunTimeLimitedMCTS(print, timeLimit);
     }
     else if (AItype == AI_TYPE.ROOT_PARALLEL_ITERATION_LIMITED_MCTS)
     {
         MonteCarlo MCTS = new MonteCarlo(game);
         end = MCTS.RunRootParallelizationIterationLimitedMCTS(print, iterationLimit, NUM_THREADS);
     }
     else if (AItype == AI_TYPE.ROOT_PARALLEL_TIME_LIMITED_MCTS)
     {
         MonteCarlo MCTS = new MonteCarlo(game);
         end = MCTS.RunRootParallelizationTimeLimitedMCTS(print, timeLimit, NUM_THREADS);
     }
     else if (AItype == AI_TYPE.EXPECTIMAX_MCTS_TIME_LIMITED)
     {
         HeuristicLearning HL = new HeuristicLearning(game);
         end = HL.RunExpectimaxMCTStimeLimited(print, depth, timeLimit);
     }
     else if (AItype == AI_TYPE.EXPECTIMAX_MCTS_WITH_SIMULATIONS_TIME_LIMITED)
     {
         HeuristicLearning HL = new HeuristicLearning(game);
         end = HL.RunExpectimaxMCTSwithSimulations(print, depth, timeLimit);
     }
     else if (AItype == AI_TYPE.FINAL_COMBI)
     {
         HeuristicLearning HL = new HeuristicLearning(game);
         end = HL.RunParallelizationMCTSExpectimaxCombi(print, depth, timeLimit);
     }
     else
     {
         throw new Exception();
     }
     if (print)
     {
         Console.WriteLine("GAME OVER!\nFinal score: " + game.scoreController.getScore());
     }
     return end;
 }