graph-games-proto 0.3.1866__py3-none-any.whl → 0.3.1877__py3-none-any.whl

graph_games_proto/fns.py

@@ -559,22 +559,6 @@ class FrozenBoardConfigDataclass:
     settings: List[FrozenSetting]
 
 
-@dataclass(frozen=True)
-class Action:
-    player_idx: int
-    action_name: str
-    return_route_cards: Set[int]
-    point_uuid: Optional[UUID]
-    path_idx: Optional[int]
-    unit_combo: Optional[str]
-    draw_faceup_unit_card_num: Optional[int]
-    draw_faceup_spot_num: Optional[int]
-    def __str__(self):
-        return f"Action({self.action_name})"
-    def __repr__(self):
-        return self.__str__()
-
-
 class FrozenRoute(PClass):
     num = field(type=int)
     uuid = field(type=str)
@@ -1005,198 +989,6 @@ class ActionDrawUnit:
        pass
 
 
-# struct PublicState
-#     fig::Fig
-#     logged_game_uuid::UUID
-#     to_play::Vector{Int}
-#     last_to_play::Union{Nothing,Int}
-#     terminal::Bool
-#     winners::Vector{Int}
-
-
-class AltAction(PClass):
-    player_idx = field(type=int)
-    action_name = field(type=str)
-    path_idx = field(type=(int, type(None)), initial=None)
-    return_route_cards = field(type=list, initial=[])  # List[int]
-    draw_faceup_unit_card_num = field(type=(int, type(None)), initial=None)
-    draw_faceup_spot_num = field(type=(int, type(None)), initial=None)
-    point_uuid = field(type=(str, type(None)), initial=None)
-    unit_combo = field(type=(str, type(None)), initial=None)  # TODO: should be list of int
-    def __todict__(self):
-        return {
-            "player_idx": self.player_idx,
-            "action_name": self.action_name,
-            "path_idx": self.path_idx,
-            "return_route_cards": self.return_route_cards,
-            "draw_faceup_unit_card_num": self.draw_faceup_unit_card_num,
-            "draw_faceup_spot_num": self.draw_faceup_spot_num,
-            "point_uuid": self.point_uuid,
-            "unit_combo": self.unit_combo
-        }
-    @staticmethod
-    def __fromdict__(json_dict):
-        return AltAction(
-            player_idx=json_dict["player_idx"],
-            action_name=json_dict["action_name"],
-            path_idx=json_dict.get("path_idx", None),  # Handle missing key gracefully
-            return_route_cards=json_dict.get("return_route_cards", []),  # Handle missing key gracefully
-            draw_faceup_unit_card_num=json_dict.get("draw_faceup_unit_card_num", None),  # Handle missing key gracefully
-            draw_faceup_spot_num=json_dict.get("draw_faceup_spot_num", None),  # Handle missing key gracefully
-            point_uuid=json_dict.get("point_uuid", None),  # Handle missing key gracefully
-            unit_combo=json_dict.get("unit_combo", None)  # Handle missing key gracefully
-        )
-
-
-class ActionSpec(PClass):
-    # # TODO: should remove "player_idx" as it's always the same as "to_play"
-    player_idx = field(type=int)
-    action_name = field(type=str)
-    return_route_option_sets = field(type=list, initial=[])  # List[OptionSet]
-    draw_faceup_spots = field(type=dict, initial={})  # Dict{Int, int}
-    points = field(type=list, initial=[])  # List[PointCombos]
-    paths = field(type=list, initial=[])  # List[PathCombos]
-    def __todict__(self):
-        return {
-            "player_idx": self.player_idx,
-            "action_name": self.action_name,
-            "return_route_option_sets": [x.__todict__() for x in self.return_route_option_sets],
-            "draw_faceup_spots": self.draw_faceup_spots,
-            "points": [x.__todict__() for x in self.points],
-            "paths": [x.__todict__() for x in self.paths],
-        }
-    @staticmethod
-    def __fromdict__(d):
-        print("""d["return_route_option_sets"]""", d["return_route_option_sets"])
-        return ActionSpec(
-            player_idx=d["player_idx"],
-            action_name=d["action_name"],
-            return_route_option_sets=[OptionSet.__fromdict__(x) for x in d["return_route_option_sets"]],
-            draw_faceup_spots=d["draw_faceup_spots"],
-            points=[PointCombos.__fromdict__(x) for x in d["points"]],
-            paths=[PathCombos.__fromdict__(x) for x in d["paths"]],
-        )
-
-
-# Implementing the following Julia function:
-# struct PathCombos
-#     path_idx::Int
-#     default_combo::String
-#     sample_fulfillment::Vector{Int}
-# end
-class PathCombos(PClass):
-    path_idx = field(type=int)
-    default_combo = field(type=str)
-    sample_fulfillment = field(type=list)  # List[int]
-    def __todict__(self):
-        return {
-            "path_idx": self.path_idx,
-            "default_combo": self.default_combo,
-            "sample_fulfillment": self.sample_fulfillment,
-        }
-    @staticmethod
-    def __fromdict__(d):
-        return PathCombos(
-            path_idx=d["path_idx"],
-            default_combo=d["default_combo"],
-            sample_fulfillment=d["sample_fulfillment"]
-        )
-
-
-# Implementing the following Julia function:
-# struct OptionSet
-#     option_idxs::Set{Int}
-# end
-class OptionSet(PClass):
-    option_idxs = field(type=set)  # Set[int]
-    def __todict__(self):
-        return {
-            "option_idxs": list(self.option_idxs),
-        }
-    @staticmethod
-    def __fromdict__(d):
-        return OptionSet(
-            option_idxs=set(d["option_idxs"])
-        )
-
-
-class PointCombos(PClass):
-    point_uuid = field(type=str)
-    default_combo = field(type=str)
-    sample_fulfillment = field(type=list)  # List[int]
-    def __todict__(self):
-        return {
-            "point_uuid": self.point_uuid,
-            "default_combo": self.default_combo,
-            "sample_fulfillment": self.sample_fulfillment,
-        }
-    @staticmethod
-    def __fromdict__(d):
-        return PointCombos(
-            point_uuid=d["point_uuid"],
-            default_combo=d["default_combo"],
-            sample_fulfillment=d["sample_fulfillment"]
-        )
-
-
-class PlayerInfo(PClass):
-    fig = field(type=Fig)
-    player_idx = field(type=int)
-    new_route_cards = field(type=PVector)  # List[int]
-    route_cards = field(type=PVector)  # List[int]
-    unit_cards = field(type=PVector)  # List[int]
-    completed_routes = field(type=list)  # List[int]
-    completed_clusters = field(type=list)  # List[UUID]
-    paths = field(type=list)  # List[int]
-    points = field(type=list)  # List[UUID]
-    tokens = field(type=list)  # List[UUID]
-    num_pieces = field(type=int)
-    num_point_pieces = field(type=int)
-    longest_trail = field(type=list)  # List[int]
-    longest_trail_len = field(type=int)
-    final_score = field(type=object)  # Union{Nothing, PlayerScore}
-    def __todict__(self):
-        return {
-            "fig": self.fig.__todict__(),
-            "player_idx": self.player_idx,
-            "new_route_cards": list(self.new_route_cards),
-            "route_cards": list(self.route_cards),
-            "unit_cards": list(self.unit_cards),
-            "completed_routes": self.completed_routes,
-            "completed_clusters": self.completed_clusters,
-            "paths": self.paths,
-            "points": self.points,
-            "tokens": self.tokens,
-            "num_pieces": self.num_pieces,
-            "num_point_pieces": self.num_point_pieces,
-            "longest_trail": self.longest_trail,
-            "longest_trail_len": self.longest_trail_len,
-            "final_score": self.final_score.__todict__() if self.final_score else None,
-        }
-    @staticmethod
-    def __fromdict__(d):
-        return PlayerInfo(
-            fig=Fig.__fromdict__(d["fig"]),
-            player_idx=d["player_idx"],
-            new_route_cards=pvector(d["new_route_cards"]),
-            route_cards=pvector(d["route_cards"]),
-            unit_cards=pvector(d["unit_cards"]),
-            completed_routes=d["completed_routes"],
-            completed_clusters=d["completed_clusters"],
-            paths=d["paths"],
-            points=d["points"],
-            tokens=d["tokens"],
-            num_pieces=d["num_pieces"],
-            num_point_pieces=d["num_point_pieces"],
-            longest_trail=d["longest_trail"],
-            longest_trail_len=d["longest_trail_len"],
-            final_score=PlayerScore.__fromdict__(d["final_score"]) if d.get("final_score") else None,
-        )
-    @staticmethod
-    def clone(hand):
-        return PlayerInfo.__fromdict__(hand.__todict__())
-
-
 class PublicPlayer(PClass):
     idx = field(type=int)
     pieces = field(type=list)  # List[Piece]
@@ -1307,36 +1099,27 @@ class PrivatePlayerScore(PClass):
         )
 
 
-# Implementing the following Julia function:
-# struct PrivateState
-#     legal_actions::Vector{ActionSpec}
-#     segment_statuses::Vector{SegmentStatus}
-#     hand::PlayerInfo
-# end
 class PrivateState(PClass):
