Initial commit.

test/cs6601/p1/CaptureTest.java

@@ -0,0 +1,80 @@
+package cs6601.p1;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class CaptureTest {
+	@Test
+	public void testCapture() {
+		GameState gameState = new GameState(5);
+		gameState.playStone('A', 2, GameBoard.BLACK_STONE);
+		gameState.playStone('B', 3, GameBoard.BLACK_STONE);
+		gameState.playStone('B', 1, GameBoard.BLACK_STONE);
+		assertTrue(gameState.playStone('B', 2, GameBoard.WHITE_STONE));
+		
+		assertEquals(0,gameState.getBlackPrisoners());
+		assertEquals(0,gameState.getWhitePrisoners());
+		
+		assertTrue(gameState.playStone('C', 2, GameBoard.BLACK_STONE));
+		
+		assertEquals(1,gameState.getBlackPrisoners());
+		assertEquals(0,gameState.getWhitePrisoners());
+		
+		System.out.println(gameState);
+	}
+	
+	@Test
+	public void testMultiGroupCapture() {
+		GameConfig gameConfig = new GameConfig();
+		GameState gameState = new GameState(5);
+		
+		gameState.playStone('A', 2, GameBoard.BLACK_STONE);
+		gameState.playStone('B', 3, GameBoard.BLACK_STONE);
+		gameState.playStone('B', 1, GameBoard.BLACK_STONE);
+		gameState.playStone('C', 4, GameBoard.BLACK_STONE);
+		gameState.playStone('D', 3, GameBoard.BLACK_STONE);
+		
+		assertTrue(gameState.playStone('B', 2, GameBoard.WHITE_STONE));
+		assertTrue(gameState.playStone('C', 3, GameBoard.WHITE_STONE));
+		
+		assertEquals(0,gameState.getBlackPrisoners());
+		assertEquals(0,gameState.getWhitePrisoners());
+		
+		assertTrue(gameState.playStone('C', 2, GameBoard.BLACK_STONE));
+		
+		assertEquals(2,gameState.getBlackPrisoners());
+		assertEquals(0,gameState.getWhitePrisoners());
+		
+		assertFalse(gameState.playStone('B', 2, GameBoard.WHITE_STONE));
+		assertFalse(gameState.playStone('C', 3, GameBoard.WHITE_STONE));
+		
+		System.out.println(gameState);
+		
+		GameScore gameScore = new StateEvaluator(gameConfig).scoreGame(gameState);
+		System.out.println(gameScore.getScoreReport());
+	}
+	
+	@Test
+	public void testCaptureFromEye() {
+		GameState gameState = new GameState(5);
+		
+		gameState.playStone('A', 1, GameBoard.BLACK_STONE);
+		gameState.playStone('B', 2, GameBoard.BLACK_STONE);
+		gameState.playStone('C', 1, GameBoard.BLACK_STONE);
+		gameState.playStone('A', 2, GameBoard.WHITE_STONE);
+		gameState.playStone('B', 3, GameBoard.WHITE_STONE);
+		gameState.playStone('C', 2, GameBoard.WHITE_STONE);
+		
+		//This capture should be allowed.
+		assertTrue("Capture from within single eye should have been allowed but move was rejected.",
+				gameState.playStone('B', 1, GameBoard.WHITE_STONE));
+
+		assertEquals(0,gameState.getBlackPrisoners());
+		assertEquals(2,gameState.getWhitePrisoners());
+		
+		System.out.println(gameState);
+	}
+}

test/cs6601/p1/GameScoreTest.java

@@ -0,0 +1,26 @@
+package cs6601.p1;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class GameScoreTest {
+
+	@Test
+	public void testGetAggregateScoreZero() {
+		GameScore gameScore = new GameScore(0,0,0);
+		assertEquals(GameScore.NORMALIZED_ZERO_SCORE, gameScore.getAggregateScore());
+	}
+	
+	@Test
+	public void testGetAggregateScoreBlackWinsNoKomi() {
+		GameScore gameScore = new GameScore(25,2,0);
+		assertEquals(425, gameScore.getAggregateScore());
+	}
+	
+	@Test
+	public void testGetAggregateScoreWhiteWinsWithKomi() {
+		GameScore gameScore = new GameScore(10,12,6.5);
+		assertEquals(362, gameScore.getAggregateScore());
+	}
+}

