graph-games-proto 0.3.1990__py3-none-any.whl → 0.3.2030__py3-none-any.whl

graph_games_proto/fns.py

@@ -1936,12 +1936,13 @@ class StateKernel(PClass):
     rng = field(type=random.Random)
     game_config = field(type=GameConfig)
     edges = field(type=list)  # List[BiEdge]
+    nodes = field(type=list)  # List[Node]
+    regions = field(type=list)  # List[Region]
     decks = field(type=list)  # List[Deck]
     piles = field(type=list)  # List[Pile]
     players = field(type=list)  # List[Player]
     player_idxs = field(type=list)  # List[int]
     history = field(type=list)  # List[PublicAction]
-    player_scores = field(type=list)  # List[PlayerScore]
     idx2path = field(type=list)  # List[Path2]
     pieceuuid2piece = field(type=dict)  # Dict[str, Piece]
     edgeuuid2idx = field(type=dict)  # Dict[str, int]
@@ -1953,17 +1954,20 @@ class StateKernel(PClass):
     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)
+    player_graphs_3 = field(type=list)  # List[PlayerGraph]
     def __todict__(self):
         return {
             "rng": rng2json(self.rng),
             "game_config": self.game_config.__todict__(),
             "edges": [edge.__todict__() for edge in self.edges],
+            "nodes": [node.__todict__() for node in self.nodes],
+            "regions": [region.__todict__() for region in self.regions],
             "decks": [deck.__todict__() for deck in self.decks],
             "piles": [pile.__todict__() for pile in self.piles],
             "players": [player.__todict__() for player in self.players],
             "player_idxs": self.player_idxs,
             "history": [action.__todict__() for action in self.history],
-            "player_scores": [score.__todict__() for score in self.player_scores],
             "idx2path": [v.__todict__() for v in self.idx2path],
             "pieceuuid2piece": {k: v.__todict__() for k, v in self.pieceuuid2piece.items()},
             "edgeuuid2idx": self.edgeuuid2idx,
@@ -1975,6 +1979,8 @@ class StateKernel(PClass):
             "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,
+            "player_graphs_3": [x.__todict__() for x in self.player_graphs_3],
         }
     @staticmethod
     def __fromdict__(d):
@@ -1982,12 +1988,13 @@ class StateKernel(PClass):
             rng=json2rng(d["rng"]),
             game_config=GameConfig.__fromdict__(d["game_config"]),
             edges=[BiEdge.__fromdict__(edge) for edge in d["edges"]],
+            nodes=[Node.__fromdict__(n) for n in d["nodes"]],
+            regions=[Region.__fromdict__(r) for r in d["regions"]],
             decks=[Deck.__fromdict__(deck) for deck in d["decks"]],
             piles=[Pile.__fromdict__(pile) for pile in d["piles"]],
             players=[Player.__fromdict__(player) for player in d["players"]],
             player_idxs=d["player_idxs"],
             history=[PublicAction.__fromdict__(action) for action in d["history"]],
-            player_scores=[PlayerScore.__fromdict__(score) for score in d["player_scores"]],
             idx2path=[Path2.__fromdict(v) for v in d["idx2path"]],
             pieceuuid2piece={k: Piece.__fromdict(v) for k, v in d["pieceuuid2piece"].items()},
             edgeuuid2idx=d["edgeuuid2idx"],
@@ -1999,6 +2006,8 @@ class StateKernel(PClass):
             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"),
+            player_graphs_3=[PlayerGraph.__fromdict__(x) for x in d["player_graphs_3"]],
         )
 
 
@@ -2007,6 +2016,7 @@ def init_state_kernel(**kwargs):
     game_config = kwargs.get('game_config')
     fig = game_config.fig
     board_config = fig.board_config
+    nodes = kwargs.get('nodes', [])
     edges = kwargs.get('edges', [])
     idx2path = []
     edgeuuid2idx = {edge.uuid: idx for idx, edge in enumerate(edges)}
@@ -2041,16 +2051,18 @@ def init_state_kernel(**kwargs):
     bonuses = game_config.fig.board_config.bonuses
     bonusuuid2bonusidx = {bonus.uuid: idx for idx, bonus in enumerate(bonuses)}
     
+    player_graphs_3 = calc_player_graphs3(nodes, edges, pieceuuid2piece, game_config)
+
     return StateKernel(
         rng=rng,
         game_config=game_config,
         edges=edges,
+        nodes=kwargs.get('nodes'),
         decks=kwargs.get('decks'),
         piles=kwargs.get('piles'),
         players=kwargs.get('players'),
         player_idxs=kwargs.get('player_idxs'),
         history=kwargs.get('history'),
-        player_scores=kwargs.get('player_scores'),
         idx2path=idx2path,
         edgeuuid2idx=edgeuuid2idx,
         carduuid2card=carduuid2card,
@@ -2062,74 +2074,40 @@ def init_state_kernel(**kwargs):
         starting_decks=kwargs.get('starting_decks'),
         starting_piles=kwargs.get('starting_piles'),
         goals=kwargs.get('goals'),
+        player_graphs_3=player_graphs_3,
     )
 
 
 class State(PClass):
-    # Identity
     kernel = field(type=StateKernel)
-    history = field(type=list)  # List[Action2]
-    players = field(type=list)  # List[Player]
-    nodes = field(type=list)  # List[Node]
-    edges = field(type=list)  # List[BiEdge]
-    regions = field(type=list)  # List[Region]
-    piles = field(type=list)  # List[Pile]
-    last_to_play = field(type=(int, type(None)), initial=None)
-    
-    idx2path = field(type=list)  # List[Path2]
 
-    # Scoring
-    player_idxs = field(type=list)  # List[int]
-    decks = field(type=list)  # List[Deck]
-    rng = field(type=random.Random)
-    
+    # Identity - these fields should be in the kernel (can only be changed in "get_initial_state" and "get_next_state")
+    # The struture should be this: uuid2segment, uuid2edge, uuid2path, uuid2region, uuid2node
+
     # Memoized
-    player_graphs = field(type=list)  # List[PlayerGraph]
     legal_actions_3 = field(type=list)  # List[LegalAction]
+    bonus_statuses_3 = field(type=list)  # List[BonusStatus]
+    player_scores_3 = field(type=list)  # List[PlayerScore2]
+    winners = field(type=list)  # List[int]
+
+    player_graphs = field(type=list)  # List[PlayerGraph]
     player_scores = field(type=list)  # List[PlayerScore2]
     bonus_statuses = field(type=list)  # List[BonusStatus]