+    my_history = field(type=list)  # List[Action2]
     player_score = field(type=PrivatePlayerScore)
     player = field(type=Player)
     legal_actions_2 = field(type=list)  # List[LegalAction]
-    legal_actions = field(type=list)  # List[ActionSpec]
-    hand = field(type=PlayerInfo)
     goal_completions = field(type=list, initial=[])  # List[GoalCompletion]
     def __todict__(self):
         return {
+            "my_history": [x.__todict__() for x in self.my_history],
             "player_score": self.player_score.__todict__(),
             "player": self.player.__todict__(),
             "legal_actions_2": [x.__todict__() for x in self.legal_actions_2],
-            "legal_actions": [x.__todict__() for x in self.legal_actions],
-            "hand": self.hand.__todict__(),
             "goal_completions": [x.__todict__() for x in self.goal_completions],
         }
     @staticmethod
     def __fromdict__(d):
         return PrivateState(
+            my_history=[Action2.__fromdict__(x) for x in d["my_history"]],
             player_score=PrivatePlayerScore.__fromdict__(d["player_score"]),
             player=Player.__fromdict__(d["player"]),
             legal_actions_2=[LegalAction.__fromdict__(x) for x in d["legal_actions_2"]],
-            legal_actions=[ActionSpec.__fromdict__(x) for x in d["legal_actions"]],
-            hand=PlayerInfo.__fromdict__(d["hand"]),
             goal_completions=[GoalCompletion.__fromdict__(x) for x in d["goal_completions"]],
         )
 
@@ -2155,7 +1938,6 @@ class State(PClass):
     uuid2segment = field(type=dict)  # Dict[str, Segment]
     pieceuuid2piece = field(type=dict)  # Dict[str, Piece]
     carduuid2card = field(type=dict)  # Dict[str, Card]
-    final_scores = field(type=(list, type(None)), initial=None)  # Optional[List[int]]
     bonus_statuses = field(type=list)  # List[BonusStatus]
     bonusuuid2bonusidx = field(type=dict)  # Dict[str, int]
     carduuid2deckidx = field(type=dict)  # Dict[str, int]
@@ -2179,10 +1961,6 @@ class State(PClass):
     game_config = field(type=GameConfig)
     rng = field(type=random.Random)
     terminal = field(type=bool)
-    initial_to_play = field(type=list)  # List[int]
-    route_cards = field(type=PVector)  # List[int]
-    route_discards = field(type=PVector)  # List[int]
-    player_hands = field(type=PVector)  # List[PlayerInfo]
     last_to_play = field(type=(int, type(None)), initial=None)
     winners = field(type=list)  # List[int]
     def __todict__(self):
@@ -2192,7 +1970,6 @@ class State(PClass):
             "uuid2segment": {k: v.__todict__() for k, v in self.uuid2segment.items()},
             "pieceuuid2piece": {k: v.__todict__() for k, v in self.pieceuuid2piece.items()},
             "carduuid2card": {k: v.__todict__() for k, v in self.carduuid2card.items()},
-            "final_scores": self.final_scores,
             "bonus_statuses": [status.__todict__() for status in self.bonus_statuses],
             "bonusuuid2bonusidx": self.bonusuuid2bonusidx,
             "carduuid2deckidx": self.carduuid2deckidx,
@@ -2216,10 +1993,6 @@ class State(PClass):
             "game_config": self.game_config.__todict__(),
             "rng": rng2json(self.rng),
             "terminal": self.terminal,
-            "initial_to_play": self.initial_to_play,
-            "route_cards": list(self.route_cards),
-            "route_discards": list(self.route_discards),
-            "player_hands": [x.__todict__() for x in self.player_hands],
             "last_to_play": self.last_to_play,
             "winners": self.winners,
         }
@@ -2231,7 +2004,6 @@ class State(PClass):
             uuid2segment={k: Segment2.__fromdict__(v) for k, v in d["uuid2segment"].items()},
             pieceuuid2piece={k: Piece.__fromdict__(v) for k, v in d["pieceuuid2piece"].items()},
             carduuid2card={k: Card.__fromdict__(v) for k, v in d["carduuid2card"].items()},
-            final_scores=d["final_scores"],
             bonus_statuses=[BonusStatus.__fromdict__(x) for x in d["bonus_statuses"]],
             bonusuuid2bonusidx=d["bonusuuid2bonusidx"],
             carduuid2deckidx=d["carduuid2deckidx"],
@@ -2255,10 +2027,6 @@ class State(PClass):
             game_config=GameConfig.__fromdict__(d["game_config"]),
             rng=json2rng(d["rng"]),
             terminal=d["terminal"],
-            initial_to_play=d["initial_to_play"],
-            route_cards=pvector(d["route_cards"]),
-            route_discards=pvector(d["route_discards"]),
-            player_hands=pvector([PlayerInfo.__fromdict__(h) for h in d["player_hands"]]),
             last_to_play=d.get("last_to_play"),
             winners=d["winners"],
         )
@@ -2514,7 +2282,6 @@ class PublicState(PClass):
     decks = field(type=list)  # List[PublicDeck]
     piles = field(type=list)  # List[Pile]
     player_idxs = field(type=list)  # List[int]
-    initial_to_play = field(type=list)  # List[int]
     players = field(type=list)  # List[PublicPlayer]
     last_to_play = field(type=(int, type(None)), initial=None)
     winners = field(type=list)
@@ -2539,7 +2306,6 @@ class PublicState(PClass):
             "decks": [deck.__todict__() for deck in self.decks],
             "piles": [pile.__todict__() for pile in self.piles],
             "player_idxs": self.player_idxs,
-            "initial_to_play": self.initial_to_play,
             "players": [x.__todict__() for x in self.players],
             "last_to_play": self.last_to_play,
             "winners": self.winners,
@@ -2566,7 +2332,6 @@ class PublicState(PClass):
             decks=[PublicDeck.__fromdict__(deck) for deck in d["decks"]],
             piles=[Pile.__fromdict__(x) for x in d["piles"]],
             player_idxs=d["player_idxs"],
-            initial_to_play=d["initial_to_play"],
             players=[PublicPlayer.__fromdict__(x) for x in d["players"]],
             last_to_play=d.get("last_to_play"),
             winners=d["winners"],
@@ -2720,50 +2485,9 @@ def getsettingvalue(s, setting_name):
 def getinitialstate(game_config):
     fig = game_config.fig
     rng = getrng(game_config.seed)
-    route_deck = shuffledeck(getnumroutecards(fig), rng)
     unit_deck = shuffledeck(gettotaldeckcards(fig), rng)
     route_deck_idx, unit_deck_idx = 0, 0
-    player_hands = []
-    initial_num_route_choices = getsettingvalue(fig, "initial_num_route_choices")
-    num_initial_unit_cards = getsettingvalue(fig, "num_initial_unit_cards")
-    num_segment_pieces_per_player = getsettingvalue(fig, "num_segment_pieces_per_player")
-    num_point_pieces_per_player = getsettingvalue(fig, "num_point_pieces_per_player")
-
-
-    for player_idx in range(game_config.num_players):
-        player_hand = PlayerInfo(
-            fig=fig,
-            player_idx=player_idx,
-            new_route_cards=pvector(route_deck[route_deck_idx:(route_deck_idx+(initial_num_route_choices))]),
-            route_cards=pvector([]),
-            unit_cards=pvector(unit_deck[unit_deck_idx:(unit_deck_idx + num_initial_unit_cards)]),
-            completed_routes=[],
-            completed_clusters=[],
-            paths=[],
-            points=[],
-            tokens=[],
-            num_pieces=num_segment_pieces_per_player,
-            num_point_pieces=num_point_pieces_per_player,
-            longest_trail=[],
-            longest_trail_len=0,
-            final_score=None,
-        )
-        player_hands.append(player_hand)
-        route_deck_idx += initial_num_route_choices
-        unit_deck_idx += num_initial_unit_cards
-
-    faceup_spots = getfaceupspots(fig, unit_deck, unit_deck_idx)
     unit_deck_idx += 5
-    # Implementing the following Julia function:
-    # unit_cards = unit_deck[unit_deck_idx:end]
-    unit_cards = unit_deck[unit_deck_idx:] if unit_deck_idx < len(unit_deck) else []
-    route_cards = route_deck[route_deck_idx:]
-
-    if getsettingvalue(fig, 'action_route_discard'):
-        initial_to_play = list(range(game_config.num_players))
-    else:
-        initial_to_play = [getfirstplayeridx(rng, game_config.num_players)]
-
     board_config = fig.board_config
     deck_0_rng = getrng(1234321)
     deck_1_rng = getrng(8738758)
@@ -2848,7 +2572,6 @@ def getinitialstate(game_config):
         uuid2segment=uuid2segment,
         pieceuuid2piece=pieceuuid2piece,
         carduuid2card=carduuid2card,
-        final_scores=None,
         bonus_statuses=bonus_statuses,
         bonusuuid2bonusidx=bonusuuid2bonusidx,
         carduuid2deckidx=carduuid2deckidx,
@@ -2879,11 +2602,7 @@ def getinitialstate(game_config):
         player_idxs=list(range(game_config.num_players)),
         decks=decks,
         game_config=game_config,
-        initial_to_play=initial_to_play,
         rng=rng,
