示例#1
0
    def setUp(self):
        self.ability_1 = {'deal_damage_to_opponent': partial(abilities.deal_damage_to_opposite_player, damage=2)}
        self.ability_2 = {DIVINE_SHIELD: abilities.divine_shield}
        self.ability_charge = {CHARGE: abilities.charge}

        self.card_1 = Minion(name='C1', cost=1, abilities=dict(), attack=1, health=1, minion_type=None)
        self.card_2 = Minion(name='C2', cost=1, abilities=dict(), attack=1, health=1, minion_type=None)

        self.card_3 = Minion(name='C3', cost=1, abilities=dict(), attack=2, health=2, minion_type=None)
        self.card_4 = Minion(name='C4', cost=1, abilities=dict(), attack=2, health=2, minion_type=None)

        self.card_5 = Minion(name='C5', cost=1, abilities=dict(), attack=3, health=3, minion_type=None)
        self.card_6 = Minion(name='C6', cost=1, abilities=dict(), attack=3, health=3, minion_type=None)

        self.card_7 = Minion(name='C7', cost=1, abilities=dict(), attack=4, health=4, minion_type=None)
        self.card_8 = Minion(name='C8', cost=1, abilities=dict(), attack=4, health=4, minion_type=None)

        self.spell_1 = Spell(name='PaSpell', cost=1, abilities={**self.ability_1, **self.ability_2})

        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 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)
示例#3
0
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
示例#4
0
def start_mcts_vs_passive():
    deck1, deck2 = build_decks()
    hero_1 = Hero(name='MCTS',
                  cost=0,
                  abilities=dict(),
                  attack=0,
                  health=20,
                  hero_class=None)
    hero_2 = Hero(name='Agent',
                  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.switch_players()
        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))
        if state.is_terminal:
            break

        state.new_turn_for_one_player()
        state, path = get_new_state(state, evaluation_utils.passive_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))

        turns += 1

    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
