AI Thread fixes

# Conflicts:
#	app/src/main/java/org/toop/Main.java
#	app/src/main/java/org/toop/app/Server.java
#	app/src/main/java/org/toop/app/canvas/ReversiBitCanvas.java
#	app/src/main/java/org/toop/app/gameControllers/ReversiBitController.java
#	app/src/main/java/org/toop/app/widget/view/LocalMultiplayerView.java
#	app/src/main/java/org/toop/app/widget/view/ServerView.java
#	framework/src/main/java/org/toop/framework/game/BitboardGame.java
#	framework/src/main/java/org/toop/framework/game/gameThreads/OnlineThreadBehaviour.java
#	framework/src/main/java/org/toop/framework/game/gameThreads/ServerThreadBehaviour.java
#	framework/src/main/java/org/toop/framework/game/games/reversi/BitboardReversi.java
#	framework/src/main/java/org/toop/framework/game/players/ArtificialPlayer.java
#	framework/src/main/java/org/toop/framework/game/players/ServerPlayer.java
#	framework/src/main/java/org/toop/framework/gameFramework/model/game/TurnBasedGame.java
#	framework/src/main/java/org/toop/framework/networking/server/GameServer.java
#	framework/src/main/java/org/toop/framework/networking/server/OnlineTurnBasedGame.java
#	framework/src/main/java/org/toop/framework/networking/server/Server.java
#	framework/src/main/java/org/toop/framework/networking/server/client/NettyClient.java
#	framework/src/main/java/org/toop/framework/networking/server/handlers/MessageHandler.java
#	game/src/main/java/org/toop/game/players/ai/MCTSAI.java

app/src/main/java/org/toop/Main.java

@@ -1,23 +1,9 @@
 package org.toop;
 
 import org.toop.app.App;
-import org.toop.framework.game.games.reversi.BitboardReversi;
-import org.toop.framework.game.players.ArtificialPlayer;
-import org.toop.game.players.ai.MCTSAI;
-import org.toop.game.players.ai.RandomAI;
-import org.toop.game.players.ai.mcts.MCTSAI1;
-import org.toop.game.players.ai.mcts.MCTSAI2;
-import org.toop.game.players.ai.mcts.MCTSAI3;
-import org.toop.game.players.ai.mcts.MCTSAI4;
-
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 
 public final class Main {
     static void main(String[] args) {
         App.run(args);
-
-		// final ExecutorService executor = Executors.newFixedThreadPool(1);
-		// executor.execute(() -> testAIs(25));
     }
 }

app/src/main/java/org/toop/app/Server.java

