def play_action_card(self, player, card):
player.activated_cards.append(card)
try:
gen = card.activate_action(self, player)
except NotImplementedError:
return
for other_player in self.participants:
if other_player is not player:
yield InfoRequest(self, other_player,
_("%s plays:", (player.name, )), [card])
generator_forward(gen)
def play_game(self, starting_from_checkpoint):
if not starting_from_checkpoint:
self.deal_cards()
gen = self.fire_hook("on_setup_card", self)
generator_forward(gen)
for player in self.players:
player.prepare_hand(self.cards_to_draw)
for optionkey, optionvalue in self.player_option_defaults.items():
player.options[optionkey] = optionvalue
while True:
yield Checkpoint(self)
self.round += 1
gen = self.play_round()
generator_forward_ex(gen, [PlayerKickedException])
def activate_action(self, game, player):
action_cards_found = 0
shuffled = 0
found_cards = []
to_be_discarded = []
while True:
ret = player.draw_cards(1)
if ret is None: # no cards left
break
shuffled += ret
if shuffled == 2: # we shuffled our discard_pile 2 times, abort
break
card = player.hand.pop()
for info_player in game.participants:
yield InfoRequest(game, info_player,
_("%s reveals:", (player.name, )), [card])
if isinstance(card, ActionCard) and not isinstance(card, Golem):
found_cards.append(card)
action_cards_found += 1
if action_cards_found == 2:
break
else:
to_be_discarded.append(card)
player.discard_pile.extend(to_be_discarded)
while found_cards:
card_classes = [type(c) for c in found_cards]
card_cls = (yield
SelectCard(game,
player,
_("Which card do you want to play next?"),
card_classes=card_classes))
card = [c for c in found_cards if isinstance(c, card_cls)][0]
found_cards.remove(card)
player.aux_cards.append(card)
gen = game.play_action_card(player, card)
generator_forward(gen)
if card.trash_after_playing:
player.aux_cards.remove(card)
game.trash_pile.append(card)
def activate_action(self, game, player):
if not [c for c in player.hand if isinstance(c, ActionCard)]:
return
action_cards = (yield SelectActionCard(
self, player,
_(
"Which action card do you want to play on the kings court? (%i actions left)",
(player.remaining_actions, ))))
if action_cards:
card = action_cards[0]
player.hand.remove(card)
gen = game.play_action_card(player, card)
generator_forward(gen)
if card.trash_after_playing and not card.throne_room_duplicates:
game.trash_pile.append(card)
else:
player.aux_cards.append(card)
gen = game.play_action_card(player, card)
generator_forward(gen)
if card.trash_after_playing and not card.throne_room_duplicates:
game.trash_pile.append(card)
else:
player.aux_cards.append(card)
gen = game.play_action_card(player, card)
generator_forward(gen)
if card.trash_after_playing:
player.aux_cards.remove(card)
game.trash_pile.append(card)
def activate_action(self, game, player):
found_treasure = None
to_be_discarded = []
while True:
ret = player.draw_cards(1)
if ret is None: # no cards left
break
card = player.hand.pop()
for info_player in game.participants:
yield InfoRequest(game, info_player,
_("%s reveals:", (player.name, )), [card])
if isinstance(card, TreasureCard):
found_treasure = card
break
else:
to_be_discarded.append(card)
player.discard_pile.extend(to_be_discarded)
if found_treasure is not None:
player.aux_cards.append(found_treasure)
gen = game.play_action_card(player, found_treasure)
generator_forward(gen)
player.activated_treasure_cards.append(found_treasure)
def play_round(self):
from domination.cards import TreasureCard
self.pending_round_players = players = self.players[:]
while players:
player = players.pop(0)
self.finished_round_players.append(player)
with player:
try:
# duration actions from last round
for card in player.duration_cards:
duration_func = card.duration_action
card.durationaction_activated = False
gen = duration_func(self, player)
generator_forward(gen)
player.aux_cards.extend(player.duration_cards)
if player.duration_cards:
for other_player in self.participants:
if other_player is not player:
yield InfoRequest(self, other_player,
_("%s had duration cards:", (player.name, )), player.duration_cards)
player.duration_cards = []
gen = self.fire_hook("on_start_of_turn", self, player)
generator_forward(gen)
# action
while player.remaining_actions and [c for c in player.hand
if isinstance(c, ActionCard)]:
action_cards = (yield SelectActionCard(self, player,
_("Which action card do you want to play? (%i actions left)", (player.remaining_actions, ))))
if action_cards is None:
break
player.remaining_actions -= 1
card = action_cards[0]
player.hand.remove(card)
if card.trash_after_playing:
self.trash_pile.append(card)
else:
player.aux_cards.append(card)
gen = self.play_action_card(player, card)
generator_forward(gen)
# select money cards
if not player.options["automatic_money_selection"]:
cards = (yield SelectHandCards(self, player, _("Which money cards do you want to play?"), TreasureCard,
preselect_all=True))
if cards is None:
cards = []
else:
cards = [c for c in player.hand if isinstance(c, TreasureCard)]
player.aux_cards.extend(cards)
for card in cards:
player.hand.remove(card)
player.activated_treasure_cards = cards
for card in cards:
gen = self.play_action_card(player, card)
generator_forward(gen)
# deal
break_selection = False
while player.remaining_deals and not break_selection:
card_key = (yield SelectDeal(self, player, _("Which card do you want to buy?")))
if card_key is None:
break_selection = True
else:
try:
cardcls = CardTypeRegistry.keys2classes((card_key, ))[0]
gen = self.fire_hook("on_pre_buy_card", self, player, cardcls)
generator_forward(gen)
except AbortBuy:
continue
player.remaining_deals -= 1
card = self.supply[card_key].pop()
for val in self.check_empty_pile(card_key):
yield val
player.used_money += card.get_cost(self, player)
player.used_potion += card.potioncost
player.discard_pile.append(card)
for other_player in self.participants:
if other_player is not player:
yield InfoRequest(self, other_player,
_("%s buys:", (player.name, )), [card])
gen = self.fire_hook("on_buy_card", self, player, card)
generator_forward(gen)
reason = self.check_end_of_game()
if reason:
self.end_of_game_reason = reason
self.end_of_game()
cards_to_draw = self.cards_to_draw
finally:
# cleanup pt. 1
for cleanup_func in player.turn_cleanups:
gen = cleanup_func(player)
generator_forward(gen)
# cleanup pt. 2
for card in player.aux_cards:
if card.durationaction_activated:
player.duration_cards.append(card)
else:
player.discard_pile.append(card)
player.aux_cards = []
player.discard_pile.extend(player.hand)
player.hand = []
player.prepare_hand(cards_to_draw)
gen = self.fire_hook("on_end_of_turn", self, player)
generator_forward(gen)
self.finished_round_players[:] = []
def fire_hook(self, hook_name, *args):
for hook in self.hooks[hook_name]:
hookgen = hook(*args)
generator_forward(hookgen)
def on_buy_card(cls, game, player, card):
gen = game.fire_hook("on_gain_card", game, player, card)
generator_forward(gen)