graph-games-proto 0.3.1739__py3-none-any.whl → 0.3.1741__py3-none-any.whl

graph_games_proto/fns.py

@@ -2678,7 +2678,7 @@ def autoplay(seed, fig, num_players, policy, log=False):
             a = getnextaction(s, policy)
             if log:
                 printaction(a, getstateidx(s))
-            s = getnextstate(s, a)
+            s = getnextstate2(s, a)
             actions.append(a)
         
         if (log):
@@ -4236,16 +4236,6 @@ def getfaceupspots(f, unit_deck, unit_deck_idx):
     return unit_deck[unit_deck_idx:(unit_deck_idx + num_faceup_spots)] if unit_deck_idx < len(unit_deck) else []
 
 
-@dispatch(GameConfig, list, bool)
-def getstate(game_config, actions, log):
-    return reduce(lambda state, action: getnextstate(state, action, log), actions, getinitialstate(game_config))
-
-
-@dispatch(State, AltAction, NoAction)
-def getnextstate(s, action, action_type):
-    return s
-
-
 # Implementing the following Julia function:
 # getpath(f::Fig, num::Int) = f.board_config.board_paths[num]
 def getpath(f, num):
@@ -4254,484 +4244,15 @@ def getpath(f, num):
     raise ValueError(f"Path number {num} not found in board config.")
 
 
