graph-games-proto 0.3.2049__py3-none-any.whl → 0.3.2077__py3-none-any.whl

graph_games_proto/fns.py

@@ -1104,7 +1104,7 @@ class PrivateState(PClass):
     player_score = field(type=PrivatePlayerScore)
     player = field(type=Player)
     legal_actions_3 = field(type=list)  # List[LegalAction]
-    goal_completions = field(type=list, initial=[])  # List[GoalCompletion]
+    goal_completions = field(type=list)  # List[GoalCompletion]
     def __todict__(self):
         return {
             "my_history": [x.__todict__() for x in self.my_history],
@@ -1779,6 +1779,33 @@ class Segment2(PClass):
             unit_uuid=d["unit_uuid"],
             pieces=d["pieces"],
         )
+    
+
+class SegmentRecord(PClass):
+    uuid = field(type=str)
+    unit_uuid = field(type=(str, type(None)), initial=None)  # Optional[str]
+    piece_uuids = field(type=list)  # List[str]
+    def __todict__(self):
+        return {
+            "uuid": self.uuid,
+            "unit_uuid": self.unit_uuid,
+            "piece_uuids": self.piece_uuids,
+        }
+    @staticmethod
+    def __fromdict__(d):
+        return SegmentRecord(
+            uuid=d["uuid"],
+            unit_uuid=d["unit_uuid"],
+            piece_uuids=d["piece_uuids"],
+        )
+
+
+def init_segment_record(segment: Segment2) -> SegmentRecord:
+    return SegmentRecord(
+        uuid=segment.uuid,
+        unit_uuid=segment.unit_uuid,
+        piece_uuids=[piece.uuid for piece in segment.pieces],
+    )
 
 
 class Path2(PClass):
@@ -1803,6 +1830,38 @@ class Path2(PClass):
         )
 
 
+class PathRecord(PClass):
+    uuid = field(type=str)
+    idx = field(type=int)
+    edge_uuid = field(type=str)
+    segment_uuids = field(type=list)  # List[str]
+    def __todict__(self):
+        return {
+            "uuid": self.uuid,
+            "idx": self.idx,
+            "edge_uuid": self.edge_uuid,
+            "segment_uuids": self.segment_uuids,
+        }
+    @staticmethod
+    def __fromdict__(d):
+        return PathRecord(
+            uuid=d["uuid"],
+            idx=d["idx"],
+            edge_uuid=d["edge_uuid"],
+            segment_uuids=d["segment_uuids"],
+        )
+
+
+def init_path_record(path: Path2) -> PathRecord:
+    return PathRecord(
+        uuid=path.uuid,
+        idx=path.idx,
+        edge_uuid=path.edge_uuid,
+        segment_uuids=[segment.uuid for segment in path.segments],
+    )
+
+
+
 class BiEdge(PClass):
     uuid = field(type=str)
     start_point_uuid = field(type=str)
@@ -1840,6 +1899,57 @@ class BiEdge(PClass):
         )
 
 
