Add TicTacToe test

jsuyash1514 · jsuyash1514 · commit b79d03b3c9c0 · 2019-08-17T02:03:05.000+05:30
diff --git a/aima-core/src/main/java/aima/core/environment/tictactoe/TicTacToeState.java b/aima-core/src/main/java/aima/core/environment/tictactoe/TicTacToeState.java
@@ -19,11 +19,22 @@ public class TicTacToeState implements Cloneable {
 	public static final String X = "X";
 	public static final String EMPTY = "-";
 	//
-	private String[] board = new String[] { EMPTY, EMPTY, EMPTY, EMPTY, EMPTY,
-			EMPTY, EMPTY, EMPTY, EMPTY };
+	private String[] board;
 
-	private String playerToMove = X;
+	private String playerToMove;
 	private double utility = -1; // 1: win for X, 0: win for O, 0.5: draw
+	
+	public TicTacToeState(){
+		this.board = new String[] { EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY };
+		playerToMove = X;
+	}
+	
+	public TicTacToeState(String[] board, String playerToMove){
+		this.board = board;
+		this.playerToMove = (Objects.equals(playerToMove, X) ? O : X);
+		analyzeUtility();
+		this.playerToMove = playerToMove;
+	}
 
 	public String getPlayerToMove() {
 		return playerToMove;
diff --git a/aima-core/src/main/java/aima/core/search/adversarial/MonteCarloTreeSearch.java b/aima-core/src/main/java/aima/core/search/adversarial/MonteCarloTreeSearch.java
@@ -43,8 +43,8 @@ public A makeDecision(S state) {
 	}
 	
 	private Node<S, A> select(GameTree gameTree) {
-		Node node = gameTree.getRoot();
-		while (isNodeFullyExpanded(node)) {
+		Node<S, A> node = gameTree.getRoot();
+		while (!game.isTerminal(node.getState()) && isNodeFullyExpanded(node)) {
 			node = gameTree.getChildWithMaxUCT(node);
 		}
 		return node;
@@ -79,15 +79,16 @@ private A bestAction(Node<S, A> root) {
 		Node<S, A> bestChild = tree.getChildWithMaxPlayouts(root);
 		for (A a : game.getActions(root.getState())) {
 			S result = game.getResult(root.getState(), a);
-			if (result == bestChild.getState()) return a;
+			if (result.equals(bestChild.getState())) return a;
 		}
 		return null;
 	}
 	
 	private boolean isNodeFullyExpanded(Node<S, A> node) {
+		List<S> visitedChildren = tree.getVisitedChildren(node);
 		for (A a : game.getActions(node.getState())) {
 			S result = game.getResult(node.getState(), a);
-			if (!tree.contains(result)) {
+			if (!visitedChildren.contains(result)) {
 				return false;
 			}
 		}
@@ -97,9 +98,10 @@ private boolean isNodeFullyExpanded(Node<S, A> node) {
 	
 	private Node<S, A> randomlySelectUnvisitedChild(Node<S, A> node) {
 		List<S> unvisitedChildren = new ArrayList<>();
+		List<S> visitedChildren = tree.getVisitedChildren(node);
 		for (A a : game.getActions(node.getState())) {
 			S result = game.getResult(node.getState(), a);
-			if (!tree.contains(result)) unvisitedChildren.add(result);
+			if (!visitedChildren.contains(result)) unvisitedChildren.add(result);
 		}
 		Random rand = new Random();
 		Node<S, A> newChild = tree.addChild(node, unvisitedChildren.get(rand.nextInt(unvisitedChildren.size())));
diff --git a/aima-core/src/main/java/aima/core/search/framework/GameTree.java b/aima-core/src/main/java/aima/core/search/framework/GameTree.java
@@ -31,6 +31,16 @@ public Node<S, A> getRoot() {
 		return root;
 	}
 	
+	public List<S> getVisitedChildren(Node<S, A> parent) {
+		List<S> visitedChildren = new ArrayList<>();
+		if (gameTree.containsKey(parent)) {
+			for (Node<S, A> child : gameTree.get(parent)) {
+				visitedChildren.add(child.getState());
+			}
+		}
+		return visitedChildren;
+	}
+	
 	public Node<S, A> addChild(Node<S, A> parent, S child) {
 		Node<S, A> newChild = nodeFactory.createNode(child);
 		List<Node<S, A>> children = successors(parent);
@@ -57,11 +67,8 @@ public Node<S, A> getParent(Node<S, A> node) {
 	}
 	
 	public List<Node<S, A>> successors(Node<S, A> node) {
-		return gameTree.get(node);
-	}
-	
-	public boolean contains(S state) {
-		return Ni.containsKey(state);
+		if (gameTree.containsKey(node)) return gameTree.get(node);
+		else return new ArrayList<>();
 	}
 	
 	public void updateStats(boolean result, Node<S, A> node) {
@@ -82,6 +89,7 @@ public Node<S, A> getChildWithMaxUCT(Node<S, A> node) {
 				best_children.add(child);
 			}
 		}
+		
 		Random rand = new Random();
 		return best_children.get(rand.nextInt(best_children.size()));
 	}
diff --git a/aima-core/src/test/java/aima/test/core/unit/search/SearchTestSuite.java b/aima-core/src/test/java/aima/test/core/unit/search/SearchTestSuite.java
@@ -2,6 +2,7 @@
 
 import aima.test.core.unit.search.adversarial.AlphaBetaSearchTest;
 import aima.test.core.unit.search.adversarial.MinimaxSearchTest;
+import aima.test.core.unit.search.adversarial.MonteCarloTreeSearchTest;
 import aima.test.core.unit.search.csp.AssignmentTest;
 import aima.test.core.unit.search.csp.CSPTest;
 import aima.test.core.unit.search.csp.MapCSPTest;
@@ -20,7 +21,7 @@
 import org.junit.runners.Suite;
 
 @RunWith(Suite.class)
-@Suite.SuiteClasses({AlphaBetaSearchTest.class, MinimaxSearchTest.class, AssignmentTest.class, CSPTest.class, MapCSPTest.class,
+@Suite.SuiteClasses({AlphaBetaSearchTest.class, MinimaxSearchTest.class, MonteCarloTreeSearchTest.class, AssignmentTest.class, CSPTest.class, MapCSPTest.class,
 		MetricsTest.class, TreeCspSolverTest.class, AStarSearchTest.class, GreedyBestFirstSearchTest.class, RecursiveBestFirstSearchTest.class,
 		AndOrSearchTest.class, LRTAStarAgentTest.class, OnlineDFSAgentTest.class,
 		BidirectionalSearchTest.class, BreadthFirstSearchTest.class, DepthFirstSearchTest.class,
diff --git a/aima-core/src/test/java/aima/test/core/unit/search/adversarial/MonteCarloTreeSearchTest.java b/aima-core/src/test/java/aima/test/core/unit/search/adversarial/MonteCarloTreeSearchTest.java
@@ -0,0 +1,47 @@
+package aima.test.core.unit.search.adversarial;
+
+import aima.core.environment.tictactoe.TicTacToeGame;
+import aima.core.environment.tictactoe.TicTacToeState;
+import aima.core.search.adversarial.Game;
+import aima.core.search.adversarial.MonteCarloTreeSearch;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class MonteCarloTreeSearchTest {
+	Game game;
+	MonteCarloTreeSearch monteCarloTreeSearch;
+	
+	@Before
+	public void setup() {
+		this.game = new TicTacToeGame();
+		this.monteCarloTreeSearch = new MonteCarloTreeSearch(game, 100);
+	}
+	
+	@Test
+	public void testTicTacToeBoard() {
+		String[] board = new String[]{TicTacToeState.X, TicTacToeState.O, TicTacToeState.O, TicTacToeState.O, TicTacToeState.X, TicTacToeState.X, TicTacToeState.X, TicTacToeState.O, TicTacToeState.X};
+		TicTacToeState state = new TicTacToeState(board, TicTacToeState.O);
+		Assert.assertTrue(game.isTerminal(state));
+		Assert.assertEquals(1, game.getUtility(state, TicTacToeState.X), 0);
+		
+		board = new String[]{TicTacToeState.X, TicTacToeState.O, TicTacToeState.O, TicTacToeState.O, TicTacToeState.X, TicTacToeState.X, TicTacToeState.X, TicTacToeState.X, TicTacToeState.O};
+		state = new TicTacToeState(board, TicTacToeState.O);
+		Assert.assertTrue(game.isTerminal(state));
+		Assert.assertEquals(0.5, game.getUtility(state, TicTacToeState.X), 0);
+		
+		board = new String[]{TicTacToeState.X, TicTacToeState.O, TicTacToeState.EMPTY, TicTacToeState.X, TicTacToeState.EMPTY, TicTacToeState.O, TicTacToeState.X, TicTacToeState.EMPTY, TicTacToeState.EMPTY};
+		state = new TicTacToeState(board, TicTacToeState.O);
+		Assert.assertTrue(game.isTerminal(state));
+		Assert.assertEquals(1, game.getUtility(state, TicTacToeState.X), 0);
+	}
+	
+	@Test
+	public void testMonteCarloTreeDecision() {
+		String[] board = new String[]{TicTacToeState.O, TicTacToeState.X, TicTacToeState.O, TicTacToeState.EMPTY, TicTacToeState.X, TicTacToeState.X, TicTacToeState.EMPTY, TicTacToeState.EMPTY, TicTacToeState.EMPTY};
+		TicTacToeState state = new TicTacToeState(board, TicTacToeState.O);
+		String[] expectedBoard = new String[]{TicTacToeState.O, TicTacToeState.X, TicTacToeState.O, TicTacToeState.O, TicTacToeState.X, TicTacToeState.X, TicTacToeState.EMPTY, TicTacToeState.EMPTY, TicTacToeState.EMPTY};
+		TicTacToeState expectedState = new TicTacToeState(expectedBoard, TicTacToeState.X);
+		Assert.assertEquals(expectedState, game.getResult(state, monteCarloTreeSearch.makeDecision(state)));
+	}
+}

Original file line number	Diff line number	Diff line change
`@@ -43,8 +43,8 @@ public A makeDecision(S state) {`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`private Node<S, A> select(GameTree gameTree) {`
`46`		`- Node node = gameTree.getRoot();`
`47`		`- while (isNodeFullyExpanded(node)) {`
	`46`	`+ Node<S, A> node = gameTree.getRoot();`
	`47`	`+ while (!game.isTerminal(node.getState()) && isNodeFullyExpanded(node)) {`
`48`	`48`	`node = gameTree.getChildWithMaxUCT(node);`
`49`	`49`	`}`
`50`	`50`	`return node;`
`@@ -79,15 +79,16 @@ private A bestAction(Node<S, A> root) {`
`79`	`79`	`Node<S, A> bestChild = tree.getChildWithMaxPlayouts(root);`
`80`	`80`	`for (A a : game.getActions(root.getState())) {`
`81`	`81`	`S result = game.getResult(root.getState(), a);`
`82`		`- if (result == bestChild.getState()) return a;`
	`82`	`+ if (result.equals(bestChild.getState())) return a;`
`83`	`83`	`}`
`84`	`84`	`return null;`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`private boolean isNodeFullyExpanded(Node<S, A> node) {`
	`88`	`+ List<S> visitedChildren = tree.getVisitedChildren(node);`
`88`	`89`	`for (A a : game.getActions(node.getState())) {`
`89`	`90`	`S result = game.getResult(node.getState(), a);`
`90`		`- if (!tree.contains(result)) {`
	`91`	`+ if (!visitedChildren.contains(result)) {`
`91`	`92`	`return false;`
`92`	`93`	`}`
`93`	`94`	`}`
`@@ -97,9 +98,10 @@ private boolean isNodeFullyExpanded(Node<S, A> node) {`
`97`	`98`
`98`	`99`	`private Node<S, A> randomlySelectUnvisitedChild(Node<S, A> node) {`
`99`	`100`	`List<S> unvisitedChildren = new ArrayList<>();`
	`101`	`+ List<S> visitedChildren = tree.getVisitedChildren(node);`
`100`	`102`	`for (A a : game.getActions(node.getState())) {`
`101`	`103`	`S result = game.getResult(node.getState(), a);`
`102`		`- if (!tree.contains(result)) unvisitedChildren.add(result);`
	`104`	`+ if (!visitedChildren.contains(result)) unvisitedChildren.add(result);`
`103`	`105`	`}`
`104`	`106`	`Random rand = new Random();`
`105`	`107`	`Node<S, A> newChild = tree.addChild(node, unvisitedChildren.get(rand.nextInt(unvisitedChildren.size())));`
Original file line number	Diff line number	Diff line change
`@@ -31,6 +31,16 @@ public Node<S, A> getRoot() {`
`31`	`31`	`return root;`
`32`	`32`	`}`
`33`	`33`
	`34`	`+ public List<S> getVisitedChildren(Node<S, A> parent) {`
	`35`	`+ List<S> visitedChildren = new ArrayList<>();`
	`36`	`+ if (gameTree.containsKey(parent)) {`
	`37`	`+ for (Node<S, A> child : gameTree.get(parent)) {`
	`38`	`+ visitedChildren.add(child.getState());`
	`39`	`+ }`
	`40`	`+ }`
	`41`	`+ return visitedChildren;`
	`42`	`+ }`
	`43`	`+`
`34`	`44`	`public Node<S, A> addChild(Node<S, A> parent, S child) {`
`35`	`45`	`Node<S, A> newChild = nodeFactory.createNode(child);`
`36`	`46`	`List<Node<S, A>> children = successors(parent);`
`@@ -57,11 +67,8 @@ public Node<S, A> getParent(Node<S, A> node) {`
`57`	`67`	`}`
`58`	`68`
`59`	`69`	`public List<Node<S, A>> successors(Node<S, A> node) {`
`60`		`- return gameTree.get(node);`
`61`		`- }`
`62`		`-`
`63`		`- public boolean contains(S state) {`
`64`		`- return Ni.containsKey(state);`
	`70`	`+ if (gameTree.containsKey(node)) return gameTree.get(node);`
	`71`	`+ else return new ArrayList<>();`
`65`	`72`	`}`
`66`	`73`
`67`	`74`	`public void updateStats(boolean result, Node<S, A> node) {`
`@@ -82,6 +89,7 @@ public Node<S, A> getChildWithMaxUCT(Node<S, A> node) {`
`82`	`89`	`best_children.add(child);`
`83`	`90`	`}`
`84`	`91`	`}`
	`92`	`+`
`85`	`93`	`Random rand = new Random();`
`86`	`94`	`return best_children.get(rand.nextInt(best_children.size()));`
`87`	`95`	`}`