Source: King of Beasts NAME_END 2 ATK_END 6 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Hunter PLAYER_CLS_END Beast RACE_END Rare RARITY_END Taunt. Battlecry: Gain +1 Attack for each other Beast you have.

Target: class KingOfBeasts(MinionCard):§    def __init__(self):§        super().__init__("King of Beasts", 5, CHARACTER_CLASS.HUNTER, CARD_RARITY.RARE, minion_type=MINION_TYPE.BEAST, battlecry=Battlecry(Give(Buff(ChangeAttack(Count(MinionSelector(IsType( MINION_TYPE.BEAST)))))), SelfSelector()))§§    def create_minion(self, player):§        return Minion(2, 6, taunt=True)§


Source: Light of the Naaru NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Priest PLAYER_CLS_END NIL RACE_END Rare RARITY_END Restore #3 Health. If the target is still damaged, summon a Lightwarden.

Target: class LightOfTheNaaru(SpellCard):§    def __init__(self):§        super().__init__("Light of the Naaru", 1, CHARACTER_CLASS.PRIEST, CARD_RARITY.RARE, target_func=hearthbreaker.targeting.find_spell_target)§§    def use(self, player, game):§        super().use(player, game)§§        self.target.heal(player.effective_heal_power(3), self)§§        lightwarden = Lightwarden()§        if self.target is None:§            lightwarden.summon(player, game, len(player.minions))§        elif self.target.health != self.target.calculate_max_health():§            lightwarden.summon(player, game, len(player.minions))§


Source: Lightbomb NAME_END -1 ATK_END -1 DEF_END 6 COST_END -1 DUR_END Spell TYPE_END Priest PLAYER_CLS_END NIL RACE_END Epic RARITY_END Deal damage to each minion equal to its Attack.

Target: class Lightbomb(SpellCard):§    def __init__(self):§        super().__init__("Lightbomb", 6, CHARACTER_CLASS.PRIEST, CARD_RARITY.EPIC)§§    def use(self, player, game):§        super().use(player, game)§§        targets = copy.copy(game.other_player.minions)§        targets.extend(player.minions)§§        for minion in targets:§            minion.damage(player.effective_spell_damage(minion.calculate_attack()), self)§


Source: Lil' Exorcist NAME_END 2 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END Taunt NL Battlecry: Gain +1/+1 for each enemy Deathrattle minion.

Target: class LilExorcist(MinionCard):§    def __init__(self):§        super().__init__("Lil' Exorcist", 3, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, battlecry=Battlecry(Give([Buff(ChangeAttack(Count(MinionSelector(MinionHasDeathrattle(), EnemyPlayer())))), Buff(ChangeHealth(Count(MinionSelector(MinionHasDeathrattle(), EnemyPlayer()))))]), SelfSelector()))§§    def create_minion(self, player):§        return Minion(2, 3, taunt=True)§


Source: Lost Tallstrider NAME_END 5 ATK_END 4 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Beast RACE_END Common RARITY_END NIL