test/cs6601/p1/IllegalMoveTest.java

@@ -0,0 +1,62 @@
+package cs6601.p1;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class IllegalMoveTest {
+	
+	@Test
+	public void testIllegalMoveOnOwnStone() {
+		GameState gameState = new GameState(5);
+		gameState.playStone('B', 3, GameBoard.BLACK_STONE);
+		assertFalse(gameState.playStone('B', 3, GameBoard.BLACK_STONE));
+	}
+	
+	@Test
+	public void testIllegalMoveOnOtherStone() {
+		GameState gameState = new GameState(5);
+		gameState.playStone('B', 3, GameBoard.BLACK_STONE);
+		assertFalse(gameState.playStone('B', 3, GameBoard.WHITE_STONE));
+	}
+	
+	@Test
+	public void testIllegalMoveNoLiberties() {
+		GameState gameState = new GameState(5);
+		gameState.playStone('A', 2, GameBoard.BLACK_STONE);
+		gameState.playStone('B', 3, GameBoard.BLACK_STONE);
+		gameState.playStone('B', 1, GameBoard.BLACK_STONE);
+		gameState.playStone('C', 2, GameBoard.BLACK_STONE);
+		assertFalse(gameState.playStone('B', 2, GameBoard.WHITE_STONE));
+		System.out.println(gameState);
+	}
+	
+	@Test
+	public void testIllegalMoveFormsTrappedGroup() {
+		GameState gameState = new GameState(9);
+		gameState.playStone('A', 5, GameBoard.BLACK_STONE);
+		gameState.playStone('B', 6, GameBoard.BLACK_STONE);
+		gameState.playStone('B', 7, GameBoard.BLACK_STONE);
+		gameState.playStone('A', 8, GameBoard.BLACK_STONE);
+		assertTrue(gameState.playStone('A', 6, GameBoard.WHITE_STONE));
+		assertFalse(gameState.playStone('A', 7, GameBoard.WHITE_STONE));
+		System.out.println(gameState);
+	}
+	
+	@Test
+	public void testIllegalMoveFormsTrappedGroup2() {
+		GameState gameState = new GameState(9);
+		gameState.playStone('G', 1, GameBoard.BLACK_STONE);
+		gameState.playStone('H', 2, GameBoard.BLACK_STONE);
+		gameState.playStone('H', 3, GameBoard.BLACK_STONE);
+		gameState.playStone('J', 4, GameBoard.BLACK_STONE);
+		gameState.playStone('A', 8, GameBoard.BLACK_STONE);
+		assertTrue(gameState.playStone('H', 1, GameBoard.WHITE_STONE));
+		assertTrue(gameState.playStone('J', 2, GameBoard.WHITE_STONE));
+		assertTrue(gameState.playStone('J', 3, GameBoard.WHITE_STONE));
+		System.out.println(gameState);
+		assertFalse(gameState.playStone('J', 1, GameBoard.WHITE_STONE));
+		System.out.println(gameState);
+	}
+}

test/cs6601/p1/LegalMoveTest.java

@@ -0,0 +1,17 @@
+package cs6601.p1;
+
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class LegalMoveTest {
+	@Test
+	public void testLegalMove1Liberty() {
+		GameState gameState = new GameState(5);
+		gameState.playStone('A', 2, GameBoard.BLACK_STONE);
+		gameState.playStone('B', 3, GameBoard.BLACK_STONE);
+		gameState.playStone('B', 1, GameBoard.BLACK_STONE);
+		assertTrue(gameState.playStone('B', 2, GameBoard.WHITE_STONE));
+		System.out.println(gameState);
+	}
+}

test/cs6601/p1/StateEvaluatorTest.java