-        route_cards=pvector(route_cards),
-        route_discards=pvector([]),
-        player_hands=pvector(player_hands),
         last_to_play=None,
         winners=[],
         terminal=False,
@@ -2994,15 +2713,20 @@ def handle_last_to_play(game):
     return game
 
 
+def getfinalscores(game):
+    return [
+        getpublicplayerscore(game, game.player_scores[player_idx]).total
+        for player_idx in range(len(game.players))
+    ]
+
+
 def handle_calc_winners(game):
     if game.terminal:
         players_with_highest_score = []
         highest_score = -1000
-        final_scores = []
+        final_scores = getfinalscores(game)
         for player_idx in range(len(game.players)):
-            player_score = game.player_scores[player_idx]
-            final_score = getpublicplayerscore(game, player_score).total
-            final_scores.append(final_score)
+            final_score = final_scores[player_idx]
             if final_score > highest_score:
                 highest_score = final_score
                 players_with_highest_score = [player_idx]
@@ -3010,7 +2734,6 @@ def handle_calc_winners(game):
                 players_with_highest_score.append(player_idx)
         return game.set(
             winners=players_with_highest_score,
-            final_scores=final_scores,
         )
 
     return game
@@ -4308,63 +4031,6 @@ def getnextstate2(s, a, log=False):
     return s
 
 
-
-@dispatch(State, QValueLearningPolicy)
-def getnextaction(s, policy):
-    player_idx = gettoplay(s)[0]
-    legal_action_specs = getlegalactionspecsforplayer(s, player_idx, None, None)
-    legal_actions = get_all_legal_actions(s, player_idx, legal_action_specs)
-    
-    if s.rng.random() <= policy.epsilon:
-        random_action = legal_actions[s.rng.randint(0, len(legal_actions) - 1)]
-        return random_action
-    
-    q_values = policy.qvalue_fn(s, legal_actions)
-    argmax_idx = max(range(len(q_values)), key=lambda i: q_values[i])
-
-    return legal_actions[argmax_idx]
-
-
-@dispatch(State, RandoPolicy)
-def getnextaction(s, policy):
-    player_idx = gettoplay(s)[0]
-    legal_actions = getlegalactionspecsforplayer(s, player_idx, None, None)
-    action_spec = legal_actions[s.rng.randint(0, len(legal_actions) - 1)]
-
-    if action_spec.action_name == "ROUTE_DISCARD":
-        return AltAction(
-            action_name="ROUTE_DISCARD", 
-            player_idx=player_idx,
-            return_route_cards=[0],
-        )
-    
-    if action_spec.action_name == "DRAW_UNIT_FACEUP":
-        draw_faceup_spot_num = 1
-        return AltAction(
-            action_name="DRAW_UNIT_FACEUP", 
-            player_idx=player_idx,
-            draw_faceup_unit_card_num=s.faceup_spots[draw_faceup_spot_num-1],
-            draw_faceup_spot_num=draw_faceup_spot_num,
-        )
-
-    if action_spec.action_name == "DRAW_UNIT_DECK":
-        return AltAction(
-            action_name="DRAW_UNIT_DECK", 
-            player_idx=player_idx,
-        )
-    
-    if action_spec.action_name == "CLAIM_POINT":
-        point = action_spec.points[s.rng.randint(0, len(action_spec.points) - 1)]
-        return AltAction(
-            action_name="CLAIM_POINT",
-            player_idx=player_idx,
-            point_uuid=str(point.point_uuid),
-            unit_combo=point.default_combo,
-        )
-    
-    return None
-
-
 def getpublicplayerscore(s, player_score):
     if s.terminal:
         # Join the arrays of public and private items
@@ -4448,6 +4114,98 @@ def get_deadlines(s):
     ]
 
 
