graph-games-proto 0.3.1752__py3-none-any.whl → 0.3.1756__py3-none-any.whl

graph_games_proto/fns.py

@@ -2005,11 +2005,13 @@ class Segment2(PClass):
 class Path2(PClass):
     uuid = field(type=str)
     idx = field(type=int)
+    edge_uuid = field(type=str)
     segments = field(type=list)  # List[Segment]
     def __todict__(self):
         return {
             "uuid": self.uuid,
             "idx": self.idx,
+            "edge_uuid": self.edge_uuid,
             "segments": [segment.__todict__() for segment in self.segments],
         }
     @staticmethod
@@ -2017,6 +2019,7 @@ class Path2(PClass):
         return Path2(
             uuid=d["uuid"],
             idx=d["idx"],
+            edge_uuid=d["edge_uuid"],
             segments=[Segment2.__fromdict__(segment) for segment in d["segments"]],
         )
 
@@ -2358,21 +2361,43 @@ class PublicPlayerScore(PClass):
             items=[ScoreItem2.__fromdict__(x) for x in d["items"]],
             total=d["total"]
         )
+    
+
+class ScoreItemOwnsPath(PClass):
+    path_idx = field(type=int)
+    edge_uuid = field(type=str)
+    length = field(type=int)
+    def __todict__(self):
+        return {
+            "path_idx": self.path_idx,
+            "edge_uuid": self.edge_uuid,
+            "length": self.length,
+        }
+    @staticmethod
+    def __fromdict__(d):
+        return ScoreItemOwnsPath(
+            path_idx=d["path_idx"],
+            edge_uuid=d["edge_uuid"],
+            length=d["length"],
+        )
 
 
 class ScoreItem2(PClass):
     amount = field(type=int)
     description = field(type=(str, type(None)), initial=None)
+    owns_path = field(type=(ScoreItemOwnsPath, type(None)), initial=None)  # Optional[ScoreItemOwnsPath]
     def __todict__(self):
         return {
             "amount": self.amount,
             "description": self.description,
+            "owns_path": self.owns_path.__todict__() if self.owns_path else None,
         }
     @staticmethod
     def __fromdict__(d):
         return ScoreItem2(
             amount=d["amount"],
-            description=d.get("description")  # Handle None case
+            description=d.get("description"),  # Handle None case
+            owns_path=ScoreItemOwnsPath.__fromdict__(d["owns_path"]) if d.get("owns_path") else None
         )
 
 
@@ -2532,7 +2557,6 @@ class PublicState(PClass):
     decks = field(type=list)  # List[PublicDeck]
     piles = field(type=list)  # List[Pile]
     player_idxs = field(type=list)  # List[int]
-    game_idx = field(type=int)
     initial_to_play = field(type=list)  # List[int]
     to_play = field(type=list)  # List[int]
     unit_discards = field(type=list)  # List[int]
@@ -2605,7 +2629,6 @@ class PublicState(PClass):
             decks=[PublicDeck.__fromdict__(deck) for deck in d["decks"]],
             piles=[Pile.__fromdict__(x) for x in d["piles"]],
             player_idxs=d["player_idxs"],
-            game_idx=d["game_idx"],
             initial_to_play=d["initial_to_play"],
             to_play=d["to_play"],
             unit_discards=d["unit_discards"],
@@ -2694,7 +2717,12 @@ def get_edges(rng, board_config, nodeuuid2idx):
             segments = [
                 Segment2(uuid=s.uuid, unit_uuid=s.unit_uuid, pieces=[]) for s in matching_board_path.path.segments
             ]
-            path = Path2(uuid=str(generate_uuid_with_rng(rng)), idx=path_idx, segments=segments)
+            path = Path2(
+                uuid=str(generate_uuid_with_rng(rng)), 
+                idx=path_idx, 
+                edge_uuid=link.uuid,
+                segments=segments,
+            )
             paths.append(path)
         
         if len(paths) == 0:
@@ -2979,7 +3007,15 @@ def score_public_items(game, player_idx):
                     first_piece = game.pieceuuid2piece[first_segment.pieces[0]]
                     if first_piece.player_idx == player_idx:
                         items.append(
-                            ScoreItem2(amount=edge.score, description="Player {} owns edge {}".format(player_idx, edge.uuid))
+                            ScoreItem2(
+                                amount=edge.score,
+                                owns_path=ScoreItemOwnsPath(
+                                    path_idx=path.idx, 
+                                    edge_uuid=edge.uuid,
+                                    length=len(path.segments),
+                                ),
+                                description="Player {} owns edge {}".format(player_idx, edge.uuid),
+                            )
                         )
     for bonus_status in game.bonus_statuses:
         bonus_idx = game.bonusuuid2bonusidx.get(bonus_status.bonus_uuid)
@@ -2987,7 +3023,10 @@ def score_public_items(game, player_idx):
         if bonus:
             if player_idx in bonus_status.winners:
                 items.append(
-                    ScoreItem2(amount=bonus.score, description="Player {} wins bonus {}".format(player_idx, bonus.code))
+                    ScoreItem2(
+                        amount=bonus.score, 
+                        description="Player {} wins bonus {}".format(player_idx, bonus.code),
+                    )
                 )
     return items
 
@@ -3911,16 +3950,41 @@ def get_legal_actions_for_paths(game, player_idx):
     return legal_actions
 
 
+def get_player_idxs_on_edge(game, edge):
+    player_idxs = set()
+    if not edge or not edge.paths:
+        return list(player_idxs)
+    
+    for path in edge.paths:
+        for segment in path.segments:
+            if segment.pieces and segment.pieces[0]:
+                piece = game.pieceuuid2piece.get(segment.pieces[0])
+                if piece:
+                    player_idxs.add(piece.player_idx)
+    
+    return list(player_idxs)
+
+
 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:
         return False
     
+    path = game.idx2path[path_idx]
+    edge_idx = game.edgeuuid2idx[path.edge_uuid]
+    edge = game.edges[edge_idx]
+
+    player_idxs_on_edge = get_player_idxs_on_edge(game, edge)
+
     # Check if edge is too crowded for the number of players
-    
+    if game.game_config.num_players <= 3:
+        if len(player_idxs_on_edge) > 0:
+            return False
+        
+    if player_idx in player_idxs_on_edge:
+        return False
     
     # Check if any segment of the path has pieces from any player
-    path = game.idx2path[path_idx]
     if path.segments[0].pieces:
         return False
 

{graph_games_proto-0.3.1752.dist-info → graph_games_proto-0.3.1756.dist-info}/METADATA

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

{graph_games_proto-0.3.1752.dist-info → graph_games_proto-0.3.1756.dist-info}/RECORD

@@ -1,9 +1,9 @@
 graph_games_proto/__init__.py,sha256=O5XjRfe3DlxbJn4zezDvvy7cXvL4IzIRPZCL3Y-n7s8,776
 graph_games_proto/all_types.py,sha256=IpbwftEcHS5Ewz-saFNk0lO9FvcbuHG36odRTayCXUk,54911
-graph_games_proto/fns.py,sha256=CEs1hScC6_KPdLxWM13SrcunwYg4SICQPo2blYG7o_o,235957
+graph_games_proto/fns.py,sha256=9eEpZsQCdHcRGNp1K-cfbpztqDEHxAA8pnleeRRAovE,238084
 graph_games_proto/main.py,sha256=fj2U7KcwrpZtuUhjOX5yVxY18LZvvsxDFYZ_S5mxe04,145
 graph_games_proto/state.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graph_games_proto-0.3.1752.dist-info/METADATA,sha256=ponF3VF7XgXC18_uuCgAWnm3jBlXhIA1RVeqDEPJS5Q,188
-graph_games_proto-0.3.1752.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-graph_games_proto-0.3.1752.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
-graph_games_proto-0.3.1752.dist-info/RECORD,,
+graph_games_proto-0.3.1756.dist-info/METADATA,sha256=FyQgp8JTxy5-lL1ictgC3444TV6pe2kWpDSC_FJYthg,188
+graph_games_proto-0.3.1756.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+graph_games_proto-0.3.1756.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
+graph_games_proto-0.3.1756.dist-info/RECORD,,