graph-games-proto 0.3.1864__py3-none-any.whl → 0.3.1866__py3-none-any.whl

graph_games_proto/fns.py

@@ -1009,18 +1009,9 @@ class ActionDrawUnit:
 #     fig::Fig
 #     logged_game_uuid::UUID
 #     to_play::Vector{Int}
-#     num_route_cards::Int
-#     num_route_discards::Int
-#     num_unit_cards::Int
-#     num_unit_discards::Int
-#     faceup_spots::Vector{Union{Nothing,Int}}
-#     player_hands::Vector{PublicPlayerInfo}
-#     captured_segments::Vector{CapturedSegment}
-#     captured_points::Vector{CapturedPoint}
 #     last_to_play::Union{Nothing,Int}
 #     terminal::Bool
 #     winners::Vector{Int}
-#     market_refills::Vector{MarketRefill}
 
 
 class AltAction(PClass):
@@ -2192,12 +2183,8 @@ class State(PClass):
     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]
     last_to_play = field(type=(int, type(None)), initial=None)
     winners = field(type=list)  # List[int]
-    # market_refills::Vector{MarketRefill}
     def __todict__(self):
         return {
             "uuid2edge": {k: v.__todict__() for k, v in self.uuid2edge.items()},
@@ -2233,9 +2220,6 @@ class State(PClass):
             "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),
             "last_to_play": self.last_to_play,
             "winners": self.winners,
         }
@@ -2275,9 +2259,6 @@ class State(PClass):
             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"]),
             last_to_play=d.get("last_to_play"),
             winners=d["winners"],
         )
@@ -2479,70 +2460,6 @@ class ScoreItem(PClass):
         )
 
 
-# Implementing the following GraphQL type:
-# type PublicPlayerInfo {
-# 	final_score: PlayerScore
-# 	longest_trail: [Int]!
-# 	longest_trail_len: Int!
-# 	num_pieces: Int!
-# 	num_route_cards: Int!
-# 	num_unit_cards: Int!
-# 	paths: [Int]!
-# 	route_statuses: [RouteStatus]
-# 	score: Int!
-# }
-class PublicPlayerInfo(PClass):
-    final_score = field(type=(PlayerScore, type(None)), initial=None)  # Union{Nothing, PlayerScore}
-    longest_trail = field(type=list)  # List[int]
-    longest_trail_len = field(type=int)
-    num_pieces = field(type=int)
-    num_route_cards = field(type=int)
-    num_new_route_cards = field(type=int)
-    num_unit_cards = field(type=int)
-    paths = field(type=list)  # List[int]
-    points = field(type=list)  # List[UUID]
-    tokens = field(type=list)  # List[UUID]
-    route_statuses = field(type=list)  # List[RouteStatus]
-    score = field(type=int)
-    num_point_pieces = field(type=int, initial=0)  # Added to match PlayerInfo
-    completed_clusters = field(type=list, initial=[])  # Added to match PlayerInfo
-    def __todict__(self):
-        return {
-            "final_score": self.final_score.__todict__() if self.final_score else None,
-            "longest_trail": self.longest_trail,
-            "longest_trail_len": self.longest_trail_len,
-            "num_pieces": self.num_pieces,
-            "num_route_cards": self.num_route_cards,
-            "num_new_route_cards": self.num_new_route_cards,
-            "num_unit_cards": self.num_unit_cards,
-            "paths": self.paths,
-            "points": self.points,
-            "tokens": self.tokens,
-            "route_statuses": [x.__todict__() for x in self.route_statuses],
-            "score": self.score,
-            "num_point_pieces": self.num_point_pieces,
-            "completed_clusters": self.completed_clusters,
-        }
-    @staticmethod
-    def __fromdict__(d):
-        return PublicPlayerInfo(
-            final_score=PlayerScore.__fromdict__(d["final_score"]) if d.get("final_score") else None,
-            longest_trail=d["longest_trail"],
-            longest_trail_len=d["longest_trail_len"],
-            num_pieces=d["num_pieces"],
-            num_route_cards=d["num_route_cards"],
-            num_new_route_cards=d["num_new_route_cards"],
-            num_unit_cards=d["num_unit_cards"],
-            paths=d["paths"],
-            points=d["points"],
-            tokens=d["tokens"],
-            route_statuses=[RouteStatus.__fromdict__(x) for x in d["route_statuses"]],
-            score=d["score"],
-            num_point_pieces=d.get("num_point_pieces", 0),
-            completed_clusters=d.get("completed_clusters", []),
-        )
-
-
 class AllottedTime(PClass):
     seconds = field(type=int)
     since_action_idx = field(type=int)