+def get_public_player_scores(s):
+    return [getpublicplayerscore(s, player_score) for player_score in s.player_scores]
+
+
+# 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]
+# player_graphs = field(type=list)  # List[PlayerGraph]
+# goals = field(type=list)  # List[Goal]
+# nodes = field(type=list)  # List[Node]
+# edges = field(type=list)  # List[BiEdge]
+# regions = field(type=list)
+# decks = field(type=list)  # List[PublicDeck]
+# piles = field(type=list)  # List[Pile]
+# player_idxs = field(type=list)  # List[int]
+# players = field(type=list)  # List[PublicPlayer]
+# last_to_play = field(type=(int, type(None)), initial=None)
+# winners = field(type=list)
+#  = field(type=bool)
+
+
+# player_score = field(type=PrivatePlayerScore)
+# player = field(type=Player)
+# legal_actions_2 = field(type=list)  # List[LegalAction]
+# goal_completions = field(type=list, initial=[])  # List[GoalCompletion]
+
+
+
+def get_public_history(s):
+    return [action.get_public(s) for action in s.history]
+
+def imagine_history(public_state, private_state):
+    pass
+
+def imagine_player_scores(public_state, private_state):
+    pass
+
+def imagine_legal_actions(public_state, private_state):
+    pass
+
+def imagine_players(public_state, private_state):
+    pass
+
+def imagine_decks(public_state, private_state):
+    pass
+
+def imagine_rng(public_state, private_state):
+    pass
+
+
+def imagine_state(public_state, private_state):
+    return State(
+        uuid2edge = public_state.uuid2edge,
+        idx2path = public_state.idx2path,
+        uuid2segment = public_state.uuid2segment,
+        pieceuuid2piece = public_state.pieceuuid2piece,
+        carduuid2card = public_state.carduuid2card,
+        bonus_statuses = public_state.bonus_statuses,
+        bonusuuid2bonusidx = public_state.bonusuuid2bonusidx,
+        carduuid2deckidx = public_state.carduuid2deckidx,
+        starting_decks = public_state.starting_decks,
+        starting_piles = public_state.starting_piles,
+        player_graphs = public_state.player_graphs,
+        goals = public_state.goals,
+        nodes = public_state.nodes,
+        nodeuuid2idx = public_state.nodeuuid2idx,
+        edges = public_state.edges,
+        edgeuuid2idx = public_state.edgeuuid2idx,
+        edgetuple2uuid = public_state.edgetuple2uuid,
+        regions = public_state.regions,
+        terminal = public_state.terminal,
+        last_to_play = public_state.last_to_play,
+        winners = public_state.winners,
+        piles = public_state.piles,
+        player_idxs = public_state.player_idxs,
+        game_config = public_state.game_config,
+        legal_actions_2 = imagine_legal_actions(public_state, private_state),
+        players = imagine_players(public_state, private_state),
+        decks = imagine_decks(public_state, private_state),
+        rng = imagine_rng(public_state, private_state),
+        history = imagine_history(public_state, private_state),
+        player_scores = imagine_player_scores(public_state, private_state),
+    )
+
+
 @dispatch(State)
 def getpublicstate(s):
     return PublicState(
@@ -4459,8 +4217,8 @@ def getpublicstate(s):
         bonus_statuses=s.bonus_statuses,
         starting_decks=s.starting_decks,
         starting_piles=s.starting_piles,
-        history=[action.get_public(s) for action in s.history],
-        player_scores=[getpublicplayerscore(s, player_score) for player_score in s.player_scores],
+        history=get_public_history(s),
+        player_scores=get_public_player_scores(s),
         player_graphs=s.player_graphs,
         goals=s.goals,
         nodes=s.nodes,
@@ -4469,7 +4227,6 @@ def getpublicstate(s):
         decks=[getpublicdeck(s, deck) for deck in s.decks],
         piles=s.piles,
         player_idxs=s.player_idxs,
-        initial_to_play=s.initial_to_play,
         players=[getpublicplayer(s, p) for p in s.players],
         last_to_play=s.last_to_play,
         winners=s.winners,
@@ -4619,18 +4376,6 @@ def gettoplay(s, last_action_type):
     return [getlastplayeridxplus1(s)]
 
 
-# Implementing the following Julia function:
-@dispatch(State, NoAction)
-# function gettoplay(s::State, last_action_key::Nothing)
-#     if getsettingvalue(s, :action_route_discard)
-#         return collect(1:s.game_config.num_players)
-#     end
-#     [getfirstplayeridx(s.game)]
-# end
-def gettoplay(s, last_action_type):
-    return s.initial_to_play
-
-
 def getrng(seed):
     rng = random.Random()
     rng.seed(seed)
@@ -4791,262 +4536,6 @@ def combinations(a, n=None):
 # then the state is "terminal".
 ###
 
-# Implementing the following Julia function:
-# function getrouteoptionsets(s::State, player_idx, min_required)
-#     num_choices = length(s.player_hands[player_idx].new_route_cards)
-#     max_return_size = num_choices - min_required
-#     set = collect(1:num_choices)
-#     OptionSet.(
-#         Set{Int}.(
-#             reduce(
-#                 vcat,
-#                 [collect(combinations(set, n)) for n in 0:max_return_size],
-#             )
-#         )
-#     )
-# end
-def getrouteoptionsets(s, player_idx, min_required):
-    num_choices = len(s.player_hands[player_idx].new_route_cards)
-    max_return_size = num_choices - min_required
-    choice_set = list(range(num_choices))
-    all_combinations = [
-        set(comb)
-        for n in range(max_return_size + 1)
-        for comb in combinations(choice_set, n)
-    ]
-    return [OptionSet(option_idxs=comb) for comb in all_combinations]
-
-
-
-# Implementing the following Julia function:
-# function getlegalactionsforplayer(s::State, player_idx, repeat_player, last_action)
-#     min_initial_routes = getsettingvalue(s.fig, :min_initial_routes)
-#     min_chosen_routes = getsettingvalue(s.fig, :min_chosen_routes)
-
-#     action_specs = ActionSpec[]
-#     if getsettingvalue(s, :action_draw_unit_faceup) && !isempty(getvalidspotnums(s))
-#         push!(
-#             action_specs, 
-#             ActionSpec(
-#                 player_idx=player_idx, 
-#                 action_name=DRAW_UNIT_FACEUP,
-#                 draw_faceup_spots=Dict((spot_num, s.faceup_spots[spot_num]) for spot_num in getvalidspotnums(s)),
-#             )
-#         )
-#     end
-
-#     if getsettingvalue(s, :action_draw_route) && (length(s.route_cards) + length(s.route_discards)) >= min_chosen_routes
-#         push!(action_specs, ActionSpec(s.fig, player_idx, :DRAW_ROUTE))
-#     end
-
-#     if getsettingvalue(s, :action_draw_unit_deck) && (!isempty(s.unit_cards) || !isempty(s.unit_discards))
-#         push!(action_specs, ActionSpec(s.fig, player_idx, :DRAW_UNIT_DECK))
-#     end
-
-#     if getsettingvalue(s, :action_claim_path)
-#         append!(action_specs, getclaimpathactionspecs(s, player_idx))
-#     end
-
-#     if getsettingvalue(s.fig, :action_claim_point)
-#         append!(action_specs, getclaimpointactionspecs(s, player_idx))
-#     end
-
-#     action_specs
-# end
-@dispatch(State, int, object, object)
-def getlegalactionspecsforplayer(s, player_idx, repeat_player, last_action):
-    min_chosen_routes = getsettingvalue(s, 'min_chosen_routes')
-
-    action_specs = []
-    if getsettingvalue(s, 'action_draw_unit_faceup') and s.faceup_spots:
-        
-        # Convert this Julia to Python:
-        # Julia:
-        # draw_faceup_spots = Dict((spot_num, s.faceup_spots[spot_num]) for spot_num in getvalidspotnums(s))
-        # Python:
-        draw_faceup_spots = {spot_num: s.faceup_spots[spot_num-1] for spot_num in getvalidspotnums(s)}
-        
-        action_specs.append(
-            ActionSpec(
-                player_idx=player_idx,
-                action_name="DRAW_UNIT_FACEUP",
-                return_route_option_sets = [],
-                draw_faceup_spots=draw_faceup_spots,
-                points = [],
-                paths = [],
-            )
-        )
-
-    if getsettingvalue(s, 'action_draw_route') and (len(s.route_cards) + len(s.route_discards)) >= min_chosen_routes:
-        action_specs.append(
-            AltAction(
-                player_idx=player_idx, 
-                action_name="DRAW_ROUTE",
-                return_route_option_sets = [],
-                draw_faceup_spots={},
-                points = [],
-                paths = [],
-            )
-        )
-
-    if getsettingvalue(s, 'action_draw_unit_deck') and (s.unit_cards or s.unit_discards):
-        action_specs.append(
-            ActionSpec(
-                player_idx=player_idx, 
-                action_name="DRAW_UNIT_DECK",
-                return_route_option_sets = [],
-                draw_faceup_spots={},
-                points = [],
-                paths = [],
-            )
-        )
-
-    if getsettingvalue(s, 'action_claim_path'):
-        action_specs.extend(getclaimpathactionspecs(s, player_idx))
-        pass
-
-    if getsettingvalue(s, 'action_claim_point'):
-        action_specs.extend(getclaimpointactionspecs(s, player_idx))
-
-    return action_specs
-
-
-# Implementing the following Julia function:
-# function getclaimpointactionspecs(s::State, player_idx::Int; log=false)
-#     action_specs = ActionSpec[]
-#     available_point_statuses = getavailablepoints(s, player_idx)
-#     points = map(available_point_statuses) do available_point_status
-#         (; uuid, sample_fulfillment) = available_point_status
-#         fulfillment_sorted = sample_fulfillment
-#         sample_fulfillment = [x.unit_card_num for x in fulfillment_sorted]
-#         fulfillment_str = join(sample_fulfillment, "-")
-#         PointCombos(uuid, fulfillment_str, sample_fulfillment)
-#     end
-#     if !isempty(points)
-#         push!(
-#             action_specs,
-#             ActionSpec(
-#                 action_name=CLAIM_POINT,
-#                 player_idx=player_idx,
-#                 points=points,
-#             )
-#         )
-#     end
-#     action_specs
-# end
-def getclaimpointactionspecs(s, player_idx, log=False):
-    action_specs = []
-    available_point_statuses = getavailablepoints(s, player_idx)
-    
-    #     points = map(available_point_statuses) do available_point_status
-    #         (; uuid, sample_fulfillment) = available_point_status
-    #         fulfillment_sorted = sample_fulfillment
-    #         sample_fulfillment = [x.unit_card_num for x in fulfillment_sorted]
-    #         fulfillment_str = join(sample_fulfillment, "-")
-    #         PointCombos(uuid, fulfillment_str, sample_fulfillment)
-    #     end
-
-    def process_point_status(available_point_status):
-        uuid = available_point_status['uuid']
-        sample_fulfillment = available_point_status['sample_fulfillment']
-        fulfillment_sorted = sample_fulfillment
-        sample_fulfillment = [x['unit_card_num'] for x in fulfillment_sorted]
-        fulfillment_str = '-'.join(map(str, sample_fulfillment))
-        return PointCombos(
-            point_uuid=uuid,
-            default_combo=fulfillment_str,
-            sample_fulfillment=sample_fulfillment
-        )
-
-    point_combos = list(map(process_point_status, available_point_statuses))
-    
-    if point_combos:
-        action_specs.append(
-            ActionSpec(
-                player_idx=player_idx,
-                action_name="CLAIM_POINT",
-                return_route_option_sets = [],
-                draw_faceup_spots = {},
-                points=point_combos,
-                paths = [],
-            )
-        )
-    
-    return action_specs
-
-
-# Implementing the following Julia function:
-# function getclaimpathactionspecs(s::State, player_idx::Int; log=false)
-#     action_specs = ActionSpec[]
-#     available_path_statuses = getavailablepaths(s, player_idx)
-#     paths = map(available_path_statuses) do available_path_status
-#         (; num, sample_fulfillment) = available_path_status
-#         fulfillment_sorted = Base.sort(sample_fulfillment; by=x -> x.segment_num)
-#         sample_fulfillment = [x.unit_card_num for x in fulfillment_sorted]
-#         fulfillment_str = join(sample_fulfillment, "-")
-#         PathCombos(num, fulfillment_str, sample_fulfillment)
-#     end
-#     if !isempty(paths)
-#         push!(
-#             action_specs,
-#             ActionSpec(
-#                 action_name=CLAIM_PATH,
-#                 player_idx=player_idx,
-#                 paths=paths,
-#             )
-#         )
-#     end
-#     action_specs
-# end
-def getclaimpathactionspecs(s, player_idx, log=False):
-    action_specs = []
-    available_path_statuses = getavailablepathstatuses(s, player_idx)
-    
-    def process_path_status(available_path_status):
-        num = available_path_status.num
-        sample_fulfillment = available_path_status.sample_fulfillment
-        fulfillment_sorted = sorted(sample_fulfillment, key=lambda x: x.segment_num)
-        sample_fulfillment = [x.unit_card_num for x in fulfillment_sorted]
-        fulfillment_str = '-'.join(map(str, sample_fulfillment))
-        return PathCombos(
-            path_idx=(num-1),
-            default_combo=fulfillment_str,
-            sample_fulfillment=sample_fulfillment
-        )
-
-    paths = list(map(process_path_status, available_path_statuses))
-    
-    if paths:
-        action_specs.append(
-            ActionSpec(
-                player_idx=player_idx,
-                action_name="CLAIM_PATH",
-                return_route_option_sets = [],
-                draw_faceup_spots={},
-                points=[],
-                paths=paths,
-            )
-        )
-    
-    return action_specs
-
-
-# Implementing the following Julia function:
-# function getavailablepaths(s::State, player_num::Int)
-#     balance = s.player_hands[player_num].unit_cards
-#     path_statuses = map(getpotentialpathnums(s, player_num)) do path_num
-#         getpathstatus(s, player_num, path_num)
-#     end
-#     filter(x -> x.fulfillable, path_statuses)
-# end
-def getavailablepathstatuses(s, player_num):
-    balance = s.player_hands[player_num].unit_cards
-    path_statuses = [
-        getpathstatus(s, player_num, path_idx)
-        for path_idx in getpotentialpathidxs(s, player_num)
-    ]
-    return list(filter(lambda x: x.fulfillable, path_statuses))
-
 
 # Implementing the following Julia function:
 # function getpotentialpathnums(s::State, player_num::Int)
@@ -5275,409 +4764,9 @@ def getclaimedpathidxs(s):
     return claimed
 
 
-# Implementing the following Julia function:
-# function getpathstatus(s::State, player_idx, path_num)
-#     balance = s.player_hands[player_idx].unit_cards
-#     (; fig) = s
-#     (; board_config) = fig
-#     (; deck_units, board_paths) = board_config
-#     unituuid2deckunit = Dict(x.unit_uuid => x for x in deck_units)
-#     path = board_paths[path_num]
-#     ordered_segments = prioritysort(fig, path.path.segments)
-#     fulfillment = OrderedFullfillment[]
-#     wild_unit_uuids = getwildunituuids(fig)
-#     # @show wild_unit_uuids
-#     non_wild_unit_uuids = getnonwildunituuids(fig)
-#     # @show non_wild_unit_uuids
-
-#     # @show balance
-
-#     balance_unituuid2deckcardnums = Dict()
-#     for deck_card_num in balance
-#         unit_uuid = getunituuid(fig, deck_card_num)
-#         if !haskey(balance_unituuid2deckcardnums, unit_uuid)
-#             balance_unituuid2deckcardnums[unit_uuid] = []
-#         end
-#         push!(balance_unituuid2deckcardnums[unit_uuid], deck_card_num)
-#     end
 
-#     # @show balance_unituuid2deckcardnums
 
-#     function hasexactunitmatch(unit_uuid)
-#         (
-#             haskey(balance_unituuid2deckcardnums, unit_uuid) &&
-#             length(balance_unituuid2deckcardnums[unit_uuid]) > 0
-#         )
-#     end
 
-#     function anywildsleft()
-#         for wild_unit_uuid in wild_unit_uuids
-#             if haskey(balance_unituuid2deckcardnums, wild_unit_uuid)
-#                 if !isempty(balance_unituuid2deckcardnums[wild_unit_uuid])
-#                     return true
-#                 end
-#             end
-#         end
-#         false
-#     end
-
-#     function gettotalwildcount()
-#         count = 0
-#         for wild_unit_uuid in wild_unit_uuids
-#             if haskey(balance_unituuid2deckcardnums, wild_unit_uuid)
-#                 count += length(balance_unituuid2deckcardnums[wild_unit_uuid])
-#             end
-#         end
-#         count
-#     end
-
-#     function popawildcard!()
-#         for wild_unit_uuid in wild_unit_uuids
-#             if haskey(balance_unituuid2deckcardnums, wild_unit_uuid)
-#                 if !isempty(balance_unituuid2deckcardnums[wild_unit_uuid])
-#                     return pop!(balance_unituuid2deckcardnums[wild_unit_uuid])
-#                 end
-#             end
-#         end
-#         nothing
-#     end
-
-#     function getnonemptywildstack()
-#         for wild_unit_uuid in wild_unit_uuids
-#             if haskey(balance_unituuid2deckcardnums, wild_unit_uuid)
-#                 if !isempty(balance_unituuid2deckcardnums[wild_unit_uuid])
-#                     return balance_unituuid2deckcardnums[wild_unit_uuid]
-#                 end
-#             end
-#         end
-#         nothing
-#     end
-
-#     function getlargestnonwildstack()
-#         largest_non_wild_unit_uuid = nothing
-#         largest_found = 0
-#         for non_wild_unit_uuid in non_wild_unit_uuids
-#             if haskey(balance_unituuid2deckcardnums, non_wild_unit_uuid)
-#                 curr_length = length(balance_unituuid2deckcardnums[non_wild_unit_uuid])
-#                 if curr_length > largest_found
-#                     largest_found = curr_length
-#                     largest_non_wild_unit_uuid = non_wild_unit_uuid
-#                 end
-#             end
-#         end
-#         if !isnothing(largest_non_wild_unit_uuid)
-#             return balance_unituuid2deckcardnums[largest_non_wild_unit_uuid]
-#         end
-#         nothing
-#     end
-
-#     for ordered_segment in ordered_segments
-#         target_segment = ordered_segment.segment
-#         segment_num = ordered_segment.path_segment_num
-#         (; unit_uuid) = target_segment
-#         # @show unit_uuid
-#         # @show keys(unituuid2deckunit)
-#         target_unit = isnothing(unit_uuid) ? nothing : unituuid2deckunit[unit_uuid]
-#         # @show target_unit
-
-#         if isnothing(target_unit)
-#             # do nothing (this is a blank segment)
-#         elseif target_unit.is_wild
-#             if hasexactunitmatch(unit_uuid)
-#                 popped = pop!(balance_unituuid2deckcardnums[unit_uuid])
-#                 push!(fulfillment, OrderedFullfillment(segment_num, popped))
-#             end
-#         else
-#             # @show 3
-#             if hasexactunitmatch(unit_uuid)
-#                 # @show 4
-#                 popped = pop!(balance_unituuid2deckcardnums[unit_uuid])
-#                 push!(fulfillment, OrderedFullfillment(segment_num, popped))
-#             elseif anywildsleft()
-#                 # @show 5
-#                 non_empty_wild_stack = getnonemptywildstack()
-#                 popped = pop!(non_empty_wild_stack)
-#                 push!(fulfillment, OrderedFullfillment(segment_num, popped))
-#             end
-#         end
-#     end
-
-#     blank_remaining_segments = filter(
-#         ordered_segment -> isblank(ordered_segment.segment.unit_uuid),
-#         ordered_segments,
-#     )
-#     # @show blank_remaining_segments
-#     largest_non_wild_stack = getlargestnonwildstack()
-#     # @show largest_non_wild_stack
-#     for blank_remaining_segment in blank_remaining_segments
-#         if !isnothing(largest_non_wild_stack) && !isempty(largest_non_wild_stack)
-#             popped = pop!(largest_non_wild_stack)
-#             push!(fulfillment, OrderedFullfillment(blank_remaining_segment.path_segment_num, popped))
-#         elseif gettotalwildcount() > 0
-#             popped = popawildcard!()
-#             push!(fulfillment, OrderedFullfillment(blank_remaining_segment.path_segment_num, popped))
-#         end
-#     end
-
-#     # @show fulfillment
-#     deepq_edges = map(ordered_segments) do ordered_segment
-#         (; path_segment_num) = ordered_segment
-#         (; segment) = ordered_segment
-#         fullfillable_by_me = in(path_segment_num, [x.segment_num for x in fulfillment])
-#         captured_by_me = in(path_num, s.player_hands[player_idx].paths)
-#         captured_by_other = !captured_by_me && in(path_num, getclaimedpathidxs(s))
-#         available_to_me = !(captured_by_me || captured_by_other) && fullfillable_by_me
-#         status = "Other"
-#         if captured_by_me
-#             status = "CapturedByMe"
-#         elseif captured_by_other
-#             status = "CapturedByOther"
-#         elseif available_to_me
-#             status = "AvailableToMe" 
-#         end
-#         SegmentStatus(
-#             path_num,
-#             path_segment_num,
-#             captured_by_me,
-#             captured_by_other,
-#             available_to_me,
-#             status,
-#             segment,
-#         )
-#     end
-
-#     fulfillable = Base.all([x.available_to_me for x in deepq_edges])
-#     PathStatus(path_num, fulfillable, deepq_edges, fulfillment)
-# end
-def getpathstatus(s, player_idx, path_idx):
-    path_num = path_idx + 1
-    balance = s.player_hands[player_idx].unit_cards
-    fig = s.game_config.fig
-    board_config = fig.board_config
-    deck_units = board_config.deck_units
-    board_paths = board_config.board_paths
-    unituuid2deckunit = {x.unit_uuid: x for x in deck_units}
-    path = board_paths[path_idx]
-    ordered_segments = prioritysort(fig, path.path.segments)
-    fulfillment = []
-    wild_unit_uuids = getwildunituuids(fig)
-    non_wild_unit_uuids = getnonwildunituuids(fig)
-
-    balance_unituuid2deckcardnums = {}
-
-    for deck_card_num in balance:
-        unit_uuid = getunituuid(fig, deck_card_num)
-        if unit_uuid not in balance_unituuid2deckcardnums:
-            balance_unituuid2deckcardnums[unit_uuid] = []
-        balance_unituuid2deckcardnums[unit_uuid].append(deck_card_num)
-
-    def hasexactunitmatch(unit_uuid):
-        # print("unit_uuid: ", unit_uuid)
-        # print("balance_unituuid2deckcardnums: ", balance_unituuid2deckcardnums)
-        print("")
-        return (
-            unit_uuid in balance_unituuid2deckcardnums and
-            len(balance_unituuid2deckcardnums[unit_uuid]) > 0
-        )
-
-    def anywildsleft():
-        for wild_unit_uuid in wild_unit_uuids:
-            if wild_unit_uuid in balance_unituuid2deckcardnums:
-                if balance_unituuid2deckcardnums[wild_unit_uuid]:
-                    return True
-        return False
-
-    def gettotalwildcount():
-        count = 0
-        for wild_unit_uuid in wild_unit_uuids:
-            if wild_unit_uuid in balance_unituuid2deckcardnums:
-                count += len(balance_unituuid2deckcardnums[wild_unit_uuid])
-        return count
-
-    def popawildcard():
-        for wild_unit_uuid in wild_unit_uuids:
-            if wild_unit_uuid in balance_unituuid2deckcardnums:
-                if balance_unituuid2deckcardnums[wild_unit_uuid]:
-                    return balance_unituuid2deckcardnums[wild_unit_uuid].pop()
-        return None
-
-    def getnonemptywildstack():
-        for wild_unit_uuid in wild_unit_uuids:
-            if wild_unit_uuid in balance_unituuid2deckcardnums:
-                if balance_unituuid2deckcardnums[wild_unit_uuid]:
-                    return balance_unituuid2deckcardnums[wild_unit_uuid]
-        return None
-
-    def getlargestnonwildstack():
-        largest_non_wild_unit_uuid = None
-        largest_found = 0
-        for non_wild_unit_uuid in non_wild_unit_uuids:
-            if non_wild_unit_uuid in balance_unituuid2deckcardnums:
-                curr_length = len(balance_unituuid2deckcardnums[non_wild_unit_uuid])
-                if curr_length > largest_found:
-                    largest_found = curr_length
-                    largest_non_wild_unit_uuid = non_wild_unit_uuid
-        if largest_non_wild_unit_uuid is not None:
-            return balance_unituuid2deckcardnums[largest_non_wild_unit_uuid]
-        return None
-    
-    for ordered_segment in ordered_segments:
-        target_segment = ordered_segment.segment
-        segment_num = ordered_segment.path_segment_num
-        unit_uuid = target_segment.unit_uuid
-        target_unit = None if unit_uuid is None else unituuid2deckunit[unit_uuid]
-
-        if target_unit is None:
-            # do nothing (this is a blank segment)
-            pass
-        elif target_unit.is_wild:
-            if hasexactunitmatch(unit_uuid):
-                popped = balance_unituuid2deckcardnums[unit_uuid].pop()
-                fulfillment.append(OrderedFullfillment(segment_num=segment_num, unit_card_num=popped))
-        else:
-            # print("anywildsleft(): ", anywildsleft())
-            if hasexactunitmatch(unit_uuid):
-                popped = balance_unituuid2deckcardnums[unit_uuid].pop()
-                fulfillment.append(OrderedFullfillment(segment_num=segment_num, unit_card_num=popped))
-            elif anywildsleft():
-                non_empty_wild_stack = getnonemptywildstack()
-                popped = non_empty_wild_stack.pop()
-                fulfillment.append(OrderedFullfillment(segment_num=segment_num, unit_card_num=popped))
-            # @show 5
-    
-    blank_remaining_segments = list(filter(
-        lambda ordered_segment: ordered_segment.segment.unit_uuid is None,
-        ordered_segments,
-    ))
-
-    largest_non_wild_stack = getlargestnonwildstack()
-
-    for blank_remaining_segment in blank_remaining_segments:
-        if largest_non_wild_stack is not None and largest_non_wild_stack:
-            popped = largest_non_wild_stack.pop()
-            fulfillment.append(OrderedFullfillment(segment_num=blank_remaining_segment.path_segment_num, unit_card_num=popped))
-        elif gettotalwildcount() > 0:
-            popped = popawildcard()
-            fulfillment.append(OrderedFullfillment(segment_num=blank_remaining_segment.path_segment_num, unit_card_num=popped))
-    
-    # Implementing the following Julia code:
-    # deepq_edges = map(ordered_segments) do ordered_segment
-    #     (; path_segment_num) = ordered_segment
-    #     (; segment) = ordered_segment
-    #     fullfillable_by_me = in(path_segment_num, [x.segment_num for x in fulfillment])
-    #     captured_by_me = in(path_num, s.player_hands[player_idx].paths)
-    #     captured_by_other = !captured_by_me && in(path_num, getclaimedpathidxs(s))
-    #     available_to_me = !(captured_by_me || captured_by_other) && fullfillable_by_me
-    #     status = "Other"
-    #     if captured_by_me
-    #         status = "CapturedByMe"
-    #     elseif captured_by_other
-    #         status = "CapturedByOther"
-    #     elseif available_to_me
-    #         status = "AvailableToMe" 
-    #     end
-    #     SegmentStatus(
-    #         path_num,
-    #         path_segment_num,
-    #         captured_by_me,
-    #         captured_by_other,
-    #         available_to_me,
-    #         status,
-    #         segment,
-    #     )
-    # end
-    # fulfillable = Base.all([x.available_to_me for x in deepq_edges])
-    # PathStatus(path_num, fulfillable, deepq_edges, fulfillment)
-    deepq_edges = []
-    for ordered_segment in ordered_segments:
-        path_segment_num = ordered_segment.path_segment_num
-        segment = ordered_segment.segment
-        fullfillable_by_me = path_segment_num in [x.segment_num for x in fulfillment]
-        captured_by_me = path_idx in s.player_hands[player_idx].paths
-        captured_by_other = not captured_by_me and path_idx in getclaimedpathidxs(s)
-        available_to_me = not (captured_by_me or captured_by_other) and fullfillable_by_me
-        status = "Other"
-        if captured_by_me:
-            status = "CapturedByMe"
-        elif captured_by_other:
-            status = "CapturedByOther"
-        elif available_to_me:
-            status = "AvailableToMe"
-        
-        deepq_edges.append(
-            SegmentStatus(
-                path_idx=path_idx,
-                path_num=path_num,
-                path_segment_num=path_segment_num,
-                captured_by_me=captured_by_me,
-                captured_by_other=captured_by_other,
-                available_to_me=available_to_me,
-                status=status,
-                segment=segment
-            )
-        )
-    
-    fulfillable = all([x.available_to_me for x in deepq_edges])
-    return PathStatus(
-        idx=path_idx,
-        num=path_num,
-        fulfillable=fulfillable,
-        segment_statuses=deepq_edges,
-        sample_fulfillment=fulfillment
-    )
-
-
-# Implementing the following Julia function:
-# function getavailablepoints(s::State, player_num::Int)
-#     point_statuses = map(getpotentialpointuuids(s, player_num)) do point_uuid
-#         getpointstatus(s, player_num, point_uuid)
-#     end
-#     sort(filter(x -> x.fulfillable, point_statuses); by=x -> x.uuid)
-# end
-def getavailablepoints(s, player_num):
-    point_statuses = [
-        getpointstatus(s, player_num, point_uuid)
-        for point_uuid in getpotentialpointuuids(s, player_num)
-    ]
-    return sorted(
-        filter(lambda x: x['fulfillable'], point_statuses),
-        key=lambda x: x['uuid']
-    )
-
-# Implementing the following Julia function:
-# function getpointstatus(s::State, player_idx::Int, point_uuid::UUID)
-#     balance = s.player_hands[player_idx].unit_cards
-#     fulfillment = OrderedPointFullfillment[]
-#     if !isempty(balance)
-#         push!(fulfillment, OrderedPointFullfillment(balance[1]))
-#     end
-#     PointStatus(point_uuid, true, fulfillment)
-# end
-def getpointstatus(s, player_idx, point_uuid):
-    balance = s.player_hands[player_idx].unit_cards
-    fulfillment = []
-    if balance:
-        fulfillment.append({'unit_card_num': balance[0]})
-    return {
-        'uuid': point_uuid,
-        'fulfillable': True,
-        'sample_fulfillment': fulfillment
-    }
-
-# Implementing the following Julia function:
-# function getpotentialpointuuids(s::State, player_num::Int)
-#     (; num_point_pieces) = s.player_hands[player_num]
-#     setdiff(
-#         Set(getnodeuuids(s.fig, num_point_pieces)),
-#         Set(getunavailablepoints(s)),
-#     ) |> collect
-# end
-def getpotentialpointuuids(s, player_num):
-    num_point_pieces = s.player_hands[player_num].num_point_pieces
-    return list(
-        set(getnodeuuids(s.game_config.fig, num_point_pieces)) -
-        set(getunavailablepoints(s))
-    )
 
 # Implementing the following Julia function:
 # function getnodeuuids(f::Fig, remaining_pieces::Int)
@@ -5714,33 +4803,6 @@ def getunavailablepoints(s):
     return unavailable_points
 
 
-# Implementing the following Julia function:
-# function calcfinalscores(s::State)
-#     if !s.terminal
-#         return s
-#     end
-#     @reset s.player_hands = calcfinalscore.(s, s.player_hands)
-#     s
-# end
-@dispatch(State)
-def calcfinalscores(s):
-    if not s.terminal:
-        return s
-    return s.set(player_hands=pvector([calcfinalscore(s, h) for h in s.player_hands]))
-
-
-# Implementing the following Julia function:
-# function calcfinalscore(s::State, hand::PlayerInfo)
-#     (; total, breakdown) = getprivatescore(s, hand)
-#     @reset hand.final_score = PlayerScore(total, breakdown)
-#     hand
-# end
-@dispatch(State, PlayerInfo)
-def calcfinalscore(s, hand):
-    total, breakdown = getprivatescore(s, hand)
-    return hand.set(final_score=PlayerScore(total=total, breakdown=breakdown))
-
-
 # Implementing the following Julia function:
 # function calcwinners(s::State)
 #     if !s.terminal
@@ -5764,158 +4826,15 @@ def calcwinners(s):
 
 
 def printplayer(s, player_idx):
-    hand = s.player_hands[player_idx]
-    legal_actions = getlegalactionspecs(s, player_idx)
-    print(f"~~~~~~~~~~~~ P{player_idx} ~~~~~~~~~~~~")
-    print(f"private score:     {getprivatescore(s, hand)}")
-    print(f"public score:       {getpublicscore(s, player_idx)}")
-    print(f"completed clusters: {list(str(c) for c in hand.completed_clusters)}")
-    print(f"units:              {list(hand.unit_cards)}")
-    if getsettingvalue(s, "route_scoring"):
-        print(f"routes:            {list(hand.route_cards)} choices:{list(hand.new_route_cards)}")
-    print(f"captured points:    {list(str(p) for p in hand.points)}")
-    print(f"legal actions:      {list(a.action_name for a in legal_actions)}")
+    pass
 
 
 def printstate(s):
-    print(f"*************** State {state_idx} ***************")
-    print(f"Last to play:    {s.last_to_play}")
-    print(f"Winners:         {list(s.winners)}")
-    print(f"Route Deck:      {list(s.route_cards)}")
-    print(f"Route Disc:      {list(s.route_discards)}")
-    print(f"Unit Deck:       ...{list(s.unit_cards[60:])}")
-    print(f"Unit Disc:       {list(s.unit_discards)}")
-    print(f"FaceUp:          {list(s.faceup_spots)}")
-    print(f"ToPlay:          {gettoplay(s)}")
-    print(f"Terminal:        {s.terminal}")
-    
-    for i in range(s.game_config.num_players):
-        printplayer(s, i)
-    print(f"****************************************\n")
+    pass
 
 
 def printaction(a, i):
-    print(f"\n\n*************** Action {i} ***************")
-    print(f"{a}")
-    print(f"****************************************\n\n\n")
-
-
-# Implementing the following Julia function:
-# function getprivatescore(s::State, hand::PlayerInfo; bonus=true)
-#     player_idx = hand.player_idx
-#     breakdown = []
-
-#     # Path scores
-#     if getsettingvalue(s, :path_scoring)
-#         (; path_scores) = s.fig
-#         for len in getplayerpathlens(s, player_idx)
-#             push!(
-#                 breakdown, 
-#                 ScoreItem(
-#                     code_idx=getscorecodeidx(s.fig, :PATH),
-#                     amount=path_scores[len],
-#                 )
-#             )
-#         end
-#     end
-    
-#     # Bonus: most clusters
-#     if getsettingvalue(s, :most_clusters_bonus)
-#         bonus_most_clusters_score = getsettingvalue(s.fig, :bonus_most_clusters_score)
-#         if in(player_idx, s.most_clusters_player_idxs)
-#             push!(
-#                 breakdown, 
-#                 ScoreItem(
-#                     code_idx=getscorecodeidx(s.fig, :MOST_CLUSTERS),
-#                     amount=bonus_most_clusters_score,
-#                 )
-#             )
-#         end
-#     end
-#
-#     # Completed routes
-#     if getsettingvalue(s, :route_scoring)
-#         hand = s.player_hands[player_idx]
-#         (; board_config) = s.fig
-#         (; routes) = board_config
-#         for route_idx in hand.route_cards
-#             route_score = routes[route_idx].score
-#             amount = in(route_idx, hand.completed_routes) ? route_score : -1*route_score
-#             push!(
-#                 breakdown, 
-#                 ScoreItem(
-#                     code_idx=getscorecodeidx(s.fig, :ROUTE),
-#                     amount=amount
-#                 )
-#             )
-#         end
-#     end
-
-#     # Completed clusters
-#     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!(breakdown, 
-#                 ScoreItem(
-#                     code_idx=getscorecodeidx(s.fig, :CLUSTER),
-#                     amount=sum(cluster_scores)
-#                 )
-#             )
-#         end
-#     end
-
-#     amounts = [item.amount for item in breakdown]
-#     total = sum(amounts; init=0)
-#     (
-#         total=total,
-#         breakdown=breakdown,
-#     )
-# end
-@dispatch(State, PlayerInfo)
-def getprivatescore(s, hand):
-    player_idx = hand.player_idx
-    breakdown = []
-
-    # Path scores
-    if getsettingvalue(s, 'path_scoring'):
-        path_scores = s.game_config.fig.path_scores
-        for len in getplayerpathlens(s, player_idx):
-            breakdown.append(ScoreItem(
-                code_idx=getscorecodeidx(s.game_config.fig, 'PATH'),
-                amount=path_scores[len],
-            ))
-
-    # Completed routes
-    if False and getsettingvalue(s, 'route_scoring'):
-        routes = s.game_config.fig.board_config.routes
-        for route_idx in hand.route_cards:
-            route_score = routes[route_idx].score
-            amount = route_score if route_idx in hand.completed_routes else -1 * route_score
-            breakdown.append(ScoreItem(
-                code_idx=getscorecodeidx(s.game_config.fig, 'ROUTE'),
-                amount=amount
-            ))
-
-    # Completed clusters
-    if getsettingvalue(s, 'cluster_scoring'):
-        clusters = s.game_config.fig.board_config.clusters
-        uuid2cluster = {x.uuid: x for x in clusters}
-        completed_clusters = hand.completed_clusters
-        cluster_scores = [uuid2cluster[cluster_uuid].score for cluster_uuid in completed_clusters]
-        if cluster_scores:
-            breakdown.append(ScoreItem(
-                code_idx=getscorecodeidx(s.game_config.fig, 'CLUSTER'),
-                amount=sum(cluster_scores)
-            ))
-
-    amounts = [item.amount for item in breakdown]
-    total = sum(amounts)
-    return total, breakdown
+    pass
 
 
 # Implementing the following Julia function:
@@ -5954,46 +4873,6 @@ def getscorecodes(f):
     return score_codes
 
 
-# Implementing the following Julia function:
-# function assertunitcardsaccountedfor(s::State) 
-#     total_num_unit_cards = gettotaldeckcards(s.fig)
-#     total_found = getunitcardstotalfound(s)
-#     @assert total_num_unit_cards == total_found "Unit cards not accounted for. $(total_num_unit_cards) != $(total_found)"
-# end
-def assertunitcardsaccountedfor(s):
-    total_num_unit_cards = gettotaldeckcards(s.game_config.fig)
-    total_found = getunitcardstotalfound(s)
-    assert total_num_unit_cards == total_found, f"Unit cards not accounted for. {total_num_unit_cards} != {total_found}"
-
-
-# Implementing the following Julia function:
-# function getunitcardstotalfound(s::State)
-#     num_player_unit_cards = sum(gettotalnumunitcards.(s.player_hands))
-#     total_found = sum([
-#         num_player_unit_cards,
-#         length(s.unit_discards),
-#         length(s.unit_cards),
-#         length(getvalidspotnums(s)),
-#     ])
-#     total_found
-# end
-def getunitcardstotalfound(s):
-    num_player_unit_cards = sum(gettotalnumunitcards(p) for p in s.player_hands)
-    total_found = sum([
-        num_player_unit_cards,
-        len(s.unit_discards),
-        len(s.unit_cards),
-        len(getvalidspotnums(s)),
-    ])
-    return total_found
-
-
-# Implementing the following Julia function:
-# gettotalnumunitcards(player_hand::PlayerInfo) = length(player_hand.unit_cards)
-def gettotalnumunitcards(player_hand):
-    return len(player_hand.unit_cards)
-
-
 # Implementing the following Julia function:
 # function getvalidspotnums(s::State)
 #     filter(n -> !isnothing(s.faceup_spots[n]), 1:length(s.faceup_spots))
@@ -6002,44 +4881,6 @@ def getvalidspotnums(s):
     return [n for n in range(1, len(s.faceup_spots) + 1) if s.faceup_spots[n-1] is not None]
 
 
-# Implementing the following Julia function:
-# function assertroutecardsaccountedfor(s::State)
-#     total_num_route_cards = getnumroutecards(s.fig)
-#     num_player_route_cards = sum(gettotalnumroutecards.(s.player_hands))
-#     total_found = sum([
-#         num_player_route_cards, 
-#         length(s.route_discards), 
-#         length(s.route_cards),
-#     ])
-#     @assert total_num_route_cards == total_found "Route cards not accounted for. $(total_num_route_cards) != $(total_found)"
-# end
-def assertroutecardsaccountedfor(s):
-    total_num_route_cards = getnumroutecards(s.game_config.fig)
-    num_player_route_cards = sum(gettotalnumroutecards(p) for p in s.player_hands)
-    total_found = sum([
-        num_player_route_cards, 
-        len(s.route_discards), 
-        len(s.route_cards),
-    ])
-    assert total_num_route_cards == total_found, f"Route cards not accounted for. {total_num_route_cards} != {total_found}"
-
-
-# Implementing the following Julia function:
-# gettotalnumroutecards(player_hand::PlayerInfo) = length(player_hand.route_cards) + length(player_hand.new_route_cards)
-def gettotalnumroutecards(player_hand):
-    return len(player_hand.route_cards) + len(player_hand.new_route_cards)
-
-
-# Implementing the following Julia function:
-# function assertallcardsaccountedfor(s::State)
-#     assertroutecardsaccountedfor(s)
-#     assertunitcardsaccountedfor(s)
-# end
-def assertallcardsaccountedfor(s):
-    assertroutecardsaccountedfor(s)
-    assertunitcardsaccountedfor(s)
-
-
 # Implementing the following Julia function:
 # function getlegalactions(s::State)
 #     getlegalactions(s, gettoplay(s))
@@ -6126,7 +4967,6 @@ def getprivatestate(s, player_idx):
         player=s.players[player_idx],
         legal_actions_2 = get_legal_actions(s, player_idx),
         legal_actions=legal_actions,
-        hand=s.player_hands[player_idx],
         goal_completions=goal_completions,
     )
 
