Server update with new dev changes (#305)

* merge widgets with development

* readd previous game thread code

* Revert "readd previous game thread code"

This reverts commit d24feef73e.

* Revert "Merge remote-tracking branch 'origin/Development' into Development"

This reverts commit 59d46cb73c, reversing
changes made to 38681c5db0.

* Revert "merge widgets with development"

This reverts commit 38681c5db0.

* Merge 292 into development (#293)

Applied template method pattern to abstract player

* Added documentation to player classes and improved method names (#295)

* mcts v1

* bitboard optimization

* bitboard fix & mcts v2 & mcts v3. v3 still in progress and v4 coming soon

* main

---------

Co-authored-by: ramollia <>
Co-authored-by: Stef <stbuwalda@gmail.com>
Co-authored-by: Stef <48526421+StefBuwalda@users.noreply.github.com>

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

@@ -0,0 +1,193 @@
+package org.toop.game.players.ai;
+
+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.AbstractAI;
+
+import java.util.Random;
+
+public class MCTSAI extends AbstractAI {
+	private static class Node {
+		public TurnBasedGame state;
+		public long move;
+
+		public Node parent;
+
+		public int expanded;
+		public Node[] children;
+
+		public int visits;
+		public float value;
+
+		public Node(TurnBasedGame state, long move, Node parent) {
+			this.state = state;
+			this.move = move;
+
+			this.parent = parent;
+
+			this.expanded = 0;
+			this.children = new Node[Long.bitCount(state.getLegalMoves())];
+
+			this.visits = 0;
+			this.value = 0.0f;
+		}
+
+		public Node(TurnBasedGame state) {
+			this(state, 0L, null);
+		}
+
+		public boolean isFullyExpanded() {
+			return expanded >= children.length;
+		}
+
+		float calculateUCT() {
+			float exploitation = visits <= 0? 0 : value / visits;
+			float exploration = 1.41f * (float)(Math.sqrt(Math.log(visits) / visits));
+
+			return exploitation + exploration;
+		}
+
+		public Node bestUCTChild() {
+			int bestChildIndex = -1;
+			float bestScore = Float.NEGATIVE_INFINITY;
+
+			for (int i = 0; i < expanded; i++) {
+				final float score = calculateUCT();
+
+				if (score > bestScore) {
+					bestChildIndex = i;
+					bestScore = score;
+				}
+			}
+
+			return bestChildIndex >= 0? children[bestChildIndex] : this;
+		}
+	}
+
+	private final int milliseconds;
+
+	public MCTSAI(int milliseconds) {
+		this.milliseconds = milliseconds;
+	}
+
+	public MCTSAI(MCTSAI other) {
+		this.milliseconds = other.milliseconds;
+	}
+
+	@Override
+	public MCTSAI deepCopy() {
+		return new MCTSAI(this);
+	}
+
+	@Override
+	public long getMove(TurnBasedGame game) {
+		Node root = new Node(game.deepCopy());
+
+		long endTime = System.currentTimeMillis() + milliseconds;
+
+		while (System.currentTimeMillis() <= endTime) {
+			Node node = selection(root);
+			long legalMoves = node.state.getLegalMoves();
+
+			if (legalMoves != 0) {
+				node = expansion(node, legalMoves);
+			}
+
+			float result = 0.0f;
+
+			if (node.state.getLegalMoves() != 0) {
+				result = simulation(node.state, game.getCurrentTurn());
+			}
+
+			backPropagation(node, result);
+		}
+
+		int mostVisitedIndex = -1;
+		int mostVisits = -1;
+
+		for (int i = 0; i < root.expanded; i++) {
+			if (root.children[i].visits > mostVisits) {
+				mostVisitedIndex = i;
+				mostVisits = root.children[i].visits;
+			}
+		}
+
+		return mostVisitedIndex != -1? root.children[mostVisitedIndex].move : randomSetBit(game.getLegalMoves());
+	}
+
+	private Node selection(Node node) {
+		while (node.state.getLegalMoves() != 0L && node.isFullyExpanded()) {
+			node = node.bestUCTChild();
+		}
+
+		return node;
+	}
+
+	private Node expansion(Node node, long legalMoves) {
+		for (int i = 0; i < node.expanded; i++) {
+			legalMoves &= ~node.children[i].move;
+		}
+
+		if (legalMoves == 0L) {
+			return node;
+		}
+
+		long move = randomSetBit(legalMoves);
+
+		TurnBasedGame copy = node.state.deepCopy();
+		copy.play(move);
+
+		Node newlyExpanded = new Node(copy, move, node);
+
+		node.children[node.expanded] = newlyExpanded;
+		node.expanded++;
+
+		return newlyExpanded;
+	}
+
+	private float simulation(TurnBasedGame state, int playerIndex) {
+		TurnBasedGame copy = state.deepCopy();
+		long legalMoves = copy.getLegalMoves();
+		PlayResult result = null;
+
+		while (legalMoves != 0) {
+			result = copy.play(randomSetBit(legalMoves));
+			legalMoves = copy.getLegalMoves();
+		}
+
+		if (result.state() == GameState.WIN) {
+			if (result.player() == playerIndex) {
+				return 1.0f;
+			}
+
+			return -1.0f;
+		}
+
+		return -0.2f;
+	}
+
+	private void backPropagation(Node node, float value) {
+		while (node != null) {
+			node.visits++;
+			node.value += value;
+			node = node.parent;
+		}
+	}
+
+	public static long randomSetBit(long value) {
+		Random random = new Random();
+
+		int count = Long.bitCount(value);
+		int target = random.nextInt(count);
+
+		while (true) {
+			int bit = Long.numberOfTrailingZeros(value);
+			if (target == 0) {
+				return 1L << bit;
+			}
+			value &= value - 1;
+			target--;
+		}
+	}
+}

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/MiniMaxAI.java

@@ -0,0 +1,165 @@
+package org.toop.game.players.ai;
+
+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.AbstractAI;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class MiniMaxAI extends AbstractAI {
+
+    private final int maxDepth;
+    private final Random random = new Random();
+
+    public MiniMaxAI(int depth) {
+        this.maxDepth = depth;
+    }
+
+    public MiniMaxAI(MiniMaxAI other) {
+        this.maxDepth = other.maxDepth;
+    }
+
+    @Override
+    public MiniMaxAI deepCopy() {
+        return new MiniMaxAI(this);
+    }
+
+    @Override
+    public long getMove(TurnBasedGame game) {
+        long legalMoves = game.getLegalMoves();
+        if (legalMoves == 0) return 0;
+
+        List<Long> bestMoves = new ArrayList<>();
+        int bestScore = Integer.MIN_VALUE;
+        int aiPlayer = game.getCurrentTurn();
+
+        long movesLoop = legalMoves;
+        while (movesLoop != 0) {
+            long move = 1L << Long.numberOfTrailingZeros(movesLoop);
+            TurnBasedGame copy = game.deepCopy();
+            PlayResult result = copy.play(move);
+
+            int score;
+            switch (result.state()) {
+                case WIN -> score = (result.player() == aiPlayer ? maxDepth : -maxDepth);
+                case DRAW -> score = 0;
+                default -> score = getMoveScore(copy, maxDepth - 1, false, aiPlayer, Integer.MIN_VALUE, Integer.MAX_VALUE);
+            }
+
+            if (score > bestScore) {
+                bestScore = score;
+                bestMoves.clear();
+                bestMoves.add(move);
+            } else if (score == bestScore) {
+                bestMoves.add(move);
+            }
+
+            movesLoop &= movesLoop - 1;
+        }
+
+        long chosenMove = bestMoves.get(random.nextInt(bestMoves.size()));
+        return chosenMove;
+    }
+
+    /**
+     * Recursive minimax with alpha-beta pruning and heuristic evaluation.
+     *
+     * @param game       Current game state
+     * @param depth      Remaining depth
+     * @param maximizing True if AI is maximizing, false if opponent
+     * @param aiPlayer   AI's player index
+     * @param alpha      Alpha value
+     * @param beta       Beta value
+     * @return score of the position
+     */
+    private int getMoveScore(TurnBasedGame game, int depth, boolean maximizing, int aiPlayer, int alpha, int beta) {
+        long legalMoves = game.getLegalMoves();
+
+        // Terminal state
+        PlayResult lastResult = null;
+        if (legalMoves == 0) {
+            lastResult = new PlayResult(GameState.DRAW, -1);
+        }
+
+        // If the game is over or depth limit reached, evaluate
+        if (depth <= 0 || legalMoves == 0) {
+            if (lastResult != null) return 0;
+            return evaluateBoard(game, aiPlayer);
+        }
+
+        int bestScore = maximizing ? Integer.MIN_VALUE : Integer.MAX_VALUE;
+        long movesLoop = legalMoves;
+
+        while (movesLoop != 0) {
+            long move = 1L << Long.numberOfTrailingZeros(movesLoop);
+            TurnBasedGame copy = game.deepCopy();
+            PlayResult result = copy.play(move);
+
+            int score;
+            switch (result.state()) {
+                case WIN -> score = (result.player() == aiPlayer ? depth : -depth);
+                case DRAW -> score = 0;
+                default -> score = getMoveScore(copy, depth - 1, !maximizing, aiPlayer, alpha, beta);
+            }
+
+            if (maximizing) {
+                bestScore = Math.max(bestScore, score);
+                alpha = Math.max(alpha, bestScore);
+            } else {
+                bestScore = Math.min(bestScore, score);
+                beta = Math.min(beta, bestScore);
+            }
+
+            // Alpha-beta pruning
+            if (beta <= alpha) break;
+
+            movesLoop &= movesLoop - 1;
+        }
+
+        return bestScore;
+    }
+
+    /**
+     * Simple heuristic evaluation for Reversi-like games.
+     * Positive = good for AI, Negative = good for opponent.
+     *
+     * @param game     OnlineTurnBasedGame state
+     * @param aiPlayer AI's player index
+     * @return heuristic score
+     */
+    private int evaluateBoard(TurnBasedGame game, int aiPlayer) {
+        long[] board = game.getBoard();
+        int aiCount = 0;
+        int opponentCount = 0;
+
+        // Count pieces for AI vs opponent
+        for (int i = 0; i < board.length; i++) {
+            long bits = board[i];
+            for (int j = 0; j < 64; j++) {
+                if ((bits & (1L << j)) != 0) {
+                    // Assume player 0 occupies even indices, player 1 occupies odd
+                    if ((i * 64 + j) % game.getPlayerCount() == aiPlayer) aiCount++;
+                    else opponentCount++;
+                }
+            }
+        }
+
+        // Mobility (number of legal moves)
+        int mobility = Long.bitCount(game.getLegalMoves());
+
+        // Corner control (top-left, top-right, bottom-left, bottom-right)
+        int corners = 0;
+        long[] cornerMasks = {1L << 0, 1L << 7, 1L << 56, 1L << 63};
+        for (long mask : cornerMasks) {
+            for (long b : board) {
+                if ((b & mask) != 0) corners += 1;
+            }
+        }
+
+        // Weighted sum
+        return (aiCount - opponentCount) + 2 * mobility + 5 * corners;
+    }
+}

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

@@ -0,0 +1,38 @@
+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 RandomAI extends AbstractAI {
+
+    public RandomAI() {
+        super();
+    }
+
+    @Override
+    public RandomAI deepCopy() {
+        return new RandomAI();
+    }
+
+    @Override
+    public long getMove(TurnBasedGame game) {
+        long legalMoves = game.getLegalMoves();
+        int move = new Random().nextInt(Long.bitCount(legalMoves));
+        return nthBitIndex(legalMoves, move);
+    }
+
+    public static long nthBitIndex(long bb, int n) {
+        while (bb != 0) {
+            int tz = Long.numberOfTrailingZeros(bb);
+            if (n == 0) {
+                return 1L << tz;
+            }
+            bb &= bb - 1; // clear the least significant 1
+            n--;
+        }
+        return 0L; // not enough 1s
+    }
+}