def game():
deck1, deck2 = build_decks()
hero_1 = Hero(name='Pamisio',
cost=0,
abilities=dict(),
attack=0,
health=20,
hero_class=None)
hero_2 = Hero(name='Pamewcia',
cost=0,
abilities=dict(),
attack=0,
health=20,
hero_class=None)
first_player = Player(hero_1, [], deck1, [], [])
second_player = Player(hero_2, [], deck2, [], [])
state = State(first_player, second_player)
for i in range(2):
state.draw_card()
state.switch_players()
for i in range(3):
state.draw_card()
state.switch_players()
for mana in range(1, 10):
state.draw_card()
print("Player {}".format(1))
print("Hand: {}".format([(minion.name, minion.cost)
for minion in state.current_player.hand]))
for card in state.current_player.board:
card.summoning_sickness = False
state = get_new_state(state, mana, evaluation_utils.offensive_strategy)
print("Player 1 health = {} \nPlayer 2 health = {}".format(
state.current_player.hero.health,
state.opposite_player.hero.health))
state.switch_players()
state.draw_card()
print("\nPlayer {}".format(2))
print("Hand: {}".format([(minion.name, minion.cost)
for minion in state.current_player.hand]))
for card in state.current_player.board:
card.summoning_sickness = False
state = get_new_state(state, mana, evaluation_utils.offensive_strategy)
print("Player 1 health = {} \nPlayer 2 health = {}".format(
state.current_player.hero.health,
state.opposite_player.hero.health))
state.switch_players()
print("\n----------------\n")
if state.is_terminal:
break
def play_start_agent_offensive_vs_mcts():
deck1, deck2 = build_decks()
hero_1 = Hero(name='Agent',
cost=0,
abilities=dict(),
attack=0,
health=20,
hero_class=None)
hero_2 = Hero(name='MCTS',
cost=0,
abilities=dict(),
attack=0,
health=20,
hero_class=None)
first_player = Player(hero_1, [], deck1, [], [])
second_player = Player(hero_2, [], deck2, [], [])
state = State(first_player, second_player)
state.draw_card()
state.draw_card()
state.switch_players()
state.draw_card()
state.draw_card()
state.draw_card()
turns = 1
root_wins = []
root_loses = []
best_child_wins = []
best_child_losses = []
visited_nodes = []
while not state.is_terminal:
state.new_turn_for_one_player()
# state, path = get_random_state(state)
state, path = get_new_state(state, evaluation_utils.offensive_strategy)
#print("\n\nAction taken by {}: {}\n\n".format(state.current_player.name, path))
#print_state(state.get_player_by_name(hero_1.name), state.get_player_by_name(hero_2.name))
if state.is_terminal:
break
start_node = get_node_from_state(state)
best_child = perform_mcts(start_node)
state, path = best_child['state'], best_child['path']
root_wins.append(start_node['wins'])
root_loses.append(start_node['losses'])
best_child_wins.append(best_child['wins'])
best_child_losses.append(best_child['losses'])
visited_nodes.append(start_node['wins'] + start_node['losses'])
#print("\n\nAction taken by {}: {}\n\n".format(state.current_player.name, path))
#print_state(state.get_player_by_name(hero_1.name), state.get_player_by_name(hero_2.name))
turns += 1
visited_nodes.append(start_node['wins'] + start_node['losses'])
mcts_win = 1 if state.get_player_by_name('Agent').health == 0 else 0
#print_state(state.get_player_by_name(hero_1.name), state.get_player_by_name(hero_2.name))
return turns, root_wins, root_loses, best_child_wins, best_child_losses, visited_nodes, mcts_win
class TestActions(unittest.TestCase):
def setUp(self):
with open(CARDS_FILE) as json_file:
data = json.load(json_file)
self.abusive_sergeant = card_from_json(data[0])
self.agent_squire = card_from_json(data[1])
self.divine_strength = card_from_json(data[2])
self.selfless_hero = card_from_json(data[3])
self.divine_favor = card_from_json(data[4])
self.seal_of_champions = card_from_json(data[5])
self.steward_of_darshire = card_from_json(data[6])
self.wolfrider = card_from_json(data[7])
self.blessing_of_kings = card_from_json(data[8])
self.defender_of_argus = card_from_json(data[9])
self.hero_1 = Hero(name='Pamisio', cost=0, abilities=dict(), attack=0, health=20, hero_class=None)
self.hero_2 = Hero(name='Pamewcia', cost=0, abilities=dict(), attack=0, health=20, hero_class=None)
self.first_player = Player(self.hero_1, [], [], [], [])
self.second_player = Player(self.hero_2, [], [], [], [])
self.state = State(self.first_player, self.second_player)
def test_how_many_combinations_of_playing_cards(self):
self.state.current_player.hand = [self.abusive_sergeant, self.agent_squire, self.divine_strength,
self.divine_favor]
player_hand = self.state.current_player.hand
indexes = np.arange(len(player_hand))
self.assertEqual(len(list(get_cards_play_combinations(player_hand, indexes, 0))), 1)
self.assertEqual(len(list(get_cards_play_combinations(player_hand, indexes, 1))), 4)
self.assertEqual(len(list(get_cards_play_combinations(player_hand, indexes, 2))), 7)
self.assertEqual(len(list(get_cards_play_combinations(player_hand, indexes, 3))), 9)
def test_cards_to_play_with_combination(self):
self.state.current_player.hand = [self.abusive_sergeant, self.agent_squire, self.selfless_hero]
self.state.play_cards([self.state.current_player.hand[i] for i in [0, 2]])
self.assertAlmostEqual(self.state.current_player.board, [self.abusive_sergeant, self.selfless_hero])
def test_cards_to_play(self):
self.state.current_player.hand = [self.abusive_sergeant, self.agent_squire, self.selfless_hero]
combinations = list(get_cards_to_play(self.state.current_player.hand, 1))
self.assertEqual(combinations[0], [])
self.assertEqual(combinations[1], [self.abusive_sergeant])
self.assertEqual(combinations[2], [self.agent_squire])
self.assertEqual(combinations[3], [self.selfless_hero])
self.state.play_cards([self.abusive_sergeant])
self.assertEqual(self.state.current_player.hand, [self.agent_squire, self.selfless_hero])
self.assertEqual(self.state.current_player.board, [self.abusive_sergeant])
def test_ewcia(self):
self.state.current_player.hand = [self.abusive_sergeant, self.agent_squire, self.selfless_hero]
self.state.current_player.board = [deepcopy(self.abusive_sergeant), deepcopy(self.selfless_hero)]
for card in self.state.current_player.board:
card.summoning_sickness = False
self.state.opposite_player.board = [deepcopy(self.selfless_hero), deepcopy(self.abusive_sergeant)]
self.state = get_new_state(self.state, 3, evaluation_utils.random_strategy)
print(str(self.state.opposite_player.hero.health))
self.state.switch_players()
print(str(self.state.current_player.hero.health))
print(str(self.state.opposite_player.hero.health))
def test_random_moves(self):
self.state.current_player.hand = [self.abusive_sergeant, self.agent_squire,
self.selfless_hero, self.divine_strength]
self.state.current_player.board = [deepcopy(self.abusive_sergeant), deepcopy(self.selfless_hero),
deepcopy(self.steward_of_darshire)]
for card in self.state.current_player.board:
card.summoning_sickness = False
self.state.opposite_player.hand = [deepcopy(self.abusive_sergeant), deepcopy(self.agent_squire),
deepcopy(self.selfless_hero), deepcopy(self.divine_strength)]
self.state.opposite_player.board = [deepcopy(self.abusive_sergeant), deepcopy(self.selfless_hero),
deepcopy(self.steward_of_darshire)]
self.state.current_player.mana = 1
np.random.seed(0)
s, p = get_random_state(self.state)
print(p)
def test_mtcs(self):
deck1 = [deepcopy(self.selfless_hero),
deepcopy(self.divine_favor),
deepcopy(self.abusive_sergeant),
deepcopy(self.agent_squire),
deepcopy(self.seal_of_champions),
deepcopy(self.steward_of_darshire),
deepcopy(self.blessing_of_kings),
deepcopy(self.divine_strength),
deepcopy(self.wolfrider),
deepcopy(self.defender_of_argus)]
deck2 = [deepcopy(self.abusive_sergeant),
deepcopy(self.defender_of_argus),
deepcopy(self.divine_favor),
deepcopy(self.seal_of_champions),
deepcopy(self.agent_squire),
deepcopy(self.divine_strength),
deepcopy(self.selfless_hero),
deepcopy(self.blessing_of_kings),
deepcopy(self.wolfrider),
deepcopy(self.steward_of_darshire)]
deck1 = deck1[::-1]
deck2 = deck2[::-1]
self.first_player.deck = deck1
self.second_player.deck = deck2
self.state.draw_card()
self.state.draw_card()
self.state.switch_players()
self.state.draw_card()
self.state.draw_card()
self.state.draw_card()
self.state.switch_players()
self.assertEqual(len(self.state.current_player.hand), 2)
self.assertEqual(len(self.state.current_player.board), 0)
self.assertEqual(len(self.state.current_player.graveyard), 0)
self.assertEqual(len(self.state.opposite_player.hand), 3)
self.assertEqual(len(self.state.opposite_player.board), 0)
self.assertEqual(len(self.state.opposite_player.graveyard), 0)
root = {'wins': 0,
'losses': 0,
'state': self.state,
'children': [],
'path': '',
'parent': None}
import graphviz as gv
graph = gv.Graph(format='svg')
graph.node(name=str(0), label="{} / {}".format(root['wins'], root['wins'] + root['losses']), color=get_color(color))
graph.render(filename='graph_{}'.format(0))
for k in range(1, 200):
selected = select_node(None, root)
win = sim(selected)
back_propagation(selected, win)
print("Win = {}".format(win))
i = 0
graph = gv.Graph(format='svg')
graph.node(name=str(i), label="{} / {}".format(root['wins'], root['wins'] + root['losses']), color=get_color(color))
# graph.render(filename='graph_{}'.format(k))
for child in root['children']:
if child['wins'] + child['losses'] > 0:
preorder(node=child, graph=graph, parent_name=i, parent_color=color)
graph.render(filename='graph')
def test_gui(self):
self.state.current_player.hand = [self.abusive_sergeant, self.agent_squire,
self.selfless_hero, self.divine_strength]
self.state.current_player.board = [deepcopy(self.abusive_sergeant), deepcopy(self.selfless_hero),
deepcopy(self.steward_of_darshire)]
from beautifultable import BeautifulTable
table = BeautifulTable()
for card in self.state.current_player.hand:
table.append_column(card.name, ['Cost = {}'.format(card.cost), get_static_abi(card), get_desc(card)])
print(table)
print('\n')
table = BeautifulTable()
for card in self.state.current_player.board:
table.append_column(card.name, [get_static_abi(card), get_desc(card)])
print(table)