graph-games-proto 0.3.1952__py3-none-any.whl → 0.3.1964__py3-none-any.whl

graph_games_proto/fns.py

@@ -1947,6 +1947,7 @@ class StateKernel(PClass):
     edgeuuid2idx = field(type=dict)  # Dict[str, int]
     carduuid2card = field(type=dict)  # Dict[str, Card]
     edgetuple2uuid = field(type=dict)  # Dict[Tuple[int, int], str]
+    nodeuuid2idx = field(type=dict)  # Dict[str, int]
     def __todict__(self):
         return {
             "rng": rng2json(self.rng),
@@ -1963,6 +1964,7 @@ class StateKernel(PClass):
             "edgeuuid2idx": self.edgeuuid2idx,
             "carduuid2card": {k: v.__todict__() for k, v in self.carduuid2card.items()},
             "edgetuple2uuid": [{"k": list(k), "v": v} for k, v in self.edgetuple2uuid.items()],
+            "nodeuuid2idx": self.nodeuuid2idx,
         }
     @staticmethod
     def __fromdict__(d):
@@ -1981,6 +1983,7 @@ class StateKernel(PClass):
             edgeuuid2idx=d["edgeuuid2idx"],
             carduuid2card={k: Card.__fromdict(v) for k, v in d["carduuid2card"].items()},
             edgetuple2uuid={tuple(item["k"]): item["v"] for item in d["edgetuple2uuid"]},
+            nodeuuid2idx=d["nodeuuid2idx"],
         )
 
 
@@ -2032,6 +2035,7 @@ def init_state_kernel(**kwargs):
         carduuid2card=carduuid2card,
         pieceuuid2piece=pieceuuid2piece,
         edgetuple2uuid=edgetuple2uuid,
+        nodeuuid2idx=nodeuuid2idx,
     )
 
 
@@ -2049,7 +2053,6 @@ class State(PClass):
     player_graphs = field(type=list)  # List[PlayerGraph]
     goals = field(type=list)  # List[Goal]
     nodes = field(type=list)  # List[Node]
-    nodeuuid2idx = field(type=dict)  # Dict[str, int]
     edges = field(type=list)  # List[BiEdge]
     regions = field(type=list)  # List[Region]
     legal_actions_3 = field(type=list)  # List[LegalAction]
@@ -2057,7 +2060,6 @@ class State(PClass):
     players = field(type=list)  # List[Player]
     player_idxs = field(type=list)  # List[int]
     decks = field(type=list)  # List[Deck]
-    game_config = field(type=GameConfig)
     rng = field(type=random.Random)
     last_to_play = field(type=(int, type(None)), initial=None)
     winners = field(type=list)  # List[int]
@@ -2076,7 +2078,6 @@ class State(PClass):
             "player_graphs": [x.__todict__() for x in self.player_graphs],
             "goals": [goal.__todict__() for goal in self.goals],
             "nodes": [node.__todict__() for node in self.nodes],
-            "nodeuuid2idx": self.nodeuuid2idx,
             "edges": [edge.__todict__() for edge in self.edges],
             "regions": [region.__todict__() for region in self.regions],
             "legal_actions_3": [x.__todict__() for x in self.legal_actions_3],
@@ -2084,7 +2085,6 @@ class State(PClass):
             "players": [player.__todict__() for player in self.players],
             "player_idxs": self.player_idxs,
             "decks": [deck.__todict__() for deck in self.decks],
-            "game_config": self.game_config.__todict__(),
             "rng": rng2json(self.rng),
             "last_to_play": self.last_to_play,
             "winners": self.winners,
@@ -2105,7 +2105,6 @@ class State(PClass):
             player_graphs=[PlayerGraph.__fromdict__(x) for x in d["player_graphs"]],
             goals=[FrozenGoal.__fromdict__(goal) for goal in d["goals"]],
             nodes=[Node.__fromdict__(n) for n in d["nodes"]],
-            nodeuuid2idx=d["nodeuuid2idx"],
             edges=[BiEdge.__fromdict__(e) for e in d["edges"]],
             regions=[Region.__fromdict__(r) for r in d["regions"]],
             legal_actions_3=[LegalAction.__fromdict__(x) for x in d["legal_actions_3"]],
