graph-games-proto 0.3.1748__py3-none-any.whl → 0.3.1755__py3-none-any.whl

graph_games_proto/__init__.py

@@ -1,3 +1,3 @@
 # __init__.py
 from .main import hello
-from .fns import get_deadlines, get_longest_path_length, get_max_allotted_times, get_legal_actions_for_path, find_player_with_longest_path, calc_player_graph, get_edges, FrozenDek, QValueLearningPolicy, Action2, getnextstate2, isactionlegal2, LegalAction, AltAction, Fig, RandoPolicy, StaticBoardConfig, autoplay, getpublicstate, generate_cards, PublicState, State, PlayerInfo, Action, Fig, get_imagined_state, getprivatescore, get_qvalue_trajectories, getnextaction, PlayerState, initfig, getavailablepathstatuses, initboardconfig, gettoplay, getlegalactionspecsforplayer, getstateidx, getpathstatus, printstate, getinitialstate, Card, PrivateState, getprivatestate, printaction, json_serializer, getrng, FrozenBoardConfig, initgameconfig, GameConfig
+from .fns import get_deadlines, get_longest_path_length, get_max_allotted_times, get_legal_actions_for_path, find_player_with_longest_path, calc_player_graph, get_edges, FrozenDek, QValueLearningPolicy, Action2, getnextstate2, isactionlegal2, LegalAction, AltAction, Fig, RandoPolicy, StaticBoardConfig, autoplay, getpublicstate, generate_cards, PublicState, State, PlayerInfo, Action, Fig, get_imagined_state, getprivatescore, get_qvalue_trajectories, getnextaction, PlayerState, initfig, getavailablepathstatuses, initboardconfig, gettoplay, getlegalactionspecsforplayer, getpathstatus, printstate, getinitialstate, Card, PrivateState, getprivatestate, printaction, json_serializer, getrng, FrozenBoardConfig, initgameconfig, GameConfig

graph_games_proto/fns.py

@@ -1008,7 +1008,6 @@ class ActionDrawUnit:
 # struct PublicState
 #     fig::Fig
 #     logged_game_uuid::UUID
-#     action_history::Vector{Action}
 #     to_play::Vector{Int}
 #     num_route_cards::Int
 #     num_route_discards::Int
@@ -1020,8 +1019,6 @@ class ActionDrawUnit:
 #     captured_points::Vector{CapturedPoint}
 #     last_to_play::Union{Nothing,Int}
 #     terminal::Bool
-#     longest_trail_player_idxs::Vector{Int}
-#     most_clusters_player_idxs::Vector{Int}
 #     winners::Vector{Int}
 #     market_refills::Vector{MarketRefill}
 
@@ -2008,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
@@ -2020,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"]],
         )
 
@@ -2184,15 +2184,12 @@ class State(PClass):
     rng = field(type=random.Random)
     terminal = field(type=bool)
     initial_to_play = field(type=list)  # List[int]
-    action_history = field(type=list)  # List[Action]
     route_cards = field(type=PVector)  # List[int]
     route_discards = field(type=PVector)  # List[int]
     player_hands = field(type=PVector)  # List[PlayerInfo]
     unit_cards = field(type=PVector)  # List[int]
     faceup_spots = field(type=PVector)  # List[Union{Nothing, int}]
     unit_discards = field(type=PVector)  # List[int]
-    most_clusters_player_idxs = field(type=list)  # List[int]
-    longest_trail_player_idxs = field(type=list)  # List[int]
     last_to_play = field(type=(int, type(None)), initial=None)
     winners = field(type=list)  # List[int]
     # market_refills::Vector{MarketRefill}
@@ -2228,15 +2225,12 @@ class State(PClass):
             "rng": rng2json(self.rng),
             "terminal": self.terminal,
             "initial_to_play": self.initial_to_play,
-            "action_history": [x.__todict__() for x in self.action_history],
             "route_cards": list(self.route_cards),
             "route_discards": list(self.route_discards),
             "player_hands": [x.__todict__() for x in self.player_hands],
             "unit_cards": list(self.unit_cards),
             "faceup_spots": list(self.faceup_spots),
             "unit_discards": list(self.unit_discards),
-            "most_clusters_player_idxs": self.most_clusters_player_idxs,
-            "longest_trail_player_idxs": self.longest_trail_player_idxs,
             "last_to_play": self.last_to_play,
             "winners": self.winners,
         }
@@ -2273,15 +2267,12 @@ class State(PClass):
             rng=json2rng(d["rng"]),
             terminal=d["terminal"],
             initial_to_play=d["initial_to_play"],
