graph-games-proto 0.3.1935__py3-none-any.whl → 0.3.1952__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]
@@ -1946,6 +1946,7 @@ class StateKernal(PClass):
     pieceuuid2piece = field(type=dict)  # Dict[str, Piece]
     edgeuuid2idx = field(type=dict)  # Dict[str, int]
     carduuid2card = field(type=dict)  # Dict[str, Card]
+    edgetuple2uuid = field(type=dict)  # Dict[Tuple[int, int], str]
     def __todict__(self):
         return {
             "rng": rng2json(self.rng),
@@ -1961,10 +1962,11 @@ class StateKernal(PClass):
             "pieceuuid2piece": {k: v.__todict__() for k, v in self.pieceuuid2piece.items()},
             "edgeuuid2idx": self.edgeuuid2idx,
             "carduuid2card": {k: v.__todict__() for k, v in self.carduuid2card.items()},
+            "edgetuple2uuid": [{"k": list(k), "v": v} for k, v in self.edgetuple2uuid.items()],
         }
     @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"]],
@@ -1978,10 +1980,12 @@ class StateKernal(PClass):
             pieceuuid2piece={k: Piece.__fromdict(v) for k, v in d["pieceuuid2piece"].items()},
             edgeuuid2idx=d["edgeuuid2idx"],
             carduuid2card={k: Card.__fromdict(v) for k, v in d["carduuid2card"].items()},
+            edgetuple2uuid={tuple(item["k"]): item["v"] for item in d["edgetuple2uuid"]},
         )
 
 
 def init_state_kernel(**kwargs):
+    rng = kwargs.get('rng')
     game_config = kwargs.get('game_config')
     fig = game_config.fig
     board_config = fig.board_config
@@ -2003,9 +2007,18 @@ def init_state_kernel(**kwargs):
         cards = generate_cards(dek)
         for card in cards:
             carduuid2card[card.uuid] = card
+
+    nodeuuid2idx = {node.uuid: idx for idx, node in enumerate(board_config.points)}
+    edges = get_edges(rng, board_config, nodeuuid2idx)
+    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 StateKernal(
-        rng=kwargs.get('rng'),
+    return StateKernel(
+        rng=rng,
         game_config=game_config,
         edges=edges,
         decks=kwargs.get('decks'),
@@ -2018,11 +2031,12 @@ def init_state_kernel(**kwargs):
         edgeuuid2idx=edgeuuid2idx,
         carduuid2card=carduuid2card,
         pieceuuid2piece=pieceuuid2piece,
+        edgetuple2uuid=edgetuple2uuid,
     )
 
 
 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]
@@ -2037,7 +2051,6 @@ class State(PClass):
     nodes = field(type=list)  # List[Node]
     nodeuuid2idx = field(type=dict)  # Dict[str, int]
     edges = field(type=list)  # List[BiEdge]
-    edgetuple2uuid = field(type=dict)  # Dict[Tuple[int, int], str]
     regions = field(type=list)  # List[Region]
     legal_actions_3 = field(type=list)  # List[LegalAction]
     piles = field(type=list)  # List[Pile]
@@ -2065,7 +2078,6 @@ class State(PClass):
             "nodes": [node.__todict__() for node in self.nodes],
             "nodeuuid2idx": self.nodeuuid2idx,
             "edges": [edge.__todict__() for edge in self.edges],
-            "edgetuple2uuid": [{"k": list(k), "v": v} for k, v in self.edgetuple2uuid.items()],
             "regions": [region.__todict__() for region in self.regions],
             "legal_actions_3": [x.__todict__() for x in self.legal_actions_3],
             "piles": [pile.__todict__() for pile in self.piles],
@@ -2080,7 +2092,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"]],
@@ -2095,7 +2107,6 @@ class State(PClass):
             nodes=[Node.__fromdict__(n) for n in d["nodes"]],
             nodeuuid2idx=d["nodeuuid2idx"],
             edges=[BiEdge.__fromdict__(e) for e in d["edges"]],
-            edgetuple2uuid={tuple(item["k"]): item["v"] for item in d["edgetuple2uuid"]},
             regions=[Region.__fromdict__(r) for r in d["regions"]],
             legal_actions_3=[LegalAction.__fromdict__(x) for x in d["legal_actions_3"]],
             piles=[Pile.__fromdict__(p) for p in d["piles"]],
@@ -2603,12 +2614,6 @@ def getinitialstate(game_config):
 
     nodeuuid2idx = {node.uuid: idx for idx, node in enumerate(board_config.points)}
     edges = get_edges(rng, board_config, nodeuuid2idx)
-    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
 
     idx2path = []
     
@@ -2658,7 +2663,6 @@ def getinitialstate(game_config):
         nodes = nodes,
         nodeuuid2idx = nodeuuid2idx,
         edges = edges,
-        edgetuple2uuid = edgetuple2uuid,
         regions = get_regions(board_config),
         legal_actions_3=[],
         piles=piles,
@@ -3188,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.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)
@@ -3564,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,
@@ -3714,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:
@@ -3741,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))
@@ -3760,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}")
@@ -3788,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)
@@ -3859,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")
@@ -3869,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
@@ -3877,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
 

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

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

{graph_games_proto-0.3.1935.dist-info → graph_games_proto-0.3.1952.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=Z1wk8lPk39U7qe84dnL749mSIcG-xiIiPKFjCG0mUGE,182031
+graph_games_proto/fns.py,sha256=k9npdHPzXr009dTSA_iJeTC7GiZj8TYohJlLyp1wULg,182582
 graph_games_proto/main.py,sha256=fj2U7KcwrpZtuUhjOX5yVxY18LZvvsxDFYZ_S5mxe04,145
 graph_games_proto/state.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graph_games_proto-0.3.1935.dist-info/METADATA,sha256=LWnt0sLT7V7SwgFk3_hXmRXORmEu0mZQshFGugg-sTw,188
-graph_games_proto-0.3.1935.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-graph_games_proto-0.3.1935.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
-graph_games_proto-0.3.1935.dist-info/RECORD,,
+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,,