@@ -2598,20 +2515,10 @@ class PublicState(PClass):
     piles = field(type=list)  # List[Pile]
     player_idxs = field(type=list)  # List[int]
     initial_to_play = field(type=list)  # List[int]
-    to_play = field(type=list)  # List[int]
-    unit_discards = field(type=list)  # List[int]
-    num_route_cards = field(type=int)
-    num_route_discards = field(type=int)
-    num_unit_cards = field(type=int)
-    num_unit_discards = field(type=int)
-    faceup_spots = field(type=list)  # List[Union{Nothing, int}]
     players = field(type=list)  # List[PublicPlayer]
-    player_hands = field(type=list)  # List[PublicPlayerInfo]
     last_to_play = field(type=(int, type(None)), initial=None)
     winners = field(type=list)
     terminal = field(type=bool)
-    captured_points = field(type=list)  # List[CapturedPoint]
-    captured_segments = field(type=list)  # List[CapturedSegment]
     def __todict__(self):
         return {
             "deadlines": [deadline.__todict__() if deadline else None for deadline in self.deadlines],
@@ -2633,20 +2540,10 @@ class PublicState(PClass):
             "piles": [pile.__todict__() for pile in self.piles],
             "player_idxs": self.player_idxs,
             "initial_to_play": self.initial_to_play,
-            "to_play": self.to_play,
-            "unit_discards": self.unit_discards,
-            "num_route_cards": self.num_route_cards,
-            "num_route_discards": self.num_route_discards,
-            "num_unit_cards": self.num_unit_cards,
-            "num_unit_discards": self.num_unit_discards,
-            "faceup_spots": self.faceup_spots,
             "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,
             "winners": self.winners,
             "terminal": self.terminal,
-            "captured_points": [x.__todict__() for x in self.captured_points],
-            "captured_segments": [x.__todict__() for x in self.captured_segments],
         }
     @staticmethod
     def __fromdict__(d):
@@ -2670,25 +2567,11 @@ class PublicState(PClass):
             piles=[Pile.__fromdict__(x) for x in d["piles"]],
             player_idxs=d["player_idxs"],
             initial_to_play=d["initial_to_play"],
-            to_play=d["to_play"],
-            unit_discards=d["unit_discards"],
-            num_route_cards=d["num_route_cards"],
-            num_route_discards=d["num_route_discards"],
-            num_unit_cards=d["num_unit_cards"],
-            num_unit_discards=d["num_unit_discards"],
-            faceup_spots=d["faceup_spots"],
             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"),
             winners=d["winners"],
             terminal=d["terminal"],
-            captured_points=[CapturedPoint.__fromdict__(x) for x in d["captured_points"]],
-            captured_segments=[CapturedSegment.__fromdict__(x) for x in d["captured_segments"]],
         )
-    # fig::Fig
-    # captured_segments::Vector{CapturedSegment}
-    # captured_points::Vector{CapturedPoint}
-    # market_refills::Vector{MarketRefill}
 
 
 class PlayerState(PClass):
@@ -3001,9 +2884,6 @@ def getinitialstate(game_config):
         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),
         last_to_play=None,
         winners=[],
         terminal=False,