Target: class LostTallstrider(MinionCard):§    def __init__(self):§        super().__init__("Lost Tallstrider", 4, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(5, 4)§


Source: Malorne NAME_END 9 ATK_END 7 DEF_END 7 COST_END -1 DUR_END Minion TYPE_END Druid PLAYER_CLS_END Beast RACE_END Legendary RARITY_END <b>Deathrattle:</b> Shuffle this minion into your deck.

Target: class Malorne(MinionCard):§    def __init__(self):§        super().__init__("Malorne", 7, CHARACTER_CLASS.DRUID, CARD_RARITY.LEGENDARY, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(9, 7, deathrattle=[Deathrattle(AddCard(CardQuery(source=CARD_SOURCE.MINION, minion=SelfSelector()), add_to_deck=True), PlayerSelector()), Deathrattle(Remove(), SelfSelector())])§


Source: Mech-Bear-Cat NAME_END 7 ATK_END 6 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Druid PLAYER_CLS_END Mech RACE_END Rare RARITY_END Whenever this minion takes damage, add a <b>Spare Part</b> card to your hand.

Target: class MechBearCat(MinionCard):§    def __init__(self):§        super().__init__("Mech-Bear-Cat", 6, CHARACTER_CLASS.DRUID, CARD_RARITY.RARE, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(7, 6, effects=[Effect(Damaged(), ActionTag(AddCard(CardQuery(source=CARD_SOURCE.LIST, source_list=spare_part_list)), PlayerSelector()))])§


Source: Mechanical Yeti NAME_END 4 ATK_END 5 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Common RARITY_END Deathrattle: Give each player a Spare Part.

Target: class MechanicalYeti(MinionCard):§    def __init__(self):§        super().__init__("Mechanical Yeti", 4, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        from hearthbreaker.cards.spells.neutral import spare_part_list§        return Minion(4, 5, deathrattle=Deathrattle(AddCard(CardQuery(source=CARD_SOURCE.LIST, source_list=spare_part_list)), PlayerSelector(BothPlayer())))§


Source: Mechwarper NAME_END 2 ATK_END 3 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Common RARITY_END Your Mechs cost (1) less.

Target: class Mechwarper(MinionCard):§    def __init__(self):§        super().__init__("Mechwarper", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(2, 3, auras=[Aura(ManaChange(-1), CardSelector(condition=IsType(MINION_TYPE.MECH)))])§


Source: Mekgineer Thermaplugg NAME_END 9 ATK_END 7 DEF_END 9 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Legendary RARITY_END Whenever an enemy minion dies, summon a Leper Gnome.

Target: class MekgineerThermaplugg(MinionCard):§    def __init__(self):§        super().__init__("Mekgineer Thermaplugg", 9, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(9, 7, effects=[Effect(MinionDied(player=EnemyPlayer()), ActionTag(Summon(LeperGnome()), PlayerSelector()))])§


Source: Metaltooth Leaper NAME_END 3 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Hunter PLAYER_CLS_END Mech RACE_END Rare RARITY_END <b>Battlecry</b>: Give your other Mechs +2 Attack.

Target: class MetaltoothLeaper(MinionCard):§    def __init__(self):§        super().__init__("Metaltooth Leaper", 3, CHARACTER_CLASS.HUNTER, CARD_RARITY.RARE, minion_type=MINION_TYPE.MECH, battlecry=Battlecry(Give(Buff(ChangeAttack(2))), MinionSelector(IsType(MINION_TYPE.MECH))))§§    def create_minion(self, player):§        return Minion(3, 3)§


Source: Micro Machine NAME_END 1 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Common RARITY_END At the start of each turn, gain +1 Attack.

Target: class MicroMachine(MinionCard):§    def __init__(self):§        super().__init__("Micro Machine", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(1, 2, effects=[Effect(TurnStarted(player=BothPlayer()), ActionTag(Give(ChangeAttack(1)), SelfSelector()))])§


Source: Mimiron's Head NAME_END 4 ATK_END 5 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Legendary RARITY_END At the start of your turn, if you have at least 3 Mechs, destroy them all and form V-07-TR-0N.

Target: class MimironsHead(MinionCard):§    def __init__(self):§        super().__init__("Mimiron's Head", 5, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(4, 5, effects=[Effect(TurnStarted(), [ActionTag(Kill(), MinionSelector(IsType(MINION_TYPE.MECH, True)), GreaterThan(Count(MinionSelector(IsType(MINION_TYPE.MECH, True))), value=2)), ActionTag(Summon(V07TR0N()), PlayerSelector())])])§


Source: Mogor the Ogre NAME_END 7 ATK_END 6 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END All minions have a 50% chance to attack the wrong enemy.

Target: class MogorTheOgre(MinionCard):§    def __init__(self):§        super().__init__("Mogor the Ogre", 6, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(7, 6, effects=[Effect(CharacterAttack(None, BothPlayer()), ActionTag(ChangeTarget(§            CharacterSelector(NotCurrentTarget(), EnemyPlayer(), RandomPicker())), TargetSelector(),§            And(OneIn(2), OpponentMinionCountIsGreaterThan(0))))])§


Source: Muster for Battle NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Rare RARITY_END Summon three 1/1 Silver Hand Recruits. Equip a 1/4 Weapon.

Target: class MusterForBattle(SpellCard):§    def __init__(self):§        super().__init__("Muster for Battle", 3, CHARACTER_CLASS.PALADIN, CARD_RARITY.RARE)§§    def use(self, player, game):§        super().use(player, game)§§        for i in range(0, 3):§            dude = SilverHandRecruit()§            dude.summon(player, player.game, len(player.minions))§        justice = LightsJustice()§        hammer = justice.create_weapon(player)§        hammer.card = justice§        hammer.equip(player)§


Source: Neptulon NAME_END 7 ATK_END 7 DEF_END 7 COST_END -1 DUR_END Minion TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Legendary RARITY_END Battlecry: Add 4 random Murlocs to your hand. Overload: (3)

Target: class Neptulon(MinionCard):§    def __init__(self):§        from hearthbreaker.cards.minions.neutral import BluegillWarrior, ColdlightOracle, ColdlightSeer, \§            GrimscaleOracle, MurlocRaider, MurlocTidecaller, MurlocTidehunter, MurlocWarleader, OldMurkEye, \§            Puddlestomper§        murloc_list = [BluegillWarrior(), ColdlightOracle(), ColdlightSeer(), GrimscaleOracle(), MurlocRaider(), MurlocTidecaller(), MurlocTidehunter(), MurlocWarleader(), OldMurkEye(), Puddlestomper(), SiltfinSpiritwalker()]§        super().__init__("Neptulon", 7, CHARACTER_CLASS.SHAMAN, CARD_RARITY.LEGENDARY, overload=3, battlecry=Battlecry(AddCard(CardQuery(source=CARD_SOURCE.LIST, source_list=murloc_list), 4), PlayerSelector()))§§    def create_minion(self, player):§        return Minion(7, 7)§


Source: Ogre Brute NAME_END 4 ATK_END 4 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END 50% chance to attack the wrong enemy.

Target: class OgreBrute(MinionCard):§    def __init__(self):§        super().__init__("Ogre Brute", 3, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(4, 4, effects=[Effect(Attack(), ActionTag(ChangeTarget(CharacterSelector(NotCurrentTarget(), EnemyPlayer(), RandomPicker())), SelfSelector(), And(OneIn(2), OpponentMinionCountIsGreaterThan(0))))])§


Source: Ogre Ninja NAME_END 6 ATK_END 6 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Stealth</b> NL 50% chance to attack the wrong enemy.

Target: class OgreNinja(MinionCard):§    def __init__(self):§        super().__init__("Ogre Ninja", 5, CHARACTER_CLASS.ROGUE, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(6, 6, stealth=True, effects=[Effect(Attack(), ActionTag(ChangeTarget( CharacterSelector(NotCurrentTarget(), EnemyPlayer(), RandomPicker())), SelfSelector(), And(OneIn(2), OpponentMinionCountIsGreaterThan(0))))])§


Source: Ogre Warmaul NAME_END 4 ATK_END -1 DEF_END 3 COST_END 2 DUR_END Weapon TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Common RARITY_END 50% chance to attack the wrong enemy.

Target: class OgreWarmaul(WeaponCard):§    def __init__(self):§        super().__init__("Ogre Warmaul", 3, CHARACTER_CLASS.WARRIOR, CARD_RARITY.COMMON)§§    def create_weapon(self, player):§        return Weapon(4, 2, effects=[Effect(CharacterAttack(IsHero()), ActionTag(ChangeTarget(CharacterSelector(NotCurrentTarget(), EnemyPlayer(), RandomPicker())), HeroSelector(), And(OneIn(2), OpponentMinionCountIsGreaterThan(0))))])§


Source: One-eyed Cheat NAME_END 4 ATK_END 1 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Rogue PLAYER_CLS_END Pirate RACE_END Rare RARITY_END Whenever you summon a Pirate, gain <b>Stealth</b>.

Target: class OneeyedCheat(MinionCard):§    def __init__(self):§        super().__init__("One-eyed Cheat", 2, CHARACTER_CLASS.ROGUE, CARD_RARITY.RARE, minion_type=MINION_TYPE.PIRATE)§§    def create_minion(self, player):§        return Minion(4, 1, effects=[Effect(MinionSummoned(IsType(MINION_TYPE.PIRATE)), ActionTag(Give(Stealth()), SelfSelector()))])§


Source: Piloted Shredder NAME_END 4 ATK_END 3 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Common RARITY_END <b>Deathrattle:</b> Summon a random 2-Cost minion.

Target: class PilotedShredder(MinionCard):§    def __init__(self):§        super().__init__("Piloted Shredder", 4, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(4, 3, deathrattle=Deathrattle(Summon(CardQuery(conditions=[ManaCost(2), IsMinion()])), PlayerSelector()))§


Source: Puddlestomper NAME_END 3 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Murloc RACE_END Common RARITY_END NIL

Target: class Puddlestomper(MinionCard):§    def __init__(self):§        super().__init__("Puddlestomper", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.MURLOC)§§    def create_minion(self, player):§        return Minion(3, 2)§


Source: Quartermaster NAME_END 2 ATK_END 5 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Epic RARITY_END <b>Battlecry:</b> Give your Silver Hand Recruits +2/+2.

Target: class Quartermaster(MinionCard):§    def __init__(self):§        super().__init__("Quartermaster", 5, CHARACTER_CLASS.PALADIN, CARD_RARITY.EPIC, battlecry=Battlecry(Give([Buff(ChangeAttack(2)), Buff(ChangeHealth(2))]), MinionSelector(HasCardName("Silver Hand Recruit"))))§§    def create_minion(self, player):§        return Minion(2, 5)§


Source: Recombobulator NAME_END 3 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Epic RARITY_END <b>Battlecry:</b> Transform a friendly minion into a random minion with the same Cost.

Target: class Recombobulator(MinionCard):§    def __init__(self):§        super().__init__("Recombobulator", 2, CHARACTER_CLASS.ALL, CARD_RARITY.EPIC, battlecry=Battlecry(Transform(CardQuery(conditions=[ ManaCost(Attribute("mana", SelfSelector())), IsMinion()])), MinionSelector(picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(3, 2)§


Source: Recycle NAME_END -1 ATK_END -1 DEF_END 6 COST_END -1 DUR_END Spell TYPE_END Druid PLAYER_CLS_END NIL RACE_END Rare RARITY_END Shuffle an enemy minion into your opponent's deck.

Target: class Recycle(SpellCard):§    def __init__(self):§        super().__init__("Recycle", 6, CHARACTER_CLASS.DRUID, CARD_RARITY.RARE, target_func=hearthbreaker.targeting.find_enemy_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        player.opponent.deck.put_back(self.target)§        self.target.remove_from_board()§


Source: Reversing Switch NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Neutral PLAYER_CLS_END NIL RACE_END NIL RARITY_END Swap a minion's Attack and Health.

Target: class ReversingSwitch(SpellCard):§    def __init__(self):§        super().__init__("Reversing Switch", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, False, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        temp_attack = self.target.calculate_attack()§        temp_health = self.target.health§        if temp_attack == 0:§            self.target.die(None)§        else:§            self.target.set_attack_to(temp_health)§            self.target.set_health_to(temp_attack)§


Source: Rusty Horn NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Neutral PLAYER_CLS_END NIL RACE_END NIL RARITY_END Give a minion <b>Taunt</b>.

Target: class RustyHorn(SpellCard):§    def __init__(self):§        super().__init__("Rusty Horn", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, False, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        self.target.add_buff(Buff(Taunt()))§


Source: Sabotage NAME_END -1 ATK_END -1 DEF_END 4 COST_END -1 DUR_END Spell TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Epic RARITY_END Destroy a random enemy minion. <b>Combo</b>: And your opponent's weapon.

Target: class Sabotage(SpellCard):§    def __init__(self):§        super().__init__("Sabotage", 4, CHARACTER_CLASS.ROGUE, CARD_RARITY.EPIC)§§    def use(self, player, game):§        super().use(player, game)§        targets = hearthbreaker.targeting.find_enemy_minion_battlecry_target(player.game, lambda x: True)§        target = game.random_choice(targets)§        target.die(None)§        game.check_delayed()§        if player.cards_played > 0 and game.other_player.weapon is not None:§            game.other_player.weapon.destroy()§§    def can_use(self, player, game):§        return super().can_use(player, game) and len(game.other_player.minions) >= 1§


Source: Salty Dog NAME_END 7 ATK_END 4 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Pirate RACE_END Common RARITY_END NIL

Target: class SaltyDog(MinionCard):§    def __init__(self):§        super().__init__("Salty Dog", 5, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.PIRATE)§§    def create_minion(self, player):§        return Minion(7, 4)§


Source: Seal of Light NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Common RARITY_END Restore #4 Health to your hero and gain +2 Attack this turn.

Target: class SealOfLight(SpellCard):§    def __init__(self):§        super().__init__("Seal of Light", 2, CHARACTER_CLASS.PALADIN, CARD_RARITY.COMMON)§§    def use(self, player, game):§        super().use(player, game)§        player.hero.heal(player.effective_heal_power(4), self)§        player.hero.change_temp_attack(2)§


Source: Shadowbomber NAME_END 2 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Priest PLAYER_CLS_END NIL RACE_END Epic RARITY_END <b>Battlecry:</b> Deal 3 damage to each hero.

Target: class Shadowbomber(MinionCard):§    def __init__(self):§        super().__init__("Shadowbomber", 1, CHARACTER_CLASS.PRIEST, CARD_RARITY.EPIC, battlecry=Battlecry(Damage(3), HeroSelector(players=BothPlayer())))§§    def create_minion(self, player):§        return Minion(2, 1)§


Source: Shadowboxer NAME_END 2 ATK_END 3 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Priest PLAYER_CLS_END Mech RACE_END Rare RARITY_END Whenever a character is healed, deal 1 damage to a random enemy.

Target: class Shadowboxer(MinionCard):§    def __init__(self):§        super().__init__("Shadowboxer", 2, CHARACTER_CLASS.PRIEST, CARD_RARITY.RARE, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(2, 3, effects=[Effect(CharacterHealed(player=BothPlayer()), ActionTag(Damage(1), CharacterSelector(players=EnemyPlayer(), picker=RandomPicker(), condition=None)))])§


Source: Shielded Minibot NAME_END 2 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Paladin PLAYER_CLS_END Mech RACE_END Common RARITY_END <b>Divine Shield</b>

Target: class ShieldedMinibot(MinionCard):§    def __init__(self):§        super().__init__("Shielded Minibot", 2, CHARACTER_CLASS.PALADIN, CARD_RARITY.COMMON, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(2, 2, divine_shield=True)§


Source: Shieldmaiden NAME_END 5 ATK_END 5 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Battlecry:</b> Gain 5 Armor.

Target: class Shieldmaiden(MinionCard):§    def __init__(self):§        super().__init__("Shieldmaiden", 6, CHARACTER_CLASS.WARRIOR, CARD_RARITY.RARE, battlecry=Battlecry(IncreaseArmor(5), HeroSelector()))§§    def create_minion(self, player):§        return Minion(5, 5)§


Source: Ship's Cannon NAME_END 2 ATK_END 3 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END Whenever you summon a Pirate, deal 2 damage to a random enemy.

Target: class ShipsCannon(MinionCard):§    def __init__(self):§        super().__init__("Ship's Cannon", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(2, 3, effects=[Effect(MinionSummoned(IsType(MINION_TYPE.PIRATE)), ActionTag(Damage(2), CharacterSelector(None, EnemyPlayer(), RandomPicker())))])§


Source: Shrinkmeister NAME_END 3 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Priest PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Battlecry:</b> Give a minion -2 Attack this turn.

Target: class Shrinkmeister(MinionCard):§    def __init__(self):§        super().__init__("Shrinkmeister", 2, CHARACTER_CLASS.PRIEST, CARD_RARITY.COMMON, battlecry=Battlecry(Give(BuffUntil(ChangeAttack(-2), TurnEnded(player=CurrentPlayer()))), MinionSelector(players=BothPlayer(), picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(3, 2)§


Source: Siege Engine NAME_END 5 ATK_END 5 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Warrior PLAYER_CLS_END Mech RACE_END Rare RARITY_END Whenever you gain Armor, give this minion +1 Attack.

Target: class SiegeEngine(MinionCard):§    def __init__(self):§        super().__init__("Siege Engine", 5, CHARACTER_CLASS.WARRIOR, CARD_RARITY.RARE, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(5, 5, effects=[Effect(ArmorIncreased(), ActionTag(Give(ChangeAttack(1)), SelfSelector()))])§


Source: Snowchugger NAME_END 2 ATK_END 3 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Mage PLAYER_CLS_END Mech RACE_END Common RARITY_END <b>Freeze</b> any character damaged by this minion.

Target: class Snowchugger(MinionCard):§    def __init__(self):§        super().__init__("Snowchugger", 2, CHARACTER_CLASS.MAGE, CARD_RARITY.COMMON, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(2, 3, effects=[Effect(DidDamage(), ActionTag(Give(Frozen()), TargetSelector()))])§


Source: Soot Spewer NAME_END 3 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Mage PLAYER_CLS_END Mech RACE_END Rare RARITY_END <b>Spell Damage +1</b>

Target: class SootSpewer(MinionCard):§    def __init__(self):§        super().__init__("Soot Spewer", 3, CHARACTER_CLASS.MAGE, CARD_RARITY.RARE, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(3, 3, spell_damage=1)§


Source: Spider Tank NAME_END 3 ATK_END 4 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Common RARITY_END NIL

Target: class SpiderTank(MinionCard):§    def __init__(self):§        super().__init__("Spider Tank", 3, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(3, 4)§


Source: Steamwheedle Sniper NAME_END 2 ATK_END 3 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Hunter PLAYER_CLS_END NIL RACE_END Epic RARITY_END Your Hero Power can target minions.

Target: class SteamwheedleSniper(MinionCard):§    def __init__(self):§        super().__init__("Steamwheedle Sniper", 2, CHARACTER_CLASS.HUNTER, CARD_RARITY.EPIC)§§    def create_minion(self, player):§        return Minion(2, 3, auras=[Aura(PowerTargetsMinions(), HeroSelector())])§


Source: Stonesplinter Trogg NAME_END 2 ATK_END 3 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END Whenever your opponent casts a spell, gain +1 Attack.

Target: class StonesplinterTrogg(MinionCard):§    def __init__(self):§        super().__init__("Stonesplinter Trogg", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(2, 3, effects=[Effect(SpellCast(player=EnemyPlayer()), ActionTag(Give(ChangeAttack(1)), SelfSelector()))])§


Source: Target Dummy NAME_END 0 ATK_END 2 DEF_END 0 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Rare RARITY_END <b>Taunt</b>

Target: class TargetDummy(MinionCard):§    def __init__(self):§        super().__init__("Target Dummy", 0, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(0, 2, taunt=True)§


Source: Time Rewinder NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Neutral PLAYER_CLS_END NIL RACE_END NIL RARITY_END Return a friendly minion to your hand.

Target: class TimeRewinder(SpellCard):§    def __init__(self):§        super().__init__("Time Rewinder", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, False, target_func=hearthbreaker.targeting.find_friendly_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        self.target.bounce()§


Source: Tinker's Sharpsword Oil NAME_END -1 ATK_END -1 DEF_END 4 COST_END -1 DUR_END Spell TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Common RARITY_END Give your weapon +3 Attack. <b>Combo:</b> Give a random friendly minion +3 Attack.

Target: class TinkersSharpswordOil(SpellCard):§    def __init__(self):§        super().__init__("Tinker's Sharpsword Oil", 4, CHARACTER_CLASS.ROGUE, CARD_RARITY.COMMON)§§    def use(self, player, game):§        super().use(player, game)§        player.weapon.base_attack += 3§        player.hero.change_temp_attack(3)§        if player.cards_played > 0:§            targets = hearthbreaker.targeting.find_friendly_minion_battlecry_target(player.game, lambda x: x)§            if targets is not None:§                target = player.game.random_choice(targets)§                target.add_buff(Buff(ChangeAttack(3)))§§    def can_use(self, player, game):§        return super().can_use(player, game) and player.weapon is not None§


Source: Trade Prince Gallywix NAME_END 5 ATK_END 8 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Legendary RARITY_END Whenever your opponent casts a spell, gain a copy of it and give them a Coin.

Target: class TradePrinceGallywix(MinionCard):§    def __init__(self):§        super().__init__("Trade Prince Gallywix", 6, CHARACTER_CLASS.ROGUE, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(5, 8, effects=[Effect(SpellCast(Not(HasCardName("Gallywix's Coin")), EnemyPlayer()), ActionTag(AddCard(CardQuery(source=CARD_SOURCE.LAST_CARD)), PlayerSelector(FriendlyPlayer()))), Effect(SpellCast(Not(HasCardName("Gallywix's Coin")), EnemyPlayer()), ActionTag(AddCard(GallywixsCoin()), PlayerSelector(EnemyPlayer())))])§


Source: Tree of Life NAME_END -1 ATK_END -1 DEF_END 9 COST_END -1 DUR_END Spell TYPE_END Druid PLAYER_CLS_END NIL RACE_END Epic RARITY_END Restore all characters to full Health.

Target: class TreeOfLife(SpellCard):§    def __init__(self):§        super().__init__("Tree of Life", 9, CHARACTER_CLASS.DRUID, CARD_RARITY.EPIC)§§    def use(self, player, game):§        super().use(player, game)§§        targets = copy.copy(game.other_player.minions)§        targets.extend(game.current_player.minions)§        targets.append(game.other_player.hero)§        targets.append(game.current_player.hero)§        for target in targets:§            target.heal(player.effective_heal_power(target.calculate_max_health()), self)§


Source: Troggzor the Earthinator NAME_END 6 ATK_END 6 DEF_END 7 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END Whenever your opponent casts a spell, summon a Burly Rockjaw Trogg.

Target: class TroggzorTheEarthinator(MinionCard):§    def __init__(self):§        super().__init__("Troggzor the Earthinator", 7, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(6, 6, effects=[Effect(SpellCast(player=EnemyPlayer()), ActionTag(Summon(BurlyRockjawTrogg()), PlayerSelector()))])§


Source: Unstable Portal NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Mage PLAYER_CLS_END NIL RACE_END Rare RARITY_END Add a random minion to your hand. It costs (3) less.

Target: class UnstablePortal(SpellCard):§    def __init__(self):§        super().__init__("Unstable Portal", 2, CHARACTER_CLASS.MAGE, CARD_RARITY.RARE)§§    def use(self, player, game):§        super().use(player, game)§        query = CardQuery(conditions=[IsMinion()])§        new_minon = query.get_card(player, player, self)§        new_minon.add_buff(Buff(ManaChange(-3)))§        player.hand.append(new_minon)§


Source: Upgraded Repair Bot NAME_END 5 ATK_END 5 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Priest PLAYER_CLS_END Mech RACE_END Rare RARITY_END <b>Battlecry:</b> Give a friendly Mech +4 Health.

Target: class UpgradedRepairBot(MinionCard):§    def __init__(self):§        super().__init__("Upgraded Repair Bot", 5, CHARACTER_CLASS.PRIEST, CARD_RARITY.RARE, minion_type=MINION_TYPE.MECH, battlecry=Battlecry(Give(ChangeHealth(4)), MinionSelector(IsType(MINION_TYPE.MECH), picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(5, 5)§


Source: V-07-TR-0N NAME_END 4 ATK_END 8 DEF_END 8 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Legendary RARITY_END Charge NL Mega-Windfury (Can attack four times a turn.)

Target: class V07TR0N(MinionCard):§    def __init__(self):§        super().__init__("V-07-TR-0N", 8, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, False, MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(4, 8, charge=True, buffs=[Buff(MegaWindfury())])§


Source: Velen's Chosen NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Priest PLAYER_CLS_END NIL RACE_END Common RARITY_END Give a minion +2/+4 and <b>Spell Damage +1</b>.

Target: class VelensChosen(SpellCard):§    def __init__(self):§        super().__init__("Velen's Chosen", 3, CHARACTER_CLASS.PRIEST, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§§        self.target.change_attack(2)§        self.target.increase_health(4)§        self.target.add_buff(Buff(SpellDamage(1)))§


Source: Vitality Totem NAME_END 0 ATK_END 3 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Shaman PLAYER_CLS_END Totem RACE_END Rare RARITY_END At the end of your turn, restore 4 Health to your hero.

Target: class VitalityTotem(MinionCard):§    def __init__(self):§        super().__init__("Vitality Totem", 2, CHARACTER_CLASS.SHAMAN, CARD_RARITY.RARE, minion_type=MINION_TYPE.TOTEM)§§    def create_minion(self, player):§        return Minion(0, 3, effects=[Effect(TurnEnded(), ActionTag(Heal(4), HeroSelector()))])§


Source: Wee Spellstopper NAME_END 2 ATK_END 5 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Mage PLAYER_CLS_END NIL RACE_END Epic RARITY_END Adjacent minions can't be targeted by spells or Hero Powers.

Target: class WeeSpellstopper(MinionCard):§    def __init__(self):§        super().__init__("Wee Spellstopper", 4, CHARACTER_CLASS.MAGE, CARD_RARITY.EPIC)§§    def create_minion(self, player):§        return Minion(2, 5, auras=[Aura(NoSpellTarget(), MinionSelector(Adjacent()))])§


Source: Whirling Blades NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Neutral PLAYER_CLS_END NIL RACE_END NIL RARITY_END Give a minion +1 Attack.

Target: class WhirlingBlades(SpellCard):§    def __init__(self):§        super().__init__("Whirling Blades", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, False, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        self.target.change_attack(1)§


Source: Whirling Zap-o-matic NAME_END 3 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Shaman PLAYER_CLS_END Mech RACE_END Common RARITY_END <b>Windfury</b>

Target: class WhirlingZapomatic(MinionCard):§    def __init__(self):§        super().__init__("Whirling Zap-o-matic", 2, CHARACTER_CLASS.SHAMAN, CARD_RARITY.COMMON, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, p):§        return Minion(3, 2, windfury=True)§


Source: Anub'ar Ambusher NAME_END 5 ATK_END 5 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Deathrattle:</b> Return a random friendly minion to your hand.

Target: class AnubarAmbusher(MinionCard):§    def __init__(self):§        super().__init__("Anub'ar Ambusher", 4, CHARACTER_CLASS.ROGUE, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(5, 5, deathrattle=Deathrattle(Bounce(), MinionSelector(picker=RandomPicker())))§


Source: Avenge NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Secret:</b> When one of your minions dies, give a random friendly minion +3/+2.

Target: class Avenge(SecretCard):§    def __init__(self):§        super().__init__("Avenge", 1, CHARACTER_CLASS.PALADIN, CARD_RARITY.COMMON)§§    def _reveal(self, dead_minion, attacker):§        if len([minion for minion in self.player.minions if not minion.dead]) > 0:§            target = self.player.game.random_choice(self.player.minions)§            target.change_attack(3)§            target.increase_health(2)§            super().reveal()§§    def activate(self, player):§        player.bind("minion_died", self._reveal)§§    def deactivate(self, player):§        player.unbind("minion_died", self._reveal)§


Source: Baron Rivendare NAME_END 1 ATK_END 7 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END Your minions trigger their <b>Deathrattles</b> twice.

Target: class BaronRivendare(MinionCard):§    def __init__(self):§        super().__init__("Baron Rivendare", 4, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(1, 7, auras=[Aura(DoubleDeathrattle(), PlayerSelector())])§


Source: Dancing Swords NAME_END 4 ATK_END 4 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Deathrattle:</b> Your opponent draws a card.

Target: class DancingSwords(MinionCard):§    def __init__(self):§        super().__init__("Dancing Swords", 3, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(4, 4, deathrattle=Deathrattle(Draw(), PlayerSelector(EnemyPlayer())))§


Source: Dark Cultist NAME_END 3 ATK_END 4 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Priest PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Deathrattle:</b> Give a random friendly minion +3 Health.

Target: class DarkCultist(MinionCard):§    def __init__(self):§        super().__init__("Dark Cultist", 3, CHARACTER_CLASS.PRIEST, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(3, 4, deathrattle=Deathrattle(Give(ChangeHealth(3)), MinionSelector(picker=RandomPicker())))§


Source: Duplicate NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Mage PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Secret:</b> When a friendly minion dies, put 2 copies of it into your hand.

Target: class Duplicate(SecretCard):§    def __init__(self):§        super().__init__("Duplicate", 3, CHARACTER_CLASS.MAGE, CARD_RARITY.COMMON)§        self.player = None§§    def activate(self, player):§        player.bind("minion_died", self._reveal)§        self.player = player§§    def deactivate(self, player):§        player.unbind("minion_died", self._reveal)§        self.player = None§§    def _reveal(self, minion, by):§        for c in range(0, 2):§            if len(self.player.hand) < 10:§                new_card = type(minion.card)()§                self.player.hand.append(new_card)§                new_card.attach(new_card, self.player)§        super().reveal()§


Source: Echoing Ooze NAME_END 1 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Epic RARITY_END <b>Battlecry:</b> Summon an exact copy of this minion at the end of the turn.

Target: class EchoingOoze(MinionCard):§    def __init__(self):§        super().__init__("Echoing Ooze", 2, CHARACTER_CLASS.ALL, CARD_RARITY.EPIC, battlecry=Battlecry(GiveEffect(Effect(TurnEnded(), ActionTag(Duplicate(SelfSelector()), PlayerSelector()))), PlayerSelector()))§§    def create_minion(self, player):§        return Minion(1, 2)§


Source: Feugen NAME_END 4 ATK_END 7 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END NIL

Target: class Feugen(MinionCard):§    def __init__(self):§        super().__init__("Feugen", 5, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(4, 7, deathrattle=Deathrattle(Summon(Thaddius()), PlayerSelector(), InGraveyard(Stalagg())))§


Source: Feugen NAME_END 4 ATK_END 7 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END <b>Deathrattle:</b> If Stalagg also died this game, summon Thaddius.

Target: class Feugen(MinionCard):§    def __init__(self):§        super().__init__("Feugen", 5, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(4, 7, deathrattle=Deathrattle(Summon(Thaddius()), PlayerSelector(), InGraveyard(Stalagg())))§


Source: Haunted Creeper NAME_END 1 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Beast RACE_END Common RARITY_END <b>Deathrattle:</b> Summon two 1/1 Spectral Spiders.

Target: class HauntedCreeper(MinionCard):§    def __init__(self):§        super().__init__("Haunted Creeper", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(1, 2, deathrattle=Deathrattle(Summon(SpectralSpider(), 2), PlayerSelector()))§


Source: Kel'Thuzad NAME_END 6 ATK_END 8 DEF_END 8 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END At the end of each turn, summon all friendly minions that died this turn.

Target: class KelThuzad(MinionCard):§    def __init__(self):§        super().__init__("Kel'Thuzad", 8, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(6, 8, effects=[Effect(TurnEnded(player=BothPlayer()), ActionTag(ResurrectFriendly(), PlayerSelector()))])§


Source: Loatheb NAME_END 5 ATK_END 5 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END <b>Battlecry:</b> Enemy spells cost (5) more next turn.

Target: class Loatheb(MinionCard):§    def __init__(self):§        super().__init__("Loatheb", 5, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, battlecry=Battlecry(GiveAura(AuraUntil(ManaChange(5), CardSelector(condition=IsSpell()), TurnEnded())), PlayerSelector(players=EnemyPlayer())))§§    def create_minion(self, player):§        return Minion(5, 5)§


Source: Mad Scientist NAME_END 2 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END Deathrattle: Put a Secret from your deck into the battlefield.

Target: class MadScientist(MinionCard):§    def __init__(self):§        super().__init__("Mad Scientist", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(2, 2, deathrattle=Deathrattle(ApplySecret(CARD_SOURCE.MY_DECK), PlayerSelector()))§


Source: Nerubian NAME_END 4 ATK_END 4 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END NIL RARITY_END NIL

Target: class Nerubian(MinionCard):§    def __init__(self):§        super().__init__("Nerubian", 3, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, False)§§    def create_minion(self, p):§        return Minion(4, 4)§


Source: Nerubian NAME_END 3 ATK_END 1 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END NIL RARITY_END NIL

Target: class Nerubian(MinionCard):§    def __init__(self):§        super().__init__("Nerubian", 3, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, False)§§    def create_minion(self, p):§        return Minion(4, 4)§


Source: Nerubian NAME_END 4 ATK_END 4 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END NIL

Target: class Nerubian(MinionCard):§    def __init__(self):§        super().__init__("Nerubian", 3, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, False)§§    def create_minion(self, p):§        return Minion(4, 4)§


Source: Nerubian Egg NAME_END 0 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Deathrattle:</b> Summon a 4/4 Nerubian.

Target: class NerubianEgg(MinionCard):§    def __init__(self):§        super().__init__("Nerubian Egg", 2, CHARACTER_CLASS.ALL, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(0, 2, deathrattle=Deathrattle(Summon(Nerubian()), PlayerSelector()))§


Source: Poison Seeds NAME_END -1 ATK_END -1 DEF_END 4 COST_END -1 DUR_END Spell TYPE_END Druid PLAYER_CLS_END NIL RACE_END Common RARITY_END Destroy all minions and summon 2/2 Treants to replace them.

Target: class PoisonSeeds(SpellCard):§    def __init__(self):§        super().__init__("Poison Seeds", 4, CHARACTER_CLASS.DRUID, CARD_RARITY.COMMON)§§    def use(self, player, game):§        super().use(player, game)§        from hearthbreaker.cards.minions.druid import PoisonSeedsTreant§        targets = hearthbreaker.targeting.find_minion_spell_target(game, lambda m: True)§        for target in targets:§            target.die(None)§§        game.check_delayed()§§        for target in targets:§            PoisonSeedsTreant().summon(target.player, target.game, len(target.player.minions))§


Source: Reincarnate NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Common RARITY_END Destroy a minion, then return it to life with full Health.

Target: class Reincarnate(SpellCard):§§    def __init__(self):§        super().__init__("Reincarnate", 2, CHARACTER_CLASS.SHAMAN, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        self.target.die(self)§        game.check_delayed()§        self.target.card.summon(self.target.player, game, len(self.target.player.minions))§


Source: Shade of Naxxramas NAME_END 2 ATK_END 2 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Epic RARITY_END <b>Stealth.</b> At the start of your turn, gain +1/+1.

Target: class ShadeOfNaxxramas(MinionCard):§    def __init__(self):§        super().__init__("Shade of Naxxramas", 3, CHARACTER_CLASS.ALL, CARD_RARITY.EPIC)§§    def create_minion(self, player):§        return Minion(2, 2, stealth=True, effects=[Effect(TurnStarted(), ActionTag(Give([Buff(ChangeAttack(1)), Buff(ChangeHealth(1))]), SelfSelector()))])§


Source: Slime NAME_END 1 ATK_END 2 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END NIL RARITY_END <b>Taunt</b>

Target: class Slime(MinionCard):§    def __init__(self):§        super().__init__("Slime", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, False)§§    def create_minion(self, p):§        return Minion(1, 2, taunt=True)§


Source: Spectral Spider NAME_END 1 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END NIL RARITY_END NIL

Target: class SpectralSpider(MinionCard):§    def __init__(self):§        super().__init__("Spectral Spider", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, False)§§    def create_minion(self, player):§        return Minion(1, 1)§


Source: Stalagg NAME_END 7 ATK_END 4 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END NIL

Target: class Stalagg(MinionCard):§    def __init__(self):§        super().__init__("Stalagg", 5, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(7, 4, deathrattle=Deathrattle(Summon(Thaddius()), PlayerSelector(), InGraveyard(Feugen())))§


Source: Stalagg NAME_END 7 ATK_END 4 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END <b>Deathrattle:</b> If Feugen also died this game, summon Thaddius.

Target: class Stalagg(MinionCard):§    def __init__(self):§        super().__init__("Stalagg", 5, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(7, 4, deathrattle=Deathrattle(Summon(Thaddius()), PlayerSelector(), InGraveyard(Feugen())))§


Source: Stoneskin Gargoyle NAME_END 1 ATK_END 4 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END At the start of your turn, restore this minion to full Health.

Target: class StoneskinGargoyle(MinionCard):§    def __init__(self):§        super().__init__("Stoneskin Gargoyle", 3, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(1, 4, effects=[Effect(TurnStarted(), ActionTag(Heal(10000), SelfSelector()))])§


Source: Thaddius NAME_END 11 ATK_END 11 DEF_END 10 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END NIL

Target: class Thaddius(MinionCard):§    def __init__(self):§        super().__init__("Thaddius", 10, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, False)§§    def create_minion(self, player):§        return Minion(11, 11)§


Source: Treant NAME_END 2 ATK_END 2 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Druid PLAYER_CLS_END NIL RACE_END NIL RARITY_END NIL

Target: class Treant(MinionCard):§    def __init__(self):§        super().__init__("Treant", 1, CHARACTER_CLASS.DRUID, CARD_RARITY.COMMON)§§    def create_minion(self, _):§        return Minion(2, 2)§


Source: Undertaker NAME_END 1 ATK_END 2 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END Whenever you summon a minion with <b>Deathrattle</b>, gain +1 Attack.

Target: class Undertaker(MinionCard):§    def __init__(self):§        super().__init__("Undertaker", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(1, 2, effects=[Effect(MinionSummoned(MinionHasDeathrattle()), ActionTag(Give(ChangeAttack(1)), SelfSelector()))])§


Source: Unstable Ghoul NAME_END 1 ATK_END 3 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END Taunt. Deathrattle: Deal 1 damage to all minions.

Target: class UnstableGhoul(MinionCard):§    def __init__(self):§        super().__init__("Unstable Ghoul", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(1, 3, deathrattle=Deathrattle(Damage(1), MinionSelector(players=BothPlayer())), taunt=True)§


Source: Webspinner NAME_END 1 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Hunter PLAYER_CLS_END Beast RACE_END Common RARITY_END <b>Deathrattle:</b> Add a random Beast card to your hand.

Target: class Webspinner(MinionCard):§    def __init__(self):§        super().__init__("Webspinner", 1, CHARACTER_CLASS.HUNTER, CARD_RARITY.COMMON, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(1, 1, deathrattle=Deathrattle(AddCard(CardQuery(conditions=[IsType(MINION_TYPE.BEAST)])), PlayerSelector()))§


Source: Zombie Chow NAME_END 2 ATK_END 3 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Deathrattle:</b> Restore 5 Health to the enemy hero.

Target: class ZombieChow(MinionCard):§    def __init__(self):§        super().__init__("Zombie Chow", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(2, 3, deathrattle=Deathrattle(Heal(5), HeroSelector(EnemyPlayer())))§


Source: Abomination NAME_END 4 ATK_END 4 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END Taunt. Deathrattle: Deal 2 damage to ALL characters.

Target: class Abomination(MinionCard):§    def __init__(self):§        super().__init__("Abomination", 5, CHARACTER_CLASS.ALL, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(4, 4, deathrattle=Deathrattle(Damage(2), CharacterSelector(players=BothPlayer())), taunt=True)§


Source: Abusive Sergeant NAME_END 2 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Battlecry:</b> Give a minion +2 Attack this turn.

Target: class AbusiveSergeant(MinionCard):§    def __init__(self):§        super().__init__("Abusive Sergeant", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, battlecry=Battlecry(Give(BuffUntil(ChangeAttack(2), TurnEnded(player=CurrentPlayer()))), MinionSelector(players=BothPlayer(), picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(2, 1)§


Source: Acolyte of Pain NAME_END 1 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END Whenever this minion takes damage, draw a card.

Target: class AcolyteOfPain(MinionCard):§    def __init__(self):§        super().__init__("Acolyte of Pain", 3, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(1, 3, effects=[Effect(Damaged(), ActionTag(Draw(), PlayerSelector()))])§


Source: Al'Akir the Windlord NAME_END 3 ATK_END 5 DEF_END 8 COST_END -1 DUR_END Minion TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Legendary RARITY_END <b>Windfury, Charge, Divine Shield, Taunt</b>

Target: class AlAkirTheWindlord(MinionCard):§    def __init__(self):§        super().__init__("Al'Akir the Windlord", 8, CHARACTER_CLASS.SHAMAN, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(3, 5, windfury=True, charge=True, divine_shield=True, taunt=True)§


Source: Alarm-o-Bot NAME_END 0 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Rare RARITY_END At the start of your turn, swap this minion with a random one in your hand.

Target: class AlarmoBot(MinionCard):§    def __init__(self):§        super().__init__("Alarm-o-Bot", 3, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(0, 3, effects=[Effect(TurnStarted(), ActionTag(SwapWithHand(), PlayerSelector()))])§


Source: Aldor Peacekeeper NAME_END 3 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Battlecry:</b> Change an enemy minion's Attack to 1.

Target: class AldorPeacekeeper(MinionCard):§    def __init__(self):§        super().__init__("Aldor Peacekeeper", 3, CHARACTER_CLASS.PALADIN, CARD_RARITY.RARE, battlecry=Battlecry(Give(SetAttack(1)), MinionSelector(condition=None, players=EnemyPlayer())))§§    def create_minion(self, player):§        return Minion(3, 3)§


Source: Ancestral Spirit NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Rare RARITY_END Give a minion "<b>Deathrattle:</b> Resummon this minion."

Target: class AncestralSpirit(SpellCard):§    def __init__(self):§        super().__init__("Ancestral Spirit", 2, CHARACTER_CLASS.SHAMAN, CARD_RARITY.RARE, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        self.target.deathrattle.append(Deathrattle(Summon(self.target.card), PlayerSelector()))§


Source: Ancient Brewmaster NAME_END 5 ATK_END 4 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Battlecry:</b> Return a friendly minion from the battlefield to your hand.

Target: class AncientBrewmaster(MinionCard):§    def __init__(self):§        super().__init__("Ancient Brewmaster", 4, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, battlecry=Battlecry(Bounce(), MinionSelector(picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(5, 4)§


Source: Ancient Mage NAME_END 2 ATK_END 5 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END Battlecry: Give adjacent minions Spell Damage +1.

Target: class AncientMage(MinionCard):§    def __init__(self):§        super().__init__("Ancient Mage", 4, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, battlecry=Battlecry(Give(SpellDamage(1)), MinionSelector(condition=Adjacent())))§§    def create_minion(self, player):§        return Minion(2, 5)§


Source: Ancient Watcher NAME_END 4 ATK_END 5 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END Can't attack.

Target: class AncientWatcher(MinionCard):§    def __init__(self):§        super().__init__("Ancient Watcher", 2, CHARACTER_CLASS.ALL, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(4, 5, buffs=[Buff(CantAttack())])§


Source: Ancient of Lore NAME_END 5 ATK_END 5 DEF_END 7 COST_END -1 DUR_END Minion TYPE_END Druid PLAYER_CLS_END NIL RACE_END Epic RARITY_END <b>Choose One -</b> Draw 2 cards; or Restore 5 Health.

Target: class AncientOfLore(MinionCard):§    def __init__(self):§§        super().__init__("Ancient of Lore", 7, CHARACTER_CLASS.DRUID, CARD_RARITY.EPIC, choices=[§            Choice(AncientSecrets(), Heal(5), HeroSelector()),§            Choice(AncientTeachings(), Draw(3), PlayerSelector())§        ])§§    def create_minion(self, player):§        return Minion(5, 5)§


Source: Ancient of War NAME_END 5 ATK_END 5 DEF_END 7 COST_END -1 DUR_END Minion TYPE_END Druid PLAYER_CLS_END NIL RACE_END Epic RARITY_END Choose One - NL +5 Attack; or +5 Health and Taunt.

Target: class AncientOfWar(MinionCard):§    def __init__(self):§§        super().__init__("Ancient of War", 7, CHARACTER_CLASS.DRUID, CARD_RARITY.EPIC, choices=[§            Choice(Health(), Give([Buff(ChangeHealth(5)), Buff(Taunt())]), SelfSelector()),§            Choice(Attack(), Give([Buff(ChangeAttack(5))]), SelfSelector()),§        ])§§    def create_minion(self, player):§        return Minion(5, 5)§


Source: Angry Chicken NAME_END 1 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Beast RACE_END Rare RARITY_END <b>Enrage:</b> +5 Attack.

Target: class AngryChicken(MinionCard):§    def __init__(self):§        super().__init__("Angry Chicken", 1, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(1, 1, enrage=[Aura(ChangeAttack(5), SelfSelector())])§


Source: Arathi Weaponsmith NAME_END 3 ATK_END 3 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Battlecry:</b> Equip a 2/2 weapon.

Target: class ArathiWeaponsmith(MinionCard):§    def __init__(self):§        super().__init__("Arathi Weaponsmith", 4, CHARACTER_CLASS.WARRIOR, CARD_RARITY.COMMON, battlecry=Battlecry(Equip(BattleAxe()), PlayerSelector()))§§    def create_minion(self, player):§        return Minion(3, 3)§


Source: Argent Commander NAME_END 4 ATK_END 2 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END Charge NL Divine Shield

Target: class ArgentCommander(MinionCard):§    def __init__(self):§        super().__init__("Argent Commander", 6, CHARACTER_CLASS.ALL, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(4, 2, divine_shield=True, charge=True)§


Source: Argent Protector NAME_END 2 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Common RARITY_END Battlecry: Give a friendly minion Divine Shield.

Target: class ArgentProtector(MinionCard):§    def __init__(self):§        super().__init__("Argent Protector", 2, CHARACTER_CLASS.PALADIN, CARD_RARITY.COMMON, battlecry=Battlecry(Give(DivineShield()), MinionSelector()))§§    def create_minion(self, player):§        return Minion(2, 2)§


Source: Argent Squire NAME_END 1 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Divine Shield</b>

Target: class ArgentSquire(MinionCard):§    def __init__(self):§        super().__init__("Argent Squire", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(1, 1, divine_shield=True)§


Source: Armorsmith NAME_END 1 ATK_END 4 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Rare RARITY_END Whenever a friendly minion takes damage, gain 1 Armor.

Target: class Armorsmith(MinionCard):§    def __init__(self):§        super().__init__("Armorsmith", 2, CHARACTER_CLASS.WARRIOR, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(1, 4, effects=[Effect(CharacterDamaged(condition=IsMinion()), ActionTag(IncreaseArmor(), HeroSelector()))])§


Source: Ashbringer NAME_END 5 ATK_END -1 DEF_END 5 COST_END 3 DUR_END Weapon TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Legendary RARITY_END NIL

Target: class Ashbringer(WeaponCard):§    def __init__(self):§        super().__init__("Ashbringer", 5, CHARACTER_CLASS.PALADIN, CARD_RARITY.LEGENDARY, False)§§    def create_weapon(self, player):§        weapon = Weapon(5, 3)§        return weapon§


Source: Auchenai Soulpriest NAME_END 3 ATK_END 5 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Priest PLAYER_CLS_END NIL RACE_END Rare RARITY_END Your cards and powers that restore Health now deal damage instead.

Target: class AuchenaiSoulpriest(MinionCard):§    def __init__(self):§        super().__init__("Auchenai Soulpriest", 4, CHARACTER_CLASS.PRIEST, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(3, 5, auras=[Aura(HealAsDamage(), PlayerSelector())])§


Source: Avenging Wrath NAME_END -1 ATK_END -1 DEF_END 6 COST_END -1 DUR_END Spell TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Epic RARITY_END Deal $8 damage randomly split among all enemies.

Target: class AvengingWrath(SpellCard):§    def __init__(self):§        super().__init__("Avenging Wrath", 6, CHARACTER_CLASS.PALADIN, CARD_RARITY.EPIC)§§    def use(self, player, game):§        super().use(player, game)§        for i in range(0, player.effective_spell_damage(8)):§            targets = copy.copy(game.other_player.minions)§            targets.append(game.other_player.hero)§            target = game.random_choice(targets)§            target.damage(1, self)§


Source: Azure Drake NAME_END 4 ATK_END 4 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Dragon RACE_END Rare RARITY_END Spell Damage +1. Battlecry: Draw a card.

Target: class AzureDrake(MinionCard):§    def __init__(self):§        super().__init__("Azure Drake", 5, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, minion_type=MINION_TYPE.DRAGON, battlecry=Battlecry(Draw(), PlayerSelector()))§§    def create_minion(self, player):§        return Minion(4, 4, spell_damage=1)§


Source: Bane of Doom NAME_END -1 ATK_END -1 DEF_END 5 COST_END -1 DUR_END Spell TYPE_END Warlock PLAYER_CLS_END NIL RACE_END Epic RARITY_END Deal $2 damage to a character. If that kills it, summon a random Demon.

Target: class BaneOfDoom(SpellCard):§    def __init__(self):§        super().__init__("Bane of Doom", 5, CHARACTER_CLASS.WARLOCK, CARD_RARITY.EPIC, target_func=hearthbreaker.targeting.find_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        if self.target.health <= player.effective_spell_damage(2) and \ (isinstance(self.target, Minion) and not self.target.divine_shield):§            self.target.damage(player.effective_spell_damage(2), self)§            demons = CardQuery(conditions=[IsType(MINION_TYPE.DEMON)])§            demons.get_card(player, player, self).summon(player, game, len(player.minions))§        else:§            self.target.damage(player.effective_spell_damage(2), self)§


Source: Baron Geddon NAME_END 7 ATK_END 5 DEF_END 7 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END At the end of your turn, deal 2 damage to ALL other characters.

Target: class BaronGeddon(MinionCard):§    def __init__(self):§        super().__init__("Baron Geddon", 7, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(7, 5, effects=[Effect(TurnEnded(), ActionTag(Damage(2), CharacterSelector(players=BothPlayer())))])§


Source: Battle Axe NAME_END 2 ATK_END -1 DEF_END 1 COST_END 2 DUR_END Weapon TYPE_END Warrior PLAYER_CLS_END NIL RACE_END NIL RARITY_END NIL

Target: class BattleAxe(WeaponCard):§    def __init__(self):§        super().__init__("Battle Axe", 1, CHARACTER_CLASS.WARRIOR, CARD_RARITY.COMMON, False)§§    def create_weapon(self, player):§        return Weapon(2, 2)§


Source: Battle Rage NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Common RARITY_END Draw a card for each damaged friendly character.

Target: class BattleRage(SpellCard):§    def __init__(self):§        super().__init__("Battle Rage", 2, CHARACTER_CLASS.WARRIOR, CARD_RARITY.COMMON)§§    def use(self, player, game):§        def damaged_character(character):§            return character.health < character.calculate_max_health()§§        super().use(player, game)§§        characters = copy.copy(player.minions)§        characters.append(player.hero)§§        characters = [character for character in characters if damaged_character(character)]§§        for i in range(0, len(characters)):§            player.draw()§


Source: Bestial Wrath NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Hunter PLAYER_CLS_END NIL RACE_END Epic RARITY_END Give a friendly Beast +2 Attack and <b>Immune</b> this turn.

Target: class BestialWrath(SpellCard):§    def __init__(self):§        super().__init__("Bestial Wrath", 1, CHARACTER_CLASS.HUNTER, CARD_RARITY.EPIC, target_func=hearthbreaker.targeting.find_friendly_minion_spell_target, filter_func=lambda minion: minion.card.minion_type is MINION_TYPE.BEAST and minion.spell_targetable())§§    def use(self, player, game):§        super().use(player, game)§        self.target.add_buff(BuffUntil(Immune(), TurnEnded(player=CurrentPlayer())))§        self.target.change_temp_attack(2)§


Source: Betrayal NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Common RARITY_END Force an enemy minion to deal its damage to the minions next to it.

Target: class Betrayal(SpellCard):§    def __init__(self):§        super().__init__("Betrayal", 2, CHARACTER_CLASS.ROGUE, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_enemy_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§§        left_minion = None§        right_minion = None§§        index = self.target.index§        if index > 0:§            left_minion = game.other_player.minions[index - 1]§        if index < min(len(game.other_player.minions) - 1, 6):§            right_minion = game.other_player.minions[index + 1]§§        original_immune = self.target.immune§        self.target.immune = True§        if left_minion is not None:§            left_minion.damage(self.target.calculate_attack(), self.target)§        if right_minion is not None:§            right_minion.damage(self.target.calculate_attack(), self.target)§        self.target.immune = original_immune§


Source: Big Game Hunter NAME_END 4 ATK_END 2 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Epic RARITY_END <b>Battlecry:</b> Destroy a minion with an Attack of 7 or more.

Target: class BigGameHunter(MinionCard):§    def __init__(self):§        super().__init__("Big Game Hunter", 3, CHARACTER_CLASS.ALL, CARD_RARITY.EPIC, battlecry=Battlecry(Kill(), MinionSelector(AttackGreaterThan(6), BothPlayer())))§§    def create_minion(self, player):§        return Minion(4, 2)§


Source: Bite NAME_END -1 ATK_END -1 DEF_END 4 COST_END -1 DUR_END Spell TYPE_END Druid PLAYER_CLS_END NIL RACE_END Rare RARITY_END Give your hero +4 Attack this turn and 4 Armor.

Target: class Bite(SpellCard):§    def __init__(self):§        super().__init__("Bite", 4, CHARACTER_CLASS.DRUID, CARD_RARITY.RARE)§§    def use(self, player, game):§        super().use(player, game)§        player.hero.change_temp_attack(4)§        player.hero.increase_armor(4)§


Source: Blessing of Wisdom NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Common RARITY_END Choose a minion. Whenever it attacks, draw a card.

Target: class BlessingOfWisdom(SpellCard):§    def __init__(self):§        super().__init__("Blessing of Wisdom", 1, CHARACTER_CLASS.PALADIN, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        if player is game.players[0]:§            draw_player = PlayerOne()§        else:§            draw_player = PlayerTwo()§        self.target.add_effect(Effect(Attack(), ActionTag(Draw(), PlayerSelector(draw_player))))§


Source: Blizzard NAME_END -1 ATK_END -1 DEF_END 6 COST_END -1 DUR_END Spell TYPE_END Mage PLAYER_CLS_END NIL RACE_END Rare RARITY_END Deal $2 damage to all enemy minions and <b>Freeze</b> them.

Target: class Blizzard(SpellCard):§    def __init__(self):§        super().__init__("Blizzard", 6, CHARACTER_CLASS.MAGE, CARD_RARITY.RARE)§§    def use(self, player, game):§        super().use(player, game)§        for minion in copy.copy(game.other_player.minions):§            minion.damage(player.effective_spell_damage(2), self)§        for minion in game.other_player.minions:§            minion.add_buff(Buff(Frozen()))§


Source: Blood Fury NAME_END 3 ATK_END -1 DEF_END 3 COST_END 8 DUR_END Weapon TYPE_END Warlock PLAYER_CLS_END NIL RACE_END NIL RARITY_END NIL

Target: class BloodFury(WeaponCard):§    def __init__(self):§        super().__init__("Blood Fury", 3, CHARACTER_CLASS.WARLOCK, CARD_RARITY.RARE, False)§§    def create_weapon(self, player):§        return Weapon(3, 8)§


Source: Blood Imp NAME_END 0 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Warlock PLAYER_CLS_END Demon RACE_END Common RARITY_END <b>Stealth</b>. At the end of your turn, give another random friendly minion +1 Health.

Target: class BloodImp(MinionCard):§    def __init__(self):§        super().__init__("Blood Imp", 1, CHARACTER_CLASS.WARLOCK, CARD_RARITY.COMMON, minion_type=MINION_TYPE.DEMON)§§    def create_minion(self, player):§        return Minion(0, 1, stealth=True, effects=[Effect(TurnEnded(), ActionTag(Give(ChangeHealth(1)), MinionSelector(picker=RandomPicker())))])§


Source: Blood Knight NAME_END 3 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Epic RARITY_END Battlecry: All minions lose Divine Shield. Gain +3/+3 for each Shield lost.

Target: class BloodKnight(MinionCard):§    def __init__(self):§        super().__init__("Blood Knight", 3, CHARACTER_CLASS.ALL, CARD_RARITY.EPIC, battlecry=(Battlecry([Give([Buff(ChangeAttack(Count(MinionSelector(HasDivineShield(), BothPlayer())), 3)), Buff(ChangeHealth(Count(MinionSelector(HasDivineShield(), BothPlayer())), 3))])], SelfSelector()), Battlecry(RemoveDivineShields(), (MinionSelector(HasDivineShield(), BothPlayer())))))§§    def create_minion(self, player):§        return Minion(3, 3)§


Source: Bloodmage Thalnos NAME_END 1 ATK_END 1 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END Spell Damage +1. Deathrattle: Draw a card.

Target: class BloodmageThalnos(MinionCard):§    def __init__(self):§        super().__init__("Bloodmage Thalnos", 2, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(1, 1, spell_damage=1, deathrattle=Deathrattle(Draw(), PlayerSelector()))§


Source: Bloodsail Corsair NAME_END 1 ATK_END 2 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Pirate RACE_END Rare RARITY_END <b>Battlecry:</b> Remove 1 Durability from your opponent's weapon.

Target: class BloodsailCorsair(MinionCard):§    def __init__(self):§        super().__init__("Bloodsail Corsair", 1, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, minion_type=MINION_TYPE.PIRATE, battlecry=Battlecry(DecreaseDurability(), WeaponSelector(EnemyPlayer())))§§    def create_minion(self, player):§        return Minion(1, 2)§


Source: Bloodsail Raider NAME_END 2 ATK_END 3 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Pirate RACE_END Common RARITY_END <b>Battlecry:</b> Gain Attack equal to the Attack of your weapon.

Target: class BloodsailRaider(MinionCard):§    def __init__(self):§        super().__init__("Bloodsail Raider", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.PIRATE, battlecry=Battlecry(Give(Buff(ChangeAttack(Attribute("base_attack", WeaponSelector())))), SelfSelector()))§§    def create_minion(self, player):§        return Minion(2, 3)§


Source: Cairne Bloodhoof NAME_END 4 ATK_END 5 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END <b>Deathrattle:</b> Summon a 4/5 Baine Bloodhoof.

Target: class CairneBloodhoof(MinionCard):§    def __init__(self):§        super().__init__("Cairne Bloodhoof", 6, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY)§§    def create_minion(self, player):§        return Minion(4, 5, deathrattle=Deathrattle(Summon(BaineBloodhoof()), PlayerSelector()))§


Source: Captain Greenskin NAME_END 5 ATK_END 4 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Pirate RACE_END Legendary RARITY_END <b>Battlecry:</b> Give your weapon +1/+1.

Target: class CaptainGreenskin(MinionCard):§    def __init__(self):§        super().__init__("Captain Greenskin", 5, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, minion_type=MINION_TYPE.PIRATE, battlecry=Battlecry([IncreaseWeaponAttack(1), IncreaseDurability()], WeaponSelector()))§§    def create_minion(self, player):§        return Minion(5, 4)§


Source: Cenarius NAME_END 5 ATK_END 8 DEF_END 9 COST_END -1 DUR_END Minion TYPE_END Druid PLAYER_CLS_END NIL RACE_END Legendary RARITY_END Choose One - Give your other minions +2/+2; or Summon two 2/2 Treants with Taunt.

Target: class Cenarius(MinionCard):§    def __init__(self):§        super().__init__("Cenarius", 9, CHARACTER_CLASS.DRUID, CARD_RARITY.LEGENDARY, choices=[§            Choice(IncreaseStats(), Give([Buff(ChangeAttack(2)), Buff(ChangeHealth(2)), Buff(Taunt())]), MinionSelector()),§            Choice(SummonTreants(), Summon(TauntTreant(), 2), PlayerSelector())§        ])§§    def create_minion(self, player):§        return Minion(5, 8)§


Source: Circle of Healing NAME_END -1 ATK_END -1 DEF_END 0 COST_END -1 DUR_END Spell TYPE_END Priest PLAYER_CLS_END NIL RACE_END Common RARITY_END Restore #4 Health to ALL minions.

Target: class CircleOfHealing(SpellCard):§    def __init__(self):§        super().__init__("Circle of Healing", 0, CHARACTER_CLASS.PRIEST, CARD_RARITY.COMMON)§§    def use(self, player, game):§        super().use(player, game)§§        targets = copy.copy(game.other_player.minions)§        targets.extend(player.minions)§§        for minion in targets:§            minion.heal(player.effective_heal_power(4), self)§


Source: Cold Blood NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Common RARITY_END Give a minion +2 Attack. <b>Combo:</b> +4 Attack instead.

Target: class ColdBlood(SpellCard):§    def __init__(self):§        super().__init__("Cold Blood", 1, CHARACTER_CLASS.ROGUE, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§§        if player.cards_played > 0:§            self.target.change_attack(4)§        else:§            self.target.change_attack(2)§


Source: Coldlight Oracle NAME_END 2 ATK_END 2 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Murloc RACE_END Rare RARITY_END <b>Battlecry:</b> Each player draws 2 cards.

Target: class ColdlightOracle(MinionCard):§    def __init__(self):§        super().__init__("Coldlight Oracle", 3, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, minion_type=MINION_TYPE.MURLOC, battlecry=Battlecry(Draw(2), PlayerSelector(players=BothPlayer())))§§    def create_minion(self, player):§        return Minion(2, 2)§


Source: Coldlight Seer NAME_END 2 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Murloc RACE_END Rare RARITY_END <b>Battlecry:</b> Give ALL other Murlocs +2 Health.

Target: class ColdlightSeer(MinionCard):§    def __init__(self):§        super().__init__("Coldlight Seer", 3, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, minion_type=MINION_TYPE.MURLOC, battlecry=Battlecry(Give(ChangeHealth(2)), MinionSelector(IsType(MINION_TYPE.MURLOC), BothPlayer())))§§    def create_minion(self, player):§        return Minion(2, 3)§


Source: Commanding Shout NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Rare RARITY_END Your minions can't be reduced below 1 Health this turn. Draw a card.

Target: class CommandingShout(SpellCard):§    def __init__(self):§        super().__init__("Commanding Shout", 2, CHARACTER_CLASS.WARRIOR, CARD_RARITY.RARE)§§    def use(self, player, game):§        super().use(player, game)§        player.add_aura(AuraUntil(MinimumHealth(1), MinionSelector(), TurnEnded()))§§        player.draw()§


Source: Counterspell NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Mage PLAYER_CLS_END NIL RACE_END Rare RARITY_END Secret: When your opponent casts a spell, Counter it.

Target: class Counterspell(SecretCard):§    def __init__(self):§        super().__init__("Counterspell", 3, CHARACTER_CLASS.MAGE, CARD_RARITY.RARE)§§    def use(self, player, game):§        super().use(player, game)§§    def _reveal(self, card, index):§        if card.is_spell():§            card.cancel = True§            super().reveal()§§    def activate(self, player):§        player.game.current_player.bind("card_played", self._reveal)§§    def deactivate(self, player):§        player.game.current_player.unbind("card_played", self._reveal)§


Source: Crazed Alchemist NAME_END 2 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Rare RARITY_END <b>Battlecry:</b> Swap the Attack and Health of a minion.

Target: class CrazedAlchemist(MinionCard):§    def __init__(self):§        super().__init__("Crazed Alchemist", 2, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, battlecry=Battlecry(SwapStats('health', 'attack', False), MinionSelector(players=BothPlayer(), picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(2, 2)§


Source: Cruel Taskmaster NAME_END 2 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Warrior PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Battlecry:</b> Deal 1 damage to a minion and give it +2 Attack.

Target: class CruelTaskmaster(MinionCard):§    def __init__(self):§        super().__init__("Cruel Taskmaster", 2, CHARACTER_CLASS.WARRIOR, CARD_RARITY.COMMON, battlecry=Battlecry([Damage(1), Give(ChangeAttack(2))], MinionSelector(players=BothPlayer(), picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(2, 2)§


Source: Cult Master NAME_END 4 ATK_END 2 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END Whenever one of your other minions dies, draw a card.

Target: class CultMaster(MinionCard):§    def __init__(self):§        super().__init__("Cult Master", 4, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(4, 2, effects=[Effect(MinionDied(), ActionTag(Draw(), PlayerSelector()))])§


Source: Damaged Golem NAME_END 2 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Common RARITY_END NIL

Target: class DamagedGolem(MinionCard):§    def __init__(self):§        super().__init__("Damaged Golem", 1, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, False, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(2, 1)§


Source: Dark Iron Dwarf NAME_END 4 ATK_END 4 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Battlecry:</b> Give a minion +2 Attack this turn.

Target: class DarkIronDwarf(MinionCard):§    def __init__(self):§        super().__init__("Dark Iron Dwarf", 4, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, battlecry=Battlecry(Give(BuffUntil(ChangeAttack(2), TurnEnded(player=CurrentPlayer()))), MinionSelector(players=BothPlayer(), picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(4, 4)§


Source: Deadly Shot NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Hunter PLAYER_CLS_END NIL RACE_END Common RARITY_END Destroy a random enemy minion.

Target: class DeadlyShot(SpellCard):§    def __init__(self):§        super().__init__("Deadly Shot", 3, CHARACTER_CLASS.HUNTER, CARD_RARITY.COMMON)§§    def use(self, player, game):§        super().use(player, game)§        targets = hearthbreaker.targeting.find_enemy_minion_battlecry_target(player.game, lambda x: True)§        target = game.random_choice(targets)§        target.die(None)§        game.check_delayed()§§    def can_use(self, player, game):§        return super().can_use(player, game) and len(game.other_player.minions) >= 1§


Source: Deathwing NAME_END 12 ATK_END 12 DEF_END 10 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Dragon RACE_END Legendary RARITY_END <b>Battlecry:</b> Destroy all other minions and discard your hand.

Target: class Deathwing(MinionCard):§    def __init__(self):§        super().__init__("Deathwing", 10, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, minion_type=MINION_TYPE.DRAGON, battlecry=(Battlecry(Kill(), MinionSelector(players=BothPlayer())), Battlecry(Discard(amount=Count(CardSelector())), PlayerSelector())))§§    def create_minion(self, player):§        return Minion(12, 12)§


Source: Defias Bandit NAME_END 2 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Rogue PLAYER_CLS_END NIL RACE_END NIL RARITY_END NIL

Target: class DefiasBandit(MinionCard):§    def __init__(self):§        super().__init__("Defias Bandit", 1, CHARACTER_CLASS.ROGUE, CARD_RARITY.COMMON, False)§§    def create_minion(self, player):§        return Minion(2, 1)§


Source: Defias Ringleader NAME_END 2 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Combo:</b> Summon a 2/1 Defias Bandit.

Target: class DefiasRingleader(MinionCard):§    def __init__(self):§        super().__init__("Defias Ringleader", 2, CHARACTER_CLASS.ROGUE, CARD_RARITY.COMMON, combo=Battlecry(Summon(DefiasBandit()), PlayerSelector()))§§    def create_minion(self, player):§        return Minion(2, 2)§


Source: Demolisher NAME_END 1 ATK_END 4 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Mech RACE_END Rare RARITY_END At the start of your turn, deal 2 damage to a random enemy.

Target: class Demolisher(MinionCard):§    def __init__(self):§        super().__init__("Demolisher", 3, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, minion_type=MINION_TYPE.MECH)§§    def create_minion(self, player):§        return Minion(1, 4, effects=[Effect(TurnStarted(), ActionTag(Damage(2), CharacterSelector(players=EnemyPlayer(), picker=RandomPicker())))])§


Source: Demonfire NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Warlock PLAYER_CLS_END NIL RACE_END Common RARITY_END Deal $2 damage to a minion. If it’s a friendly Demon, give it +2/+2 instead.

Target: class Demonfire(SpellCard):§    def __init__(self):§        super().__init__("Demonfire", 2, CHARACTER_CLASS.WARLOCK, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        targets = copy.copy(player.game.current_player.minions)§        if self.target.card.minion_type is MINION_TYPE.DEMON and self.target in targets:§            self.target.change_attack(2)§            self.target.increase_health(2)§        else:§            self.target.damage(player.effective_spell_damage(2), self)§


Source: Demonfire NAME_END -1 ATK_END -1 DEF_END 0 COST_END -1 DUR_END Enchantment TYPE_END Warlock PLAYER_CLS_END NIL RACE_END Common RARITY_END This Demon has +2/+2.

Target: class Demonfire(SpellCard):§    def __init__(self):§        super().__init__("Demonfire", 2, CHARACTER_CLASS.WARLOCK, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        targets = copy.copy(player.game.current_player.minions)§        if self.target.card.minion_type is MINION_TYPE.DEMON and self.target in targets:§            self.target.change_attack(2)§            self.target.increase_health(2)§        else:§            self.target.damage(player.effective_spell_damage(2), self)§


Source: Devilsaur NAME_END 5 ATK_END 5 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Beast RACE_END Common RARITY_END NIL

Target: class Devilsaur(MinionCard):§    def __init__(self):§        super().__init__("Devilsaur", 5, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, False, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(5, 5)§


Source: Dire Wolf Alpha NAME_END 2 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Beast RACE_END Common RARITY_END Adjacent minions have +1 Attack.

Target: class DireWolfAlpha(MinionCard):§    def __init__(self):§        super().__init__("Dire Wolf Alpha", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(2, 2, auras=[Aura(ChangeAttack(1), MinionSelector(Adjacent()))])§


Source: Divine Favor NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Rare RARITY_END Draw cards until you have as many in hand as your opponent.

Target: class DivineFavor(SpellCard):§    def __init__(self):§        super().__init__("Divine Favor", 3, CHARACTER_CLASS.PALADIN, CARD_RARITY.RARE)§§    def use(self, player, game):§        super().use(player, game)§        difference = len(game.other_player.hand) - len(player.hand)§        for i in range(0, difference):§            player.draw()§


Source: Doomsayer NAME_END 0 ATK_END 7 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Epic RARITY_END At the start of your turn, destroy ALL minions.

Target: class Doomsayer(MinionCard):§    def __init__(self):§        super().__init__("Doomsayer", 2, CHARACTER_CLASS.ALL, CARD_RARITY.EPIC)§§    def create_minion(self, player):§        return Minion(0, 7, effects=[Effect(TurnStarted(), ActionTag(Kill(), MinionSelector(condition=None, players=BothPlayer())))])§


Source: Dread Corsair NAME_END 3 ATK_END 3 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Pirate RACE_END Common RARITY_END <b>Taunt.</b> Costs (1) less per Attack of your weapon.

Target: class DreadCorsair(MinionCard):§    def __init__(self):§        super().__init__("Dread Corsair", 4, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.PIRATE, buffs=[Buff(ManaChange(Attribute("attack", WeaponSelector()), -1))])§§    def create_minion(self, player):§        return Minion(3, 3, taunt=True)§


Source: Dream NAME_END -1 ATK_END -1 DEF_END 0 COST_END -1 DUR_END Spell TYPE_END Dream PLAYER_CLS_END NIL RACE_END NIL RARITY_END Return a minion to its owner's hand.

Target: class Dream(SpellCard):§    def __init__(self):§        super().__init__("Dream", 0, CHARACTER_CLASS.DREAM, CARD_RARITY.COMMON, False, hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§        self.target.bounce()§


Source: Druid of the Claw NAME_END 4 ATK_END 6 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Druid PLAYER_CLS_END Beast RACE_END Common RARITY_END <b>Taunt</b>

Target: class DruidOfTheClaw(MinionCard):§    def __init__(self):§        super().__init__("Druid of the Claw", 5, CHARACTER_CLASS.DRUID, CARD_RARITY.COMMON, choices=[§            Choice(CatForm(), Transform(CatDruid()), SelfSelector()),§            Choice(BearForm(), Transform(BearDruid()), SelfSelector())§        ])§§    def create_minion(self, player):§        return Minion(4, 4)§


Source: Druid of the Claw NAME_END 4 ATK_END 4 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Druid PLAYER_CLS_END NIL RACE_END Common RARITY_END Choose One - Charge; or +2 Health and Taunt.

Target: class DruidOfTheClaw(MinionCard):§    def __init__(self):§        super().__init__("Druid of the Claw", 5, CHARACTER_CLASS.DRUID, CARD_RARITY.COMMON, choices=[§            Choice(CatForm(), Transform(CatDruid()), SelfSelector()),§            Choice(BearForm(), Transform(BearDruid()), SelfSelector())§        ])§§    def create_minion(self, player):§        return Minion(4, 4)§


Source: Druid of the Claw NAME_END 4 ATK_END 4 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Druid PLAYER_CLS_END Beast RACE_END Common RARITY_END <b>Charge</b>

Target: class DruidOfTheClaw(MinionCard):§    def __init__(self):§        super().__init__("Druid of the Claw", 5, CHARACTER_CLASS.DRUID, CARD_RARITY.COMMON, choices=[§            Choice(CatForm(), Transform(CatDruid()), SelfSelector()),§            Choice(BearForm(), Transform(BearDruid()), SelfSelector())§        ])§§    def create_minion(self, player):§        return Minion(4, 4)§


Source: Dust Devil NAME_END 3 ATK_END 1 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Common RARITY_END Windfury. Overload: (2)

Target: class DustDevil(MinionCard):§    def __init__(self):§        super().__init__("Dust Devil", 1, CHARACTER_CLASS.SHAMAN, CARD_RARITY.COMMON, overload=2)§§    def create_minion(self, player):§        return Minion(3, 1, windfury=True)§


Source: Eaglehorn Bow NAME_END 3 ATK_END -1 DEF_END 3 COST_END 2 DUR_END Weapon TYPE_END Hunter PLAYER_CLS_END NIL RACE_END Rare RARITY_END Whenever a friendly <b>Secret</b> is revealed, gain +1 Durability.

Target: class EaglehornBow(WeaponCard):§    def __init__(self):§        super().__init__("Eaglehorn Bow", 3, CHARACTER_CLASS.HUNTER, CARD_RARITY.RARE)§§    def create_weapon(self, player):§        return Weapon(3, 2, effects=[Effect(SecretRevealed(), ActionTag(IncreaseDurability(), WeaponSelector()))])§


Source: Earthen Ring Farseer NAME_END 3 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Battlecry:</b> Restore 3 Health.

Target: class EarthenRingFarseer(MinionCard):§    def __init__(self):§        super().__init__("Earthen Ring Farseer", 3, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, battlecry=Battlecry(Heal(3), CharacterSelector(players=BothPlayer(), picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(3, 3)§


Source: Edwin VanCleef NAME_END 2 ATK_END 2 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Legendary RARITY_END <b>Combo:</b> Gain +2/+2 for each card played earlier this turn.

Target: class EdwinVanCleef(MinionCard):§    def __init__(self):§        super().__init__("Edwin VanCleef", 3, CHARACTER_CLASS.ROGUE, CARD_RARITY.LEGENDARY, battlecry=Battlecry(Give([Buff(ChangeAttack(Attribute("cards_played", PlayerSelector()), 2)), Buff(ChangeHealth(Attribute("cards_played", PlayerSelector()), 2))]), SelfSelector()))§§    def create_minion(self, player):§        return Minion(2, 2)§


Source: Emerald Drake NAME_END 7 ATK_END 6 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Dream PLAYER_CLS_END Dragon RACE_END NIL RARITY_END NIL

Target: class EmeraldDrake(MinionCard):§    def __init__(self):§        super().__init__("Emerald Drake", 4, CHARACTER_CLASS.DREAM, CARD_RARITY.COMMON, False, MINION_TYPE.DRAGON)§§    def create_minion(self, player):§        return Minion(7, 6)§


Source: Emperor Cobra NAME_END 2 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Beast RACE_END Rare RARITY_END Destroy any minion damaged by this minion.

Target: class EmperorCobra(MinionCard):§    def __init__(self):§        super().__init__("Emperor Cobra", 3, CHARACTER_CLASS.ALL, CARD_RARITY.RARE, minion_type=MINION_TYPE.BEAST)§§    def create_minion(self, player):§        return Minion(2, 3, effects=[Effect(DidDamage(), ActionTag(Kill(), TargetSelector(IsMinion())))])§


Source: Equality NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Paladin PLAYER_CLS_END NIL RACE_END Rare RARITY_END Change the Health of ALL minions to 1.

Target: class Equality(SpellCard):§    def __init__(self):§        super().__init__("Equality", 2, CHARACTER_CLASS.PALADIN, CARD_RARITY.RARE)§§    def use(self, player, game):§        super().use(player, game)§§        targets = copy.copy(game.other_player.minions)§        targets.extend(player.minions)§§        for minion in targets:§            minion.set_health_to(1)§§    def can_use(self, player, game):§        return super().can_use(player, game) and (len(player.minions) > 0 or len(game.other_player.minions) > 0)§


Source: Ethereal Arcanist NAME_END 3 ATK_END 3 DEF_END 4 COST_END -1 DUR_END Minion TYPE_END Mage PLAYER_CLS_END NIL RACE_END Rare RARITY_END If you control a <b>Secret</b> at the end of your turn, gain +2/+2.

Target: class EtherealArcanist(MinionCard):§    def __init__(self):§        super().__init__("Ethereal Arcanist", 4, CHARACTER_CLASS.MAGE, CARD_RARITY.RARE)§§    def create_minion(self, player):§        return Minion(3, 3, effects=[Effect(TurnEnded(HasSecret()), ActionTag(Give(ChangeAttack(2)), SelfSelector())), Effect(TurnEnded(HasSecret()), ActionTag(Give(ChangeHealth(2)), SelfSelector()))])§


Source: Eviscerate NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Rogue PLAYER_CLS_END NIL RACE_END Common RARITY_END Deal $2 damage. <b>Combo:</b> Deal $4 damage instead.

Target: class Eviscerate(SpellCard):§    def __init__(self):§        super().__init__("Eviscerate", 2, CHARACTER_CLASS.ROGUE, CARD_RARITY.COMMON, target_func=hearthbreaker.targeting.find_spell_target)§§    def use(self, player, game):§        super().use(player, game)§§        if player.cards_played > 0:§            self.target.damage(player.effective_spell_damage(4), self)§        else:§            self.target.damage(player.effective_spell_damage(2), self)§


Source: Explosive Shot NAME_END -1 ATK_END -1 DEF_END 5 COST_END -1 DUR_END Spell TYPE_END Hunter PLAYER_CLS_END NIL RACE_END Rare RARITY_END Deal $5 damage to a minion and $2 damage to adjacent ones.

Target: class ExplosiveShot(SpellCard):§    def __init__(self):§        super().__init__("Explosive Shot", 5, CHARACTER_CLASS.HUNTER, CARD_RARITY.RARE, target_func=hearthbreaker.targeting.find_minion_spell_target)§§    def use(self, player, game):§        super().use(player, game)§§        index = self.target.index§        if self.target.index < len(self.target.player.minions) - 1:§            minion = self.target.player.minions[index + 1]§            minion.damage(player.effective_spell_damage(2), self)§§        self.target.damage(player.effective_spell_damage(5), self)§§        if self.target.index > 0:§            minion = self.target.player.minions[index - 1]§            minion.damage(player.effective_spell_damage(2), self)§


Source: Faceless Manipulator NAME_END 3 ATK_END 3 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Epic RARITY_END <b>Battlecry:</b> Choose a minion and become a copy of it.

Target: class FacelessManipulator(MinionCard):§    def __init__(self):§        super().__init__("Faceless Manipulator", 5, CHARACTER_CLASS.ALL, CARD_RARITY.EPIC, battlecry=Battlecry(Replace(), MinionSelector(players=BothPlayer(), picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(3, 3)§


Source: Faerie Dragon NAME_END 3 ATK_END 2 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END Dragon RACE_END Common RARITY_END Can't be targeted by spells or Hero Powers.

Target: class FaerieDragon(MinionCard):§    def __init__(self):§        super().__init__("Faerie Dragon", 2, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, minion_type=MINION_TYPE.DRAGON)§§    def create_minion(self, player):§        return Minion(3, 2, spell_targetable=False)§


Source: Far Sight NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Epic RARITY_END Draw a card. That card costs (3) less.

Target: class FarSight(SpellCard):§    def __init__(self):§        super().__init__("Far Sight", 3, CHARACTER_CLASS.SHAMAN, CARD_RARITY.EPIC)§§    def use(self, player, game):§        def reduce_cost(card):§            card.add_buff(Buff(ManaChange(-3)))§§        super().use(player, game)§        player.bind_once("card_drawn", reduce_cost)§        player.draw()§


Source: Felguard NAME_END 3 ATK_END 5 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Warlock PLAYER_CLS_END Demon RACE_END Rare RARITY_END Taunt. Battlecry: Destroy one of your Mana Crystals.

Target: class Felguard(MinionCard):§    def __init__(self):§        super().__init__("Felguard", 3, CHARACTER_CLASS.WARLOCK, CARD_RARITY.RARE, minion_type=MINION_TYPE.DEMON, battlecry=Battlecry(DestroyManaCrystal(), PlayerSelector()))§§    def create_minion(self, player):§        return Minion(3, 5, taunt=True)§


Source: Fen Creeper NAME_END 3 ATK_END 6 DEF_END 5 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Taunt</b>

Target: class FenCreeper(MinionCard):§    def __init__(self):§        super().__init__("Fen Creeper", 5, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(3, 6, taunt=True)§


Source: Feral Spirit NAME_END -1 ATK_END -1 DEF_END 3 COST_END -1 DUR_END Spell TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Rare RARITY_END Summon two 2/3 Spirit Wolves with Taunt. Overload: (2)

Target: class FeralSpirit(SpellCard):§    def __init__(self):§        super().__init__("Feral Spirit", 3, CHARACTER_CLASS.SHAMAN, CARD_RARITY.RARE, overload=2)§§    def use(self, player, game):§        super().use(player, game)§§        for i in range(0, 2):§            spirit_wolf = hearthbreaker.cards.minions.shaman.SpiritWolf()§            spirit_wolf.summon(player, game, len(player.minions))§§    def can_use(self, player, game):§        return super().can_use(player, game) and len(player.minions) < 7§


Source: Finkle Einhorn NAME_END 3 ATK_END 3 DEF_END 2 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Legendary RARITY_END NIL

Target: class FinkleEinhorn(MinionCard):§    def __init__(self):§        super().__init__("Finkle Einhorn", 2, CHARACTER_CLASS.ALL, CARD_RARITY.LEGENDARY, False)§§    def create_minion(self, player):§        return Minion(3, 3)§


Source: Flame Imp NAME_END 3 ATK_END 2 DEF_END 1 COST_END -1 DUR_END Minion TYPE_END Warlock PLAYER_CLS_END Demon RACE_END Common RARITY_END <b>Battlecry:</b> Deal 3 damage to your hero.

Target: class FlameImp(MinionCard):§    def __init__(self):§        super().__init__("Flame Imp", 1, CHARACTER_CLASS.WARLOCK, CARD_RARITY.COMMON, minion_type=MINION_TYPE.DEMON, battlecry=Battlecry(Damage(3), HeroSelector()))§§    def create_minion(self, player):§        return Minion(3, 2)§


Source: Flesheating Ghoul NAME_END 2 ATK_END 3 DEF_END 3 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END Whenever a minion dies, gain +1 Attack.

Target: class FlesheatingGhoul(MinionCard):§    def __init__(self):§        super().__init__("Flesheating Ghoul", 3, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON)§§    def create_minion(self, player):§        return Minion(2, 3, effects=[Effect(MinionDied(player=BothPlayer()), ActionTag(Give(ChangeAttack(1)), SelfSelector()))])§


Source: Force of Nature NAME_END -1 ATK_END -1 DEF_END 6 COST_END -1 DUR_END Spell TYPE_END Druid PLAYER_CLS_END NIL RACE_END Epic RARITY_END Summon three 2/2 Treants with <b>Charge</b> that die at the end of the turn.

Target: class ForceOfNature(SpellCard):§    def __init__(self):§        super().__init__("Force of Nature", 6, CHARACTER_CLASS.DRUID, CARD_RARITY.EPIC)§§    def use(self, player, game):§        super().use(player, game)§        from hearthbreaker.cards.minions.druid import ChargeTreant§        for i in [0, 1, 2]:§            treant_card = ChargeTreant()§            treant_card.summon(player, game, len(player.minions))§§    def can_use(self, player, game):§        return super().can_use(player, game) and len(player.minions) < 7§


Source: Forked Lightning NAME_END -1 ATK_END -1 DEF_END 1 COST_END -1 DUR_END Spell TYPE_END Shaman PLAYER_CLS_END NIL RACE_END Common RARITY_END Deal $2 damage to 2 random enemy minions. <b>Overload:</b> (2)

Target: class ForkedLightning(SpellCard):§    def __init__(self):§        super().__init__("Forked Lightning", 1, CHARACTER_CLASS.SHAMAN, CARD_RARITY.COMMON, overload=2)§§    def use(self, player, game):§        super().use(player, game)§§        minions = copy.copy(game.other_player.minions)§        for i in range(0, 2):§            minion = game.random_choice(minions)§            minions.remove(minion)§            minion.damage(player.effective_spell_damage(3), self)§§    def can_use(self, player, game):§        return super().can_use(player, game) and len(game.other_player.minions) >= 2§


Source: Freezing Trap NAME_END -1 ATK_END -1 DEF_END 2 COST_END -1 DUR_END Spell TYPE_END Hunter PLAYER_CLS_END NIL RACE_END Common RARITY_END <b>Secret:</b> When an enemy minion attacks, return it to its owner's hand and it costs (2) more.

Target: class FreezingTrap(SecretCard):§    def __init__(self):§        super().__init__("Freezing Trap", 2, CHARACTER_CLASS.HUNTER, CARD_RARITY.COMMON)§§    def activate(self, player):§        player.game.current_player.bind("character_attack", self._reveal)§§    def deactivate(self, player):§        player.game.current_player.unbind("character_attack", self._reveal)§§    def _reveal(self, attacker, target):§        if isinstance(attacker, Minion) and not attacker.removed:§            attacker.bounce()§            attacker.card.add_buff(Buff(ManaChange(2)))§            super().reveal()§


Source: Frost Elemental NAME_END 5 ATK_END 5 DEF_END 6 COST_END -1 DUR_END Minion TYPE_END Neutral PLAYER_CLS_END NIL RACE_END Common RARITY_END Battlecry: Freeze a character.

Target: class FrostElemental(MinionCard):§    def __init__(self):§        super().__init__("Frost Elemental", 6, CHARACTER_CLASS.ALL, CARD_RARITY.COMMON, battlecry=Battlecry(Give(Frozen()), CharacterSelector(players=BothPlayer(), picker=UserPicker())))§§    def create_minion(self, player):§        return Minion(5, 5)§