@@ -0,0 +1,96 @@
+package cs6601.p1;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+import cs6601.p1.generator.AlphaBetaMoveGenerator;
+import cs6601.p1.generator.MoveGenerator;
+
+public class StateEvaluatorTest {
+	GameConfig gameConfig = new GameConfig();
+	
+	@Test
+	public void testScoreEmptyBoard() {
+		GameState gameState = new GameState(5);
+		GameScore gameScore = new StateEvaluator(gameConfig).scoreGame(gameState);
+		
+		assertEquals(0.0,gameScore.getWhiteScore(),0.5);
+		assertEquals(0.0,gameScore.getBlackScore(),0.5);
+	}
+	
+	@Test
+	public void testScoreFirstMove() {
+		GameState gameState = new GameState(5);
+		gameState.playStone('B',3,GameBoard.BLACK_STONE);
+		
+		GameScore gameScore = new StateEvaluator(gameConfig).scoreGame(gameState);
+		
+		System.out.println(gameScore.getScoreReport());
+		
+		assertEquals(0.0,gameScore.getWhiteScore(),0.5);
+		assertEquals(25.0,gameScore.getBlackScore(),0.5);
+	}
+	
+	@Test
+	public void testScoreTiedAtMove2() {
+		GameState gameState = new GameState(5);
+		
+		gameState.playStone('B',3,GameBoard.BLACK_STONE);
+		gameState.playStone('A',1,GameBoard.WHITE_STONE);
+		GameScore gameScore = new StateEvaluator(gameConfig).scoreGame(gameState);
+		
+		System.out.println(gameScore.getScoreReport());
+		
+		assertEquals(1.0,gameScore.getWhiteScore(),0.5);
+		assertEquals(1.0,gameScore.getBlackScore(),0.5);
+	}
+	
+	@Test
+	public void testScoreTerritory() {
+		GameState gameState = new GameState(5);
+		
+		gameState.playStone('A',2,GameBoard.BLACK_STONE);
+		gameState.playStone('B',3,GameBoard.BLACK_STONE);
+		gameState.playStone('C',2,GameBoard.BLACK_STONE);
+		gameState.playStone('B',1,GameBoard.BLACK_STONE);
+		gameState.playStone('E',5,GameBoard.WHITE_STONE);
+		
+		System.out.println(gameState);
+		GameScore gameScore = new StateEvaluator(gameConfig).scoreGame(gameState);
+		
+		System.out.println(gameScore.getScoreReport());
+		
+		assertEquals(1.0,gameScore.getWhiteScore(),0.5);
+		assertEquals(6.0,gameScore.getBlackScore(),0.5);
+		//Black should be up by 5 if Black's territory at A1 & B2 is scored correctly.
+	}
+	
+	@Test
+	public void testCaptureAggScore() {
+		GameState gameState = new GameState(9);
+		gameState.playStone('A', 2, GameBoard.WHITE_STONE);
+		gameState.playStone('B', 1, GameBoard.WHITE_STONE);
+		gameState.playStone('C', 2, GameBoard.WHITE_STONE);
+		gameState.playStone('B', 2, GameBoard.BLACK_STONE);
+		
+		GameState moveToA1 = new GameState(gameState);
+		GameState capAtB3 = new GameState(gameState);
+		
+		moveToA1.playStone("w","A1");
+		capAtB3.playStone("w", "B3");
+		
+		System.out.println(moveToA1);
+		System.out.println(capAtB3);
+		
+		StateEvaluator eval = new StateEvaluator(new GameConfig());
+		int scoreA1 = eval.scoreGame(moveToA1).getAggregateScore();
+		int scoreB3 = eval.scoreGame(capAtB3).getAggregateScore();
+		
+		System.out.println("Score at A1: " + scoreA1);
+		System.out.println("Score at B3: " + scoreB3);
+		//moving as white, lower is better
+		assertTrue(scoreA1 > scoreB3);
+	}
+}

test/cs6601/p1/TerritoryFinderTest.java