@@ -3024,9 +2904,12 @@ def run_state_hooks(state, hooks, log=False):
 def run_accept_action_hooks(state, action, hooks, log=False):
     # Just like "run_state_action_hooks", but returns immediately returns True if any hook returns True, otherwise returns False
     for hook in hooks:
-        if run_state_action_hook(state, action, hook, log):
-            return True
-    return False
+        is_accepted, reason = run_state_action_hook(state, action, hook, log)
+        if is_accepted is not None and is_accepted:
+            return True, reason
+        elif is_accepted is not None and not is_accepted:
+            return False, reason
+    return False, "No hook accepted the action"
 
 
 def run_state_action_hooks(state, action, hooks, log=False):
@@ -3887,19 +3770,19 @@ def append_to_legal_actions(game, legal_action):
 
 
 def default_accept_action(game, action):
-    if not game or not action or not action.legal_action:
-        return False
 
     # Returns true if action.legal_action is found in game.legal_actions_2
     # The comparision is by value, not by reference
     if action.legal_action not in game.legal_actions_2:
-        return False
+        return False, "Action not found in legal actions"
     
     # Check if "action.move_pieces_to_path" is not None
     if action.move_pieces_to_path: 
-        return is_move_pieces_to_path_action_legal(game, action)
+        is_legal = is_move_pieces_to_path_action_legal(game, action)
+        if not is_legal:
+            return False, "Move pieces to path action is not legal"
     
-    return True
+    return True, "Action is legal"
 
 
 def is_move_pieces_to_path_action_legal(game, action):
@@ -4413,8 +4296,9 @@ def isactionlegal2(s, a):
 
 
 def getnextstate2(s, a, log=False):
-    if not isactionlegal2(s, a):
-        raise ValueError(f"Action is not legal: {a}")
+    is_legal, reason = isactionlegal2(s, a)
+    if not is_legal:
+        raise ValueError(f"Action is not legal: {a}. Reason: {reason}")
     s = run_state_action_hooks(s, a, AFTER_ACCEPT_ACTION_HOOKS, log)
     s = run_state_action_hooks(s, a, HANDLE_ACTION_HOOKS, log)
     s = run_state_hooks(s, HANDLE_SCORING_HOOKS, log)
@@ -4586,20 +4470,10 @@ def getpublicstate(s):
         piles=s.piles,
         player_idxs=s.player_idxs,
         initial_to_play=s.initial_to_play,
-        to_play=gettoplay(s),
-        unit_discards=list(s.unit_discards),
-        num_route_cards=len(s.route_cards),
-        num_route_discards=len(s.route_discards),
-        num_unit_cards=len(s.unit_cards),
-        num_unit_discards=len(s.unit_discards),
-        faceup_spots=list(s.faceup_spots),
         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,
         winners=s.winners,
         terminal=s.terminal,
-        captured_points=getcapturedpoints(s),
-        captured_segments=getcapturedsegments(s),
     )
 
 
@@ -4631,31 +4505,6 @@ def getpublicplayer(s, p):
     )
 
 
-@dispatch(State, PlayerInfo)
-def getpublicplayerinfo(s, p):
-    # if s.terminal
-    #     route_statuses = getroutestatuses(p)
-    # else
-    #     route_statuses = []
-    # end
-    return PublicPlayerInfo(
-        final_score=p.final_score,
-        longest_trail=p.longest_trail,
-        longest_trail_len=p.longest_trail_len,
-        num_pieces=p.num_pieces,
-        num_route_cards=len(p.route_cards),
-        num_new_route_cards=len(p.new_route_cards),
-        num_unit_cards=len(p.unit_cards),
-        paths=p.paths,
-        points=p.points,
-        tokens=p.tokens,
-        route_statuses=[], # TODO: implement!
-        score=getpublicscore(s, p.player_idx),
-        num_point_pieces=p.num_point_pieces,
-        completed_clusters=p.completed_clusters,
-    )
-
-
 # Implementing the following Julia function:
 # function getpublicscore(s::State, player_idx::Int)
 #     addends = Int[]