-            action_history=[AltAction.__fromdict__(a) for a in d["action_history"]],
             route_cards=pvector(d["route_cards"]),
             route_discards=pvector(d["route_discards"]),
             player_hands=pvector([PlayerInfo.__fromdict__(h) for h in d["player_hands"]]),
             unit_cards=pvector(d["unit_cards"]),
             faceup_spots=pvector(d["faceup_spots"]),
             unit_discards=pvector(d["unit_discards"]),
-            most_clusters_player_idxs=d["most_clusters_player_idxs"],
-            longest_trail_player_idxs=d["longest_trail_player_idxs"],
             last_to_play=d.get("last_to_play"),
             winners=d["winners"],
         )
@@ -2544,9 +2535,7 @@ 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]
-    action_history = field(type=list) # List[AltAction]
     to_play = field(type=list)  # List[int]
     unit_discards = field(type=list)  # List[int]
     num_route_cards = field(type=int)
@@ -2554,11 +2543,9 @@ class PublicState(PClass):
     num_unit_cards = field(type=int)
     num_unit_discards = field(type=int)
     faceup_spots = field(type=list)  # List[Union{Nothing, int}]
-    most_clusters_player_idxs = field(type=list)
     players = field(type=list)  # List[PublicPlayer]
     player_hands = field(type=list)  # List[PublicPlayerInfo]
     last_to_play = field(type=(int, type(None)), initial=None)
-    longest_trail_player_idxs = field(type=list)
     winners = field(type=list)
     terminal = field(type=bool)
     captured_points = field(type=list)  # List[CapturedPoint]
@@ -2583,9 +2570,7 @@ class PublicState(PClass):
             "decks": [deck.__todict__() for deck in self.decks],
             "piles": [pile.__todict__() for pile in self.piles],
             "player_idxs": self.player_idxs,
-            "game_idx": self.game_idx,
             "initial_to_play": self.initial_to_play,
-            "action_history": [x.__todict__() for x in self.action_history],
             "to_play": self.to_play,
             "unit_discards": self.unit_discards,
             "num_route_cards": self.num_route_cards,
@@ -2593,11 +2578,9 @@ class PublicState(PClass):
             "num_unit_cards": self.num_unit_cards,
             "num_unit_discards": self.num_unit_discards,
             "faceup_spots": self.faceup_spots,
-            "most_clusters_player_idxs": self.most_clusters_player_idxs,
             "players": [x.__todict__() for x in self.players],
             "player_hands": [x.__todict__() for x in self.player_hands],
             "last_to_play": self.last_to_play,
-            "longest_trail_player_idxs": self.longest_trail_player_idxs,
             "winners": self.winners,
             "terminal": self.terminal,
             "captured_points": [x.__todict__() for x in self.captured_points],
@@ -2624,9 +2607,7 @@ 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"],
-            action_history=[AltAction.__fromdict__(x) for x in d["action_history"]],
             to_play=d["to_play"],
             unit_discards=d["unit_discards"],
             num_route_cards=d["num_route_cards"],
@@ -2634,11 +2615,9 @@ class PublicState(PClass):
             num_unit_cards=d["num_unit_cards"],
             num_unit_discards=d["num_unit_discards"],
             faceup_spots=d["faceup_spots"],
-            most_clusters_player_idxs=d["most_clusters_player_idxs"],
             players=[PublicPlayer.__fromdict__(x) for x in d["players"]],
             player_hands=[PublicPlayerInfo.__fromdict__(x) for x in d["player_hands"]],
             last_to_play=d.get("last_to_play"),
-            longest_trail_player_idxs=d["longest_trail_player_idxs"],
             winners=d["winners"],
             terminal=d["terminal"],
             captured_points=[CapturedPoint.__fromdict__(x) for x in d["captured_points"]],
@@ -2676,8 +2655,6 @@ def autoplay(seed, fig, num_players, policy, log=False):
             if log:
                 printstate(s)
             a = getnextaction(s, policy)
-            if log:
-                printaction(a, getstateidx(s))
             s = getnextstate2(s, a)
             actions.append(a)
         
@@ -2718,7 +2695,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:
@@ -2954,15 +2936,12 @@ def getinitialstate(game_config):
         game_config=game_config,
         initial_to_play=initial_to_play,
         rng=rng,
-        action_history=[],
         route_cards=pvector(route_cards),
         route_discards=pvector([]),
         player_hands=pvector(player_hands),
         unit_cards=pvector(unit_cards),
         unit_discards=pvector([]),
         faceup_spots=pvector(faceup_spots),
-        most_clusters_player_idxs=[],
-        longest_trail_player_idxs=[],
         last_to_play=None,
         winners=[],
         terminal=False,
@@ -3938,16 +3917,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
 
