class TestLottoGame:
def test_human_winner(self, game):
for player in players:
if isinstance(player, Human):
break
player.card = game.nrg.numbers[74:] + [game.nrg.number] + [0] * 11
player.card_game = player.card.copy()
with mock.patch('builtins.input', return_value="y"):
game_process(game)
assert player == game.winner
def test_first_player_winner(self, game):
player = game.players[0]
player.card = [0] * 27
player.card_game = player.card.copy()
game_process(game)
assert player == game.winner
def test_one_player_winner(self, game):
game.players = [Bot()]
game_process(game)
assert isinstance(game.winner, Bot)
@pytest.mark.parametrize("game, players, game_players", [
pytest.param(Game(), ("Alex bot", "Pavlik human", "Botik bot"),
(Bot('Alex'), Human('Pavlik'), Bot('Botik')),
id="add bot - human - bot"),
pytest.param(Game(), ("First bot", "Second BOT", "Noname bOT"),
(Bot('First'), Bot('Second'), Bot('Noname')),
id="add bot with different name"),
pytest.param(Game(),
("Alex", "Pavlik human", "nam h", "Alex bot b b", "1 2 "),
(Human('Pavlik'), Bot('Alex')),
id="only 2 players added")
])
def test_add_players(self, game, players, game_players):
side_effect = []
for player in players:
side_effect.append('y')
side_effect.append(player)
else:
side_effect.append('n')
with mock.patch('builtins.input', side_effect=side_effect):
add_players(game)
assert len(game_players) == len(game.players)
for player, game_player in zip(game_players, game.players):
assert isinstance(player, game_player.__class__)
assert str(player) == str(game_player)
def test():
const.DEBUG = True
ai1 = Human('P1')
ai2 = Human('P2')
player_pair = (ai1, ai2)
game = Game(player_pair)
f = open('fail.txt')
lf = [l.strip() for l in f]
last = lf[-1]
seq = map(lambda s: s.strip('()').split(', '), last.split('),('))
mv_list = list(map(lambda t: Move(t[0].strip("'"), int(t[1]), int(t[2])), seq))
game.drawScreen()
for mv in mv_list:
game.update(mv)
game.drawScreen()
print(game.checkWin())
def welcome() -> str:
"""Get game type and player name (if human is playing)."""
os.system('clear')
print(BANNER)
game_type = input('(P)lay or (S)im? ').upper()
if game_type == 'P':
p1_name = input('Player Name: ')
player1 = Human(p1_name)
else:
player1 = CPU('cpu_p1')
player2 = CPU('cpu_p2', level=3)
play(player1, player2)
for action in range(9):
if not self.env.is_illegal(action):
actions.append(action)
ob = self.make_ob(state, action)
value = self.value(ob)
values.append(value)
if not state[-1]: # if O player, try to minimize expected reward
values = [-1 * value for value in values]
values = np.array(values)
action = np.argmax(values)
n = len(values)
probs = np.zeros(values.shape)
probs[...] = self.epsilon / n
probs[action] = 1 - self.epsilon + (self.epsilon / n)
return np.random.choice(actions, p=probs)
if __name__ == "__main__":
from game import Tic_Tac_Toe, Human
env = Tic_Tac_Toe()
agent = Sarsa(env,
learning_rate=0.0001,
epsilon=0.3,
n_hidden1=100,
n_hidden2=20)
agent.learn(2000)
while True:
env.episode(agent, Human(), display=True)
self.all_actions: all_actions,
self.all_advs: all_advs
})
eprews = np.array([traj["rewards"].sum()
for traj in trajs]) # episode total rewards
eplens = np.array([len(traj["rewards"])
for traj in trajs]) # episode lengths
# Print stats
#"""
print("-----------------")
print("Iteration: \t %i" % iteration)
print("NumTrajs: \t %i" % len(eprews))
print("NumTimesteps: \t %i" % np.sum(eplens))
print("MaxRew: \t %s" % eprews.max())
print("MeanRew: \t %s +- %s" %
(eprews.mean(), eprews.std() / np.sqrt(len(eprews))))
print("MeanLen: \t %s +- %s" %
(eplens.mean(), eplens.std() / np.sqrt(len(eplens))))
print("-----------------") #"""""
env.episode(self, self, display=False)
from game import Tic_Tac_Toe, Human, Random
env = Tic_Tac_Toe()
agent = TTT_Agent(env)
agent.learn(env, player1=agent, player2=Random(env))
while True:
env.episode(Human(), agent, display=True)
from game import Bot, Game, Human, NRG, Player
from lotto import add_players, game_process
import mock
import pytest
players = [Bot('Botik'), Human('Pavlik'), Bot('Bot'), Bot()]
@pytest.fixture()
def game():
game = Game()
for player in players:
game.add_player(player)
return game
class Gamer(Player):
"""Class for testing class Player"""
class TestGamePlayers:
def test_game_players(self, game):
assert players == game.players
def test_game_len_players(self, game):
assert len(players) == len(game.players)
while not winner and game.nrg.numbers:
for player in game.players.copy():
if not game.winner:
if isinstance(player, Human):
choice = player_choice(player.name)
game.one_cycle(player, choice=choice)
print(f"{player.name:*^30}")
card = card_formater(player)
print_card(card)
else:
winner = game.winner
break
print(f"Number was - {game.nrg.number}")
game.nrg.number = game.nrg.numbers.pop()
else:
winner = game.players[0]
print(f"{winner} you win")
if __name__ == '__main__':
game = Game()
add_players(game)
if not game.players:
game.add_player(Bot())
game.add_player(Human())
game_process(game)