graph-games-proto 0.3.1937__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]
@@ -1966,7 +1966,7 @@ class StateKernal(PClass):
         }
     @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"]],
@@ -2017,7 +2017,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,
@@ -2036,7 +2036,7 @@ def init_state_kernel(**kwargs):
 
 
 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]
@@ -2092,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"]],
@@ -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
 

{graph_games_proto-0.3.1937.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.1937
+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.1937.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=7Sub-734RnmdNZ2bR9r4b2dYjWdaTNcD8v6MxS6dBhQ,182190
+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.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.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,,