@@ -4438,9 +4442,7 @@ def getpublicstate(s):
         decks=[getpublicdeck(s, deck) for deck in s.decks],
         piles=s.piles,
         player_idxs=s.player_idxs,
-        game_idx=len(s.action_history),
         initial_to_play=s.initial_to_play,
-        action_history=s.action_history,
         to_play=gettoplay(s),
         unit_discards=list(s.unit_discards),
         num_route_cards=len(s.route_cards),
@@ -4448,11 +4450,9 @@ def getpublicstate(s):
         num_unit_cards=len(s.unit_cards),
         num_unit_discards=len(s.unit_discards),
         faceup_spots=list(s.faceup_spots),
-        most_clusters_player_idxs=s.most_clusters_player_idxs,
         players=[getpublicplayer(s, p) for p in s.players],
         player_hands=[getpublicplayerinfo(s, p) for p in s.player_hands],
         last_to_play=s.last_to_play,
-        longest_trail_player_idxs=s.longest_trail_player_idxs,
         winners=s.winners,
         terminal=s.terminal,
         captured_points=getcapturedpoints(s),
@@ -4582,14 +4582,6 @@ def getplayerpathidxs(s, player_idx):
     return s.player_hands[player_idx].paths
 
 
-# Implementing the following Julia function:
-# getlastaction(s::State) = isempty(s.actions) ? nothing : s.actions[end]
-def getlastaction(s):
-    if not s.action_history:
-        return None
-    return s.action_history[-1]
-
-
 # Function implements the following Julia function:
 # function getlastactionkey(s)
 #     last_action = getlastaction(s)
@@ -4600,10 +4592,7 @@ def getlastaction(s):
 # end
 @dispatch(State)
 def getlastactiontype(s):
-    last_action = getlastaction(s)
-    if last_action is None:
-        return NoAction()
-    return getactiontype(last_action.action_name)
+    pass
 
 
 def getactiontype(action_name):
@@ -4625,10 +4614,7 @@ def getactiontype(action_name):
 # Function implements the following Julia function:
 # getlastplayeridxplus1(s) = mod1(getlastaction(s).player_idx + 1, s.game_config.num_players)
 def getlastplayeridxplus1(s):
-    last_action = getlastaction(s)
-    if last_action is None:
-        return 0
-    return (last_action.player_idx + 1) % s.game_config.num_players
+    pass
 
 
 @dispatch(State)
@@ -4777,10 +4763,7 @@ def getlegalactionspecs(s, player_idx):
 #     Val(player_idx == last_action.player_idx)
 # end
 def getrepeatplayerbooltype(s, player_idx):
-    last_action = getlastaction(s)
-    if last_action is None:
-        return getbooltype(False)
-    return getbooltype(player_idx == last_action.player_idx)
+    pass
 
 
 def combinations(a, n=None):
@@ -4891,22 +4874,8 @@ def getrouteoptionsets(s, player_idx, min_required):
 # end
 @dispatch(State, int, object, object)
 def getlegalactionspecsforplayer(s, player_idx, repeat_player, last_action):
-    min_initial_routes = getsettingvalue(s, 'min_initial_routes')
     min_chosen_routes = getsettingvalue(s, 'min_chosen_routes')
 
-    # Initial Route Card Discard
-    if getsettingvalue(s, 'action_route_discard') and len(s.action_history) < s.game_config.num_players:
-        return [
-            ActionSpec(
-                player_idx=player_idx,
-                action_name="ROUTE_DISCARD",
-                return_route_option_sets = getrouteoptionsets(s, player_idx, min_initial_routes),
-                draw_faceup_spots={},
-                points = [],
-                paths = [],
-            )
-        ]
-
     action_specs = []
     if getsettingvalue(s, 'action_draw_unit_faceup') and s.faceup_spots:
         
@@ -5764,11 +5733,6 @@ def getunavailablepoints(s):
     return unavailable_points
 
 
-def getstateidx(s):
-    return len(s.action_history)
-
-
-
 # Implementing the following Julia function:
 # function calcfinalscores(s::State)
 #     if !s.terminal
@@ -5833,9 +5797,7 @@ def printplayer(s, player_idx):
 
 
 def printstate(s):
-    state_idx = getstateidx(s)
     print(f"*************** State {state_idx} ***************")
-    print(f"Most clusters:   {list(s.most_clusters_player_idxs)}")
     print(f"Last to play:    {s.last_to_play}")
     print(f"Winners:         {list(s.winners)}")
     print(f"Route Deck:      {list(s.route_cards)}")
@@ -5961,24 +5923,6 @@ def getprivatescore(s, hand):
                 amount=path_scores[len],
             ))
 
