SeaSaltPaper pull request

json/seasaltpaper/mcts-seasalt-128ms.json

@@ -0,0 +1,28 @@
+{
+	"class" : "players.mcts.MCTSParams",
+	"budgetType" : "BUDGET_TIME",
+	"budget" : 128,
+	"breakMS" : 0,
+	"K" : [0.1, 1.0, 3.0, 5.0],
+	"rolloutLength" : [0, 10, 15, 30, 50],
+	"maxTreeDepth" : [1, 3, 5, 15],
+	"rolloutTermination" : "DEFAULT",
+	"information" : "Open_Loop",
+	"selectionPolicy" : ["SIMPLE", "ROBUST"],
+	"treePolicy" : ["UCB","UCB_Tuned"],
+	"opponentTreePolicy" : ["OneTree", "MultiTree", "SelfOnly"],
+	"heuristic" : [
+		{
+			"class" : "games.seasaltpaper.heuristics.LeadHeuristic"
+		},
+		{
+			"class" : "games.seasaltpaper.heuristics.ScoreAndHandHeuristic"
+		}
+	],
+	"exploreEpsilon" : [0.03, 0.1, 0.3],
+	"expansionPolicy" :"RANDOM",
+	"rolloutType" : "RANDOM",
+	"biasVisits" : 0,
+	"progressiveWideningConstant" : 0.0,
+	"progressiveWideningExponent" : 0.2
+}

json/seasaltpaper/mcts-seasalt-64ms.json

@@ -0,0 +1,28 @@
+{
+	"class" : "players.mcts.MCTSParams",
+	"budgetType" : "BUDGET_TIME",
+	"budget" : 64,
+	"breakMS" : 0,
+	"K" : [0.1, 1.0, 3.0, 5.0],
+	"rolloutLength" : [0, 10, 15, 30, 50],
+	"maxTreeDepth" : [1, 3, 5, 15],
+	"rolloutTermination" : "DEFAULT",
+	"information" : "Open_Loop",
+	"selectionPolicy" : ["SIMPLE", "ROBUST"],
+	"treePolicy" : ["UCB","UCB_Tuned"],
+	"opponentTreePolicy" : ["OneTree", "MultiTree", "SelfOnly"],
+	"heuristic" : [
+		{
+			"class" : "games.seasaltpaper.heuristics.LeadHeuristic"
+		},
+		{
+			"class" : "games.seasaltpaper.heuristics.ScoreAndHandHeuristic"
+		}
+	],
+	"exploreEpsilon" : [0.03, 0.1, 0.3],
+	"expansionPolicy" :"RANDOM",
+	"rolloutType" : "RANDOM",
+	"biasVisits" : 0,
+	"progressiveWideningConstant" : 0.0,
+	"progressiveWideningExponent" : 0.2
+}

json/seasaltpaper/paramsearch.json

@@ -0,0 +1,15 @@
+{
+  "game": "SeaSaltPaper",
+  "destDir": "param-optimisation/",
+  "repeats": 5,
+  "iterations": 100,
+  "evalGames": 20,
+  "matchups": 50,
+  "samplingRate": 1,
+  "neighbourhood": 100,
+  "evalMethod": "Heuristic",
+  "nPlayers": 4,
+  "output": "results_optimisation_mcts64ms.txt",
+  "searchSpace": "json/seasaltpaper/mcts-seasalt-64ms.json",
+  "verbose": true
+}

src/main/java/core/AbstractGameStateContainer.java