-# Implementing the following Julia function:
-# function getnextstate(s::State, a::Action, ::Val{:CLAIM_PATH})
-#     player_hand_idx = findfirst(p -> p.player_idx == a.player_idx, s.player_hands)
-#     player_hand = s.player_hands[player_hand_idx]
-#     num_path_pieces = getpath(s.fig, a.path_idx).path.segments |> length
-#     @reset player_hand.num_pieces = player_hand.num_pieces - num_path_pieces
-#     new_unit_cards, new_discards = removecombo(player_hand, a.unit_combo)
-#     @reset s.unit_discards = [s.unit_discards..., new_discards...]
-#     @reset player_hand.unit_cards = new_unit_cards
-#     @reset player_hand.paths = [player_hand.paths..., a.path_idx]
-#     @reset player_hand.completed_routes = getcompletedroutes(s.fig, player_hand)
-#     longest_trail, longest_trail_len = getlongesttrail(s.fig, player_hand)
-#     @reset player_hand.longest_trail = longest_trail
-#     @reset player_hand.longest_trail_len = longest_trail_len
-#     @reset s.player_hands = [p.player_idx == a.player_idx ? player_hand : p for p in s.player_hands]
-#     @reset s.longest_trail_player_idxs = getlongesttrailplayeridxs(s.player_hands)
-#     @reset s.most_clusters_player_idxs = getmostclustersplayeridxs(s.player_hands)
-#     s
-# end
-@dispatch(State, AltAction, MovePiecesToPathAction)
-def getnextstate(s, action, action_type):
-    player_hand_idx = next((i for i, p in enumerate(s.player_hands) if p.player_idx == action.player_idx), None)
-    if player_hand_idx is None:
-        raise ValueError(f"Player index {action.player_idx} not found in player hands.")
-    
-    player_hand = s.player_hands[player_hand_idx]
-    num_path_pieces = len(getpath(s.game_config.fig, action.path_idx).path.segments)
-    # @reset player_hand.num_pieces = player_hand.num_pieces - num_path_pieces
-    player_hand = player_hand.set(num_pieces=player_hand.num_pieces - num_path_pieces)
-
-    # new_unit_cards, new_discards = removecombo(player_hand, a.unit_combo)
-    new_unit_cards, new_discards = pvector([]), pvector([])
-    if action.unit_combo:
-        new_unit_cards, new_discards = removecombo(player_hand, action.unit_combo)
-    # @reset s.unit_discards = [s.unit_discards..., new_discards...]
-    s = s.set(unit_discards=s.unit_discards.extend(new_discards))
-    # @reset player_hand.unit_cards = new_unit_cards
-    player_hand = player_hand.set(unit_cards=new_unit_cards)
-    # @reset player_hand.paths = [player_hand.paths..., a.path_idx]
-    player_hand = player_hand.set(paths=player_hand.paths + [action.path_idx])
-    # @reset player_hand.completed_routes = getcompletedroutes(s.fig, player_hand)
-
-    if len(s.game_config.fig.board_config.routes) > 0:
-        player_hand = player_hand.set(completed_routes=getcompletedroutes(s.game_config.fig, player_hand))
-
-    ###longest_trail, longest_trail_len = getlongesttrail(s.game_config.fig, player_hand)
-    # @reset player_hand.longest_trail = longest_trail
-    ###player_hand = player_hand.set(longest_trail=longest_trail)
-    # @reset player_hand.longest_trail_len = longest_trail_len
-    ###player_hand = player_hand.set(longest_trail_len=longest_trail_len)
-    
-    # Implementing the following Julia function:
-    # @reset s.player_hands = [p.player_idx == a.player_idx ? player_hand : p for p in s.player_hands]
-    s = s.transform(
-        ('player_hands', player_hand_idx),
-        player_hand.set(player_idx=player_hand.player_idx),
-    )
-
-    # @reset s.longest_trail_player_idxs = getlongesttrailplayeridxs(s.player_hands)
-    ###s = s.set(longest_trail_player_idxs=getlongesttrailplayeridxs(s.player_hands))
-    # @reset s.most_clusters_player_idxs = getmostclustersplayeridxs(s.player_hands)
-    s = s.set(most_clusters_player_idxs=getmostclustersplayeridxs(s.player_hands))
-    return s
-
-
-def getlinkadjmat(fig, paths):
-    path2edgeidx = {}
-    edgeidx2edge = {}
-    for frozen_path in fig.board_config.board_paths:
-        edge_num = frozen_path.link_num
-        path_num = frozen_path.num
-        path2edgeidx[path_num - 1] = edge_num - 1
-        edgeidx2edge[edge_num - 1] = (frozen_path.start_point_num-1, frozen_path.end_point_num-1)
-
-    num_nodes = len(fig.board_config.points)
-    adj_mat = np.eye(num_nodes, dtype=int)
-
-    # print("path2edgeidx: ", path2edgeidx)
-    # print("\nedgeidx2edge: ", edgeidx2edge)
-
-    for path_idx in paths:
-        edge_idx = path2edgeidx[path_idx]
-        src, dst = edgeidx2edge[edge_idx]
-        adj_mat[src, dst] = 1
-        adj_mat[dst, src] = 1
-
-    return adj_mat
-
-
-def getcompletedroutes(fig, player_hand, log=False):
-    adj_mat = getlinkadjmat(fig, player_hand.paths)
-
-    if False:
-        print("\nadj_mat:")
-        print(adj_mat)
-
-    route_nums = player_hand.route_cards
-    routes = fig.board_config.routes
-    num_points = len(fig.board_config.points)
-
-    # print("route_nums: ", route_nums)
-
-    visited_nodes = np.column_stack([
-        np.eye(1, num_points, routes[route_num - 1].start_num, dtype=int).flatten()
-        for route_num in route_nums
-    ])
-
-    target_nodes = np.column_stack([
-        np.eye(1, num_points, routes[route_num - 1].end_num, dtype=int).flatten()
-        for route_num in route_nums
-    ])
-
-    if False:
-        print("\nvisited_nodes:")
-        print(visited_nodes)
-        print("\ntarget_nodes:")
-        print(target_nodes)
-
-    for _ in range(len(player_hand.paths)):
-        visited_nodes = (adj_mat @ visited_nodes) > 0
-
-    res = visited_nodes & target_nodes
-
-    if log:
-        print("\nres:")
-        print(res)
-
-    bools = np.any(res, axis=0)
-    completed = [route_num for route_num, completed_bool in zip(route_nums, bools) if completed_bool]
-
-    return completed
-
-
-
-# Implementing the following Julia function:
-# function getnextstate(s::State, a::Action, ::Val{:CLAIM_POINT})
-#     player_hand_idx = findfirst(p -> p.player_idx == a.player_idx, s.player_hands)
-#     player_hand = s.player_hands[player_hand_idx]
-#     @reset player_hand.num_point_pieces = player_hand.num_point_pieces - 1
-#     new_unit_cards, new_discards = removecombo(player_hand, a.unit_combo)
-#     @reset s.unit_discards = [s.unit_discards..., new_discards...]
-#     @reset player_hand.unit_cards = new_unit_cards
-#     @reset player_hand.points = [player_hand.points..., a.point_uuid]
-#     @reset player_hand.completed_clusters = getcompletedclusters(s.fig, player_hand)
-#     @reset s.player_hands = [p.player_idx == a.player_idx ? player_hand : p for p in s.player_hands]
-#     @reset s.most_clusters_player_idxs = getmostclustersplayeridxs(s.player_hands)
-#     s
-# end
-@dispatch(State, AltAction, ClaimPointAction)
-def getnextstate(s, action, action_type):
-    player_hand_idx = next((i for i, p in enumerate(s.player_hands) if p.player_idx == action.player_idx), None)
-    if player_hand_idx is None:
-        raise ValueError(f"Player index {action.player_idx} not found in player hands.")
-    
-    player_hand = s.player_hands[player_hand_idx]
-    # @reset player_hand.num_point_pieces = player_hand.num_point_pieces - 1
-    player_hand = player_hand.set(num_point_pieces=player_hand.num_point_pieces - 1)
-
-    # new_unit_cards, new_discards = removecombo(player_hand, a.unit_combo)
-    new_unit_cards, new_discards = pvector([]), pvector([])
-    if action.unit_combo:
-        new_unit_cards, new_discards = removecombo(player_hand, action.unit_combo)
-    # @reset s.unit_discards = [s.unit_discards..., new_discards...]
-    s = s.set(unit_discards=s.unit_discards.extend(new_discards))
-    # @reset player_hand.unit_cards = new_unit_cards
-    player_hand = player_hand.set(unit_cards=new_unit_cards)
-    # @reset player_hand.points = [player_hand.points..., a.point_uuid]
-    player_hand = player_hand.set(points=player_hand.points + [action.point_uuid])
-    # @reset player_hand.completed_clusters = getcompletedclusters(s.fig, player_hand)
-    player_hand = player_hand.set(completed_clusters=getcompletedclusters(s.game_config.fig, player_hand))
-    # @reset s.player_hands = [p.player_idx == a.player_idx ? player_hand : p for p in s.player_hands]
-    s = s.transform(
-        ('player_hands', player_hand_idx),
-        player_hand.set(player_idx=player_hand.player_idx),
-    )
-    # @reset s.most_clusters_player_idxs = getmostclustersplayeridxs(s.player_hands)
-    s = s.set(most_clusters_player_idxs=getmostclustersplayeridxs(s.player_hands))
-    
-    return s
-
-
-# Implementing the following Julia function:
-# function getmostclustersplayeridxs(player_hands::Vector{PlayerInfo})
-#     most_clusters = maximum([length(p.completed_clusters) for p in player_hands])
-#     if iszero(most_clusters)
-#         return Int[]
-#     end
-#     [p.player_idx for p in player_hands if length(p.completed_clusters) == most_clusters]
-# end
-def getmostclustersplayeridxs(player_hands):
-    most_clusters = max(len(p.completed_clusters) for p in player_hands)
-    if most_clusters == 0:
-        return []
-    return [p.player_idx for p in player_hands if len(p.completed_clusters) == most_clusters]
-
-
-# Implementing the following Julia function:
-# function getcompletedclusters(fig::Fig, player_hand::PlayerInfo; log=false)
-#     (; clusters) = fig.board_config
-#     completed = filter(clusters) do cluster
-#         for point in cluster.points
-#             if !in(point, player_hand.points)
-#                 return false
-#             end
-#         end
-#         true
-#     end
-#     if isempty(completed)
-#         return UUID[]
-#     end
-#     [x.uuid for x in completed]
-# end
-def getcompletedclusters(fig, player_hand, log=False):
-    clusters = fig.board_config.clusters
-    completed = [
-        cluster
-        for cluster in clusters
-        if all(point in player_hand.points for point in cluster.points)
-    ]
-    if not completed:
-        return []
-    return [x.uuid for x in completed]
-
-# Implementing the following Julia function:
-# function removecombo(player_hand::PlayerInfo, combo::String)
-#     (; unit_cards) = player_hand
-#     unit_cards_to_remove = parse.(Int, split(combo, "-"))
-#     new_unit_cards = filter(x->!in(x, unit_cards_to_remove), unit_cards)
-#     new_discards = unit_cards_to_remove
-#     new_unit_cards, new_discards
-# end
-def removecombo(player_hand, combo):
-    if not combo:
-        return player_hand.unit_cards, []
-    unit_cards_to_remove = list(map(int, combo.split("-")))
-    new_unit_cards = pvector([x for x in player_hand.unit_cards if x not in unit_cards_to_remove])
-    new_discards = pvector([x for x in unit_cards_to_remove if x in player_hand.unit_cards])
-    if len(new_discards) != len(unit_cards_to_remove):
-        raise ValueError(f"Discarded cards {new_discards} do not match combo {combo} (from {player_hand.unit_cards})")
-    return new_unit_cards, new_discards
-
-
-@dispatch(State, AltAction, DrawUnitFaceupAction)
-def getnextstate(s, action, action_type):
-    pass
-# Implementing the following Julia function:
-# function getnextstate(s::State, a::Action, ::Val{:DRAW_UNIT_FACEUP})
-#     player_hand_idx = findfirst(p -> p.player_idx == a.player_idx, s.player_hands)
-#     player_hand = s.player_hands[player_hand_idx]
-#     player_new_unit_idx = s.faceup_spots[a.draw_faceup_spot_num]
-
-#     if isempty(s.unit_cards)
-#         # TODO: do we need to reshuffle the unit discards?
-#         @reset s.faceup_spots[a.draw_faceup_spot_num] = nothing
-#     else
-#         @reset s.faceup_spots[a.draw_faceup_spot_num] = s.unit_cards[end]
-#         @reset s.unit_cards = s.unit_cards[1:end-1]
-#     end
-
-#     s = recycleunitdiscardsifneeded(s)
-#     @reset s.player_hands[player_hand_idx].unit_cards = [player_hand.unit_cards..., player_new_unit_idx]
-#     num_market_refills = 0
-
-#     num_faceup_spots = getsettingvalue(s.fig, :num_faceup_spots)
-
-#     s
-# end
-    player_hand_idx = next((i for i, p in enumerate(s.player_hands) if p.player_idx == action.player_idx), None)
-    if player_hand_idx is None:
-        raise ValueError(f"Player index {action.player_idx} not found in player hands.")
-    player_hand = s.player_hands[player_hand_idx]
-    player_new_unit_idx = s.faceup_spots[action.draw_faceup_spot_num-1]
-
-    if not s.unit_cards:
-        # TODO: do we need to reshuffle the unit discards?
-        # @reset s.faceup_spots[a.draw_faceup_spot_num] = nothing
-        s = s.set(
-            faceup_spots = s.faceup_spots.set(action.draw_faceup_spot_num-1, None)
-        )
-    else:
-        # Implementing the following Julia code:
-        # @reset s.faceup_spots[a.draw_faceup_spot_num] = s.unit_cards[end]
-        # @reset s.unit_cards = s.unit_cards[1:end-1]
-        s = s.set(
-            faceup_spots = s.faceup_spots.set(action.draw_faceup_spot_num-1, s.unit_cards[-1])
-        )
-        s = s.set(unit_cards = s.unit_cards[:-1])
-    
-    # s = recycleunitdiscardsifneeded(s)
-    unit_cards = player_hand.unit_cards
-    s = s.transform(
-        ('player_hands', player_hand_idx),
-        player_hand.set(unit_cards=unit_cards.append(player_new_unit_idx)),
-    )
-    num_market_refills = 0
-    num_faceup_spots = getsettingvalue(s.game_config.fig, 'num_faceup_spots')
-    return s
-
-
-# Implementing the following Julia function:
-# function getsettingvalue(f::Fig, setting_name::Symbol)
-#     for setting in f.board_config.settings
-#         if Symbol(setting.name) === setting_name
-#             return JSON3.read(setting.value_json)
-#         end
-#     end
-#     nothing
-# end
-@dispatch(Fig, str)
-def getsettingvalue(f, setting_name):
-    for setting in f.board_config.settings:
-        if setting.name == setting_name:
-            return json.loads(setting.value_json)
-    return None
-
-@dispatch(State, str)
-def getsettingvalue(s, setting_name):
-    return getsettingvalue(s.game_config.fig, setting_name)
-
-
-@dispatch(State, AltAction, DrawUnitDeckAction)
-def getnextstate(s, action, action_type):
-# Implementing the following Julia function:
-# function getnextstate(s::State, a::Action, ::Val{:DRAW_UNIT_DECK})
-#     player_hand_idx = findfirst(p -> p.player_idx == a.player_idx, s.player_hands)
-#     player_hand = s.player_hands[player_hand_idx]
-#     @assert anyunitcardsleft(s) "Unit and discard decks are empty. Action illegal!"
-#     s = recycleunitdiscardsifneeded(s)
-#     drawn_card = s.unit_cards[end]
-#     @reset s.unit_cards = s.unit_cards[1:end-1]
-#     @reset s.player_hands[player_hand_idx].unit_cards = [player_hand.unit_cards..., drawn_card]
-#     s = recycleunitdiscardsifneeded(s)
-#     s
-# end
-    player_hand_idx = next((i for i, p in enumerate(s.player_hands) if p.player_idx == action.player_idx), None)
-    if player_hand_idx is None:
-        raise ValueError(f"Player index {action.player_idx} not found in player hands.")
-    
-    ## if not anyunitcardsleft(s):
-    ##     raise ValueError("Unit and discard decks are empty. Action illegal!")
-    ## s = recycleunitdiscardsifneeded(s)
-    drawn_card = s.unit_cards[-1]
-    s = s.set(unit_cards = s.unit_cards[:-1])
-    
-    # @reset s.player_hands[player_hand_idx].unit_cards = [player_hand.unit_cards..., drawn_card]
-    player_hand = s.player_hands[player_hand_idx]
-    unit_cards = player_hand.unit_cards
-    s = s.transform(
-        ('player_hands', player_hand_idx), 
-        player_hand.set(unit_cards=unit_cards.append(drawn_card)),
-    )
-
-    ## s = recycleunitdiscardsifneeded(s)
-    return s
 
 
-@dispatch(State, AltAction)
-def getnextstateold(s, action):
-    action_type = getactiontype(action.action_name)
-    next = getnextstate(s, action, action_type)
-    next = next.set(action_history=(next.action_history + [action]))
-    return next
 
 
-# Implementing the following Julia function:
-# function isactionlegal(s::State, a::Action)
-#     action_specs = getlegalactions(s)
-#     for action_spec in action_specs
-#         if istospec(action_spec, a)
-#             return true
-#         else
-#             # println("Action is not to spec~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", a, action_spec)
-#         end
-#     end
-#     false
-# end
-def isactionlegal(s, a):
-    action_specs = getlegalactionspecs(s)
-    for action_spec in action_specs:
-        if istospec(action_spec, a):
-            return True
-        else:
-            # println("Action is not to spec~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", a, action_spec)
-            pass
-    return False
-
 
 def isactionlegal2(s, a):
     return run_accept_action_hooks(s, a, ACCEPT_ACTION_HOOKS, False)
 
 