@@ -4974,17 +4823,6 @@ def getrouteoptionsets(s, player_idx, min_required):
 #     min_initial_routes = getsettingvalue(s.fig, :min_initial_routes)
 #     min_chosen_routes = getsettingvalue(s.fig, :min_chosen_routes)
 
-#     # Initial Route Card Discard
-#     if getsettingvalue(s, :action_route_discard) && length(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),
-#             )
-#         ]
-#     end
-
 #     action_specs = ActionSpec[]
 #     if getsettingvalue(s, :action_draw_unit_faceup) && !isempty(getvalidspotnums(s))
 #         push!(
@@ -5994,21 +5832,7 @@ def printaction(a, i):
 #             )
 #         end
 #     end
-
-#     # Longest trail
-#     if !getsettingvalue(s, :disable_longest_path_bonus)
-#         longest_path_score = getsettingvalue(s.fig, :longest_path_score)
-#         if in(player_idx, s.longest_trail_player_idxs)
-#             push!(
-#                 breakdown, 
-#                 ScoreItem(
-#                     code_idx=getscorecodeidx(s.fig, :LONGEST_ROAD),
-#                     amount=longest_path_score,
-#                 )
-#             )
-#         end
-#     end
-    
+#
 #     # Completed routes
 #     if getsettingvalue(s, :route_scoring)
 #         hand = s.player_hands[player_idx]
@@ -6241,74 +6065,6 @@ def getlegalactionspecs(s, player_idxs):
     return legal_actions
 
 
-# Implementing the following Julia function:
-# function getcapturedsegments(s::State)
-#     (; fig) = s
-#     (; board_config) = fig
-#     public_player_hands = PublicPlayerInfo.(s, s.player_hands)
-#     (; board_paths) = board_config
-#     captured_segments = CapturedSegment[]
-#     for (player_num, player_hand) in enumerate(public_player_hands)
-#         for path_num in player_hand.paths
-#             link_path = board_paths[path_num].path
-#             for segment in link_path.segments
-#                 captured_segment = CapturedSegment(
-#                     player_num,
-#                     segment.uuid,
-#                 )
-#                 push!(captured_segments, captured_segment)
-#             end
-#         end
-#     end
-#     captured_segments
-# end
-@dispatch(State)
-def getcapturedsegments(s):
-    public_player_hands = [getpublicplayerinfo(s, p) for p in s.player_hands]
-    board_paths = s.game_config.fig.board_config.board_paths
-    captured_segments = []
-    for player_idx, player_hand in enumerate(public_player_hands):
-        for path_idx in player_hand.paths:
-            link_path = board_paths[path_idx].path
-            for segment in link_path.segments:
-                captured_segment = CapturedSegment(
-                    player_num=(player_idx+1),
-                    segment_uuid=segment.uuid,
-                )
-                captured_segments.append(captured_segment)
-    return captured_segments
-
-
-# Implementing the following Julia function:
-# function getcapturedpoints(s::State)
-#     (; fig) = s
-#     public_player_hands = PublicPlayerInfo.(s, s.player_hands)
-#     captured_points = CapturedPoint[]
-#     for (player_num, player_hand) in enumerate(public_player_hands)
-#         for point_uuid in player_hand.points
-#             captured_point = CapturedPoint(
-#                 player_num,
-#                 point_uuid,
-#             )
-#             push!(captured_points, captured_point)
-#         end
-#     end
-#     captured_points
-# end
-@dispatch(State)
-def getcapturedpoints(s):
-    public_player_hands = [getpublicplayerinfo(s, p) for p in s.player_hands]
-    captured_points = []
-    for player_idx, player_hand in enumerate(public_player_hands):
-        for point_uuid in player_hand.points:
-            captured_point = CapturedPoint(
-                player_num=player_idx+1,
-                point_uuid=point_uuid,
-            )
-            captured_points.append(captured_point)
-    return captured_points
-
-
 def json_serializer(obj):
     if isinstance(obj, set):
         return list(obj)