@@ -0,0 +1,19 @@
+package cs6601.p1;
+
+import org.junit.Test;
+
+public class TerritoryFinderTest {
+	@Test
+	public void testMarkTerritory() {
+		GameState gameState = new GameState(5);
+		
+		gameState.playStone('A',2,GameBoard.BLACK_STONE);
+		gameState.playStone('B',3,GameBoard.BLACK_STONE);
+		gameState.playStone('C',2,GameBoard.BLACK_STONE);
+		gameState.playStone('B',1,GameBoard.BLACK_STONE);
+		gameState.playStone('E',5,GameBoard.WHITE_STONE);
+		
+		TerritoryMarker.markTerritory(gameState.getGameBoard());
+		System.out.println(gameState);
+	}
+}

test/cs6601/p1/generator/AlphaBetaTest.java

@@ -0,0 +1,53 @@
+package cs6601.p1.generator;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+import cs6601.p1.GameBoard;
+import cs6601.p1.GameConfig;
+import cs6601.p1.GameState;
+
+public class AlphaBetaTest {
+	@Test
+	public void testGenmoveAsW() {
+		MoveGenerator moveGenerator = new AlphaBetaMoveGenerator();
+		GameState gameState = new GameState(6);
+		gameState.playStone('A', 2, GameBoard.WHITE_STONE);
+		gameState.playStone('B', 1, GameBoard.WHITE_STONE);
+		gameState.playStone('C', 2, GameBoard.WHITE_STONE);
+		gameState.playStone('B', 2, GameBoard.BLACK_STONE);
+		
+		String move = moveGenerator.genMove(new GameConfig(), gameState, "b");
+		System.out.println(gameState);
+		
+		System.out.println("Generated move: " + move);
+		assertEquals("Expected B3 but was: " + move, "B3", move);
+		gameState.playStone("b", move);
+		
+		System.out.println(gameState);
+		
+		assertEquals(MoveGenerator.PASS,moveGenerator.genMove(new GameConfig(), gameState, "?"));
+	}
+	
+	@Test
+	public void testGenmoveAsB() {
+		MoveGenerator moveGenerator = new AlphaBetaMoveGenerator();
+		GameState gameState = new GameState(6);
+		gameState.playStone('A', 2, GameBoard.BLACK_STONE);
+		gameState.playStone('B', 1, GameBoard.BLACK_STONE);
+		gameState.playStone('C', 2, GameBoard.BLACK_STONE);
+		gameState.playStone('B', 2, GameBoard.WHITE_STONE);
+		
+		String move = moveGenerator.genMove(new GameConfig(), gameState, "b");
+		System.out.println(gameState);
+		
+		System.out.println("Generated move: " + move);
+		assertEquals("Expected B3 but was: " + move, "B3", move);
+		gameState.playStone("b", move);
+		
+		System.out.println(gameState);
+		
+		assertEquals(MoveGenerator.PASS,moveGenerator.genMove(new GameConfig(), gameState, "?"));
+	}
+}

test/cs6601/p1/generator/MinimaxTest.java

@@ -0,0 +1,33 @@
+package cs6601.p1.generator;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+import cs6601.p1.GameBoard;
+import cs6601.p1.GameConfig;
+import cs6601.p1.GameState;
+import cs6601.p1.generator.MoveGenerator;
+
+public class MinimaxTest {
+	
+	@Test
+	public void testGenmove() {
+		MoveGenerator moveGenerator = new MinimaxMoveGenerator();
+		GameState gameState = new GameState(5);
+		gameState.playStone('A', 2, GameBoard.BLACK_STONE);
+		gameState.playStone('B', 1, GameBoard.BLACK_STONE);
+		gameState.playStone('C', 2, GameBoard.BLACK_STONE);
+		gameState.playStone('B', 4, GameBoard.BLACK_STONE);
+		
+		String move = moveGenerator.genMove(new GameConfig(), gameState, "w");
+		System.out.println("Generated move: " + move);
+		gameState.playStone("w", move);
+		
+		System.out.println(gameState);
+		
+		assertEquals(MoveGenerator.PASS,moveGenerator.genMove(new GameConfig(), gameState, "?"));
+		
+		System.out.println(gameState);
+	}
+}

test/cs6601/p1/generator/RandomTest.java

