def main():
decks = cards.Deck()
player.create_players()
"""
print(player.Player.List)
for player_number in player.Player.List:
print(player_number.player_number)
"""
player.create_teams()
cards.create_hands()
gl.calling_round()
gl.play_round()
"""
print(player.Team.List)
for team in player.Team.List:
for person in team.players:
print()
print(person.player_number)
for card in person.hand.cards:
print(card.name)
print()
for card in decks.Cards:
print(card.name)
print()
print(len(decks.Cards))
"""
quit()
def test_create_players() -> None:
new_players = create_players(0, 0, [1, 2, 3, 4])
assert len(new_players) == 4
for i in range(0, len(new_players)):
assert isinstance(new_players[i], SmartPlayer) is True
new_players2 = create_players(1, 1, [1, 2])
assert len(new_players2) == 4
for i in range(0, len(new_players)):
if i <= 0:
assert isinstance(new_players2[i], HumanPlayer) is True
if 0 < i <= 1:
assert isinstance(new_players2[i], RandomPlayer) is True
if i > 1:
assert isinstance(new_players2[i], SmartPlayer) is True
def test_create_players_difficulty(self) -> None:
players = create_players(1, 0, [3, 6, 300])
s_player1 = players[1]
s_player2 = players[2]
s_player3 = players[3]
assert s_player1.difficulty == 3
assert s_player2.difficulty == 6
assert s_player3.difficulty == 300
def test_create_players_01() -> None:
players = create_players(1, 1, [2, 4])
assert len(players) == 4
assert players[0].id == 0
assert players[1].id == 1
assert type(players[0]) == HumanPlayer
assert type(players[1]) == RandomPlayer
assert type(players[2]) == SmartPlayer
assert type(players[3]) == SmartPlayer
assert players[3]._diff == 4
def test_create_players() -> None:
""" Test the create_players function. """
players = create_players(1, 1, [1, 3])
assert isinstance(players[0], HumanPlayer)
assert isinstance(players[1], RandomPlayer)
assert isinstance(players[2], SmartPlayer)
assert players[2]._difficulty == 1
assert isinstance(players[3], SmartPlayer)
assert players[3]._difficulty == 3
for player in range(1, len(players)):
assert players[player - 1].id < players[player].id
players2 = create_players(1, 0, [])
assert isinstance(players2[0], HumanPlayer)
assert players2[0].id == 0
players3 = create_players(0, 1, [])
assert isinstance(players3[0], RandomPlayer)
assert players3[0].id == 0
players4 = create_players(0, 0, [1])
assert isinstance(players4[0], SmartPlayer)
assert players4[0].id == 0
assert players4[0]._difficulty == 1
players5 = create_players(0, 0, [])
assert not players5
def test_create_players_(self) -> None:
h = random.randint(0, 2)
r = random.randint(0, 2)
diffs = []
for i in range(random.randint(0, 2)):
diffs.append(random.randint(1, 50))
players = create_players(h, r, diffs)
assert len(players) == h + r + len(diffs)
c = 0
for i in players[h + r:]:
assert i._difficulty == diffs[c]
c += 1
def player_playground():
from player import RandomPlayer, SmartPlayer, create_players, _get_block
b = block_three_level1()
found = _get_block(b, (0, 0), 0)
print(block_graph(found))
found = _get_block(b, (0, 0), 1)
print(block_graph(found))
players = create_players(1, 1, [10])
print(players)
def run_casino(self):
for i in range(random.randint(100, 1000)):
tokick = []
for i in range(random.randint(0, 4)):
self.player_enter(create_players())
for player in self.players_inside:
self.player_activity(player)
if player.lgs < 20:
tokick.append(player)
for player in tokick:
self.player_exit(player)
print(self.safe)
def __init__(self, max_depth: int, num_human: int, num_random: int,
smart_players: List[int]) -> None:
"""Initialize this game, as described in the Assignment 2 handout.
Precondition:
2 <= max_depth <= 5
"""
board = generate_board(max_depth, BOARD_SIZE)
players = create_players(num_human, num_random, smart_players)
self._renderer = Renderer(BOARD_SIZE)
self._data = GameData(board, players)
self._state = MainState(self._data)
def test_create_players() -> None:
"""Test create_players.
- test order is correct
- test numbers align
- all their ids are unique and in order
- unique goals (representation invariants?)
"""
players = create_players(2, 1, [3])
assert len(players) == 4
assert isinstance(players[0], HumanPlayer) and players[0].id == 0
assert isinstance(players[1], HumanPlayer) and players[1].id == 1
assert isinstance(players[2], RandomPlayer) and players[2].id == 2
assert isinstance(players[3], SmartPlayer) and players[3].id == 3
assert players[3]._difficulty == 3
def test_create_players(self):
"""test the create_players function"""
labels = ['Bob', 'Susie', 'Katie', 'Graham']
players = create_players(labels)
self.assertEqual(len(labels), len(players))
found_bob = False
for player in players:
self.assertEqual(player.__class__, Player)
self.assertEqual(player, player)
self.assertEqual(player, Player(player.label))
self.assertEqual(player.label, str(player))
if player.label == 'Bob':
found_bob = True
self.assert_(found_bob)
self.assertNotEqual(players[0], players[2])
def test_create_players_nums(self) -> None:
players = create_players(0, 2, [3, 6])
h_count = 0
r_count = 0
s_count = 0
for player in players:
if type(player) == HumanPlayer:
h_count += 1
if type(player) == RandomPlayer:
r_count += 1
if type(player) == SmartPlayer:
s_count += 1
assert h_count == 0
assert r_count == 2
assert s_count == 2
def test_create_players() -> None:
players = create_players(1, 2, [2])
exp = [1, 2, 1]
result = [0, 0, 0]
for player in players:
if isinstance(player, HumanPlayer):
result[0] += 1
elif isinstance(player, RandomPlayer):
result[1] += 1
elif isinstance(player, SmartPlayer):
result[2] += 1
result_id = []
exp_id = [i for i in range(4)]
for player in players:
result_id.append(player.id)
assert exp == result
assert exp_id == result_id
def play(ctx, ntimes, player, sequence, shape):
verbose = ctx.obj['VERBOSE']
# Cria o jogo
game = create_game(shape, verbose)
# Cria os jogadores
game.players = create_players(game, player, sequence, verbose)
# Realiza N partidas
game.play(ntimes)
# Cria um histogram e um arquiv opdf com a estatisitica de todos os jogos
game.show_statistic()
# Finaliza o jogo
game.deinit()
def test_create_players_02() -> None:
players = create_players(1, 1, [2, 4])
for player in players:
assert type(player.goal) == PerimeterGoal or \
type(player.goal) == BlobGoal
def test_create_players_id(self) -> None:
players = create_players(2, 1, [3])
for i in range(len(players)):
assert players[i].id == i
from player import create_players
from casino import Casino
lasgavares = Casino()
lasgavares.invest(500000)
for i in range(100):
lasgavares.buy_slot_machine()
for i in range(10):
lasgavares.player_enter(create_players())
lasgavares.run_casino()
print(lasgavares.safe, len(lasgavares.players_inside))
def test_create_players() -> None:
lst = create_players(1, 1, [3, 1])
assert len(lst) == 4
assert isinstance(lst[0], HumanPlayer)
assert isinstance(lst[1], RandomPlayer)
assert isinstance(lst[2], SmartPlayer)
