Merge remote-tracking branch 'origin/Development' into Development

.github/workflows/checks.yaml

@@ -1,42 +1,42 @@
-name: Checks
+#name: Checks
 
-on:
+#on:
-  push:
+#  push:
-    branches:
+#    branches:
-      - 'main'
+#      - 'main'
-  pull_request:
+#  pull_request:
-    branches:
+#    branches:
-      - 'main'
+#      - 'main'
+#
+#jobs:
+#  formatting-check:
+#    name: Follow Google Formatting Guidelines
+#    runs-on: ubuntu-latest
+#    steps:
+#      - uses: actions/checkout@v5
+#        with:
+#          fetch-depth: 0 # Fix for incremental formatting
+#      - uses: actions/setup-java@v5
+#        with:
+#          java-version: '25'
+#          distribution: 'temurin'
+#          cache: maven
+#      - name: Run Format Check
+#        run: mvn spotless:check
 
-jobs:
+#  tests:
-  formatting-check:
+#    name: Unittests
-    name: Follow Google Formatting Guidelines
+#    runs-on: ${{ matrix.os }}
-    runs-on: ubuntu-latest
+#    needs: formatting-check
-    steps:
+#    strategy:
-      - uses: actions/checkout@v5
+#      matrix:
-        with:
+#        os: [ubuntu-latest] #windows-latest, macos-latest
-          fetch-depth: 0 # Fix for incremental formatting
+#    steps:
-      - uses: actions/setup-java@v5
+#      - uses: actions/checkout@v5
-        with:
+#      - uses: actions/setup-java@v5
-          java-version: '25'
+#        with:
-          distribution: 'temurin'
+#          java-version: '25'
-          cache: maven
+#          distribution: 'temurin'
-      - name: Run Format Check
+#          cache: maven
-        run: mvn spotless:check
+#      - name: Run Unittests
-
+#        run: mvn -B test
-  tests:
-    name: Unittests
-    runs-on: ${{ matrix.os }}
-    needs: formatting-check
-    strategy:
-      matrix:
-        os: [ubuntu-latest] #windows-latest, macos-latest
-    steps:
-      - uses: actions/checkout@v5
-      - uses: actions/setup-java@v5
-        with:
-          java-version: '25'
-          distribution: 'temurin'
-          cache: maven
-      - name: Run Unittests
-        run: mvn -B test

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

@@ -3,7 +3,6 @@ package org.toop.app;
 import javafx.application.Platform;
 import javafx.scene.input.KeyCode;
 import javafx.scene.input.KeyCodeCombination;
-import javafx.scene.input.KeyCombination;
 import javafx.scene.input.KeyEvent;
 
 import org.toop.app.widget.Primitive;
@@ -112,20 +111,19 @@ public final class App extends Application {
 						Platform.runLater(() -> stage.setOpacity(1.0));
 					}
 
-					Platform.runLater(() -> loading.setMaxAmount(e.isLoadingAmount()));
-
 					Platform.runLater(() -> {
+                        loading.setMaxAmount(e.isLoadingAmount());
 						try {
 							loading.setAmount(e.hasLoadedAmount());
 						} catch (Exception ex) {
 							throw new RuntimeException(ex);
 						}
-					});
+                        if (e.hasLoadedAmount() >= e.isLoadingAmount()-1) {
-
-                    if (e.hasLoadedAmount() >= e.isLoadingAmount()) {
                             Platform.runLater(loading::triggerSuccess);
                             loadingFlow.unsubscribe("init_loading");
                         }
+					});
+
 
                 }, false, "init_loading");
 

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

@@ -21,7 +21,7 @@ import org.toop.game.games.reversi.BitboardReversi;
 import org.toop.game.games.tictactoe.BitboardTicTacToe;
 import org.toop.game.players.ArtificialPlayer;
 import org.toop.game.players.OnlinePlayer;
-import org.toop.game.players.RandomAI;
+import org.toop.game.players.ai.RandomAI;
 import org.toop.local.AppContext;
 
 import java.util.List;

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

@@ -55,7 +55,7 @@ public class GenericGameController<T extends TurnBasedGame<T>> implements GameCo
         // 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);