+class BiEdgeRecord(PClass):
+    uuid = field(type=str)
+    start_point_uuid = field(type=str)
+    end_point_uuid = field(type=str)
+    node_1_uuid = field(type=str)
+    node_2_uuid = field(type=str)
+    node_1_idx = field(type=int)
+    node_2_idx = field(type=int)
+    path_idxs = field(type=list)  # List[str]
+    score = field(type=int)
+    def __todict__(self):
+        return {
+            "uuid": self.uuid,
+            "start_point_uuid": self.start_point_uuid,
+            "end_point_uuid": self.end_point_uuid,
+            "node_1_uuid": self.node_1_uuid,
+            "node_2_uuid": self.node_2_uuid,
+            "node_1_idx": self.node_1_idx,
+            "node_2_idx": self.node_2_idx,
+            "path_idxs": self.path_idxs,
+            "score": self.score,
+        }
+    @staticmethod
+    def __fromdict__(d):
+        return BiEdgeRecord(
+            uuid=d["uuid"],
+            start_point_uuid=d["start_point_uuid"],
+            end_point_uuid=d["end_point_uuid"],
+            node_1_uuid=d["node_1_uuid"],
+            node_2_uuid=d["node_2_uuid"],
+            node_1_idx=d["node_1_idx"],
+            node_2_idx=d["node_2_idx"],
+            path_idxs=d["path_idxs"],
+            score=d["score"],
+        )
+
+
+def init_biedge_record(biedge: BiEdge) -> BiEdgeRecord:
+    return BiEdgeRecord(
+        uuid=biedge.uuid,
+        start_point_uuid=biedge.start_point_uuid,
+        end_point_uuid=biedge.end_point_uuid,
+        node_1_uuid=biedge.node_1_uuid,
+        node_2_uuid=biedge.node_2_uuid,
+        node_1_idx=biedge.node_1_idx,
+        node_2_idx=biedge.node_2_idx,
+        path_idxs=[path.idx for path in biedge.paths],
+        score=biedge.score,
+    )
+
+
 class Node(PClass):
     idx = field(type=int)
     uuid = field(type=str)
@@ -1932,9 +2042,23 @@ class BonusStatus(PClass):
         )
 
 
+#==
+# uuid2edgerecord
+# uuid2segmentrecord
+# idx2pathrecord
+# uuid2piece
+#==#
+
+
+
 class StateKernel(PClass):
     rng = field(type=random.Random)
     game_config = field(type=GameConfig)
+
+    uuid2edgerecord = field(type=dict)  # Dict[str, BiEdgeRecord]
+    uuid2segmentrecord = field(type=dict)  # Dict[str, SegmentRecord]
+    idx2pathrecord = field(type=list)  # List[PathRecord]
+
     edges = field(type=list)  # List[BiEdge]
     nodes = field(type=list)  # List[Node]
     regions = field(type=list)  # List[Region]
@@ -1943,7 +2067,6 @@ class StateKernel(PClass):
     players = field(type=list)  # List[Player]
     player_idxs = field(type=list)  # List[int]
     history = field(type=list)  # List[PublicAction]
-    idx2path = field(type=list)  # List[Path2]
     pieceuuid2piece = field(type=dict)  # Dict[str, Piece]
     edgeuuid2idx = field(type=dict)  # Dict[str, int]
     carduuid2card = field(type=dict)  # Dict[str, Card]
@@ -1968,7 +2091,9 @@ class StateKernel(PClass):
             "players": [player.__todict__() for player in self.players],
             "player_idxs": self.player_idxs,
             "history": [action.__todict__() for action in self.history],
-            "idx2path": [v.__todict__() for v in self.idx2path],
+            "uuid2edgerecord": {k: v.__todict__() for k, v in self.uuid2edgerecord.items()},
+            "uuid2segmentrecord": {k: v.__todict__() for k, v in self.uuid2segmentrecord.items()},
+            "idx2pathrecord": [v.__todict__() for v in self.idx2pathrecord],
             "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()},
@@ -1995,7 +2120,9 @@ class StateKernel(PClass):
             players=[Player.__fromdict__(player) for player in d["players"]],
             player_idxs=d["player_idxs"],
             history=[PublicAction.__fromdict__(action) for action in d["history"]],
-            idx2path=[Path2.__fromdict(v) for v in d["idx2path"]],
+            uuid2edgerecord={k: BiEdgeRecord.__fromdict__(v) for k, v in d["uuid2edgerecord"].items()},
+            uuid2segmentrecord={k: Segment2.__fromdict__(v) for k, v in d["uuid2segmentrecord"].items()},
+            idx2pathrecord=[Path2.__fromdict(v) for v in d["idx2pathrecord"]],
             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()},
@@ -2018,11 +2145,11 @@ def init_state_kernel(**kwargs):
     board_config = fig.board_config
     nodes = kwargs.get('nodes', [])
     edges = kwargs.get('edges', [])
