graph-games-proto 0.3.1937__py3-none-any.whl → 0.3.1953__py3-none-any.whl

graph_games_proto/fns.py

@@ -1932,7 +1932,7 @@ class BonusStatus(PClass):
         )
 
 
-class StateKernal(PClass):
+class StateKernel(PClass):
     rng = field(type=random.Random)
     game_config = field(type=GameConfig)
     edges = field(type=list)  # List[BiEdge]
@@ -1947,6 +1947,7 @@ class StateKernal(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,10 +1964,11 @@ class StateKernal(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):
-        return StateKernal(
+        return StateKernel(
             rng=json2rng(d["rng"]),
             game_config=GameConfig.__fromdict__(d["game_config"]),
             edges=[BiEdge.__fromdict__(edge) for edge in d["edges"]],
@@ -1981,6 +1983,7 @@ class StateKernal(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"],
         )
 
 
@@ -2017,7 +2020,7 @@ def init_state_kernel(**kwargs):
         edge_tuple = (min(node_1_idx, node_2_idx), max(node_1_idx, node_2_idx))
         edgetuple2uuid[edge_tuple] = edge.uuid
     
-    return StateKernal(
+    return StateKernel(
         rng=rng,
         game_config=game_config,
         edges=edges,
@@ -2032,11 +2035,12 @@ def init_state_kernel(**kwargs):
         carduuid2card=carduuid2card,
         pieceuuid2piece=pieceuuid2piece,
         edgetuple2uuid=edgetuple2uuid,
+        nodeuuid2idx=nodeuuid2idx,
     )
 
 
 class State(PClass):
-    kernel = field(type=StateKernal)
+    kernel = field(type=StateKernel)
     idx2path = field(type=list)  # List[Path2]
     pieceuuid2piece = field(type=dict)  # Dict[str, Piece]
     bonus_statuses = field(type=list)  # List[BonusStatus]
@@ -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]
@@ -2076,7 +2079,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],
@@ -2092,7 +2094,7 @@ class State(PClass):
     @staticmethod
     def __fromdict__(d):
         return State(
-            kernel=StateKernal.__fromdict__(d["kernel"]),
+            kernel=StateKernel.__fromdict__(d["kernel"]),
             idx2path=[Path2.__fromdict__(v) for v in d["idx2path"]],
             pieceuuid2piece={k: Piece.__fromdict__(v) for k, v in d["pieceuuid2piece"].items()},
             bonus_statuses=[BonusStatus.__fromdict__(x) for x in d["bonus_statuses"]],
@@ -2105,7 +2107,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"]],
@@ -2661,7 +2662,6 @@ def getinitialstate(game_config):
         ],
         goals = board_config.goals,
         nodes = nodes,
-        nodeuuid2idx = nodeuuid2idx,
         edges = edges,
         regions = get_regions(board_config),
         legal_actions_3=[],
@@ -3192,15 +3192,16 @@ def find_player_with_longest_path(game):
     return game.players[longest_path_player_idx]
 
 
-def calc_path_len_from_edges(game, edge_tuples):
+@dispatch(State, set)
+def calc_path_len_from_edges(state, edge_tuples):
     if edge_tuples is None:
         return 0
     edge_lens = []
     for edge_tuple in edge_tuples:
-        edge_uuid = game.kernel.edgetuple2uuid.get(edge_tuple)
-        edge_idx = game.edgeuuid2idx.get(edge_uuid)
+        edge_uuid = state.kernel.edgetuple2uuid.get(edge_tuple)
+        edge_idx = state.kernel.edgeuuid2idx.get(edge_uuid)
         if edge_idx is not None:
-            edge = game.edges[edge_idx]
+            edge = state.edges[edge_idx]
             if edge and edge.paths:
                 first_path = edge.paths[0]
                 edge_len = len(first_path.segments)
@@ -3568,7 +3569,7 @@ def is_move_pieces_to_path_action_legal(game, action):
     # print("******************************1234 is_move_pieces_to_path_action_legal 1d: ", len(remaining_segments))
     
     card_fulfillment, piece_fulfillment = get_path_fulfillment_from_resources(
-        game,
+        game.kernel,
         proposed_cards,
         proposed_pieces,
         remaining_segments,
@@ -3718,24 +3719,25 @@ HOOK_NAMESPACE = {
     'ActionMovePiecesToPath': ActionMovePiecesToPathOptional,
 }
 
-
-def get_wild_unit_uuids(game):
+@dispatch(StateKernel)
+def get_wild_unit_uuids(state_kernel):
     wild_unit_uuids = []
-    for card in game.carduuid2card.values():
+    for card in state_kernel.carduuid2card.values():
         if card.is_wild:
             wild_unit_uuids.append(card.resource_uuid)
     return wild_unit_uuids
 
 
-def match_strict_wild(game, fulfillment, cards, segments):
+@dispatch(StateKernel, list, list, list)
+def match_strict_wild(state_kernel, fulfillment, cards, segments):
     new_fulfillment = fulfillment.copy()
     new_cards = cards.copy()
-    wild_unit_uuids = get_wild_unit_uuids(game)
+    wild_unit_uuids = get_wild_unit_uuids(state_kernel)
     new_segments = []
 
     for segment in segments:
         if segment.unit_uuid and segment.unit_uuid in wild_unit_uuids:
-            first_matching_idx = next((i for i, card_uuid in enumerate(new_cards) if game.carduuid2card[card_uuid].resource_uuid == segment.unit_uuid), None)
+            first_matching_idx = next((i for i, card_uuid in enumerate(new_cards) if state_kernel.carduuid2card[card_uuid].resource_uuid == segment.unit_uuid), None)
             if first_matching_idx is not None:
                 new_fulfillment.append(new_cards.pop(first_matching_idx))
             else:
@@ -3745,16 +3747,16 @@ def match_strict_wild(game, fulfillment, cards, segments):
 
     return new_fulfillment, new_cards, new_segments
 
-
-def match_non_wild_non_empty(game, fulfillment, cards, segments, log=False):
+@dispatch(StateKernel, list, list, list)
+def match_non_wild_non_empty(state_kernel, fulfillment, cards, segments):
     new_fulfillment = fulfillment.copy()
     new_cards = cards.copy()
-    wild_unit_uuids = get_wild_unit_uuids(game)
+    wild_unit_uuids = get_wild_unit_uuids(state_kernel)
     new_segments = []
 
     for segment in segments:
-        first_strict_matching_idx = next((i for i, card_uuid in enumerate(new_cards) if game.carduuid2card[card_uuid].resource_uuid == segment.unit_uuid), None)
-        first_wild_matching_idx = next((i for i, card_uuid in enumerate(new_cards) if game.carduuid2card[card_uuid].resource_uuid in wild_unit_uuids), None)
+        first_strict_matching_idx = next((i for i, card_uuid in enumerate(new_cards) if state_kernel.carduuid2card[card_uuid].resource_uuid == segment.unit_uuid), None)
+        first_wild_matching_idx = next((i for i, card_uuid in enumerate(new_cards) if state_kernel.carduuid2card[card_uuid].resource_uuid in wild_unit_uuids), None)
         first_matching_idx = first_strict_matching_idx if first_strict_matching_idx is not None else first_wild_matching_idx
         if first_matching_idx is not None:
             new_fulfillment.append(new_cards.pop(first_matching_idx))
@@ -3764,14 +3766,13 @@ def match_non_wild_non_empty(game, fulfillment, cards, segments, log=False):
     return new_fulfillment, new_cards, new_segments
 
     
-
-
-def match_empty(game, fulfillment, cards, segments):
+@dispatch(StateKernel, list, list, list)
+def match_empty(state_kernel, fulfillment, cards, segments):
     num_empty_segments = sum(1 for segment in segments if segment.unit_uuid is None)
     if num_empty_segments == 0:
         return fulfillment, cards, segments
     
-    tuples = get_uniform_sets(game, cards, num_empty_segments)
+    tuples = get_uniform_sets(state_kernel, cards, num_empty_segments)
     # print(f"****************************************** len(cards): {len(cards)}")
     # print(f"****************************************** num_empty_segments: {num_empty_segments}")
     # print(f"Found {len(tuples)} tuples for empty segments: {tuples}")
@@ -3792,15 +3793,16 @@ def match_empty(game, fulfillment, cards, segments):
     return new_fulfillment, new_cards, new_segments
 
 
-def get_uniform_sets(game, cards, min_length):
-    wilds = [card_uuid for card_uuid in cards if game.carduuid2card[card_uuid].is_wild]
-    non_wilds = [card_uuid for card_uuid in cards if not game.carduuid2card[card_uuid].is_wild]
+@dispatch(StateKernel, list, int)
+def get_uniform_sets(state_kernel, cards, min_length):
+    wilds = [card_uuid for card_uuid in cards if state_kernel.carduuid2card[card_uuid].is_wild]
+    non_wilds = [card_uuid for card_uuid in cards if not state_kernel.carduuid2card[card_uuid].is_wild]
     # print("********************* cards: ", cards)
     # print("********************* wilds: ", wilds)
     # print("********************* non_wilds: ", non_wilds)
     unit_uuid_2_cards = {}
     for card_uuid in non_wilds:
-        card = game.carduuid2card[card_uuid]
+        card = state_kernel.carduuid2card[card_uuid]
         if card.resource_uuid not in unit_uuid_2_cards:
             unit_uuid_2_cards[card.resource_uuid] = []
         unit_uuid_2_cards[card.resource_uuid].append(card_uuid)
@@ -3863,8 +3865,8 @@ def get_sample_path_fulfillment(game, player_idx, path_idx):
         remaining_segments,
     )
 
-
-def get_path_fulfillment_from_resources(game, remaining_card_uuids, remaining_pieces, remaining_segments, log=False):
+@dispatch(StateKernel, list, list, list)
+def get_path_fulfillment_from_resources(state_kernel, remaining_card_uuids, remaining_pieces, remaining_segments, log=False):
 
     if len(remaining_pieces) < len(remaining_segments):
         print("Not enough pieces to fulfill the path segments")
@@ -3873,7 +3875,7 @@ def get_path_fulfillment_from_resources(game, remaining_card_uuids, remaining_pi
     piece_fulfillment = remaining_pieces[:len(remaining_segments)]
 
     card_fulfillment = []
-    card_fulfillment, remaining_card_uuids, remaining_segments = match_strict_wild(game, card_fulfillment, remaining_card_uuids, remaining_segments)
+    card_fulfillment, remaining_card_uuids, remaining_segments = match_strict_wild(state_kernel, card_fulfillment, remaining_card_uuids, remaining_segments)
 
     if len(remaining_segments) == 0:
         return card_fulfillment, piece_fulfillment
@@ -3881,14 +3883,14 @@ def get_path_fulfillment_from_resources(game, remaining_card_uuids, remaining_pi
     # elif len(get_wild_segments(remaining_segments)) > 0:
     #     return None
 
-    card_fulfillment, remaining_card_uuids, remaining_segments = match_non_wild_non_empty(game, card_fulfillment, remaining_card_uuids, remaining_segments, log)
+    card_fulfillment, remaining_card_uuids, remaining_segments = match_non_wild_non_empty(state_kernel, card_fulfillment, remaining_card_uuids, remaining_segments)
     if len(remaining_segments) == 0:
         return card_fulfillment, piece_fulfillment
     # Probably don't need this check, but we should unit test
     # elif len(get_non_wild_non_empty_segments(remaining_segments)) > 0:
     #     return None
 
-    card_fulfillment, remaining_card_uuids, remaining_segments = match_empty(game, card_fulfillment, remaining_card_uuids, remaining_segments)
+    card_fulfillment, remaining_card_uuids, remaining_segments = match_empty(state_kernel, card_fulfillment, remaining_card_uuids, remaining_segments)
     if len(remaining_segments) == 0:
         return card_fulfillment, piece_fulfillment
 
@@ -4466,19 +4468,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.1937.dist-info → graph_games_proto-0.3.1953.dist-info}/METADATA

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

{graph_games_proto-0.3.1937.dist-info → graph_games_proto-0.3.1953.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=7Sub-734RnmdNZ2bR9r4b2dYjWdaTNcD8v6MxS6dBhQ,182190
+graph_games_proto/fns.py,sha256=Y880m_lmU6FCvxx4zowDu9Lrgcco4pOdDYYYQXzrQNY,182121
 graph_games_proto/main.py,sha256=fj2U7KcwrpZtuUhjOX5yVxY18LZvvsxDFYZ_S5mxe04,145
 graph_games_proto/state.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graph_games_proto-0.3.1937.dist-info/METADATA,sha256=L7F7-8wAqBVh6XrujYeaukSL2Lcn_xTOHKdVhDknwoQ,188
-graph_games_proto-0.3.1937.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-graph_games_proto-0.3.1937.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
-graph_games_proto-0.3.1937.dist-info/RECORD,,
+graph_games_proto-0.3.1953.dist-info/METADATA,sha256=ZAxOkRoFWLDz0NzLq1q15j0-FWw_gYTHWiqVvOH_Is8,188
+graph_games_proto-0.3.1953.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+graph_games_proto-0.3.1953.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
+graph_games_proto-0.3.1953.dist-info/RECORD,,