internal void OnDamagedEffect(IDamageableEntity target, int damageDealt)
 {
     if (target == this)
     {
         this.Owner.DrawCard();
     }
 }

        public void Battlecry(IDamageableEntity subTarget)
        {
            if (subTarget != null &&
                !GameEngine.GameState.CurrentPlayerPlayZone.Any(card => card != null && card.CurrentAttackPower >= BATTLECRY_POWER && card != this) &&
                !GameEngine.GameState.WaitingPlayerPlayZone.Any(card => card != null && card.CurrentAttackPower >= BATTLECRY_POWER))
            {
                throw new InvalidOperationException("No valid targets!");
            }

            if (subTarget == null &&
                (GameEngine.GameState.CurrentPlayerPlayZone.Any(card => card != null && card.CurrentAttackPower >= BATTLECRY_POWER && card != this) ||
                GameEngine.GameState.WaitingPlayerPlayZone.Any(card => card != null && card.CurrentAttackPower >= BATTLECRY_POWER)))
            {
                throw new InvalidOperationException("There is a valid target, must select one!");
            }

            if (subTarget != null && !(subTarget is BaseMinion))
            {
                throw new InvalidOperationException("Must target minions!");
            }

            var targetMinion = subTarget as BaseMinion;
            if (targetMinion != null)
            {
                if (targetMinion.CurrentAttackPower < BATTLECRY_POWER)
                {
                    throw new InvalidOperationException(
                        string.Format(
                            "Invalid minion {0}! It does not have enough attack power! Needs to be at least {1}",
                            targetMinion, BATTLECRY_POWER));
                }

                targetMinion.Die();
            }
        }

        /// <summary>
        /// First Effect: Draw 2 cards
        /// Second Effect: Restore 5 Health
        /// </summary>
        /// <param name="cardEffect">The card effect to use</param>
        /// <param name="target">The target of the heal</param>
        public void UseCardEffect(CardEffect cardEffect, IDamageableEntity target = null)
        {
            if (cardEffect == CardEffect.FIRST)
            {
                // Draw cards
                this.Owner.DrawCards(DRAW_COUNT);
            }
            else if (cardEffect == CardEffect.SECOND)
            {
                // Heal
                if (target == null)
                {
                    throw new InvalidOperationException("Needs to have a target!");
                }

                bool shouldAbort;
                GameEventManager.Healing(this.Owner, target, HEAL_AMOUNT, out shouldAbort);

                if (!shouldAbort)
                {
                    target.TakeHealing(HEAL_AMOUNT);
                }
            }
            else
            {
                throw new InvalidOperationException("You must choose a card effect to play it!");
            }
        }

 public void Battlecry(IDamageableEntity subTarget)
 {
     BaseWeapon weapon = GameEngine.GameState.CurrentPlayer.Weapon;
     if (weapon != null) {
         weapon.TakeBuff(BATTLECRY_BUFF_VALUE, BATTLECRY_BUFF_VALUE);
     }
 }

 public void Battlecry(IDamageableEntity subTarget)
 {
     if (this.Owner.Weapon != null)
     {
         this.TakeBuff(this.Owner.Weapon.CurrentAttackPower, 0);
     }
 }

 public void Battlecry(IDamageableEntity subTarget)
 {
     var enemy = GameEngine.GameState.WaitingPlayer;
     if (enemy.Weapon != null)
     {
         enemy.Weapon.Die();
     }
 }

 private void OnSpellCasting(BaseSpell spell, IDamageableEntity target, out bool shouldAbort)
 {
     if (spell.Owner == this.Owner) {
         var fireball = HearthEntityFactory.CreateCard<Fireball> ();
         this.Owner.AddCardToHand (fireball);
     }
     shouldAbort = false;
 }

 private void OnDamageDealt(IDamageableEntity target, int damageDealt)
 {
     var targetMinion = target as BaseMinion;
     if (targetMinion != null && GameEngine.GameState.CurrentPlayerPlayZone.Contains(targetMinion))
     {
         this.Owner.Armor++;
     }
 }

 public override void Activate(IDamageableEntity target = null, CardEffect cardEffect = CardEffect.NONE)
 {
     int totalSpellDamage = MAX_SPELL_POWER + this.BonusSpellPower;
     GameEngine.GameState.CurrentPlayer.TakeDamage(totalSpellDamage);
     GameEngine.GameState.WaitingPlayer.TakeDamage(totalSpellDamage);
     GameEngine.GameState.CurrentPlayerPlayZone.Where(card => card != null).ToList().ForEach(card => ((IDamageableEntity)card).TakeDamage(totalSpellDamage));
     GameEngine.GameState.WaitingPlayerPlayZone.Where(card => card != null).ToList().ForEach(card => ((IDamageableEntity)card).TakeDamage(totalSpellDamage));
 }

        /// <summary>
        /// Constructs an instance of DeathrattleHealTarget
        /// </summary>
        /// <param name="owner">The owner of the deathrattle</param>
        /// <param name="healTarget">The target to heal</param>
        /// <param name="healAmount">The amount to heal</param>
        public DeathrattleHealTarget(BaseCard owner, IDamageableEntity healTarget, int healAmount)
        {
            if (owner == null) throw new ArgumentNullException("owner");
            if (healTarget == null) throw new ArgumentNullException("healTarget");

            this.owner = owner;
            this.healTarget = healTarget;
            this.healAmount = healAmount;
        }

        public void Battlecry(IDamageableEntity subTarget)
        {
            if (subTarget is BasePlayer)
            {
                throw new InvalidOperationException("Can't buff players!");
            }

            subTarget.TakeTemporaryBuff(BATTLECRY_POWER);
        }

        public void Battlecry(IDamageableEntity subTarget)
        {
            var targetPlayer = subTarget as BasePlayer;
            if (targetPlayer == null)
            {
                throw new InvalidOperationException("Target must be a player!");
            }

            targetPlayer.Health = 15;
        }

        private void OnHealing(BasePlayer healer, IDamageableEntity target, int healAmount, out bool shouldAbort)
        {
            shouldAbort = false;

            if (healer == this.Owner)
            {
                shouldAbort = true;
                // Instead, do damage!
                target.TakeDamage(healAmount);
            }
        }

        public override void Activate(IDamageableEntity target = null, CardEffect cardEffect = CardEffect.NONE)
        {
            if (target == null)
            {
                throw new ArgumentNullException("Fireball must be cast with target in mind");
            }

            // Deal damage to the target
            var damageToDeal = MAX_SPELL_POWER + this.BonusSpellPower;
            target.TakeDamage(damageToDeal);
        }

        public virtual void Attack(IDamageableEntity target)
        {
            // Fire attacking event
            bool shouldAbort;
            GameEventManager.Attacking(this, target, isRetaliation: false, shouldAbort: out shouldAbort);

            if (!shouldAbort)
            {
                // Use up a durability charge
                this.TakeDamage(1);
                GameEngine.TriggerDeathrattles();
            }
        }

        public void Battlecry(IDamageableEntity subTarget)
        {
            var targetMinion = subTarget as BaseMinion;
            var targetPlayer = subTarget as BasePlayer;

            if (targetMinion != null)
            {
                targetMinion.ApplyStatusEffects(MinionStatusEffects.FROZEN);
            }
            else if (targetPlayer != null)
            {
                targetPlayer.ApplyStatusEffects(PlayerStatusEffects.FROZEN);
            }
        }

        public void Battlecry(IDamageableEntity subTarget)
        {
            var battleAxe = HearthEntityFactory.CreateCard<BattleAxe>();

            // kill the old weapon
            if (this.Owner.Weapon != null)
            {
                this.Owner.Weapon.Die();
            }

            this.Owner.Weapon = battleAxe;
            battleAxe.Owner = this.Owner;
            battleAxe.WeaponOwner = this.Owner;
        }

 public void UseCardEffect(CardEffect cardEffect, IDamageableEntity target = null)
 {
     if (cardEffect == CardEffect.FIRST)
     {
         this.TakeBuff(ATTACK_BUFF, 0);
     }
     else if (cardEffect == CardEffect.SECOND)
     {
         this.TakeBuff(0, HEALTH_BUFF);
         this.ApplyStatusEffects(MinionStatusEffects.TAUNT);
     }
     else
     {
         throw new InvalidOperationException("You must choose a card effect to play!");
     }
 }

 public void Battlecry(IDamageableEntity subTarget)
 {
     var opponent = GameEngine.GameState.WaitingPlayer;
     if (opponent.Weapon != null)
     {
         if (opponent.Weapon is Gorehowl)
         {
             // HACK: this card can bypass gorehowl's override of TakeDamage
             ((Gorehowl)opponent.Weapon).TakeDamage(BATTLECRY_DAMAGE, forceUseBaseImplementation: true);
         }
         else
         {
             opponent.Weapon.TakeDamage(BATTLECRY_DAMAGE);
         }
     }
 }

        public void Battlecry(IDamageableEntity subTarget)
        {
            var targetMinion = subTarget as BaseMinion;
            if (targetMinion == null)
            {
                throw new InvalidOperationException("Target needs to be a minion!");
            }

            if (!GameEngine.GameState.WaitingPlayerPlayZone.Contains(targetMinion))
            {
                throw new InvalidOperationException("Target must be an enemy");
            }

            var attackToSubtract = targetMinion.CurrentAttackPower - 1;
            targetMinion.TakeBuff(-attackToSubtract, 0);
        }