-    idx2path = []
+    idx2pathrecord = []
     edgeuuid2idx = {edge.uuid: idx for idx, edge in enumerate(edges)}
     for edge in edges:
         for path in edge.paths:
-            idx2path.append(path)
+            idx2pathrecord.append(init_path_record(path))
     pieceuuid2piece = {}
     for piece_template in board_config.piece_templates:
         if piece_template.has_player:
@@ -2053,6 +2180,11 @@ def init_state_kernel(**kwargs):
     
     player_graphs_3 = calc_player_graphs3(nodes, edges, pieceuuid2piece, game_config)
 
+    segments = kwargs.get('segments', [])
+    
+    uuid2segmentrecord = {segment.uuid: init_segment_record(segment) for segment in segments}
+    uuid2edgerecord = {edge.uuid: init_biedge_record(edge) for edge in edges}
+
     return StateKernel(
         rng=rng,
         game_config=game_config,
@@ -2064,7 +2196,9 @@ def init_state_kernel(**kwargs):
         players=kwargs.get('players'),
         player_idxs=kwargs.get('player_idxs'),
         history=kwargs.get('history', []),
-        idx2path=idx2path,
+        uuid2edgerecord=uuid2edgerecord,
+        uuid2segmentrecord=uuid2segmentrecord,
+        idx2pathrecord=idx2pathrecord,
         edgeuuid2idx=edgeuuid2idx,
         carduuid2card=carduuid2card,
         pieceuuid2piece=pieceuuid2piece,
@@ -2083,7 +2217,7 @@ class State(PClass):
     kernel = field(type=StateKernel)
 
     # Identity - these fields should be in the kernel (can only be changed in "get_initial_state" and "get_next_state")
-    # The struture should be this: uuid2segment, uuid2edge, uuid2path, uuid2region, uuid2node
+    # The struture should be this: uuid2segmentrecord, uuid2edge, uuid2path, uuid2region, uuid2node
 
     # Memoized
     legal_actions_3 = field(type=list)  # List[LegalAction]
@@ -2466,6 +2600,20 @@ def get_nodes(board_config):
     return []
 
 
+def get_segments(board_config):
+    segments = []
+    for board_path in board_config.board_paths:
+        for segment in board_path.path.segments:
+            segments.append(
+                Segment2(
+                    uuid=segment.uuid, 
+                    unit_uuid=segment.unit_uuid, 
+                    pieces=[]
+                )
+            )
+    return segments
+
+
 def get_edges(rng, board_config, nodeuuid2idx):
     edges = []
     
@@ -2634,6 +2782,7 @@ def getinitialstate(game_config):
     kernel = init_state_kernel(
         rng=rng,
         game_config=game_config,
+        segments=get_segments(board_config),
         edges=edges,
         nodes=nodes,
         decks=decks,
@@ -3288,8 +3437,9 @@ def handle_move_bonus_cards(kernel, action):
 
 # Take a random walk on the player's graph. A node can be visiting more than once, but an edge cannot be visited more than once.
 # Example graph: PlayerGraph(player_idx=0, neighbors=[[], [], [], [], [], [], [], [], [], [], [30]
-def random_player_graph_walk(game, player_idx):
-    player_graph = game.player_graphs[player_idx]
+@dispatch(StateKernel, int)
+def random_player_graph_walk(kernel, player_idx):
+    player_graph = kernel.player_graphs_3[player_idx]
     nodes_indices_with_neighbors = [i for i, neighbors in enumerate(player_graph.neighbors) if neighbors]
     
     if not nodes_indices_with_neighbors:
@@ -3524,18 +3674,19 @@ def handle_move_pieces_to_path_action(kernel, action):
         return kernel
 
     path_idx = move_pieces_to_path.path_idx
-    path = kernel.idx2path[path_idx]
+    path_record = kernel.idx2pathrecord[path_idx]
 
-    if path is None or not path.segments:
+    if path_record is None or not path_record.segment_uuids:
         return kernel
 
-    for piece_uuid, segment in zip(default.piece_uuids, path.segments):
+    for piece_uuid, segment_uuid in zip(default.piece_uuids, path_record.segment_uuids):
+        segment_record = kernel.uuid2segmentrecord[segment_uuid]
         # Find the piece in the player's pieces
         piece_idx = next((i for i, player_piece_uuid in enumerate(player.pieces) if player_piece_uuid == piece_uuid), None)
         if piece_idx is not None:
             # Remove the piece from player's pieces
             piece = player.pieces.pop(piece_idx)
-            segment.pieces.append(piece)
+            segment_record.piece_uuids.append(piece)
 
     for card_uuid in default.card_uuids:
         # Find the card in the player's cards
@@ -3549,7 +3700,7 @@ def handle_move_pieces_to_path_action(kernel, action):
     kernel = recycle_decks_if_needed(kernel)
     kernel = replenish_decks_if_needed(kernel)
     kernel = kernel.set(players=kernel.players)
-    kernel = kernel.set(idx2path=kernel.idx2path)
+    kernel = kernel.set(idx2pathrecord=kernel.idx2pathrecord)
 
     return kernel
 
@@ -3835,10 +3986,10 @@ def is_move_pieces_to_path_action_legal(state, action):
     player_idx = action.legal_action.player_idx
     proposed_cards_uuids = action.move_pieces_to_path.card_uuids
     path_idx = action.legal_action.move_pieces_to_path.path_idx
-    path = state.kernel.idx2path[path_idx]
+    path_record = state.kernel.idx2pathrecord[path_idx]
     proposed_cards = [card_uuid for card_uuid in state.kernel.players[player_idx].cards if card_uuid in proposed_cards_uuids]
     proposed_pieces = [piece_uuid for piece_uuid in state.kernel.players[player_idx].pieces if piece_uuid in action.move_pieces_to_path.piece_uuids]
-    remaining_segments = path.segments
+    remaining_segment_records = [state.kernel.uuid2segmentrecord[segment_uuid] for segment_uuid in path_record.segment_uuids]
 
     # print("******************************1234 is_move_pieces_to_path_action_legal 1b: ", proposed_cards)
     # print("******************************1234 is_move_pieces_to_path_action_legal 1c: ", proposed_pieces)
@@ -3848,7 +3999,7 @@ def is_move_pieces_to_path_action_legal(state, action):
         state.kernel,
         proposed_cards,
         proposed_pieces,
-        remaining_segments,
+        remaining_segment_records,
     )
 
     # print("******************************1234 is_move_pieces_to_path_action_legal 2a", card_fulfillment)
@@ -3869,7 +4020,7 @@ def is_move_pieces_to_path_action_legal(state, action):
 
 @dispatch(StateKernel)
 def get_total_path_count(kernel):
-    return len(kernel.idx2path)
+    return len(kernel.idx2pathrecord)
 
 
 @dispatch(StateKernel, int, int)
@@ -3916,16 +4067,18 @@ def get_legal_actions_for_paths(kernel, player_idx):
     return legal_actions
 
 
-@dispatch(StateKernel, BiEdge)
-def get_player_idxs_on_edge(kernel, edge):
+@dispatch(StateKernel, BiEdgeRecord)
+def get_player_idxs_on_edge(kernel, edge_record):
     player_idxs = set()
-    if not edge or not edge.paths:
+    if not edge_record or not edge_record.path_idxs:
         return list(player_idxs)
     
-    for path in edge.paths:
-        for segment in path.segments:
-            if segment.pieces and segment.pieces[0]:
-                piece = kernel.pieceuuid2piece.get(segment.pieces[0])
+    for path_idx in edge_record.path_idxs:
+        path_record = kernel.idx2pathrecord[path_idx]
+        for segment_uuid in path_record.segment_uuids:
+            segment = kernel.uuid2segmentrecord[segment_uuid]
+            if segment.piece_uuids and segment.piece_uuids[0]:
+                piece = kernel.pieceuuid2piece[segment.piece_uuids[0]]
                 if piece:
                     player_idxs.add(piece.player_idx)
     
@@ -3937,11 +4090,10 @@ def is_path_open_to_player(state_kernel, path_idx, player_idx):
     if not state_kernel or path_idx < 0 or get_total_path_count(state_kernel) <= path_idx:
         return False
     
-    path = state_kernel.idx2path[path_idx]
-    edge_idx = state_kernel.edgeuuid2idx[path.edge_uuid]
-    edge = state_kernel.edges[edge_idx]
+    path_record = state_kernel.idx2pathrecord[path_idx]
+    edge_record = state_kernel.uuid2edgerecord[path_record.edge_uuid]
 
-    player_idxs_on_edge = get_player_idxs_on_edge(state_kernel, edge)
+    player_idxs_on_edge = get_player_idxs_on_edge(state_kernel, edge_record)
 
     # Check if edge is too crowded for the number of players
     if state_kernel.game_config.num_players <= 3:
@@ -3952,12 +4104,14 @@ def is_path_open_to_player(state_kernel, path_idx, player_idx):
         return False
     
     # Check if any segment of the path has pieces from any player
-    if path.segments[0].pieces:
-        return False
+    for segment_uuid in path_record.segment_uuids:
+        segment_record = state_kernel.uuid2segmentrecord[segment_uuid]
+        if segment_record.piece_uuids:
+            return False
 
     # Check if the player has enough pieces to claim the path
     player_pieces = state_kernel.players[player_idx].pieces
-    if len(player_pieces) < len(path.segments):
+    if len(player_pieces) < len(path_record.segment_uuids):
         return False
     
     return True
@@ -4009,68 +4163,68 @@ def get_wild_unit_uuids(state_kernel):
 
 
 @dispatch(StateKernel, list, list, list)
-def match_strict_wild(state_kernel, fulfillment, cards, segments):
+def match_strict_wild(state_kernel, fulfillment, cards, segment_records):
     new_fulfillment = fulfillment.copy()
     new_cards = cards.copy()
     wild_unit_uuids = get_wild_unit_uuids(state_kernel)
-    new_segments = []
+    new_segment_records = []
 
-    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 state_kernel.carduuid2card[card_uuid].resource_uuid == segment.unit_uuid), None)
+    for segment_record in segment_records:
+        if segment_record.unit_uuid and segment_record.unit_uuid in wild_unit_uuids:
+            first_matching_idx = next((i for i, card_uuid in enumerate(new_cards) if state_kernel.carduuid2card[card_uuid].resource_uuid == segment_record.unit_uuid), None)
             if first_matching_idx is not None:
                 new_fulfillment.append(new_cards.pop(first_matching_idx))
             else:
-                new_segments.append(segment)
+                new_segment_records.append(segment_record)
         else:
-            new_segments.append(segment)
+            new_segment_records.append(segment_record)
 
-    return new_fulfillment, new_cards, new_segments
+    return new_fulfillment, new_cards, new_segment_records
 
 @dispatch(StateKernel, list, list, list)
-def match_non_wild_non_empty(state_kernel, fulfillment, cards, segments):
+def match_non_wild_non_empty(state_kernel, fulfillment, cards, segment_records):
     new_fulfillment = fulfillment.copy()
     new_cards = cards.copy()
     wild_unit_uuids = get_wild_unit_uuids(state_kernel)
-    new_segments = []
+    new_segment_records = []
 
-    for segment in segments:
-        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)
+    for segment_record in segment_records:
+        first_strict_matching_idx = next((i for i, card_uuid in enumerate(new_cards) if state_kernel.carduuid2card[card_uuid].resource_uuid == segment_record.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))
         else:
-            new_segments.append(segment)
+            new_segment_records.append(segment_record)
     
-    return new_fulfillment, new_cards, new_segments
+    return new_fulfillment, new_cards, new_segment_records
 
     
 @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
+def match_empty(state_kernel, fulfillment, cards, segment_records):
+    num_empty_segment_records = sum(1 for segment_record in segment_records if segment_record.unit_uuid is None)
+    if num_empty_segment_records == 0:
+        return fulfillment, cards, segment_records
     