-    winners = field(type=list)  # List[int]
 
     def __todict__(self):
         return {
             "kernel": self.kernel.__todict__(),
-            "idx2path": [v.__todict__() for v in self.idx2path],
-            "bonus_statuses": [status.__todict__() for status in self.bonus_statuses],
-            "history": [x.__todict__() for x in self.history],
-            "player_scores": [x.__todict__() for x in self.player_scores],
-            "player_graphs": [x.__todict__() for x in self.player_graphs],
-            "nodes": [node.__todict__() for node in self.nodes],
-            "edges": [edge.__todict__() for edge in self.edges],
-            "regions": [region.__todict__() for region in self.regions],
+            "bonus_statuses_3": [status.__todict__() for status in self.bonus_statuses_3],
+            "player_scores_3": [x.__todict__() for x in self.player_scores_3],
             "legal_actions_3": [x.__todict__() for x in self.legal_actions_3],
-            "piles": [pile.__todict__() for pile in self.piles],
-            "players": [player.__todict__() for player in self.players],
-            "player_idxs": self.player_idxs,
-            "decks": [deck.__todict__() for deck in self.decks],
-            "rng": rng2json(self.rng),
-            "last_to_play": self.last_to_play,
-            "winners": self.winners,
         }
     @staticmethod
     def __fromdict__(d):
         return State(
             kernel=StateKernel.__fromdict__(d["kernel"]),
-            idx2path=[Path2.__fromdict__(v) for v in d["idx2path"]],
-            bonus_statuses=[BonusStatus.__fromdict__(x) for x in d["bonus_statuses"]],
-            history=[Action2.__fromdict__(x) for x in d["history"]],
-            player_scores=[PlayerScore2.__fromdict__(x) for x in d["player_scores"]],
-            player_graphs=[PlayerGraph.__fromdict__(x) for x in d["player_graphs"]],
-            nodes=[Node.__fromdict__(n) for n in d["nodes"]],
-            edges=[BiEdge.__fromdict__(e) for e in d["edges"]],
-            regions=[Region.__fromdict__(r) for r in d["regions"]],
+            bonus_statuses_3=[BonusStatus.__fromdict__(x) for x in d["bonus_statuses_3"]],
+            player_scores_3=[PlayerScore2.__fromdict__(x) for x in d["player_scores_3"]],
             legal_actions_3=[LegalAction.__fromdict__(x) for x in d["legal_actions_3"]],
-            piles=[Pile.__fromdict__(p) for p in d["piles"]],
-            players=[Player.__fromdict__(p) for p in d["players"]],
-            player_idxs=d["player_idxs"],
-            decks=[Deck.__fromdict__(deck) for deck in d["decks"]],
-            rng=json2rng(d["rng"]),
-            last_to_play=d.get("last_to_play"),
-            winners=d["winners"],
         )
 
 
@@ -2625,12 +2603,6 @@ def getinitialstate(game_config):
     nodeuuid2idx = {node.uuid: idx for idx, node in enumerate(board_config.points)}
     edges = get_edges(rng, board_config, nodeuuid2idx)
 
-    idx2path = []
-    
-    for edge in edges:
-        for path in edge.paths:
-            idx2path.append(path)
-
     bonuses = game_config.fig.board_config.bonuses
     bonus_statuses = [
         BonusStatus(
@@ -2647,57 +2619,81 @@ def getinitialstate(game_config):
         ) 
         for bonus in bonuses
     ]
-    
-    starting_decks=[Deck.__fromdict__(x.__todict__()) for x in decks]
-    starting_piles=[Pile.__fromdict__(x.__todict__()) for x in piles]
-
-    state = State(
-        idx2path=idx2path,
-        bonus_statuses=bonus_statuses,
-        history=[],
-        player_scores=[PlayerScore2(public_items=[], private_items=[]) for _ in range(game_config.num_players)],
-        player_graphs=[
-            PlayerGraph(
-                player_idx=player_idx, 
-                neighbors=[[] for _ in range(len(nodes))]
-            ) for player_idx in range(game_config.num_players)
-        ],
-        nodes = nodes,
-        edges = edges,
-        regions = get_regions(board_config),
-        legal_actions_3=[],
-        piles=piles,
-        players=[Player(idx=idx, pieces=[], cards=[], discard_tray=[]) for idx in range(game_config.num_players)],
-        player_idxs=list(range(game_config.num_players)),
-        decks=decks,
-        rng=rng,
-        last_to_play=None,
-        winners=[],
-    )
 
-    state = run_state_hooks(state, INITIALIZATION_HOOKS, True)
+    # state = State(
+    #     bonus_statuses=bonus_statuses,
+    #     history=[],
+    #     player_scores=[PlayerScore2(public_items=[], private_items=[]) for _ in range(game_config.num_players)],
+    #     player_graphs=[
+    #         PlayerGraph(
+    #             player_idx=player_idx, 
+    #             neighbors=[[] for _ in range(len(nodes))]
+    #         ) for player_idx in range(game_config.num_players)
+    #     ],
+    #     nodes = nodes,
+    #     edges = edges,
+    #     regions = get_regions(board_config),
+    #     legal_actions_3=[],
+    #     piles=piles,
+    #     players=[Player(idx=idx, pieces=[], cards=[], discard_tray=[]) for idx in range(game_config.num_players)],
+    #     player_idxs=list(range(game_config.num_players)),
+    #     decks=decks,
+    #     rng=rng,
+    #     last_to_play=None,
+    #     winners=[],
+    # )
     
     kernel = init_state_kernel(
         rng=rng,
         game_config=game_config,
-        edges=state.edges,
-        decks=state.decks,
-        piles=state.piles,
-        players=state.players,
-        player_idxs=state.player_idxs,
-        history=state.history,
-        player_scores=state.player_scores,
-        starting_decks=starting_decks,
-        starting_piles=starting_piles,
+        edges=edges,
+        nodes=nodes,
+        decks=decks,
+        piles=piles,
+        players=[Player(idx=idx, pieces=[], cards=[], discard_tray=[]) for idx in range(game_config.num_players)],
+        player_idxs=list(range(game_config.num_players)),
+        history=[],
+        player_scores=[PlayerScore2(public_items=[], private_items=[]) for _ in range(game_config.num_players)],
+        starting_decks=[Deck.__fromdict__(x.__todict__()) for x in decks],
+        starting_piles=[Pile.__fromdict__(x.__todict__()) for x in piles],
         goals=board_config.goals,
     )
 
-    state = state.set(kernel=kernel)
-    state = state.set(legal_actions_3=calc_legal_actions3(kernel))
+    kernel = run_kernel_hooks(kernel, INITIALIZATION_HOOKS, True)
+
+    state = State(
+        kernel=kernel,
+        legal_actions_3=calc_legal_actions3(kernel),
+        bonus_statuses_3=calc_bonus_statuses3(kernel),
+    )
+    
+    state = state.set(player_scores_3=calc_player_scores3(state))
+    state = state.set(winners=calc_winners_3(state))
 
     return state
 
 
+@dispatch(StateKernel)
+def calc_bonus_statuses3(kernel):
+    bonus_statuses = [
+        calc_bonus_status3(kernel, bonus)
+        for bonus in kernel.game_config.fig.board_config.bonuses
+    ]
+    bonus_statuses = [bs for bs in bonus_statuses if bs is not None]
+    return bonus_statuses
+
+
+@dispatch(State)
+def calc_player_scores3(state):
+    player_scores = [
+        PlayerScore2(
+            public_items=score_public_items3(state, player_idx), 
+            private_items=score_private_items3(state.kernel, player_idx),
+        ) for player_idx in range(len(state.kernel.players))
+    ]
+    return player_scores
+
+
 def run_state_hooks(state, hooks, log=False):
     return reduce(
         lambda s, h: run_state_hook(s, h, log), 
@@ -2706,6 +2702,15 @@ def run_state_hooks(state, hooks, log=False):
     )
 
 
+@dispatch(StateKernel, list, bool)
+def run_kernel_hooks(kernel, hooks, log=False):
+    return reduce(
+        lambda k, h: run_kernel_hook(k, h, log), 
+        hooks, 
+        kernel
+    )
+
+
 def run_accept_action_hooks(state, action, hooks, log=False):
     # Just like "run_state_action_hooks", but returns immediately returns True if any hook returns True, otherwise returns False
     for hook in hooks:
@@ -2725,6 +2730,42 @@ def run_state_action_hooks(state, action, hooks, log=False):
     )
 
 
