bitboard merge

Merge branch 'Development' into ReversiML
# Conflicts: # game/src/main/java/org/toop/game/games/reversi/ReversiR.java
2026-02-04 10:54:51 +00:00 · 2025-12-15 10:28:33 +01:00 · 2025-12-13 15:04:40 +01:00 · 2025-12-08 14:55:32 +01:00 · 2025-12-08 11:58:32 +01:00 · 2025-12-08 11:36:31 +01:00
36 changed files with 757 additions and 340 deletions
--- a/app/src/main/java/org/toop/app/App.java
+++ b/app/src/main/java/org/toop/app/App.java
@@ -16,6 +16,7 @@ import org.toop.framework.audio.*;
 import org.toop.framework.audio.events.AudioEvents;
 import org.toop.framework.eventbus.EventFlow;
 import org.toop.framework.eventbus.GlobalEventBus;
+import org.toop.game.machinelearning.NeuralNetwork;
 import org.toop.framework.networking.NetworkingClientEventListener;
 import org.toop.framework.networking.NetworkingClientManager;
 import org.toop.framework.resource.ResourceLoader;
@@ -138,6 +139,12 @@ public final class App extends Application {

 		stage.show();

+        //startML();
+	}
+
+    private void startML() {
+        NeuralNetwork nn = new NeuralNetwork();
+        nn.init();
    }

 	private void setKeybinds(StackPane root) {
--- a/app/src/main/java/org/toop/app/Server.java
+++ b/app/src/main/java/org/toop/app/Server.java
@@ -223,7 +223,7 @@ public final class Server {
                    Player<BitboardReversi>[] players = new Player[2];
                    players[(myTurn + 1) % 2] = new OnlinePlayer<>(response.opponent());
                    players[myTurn] = new ArtificialPlayer<>(new RandomAI<BitboardReversi>(), user);
-                    gameController = new ReversiBitController(players, false);}
+                    gameController = new ReversiBitController(players);}
                default -> new ErrorPopup("Unsupported game type.");

            }
--- a/app/src/main/java/org/toop/app/canvas/BitGameCanvas.java
+++ b/app/src/main/java/org/toop/app/canvas/BitGameCanvas.java
@@ -108,7 +108,6 @@ public abstract class BitGameCanvas<T extends TurnBasedGame<T>> implements GameC
        }
    }