-def istospec(action_spec, a):
-    if action_spec.action_name != a.action_name:
-        # print(f"istospec: action_spec.action_name != a.action_name: {action_spec.action_name} != {a.action_name}")
-        return False
-    if action_spec.player_idx != a.player_idx:
-        # print(f"istospec: action_spec.player_idx != a.player_idx: {action_spec.player_idx} != {a.player_idx}")
-        return False
-    # TODO: properly implement
-    return True
-
-
-@dispatch(State, AltAction)
-def getnextstate(s, action):
-    return getnextstate(s, action, False)
-
-
-# Implementing the following Julia function:
-# function getnextstate(s::State, a::Action)
-#     if !isactionlegal(s, a)
-#         println("Action is not legal~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", a)
-#         return nothing
-#     end
-#     next = getnextstate(s, a, Val(Symbol(a.action_name)))
-
-#     if next.last_to_play == a.player_idx
-#         @reset next.terminal = true
-#         next = calcwinners(next)
-#     elseif isnothing(next.last_to_play)
-#         player_hand = next.player_hands[a.player_idx]
-#         if getsettingvalue(s.fig, :terminal_two_or_less_pieces) && player_hand.num_pieces <= 2
-#             @reset next.last_to_play = a.player_idx
-#         elseif getsettingvalue(s.fig, :terminal_first_cluster) && length(player_hand.completed_clusters) > 0
-#             @reset next.last_to_play = a.player_idx
-#             @reset next.terminal = true
-#             next = calcwinners(next)
-#         elseif (
-#             getsettingvalue(s.fig, :terminal_no_available_points) 
-#             && length(getunavailablepoints(next)) == length(next.fig.board_config.points)
-#         )
-#             @reset next.last_to_play = a.player_idx
-#             @reset next.terminal = true
-#             next = calcwinners(next)
-#         end
-#     end
-
-#     @reset next.action_history = [next.action_history..., a]
-#     assertallcardsaccountedfor(next)
-#     next
-# end
-@dispatch(State, AltAction, bool)
-def getnextstate(s, action, log):
-    if log:
-        printstate(s)
-        print("(Potential action)")
-        printaction(action, getstateidx(s))
-
-    if not isactionlegal(s, action):
-        print("Action is not legal~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", action)
-        return None
-    next = getnextstate(s, action, getactiontype(action.action_name))
-
-    if next.last_to_play == action.player_idx:
-        next = next.set(terminal=True)
-        next = calcwinners(next)
-    elif next.last_to_play is None:
-        player_hand = next.player_hands[action.player_idx]
-        terminal_two_or_less_pieces = getsettingvalue(s.game_config.fig, 'terminal_two_or_less_pieces')
-        terminal_first_cluster = getsettingvalue(s.game_config.fig, 'terminal_first_cluster')
-        terminal_no_available_points = getsettingvalue(s.game_config.fig, 'terminal_no_available_points')
-        if terminal_two_or_less_pieces and player_hand.num_pieces <= 2:
-            next = next.set(last_to_play=action.player_idx)
-        elif terminal_first_cluster and len(player_hand.completed_clusters) > 0:
-            next = next.set(last_to_play=action.player_idx, terminal=True)
-            next = calcwinners(next)
-        elif (
-            terminal_no_available_points
-            and len(getunavailablepoints(next)) == len(next.game_config.fig.board_config.points)
-        ):
-            next = next.set(last_to_play=action.player_idx, terminal=True)
-            next = calcwinners(next)
-
-    next = next.set(action_history=(next.action_history + [action]))
-    assertallcardsaccountedfor(next)
-
-    return next
-
-
 def getnextstate2(s, a, log=False):
     s = run_state_action_hooks(s, a, AFTER_ACCEPT_ACTION_HOOKS, log)
     s = run_state_action_hooks(s, a, HANDLE_ACTION_HOOKS, log)