示例#5
0
class TestCards(unittest.TestCase):
    def setUp(self):
        self.ability_1 = {'deal_damage_to_opponent': partial(abilities.deal_damage_to_opposite_player, damage=2)}
        self.ability_2 = {DIVINE_SHIELD: abilities.divine_shield}
        self.ability_charge = {CHARGE: abilities.charge}

        self.card_1 = Minion(name='C1', cost=1, abilities=dict(), attack=1, health=1, minion_type=None)
        self.card_2 = Minion(name='C2', cost=1, abilities=dict(), attack=1, health=1, minion_type=None)

        self.card_3 = Minion(name='C3', cost=1, abilities=dict(), attack=2, health=2, minion_type=None)
        self.card_4 = Minion(name='C4', cost=1, abilities=dict(), attack=2, health=2, minion_type=None)

        self.card_5 = Minion(name='C5', cost=1, abilities=dict(), attack=3, health=3, minion_type=None)
        self.card_6 = Minion(name='C6', cost=1, abilities=dict(), attack=3, health=3, minion_type=None)

        self.card_7 = Minion(name='C7', cost=1, abilities=dict(), attack=4, health=4, minion_type=None)
        self.card_8 = Minion(name='C8', cost=1, abilities=dict(), attack=4, health=4, minion_type=None)

        self.spell_1 = Spell(name='PaSpell', cost=1, abilities={**self.ability_1, **self.ability_2})

        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_play_spell(self):
        self.first_player.hand = [self.card_1, self.spell_1]
        self.first_player.board = [self.card_3]

        self.state.play_card(1)

        self.assertEqual(self.first_player.hand, [self.card_1])
        self.assertEqual(self.first_player.board, [self.card_3])
        self.assertEqual(self.first_player.graveyard, [self.spell_1])
        self.assertEqual(self.second_player.hero.health, 18)

    def test_attack_minion_by_minion_1(self):
        self.first_player.board = [self.card_1, self.card_3]
        self.second_player.board = [self.card_2, self.card_4]

        self.state.attack(0, 1)
        self.assertEqual(self.first_player.graveyard, [self.card_1])
        self.assertEqual(self.first_player.board, [self.card_3])
        self.assertEqual(self.second_player.board, [self.card_2, self.card_4])
        self.assertEqual(self.second_player.board[1].health, 1)

    def test_attack_minion_by_minion_2(self):
        self.first_player.board = [self.card_1, self.card_3]
        self.second_player.board = [self.card_2, self.card_4]

        self.state.attack(1, 0)
        self.assertEqual(self.first_player.board, [self.card_1, self.card_3])
        self.assertEqual(self.second_player.board, [self.card_4])
        self.assertEqual(self.second_player.graveyard, [self.card_2])
        self.assertEqual(self.first_player.board[1].health, 1)

    def test_summoning_sickness_is_true_when_minion_is_played(self):
        self.state.current_player.hand = [self.card_1]
        self.state.play_card(0)

        self.assertTrue(self.card_1.summoning_sickness)

    def test_summoning_sickness_when_minion_with_charge_is_played(self):
        self.card_1.abilities[CHARGE] = partial(abilities.charge, minion=self.card_1)
        self.state.current_player.hand = [self.card_1]
        self.state.play_card(0)
        self.assertFalse(self.card_1.summoning_sickness)

    def test_divine_shield_reduce_damage_to_zero_and_disappear(self):
        self.card_1.abilities[DIVINE_SHIELD] = abilities.divine_shield
        self.state.current_player.board = [self.card_2]
        self.state.opposite_player.board = [self.card_1]

        self.state.attack(0, 0)

        self.assertTrue(DIVINE_SHIELD not in self.card_1.abilities)
        self.assertEqual(self.card_2.health, 0)
        self.assertEqual(self.state.current_player.board, [])
        self.assertEqual(self.state.current_player.graveyard, [self.card_2])
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)
class TestDeck(unittest.TestCase):
    def setUp(self):
        with open('../HearthstoneAI/cards.json') 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_abusive_sergeant(self):
        """
        Give a minion +2_Attack this turn.
        :return:
        """
        self.assertEqual(self.abusive_sergeant.attack, 1)
        self.assertEqual(self.abusive_sergeant.health, 1)
        self.assertEqual(self.abusive_sergeant.cost, 1)

        self.first_player.hand = [self.abusive_sergeant]
        self.first_player.board = [self.agent_squire]

        self.state.play_card(0)
        self.assertEqual(self.state.current_player.hand, [])
        self.assertEqual(self.state.current_player.board, [self.agent_squire, self.abusive_sergeant])
        self.assertEqual(self.agent_squire.attack, 3)

        self.state.compensate_abilities()
        self.assertEqual(self.agent_squire.attack, 1)
        self.state.compensate_abilities()
        self.assertEqual(self.agent_squire.attack, 1)

    def test_agent_squire(self):
        """
        Divine Shield
        :return:
        """
        self.abusive_sergeant.health = 5

        self.assertEqual(self.agent_squire.attack, 1)
        self.assertEqual(self.agent_squire.health, 1)
        self.assertEqual(self.agent_squire.cost, 1)

        self.first_player.board = [self.abusive_sergeant]
        self.second_player.board = [self.agent_squire]

        self.state.attack(0, 0)
        self.assertEqual(self.abusive_sergeant.health, 4)
        self.assertEqual(self.agent_squire.health, 1)

        self.state.disable_sickness()
        self.state.attack(0, 0)
        self.assertEqual(self.abusive_sergeant.health, 3)
        self.assertEqual(self.agent_squire.health, 0)
        self.assertEqual(self.state.opposite_player.graveyard, [self.agent_squire])

    def test_divine_strength(self):
        """
        Give a minion +1/+2.
        :return:
        """
        self.first_player.hand = [self.divine_strength]
        self.first_player.board = [self.abusive_sergeant]
        self.state.play_card(0)

        self.assertEqual(self.abusive_sergeant.attack, 2)
        self.assertEqual(self.abusive_sergeant.health, 3)
        self.assertEqual(self.abusive_sergeant.cost, 1)
        self.assertEqual(self.state.current_player.graveyard, [self.divine_strength])
        self.state.compensate_abilities()
        self.assertEqual(self.abusive_sergeant.attack, 2)
        self.assertEqual(self.abusive_sergeant.health, 3)

    def test_selfless_hero(self):
        """
        Deathrattle: Give a random friendly minion Divine Shield.
        :return:
        """
        self.first_player.board = [self.abusive_sergeant]
        self.second_player.board = [self.selfless_hero]
        self.state.attack(0, 0)

        #TODO Fails because there is no minion that can receive a divine shield. Except to pass.

    def test_divine_favor(self):
        """
        Draw cards until you have as many in hand as your opponent.
        :return:
        """
        self.first_player.hand = [self.divine_favor]
        self.first_player.deck = [self.divine_strength, self.seal_of_champions]
        self.second_player.hand = [self.abusive_sergeant, self.agent_squire]

        self.state.play_card(0)
        self.assertEqual(len(self.first_player.hand), len(self.second_player.hand))
        self.assertEqual(self.first_player.graveyard, [self.divine_favor])

    def test_seal_of_champions(self):
        """
        Give a minion +3 Attack and Divine Shield.
        :return:
        """
        self.selfless_hero.health = 10

        self.first_player.hand = [self.seal_of_champions]
        self.first_player.board = [self.abusive_sergeant]
        self.second_player.board = [self.selfless_hero]

        self.state.play_card(0)
        self.assertEqual(self.abusive_sergeant.attack, 4)
        self.state.switch_players()

        self.state.attack(0, 0)
        self.assertEqual(self.abusive_sergeant.health, 1)
        self.assertEqual(self.selfless_hero.health, 6)
        self.state.disable_sickness()

        self.state.attack(0, 0)
        self.assertLessEqual(self.abusive_sergeant.health, 0)
        self.assertEqual(self.selfless_hero.health, 2)
        self.assertEqual(self.first_player.graveyard, [self.seal_of_champions, self.abusive_sergeant])

    def test_steward_of_darshire(self):
        """
        Divine Shield
        :return:
        """
        self.abusive_sergeant.health = 9
        self.abusive_sergeant.attack = 3

        self.first_player.board = [self.abusive_sergeant]
        self.second_player.board = [self.steward_of_darshire]

        self.state.attack(0, 0)
        self.assertEqual(self.abusive_sergeant.health, 6)
        self.assertEqual(self.steward_of_darshire.health, 3)

        self.state.disable_sickness()
        self.state.attack(0, 0)
        self.assertEqual(self.abusive_sergeant.health, 3)
        self.assertEqual(self.steward_of_darshire.health, 0)
        self.assertEqual(self.state.opposite_player.graveyard, [self.steward_of_darshire])

    def test_wolfrider(self):
        """
        Charge.
        :return:
        """
        self.first_player.hand = [self.wolfrider]
        self.state.play_card(0)
        self.assertEqual(self.wolfrider.summoning_sickness, False)

    def test_blessing_of_kings(self):
        """
        Give a minion +4/+4.
        :return:
        """
        self.first_player.hand = [self.blessing_of_kings]
        self.first_player.board = [self.abusive_sergeant]
        self.state.play_card(0)

        self.assertEqual(self.abusive_sergeant.attack, 5)
        self.assertEqual(self.abusive_sergeant.health, 5)
        self.assertEqual(self.abusive_sergeant.cost, 1)
        self.state.compensate_abilities()
        self.assertEqual(self.abusive_sergeant.attack, 5)
        self.assertEqual(self.abusive_sergeant.health, 5)

    def test_defender_of_argus(self):
        """
        Give your two random minions +1/+1 and Taunt.
        :return:
        """
        self.first_player.hand = [self.defender_of_argus]
        self.first_player.board = [self.abusive_sergeant]
        self.state.play_card(0)

        self.assertEqual(self.abusive_sergeant.attack, 2)
        self.assertEqual(self.abusive_sergeant.health, 2)
        self.assertEqual(self.abusive_sergeant.cost, 1)
        self.assertEqual(self.abusive_sergeant.attack, 2)
        self.assertEqual(self.abusive_sergeant.health, 2)