-    tuples = get_uniform_sets(state_kernel, cards, num_empty_segments)
+    tuples = get_uniform_sets(state_kernel, cards, num_empty_segment_records)
     # print(f"****************************************** len(cards): {len(cards)}")
     # print(f"****************************************** num_empty_segments: {num_empty_segments}")
     # print(f"Found {len(tuples)} tuples for empty segments: {tuples}")
     if len(tuples) == 0:
-        return fulfillment, cards, segments
+        return fulfillment, cards, segment_records
     
     new_fulfillment = fulfillment.copy()
 
-    new_segments = []
-    for segment in segments:
-        if segment.unit_uuid:
-            new_segments.append(segment)
+    new_segment_records = []
+    for segment_record in segment_records:
+        if segment_record.unit_uuid:
+            new_segment_records.append(segment_record)
 
-    first_tuple = tuples[0][:num_empty_segments]
+    first_tuple = tuples[0][:num_empty_segment_records]
     # print(f"Using first tuple for empty segments: {first_tuple}")
     new_cards = list(set(cards) - set(first_tuple))
     new_fulfillment.extend(first_tuple)
-    return new_fulfillment, new_cards, new_segments
+    return new_fulfillment, new_cards, new_segment_records
 
 
 @dispatch(StateKernel, list, int)