@@ -4741,46 +4262,6 @@ def getnextstate2(s, a, log=False):
         s = run_state_action_hooks(s, a, EMPTY_LEGAL_ACTIONS_HOOKS, log)
     return s
 
-@dispatch(State, AltAction, RouteDiscardAction)
-def getnextstate(s, action, action_type):
-# Implementing the following Julia function:
-# function getnextstate(s::State, a::Action, ::Val{:ROUTE_DISCARD})
-#     player_hand = s.player_hands[a.player_idx]
-#     route_card_hand_nums = collect(a.return_route_cards)
-#     return_route_card_nums = player_hand.new_route_cards[route_card_hand_nums]
-#     chosen = setdiff(Set(player_hand.new_route_cards), Set(return_route_card_nums))
-#     existing_route_cards = player_hand.route_cards
-#     @reset s.player_hands[a.player_idx].route_cards = [existing_route_cards..., chosen...]
-#     @reset s.route_discards = [s.route_discards..., return_route_card_nums...]
-#     @reset s.player_hands[a.player_idx].new_route_cards = []
-#     s
-# end
-    player_hand_idx = next((i for i, p in enumerate(s.player_hands) if p.player_idx == action.player_idx), None)
-    if player_hand_idx is None:
-        raise ValueError(f"Player index {action.player_idx} not found in player hands.")
-    
-    player_hand = s.player_hands[player_hand_idx]
-    route_card_hand_idxs = list(action.return_route_cards)
-    return_route_card_nums = [player_hand.new_route_cards[i] for i in route_card_hand_idxs]
-    chosen = set(list(player_hand.new_route_cards)) - set(return_route_card_nums)
-    
-    print(f"new_route_cards: {list(player_hand.new_route_cards)}")
-    print(f"return_route_card_nums: {return_route_card_nums}")
-    print(f"Chosen route cards: {chosen}")
-    
-    # @reset s.player_hands[a.player_idx].route_cards = [existing_route_cards..., chosen...]
-    print(f"Existing route cards: {list(player_hand.route_cards)}")
-    player_hand = player_hand.set(route_cards=player_hand.route_cards + pvector(list(chosen)))
-    print(f"New route cards: {list(player_hand.route_cards)}")
-    # @reset s.route_discards = [s.route_discards..., return_route_card_nums...]
-    s = s.set(route_discards=s.route_discards + return_route_card_nums)
-    # @reset s.player_hands[a.player_idx].new_route_cards = []
-    player_hand = player_hand.set(new_route_cards=pvector([]))
-    print(f"New route cards: {list(player_hand.route_cards)}")
-
-    s = s.transform(('player_hands', player_hand_idx), player_hand)
-
-    return s
 
 
 @dispatch(State, QValueLearningPolicy)