@@ -0,0 +1,69 @@
+package core;
+
+import core.AbstractGameState;
+import core.AbstractParameters;
+import core.CoreConstants;
+import core.CoreParameters;
+import core.actions.AbstractAction;
+import core.components.Area;
+import core.interfaces.IExtendedSequence;
+import core.interfaces.IGamePhase;
+import evaluation.listeners.IGameListener;
+import games.GameType;
+import utilities.ElapsedCpuChessTimer;
+import utilities.Pair;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+
+public abstract class AbstractGameStateContainer {
+    // Parameters, forward model and turn order for the game
+//    public final AbstractParameters gameParameters;
+    // Game being played
+    public final GameType gameType;
+
+    // Game tick, number of iterations of game loop
+    public final int tick;
+
+    // Migrated from TurnOrder...may move later
+    public final int roundCounter, turnCounter, turnOwner, firstPlayer;
+    public final int nPlayers;
+    public final int nTeams;
+
+    // Timers for all players
+//    protected ElapsedCpuChessTimer[] playerTimer;
+
+    // Status of the game, and status for each player (in cooperative games, the game status is also each player's status)
+    public final CoreConstants.GameResult gameStatus;
+    public final CoreConstants.GameResult[] playerResults;
+    // Current game phase
+//    protected IGamePhase gamePhase;
+    // Stack for extended actions
+//    public final CoreParameters coreGameParameters;
+
+    // A record of all actions taken to reach this game state
+    // The history is stored as a list of pairs, where the first element is the player who took the action
+    // this is in chronological order
+//    public final List<Pair<Integer, AbstractAction>> history;
+    public final List<String> historyText;
+
+    protected AbstractGameStateContainer(AbstractGameState gs) {
+        this.gameType = gs.getGameType();
+
+        this.tick = gs.getGameTick();
+        this.roundCounter = gs.getRoundCounter();
+        this.turnCounter = gs.getTurnCounter();
+        this.turnOwner = gs.getTurnOwner();
+
+        this.firstPlayer = gs.getFirstPlayer();
+        this.nPlayers = gs.getNPlayers();
+        this.nTeams = gs.getNTeams();
+
+        this.gameStatus = gs.getGameStatus();
+        this.playerResults = gs.getPlayerResults();
+
+//        this.history = gs.getHistory();
+        this.historyText = gs.getHistoryAsText();
+    }
+}

src/main/java/core/Game.java

@@ -9,6 +9,9 @@
 import evaluation.metrics.Event;
 import evaluation.summarisers.TAGNumericStatSummary;
 import games.GameType;
+import games.seasaltpaper.heuristics.LeadHeuristic;
+import games.seasaltpaper.heuristics.ScoreAndHandHeuristic;
+import games.seasaltpaper.heuristics.ScoreHeuristic;
 import games.pandemic.PandemicForwardModel;
 import gui.AbstractGUIManager;
 import gui.GUI;
@@ -17,10 +20,13 @@
 import players.human.ActionController;
 import players.human.HumanConsolePlayer;
 import players.human.HumanGUIPlayer;
+import players.mcts.MCTSEnums;
 import players.mcts.MCTSParams;
 import players.mcts.MCTSPlayer;
+import players.rhea.RHEAPlayer;
 import players.rmhc.RMHCParams;
 import players.rmhc.RMHCPlayer;
+import players.simple.FirstActionPlayer;
 import players.simple.OSLAPlayer;
 import players.simple.RandomPlayer;
 import utilities.Pair;
@@ -691,28 +697,34 @@ public String toString() {
      * and then run this class.
      */
     public static void main(String[] args) {
-        String gameType = Utils.getArg(args, "game", "Chess");
+        String gameType = Utils.getArg(args, "game", "SeaSaltPaper");
         boolean useGUI = Utils.getArg(args, "gui", true);
         int turnPause = Utils.getArg(args, "turnPause", 0);
         long seed = Utils.getArg(args, "seed", System.currentTimeMillis());
         ActionController ac = new ActionController();
 
         /* Set up players for the game */
         ArrayList<AbstractPlayer> players = new ArrayList<>();
+
+//        players.add(new MCTSPlayer());
+//        players.add(new HumanConsolePlayer());
+//        players.add(new HumanConsolePlayer());
+//        players.add(new RandomPlayer());
+//        players.add(new RandomPlayer());
         players.add(new RandomPlayer());
         players.add(new RandomPlayer());
-    //    players.add(new BasicMCTSPlayer());
-//        players.add(new OSLAPlayer());
-//        players.add(new RMHCPlayer());
-        // players.add(new HumanGUIPlayer(ac));
+//        players.add(new HumanGUIPlayer(ac));
+        players.add(new BasicMCTSPlayer());
+        players.add(new BasicMCTSPlayer());
+//        players.add(new BasicMCTSPlayer());
+//        players.add(new BasicMCTSPlayer());
 
 
         /* Game parameter configuration. Set to null to ignore and use default parameters */
         String gameParams = null;
 
         /* Run! */
         runOne(GameType.valueOf(gameType), gameParams, players, seed, false, null, useGUI ? ac : null, turnPause);
-    }
-
 
+    }
 }