@@ -4130,48 +4284,48 @@ def get_sample_actionclaimpath(game, player_idx, path_idx):
 
 @dispatch(StateKernel, int, int)
 def get_sample_path_fulfillment(kernel, player_idx, path_idx):
-    path = kernel.idx2path[path_idx]
+    path_record = kernel.idx2pathrecord[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 kernel.players[player_idx].pieces 
         if kernel.pieceuuid2piece[piece_uuid].piece_template_idx == 0
     ]
-    remaining_segments = path.segments
+    remaining_segment_records = [kernel.uuid2segmentrecord[segment_uuid] for segment_uuid in path_record.segment_uuids]
     return get_path_fulfillment_from_resources(
         kernel,
         remaining_card_uuids,
         remaining_pieces,
-        remaining_segments,
+        remaining_segment_records,
     )
 
 @dispatch(StateKernel, list, list, list)
-def get_path_fulfillment_from_resources(state_kernel, remaining_card_uuids, remaining_pieces, remaining_segments, log=False):
+def get_path_fulfillment_from_resources(state_kernel, remaining_card_uuids, remaining_pieces, remaining_segment_records, log=False):
 
-    if len(remaining_pieces) < len(remaining_segments):
+    if len(remaining_pieces) < len(remaining_segment_records):
         print("Not enough pieces to fulfill the path segments")
         return None, None
     
-    piece_fulfillment = remaining_pieces[:len(remaining_segments)]
+    piece_fulfillment = remaining_pieces[:len(remaining_segment_records)]
 
     card_fulfillment = []
-    card_fulfillment, remaining_card_uuids, remaining_segments = match_strict_wild(state_kernel, card_fulfillment, remaining_card_uuids, remaining_segments)
+    card_fulfillment, remaining_card_uuids, remaining_segment_records = match_strict_wild(state_kernel, card_fulfillment, remaining_card_uuids, remaining_segment_records)
 
-    if len(remaining_segments) == 0:
+    if len(remaining_segment_records) == 0:
         return card_fulfillment, piece_fulfillment
     # Probably don't need this check, but we should unit test
     # elif len(get_wild_segments(remaining_segments)) > 0:
     #     return None
 
