graph-games-proto 0.3.2078__py3-none-any.whl → 0.3.2095__py3-none-any.whl

graph_games_proto/fns.py

@@ -982,6 +982,38 @@ class GameConfig(PClass):
             fig=Fig.__fromdict__(d["fig"]),
             seed=d["seed"]
         )
+    
+
+class PublicGameConfig(PClass):
+    uuid = field(type=str)
+    started_at = field(type=str)
+    num_players = field(type=int)
+    fig = field(type=Fig)
+    def __todict__(self):
+        return {
+            "uuid": self.uuid,
+            "started_at": self.started_at,
+            "num_players": self.num_players,
+            "fig": self.fig.__todict__(),
+        }
+    @staticmethod
+    def __fromdict__(d):
+        return PublicGameConfig(
+            uuid=d["uuid"],
+            started_at=d["started_at"],
+            num_players=d["num_players"],
+            fig=Fig.__fromdict__(d["fig"]),
+        )
+
+
+@dispatch(GameConfig)
+def getpublicgameconfig(game_config):
+    return PublicGameConfig(
+        uuid=game_config.uuid,
+        started_at=game_config.started_at,
+        num_players=game_config.num_players,
+        fig=game_config.fig,
+    )
 
 
 class ActionDrawUnit:
@@ -1195,7 +1227,7 @@ class LegalActionKeep(PClass):
         num_cards = len(card_uuids_matching_deck)
         actual_min = 0 if legal_action.keep.min is None else legal_action.keep.min
         actual_max = num_cards if legal_action.keep.max is None else min(legal_action.keep.max, num_cards)
