Simultaneous Move support

.gitignore

@@ -41,5 +41,6 @@ src/main/java/META-INF/MANIFEST.MF
 
 src/pytag/env/
 metrics/out/*
+outputdir/*
 treeRecorder*
 .vscode/*

json/config/RunGames/CantStopExample.json

@@ -1,9 +1,9 @@
 {
-  "game" : "CantStop",
+  "game" : "SushiGo",
   "nPlayers" : 3,
   "playerDirectory" : "CantStop_Agents/3P",
   "mode" : "random",
-  "matchups" : 1000,
+  "matchups" : 100,
   "verbose" : false,
   "listener" : "GameResultsListener.json",
   "destDir" : "SkillGrid_CantStop_3P",

json/config/RunGames/backwards_comp_test.json

@@ -0,0 +1,10 @@
+{
+  "game" : "SushiGo",
+  "nPlayers" : 2,
+  "mode" : "random",
+  "matchups" : 1000,
+  "verbose" : true,
+  "seed" : 740234,
+  "listener" : "json/listeners/basiclistener.json",
+  "destDir" : "outputdir"
+}

src/main/java/core/AbstractForwardModel.java

@@ -3,6 +3,7 @@
 import core.actions.AbstractAction;
 import core.actions.ActionSpace;
 import core.actions.DoNothing;
+import core.actions.SimultaneousAction;
 import core.interfaces.IPlayerDecorator;
 import utilities.ActionTreeNode;
 import utilities.ElapsedCpuChessTimer;
@@ -22,7 +23,7 @@ public AbstractForwardModel() {
     }
 
     /**
-     * Combines both super class and sub class setup methods. Called from the game loop.
+     * Combines both super class and subclass setup methods. Called from the game loop.
      *
      * @param firstState - initial state.
      */
@@ -73,12 +74,20 @@ protected void abstractSetup(AbstractGameState firstState) {
      *
      * @return - List of AbstractAction objects.
      */
+    protected List<AbstractAction> _computeAvailableActions(AbstractGameState gameState, int activePlayer) {
+        return _computeAvailableActions(gameState);
+    }
+
     protected abstract List<AbstractAction> _computeAvailableActions(AbstractGameState gameState);
 
     protected List<AbstractAction> _computeAvailableActions(AbstractGameState gameState, ActionSpace actionSpace) {
         return _computeAvailableActions(gameState);
     }
 
+    protected List<AbstractAction> _computeAvailableActions(AbstractGameState gameState, ActionSpace actionSpace, int activePlayer) {
+        return _computeAvailableActions(gameState, activePlayer);
+    }
+
     protected abstract void endPlayerTurn(AbstractGameState state);
 
     /**
@@ -131,9 +140,17 @@ public final void setup(AbstractGameState gameState) {
      */
     public final void next(AbstractGameState currentState, AbstractAction action) {
         if (action != null) {
-            int player = currentState.getCurrentPlayer();
-            currentState.recordAction(action, player);
+            if (action instanceof SimultaneousAction sa) {
+                for (Map.Entry<Integer, AbstractAction> entry : sa.getPlayerActions().entrySet()) {
+                    currentState.recordAction(entry.getValue(), entry.getKey());
+                }
+            } else {
+                int player = currentState.getCurrentPlayer();
+                currentState.recordAction(action, player);
+            }
+
             _next(currentState, action);
+
         } else {
             if (currentState.coreGameParameters.verbose) {
                 System.out.println("Invalid action.");
@@ -154,14 +171,23 @@ public final List<AbstractAction> computeAvailableActions(AbstractGameState game
     }
 
     public final List<AbstractAction> computeAvailableActions(AbstractGameState gameState, ActionSpace actionSpace) {
+        return computeAvailableActions(gameState, actionSpace, gameState.getCurrentPlayer());
+    }
+
+    public final List<AbstractAction> computeAvailableActions(AbstractGameState gameState, ActionSpace actionSpace, int activePlayer) {
         // If there is an action in progress (see IExtendedSequence), then delegate to that
         List<AbstractAction> retValue;
         if (gameState.isActionInProgress()) {
-            retValue = gameState.actionsInProgress.peek()._computeAvailableActions(gameState, actionSpace);
+            // we call appropriate method depending on the actionSpace and move simultaneity
+            if (actionSpace != null && !actionSpace.isDefault()) {
+                retValue = gameState.actionsInProgress.peek()._computeAvailableActions(gameState, actionSpace, activePlayer);
+            } else {
+                retValue = gameState.getActionsInProgress().peek()._computeAvailableActions(gameState, activePlayer);
+            }
         } else if (actionSpace != null && !actionSpace.isDefault()) {
-            retValue = _computeAvailableActions(gameState, actionSpace);
+            retValue = _computeAvailableActions(gameState, actionSpace, activePlayer);
         } else {
-            retValue = _computeAvailableActions(gameState);
+            retValue = _computeAvailableActions(gameState, activePlayer);
         }
         return retValue;
     }

src/main/java/core/AbstractGameState.java

@@ -132,9 +132,20 @@ public final AbstractParameters getGameParameters() {
      * in child classes if relevant to the game
      */
     public int getTeam(int player) { return player;}
+
     public int getCurrentPlayer() {
         return isActionInProgress() ? actionsInProgress.peek().getCurrentPlayer(this) : turnOwner;
     }
+
+    /**
+     * This method returns a list of the players in a game state that has simultaneous moves
+     */
+    public List<Integer> getCurrentSimultaneousPlayers(){
+        return isActionInProgress() ?
+                actionsInProgress.peek().getCurrentSimultaneousPlayers(this) :
+                Collections.singletonList(getCurrentPlayer());
+    }
+
     public final CoreConstants.GameResult[] getPlayerResults() {return playerResults;}
     public final Set<Integer> getWinners() {
         Set<Integer> winners = new HashSet<>();
@@ -160,10 +171,6 @@ public final GameType getGameType() {
         return gameType;
     }
 
-
-    protected void setHistoryAt(int index, Pair<Integer, AbstractAction> action) {
-        history.set(index, action);
-    }
     /**
      * @return All actions that have been executed on this state since reset()/initialisation
      */
@@ -334,6 +341,9 @@ public final AbstractGameState copy(int playerId) {
             s.playerTimer[i] = playerTimer[i].copy();
         }
 
+        if (playerId != -1 && coreGameParameters.partialObservable) {
+            s.redeterminise(playerId);
+        }
         // Update the list of components for ID matching in actions.
         s.addAllComponents();
         return s;
@@ -349,6 +359,13 @@ protected final void recordAction(AbstractAction action, int player) {
         historyText.add("Player " + player + " : " + action.getString(this));
     }
 
+    /**
+     * Override with logic to redeterminise the game state from the perspective of the specified player
+     * @param playerId
+     */
+    public void redeterminise(int playerId) {
+        // do nothing as the default
+    }
 
     // helper function to avoid time-consuming string manipulations if the message is not actually
     // going to be logged anywhere