@@ -210,7 +210,7 @@ public final class Server {
 
             Player[] players = new Player[2];
 
-            players[userStartingTurn] = new ArtificialPlayer(new MCTSAI3(1000, Runtime.getRuntime().availableProcessors()), user);
+            players[userStartingTurn] = new ArtificialPlayer(new MCTSAI3(1000, 8), user);
             players[opponentStartingTurn] = new OnlinePlayer(response.opponent());
 
             switch (type) {

app/src/main/java/org/toop/app/widget/view/LocalMultiplayerView.java

@@ -82,13 +82,13 @@ public class LocalMultiplayerView extends ViewWidget {
                     if (information.players[0].isHuman) {
                         players[0] = new LocalPlayer(information.players[0].name);
                     } else {
-						// players[0] = new ArtificialPlayer(new RandomAI<BitboardReversi>(), "Random AI");
+						// players[0] = new ArtificialPlayer(new RandomAI(), "Random AI");
-						players[0] = new ArtificialPlayer(new MCTSAI4(500, 4), "MCTS V4 AI");
+						players[0] = new ArtificialPlayer(new MCTSAI1(100), "MCTS V1 AI");
                     }
                     if (information.players[1].isHuman) {
                         players[1] = new LocalPlayer(information.players[1].name);
                     } else {
-						players[1] = new ArtificialPlayer(new MCTSAI1(500), "MCTS V1 AI");
+						players[1] = new ArtificialPlayer(new MCTSAI4(100, 8), "MCTS V4 AI");
                     }
                     if (AppSettings.getSettings().getTutorialFlag() && AppSettings.getSettings().getFirstReversi()) {
                         new ShowEnableTutorialWidget(

framework/src/main/java/org/toop/framework/game/BitboardGame.java

@@ -6,7 +6,6 @@ import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 import org.toop.framework.gameFramework.model.player.Player;
 
 import java.util.Arrays;
-import java.util.concurrent.atomic.AtomicInteger;
 
 // There is AI performance to be gained by getting rid of non-primitives and thus speeding up deepCopy
 public abstract class BitboardGame implements TurnBasedGame {
@@ -18,8 +17,8 @@ public abstract class BitboardGame implements TurnBasedGame {
     private Player[] players;
 
 	// long is 64 bits. Every game has a limit of 64 cells maximum.
-	private final long[] playerBitboard;
+	protected final long[] playerBitboard;
-	private int currentTurn = 0;
+	protected int currentTurn = 0;
 	private final int playerCount;
 
 	public BitboardGame(int columnSize, int rowSize, int playerCount) {
@@ -75,6 +74,8 @@ public abstract class BitboardGame implements TurnBasedGame {
 		return playerBitboard.length;
 	}
 
+    public int getAmountOfTurns() { return currentTurn; }
+
 	public int getCurrentTurn() {
 		return getCurrentPlayerIndex();
 	}

framework/src/main/java/org/toop/framework/game/games/reversi/BitboardReversi.java

@@ -4,7 +4,6 @@ import org.toop.framework.game.BitboardGame;
 import org.toop.framework.gameFramework.GameState;
 import org.toop.framework.gameFramework.model.game.PlayResult;
 import org.toop.framework.gameFramework.model.player.Player;
-import org.toop.framework.game.BitboardGame;
 
 public class BitboardReversi extends BitboardGame {
 
@@ -368,4 +367,11 @@ public class BitboardReversi extends BitboardGame {
 
 		return bestMove;
 	}
+
+	@Override
+	public void setFrom(long player1, long player2, int turn) {
+		this.playerBitboard[0] = player1;
+		this.playerBitboard[1] = player2;
+		this.currentTurn = turn;
+	}
 }

framework/src/main/java/org/toop/framework/game/games/tictactoe/BitboardTicTacToe.java

@@ -2,6 +2,7 @@ package org.toop.framework.game.games.tictactoe;
 
 import org.toop.framework.gameFramework.GameState;
 import org.toop.framework.gameFramework.model.game.PlayResult;
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 import org.toop.framework.gameFramework.model.player.Player;
 import org.toop.framework.game.BitboardGame;
 
@@ -120,4 +121,8 @@ public class BitboardTicTacToe extends BitboardGame {
 	public long heuristicMove(long legalMoves) {
 		return legalMoves;
 	}
+
+	@Override
+	public void setFrom(long player1, long player2, int turn) {
+	}
 }

framework/src/main/java/org/toop/framework/gameFramework/model/game/TurnBasedGame.java

@@ -16,4 +16,6 @@ public interface TurnBasedGame extends DeepCopyable<TurnBasedGame> {
 
 	float rateMove(long move);
 	long heuristicMove(long legalMoves);
+
+	void setFrom(long player1, long player2, int turn);
 }

game/src/main/java/org/toop/game/players/ai/MCTSAI.java

@@ -4,9 +4,12 @@ import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 import org.toop.framework.gameFramework.model.player.AbstractAI;
 
 import java.util.Random;
+import java.util.concurrent.atomic.AtomicInteger;
 
 public abstract class MCTSAI extends AbstractAI {
 	protected static class Node {
+		public static final int VIRTUAL_LOSS = -1;
+
 		public TurnBasedGame state;
 
 		public long move;
@@ -15,8 +18,8 @@ public abstract class MCTSAI extends AbstractAI {
 		public Node parent;
 		public Node[] children;
 
-		public float value;
+		public AtomicInteger value;
-		public int visits;
+		public AtomicInteger visits;
 
 		public float heuristic;
 
@@ -33,8 +36,8 @@ public abstract class MCTSAI extends AbstractAI {
 			this.parent = parent;
 			this.children = new Node[Long.bitCount(legalMoves)];
 
-			this.value = 0.0f;
+			this.value = new AtomicInteger(0);
-			this.visits = 0;
+			this.visits = new AtomicInteger(0);
 
 			this.heuristic = state.rateMove(move);
 
@@ -53,14 +56,14 @@ public abstract class MCTSAI extends AbstractAI {
 			return unexpandedMoves == 0L;
 		}
 
-		public float calculateUCT(int parentVisits) {
+		public float calculateUCT(float explorationFactor) {
-			if (visits == 0) {
+			if (visits.get() == 0) {
 				return Float.POSITIVE_INFINITY;
 			}
 
-			final float exploitation = value / visits;
+			final float exploitation = (float) value.get() / visits.get();
-			final float exploration = (float)(Math.sqrt(Math.log(parentVisits) / visits));
+			final float exploration = (float)(Math.sqrt(explorationFactor / visits.get()));
-			final float bias = heuristic * 10.0f / (visits + 1);
+			final float bias = heuristic * 10.0f / (visits.get() + 1);
 
 			return exploitation + exploration + bias;
 		}
@@ -72,7 +75,7 @@ public abstract class MCTSAI extends AbstractAI {
 			float highestUCT = Float.NEGATIVE_INFINITY;
 
 			for (int i = 0; i < expanded; i++) {
-				final float childUCT = children[i].calculateUCT(visits);
+				final float childUCT = children[i].calculateUCT(2.0f * (float)Math.log(visits.get()));
 
 				if (childUCT > highestUCT) {
 					highestUCTChild = children[i];
@@ -107,15 +110,21 @@ public abstract class MCTSAI extends AbstractAI {
 	}
 
 	protected Node selection(Node root) {
-		// while (Float.isNaN(root.solved) && root.isFullyExpanded() && !root.state.isTerminal()) {
+		while (Float.isNaN(root.solved) && root.isFullyExpanded() && !root.state.isTerminal()) {
-		while (root.isFullyExpanded() && !root.state.isTerminal()) {
+			root.value.addAndGet(Node.VIRTUAL_LOSS);
+			root.visits.incrementAndGet();
+
 			root = root.bestUCTChild();
 		}
 
+		root.value.addAndGet(Node.VIRTUAL_LOSS);
+		root.visits.incrementAndGet();
+
 		return root;
 	}
 
 	protected Node expansion(Node leaf) {
+		synchronized (leaf) {
 			if (leaf.unexpandedMoves == 0L) {
 				return leaf;
 			}
@@ -132,8 +141,9 @@ public abstract class MCTSAI extends AbstractAI {
 
 			return expandedChild;
 		}
+	}
 
-	protected float simulation(Node leaf) {
+	protected int simulation(Node leaf) {
 		final TurnBasedGame copiedState = leaf.state.deepCopy();
 		final int playerIndex = 1 - copiedState.getCurrentTurn();
 
@@ -145,20 +155,20 @@ public abstract class MCTSAI extends AbstractAI {
 		}
 
 		if (copiedState.getWinner() == playerIndex) {
-			return 1.0f;
+			return 1;
 		}
 
 		if (copiedState.getWinner() >= 0) {
-			return -1.0f;
+			return -1;
 		}
 
-		return 0.0f;
+		return 0;
 	}
 
-	protected void backPropagation(Node leaf, float value) {
+	protected void backPropagation(Node leaf, int value) {
 		while (leaf != null) {
-			leaf.value += value;
+			value -= Node.VIRTUAL_LOSS;
-			leaf.visits++;
+			leaf.value.addAndGet(value);
 
 			if (Float.isNaN(leaf.solved)) {
 				updateSolvedStatus(leaf);
@@ -176,9 +186,9 @@ public abstract class MCTSAI extends AbstractAI {
 		int mostVisited = -1;
 
 		for (int i = 0; i < expanded; i++) {
-			if (root.children[i].visits > mostVisited) {
+			if (root.children[i].visits.get() > mostVisited) {
 				mostVisitedChild = root.children[i];
-				mostVisited = root.children[i].visits;
+				mostVisited = root.children[i].visits.get();
 			}
 		}
 

game/src/main/java/org/toop/game/players/ai/MCTSAI2.java

@@ -0,0 +1,195 @@
+package org.toop.game.players.ai;
+
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+import org.toop.framework.gameFramework.model.player.AbstractAI;
+
+import java.util.Random;
+
+public class MCTSAI2 extends AbstractAI {
+	private static class Node {
+		public TurnBasedGame state;
+
+		public long move;
+		public long unexpandedMoves;
+
+		public Node parent;
+
+		public Node[] children;
+		public int expanded;
+
+		public float value;
+		public int visits;
+
+		public Node(TurnBasedGame state, Node parent, long move) {
+			final long legalMoves = state.getLegalMoves();
+
+			this.state = state;
+
+			this.move = move;
+			this.unexpandedMoves = legalMoves;
+
+			this.parent = parent;
+
+			this.children = new Node[Long.bitCount(legalMoves)];
+			this.expanded = 0;
+
+			this.value = 0.0f;
+			this.visits = 0;
+		}
+
+		public Node(TurnBasedGame state) {
+			this(state, null, 0L);
+		}
+
+		public boolean isFullyExpanded() {
+			return expanded == children.length;
+		}
+
+		public float calculateUCT(int parentVisits) {
+			final float exploitation = value / visits;
+			final float exploration = 1.41f * (float)(Math.sqrt(Math.log(parentVisits) / visits));
+
+			return exploitation + exploration;
+		}
+
+		public Node bestUCTChild() {
+			Node highestUCTChild = null;
+			float highestUCT = Float.NEGATIVE_INFINITY;
+
+			for (int i = 0; i < expanded; i++) {
+				final float childUCT = children[i].calculateUCT(visits);
+
+				if (childUCT > highestUCT) {
+					highestUCTChild = children[i];
+					highestUCT = childUCT;
+				}
+
+			}
+
+			return highestUCTChild;
+		}
+	}
+
+	private final Random random;
+	private final int milliseconds;
+
+	public MCTSAI2(int milliseconds) {
+		this.random = new Random();
+		this.milliseconds = milliseconds;
+	}
+
+	public MCTSAI2(MCTSAI2 other) {
+		this.random = other.random;
+		this.milliseconds = other.milliseconds;
+	}
+
+	@Override
+	public MCTSAI2 deepCopy() {
+		return new MCTSAI2(this);
+	}
+
+	@Override
+	public long getMove(TurnBasedGame game) {
+		final Node root = new Node(game, null, 0L);
+
+		final long endTime = System.nanoTime() + milliseconds * 1_000_000L;
+
+		while (System.nanoTime() < endTime) {
+			Node leaf = selection(root);
+			leaf = expansion(leaf);
+			final float value = simulation(leaf);
+			backPropagation(leaf, value);
+		}
+
+		final Node mostVisitedChild = mostVisitedChild(root);
+
+		return mostVisitedChild != null? mostVisitedChild.move : 0L;
+	}
+
+	private Node mostVisitedChild(Node root) {
+		Node mostVisitedChild = null;
+		int mostVisited = -1;
+
+		for (int i = 0; i < root.expanded; i++) {
+			if (root.children[i].visits > mostVisited) {
+				mostVisitedChild = root.children[i];
+				mostVisited = root.children[i].visits;
+			}
+		}
+
+		return mostVisitedChild;
+	}
+
+	private Node selection(Node root) {
+		while (root.isFullyExpanded() && !root.state.isTerminal()) {
+			root = root.bestUCTChild();
+		}
+
+		return root;
+	}
+
+	private Node expansion(Node leaf) {
+		if (leaf.unexpandedMoves == 0L) {
+			return leaf;
+		}
+
+		final long unexpandedMove = leaf.unexpandedMoves & -leaf.unexpandedMoves;
+
+		final TurnBasedGame copiedState = leaf.state.deepCopy();
+		copiedState.play(unexpandedMove);
+
+		final Node expandedChild = new Node(copiedState, leaf, unexpandedMove);
+
+		leaf.children[leaf.expanded] = expandedChild;
+		leaf.expanded++;
+
+		leaf.unexpandedMoves &= ~unexpandedMove;
+
+		return expandedChild;
+	}
+
+	private float simulation(Node leaf) {
+		final TurnBasedGame copiedState = leaf.state.deepCopy();
+		final int playerIndex = 1 - copiedState.getCurrentTurn();
+
+		while (!copiedState.isTerminal()) {
+			final long legalMoves = copiedState.getLegalMoves();
+			final long randomMove = randomSetBit(legalMoves);
+
+			copiedState.play(randomMove);
+		}
+
+		if (copiedState.getWinner() == playerIndex) {
+			return 1.0f;
+		} else if (copiedState.getWinner() >= 0) {
+			return -1.0f;
+		}
+
+		return 0.0f;
+	}
+
+	private void backPropagation(Node leaf, float value) {
+		while (leaf != null) {
+			leaf.value += value;
+			leaf.visits++;
+
+			value = -value;
+			leaf = leaf.parent;
+		}
+	}
+
+	private long randomSetBit(long value) {
+		if (0L == value) {
+			return 0;
+		}
+
+		final int bitCount = Long.bitCount(value);
+		final int randomBitCount = random.nextInt(bitCount);
+
+		for (int i = 0; i < randomBitCount; i++) {
+			value &= value - 1;
+		}
+
+		return value & -value;
+	}
+}

game/src/main/java/org/toop/game/players/ai/MCTSAI3.java

@@ -0,0 +1,258 @@
+package org.toop.game.players.ai;
+
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+import org.toop.framework.gameFramework.model.player.AbstractAI;
+
+import java.util.Random;
+
+public class MCTSAI3 extends AbstractAI {
+	private static class Node {
+		public TurnBasedGame state;
+
+		public long move;
+		public long unexpandedMoves;
+
+		public Node parent;
+
+		public Node[] children;
+		public int expanded;
+
+		public float value;
+		public int visits;
+
+		public Node(TurnBasedGame state, Node parent, long move) {
+			final long legalMoves = state.getLegalMoves();
+
+			this.state = state;
+
+			this.move = move;
+			this.unexpandedMoves = legalMoves;
+
+			this.parent = parent;
+
+			this.children = new Node[Long.bitCount(legalMoves)];
+			this.expanded = 0;
+
+			this.value = 0.0f;
+			this.visits = 0;
+		}
+
+		public Node(TurnBasedGame state) {
+			this(state, null, 0L);
+		}
+
+		public boolean isFullyExpanded() {
+			return expanded == children.length;
+		}
+
+		public float calculateUCT(int parentVisits) {
+			final float exploitation = value / visits;
+			final float exploration = 1.41f * (float)(Math.sqrt(Math.log(parentVisits) / visits));
+
+			return exploitation + exploration;
+		}
+
+		public Node bestUCTChild() {
+			Node highestUCTChild = null;
+			float highestUCT = Float.NEGATIVE_INFINITY;
+
+			for (int i = 0; i < expanded; i++) {
+				final float childUCT = children[i].calculateUCT(visits);
+
+				if (childUCT > highestUCT) {
+					highestUCTChild = children[i];
+					highestUCT = childUCT;
+				}
+
+			}
+
+			return highestUCTChild;
+		}
+	}
+
+	private final Random random;
+
+	private Node root;
+	private final int milliseconds;
+
+	public MCTSAI3(int milliseconds) {
+		this.random = new Random();
+
+		this.root = null;
+		this.milliseconds = milliseconds;
+	}
+
+	public MCTSAI3(MCTSAI3 other) {
+		this.random = other.random;
+
+		this.root = other.root;
+		this.milliseconds = other.milliseconds;
+	}
+
+	@Override
+	public MCTSAI3 deepCopy() {
+		return new MCTSAI3(this);
+	}
+
+	@Override
+	public long getMove(TurnBasedGame game) {
+		detectRoot(game);
+
+		final long endTime = System.nanoTime() + milliseconds * 1_000_000L;
+
+		while (System.nanoTime() < endTime) {
+			Node leaf = selection(root);
+			leaf = expansion(leaf);
+			final float value = simulation(leaf);
+			backPropagation(leaf, value);
+		}
+
+		final Node mostVisitedChild = mostVisitedChild(root);
+		final long move = mostVisitedChild != null? mostVisitedChild.move : 0L;
+
+		newRoot(move);
+
+		return move;
+	}
+
+	private Node mostVisitedChild(Node root) {
+		Node mostVisitedChild = null;
+		int mostVisited = -1;
+
+		for (int i = 0; i < root.expanded; i++) {
+			if (root.children[i].visits > mostVisited) {
+				mostVisitedChild = root.children[i];
+				mostVisited = root.children[i].visits;
+			}
+		}
+
+		return mostVisitedChild;
+	}
+
+	private void detectRoot(TurnBasedGame game) {
+		if (root == null) {
+			root = new Node(game.deepCopy());
+			return;
+		}
+
+		final long[] currentBoards = game.getBoard();
+		final long[] rootBoards = root.state.getBoard();
+
+		boolean detected = true;
+
+		for (int i = 0; i < rootBoards.length; i++) {
+			if (rootBoards[i] != currentBoards[i]) {
+				detected = false;
+				break;
+			}
+		}
+
+		if (detected) {
+			return;
+		}
+
+		for (int i = 0; i < root.expanded; i++) {
+			final Node child = root.children[i];
+
+			final long[] childBoards = child.state.getBoard();
+
+			detected = true;
+
+			for (int j = 0; j < childBoards.length; j++) {
+				if (childBoards[j] != currentBoards[j]) {
+					detected = false;
+					break;
+				}
+			}
+
+			if (detected) {
+				root = child;
+				return;
+			}
+		}
+
+		root = new Node(game.deepCopy());
+	}
+
+	private void newRoot(long move) {
+		for (final Node child : root.children) {
+			if (child.move == move) {
+				root = child;
+				break;
+			}
+		}
+	}
+
+	private Node selection(Node root) {
+		while (root.isFullyExpanded() && !root.state.isTerminal()) {
+			root = root.bestUCTChild();
+		}
+
+		return root;
+	}
+
+	private Node expansion(Node leaf) {
+		if (leaf.unexpandedMoves == 0L) {
+			return leaf;
+		}
+
+		final long unexpandedMove = leaf.unexpandedMoves & -leaf.unexpandedMoves;
+
+		final TurnBasedGame copiedState = leaf.state.deepCopy();
+		copiedState.play(unexpandedMove);
+
+		final Node expandedChild = new Node(copiedState, leaf, unexpandedMove);
+
+		leaf.children[leaf.expanded] = expandedChild;
+		leaf.expanded++;
+
+		leaf.unexpandedMoves &= ~unexpandedMove;
+
+		return expandedChild;
+	}
+
+	private float simulation(Node leaf) {
+		final TurnBasedGame copiedState = leaf.state.deepCopy();
+		final int playerIndex = 1 - copiedState.getCurrentTurn();
+
+		while (!copiedState.isTerminal()) {
+			final long legalMoves = copiedState.getLegalMoves();
+			final long randomMove = randomSetBit(legalMoves);
+
+			copiedState.play(randomMove);
+		}
+
+		if (copiedState.getWinner() == playerIndex) {
+			return 1.0f;
+		} else if (copiedState.getWinner() >= 0) {
+			return -1.0f;
+		}
+
+		return 0.0f;
+	}
+
+	private void backPropagation(Node leaf, float value) {
+		while (leaf != null) {
+			leaf.value += value;
+			leaf.visits++;
+
+			value = -value;
+			leaf = leaf.parent;
+		}
+	}
+
+	private long randomSetBit(long value) {
+		if (0L == value) {
+			return 0;
+		}
+
+		final int bitCount = Long.bitCount(value);
+		final int randomBitCount = random.nextInt(bitCount);
+
+		for (int i = 0; i < randomBitCount; i++) {
+			value &= value - 1;
+		}
+
+		return value & -value;
+	}
+}

game/src/main/java/org/toop/game/players/ai/mcts/MCTSAI1.java

@@ -23,15 +23,14 @@ public class MCTSAI1 extends MCTSAI {
 
 		final long endTime = System.nanoTime() + milliseconds * 1_000_000L;
 
-		// while (Float.isNaN(root.solved) && System.nanoTime() < endTime) {
+		while (Float.isNaN(root.solved) && System.nanoTime() < endTime) {
-		while (System.nanoTime() < endTime) {
 			Node leaf = selection(root);
 			leaf = expansion(leaf);
-			final float value = simulation(leaf);
+			final int value = simulation(leaf);
 			backPropagation(leaf, value);
 		}
 
-		lastIterations = root.visits;
+		lastIterations = root.visits.get();
 
 		final Node mostVisitedChild = mostVisitedChild(root);
 		return mostVisitedChild.move;

game/src/main/java/org/toop/game/players/ai/mcts/MCTSAI2.java

@@ -29,15 +29,14 @@ public class MCTSAI2 extends MCTSAI {
 
 		final long endTime = System.nanoTime() + milliseconds * 1_000_000L;
 
-		// while (Float.isNaN(root.solved) && System.nanoTime() < endTime) {
+		while (Float.isNaN(root.solved) && System.nanoTime() < endTime) {
-		while (System.nanoTime() < endTime) {
 			Node leaf = selection(root);
 			leaf = expansion(leaf);
-			final float value = simulation(leaf);
+			final int value = simulation(leaf);
 			backPropagation(leaf, value);
 		}
 
-		lastIterations = root.visits;
+		lastIterations = root.visits.get();
 
 		final Node mostVisitedChild = mostVisitedChild(root);
 		final long move = mostVisitedChild.move;

game/src/main/java/org/toop/game/players/ai/mcts/MCTSAI3.java

@@ -3,26 +3,27 @@ package org.toop.game.players.ai.mcts;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 import org.toop.game.players.ai.MCTSAI;
 
-import java.util.ArrayList;
+import java.util.concurrent.CountDownLatch;
-import java.util.List;
-import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
 
 public class MCTSAI3 extends MCTSAI {
 	private final int threads;
+	private final ExecutorService threadPool;
 
 	public MCTSAI3(int milliseconds, int threads) {
 		super(milliseconds);
 
 		this.threads = threads;
+		this.threadPool = Executors.newFixedThreadPool(threads);
 	}
 
 	public MCTSAI3(MCTSAI3 other) {
 		super(other);
 
 		this.threads = other.threads;
+		this.threadPool = other.threadPool;
 	}
 
 	@Override
@@ -32,53 +33,27 @@ public class MCTSAI3 extends MCTSAI {
 
 	@Override
 	public long getMove(TurnBasedGame game) {
-		final ExecutorService pool = Executors.newFixedThreadPool(threads);
+		final Node root = new Node(game.deepCopy(), null, 0L);
+
 		final long endTime = System.nanoTime() + milliseconds * 1_000_000L;
 
-		final List<Callable<Node>> tasks = new ArrayList<>();
+		final CountDownLatch latch = new CountDownLatch(threads);
 
 		for (int i = 0; i < threads; i++) {
-			tasks.add(() -> {
+			threadPool.submit(() -> {
-				final Node localRoot = new Node(game.deepCopy());
+				try {
-
+					iterate(root, endTime);
-				// while (Float.isNaN(localRoot.solved) && System.nanoTime() < endTime) {
+				} finally {
-				while (System.nanoTime() < endTime) {
+					latch.countDown();
-					Node leaf = selection(localRoot);
-					leaf = expansion(leaf);
-					final float value = simulation(leaf);
-					backPropagation(leaf, value);
 				}
-
-				return localRoot;
 			});
 		}
 
 		try {
-			final List<Future<Node>> results = pool.invokeAll(tasks);
+			final long remaining = endTime - System.nanoTime();
+			latch.await(remaining, TimeUnit.NANOSECONDS);
 
-			pool.shutdown();
+			lastIterations = root.visits.get();
-
-			final Node root = new Node(game.deepCopy());
-
-			for (int i = 0; i < root.children.length; i++) {
-				expansion(root);
-			}
-
-			for (final Future<Node> result : results) {
-				final Node localRoot = result.get();
-
-				for (final Node localChild : localRoot.children) {
-					for (int i = 0; i < root.children.length; i++) {
-						if (localChild.move == root.children[i].move) {
-							root.children[i].visits += localChild.visits;
-							root.visits += localChild.visits;
-							break;
-						}
-					}
-				}
-			}
-
-			lastIterations = root.visits;
 
 			final Node mostVisitedChild = mostVisitedChild(root);
 			return mostVisitedChild.move;
@@ -89,4 +64,13 @@ public class MCTSAI3 extends MCTSAI {
 			return randomSetBit(legalMoves);
 		}
 	}
+
+	private void iterate(Node root, long endTime) {
+		while (Float.isNaN(root.solved) && System.nanoTime() < endTime) {
+			Node leaf = selection(root);
+			leaf = expansion(leaf);
+			final int value = simulation(leaf);
+			backPropagation(leaf, value);
+		}
+	}
 }

game/src/main/java/org/toop/game/players/ai/mcts/MCTSAI4.java

@@ -3,29 +3,29 @@ package org.toop.game.players.ai.mcts;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 import org.toop.game.players.ai.MCTSAI;
 
-import java.util.ArrayList;
+import java.util.concurrent.CountDownLatch;
-import java.util.List;
-import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
 
 public class MCTSAI4 extends MCTSAI {
 	private final int threads;
-	private final Node[] threadRoots;
+	private final ExecutorService threadPool;
+
+	private Node root;
 
 	public MCTSAI4(int milliseconds, int threads) {
 		super(milliseconds);
 
 		this.threads = threads;
-		this.threadRoots = new Node[threads];
+		this.threadPool = Executors.newFixedThreadPool(threads);
 	}
 
 	public MCTSAI4(MCTSAI4 other) {
 		super(other);
 
 		this.threads = other.threads;
-		this.threadRoots = other.threadRoots;
+		this.threadPool = other.threadPool;
 	}
 
 	@Override
@@ -35,66 +35,32 @@ public class MCTSAI4 extends MCTSAI {
 
 	@Override
 	public long getMove(TurnBasedGame game) {
-		for (int i = 0; i < threads; i++) {
+		root = findOrResetRoot(root, game);
-			threadRoots[i] = findOrResetRoot(threadRoots[i], game);
-		}
 
-		final ExecutorService pool = Executors.newFixedThreadPool(threads);
 		final long endTime = System.nanoTime() + milliseconds * 1_000_000L;
 
-		final List<Callable<Node>> tasks = new ArrayList<>();
+		final CountDownLatch latch = new CountDownLatch(threads);
 
 		for (int i = 0; i < threads; i++) {
-			final int threadIndex = i;
+			threadPool.submit(() -> {
-
+				try {
-			tasks.add(() -> {
+					iterate(root, endTime);
-				final Node localRoot = threadRoots[threadIndex];
+				} finally {
-
+					latch.countDown();
-				// while (Float.isNaN(localRoot.solved) && System.nanoTime() < endTime) {
-				while (System.nanoTime() < endTime) {
-					Node leaf = selection(localRoot);
-					leaf = expansion(leaf);
-					final float value = simulation(leaf);
-					backPropagation(leaf, value);
 				}
-
-				return localRoot;
 			});
 		}
 
 		try {
-			final List<Future<Node>> results = pool.invokeAll(tasks);
+			final long remaining = endTime - System.nanoTime();
+			latch.await(remaining, TimeUnit.NANOSECONDS);
 
-			pool.shutdown();
+			lastIterations = root.visits.get();
-
-			final Node root = new Node(game.deepCopy());
-
-			for (int i = 0; i < root.children.length; i++) {
-				expansion(root);
-			}
-
-			for (final Future<Node> result : results) {
-				final Node localRoot = result.get();
-
-				for (final Node localChild : localRoot.children) {
-					for (int i = 0; i < root.children.length; i++) {
-						if (localChild.move == root.children[i].move) {
-							root.children[i].visits += localChild.visits;
-							root.visits += localChild.visits;
-							break;
-						}
-					}
-				}
-			}
-
-			lastIterations = root.visits;
 
 			final Node mostVisitedChild = mostVisitedChild(root);
 			final long move = mostVisitedChild.move;
 
-			for (int i = 0; i < threads; i++) {
+			root = findChildByMove(root, move);
-				threadRoots[i] = findChildByMove(threadRoots[i], move);
-			}
 
 			return move;
 		} catch (Exception _) {
@@ -104,4 +70,13 @@ public class MCTSAI4 extends MCTSAI {
 			return randomSetBit(legalMoves);
 		}
 	}
+
+	private void iterate(Node root, long endTime) {
+		while (Float.isNaN(root.solved) && System.nanoTime() < endTime) {
+			Node leaf = selection(root);
+			leaf = expansion(leaf);
+			final int value = simulation(leaf);
+			backPropagation(leaf, value);
+		}
+	}
 }

game/src/test/java/research/AITest.java

@@ -1,35 +1,50 @@
 package research;
 
 
+import org.apache.maven.surefire.shared.io.FileDeleteStrategy;
 import org.junit.jupiter.api.*;
 import org.toop.framework.game.games.reversi.BitboardReversi;
 import org.toop.framework.game.players.ArtificialPlayer;
 import org.toop.game.players.ai.MCTSAI;
-import org.toop.game.players.ai.RandomAI;
 import org.toop.game.players.ai.mcts.MCTSAI1;
 import org.toop.game.players.ai.mcts.MCTSAI2;
 import org.toop.game.players.ai.mcts.MCTSAI3;
 import org.toop.game.players.ai.mcts.MCTSAI4;
 
+import java.io.BufferedReader;
 import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
+import java.time.LocalTime;
+import java.time.format.DateTimeFormatter;
 import java.util.ArrayList;
 import java.util.List;
 
 public class AITest {
 
+    private static String fileName = "gameData.csv";
+
     private static List<Matchup> matchupList = new ArrayList<Matchup>();
     private static List<AIData> dataList = new ArrayList<AIData>();
+    private static List<GameData> gameDataList = new ArrayList<GameData>();
 
     @BeforeAll
     public static void init() {
 
         var versions = new ArtificialPlayer[4];
-        versions[0] = new ArtificialPlayer(new MCTSAI1(100), "MCTS V1");
+        versions[0] = new ArtificialPlayer(new MCTSAI1(10), "MCTS V1");
-        versions[1] = new ArtificialPlayer(new MCTSAI2(100), "MCTS V2");
+        versions[1] = new ArtificialPlayer(new MCTSAI2(10), "MCTS V2");
-        versions[2] = new ArtificialPlayer(new MCTSAI3(100, 8), "MCTS V3");
+        versions[2] = new ArtificialPlayer(new MCTSAI3(10, 8), "MCTS V3");
-        versions[3] = new ArtificialPlayer(new MCTSAI4(100, 8), "MCTS V4");
+        versions[3] = new ArtificialPlayer(new MCTSAI4(10, 8), "MCTS V4");
+
         for (int i = 0; i < versions.length; i++) {
             for (int j = i + 1; j < versions.length; j++) {
                 final int playerIndex1 = i % versions.length;
@@ -40,22 +55,56 @@ public class AITest {
         }
     }
 
+//    @BeforeAll
+//    public static void init() {
+//
+//        var versions = new ArtificialPlayer[11];
+//        versions[0] = new ArtificialPlayer(new MCTSAI3(10, 1), "MCTS V3T1");
+//        versions[1] = new ArtificialPlayer(new MCTSAI3(10, 2), "MCTS V3T2");
+//        versions[2] = new ArtificialPlayer(new MCTSAI3(10, 4), "MCTS V3T4");
+//        versions[3] = new ArtificialPlayer(new MCTSAI3(10, 8), "MCTS V3T8");
+//        versions[4] = new ArtificialPlayer(new MCTSAI3(10, 16), "MCTS V3T16");
+//        versions[5] = new ArtificialPlayer(new MCTSAI3(10, 128), "MCTS V3T32");
+//        versions[6] = new ArtificialPlayer(new MCTSAI3(10, 256), "MCTS V3T64");
+//        versions[7] = new ArtificialPlayer(new MCTSAI3(10, 128), "MCTS V3T128");
+//        versions[8] = new ArtificialPlayer(new MCTSAI3(10, 256), "MCTS V3T256");
+//        versions[9] = new ArtificialPlayer(new MCTSAI3(10, 512), "MCTS V3T512");
+//        versions[10] = new ArtificialPlayer(new MCTSAI3(10, 1024), "MCTS V3T1024");
+//
+//        for (int i = 0; i < versions.length; i++) {
+//            for (int j = i + 1; j < versions.length; j++) {
+//                final int playerIndex1 = i % versions.length;
+//                final int playerIndex2 = j % versions.length;
+//                addMatch(versions[playerIndex1], versions[playerIndex2]);
+//                addMatch(versions[playerIndex2], versions[playerIndex1]); // home vs away system
+//            }
+//        }
+//    }
+
     public static void addMatch(ArtificialPlayer v1, ArtificialPlayer v2) {
         matchupList.add(new Matchup(v1, v2));
     }
 
-    public void addData(AIData data) {
+    public void addAIData(AIData data) {
         dataList.add(data);
     }
 
+    public void addGameData(GameData data) {
+        gameDataList.add(data);
+    }
+
     @Test
     public void testAIvsAI() {
+        while (true) {
             for (Matchup m : matchupList) {
                 playGame(m);
             }
         }
+    }
 
     public void playGame(Matchup m) {
+        long nanocounterAI1 = 0L;
+        long nanocounterAI2 = 0L;
         List<Integer> iterationsAI1 = new ArrayList<>();
         List<Integer> iterationsAI2 = new ArrayList<>();
         final BitboardReversi match = new BitboardReversi();
@@ -65,18 +114,91 @@ public class AITest {
         match.init(players);
         while (!match.isTerminal()) {
             final int currentAI = match.getCurrentTurn();
+            final long startTime = System.nanoTime();
             final long move = players[currentAI].getMove(match);
+            final long endTime = System.nanoTime();
+
             if (players[currentAI].getAi() instanceof MCTSAI) {
                 final int lastIterations = ((MCTSAI) players[currentAI].getAi()).getLastIterations();
+
                 if (currentAI == 0) {
                     iterationsAI1.add(lastIterations);
+                    nanocounterAI1 += (endTime - startTime);
                 } else {
                     iterationsAI2.add(lastIterations);
+                    nanocounterAI2 += (endTime - startTime);
                 }
             }
             match.play(move);
         }
-        generateData(m, match, iterationsAI1, iterationsAI2);
+        generateMatchData(m.getPlayer1().getName(), m.getPlayer2().getName(), match, iterationsAI1, iterationsAI2, nanocounterAI1, nanocounterAI2);
+    }
+
+    public void generateMatchData(
+            String AI1,
+            String AI2,
+            BitboardReversi match,
+
+            List<Integer> iterationsAI1,
+            List<Integer> iterationsAI2,
+
+            long nanocounterAI1,
+            long nanocounterAI2
+    ) {
+        try {
+
+            var ai110 = iterationsAI1.subList(0,  10);
+            var ai120 = iterationsAI1.subList(10, 20);
+            var ai130 = iterationsAI1.subList(20, iterationsAI1.size());
+
+            var ai210 = iterationsAI2.subList(0,  10);
+            var ai220 = iterationsAI2.subList(10, 20);
+            var ai230 = iterationsAI2.subList(20, iterationsAI2.size());
+
+            writeGamesToCSV(fileName, new GameData(
+                    AI1,
+                    AI2,
+                    getWinnerForMatch(AI1, AI2, match),
+                    match.getAmountOfTurns(),
+
+                    iterationsAI1.stream().mapToLong(Integer::longValue).sum(),
+                    ai110.stream().mapToLong(Integer::longValue).sum(),
+                    ai120.stream().mapToLong(Integer::longValue).sum(),
+                    ai130.stream().mapToLong(Integer::longValue).sum(),
+                    iterationsAI1.stream().mapToDouble(Integer::doubleValue).sum() / iterationsAI1.size(),
+                    ai110.stream().mapToDouble(Integer::doubleValue).sum() / ai110.size(),
+                    ai120.stream().mapToDouble(Integer::doubleValue).sum() / ai120.size(),
+                    ai130.stream().mapToDouble(Integer::doubleValue).sum() / ai130.size(),
+
+                    iterationsAI2.stream().mapToInt(Integer::intValue).sum(),
+                    ai210.stream().mapToLong(Integer::longValue).sum(),
+                    ai220.stream().mapToLong(Integer::longValue).sum(),
+                    ai230.stream().mapToLong(Integer::longValue).sum(),
+                    iterationsAI2.stream().mapToDouble(Integer::doubleValue).sum() / iterationsAI2.size(),
+                    ai210.stream().mapToDouble(Integer::doubleValue).sum() / ai210.size(),
+                    ai220.stream().mapToDouble(Integer::doubleValue).sum() / ai220.size(),
+                    ai230.stream().mapToDouble(Integer::doubleValue).sum() / ai230.size(),
+
+                    nanocounterAI1,
+                    nanocounterAI2,
+                    LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss"))
+            ));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        } catch (IndexOutOfBoundsException e) {
+            return;
+        }
+    }
+
+    public String getWinnerForMatch(String AI1, String AI2, BitboardReversi match) {
+        if (match.getWinner() == 0) {
+            return AI1;
+        }
+        if (match.getWinner() == 1) {
+            return AI2;
+        } else {
+            return "TIE";
+        }
     }
 
     public void generateData(Matchup matchup, BitboardReversi match, List<Integer> iterationsAI1, List<Integer> iterationsAI2) {
@@ -90,10 +212,10 @@ public class AITest {
             }
         }
         if (!(matchup1Found)) {
-            addData(new AIData(matchup.getPlayer1().getName(), 0, 0, 0, 0, 0, 0));
+            addAIData(new AIData(matchup.getPlayer1().getName(), 0, 0, 0, 0, 0, 0));
         }
         if (!(matchup2Found)) {
-            addData(new AIData(matchup.getPlayer2().getName(), 0, 0, 0, 0, 0, 0));
+            addAIData(new AIData(matchup.getPlayer2().getName(), 0, 0, 0, 0, 0, 0));
         }
 
         for (AIData aiData : dataList) { // set data for player 1
@@ -150,13 +272,56 @@ public class AITest {
     @AfterAll
     public static void writeAfterTests() {
         try {
-            writeToCsv("Data.csv", dataList);
+            writeAIToCsv("Data.csv", dataList);
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 
-    public static void writeToCsv(String filepath, List<AIData> dataList) throws IOException {
+    public static void writeGamesToCSV(String filepath, GameData gameData) throws IOException {
+        try (
+                final BufferedWriter writer = Files.newBufferedWriter(
+                        Paths.get(filepath),
+                        StandardCharsets.UTF_8,
+                        StandardOpenOption.CREATE,
+                        StandardOpenOption.APPEND
+                );
+                final BufferedReader reader = new BufferedReader(new FileReader(filepath))
+        ) {
+            if (reader.readLine() == null || reader.readLine().isBlank()) {
+                writer.write("Black,White,Winner,Turns Played,Black total iterations,Black total iterations 0-10,Black total iterations 11-20,Black total iterations 21-30,Black average iterations,Black average iterations 0-10,Black average iterations 11-20,Black average iterations 21-30,White total iterations,White total iterations 0-10,White total iterations 11-20,White total iterations 21-30,White average iterations,White average iterations 0-10,White average iterations 11-20,White average iterations 21-30,Total Time AI1,Total Time AI2,Time");
+                writer.newLine();
+            }
+
+            writer.write(
+                    gameData.AI1() + "," +
+                    gameData.AI2() + "," +
+                    gameData.winner() + "," +
+                    gameData.turns() + "," +
+                    gameData.AI1totalIterations() + "," +
+                    gameData.AI1totalIterations10() + "," +
+                    gameData.AI1totalIterations20() + "," +
+                    gameData.AI1totalIterations30() + "," +
+                    BigDecimal.valueOf(gameData.AI1averageIterations()).setScale(2, RoundingMode.HALF_EVEN) + "," +
+                    BigDecimal.valueOf(gameData.AI1averageIterations10()).setScale(2, RoundingMode.HALF_EVEN) + "," +
+                    BigDecimal.valueOf(gameData.AI1averageIterations20()).setScale(2, RoundingMode.HALF_EVEN) + "," +
+                    BigDecimal.valueOf(gameData.AI1averageIterations30()).setScale(2, RoundingMode.HALF_EVEN) + "," +
+                    gameData.AI2totalIterations() + "," +
+                    gameData.AI2totalIterations10() + "," +
+                    gameData.AI2totalIterations20() + "," +
+                    gameData.AI2totalIterations30() + "," +
+                    BigDecimal.valueOf(gameData.AI2averageIterations()).setScale(2, RoundingMode.HALF_EVEN) + "," +
+                    BigDecimal.valueOf(gameData.AI2averageIterations10()).setScale(2, RoundingMode.HALF_EVEN) + "," +
+                    BigDecimal.valueOf(gameData.AI2averageIterations20()).setScale(2, RoundingMode.HALF_EVEN) + "," +
+                    BigDecimal.valueOf(gameData.AI2averageIterations30()).setScale(2, RoundingMode.HALF_EVEN) + "," +
+                    (gameData.nanoAI1() / 1_000_000L) + "," +
+                    (gameData.nanoAI2() / 1_000_000L) + "," +
+                    gameData.time());
+            writer.newLine();
+        }
+    }
+
+    public static void writeAIToCsv(String filepath, List<AIData> dataList) throws IOException {
         try (BufferedWriter writer = new BufferedWriter(new FileWriter(filepath))) {
             writer.write("AI Name,Games Played,Winrate,Average Iterations,Average Iterations 0-10, Average Iterations 11-20, Average Iterations 20-30");
             writer.newLine();

game/src/test/java/research/GameData.java

@@ -0,0 +1,32 @@
+package research;
+
+public record GameData(
+        String AI1,
+        String AI2,
+        String winner,
+        int turns,
+
+        long AI1totalIterations,
+        long AI1totalIterations10,
+        long AI1totalIterations20,
+        long AI1totalIterations30,
+        double AI1averageIterations,
+        double AI1averageIterations10,
+        double AI1averageIterations20,
+        double AI1averageIterations30,
+
+        long AI2totalIterations,
+        long AI2totalIterations10,
+        long AI2totalIterations20,
+        long AI2totalIterations30,
+        double AI2averageIterations,
+        double AI2averageIterations10,
+        double AI2averageIterations20,
+        double AI2averageIterations30,
+
+        long nanoAI1,
+        long nanoAI2,
+
+        String time
+) {}
+