graph-games-proto 0.3.1966__py3-none-any.whl → 0.3.1979__py3-none-any.whl

graph_games_proto/fns.py

@@ -2042,7 +2042,6 @@ def init_state_kernel(**kwargs):
 class State(PClass):
     kernel = field(type=StateKernel)
     idx2path = field(type=list)  # List[Path2]
-    pieceuuid2piece = field(type=dict)  # Dict[str, Piece]
     bonus_statuses = field(type=list)  # List[BonusStatus]
     bonusuuid2bonusidx = field(type=dict)  # Dict[str, int]
     carduuid2deckidx = field(type=dict)  # Dict[str, int]
@@ -2067,7 +2066,6 @@ class State(PClass):
         return {
             "kernel": self.kernel.__todict__(),
             "idx2path": [v.__todict__() for v in self.idx2path],
-            "pieceuuid2piece": {k: v.__todict__() for k, v in self.pieceuuid2piece.items()},
             "bonus_statuses": [status.__todict__() for status in self.bonus_statuses],
             "bonusuuid2bonusidx": self.bonusuuid2bonusidx,
             "carduuid2deckidx": self.carduuid2deckidx,
@@ -2094,7 +2092,6 @@ class State(PClass):
         return State(
             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"]],
             bonusuuid2bonusidx=d["bonusuuid2bonusidx"],
             carduuid2deckidx=d["carduuid2deckidx"],
@@ -2639,7 +2636,6 @@ def getinitialstate(game_config):
 
     state = State(
         idx2path=idx2path,
-        pieceuuid2piece=pieceuuid2piece,
         bonus_statuses=bonus_statuses,
         bonusuuid2bonusidx=bonusuuid2bonusidx,
         carduuid2deckidx=carduuid2deckidx,
@@ -2718,6 +2714,7 @@ def run_state_action_hooks(state, action, hooks, log=False):
     )
 
 
+@dispatch(State, int)
 def score_public_items(state, player_idx):
     items = []
     for edge in state.edges:
@@ -2725,7 +2722,7 @@ def score_public_items(state, player_idx):
             if len(path.segments) > 0:
                 first_segment = path.segments[0]
                 if first_segment.pieces and len(first_segment.pieces) > 0:
-                    first_piece = state.pieceuuid2piece[first_segment.pieces[0]]
+                    first_piece = state.kernel.pieceuuid2piece[first_segment.pieces[0]]
                     if first_piece.player_idx == player_idx:
                         items.append(
                             ScoreItem2(
@@ -3315,14 +3312,15 @@ def handle_move_pieces_to_path_action(game, action):
     return game
 
 
-def calc_player_graph(game, player_idx):
-    nodes = game.nodes
+@dispatch(State, int)
+def calc_player_graph(state, player_idx):
+    nodes = state.nodes
     node2neighbors = {node.idx: set() for node in nodes}
 
-    for edge in game.edges:
+    for edge in state.edges:
         for path in edge.paths:
             for segment in path.segments:
-                if segment.pieces and segment.pieces[0] and game.pieceuuid2piece[segment.pieces[0]].player_idx == player_idx:
+                if segment.pieces and segment.pieces[0] and state.kernel.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)
@@ -3587,19 +3585,21 @@ def is_move_pieces_to_path_action_legal(game, action):
     )
 
 
-def get_total_path_count(game):
-    return len(game.idx2path)
+@dispatch(StateKernel)
+def get_total_path_count(kernel):
+    return len(kernel.idx2path)
 
 
-def get_legal_actions_for_path(game, player_idx, path_idx):
-    if path_idx < 0 or get_total_path_count(game) <= path_idx:
+@dispatch(StateKernel, int, int)
+def get_legal_actions_for_path(state_kernel, player_idx, path_idx):
+    if path_idx < 0 or get_total_path_count(state_kernel) <= path_idx:
         return []
 
-    if not is_path_open_to_player(game, path_idx, player_idx):
+    if not is_path_open_to_player(state_kernel, path_idx, player_idx):
         return []
 
     legal_actions = []
-    default = get_sample_actionclaimpath(game, player_idx, path_idx)
+    default = get_sample_actionclaimpath(state_kernel, player_idx, path_idx)
     if default:
         legal_actions.append(
             LegalAction(
@@ -3608,7 +3608,7 @@ def get_legal_actions_for_path(game, player_idx, path_idx):
                 title="Select resources to claim path",
                 instruction="claim a path",
                 allotted_seconds=DEFAULT_ALLOTTED_SECONDS,
-                allotted_since_action_idx=(len(game.history) - 1),
+                allotted_since_action_idx=(len(state_kernel.history) - 1),
                 btn_text="Claim path",
                 move_pieces_to_path=LegalActionMovePiecesToPath(
                     path_idx=int(path_idx),
@@ -3620,11 +3620,12 @@ def get_legal_actions_for_path(game, player_idx, path_idx):
     return []
 
 
-def get_legal_actions_for_paths(game, player_idx):
+@dispatch(StateKernel, int)
+def get_legal_actions_for_paths(kernel, player_idx):
     legal_actions = []
     
-    for path_idx in range(get_total_path_count(game)):
-        legal_actions_for_path = get_legal_actions_for_path(game, player_idx, path_idx)
+    for path_idx in range(get_total_path_count(kernel)):
+        legal_actions_for_path = get_legal_actions_for_path(kernel, player_idx, path_idx)
         if legal_actions_for_path:
             legal_actions.extend(legal_actions_for_path)
         # else:
@@ -3633,7 +3634,8 @@ def get_legal_actions_for_paths(game, player_idx):
     return legal_actions
 
 
-def get_player_idxs_on_edge(game, edge):
+@dispatch(StateKernel, BiEdge)
+def get_player_idxs_on_edge(kernel, edge):
     player_idxs = set()
     if not edge or not edge.paths:
         return list(player_idxs)
@@ -3641,26 +3643,26 @@ def get_player_idxs_on_edge(game, edge):
     for path in edge.paths:
         for segment in path.segments:
             if segment.pieces and segment.pieces[0]:
-                piece = game.pieceuuid2piece.get(segment.pieces[0])
+                piece = kernel.pieceuuid2piece.get(segment.pieces[0])
                 if piece:
                     player_idxs.add(piece.player_idx)
     
     return list(player_idxs)
 
+@dispatch(StateKernel, int, int)
+def is_path_open_to_player(state_kernel, path_idx, player_idx):
 
-def is_path_open_to_player(game, path_idx, player_idx):
-
-    if not game or path_idx < 0 or get_total_path_count(game) <= path_idx:
+    if not state_kernel or path_idx < 0 or get_total_path_count(state_kernel) <= path_idx:
         return False
     
-    path = game.idx2path[path_idx]
-    edge_idx = game.edgeuuid2idx[path.edge_uuid]
-    edge = game.edges[edge_idx]
+    path = state_kernel.idx2path[path_idx]
+    edge_idx = state_kernel.edgeuuid2idx[path.edge_uuid]
+    edge = state_kernel.edges[edge_idx]
 
-    player_idxs_on_edge = get_player_idxs_on_edge(game, edge)
+    player_idxs_on_edge = get_player_idxs_on_edge(state_kernel, edge)
 
     # Check if edge is too crowded for the number of players
-    if game.game_config.num_players <= 3:
+    if state_kernel.game_config.num_players <= 3:
         if len(player_idxs_on_edge) > 0:
             return False
         
@@ -3672,7 +3674,7 @@ def is_path_open_to_player(game, path_idx, player_idx):
         return False
 
     # Check if the player has enough pieces to claim the path
-    player_pieces = game.players[player_idx].pieces
+    player_pieces = state_kernel.players[player_idx].pieces
     if len(player_pieces) < len(path.segments):
         return False
     
@@ -3844,18 +3846,18 @@ def get_sample_actionclaimpath(game, player_idx, path_idx):
         card_uuids=card_fulfillment,
     )
 
-
-def get_sample_path_fulfillment(game, player_idx, path_idx):
-    path = game.idx2path[path_idx]
-    remaining_card_uuids = [card_uuid for card_uuid in game.players[player_idx].cards if game.carduuid2card[card_uuid].deck_idx == 0]
+@dispatch(StateKernel, int, int)
+def get_sample_path_fulfillment(kernel, player_idx, path_idx):
+    path = kernel.idx2path[path_idx]
+    remaining_card_uuids = [card_uuid for card_uuid in kernel.players[player_idx].cards if kernel.carduuid2card[card_uuid].deck_idx == 0]
     remaining_pieces = [
         piece_uuid 
-        for piece_uuid in game.players[player_idx].pieces 
-        if game.pieceuuid2piece[piece_uuid].piece_template_idx == 0
+        for piece_uuid in kernel.players[player_idx].pieces 
+        if kernel.pieceuuid2piece[piece_uuid].piece_template_idx == 0
     ]
     remaining_segments = path.segments
     return get_path_fulfillment_from_resources(
-        game,
+        kernel,
         remaining_card_uuids,
         remaining_pieces,
         remaining_segments,
@@ -4072,7 +4074,6 @@ def init_state(kernel):
         legal_actions_3=[],
         is_terminal=False,
         idx2path=kernel.idx2path,
-        pieceuuid2piece=kernel.pieceuuid2piece,
         carduuid2card=kernel.carduuid2card,
     )
     state = state.set(legal_actions_3=calc_legal_actions3(kernel))
@@ -4266,7 +4267,7 @@ def getpublicstate(s):
         deadlines=get_deadlines(s),
         game_started_at=s.kernel.game_config.started_at,
         allotted_times=get_max_allotted_times(s),
-        all_pieces=list(s.pieceuuid2piece.values()),
+        all_pieces=list(s.kernel.pieceuuid2piece.values()),
         to_play_2=getpublictoplay(s),
         bonus_statuses=s.bonus_statuses,
         starting_decks=s.starting_decks,
@@ -4307,7 +4308,7 @@ def getpublicplayer(s, p):
         deck_counts[s.kernel.carduuid2card[card].deck_idx] += 1
     piece_template_counts = [0 for _ in s.kernel.game_config.fig.board_config.piece_templates]
     for piece_uuid in p.pieces:
-        piece_template_counts[s.pieceuuid2piece[piece_uuid].piece_template_idx] += 1
+        piece_template_counts[s.kernel.pieceuuid2piece[piece_uuid].piece_template_idx] += 1
     return PublicPlayer(
         idx=p.idx,
         pieces=p.pieces,
@@ -5293,6 +5294,7 @@ HANDLE_TERMINAL_HOOKS = [
     ),
 ]
 
+@dispatch(StateKernel, int)
 def get_default_legal_actions(state_kernel, player_idx):
     allotted_seconds = DEFAULT_ALLOTTED_SECONDS
     allotted_since_action_idx = len(state_kernel.history) - 1

{graph_games_proto-0.3.1966.dist-info → graph_games_proto-0.3.1979.dist-info}/METADATA

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

{graph_games_proto-0.3.1966.dist-info → graph_games_proto-0.3.1979.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=XaDJPmMLioflSj00zzPXjdF1JfBh-hZB5dLO1OTn7lQ,182090
+graph_games_proto/fns.py,sha256=UmMYsHE-hSIYp7yY97Ymw2slYoiksCnlyOSmh2IAXB0,182175
 graph_games_proto/main.py,sha256=fj2U7KcwrpZtuUhjOX5yVxY18LZvvsxDFYZ_S5mxe04,145
 graph_games_proto/state.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graph_games_proto-0.3.1966.dist-info/METADATA,sha256=4JWfsAdg8cjBPgPN1tFc6UuRWIMKSvKtceQmO5iRN4s,188
-graph_games_proto-0.3.1966.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-graph_games_proto-0.3.1966.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
-graph_games_proto-0.3.1966.dist-info/RECORD,,
+graph_games_proto-0.3.1979.dist-info/METADATA,sha256=SpZKxq-eiPOe7pvaqflou0pEJSMT7kpJvi5m7N9C5Co,188
+graph_games_proto-0.3.1979.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+graph_games_proto-0.3.1979.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
+graph_games_proto-0.3.1979.dist-info/RECORD,,