dbravender/dartmcts - Change LT2L5OITYEO7I6P5WA35E5FJ5AUGPMLFYYKPVI4WLBIH65AINECQC

Further ports for the MCTS engine

Created by Dan Bravender on June 18, 2020

LT2L5OITYEO7I6P5WA35E5FJ5AUGPMLFYYKPVI4WLBIH65AINECQC

Dependencies

[2] U3JHTSEMJLXNKOMAQJQPZKRW6GRPHYLG6DK53XVADIETKVCS2MFQC

In channels

main

Change contents

Insertion in test/dartmcts_test.dart at line 1 [2.22]
[2.22]
[2.23]
```
import 'dart:math';
```

Insertion in test/dartmcts_test.dart at line 6 [2.22]

[2.114]


enum Player { FIRST, SECOND }
enum Move { WIN }
class GameWithOneMove implements GameState<Move, Player> {
  Player currentPlayer;
  Player winner;

Insertion in test/dartmcts_test.dart at line 15 [2.22]

[2.115]

  GameWithOneMove({this.winner, this.currentPlayer = Player.FIRST});
  @override
  GameWithOneMove cloneAndApplyMove(Move move) {
    if (move == null) {
      return this;
    }
    return GameWithOneMove(winner: currentPlayer, currentPlayer: Player.SECOND);
  }
  @override
  List<Move> getMoves() {
    if (winner == null) {
      return [Move.WIN];
    }
    return [];
  }
  @override
  GameState<Move, Player> determine(GameState<Move, Player> initialState) {
    return this;
  }
}
enum TicTacToePlayer { X, O }
final Set<int> winningTicTacToeScores = {7, 56, 448, 73, 146, 292, 273, 84};
class TicTacToeGame implements GameState<int, TicTacToePlayer> {
  List<TicTacToePlayer> board = [];
  TicTacToePlayer currentPlayer;
  TicTacToePlayer winner;
  TicTacToeGame({this.board, this.currentPlayer, this.winner});
  @override
  GameState<int, TicTacToePlayer> determine(
      GameState<int, TicTacToePlayer> initialState) {
    return this;
  }
  @override
  List<int> getMoves() {
    if (winner == null) {
      return board
          .asMap()
          .map((index, player) =>
              player == null ? MapEntry(index, null) : MapEntry(null, null))
          .keys
          .where((index) => index != null)
          .toList();
    }
    return [];
  }
  @override
  TicTacToeGame cloneAndApplyMove(int move) {
    if (move == null) {
      return this;
    }
    if (board[move] != null) {
      throw InvalidMove();
    }
    TicTacToePlayer newCurrentPlayer = currentPlayer == TicTacToePlayer.O
        ? TicTacToePlayer.X
        : TicTacToePlayer.O;
    TicTacToePlayer newWinner;
    List<TicTacToePlayer> newBoard = List.from(board);
    newBoard[move] = currentPlayer;
    Map<TicTacToePlayer, int> scoreByPlayer = {
      TicTacToePlayer.O: 0,
      TicTacToePlayer.X: 0
    };
    board.asMap().forEach((index, player) => {
          if (player != null)
            {scoreByPlayer[player] += pow(2.0, index.toDouble()).toInt()}
        });
    for (var player in scoreByPlayer.keys) {
      if (winningTicTacToeScores.contains(scoreByPlayer[player])) {
        newWinner = player;
      }
    }
    return TicTacToeGame(
        board: newBoard, winner: newWinner, currentPlayer: newCurrentPlayer);
  }
}

Replacement in test/dartmcts_test.dart at line 103 [2.22]