src/main/java/core/components/PartialObservableDeck.java

@@ -48,7 +48,7 @@ public PartialObservableDeck(String id, int ownerID, int nPlayers, VisibilityMod
         }
     }
 
-    private PartialObservableDeck(String name, int ownerID, boolean[] defaultVisibility, int ID) {
+    protected PartialObservableDeck(String name, int ownerID, boolean[] defaultVisibility, int ID) {
         super(name, ownerID, ID, VisibilityMode.MIXED_VISIBILITY);
         this.deckVisibility = defaultVisibility;
     }

src/main/java/evaluation/tournaments/RoundRobinTournament.java

@@ -257,6 +257,7 @@ public void createAndRunMatchUp(List<Integer> matchUp) {
                 // In the RANDOM case we use a new seed for each game
                 PermutationCycler idStream = new PermutationCycler(agents.size(), seedRnd, nTeams);
                 for (int i = 0; i < totalGameBudget; i++) {
+                    // System.out.println("Playing game " + (i+1) + " out of " + totalGameBudget);
                     List<Integer> matchup = new ArrayList<>(nTeams);
                     for (int j = 0; j < nTeams; j++)
                         matchup.add(idStream.getAsInt());

src/main/java/games/GameType.java

@@ -103,6 +103,10 @@
 import games.resistance.ResGameState;
 import games.resistance.ResParameters;
 import games.resistance.gui.ResGUIManager;
+import games.seasaltpaper.SeaSaltPaperForwardModel;
+import games.seasaltpaper.SeaSaltPaperGameState;
+import games.seasaltpaper.SeaSaltPaperParameters;
+import games.seasaltpaper.gui.SSPGUIManager;
 import games.root.RootForwardModel;
 import games.root.RootGameState;
 import games.root.RootParameters;
@@ -213,6 +217,10 @@ public enum GameType {
             Arrays.asList(Cards, Deduction, Renaissance),
             Arrays.asList(HandManagement, PlayerElimination),
             LoveLetterGameState.class, LoveLetterForwardModel.class, LoveLetterParameters.class, LoveLetterGUIManager.class),
+    SeaSaltPaper(2, 4,
+            Arrays.asList(Cards, Deduction),
+            Arrays.asList(HandManagement, SetCollection),
+            SeaSaltPaperGameState.class, SeaSaltPaperForwardModel.class, SeaSaltPaperParameters.class, SSPGUIManager.class),
     Uno(2, 10,
             Arrays.asList(Cards, ComicBook, Number, MoviesTVRadio),
             Arrays.asList(HandManagement, LoseATurn, TakeThat),

src/main/java/games/seasaltpaper/SSPGameStateContainer.java

@@ -0,0 +1,31 @@
+package games.seasaltpaper;
+
+import core.AbstractGameStateContainer;
+import core.components.Deck;
+import core.components.PartialObservableDeck;
+import games.seasaltpaper.cards.SeaSaltPaperCard;
+
+import java.util.List;
+
+public class SSPGameStateContainer extends AbstractGameStateContainer {
+    public final List<PartialObservableDeck<SeaSaltPaperCard>> playerHands;
+    public final List<Deck<SeaSaltPaperCard>> playerDiscards;
+    public final Deck<SeaSaltPaperCard> discardPile1, discardPile2;
+    public final Deck<SeaSaltPaperCard> drawPile;
+    public final int lastChance; // index of the player that play "lastChance", -1 for no one
+    public final boolean[] protectedHands;
+    public final int[] playerTotalScores; // player points of previous rounds
+
+
+    public SSPGameStateContainer(SeaSaltPaperGameState gs) {
+        super(gs);
+        this.playerHands = gs.getPlayerHands();
+        this.playerDiscards = gs.getPlayerDiscards();
+        this.discardPile1 = gs.getDiscardPile1();
+        this.discardPile2 = gs.getDiscardPile2();
+        this.drawPile = gs.getDrawPile();
+        this.lastChance = gs.lastChance;
+        this.protectedHands = gs.getProtectedHands();
+        this.playerTotalScores = gs.playerTotalScores;
+    }
+}