-
 	private void render() {
 		graphics.setFill(backgroundColor);
 		graphics.fillRect(0, 0, width, height);
--- a/app/src/main/java/org/toop/app/canvas/BitLegalMoveDrawer.java
+++ b/app/src/main/java/org/toop/app/canvas/BitLegalMoveDrawer.java
@@ -1,5 +0,0 @@
-package org.toop.app.canvas;
-
-public interface BitLegalMoveDrawer {
-    void showLegalMove(long move, int currentPlayerIndex);
-}
--- a/app/src/main/java/org/toop/app/canvas/ReversiBitCanvas.java
+++ b/app/src/main/java/org/toop/app/canvas/ReversiBitCanvas.java
@@ -4,15 +4,12 @@ import javafx.scene.paint.Color;
 import org.toop.app.App;
 import org.toop.game.games.reversi.BitboardReversi;

-public class ReversiBitCanvas extends BitGameCanvas<BitboardReversi> implements BitLegalMoveDrawer {
+import java.util.Arrays;
+import java.util.function.Consumer;

-    private final boolean switchColors;
-    private final boolean local;
-
-    public ReversiBitCanvas(boolean switchColors, boolean local) {
+public class ReversiBitCanvas extends BitGameCanvas<BitboardReversi> {
+    public ReversiBitCanvas() {
        super(Color.GRAY, new Color(0f, 0.4f, 0.2f, 1f), (App.getHeight() / 4) * 3, (App.getHeight() / 4) * 3, 8, 8, 5, true);
-        this.switchColors = switchColors;
-        this.local = local;
        canvas.setOnMouseMoved(event -> {
            double mouseX = event.getX();
            double mouseY = event.getY();
@@ -39,39 +36,7 @@ public class ReversiBitCanvas extends BitGameCanvas<BitboardReversi> implements
    public void redraw(BitboardReversi gameCopy) {
        clearAll();
        long[] board = gameCopy.getBoard();
-        if (switchColors && local) {
-            loopOverBoard(board[0], (i) -> drawDot(Color.BLACK, i));
-            loopOverBoard(board[1], (i) -> drawDot(Color.WHITE, i));
-        } else {
        loopOverBoard(board[0], (i) -> drawDot(Color.WHITE, i));
        loopOverBoard(board[1], (i) -> drawDot(Color.BLACK, i));
    }
 }
-
-    @Override
-    public void showLegalMove(long move, int currentPlayerIndex) {
-        int idx = Long.numberOfTrailingZeros(move);
-        drawLegalMove(idx, currentPlayerIndex);
-    }
-
-    public void drawLegalMove(int cell, int player) {
-        Color innerColor;
-        if (switchColors) {
-            if (player == 0) {
-                innerColor = new Color(0.0f, 0.0f, 0.0f, 0.6f);
-            }
-            else {
-                innerColor = new Color(1.0f, 1.0f, 1.0f, 0.75f);
-            }
-            this.drawInnerDot(innerColor, cell, false);
-        } else {
-        if (player == 1) {
-            innerColor = new Color(0.0f, 0.0f, 0.0f, 0.6f);
-        }
-        else {
-            innerColor = new Color(1.0f, 1.0f, 1.0f, 0.75f);
-        }
-        this.drawInnerDot(innerColor, cell, false);
-        }
-    }
-}
--- a/app/src/main/java/org/toop/app/canvas/TicTacToeBitCanvas.java
+++ b/app/src/main/java/org/toop/app/canvas/TicTacToeBitCanvas.java
@@ -30,6 +30,7 @@ public class TicTacToeBitCanvas extends BitGameCanvas<BitboardTicTacToe>{
    private void drawMoves(long[] gameBoard){
        loopOverBoard(gameBoard[0], (i) -> drawX(Color.RED, i));
        loopOverBoard(gameBoard[1], (i) -> drawO(Color.BLUE, i));
+
    }


--- a/app/src/main/java/org/toop/app/gameControllers/GenericGameController.java
+++ b/app/src/main/java/org/toop/app/gameControllers/GenericGameController.java
@@ -5,7 +5,6 @@ import javafx.geometry.Pos;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.toop.app.canvas.GameCanvas;
-import org.toop.app.canvas.BitLegalMoveDrawer;
 import org.toop.app.widget.WidgetContainer;
 import org.toop.app.widget.view.GameView;
 import org.toop.framework.eventbus.EventFlow;
@@ -19,7 +18,7 @@ import org.toop.framework.gameFramework.view.GUIEvents;
 import org.toop.framework.networking.events.NetworkEvents;
 import org.toop.game.players.LocalPlayer;

-public class GenericGameController<T extends TurnBasedGame<T>, C extends GameCanvas<T>> implements GameController {
+public class GenericGameController<T extends TurnBasedGame<T>> implements GameController {
    protected final EventFlow eventFlow = new EventFlow();

    // Logger for logging
@@ -28,22 +27,18 @@ public class GenericGameController<T extends TurnBasedGame<T>, C extends GameCan
    // Reference to gameView view
    protected final GameView gameView;

-    // Reference to String gametype
-    protected final String gameType;
-
    // Reference to game canvas
-    protected final C canvas;
+    protected final GameCanvas<T> canvas;

    protected final TurnBasedGame<T> game;       // Reference to game instance
    private final ThreadBehaviour gameThreadBehaviour;

    // TODO: Change gameType to automatically happen with either dependency injection or something else.
-    public GenericGameController(C canvas, T game, ThreadBehaviour gameThreadBehaviour, String gameType) {
+    public GenericGameController(GameCanvas<T> canvas, T game, ThreadBehaviour gameThreadBehaviour, String gameType) {
        logger.info("Creating: " + this.getClass());

        this.canvas = canvas;
        this.game = game;
-        this.gameType = gameType;
        this.gameThreadBehaviour = gameThreadBehaviour;

        // Tell thread how to send moves
@@ -141,21 +136,5 @@ public class GenericGameController<T extends TurnBasedGame<T>, C extends GameCan
    @Override
    public void updateUI() {
        canvas.redraw(game.deepCopy());
-        gameView.updatePlayerInfo(
-               true,
-               getCurrentPlayer().getName(),
-               game.getCurrentTurn() == 0 ? "X" : "O",
-               getPlayer((game.getCurrentTurn() + 1 ) % 2).getName(),
-               this.gameType
-       );
-        // draw legal moves for bit canvasses
-        if (canvas instanceof BitLegalMoveDrawer) {
-            long movesLoop = game.getLegalMoves();
-            while (movesLoop != 0) {
-                long move = 1L << Long.numberOfTrailingZeros(movesLoop);
-                ((BitLegalMoveDrawer) canvas).showLegalMove(move, getCurrentPlayerIndex());
-                movesLoop &= movesLoop - 1;
-            }
-        }
    }
 }
--- a/app/src/main/java/org/toop/app/gameControllers/ReversiBitController.java
+++ b/app/src/main/java/org/toop/app/gameControllers/ReversiBitController.java
@@ -1,17 +1,15 @@
 package org.toop.app.gameControllers;

-import javafx.scene.paint.Color;
 import org.toop.app.canvas.ReversiBitCanvas;
 import org.toop.framework.gameFramework.model.game.threadBehaviour.ThreadBehaviour;
 import org.toop.framework.gameFramework.model.player.Player;
 import org.toop.game.gameThreads.LocalThreadBehaviour;
 import org.toop.game.gameThreads.OnlineThreadBehaviour;
 import org.toop.game.games.reversi.BitboardReversi;
-import org.toop.game.players.LocalPlayer;
 import org.toop.game.players.OnlinePlayer;

-public class ReversiBitController extends GenericGameController<BitboardReversi, ReversiBitCanvas> {
-    public ReversiBitController(Player<BitboardReversi>[] players, boolean switchColors) {
+public class ReversiBitController extends GenericGameController<BitboardReversi> {
+    public ReversiBitController(Player<BitboardReversi>[] players) {
        BitboardReversi game = new BitboardReversi(players);
        ThreadBehaviour thread = new LocalThreadBehaviour<>(game);
        for (Player<BitboardReversi> player : players) {
@@ -19,6 +17,6 @@ public class ReversiBitController extends GenericGameController<BitboardReversi,
                thread = new OnlineThreadBehaviour<>(game);
            }
        }
-        super(new ReversiBitCanvas(switchColors, players[0] instanceof LocalPlayer<BitboardReversi> || players[1] instanceof LocalPlayer<BitboardReversi>), game, thread, "Reversi");
+        super(new ReversiBitCanvas(), game, thread, "Reversi");
    }
 }
--- a/app/src/main/java/org/toop/app/gameControllers/TicTacToeBitController.java
+++ b/app/src/main/java/org/toop/app/gameControllers/TicTacToeBitController.java
@@ -9,7 +9,7 @@ import org.toop.game.gameThreads.OnlineThreadBehaviour;
 import org.toop.game.games.tictactoe.BitboardTicTacToe;
 import org.toop.game.players.OnlinePlayer;

-public class TicTacToeBitController extends GenericGameController<BitboardTicTacToe, TicTacToeBitCanvas > {
+public class TicTacToeBitController extends GenericGameController<BitboardTicTacToe> {
    public TicTacToeBitController(Player<BitboardTicTacToe>[] players) {
        BitboardTicTacToe game = new BitboardTicTacToe(players);
        ThreadBehaviour thread = new LocalThreadBehaviour<>(game);
--- a/app/src/main/java/org/toop/app/widget/view/GameView.java
+++ b/app/src/main/java/org/toop/app/widget/view/GameView.java
@@ -16,15 +16,14 @@ import org.toop.app.widget.tutorial.Connect4TutorialWidget;
 import org.toop.app.widget.tutorial.ReversiTutorialWidget;
 import org.toop.app.widget.tutorial.TicTacToeTutorialWidget;
 import org.toop.local.AppContext;
-import org.toop.local.AppSettings;

 public final class GameView extends ViewWidget {
 	private final Text playerHeader;
 	private final Text turnHeader;
    private final Text player1Header;
    private final Text player2Header;
-    private final Circle player1Icon;
-    private final Circle player2Icon;
+    private Circle player1Icon;
+    private Circle player2Icon;
 	private final Button forfeitButton;
 	private final Button exitButton;
    private final TextField chatInput;
@@ -95,7 +94,7 @@ public final class GameView extends ViewWidget {
 		}
 	}

-	public void updatePlayerInfo(boolean isMe, String currentPlayer, String currentMove, String nextPlayer, String GameType) {
+	public void nextPlayer(boolean isMe, String currentPlayer, String currentMove, String nextPlayer, char GameType) {
 		Platform.runLater(() -> {
            if (!(hasSet)) {
                playerHeader.setText(currentPlayer + " vs. " + nextPlayer);
@@ -113,8 +112,8 @@ public final class GameView extends ViewWidget {
 		new GameOverPopup(iWon, winner).show(Pos.CENTER);
 	}

-    private void setPlayerHeaders(boolean isMe, String currentPlayer, String nextPlayer, String GameType) {
-        if (GameType.equals("TicTacToe")) {
+    private void setPlayerHeaders(boolean isMe, String currentPlayer, String nextPlayer, char GameType) {
+        if (GameType == 'T') {
            if (isMe) {
                player1Header.setText("X: " + currentPlayer);
                player2Header.setText("O: " + nextPlayer);
@@ -125,16 +124,15 @@ public final class GameView extends ViewWidget {
            }
            setPlayerInfoTTT();
        }
-        else if (GameType.equals("Reversi")) {
-            boolean swap = AppSettings.getSettings().getSwitchReversi();
-            if (!swap) {
-                player1Header.setText(nextPlayer);
-                player2Header.setText(currentPlayer);
-            }
-            else {
+        else if (GameType == 'R') {
+            if (isMe) {
                player1Header.setText(currentPlayer);
                player2Header.setText(nextPlayer);
            }
+            else {
+                player1Header.setText(nextPlayer);
+                player2Header.setText(currentPlayer);
+            }
            setPlayerInfoReversi();
        }
    }
@@ -168,8 +166,8 @@ public final class GameView extends ViewWidget {
        var playerInfo = Primitive.vbox(
                playerHeader,
                Primitive.separator(),
-                player2box,
-                player1box
+                player1box,
+                player2box
        );

        player1Icon.setRadius(player1Header.fontProperty().map(Font::getSize).getValue());
--- a/app/src/main/java/org/toop/app/widget/view/LocalMultiplayerView.java
+++ b/app/src/main/java/org/toop/app/widget/view/LocalMultiplayerView.java
@@ -79,7 +79,6 @@ public class LocalMultiplayerView extends ViewWidget {
                    }
                    break;
                case REVERSI:
-                    boolean swap = AppSettings.getSettings().getSwitchReversi();
                    if (information.players[0].isHuman) {
                        players[0] = new LocalPlayer<>(information.players[0].name);
                    } else {
@@ -93,17 +92,17 @@ public class LocalMultiplayerView extends ViewWidget {
                    if (AppSettings.getSettings().getTutorialFlag() && AppSettings.getSettings().getFirstReversi()) {
                        new ShowEnableTutorialWidget(
                                () -> new ReversiTutorialWidget(() -> {
-                                    gameController = new ReversiBitController(players, swap);
+                                    gameController = new ReversiBitController(players);
                                    gameController.start();
                                }),
                                () -> Platform.runLater(() -> {
-                                    gameController = new ReversiBitController(players, swap);
+                                    gameController = new ReversiBitController(players);
                                    gameController.start();
                                }),
                                () -> AppSettings.getSettings().setFirstReversi(false)
                        );
                    } else {
-                        gameController = new ReversiBitController(players, swap);
+                        gameController = new ReversiBitController(players);
                        gameController.start();
                    }
                    break;
--- a/app/src/main/java/org/toop/app/widget/view/OptionsView.java
+++ b/app/src/main/java/org/toop/app/widget/view/OptionsView.java
@@ -149,22 +149,13 @@ public class OptionsView extends ViewWidget {
 			"small", "medium", "large"
 		);

-        var swapReversiColors = new ToggleWidget(
-                "reversinotswapped", "reversiswapped",
-                AppSettings.getSettings().getSwitchReversi(),
-                swap -> {
-                    AppSettings.getSettings().setSwitchReversi(swap);
-                }
-        );

 		return Primitive.vbox(
 			Primitive.header("style"),
 			Primitive.separator(),

 			themeWidget.getNode(),
-			layoutWidget.getNode(),
-            Primitive.text("reversiswap"),
-            swapReversiColors.getNode()
+			layoutWidget.getNode()
 		);
 	}
 }
--- a/app/src/main/java/org/toop/local/AppSettings.java
+++ b/app/src/main/java/org/toop/local/AppSettings.java
@@ -5,16 +5,18 @@ import org.toop.framework.audio.VolumeControl;
 import org.toop.framework.audio.events.AudioEvents;
 import org.toop.framework.eventbus.EventFlow;
 import org.toop.framework.resource.ResourceManager;
+import org.toop.framework.resource.ResourceMeta;
 import org.toop.framework.resource.resources.SettingsAsset;
 import org.toop.framework.settings.Settings;

+import java.io.File;
 import java.util.Locale;

 public class AppSettings {
 	private static SettingsAsset settingsAsset;

 	public static void applySettings() {
-		settingsAsset = getSettingsAsset();
+		settingsAsset = getPath();
 		if (!settingsAsset.isLoaded()) {
 			settingsAsset.load();
 		}
@@ -43,9 +45,26 @@ public class AppSettings {
 				.postEvent();
 	}

-	public static SettingsAsset getSettingsAsset() {
+	public static SettingsAsset getPath() {
 		if (settingsAsset == null) {
-			settingsAsset = SettingsAsset.getPath();
+			String os = System.getProperty("os.name").toLowerCase();
+			String basePath;
+
+			if (os.contains("win")) {
+				basePath = System.getenv("APPDATA");
+				if (basePath == null) {
+					basePath = System.getProperty("user.home");
+				}
+			} else if (os.contains("mac")) {
+				basePath = System.getProperty("user.home") + "/Library/Application Support";
+			} else {
+				basePath = System.getProperty("user.home") + "/.config";
+			}
+
+			File settingsFile =
+				new File(basePath + File.separator + "ISY1" + File.separator + "settings.json");
+//            this.settingsAsset = new SettingsAsset(settingsFile);
+			ResourceManager.addAsset(new ResourceMeta<>("settings.json", new SettingsAsset(settingsFile)));
 		}
 		return ResourceManager.get("settings.json");
 	}
@@ -91,6 +110,5 @@ public class AppSettings {
        settingsAsset.setMusicVolume(15);
        settingsAsset.setTutorialFlag(true);
        settingsAsset.setLayoutSize("medium");
-        settingsAsset.setSwitchReversi(false);
    }
 }
--- a/app/src/main/resources/localization/localization_ar.properties
+++ b/app/src/main/resources/localization/localization_ar.properties
@@ -89,9 +89,6 @@ turnof=\u062F\u0648\u0631\u0647
 zwartepiet=\u0633\u0647\u0644: Zwarte Piet
 sinterklaas=\u0645\u062a\u0648\u0633\u0637: Sint R. Klaas
 santa=\u0635\u0639\u0628: Santa
-reversiswapped=\u0645\u0628\u062F\u0651\u064E\u0644
-reversinotswapped=\u063A\u064A\u0631\u0020\u0645\u0628\u062F\u0651\u064E\u0644
-reversiswap=\u0647\u0644\u0020\u062A\u0631\u064A\u062F\u0020\u062A\u0628\u062F\u064A\u0644\u0020\u0623\u0644\u0648\u0627\u0646\u0020\u0627\u0644\u0631\u064A\u0641\u064E\u0631\u0633\u064A\u061F\u0020\u0645\u062D\u0644\u064A\u0020\u0641\u0642\u0637\u002E


 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629
--- a/app/src/main/resources/localization/localization_de.properties
+++ b/app/src/main/resources/localization/localization_de.properties
@@ -91,9 +91,6 @@ turnof=ist dran
 zwartepiet=Leicht: Zwarte Piet
 sinterklaas=Mittel: Sint R. Klaas
 santa=Schwer: Santa
-reversiswapped=Getauscht
-reversinotswapped=Nicht getauscht
-reversiswap=M\u00F6chten Sie die Reversi-Farben tauschen? Nur lokal.

 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (Arabisch)
 chinese=\u4e2d\u6587 (Chinesisch)
--- a/app/src/main/resources/localization/localization_en.properties
+++ b/app/src/main/resources/localization/localization_en.properties
@@ -93,9 +93,6 @@ turnof='s turn
 zwartepiet=Easy: Zwarte Piet
 sinterklaas=Medium: Sint R. Klaas
 santa=Hard:Santa
-reversiswapped=Swapped
-reversinotswapped=Not Swapped
-reversiswap=Do you want to swap the Reversi colors? Local only.

 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (Arabic)
 chinese=\u4e2d\u6587 (Chinese)
--- a/app/src/main/resources/localization/localization_es.properties
+++ b/app/src/main/resources/localization/localization_es.properties
@@ -90,9 +90,6 @@ turnof=le toca
 zwartepiet=F\u00e1cil: Zwarte Piet
 sinterklaas=Medio: Sint R. Klaas
 santa=Dif\u00edcil: Santa
-reversiswapped=Cambiado
-reversinotswapped=No cambiado
-reversiswap=\u00BFDeseas intercambiar los colores de Reversi? Solo local.

 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (Ar\u00e1bigo)
 chinese=\u4e2d\u6587 (Chino)
--- a/app/src/main/resources/localization/localization_fr.properties
+++ b/app/src/main/resources/localization/localization_fr.properties
@@ -90,9 +90,6 @@ turnof=\u00E0 son tour
 zwartepiet=Facile: Zwarte Piet
 sinterklaas=Moyen : Sint R. Klaas
 santa=Difficile: Santa
-reversiswapped=\u00C9chang\u00E9
-reversinotswapped=Non \u00E9chang\u00E9
-reversiswap=Voulez-vous \u00E9changer les couleurs de Reversi ? Local uniquement.

 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (Arabe)
 chinese=\u4e2d\u6587 (Chinois)
--- a/app/src/main/resources/localization/localization_hi.properties
+++ b/app/src/main/resources/localization/localization_hi.properties
@@ -90,9 +90,6 @@ turnof=\u0915\u0940 \u092C\u093E\u0930\u0940
 zwartepiet=\u0905\u0938\u093e\u0928: Zwarte Piet
 sinterklaas=\u092e\u0927\u094d\u092f\u092e: Sint R. Klaas
 santa=\u0915\u0924\u093f\u0928: Santa
-reversiswapped=\u092C\u0926\u0932\u093E\u0020\u0939\u0941\u0906
-reversinotswapped=\u0928\u0939\u0940\u0902\u0020\u092C\u0926\u0932\u093E\u0020\u0939\u0941\u0906
-reversiswap=\u0915\u094D\u092F\u093E\u0020\u0906\u092A\u0020\u0930\u093F\u0935\u0930\u094D\u0938\u0940\u0020\u0915\u0947\u0020\u0930\u0902\u0917\u0020\u092C\u0926\u0932\u0928\u093E\u0020\u091A\u093E\u0939\u0924\u0947\u0020\u0939\u0948\u0902?\u0020\u0915\u0947\u0935\u0932\u0020\u0938\u094D\u0925\u093E\u0928\u0940\u092F\u002E

 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (\u0905\u0930\u092c\u0940)
 chinese=\u4e2d\u6587 (\u091a\u0940\u0928\u0940)
--- a/app/src/main/resources/localization/localization_it.properties
+++ b/app/src/main/resources/localization/localization_it.properties
@@ -89,9 +89,6 @@ turnof=\u00E8 il suo turno
 zwartepiet=Facile: Zwarte Piet
 sinterklaas=Medio: Sint R. Klaas
 santa=Difficile: Santa
-reversiswapped=Scambiato
-reversinotswapped=Non scambiato
-reversiswap=Vuoi scambiare i colori di Reversi? Solo locale.

 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (Arabo)
 chinese=\u4e2d\u6587 (Cinese)
--- a/app/src/main/resources/localization/localization_ja.properties
+++ b/app/src/main/resources/localization/localization_ja.properties
@@ -89,10 +89,6 @@ turnof=\u306E\u756A
 zwartepiet=\u7c21\u5358: Zwarte Piet
 sinterklaas=\u4e2d\u7d1a: Sint R. Klaas
 santa=\u96e3\u3057\u3044: Santa
-reversiswapped=\u5165\u308C\u66FF\u3048\u6E08\u307F
-reversinotswapped=\u672A\u5165\u308C\u66FF\u3048
-reversiswap=\u30EA\u30D0\u30FC\u30B7\u306E\u8272\u3092\u5165\u308C\u66FF\u3048\u307E\u3059\u304B?\u0020\u30ED\u30FC\u30AB\u30EB\u306E\u307F\u3067\u3059\u002E
-

 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (\u30a2\u30e9\u30d3\u30a2\u8a9e)
 chinese=\u4e2d\u6587 (\u4e2d\u6587)
--- a/app/src/main/resources/localization/localization_ko.properties
+++ b/app/src/main/resources/localization/localization_ko.properties
@@ -89,9 +89,6 @@ turnof=\uC758 \uCC28\uB840
 zwartepiet=\uc218\uc601: Zwarte Piet
 sinterklaas=\ubcf4\ud1b5: Sint R. Klaas
 santa=\uc5d0\uc18c: Santa
-reversiswapped=\uAD50\uCCB4\uB428
-reversinotswapped=\uAD50\uCCB4\uB418\uC9C0 \uC54A\uC74C
-reversiswap=\uB9AC\uBC84\uC2DC \uC0C9\uC0C1\uC744 \uBC14\uAFB8\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?\u0020\uB85C\uCEEC \uC804\uC6A9\u0020\uC785\uB2C8\uB2E4\u002E

 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (\u0639\u0631\u0628\u064a\u0629)
 chinese=\u4e2d\u6587 (\u4e2d\u6587)
--- a/app/src/main/resources/localization/localization_nl.properties
+++ b/app/src/main/resources/localization/localization_nl.properties
@@ -89,9 +89,6 @@ turnof=is aan de beurt
 zwartepiet=Makkelijk: Zwarte Piet
 sinterklaas=Gemiddeld: Sint R. Klaas
 santa=Moeilijk: Santa
-reversiswapped=Gewisseld
-reversinotswapped=Niet gewisseld
-reversiswap=Wil je de Reversi-kleuren wisselen? Alleen lokaal.

 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (Arabisch)
 chinese=\u4e2d\u6587 (Chinees)
--- a/app/src/main/resources/localization/localization_ru.properties
+++ b/app/src/main/resources/localization/localization_ru.properties
@@ -89,9 +89,6 @@ turnof=\u0445\u043E\u0434\u0438\u0442
 zwartepiet=\u041b\u0435\u0433\u043a\u043e: Zwarte Piet
 sinterklaas=\u0421\u0440\u0435\u0434\u043d\u0438\u0439: Sint R. Klaas
 santa=\u0421\u043b\u043e\u0436\u043d\u043e: Santa
-reversiswapped=\u041F\u043E\u043C\u0435\u043D\u044F\u043D\u043E
-reversinotswapped=\u041D\u0435 \u043F\u043E\u043C\u0435\u043D\u044F\u043D\u043E
-reversiswap=\u0425\u043E\u0442\u0438\u0442\u0435 \u043F\u043E\u043C\u0435\u043D\u044F\u0442\u044C \u0446\u0432\u0435\u0442\u0430 \u0420\u0435\u0432\u0435\u0440\u0441\u0438?\u0020\u0422\u043E\u043B\u044C\u043A\u043E \u043B\u043E\u043A\u0430\u043B\u044C\u043D\u043E\u002E

 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (\u0410\u0440\u0430\u0431\u0441\u043a\u0438\u0439)
 chinese=\u4e2d\u6587 (\u041a\u0438\u0442\u0430\u0439\u0441\u043a\u0438\u0439)
--- a/app/src/main/resources/localization/localization_zh.properties
+++ b/app/src/main/resources/localization/localization_zh.properties
@@ -89,9 +89,6 @@ turnof=\u7684\u56DE\u5408
 zwartepiet=\u7b80\u5355: Zwarte Piet
 sinterklaas=\u4e2d\u7b49: Sint R. Klaas
 santa=\u56f0\u96be: Santa
-reversiswapped=\u5DF2\u4EA4\u6362
-reversinotswapped=\u672A\u4EA4\u6362
-reversiswap=\u662F\u5426\u8981\u4EA4\u6362\u9ED1\u767D\u68CB\u7684\u989C\u8272\uFF1F\u4EC5\u9650\u672C\u5730\u002E

 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (\u963f\u62c9\u4f2f\u8bed)
 chinese=\u4e2d\u6587
--- a/framework/pom.xml
+++ b/framework/pom.xml
@@ -146,6 +146,12 @@
            <artifactId>error_prone_annotations</artifactId>
            <version>2.42.0</version>
        </dependency>
+        <dependency>
+            <groupId>org.deeplearning4j</groupId>
+            <artifactId>deeplearning4j-nn</artifactId>
+            <version>1.0.0-M2.1</version>
+            <scope>compile</scope>
+        </dependency>
    </dependencies>

 	<build>
--- a/framework/src/main/java/org/toop/framework/resource/resources/SettingsAsset.java
+++ b/framework/src/main/java/org/toop/framework/resource/resources/SettingsAsset.java
@@ -2,9 +2,6 @@ package org.toop.framework.resource.resources;

 import java.io.File;
 import java.util.Locale;
-
-import org.toop.framework.resource.ResourceManager;
-import org.toop.framework.resource.ResourceMeta;
 import org.toop.framework.settings.Settings;

 public class SettingsAsset extends JsonAsset<Settings> {
@@ -57,10 +54,6 @@ public class SettingsAsset extends JsonAsset<Settings> {
        return getContent().firstReversi;
    }

-    public boolean getSwitchReversi() {
-        return getContent().switchReversi;
-    }
-
    public void setVolume(int volume) {
        getContent().volume = volume;
        save();
@@ -115,51 +108,4 @@ public class SettingsAsset extends JsonAsset<Settings> {
        getContent().firstReversi = firstReversi;
        save();
    }
-
-    public void setSwitchReversi(boolean switchReversi) {
-        getContent().switchReversi = switchReversi;
-        save();
-    }
-
-    public void setContent(Settings settings) {
-        setVolume(settings.volume);
-        setFxVolume(settings.fxVolume);
-        setMusicVolume(settings.musicVolume);
-        setLocale(settings.locale);
-        setFullscreen(settings.fullScreen);
-        setTheme(settings.theme);
-        setLayoutSize(settings.layoutSize);
-        setTutorialFlag(settings.showTutorials);
-        setFirstTTT(settings.firstTTT);
-        setFirstConnect4(settings.firstConnect4);
-        setFirstReversi(settings.firstReversi);
-        setSwitchReversi(settings.switchReversi);
-    }
-
-    public static SettingsAsset getPath() {
-        SettingsAsset settingsAsset;
-        try {
-            settingsAsset = ResourceManager.get("settings.json");
-        } catch (Exception e) {
-        String os = System.getProperty("os.name").toLowerCase();
-        String basePath;
-
-        if (os.contains("win")) {
-            basePath = System.getenv("APPDATA");
-            if (basePath == null) {
-                basePath = System.getProperty("user.home");
-            }
-        } else if (os.contains("mac")) {
-            basePath = System.getProperty("user.home") + "/Library/Application Support";
-        } else {
-            basePath = System.getProperty("user.home") + "/.config";
-        }
-
-        File settingsFile =
-                new File(basePath + File.separator + "ISY1" + File.separator + "settings.json");
-        settingsAsset = new SettingsAsset(settingsFile);
-        ResourceManager.addAsset(new ResourceMeta<>("settings.json", settingsAsset));
-        }
-        return settingsAsset;
-    }
 }
--- a/framework/src/main/java/org/toop/framework/settings/Settings.java
+++ b/framework/src/main/java/org/toop/framework/settings/Settings.java
@@ -12,5 +12,5 @@ public class Settings {
    public Boolean firstReversi;
    public Boolean firstTTT;
    public Boolean firstConnect4;
-    public boolean switchReversi = false;
+
 }
--- a/framework/src/test/java/org/toop/framework/settings/SettingsAssetTest.java
+++ b/framework/src/test/java/org/toop/framework/settings/SettingsAssetTest.java
@@ -1,135 +0,0 @@
-package org.toop.framework.settings;
-
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.toop.framework.resource.resources.SettingsAsset;
-
-import java.util.Locale;
-
-import static org.junit.jupiter.api.Assertions.*;
-
-public class SettingsAssetTest {
-
-    private Settings copySettings;
-    private SettingsAsset settingsAsset;
-
-    @BeforeEach
-    void setup() {
-       this.settingsAsset = SettingsAsset.getPath();
-        Settings original = settingsAsset.getContent();
-        this.copySettings = new Settings();
-        this.copySettings.volume = original.volume;
-        this.copySettings.fxVolume = original.fxVolume;
-        this.copySettings.musicVolume = original.musicVolume;
-        this.copySettings.locale = original.locale;
-        this.copySettings.fullScreen = original.fullScreen;
-        this.copySettings.theme = original.theme;
-        this.copySettings.layoutSize = original.layoutSize;
-        this.copySettings.showTutorials = original.showTutorials;
-        this.copySettings.firstTTT = original.firstTTT;
-        this.copySettings.firstConnect4 = original.firstConnect4;
-        this.copySettings.firstReversi = original.firstReversi;
-    }
-
-
-    @AfterEach
-    void teardown() {
-        settingsAsset.setContent(copySettings);
-    }
-
-    @Test
-    void testVolume() {
-        settingsAsset.setVolume(55);
-        assertEquals(55, settingsAsset.getVolume());
-    }
-
-    @Test
-    void testFxVolume() {
-        settingsAsset.setFxVolume(33);
-        assertEquals(33, settingsAsset.getFxVolume());
-    }
-
-    @Test
-    void testMusicVolume() {
-        settingsAsset.setMusicVolume(77);
-        assertEquals(77, settingsAsset.getMusicVolume());
-    }
-
-    @Test
-    void testLocale() {
-        settingsAsset.setLocale("es-ES");
-        assertEquals(Locale.forLanguageTag("es-ES"), settingsAsset.getLocale());
-    }
-
-    @Test
-    void testFullscreen() {
-        settingsAsset.setFullscreen(true);
-        assertTrue(settingsAsset.getFullscreen());
-    }
-
-    @Test
-    void testTheme() {
-        settingsAsset.setTheme("dark");
-        assertEquals("dark", settingsAsset.getTheme());
-    }
-
-    @Test
-    void testLayoutsize() {
-        settingsAsset.setLayoutSize("large");
-        assertEquals("large", settingsAsset.getLayoutSize());
-    }
-
-    @Test
-    void testTutorialflag() {
-        settingsAsset.setTutorialFlag(false);
-        assertFalse(settingsAsset.getTutorialFlag());
-    }
-
-    @Test
-    void testTTT() {
-        settingsAsset.setFirstTTT(true);
-        assertTrue(settingsAsset.getFirstTTT());
-    }
-
-    @Test
-    void testConnect4() {
-        settingsAsset.setFirstConnect4(false);
-        assertFalse(settingsAsset.getFirstConnect4());
-    }
-
-    @Test
-    void testReversi() {
-        settingsAsset.setFirstReversi(true);
-        assertTrue(settingsAsset.getFirstReversi());
-    }
-
-    @Test
-    void testReplaceFields() {
-        Settings newSettings = new Settings();
-        newSettings.volume = 10;
-        newSettings.fxVolume = 20;
-        newSettings.musicVolume = 30;
-        newSettings.locale = "fr-FR";
-        newSettings.fullScreen = true;
-        newSettings.theme = "light";
-        newSettings.layoutSize = "medium";
-        newSettings.showTutorials = false;
-        newSettings.firstTTT = false;
-        newSettings.firstConnect4 = true;
-        newSettings.firstReversi = false;
-        settingsAsset.setContent(newSettings);
-        assertEquals(10, settingsAsset.getVolume());
-        assertEquals(20, settingsAsset.getFxVolume());
-        assertEquals(30, settingsAsset.getMusicVolume());
-        assertEquals(Locale.forLanguageTag("fr-FR"), settingsAsset.getLocale());
-        assertTrue(settingsAsset.getFullscreen());
-        assertEquals("light", settingsAsset.getTheme());
-        assertEquals("medium", settingsAsset.getLayoutSize());
-        assertFalse(settingsAsset.getTutorialFlag());
-        assertFalse(settingsAsset.getFirstTTT());
-        assertTrue(settingsAsset.getFirstConnect4());
-        assertFalse(settingsAsset.getFirstReversi());
-    }
-}
-
--- a/game/pom.xml
+++ b/game/pom.xml
@@ -105,6 +105,16 @@
            <version>0.1</version>
            <scope>compile</scope>
        </dependency>
+        <dependency>
+            <groupId>org.deeplearning4j</groupId>
+            <artifactId>deeplearning4j-core</artifactId>
+            <version>1.0.0-M2.1</version>
+        </dependency>
+        <dependency>
+            <groupId>org.nd4j</groupId>
+            <artifactId>nd4j-native-platform</artifactId>
+            <version>1.0.0-M2.1</version>
+        </dependency>

    </dependencies>

--- a/game/src/main/java/org/toop/game/games/reversi/BitboardReversi.java
+++ b/game/src/main/java/org/toop/game/games/reversi/BitboardReversi.java
@@ -167,4 +167,13 @@ public class BitboardReversi extends BitboardGame<BitboardReversi> {
 	private long shift(long bit, int shift, long mask) {
 		return shift > 0 ? (bit << shift) & mask : (bit >>> -shift) & mask;
 	}
+
+    public boolean isGameOver(){
+        BitboardReversi copy = this.deepCopy();
+        if (copy.getLegalMoves() == 0){
+            nextTurn();
+            return copy.getLegalMoves() == 0;
+        }
+        return false;
+    }
 }
--- a/game/src/main/java/org/toop/game/machinelearning/NeuralNetwork.java
+++ b/game/src/main/java/org/toop/game/machinelearning/NeuralNetwork.java
@@ -0,0 +1,228 @@
+package org.toop.game.machinelearning;
+
+import org.deeplearning4j.nn.conf.MultiLayerConfiguration;
+import org.deeplearning4j.nn.conf.NeuralNetConfiguration;
+import org.deeplearning4j.nn.conf.layers.DenseLayer;
+import org.deeplearning4j.nn.conf.layers.OutputLayer;
+import org.deeplearning4j.nn.multilayer.MultiLayerNetwork;
+import org.deeplearning4j.nn.weights.WeightInit;
+import org.deeplearning4j.util.ModelSerializer;
+import org.nd4j.linalg.activations.Activation;
+import org.nd4j.linalg.api.ndarray.INDArray;
+import org.nd4j.linalg.dataset.DataSet;
+import org.nd4j.linalg.factory.Nd4j;
+import org.nd4j.linalg.learning.config.Adam;
+import org.nd4j.linalg.lossfunctions.LossFunctions;
+import org.toop.framework.gameFramework.GameState;
+import org.toop.framework.gameFramework.model.game.PlayResult;
+import org.toop.framework.gameFramework.model.player.AbstractAI;
+import org.toop.framework.gameFramework.model.player.Player;
+import org.toop.game.games.reversi.BitboardReversi;
+import org.toop.game.players.ArtificialPlayer;
+import org.toop.game.players.ai.MiniMaxAI;
+import org.toop.game.players.ai.RandomAI;
+import org.toop.game.players.ai.ReversiAIML;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import static java.lang.Math.abs;
+import static java.lang.Math.random;
+
+public class NeuralNetwork {
+
+    private MultiLayerConfiguration conf;
+    private MultiLayerNetwork model;
+    private AbstractAI<BitboardReversi> opponentAI;
+    private AbstractAI<BitboardReversi> opponentMM = new MiniMaxAI<>(6);
+    private AbstractAI<BitboardReversi> opponentRand = new RandomAI<>();
+    private AbstractAI<BitboardReversi> opponentAIML = new ReversiAIML<>();
+    private Player[] playerSet = new Player[4];
+
+
+    public NeuralNetwork() {}
+
+    public void init(){
+        initPlayers();
+
+        conf = new NeuralNetConfiguration.Builder()
+                .updater(new Adam(0.001))
+                .weightInit(WeightInit.XAVIER) //todo understand
+                .list()
+                .layer(new DenseLayer.Builder()
+                        .nIn(64)
+                        .nOut(128)
+                        .activation(Activation.RELU)
+                        .build())
+                .layer(new OutputLayer.Builder(LossFunctions.LossFunction.MCXENT)
+                        .nIn(128)
+                        .nOut(64)
+                        .activation(Activation.SOFTMAX)
+                        .build())
+                .build();
+        model = new MultiLayerNetwork(conf);
+        IO.println(model.params());
+        loadModel();
+        IO.println(model.params());
+        model.init();
+        IO.println(model.summary());
+
+        model.setLearningRate(0.0003);
+        trainingLoop();
+        saveModel();
+    }
+
+    public void initPlayers(){
+        playerSet[0] = new ArtificialPlayer<>(new MiniMaxAI<BitboardReversi>(6),"MiniMaxAI");
+        playerSet[1] = new ArtificialPlayer<>(new RandomAI<BitboardReversi>(),"RandomAI");
+        playerSet[2] = new ArtificialPlayer<>(new ReversiAIML<BitboardReversi>(),"MachineLearningAI");
+    }
+
+    public void saveModel(){
+        File modelFile = new File("reversi-model.zip");
+        try {
+            ModelSerializer.writeModel(model, modelFile, true);
+        }catch (Exception e){
+            e.printStackTrace();
+        }
+    }
+
+    public void loadModel(){
+        File modelFile = new File("reversi-model.zip");
+        try {
+            model = ModelSerializer.restoreMultiLayerNetwork(modelFile);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void trainingLoop(){
+        int totalGames = 5000;
+        double epsilon = 0.05;
+
+
+
+        long start =  System.nanoTime();
+
+        for (int game = 0; game<totalGames; game++){
+            char modelPlayer = random()<0.5?'B':'W';
+            BitboardReversi reversi = new BitboardReversi(new Player[2]);
+            opponentAI = getOpponentAI();
+            List<StateAction> gameHistory = new ArrayList<>();
+            PlayResult state = new PlayResult(GameState.NORMAL,reversi.getCurrentTurn());
+
+            double reward = 0;
+
+            while (state.state() != GameState.DRAW && state.state() != GameState.WIN){
+                int curr = reversi.getCurrentTurn();
+                long move;
+                if (curr == modelPlayer) {
+                    long[] input = reversi.getBoard();
+                    if (Math.random() < epsilon) {
+                        long moves = reversi.getLegalMoves();
+                        move = (long) (Math.random() * Long.bitCount(moves) - .5f);
+                    } else {
+                        INDArray boardInput = Nd4j.create(new long[][]{input});
+                        INDArray prediction = model.output(boardInput);
+
+                        int location = pickLegalMove(prediction, reversi);
+                        gameHistory.add(new StateAction(input, location));
+                        move = location;
+                    }
+                }else{
+                    move = opponentAI.getMove(reversi);
+                }
+                state = reversi.play(move);
+            }
+
+            //IO.println(model.params());
+            BitboardReversi.Score score = reversi.getScore();
+            int scoreDif = abs(score.black() - score.white());
+            if (score.black() > score.white()){
+                reward = 1 + ((scoreDif / 64.0) * 0.5);
+            }else if (score.black() < score.white()){
+                reward = -1 - ((scoreDif / 64.0) * 0.5);
+            }else{
+                reward = 0;
+            }
+
+            if (modelPlayer == 'W'){
+                reward = -reward;
+            }
+
+
+            for (StateAction step : gameHistory){
+                trainFromHistory(step, reward);
+            }
+
+            //IO.println("Wr: " + (double)p1wins/(game+1) + " draws: " + draws);
+            if(game % 100 == 0){
+                IO.println("Completed game " + game + " | Reward: " + reward);
+                //IO.println(Arrays.toString(reversi.getBoardDouble()));
+            }
+        }
+        long end  =  System.nanoTime();
+        IO.println((end-start));
+    }
+
+
+    private int pickLegalMove(INDArray prediction, BitboardReversi reversi) {
+        double[] logits = prediction.toDoubleVector();
+        long legalMoves = reversi.getLegalMoves();
+
+        if (legalMoves == 0L) {
+            return -1;
+        }
+
+        if (Math.random() < 0.01) {
+            int randomIndex = (int) (Math.random() * Long.bitCount(legalMoves));
+            long moves = legalMoves;
+            for (int i = 0; i < randomIndex; i++) {
+                moves &= moves - 1;
+            }
+            return Long.numberOfTrailingZeros(moves);
+        }
+
+        int bestMove = -1;
+        double bestVal = Double.NEGATIVE_INFINITY;
+
+        long moves = legalMoves;
+        while (moves != 0L) {
+            int move = Long.numberOfTrailingZeros(moves);
+            double value = logits[move];
+
+            if (value > bestVal) {
+                bestVal = value;
+                bestMove = move;
+            }
+
+            moves &= moves - 1;
+        }
+
+        return bestMove;
+    }
+
+    private AbstractAI<BitboardReversi> getOpponentAI(){
+        return switch ((int) (Math.random() * 4)) {
+            case 0 -> opponentRand;
+            case 1 -> opponentMM;
+            case 2 -> opponentAIML;
+            default -> opponentRand;
+        };
+    }
+
+    private void trainFromHistory(StateAction step, double reward){
+        double[] output = new double[64];
+        output[step.action] = reward;
+
+        DataSet ds = new DataSet(
+                Nd4j.create(new long[][] { step.state }),
+                Nd4j.create(new double[][] { output })
+        );
+
+        model.fit(ds);
+
+    }
+}
--- a/game/src/main/java/org/toop/game/machinelearning/StateAction.java
+++ b/game/src/main/java/org/toop/game/machinelearning/StateAction.java
@@ -0,0 +1,10 @@
+package org.toop.game.machinelearning;
+
+public class StateAction {
+    long[] state;
+    int action;
+    public StateAction(long[] state, int action) {
+        this.state = state;
+        this.action = action;
+    }
+}
--- a/game/src/main/java/org/toop/game/players/ai/ReversiAIML.java
+++ b/game/src/main/java/org/toop/game/players/ai/ReversiAIML.java
@@ -0,0 +1,80 @@
+package org.toop.game.players.ai;
+
+import org.deeplearning4j.nn.multilayer.MultiLayerNetwork;
+import org.deeplearning4j.util.ModelSerializer;
+import org.nd4j.linalg.api.ndarray.INDArray;
+import org.nd4j.linalg.factory.Nd4j;
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+import org.toop.framework.gameFramework.model.player.AI;
+import org.toop.framework.gameFramework.model.player.AbstractAI;
+import org.toop.game.games.reversi.BitboardReversi;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import static java.lang.Math.random;
+
+public class ReversiAIML<T extends TurnBasedGame<T>> extends AbstractAI<T> {
+
+    MultiLayerNetwork model;
+
+    public ReversiAIML() {
+        InputStream is = getClass().getResourceAsStream("/reversi-model.zip");
+        try {
+            assert is != null;
+            model = ModelSerializer.restoreMultiLayerNetwork(is);
+        } catch (IOException e) {}
+    }
+
+    private int pickLegalMove(INDArray prediction, BitboardReversi reversi) {
+        double[] logits = prediction.toDoubleVector();
+        long legalMoves = reversi.getLegalMoves();
+
+        if (legalMoves == 0L) {
+            return -1;
+        }
+
+        if (Math.random() < 0.01) {
+            int randomIndex = (int) (Math.random() * Long.bitCount(legalMoves));
+            long moves = legalMoves;
+            for (int i = 0; i < randomIndex; i++) {
+                moves &= moves - 1;
+            }
+            return Long.numberOfTrailingZeros(moves);
+        }
+
+        int bestMove = -1;
+        double bestVal = Double.NEGATIVE_INFINITY;
+
+        long moves = legalMoves;
+        while (moves != 0L) {
+            int move = Long.numberOfTrailingZeros(moves);
+            double value = logits[move];
+
+            if (value > bestVal) {
+                bestVal = value;
+                bestMove = move;
+            }
+
+            moves &= moves - 1;
+        }
+
+        return bestMove;
+    }
+
+    @Override
+    public long getMove(T game) {
+        long[] input = game.getBoard();
+
+        INDArray boardInput = Nd4j.create(new long[][] { input });
+        INDArray prediction = model.output(boardInput);
+
+        int move = pickLegalMove(prediction,(BitboardReversi) game);
+        return move;
+    }
+
+    @Override
+    public ReversiAIML<T> deepCopy() {
+        return new ReversiAIML();
+    }
+}
--- a/game/src/test/java/org/toop/game/tictactoe/ReversiTest.java
+++ b/game/src/test/java/org/toop/game/tictactoe/ReversiTest.java
@@ -0,0 +1,272 @@
+/*//todo fix this mess
+
+
+
+package org.toop.game.tictactoe;
+
+import java.util.*;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.toop.framework.gameFramework.model.player.AbstractAI;
+import org.toop.framework.gameFramework.model.player.Player;
+import org.toop.game.AI;
+import org.toop.game.enumerators.GameState;
+import org.toop.game.games.reversi.ReversiAIR;
+import org.toop.game.games.reversi.ReversiR;
+import org.toop.game.records.Move;
+import org.toop.game.reversi.Reversi;
+import org.toop.game.reversi.ReversiAI;
+import org.toop.game.players.ai.ReversiAIML;
+import org.toop.game.games.reversi.ReversiAISimple;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ReversiTest {
+    private ReversiR game;
+    private ReversiAIR ai;
+    private ReversiAIML aiml;
+    private ReversiAISimple aiSimple;
+    private AbstractAI<ReversiR> player1;
+    private AbstractAI<ReversiR> player2;
+    private Player[] players = new Player[2];
+
+    @BeforeEach
+    void setup() {
+        game = new ReversiR(players);
+        ai = new ReversiAIR();
+        aiml = new ReversiAIML();
+        aiSimple = new ReversiAISimple();
+
+    }
+
+
+    @Test
+    void testCorrectStartPiecesPlaced() {
+        assertNotNull(game);
+        assertEquals('W', game.getBoard()[27]);
+        assertEquals('B', game.getBoard()[28]);
+        assertEquals('B', game.getBoard()[35]);
+        assertEquals('W', game.getBoard()[36]);
+    }
+
+    @Test
+    void testGetLegalMovesAtStart() {
+        Move[] moves = game.getLegalMoves();
+        List<Move> expectedMoves = List.of(
+                new Move(19, 'B'),
+                new Move(26, 'B'),
+                new Move(37, 'B'),
+                new Move(44, 'B')
+        );
+        assertNotNull(moves);
+        assertTrue(moves.length > 0);
+        assertMovesMatchIgnoreOrder(expectedMoves, Arrays.asList(moves));
+    }
+
+    private void assertMovesMatchIgnoreOrder(List<Move> expected, List<Move> actual) {
+        assertEquals(expected.size(), actual.size());
+        for (int i = 0; i < expected.size(); i++) {
+            assertTrue(actual.contains(expected.get(i)));
+            assertTrue(expected.contains(actual.get(i)));
+        }
+    }
+
+    @Test
+    void testMakeValidMoveFlipsPieces() {
+        game.play(new Move(19, 'B'));
+        assertEquals('B', game.getBoard()[19]);
+        assertEquals('B', game.getBoard()[27], "Piece should have flipped to B");
+    }
+
+    @Test
+    void testMakeInvalidMoveDoesNothing() {
+        char[] before = game.getBoard().clone();
+        game.play(new Move(0, 'B'));
+        assertArrayEquals(before, game.getBoard(), "Board should not change on invalid move");
+    }
+
+    @Test
+    void testTurnSwitchesAfterValidMove() {
+        char current = game.getCurrentPlayer();
+        game.play(game.getLegalMoves()[0]);
+        assertNotEquals(current, game.getCurrentPlayer(), "Player turn should switch after a valid move");
+    }
+
+    @Test
+    void testCountScoreCorrectlyAtStart() {
+        long start = System.nanoTime();
+        Reversi.Score score = game.getScore();
+        assertEquals(2, score.player1Score()); // Black
+        assertEquals(2, score.player2Score()); // White
+        long end = System.nanoTime();
+        IO.println((end - start));
+    }
+
+    @Test
+    void zLegalMovesInCertainPosition() {
+        game.play(new Move(19, 'B'));
+        game.play(new Move(20, 'W'));
+        Move[] moves = game.getLegalMoves();
+        List<Move> expectedMoves = List.of(
+                new Move(13, 'B'),
+                new Move(21, 'B'),
+                new Move(29, 'B'),
+                new Move(37, 'B'),
+                new Move(45, 'B'));
+        assertNotNull(moves);
+        assertTrue(moves.length > 0);
+        IO.println(Arrays.toString(moves));
+        assertMovesMatchIgnoreOrder(expectedMoves, Arrays.asList(moves));
+    }
+
+    @Test
+    void testCountScoreCorrectlyAtEnd() {
+        for (int i = 0; i < 1; i++) {
+            game = new Reversi();
+            Move[] legalMoves = game.getLegalMoves();
+            while (legalMoves.length > 0) {
+                game.play(legalMoves[(int) (Math.random() * legalMoves.length)]);
+                legalMoves = game.getLegalMoves();
+            }
+            Reversi.Score score = game.getScore();
+            IO.println(score.player1Score());
+            IO.println(score.player2Score());
+
+            for (int r = 0; r < game.getRowSize(); r++) {
+                char[] row = Arrays.copyOfRange(game.getBoard(), r * game.getColumnSize(), (r + 1) * game.getColumnSize());
+                IO.println(Arrays.toString(row));
+            }
+        }
+    }
+
+    @Test
+    void testPlayerMustSkipTurnIfNoValidMoves() {
+        game.play(new Move(19, 'B'));
+        game.play(new Move(34, 'W'));
+        game.play(new Move(45, 'B'));
+        game.play(new Move(11, 'W'));
+        game.play(new Move(42, 'B'));
+        game.play(new Move(54, 'W'));
+        game.play(new Move(37, 'B'));
+        game.play(new Move(46, 'W'));
+        game.play(new Move(63, 'B'));
+        game.play(new Move(62, 'W'));
+        game.play(new Move(29, 'B'));
+        game.play(new Move(50, 'W'));
+        game.play(new Move(55, 'B'));
+        game.play(new Move(30, 'W'));
+        game.play(new Move(53, 'B'));
+        game.play(new Move(38, 'W'));
+        game.play(new Move(61, 'B'));
+        game.play(new Move(52, 'W'));
+        game.play(new Move(51, 'B'));
+        game.play(new Move(60, 'W'));
+        game.play(new Move(59, 'B'));
+        assertEquals('B', game.getCurrentPlayer());
+        game.play(ai.findBestMove(game, 5));
+        game.play(ai.findBestMove(game, 5));
+    }
+
+    @Test
+    void testGameShouldEndIfNoValidMoves() {
+        //European Grand Prix Ghent 2017: Replay Hassan - Verstuyft J. (3-17)
+        game.play(new Move(19, 'B'));
+        game.play(new Move(20, 'W'));
+        game.play(new Move(29, 'B'));
+        game.play(new Move(22, 'W'));
+        game.play(new Move(21, 'B'));
+        game.play(new Move(34, 'W'));
+        game.play(new Move(23, 'B'));
+        game.play(new Move(13, 'W'));
+        game.play(new Move(26, 'B'));
+        game.play(new Move(18, 'W'));
+        game.play(new Move(12, 'B'));
+        game.play(new Move(4, 'W'));
+        game.play(new Move(17, 'B'));
+        game.play(new Move(31, 'W'));
+        GameState stateTurn15 = game.play(new Move(39, 'B'));
+        assertEquals(GameState.NORMAL, stateTurn15);
+        GameState stateTurn16 = game.play(new Move(16, 'W'));
+        assertEquals(GameState.WIN, stateTurn16);
+        GameState stateTurn17 = game.play(new Move(5, 'B'));
+        assertNull(stateTurn17);
+        Reversi.Score score = game.getScore();
+        assertEquals(3, score.player1Score());
+        assertEquals(17, score.player2Score());
+    }
+
+    @Test
+    void testAISelectsLegalMove() {
+        Move move = ai.findBestMove(game, 4);
+        assertNotNull(move);
+        assertTrue(containsMove(game.getLegalMoves(), move), "AI should always choose a legal move");
+    }
+
+    private boolean containsMove(Move[] moves, Move move) {
+        for (Move m : moves) {
+            if (m.equals(move)) return true;
+        }
+        return false;
+    }
+
+    @Test
+    void testAis() {
+        player1 = aiml;
+        player2 = ai;
+        testAIvsAIML();
+        player2 = aiSimple;
+        testAIvsAIML();
+        player1 = ai;
+        testAIvsAIML();
+        player2 = aiml;
+        testAIvsAIML();
+        player1 = aiml;
+        testAIvsAIML();
+        player1 = aiSimple;
+        testAIvsAIML();
+    }
+
+    @Test
+    void testAIvsAIML() {
+        if(player1 == null || player2 == null) {
+            player1 = aiml;
+            player2 = ai;
+        }
+        int totalGames = 2000;
+        IO.println("Testing... " + player1.getClass().getSimpleName() + " vs " + player2.getClass().getSimpleName() + " for " + totalGames + " games");
+        int p1wins = 0;
+        int p2wins = 0;
+        int draws = 0;
+        List<Integer> moves = new ArrayList<>();
+        for (int i = 0; i < totalGames; i++) {
+            game = new ReversiR();
+            while (!game.isGameOver()) {
+                char curr = game.getCurrentPlayer();
+                Move move;
+                if (curr == 'B') {
+                    move = player1.findBestMove(game, 5);
+                } else {
+                    move = player2.findBestMove(game, 5);
+                }
+                if (i%500 == 0) moves.add(move.position());
+                game.play(move);
+            }
+            if (i%500 == 0) {
+                IO.println(moves);
+                moves.clear();
+            }
+            int winner = game.getWinner();
+            if (winner == 1) {
+                p1wins++;
+            } else if (winner == 2) {
+                p2wins++;
+            } else {
+                draws++;
+            }
+        }
+        IO.println("p1 winrate: " + p1wins + "/" + totalGames + " = " + (double) p1wins / totalGames + "\np2wins: " + p2wins + " draws: " + draws);
+    }
+}
+
+ */
--- a/game/src/test/java/org/toop/game/tictactoe/TestReversi.java
+++ b/game/src/test/java/org/toop/game/tictactoe/TestReversi.java
@@ -0,0 +1,78 @@
+package org.toop.game.tictactoe;
+
+import java.util.*;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.toop.framework.gameFramework.model.player.Player;
+import org.toop.game.games.reversi.BitboardReversi;
+import org.toop.game.players.ArtificialPlayer;
+import org.toop.game.players.ai.MiniMaxAI;
+import org.toop.game.players.ai.RandomAI;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class TestReversi {
+    private BitboardReversi game;
+    private Player[] players;
+
+    @BeforeEach
+    void setup(){
+        players = new Player[2];
+        players[0] = new ArtificialPlayer<BitboardReversi>(new RandomAI<BitboardReversi>(),"randomAI");
+        players[1] = new ArtificialPlayer<BitboardReversi>(new MiniMaxAI<BitboardReversi>(10),"miniMaxAI");
+        game = new BitboardReversi(players);
+
+    }
+
+    @Test
+    void testCorrectStartPiecesPlaced() {
+        assertNotNull(game);
+        long[] board = game.getBoard();
+        IO.println(Long.toBinaryString(board[0]));
+        IO.println(Long.toBinaryString(board[1]));
+        long black = board[0];
+        long white = board[1];
+        assertEquals(1L, ((white >>> 27) & 1L)); //checks if the 27-shifted long has a 1 bit
+        assertEquals(1L, ((black >>> 28) & 1L));
+        assertEquals(1L, ((black >>> 35) & 1L));
+        assertEquals(1L, ((white >>> 36) & 1L));
+    }
+
+    @Test
+    void testPlayGames(){
+        int totalGames = 1;
+        long start = System.nanoTime();
+        long midtime = System.nanoTime();
+        int p1wins = 0;
+        int p2wins = 0;
+        int draws = 0;
+
+        for (int i = 0; i < totalGames; i++){
+            game = new BitboardReversi(players);
+            while(!game.isGameOver()){
+                midtime = System.nanoTime();
+                int currentTurn = game.getCurrentTurn();
+                long move = players[currentTurn].getMove(game.deepCopy());
+                game.play(move);
+                IO.println(System.nanoTime() - midtime);
+            }
+            switch (game.getWinner()){
+                case 0:
+                    p1wins++;
+                    break;
+                case 1:
+                    p2wins++;
+                    break;
+                case -1:
+                    draws++;
+                    break;
+
+            }
+        }
+        System.out.println(System.nanoTime() - start);
+        IO.println(p1wins + " " + p2wins + " " + draws);
+        assertEquals(totalGames, p1wins + p2wins + draws);
+        IO.println("p1 wr: " + p1wins + "/" + totalGames + " = " + (double) p1wins / totalGames);
+    }
+}
Author	SHA1	Message	Date
Ticho Hidding	5501c3893f	bitboard merge	2025-12-15 10:28:33 +01:00
Ticho Hidding	ffdec38e5d	Merge branch 'Development' into ReversiML # Conflicts: # game/src/main/java/org/toop/game/games/reversi/ReversiR.java	2025-12-13 15:04:40 +01:00
Ticho Hidding	03dc6130e2	merge commit	2025-12-08 14:55:32 +01:00
Ticho Hidding	ca7f9e8ecf	Merge branch 'Development' into ReversiML # Conflicts: # app/src/main/java/org/toop/Main.java # app/src/main/java/org/toop/app/game/ReversiGame.java # game/pom.xml # game/src/main/java/org/toop/game/reversi/Reversi.java # game/src/main/java/org/toop/game/reversi/ReversiAI.java # game/src/test/java/org/toop/game/tictactoe/ReversiTest.java	2025-12-08 11:58:32 +01:00
Ticho Hidding	f6d90ed439	added some useful testing methods. made training slightly better.	2025-12-08 11:36:31 +01:00
Ticho Hidding	7e913ff50f	Machine learning for reversi. performance improvements for reversi.getlegalmoves	2025-12-02 10:59:33 +01:00