def test_SorcerersApprentice(self):
deck1 = StackedDeck([SorcerersApprentice(), ArcaneMissiles(), SorcerersApprentice(), Frostbolt(), Frostbolt(),
Frostbolt()], CHARACTER_CLASS.MAGE)
deck2 = StackedDeck([StonetuskBoar()], CHARACTER_CLASS.PRIEST)
game = Game([deck1, deck2], [SpellTestingAgent(), DoNothingBot()])
game.pre_game()
game.current_player = game.players[1]
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
self.assertEqual(1, len(game.current_player.minions))
self.assertEqual(3, game.current_player.minions[0].calculate_attack())
self.assertEqual(2, game.current_player.minions[0].health)
self.assertEqual("Sorcerer's Apprentice", game.current_player.minions[0].card.name)
# Arcane missiles should also have been played, since it is now free
self.assertEqual(27, game.other_player.hero.health)
# Make sure the other frostbolts have been properly reduced
self.assertEqual(1, game.current_player.hand[1].mana_cost(game.current_player))
self.assertEqual(1, game.current_player.hand[2].mana_cost(game.current_player))
game.play_single_turn()
game.play_single_turn()
# Both Sorcer's Apprentices are killed by friendly Frostbolts.
self.assertEqual(0, len(game.current_player.minions))
# Make sure that the cards in hand are no longer reduced
self.assertEqual(2, game.current_player.hand[0].mana)
def test_ManaWyrm(self):
deck1 = StackedDeck([ManaWyrm(), IceLance(), ManaWyrm(), IceLance(), IceLance(), IceLance()],
CHARACTER_CLASS.MAGE)
deck2 = StackedDeck([IronbeakOwl()], CHARACTER_CLASS.PALADIN)
game = Game([deck1, deck2], [CardTestingAgent(), OneCardPlayingAgent()])
game.pre_game()
game.current_player = 1
game.play_single_turn()
self.assertEqual(1, len(game.current_player.minions))
self.assertEqual(1, game.current_player.minions[0].calculate_attack())
self.assertEqual(3, game.current_player.minions[0].health)
self.assertEqual(3, game.current_player.minions[0].calculate_max_health())
self.assertEqual("Mana Wyrm", game.current_player.minions[0].card.name)
game.play_single_turn()
game.play_single_turn()
self.assertEqual(2, len(game.current_player.minions))
self.assertEqual(1, game.current_player.minions[0].calculate_attack())
self.assertEqual(3, game.current_player.minions[0].health)
self.assertEqual(3, game.current_player.minions[0].calculate_max_health())
self.assertEqual(2, game.current_player.minions[1].calculate_attack())
self.assertEqual(3, game.current_player.minions[1].health)
self.assertEqual(3, game.current_player.minions[1].calculate_max_health())
game.play_single_turn()
game.play_single_turn()
self.assertEqual(2, len(game.current_player.minions))
self.assertEqual(1, game.current_player.minions[0].calculate_attack())
self.assertEqual(3, game.current_player.minions[0].health)
self.assertEqual(3, game.current_player.minions[0].calculate_max_health())
self.assertEqual(5, game.current_player.minions[1].calculate_attack())
self.assertEqual(3, game.current_player.minions[1].health)
self.assertEqual(3, game.current_player.minions[1].calculate_max_health())
def do_stuff(net):
def play_game():
new_game = game.copy()
new_game.start()
deck1 = load_deck("example.hsdeck")
deck2 = load_deck("example.hsdeck")
game = Game([deck1, deck2], [CustomAgent(net), TradeAgent()])
#print(timeit.timeit(play_game, 'gc.enable()', number=1000))
return game.start()
def test_create_game(self):
card_set1 = []
card_set2 = []
test_env = self
for cardIndex in range(0, 30):
card_set1.append(card_lookup("Stonetusk Boar"))
card_set2.append(card_lookup("Novice Engineer"))
deck1 = Deck(card_set1, CHARACTER_CLASS.DRUID)
deck2 = Deck(card_set2, CHARACTER_CLASS.MAGE)
checked_cards = []
class MockAgent1:
def do_card_check(self, cards):
test_env.assertEqual(len(cards), 3)
checked_cards.append(list(cards))
return [False, True, True]
def set_game(self, game):
pass
class MockAgent2:
def do_card_check(self, cards):
test_env.assertEqual(len(cards), 4)
checked_cards.append(list(cards))
return [False, True, True, False]
def set_game(self, game):
pass
agent1 = mock.Mock(spec=MockAgent1(), wraps=MockAgent1())
agent2 = mock.Mock(spec=MockAgent2(), wraps=MockAgent2())
game = Game([deck1, deck2], [agent1, agent2])
game.pre_game()
self.assertEqual(agent1.method_calls[0][0], "do_card_check",
"Agent not asked to select cards")
self.assertEqual(agent2.method_calls[0][0], "do_card_check",
"Agent not asked to select cards")
self.assertTrue(game.players[0].deck == deck1,
"Deck not assigned to player")
self.assertTrue(game.players[1].deck == deck2,
"Deck not assigned to player")
self.assertTrue(game.players[0].agent == agent1,
"Agent not stored in the hearthbreaker")
self.assertTrue(game.players[1].agent == agent2,
"Agent not stored in the hearthbreaker")
self.assertListEqual(checked_cards[0][1:], game.players[0].hand[:-1],
"Cards not retained after request")
self.assertListEqual(checked_cards[1][1:2], game.players[1].hand[:-4],
"Cards not retained after request")
def test_CircleOfHealing(self):
deck1 = StackedDeck([
CircleOfHealing(),
MogushanWarden(),
CircleOfHealing(),
CircleOfHealing(),
CircleOfHealing(),
CircleOfHealing(),
CircleOfHealing()
], CHARACTER_CLASS.PRIEST)
deck2 = StackedDeck([MogushanWarden()], CHARACTER_CLASS.PALADIN)
game = Game(
[deck1, deck2],
[SpellTestingAgent(), MinionPlayingAgent()])
game.pre_game()
game.current_player = 1
for turn in range(0, 8):
game.play_single_turn()
game.players[0].minions[0].health = 4
game.players[1].minions[0].health = 4
game.play_single_turn() # Circle of Healing should be played
self.assertEqual(game.players[0].minions[0].calculate_max_health(),
game.players[0].minions[0].health)
self.assertEqual(game.players[1].minions[0].calculate_max_health(),
game.players[1].minions[0].health)
def do_stuff():
def play_game():
new_game = game.copy()
new_game.start()
deck1 = load_deck("example.hsdeck")
deck2 = load_deck("example.hsdeck")
game = Game([deck1, deck2], [RandomAgent(), RandomAgent()])
game.start()
print(timeit.timeit(play_game, 'gc.enable()', number=1000))
def do_stuff():
def play_game():
new_game = game.copy()
new_game.start()
deck1 = load_deck("example.hsdeck")
deck2 = load_deck("example.hsdeck")
game = Game([deck1, deck2], [RandomAgent(), RandomAgent()])
game.start()
print(timeit.timeit(play_game, 'gc.enable()', number=1000))
def test_deck_shortening(self):
deck1 = Deck([RagnarosTheFirelord(), RagnarosTheFirelord(), RagnarosTheFirelord(), RagnarosTheFirelord(),
RagnarosTheFirelord(), RagnarosTheFirelord(), RagnarosTheFirelord(), RagnarosTheFirelord(),
RagnarosTheFirelord(), RagnarosTheFirelord(), RagnarosTheFirelord(), RagnarosTheFirelord(),
RagnarosTheFirelord(), RagnarosTheFirelord(), RagnarosTheFirelord(), RagnarosTheFirelord(),
RagnarosTheFirelord(), RagnarosTheFirelord(), RagnarosTheFirelord(), RagnarosTheFirelord(),
RagnarosTheFirelord(), RagnarosTheFirelord(), RagnarosTheFirelord(), RagnarosTheFirelord(),
RagnarosTheFirelord(), RagnarosTheFirelord(), RagnarosTheFirelord(), RagnarosTheFirelord(),
GoldshireFootman(), GoldshireFootman()], CHARACTER_CLASS.DRUID)
deck2 = StackedDeck([StonetuskBoar()], CHARACTER_CLASS.HUNTER)
game = Game([deck1, deck2], [RandomAgent(), RandomAgent()])
replay = record(game)
game.start()
replay.write(StringIO())
def test_SavageRoar(self):
deck1 = StackedDeck([StonetuskBoar(), StonetuskBoar(), SavageRoar()], CHARACTER_CLASS.DRUID)
deck2 = StackedDeck([StonetuskBoar()], CHARACTER_CLASS.MAGE)
game = Game([deck1, deck2], [OneCardPlayingAgent(), OneCardPlayingAgent()])
game.current_player = 1
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
minion_increase_mock = mock.Mock()
game.other_player.minions[0].bind("attack_changed", minion_increase_mock)
game.other_player.minions[1].bind("attack_changed", minion_increase_mock)
player_increase_mock = mock.Mock()
game.other_player.hero.bind("attack_changed", player_increase_mock)
game.play_single_turn()
self.assertEqual(0, game.current_player.mana)
# Make sure the attack got increased
self.assertListEqual([mock.call(2), mock.call(2)], minion_increase_mock.call_args_list)
self.assertListEqual([mock.call(2)], player_increase_mock.call_args_list)
# And make sure that it went down again
self.assertEqual(1, game.current_player.minions[0].calculate_attack())
self.assertEqual(1, game.current_player.minions[1].calculate_attack())
self.assertEqual(0, game.current_player.hero.calculate_attack())
def test_first_turn(self):
card_set1 = []
card_set2 = []
for cardIndex in range(0, 30):
card_set1.append(card_lookup("Stonetusk Boar"))
card_set2.append(card_lookup("Novice Engineer"))
deck1 = Deck(card_set1, CHARACTER_CLASS.DRUID)
deck2 = Deck(card_set2, CHARACTER_CLASS.MAGE)
agent1 = mock.Mock(spec=DoNothingBot(), wraps=DoNothingBot())
agent2 = mock.Mock(spec=DoNothingBot(), wraps=DoNothingBot())
game = Game([deck1, deck2], [agent1, agent2])
game.start()
def serialization_copy(old_game):
game_json = json.dumps(old_game, default=_save_object, indent=2)
d = json.loads(game_json)
game = Game.__from_json__(
d, [player.agent for player in old_game.players])
game._has_turn_ended = old_game._has_turn_ended
return game
def test_first_turn(self):
card_set1 = []
card_set2 = []
for cardIndex in range(0, 30):
card_set1.append(card_lookup("Stonetusk Boar"))
card_set2.append(card_lookup("Novice Engineer"))
deck1 = Deck(card_set1, CHARACTER_CLASS.DRUID)
deck2 = Deck(card_set2, CHARACTER_CLASS.MAGE)
agent1 = mock.Mock(spec=DoNothingBot(), wraps=DoNothingBot())
agent2 = mock.Mock(spec=DoNothingBot(), wraps=DoNothingBot())
game = Game([deck1, deck2], [agent1, agent2])
game.start()
def test_create_game(self):
card_set1 = []
card_set2 = []
test_env = self
for cardIndex in range(0, 30):
card_set1.append(card_lookup("Stonetusk Boar"))
card_set2.append(card_lookup("Novice Engineer"))
deck1 = Deck(card_set1, CHARACTER_CLASS.DRUID)
deck2 = Deck(card_set2, CHARACTER_CLASS.MAGE)
checked_cards = []
class MockAgent1:
def do_card_check(self, cards):
test_env.assertEqual(len(cards), 3)
checked_cards.append(list(cards))
return [False, True, True]
def set_game(self, game):
pass
class MockAgent2:
def do_card_check(self, cards):
test_env.assertEqual(len(cards), 4)
checked_cards.append(list(cards))
return [False, True, True, False]
def set_game(self, game):
pass
agent1 = mock.Mock(spec=MockAgent1(), wraps=MockAgent1())
agent2 = mock.Mock(spec=MockAgent2(), wraps=MockAgent2())
game = Game([deck1, deck2], [agent1, agent2])
game.pre_game()
self.assertEqual(agent1.method_calls[0][0], "do_card_check", "Agent not asked to select cards")
self.assertEqual(agent2.method_calls[0][0], "do_card_check", "Agent not asked to select cards")
self.assertTrue(game.players[0].deck == deck1, "Deck not assigned to player")
self.assertTrue(game.players[1].deck == deck2, "Deck not assigned to player")
self.assertTrue(game.players[0].agent == agent1, "Agent not stored in the hearthbreaker")
self.assertTrue(game.players[1].agent == agent2, "Agent not stored in the hearthbreaker")
self.assertListEqual(checked_cards[0][1:], game.players[0].hand[:-1], "Cards not retained after request")
self.assertListEqual(checked_cards[1][1:2], game.players[1].hand[:-4], "Cards not retained after request")
def test_recording_game(self):
self.maxDiff = None
random.seed(9876)
deck1 = hearthbreaker.game_objects.Deck([StonetuskBoar() for i in range(0, 30)], CHARACTER_CLASS.MAGE)
deck2 = hearthbreaker.game_objects.Deck([Naturalize() for i in range(0, 30)], CHARACTER_CLASS.DRUID)
agent1 = PredictableAgent()
agent2 = PredictableAgent()
game = Game([deck1, deck2], [agent1, agent2])
replay = record(game)
game.start()
output = StringIO()
replay.write_json(output)
f = open("tests/replays/stonetusk_innervate.hsreplay", "r")
dif = self.__compare_json(output.getvalue(), f.read())
self.assertTrue(dif)
f.close()
def deserialize(json_string, agents):
"""
Decode the given game instance from a JSON formatted string.
:param string json_string: The string representation of the game
:rtype: :class:`hearthbreaker.game_objects.Game`
"""
d = json.loads(json_string)
return Game.__from_json__(d, agents)
def deserialize(json_string, agents):
"""
Decode the given game instance from a JSON formatted string.
:param string json_string: The string representation of the game
:rtype: :class:`hearthbreaker.game_objects.Game`
"""
d = json.loads(json_string)
return Game.__from_json__(d, agents)
def test_random_character_saving(self):
deck1 = hearthbreaker.game_objects.Deck(
[RagnarosTheFirelord() for i in range(0, 30)],
CHARACTER_CLASS.MAGE)
deck2 = hearthbreaker.game_objects.Deck(
[StonetuskBoar() for i in range(0, 30)], CHARACTER_CLASS.DRUID)
agent1 = PlayAndAttackAgent()
agent2 = OneCardPlayingAgent()
random.seed(4879)
game = Game([deck1, deck2], [agent1, agent2])
replay = record(game)
game.pre_game()
for turn in range(0, 17):
game.play_single_turn()
output = StringIO()
replay.write_json(output)
random.seed(4879)
new_game = playback(Replay(StringIO(output.getvalue())))
new_game.pre_game()
for turn in range(0, 17):
new_game.play_single_turn()
self.assertEqual(2, len(new_game.current_player.minions))
self.assertEqual(30, new_game.other_player.hero.health)
self.assertEqual(5, len(new_game.other_player.minions))
def test_json_saving(self):
self.maxDiff = 6000
deck1 = hearthbreaker.game_objects.Deck(
[RagnarosTheFirelord() for i in range(0, 30)],
CHARACTER_CLASS.MAGE)
deck2 = hearthbreaker.game_objects.Deck(
[StonetuskBoar() for i in range(0, 30)], CHARACTER_CLASS.DRUID)
agent1 = PlayAndAttackAgent()
agent2 = OneCardPlayingAgent()
random.seed(4879)
game = Game([deck1, deck2], [agent1, agent2])
replay = record(game)
game.pre_game()
for turn in range(0, 17):
game.play_single_turn()
output = StringIO()
replay.write_json(output)
inp = StringIO(output.getvalue())
new_replay = Replay()
new_replay.read_json(inp)
old_output = output.getvalue()
other_output = StringIO()
new_replay.write_json(other_output)
self.assertEqual(other_output.getvalue(), old_output)
def generate_game_for(card1, card2, first_agent_type, second_agent_type):
if not isinstance(card1, collections.Sequence):
card_set1 = [card1()]
else:
card_set1 = [card() for card in card1]
class1 = CHARACTER_CLASS.MAGE
for card in card_set1:
if card.character_class != CHARACTER_CLASS.ALL:
class1 = card.character_class
break
if not isinstance(card2, collections.Sequence):
card_set2 = [card2()]
else:
card_set2 = [card() for card in card2]
class2 = CHARACTER_CLASS.MAGE
for card in card_set2:
if card.character_class != CHARACTER_CLASS.ALL:
class2 = card.character_class
break
deck1 = StackedDeck(card_set1, class1)
deck2 = StackedDeck(card_set2, class2)
game = Game([deck1, deck2], [first_agent_type(), second_agent_type()])
game.current_player = game.players[1]
game.other_player = game.players[0]
game.pre_game()
return game
def test_HolyNova(self):
deck1 = StackedDeck([MogushanWarden(), HolyNova()], CHARACTER_CLASS.PRIEST)
deck2 = StackedDeck([MogushanWarden()], CHARACTER_CLASS.PALADIN)
game = Game([deck1, deck2], [CardTestingAgent(), OneCardPlayingAgent()])
game.pre_game()
game.current_player = 1
for turn in range(0, 8):
game.play_single_turn()
self.assertEqual(1, len(game.players[0].minions))
self.assertEqual(1, len(game.players[1].minions))
game.players[0].minions[0].health = 4 # Fake damage
self.assertEqual(4, game.players[0].minions[0].health)
self.assertEqual(7, game.players[1].minions[0].health)
game.play_single_turn() # Holy Nova should be played
self.assertEqual(6, game.players[0].minions[0].health)
self.assertEqual(5, game.players[1].minions[0].health)
def test_recording_game(self):
self.maxDiff = None
random.seed(9876)
deck1 = hearthbreaker.game_objects.Deck(
[StonetuskBoar() for i in range(0, 30)], CHARACTER_CLASS.MAGE)
deck2 = hearthbreaker.game_objects.Deck(
[Naturalize() for i in range(0, 30)], CHARACTER_CLASS.DRUID)
agent1 = PredictableAgent()
agent2 = PredictableAgent()
game = Game([deck1, deck2], [agent1, agent2])
replay = record(game)
game.start()
output = StringIO()
replay.write_json(output)
f = open("tests/replays/stonetusk_innervate.hsreplay", 'r')
dif = self.__compare_json(output.getvalue(), f.read())
with open("bler.hsreplay", "w") as debug_file:
replay.write_json(debug_file)
self.assertTrue(dif)
f.close()
def test_json_saving(self):
self.maxDiff = 6000
deck1 = hearthbreaker.game_objects.Deck([RagnarosTheFirelord() for i in range(0, 30)], CHARACTER_CLASS.MAGE)
deck2 = hearthbreaker.game_objects.Deck([StonetuskBoar() for i in range(0, 30)], CHARACTER_CLASS.DRUID)
agent1 = PlayAndAttackAgent()
agent2 = OneCardPlayingAgent()
random.seed(4879)
game = Game([deck1, deck2], [agent1, agent2])
replay = record(game)
game.pre_game()
for turn in range(0, 17):
game.play_single_turn()
output = StringIO()
replay.write_json(output)
inp = StringIO(output.getvalue())
new_replay = Replay()
new_replay.read_json(inp)
old_output = output.getvalue()
other_output = StringIO()
new_replay.write_json(other_output)
self.assertEqual(other_output.getvalue(), old_output)
def test_deck_shortening(self):
deck1 = Deck([
RagnarosTheFirelord(),
RagnarosTheFirelord(),
RagnarosTheFirelord(),
RagnarosTheFirelord(),
RagnarosTheFirelord(),
RagnarosTheFirelord(),
RagnarosTheFirelord(),
RagnarosTheFirelord(),
RagnarosTheFirelord(),
RagnarosTheFirelord(),
RagnarosTheFirelord(),
RagnarosTheFirelord(),
RagnarosTheFirelord(),
RagnarosTheFirelord(),
RagnarosTheFirelord(),
RagnarosTheFirelord(),
RagnarosTheFirelord(),
RagnarosTheFirelord(),
RagnarosTheFirelord(),
RagnarosTheFirelord(),
RagnarosTheFirelord(),
RagnarosTheFirelord(),
RagnarosTheFirelord(),
RagnarosTheFirelord(),
RagnarosTheFirelord(),
RagnarosTheFirelord(),
RagnarosTheFirelord(),
RagnarosTheFirelord(),
GoldshireFootman(),
GoldshireFootman()
], CHARACTER_CLASS.DRUID)
deck2 = StackedDeck([StonetuskBoar()], CHARACTER_CLASS.HUNTER)
game = Game([deck1, deck2], [RandomAgent(), RandomAgent()])
replay = record(game)
game.start()
replay.write(StringIO())
def test_random_character_saving(self):
deck1 = hearthbreaker.game_objects.Deck([RagnarosTheFirelord() for i in range(0, 30)], CHARACTER_CLASS.MAGE)
deck2 = hearthbreaker.game_objects.Deck([StonetuskBoar() for i in range(0, 30)], CHARACTER_CLASS.DRUID)
agent1 = PlayAndAttackAgent()
agent2 = OneCardPlayingAgent()
random.seed(4879)
game = Game([deck1, deck2], [agent1, agent2])
replay = record(game)
game.pre_game()
for turn in range(0, 17):
game.play_single_turn()
output = StringIO()
replay.write_json(output)
random.seed(4879)
new_game = playback(Replay(StringIO(output.getvalue())))
new_game.pre_game()
for turn in range(0, 17):
new_game.play_single_turn()
self.assertEqual(2, len(new_game.current_player.minions))
self.assertEqual(30, new_game.other_player.hero.health)
self.assertEqual(5, len(new_game.other_player.minions))
def test_CircleOfHealing(self):
deck1 = StackedDeck(
[CircleOfHealing(), MogushanWarden(), CircleOfHealing(), CircleOfHealing(), CircleOfHealing(),
CircleOfHealing(), CircleOfHealing()], CHARACTER_CLASS.PRIEST)
deck2 = StackedDeck([MogushanWarden()], CHARACTER_CLASS.PALADIN)
game = Game([deck1, deck2], [SpellTestingAgent(), MinionPlayingAgent()])
game.pre_game()
game.current_player = 1
for turn in range(0, 8):
game.play_single_turn()
game.players[0].minions[0].health = 4
game.players[1].minions[0].health = 4
game.play_single_turn() # Circle of Healing should be played
self.assertEqual(game.players[0].minions[0].calculate_max_health(), game.players[0].minions[0].health)
self.assertEqual(game.players[1].minions[0].calculate_max_health(), game.players[1].minions[0].health)
def test_SavageRoar(self):
deck1 = StackedDeck(
[StonetuskBoar(), StonetuskBoar(),
SavageRoar()], CHARACTER_CLASS.DRUID)
deck2 = StackedDeck([StonetuskBoar()], CHARACTER_CLASS.MAGE)
game = Game([deck1, deck2],
[OneCardPlayingAgent(),
OneCardPlayingAgent()])
game.current_player = 1
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
minion_increase_mock = mock.Mock()
game.other_player.minions[0].bind("attack_changed",
minion_increase_mock)
game.other_player.minions[1].bind("attack_changed",
minion_increase_mock)
player_increase_mock = mock.Mock()
game.other_player.hero.bind("attack_changed", player_increase_mock)
game.play_single_turn()
self.assertEqual(0, game.current_player.mana)
# Make sure the attack got increased
self.assertListEqual([mock.call(2), mock.call(2)],
minion_increase_mock.call_args_list)
self.assertListEqual([mock.call(2)],
player_increase_mock.call_args_list)
# And make sure that it went down again
self.assertEqual(1, game.current_player.minions[0].calculate_attack())
self.assertEqual(1, game.current_player.minions[1].calculate_attack())
self.assertEqual(0, game.current_player.hero.calculate_attack())
def test_HolyNova(self):
deck1 = StackedDeck([MogushanWarden(), HolyNova()], CHARACTER_CLASS.PRIEST)
deck2 = StackedDeck([MogushanWarden()], CHARACTER_CLASS.PALADIN)
game = Game([deck1, deck2], [SpellTestingAgent(), MinionPlayingAgent()])
game.pre_game()
game.current_player = 1
for turn in range(0, 8):
game.play_single_turn()
self.assertEqual(1, len(game.players[0].minions))
self.assertEqual(1, len(game.players[1].minions))
game.players[0].minions[0].health = 4 # Fake damage
self.assertEqual(4, game.players[0].minions[0].health)
self.assertEqual(7, game.players[1].minions[0].health)
game.play_single_turn() # Holy Nova should be played
self.assertEqual(6, game.players[0].minions[0].health)
self.assertEqual(5, game.players[1].minions[0].health)
def test_Swipe(self):
deck1 = StackedDeck([BloodfenRaptor(), StonetuskBoar(), StonetuskBoar()], CHARACTER_CLASS.DRUID)
deck2 = StackedDeck([Swipe()], CHARACTER_CLASS.DRUID, )
game = Game([deck1, deck2], [OneCardPlayingAgent(), EnemyMinionSpellTestingAgent()])
game.pre_game()
game.current_player = game.players[1]
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
spell_damage_mock = mock.Mock()
game.current_player.minions[0].bind('damaged_by_spell', spell_damage_mock)
game.current_player.minions[1].bind('damaged_by_spell', spell_damage_mock)
game.current_player.minions[2].bind('damaged_by_spell', spell_damage_mock)
swipe_card = game.other_player.hand[0]
game.play_single_turn()
self.assertListEqual([mock.call(4, swipe_card), mock.call(1, swipe_card), mock.call(1, swipe_card)],
spell_damage_mock.call_args_list)
# The bloodfen raptor should be left, with one hp
self.assertEqual(1, len(game.other_player.minions))
self.assertEqual(1, game.other_player.minions[0].health)
self.assertEqual(29, game.other_player.hero.health)
def test_ManaWyrm(self):
deck1 = StackedDeck([
ManaWyrm(),
IceLance(),
ManaWyrm(),
IceLance(),
IceLance(),
IceLance()
], CHARACTER_CLASS.MAGE)
deck2 = StackedDeck([IronbeakOwl()], CHARACTER_CLASS.PALADIN)
game = Game(
[deck1, deck2],
[CardTestingAgent(), OneCardPlayingAgent()])
game.pre_game()
game.current_player = 1
game.play_single_turn()
self.assertEqual(1, len(game.current_player.minions))
self.assertEqual(1, game.current_player.minions[0].calculate_attack())
self.assertEqual(3, game.current_player.minions[0].health)
self.assertEqual(3,
game.current_player.minions[0].calculate_max_health())
self.assertEqual("Mana Wyrm", game.current_player.minions[0].card.name)
game.play_single_turn()
game.play_single_turn()
self.assertEqual(2, len(game.current_player.minions))
self.assertEqual(1, game.current_player.minions[0].calculate_attack())
self.assertEqual(3, game.current_player.minions[0].health)
self.assertEqual(3,
game.current_player.minions[0].calculate_max_health())
self.assertEqual(2, game.current_player.minions[1].calculate_attack())
self.assertEqual(3, game.current_player.minions[1].health)
self.assertEqual(3,
game.current_player.minions[1].calculate_max_health())
game.play_single_turn()
game.play_single_turn()
self.assertEqual(2, len(game.current_player.minions))
self.assertEqual(1, game.current_player.minions[0].calculate_attack())
self.assertEqual(3, game.current_player.minions[0].health)
self.assertEqual(3,
game.current_player.minions[0].calculate_max_health())
self.assertEqual(5, game.current_player.minions[1].calculate_attack())
self.assertEqual(3, game.current_player.minions[1].health)
self.assertEqual(3,
game.current_player.minions[1].calculate_max_health())
def test_MarkOfNature(self):
deck1 = StackedDeck([StonetuskBoar(), StonetuskBoar(), MarkOfNature()], CHARACTER_CLASS.DRUID)
deck2 = StackedDeck([StonetuskBoar()], CHARACTER_CLASS.MAGE)
game = Game([deck1, deck2], [OneCardPlayingAgent(), OneCardPlayingAgent()])
game.current_player = 1
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
self.assertEqual(5, game.other_player.minions[0].calculate_attack())
deck1 = StackedDeck([StonetuskBoar(), StonetuskBoar(), MarkOfNature()], CHARACTER_CLASS.DRUID)
deck2 = StackedDeck([StonetuskBoar()], CHARACTER_CLASS.MAGE)
agent = OneCardPlayingAgent()
agent.choose_option = lambda *options: options[1]
game = Game([deck1, deck2], [agent, OneCardPlayingAgent()])
game.current_player = 1
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
self.assertEqual(5, game.other_player.minions[0].calculate_max_health())
self.assertEqual(5, game.other_player.minions[0].health)
self.assertTrue(game.other_player.minions[0].taunt)
def _load_object(d):
return Game.__from_json__(d)
def serialization_copy(old_game):
game_json = json.dumps(old_game, default=_save_object, indent=2)
d = json.loads(game_json)
return Game.__from_json__(d, [player.agent for player in old_game.players])
def test_RandomAgent(self):
deck1 = Deck([
GoldshireFootman(),
GoldshireFootman(),
MurlocRaider(),
MurlocRaider(),
BloodfenRaptor(),
BloodfenRaptor(),
FrostwolfGrunt(),
FrostwolfGrunt(),
RiverCrocolisk(),
RiverCrocolisk(),
IronfurGrizzly(),
IronfurGrizzly(),
MagmaRager(),
MagmaRager(),
SilverbackPatriarch(),
SilverbackPatriarch(),
ChillwindYeti(),
ChillwindYeti(),
KeeperOfTheGrove(),
KeeperOfTheGrove(),
SenjinShieldmasta(),
SenjinShieldmasta(),
BootyBayBodyguard(),
BootyBayBodyguard(),
FenCreeper(),
FenCreeper(),
BoulderfistOgre(),
BoulderfistOgre(),
WarGolem(),
WarGolem(),
], CHARACTER_CLASS.DRUID)
deck2 = Deck([
Shieldbearer(),
Shieldbearer(),
FlameImp(),
FlameImp(),
YoungPriestess(),
YoungPriestess(),
DarkIronDwarf(),
DarkIronDwarf(),
DireWolfAlpha(),
DireWolfAlpha(),
Voidwalker(),
Voidwalker(),
HarvestGolem(),
HarvestGolem(),
KnifeJuggler(),
KnifeJuggler(),
ShatteredSunCleric(),
ShatteredSunCleric(),
ArgentSquire(),
ArgentSquire(),
Doomguard(),
Doomguard(),
Soulfire(),
Soulfire(),
DefenderOfArgus(),
DefenderOfArgus(),
AbusiveSergeant(),
AbusiveSergeant(),
NerubianEgg(),
NerubianEgg(),
], CHARACTER_CLASS.WARLOCK)
game = Game([deck1, deck2], [RandomAgent(), RandomAgent()])
game.pre_game()
game.current_player = game.players[1]
game.play_single_turn()
self.assertEqual(0, len(game.current_player.minions))
game.play_single_turn()
self.assertEqual(2, len(game.current_player.minions))
self.assertEqual(3, game.current_player.minions[1].health)
self.assertEqual("Young Priestess", game.current_player.minions[0].card.name)
game.play_single_turn()
self.assertEqual(1, len(game.current_player.minions))
self.assertEqual("Frostwolf Grunt", game.current_player.minions[0].card.name)
game.play_single_turn()
self.assertEqual(0, len(game.other_player.minions))
self.assertEqual(28, game.other_player.hero.health)
self.assertEqual(3, len(game.current_player.minions))
self.assertEqual("Dire Wolf Alpha", game.current_player.minions[2].card.name)
for turn in range(0, 21):
game.play_single_turn()
self.assertFalse(game.game_ended)
game.play_single_turn()
self.assertEqual(0, game.current_player.hero.health)
self.assertEqual(3, game.other_player.hero.health)
self.assertTrue(game.game_ended)
def render_game(stdscr):
class TextAgent:
def __init__(self, game_window, prompt_window, text_window):
self.window = prompt_window
self.game_window = game_window
self.text_window = text_window
curses.init_pair(5, curses.COLOR_WHITE, curses.COLOR_CYAN)
curses.init_pair(6, curses.COLOR_BLACK, curses.COLOR_GREEN)
def do_turn(self, player):
renderer.draw_game()
index = 0
action = self.choose_action()
while not (action == "quit" or action == "end"):
if action == "play":
card = self.choose_card(player)
if card is not None:
player.game.play_card(card)
elif action == "attack":
attacker = self.choose_attacker(player)
if attacker is not None:
attacker.attack()
elif action == "power":
if player.hero.power.can_use():
player.hero.power.use()
index += 1
renderer.draw_game()
action = self.choose_action()
if action == "quit":
sys.exit(0)
def choose_action(self):
self.window.addstr(0, 0, "Choose action")
actions = ["play", "attack", "power", "end", "quit"]
index = 0
selected = 0
for action in actions:
if index == selected:
color = curses.color_pair(4)
else:
color = curses.color_pair(3)
self.text_window.addstr(0, index * 10, "{0:^9}".format(action), color)
index += 1
self.window.refresh()
self.text_window.refresh()
ch = 0
while ch != 10 and ch != 27:
ch = self.game_window.getch()
if ch == curses.KEY_LEFT:
selected -= 1
if selected < 0:
selected = len(actions) - 1
if ch == curses.KEY_RIGHT:
selected += 1
if selected == len(actions):
selected = 0
index = 0
for action in actions:
if index == selected:
color = curses.color_pair(4)
else:
color = curses.color_pair(3)
self.text_window.addstr(0, index * 10, "{0:^9}".format(action), color)
index += 1
self.window.refresh()
self.text_window.refresh()
if ch == 27:
return None
return actions[selected]
def choose_card(self, player):
filtered_cards = [card for card in filter(lambda card: card.can_use(player, player.game), player.hand)]
if len(filtered_cards) is 0:
return None
renderer.targets = filtered_cards
renderer.selected_target = renderer.targets[0]
renderer.draw_game()
self.window.addstr(0, 0, "Choose Card")
self.window.refresh()
ch = 0
index = 0
while ch != 10 and ch != 27:
ch = self.game_window.getch()
if ch == curses.KEY_LEFT:
index -= 1
if index < 0:
index = len(renderer.targets) - 1
if ch == curses.KEY_RIGHT:
index += 1
if index == len(renderer.targets):
index = 0
renderer.selected_target = renderer.targets[index]
renderer.draw_game()
self.window.addstr(0, 0, "Choose Card")
self.window.refresh()
renderer.targets = None
if ch == 27:
return None
return renderer.selected_target
def choose_attacker(self, player):
filtered_attackers = [minion for minion in filter(lambda minion: minion.can_attack(), player.minions)]
if player.hero.can_attack():
filtered_attackers.append(player.hero)
if len(filtered_attackers) is 0:
return None
renderer.targets = filtered_attackers
renderer.selected_target = renderer.targets[0]
renderer.draw_game()
self.window.addstr(0, 0, "Choose attacker")
self.window.refresh()
ch = 0
index = 0
while ch != 10 and ch != 27:
ch = self.game_window.getch()
self.window.addstr(0, 0, "{0}".format(ch))
self.window.refresh()
if ch == curses.KEY_LEFT:
index -= 1
if index < 0:
index = len(renderer.targets) - 1
if ch == curses.KEY_RIGHT:
index += 1
if index == len(renderer.targets):
index = 0
renderer.selected_target = renderer.targets[index]
renderer.draw_game()
self.window.refresh()
renderer.targets = None
if ch == 27:
return None
return renderer.selected_target
def do_card_check(self, cards):
self.window.addstr(0, 0, "Select cards to keep (space selects/deselects a card)")
keeping = [True, True, True]
if len(cards) > 3:
keeping.append(True)
index = 0
selected = 0
for card in cards:
if keeping[index]:
if index == selected:
color = curses.color_pair(6)
else:
color = curses.color_pair(5)
else:
if index == selected:
color = curses.color_pair(4)
else:
color = curses.color_pair(0)
self.text_window.addstr(0, index * 20, "{0:^19}".format(card.name[:19]), color)
index += 1
self.window.refresh()
self.text_window.refresh()
ch = 0
while ch != 10 and ch != 27:
ch = self.game_window.getch()
if ch == curses.KEY_LEFT:
selected -= 1
if selected < 0:
selected = len(cards) - 1
if ch == curses.KEY_RIGHT:
selected += 1
if selected == len(cards):
selected = 0
if ch == 32:
keeping[selected] = not keeping[selected]
index = 0
for card in cards:
if keeping[index]:
if index == selected:
color = curses.color_pair(6)
else:
color = curses.color_pair(5)
else:
if index == selected:
color = curses.color_pair(4)
else:
color = curses.color_pair(0)
self.text_window.addstr(0, index * 20, "{0:^19}".format(card.name[:19]), color)
index += 1
self.window.refresh()
self.text_window.refresh()
if ch == 27:
return None
return keeping
def choose_target(self, targets):
if len(targets) is 0:
return None
renderer.targets = targets
renderer.selected_target = renderer.targets[0]
renderer.draw_game()
self.window.addstr(0, 0, "Choose target")
self.window.refresh()
ch = 0
index = 0
while ch != 10 and ch != 27:
ch = self.game_window.getch()
if ch == curses.KEY_LEFT:
index -= 1
if index < 0:
index = len(renderer.targets) - 1
if ch == curses.KEY_RIGHT:
index += 1
if index == len(renderer.targets):
index = 0
renderer.selected_target = renderer.targets[index]
renderer.draw_game()
self.window.refresh()
renderer.targets = None
if ch == 27:
return None
return renderer.selected_target
def choose_index(self, card, player):
renderer.selection_index = 0
renderer.draw_game()
self.window.addstr(0, 0, "Choose placement location")
self.window.refresh()
ch = 0
while ch != 10 and ch != 27:
ch = self.game_window.getch()
if ch == curses.KEY_LEFT:
renderer.selection_index -= 1
if renderer.selection_index < 0:
renderer.selection_index = len(player.minions)
if ch == curses.KEY_RIGHT:
renderer.selection_index += 1
if renderer.selection_index > len(player.minions):
renderer.selection_index = 0
renderer.draw_game()
self.window.refresh()
index = renderer.selection_index
renderer.selection_index = -1
if ch == 27:
return -1
return index
def choose_option(self, *options):
self.window.addstr(0, 0, "Choose option")
index = 0
selected = 0
for option in options:
if index == selected:
color = curses.color_pair(4)
else:
color = curses.color_pair(3)
self.text_window.addstr(0, index * 20, "{0:^19}".format(option.name[:19]), color)
index += 1
self.window.refresh()
self.text_window.refresh()
ch = 0
while ch != 10 and ch != 27:
ch = self.game_window.getch()
if ch == curses.KEY_LEFT:
selected -= 1
if selected < 0:
selected = len(options) - 1
if ch == curses.KEY_RIGHT:
selected += 1
if selected == len(options):
selected = 0
index = 0
for option in options:
if index == selected:
color = curses.color_pair(4)
else:
color = curses.color_pair(3)
self.text_window.addstr(0, index * 20, "{0:^19}".format(option.name[:19]), color)
index += 1
self.window.refresh()
self.text_window.refresh()
if ch == 27:
return None
return options[selected]
def choose_agent(window):
agents = registry.get_names()
curses.init_pair(3, curses.COLOR_WHITE, curses.COLOR_BLUE)
window.addstr(10, 34, "Choose agent")
ch = 0
selected = 0
while ch != 10 and ch != 27:
index = 0
for agent in agents:
if index == selected:
color = curses.color_pair(3)
else:
color = curses.color_pair(0)
window.addstr(index + 11, 25, "{:^30}".format(agent), color)
index += 1
window.refresh()
ch = window.getch()
if ch == curses.KEY_UP:
selected -= 1
if selected < 0:
selected = len(agents) - 1
if ch == curses.KEY_DOWN:
selected += 1
if selected == len(agents):
selected = 0
window.clear()
if ch == 27:
sys.exit(0)
else:
return registry.create_agent(agents[selected])
stdscr.clear()
prompt_window = stdscr.derwin(1, 80, 23, 0)
text_window = stdscr.derwin(1, 80, 24, 0)
agent = choose_agent(stdscr)
deck1 = load_deck(sys.argv[1])
deck2 = load_deck(sys.argv[2])
game = Game([deck1, deck2], [TextAgent(stdscr, prompt_window, text_window), agent])
if isinstance(game.players[0].agent, TextAgent):
renderer = GameRender(stdscr, game, game.players[0])
else:
renderer = GameRender(stdscr, game, game.players[1])
game.start()
def _load_object(d):
return Game.__from_json__(d)
def test_PowerOfTheWild(self):
deck1 = StackedDeck(
[StonetuskBoar(),
StonetuskBoar(),
PowerOfTheWild()], CHARACTER_CLASS.DRUID)
deck2 = StackedDeck([StonetuskBoar()], CHARACTER_CLASS.MAGE)
# This is a test of the +1/+1 option of the Power Of the Wild Card
game = Game([deck1, deck2],
[OneCardPlayingAgent(),
OneCardPlayingAgent()])
game.current_player = game.players[1]
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
self.assertEqual(2, game.current_player.minions[0].calculate_attack())
self.assertEqual(2, game.current_player.minions[0].health)
self.assertEqual(2,
game.current_player.minions[0].calculate_max_health())
self.assertEqual(2, game.current_player.minions[1].calculate_attack())
self.assertEqual(2,
game.current_player.minions[1].calculate_max_health())
# This is a test of the "Summon Panther" option of the Power of the Wild Card
agent = OneCardPlayingAgent()
agent.choose_option = mock.Mock(
side_effect=lambda *options: options[1])
deck1 = StackedDeck(
[StonetuskBoar(),
StonetuskBoar(),
PowerOfTheWild()], CHARACTER_CLASS.DRUID)
deck2 = StackedDeck([StonetuskBoar()], CHARACTER_CLASS.MAGE)
game = Game([deck1, deck2], [agent, OneCardPlayingAgent()])
game.current_player = game.players[1]
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
self.assertEqual(
"Panther", game.current_player.minions[2].card.__class__.__name__)
self.assertEqual(3, game.current_player.minions[2].calculate_attack())
self.assertEqual(2,
game.current_player.minions[2].calculate_max_health())
def test_MarkOfNature(self):
deck1 = StackedDeck(
[StonetuskBoar(), StonetuskBoar(),
MarkOfNature()], CHARACTER_CLASS.DRUID)
deck2 = StackedDeck([StonetuskBoar()], CHARACTER_CLASS.MAGE)
game = Game([deck1, deck2],
[OneCardPlayingAgent(),
OneCardPlayingAgent()])
game.current_player = 1
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
self.assertEqual(5, game.other_player.minions[0].calculate_attack())
deck1 = StackedDeck(
[StonetuskBoar(), StonetuskBoar(),
MarkOfNature()], CHARACTER_CLASS.DRUID)
deck2 = StackedDeck([StonetuskBoar()], CHARACTER_CLASS.MAGE)
agent = OneCardPlayingAgent()
agent.choose_option = lambda *options: options[1]
game = Game([deck1, deck2], [agent, OneCardPlayingAgent()])
game.current_player = 1
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
self.assertEqual(5,
game.other_player.minions[0].calculate_max_health())
self.assertEqual(5, game.other_player.minions[0].health)
self.assertTrue(game.other_player.minions[0].taunt)
def test_Cenarius(self):
deck1 = StackedDeck([StonetuskBoar()], CHARACTER_CLASS.DRUID)
deck2 = StackedDeck([WarGolem(), WarGolem(), Cenarius(), Cenarius()], CHARACTER_CLASS.DRUID)
game = Game([deck1, deck2], [DoNothingAgent(), OneCardPlayingAgent()])
game.pre_game()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
self.assertEqual(2, len(game.other_player.minions))
for minion in game.other_player.minions:
self.assertEqual(7, minion.calculate_attack())
self.assertEqual(7, minion.health)
self.assertEqual(7, minion.calculate_max_health())
game.play_single_turn()
self.assertEqual(3, len(game.current_player.minions))
self.assertEqual(5, game.current_player.minions[0].calculate_attack())
self.assertEqual(8, game.current_player.minions[0].health)
self.assertEqual(8, game.current_player.minions[0].calculate_max_health())
self.assertEqual("Cenarius", game.current_player.minions[0].card.name)
for minion_index in range(1, 3):
minion = game.current_player.minions[minion_index]
self.assertEqual(9, minion.calculate_attack())
self.assertEqual(9, minion.health)
self.assertEqual(9, minion.calculate_max_health())
game.players[1].agent.choose_option = lambda stats, summon: summon
game.play_single_turn()
game.play_single_turn()
self.assertEqual(6, len(game.current_player.minions))
self.assertEqual(5, game.current_player.minions[1].calculate_attack())
self.assertEqual(8, game.current_player.minions[1].health)
self.assertEqual(8, game.current_player.minions[1].calculate_max_health())
self.assertEqual("Cenarius", game.current_player.minions[1].card.name)
self.assertEqual(2, game.current_player.minions[0].calculate_attack())
self.assertEqual(2, game.current_player.minions[0].health)
self.assertEqual(2, game.current_player.minions[0].calculate_max_health())
self.assertTrue(game.current_player.minions[0].taunt)
self.assertEqual("Treant", game.current_player.minions[0].card.name)
self.assertEqual(2, game.current_player.minions[2].calculate_attack())
self.assertEqual(2, game.current_player.minions[2].health)
self.assertEqual(2, game.current_player.minions[2].calculate_max_health())
self.assertTrue(game.current_player.minions[2].taunt)
self.assertEqual("Treant", game.current_player.minions[2].card.name)
def test_Swipe(self):
deck1 = StackedDeck([BloodfenRaptor(), StonetuskBoar(), StonetuskBoar()], CHARACTER_CLASS.DRUID)
deck2 = StackedDeck([Swipe()], CHARACTER_CLASS.DRUID, )
game = Game([deck1, deck2], [OneCardPlayingAgent(), EnemyMinionSpellTestingAgent()])
game.pre_game()
game.current_player = game.players[1]
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
# The bloodfen raptor should be left, with one hp
self.assertEqual(1, len(game.other_player.minions))
self.assertEqual(1, game.other_player.minions[0].health)
self.assertEqual(29, game.other_player.hero.health)
def test_Cenarius(self):
deck1 = StackedDeck([StonetuskBoar()], CHARACTER_CLASS.DRUID)
deck2 = StackedDeck(
[WarGolem(), WarGolem(),
Cenarius(), Cenarius()], CHARACTER_CLASS.DRUID)
game = Game([deck1, deck2], [DoNothingAgent(), OneCardPlayingAgent()])
game.pre_game()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
self.assertEqual(2, len(game.other_player.minions))
for minion in game.other_player.minions:
self.assertEqual(7, minion.calculate_attack())
self.assertEqual(7, minion.health)
self.assertEqual(7, minion.calculate_max_health())
game.play_single_turn()
self.assertEqual(3, len(game.current_player.minions))
self.assertEqual(5, game.current_player.minions[0].calculate_attack())
self.assertEqual(8, game.current_player.minions[0].health)
self.assertEqual(8,
game.current_player.minions[0].calculate_max_health())
self.assertEqual("Cenarius", game.current_player.minions[0].card.name)
for minion_index in range(1, 3):
minion = game.current_player.minions[minion_index]
self.assertEqual(9, minion.calculate_attack())
self.assertEqual(9, minion.health)
self.assertEqual(9, minion.calculate_max_health())
game.players[1].agent.choose_option = lambda stats, summon: summon
game.play_single_turn()
game.play_single_turn()
self.assertEqual(6, len(game.current_player.minions))
self.assertEqual(5, game.current_player.minions[1].calculate_attack())
self.assertEqual(8, game.current_player.minions[1].health)
self.assertEqual(8,
game.current_player.minions[1].calculate_max_health())
self.assertEqual("Cenarius", game.current_player.minions[1].card.name)
self.assertEqual(2, game.current_player.minions[0].calculate_attack())
self.assertEqual(2, game.current_player.minions[0].health)
self.assertEqual(2,
game.current_player.minions[0].calculate_max_health())
self.assertTrue(game.current_player.minions[0].taunt)
self.assertEqual("Treant", game.current_player.minions[0].card.name)
self.assertEqual(2, game.current_player.minions[2].calculate_attack())
self.assertEqual(2, game.current_player.minions[2].health)
self.assertEqual(2,
game.current_player.minions[2].calculate_max_health())
self.assertTrue(game.current_player.minions[2].taunt)
self.assertEqual("Treant", game.current_player.minions[2].card.name)
def render_game(stdscr):
class TextAgent:
def __init__(self, game_window, prompt_window, text_window):
self.window = prompt_window
self.game_window = game_window
self.text_window = text_window
curses.init_pair(5, curses.COLOR_WHITE, curses.COLOR_CYAN)
curses.init_pair(6, curses.COLOR_BLACK, curses.COLOR_GREEN)
def do_turn(self, player):
renderer.draw_game()
index = 0
action = self.choose_action()
while not (action == "quit" or action == "end"):
if action == "play":
card = self.choose_card(player)
if card is not None:
player.game.play_card(card)
elif action == "attack":
attacker = self.choose_attacker(player)
if attacker is not None:
attacker.attack()
elif action == "power":
if player.hero.power.can_use():
player.hero.power.use()
index += 1
renderer.draw_game()
action = self.choose_action()
if action == "quit":
sys.exit(0)
def choose_action(self):
self.window.addstr(0, 0, "Choose action")
actions = ["play", "attack", "power", "end", "quit"]
index = 0
selected = 0
for action in actions:
if index == selected:
color = curses.color_pair(4)
else:
color = curses.color_pair(3)
self.text_window.addstr(0, index * 10, "{0:^9}".format(action), color)
index += 1
self.window.refresh()
self.text_window.refresh()
ch = 0
while ch != 10 and ch != 27:
ch = self.window.getch()
if ch == curses.KEY_LEFT:
selected -= 1
if selected < 0:
selected = len(actions) - 1
if ch == curses.KEY_RIGHT:
selected += 1
if selected == len(actions):
selected = 0
index = 0
for action in actions:
if index == selected:
color = curses.color_pair(4)
else:
color = curses.color_pair(3)
self.text_window.addstr(0, index * 10, "{0:^9}".format(action), color)
index += 1
self.window.refresh()
self.text_window.refresh()
if ch == 27:
return None
return actions[selected]
def choose_card(self, player):
filtered_cards = [card for card in filter(lambda card: card.can_use(player, player.game), player.hand)]
if len(filtered_cards) is 0:
return None
renderer.targets = filtered_cards
renderer.selected_target = renderer.targets[0]
renderer.draw_game()
self.window.addstr(0, 0, "Choose Card")
self.window.refresh()
ch = 0
index = 0
while ch != 10 and ch != 27:
ch = self.window.getch()
if ch == curses.KEY_LEFT:
index -= 1
if index < 0:
index = len(renderer.targets) - 1
if ch == curses.KEY_RIGHT:
index += 1
if index == len(renderer.targets):
index = 0
renderer.selected_target = renderer.targets[index]
renderer.draw_game()
self.window.addstr(0, 0, "Choose Card")
self.window.refresh()
renderer.targets = None
if ch == 27:
return None
return renderer.selected_target
def choose_attacker(self, player):
filtered_attackers = [minion for minion in filter(lambda minion: minion.can_attack(), player.minions)]
if player.hero.can_attack():
filtered_attackers.append(player.hero)
if len(filtered_attackers) is 0:
return None
renderer.targets = filtered_attackers
renderer.selected_target = renderer.targets[0]
renderer.draw_game()
self.window.addstr(0, 0, "Choose attacker")
self.window.refresh()
ch = 0
index = 0
while ch != 10 and ch != 27:
ch = self.window.getch()
self.window.addstr(0, 0, "{0}".format(ch))
self.window.refresh()
if ch == curses.KEY_LEFT:
index -= 1
if index < 0:
index = len(renderer.targets) - 1
if ch == curses.KEY_RIGHT:
index += 1
if index == len(renderer.targets):
index = 0
renderer.selected_target = renderer.targets[index]
renderer.draw_game()
self.window.refresh()
renderer.targets = None
if ch == 27:
return None
return renderer.selected_target
def do_card_check(self, cards):
self.window.addstr(0, 0, "Select cards to keep (space selects/deselects a card)")
keeping = [True, True, True]
if len(cards) > 3:
keeping.append(True)
index = 0
selected = 0
for card in cards:
if keeping[index]:
if index == selected:
color = curses.color_pair(6)
else:
color = curses.color_pair(5)
else:
if index == selected:
color = curses.color_pair(4)
else:
color = curses.color_pair(0)
self.text_window.addstr(0, index * 20, "{0:^19}".format(card.name[:19]), color)
index += 1
self.window.refresh()
self.text_window.refresh()
ch = 0
while ch != 10 and ch != 27:
ch = self.window.getch()
if ch == curses.KEY_LEFT:
selected -= 1
if selected < 0:
selected = len(cards) - 1
if ch == curses.KEY_RIGHT:
selected += 1
if selected == len(cards):
selected = 0
if ch == 32:
keeping[selected] = not keeping[selected]
index = 0
for card in cards:
if keeping[index]:
if index == selected:
color = curses.color_pair(6)
else:
color = curses.color_pair(5)
else:
if index == selected:
color = curses.color_pair(4)
else:
color = curses.color_pair(0)
self.text_window.addstr(0, index * 20, "{0:^19}".format(card.name[:19]), color)
index += 1
self.window.refresh()
self.text_window.refresh()
if ch == 27:
return None
return keeping
def choose_target(self, targets):
if len(targets) is 0:
return None
renderer.targets = targets
renderer.selected_target = renderer.targets[0]
renderer.draw_game()
self.window.addstr(0, 0, "Choose target")
self.window.refresh()
ch = 0
index = 0
while ch != 10 and ch != 27:
ch = self.window.getch()
if ch == curses.KEY_LEFT:
index -= 1
if index < 0:
index = len(renderer.targets) - 1
if ch == curses.KEY_RIGHT:
index += 1
if index == len(renderer.targets):
index = 0
renderer.selected_target = renderer.targets[index]
renderer.draw_game()
self.window.refresh()
renderer.targets = None
if ch == 27:
return None
return renderer.selected_target
def choose_index(self, card, player):
renderer.selection_index = 0
renderer.draw_game()
self.window.addstr(0, 0, "Choose placement location")
self.window.refresh()
ch = 0
while ch != 10 and ch != 27:
ch = self.window.getch()
if ch == curses.KEY_LEFT:
renderer.selection_index -= 1
if renderer.selection_index < 0:
renderer.selection_index = len(player.minions)
if ch == curses.KEY_RIGHT:
renderer.selection_index += 1
if renderer.selection_index > len(player.minions):
renderer.selection_index = 0
renderer.draw_game()
self.window.refresh()
index = renderer.selection_index
renderer.selection_index = -1
if ch == 27:
return -1
return index
def choose_option(self, *options):
self.window.addstr(0, 0, "Choose option")
index = 0
selected = 0
for option in options:
if index == selected:
color = curses.color_pair(4)
else:
color = curses.color_pair(3)
self.text_window.addstr(0, index * 20, "{0:^19}".format(option.name[:19], color))
index += 1
self.window.refresh()
self.text_window.refresh()
ch = 0
while ch != 10 and ch != 27:
ch = self.window.getch()
if ch == curses.KEY_LEFT:
selected -= 1
if selected < 0:
selected = len(options) - 1
if ch == curses.KEY_RIGHT:
selected += 1
if selected == len(options):
selected = 0
index = 0
for option in options:
if index == selected:
color = curses.color_pair(4)
else:
color = curses.color_pair(3)
self.text_window.addstr(0, index * 20, "{0:^19}".format(option.name[:19], color))
index += 1
self.window.refresh()
self.text_window.refresh()
if ch == 27:
return None
return options[selected]
stdscr.clear()
prompt_window = stdscr.derwin(1, 80, 23, 0)
text_window = stdscr.derwin(1, 80, 24, 0)
deck1 = load_deck(sys.argv[1])
deck2 = load_deck(sys.argv[2])
game = Game([deck1, deck2], [TextAgent(stdscr, prompt_window, text_window), RandomAgent()])
if isinstance(game.players[0].agent, TextAgent):
renderer = GameRender(stdscr, game, game.players[0])
else:
renderer = GameRender(stdscr, game, game.players[1])
game.start()
def test_PowerOfTheWild(self):
deck1 = StackedDeck([StonetuskBoar(), StonetuskBoar(), PowerOfTheWild()], CHARACTER_CLASS.DRUID)
deck2 = StackedDeck([StonetuskBoar()], CHARACTER_CLASS.MAGE)
# This is a test of the +1/+1 option of the Power Of the Wild Card
game = Game([deck1, deck2], [OneCardPlayingAgent(), OneCardPlayingAgent()])
game.current_player = game.players[1]
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
self.assertEqual(2, game.current_player.minions[0].calculate_attack())
self.assertEqual(2, game.current_player.minions[0].health)
self.assertEqual(2, game.current_player.minions[0].calculate_max_health())
self.assertEqual(2, game.current_player.minions[1].calculate_attack())
self.assertEqual(2, game.current_player.minions[1].calculate_max_health())
# This is a test of the "Summon Panther" option of the Power of the Wild Card
agent = OneCardPlayingAgent()
agent.choose_option = mock.Mock(side_effect=lambda *options: options[1])
deck1 = StackedDeck([StonetuskBoar(), StonetuskBoar(), PowerOfTheWild()], CHARACTER_CLASS.DRUID)
deck2 = StackedDeck([StonetuskBoar()], CHARACTER_CLASS.MAGE)
game = Game([deck1, deck2], [agent, OneCardPlayingAgent()])
game.current_player = game.players[1]
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
self.assertEqual("Panther", game.current_player.minions[2].card.__class__.__name__)
self.assertEqual(3, game.current_player.minions[2].calculate_attack())
self.assertEqual(2, game.current_player.minions[2].calculate_max_health())
def test_Swipe(self):
deck1 = StackedDeck(
[BloodfenRaptor(),
StonetuskBoar(),
StonetuskBoar()], CHARACTER_CLASS.DRUID)
deck2 = StackedDeck(
[Swipe()],
CHARACTER_CLASS.DRUID,
)
game = Game([deck1, deck2],
[OneCardPlayingAgent(),
EnemyMinionSpellTestingAgent()])
game.pre_game()
game.current_player = game.players[1]
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
spell_damage_mock = mock.Mock()
game.current_player.minions[0].bind('damaged_by_spell',
spell_damage_mock)
game.current_player.minions[1].bind('damaged_by_spell',
spell_damage_mock)
game.current_player.minions[2].bind('damaged_by_spell',
spell_damage_mock)
swipe_card = game.other_player.hand[0]
game.play_single_turn()
self.assertListEqual([
mock.call(4, swipe_card),
mock.call(1, swipe_card),
mock.call(1, swipe_card)
], spell_damage_mock.call_args_list)
# The bloodfen raptor should be left, with one hp
self.assertEqual(1, len(game.other_player.minions))
self.assertEqual(1, game.other_player.minions[0].health)
self.assertEqual(29, game.other_player.hero.health)