Added a method getWinner() to game interface.Controller now tells gameThreads how to deal with drawing UI and sending a move to server.

app/src/main/java/org/toop/app/canvas/BitGameCanvas.java

@@ -41,9 +41,9 @@ public abstract class BitGameCanvas<T extends BitboardGame<T>> implements GameCa
 
 	protected final Cell[] cells;
 
-    private Consumer<Integer> onCellCLicked;
+    private Consumer<Long> onCellCLicked;
 
-    public void setOnCellClicked(Consumer<Integer> onClick) {
+    public void setOnCellClicked(Consumer<Long> onClick) {
         this.onCellCLicked = onClick;
     }
 
@@ -91,7 +91,7 @@ public abstract class BitGameCanvas<T extends BitboardGame<T>> implements GameCa
 
 			if (cell.isInside(event.getX(), event.getY())) {
 				event.consume();
-				this.onCellCLicked.accept(column + row * rowSize);
+				this.onCellCLicked.accept(1L << (column + row * rowSize));
 			}
 		});
 

app/src/main/java/org/toop/app/gameControllers/GenericGameController.java

@@ -1,5 +1,6 @@
 package org.toop.app.gameControllers;
 
+import javafx.application.Platform;
 import javafx.geometry.Pos;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
@@ -7,6 +8,7 @@ import org.toop.app.canvas.GameCanvas;
 import org.toop.app.widget.WidgetContainer;
 import org.toop.app.widget.view.GameView;
 import org.toop.framework.eventbus.EventFlow;
+import org.toop.framework.eventbus.GlobalEventBus;
 import org.toop.framework.gameFramework.controller.GameController;
 import org.toop.framework.gameFramework.model.game.SupportsOnlinePlay;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
@@ -23,8 +25,6 @@ import java.util.function.Consumer;
 public class GenericGameController<T extends TurnBasedGame<T>> implements GameController {
     protected final EventFlow eventFlow = new EventFlow();
 
-    protected final List<Consumer<?>> listeners = new ArrayList<>();
-
     // Logger for logging
     protected final Logger logger = LogManager.getLogger(this.getClass());
 
@@ -44,13 +44,22 @@ public class GenericGameController<T extends TurnBasedGame<T>> implements GameCo
         this.canvas = canvas;
         this.game = game;
         this.gameThreadBehaviour = gameThreadBehaviour;
-        this.gameThreadBehaviour.setController(this);
 
+        // Tell thread how to send moves
+        this.gameThreadBehaviour.setOnSendMove((id, m) -> GlobalEventBus.postAsync(new NetworkEvents.SendMove(id, (short)translateMove(m))));
 
+        // Tell thread how to update UI
+        this.gameThreadBehaviour.setOnUpdateUI(() -> Platform.runLater(() -> canvas.redraw(game.deepCopy())));
+
+        // Change scene to game view
         gameView = new GameView(null, null, null, gameType);
         gameView.add(Pos.CENTER, canvas.getCanvas());
         WidgetContainer.getCurrentView().transitionNext(gameView, true);
-        addListeners();
+
+        // Listen to updates
+        eventFlow
+                .listen(GUIEvents.GameEnded.class, this::onGameFinish, false)
+                .listen(GUIEvents.PlayerAttemptedMove.class, event -> {if (getCurrentPlayer() instanceof LocalPlayer<T> lp){lp.setMove(event.move());}}, false);
     }
 
     public void start(){
@@ -73,23 +82,16 @@ public class GenericGameController<T extends TurnBasedGame<T>> implements GameCo
         return game.getCurrentTurn();
     }
 
-    private void addListeners(){
-        eventFlow
-                .listen(GUIEvents.RefreshGameCanvas.class, this::onUpdateGameUI, false)
-                .listen(GUIEvents.GameEnded.class, this::onGameFinish, false)
-                .listen(GUIEvents.PlayerAttemptedMove.class, event -> {if (getCurrentPlayer() instanceof LocalPlayer<T> lp){lp.setMove(translateMove(event.move()));}}, false);
-    }
-
     protected long translateMove(int move){
         return 1L << move;
     }
 