+@dispatch(State, int)
+def score_public_items3(state, player_idx):
+    items = []
+    for edge in state.kernel.edges:
+        for path in edge.paths:
+            if len(path.segments) > 0:
+                first_segment = path.segments[0]
+                if first_segment.pieces and len(first_segment.pieces) > 0:
+                    first_piece = state.kernel.pieceuuid2piece[first_segment.pieces[0]]
+                    if first_piece.player_idx == player_idx:
+                        items.append(
+                            ScoreItem2(
+                                amount=edge.score,
+                                owns_path=ScoreItemOwnsPath(
+                                    path_idx=path.idx, 
+                                    edge_uuid=edge.uuid,
+                                    length=len(path.segments),
+                                ),
+                                description="Player {} owns edge {}".format(player_idx, edge.uuid),
+                            )
+                        )
+    for bonus_status in state.bonus_statuses_3:
+        bonus_idx = state.kernel.bonusuuid2bonusidx.get(bonus_status.bonus_uuid)
+        bonus = state.kernel.game_config.fig.board_config.bonuses[bonus_idx] if bonus_idx is not None else None
+        if bonus:
+            if player_idx in bonus_status.winners:
+                items.append(
+                    ScoreItem2(
+                        amount=bonus.score, 
+                        description="Player {} wins bonus {}".format(player_idx, bonus.code),
+                        bonus=ScoreItemBonus(bonus_uuid=bonus.uuid),
+                    )
+                )
+    return items
+
+
 @dispatch(State, int)
 def score_public_items(state, player_idx):
     items = []
@@ -2789,6 +2830,34 @@ def score_private_items(state, player_idx):
     return items
 
 
+@dispatch(StateKernel, int)
+def score_private_items3(kernel, player_idx):
+    items = []
+    goaluuid2goal = {goal.uuid: goal for goal in kernel.goals}
+    goal_completions = get_goal_completions3(kernel, player_idx)
+    complete_goal_uuids = [gc.goal_uuid for gc in goal_completions if gc.complete]
+    incomplete_goal_uuids = [gc.goal_uuid for gc in goal_completions if not gc.complete]
+    for complete_goal_uuid in complete_goal_uuids:
+        goal = goaluuid2goal[complete_goal_uuid]
+        items.append(
+            ScoreItem2(
+                amount=goal.score, 
+                description="Player {} completed goal {}".format(player_idx, complete_goal_uuid),
+                goal=ScoreItemGoal(goal_uuid=complete_goal_uuid, complete=True)
+            )
+        )
+    for incomplete_goal_uuid in incomplete_goal_uuids:
+        goal = goaluuid2goal[incomplete_goal_uuid]
+        items.append(
+            ScoreItem2(
+                amount=(-1*goal.score), 
+                description="Player {} incomplete goal {}".format(player_idx, incomplete_goal_uuid),
+                goal=ScoreItemGoal(goal_uuid=incomplete_goal_uuid, complete=False)
+            )
+        )
+    return items
+
+
 def handle_last_to_play(game):
     if game.last_to_play is None:
         # If any player can less than 3 pieces, the game is terminal
@@ -2808,6 +2877,14 @@ def getfinalscores(game):
     ]
 
 
+@dispatch(State)
+def getfinalscores3(state):
+    return [
+        getpublicplayerscore(state, state.player_scores_3[player_idx]).total
+        for player_idx in range(len(state.kernel.players))
+    ]
+
+
 def handle_calc_winners(game):
     if isterminal(game):
         players_with_highest_score = []
@@ -2827,6 +2904,24 @@ def handle_calc_winners(game):
     return game
 
 
+@dispatch(State)
+def calc_winners_3(state):
+    if isterminal(state):
+        players_with_highest_score = []
+        highest_score = -1000
+        final_scores = getfinalscores3(state)
+        for player_idx in range(len(state.kernel.players)):
+            final_score = final_scores[player_idx]
+            if final_score > highest_score:
+                highest_score = final_score
+                players_with_highest_score = [player_idx]
+            elif final_score == highest_score:
+                players_with_highest_score.append(player_idx)
+        return players_with_highest_score
+
+    return []
+
+
 def default_handle_terminal(game):
     game = handle_last_to_play(game)
     game = handle_calc_winners(game)
@@ -2841,6 +2936,48 @@ def calc_bonus_status(game, bonus):
     return None
 
 
+@dispatch(StateKernel, FrozenBonus)
+def calc_bonus_status3(kernel, bonus):
+    if not bonus:
+        return None
+    if bonus.code == "longest-trail":
+        return get_bonus_status_longest_trail3(kernel, bonus)
+    return None
+
+
+@dispatch(StateKernel, FrozenBonus)
+def get_bonus_status_longest_trail3(kernel, bonus):
+    longest_trail = 0
+    winners = []
+    player_longest_trail_lens = []
+
+    for player_idx in range(kernel.game_config.num_players):
+        trail_length = get_longest_path_length3(kernel, player_idx)
+        player_longest_trail_lens.append(trail_length)
+        if trail_length > longest_trail:
+            longest_trail = trail_length
+            winners = [player_idx]
+        elif trail_length == longest_trail and trail_length > 0:
+            winners.append(player_idx)
+
+    player_statuses = [
+        BonusPlayerStatus(
+            player_idx=player_idx,
+            score=bonus.score if player_idx in winners else 0,
+            longest_trail=LongestTrailBonusPlayerStatus(
+                length=player_longest_trail_len
+            ),
+        )
+        for player_idx, player_longest_trail_len in enumerate(player_longest_trail_lens)
+    ]
+
+    return BonusStatus(
+        bonus_uuid=bonus.uuid,
+        winners=winners,
+        player_statuses=player_statuses,
+    )
+
+
 def get_bonus_status_longest_trail(state, bonus):
     longest_trail = 0
     winners = []
@@ -2894,137 +3031,142 @@ def default_handle_scoring(game):
     return game.set(player_scores=player_scores)
 
 
-def default_handle_action(game, action):
+@dispatch(StateKernel, Action2)
+def default_handle_action(kernel, action):
     if action.legal_action.discard:
-        return handle_discard_action(game, action)
+        return handle_discard_action(kernel, action)
     if action.legal_action.keep:
-        return handle_keep_action(game, action)
+        return handle_keep_action(kernel, action)
     if action.legal_action.move_pieces_to_path:
-        game = handle_move_pieces_to_path_action(game, action)
-        return handle_after_move_pieces_to_path_action(game, action)
+        kernel = handle_move_pieces_to_path_action(kernel, action)
+        return handle_after_move_pieces_to_path_action(kernel, action)
     if action.legal_action.faceup_draw:
-        return handle_faceup_draw_action(game, action)
+        return handle_faceup_draw_action(kernel, action)
     if action.legal_action.draw:
-        return handle_draw_action(game, action)
+        return handle_draw_action(kernel, action)
     if action.legal_action.draw_discard:
-        return handle_draw_discard_action(game, action)
+        return handle_draw_discard_action(kernel, action)
 
-    return game
+    return kernel
 
 
-def default_after_accept_action(game, action):
+@dispatch(StateKernel, Action2)
+def default_after_accept_action(kernel, action):
     # Remove all actions for matching player of action
-    if not game or not action or not action.legal_action:
-        return game
+    if not kernel or not action or not action.legal_action:
+        return kernel
     player_idx = action.legal_action.player_idx
