def show_new_game(game_canvas: 'GameCanvas'):
game = game_canvas.game_canvas_updater.env_thread.gin_rummy_env.game
game_canvas.dealer_id = game.round.dealer_id
dealer = game.round.dealer
shuffled_deck = dealer.shuffled_deck
# Deal cards to players
if utils.is_debug():
for card_id in range(52):
card_item_id = game_canvas.card_item_ids[card_id]
tags = game_canvas.gettags(card_item_id)
assert not tags
for i in range(2):
player_id = (game_canvas.dealer_id + 1 + i) % 2
anchor_x, anchor_y = game_canvas.player_held_pile_anchors[player_id]
face_up = True
# Note: cannot use card_ids = [gin_rummy_utils.get_card_id(card) for card in game.round.players[player_id].hand]
if not game_canvas.is_treating_as_human(player_id=player_id):
face_up = False
if i == 0:
dealt_cards = list(shuffled_deck[-11:])
else:
dealt_cards = list(shuffled_deck[-21:-11])
card_ids = [gin_rummy_utils.get_card_id(card=card) for card in dealt_cards]
card_ids = sorted(card_ids, reverse=True, key=utils.gin_rummy_sort_order_id)
for card_id in card_ids:
card_item_id = game_canvas.card_item_ids[card_id]
if utils.is_debug() or True:
tags = game_canvas.gettags(card_item_id)
assert not tags
game_canvas.tag_raise(card_item_id) # note this
game_canvas.itemconfig(card_item_id, tag=game_canvas.held_pile_tags[player_id])
utils.set_card_id_face_up(card_id=card_id, face_up=face_up, game_canvas=game_canvas)
utils.move_to(card_item_id, anchor_x, anchor_y, parent=game_canvas)
game_canvas.itemconfigure(card_item_id, state=tk.NORMAL)
anchor_x += game_canvas.held_pile_tab
# Deal stockpile cards
stock_pile_x, stock_pile_y = game_canvas.stock_pile_anchor
# Note: cannot use stock_pile = [gin_rummy_utils.get_card_id(card) for card in game.round.dealer.stock_pile]
stock_pile = list(shuffled_deck[:31])
stock_pile_card_ids = [gin_rummy_utils.get_card_id(card) for card in stock_pile]
for card_id in stock_pile_card_ids:
card_item_id = game_canvas.card_item_ids[card_id]
if utils.is_debug():
tags = game_canvas.gettags(card_item_id)
assert not tags
game_canvas.tag_raise(card_item_id) # note this
game_canvas.itemconfig(card_item_id, tag=configurations.STOCK_PILE_TAG)
utils.set_card_id_face_up(card_id=card_id, face_up=False, game_canvas=game_canvas)
utils.move_to(card_item_id, stock_pile_x, stock_pile_y, parent=game_canvas)
game_canvas.itemconfigure(card_item_id, state=tk.NORMAL)
stock_pile_x += game_canvas.stock_pile_tab
# update canvas
game_canvas.update() # seems to be needed: scores not cleared if 'new game' chosen from menu with no mouse move
if utils.is_debug():
settings = game.settings
settings.print_settings()
def put_down_meld_cluster(self, meld_cluster, player_id: int):
game_canvas = self.game_canvas
card_width = game_canvas.card_width
card_height = game_canvas.card_height
player_pane = game_canvas.player_panes[player_id]
y_tab = int(card_height * 0.15)
anchor_x = int(card_width * 0.5) # type: int
anchor_y = int(game_canvas.coords(player_pane.item_id)[1]) + y_tab # type: int
for index in range(len(meld_cluster)):
meld_pile = meld_cluster[index]
self.put_down_meld_pile(meld_pile, anchor=(anchor_x, anchor_y), player_id=player_id)
utils.fan_held_pile(player_id=player_id, game_canvas=game_canvas)
anchor_x += len(meld_pile) * game_canvas.held_pile_tab
anchor_y += y_tab
held_pile_item_ids = game_canvas.getter.get_held_pile_item_ids(player_id=player_id)
if not game_canvas.query.is_human(player_id):
# sort deadwood cards of computer player
held_pile_cards = game_canvas.getter.get_held_pile_cards(player_id=player_id)
card_ids = [gin_rummy_utils.get_card_id(card) for card in held_pile_cards]
sorted_card_ids = sorted(card_ids, reverse=True, key=utils.gin_rummy_sort_order_id)
for sorted_card_id in sorted_card_ids:
card_item_id = game_canvas.card_item_ids[sorted_card_id]
game_canvas.tag_raise(card_item_id)
utils.fan_held_pile(player_id, game_canvas=game_canvas)
# face up deadwood cards of computer player
for held_pile_item_id in held_pile_item_ids:
utils.set_card_item_id_face_up(card_item_id=held_pile_item_id, face_up=True, game_canvas=game_canvas)
def get_all_run_melds(hand: List[Card]) -> List[List[Card]]:
card_count = len(hand)
hand_by_suit = sorted(hand, key=lambda card: utils.get_card_id(card))
max_run_melds = []
i = 0
while i < card_count - 2:
card_i = hand_by_suit[i]
j = i + 1
card_j = hand_by_suit[j]
while utils.get_rank_id(card_j) == utils.get_rank_id(
card_i) + j - i and card_j.suit == card_i.suit:
j += 1
if j < card_count:
card_j = hand_by_suit[j]
else:
break
max_run_meld = hand_by_suit[i:j]
if len(max_run_meld) >= 3:
max_run_melds.append(max_run_meld)
i = j
result = []
for max_run_meld in max_run_melds:
max_run_meld_count = len(max_run_meld)
for i in range(max_run_meld_count - 2):
for j in range(i + 3, max_run_meld_count + 1):
result.append(max_run_meld[i:j])
return result
def get_all_run_melds_for_suit(cards: List[Card],
suit: str) -> List[List[Card]]:
cards_for_suit = [card for card in cards if card.suit == suit]
cards_for_suit_count = len(cards_for_suit)
cards_for_suit = sorted(cards_for_suit,
key=lambda card: utils.get_card_id(card))
max_run_melds = []
i = 0
while i < cards_for_suit_count - 2:
card_i = cards_for_suit[i]
j = i + 1
card_j = cards_for_suit[j]
while utils.get_rank_id(card_j) == utils.get_rank_id(card_i) + j - i:
j += 1
if j < cards_for_suit_count:
card_j = cards_for_suit[j]
else:
break
max_run_meld = cards_for_suit[i:j]
if len(max_run_meld) >= 3:
max_run_melds.append(max_run_meld)
i = j
result = []
for max_run_meld in max_run_melds:
max_run_meld_count = len(max_run_meld)
for i in range(max_run_meld_count - 2):
for j in range(i + 3, max_run_meld_count + 1):
result.append(max_run_meld[i:j])
return result
def put_down_meld_pile(self, meld_pile: List[Card], anchor: Tuple[int, int], player_id: int):
game_canvas = self.game_canvas
held_pile_tag = game_canvas.held_pile_tags[player_id]
x, y = anchor
card_ids = [gin_rummy_utils.get_card_id(card=card) for card in meld_pile]
sorted_card_ids = sorted(card_ids, reverse=True, key=utils.gin_rummy_sort_order_id)
for sorted_card_id in sorted_card_ids:
card_item_id = game_canvas.card_item_ids[sorted_card_id]
game_canvas.tag_raise(card_item_id)
game_canvas.dtag(card_item_id, held_pile_tag)
utils.move_to(card_item_id, x, y, game_canvas)
utils.set_card_item_id_face_up(card_item_id, face_up=True, game_canvas=game_canvas)
x += game_canvas.held_pile_tab
def post_do_gin_action(self):
game_canvas = self.game_canvas
game_canvas.going_out_button.place_forget()
current_player_id = game_canvas.current_player_id
current_hand = game_canvas.getter.get_held_pile_cards(
player_id=current_player_id)
going_out_deadwood_count = self.game_canvas.game_canvas_updater.env.game.settings.going_out_deadwood_count
_, gin_cards = judge.get_going_out_cards(
hand=current_hand,
going_out_deadwood_count=going_out_deadwood_count)
card = gin_cards[0]
card_id = gin_rummy_utils.get_card_id(card=card)
card_item = game_canvas.card_items[card_id]
selected_held_pile_item_id = card_item.item_id
top_discard_pile_item_id = game_canvas.getter.get_top_discard_pile_item_id(
)
if top_discard_pile_item_id is None:
to_location = game_canvas.discard_pile_anchor
else:
dx = game_canvas.discard_pile_tab
to_location = game_canvas.coords(top_discard_pile_item_id)
to_location = utils.translated_by(dx=dx,
dy=0,
location=to_location)
utils.set_card_item_id_face_up(card_item_id=selected_held_pile_item_id,
face_up=True,
game_canvas=game_canvas)
def loop_completion():
game_canvas.dtag(selected_held_pile_item_id,
configurations.SELECTED_TAG)
game_canvas.dtag(selected_held_pile_item_id,
configurations.JOGGED_TAG)
game_canvas.dtag(selected_held_pile_item_id,
game_canvas.held_pile_tags[current_player_id])
game_canvas.addtag_withtag(configurations.DISCARD_PILE_TAG,
selected_held_pile_item_id)
utils.fan_held_pile(player_id=current_player_id,
game_canvas=game_canvas)
# show meld piles for both players
self._show_meld_piles()
# submit action to game_canvas_updater
action = GIN_ACTION_ID
game_canvas.after_idle(
game_canvas.game_canvas_updater.did_perform_actions, [action])
self._move_loop(selected_held_pile_item_id,
to_location,
completion=loop_completion)
def _get_all_run_melds(hand: List[Card]) -> List[List[Card]]:
card_count = len(hand)
hand_by_suit = sorted(hand, key=lambda card: utils.get_card_id(card))
max_run_melds_from_left = [[] for _ in hand_by_suit]
for i in range(card_count):
card = hand_by_suit[i]
card_rank_id = utils.get_card_id(card)
max_run_melds_from_left[i].append(card)
for j in range(i + 1, card_count):
next_card = hand_by_suit[j]
next_card_rank_id = utils.get_card_id(next_card)
if next_card.suit != card.suit or next_card_rank_id != card_rank_id + (j - i):
break
else:
max_run_melds_from_left[i].append(next_card)
max_run_melds_from_left = [run_meld for run_meld in max_run_melds_from_left if len(run_meld) >= 3]
result = copy.deepcopy(max_run_melds_from_left)
for max_run_meld in max_run_melds_from_left:
max_run_meld_count = len(max_run_meld)
if max_run_meld_count > 3:
for i in range(max_run_meld_count - 3):
result.append(max_run_meld[:-(i + 1)])
return result
def test_gin_rummy_dealer(self):
dealer = GinRummyDealer(np.random.RandomState())
current_deck = utils.get_deck()
deck_card_ids = [utils.get_card_id(card) for card in current_deck]
self.assertEqual(deck_card_ids, list(range(52)))
# Deal 10 cards.
player = GinRummyPlayer(player_id=0, np_random=np.random.RandomState())
dealer.deal_cards(player=player, num=10)
self.assertEqual(len(dealer.shuffled_deck), 52)
self.assertEqual(len(dealer.stock_pile), 42)
self.assertEqual(len(current_deck), 52)
self.assertEqual(len(utils.get_deck()), 52)
# Pop top_card from current_deck.
top_card = current_deck.pop(-1)
self.assertEqual(str(top_card), "KC")
self.assertEqual(len(current_deck), 51)
self.assertEqual(len(utils.get_deck()), 52)
def _perform_pick_up_discard_move(self, move: PickupDiscardMove):
if utils.is_debug():
print("{}".format(move))
player = move.player
player_id = player.player_id
card = move.card
source_item_id = self.game_canvas.getter.get_top_discard_pile_item_id()
source_card_item_id = self.game_canvas.getter.get_card_id(
card_item_id=source_item_id)
assert source_card_item_id == gin_rummy_utils.get_card_id(card=card)
self.game_canvas.addtag_withtag(configurations.DRAWN_TAG,
source_item_id)
target_item_id = self.game_canvas.getter.get_held_pile_item_ids(
player_id=player_id)[-1]
target_item = self.game_canvas.canvas_item_by_item_id[target_item_id]
handling_tap_held_pile.handle_tap_held_pile(
hit_item=target_item, game_canvas=self.game_canvas)
def _perform_draw_card_move(self, move: DrawCardMove):
if utils.is_debug():
print("{}".format(move))
player = move.player
player_id = player.player_id
card = move.card
source_item_id = self.game_canvas.getter.get_top_stock_pile_item_id()
source_card_item_id = self.game_canvas.getter.get_card_id(
card_item_id=source_item_id)
if not source_card_item_id == gin_rummy_utils.get_card_id(card=card):
raise GinRummyProgramError(
"source_card_item_id={} doesn't match with card={}.".format(
source_card_item_id, card))
self.game_canvas.addtag_withtag(configurations.DRAWN_TAG,
source_item_id)
target_item_id = self.game_canvas.getter.get_held_pile_item_ids(
player_id=player_id)[-1]
target_item = self.game_canvas.canvas_item_by_item_id[target_item_id]
handling_tap_held_pile.handle_tap_held_pile(
hit_item=target_item, game_canvas=self.game_canvas)