B:BD[2.129] → [2.129:387]

  test('adds one to input values', () {
    final calculator = Calculator();
    expect(calculator.addOne(2), 3);
    expect(calculator.addOne(-7), -6);
    expect(calculator.addOne(0), 1);
    expect(() => calculator.addOne(null), throwsNoSuchMethodError);

[2.129]

[2.387]

  test('game with one move works', () {
    var game = GameWithOneMove();
    expect(game.getMoves(), equals([Move.WIN]));
    var result =
        MCTS(gameState: GameWithOneMove()).getSimulationResult(iterations: 10);
    expect(result.move, equals(Move.WIN));
    expect(result.root.children.values.first.getWinner(), equals(Player.FIRST));

Insertion in test/dartmcts_test.dart at line 111 [2.22]

[2.393]

  test('selects winning tic tac toe move (scenario 1)', () {
    var o = TicTacToePlayer.O;
    var x = TicTacToePlayer.X;
    var e;
    var oneMoveFromWinning =
        TicTacToeGame(board: [o, o, e, x, e, x, e, x, e], currentPlayer: o);
    var result = MCTS(gameState: oneMoveFromWinning)
        .getSimulationResult(iterations: 100);
    expect(result.root.children.length, equals(4));
    expect(result.move, equals(2));
    expect(result.maxDepth, equals(4));
  });
  test('selects winning tic tac toe move (scenario 2)', () {
    var o = TicTacToePlayer.O;
    var x = TicTacToePlayer.X;
    var e;
    var oneMoveFromWinning =
        TicTacToeGame(board: [o, e, e, o, x, x, e, x, e], currentPlayer: o);
    var result = MCTS(gameState: oneMoveFromWinning)
        .getSimulationResult(iterations: 100);
    expect(result.root.children.length, equals(4));
    expect(result.maxDepth, equals(4));
    expect(result.move, equals(6));
  });

Insertion in test/dartmcts_test.dart at line 136 [2.22]

[2.395]


/*  @Test
    @Test
    fun testWinningBoard() {
        val e = null
        val r = FourInARowPlayer.RED
        val b = FourInARowPlayer.BLUE
        val board: FourInARowBoard = arrayOf(
                arrayOfNulls(7),
                arrayOfNulls(7),
                arrayOfNulls(7),
                arrayOfNulls(7),
                arrayOf(e, e, r, r, r, e, e),
                arrayOf(e, b, b, b, b, e, e))
        assertEquals(BigInteger("270549120"),
            getBitBoard(
                FourInARowPlayer.BLUE,
                board
            )
        )
        assertEquals(true,
            winningBoard(
                FourInARowPlayer.BLUE,
                board
            )
        )
    }
    @Test
    fun testOnlyDeterminedMovesAreFollowed() {
        result = (MCTS(GameWithManyMovesOnlyOneDetermined)
            .get_simulation_result(100))
        self.assertEqual(result.root.children[0].move, 1)
        self.assertEqual(result.root.children[0].visits, 100)
    }
    @Test
    fun testFourInARowWithMCTS() {
        val e = null
        val r = FourInARowPlayer.RED
        val b = FourInARowPlayer.BLUE
        val oneMoveFromWinning = FourInARowGame(
            board = arrayOf(
                arrayOfNulls(7),
                arrayOfNulls(7),
                arrayOfNulls(7),
                arrayOfNulls(7),
                arrayOf(e, e, r, r, r, e, e),
                arrayOf(e, e, b, b, b, e, e)
            ),
            currentPlayer = FourInARowPlayer.BLUE
        )
        val result = MCTS(oneMoveFromWinning).getSimulationResult(maxSeconds = 10)
        assertTrue(result.move in listOf(1, 5))
        val board = arrayOf(
                arrayOfNulls(7),
                arrayOfNulls(7),
                arrayOfNulls(7),
                arrayOfNulls(7),
                arrayOf(e, e, r, r, r, e, e),
                arrayOf(e, e, b, b, b, b, e))
        assertEquals(BigInteger("34630287360"),
            getBitBoard(b, board)
        )
        assertTrue(
            checkWin(
                getBitBoard(
                    b,
                    board
                )
            )
        )
    }
}
*/

Replacement in lib/dartmcts.dart at line 24 [2.12817]
B:BD[2.13400] → [2.13400:13443]
```
  final Map<PlayerType, int> winsByPlayer;
```
[2.13400]
[2.13443]
```
  final Map<PlayerType, int> winsByPlayer = {};
```

Replacement in lib/dartmcts.dart at line 36 [2.12817]

B:BD[2.13698] → [2.13698:13759]

      this.depth,
      this.winsByPlayer,
      this.draws,

[2.13698]

[2.13759]

      this.depth = 0,
      this.draws = 0,

Replacement in lib/dartmcts.dart at line 73 [2.12817]

B:BD[2.14652] → [2.14652:14727]

    return Map.fromEntries(_children.entries.where((x) => x.key == move));

[2.14652]

[2.14727]

    return Map.fromEntries(
        _children.entries.where((x) => moves.contains(x.value.move)));

Replacement in lib/dartmcts.dart at line 98 [2.12817]

B:BD[2.15200] → [2.15200:15714]

    var sortedChildren = children.entries
      ..toList().sort((a, b) {
        var aVisits = a.value.visits;
        var bVisits = b.value.visits;
        if (aVisits == 0 && bVisits == 0) {
          return random.nextInt(100).compareTo(random.nextInt(100));
        }
        if (aVisits == 0) {
          return -1;
        }
        if (bVisits == 0) {
          return 1;
        }
        return -a.value
            .ucb1(currentPlayer())
            .compareTo(-b.value.ucb1(currentPlayer()));
      });

[2.15200]

[2.15714]

    var sortedChildren = children.entries.toList();
    sortedChildren.sort((a, b) {
      var aVisits = a.value.visits;
      var bVisits = b.value.visits;
      if (aVisits == 0 && bVisits == 0) {
        return random.nextInt(100).compareTo(random.nextInt(100));
      }
      if (aVisits == 0) {
        return -1;
      }
      if (bVisits == 0) {
        return 1;
      }
      return b.value
          .ucb1(currentPlayer())
          .compareTo(a.value.ucb1(currentPlayer()));
    });

Replacement in lib/dartmcts.dart at line 139 [2.12817]

B:BD[2.16423] → [2.16423:16521]

      currentChildren =
          Map.fromEntries(_children.entries.where((x) => x.key == move));

[2.16423]

[2.16521]

      currentChildren = Map.fromEntries(
          _children.entries.where((x) => actualMoves.contains(x.value.move)));

Replacement in lib/dartmcts.dart at line 142 [2.12817]

B:BD[2.16527] → [2.16527:16671]

    var sortedChildren = currentChildren.entries
      ..toList().sort((a, b) => a.value.visits.compareTo(b.value.visits))
      ..first.value;

[2.16527]

[2.16671]

    var sortedChildren = currentChildren.entries.toList();
    sortedChildren.sort((b, a) => a.value.visits.compareTo(b.value.visits));

Insertion in lib/dartmcts.dart at line 160 [2.12817]
[2.17107]
[2.17107]
```
  MCTS({this.gameState});
```

Replacement in lib/dartmcts.dart at line 163 [2.12817]

B:BD[2.17163] → [2.17163:17242]

      Node<MoveType, PlayerType> initialRootNode,
      {int iterations = 100,

[2.17163]

[2.17242]

      {Node<MoveType, PlayerType> initialRootNode,
      int iterations = 100,