@@ -2113,7 +2112,6 @@ class State(PClass):
             players=[Player.__fromdict__(p) for p in d["players"]],
             player_idxs=d["player_idxs"],
             decks=[Deck.__fromdict__(deck) for deck in d["decks"]],
-            game_config=GameConfig.__fromdict__(d["game_config"]),
             rng=json2rng(d["rng"]),
             last_to_play=d.get("last_to_play"),
             winners=d["winners"],
@@ -2661,7 +2659,6 @@ def getinitialstate(game_config):
         ],
         goals = board_config.goals,
         nodes = nodes,
-        nodeuuid2idx = nodeuuid2idx,
         edges = edges,
         regions = get_regions(board_config),
         legal_actions_3=[],
@@ -2669,7 +2666,6 @@ def getinitialstate(game_config):
         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,
-        game_config=game_config,
         rng=rng,
         last_to_play=None,
         winners=[],
@@ -2679,7 +2675,7 @@ def getinitialstate(game_config):
     
     kernel = init_state_kernel(
         rng=rng,
-        game_config=state.game_config,
+        game_config=game_config,
         edges=state.edges,
         decks=state.decks,
         piles=state.piles,
@@ -2722,14 +2718,14 @@ def run_state_action_hooks(state, action, hooks, log=False):
     )
 
 
-def score_public_items(game, player_idx):
+def score_public_items(state, player_idx):
     items = []
-    for edge in game.edges:
+    for edge in state.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 = game.pieceuuid2piece[first_segment.pieces[0]]
+                    first_piece = state.pieceuuid2piece[first_segment.pieces[0]]
                     if first_piece.player_idx == player_idx:
                         items.append(
                             ScoreItem2(
@@ -2742,9 +2738,9 @@ def score_public_items(game, player_idx):
                                 description="Player {} owns edge {}".format(player_idx, edge.uuid),
                             )
                         )
-    for bonus_status in game.bonus_statuses:
-        bonus_idx = game.bonusuuid2bonusidx.get(bonus_status.bonus_uuid)
-        bonus = game.game_config.fig.board_config.bonuses[bonus_idx] if bonus_idx is not None else None
+    for bonus_status in state.bonus_statuses:
+        bonus_idx = state.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(
@@ -2836,13 +2832,13 @@ def calc_bonus_status(game, bonus):
     return None
 
 
-def get_bonus_status_longest_trail(game, bonus):
+def get_bonus_status_longest_trail(state, bonus):
     longest_trail = 0
     winners = []
     player_longest_trail_lens = []
 
-    for player_idx in range(game.game_config.num_players):
-        trail_length = get_longest_path_length(game, player_idx)
+    for player_idx in range(state.kernel.game_config.num_players):
+        trail_length = get_longest_path_length(state, player_idx)
         player_longest_trail_lens.append(trail_length)
         if trail_length > longest_trail:
             longest_trail = trail_length
@@ -2868,14 +2864,14 @@ def get_bonus_status_longest_trail(game, bonus):
     )
 
 
-def handle_bonus_statuses(game):
+def handle_bonus_statuses(state):
     bonus_statuses = [
-        calc_bonus_status(game, bonus)
-        for bonus in game.game_config.fig.board_config.bonuses
+        calc_bonus_status(state, bonus)
+        for bonus in state.kernel.game_config.fig.board_config.bonuses
     ]
     # Remove all None bonus statuses
     bonus_statuses = [bs for bs in bonus_statuses if bs is not None]
-    return game.set(bonus_statuses=bonus_statuses)
+    return state.set(bonus_statuses=bonus_statuses)
 
 
 def default_handle_scoring(game):
@@ -3176,12 +3172,12 @@ def random_player_graph_walk(game, player_idx):
     return walk([random_start_node_idx], set([]))
 
 
-def find_player_with_longest_path(game):
+def find_player_with_longest_path(state):
     longest_path_player_idx = None
     longest_path_length = 0
 