-        rand_num_chosen = state.rng.randint(actual_min, actual_max)
+        rand_num_chosen = state.kernel.rng.randint(actual_min, actual_max)
         card_uuids = card_uuids_matching_deck[0:rand_num_chosen]
         return Action2(
             submitted_at=submitted_at,
@@ -1236,7 +1268,7 @@ class LegalActionDiscard(PClass):
         num_cards = len(card_uuids_matching_deck)
         actual_min = 0 if legal_action.discard.min is None else legal_action.discard.min
         actual_max = num_cards if legal_action.discard.max is None else min(legal_action.discard.max, num_cards)
-        rand_num_chosen = state.rng.randint(actual_min, actual_max)
+        rand_num_chosen = state.kernel.rng.randint(actual_min, actual_max)
         card_uuids = card_uuids_matching_deck[0:rand_num_chosen]
         return Action2(
             submitted_at=submitted_at,
@@ -1809,13 +1841,11 @@ def init_segment_record(segment: Segment2) -> SegmentRecord:
 
 
 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],
@@ -1823,7 +1853,6 @@ class Path2(PClass):
     @staticmethod
     def __fromdict__(d):
         return Path2(
-            uuid=d["uuid"],
             idx=d["idx"],
             edge_uuid=d["edge_uuid"],
             segments=[Segment2.__fromdict__(segment) for segment in d["segments"]],
@@ -1831,13 +1860,11 @@ 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,
@@ -1845,7 +1872,6 @@ class PathRecord(PClass):
     @staticmethod
     def __fromdict__(d):
         return PathRecord(
-            uuid=d["uuid"],
             idx=d["idx"],
             edge_uuid=d["edge_uuid"],
             segment_uuids=d["segment_uuids"],
@@ -1854,7 +1880,6 @@ class PathRecord(PClass):
 
 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],
@@ -2052,8 +2077,8 @@ class BonusStatus(PClass):
 
 
 class StateKernel(PClass):
-    rng = field(type=random.Random)
     game_config = field(type=GameConfig)
+    rng = field(type=random.Random)
 
     uuid2edgerecord = field(type=dict)  # Dict[str, BiEdgeRecord]
     uuid2segmentrecord = field(type=dict)  # Dict[str, SegmentRecord]
@@ -2081,8 +2106,8 @@ class StateKernel(PClass):
     player_graphs_3 = field(type=list)  # List[PlayerGraph]
     def __todict__(self):
         return {
-            "rng": rng2json(self.rng),
             "game_config": self.game_config.__todict__(),
+            "rng": rng2json(self.rng),
             "edges": [edge.__todict__() for edge in self.edges],
             "nodes": [node.__todict__() for node in self.nodes],
             "regions": [region.__todict__() for region in self.regions],
@@ -2110,8 +2135,8 @@ class StateKernel(PClass):
     @staticmethod
     def __fromdict__(d):
         return StateKernel(
-            rng=json2rng(d["rng"]),
             game_config=GameConfig.__fromdict__(d["game_config"]),
+            rng=json2rng(d["rng"]),
             edges=[BiEdge.__fromdict__(edge) for edge in d["edges"]],
             nodes=[Node.__fromdict__(n) for n in d["nodes"]],
             regions=[Region.__fromdict__(r) for r in d["regions"]],
@@ -2138,13 +2163,15 @@ class StateKernel(PClass):
         )
 
 
-def init_state_kernel(**kwargs):
-    rng = kwargs.get('rng')
-    game_config = kwargs.get('game_config')
-    fig = game_config.fig
-    board_config = fig.board_config
-    nodes = kwargs.get('nodes', [])
-    edges = kwargs.get('edges', [])
+def init_state_kernel(game_config, **kwargs):
+    board_config = game_config.fig.board_config
+    nodes = kwargs.get('nodes', get_nodes(board_config))
+    nodeuuid2idx = {node.uuid: idx for idx, node in enumerate(nodes)}
+    edges = get_edges(board_config, nodeuuid2idx)
+    segments = kwargs.get('segments', get_segments(board_config))
+    goals = board_config.goals
+    regions = kwargs.get('regions', [])
+
     idx2pathrecord = []
     edgeuuid2idx = {edge.uuid: idx for idx, edge in enumerate(edges)}
     for edge in edges:
@@ -2166,8 +2193,18 @@ def init_state_kernel(**kwargs):
             carduuid2card[card.uuid] = card
             carduuid2deckidx[card.uuid] = dek.idx
 
-    nodeuuid2idx = {node.uuid: idx for idx, node in enumerate(board_config.points)}
-    edges = get_edges(rng, board_config, nodeuuid2idx)
+    starting_piles = []
+    for piece_template in board_config.piece_templates:
+        if piece_template.has_player:
+            for player_idx in range(game_config.num_players):
+                pieces = generate_pieces(piece_template, player_idx)
+                pile = Pile(
+                    player_idx=player_idx,
+                    num_pieces=piece_template.quantity,
+                    pieces=[piece.uuid for piece in pieces],
+                )
+                starting_piles.append(pile)
+
     edgetuple2uuid = {}
     for edge in edges:
         node_1_idx = nodeuuid2idx[edge.node_1_uuid]
@@ -2175,27 +2212,42 @@ def init_state_kernel(**kwargs):
         edge_tuple = (min(node_1_idx, node_2_idx), max(node_1_idx, node_2_idx))
         edgetuple2uuid[edge_tuple] = edge.uuid
 
-    bonuses = game_config.fig.board_config.bonuses
+    bonuses = board_config.bonuses
     bonusuuid2bonusidx = {bonus.uuid: idx for idx, bonus in enumerate(bonuses)}
     
-    player_graphs_3 = calc_player_graphs3(nodes, edges, pieceuuid2piece, game_config)
+    player_graphs_3 = calc_player_graphs3(nodes, edges, pieceuuid2piece, game_config.num_players)
 
-    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}
 
+    starting_decks = []
+    for dek in board_config.deks:
+        cards = generate_cards(dek)
+        deck_obj = Deck(
+            uuid=dek.uuid,
+            idx=dek.idx,
+            units=[],
+            faceup_spots=[],
+            discard=[],
+            facedown_stack=[card.uuid for card in cards],
+        )
+        starting_decks.append(deck_obj)
+
+    default_players = [
+        Player(idx=idx, pieces=[], cards=[], discard_tray=[]) for idx in range(game_config.num_players)
+    ]
+
     return StateKernel(
-        rng=rng,
         game_config=game_config,
-        edges=edges,
-        nodes=kwargs.get('nodes', []),
-        regions=kwargs.get('regions', []),
-        decks=kwargs.get('decks', []),
-        piles=kwargs.get('piles', []),
-        players=kwargs.get('players'),
-        player_idxs=kwargs.get('player_idxs'),
+        rng=getrng(game_config.seed),
+        decks=kwargs.get('decks', starting_decks),
+        piles=kwargs.get('piles', starting_piles),
+        players=kwargs.get('players', default_players),
+        player_idxs=kwargs.get('player_idxs', list(range(game_config.num_players))),
         history=kwargs.get('history', []),
+        edges=edges,
+        nodes=nodes,
+        regions=regions,
         uuid2edgerecord=uuid2edgerecord,
         uuid2segmentrecord=uuid2segmentrecord,
         idx2pathrecord=idx2pathrecord,
@@ -2206,9 +2258,9 @@ def init_state_kernel(**kwargs):
         nodeuuid2idx=nodeuuid2idx,
         carduuid2deckidx=carduuid2deckidx,
         bonusuuid2bonusidx=bonusuuid2bonusidx,
-        starting_decks=kwargs.get('starting_decks', []),
-        starting_piles=kwargs.get('starting_piles', []),
-        goals=kwargs.get('goals', []),
+        starting_decks=starting_decks,
+        starting_piles=starting_piles,
+        goals=goals,
         player_graphs_3=player_graphs_3,
     )
 
@@ -2474,6 +2526,7 @@ class RemainingAllottedTime(PClass):
 
 
 class PublicState(PClass):
+    game_config = field(type=PublicGameConfig)
     deadlines = field(type=list)  # List[RemainingAllottedTime|None]
     game_started_at = field(type=str)
     allotted_times = field(type=list)
@@ -2614,7 +2667,7 @@ def get_segments(board_config):
     return segments
 
 
-def get_edges(rng, board_config, nodeuuid2idx):
+def get_edges(board_config, nodeuuid2idx):
     edges = []
     
 
@@ -2630,7 +2683,6 @@ def get_edges(rng, board_config, nodeuuid2idx):
                 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, 
                 edge_uuid=link.uuid,
                 segments=segments,
@@ -2707,97 +2759,8 @@ def getsettingvalue(s, setting_name):
 
 @dispatch(GameConfig)
 def getinitialstate(game_config):
-    rng = getrng(game_config.seed)
-    board_config = game_config.fig.board_config
-    nodes = get_nodes(board_config)
-
-    piles = []
-    for piece_template in board_config.piece_templates:
-        if piece_template.has_player:
-            for player_idx in range(game_config.num_players):
-                pieces = generate_pieces(piece_template, player_idx)
-                pile = Pile(
-                    player_idx=player_idx,
-                    num_pieces=piece_template.quantity,
-                    pieces=[piece.uuid for piece in pieces],
-                )
-                piles.append(pile)
-
-    decks = []
-    for dek in board_config.deks:
-        cards = generate_cards(dek)
-        deck_obj = Deck(
-            uuid=dek.uuid,
-            idx=dek.idx,
-            units=[],
-            faceup_spots=[],
-            discard=[],
-            facedown_stack=[card.uuid for card in cards],
-        )
-        decks.append(deck_obj)
-
-    # bonuses = game_config.fig.board_config.bonuses
-    # bonus_statuses = [
-    #     BonusStatus(
-    #         bonus_uuid=bonus.uuid, 
-    #         winners=[],
-    #         player_statuses=[
-    #             BonusPlayerStatus(
-    #                 player_idx=player_idx,
-    #                 score=0,
-    #                 longest_trail=None,
-    #             )
-    #             for player_idx in range(game_config.num_players)
-    #         ]
-    #     ) 
-    #     for bonus in bonuses
-    # ]
-
-    # state = State(
-    #     bonus_statuses=bonus_statuses,
-    #     history=[],
-    #     player_scores=[PlayerScore2(public_items=[], private_items=[]) for _ in range(game_config.num_players)],
-    #     player_graphs=[
-    #         PlayerGraph(
-    #             player_idx=player_idx, 
-    #             neighbors=[[] for _ in range(len(nodes))]
-    #         ) for player_idx in range(game_config.num_players)
-    #     ],
-    #     nodes = nodes,
-    #     edges = edges,
-    #     regions = get_regions(board_config),
-    #     legal_actions_3=[],
-    #     piles=piles,
-    #     players=[Player(idx=idx, pieces=[], cards=[], discard_tray=[]) for idx in range(game_config.num_players)],
-    #     player_idxs=list(range(game_config.num_players)),
-    #     decks=decks,
-    #     rng=rng,
-    #     last_to_play=None,
-    #     winners=[],
-    # )
-
-    nodeuuid2idx = {node.uuid: idx for idx, node in enumerate(board_config.points)}
-    edges = get_edges(rng, board_config, nodeuuid2idx)
-    
-    kernel = init_state_kernel(
-        rng=rng,
-        game_config=game_config,
-        segments=get_segments(board_config),
-        edges=edges,
-        nodes=nodes,
-        decks=decks,
-        piles=piles,
-        players=[Player(idx=idx, pieces=[], cards=[], discard_tray=[]) for idx in range(game_config.num_players)],
-        player_idxs=list(range(game_config.num_players)),
-        history=[],
-        player_scores=[PlayerScore2(public_items=[], private_items=[]) for _ in range(game_config.num_players)],
-        starting_decks=[Deck.__fromdict__(x.__todict__()) for x in decks],
-        starting_piles=[Pile.__fromdict__(x.__todict__()) for x in piles],
-        goals=board_config.goals,
-    )
-
+    kernel = init_state_kernel(game_config)
     kernel = run_kernel_hooks(kernel, INITIALIZATION_HOOKS, True)
-
     return init_memoized_state(kernel)
 
 
@@ -3749,18 +3712,17 @@ def calc_player_graph3(nodes, edges, pieceuuid2piece, player_idx):
 
 
 def calc_player_graphs(state):
-    game_config = state.kernel.game_config
     return [
         calc_player_graph(state, player_idx) 
-        for player_idx in range(game_config.num_players)
+        for player_idx in range(state.kernel.game_config.num_players)
     ]
 
 
-@dispatch(list, list, dict, GameConfig)
-def calc_player_graphs3(nodes, edges, pieceuuid2piece, game_config):
+@dispatch(list, list, dict, int)
+def calc_player_graphs3(nodes, edges, pieceuuid2piece, num_players):
     return [
         calc_player_graph3(nodes, edges, pieceuuid2piece, player_idx)
-        for player_idx in range(game_config.num_players)
+        for player_idx in range(num_players)
     ]
 
 
@@ -4595,7 +4557,7 @@ def get_deadline(s, max_allotted_time):
     since_action_idx = max_allotted_time.since_action_idx
     if since_action_idx == -1:
         allotted_since = datetime.strptime(
-            s.kernel.game_config.started_at, 
+            s.kernel.started_at, 
             "%Y-%m-%d %H:%M:%S"
         )
     else:
@@ -4676,21 +4638,23 @@ def imagine_decks(public_state, private_state):
 
 
 def imagine_state(public_state, private_state):
-    game_config = public_state.game_config
+    public_game_config = public_state.game_config
+
     imagined_kernel = init_state_kernel(
-        rng=random.Random(),
-        game_config=game_config,
+        GameConfig(
+            seed=random.randint(0, 2**31 - 1),
+            uuid=public_game_config.uuid,
+            num_players=public_game_config.num_players,
+            fig=public_game_config.fig,
+            started_at=public_game_config.started_at,
+        ),
         edges=public_state.edges,
         nodes=public_state.nodes,
         piles=public_state.piles,
+        player_idxs=public_state.player_idxs,
         decks=imagine_decks(public_state, private_state),
         players=imagine_players(public_state, private_state),
-        player_idxs=public_state.player_idxs,
         history=imagine_history(public_state, private_state),
-        player_scores=imagine_player_scores(public_state, private_state),
-        starting_decks=[Deck.__fromdict__(x.__todict__()) for x in decks],
-        starting_piles=[Pile.__fromdict__(x.__todict__()) for x in public_state.piles],
-        goals=game_config.fig.board_config.goals,
     )
     return init_memoized_state(imagined_kernel)
 
@@ -4723,7 +4687,6 @@ def getpublicstate(s):
                 )
             paths.append(
                 Path2(
-                    uuid=path_record.uuid,
                     edge_uuid=path_record.edge_uuid,
                     segments=segments,
                     idx=path_record.idx
@@ -4748,8 +4711,9 @@ def getpublicstate(s):
 
 
     return PublicState(
+        game_config=getpublicgameconfig(s.kernel.game_config),
         deadlines=get_deadlines(s),
-        game_started_at=s.kernel.game_config.started_at,
+        game_started_at=s.kernel.started_at,
         allotted_times=get_max_allotted_times(s),
         all_pieces=list(s.kernel.pieceuuid2piece.values()),
         to_play_2=getpublictoplay(s),

{graph_games_proto-0.3.2078.dist-info → graph_games_proto-0.3.2095.dist-info}/METADATA

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

{graph_games_proto-0.3.2078.dist-info → graph_games_proto-0.3.2095.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=_1ih4jhg9LtO2OTx5Bo3Xa5G7o43XWEa1jFty_f1lF0,201156
+graph_games_proto/fns.py,sha256=aq2Vxkuz1J4LGAPlO8OZtW1Tns81gL68UICMfsZzeHY,199556
 graph_games_proto/main.py,sha256=fj2U7KcwrpZtuUhjOX5yVxY18LZvvsxDFYZ_S5mxe04,145
 graph_games_proto/state.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graph_games_proto-0.3.2078.dist-info/METADATA,sha256=45PxNh56O2ygcfAq64cbl5dlm4if0pHZURIMCkBCPfU,188
-graph_games_proto-0.3.2078.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-graph_games_proto-0.3.2078.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
-graph_games_proto-0.3.2078.dist-info/RECORD,,
+graph_games_proto-0.3.2095.dist-info/METADATA,sha256=3B4hZJi4LhHbTKGGFf-y7t0nTc0sQ-w_1rPTCZ0-jyA,188
+graph_games_proto-0.3.2095.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+graph_games_proto-0.3.2095.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
+graph_games_proto-0.3.2095.dist-info/RECORD,,