graph-games-proto 0.3.2125__py3-none-any.whl → 0.3.2225__py3-none-any.whl

graph_games_proto/__init__.py

@@ -1,3 +1,3 @@
 # __init__.py
 from .main import hello
-from .fns import isterminal, getfinalscores, get_deadlines, get_longest_path_length, get_max_allotted_times, get_legal_actions_for_path, find_player_with_longest_path, calc_player_graph, get_edges, FrozenDek, QValueLearningPolicy, Action2, getnextstate2, isactionlegal2, LegalAction, Fig, RandoPolicy, StaticBoardConfig, autoplay, getpublicstate, generate_cards, PublicState, State, Fig, getprivatescore, get_qvalue_trajectories, PlayerState, initfig, initboardconfig, gettoplay, printstate, getinitialstate, Card, PrivateState, getprivatestate, printaction, json_serializer, getrng, FrozenBoardConfig, initgameconfig, GameConfig
+from .fns import getpublicgameconfig, alpha0, isterminal, getfinalscores, get_deadlines, get_longest_path_length, get_max_allotted_times, get_legal_actions_for_path, find_player_with_longest_path, calc_player_graph, get_edges, FrozenDek, QValueLearningPolicy, Action2, getnextstate2, isactionlegal2, LegalAction, Fig, RandoPolicy, StaticBoardConfig, autoplay, getpublicstate, generate_cards, PublicState, State, Fig, getprivatescore, get_qvalue_trajectories, PlayerState, initfig, initboardconfig, gettoplay, printstate, getinitialstate, Card, PrivateState, getprivatestate, printaction, json_serializer, getrng, FrozenBoardConfig, initgameconfig, GameConfig

graph_games_proto/fns.py

@@ -932,78 +932,80 @@ class Fig(PClass):
     # TODO: the two fields below should just be a "StaticBoardConfig" object
     static_board_config_uuid = field(type=str)
     board_config = field(type=FrozenBoardConfig)
-    path_scores = field(type=list)  # List[int]
-    # graph = field(type=int)
-    # path_scores = field(type=int)
-    # graph: BoardGraph
-    # path_scores: List[int]
+    carduuid2card = field(type=dict)  # Dict[str, Card]
     def __todict__(self):
         return {
             "static_board_config_uuid": self.static_board_config_uuid,
             "board_config": self.board_config.__todict__(),
-            "path_scores": self.path_scores,
+            "carduuid2card": {k: v.__todict__() for k, v in self.carduuid2card.items()},
         }
     @staticmethod
     def __fromdict__(d):
         return initfig(
             d["static_board_config_uuid"], 
             FrozenBoardConfig.__fromdict__(d["board_config"]),
+            carduuid2card={k: Card.__fromdict__(v) for k, v in d["carduuid2card"].items()},
         )
 
 
 @dispatch(str, FrozenBoardConfig)
 def initfig(static_board_config_uuid, board_config):
+    carduuid2card = {}
+    for dek in board_config.deks:
+        cards = generate_cards(dek)
+        for card in cards:
+            carduuid2card[card.uuid] = card
     return Fig(
         static_board_config_uuid=static_board_config_uuid,
         board_config=board_config,
-        path_scores=getfrozenpathscores(board_config),
+        carduuid2card=carduuid2card,
     )
 
 
-class GameConfig(PClass):
+class PublicGameConfig(PClass):
     uuid = field(type=str)
     started_at = field(type=str)
     num_players = field(type=int)
     fig = field(type=Fig)
-    seed = field(type=int) 
     def __todict__(self):
         return {
             "uuid": self.uuid,
             "started_at": self.started_at,
             "num_players": self.num_players,
             "fig": self.fig.__todict__(),
-            "seed": self.seed,
         }
     @staticmethod
     def __fromdict__(d):
-        return GameConfig(
+        return PublicGameConfig(
             uuid=d["uuid"],
             started_at=d["started_at"],
             num_players=d["num_players"],
             fig=Fig.__fromdict__(d["fig"]),
-            seed=d["seed"]
         )
-    
 
-class PublicGameConfig(PClass):
+
+class GameConfig(PClass):
     uuid = field(type=str)
     started_at = field(type=str)
     num_players = field(type=int)
     fig = field(type=Fig)
+    seed = field(type=int) 
     def __todict__(self):
         return {
             "uuid": self.uuid,
             "started_at": self.started_at,
             "num_players": self.num_players,
             "fig": self.fig.__todict__(),
+            "seed": self.seed,
         }
     @staticmethod
     def __fromdict__(d):
-        return PublicGameConfig(
+        return GameConfig(
             uuid=d["uuid"],
             started_at=d["started_at"],
             num_players=d["num_players"],
             fig=Fig.__fromdict__(d["fig"]),
+            seed=d["seed"]
         )
 
 
@@ -1161,30 +1163,136 @@ class PrivateState(PClass):
         )
 
 
+class FaceupCardStack(PClass):
+    cards = field(type=list)  # List[Card]
+    def __todict__(self):
+        return {
+            "cards": self.cards,
+        }
+    @staticmethod
+    def __fromdict__(d):
+        return FaceupCardStack(
+            cards=d["cards"],
+        )
+
+
+class FacedownCardStack(PClass):
+    cards = field(type=list)  # List[Card]
+    def __todict__(self):
+        return {
+            "cards": self.cards,
+        }
+    @staticmethod
+    def __fromdict__(d):
+        return FaceupCardStack(
+            cards=d["cards"],
+        )
+
+
+class PublicFacedownCardStack(PClass):
+    num_cards = field(type=int)
+    def __todict__(self):
+        return {
+            "num_cards": self.num_cards,
+        }
+    @staticmethod
+    def __fromdict__(d):
+        return PublicFacedownCardStack(
+            num_cards=d["num_cards"],
+        )
+
+
+class FaceupCardSpread(PClass):
+    spots = field(type=list)  # List[Card|None]
+    def __todict__(self):
+        return {
+            "spots": self.spots,
+        }
+    @staticmethod
+    def __fromdict__(d):
+        return FaceupCardSpread(
+            spots=d["spots"],
+        )
+
+
+class FacedownCardSpread(PClass):
+    spots = field(type=list)  # List[Card|None]
+    def __todict__(self):
+        return {
+            "spots": self.spots,
+        }
+    @staticmethod
+    def __fromdict__(d):
+        return FacedownCardSpread(
+            spots=d["spots"],
+        )
+
+
+class PublicFacedownCardSpread(PClass):
+    spots = field(type=list)  # List[bool]  # True if card is present, False if empty
+    def __todict__(self):
+        return {
+            "spots": self.spots,
+        }
+    @staticmethod
+    def __fromdict__(d):
+        return PublicFacedownCardSpread(
+            spots=d["spots"],
+        )
+
+
 class PublicDeck(PClass):
     idx = field(type=int)
     uuid = field(type=str)
-    facedown_stack_len = field(type=int)
-    discard_len = field(type=int)
-    faceup_spots = field(type=list)  # List[Card]
+    all_cards = field(type=list)  # List[str]
+    faceup_stack = field(type=(FaceupCardStack, type(None)), initial=None)
+    faceup_spread = field(type=(FaceupCardSpread, type(None)), initial=None)
+    facedown_stack = field(type=(PublicFacedownCardStack, type(None)), initial=None)
+    facedown_spread = field(type=(PublicFacedownCardSpread, type(None)), initial=None)
+    discard_faceup_stack = field(type=(FaceupCardStack, type(None)), initial=None)
+    discard_facedown_stack = field(type=(PublicFacedownCardStack, type(None)), initial=None)
     def __todict__(self):
         return {
             "idx": self.idx,
             "uuid": self.uuid,
-            "facedown_stack_len": self.facedown_stack_len,
-            "discard_len": self.discard_len,
-            "faceup_spots": self.faceup_spots,
+            'all_cards': self.all_cards,
+            "faceup_stack": self.faceup_stack.__todict__() if self.faceup_stack else None,
+            "faceup_spread": self.faceup_spread.__todict__() if self.faceup_spread else None,
+            "facedown_stack": self.facedown_stack.__todict__() if self.facedown_stack else None,
+            "facedown_spread": self.facedown_spread.__todict__() if self.facedown_spread else None,
+            "discard_faceup_stack": self.discard_faceup_stack.__todict__() if self.discard_faceup_stack else None,
+            "discard_facedown_stack": self.discard_facedown_stack.__todict__() if self.discard_facedown_stack else None,
         }
     @staticmethod
     def __fromdict__(d):
         return PublicDeck(
             idx=d["idx"],
             uuid=d["uuid"],
-            facedown_stack_len=d["facedown_stack_len"],
-            discard_len=d["discard_len"],
-            faceup_spots=d["faceup_spots"],
+            all_cards=d["all_cards"],
+            faceup_stack=FaceupCardStack.__fromdict__(d["faceup_stack"]) if d.get("faceup_stack") else None,
+            faceup_spread=FaceupCardSpread.__fromdict__(d["faceup_spread"]) if d.get("faceup_spread") else None,
+            facedown_stack=PublicFacedownCardStack.__fromdict__(d["facedown_stack"]) if d.get("facedown_stack") else None,
+            facedown_spread=PublicFacedownCardSpread.__fromdict__(d["facedown_spread"]) if d.get("facedown_spread") else None,
+            discard_faceup_stack=FaceupCardStack.__fromdict__(d["discard_faceup_stack"]) if d.get("discard_faceup_stack") else None,
+            discard_facedown_stack=PublicFacedownCardStack.__fromdict__(d["discard_facedown_stack"]) if d.get("discard_facedown_stack") else None,
         )
     
+def print_public_deck_stats(deck):
+    print("Deck idx:", deck.idx)
+    print("Total cards in deck:", len(deck.all_cards))
+    if deck.faceup_stack:
+        print("Faceup stack cards:", len(deck.faceup_stack.cards))
+    if deck.faceup_spread:
+        print("Faceup spread cards:", sum(1 for card in deck.faceup_spread.spots if card is not None))
+    if deck.facedown_stack:
+        print("Facedown stack cards:", deck.facedown_stack.num_cards)
+    if deck.facedown_spread:
+        print("Facedown spread cards:", sum(1 for present in deck.facedown_spread.spots if present))
+    if deck.discard_faceup_stack:
+        print("Discard faceup stack cards:", len(deck.discard_faceup_stack.cards))
+    if deck.discard_facedown_stack:
+        print("Discard facedown stack cards:", deck.discard_facedown_stack.num_cards)
+    
 
 class LegalActionKeep(PClass):
     deck_idx = field(type=int)
@@ -1207,15 +1315,7 @@ class LegalActionKeep(PClass):
         )
     @staticmethod
     def get_default_action(legal_action, state, submitted_at):