@@ -6552,9 +6308,9 @@ def get_imagined_state(static_board_config, player_state):
             remove_card_idx(to_mutate, card_idx)
 
     
-    imagined_route_card_idxs = rng.sample(possible_route_card_idxs, public_state.num_route_cards)
+    # imagined_route_card_idxs = rng.sample(possible_route_card_idxs, public_state.num_route_cards)
     remove_card_idxs(possible_route_card_idxs, imagined_route_card_idxs)
-    imagined_route_discard_idxs = rng.sample(possible_route_card_idxs, public_state.num_route_discards)
+    # imagined_route_discard_idxs = rng.sample(possible_route_card_idxs, public_state.num_route_discards)
     remove_card_idxs(possible_route_card_idxs, imagined_route_discard_idxs)
 
     imagined_route_cards = [x+1 for x in imagined_route_card_idxs]
@@ -6566,9 +6322,9 @@ 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)
 
-    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)
+    # 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)
 
 
     imagined_player_hands = []
@@ -6577,10 +6333,10 @@ def get_imagined_state(static_board_config, player_state):
         if player_idx == my_hand.player_idx:
             imagined_player_hands.append(PlayerInfo.clone(my_hand))
         else:
-            imagined_player_unit_card_idxs = rng.sample(possible_unit_card_idxs, public_player_info.num_unit_cards)
+            # imagined_player_unit_card_idxs = rng.sample(possible_unit_card_idxs, public_player_info.num_unit_cards)
             imagined_player_unit_cards = [x+1 for x in imagined_player_unit_card_idxs]
             remove_card_idxs(possible_unit_card_idxs, imagined_player_unit_card_idxs)
-            imagined_player_route_card_idxs = rng.sample(possible_route_card_idxs, public_player_info.num_route_cards)
+            # imagined_player_route_card_idxs = rng.sample(possible_route_card_idxs, public_player_info.num_route_cards)
             remove_card_idxs(possible_route_card_idxs, imagined_player_route_card_idxs)
             imagined_player_new_route_card_idxs = rng.sample(possible_route_card_idxs, public_player_info.num_new_route_cards)
             remove_card_idxs(possible_route_card_idxs, imagined_player_new_route_card_idxs)

{graph_games_proto-0.3.1864.dist-info → graph_games_proto-0.3.1866.dist-info}/METADATA

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

{graph_games_proto-0.3.1864.dist-info → graph_games_proto-0.3.1866.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=PosUF9Gr77oZzIaEpfhJteapz6te67HhrbwXWhxgo20,242399
+graph_games_proto/fns.py,sha256=5BJ0dY9mk4e0hoMBdyJyxsEvPvy8bFgP4vtdCtrnoKY,232658
 graph_games_proto/main.py,sha256=fj2U7KcwrpZtuUhjOX5yVxY18LZvvsxDFYZ_S5mxe04,145
 graph_games_proto/state.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graph_games_proto-0.3.1864.dist-info/METADATA,sha256=2-OMsPvMLX071_QjZDvVDm8yKWj7NlSwB_Agv14gPtY,188
-graph_games_proto-0.3.1864.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-graph_games_proto-0.3.1864.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
-graph_games_proto-0.3.1864.dist-info/RECORD,,
+graph_games_proto-0.3.1866.dist-info/METADATA,sha256=NyOtxe3kFzamm50WU8vuNk9VdjbnbuoQkgWnZNAZPm8,188
+graph_games_proto-0.3.1866.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+graph_games_proto-0.3.1866.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
+graph_games_proto-0.3.1866.dist-info/RECORD,,