-    if player_idx < 0 or player_idx >= len(game.players):
-        return game
-    new_legal_actions = [
-        la for la in game.legal_actions_3 if la.player_idx != player_idx
-    ]
-    history = game.history + [action]
-    return game.set(
-        legal_actions_3=new_legal_actions,
+    if player_idx < 0 or player_idx >= len(kernel.players):
+        return kernel
+    history = kernel.history + [action]
+    return kernel.set(
         history=history,
     )
 
 
-def recycle_decks_if_needed(game):
-    for deck_idx in range(len(game.decks)):
+@dispatch(StateKernel)
+def recycle_decks_if_needed(kernel):
+    for deck_idx in range(len(kernel.decks)):
         print("recycle_decks_if_needed for deck_idx =", deck_idx)
-        game = recycle_if_needed(game, deck_idx)
-    return game
+        kernel = recycle_if_needed(kernel, deck_idx)
+    return kernel
 
 
-def replenish_decks_if_needed(game):
-    for deck_idx in range(len(game.decks)):
-        game = replenish_faceup_if_needed(game, deck_idx)
-    return game
+@dispatch(StateKernel)
+def replenish_decks_if_needed(kernel):
+    for deck_idx in range(len(kernel.decks)):
+        kernel = replenish_faceup_if_needed(kernel, deck_idx)
+    return kernel
 
 
-def replenish_faceup_spot_if_needed(game, deck_idx, spot_idx):
-    deck = game.decks[deck_idx]
+@dispatch(StateKernel, int, int)
+def replenish_faceup_spot_if_needed(kernel, deck_idx, spot_idx):
+    deck = kernel.decks[deck_idx]
 
     if deck.faceup_spots[spot_idx] is not None:
-        return game
+        return kernel
     
     if len(deck.facedown_stack) == 0:
-        return game
+        return kernel
     
     deck.faceup_spots[spot_idx] = deck.facedown_stack.pop()
 
-    game = ensure_faceup_spots_valid(game)
+    kernel = ensure_faceup_spots_valid(kernel)
 
-    return game.set(
-        decks=game.decks,
+    return kernel.set(
+        decks=kernel.decks,
     )
 
 
-def replenish_faceup_if_needed(game, deck_idx):
-    deck = game.decks[deck_idx]
+@dispatch(StateKernel, int)
+def replenish_faceup_if_needed(kernel, deck_idx):
+    deck = kernel.decks[deck_idx]
     for spot_idx in range(len(deck.faceup_spots)):
-        game = replenish_faceup_spot_if_needed(game, deck_idx, spot_idx)
-    return game
+        kernel = replenish_faceup_spot_if_needed(kernel, deck_idx, spot_idx)
+    return kernel
 
 
-def recycle_if_needed(game, deck_idx):
-    deck = game.decks[deck_idx]
+@dispatch(StateKernel, int)
+def recycle_if_needed(kernel, deck_idx):
+    deck = kernel.decks[deck_idx]
     if len(deck.facedown_stack) == 0:
         shuffled_discards = list(deck.discard)
-        game.rng.shuffle(shuffled_discards)
+        kernel.rng.shuffle(shuffled_discards)
         deck = deck.set(
             facedown_stack = shuffled_discards,
             discard = []
         )
-        game = set_deck(game, deck.idx, deck)
-    return game
+        kernel = set_deck(kernel, deck.idx, deck)
+    return kernel
 
 
-def handle_draw_action(game, action):
-    if not game or not action or not action.legal_action or not action.legal_action.draw:
-        return game
+@dispatch(StateKernel, Action2)
+def handle_draw_action(kernel, action):
+    if not kernel or not action or not action.legal_action or not action.legal_action.draw:
+        return kernel
     legal_action = action.legal_action
     draw = legal_action.draw
-    player = game.players[legal_action.player_idx]
-    deck = game.decks[draw.deck_idx]
+    player = kernel.players[legal_action.player_idx]
+    deck = kernel.decks[draw.deck_idx]
     
     if len(deck.facedown_stack) == 0:
-        return game  # No cards to draw
+        return kernel  # No cards to draw
 
     for _ in range(draw.quantity):
         drawn_card = deck.facedown_stack.pop()
         player.cards.append(drawn_card)
-        game = recycle_if_needed(game, draw.deck_idx)
+        kernel = recycle_if_needed(kernel, draw.deck_idx)
 
-    game = game.set(
-        players=game.players,
+    kernel = kernel.set(
+        players=kernel.players,
     )
 
     # TODO: extract this out to user-defined function/hook
     # if draw.quantity == 1:
     #     game = append_follow_up_draw_legal_actions(game, action)
 
-    return game
+    return kernel
 
 
-def handle_draw_discard_action(game, action):
-    if not game or not action or not action.legal_action or not action.legal_action.draw_discard:
-        return game
+@dispatch(StateKernel, Action2)
+def handle_draw_discard_action(kernel, action):
+    if not kernel or not action or not action.legal_action or not action.legal_action.draw_discard:
+        return kernel
     legal_action = action.legal_action
     draw_discard = legal_action.draw_discard
-    player = game.players[legal_action.player_idx]
-    deck = game.decks[draw_discard.deck_idx]
+    player = kernel.players[legal_action.player_idx]
+    deck = kernel.decks[draw_discard.deck_idx]
     
     if len(deck.facedown_stack) == 0:
-        return game  # No cards to draw
+        return kernel  # No cards to draw
 
     for _ in range(draw_discard.quantity):
         drawn_card = deck.facedown_stack.pop()
         player.discard_tray.append(drawn_card)
 
-    return game.set(
-        players=game.players,
-        decks=game.decks,
+    return kernel.set(
+        players=kernel.players,
+        decks=kernel.decks,
     )
 
 
@@ -3071,26 +3213,29 @@ def get_follow_up_draw_legal_actions(game, action):
     return to_return
 
 
-def get_num_faceup_wilds(game, deck_idx):
-    deck = game.decks[deck_idx]
+@dispatch(StateKernel, int)
+def get_num_faceup_wilds(kernel, deck_idx):
+    deck = kernel.decks[deck_idx]
     non_empty_spots = [spot for spot in deck.faceup_spots if spot]
     if not non_empty_spots:
         return 0
-    return sum(1 for card_uuid in non_empty_spots if game.kernel.carduuid2card[card_uuid].is_wild)
+    return sum(1 for card_uuid in non_empty_spots if kernel.carduuid2card[card_uuid].is_wild)
 
 
-def ensure_faceup_spots_valid(game):
-    for deck in game.decks:
+@dispatch(StateKernel)
+def ensure_faceup_spots_valid(kernel):
+    for deck in kernel.decks:
         max_iters = 5
         i = 0
-        while i < max_iters and get_num_faceup_wilds(game, deck.idx) >= 3:
-            game = discardfaceup_shuffle_flip(game, deck.idx)
+        while i < max_iters and get_num_faceup_wilds(kernel, deck.idx) >= 3:
+            kernel = discardfaceup_shuffle_flip(kernel, deck.idx)
             i += 1
-    return game
+    return kernel
 
 
-def discardfaceup_shuffle_flip(game, deck_idx):
-    deck = game.decks[deck_idx]
+@dispatch(StateKernel, int)
+def discardfaceup_shuffle_flip(kernel, deck_idx):
+    deck = kernel.decks[deck_idx]
     num_faceup_spots = len(deck.faceup_spots)
     for faceup_spot in deck.faceup_spots:
         if faceup_spot:
@@ -3099,45 +3244,48 @@ def discardfaceup_shuffle_flip(game, deck_idx):
     while len(deck.discard) > 0:
         card = deck.discard.pop()
         deck.facedown_stack.append(card)
-    deck = shuffle(game.rng, deck)
-    game = set_deck(game, deck.idx, deck)
-    game = flip_cards(game, deck.idx, num_faceup_spots)
-    return game
+    deck = shuffle(kernel.rng, deck)
+    kernel = set_deck(kernel, deck.idx, deck)
+    kernel = flip_cards(kernel, deck.idx, num_faceup_spots)
+    return kernel
 
 
-def handle_faceup_draw_action(game, action):
-    if not game or not action or not action.legal_action or not action.legal_action.faceup_draw:
-        return game
+@dispatch(StateKernel, Action2)
+def handle_faceup_draw_action(kernel, action):
+    if not kernel or not action or not action.legal_action or not action.legal_action.faceup_draw:
+        return kernel
     legal_action = action.legal_action
     faceup_draw = legal_action.faceup_draw
-    player = game.players[legal_action.player_idx]
-    deck = game.decks[faceup_draw.deck_idx]
+    player = kernel.players[legal_action.player_idx]
+    deck = kernel.decks[faceup_draw.deck_idx]
     # find the faceup spot idx with uuid "faceup_draw.card_uuid"
     spot_idx = next((i for i, card_uuid in enumerate(deck.faceup_spots) if card_uuid == faceup_draw.card_uuid), None)
     drawn_card = deck.faceup_spots[spot_idx] if spot_idx is not None else None
     player.cards.append(drawn_card)
     
     deck.faceup_spots[spot_idx] = None
-    game = game.set(decks=game.decks)
-    game = replenish_faceup_spot_if_needed(game, faceup_draw.deck_idx, spot_idx)
+    kernel = kernel.set(decks=kernel.decks)
+    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:
     #     # TODO: extract this out to user-defined function/hook
     #     game = append_follow_up_draw_legal_actions(game, action)
 
-    return game.set(
-        players=game.players,
+    return kernel.set(
+        players=kernel.players,
     )
 
 
-def handle_after_move_pieces_to_path_action(game, action):
-    game = handle_move_bonus_cards(game, action)
-    return game
+@dispatch(StateKernel, Action2)
+def handle_after_move_pieces_to_path_action(kernel, action):
+    kernel = handle_move_bonus_cards(kernel, action)
+    return kernel
 
 
-def handle_move_bonus_cards(game, action):
-    return handle_move_longest_path_card(game, action)
+@dispatch(StateKernel, Action2)
+def handle_move_bonus_cards(kernel, action):
+    return handle_move_longest_path_card(kernel, action)
 
 
 # Take a random walk on the player's graph. A node can be visiting more than once, but an edge cannot be visited more than once.
@@ -3181,12 +3329,53 @@ def random_player_graph_walk(game, player_idx):
     return walk([random_start_node_idx], set([]))
 
 
-def find_player_with_longest_path(state):
+@dispatch(StateKernel, int)
+def random_player_graph_walk3(kernel, player_idx):
+    player_graph = kernel.player_graphs_3[player_idx]
+    nodes_indices_with_neighbors = [i for i, neighbors in enumerate(player_graph.neighbors) if neighbors]
+    
+    if not nodes_indices_with_neighbors:
+        return None
+    
+    rng = random.Random()
+    random_start_node_idx = rng.choice(nodes_indices_with_neighbors)
+
+    def choose_next_node(visited_nodes, visited_edges):
+        current_node_idx = visited_nodes[-1]
+        neighbors = player_graph.neighbors[current_node_idx]
+        if not neighbors:
+            return None
+        
+        shuffled_neighbors = neighbors.copy()
+        rng.shuffle(shuffled_neighbors)
+        
+        for neighbor in shuffled_neighbors:
+            edge = (min(current_node_idx, neighbor), max(current_node_idx, neighbor))
+            if edge not in visited_edges:
+                return neighbor
+        
+        return None
+
+    def walk(visited_nodes, visited_edges):
+        next_node = choose_next_node(visited_nodes, visited_edges)
+        if next_node is None:
+            return (visited_nodes, visited_edges)
+        next_edge = (min(visited_nodes[-1], next_node), max(visited_nodes[-1], next_node))
+        return walk(
+            visited_nodes + [next_node], 
+            set(list(visited_edges) + [next_edge])
+        )
+
+    return walk([random_start_node_idx], set([]))
+
+
+@dispatch(StateKernel)
+def find_player_with_longest_path(kernel):
     longest_path_player_idx = None
     longest_path_length = 0
 
-    for player_idx in range(state.kernel.game_config.num_players):
-        path_length = get_longest_path_length(state, player_idx)
+    for player_idx in range(kernel.game_config.num_players):
+        path_length = get_longest_path_length(kernel, player_idx)
         if path_length > longest_path_length:
             longest_path_length = path_length
             longest_path_player_idx = player_idx
@@ -3194,7 +3383,7 @@ def find_player_with_longest_path(state):
     if longest_path_player_idx is None:
         return None
     
-    return state.players[longest_path_player_idx]
+    return kernel.players[longest_path_player_idx]
 
 
 @dispatch(State, set)
@@ -3215,15 +3404,34 @@ def calc_path_len_from_edges(state, edge_tuples):
     return sum(edge_lens)
 
 
-def get_longest_path_length(game, player_idx):
+@dispatch(StateKernel, set)
+def calc_path_len_from_edges3(kernel, edge_tuples):
+    if edge_tuples is None:
+        return 0
+    edge_lens = []
+    for edge_tuple in edge_tuples:
+        edge_uuid = kernel.edgetuple2uuid.get(edge_tuple)
+        edge_idx = kernel.edgeuuid2idx.get(edge_uuid)
+        if edge_idx is not None:
+            edge = kernel.edges[edge_idx]
+            if edge and edge.paths:
+                first_path = edge.paths[0]
+                edge_len = len(first_path.segments)
+                edge_lens.append(edge_len)
+
+    return sum(edge_lens)
+
+
+@dispatch(StateKernel, int)
+def get_longest_path_length3(kernel, player_idx):
     longest_path_length = 0
     num_iters_since_change = 0
 
     for _ in range(1000):
-        walk = random_player_graph_walk(game, player_idx)
+        walk = random_player_graph_walk3(kernel, player_idx)
         if not walk:
             return 0
-        path_len = calc_path_len_from_edges(game, walk[1])
+        path_len = calc_path_len_from_edges3(kernel, walk[1])
         if path_len > longest_path_length:
             longest_path_length = path_len
             num_iters_since_change = 0
@@ -3237,25 +3445,49 @@ def get_longest_path_length(game, player_idx):
     return longest_path_length
 
 
-def handle_move_longest_path_card(game, action):
-    player = find_player_with_longest_path(game)
+@dispatch(StateKernel, int)
+def get_longest_path_length(kernel, player_idx):
+    longest_path_length = 0
+    num_iters_since_change = 0
+
+    for _ in range(1000):
+        walk = random_player_graph_walk(kernel, player_idx)
+        if not walk:
+            return 0
+        path_len = calc_path_len_from_edges(kernel, walk[1])
+        if path_len > longest_path_length:
+            longest_path_length = path_len
+            num_iters_since_change = 0
+        else:
+            num_iters_since_change += 1
+        # If we haven't found a longer path in 500 iterations, return
+        if num_iters_since_change > 500:
+            return longest_path_length
+
+    print("longest_path_length: ", longest_path_length)
+    return longest_path_length
 
-    if not game or not player:
-        return game
+
+@dispatch(StateKernel, Action2)
+def handle_move_longest_path_card(kernel, action):
+    player = find_player_with_longest_path(kernel)
+
+    if not kernel or not player:
+        return kernel
 
     longest_path_card = None
 
-    if len(game.decks) > 2:
-        longest_path_deck = game.decks[2]
+    if len(kernel.decks) > 2:
+        longest_path_deck = kernel.decks[2]
         if longest_path_deck.facedown_stack:
             # Move the longest path card to the player's hand
             longest_path_card = longest_path_deck.facedown_stack.pop()
         else:
             # Search for the longest path card in each player's cards
-            player_with_card = find_player_with_longest_path_card(game)
+            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 game.kernel.carduuid2card[card_uuid].deck_idx == 2), None)
+                card_idx = next((i for i, card_uuid in enumerate(player_with_card.cards) if kernel.carduuid2card[card_uuid].deck_idx == 2), None)
                 if card_idx is not None:
                     longest_path_card = player_with_card.cards.pop(card_idx)
 
@@ -3263,9 +3495,9 @@ def handle_move_longest_path_card(game, action):
     if longest_path_card:
         player.cards.append(longest_path_card)
 
-    return game.set(
-        players=game.players,
-        decks=game.decks,
+    return kernel.set(
+        players=kernel.players,
+        decks=kernel.decks,
     )
 
 
@@ -3276,9 +3508,10 @@ def find_player_with_longest_path_card(game):
     return None
 
 
-def handle_move_pieces_to_path_action(game, action):
-    if not game or not action or not action.legal_action or not action.legal_action.move_pieces_to_path:
-        return game
+@dispatch(StateKernel, Action2)
+def handle_move_pieces_to_path_action(kernel, action):
+    if not kernel or not action or not action.legal_action or not action.legal_action.move_pieces_to_path:
+        return kernel
     
     legal_action = action.legal_action
     move_pieces_to_path = legal_action.move_pieces_to_path
@@ -3288,15 +3521,15 @@ def handle_move_pieces_to_path_action(game, action):
         default = default.set(piece_uuids=override.piece_uuids)
         default = default.set(card_uuids=override.card_uuids)
 
-    player = game.players[legal_action.player_idx]
+    player = kernel.players[legal_action.player_idx]
     if not player or not player.pieces:
-        return game
+        return kernel
 
     path_idx = move_pieces_to_path.path_idx
-    path = game.idx2path[path_idx]
+    path = kernel.idx2path[path_idx]
 
     if path is None or not path.segments:
-        return game
+        return kernel
 
     for piece_uuid, segment in zip(default.piece_uuids, path.segments):
         # Find the piece in the player's pieces
@@ -3313,15 +3546,14 @@ def handle_move_pieces_to_path_action(game, action):
             # Remove the card from player's cards
             card_uuid = player.cards.pop(card_idx)
             # add to discard
-            game.decks[game.kernel.carduuid2card[card_uuid].deck_idx].discard.append(card_uuid)
+            kernel.decks[kernel.carduuid2card[card_uuid].deck_idx].discard.append(card_uuid)
 
-    game = recycle_decks_if_needed(game)
-    game = replenish_decks_if_needed(game)
-    game = game.set(players=game.players)
-    game = game.set(idx2path=game.idx2path)
-    game = game.set(player_graphs=calc_player_graphs(game)) #
+    kernel = recycle_decks_if_needed(kernel)
+    kernel = replenish_decks_if_needed(kernel)
+    kernel = kernel.set(players=kernel.players)
+    kernel = kernel.set(idx2path=kernel.idx2path)
 
-    return game
+    return kernel
 
 
 @dispatch(State, int)
@@ -3346,6 +3578,27 @@ def calc_player_graph(state, player_idx):
     )
 
 
+@dispatch(list, list, dict, int)
+def calc_player_graph3(nodes, edges, pieceuuid2piece, player_idx):
+    node2neighbors = {node.idx: set() for node in nodes}
+
+    for edge in edges:
+        for path in edge.paths:
+            for segment in path.segments:
+                if segment.pieces and segment.pieces[0] and pieceuuid2piece[segment.pieces[0]].player_idx == player_idx:
+                    # print(f"[path_idx {path.idx}] edge.start_point_uuid {edge.start_point_uuid} ({edge.node_1_idx}) connected to edge.end_point_uuid {edge.end_point_uuid} ({edge.node_2_idx}) player_idx: {player_idx}")
+                    node2neighbors[edge.node_1_idx].add(edge.node_2_idx)
+                    node2neighbors[edge.node_2_idx].add(edge.node_1_idx)
+    
+    return PlayerGraph(
+        player_idx=player_idx, 
+        neighbors=[
+            list(node2neighbors.get(node_idx, set())) 
+            for node_idx in range(len(nodes))
+        ]
+    )
+
+
 def calc_player_graphs(state):
     game_config = state.kernel.game_config
     return [
@@ -3354,22 +3607,31 @@ def calc_player_graphs(state):
     ]
 
 
+@dispatch(list, list, dict, GameConfig)
+def calc_player_graphs3(nodes, edges, pieceuuid2piece, game_config):
+    return [
+        calc_player_graph3(nodes, edges, pieceuuid2piece, player_idx)
+        for player_idx in range(game_config.num_players)
+    ]
+
+
 # Does the opposite of handle_discard_action, i.e., it keeps the cards in the discard tray (the other cards are discarded)
-def handle_keep_action(game, action):
-    if not game or not action or not action.legal_action.keep:
-        return game
+@dispatch(StateKernel, Action2)
+def handle_keep_action(kernel, action):
+    if not kernel or not action or not action.legal_action.keep:
+        return kernel
 
     deck_idx = action.legal_action.keep.deck_idx
-    if deck_idx < 0 or deck_idx >= len(game.decks):
-        return game
+    if deck_idx < 0 or deck_idx >= len(kernel.decks):
+        return kernel
 
-    deck = game.decks[deck_idx]
+    deck = kernel.decks[deck_idx]
     if not deck:
-        return game
+        return kernel
 
-    player = game.players[action.legal_action.player_idx]
+    player = kernel.players[action.legal_action.player_idx]
     if not player:
-        return game
+        return kernel
 
     # Keep the specified cards in the discard tray
     kept_cards = [card_uuid for card_uuid in player.discard_tray if card_uuid in action.keep.card_uuids]
@@ -3383,32 +3645,33 @@ def handle_keep_action(game, action):
     player.cards.extend([c for c in kept_cards if c is not None])
 
     player.discard_tray.clear()
-    return game.set(decks=game.decks, players=game.players)
+    return kernel.set(decks=kernel.decks, players=kernel.players)
 
 
-def handle_discard_action(game, action):
+@dispatch(StateKernel, Action2)
+def handle_discard_action(kernel, action):
     print("****************************** handle_discard_action 1", action)
-    if not game or not action or not action.legal_action.discard:
-        return game
+    if not kernel or not action or not action.legal_action.discard:
+        return kernel
 
     print("****************************** handle_discard_action 2", action)
 
     deck_idx = action.legal_action.discard.deck_idx
-    if deck_idx < 0 or deck_idx >= len(game.decks):
-        return game
+    if deck_idx < 0 or deck_idx >= len(kernel.decks):
+        return kernel
 
     print("****************************** handle_discard_action 3", deck_idx)
 
-    deck = game.decks[deck_idx]
+    deck = kernel.decks[deck_idx]
     print("****************************** handle_discard_action 3.5", deck)
     if not deck:
-        return game
+        return kernel
 
     print("****************************** handle_discard_action 4")
 
-    player = game.players[action.legal_action.player_idx]
+    player = kernel.players[action.legal_action.player_idx]
     if not player:
-        return game
+        return kernel
 
     # Keep the specified cards in the discard tray
     non_kept_cards = [card_uuid for card_uuid in player.discard_tray if card_uuid in action.discard.card_uuids]
@@ -3426,22 +3689,24 @@ def handle_discard_action(game, action):
     player.discard_tray.clear()
     print("****************************** handle_discard_action 10 kept_cards: ", kept_cards)
 
-    return game.set(decks=game.decks, players=game.players)
+    return kernel.set(decks=kernel.decks, players=kernel.players)
 
 
-def shuffle_all_decks(game):
-    if not game or not game.decks:
-        return game
+@dispatch(StateKernel)
+def shuffle_all_decks(kernel):
+    if not kernel or not kernel.decks:
+        return kernel
 
-    for i in range(len(game.decks)):
-        game = shuffle_deck(game, i)
+    for i in range(len(kernel.decks)):
+        kernel = shuffle_deck(kernel, i)
 
-    return game
+    return kernel
 
 
-def set_deck(game, deck_idx, deck):
-    new_decks = game.decks[:deck_idx] + [deck] + game.decks[deck_idx + 1:]
-    return game.set(decks=new_decks)
+@dispatch(StateKernel, int, Deck)
+def set_deck(kernel, deck_idx, deck):
+    new_decks = kernel.decks[:deck_idx] + [deck] + kernel.decks[deck_idx + 1:]
+    return kernel.set(decks=new_decks)
 
 
 def shuffle(rng, deck):
@@ -3450,37 +3715,40 @@ def shuffle(rng, deck):
     return deck.set(facedown_stack=shuffled_cards)
 
 
-def shuffle_deck(game, deck_idx):
-    if not game or not game.decks or deck_idx < 0 or deck_idx >= len(game.decks):
-        return game
+@dispatch(StateKernel, int)
+def shuffle_deck(kernel, deck_idx):
+    if not kernel or not kernel.decks or deck_idx < 0 or deck_idx >= len(kernel.decks):
+        return kernel
     
-    deck = game.decks[deck_idx]
+    deck = kernel.decks[deck_idx]
     if not deck or not deck.facedown_stack:
-        return game
+        return kernel
 
-    shuffled_deck = shuffle(game.rng, deck)
-    game = set_deck(game, deck_idx, shuffled_deck)
-    return game
+    shuffled_deck = shuffle(kernel.rng, deck)
+    kernel = set_deck(kernel, deck_idx, shuffled_deck)
+    return kernel
 
 
-def shuffle_player_order(game):
-    if not game or not game.player_idxs:
-        return game
+@dispatch(StateKernel)
+def shuffle_player_order(kernel):
+    if not kernel or not kernel.player_idxs:
+        return kernel
     
-    rng = game.rng
-    shuffled_idxs = list(game.player_idxs)
+    rng = kernel.rng
+    shuffled_idxs = list(kernel.player_idxs)
     rng.shuffle(shuffled_idxs)
     
-    return game.set(player_idxs=shuffled_idxs)
+    return kernel.set(player_idxs=shuffled_idxs)
 
 
-def flip_cards(game, deck_idx, num_cards):
-    if not game or deck_idx < 0 or deck_idx >= len(game.decks):
-        return game
+@dispatch(StateKernel, int, int)
+def flip_cards(kernel, deck_idx, num_cards):
+    if not kernel or deck_idx < 0 or deck_idx >= len(kernel.decks):
+        return kernel
     
-    deck = game.decks[deck_idx]
+    deck = kernel.decks[deck_idx]
     if not deck or not deck.facedown_stack:
-        return game
+        return kernel
 
     # Flip the top num_cards from the facedown_stack to the faceup_spots
     for _ in range(num_cards):
@@ -3488,52 +3756,55 @@ def flip_cards(game, deck_idx, num_cards):
             card = deck.facedown_stack.pop()
             deck.faceup_spots.append(card)
 
-    return game.set(decks=game.decks)
+    return kernel.set(decks=kernel.decks)
 
 
-def distribute_all_piles(game):
-    if not game or not game.piles:
-        return game
+@dispatch(StateKernel)
+def distribute_all_piles(kernel):
+    if not kernel or not kernel.piles:
+        return kernel
 
-    for pile in game.piles:
+    for pile in kernel.piles:
         player_idx = pile.player_idx
-        if player_idx < 0 or player_idx >= len(game.players):
+        if player_idx < 0 or player_idx >= len(kernel.players):
             continue
         
-        player = game.players[player_idx]
+        player = kernel.players[player_idx]
         player.pieces.extend(pile.pieces)
         pile.pieces.clear()  # Clear the pile after distribution
 
-    return game.set(players=game.players, piles=game.piles)
+    return kernel.set(players=kernel.players, piles=kernel.piles)
 
 
-def deal_cards_to_each_player_discard_tray(game, deck_idx, num_cards):
-    if not game or deck_idx < 0 or deck_idx >= len(game.decks):
-        return game
+@dispatch(StateKernel, int, int)
+def deal_cards_to_each_player_discard_tray(kernel, deck_idx, num_cards):
+    if not kernel or deck_idx < 0 or deck_idx >= len(kernel.decks):
+        return kernel
 
-    deck = game.decks[deck_idx]
+    deck = kernel.decks[deck_idx]
     if not deck or not deck.facedown_stack:
-        return game
+        return kernel
 
-    for player in game.players:
+    for player in kernel.players:
         # Deal cards to the player's discard tray
         for _ in range(num_cards):
             if deck.facedown_stack:
                 card = deck.facedown_stack.pop()
                 player.discard_tray.append(card)
 
-    return game.set(players=game.players, decks=game.decks)
+    return kernel.set(players=kernel.players, decks=kernel.decks)
 
 
-def deal_cards_to_each_player(game, deck_idx, num_cards):
-    if not game or deck_idx < 0 or deck_idx >= len(game.decks):
-        return game
+@dispatch(StateKernel, int, int)
+def deal_cards_to_each_player(kernel, deck_idx, num_cards):
+    if not kernel or deck_idx < 0 or deck_idx >= len(kernel.decks):
+        return kernel
 
-    deck = game.decks[deck_idx]
+    deck = kernel.decks[deck_idx]
     if not deck or not deck.facedown_stack:
-        return game
+        return kernel
 
-    for player in game.players:
+    for player in kernel.players:
         player_hand = player.cards
         # Deal cards to the player's hand
         for _ in range(num_cards):
@@ -3541,7 +3812,7 @@ def deal_cards_to_each_player(game, deck_idx, num_cards):
                 card = deck.facedown_stack.pop()
                 player_hand.append(card)
 
-    return game.set(players=game.players, decks=game.decks)
+    return kernel.set(players=kernel.players, decks=kernel.decks)
 
 
 def default_accept_action(game, action):
@@ -3972,6 +4243,37 @@ def run_state_hook(state, hook, log=False):
         raise Exception(msg) from e
 
 
+def run_kernel_hook(kernel, hook, log=False):
+
+    namespace = HOOK_NAMESPACE.copy()
+
+    try:
+        # Execute the code string
+        exec(hook.code, namespace)
+        
+        # Retrieve the handler function
+        handler_func = namespace.get('handler')
+        
+        if handler_func is None or not callable(handler_func):
+            raise ValueError("No callable function named 'handler' found in the code")
+        
+        # Call the handler function
+        result = handler_func(kernel)
+        # if log:
+        #     print(f"****************************** Running initialization hook 3: {hook.uuid} {result.player_idxs}")
+            # print(f"****************************** Result of handler(5, 3): {result}")
+        return result
+
+    except SyntaxError as e:
+        msg = f"Syntax error in initialization hook {hook.uuid}: {str(e)}"
+        logging.error(msg, exc_info=True)
+        raise SyntaxError(msg) from e
+    except Exception as e:
+        msg = f"Error in initialization hook {hook.uuid}: {str(e)}"
+        logging.error(msg, exc_info=True)
+        raise Exception(msg) from e
+
+
 # Implementing the following Julia function:
 # function getfaceupspots(f, unit_deck, unit_deck_idx)
 #     num_faceup_spots = getsettingvalue(f, :num_faceup_spots)
@@ -4073,7 +4375,11 @@ def get_next_player_shuffled_idx(state_kernel, last_action):
 
 
 def init_state(kernel):
-    state = State(
+
+    legal_actions_3 = calc_legal_actions3(kernel)
+
+    return State(
+        kernel=kernel,
         rng=kernel.rng,
         game_config=kernel.game_config,
         edges=kernel.edges,
@@ -4083,41 +4389,31 @@ def init_state(kernel):
         player_idxs=kernel.player_idxs,
         history=kernel.history,
         player_scores=kernel.player_scores,
-        legal_actions_3=[],
         is_terminal=False,
         idx2path=kernel.idx2path,
         carduuid2card=kernel.carduuid2card,
+        legal_actions_3=legal_actions_3,
     )
-    state = state.set(legal_actions_3=calc_legal_actions3(kernel))
-    return state
 
 
 def getnextstate2(s, a, log=False):
     is_legal, reason = isactionlegal2(s, a)
     if not is_legal:
         raise ValueError(f"Action is not legal: {a}. Reason: {reason}")
-    s = run_state_action_hooks(s, a, AFTER_ACCEPT_ACTION_HOOKS, log)
-    s = run_state_action_hooks(s, a, HANDLE_ACTION_HOOKS, log)
-    s = run_state_hooks(s, HANDLE_SCORING_HOOKS, log)
-    s = run_state_hooks(s, HANDLE_TERMINAL_HOOKS, log)
-
-    state_kernel = init_state_kernel(
-        rng=s.rng,
-        game_config=s.kernel.game_config,
-        edges=s.edges,
-        decks=s.decks,
-        piles=s.piles,
-        players=s.players,
-        player_idxs=s.player_idxs,
-        history=s.history,
-        player_scores=s.player_scores,
-        starting_decks=s.kernel.starting_decks,
-        starting_piles=s.kernel.starting_piles,
-        goals=s.kernel.goals,
+    
+    kernel = s.kernel
+    kernel = run_state_action_hooks(kernel, a, AFTER_ACCEPT_ACTION_HOOKS, log)
+    kernel = run_state_action_hooks(kernel, a, HANDLE_ACTION_HOOKS, log)
+
+    state = State(
+        kernel=kernel,
+        legal_actions_3=calc_legal_actions3(kernel),
+        bonus_statuses_3=calc_bonus_statuses3(kernel),
     )
-    s = s.set(legal_actions_3=calc_legal_actions3(state_kernel))
+    state = state.set(player_scores_3=calc_player_scores3(state))
+    state = state.set(winners=calc_winners_3(state))
 
-    return s
+    return state
 
 
 def getpublicplayerscore(s, player_score):
@@ -4257,19 +4553,19 @@ def imagine_decks(public_state, private_state):
 
 
 def imagine_state(public_state, private_state):
-    kernel = init_state_kernel(
+    imagined_kernel = init_state_kernel(
         rng=random.Random(),
         game_config=public_state.game_config,
         player_idxs=public_state.player_idxs,
         piles=public_state.piles,
         edges=public_state.edges,
+        nodes=public_state.nodes,
         decks=imagine_decks(public_state, private_state),
         players=imagine_players(public_state, private_state),
         history=imagine_history(public_state, private_state),
         player_scores=imagine_player_scores(public_state, private_state),
     )
-    imagined_state = init_state(kernel)
-    return imagined_state
+    return init_state(imagined_kernel) 
 
 
 def isterminal(s):
@@ -4284,22 +4580,22 @@ def getpublicstate(s):
         allotted_times=get_max_allotted_times(s),
         all_pieces=list(s.kernel.pieceuuid2piece.values()),
         to_play_2=getpublictoplay(s),
-        bonus_statuses=s.bonus_statuses,
+        bonus_statuses=s.bonus_statuses_3,
         starting_decks=s.kernel.starting_decks,
         starting_piles=s.kernel.starting_piles,
         history=get_public_history(s),
         player_scores=get_public_player_scores(s),
-        player_graphs=s.player_graphs,
+        player_graphs=s.kernel.player_graphs_3,
         goals=s.kernel.goals,
-        nodes=s.nodes,
-        edges=s.edges,
-        regions=s.regions,
+        nodes=s.kernel.nodes,
+        edges=s.kernel.edges,
+        regions=s.kernel.regions,
         decks=[getpublicdeck(s, deck) for deck in s.decks],
-        piles=s.piles,
-        player_idxs=s.player_idxs,
+        piles=s.kernel.piles,
+        player_idxs=s.kernel.player_idxs,
         players=[getpublicplayer(s, p) for p in s.players],
-        last_to_play=s.last_to_play,
-        winners=s.winners,
+        last_to_play=s.kernel.last_to_play,
+        winners=s.kernel.winners,
         terminal=isterminal(s),
     )
 
@@ -4467,6 +4763,7 @@ def get_legal_actions(s, player_idx):
     return [a for a in s.legal_actions_3 if a.player_idx == player_idx]
 
 
+@dispatch(State, int)
 def get_goal_completions(s, player_idx):
     # print("len(get_goals(s, player_idx)): ", len(get_goals(s, player_idx)))
     # print("len(s.history): ", len(s.history))
@@ -4480,10 +4777,24 @@ def get_goal_completions(s, player_idx):
     ]
 
 
-@dispatch(State, FrozenGoal, int)
-def is_goal_complete(s, goal, player_idx):
-    graph = s.player_graphs[player_idx].neighbors
-    node_idxs = [s.kernel.nodeuuid2idx[node_uuid] for node_uuid in goal.node_uuids]
+@dispatch(StateKernel, int)
+def get_goal_completions3(kernel, player_idx):
+    # print("len(get_goals(s, player_idx)): ", len(get_goals(s, player_idx)))
+    # print("len(s.history): ", len(s.history))
+    # print("player.cards: ", len(s.players[player_idx].cards))
+    return [
+        GoalCompletion(
+            goal_uuid=goal.uuid,
+            complete=is_goal_complete(kernel, goal, player_idx),
+        )
+        for goal in get_goals3(kernel, player_idx)
+    ]
+
+
+@dispatch(StateKernel, FrozenGoal, int)
+def is_goal_complete(kernel, goal, player_idx):
+    graph = kernel.player_graphs_3[player_idx].neighbors
+    node_idxs = [kernel.nodeuuid2idx[node_uuid] for node_uuid in goal.node_uuids]
     return are_nodes_connected(
         graph,
         node_idxs,
@@ -4519,11 +4830,21 @@ def get_player_graph(s, player_idx):
     return nodes
 
 
-@dispatch(State, int)
-def get_goals(s, player_idx):
-    player = s.players[player_idx]
-    goaluuid2goal = {goal.uuid: goal for goal in s.kernel.goals}
-    goal_uuids = [s.kernel.carduuid2card[card_uuid].goal_uuid for card_uuid in player.cards if s.kernel.carduuid2card[card_uuid].goal_uuid]
+@dispatch(StateKernel, int)
+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]
+    return [
+        goaluuid2goal[goal_uuid] for goal_uuid in goal_uuids if goal_uuid in goaluuid2goal
+    ]
+
+
+@dispatch(StateKernel, int)
+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]
     return [
         goaluuid2goal[goal_uuid] for goal_uuid in goal_uuids if goal_uuid in goaluuid2goal
     ]
@@ -5182,23 +5503,23 @@ def getqproxy0(ps, a, td):
     return qproxyrecurse() if td > 0 else qproxybase()
 
 
-INIT_HOOK_1 = """def handler(game):
-    return shuffle_all_decks(game)  
+INIT_HOOK_1 = """def handler(kernel):
+    return shuffle_all_decks(kernel)  
 """
-INIT_HOOK_2 = """def handler(game):
-    return deal_cards_to_each_player(game, 0, 4)
+INIT_HOOK_2 = """def handler(kernel):
+    return deal_cards_to_each_player(kernel, 0, 4)
 """
-INIT_HOOK_3 = """def handler(game):
-    return deal_cards_to_each_player_discard_tray(game, 1, 3)
+INIT_HOOK_3 = """def handler(kernel):
+    return deal_cards_to_each_player_discard_tray(kernel, 1, 3)
 """
-INIT_HOOK_4 = """def handler(game):
-    return distribute_all_piles(game)
+INIT_HOOK_4 = """def handler(kernel):
+    return distribute_all_piles(kernel)
 """
-INIT_HOOK_5 = """def handler(game):
-    return flip_cards(game, 0, 5)
+INIT_HOOK_5 = """def handler(kernel):
+    return flip_cards(kernel, 0, 5)
 """
-INIT_HOOK_7 = """def handler(game):
-    return shuffle_player_order(game)
+INIT_HOOK_7 = """def handler(kernel):
+    return shuffle_player_order(kernel)
 """
 
 INITIALIZATION_HOOKS = [
@@ -5240,9 +5561,10 @@ INITIALIZATION_HOOKS = [
     ),
 ]
 
+
 HANDLE_ACTION_HOOK_1 = """
-def handler(game, action):
-    return default_handle_action(game, action)
+def handler(kernel, action):
+    return default_handle_action(kernel, action)
 """
 
 HANDLE_ACTION_HOOKS = [
@@ -5255,8 +5577,8 @@ HANDLE_ACTION_HOOKS = [
 ]
 
 AFTER_ACCEPT_ACTION_HOOK_1 = """
-def handler(game, action):
-    return default_after_accept_action(game, action)
+def handler(kernel, action):
+    return default_after_accept_action(kernel, action)
 """
 
 AFTER_ACCEPT_ACTION_HOOKS = [