-        discard_tray = state.players[legal_action.player_idx].discard_tray
-        deck_idx = legal_action.keep.deck_idx
-        card_uuids_matching_deck = [
-            card_uuid for card_uuid in discard_tray 
-            if state.kernel.carduuid2deckidx[card_uuid] == deck_idx
-        ]
-        num_cards = len(card_uuids_matching_deck)
         actual_min = 0 if legal_action.keep.min is None else legal_action.keep.min
-        # actual_max = num_cards if legal_action.keep.max is None else min(legal_action.keep.max, num_cards)
         return Action2(
             submitted_at=submitted_at,
             legal_action=legal_action,
@@ -1246,22 +1346,12 @@ class LegalActionDiscard(PClass):
         )
     @staticmethod
     def get_default_action(legal_action, state, submitted_at):
-        discard_tray = state.players[legal_action.player_idx].discard_tray
-        deck_idx = legal_action.discard.deck_idx
-        card_uuids_matching_deck = [
-            card_uuid for card_uuid in discard_tray 
-            if state.kernel.carduuid2deckidx[card_uuid] == deck_idx
-        ]
-        num_cards = len(card_uuids_matching_deck)
         actual_min = 0 if legal_action.discard.min is None else legal_action.discard.min
-        actual_max = num_cards if legal_action.discard.max is None else min(legal_action.discard.max, num_cards)
-        rand_num_chosen = state.kernel.rng.randint(actual_min, actual_max)
-        card_uuids = card_uuids_matching_deck[0:rand_num_chosen]
         return Action2(
             submitted_at=submitted_at,
             legal_action=legal_action,
             discard=ActionDiscard(
-                card_uuids=card_uuids
+                discard_tray_idxs=list(range(actual_min)), 
             )
         )
 
@@ -1663,52 +1753,21 @@ class Action2(PClass):
         )
 
 
-class CardStack(PClass):
-    hidden = field(type=bool)
-    cards = field(type=list)  # List[Card]
-    def __todict__(self):
-        return {
-            "hidden": self.hidden,
-            "cards": self.cards,
-        }
-    @staticmethod
-    def __fromdict__(d):
-        return CardStack(
-            hidden=d["hidden"],
-            cards=d["cards"],
-        )
-
-
-class CardSpread(PClass):
-    hidden = field(type=bool)
-    spots = field(type=list)  # List[Card|None]
-    def __todict__(self):
-        return {
-            "hidden": self.hidden,
-            "spots": self.spots,
-        }
-    @staticmethod
-    def __fromdict__(d):
-        return CardSpread(
-            hidden=d["hidden"],
-            spots=d["spots"],
-        )
-
-
-
 class Deck(PClass):
     idx = field(type=int)
     uuid = field(type=str)