-    private void removeListeners(){
+    protected int translateMove(long move){
-        eventFlow.unsubscribeAll();
+        return Long.numberOfTrailingZeros(move);
     }
 
-    private void onUpdateGameUI(GUIEvents.RefreshGameCanvas event){
+    private void removeListeners(){
-        this.updateUI();
+        eventFlow.unsubscribeAll();
     }
 
     private void onGameFinish(GUIEvents.GameEnded event){

app/src/main/java/org/toop/app/gameControllers/TicTacToeBitController.java

@@ -3,10 +3,8 @@ package org.toop.app.gameControllers;
 import org.toop.app.canvas.TicTacToeBitCanvas;
 import org.toop.framework.gameFramework.model.game.threadBehaviour.ThreadBehaviour;
 import org.toop.framework.gameFramework.model.player.Player;
-import org.toop.game.gameThreads.LocalFixedRateThreadBehaviour;
 import org.toop.game.gameThreads.LocalThreadBehaviour;
 import org.toop.game.gameThreads.OnlineThreadBehaviour;
-import org.toop.game.gameThreads.OnlineWithSleepThreadBehaviour;
 import org.toop.game.games.tictactoe.BitboardTicTacToe;
 import org.toop.game.players.OnlinePlayer;
 

framework/src/main/java/org/toop/framework/gameFramework/LongPairConsumer.java

@@ -0,0 +1,6 @@
+package org.toop.framework.gameFramework;
+
+@FunctionalInterface
+public interface LongPairConsumer {
+    void accept(long a, long b);
+}

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

@@ -2,4 +2,6 @@ package org.toop.framework.gameFramework.model.game;
 
 public interface TurnBasedGame<T extends TurnBasedGame<T>> extends Playable, DeepCopyable<T>, PlayerProvider<T>, BoardProvider {
     int getCurrentTurn();
+    int getPlayerCount();
+    int getWinner();
 }

framework/src/main/java/org/toop/framework/gameFramework/model/game/threadBehaviour/AbstractThreadBehaviour.java

@@ -2,11 +2,13 @@ package org.toop.framework.gameFramework.model.game.threadBehaviour;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.toop.framework.gameFramework.LongPairConsumer;
 import org.toop.framework.gameFramework.controller.GameController;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 import org.toop.framework.gameFramework.model.player.Player;
 
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Consumer;
 
 /**
  * Base class for thread-based game behaviours.
@@ -16,7 +18,8 @@ import java.util.concurrent.atomic.AtomicBoolean;
  * Subclasses implement the actual game-loop logic.
  */
 public abstract class AbstractThreadBehaviour<T extends TurnBasedGame<T>> implements ThreadBehaviour {
-    protected GameController controller;
+    private LongPairConsumer onSendMove;
+    private Runnable onUpdateUI;
     /** Indicates whether the game loop or event processing is active. */
     protected final AtomicBoolean isRunning = new AtomicBoolean();
 
@@ -35,8 +38,25 @@ public abstract class AbstractThreadBehaviour<T extends TurnBasedGame<T>> implem
         this.game = game;
     }
 
+    protected void updateUI(){
+        if (onUpdateUI != null) {
+            onUpdateUI.run();
+        }
+    }
+
+    protected void sendMove(long clientId, long move){
+        if (onSendMove != null) {
+            onSendMove.accept(clientId, move);
+        }
+    }
+
     @Override
-    public void setController(GameController controller) {
+    public void setOnUpdateUI(Runnable onUpdateUI) {
-        this.controller = controller;
+        this.onUpdateUI = onUpdateUI;
+    }
+
+    @Override
+    public void setOnSendMove(LongPairConsumer onSendMove) {
+        this.onSendMove = onSendMove;
     }
 }

framework/src/main/java/org/toop/framework/gameFramework/model/game/threadBehaviour/ThreadBehaviour.java

@@ -1,15 +1,20 @@
 package org.toop.framework.gameFramework.model.game.threadBehaviour;
 
+import org.toop.framework.gameFramework.LongPairConsumer;
 import org.toop.framework.gameFramework.controller.GameController;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 import org.toop.framework.gameFramework.model.player.AbstractPlayer;
 import org.toop.framework.gameFramework.model.player.Player;
 
+import java.util.function.Consumer;
+
 /**
  * Strategy interface for controlling game thread behavior.
  * <p>
  * Defines how a game's execution is started, stopped, and which player is active.
  */
 public interface ThreadBehaviour extends Controllable {
-    void setController(GameController controller);
+    void setOnUpdateUI(Runnable onUpdateUI);
+    void setOnSendMove(LongPairConsumer onSendMove);
 }
+

framework/src/main/java/org/toop/framework/gameFramework/view/GUIEvents.java

@@ -10,10 +10,6 @@ import org.toop.framework.eventbus.events.GenericEvent;
  * player actions, and game completion.
  */
 public class GUIEvents extends EventsBase {
-
-    /** Event to refresh or redraw the game canvas. */
-    public record RefreshGameCanvas() implements GenericEvent {}
-
     /**
      * Event indicating the game has ended.
      *
@@ -23,8 +19,8 @@ public class GUIEvents extends EventsBase {
     public record GameEnded(boolean winOrTie, int winner) implements GenericEvent {}
 
     /** Event indicating a player has attempted a move. */
-    public record PlayerAttemptedMove(int move) implements GenericEvent {}
+    public record PlayerAttemptedMove(long move) implements GenericEvent {}
 
     /** Event indicating a player is hovering over a move (for UI feedback). */
-    public record PlayerMoveHovered(int move) implements GenericEvent {}
+    public record PlayerMoveHovered(long move) implements GenericEvent {}
 }

game/src/main/java/org/toop/game/gameThreads/LocalFixedRateThreadBehaviour.java

@@ -8,6 +8,8 @@ import org.toop.framework.gameFramework.view.GUIEvents;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 import org.toop.framework.gameFramework.model.player.Player;
 
+import java.util.function.Consumer;
+
 /**
  * Handles local turn-based game logic at a fixed update rate.
  * <p>
@@ -22,7 +24,7 @@ public class LocalFixedRateThreadBehaviour<T extends TurnBasedGame<T>> extends A
      *
      * @param game    the game instance
      */
-    public LocalFixedRateThreadBehaviour(T game) {
+    public LocalFixedRateThreadBehaviour(T game, Consumer<Long> onSendMove) {
         super(game);
     }
 
@@ -60,7 +62,8 @@ public class LocalFixedRateThreadBehaviour<T extends TurnBasedGame<T>> extends A
                 Player<T> currentPlayer = game.getPlayer(game.getCurrentTurn());
                 long move = currentPlayer.getMove(game.deepCopy());
                 PlayResult result = game.play(move);
-                new EventFlow().addPostEvent(GUIEvents.RefreshGameCanvas.class).postEvent();
+
+                updateUI();
 
                 GameState state = result.state();
                 switch (state) {

game/src/main/java/org/toop/game/gameThreads/LocalThreadBehaviour.java

@@ -8,6 +8,8 @@ import org.toop.framework.gameFramework.GameState;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 import org.toop.framework.gameFramework.model.player.Player;
 
+import java.util.function.Consumer;
+
 /**
  * Handles local turn-based game logic in its own thread.
  * <p>
@@ -49,7 +51,8 @@ public class LocalThreadBehaviour<T extends TurnBasedGame<T>> extends AbstractTh
             Player<T> currentPlayer = game.getPlayer(game.getCurrentTurn());
             long move = currentPlayer.getMove(game.deepCopy());
             PlayResult result = game.play(move);
-            controller.updateUI();
+
+            updateUI();
 
             GameState state = result.state();
             switch (state) {

game/src/main/java/org/toop/game/gameThreads/OnlineThreadBehaviour.java

@@ -53,7 +53,7 @@ public class OnlineThreadBehaviour<T extends TurnBasedGame<T>> extends AbstractT
     public void onYourTurn(long clientId) {
         if (!isRunning.get()) return;
         long move = game.getPlayer(game.getCurrentTurn()).getMove(game.deepCopy());
-        controller.sendMove(clientId, move);
+        sendMove(clientId, move);
     }
 
     /**
@@ -63,7 +63,8 @@ public class OnlineThreadBehaviour<T extends TurnBasedGame<T>> extends AbstractT
     public void onMoveReceived(long move) {
         if (!isRunning.get()) return;
         game.play(move);
-        new EventFlow().addPostEvent(GUIEvents.RefreshGameCanvas.class).postEvent();
+
+        updateUI();
     }
 
     /**
@@ -72,9 +73,8 @@ public class OnlineThreadBehaviour<T extends TurnBasedGame<T>> extends AbstractT
      */
     public void gameFinished(String condition) {
         switch(condition.toUpperCase()){
-            case "WIN" -> new EventFlow().addPostEvent(GUIEvents.GameEnded.class, true, game.getCurrentTurn()).postEvent();
+            case "WIN", "LOSS" -> new EventFlow().addPostEvent(GUIEvents.GameEnded.class, true, game.getWinner()).postEvent();
             case "DRAW" -> new EventFlow().addPostEvent(GUIEvents.GameEnded.class, false, -1).postEvent();
-            case "LOSS" -> new EventFlow().addPostEvent(GUIEvents.GameEnded.class, true, (game.getCurrentTurn() + 1)%2).postEvent();
             default -> {
                 logger.error("Invalid condition");
                 throw new RuntimeException("Unknown condition");

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

@@ -97,17 +97,13 @@ public class BitboardReversi extends BitboardGame<BitboardReversi> {
 			final long skippedLegalMoves = getLegalMoves();
 
 			if (skippedLegalMoves == 0) {
-				final long black = getPlayerBitboard(0);
+				int winner = getWinner();
-				final long white = getPlayerBitboard(1);
 
-				final int blackCount = Long.bitCount(black);
+				if (winner == -1) {
-				final int whiteCount = Long.bitCount(white);
-
-				if (blackCount == whiteCount) {
 					return new PlayResult(GameState.DRAW, -1);
 				}
 
-				return new PlayResult(GameState.WIN, blackCount > whiteCount ? 0 : 1);
+				return new PlayResult(GameState.WIN, winner);
 			}
 
 			return new PlayResult(GameState.TURN_SKIPPED, getCurrentPlayerIndex());
@@ -123,6 +119,24 @@ public class BitboardReversi extends BitboardGame<BitboardReversi> {
 		);
 	}
 
+    public int getWinner(){
+        final long black = getPlayerBitboard(0);
+        final long white = getPlayerBitboard(1);
+
+        final int blackCount = Long.bitCount(black);
+        final int whiteCount = Long.bitCount(white);
+
+        if (blackCount == whiteCount){
+            return -1;
+        }
+        else if (blackCount > whiteCount){
+            return 0;
+        }
+        else{
+            return 1;
+        }
+    }
+
 	private long computeMoves(long player, long opponent, int shift, long mask) {
 		long moves = shift(player, shift, mask) & opponent;
 		long captured = moves;

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

@@ -32,6 +32,10 @@ public class BitboardTicTacToe extends BitboardGame<BitboardTicTacToe> {
 		return (~taken) & 0x1ffL;
 	}
 
+    public int getWinner(){
+        return getCurrentPlayerIndex();
+    }
+
 	public PlayResult play(long move) {
         // Player loses if move is invalid
         if ((move & getLegalMoves()) == 0 || Long.bitCount(move) != 1){