@@ -0,0 +1,52 @@
+package cs6601.p1.generator;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+import cs6601.p1.GameBoard;
+import cs6601.p1.GameConfig;
+import cs6601.p1.GameState;
+import cs6601.p1.generator.MoveGenerator;
+import cs6601.p1.generator.RandomMoveGenerator;
+
+public class RandomTest {
+	
+	@Test
+	public void testGenmove() {
+		MoveGenerator moveGenerator = new RandomMoveGenerator();
+		GameState gameState = new GameState(5);
+		moveGenerator.genMove(new GameConfig(), gameState, "b");
+		gameState = new GameState(5);
+		moveGenerator.genMove(new GameConfig(), gameState, "w");
+		
+		assertEquals(MoveGenerator.PASS,moveGenerator.genMove(new GameConfig(), gameState, "?"));
+		
+		System.out.println(gameState);
+	}
+	
+	@Test
+	public void testAlternativeToIllegalMove() {
+		GameState gameState = new GameState(4);
+		gameState.playStone('A', 1, GameBoard.BLACK_STONE);
+		gameState.playStone('A', 2, GameBoard.BLACK_STONE);
+		gameState.playStone('A', 3, GameBoard.BLACK_STONE);
+		gameState.playStone('A', 4, GameBoard.BLACK_STONE);
+		gameState.playStone('B', 1, GameBoard.BLACK_STONE);
+		gameState.playStone('B', 2, GameBoard.BLACK_STONE);
+		//gameState.playStone('B', 3, GameBoard.BLACK_STONE);
+		gameState.playStone('B', 4, GameBoard.BLACK_STONE);
+		gameState.playStone('C', 2, GameBoard.BLACK_STONE);
+		gameState.playStone('C', 3, GameBoard.BLACK_STONE);
+		gameState.playStone('C', 4, GameBoard.BLACK_STONE);
+		gameState.playStone('D', 4, GameBoard.BLACK_STONE);
+		assertTrue(gameState.playStone('C', 1, GameBoard.WHITE_STONE));
+		assertTrue(gameState.playStone('D', 2, GameBoard.WHITE_STONE));
+		assertTrue(gameState.playStone('D', 3, GameBoard.WHITE_STONE));
+		System.out.println(gameState);
+		//This is correct - checked vs. MFOG
+		assertEquals("B3", new RandomMoveGenerator().genMove(new GameConfig(), gameState, "w"));
+		System.out.println(gameState);
+	}
+}

test/cs6601/p1/generator/ValidMoveGeneratorTest.java

@@ -0,0 +1,43 @@
+package cs6601.p1.generator;
+
+import static org.junit.Assert.*;
+
+import java.util.List;
+
+import org.junit.Test;
+
+import cs6601.p1.GameBoard;
+import cs6601.p1.GameConfig;
+import cs6601.p1.GameState;
+
+public class ValidMoveGeneratorTest {
+
+	@Test
+	public void test() {
+/* move generator should not include A1 here when playing as black:
+   A B C D E
+ 5 . . . . . 5
+ 4 . O . . . 4
+ 3 . . . . . 3     WHITE(O) has captured 0 stones
+ 2 O . O . . 2     BLACK(X) has captured 0 stones
+ 1 . O . . . 1
+   A B C D E
+ */
+		GameState gameState = new GameState(5);
+		gameState.playStone('A', 2, GameBoard.WHITE_STONE);
+		gameState.playStone('B', 1, GameBoard.WHITE_STONE);
+		gameState.playStone('B', 4, GameBoard.WHITE_STONE);
+		gameState.playStone('C', 2, GameBoard.WHITE_STONE);
+		assertFalse(gameState.playStone('A', 1, GameBoard.BLACK_STONE));
+		
+		List<String> validMoves = new ValidMoveGenerator().genMoves(new GameConfig(), gameState, "b",0);
+		assertTrue(validMoves.size() > 0);
+		for (String vm : validMoves) {
+			System.out.println(vm);
+		}
+		assertFalse(validMoves.contains("A1"));
+		
+		System.out.println(gameState);
+	}
+
+}