@@ -4799,52 +4280,6 @@ def getnextaction(s, policy):
     return legal_actions[argmax_idx]
 
 
-def get_all_legal_actions(s, player_idx, legal_action_specs):
-    legal_actions = []
-    
-    for action_spec in legal_action_specs:
-        if action_spec.action_name == "ROUTE_DISCARD":
-            legal_actions.append(
-                AltAction(
-                    action_name="ROUTE_DISCARD", 
-                    player_idx=player_idx,
-                    return_route_cards=[0],  # Placeholder, should be filled with actual logic
-                )
-            )
-        
-        elif action_spec.action_name == "DRAW_UNIT_FACEUP":
-            draw_faceup_spot_num = 1  # Placeholder, should be filled with actual logic
-            legal_actions.append(
-                AltAction(
-                    action_name="DRAW_UNIT_FACEUP", 
-                    player_idx=player_idx,
-                    draw_faceup_unit_card_num=s.faceup_spots[draw_faceup_spot_num-1],
-                    draw_faceup_spot_num=draw_faceup_spot_num,
-                )
-            )
-        
-        elif action_spec.action_name == "DRAW_UNIT_DECK":
-            legal_actions.append(
-                AltAction(
-                    action_name="DRAW_UNIT_DECK", 
-                    player_idx=player_idx,
-                )
-            )
-        
-        elif action_spec.action_name == "CLAIM_POINT":
-            for point in action_spec.points:
-                legal_actions.append(
-                    AltAction(
-                        action_name="CLAIM_POINT",
-                        player_idx=player_idx,
-                        point_uuid=str(point.point_uuid),
-                        unit_combo=point.default_combo,  # Placeholder, should be filled with actual logic
-                    )
-                )
-
-    return legal_actions
-
-
 @dispatch(State, RandoPolicy)
 def getnextaction(s, policy):
     player_idx = gettoplay(s)[0]