-    # Bonus: most clusters
-    if getsettingvalue(s, 'most_clusters_bonus'):
-        bonus_most_clusters_score = getsettingvalue(s.game_config.fig, 'bonus_most_clusters_score')
-        if player_idx in s.most_clusters_player_idxs:
-            breakdown.append(ScoreItem(
-                code_idx=getscorecodeidx(s.game_config.fig, 'MOST_CLUSTERS'),
-                amount=bonus_most_clusters_score,
-            ))
-
-    # Longest trail
-    if not getsettingvalue(s, 'disable_longest_path_bonus'):
-        longest_path_score = getsettingvalue(s.game_config.fig, 'longest_path_score')
-        if player_idx in s.longest_trail_player_idxs:
-            breakdown.append(ScoreItem(
-                code_idx=getscorecodeidx(s.game_config.fig, 'LONGEST_ROAD'),
-                amount=longest_path_score,
-            ))
-
     # Completed routes
     if False and getsettingvalue(s, 'route_scoring'):
         routes = s.game_config.fig.board_config.routes
@@ -6479,10 +6423,6 @@ def get_imagined_state(static_board_config, player_state):
     for unit_card in my_hand.unit_cards:
         remove_card_idx(possible_unit_card_idxs, unit_card-1)
 
-    for action in public_state.action_history:
-        if action.action_name == "DRAW_UNIT_DECK":
-            remove_card_idx(possible_unit_card_idxs, action.unit_card_num - 1)
-
     imagined_unit_card_idxs = rng.sample(possible_unit_card_idxs, public_state.num_unit_cards)
     imagined_unit_cards = [x+1 for x in imagined_unit_card_idxs]
     remove_card_idxs(possible_unit_card_idxs, imagined_unit_card_idxs)
@@ -6552,15 +6492,12 @@ def get_imagined_state(static_board_config, player_state):
         rng = rng, # TODO: again figure out this stochasticity
         terminal = public_state.terminal,
         initial_to_play = public_state.initial_to_play,
-        action_history = public_state.action_history,
         route_cards = pvector(imagined_route_cards), # Guess at this.
         route_discards = pvector(imagined_route_discards), # Guess at this.
         player_hands = pvector(imagined_player_hands), # Guess at this.
         unit_cards = pvector(imagined_unit_cards), # Guess at this.
         faceup_spots = pvector(public_state.faceup_spots),
         unit_discards = pvector(public_state.unit_discards),
-        most_clusters_player_idxs = public_state.most_clusters_player_idxs,
-        longest_trail_player_idxs = public_state.longest_trail_player_idxs,
         last_to_play = public_state.last_to_play,
         winners = public_state.winners,
     )

{graph_games_proto-0.3.1748.dist-info → graph_games_proto-0.3.1755.dist-info}/METADATA

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

graph_games_proto-0.3.1755.dist-info/RECORD

@@ -0,0 +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=tXNB_opKY3SYSh0NHlIH77l_xKaTVaVzIDSQrP6G_hg,236864
+graph_games_proto/main.py,sha256=fj2U7KcwrpZtuUhjOX5yVxY18LZvvsxDFYZ_S5mxe04,145
+graph_games_proto/state.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+graph_games_proto-0.3.1755.dist-info/METADATA,sha256=GbwVTuU6vysYcnS_l9_wdaFLS3M0XcfYSx-A97huRiA,188
+graph_games_proto-0.3.1755.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+graph_games_proto-0.3.1755.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
+graph_games_proto-0.3.1755.dist-info/RECORD,,

graph_games_proto-0.3.1748.dist-info/RECORD

@@ -1,9 +0,0 @@
-graph_games_proto/__init__.py,sha256=WhMxLCEu4pgZ9LRltIgPLcYT7hTY6pMayISVcT2HN74,789
-graph_games_proto/all_types.py,sha256=IpbwftEcHS5Ewz-saFNk0lO9FvcbuHG36odRTayCXUk,54911
-graph_games_proto/fns.py,sha256=rgPfMVmsCppJP0me5CFWpbBHi9fG0XGC7fZFZfnAaxA,240267
-graph_games_proto/main.py,sha256=fj2U7KcwrpZtuUhjOX5yVxY18LZvvsxDFYZ_S5mxe04,145
-graph_games_proto/state.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graph_games_proto-0.3.1748.dist-info/METADATA,sha256=OjdLHbApfzG4ZHPWvyrhpJGHnwzR1h8AgH58PCXNSd0,188
-graph_games_proto-0.3.1748.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-graph_games_proto-0.3.1748.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
-graph_games_proto-0.3.1748.dist-info/RECORD,,