@@ -6274,132 +5114,92 @@ def diff(A, dims=None):
             return [[A[i][j] - A[i][j - 1] for j in range(1, len(A[0]))] for i in range(len(A))]
         else:
             raise ValueError("dims must be either 1 or 2")
-        
 
-@dispatch(StaticBoardConfig, PlayerState)
-def get_imagined_state(static_board_config, player_state):
-    board_config = static_board_config.board_config
-    public_state = player_state.public
-    private_state = player_state.private
-    my_hand = private_state.hand
-
-    fig = initfig("af472d67-05ec-4b5d-9eb7-6b0cea9eec5a", board_config)
-    seed = 4012489341 # TODO: this should be random (or if non-stochastic, loaded from the net.seed)
-    rng = getrng(seed)
-
-    # TODO: this needs to come from x_json['game_config']
-    game_config = GameConfig(
-        uuid = str(generate_uuid_with_rng(rng)),
-        started_at = "2025-01-01 00:00:00",
-        num_players = 2, 
-        fig = fig,
-        seed = seed     
-    )
 
-    possible_route_card_idxs = list(range(getnumroutecards(fig)))
-    possible_unit_card_idxs = list(range(gettotaldeckcards(fig)))
+def get_default_toplay(s):
+    if s.legal_actions_2:
+        return s.legal_actions_2[0].player_idx
+    return None
 