-    faceup_stack = field(type=(CardStack, type(None)), initial=None)
-    faceup_spread = field(type=(CardSpread, type(None)), initial=None)
-    facedown_stack = field(type=(CardStack, type(None)), initial=None)
-    facedown_spread = field(type=(CardSpread, type(None)), initial=None)
-    discard_faceup_stack = field(type=(CardStack, type(None)), initial=None)
-    discard_facedown_stack = field(type=(CardStack, type(None)), initial=None)
+    all_cards = field(type=list)  # List[str]
+    faceup_stack = field(type=(FaceupCardStack, type(None)), initial=None)
+    faceup_spread = field(type=(FaceupCardSpread, type(None)), initial=None)
+    facedown_stack = field(type=(FacedownCardStack, type(None)), initial=None)
+    facedown_spread = field(type=(FacedownCardSpread, type(None)), initial=None)
+    discard_faceup_stack = field(type=(FaceupCardStack, type(None)), initial=None)
+    discard_facedown_stack = field(type=(FacedownCardStack, type(None)), initial=None)
     def __todict__(self):
         return {
             "idx": self.idx,
             "uuid": self.uuid,
+            'all_cards': self.all_cards,
             "faceup_stack": self.faceup_stack.__todict__() if self.faceup_stack else None,
             "faceup_spread": self.faceup_spread.__todict__() if self.faceup_spread else None,
             "facedown_stack": self.facedown_stack.__todict__() if self.facedown_stack else None,
@@ -1721,28 +1780,32 @@ class Deck(PClass):
         return Deck(
             idx=d["idx"],
             uuid=d["uuid"],
-            faceup_stack=CardStack.__fromdict__(d["faceup_stack"]) if d.get("faceup_stack") else None,
-            faceup_spread=CardSpread.__fromdict__(d["faceup_spread"]) if d.get("faceup_spread") else None,
-            facedown_stack=CardStack.__fromdict__(d["facedown_stack"]) if d.get("facedown_stack") else None,
-            facedown_spread=CardSpread.__fromdict__(d["facedown_spread"]) if d.get("facedown_spread") else None,
-            discard_faceup_stack=CardStack.__fromdict__(d["discard_faceup_stack"]) if d.get("discard_faceup_stack") else None,
-            discard_facedown_stack=CardStack.__fromdict__(d["discard_facedown_stack"]) if d.get("discard_facedown_stack") else None,
+            all_cards=d["all_cards"],
+            faceup_stack=FaceupCardStack.__fromdict__(d["faceup_stack"]) if d.get("faceup_stack") else None,
+            faceup_spread=FaceupCardSpread.__fromdict__(d["faceup_spread"]) if d.get("faceup_spread") else None,
+            facedown_stack=FaceupCardStack.__fromdict__(d["facedown_stack"]) if d.get("facedown_stack") else None,
+            facedown_spread=FaceupCardSpread.__fromdict__(d["facedown_spread"]) if d.get("facedown_spread") else None,
+            discard_faceup_stack=FaceupCardStack.__fromdict__(d["discard_faceup_stack"]) if d.get("discard_faceup_stack") else None,
+            discard_facedown_stack=FaceupCardStack.__fromdict__(d["discard_facedown_stack"]) if d.get("discard_facedown_stack") else None,
         )
 
 
 class CandidateDeck(PClass):
     deck_idx = field(type=int)
-    candidates = field(type=list)  # List[Card]
+    candidates = field(type=list)  # List[str]
+    notes = field(type=list)  # List[str]
     def __todict__(self):
         return {
             'deck_idx': self.deck_idx,
-            'candidates': [card.__todict__() for card in self.candidates],
+            'candidates': self.candidates,
+            'notes': self.notes,
         }
     @staticmethod
     def __fromdict__(d):
         return CandidateDeck(
             deck_idx=d["deck_idx"],
-            candidates=[Card.__fromdict__(card) for card in d["candidates"]],
+            candidates=d["candidates"],
+            notes=d["notes"],
         )    
 
 
@@ -2134,12 +2197,9 @@ class StateKernel(PClass):
     history = field(type=list)  # List[Action2]
     pieceuuid2piece = field(type=dict)  # Dict[str, Piece]
     edgeuuid2idx = field(type=dict)  # Dict[str, int]
-    carduuid2card = field(type=dict)  # Dict[str, Card]
     edgetuple2uuid = field(type=dict)  # Dict[Tuple[int, int], str]
     nodeuuid2idx = field(type=dict)  # Dict[str, int]
-    carduuid2deckidx = field(type=dict)  # Dict[str, int]
     bonusuuid2bonusidx = field(type=dict)  # Dict[str, int]
-    starting_decks = field(type=list)  # List[Deck]
     starting_piles = field(type=list) # List[Pile]
     goals = field(type=list)  # List[FrozenGoal]
     last_to_play = field(type=(int, type(None)), initial=None)
@@ -2161,12 +2221,9 @@ class StateKernel(PClass):
             "idx2pathrecord": [v.__todict__() for v in self.idx2pathrecord],
             "pieceuuid2piece": {k: v.__todict__() for k, v in self.pieceuuid2piece.items()},
             "edgeuuid2idx": self.edgeuuid2idx,
-            "carduuid2card": {k: v.__todict__() for k, v in self.carduuid2card.items()},
             "edgetuple2uuid": [{"k": list(k), "v": v} for k, v in self.edgetuple2uuid.items()],
             "nodeuuid2idx": self.nodeuuid2idx,
-            "carduuid2deckidx": self.carduuid2deckidx,
             "bonusuuid2bonusidx": self.bonusuuid2bonusidx,
-            "starting_decks": [deck.__todict__() for deck in self.starting_decks],
             "starting_piles": [pile.__todict__() for pile in self.starting_piles],
             "goals": [goal.__todict__() for goal in self.goals],
             "last_to_play": self.last_to_play,
@@ -2190,12 +2247,9 @@ class StateKernel(PClass):
             idx2pathrecord=[Path2.__fromdict(v) for v in d["idx2pathrecord"]],
             pieceuuid2piece={k: Piece.__fromdict(v) for k, v in d["pieceuuid2piece"].items()},
             edgeuuid2idx=d["edgeuuid2idx"],
-            carduuid2card={k: Card.__fromdict(v) for k, v in d["carduuid2card"].items()},
             edgetuple2uuid={tuple(item["k"]): item["v"] for item in d["edgetuple2uuid"]},
             nodeuuid2idx=d["nodeuuid2idx"],
-            carduuid2deckidx=d["carduuid2deckidx"],
             bonusuuid2bonusidx=d["bonusuuid2bonusidx"],
-            starting_decks=[Deck.__fromdict__(x) for x in d["starting_decks"]],
             starting_piles=[Pile.__fromdict__(x) for x in d["starting_piles"]],
             goals=[FrozenGoal.__fromdict__(goal) for goal in d["goals"]],
             last_to_play=d.get("last_to_play"),
@@ -2225,14 +2279,6 @@ def init_state_kernel(game_config, **kwargs):
                 for piece in pieces:
                     pieceuuid2piece[piece.uuid] = piece
 
-    carduuid2deckidx = {}
-    carduuid2card = {}
-    for dek in board_config.deks:
-        cards = generate_cards(dek)
-        for card in cards:
-            carduuid2card[card.uuid] = card
-            carduuid2deckidx[card.uuid] = dek.idx
-
     starting_piles = []
     for piece_template in board_config.piece_templates:
         if piece_template.has_player:
@@ -2263,12 +2309,15 @@ def init_state_kernel(game_config, **kwargs):
     starting_decks = []
     for dek in board_config.deks:
         cards = generate_cards(dek)
+        all_card_uuids = [c.uuid for c in cards]
         deck_obj = Deck(
             uuid=dek.uuid,
             idx=dek.idx,
-            facedown_stack=CardStack(hidden=True, cards=[c.uuid for c in cards]),
-            faceup_spread=CardSpread(hidden=False, spots=[]),
-            discard_faceup_stack=CardStack(hidden=False, cards=[]),
+            all_cards=all_card_uuids,
+            facedown_stack=FacedownCardStack(cards=all_card_uuids),
+            faceup_spread=FaceupCardSpread(spots=[]),
+            discard_faceup_stack=FaceupCardStack(cards=[]),
+            discard_facedown_stack=FacedownCardStack(cards=[]),
         )
         starting_decks.append(deck_obj)
 
@@ -2291,13 +2340,10 @@ def init_state_kernel(game_config, **kwargs):
         uuid2segmentrecord=uuid2segmentrecord,
         idx2pathrecord=idx2pathrecord,
         edgeuuid2idx=edgeuuid2idx,
-        carduuid2card=carduuid2card,
         pieceuuid2piece=pieceuuid2piece,
         edgetuple2uuid=edgetuple2uuid,
         nodeuuid2idx=nodeuuid2idx,
-        carduuid2deckidx=carduuid2deckidx,
         bonusuuid2bonusidx=bonusuuid2bonusidx,
-        starting_decks=starting_decks,
         starting_piles=starting_piles,
         goals=goals,
         player_graphs_3=player_graphs_3,
@@ -2565,14 +2611,12 @@ class RemainingAllottedTime(PClass):
 
 
 class PublicState(PClass):
-    game_config = field(type=PublicGameConfig)
     deadlines = field(type=list)  # List[RemainingAllottedTime|None]
     game_started_at = field(type=str)
     allotted_times = field(type=list)
     all_pieces = field(type=list)  # List[Piece]
     to_play_2 = field(type=list)  # List[int]
     bonus_statuses = field(type=list)  # List[BonusStatus]
-    starting_decks = field(type=list)  # List[Deck]
     starting_piles = field(type=list)  # List[Pile]
     history = field(type=list)  # List[PublicAction]
     player_scores = field(type=list)  # List[PublicPlayerScore]
@@ -2590,14 +2634,12 @@ class PublicState(PClass):
     terminal = field(type=bool)
     def __todict__(self):
         return {
-            "game_config": self.game_config.__todict__(),
             "deadlines": [deadline.__todict__() if deadline else None for deadline in self.deadlines],
             "game_started_at": self.game_started_at,
             "allotted_times": [allotted_time.__todict__() if allotted_time else None for allotted_time in self.allotted_times], # List[AllottedTime|None]
             "all_pieces": [piece.__todict__() for piece in self.all_pieces],
             "to_play_2": self.to_play_2,
             "bonus_statuses": [bs.__todict__() for bs in self.bonus_statuses],
-            "starting_decks": [deck.__todict__() for deck in self.starting_decks],
             "starting_piles": [pile.__todict__() for pile in self.starting_piles],
             "history": [x.__todict__() for x in self.history],
             "player_scores": [x.__todict__() for x in self.player_scores],
@@ -2617,14 +2659,12 @@ class PublicState(PClass):
     @staticmethod
     def __fromdict__(d):
         return PublicState(
-            game_config=PublicGameConfig.__fromdict__(d["game_config"]),
             deadlines=[RemainingAllottedTime.__fromdict__(x) for x in d["deadlines"]],
             game_started_at=d["game_started_at"],
             allotted_times=[AllottedTime.__fromdict__(x) if x else None for x in d["allotted_times"]], # List[AllottedTime|None]
             all_pieces=[Piece.__fromdict__(x) for x in d["all_pieces"]],
             to_play_2=d["to_play_2"],
             bonus_statuses=[BonusStatus.__fromdict__(x) for x in d["bonus_statuses"]],
-            starting_decks=[Deck.__fromdict__(x) for x in d["starting_decks"]],
             starting_piles=[Pile.__fromdict__(x) for x in d["starting_piles"]],
             history=[PublicAction.__fromdict__(x) for x in d["history"]],
             player_scores=[PublicPlayerScore.__fromdict__(x) for x in d["player_scores"]],
@@ -2644,16 +2684,19 @@ class PublicState(PClass):
 
 
 class PlayerState(PClass):
+    game_config = field(type=PublicGameConfig)
     public = field(type=PublicState)
     private = field(type=PrivateState)
     def __todict__(self):
         return {
+            "game_config": self.game_config.__todict__(),
             "public": self.public.__todict__(),
             "private": self.private.__todict__()
         }
     @staticmethod
     def __fromdict__(d):
         return PlayerState(
+            game_config=PublicGameConfig.__fromdict__(d["game_config"]),
             public=PublicState.__fromdict__(d["public"]),
             private=PrivateState.__fromdict__(d["private"])
         )
@@ -3264,11 +3307,12 @@ def replenish_faceup_if_needed(kernel, deck_idx):
 def recycle_if_needed(kernel, deck_idx):
     deck = kernel.decks[deck_idx]
     if len(deck.facedown_stack.cards) == 0:
-        shuffled_discards = list(deck.discard_faceup_stack.cards)
+        shuffled_discards = list(deck.discard_faceup_stack.cards) + list(deck.discard_facedown_stack.cards)
         kernel.rng.shuffle(shuffled_discards)
         deck = deck.set(
-            facedown_stack=CardStack(hidden=True, cards=shuffled_discards),
-            discard_faceup_stack=CardStack(hidden=False, cards=[])
+            facedown_stack=FacedownCardStack(cards=shuffled_discards),
+            discard_faceup_stack=FaceupCardStack(cards=[]),
+            discard_facedown_stack=FacedownCardStack(cards=[]),
         )
         kernel = set_deck(kernel, deck.idx, deck)
     return kernel
@@ -3350,7 +3394,7 @@ def get_follow_up_draw_legal_actions(kernel, action):
 
             for card_uuid in kernel.decks[0].faceup_spread.spots:
                 if card_uuid:
-                    if not kernel.carduuid2card[card_uuid].is_wild:
+                    if not kernel.game_config.fig.carduuid2card[card_uuid].is_wild:
                         to_return.append(
                             LegalAction(
                                 player_idx=legal_action.player_idx,
@@ -3374,7 +3418,7 @@ def get_num_faceup_wilds(kernel, deck_idx):
     non_empty_spots = [spot for spot in deck.faceup_spread.spots if spot]
     if not non_empty_spots:
         return 0
-    return sum(1 for card_uuid in non_empty_spots if kernel.carduuid2card[card_uuid].is_wild)
+    return sum(1 for card_uuid in non_empty_spots if kernel.game_config.fig.carduuid2card[card_uuid].is_wild)
 
 
 @dispatch(StateKernel)
@@ -3395,10 +3439,15 @@ def discardfaceup_shuffle_flip(kernel, deck_idx):
     for faceup_spot in deck.faceup_spread.spots:
         if faceup_spot:
             deck.discard_faceup_stack.cards.append(faceup_spot)
-    deck = deck.set(faceup_spread=CardStack(hidden=False, cards=[]))
+    deck = deck.set(faceup_spread=FaceupCardStack(cards=[]))
     while len(deck.discard_faceup_stack.cards) > 0:
-        card = deck.discard_faceup_stack.cards.pop()
-        deck.facedown_stack.cards.append(card)
+        deck.facedown_stack.cards.append(
+            deck.discard_faceup_stack.cards.pop()
+        )
+    while len(deck.discard_facedown_stack.cards) > 0:
+        deck.facedown_stack.cards.append(
+            deck.discard_facedown_stack.cards.pop()
+        )
     deck = shuffle(kernel.rng, deck)
     kernel = set_deck(kernel, deck.idx, deck)
     kernel = flip_cards(kernel, deck.idx, num_faceup_spots)
@@ -3423,7 +3472,7 @@ def handle_faceup_draw_action(kernel, action):
     kernel = replenish_faceup_spot_if_needed(kernel, faceup_draw.deck_idx, spot_idx)
 
     # Prevent an extra draw if last draw was a face-wild-draw
-    # if not game.kernel.carduuid2card[drawn_card].is_wild:
+    # if not game.kernel.game_config.fig.carduuid2card[drawn_card].is_wild:
     #     # TODO: extract this out to user-defined function/hook
     #     game = append_follow_up_draw_legal_actions(game, action)
 
@@ -3643,7 +3692,7 @@ def handle_move_longest_path_card(kernel, action):
             player_with_card = find_player_with_longest_path_card(kernel)
             if player_with_card:
                 # Find the index of the card from the player's cards, then pop it
-                card_idx = next((i for i, card_uuid in enumerate(player_with_card.cards) if kernel.carduuid2card[card_uuid].deck_idx == 2), None)
+                card_idx = next((i for i, card_uuid in enumerate(player_with_card.cards) if kernel.game_config.fig.carduuid2card[card_uuid].deck_idx == 2), None)
                 if card_idx is not None:
                     longest_path_card = player_with_card.cards.pop(card_idx)
 
@@ -3659,7 +3708,7 @@ def handle_move_longest_path_card(kernel, action):
 
 def find_player_with_longest_path_card(game):
     for player in game.players:
-        if any(game.kernel.carduuid2card[card_uuid].deck_idx == 2 for card_uuid in player.cards):
+        if any(game.kernel.game_config.fig.carduuid2card[card_uuid].deck_idx == 2 for card_uuid in player.cards):
             return player
     return None
 
@@ -3703,7 +3752,7 @@ def handle_move_pieces_to_path_action(kernel, action):
             # Remove the card from player's cards
             card_uuid = player.cards.pop(card_idx)
             # add to discard
-            kernel.decks[kernel.carduuid2card[card_uuid].deck_idx].discard_faceup_stack.cards.append(card_uuid)
+            kernel.decks[kernel.game_config.fig.carduuid2card[card_uuid].deck_idx].discard_faceup_stack.cards.append(card_uuid)
 
     kernel = recycle_decks_if_needed(kernel)
     kernel = replenish_decks_if_needed(kernel)
@@ -3799,7 +3848,7 @@ def handle_keep_action(kernel, action):
             non_kept_cards.append(card_uuid)
 
     # Discard the non-kept cards to the deck's discard pile
-    deck.discard_faceup_stack.cards.extend(non_kept_cards)
+    deck.discard_facedown_stack.cards.extend(non_kept_cards)
     
     # Clear the discard tray and add the kept cards back
     player.cards.extend([c for c in kept_cards if c is not None])
@@ -3846,7 +3895,7 @@ def handle_discard_action(kernel, action):
     print("****************************** handle_discard_action 6", non_kept_cards)
 
     # Discard the non-kept cards to the deck's discard pile
-    deck.discard_faceup_stack.cards.extend(non_kept_cards)
+    deck.discard_facedown_stack.cards.extend(non_kept_cards)
     
     # Clear the discard tray and add the kept cards back
     player.cards.extend([c for c in kept_cards if c is not None])
@@ -3877,7 +3926,7 @@ def set_deck(kernel, deck_idx, deck):
 def shuffle(rng, deck):
     shuffled_cards = list(deck.facedown_stack.cards)
     rng.shuffle(shuffled_cards)
-    return deck.set(facedown_stack=CardStack(hidden=True, cards=shuffled_cards))
+    return deck.set(facedown_stack=FacedownCardStack(cards=shuffled_cards))
 
 
 @dispatch(StateKernel, int)
@@ -4172,7 +4221,7 @@ HOOK_NAMESPACE = {
 @dispatch(StateKernel)
 def get_wild_unit_uuids(state_kernel):
     wild_unit_uuids = []
-    for card in state_kernel.carduuid2card.values():
+    for card in state_kernel.game_config.fig.carduuid2card.values():
         if card.is_wild:
             wild_unit_uuids.append(card.resource_uuid)
     return wild_unit_uuids
@@ -4187,7 +4236,7 @@ def match_strict_wild(state_kernel, fulfillment, cards, segment_records):
 
     for segment_record in segment_records:
         if segment_record.unit_uuid and segment_record.unit_uuid in wild_unit_uuids:
-            first_matching_idx = next((i for i, card_uuid in enumerate(new_cards) if state_kernel.carduuid2card[card_uuid].resource_uuid == segment_record.unit_uuid), None)
+            first_matching_idx = next((i for i, card_uuid in enumerate(new_cards) if state_kernel.game_config.fig.carduuid2card[card_uuid].resource_uuid == segment_record.unit_uuid), None)
             if first_matching_idx is not None:
                 new_fulfillment.append(new_cards.pop(first_matching_idx))
             else:
@@ -4205,8 +4254,8 @@ def match_non_wild_non_empty(state_kernel, fulfillment, cards, segment_records):
     new_segment_records = []
 
     for segment_record in segment_records:
-        first_strict_matching_idx = next((i for i, card_uuid in enumerate(new_cards) if state_kernel.carduuid2card[card_uuid].resource_uuid == segment_record.unit_uuid), None)
-        first_wild_matching_idx = next((i for i, card_uuid in enumerate(new_cards) if state_kernel.carduuid2card[card_uuid].resource_uuid in wild_unit_uuids), None)
+        first_strict_matching_idx = next((i for i, card_uuid in enumerate(new_cards) if state_kernel.game_config.fig.carduuid2card[card_uuid].resource_uuid == segment_record.unit_uuid), None)
+        first_wild_matching_idx = next((i for i, card_uuid in enumerate(new_cards) if state_kernel.game_config.fig.carduuid2card[card_uuid].resource_uuid in wild_unit_uuids), None)
         first_matching_idx = first_strict_matching_idx if first_strict_matching_idx is not None else first_wild_matching_idx
         if first_matching_idx is not None:
             new_fulfillment.append(new_cards.pop(first_matching_idx))
@@ -4245,14 +4294,14 @@ def match_empty(state_kernel, fulfillment, cards, segment_records):
 
 @dispatch(StateKernel, list, int)
 def get_uniform_sets(state_kernel, cards, min_length):
-    wilds = [card_uuid for card_uuid in cards if state_kernel.carduuid2card[card_uuid].is_wild]
-    non_wilds = [card_uuid for card_uuid in cards if not state_kernel.carduuid2card[card_uuid].is_wild]
+    wilds = [card_uuid for card_uuid in cards if state_kernel.game_config.fig.carduuid2card[card_uuid].is_wild]
+    non_wilds = [card_uuid for card_uuid in cards if not state_kernel.game_config.fig.carduuid2card[card_uuid].is_wild]
     # print("********************* cards: ", cards)
     # print("********************* wilds: ", wilds)
     # print("********************* non_wilds: ", non_wilds)
     unit_uuid_2_cards = {}
     for card_uuid in non_wilds:
-        card = state_kernel.carduuid2card[card_uuid]
+        card = state_kernel.game_config.fig.carduuid2card[card_uuid]
         if card.resource_uuid not in unit_uuid_2_cards:
             unit_uuid_2_cards[card.resource_uuid] = []
         unit_uuid_2_cards[card.resource_uuid].append(card_uuid)
@@ -4301,7 +4350,7 @@ def get_sample_actionclaimpath(game, player_idx, path_idx):
 @dispatch(StateKernel, int, int)
 def get_sample_path_fulfillment(kernel, player_idx, path_idx):
     path_record = kernel.idx2pathrecord[path_idx]
-    remaining_card_uuids = [card_uuid for card_uuid in kernel.players[player_idx].cards if kernel.carduuid2card[card_uuid].deck_idx == 0]
+    remaining_card_uuids = [card_uuid for card_uuid in kernel.players[player_idx].cards if kernel.game_config.fig.carduuid2card[card_uuid].deck_idx == 0]
     remaining_pieces = [
         piece_uuid 
         for piece_uuid in kernel.players[player_idx].pieces 
@@ -4503,7 +4552,7 @@ def calc_legal_actions3(state_kernel):
     
     elif last_action.legal_action.faceup_draw:
         faceup_draw = last_action.legal_action.faceup_draw
-        if not state_kernel.carduuid2card[faceup_draw.card_uuid].is_wild:
+        if not state_kernel.game_config.fig.carduuid2card[faceup_draw.card_uuid].is_wild:
             legal_actions = get_follow_up_draw_legal_actions(state_kernel, last_action)
             if legal_actions:
                 return legal_actions
@@ -4647,7 +4696,6 @@ def get_public_player_scores(s):
 # all_pieces = field(type=list)  # List[Piece]
 # to_play_2 = field(type=list)  # List[int]
 # bonus_statuses = field(type=list)  # List[BonusStatus]
-# starting_decks = field(type=list)  # List[Deck]
 # starting_piles = field(type=list)  # List[Pile]
 # history = field(type=list)  # List[PublicAction]
 # player_scores = field(type=list)  # List[PublicPlayerScore]
@@ -4670,24 +4718,69 @@ def get_public_player_scores(s):
 # goal_completions = field(type=list, initial=[])  # List[GoalCompletion]
 
 
-def get_public_history(s: State):
-    return [action.get_public(s) for action in s.kernel.history]
+def get_candidate_decks(ps: PlayerState) -> List[CandidateDeck]:
+    candidate_lists = [
+        copy.deepcopy(public_deck.all_cards)
+        for public_deck in ps.public.decks
+    ]
 
+    note_lists = [
+        [f"Deck {deck_idx} started with {len(candidate_deck)} cards"]
+        for deck_idx, candidate_deck in enumerate(candidate_lists)
+    ]
 
-def get_candidate_decks(ps: PlayerState) -> List[CandidateDeck]:
-    pass
+    for deck_idx, (public_deck, candidates) in enumerate(zip(ps.public.decks, candidate_lists)):
+        # filter out cards that are faceup
+        spots_to_remove = [card_uuid for card_uuid in public_deck.faceup_spread.spots if card_uuid]
+        for card_uuid in spots_to_remove:
+            if card_uuid:
+                print("************************************ spots_to_remove: ", spots_to_remove)
+                candidates.remove(card_uuid)
+
+        note_lists[deck_idx].append(f"Removed {len(spots_to_remove)} candidates from deck {public_deck.idx} for faceup spots")
+        
+        # filter out cards in faceup discard
+        for card_uuid in public_deck.discard_faceup_stack.cards:
+            candidates.remove(card_uuid)
+
+        note_lists[deck_idx].append(f"Removed {len(public_deck.discard_faceup_stack.cards)} candidates from deck {public_deck.idx} for faceup discard")
+
+
+    for card_uuid in ps.private.player.cards:
+        card = ps.game_config.fig.carduuid2card[card_uuid]
+        candidate_lists[card.deck_idx].remove(card_uuid)
+        note_lists[card.deck_idx].append(f"Removed 1 candidate from deck {card.deck_idx} for player hand (for player {ps.private.player.idx})")
+
+    return [
+        CandidateDeck(
+            deck_idx=deck_idx,
+            candidates=candidate_list,
+            notes=note_list + [f"Deck {deck_idx} ends with {len(candidate_list)} cards"]
+        )
+        for deck_idx, (candidate_list, note_list) in enumerate(zip(candidate_lists, note_lists))
+    ]
 
 
 def imagine_player(p_idx: int, ps: PlayerState, candidate_decks: List[CandidateDeck]) -> Player:
+    print(f"imagine_player {p_idx}")
     if ps.private.player.idx == p_idx:
+        print(f"No need to imagine player {p_idx}, returning private player")
         return ps.private.player
+    print(f"len(candidate_decks[0].candidates): ", len(candidate_decks[0].candidates))
+    print(f"public_player.deck_counts: ", ps.public.players[p_idx].deck_counts)
     public_player = ps.public.players[p_idx]
+    print(f"z1")
     cards = []
+    print(f"z2")
     for deck_idx, count in enumerate(public_player.deck_counts):
+        print(f"deck_idx: {deck_idx}, count: {count}")
         candidate_deck = candidate_decks[deck_idx]
+        print(f"len(candidate_deck.candidates) before: {len(candidate_deck.candidates)}")
         for _ in range(count):
             cards.append(candidate_deck.candidates.pop())
+        print(f"len(candidate_deck.candidates) after: {len(candidate_deck.candidates)}")
     discard_tray = []
+    print(f"z4")
     for deck_idx, count in enumerate(public_player.discard_deck_counts):
         candidate_deck = candidate_decks[deck_idx]
         for _ in range(count):
@@ -4709,18 +4802,25 @@ def imagine_players(ps: PlayerState, candidate_decks: List[CandidateDeck]) -> Li
 
 
 def imagine_decks(ps: PlayerState, candidate_decks: List[CandidateDeck]) -> List[Deck]:
-    public = ps.public
+    # print("************************************ candidate_decks[1]: ", candidate_decks[1])
     imagined = [
-        imagine_deck(public_deck, candidate_deck)
-        for public_deck in public.decks
+        imagine_deck(public_deck, candidate_decks[deck_idx])
+        for deck_idx, public_deck in enumerate(ps.public.decks)
     ]
+    # print("************************************ imagined[1]: ", imagined[1])
     return imagined
 
 
 def imagine_deck(public_deck: PublicDeck, candidate_deck: CandidateDeck) -> Deck:
-    return Deck(
+    facedown_stack_cards = [
+        candidate_deck.candidates.pop() for _ in range(public_deck.facedown_stack.num_cards)
+    ]
+    print(f"len(facedown_stack_cards) pops for deck_idx [{public_deck.idx}]: ", len(facedown_stack_cards))
+
+    imagined = Deck(
         idx=public_deck.idx,
         uuid=public_deck.uuid,
+        all_cards=copy.deepcopy(public_deck.all_cards),
         faceup_stack=(
             copy.deepcopy(public_deck.faceup_stack)
             if public_deck.faceup_stack else None
@@ -4730,47 +4830,66 @@ def imagine_deck(public_deck: PublicDeck, candidate_deck: CandidateDeck) -> Deck
             if public_deck.faceup_spread else None
         ),
         facedown_stack=(
-            CardStack(
-                hidden=True, 
-                cards=[
-                    candidate_deck.candidates.pop() for _ in range(public_deck.facedown_stack_len)
-                ]
+            FacedownCardStack(
+                cards=facedown_stack_cards
             )
-            if public_deck.facedown_stack_len > 0 else None
+            if public_deck.facedown_stack else None
         ),
         facedown_spread=(
-            CardSpread(
-                hidden=True,
+            FacedownCardSpread(
                 spots=[
-                    candidate_deck.candidates.pop() for _ in range(len(public_deck.facedown_spread_len))
+                    candidate_deck.candidates.pop() if spot else None
+                    for spot in public_deck.facedown_spread.spots
                 ]
             )
-            if public_deck.facedown_spread_len > 0 else None
+            if public_deck.facedown_spread else None
         ),
         discard_faceup_stack=(
             copy.deepcopy(public_deck.discard_faceup_stack)
             if public_deck.discard_faceup_stack else None
         ),
         discard_facedown_stack=(
-            CardStack(
-                hidden=True,
+            FacedownCardStack(
                 cards=[
-                    candidate_deck.candidates.pop() for _ in range(public_deck.discard_facedown_stack_len)
+                    candidate_deck.candidates.pop() for _ in range(public_deck.discard_facedown_stack.num_cards)
                 ]
             )
-            if public_deck.discard_facedown_stack_len > 0 else None
+            if public_deck.discard_facedown_stack else None
         ),
     )
 
+    # print("************************************ public_deck.facedown_stack 10: ", public_deck.facedown_stack)
+    # print("************************************ imagined.facedown_stack: ", imagined.facedown_stack)
+
+    return imagined
+
 
 @dispatch(PlayerState)
-def imagine_state(ps):
+def imagine_state(ps: PlayerState) -> State:
     public = ps.public
-    game_config = public.game_config
+    game_config = ps.game_config
 
     candidate_decks = get_candidate_decks(ps)
+
+    print_public_deck_stats(ps.public.decks[0])
+    
+    print("\n")
+    print("************************************ candidate_decks[1].notes a: ", candidate_decks[1].notes)
+    print("************************************ len(candidate_decks[1].candidates) a: ", len(candidate_decks[1].candidates))
+    print("\n")
+    
     imagined_decks = imagine_decks(ps, candidate_decks)
+
+    print("\n")
+    print("************************************ len(candidate_decks[1].candidates) b: ", len(candidate_decks[1].candidates))
+    print("player deck[1] counts: ", [public_player.deck_counts[1] for public_player in ps.public.players])
+    print("\n")
+
     imagined_players = imagine_players(ps, candidate_decks)
+    
+    print("\n")
+    print("************************************ len(candidate_decks[1].candidates) c: ", len(candidate_decks[1].candidates))
+    print("\n")
 
     imagined_kernel = init_state_kernel(
         GameConfig(
@@ -4843,16 +4962,14 @@ def getpublicstate(s):
 
 
     return PublicState(
-        game_config=getpublicgameconfig(s.kernel.game_config),
         deadlines=get_deadlines(s),
         game_started_at=s.kernel.game_config.started_at,
         allotted_times=get_max_allotted_times(s),
         all_pieces=list(s.kernel.pieceuuid2piece.values()),
         to_play_2=getpublictoplay(s),
         bonus_statuses=s.bonus_statuses_3,
-        starting_decks=s.kernel.starting_decks,
         starting_piles=s.kernel.starting_piles,
-        history=get_public_history(s),
+        history=s.kernel.history,
         player_scores=get_public_player_scores(s),
         player_graphs=s.kernel.player_graphs_3,
         goals=s.kernel.goals,
@@ -4874,20 +4991,25 @@ def getpublicdeck(s, d):
     return PublicDeck(
         idx=d.idx,
         uuid=d.uuid,
-        facedown_stack_len=len(d.facedown_stack.cards),
-        discard_len=len(d.discard_faceup_stack.cards),
-        faceup_spots=d.faceup_spread.spots,
+        all_cards=d.all_cards,
+        faceup_stack = copy.deepcopy(d.faceup_stack) if d.faceup_stack else None,
+        faceup_spread = copy.deepcopy(d.faceup_spread) if d.faceup_spread else None,
+        facedown_stack = PublicFacedownCardStack(num_cards=len(d.facedown_stack.cards)) if d.facedown_stack else None,
+        facedown_spread = PublicFacedownCardSpread(spots=[spot is not None for spot in d.facedown_spread.spots]) if d.facedown_spread else None,
+        discard_faceup_stack = copy.deepcopy(d.discard_faceup_stack) if d.discard_faceup_stack else None,
+        discard_facedown_stack = PublicFacedownCardStack(num_cards=len(d.discard_facedown_stack.cards)) if d.discard_facedown_stack else None,
     )
+    # print("************************************ public_state.decks[0].facedown_stack 7: ", public_state.decks[0].facedown_stack)
 
 
 @dispatch(State, Player)
 def getpublicplayer(s, p):
     deck_counts = [0 for _ in s.kernel.game_config.fig.board_config.deks]
     for card in p.cards:
-        deck_counts[s.kernel.carduuid2card[card].deck_idx] += 1
+        deck_counts[s.kernel.game_config.fig.carduuid2card[card].deck_idx] += 1
     discard_deck_counts = [0 for _ in s.kernel.game_config.fig.board_config.deks]
     for card in p.discard_tray:
-        discard_deck_counts[s.kernel.carduuid2card[card].deck_idx] += 1
+        discard_deck_counts[s.kernel.game_config.fig.carduuid2card[card].deck_idx] += 1
     piece_template_counts = [0 for _ in s.kernel.game_config.fig.board_config.piece_templates]
     for piece_uuid in p.pieces:
         piece_template_counts[s.kernel.pieceuuid2piece[piece_uuid].piece_template_idx] += 1
@@ -4900,52 +5022,6 @@ def getpublicplayer(s, p):
     )
 
 
-# Implementing the following Julia function:
-# function getpublicscore(s::State, player_idx::Int)
-#     addends = Int[]
-    
-#     if getsettingvalue(s, :path_scoring)
-#         (; path_scores) = s.fig
-#         path_lens = getplayerpathlens(s, player_idx)
-#         if isempty(path_lens)
-#             return 0
-#         end
-#         push!(addends, sum(map(len -> path_scores[len], path_lens)))
-#     end
-
-#     if getsettingvalue(s, :cluster_scoring)
-#         (; clusters) = s.fig.board_config
-#         uuid2cluster = Dict((x.uuid, x) for x in clusters)
-#         (; completed_clusters) = s.player_hands[player_idx]
-#         cluster_scores = map(completed_clusters) do cluster_uuid
-#             uuid2cluster[cluster_uuid].score
-#         end
-#         if !isempty(cluster_scores)
-#             push!(addends, sum(cluster_scores))
-#         end
-#     end
-
-#     sum(addends)
-# end
-def getpublicscore(s, player_idx):
-    addends = []
-    if getsettingvalue(s, 'path_scoring'):
-        path_lens = getplayerpathlens(s, player_idx)
-        if not path_lens:
-            return 0
-        addends.append(sum(s.kernel.game_config.fig.path_scores[len] for len in path_lens))
-    
-    if getsettingvalue(s, 'cluster_scoring'):
-        clusters = s.kernel.game_config.fig.board_config.clusters
-        uuid2cluster = {x.uuid: x for x in clusters}
-        completed_clusters = s.player_hands[player_idx].completed_clusters
-        cluster_scores = [uuid2cluster[cluster_uuid].score for cluster_uuid in completed_clusters]
-        if cluster_scores:
-            addends.append(sum(cluster_scores))
-    
-    return sum(addends)
-
-
 # Implementing the following Julia function:
 # function getplayerpathlens(s::State, player_idx::Int)
 #     getpathlens(s)[getplayerpathidxs(s, player_idx)]
@@ -5107,7 +5183,7 @@ def get_player_graph(s, player_idx):
 def get_goals(kernel, player_idx):
     player = kernel.players[player_idx]
     goaluuid2goal = {goal.uuid: goal for goal in kernel.goals}
-    goal_uuids = [kernel.carduuid2card[card_uuid].goal_uuid for card_uuid in player.cards if kernel.carduuid2card[card_uuid].goal_uuid]
+    goal_uuids = [kernel.game_config.fig.carduuid2card[card_uuid].goal_uuid for card_uuid in player.cards if kernel.game_config.fig.carduuid2card[card_uuid].goal_uuid]
     return [
         goaluuid2goal[goal_uuid] for goal_uuid in goal_uuids if goal_uuid in goaluuid2goal
     ]
@@ -5117,7 +5193,7 @@ def get_goals(kernel, player_idx):
 def get_goals3(kernel, player_idx):
     player = kernel.players[player_idx]
     goaluuid2goal = {goal.uuid: goal for goal in kernel.goals}
-    goal_uuids = [kernel.carduuid2card[card_uuid].goal_uuid for card_uuid in player.cards if kernel.carduuid2card[card_uuid].goal_uuid]
+    goal_uuids = [kernel.game_config.fig.carduuid2card[card_uuid].goal_uuid for card_uuid in player.cards if kernel.game_config.fig.carduuid2card[card_uuid].goal_uuid]
     return [
         goaluuid2goal[goal_uuid] for goal_uuid in goal_uuids if goal_uuid in goaluuid2goal
     ]
@@ -5698,10 +5774,15 @@ def get_default_toplay(s):
 
 
 @dispatch(PlayerState)
-def get_intuited_best_actions(ps):
-    if not ps.private.legal_actions_3:
+def get_intuited_best_actions(ps: PlayerState):
+    imagined_state = imagine_state(ps)
+    possible_actions = [
+        legal_action.get_default_action(imagined_state)
+        for legal_action in ps.private.legal_actions_3
+    ]
+    if not possible_actions:
         return None
-    return ps.private.legal_actions_3[:8]
+    return possible_actions[:8]
 
 
 def get_spread(q_values, p_idx):
@@ -5716,7 +5797,7 @@ def getvproxy0(ps):
 
 
 @dispatch(PlayerState, Action2)
-def imagine_dynamics(ps, a):
+def imagine_dynamics(ps: PlayerState, a: Action2):
     return dynamics(imagine_state(ps), a)
 
 
@@ -5725,14 +5806,14 @@ def dynamics(s, a):
     scores = get_public_player_scores(s)
     next_s = getnextstate2(s, a)
     next_scores = get_public_player_scores(next_s)
-    rewards = [next_scores[i] - scores[i] for i in range(len(scores))]
+    rewards = [next_scores[i].total - scores[i].total for i in range(len(scores))]
     return next_s, rewards
 
 
-@dispatch(PlayerState)
-def alpha0(ps):
+def alpha0(ps: PlayerState):
+    # print("************************************ ps.public.decks[0].facedown_stack 8: ", ps.public.decks[0].facedown_stack)
     td = 3
-    legal_actions = ps.legal_actions_3
+    legal_actions = ps.private.legal_actions_3
     if not legal_actions:
         return None
     intuited = get_intuited_best_actions(ps)
@@ -5748,7 +5829,8 @@ def get_max_spread_idx(q_proxies, p_idx):
 
 
 @dispatch(PlayerState, Action2, int)
-def getqproxy0(ps, a, td):
+def getqproxy0(ps: PlayerState, a: LegalAction, td: int):
+    print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ getqproxy0 td: ", td)
 
     def qproxybase():
         next_s, rewards = imagine_dynamics(ps, a)
@@ -5770,9 +5852,13 @@ def getqproxy0(ps, a, td):
             return rewards
         next_p_idx = get_default_toplay(next_s)
         next_ps = getprivatestate(next_s, next_p_idx)
-        next_p_idx = next_ps.player.player_idx
-        next_intuited = get_intuited_best_actions(next_ps)
-        competing_next_q_values = [getqproxy0(next_ps, a, td-1) for a in next_intuited]
+        player_state = PlayerState(
+            game_config=getpublicgameconfig(next_s.kernel.game_config),
+            public=getpublicstate(next_s),
+            private=next_ps,
+        )
+        next_intuited = get_intuited_best_actions(player_state)
+        competing_next_q_values = [getqproxy0(player_state, a, td-1) for a in next_intuited]
         max_next_spread_idx = get_max_spread_idx(competing_next_q_values, next_p_idx)
         next_q_values = competing_next_q_values[max_next_spread_idx]
         q_values = [r + next_q_values[i] for i, r in enumerate(rewards)]

{graph_games_proto-0.3.2125.dist-info → graph_games_proto-0.3.2225.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graph_games_proto
-Version: 0.3.2125
+Version: 0.3.2225
 Requires-Dist: multipledispatch==1.0.0
 Requires-Dist: pyrsistent==0.20.0
 Requires-Dist: numpy==2.2.4

graph_games_proto-0.3.2225.dist-info/RECORD

@@ -0,0 +1,9 @@
+graph_games_proto/__init__.py,sha256=BcRdYe0yElSo3vQ5eqhecM1QP-NXaV-mQtcBH6KUnN0,696
+graph_games_proto/all_types.py,sha256=IpbwftEcHS5Ewz-saFNk0lO9FvcbuHG36odRTayCXUk,54911
+graph_games_proto/fns.py,sha256=UgSKX2RtHOY0LwQwV3RE_h0AUE-vGKCiw5nSz25oZF8,211032
+graph_games_proto/main.py,sha256=fj2U7KcwrpZtuUhjOX5yVxY18LZvvsxDFYZ_S5mxe04,145
+graph_games_proto/state.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+graph_games_proto-0.3.2225.dist-info/METADATA,sha256=yq0W9HamGVrJZy9eeEyIe9FwF1qdnKW2HrsuuL2DTm0,188
+graph_games_proto-0.3.2225.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+graph_games_proto-0.3.2225.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
+graph_games_proto-0.3.2225.dist-info/RECORD,,

graph_games_proto-0.3.2125.dist-info/RECORD

@@ -1,9 +0,0 @@
-graph_games_proto/__init__.py,sha256=_EVQR-51XehfH45XZlba1WPdx3omS3Gm1nTwrgGyn2Q,667
-graph_games_proto/all_types.py,sha256=IpbwftEcHS5Ewz-saFNk0lO9FvcbuHG36odRTayCXUk,54911
-graph_games_proto/fns.py,sha256=4AJuya9rToZ6X9R1s3VaIgPVfgSzWgFGtcpq1fcb08E,205649
-graph_games_proto/main.py,sha256=fj2U7KcwrpZtuUhjOX5yVxY18LZvvsxDFYZ_S5mxe04,145
-graph_games_proto/state.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graph_games_proto-0.3.2125.dist-info/METADATA,sha256=QXSXIlQrExUjx_OAlmIh0lqTA_OvtbGwxj9OLyIw288,188
-graph_games_proto-0.3.2125.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-graph_games_proto-0.3.2125.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
-graph_games_proto-0.3.2125.dist-info/RECORD,,