+                .listen(GUIEvents.PlayerAttemptedMove.class, event -> {if (getCurrentPlayer() instanceof LocalPlayer<T> lp){lp.setLastMove(event.move());}}, false);
     }
 
     public void start(){

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

@@ -2,9 +2,6 @@ package org.toop.app.widget.view;
 
 import javafx.application.Platform;
 import org.toop.app.GameInformation;
-import org.toop.app.canvas.ReversiBitCanvas;
-import org.toop.app.canvas.TicTacToeBitCanvas;
-import org.toop.app.gameControllers.GenericGameController;
 import org.toop.app.gameControllers.ReversiBitController;
 import org.toop.app.gameControllers.TicTacToeBitController;
 import org.toop.framework.gameFramework.controller.GameController;
@@ -18,8 +15,8 @@ import org.toop.app.widget.complex.PlayerInfoWidget;
 import org.toop.app.widget.complex.ViewWidget;
 import org.toop.app.widget.popup.ErrorPopup;
 import org.toop.app.widget.tutorial.*;
-import org.toop.game.players.MiniMaxAI;
+import org.toop.game.players.ai.MiniMaxAI;
-import org.toop.game.players.RandomAI;
+import org.toop.game.players.ai.RandomAI;
 import org.toop.local.AppContext;
 
 import javafx.geometry.Pos;
@@ -27,9 +24,6 @@ import javafx.scene.control.ScrollPane;
 import javafx.scene.layout.VBox;
 import org.toop.local.AppSettings;
 
-import java.util.Arrays;
-import java.util.Random;
-
 public class LocalMultiplayerView extends ViewWidget {
 	private final GameInformation information;
 

framework/src/main/java/org/toop/framework/eventbus/EventFlow.java

@@ -14,7 +14,8 @@ import org.toop.framework.eventbus.events.EventType;
 import org.toop.framework.eventbus.events.ResponseToUniqueEvent;
 import org.toop.framework.eventbus.events.UniqueEvent;
 import org.toop.framework.eventbus.bus.EventBus;
-import org.toop.framework.eventbus.subscriber.DefaultSubscriber;
+import org.toop.framework.eventbus.subscriber.DefaultNamedSubscriber;
+import org.toop.framework.eventbus.subscriber.NamedSubscriber;
 import org.toop.framework.eventbus.subscriber.Subscriber;
 
 /**
@@ -43,7 +44,7 @@ public class EventFlow {
     private EventType event = null;
 
     /** The listener returned by GlobalEventBus subscription. Used for unsubscription. */
-    private final List<Subscriber<?, ?>> listeners = new ArrayList<>();
+    private final List<NamedSubscriber<?>> listeners = new ArrayList<>();
 
     /** Holds the results returned from the subscribed event, if any. */
     private Map<String, ?> result = null;
@@ -161,7 +162,7 @@ public class EventFlow {
             this.result = eventClass.result();
         };
 
-        var subscriber = new DefaultSubscriber<>(
+        var subscriber = new DefaultNamedSubscriber<>(
                 name,
                 event,
                 newAction
@@ -248,7 +249,7 @@ public class EventFlow {
             }
         };
 
-        var listener = new DefaultSubscriber<>(
+        var listener = new DefaultNamedSubscriber<>(
                 name,
                 (Class<TT>) action.getClass().getDeclaredMethods()[0].getParameterTypes()[0],
                 newAction
@@ -295,7 +296,7 @@ public class EventFlow {
             if (unsubscribeAfterSuccess) unsubscribe(String.valueOf(id));
         };
 
-        var listener = new DefaultSubscriber<>(
+        var listener = new DefaultNamedSubscriber<>(
                         name,
                         event,
                         newAction
@@ -378,7 +379,7 @@ public class EventFlow {
             }
         };
 
-        var listener = new DefaultSubscriber<>(
+        var listener = new DefaultNamedSubscriber<>(
                 name,
                 eventClass,
                 newAction
@@ -496,7 +497,7 @@ public class EventFlow {
      *
      * @return Copy of the list of listeners.
      */
-    public Subscriber<?, ?>[] getListeners() {
+    public Subscriber<?>[] getListeners() {
         return listeners.toArray(new Subscriber[0]);
     }
 

framework/src/main/java/org/toop/framework/eventbus/GlobalEventBus.java

@@ -3,6 +3,7 @@ package org.toop.framework.eventbus;
 import org.apache.logging.log4j.LogManager;
 import org.toop.framework.eventbus.bus.DisruptorEventBus;
 import org.toop.framework.eventbus.bus.EventBus;
+import org.toop.framework.eventbus.events.EventType;
 import org.toop.framework.eventbus.store.DefaultSubscriberStore;
 import org.toop.framework.eventbus.subscriber.Subscriber;
 
@@ -19,17 +20,17 @@ public class GlobalEventBus implements EventBus {
     }
 
     @Override
-    public void subscribe(Subscriber<?, ?> listener) {
+    public void subscribe(Subscriber<? extends EventType> listener) {
         INSTANCE.subscribe(listener);
     }
 
     @Override
-    public void unsubscribe(Subscriber<?, ?> listener) {
+    public void unsubscribe(Subscriber<? extends EventType> listener) {
         INSTANCE.unsubscribe(listener);
     }
 
     @Override
-    public <T> void post(T event) {
+    public <T extends EventType> void post(T event) {
         INSTANCE.post(event);
     }
 

framework/src/main/java/org/toop/framework/eventbus/bus/DefaultEventBus.java

@@ -17,22 +17,22 @@ public class DefaultEventBus implements EventBus {
     }
 
     @Override
-    public void subscribe(Subscriber<?, ?> subscriber) {
+    public void subscribe(Subscriber<? extends EventType> subscriber) {
         eventsHolder.add(subscriber);
     }
 
     @Override
-    public void unsubscribe(Subscriber<?, ?> subscriber) {
+    public void unsubscribe(Subscriber<? extends EventType> subscriber) {
         eventsHolder.remove(subscriber);
     }
 
     @Override
     @SuppressWarnings("unchecked")
-    public <T> void post(T event) {
+    public <T extends EventType> void post(T event) {
         Class<T> eventType = (Class<T>) event.getClass();
         var subs = eventsHolder.get(eventType);
         if (subs != null) {
-            for (Subscriber<?, ?> subscriber : subs) {
+            for (Subscriber<?> subscriber : subs) {
                 Class<T> eventClass = (Class<T>) subscriber.event();
                 Consumer<EventType> action = (Consumer<EventType>) subscriber.handler();
 

framework/src/main/java/org/toop/framework/eventbus/bus/DisruptorEventBus.java

@@ -21,8 +21,8 @@ public class DisruptorEventBus implements EventBus {
     private final Logger logger;
     private final SubscriberStore eventsHolder;
 
-    private final Disruptor<EventHolder<?>> disruptor;
+    private final Disruptor<EventHolder<? extends EventType>> disruptor;
-    private final RingBuffer<EventHolder<?>> ringBuffer;
+    private final RingBuffer<EventHolder<? extends EventType>> ringBuffer;
 
     public DisruptorEventBus(Logger logger, SubscriberStore eventsHolder) {
         this.logger = logger;
@@ -41,9 +41,9 @@ public class DisruptorEventBus implements EventBus {
         this.ringBuffer = disruptor.getRingBuffer();
     }
 
-    private Disruptor<EventHolder<?>> getEventHolderDisruptor(ThreadFactory threadFactory) {
+    private Disruptor<EventHolder<? extends EventType>> getEventHolderDisruptor(ThreadFactory threadFactory) {
         int RING_BUFFER_SIZE = 1024 * 64;
-        Disruptor<EventHolder<?>> disruptor = new Disruptor<>(
+        Disruptor<EventHolder<? extends EventType>> disruptor = new Disruptor<>(
                 EventHolder::new,
                 RING_BUFFER_SIZE,
                 threadFactory,
@@ -61,17 +61,17 @@ public class DisruptorEventBus implements EventBus {
     }
 
     @Override
-    public void subscribe(Subscriber<?, ?> listener) {
+    public void subscribe(Subscriber<? extends EventType> listener) {
         eventsHolder.add(listener);
     }
 
     @Override
-    public void unsubscribe(Subscriber<?, ?> listener) {
+    public void unsubscribe(Subscriber<? extends EventType> listener) {
         eventsHolder.remove(listener);
     }
 
     @Override
-    public <T> void post(T event) {
+    public <T extends EventType> void post(T event) {
         long seq = ringBuffer.next();
         try {
             @SuppressWarnings("unchecked")
@@ -93,10 +93,10 @@ public class DisruptorEventBus implements EventBus {
         eventsHolder.reset();
     }
 
-    private <T> void dispatchEvent(T event) {
+    private <T extends EventType> void dispatchEvent(T event) {
         var classListeners = eventsHolder.get(event.getClass());
         if (classListeners != null) {
-            for (Subscriber<?, ?> listener : classListeners) {
+            for (Subscriber<?> listener : classListeners) {
                 try {
                     callListener(listener, event);
                 } catch (Throwable e) {
@@ -108,7 +108,7 @@ public class DisruptorEventBus implements EventBus {
 
 
     @SuppressWarnings("unchecked")
-    private <T> void callListener(Subscriber<?, ?> subscriber, T event) {
+    private <T> void callListener(Subscriber<?> subscriber, T event) {
         Class<T> eventClass = (Class<T>) subscriber.event();
         Consumer<EventType> action = (Consumer<EventType>) subscriber.handler();
 

framework/src/main/java/org/toop/framework/eventbus/bus/EventBus.java

@@ -1,11 +1,12 @@
 package org.toop.framework.eventbus.bus;
 
+import org.toop.framework.eventbus.events.EventType;
 import org.toop.framework.eventbus.subscriber.Subscriber;
 
 public interface EventBus {
-    void subscribe(Subscriber<?, ?> subscriber);
+    void subscribe(Subscriber<? extends EventType> subscriber);
-    void unsubscribe(Subscriber<?, ?> subscriber);
+    void unsubscribe(Subscriber<? extends EventType> subscriber);
-    <T> void post(T event);
+    <T extends EventType> void post(T event);
     void shutdown();
     void reset();
 }

framework/src/main/java/org/toop/framework/eventbus/store/AsyncSubscriberStore.java

@@ -1,23 +1,24 @@
 package org.toop.framework.eventbus.store;
 
+import org.toop.framework.eventbus.events.EventType;
 import org.toop.framework.eventbus.subscriber.Subscriber;
 
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentLinkedQueue;
 
 public class AsyncSubscriberStore implements SubscriberStore {
-    private final ConcurrentHashMap<Class<?>, ConcurrentLinkedQueue<Subscriber<?, ?>>> queues = new ConcurrentHashMap<>();
+    private final ConcurrentHashMap<Class<? extends EventType>, ConcurrentLinkedQueue<Subscriber<? extends EventType>>> queues = new ConcurrentHashMap<>();
-    private final ConcurrentHashMap<Class<?>, Subscriber<?, ?>[]> snapshots = new ConcurrentHashMap<>();
+    private final ConcurrentHashMap<Class<? extends EventType>, Subscriber<? extends EventType>[]> snapshots = new ConcurrentHashMap<>();
 
     @Override
-    public void add(Subscriber<?, ?> sub) {
+    public void add(Subscriber<? extends EventType> sub) {
         queues.computeIfAbsent(sub.event(), _ -> new ConcurrentLinkedQueue<>()).add(sub);
         rebuildSnapshot(sub.event());
     }
 
     @Override
-    public void remove(Subscriber<?, ?> sub) {
+    public void remove(Subscriber<? extends EventType> sub) {
-        ConcurrentLinkedQueue<Subscriber<?, ?>> queue = queues.get(sub.event());
+        ConcurrentLinkedQueue<Subscriber<?>> queue = queues.get(sub.event());
         if (queue != null) {
             queue.remove(sub);
             rebuildSnapshot(sub.event());
@@ -25,8 +26,8 @@ public class AsyncSubscriberStore implements SubscriberStore {
     }
 
     @Override
-    public Subscriber<?, ?>[] get(Class<?> event) {
+    public Subscriber<? extends EventType>[] get(Class<? extends EventType> event) {
-        return snapshots.getOrDefault(event, new Subscriber[0]);
+        return snapshots.getOrDefault(event, new Subscriber<?>[0]);
     }
 
     @Override
@@ -35,12 +36,12 @@ public class AsyncSubscriberStore implements SubscriberStore {
         snapshots.clear();
     }
 
-    private void rebuildSnapshot(Class<?> event) {
+    private void rebuildSnapshot(Class<? extends EventType> event) {
-        ConcurrentLinkedQueue<Subscriber<?, ?>> queue = queues.get(event);
+        ConcurrentLinkedQueue<Subscriber<?>> queue = queues.get(event);
         if (queue != null) {
-            snapshots.put(event, queue.toArray(new Subscriber[0]));
+            snapshots.put(event, queue.toArray(new Subscriber<?>[0]));
         } else {
-            snapshots.put(event, new Subscriber[0]);
+            snapshots.put(event, new Subscriber<?>[0]);
         }
     }
 }

framework/src/main/java/org/toop/framework/eventbus/store/DefaultSubscriberStore.java

@@ -1,25 +1,27 @@
 package org.toop.framework.eventbus.store;
 
+import org.toop.framework.eventbus.events.EventType;
+import org.toop.framework.eventbus.subscriber.NamedSubscriber;
 import org.toop.framework.eventbus.subscriber.Subscriber;
 
 import java.util.concurrent.ConcurrentHashMap;
 
 public class DefaultSubscriberStore implements SubscriberStore {
 
-    private static final Subscriber<?, ?>[] EMPTY = new Subscriber[0];
+    private static final Subscriber<? extends EventType>[] EMPTY = new Subscriber<?>[0];
 
-    private final ConcurrentHashMap<Class<?>, Subscriber<?, ?>[]> listeners =
+    private final ConcurrentHashMap<Class<? extends EventType>, Subscriber<? extends EventType>[]>
-            new ConcurrentHashMap<>();
+            listeners = new ConcurrentHashMap<>();
 
     @Override
-    public void add(Subscriber<?, ?> sub) {
+    public void add(Subscriber<? extends EventType> sub) {
         listeners.compute(sub.event(), (_, arr) -> {
             if (arr == null || arr.length == 0) {
-                return new Subscriber<?, ?>[]{sub};
+                return new Subscriber<?>[]{sub};
             }
 
             int len = arr.length;
-            Subscriber<?, ?>[] newArr = new Subscriber[len + 1];
+            Subscriber<?>[] newArr = new Subscriber[len + 1];
             System.arraycopy(arr, 0, newArr, 0, len);
             newArr[len] = sub;
             return newArr;
@@ -27,7 +29,7 @@ public class DefaultSubscriberStore implements SubscriberStore {
     }
 
     @Override
-    public void remove(Subscriber<?, ?> sub) {
+    public void remove(Subscriber<? extends EventType> sub) {
         listeners.computeIfPresent(sub.event(), (_, arr) -> {
             int len = arr.length;
 
@@ -36,7 +38,7 @@ public class DefaultSubscriberStore implements SubscriberStore {
             }
 
             int keep = 0;
-            for (Subscriber<?, ?> s : arr) {
+            for (Subscriber<?> s : arr) {
                 if (!s.equals(sub)) keep++;
             }
 
@@ -47,9 +49,9 @@ public class DefaultSubscriberStore implements SubscriberStore {
                 return null;
             }
 
-            Subscriber<?, ?>[] newArr = new Subscriber[keep];
+            Subscriber<?>[] newArr = new Subscriber[keep];
             int i = 0;
-            for (Subscriber<?, ?> s : arr) {
+            for (Subscriber<?> s : arr) {
                 if (!s.equals(sub)) {
                     newArr[i++] = s;
                 }
@@ -60,7 +62,7 @@ public class DefaultSubscriberStore implements SubscriberStore {
     }
 
     @Override
-    public Subscriber<?, ?>[] get(Class<?> event) {
+    public Subscriber<? extends EventType>[] get(Class<? extends EventType> event) {
         return listeners.getOrDefault(event, EMPTY);
     }
 

framework/src/main/java/org/toop/framework/eventbus/store/SubscriberStore.java

@@ -1,10 +1,11 @@
 package org.toop.framework.eventbus.store;
 
+import org.toop.framework.eventbus.events.EventType;
 import org.toop.framework.eventbus.subscriber.Subscriber;
 
 public interface SubscriberStore {
-    void add(Subscriber<?, ?> subscriber);
+    void add(Subscriber<? extends EventType> subscriber);
-    void remove(Subscriber<?, ?> subscriber);
+    void remove(Subscriber<? extends EventType> subscriber);
-    Subscriber<?, ?>[] get(Class<?> event);
+    Subscriber<? extends EventType>[] get(Class<? extends EventType> event);
     void reset();
 }

framework/src/main/java/org/toop/framework/eventbus/store/SyncSubscriberStore.java

@@ -1,5 +1,6 @@
 package org.toop.framework.eventbus.store;
 
+import org.toop.framework.eventbus.events.EventType;
 import org.toop.framework.eventbus.subscriber.Subscriber;
 
 import java.util.ArrayList;
@@ -8,23 +9,23 @@ import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
 public class SyncSubscriberStore implements SubscriberStore {
-    private final Map<Class<?>, List<Subscriber<?, ?>>> LISTENERS = new ConcurrentHashMap<>();
+    private final Map<Class<? extends EventType>, List<Subscriber<? extends EventType>>> LISTENERS = new ConcurrentHashMap<>();
-    private static final Subscriber<?, ?>[] EMPTY = new Subscriber[0];
+    private static final Subscriber<? extends EventType>[] EMPTY = new Subscriber<?>[0];
 
     @Override
-    public void add(Subscriber<?, ?> sub) {
+    public void add(Subscriber<? extends EventType> sub) {
         LISTENERS.computeIfAbsent(sub.event(), _ -> new ArrayList<>()).add(sub);
     }
 
     @Override
-    public void remove(Subscriber<?, ?> sub) {
+    public void remove(Subscriber<? extends EventType> sub) {
         LISTENERS.getOrDefault(sub.event(), new ArrayList<>()).remove(sub);
         LISTENERS.entrySet().removeIf(entry -> entry.getValue().isEmpty());
     }
 
     @Override
-    public Subscriber<?, ?>[] get(Class<?> event) {
+    public Subscriber<? extends EventType>[] get(Class<? extends EventType> event) {
-        List<Subscriber<?, ?>> list = LISTENERS.get(event);
+        List<Subscriber<? extends EventType>> list = LISTENERS.get(event);
         if (list == null || list.isEmpty()) return EMPTY;
         return list.toArray(EMPTY);
     }

framework/src/main/java/org/toop/framework/eventbus/subscriber/DefaultNamedSubscriber.java

@@ -0,0 +1,8 @@
+package org.toop.framework.eventbus.subscriber;
+
+import org.toop.framework.eventbus.events.EventType;
+
+import java.util.function.Consumer;
+
+public record DefaultNamedSubscriber<K extends EventType>(String id, Class<K> event, Consumer<K> handler)
+        implements NamedSubscriber<K> {}

framework/src/main/java/org/toop/framework/eventbus/subscriber/DefaultSubscriber.java

@@ -1,5 +1,8 @@
 package org.toop.framework.eventbus.subscriber;
 
+import org.toop.framework.eventbus.events.EventType;
+
 import java.util.function.Consumer;
 
-public record DefaultSubscriber<K>(String id, Class<K> event, Consumer<K> handler) implements NamedSubscriber<K> {}
+public record DefaultSubscriber<K extends EventType>(Class<K> event, Consumer<K> handler) implements Subscriber<K> {}
+

framework/src/main/java/org/toop/framework/eventbus/subscriber/HasId.java

@@ -0,0 +1,5 @@
+package org.toop.framework.eventbus.subscriber;
+
+public interface HasId<ID> {
+    ID id();
+}

framework/src/main/java/org/toop/framework/eventbus/subscriber/IdSubscriber.java

@@ -1,3 +1,5 @@
 package org.toop.framework.eventbus.subscriber;
 
-public interface IdSubscriber<T> extends Subscriber<Long, T> {}
+import org.toop.framework.eventbus.events.EventType;
+
+public interface IdSubscriber<K extends EventType> extends Subscriber<K>, HasId<Long> {}

framework/src/main/java/org/toop/framework/eventbus/subscriber/LongIdSubscriber.java

@@ -1,5 +1,8 @@
 package org.toop.framework.eventbus.subscriber;
 
+import org.toop.framework.eventbus.events.EventType;
+
 import java.util.function.Consumer;
 
-public record LongIdSubscriber<K>(Long id, Class<K> event, Consumer<K> handler) implements IdSubscriber<K> {}
+public record LongIdSubscriber<K extends EventType>(Long id, Class<K> event, Consumer<K> handler)
+        implements IdSubscriber<K> {}

framework/src/main/java/org/toop/framework/eventbus/subscriber/NamedSubscriber.java

@@ -1,3 +1,5 @@
 package org.toop.framework.eventbus.subscriber;
 
-public interface NamedSubscriber<T> extends Subscriber<String, T> {}
+import org.toop.framework.eventbus.events.EventType;
+
+public interface NamedSubscriber<K extends EventType> extends Subscriber<K>, HasId<String> {}

framework/src/main/java/org/toop/framework/eventbus/subscriber/Subscriber.java

@@ -1,9 +1,10 @@
 package org.toop.framework.eventbus.subscriber;
 
+import org.toop.framework.eventbus.events.EventType;
+
 import java.util.function.Consumer;
 
-public interface Subscriber<ID, K> {
+public interface Subscriber<K extends EventType> {
-    ID id();
     Class<K> event();
     Consumer<K> handler();
 }

framework/src/main/java/org/toop/framework/gameFramework/model/player/AbstractPlayer.java

@@ -5,45 +5,65 @@ import org.apache.logging.log4j.Logger;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 
 /**
- * Abstract class representing a player in a game.
+ * Base class for players in a turn-based game.
- * <p>
+ *
- * Players are entities that can make moves based on the current state of a game.
+ * @param <T> the game type
- * player types, such as human players or AI players.
- * </p>
- * <p>
- * Subclasses should override the {@link #getMove(GameR)} method to provide
- * specific move logic.
- * </p>
  */
 public abstract class AbstractPlayer<T extends TurnBasedGame<T>> implements Player<T> {
-    private final Logger logger = LogManager.getLogger(this.getClass());
 
+    private final Logger logger = LogManager.getLogger(this.getClass());
     private final String name;
 
+    /**
+     * Creates a new player with the given name.
+     *
+     * @param name the player name
+     */
     protected AbstractPlayer(String name) {
         this.name = name;
     }
 
+    /**
+     * Creates a copy of another player.
+     *
+     * @param other the player to copy
+     */
     protected AbstractPlayer(AbstractPlayer<T> other) {
         this.name = other.name;
     }
+
     /**
-     * Determines the next move based on the provided game state.
+     * Gets the player's move for the given game state.
+     * A deep copy is provided so the player cannot modify the real state.
      * <p>
-     * The default implementation throws an {@link UnsupportedOperationException},
+     * This method uses the Template Method Pattern: it defines the fixed
-     * indicating that concrete subclasses must override this method to provide
+     * algorithm and delegates the variable part to {@link #determineMove(T)}.
-     * actual move logic.
-     * </p>
      *
-     * @param gameCopy a snapshot of the current game state
+     * @param game the current game
-     * @return an integer representing the chosen move
+     * @return the chosen move
-     * @throws UnsupportedOperationException if the method is not overridden
      */
-    public long getMove(T gameCopy) {
+    public final long getMove(T game) {
-        logger.error("Method getMove not implemented.");
+        return determineMove(game.deepCopy());
-        throw new UnsupportedOperationException("Not supported yet.");
     }
 
+
+    /**
+     * Determines the player's move using a safe copy of the game.
+     * <p>
+     * This method is called by {@link #getMove(T)} and should contain
+     * the player's strategy for choosing a move.
+     *
+     * @param gameCopy a deep copy of the game
+     * @return the chosen move
+     */
+    protected abstract long determineMove(T gameCopy);
+
+
+    /**
+     * Returns the player's name.
+     *
+     * @return the name
+     */
     public String getName() {
         return this.name;
     }

game/src/main/java/org/toop/game/players/ArtificialPlayer.java

@@ -4,52 +4,52 @@ import org.toop.framework.gameFramework.model.player.*;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 
 /**
- * Represents a player controlled by an AI in a game.
+ * Represents a player controlled by an AI.
- * <p>
- * This player uses an {@link AbstractAI} instance to determine its moves. The generic
- * parameter {@code T} specifies the type of {@link GameR} the AI can handle.
- * </p>
  *
- * @param <T> the specific type of game this AI player can play
+ * @param <T> the type of turn-based game
  */
 public class ArtificialPlayer<T extends TurnBasedGame<T>> extends AbstractPlayer<T> {
 
-    /** The AI instance used to calculate moves. */
     private final AI<T> ai;
 
     /**
-     * Constructs a new ArtificialPlayer using the specified AI.
+     * Creates a new AI-controlled player.
      *
-     * @param ai the AI instance that determines moves for this player
+     * @param ai the AI controlling this player
+     * @param name the player's name
      */
     public ArtificialPlayer(AI<T> ai, String name) {
         super(name);
         this.ai = ai;
     }
 
+    /**
+     * Creates a copy of another AI-controlled player.
+     *
+     * @param other the player to copy
+     */
     public ArtificialPlayer(ArtificialPlayer<T> other) {
         super(other);
         this.ai = other.ai.deepCopy();
     }
 
     /**
-     * Determines the next move for this player using its AI.
+     * Determines the player's move using the AI.
-     * <p>
-     * This method overrides {@link AbstractPlayer#getMove(GameR)}. Because the AI is
-     * typed to {@code T}, a runtime cast is required. It is the caller's
-     * responsibility to ensure that {@code gameCopy} is of type {@code T}.
-     * </p>
      *
-     * @param gameCopy a copy of the current game state
+     * @param gameCopy a copy of the current game
-     * @return the integer representing the chosen move
+     * @return the move chosen by the AI
-     * @throws ClassCastException if {@code gameCopy} is not of type {@code T}
      */
-    public long getMove(T gameCopy) {
+    protected long determineMove(T gameCopy) {
         return ai.getMove(gameCopy);
     }
 
+    /**
+     * Creates a deep copy of this AI player.
+     *
+     * @return a copy of this player
+     */
     @Override
     public ArtificialPlayer<T> deepCopy() {
-        return new ArtificialPlayer<T>(this);
+        return new ArtificialPlayer<>(this);
     }
 }

game/src/main/java/org/toop/game/players/LocalPlayer.java

@@ -2,85 +2,86 @@ package org.toop.game.players;
 
 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.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 
+/**
+ * Represents a local player who provides moves manually.
+ *
+ * @param <T> the type of turn-based game
+ */
 public class LocalPlayer<T extends TurnBasedGame<T>> extends AbstractPlayer<T> {
-    // Future can be used with event system, IF unsubscribeAfterSuccess works...
-    // private CompletableFuture<Integer> LastMove = new CompletableFuture<>();
 
-    private CompletableFuture<Long> LastMove;
+    private CompletableFuture<Long> LastMove = new CompletableFuture<>();
 
+    /**
+     * Creates a new local player with the given name.
+     *
+     * @param name the player's name
+     */
     public LocalPlayer(String name) {
         super(name);
     }
 
+    /**
+     * Creates a copy of another local player.
+     *
+     * @param other the player to copy
+     */
     public LocalPlayer(LocalPlayer<T> other) {
         super(other);
+        this.LastMove = other.LastMove;
     }
 
+    /**
+     * Waits for and returns the player's next legal move.
+     *
+     * @param gameCopy a copy of the current game
+     * @return the chosen move
+     */
     @Override
-    public long getMove(T gameCopy) {
+    protected long determineMove(T gameCopy) {
-        return getValidMove(gameCopy);
+        long legalMoves = gameCopy.getLegalMoves();
+        long move;
+
+        do {
+            move = getLastMove();
+        } while ((legalMoves & move) == 0);
+
+        return move;
     }
 
-    public void setMove(long move) {
+    /**
+     * Sets the player's last move.
+     *
+     * @param move the move to set
+     */
+    public void setLastMove(long move) {
         LastMove.complete(move);
     }
 
-    // TODO: helper function, would like to replace to get rid of this method
+    /**
-    public static boolean contains(int[] array, int value){
+     * Waits for the next move from the player.
-        for (int i : array) if (i == value) return true;
+     *
-        return false;
+     * @return the chosen move or 0 if interrupted
-    }
+     */
-
+    private long getLastMove() {
-    private long getMove2(T gameCopy) {
+        LastMove = new CompletableFuture<>(); // Reset the future
-        LastMove = new CompletableFuture<>();
-        long move = 0;
         try {
-            move = LastMove.get();
+            return LastMove.get();
-            System.out.println(Long.toBinaryString(move));
+        } catch (ExecutionException | InterruptedException e) {
-        } catch (InterruptedException | ExecutionException e) {
+            return 0;
-            // TODO: Add proper logging.
-            e.printStackTrace();
         }
-        return move;
-    }
-
-    protected long getValidMove(T gameCopy){
-        // Get this player's valid moves
-        long validMoves = gameCopy.getLegalMoves();
-        // Make sure provided move is valid
-        // TODO: Limit amount of retries?
-        // TODO: Stop copying game so many times
-        long move = getMove2(gameCopy.deepCopy());
-        while ((validMoves & move) == 0) {
-            System.out.println("Not a valid move, try again");
-            move = getMove2(gameCopy.deepCopy());
-        }
-        return move;
     }
 
+    /**
+     * Creates a deep copy of this local player.
+     *
+     * @return a copy of this player
+     */
     @Override
     public LocalPlayer<T> deepCopy() {
-        return new LocalPlayer<T>(this.getName());
+        return new LocalPlayer<>(this);
     }
-
-    /*public void register() {
-        // Listening to PlayerAttemptedMove
-        new EventFlow().listen(GUIEvents.PlayerAttemptedMove.class, event -> {
-            if (!LastMove.isDone()) {
-                LastMove.complete(event.move()); // complete the future
-            }
-        }, true); // auto-unsubscribe
-    }
-
-    // This blocks until the next move arrives
-    public int take() throws ExecutionException, InterruptedException {
-        int move = LastMove.get(); // blocking
-        LastMove = new CompletableFuture<>(); // reset for next move
-        return move;
-    }*/
 }

game/src/main/java/org/toop/game/players/OnlinePlayer.java

@@ -5,30 +5,45 @@ import org.toop.framework.gameFramework.model.player.AbstractPlayer;
 import org.toop.framework.gameFramework.model.player.Player;
 
 /**
- * Represents a player controlled remotely or over a network.
+ * Represents a player that participates online.
- * <p>
+ *
- * This class extends {@link AbstractPlayer} and can be used to implement game logic
+ * @param <T> the type of turn-based game
- * where moves are provided by an external source (e.g., another user or a server).
- * Currently, this class is a placeholder and does not implement move logic.
- * </p>
  */
 public class OnlinePlayer<T extends TurnBasedGame<T>> extends AbstractPlayer<T> {
 
     /**
-     * Constructs a new OnlinePlayer.
+     * Creates a new online player with the given name.
-     * <p>
+     *
-     * Currently, no additional initialization is performed. Subclasses or
+     * @param name the name of the player
-     * future implementations should provide mechanisms to receive moves from
-     * an external source.
      */
     public OnlinePlayer(String name) {
         super(name);
     }
 
+    /**
+     * Creates a copy of another online player.
+     *
+     * @param other the player to copy
+     */
     public OnlinePlayer(OnlinePlayer<T> other) {
         super(other);
     }
 
+    /**
+     * {@inheritDoc}
+     * <p>
+     * This method is not supported for online players.
+     *
+     * @throws UnsupportedOperationException always
+     */
+    @Override
+    protected long determineMove(T gameCopy) {
+        throw new UnsupportedOperationException("An online player does not support determining move");
+    }
+
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public Player<T> deepCopy() {
         return new OnlinePlayer<>(this);

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

@@ -1,4 +1,4 @@
-package org.toop.game.players;
+package org.toop.game.players.ai;
 
 import org.toop.framework.gameFramework.GameState;
 import org.toop.framework.gameFramework.model.game.PlayResult;

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

@@ -1,4 +1,4 @@
-package org.toop.game.players;
+package org.toop.game.players.ai;
 
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 import org.toop.framework.gameFramework.model.player.AbstractAI;