-    def remove_card_idx(to_mutate, card_idx):
-        if card_idx in to_mutate:
-            to_mutate.remove(card_idx)
 
-    def remove_card_idxs(to_mutate, card_idxs):
-        for card_idx in card_idxs:
-            remove_card_idx(to_mutate, card_idx)
+def get_intuited_best_actions(ps):
+    if not ps.legal_actions_2:
+        return None
+    return ps.legal_actions_2[:8]
 
-    
-    # imagined_route_card_idxs = rng.sample(possible_route_card_idxs, public_state.num_route_cards)
-    remove_card_idxs(possible_route_card_idxs, imagined_route_card_idxs)
-    # imagined_route_discard_idxs = rng.sample(possible_route_card_idxs, public_state.num_route_discards)
-    remove_card_idxs(possible_route_card_idxs, imagined_route_discard_idxs)
 
-    imagined_route_cards = [x+1 for x in imagined_route_card_idxs]
-    imagined_route_discards = [x+1 for x in imagined_route_discard_idxs]
+def get_spread(q_values, p_idx):
+    my_q = q_values[p_idx]
+    other_qs = [q for i, q in enumerate(q_values) if i != p_idx]
+    spread = my_q - max(other_qs)
+    return spread
 
-    for unit_card in public_state.unit_discards:
-        remove_card_idx(possible_unit_card_idxs, unit_card-1)
 