-    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:
+    card_fulfillment, remaining_card_uuids, remaining_segment_records = match_non_wild_non_empty(state_kernel, card_fulfillment, remaining_card_uuids, remaining_segment_records)
+    if len(remaining_segment_records) == 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(state_kernel, card_fulfillment, remaining_card_uuids, remaining_segments)
-    if len(remaining_segments) == 0:
+    card_fulfillment, remaining_card_uuids, remaining_segment_records = match_empty(state_kernel, card_fulfillment, remaining_card_uuids, remaining_segment_records)
+    if len(remaining_segment_records) == 0:
         return card_fulfillment, piece_fulfillment
 
     # print("get_path_fulfillment_from_resources (None, None) because remaining_segments is not empty: ", remaining_segments)
@@ -4548,6 +4702,52 @@ def isterminal(s):
 
 @dispatch(State)
 def getpublicstate(s):
+    k = s.kernel
+    edges = []
+    for edge_record in s.kernel.uuid2edgerecord.values():
+        paths = []
+        for path_idx in edge_record.path_idxs:
+            path_record = k.idx2pathrecord[path_idx]
+            segments = []
+            for segment_uuid in path_record.segment_uuids:
+                segment_record = k.uuid2segmentrecord[segment_uuid]
+                pieces = []
+                for piece_uuid in segment_record.piece_uuids:
+                    piece = k.pieceuuid2piece[piece_uuid]
+                    pieces.append(piece)
+                segments.append(
+                    Segment2(
+                        uuid=segment_record.uuid,
+                        unit_uuid=segment_record.unit_uuid,
+                        pieces=pieces,
+                    )
+                )
+            paths.append(
+                Path2(
+                    uuid=path_record.uuid,
+                    edge_uuid=path_record.edge_uuid,
+                    segments=segments,
+                    idx=path_record.idx
+                )
+            )
+        
+        edge = BiEdge(
+            uuid=edge_record.uuid,
+            start_point_uuid=edge_record.start_point_uuid,
+            end_point_uuid=edge_record.end_point_uuid,
+            node_1_uuid=edge_record.node_1_uuid,
+            node_2_uuid=edge_record.node_2_uuid,
+            node_1_idx=edge_record.node_1_idx,
+            node_2_idx=edge_record.node_2_idx,
+            paths=paths,
+            score=edge_record.score,
+        )
+        edges.append(edge)
+
+        # stopped here
+
+
+
     return PublicState(
         deadlines=get_deadlines(s),
         game_started_at=s.kernel.game_config.started_at,
@@ -4562,7 +4762,7 @@ def getpublicstate(s):
         player_graphs=s.kernel.player_graphs_3,
         goals=s.kernel.goals,
         nodes=s.kernel.nodes,
-        edges=s.kernel.edges,
+        edges=edges,
         regions=s.kernel.regions,
         decks=[getpublicdeck(s, deck) for deck in s.kernel.decks],
         piles=s.kernel.piles,

{graph_games_proto-0.3.2049.dist-info → graph_games_proto-0.3.2077.dist-info}/METADATA

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

{graph_games_proto-0.3.2049.dist-info → graph_games_proto-0.3.2077.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=XmmV1LeHVFb124gHfvHwivUnO8B231kEfpFYPZ746zY,193928
+graph_games_proto/fns.py,sha256=vKVTt-EYziaIHajv8gxt5FMGTvQXW1eWh851DyxDyyY,201209
 graph_games_proto/main.py,sha256=fj2U7KcwrpZtuUhjOX5yVxY18LZvvsxDFYZ_S5mxe04,145
 graph_games_proto/state.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graph_games_proto-0.3.2049.dist-info/METADATA,sha256=Hs1pmJOZluWebeiniLQ1oUCQFlU4M43oPIO-oeHiukM,188
-graph_games_proto-0.3.2049.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-graph_games_proto-0.3.2049.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
-graph_games_proto-0.3.2049.dist-info/RECORD,,
+graph_games_proto-0.3.2077.dist-info/METADATA,sha256=o6EAHn38ZoToH0VTgQsZhG0xMVK6Zh3tFN7rbL20Y8o,188
+graph_games_proto-0.3.2077.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+graph_games_proto-0.3.2077.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
+graph_games_proto-0.3.2077.dist-info/RECORD,,