def winner(self):
assert self.game_over
# SCORE-WINNER
by_score = defaultdict(list)
for player in self._game.players:
score = rules.score(player, self._game)
by_score[score].append(player)
max_score = max(by_score.keys())
if len(by_score[max_score]) == 1:
return by_score[max_score][0]
by_pure_score = defaultdict(list)
for player in by_score[max_score]:
pure_score = rules.score(player, self._game, with_bonuses=False)
by_pure_score[pure_score].append(player)
max_pure_score = max(by_pure_score.keys())
if len(by_pure_score[max_pure_score]) == 1:
return by_pure_score[max_pure_score][0]
by_gold = defaultdict(list)
for player in by_pure_score[max_pure_score]:
by_gold[player.gold].append(player)
max_gold = max(by_gold.keys())
return by_gold[max_gold][0]
def play_some_games(num_games):
try:
game = Game(Deck(standard_chars()), Deck(simple_districts()))
game_controller = GameController(game)
bot_factory = {'R': RandomBotController, 'N': NaiveBotController}
for i, b in enumerate(bots_spec):
bot = game.add_player('Bot{}'.format(i + 1))
game_controller.set_player_controller(bot, bot_factory[b]())
scores = []
winners = []
for _ in range(num_games):
while not game_controller.game_over:
game_controller.play()
scores.append(
[rules.score(player, game) for player in game.players])
winners.append(game_controller.winner.player_id)
game_controller.end_game()
return scores, winners
except KeyboardInterrupt:
return None
def test_winner_with_most_score_without_bonuses_if_tie(game):
# arrange
player1 = game.add_player('Player1', city=[District.Watchtower] * 8)
player2 = game.add_player(
'Player2',
city=[District.Palace, District.Cathedral, District.TradingPost])
game_controller = GameController(game)
game.turn.first_completer = player1
assert rules.score(player1, game) == 12
assert rules.score(player2, game) == 12
# act
winner = game_controller.winner
# assert
assert winner == player2
def test_score_is_cost_of_the_city(game):
# arrange
player = game.add_player('Player',
city=[District.Watchtower, District.Palace])
# act
score = rules.score(player, game)
# assert
assert score == 1 + 5
def test_bonus_for_completing_city(game):
# arrange
player = game.add_player('Player', city=[District.Watchtower] * 8)
# act
score = rules.score(player, game)
# assert
bonus = 2
assert score == 8 + bonus
def test_winner_with_most_gold_if_double_tie(game):
# arrange
player1 = game.add_player('Player1', city=[District.Watchtower] * 8)
player2 = game.add_player('Player2', city=[District.Tavern] * 8)
player1.cash_in(9)
player2.cash_in(10)
game_controller = GameController(game)
assert rules.score(player1, game) == 10
assert rules.score(player1, game, with_bonuses=False) == 8
assert rules.score(player2, game) == 10
assert rules.score(player2, game, with_bonuses=False) == 8
# act
winner = game_controller.winner
# assert
assert winner == player2
def test_bonus_for_all_colors(game):
# arrange
player = game.add_player('Player',
city=[
District.Watchtower, District.Tavern,
District.Temple, District.Manor
])
# act
score = rules.score(player, game)
# assert
bonus = 3
assert score == 1 + 1 + 1 + 3 + bonus
def examine(my_player, game):
unusable_chars = [
help_str(char) for char in game.turn.unused_chars if char
]
if unusable_chars:
print('Unusable chars: {}'.format(', '.join(unusable_chars)))
print('There are {} districts in the deck'.format(len(game.districts)))
for player in game.players:
if player == game.crowned_player:
if COLORING:
king = f'{Fore.LIGHTYELLOW_EX}{Style.BRIGHT}*{Style.RESET_ALL} '
else:
king = '* '
else:
king = ' '
values = {
'king': king,
'plr': help_str(player.name),
'gold': help_str(player.gold),
'city': ', '.join(help_str(d) for d in player.city),
'city_size': len(player.city)
}
is_me = player.player_id == my_player.player_id
values['hand'] = ', '.join(
help_str(d) if is_me else '?' for d in my_player.hand)
known_char = is_me and player.char
if not known_char:
if bool(player.char):
player_ids = [
p.player_id for p in game.players.order_by_take_turn()
]
player_index = player_ids.index(player.player_id)
my_player_index = player_ids.index(my_player.player_id)
known_char = player_index < my_player_index
values['char'] = ' ({})'.format(help_str(
player.char)) if known_char else ''
values['score'] = rules.score(player, game, with_bonuses=True)
print(
'{king}[{score}] {plr}{char} with {gold} gold | hand=[{hand}] | city({city_size})=[{city}]'
.format(**values))
def main():
parser = ArgumentParser()
parser.add_argument('--name', type=str, default='')
parser.add_argument('--bots', type=str, default='NRR')
parser.add_argument('--no-color', action='store_true', default=False)
args = parser.parse_args()
global COLORING
COLORING = not args.no_color
if COLORING:
init_colorama()
bots = args.bots
name = args.name
if not name:
name = io.dialog('Enter your name', lambda n: n.strip() != '')
game = Game(Deck(standard_chars()), Deck(simple_districts()))
game_controller = GameController(game)
assert 1 <= len(bots) <= 3
assert all(b in 'NR' for b in bots)
player = game.add_player(name)
game_controller.set_player_controller(player, TermPlayerController())
game_controller.add_listener(TermGamePlayListener(player, game))
bot_factory = {'R': RandomBotController, 'N': NaiveBotController}
for i, b in enumerate(bots):
bot = game.add_player('bot{}'.format(i + 1))
game_controller.set_player_controller(bot, bot_factory[b]())
while not game_controller.game_over:
game_controller.play()
print('\n----------------------\nGame over!\n')
for player in game.players:
print('{plr} scored {score}'.format(plr=player.name,
score=rules.score(player, game)))
print('Winner is {plr}'.format(plr=game_controller.winner.name))