-    for unit_card in my_hand.unit_cards:
-        remove_card_idx(possible_unit_card_idxs, unit_card-1)
+def getvproxy0(ps):
+    return 0
 
-    # imagined_unit_card_idxs = rng.sample(possible_unit_card_idxs, public_state.num_unit_cards)
-    # imagined_unit_cards = [x+1 for x in imagined_unit_card_idxs]
-    # remove_card_idxs(possible_unit_card_idxs, imagined_unit_card_idxs)
 
+def imagine_dynamics(ps, a):
+    return dynamics(imagine_state(ps), a)
 
-    imagined_player_hands = []
 
-    for (player_idx, public_player_info) in enumerate(public_state.player_hands):
-        if player_idx == my_hand.player_idx:
-            imagined_player_hands.append(PlayerInfo.clone(my_hand))
-        else:
-            # imagined_player_unit_card_idxs = rng.sample(possible_unit_card_idxs, public_player_info.num_unit_cards)
-            imagined_player_unit_cards = [x+1 for x in imagined_player_unit_card_idxs]
-            remove_card_idxs(possible_unit_card_idxs, imagined_player_unit_card_idxs)
-            # imagined_player_route_card_idxs = rng.sample(possible_route_card_idxs, public_player_info.num_route_cards)
-            remove_card_idxs(possible_route_card_idxs, imagined_player_route_card_idxs)
-            imagined_player_new_route_card_idxs = rng.sample(possible_route_card_idxs, public_player_info.num_new_route_cards)
-            remove_card_idxs(possible_route_card_idxs, imagined_player_new_route_card_idxs)
-            imagined_player_route_cards = [x+1 for x in imagined_player_route_card_idxs]
-            imagined_player_new_route_cards = [x+1 for x in imagined_player_new_route_card_idxs]
-            imagined_player_hands.append(
-                PlayerInfo(
-                    fig = fig,
-                    player_idx = player_idx,
-                    new_route_cards = pvector(imagined_player_new_route_cards), # Guess at this.
-                    route_cards = pvector(imagined_player_route_cards), # Guess at this.
-                    unit_cards = pvector(imagined_player_unit_cards), # Guess at this.
-                    completed_routes = [], # Guess at this.
-                    completed_clusters = public_player_info.completed_clusters,
-                    paths = public_player_info.paths,
-                    points = public_player_info.points,
-                    tokens = public_player_info.tokens,
-                    num_pieces = public_player_info.num_pieces,
-                    num_point_pieces = public_player_info.num_point_pieces,
-                    longest_trail = public_player_info.longest_trail,
-                    longest_trail_len = public_player_info.longest_trail_len,
-                    final_score = public_player_info.final_score,
-                )
-            )
+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))]
+    return next_s, rewards
 
 
-    nodeuuid2idx = {node.uuid: idx for idx, node in enumerate(board_config.points)}
-    edges = get_edges(rng, board_config, nodeuuid2idx)
-    edgeuuid2idx = {edge.uuid: idx for idx, edge in enumerate(edges)}
-    edgetuple2uuid = {}
-    for edge in edges:
-        node_1_idx = nodeuuid2idx[edge.node_1_uuid]
-        node_2_idx = nodeuuid2idx[edge.node_2_uuid]
-        edge_tuple = (min(node_1_idx, node_2_idx), max(node_1_idx, node_2_idx))
-        edgetuple2uuid[edge_tuple] = edge.uuid
-    
-    return State(
-        final_scores = None,
-        player_graphs = [],
-        nodes = get_nodes(board_config),
-        nodeuuid2idx = nodeuuid2idx,
-        edges = edges,
-        edgeuuid2idx = edgeuuid2idx,
-        edgetuple2uuid = edgetuple2uuid,
-        regions = get_regions(board_config),
-        legal_actions = [],  # TODO: Should use PublicState, but empty for now.
-        piles = [], # TODO: Should use PublicState, but empty for now.
-        players = [], # TODO: Should use PublicState, but empty for now.
-        player_idxs = public_state.player_idxs,
-        decks = [], # TODO: Should use PublicState, but empty for now.
-        game_config = game_config,
-        rng = rng, # TODO: again figure out this stochasticity
-        terminal = public_state.terminal,
-        initial_to_play = public_state.initial_to_play,
-        route_cards = pvector(imagined_route_cards), # Guess at this.
-        route_discards = pvector(imagined_route_discards), # Guess at this.
-        player_hands = pvector(imagined_player_hands), # Guess at this.
-        unit_cards = pvector(imagined_unit_cards), # Guess at this.
-        faceup_spots = pvector(public_state.faceup_spots),
-        unit_discards = pvector(public_state.unit_discards),
-        last_to_play = public_state.last_to_play,
-        winners = public_state.winners,
-    )
+def alpha0(ps):
+    td = 3
+    legal_actions = ps.legal_actions_2
+    if not legal_actions:
+        return None
+    intuited = get_intuited_best_actions(ps)
+    q_proxies = [getqproxy0(ps, a, td) for a in intuited]
+    max_spread_idx = get_max_spread_idx(q_proxies, ps.player.player_idx)
+    return intuited[max_spread_idx]
+
+
+def get_max_spread_idx(q_proxies, p_idx):
+    spreads = [get_spread(q_proxy, p_idx) for q_proxy in q_proxies]
+    max_spread_idx = np.argmax(spreads)
+    return max_spread_idx
+
+
+def getqproxy0(ps, a, td):
+
+    def qproxybase():
+        next_s, rewards = imagine_dynamics(ps, a)
+        if next_s.terminal:
+            return rewards
+        v_proxies = [
+            getvproxy0(getprivatestate(next_s, i))
+            for i in range(next_s.game_config.num_players)
+        ]
+        q_proxies = [
+            r + v_proxies[i]
+            for i, r in enumerate(rewards)
+        ]
+        return q_proxies
+
+    def qproxyrecurse():
+        next_s, rewards = imagine_dynamics(ps, a)
+        if next_s.terminal:
+            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]
+        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)]
+        return q_values
+
+    return qproxyrecurse() if td > 0 else qproxybase()
+
 
 INIT_HOOK_1 = """def handler(game):
     return shuffle_all_decks(game)