@@ -4885,14 +4320,6 @@ def getnextaction(s, policy):
     return None
 
 
-@dispatch(State, int)
-def getplayerstate(s, player_idx):
-    return PlayerState(
-        public=getpublicstate(s), 
-        private=getprivatestate(s, player_idx),
-    )
-
-
 def getpublicplayerscore(s, player_score):
     print("*****************321 player_score: ", player_score)
     if s.terminal:

{graph_games_proto-0.3.1739.dist-info → graph_games_proto-0.3.1741.dist-info}/METADATA

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

{graph_games_proto-0.3.1739.dist-info → graph_games_proto-0.3.1741.dist-info}/RECORD

@@ -1,9 +1,9 @@
 graph_games_proto/__init__.py,sha256=sI31dBPkrs_UHYsuc1Q2sdYkJfpVPKpB--FuqghA208,864
 graph_games_proto/all_types.py,sha256=IpbwftEcHS5Ewz-saFNk0lO9FvcbuHG36odRTayCXUk,54911
-graph_games_proto/fns.py,sha256=6g0ZmnvRPm24KVE8G8X6ZHiy4MCw2lTdLckxIcxKX9w,264080
+graph_games_proto/fns.py,sha256=Yjdzi-ST7rSv5PLcJiECu5fgWXSbOjNl_LCYmulfuJc,239934
 graph_games_proto/main.py,sha256=fj2U7KcwrpZtuUhjOX5yVxY18LZvvsxDFYZ_S5mxe04,145
 graph_games_proto/state.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graph_games_proto-0.3.1739.dist-info/METADATA,sha256=entYuJ6psfY811c2Vkniil53jz5-U_RR1XStLn34CtE,188
-graph_games_proto-0.3.1739.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-graph_games_proto-0.3.1739.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
-graph_games_proto-0.3.1739.dist-info/RECORD,,
+graph_games_proto-0.3.1741.dist-info/METADATA,sha256=iaIQuc2Cf9DaYgB4dq4A1j85nGei4di7auJx4wb3Ans,188
+graph_games_proto-0.3.1741.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+graph_games_proto-0.3.1741.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
+graph_games_proto-0.3.1741.dist-info/RECORD,,