graph-games-proto 0.3.2099__py3-none-any.whl → 0.3.2107__py3-none-any.whl

graph_games_proto/fns.py

@@ -1170,7 +1170,6 @@ class PrivateState(PClass):
 class PublicDeck(PClass):
     idx = field(type=int)
     uuid = field(type=str)
-    units = field(type=list)  # List[Card]
     facedown_stack_len = field(type=int)
     discard_len = field(type=int)
     faceup_spots = field(type=list)  # List[Card]
@@ -1178,7 +1177,6 @@ class PublicDeck(PClass):
         return {
             "idx": self.idx,
             "uuid": self.uuid,
-            "units": [unit.__todict__() for unit in self.units],
             "facedown_stack_len": self.facedown_stack_len,
             "discard_len": self.discard_len,
             "faceup_spots": self.faceup_spots,
@@ -1188,7 +1186,6 @@ class PublicDeck(PClass):
         return PublicDeck(
             idx=d["idx"],
             uuid=d["uuid"],
-            units=[Card.__fromdict__(card) for card in d["units"]],
             facedown_stack_len=d["facedown_stack_len"],
             discard_len=d["discard_len"],
             faceup_spots=d["faceup_spots"],
@@ -1687,31 +1684,76 @@ class Action2(PClass):
         )
 
 
+class CardStack(PClass):
+    hidden = field(type=bool)
+    cards = field(type=list)  # List[Card]
+    def __todict__(self):
+        return {
+            "hidden": self.hidden,
+            "cards": self.cards,
+        }
+    @staticmethod
+    def __fromdict__(d):
+        return CardStack(
+            hidden=d["hidden"],
+            cards=d["cards"],
+        )
+
+
+class CardSpread(PClass):
+    hidden = field(type=bool)
+    spots = field(type=list)  # List[Card|None]
+    def __todict__(self):
+        return {
+            "hidden": self.hidden,
+            "spots": self.spots,
+        }
+    @staticmethod
+    def __fromdict__(d):
+        return CardSpread(
+            hidden=d["hidden"],
+            spots=d["spots"],
+        )
+
+
+
 class Deck(PClass):
     idx = field(type=int)
     uuid = field(type=str)
-    units = field(type=list)  # List[Card]
-    facedown_stack = field(type=list)  # List[str]
-    discard = field(type=list)  # List[str]
-    faceup_spots = field(type=list)  # List[str]
+    faceup_stack = field(type=CardStack)
+    faceup_spread = field(type=CardSpread)
+    facedown_stack = field(type=CardStack)
+    facedown_spread = field(type=CardSpread)
+    discard_faceup_stack = field(type=CardStack)
+    discard_faceup_spread = field(type=CardSpread)
+    discard_facedown_stack = field(type=CardStack)
+    discard_facedown_spread = field(type=CardSpread)
     def __todict__(self):
         return {
             "idx": self.idx,
             "uuid": self.uuid,
-            "units": [unit.__todict__() for unit in self.units],
-            "facedown_stack": self.facedown_stack,
-            "discard": self.discard,
-            "faceup_spots": self.faceup_spots,
+            "faceup_stack": self.faceup_stack.__todict(),
+            "faceup_spread": self.faceup_spread.__todict(),
+            "facedown_stack": self.facedown_stack.__todict(),
+            "facedown_spread": self.facedown_spread.__todict(),
+            "discard_faceup_stack": self.discard_faceup_stack.__todict(),
+            "discard_faceup_spread": self.discard_faceup_spread.__todict(),
+            "discard_facedown_stack": self.discard_facedown_stack.__todict(),
+            "discard_facedown_spread": self.discard_facedown_spread.__todict(),
         }
     @staticmethod
     def __fromdict__(d):
         return Deck(
             idx=d["idx"],
             uuid=d["uuid"],
-            units=[], # TODO: Card.__fromdict__(card) for card in d["cards"]
-            facedown_stack=d["facedown_stack"],
-            discard=d["discard"],
-            faceup_spots=d["faceup_spots"],
+            faceup_stack=CardStack.__fromdict__(d["faceup_stack"]),
+            faceup_spread=CardSpread.__fromdict__(d["faceup_spread"]),
+            facedown_stack=CardStack.__fromdict__(d["facedown_stack"]),
+            facedown_spread=CardSpread.__fromdict__(d["facedown_spread"]),
+            discard_faceup_stack=CardStack.__fromdict__(d["discard_faceup_stack"]),
+            discard_faceup_spread=CardSpread.__fromdict__(d["discard_faceup_spread"]),
+            discard_facedown_stack=CardStack.__fromdict__(d["discard_facedown_stack"]),
+            discard_facedown_spread=CardSpread.__fromdict__(d["discard_facedown_spread"]),
         )
 
 
@@ -2237,10 +2279,9 @@ def init_state_kernel(game_config, **kwargs):
         deck_obj = Deck(
             uuid=dek.uuid,
             idx=dek.idx,
-            units=[],
-            faceup_spots=[],
-            discard=[],
-            facedown_stack=[card.uuid for card in cards],
+            facedown_stack=CardStack(hidden=True, cards=[c.uuid for c in cards]),
+            faceup_spread=CardSpread(hidden=False, spots=[]),
+            discard_facedown_stack=CardStack(hidden=True, cards=[]),
         )
         starting_decks.append(deck_obj)
 
@@ -3205,13 +3246,13 @@ def replenish_decks_if_needed(kernel):
 def replenish_faceup_spot_if_needed(kernel, deck_idx, spot_idx):
     deck = kernel.decks[deck_idx]
 
-    if deck.faceup_spots[spot_idx] is not None:
+    if deck.faceup_spread.spots[spot_idx] is not None:
         return kernel
     
-    if len(deck.facedown_stack) == 0:
+    if len(deck.facedown_stack.cards) == 0:
         return kernel
-    
-    deck.faceup_spots[spot_idx] = deck.facedown_stack.pop()
+
+    deck.faceup_spread.spots[spot_idx] = deck.facedown_stack.cards.pop()
 
     kernel = ensure_faceup_spots_valid(kernel)
 
@@ -3223,7 +3264,7 @@ def replenish_faceup_spot_if_needed(kernel, deck_idx, spot_idx):
 @dispatch(StateKernel, int)
 def replenish_faceup_if_needed(kernel, deck_idx):
     deck = kernel.decks[deck_idx]
-    for spot_idx in range(len(deck.faceup_spots)):
+    for spot_idx in range(len(deck.faceup_spread.spots)):
         kernel = replenish_faceup_spot_if_needed(kernel, deck_idx, spot_idx)
     return kernel
 
@@ -3231,12 +3272,12 @@ def replenish_faceup_if_needed(kernel, deck_idx):
 @dispatch(StateKernel, int)
 def recycle_if_needed(kernel, deck_idx):
     deck = kernel.decks[deck_idx]
-    if len(deck.facedown_stack) == 0:
-        shuffled_discards = list(deck.discard)
+    if len(deck.facedown_stack.cards) == 0:
+        shuffled_discards = list(deck.discard_facedown_stack.cards)
         kernel.rng.shuffle(shuffled_discards)
         deck = deck.set(
-            facedown_stack = shuffled_discards,
-            discard = []
+            facedown_stack=CardStack(hidden=True, cards=shuffled_discards),
+            discard_facedown_stack=CardStack(hidden=True, cards=[])
         )
         kernel = set_deck(kernel, deck.idx, deck)
     return kernel
@@ -3251,11 +3292,11 @@ def handle_draw_action(kernel, action):
     player = kernel.players[legal_action.player_idx]
     deck = kernel.decks[draw.deck_idx]
     
-    if len(deck.facedown_stack) == 0:
+    if len(deck.facedown_stack.cards) == 0:
         return kernel  # No cards to draw
 
     for _ in range(draw.quantity):
-        drawn_card = deck.facedown_stack.pop()
+        drawn_card = deck.facedown_stack.cards.pop()
         player.cards.append(drawn_card)
         kernel = recycle_if_needed(kernel, draw.deck_idx)
 
@@ -3279,11 +3320,11 @@ def handle_draw_discard_action(kernel, action):
     player = kernel.players[legal_action.player_idx]
     deck = kernel.decks[draw_discard.deck_idx]
     
-    if len(deck.facedown_stack) == 0:
+    if len(deck.facedown_stack.cards) == 0:
         return kernel  # No cards to draw
 
     for _ in range(draw_discard.quantity):
-        drawn_card = deck.facedown_stack.pop()
+        drawn_card = deck.facedown_stack.cards.pop()
         player.discard_tray.append(drawn_card)
 
     return kernel.set(
@@ -3299,8 +3340,8 @@ def get_follow_up_draw_legal_actions(kernel, action):
     if len(kernel.history) >= 2:
         last_action = kernel.history[-2]
         if (last_action.legal_action.player_idx != legal_action.player_idx) or last_action.legal_action.name == "INITIAL-GOAL-KEEP":
-            
-            if len(kernel.decks[0].facedown_stack) >= 1:
+
+            if len(kernel.decks[0].facedown_stack.cards) >= 1:
                 to_return.append(
                     LegalAction(
                         auto_preferred=True,
@@ -3315,8 +3356,8 @@ def get_follow_up_draw_legal_actions(kernel, action):
                         )
                     )
                 )
-            
-            for card_uuid in kernel.decks[0].faceup_spots:
+
+            for card_uuid in kernel.decks[0].faceup_spread.spots:
                 if card_uuid:
                     if not kernel.carduuid2card[card_uuid].is_wild:
                         to_return.append(
@@ -3339,7 +3380,7 @@ def get_follow_up_draw_legal_actions(kernel, action):
 @dispatch(StateKernel, int)
 def get_num_faceup_wilds(kernel, deck_idx):
     deck = kernel.decks[deck_idx]
-    non_empty_spots = [spot for spot in deck.faceup_spots if spot]
+    non_empty_spots = [spot for spot in deck.faceup_spread.spots if spot]
     if not non_empty_spots:
         return 0
     return sum(1 for card_uuid in non_empty_spots if kernel.carduuid2card[card_uuid].is_wild)
@@ -3359,14 +3400,14 @@ def ensure_faceup_spots_valid(kernel):
 @dispatch(StateKernel, int)
 def discardfaceup_shuffle_flip(kernel, deck_idx):
     deck = kernel.decks[deck_idx]
-    num_faceup_spots = len(deck.faceup_spots)
-    for faceup_spot in deck.faceup_spots:
+    num_faceup_spots = len(deck.faceup_spread.spots)
+    for faceup_spot in deck.faceup_spread.spots:
         if faceup_spot:
-            deck.discard.append(faceup_spot)
-    deck = deck.set(faceup_spots=[])
-    while len(deck.discard) > 0:
-        card = deck.discard.pop()
-        deck.facedown_stack.append(card)
+            deck.discard_facedown_stack.cards.append(faceup_spot)
+    deck = deck.set(faceup_spread=CardStack(hidden=False, cards=[]))
+    while len(deck.discard_facedown_stack.cards) > 0:
+        card = deck.discard_facedown_stack.cards.pop()
+        deck.facedown_stack.cards.append(card)
     deck = shuffle(kernel.rng, deck)
     kernel = set_deck(kernel, deck.idx, deck)
     kernel = flip_cards(kernel, deck.idx, num_faceup_spots)
@@ -3382,11 +3423,11 @@ def handle_faceup_draw_action(kernel, action):
     player = kernel.players[legal_action.player_idx]
     deck = kernel.decks[faceup_draw.deck_idx]
     # find the faceup spot idx with uuid "faceup_draw.card_uuid"
-    spot_idx = next((i for i, card_uuid in enumerate(deck.faceup_spots) if card_uuid == faceup_draw.card_uuid), None)
-    drawn_card = deck.faceup_spots[spot_idx] if spot_idx is not None else None
+    spot_idx = next((i for i, card_uuid in enumerate(deck.faceup_spread.spots) if card_uuid == faceup_draw.card_uuid), None)
+    drawn_card = deck.faceup_spread.spots[spot_idx] if spot_idx is not None else None
     player.cards.append(drawn_card)
-    
-    deck.faceup_spots[spot_idx] = None
+
+    deck.faceup_spread.spots[spot_idx] = None
     kernel = kernel.set(decks=kernel.decks)
     kernel = replenish_faceup_spot_if_needed(kernel, faceup_draw.deck_idx, spot_idx)
 
@@ -3603,9 +3644,9 @@ def handle_move_longest_path_card(kernel, action):
 
     if len(kernel.decks) > 2:
         longest_path_deck = kernel.decks[2]
-        if longest_path_deck.facedown_stack:
+        if longest_path_deck.facedown_stack.cards:
             # Move the longest path card to the player's hand
-            longest_path_card = longest_path_deck.facedown_stack.pop()
+            longest_path_card = longest_path_deck.facedown_stack.cards.pop()
         else:
             # Search for the longest path card in each player's cards
             player_with_card = find_player_with_longest_path_card(kernel)
@@ -3671,7 +3712,7 @@ def handle_move_pieces_to_path_action(kernel, action):
             # Remove the card from player's cards
             card_uuid = player.cards.pop(card_idx)
             # add to discard
-            kernel.decks[kernel.carduuid2card[card_uuid].deck_idx].discard.append(card_uuid)
+            kernel.decks[kernel.carduuid2card[card_uuid].deck_idx].discard_facedown_stack.cards.append(card_uuid)
 
     kernel = recycle_decks_if_needed(kernel)
     kernel = replenish_decks_if_needed(kernel)
@@ -3763,7 +3804,7 @@ def handle_keep_action(kernel, action):
 
 
     # Discard the non-kept cards to the deck's discard pile
-    deck.discard.extend(non_kept_cards)
+    deck.discard_facedown_stack.cards.extend(non_kept_cards)
     
     # Clear the discard tray and add the kept cards back
     player.cards.extend([c for c in kept_cards if c is not None])
@@ -3805,7 +3846,7 @@ def handle_discard_action(kernel, action):
     print("****************************** handle_discard_action 6", non_kept_cards)
 
     # Discard the non-kept cards to the deck's discard pile
-    deck.discard.extend(non_kept_cards)
+    deck.discard_facedown_stack.cards.extend(non_kept_cards)
     
     # Clear the discard tray and add the kept cards back
     player.cards.extend([c for c in kept_cards if c is not None])
@@ -3834,9 +3875,9 @@ def set_deck(kernel, deck_idx, deck):
 
 
 def shuffle(rng, deck):
-    shuffled_cards = list(deck.facedown_stack)
+    shuffled_cards = list(deck.facedown_stack.cards)
     rng.shuffle(shuffled_cards)
-    return deck.set(facedown_stack=shuffled_cards)
+    return deck.set(facedown_stack=CardStack(hidden=True, cards=shuffled_cards))
 
 
 @dispatch(StateKernel, int)
@@ -3845,7 +3886,7 @@ def shuffle_deck(kernel, deck_idx):
         return kernel
     
     deck = kernel.decks[deck_idx]
-    if not deck or not deck.facedown_stack:
+    if not deck or not deck.facedown_stack.cards:
         return kernel
 
     shuffled_deck = shuffle(kernel.rng, deck)
@@ -3871,14 +3912,14 @@ def flip_cards(kernel, deck_idx, num_cards):
         return kernel
     
     deck = kernel.decks[deck_idx]
-    if not deck or not deck.facedown_stack:
+    if not deck or not deck.facedown_stack.cards:
         return kernel
 
-    # Flip the top num_cards from the facedown_stack to the faceup_spots
+    # Flip the top num_cards from the facedown_stack to the faceup_spread
     for _ in range(num_cards):
-        if deck.facedown_stack:
-            card = deck.facedown_stack.pop()
-            deck.faceup_spots.append(card)
+        if deck.facedown_stack.cards:
+            card = deck.facedown_stack.cards.pop()
+            deck.faceup_spread.spots.append(card)
 
     return kernel.set(decks=kernel.decks)
 
@@ -3906,14 +3947,14 @@ def deal_cards_to_each_player_discard_tray(kernel, deck_idx, num_cards):
         return kernel
 
     deck = kernel.decks[deck_idx]
-    if not deck or not deck.facedown_stack:
+    if not deck or not deck.facedown_stack.cards:
         return kernel
 
     for player in kernel.players:
         # Deal cards to the player's discard tray
         for _ in range(num_cards):
-            if deck.facedown_stack:
-                card = deck.facedown_stack.pop()
+            if deck.facedown_stack.cards:
+                card = deck.facedown_stack.cards.pop()
                 player.discard_tray.append(card)
 
     return kernel.set(players=kernel.players, decks=kernel.decks)
@@ -3925,15 +3966,15 @@ def deal_cards_to_each_player(kernel, deck_idx, num_cards):
         return kernel
 
     deck = kernel.decks[deck_idx]
-    if not deck or not deck.facedown_stack:
+    if not deck or not deck.facedown_stack.cards:
         return kernel
 
     for player in kernel.players:
         player_hand = player.cards
         # Deal cards to the player's hand
         for _ in range(num_cards):
-            if deck.facedown_stack:
-                card = deck.facedown_stack.pop()
+            if deck.facedown_stack.cards:
+                card = deck.facedown_stack.cards.pop()
                 player_hand.append(card)
 
     return kernel.set(players=kernel.players, decks=kernel.decks)
@@ -4758,10 +4799,9 @@ def getpublicdeck(s, d):
     return PublicDeck(
         idx=d.idx,
         uuid=d.uuid,
-        units=d.units,
-        facedown_stack_len=len(d.facedown_stack),
-        discard_len=len(d.discard),
-        faceup_spots=d.faceup_spots,
+        facedown_stack_len=len(d.facedown_stack.cards),
+        discard_len=len(d.discard_facedown_stack.cards),
+        faceup_spots=d.faceup_spread.spots,
     )
 
 
@@ -5361,7 +5401,7 @@ def getscorecodes(f):
 #     filter(n -> !isnothing(s.faceup_spots[n]), 1:length(s.faceup_spots))
 # end
 def getvalidspotnums(s):
-    return [n for n in range(1, len(s.faceup_spots) + 1) if s.faceup_spots[n-1] is not None]
+    return [n for n in range(1, len(s.faceup_spread.spots) + 1) if s.faceup_spread.spots[n-1] is not None]
 
 
 def json_serializer(obj):
@@ -5797,7 +5837,7 @@ def get_default_legal_actions(state_kernel, player_idx):
     allotted_since_action_idx = len(state_kernel.history) - 1
     legal_actions = []
 
-    if len(state_kernel.decks[1].facedown_stack) >= 1:
+    if len(state_kernel.decks[1].facedown_stack.cards) >= 1:
         legal_actions.append(
             LegalAction(
                 player_idx=player_idx,
@@ -5813,7 +5853,7 @@ def get_default_legal_actions(state_kernel, player_idx):
             )
         )
 
-    if len(state_kernel.decks[0].facedown_stack) >= 1:
+    if len(state_kernel.decks[0].facedown_stack.cards) >= 1:
         legal_actions.append(
             LegalAction(
                 auto_preferred=True,
@@ -5829,7 +5869,7 @@ def get_default_legal_actions(state_kernel, player_idx):
             )
         )
 
-    if len(state_kernel.decks[0].facedown_stack) >= 2:
+    if len(state_kernel.decks[0].facedown_stack.cards) >= 2:
         legal_actions.append(
             LegalAction(
                 player_idx=player_idx,
@@ -5844,7 +5884,7 @@ def get_default_legal_actions(state_kernel, player_idx):
             )
         )
 
-    for card_uuid in state_kernel.decks[0].faceup_spots:
+    for card_uuid in state_kernel.decks[0].faceup_spread.spots:
         if card_uuid:
             legal_actions.append(
                 LegalAction(

{graph_games_proto-0.3.2099.dist-info → graph_games_proto-0.3.2107.dist-info}/METADATA

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

{graph_games_proto-0.3.2099.dist-info → graph_games_proto-0.3.2107.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=c5Vj7Ye-LnNQBbOm7tQg0EWvcinATUSeDLWduCdrHaw,199901
+graph_games_proto/fns.py,sha256=hjbhH7cyvxpZncYg2LTGqlBt_mrDAjKG56VuvCiO54Y,202019
 graph_games_proto/main.py,sha256=fj2U7KcwrpZtuUhjOX5yVxY18LZvvsxDFYZ_S5mxe04,145
 graph_games_proto/state.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graph_games_proto-0.3.2099.dist-info/METADATA,sha256=tsn8lVkH1Vnv04mvMZhdfh8vRmWeDEW65g-VkZ5GXRQ,188
-graph_games_proto-0.3.2099.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-graph_games_proto-0.3.2099.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
-graph_games_proto-0.3.2099.dist-info/RECORD,,
+graph_games_proto-0.3.2107.dist-info/METADATA,sha256=dutsrkox9vObZA9gR7Cqk0htBKvxmDQKB6erQi69UyQ,188
+graph_games_proto-0.3.2107.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+graph_games_proto-0.3.2107.dist-info/top_level.txt,sha256=-4QSrBMf_MM4BGsr2QXBpqDx8c8k_OPnzGyFjqjakes,18
+graph_games_proto-0.3.2107.dist-info/RECORD,,