-    for player_idx in range(game.game_config.num_players):
-        path_length = get_longest_path_length(game, player_idx)
+    for player_idx in range(state.kernel.game_config.num_players):
+        path_length = get_longest_path_length(state, player_idx)
         if path_length > longest_path_length:
             longest_path_length = path_length
             longest_path_player_idx = player_idx
@@ -3189,7 +3185,7 @@ def find_player_with_longest_path(game):
     if longest_path_player_idx is None:
         return None
     
-    return game.players[longest_path_player_idx]
+    return state.players[longest_path_player_idx]
 
 
 @dispatch(State, set)
@@ -3340,10 +3336,10 @@ def calc_player_graph(game, player_idx):
     )
 
 
-def calc_player_graphs(game):
-    game_config = game.game_config
+def calc_player_graphs(state):
+    game_config = state.kernel.game_config
     return [
-        calc_player_graph(game, player_idx) 
+        calc_player_graph(state, player_idx) 
         for player_idx in range(game_config.num_players)
     ]
 
@@ -4094,7 +4090,7 @@ def getnextstate2(s, a, log=False):
 
     state_kernel = init_state_kernel(
         rng=s.rng,
-        game_config=s.game_config,
+        game_config=s.kernel.game_config,
         edges=s.edges,
         decks=s.decks,
         piles=s.piles,
@@ -4468,19 +4464,10 @@ 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
-    nodeuuid2idx = {node.uuid: node.idx for node in s.nodes}
-    node_idxs = [nodeuuid2idx[node_uuid] for node_uuid in goal.node_uuids]
-    if goal.uuid == "d9ef7d75-63d4-4ceb-adce-f889db3c75f0":
-        print("goal.uuid: ", goal.uuid)
-        print("goal.node_uuids: ", goal.node_uuids)
-        print(f"player: {player_idx} goal: ", goal.uuid)
-        print("graph: ", graph)
-        print("node_idxs: ", node_idxs)
-        print("are_nodes_connected(graph, node_idxs): ", are_nodes_connected(graph, node_idxs))
-        for node in s.nodes:
-            print(f"node: {node}")
+    node_idxs = [s.kernel.nodeuuid2idx[node_uuid] for node_uuid in goal.node_uuids]
     return are_nodes_connected(
         graph,
         node_idxs,

{graph_games_proto-0.3.1952.dist-info → graph_games_proto-0.3.1964.dist-info}/METADATA

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

{graph_games_proto-0.3.1952.dist-info → graph_games_proto-0.3.1964.dist-info}/RECORD

@@ -1,9 +1,9 @@
 graph_games_proto/__init__.py,sha256=_EVQR-51XehfH45XZlba1WPdx3omS3Gm1nTwrgGyn2Q,667
 graph_games_proto/all_types.py,sha256=IpbwftEcHS5Ewz-saFNk0lO9FvcbuHG36odRTayCXUk,54911
-graph_games_proto/fns.py,sha256=k9npdHPzXr009dTSA_iJeTC7GiZj8TYohJlLyp1wULg,182582
+graph_games_proto/fns.py,sha256=NBy2Ugs9XrIkerSWX6c9yshGiWJKg3P6KoehZa1iIOE,181978
 graph_games_proto/main.py,sha256=fj2U7KcwrpZtuUhjOX5yVxY18LZvvsxDFYZ_S5mxe04,145
 graph_games_proto/state.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graph_games_proto-0.3.1952.dist-info/METADATA,sha256=5BHTXHDTovOFX5UTg17YNTXEHi2_Q1vTPpfCl6vJkwA,188
-graph_games_proto-0.3.1952.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-graph_games_proto-0.3.1952.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
-graph_games_proto-0.3.1952.dist-info/RECORD,,
+graph_games_proto-0.3.1964.dist-info/METADATA,sha256=B3PirCx5a9Pcc2dG8qv9uT3ErTjWCEE0oIqs7eVk2QI,188
+graph_games_proto-0.3.1964.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+graph_games_proto-0.3.1964.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
+graph_games_proto-0.3.1964.dist-info/RECORD,,