public override decimal ChangeDamageWhenAttacking(
            ICreaturesInBattle attackerWithSpecialty,
            ICreaturesInBattle defender,
            decimal currentDamage)
        {
            if (attackerWithSpecialty == null)
            {
                throw new ArgumentNullException("attackerWithSpecialty");
            }

            if (defender == null)
            {
                throw new ArgumentNullException("defender");
            }

            if (this.Rounds <= 0)
            {
                // Effect expires after fixed number of rounds
                return currentDamage;
            }

            //attackerWithSpecialty.CurrentDefense *= 2;

            this.rounds--;
            return currentDamage * 2;
        }

        public override void ApplyWhenAttacking(
            ICreaturesInBattle attackerWithSpecialty,
            ICreaturesInBattle defender)
        {
            if (defender == null)
            {
                throw new ArgumentNullException("defender");
            }

            if (attackerWithSpecialty == null)
            {
                throw new ArgumentNullException("attackerWithSpecialty");
            }

            if (this.rounds <= 0)
            {
                // Effect expires after fixed number of rounds
                return;
            }

            attackerWithSpecialty.CurrentAttack *= 2;
            this.rounds--;

            // I don't remove invoking base method, because in future could be added some different logic.
            base.ApplyWhenAttacking(attackerWithSpecialty, defender);
        }

 public override void ApplyOnSkip(ICreaturesInBattle skipCreature)
 {
     if (skipCreature == null)
     {
         throw new NullReferenceException("skipCreature");
     }
 }

        protected override void AddCreaturesByIdentifier(CreatureIdentifier creatureIdentifier, ICreaturesInBattle creaturesInBattle)
        {
            if (creatureIdentifier == null)
            {
                throw new ArgumentNullException("creatureIdentifier");
            }

            if (creaturesInBattle == null)
            {
                throw new ArgumentNullException("creaturesInBattle");
            }

            if (creatureIdentifier.ArmyNumber >= 3)
            {
                int armyNumber = creatureIdentifier.ArmyNumber;
                if (armies.Capacity < armyNumber)
                {
                    armies.AddRange(new ICollection<ICreaturesInBattle>[armyNumber - armies.Capacity + 1]);
                }

                if (armies[armyNumber] == null)
                {
                    armies[armyNumber] = new List<ICreaturesInBattle>();
                }

                this.armies[armyNumber].Add(creaturesInBattle);
                //this.thirthArmyCreatures.Add(creaturesInBattle);
            }
            else
            {
                base.AddCreaturesByIdentifier(creatureIdentifier, creaturesInBattle);
            }
        }

 public virtual decimal ChangeDamageWhenAttacking(
     ICreaturesInBattle attackerWithSpecialty, 
     ICreaturesInBattle defender, 
     decimal currentDamage)
 {
     return currentDamage;
 }

        public override decimal ChangeDamageWhenAttacking(
            ICreaturesInBattle attackerWithSpecialty,
            ICreaturesInBattle defender,
            decimal currentDamage)
        {
            if (attackerWithSpecialty == null)
            {
                throw new ArgumentNullException("attackerWithSpecialty");
            }

            if (defender == null)
            {
                throw new ArgumentNullException("defender");
            }

            if (this.rounds <= 0)
            {
                // Effect expires after fixed number of rounds

                // Perhaps in this case the most correct way is to invoke base method
                // return base.ChangeDamageWhenAttacking(attackerWithSpecialty, defender, currentDamage);
                return currentDamage;
            }
            else
            {
                this.rounds--;

                return currentDamage * 2;
            }
        }

        public override void ApplyWhenAttacking(ICreaturesInBattle attackerWithSpecialty, ICreaturesInBattle defender)
        {
            if (roundsRemaining <= 0)
                return;

            attackerWithSpecialty.CurrentAttack *= 2;
            roundsRemaining--;
        }

        protected override void AddCreaturesByIdentifier(CreatureIdentifier creatureIdentifier, ICreaturesInBattle creaturesInBattle)
        {
            if (creatureIdentifier.ArmyNumber == 3)
            {
                this.thirdArmyCreatues.Add(creaturesInBattle);
            }

            base.AddCreaturesByIdentifier(creatureIdentifier, creaturesInBattle);
        }

 protected override void AddCreaturesByIdentifier(CreatureIdentifier creatureIdentifier, ICreaturesInBattle creaturesInBattle)
 {
     if (creatureIdentifier.ArmyNumber == 1)
     {
         this.FirstArmyCreatures.Add(creaturesInBattle);
     }
     else if (creatureIdentifier.ArmyNumber == 2)
     {
         this.SecondArmyCreatures.Add(creaturesInBattle);
     }
 }

        public override void ApplyOnSkip(ICreaturesInBattle skipCreature)
        {
            if (skipCreature == null)
            {
                throw new ArgumentNullException("skipCreature");
            }

            skipCreature.PermanentAttack += this.attackToAdd;

            // I don't remove invoking base method, because in future could be added some different logic.
            base.ApplyOnSkip(skipCreature);
        }

        public override void ApplyAfterDefending(ICreaturesInBattle defenderWithSpecialty)
        {
            if (defenderWithSpecialty == null)
            {
                throw new ArgumentNullException("defenderWithSpecialty");
            }

            if (defenderWithSpecialty.TotalHitPoints > 0)
            {
                defenderWithSpecialty.TotalHitPoints = defenderWithSpecialty.Count
                                                       * defenderWithSpecialty.Creature.HealthPoints;
            }
        }

        public override void ApplyWhenAttacking(ICreaturesInBattle attackerWithSpecialty, ICreaturesInBattle defender)
        {
            if (attackerWithSpecialty == null)
            {
                throw new ArgumentNullException("attackerWithSpecialty");
            }

            if (defender == null)
            {
                throw new ArgumentNullException("defender");
            }

            var reduceDefenseBy = (int)(defender.CurrentDefense * (this.Percentage / 100.0M));
            defender.CurrentDefense = defender.CurrentDefense - reduceDefenseBy;
        }

        public override void ApplyWhenAttacking(ICreaturesInBattle attackerWithSpecialty, ICreaturesInBattle defender)
        {
            if (attackerWithSpecialty == null)
            {
                throw new ArgumentNullException("attackerWithSpecialty");
            }

            if (defender == null)
            {
                throw new ArgumentNullException("defender");
            }
            this.rounds--;
            attackerWithSpecialty.CurrentAttack *= 2;
            //defender.CurrentAttack *= 2;
        }

        public override decimal ChangeDamageWhenAttacking(ICreaturesInBattle attackerWithSpecialty, ICreaturesInBattle defender,
            decimal currentDamage)
        {
            if (attackerWithSpecialty == null)
            {
                throw new ArgumentNullException("attackerWithSpecialty");
            }
            if (rounds==0)
            {
                return currentDamage;
            }
            currentDamage *= 2;
            rounds--;

            return currentDamage;
        }

 protected override void AddCreaturesByIdentifier(CreatureIdentifier creatureIdentifier, ICreaturesInBattle creaturesInBattle)
 {
     try
     {
         base.AddCreaturesByIdentifier(creatureIdentifier, creaturesInBattle);
     }
     catch (ArgumentOutOfRangeException e)
     {
         if (creatureIdentifier.ArmyNumber == 3)
         {
             this.thirdArmyCreatures.Add(creaturesInBattle);
         }
         else
         {
             throw new ArgumentException(e.Message);
         }
     }
 }

        public override decimal ChangeDamageWhenAttacking(ICreaturesInBattle attackerWithSpecialty, ICreaturesInBattle defender,
            decimal currentDamage)
        {
            if (attackerWithSpecialty == null)
            {
                throw new ArgumentNullException("attackerWithSpecialty");
            }

            if (defender == null)
            {
                throw new ArgumentNullException("defender");
            }
            if (NumberOfRounds <= 0)
            {
                return currentDamage;
            }
            this.NumberOfRounds --;
            return currentDamage;
        }

        public override decimal ChangeDamageWhenAttacking(ICreaturesInBattle attackerWithSpecialty, ICreaturesInBattle defender, decimal currentDamage)
        {
            if (attackerWithSpecialty == null)
            {
                throw new ArgumentNullException("attackerWithSpecialty");
            }

            if (defender == null)
            {
                throw new ArgumentNullException("defender");
            }

            if (defender.Creature.GetType() == this.creatureTypeToHate)
            {
                return currentDamage * 1.5M;
            }

            return currentDamage;
        }

        public override void ApplyWhenAttacking(ICreaturesInBattle attackerWithSpecialty, ICreaturesInBattle defender)
        {
            if (attackerWithSpecialty == null)
            {
                throw new ArgumentNullException("attackerWithSpecialty");
            }

            if (defender == null)
            {
                throw new ArgumentNullException("defender");
            }
            if (this.rounds <= 0)
            {
                // Effect expires after fixed number of rounds
                return;
            }
            attackerWithSpecialty.CurrentAttack *= 2;
            this.rounds--;
        }

        protected override void AddCreaturesByIdentifier(CreatureIdentifier creatureIdentifier, ICreaturesInBattle creaturesInBattle)
        {
            if (creatureIdentifier == null)
            {
                throw new ArgumentNullException("creatureIdentifier");
            }

            if (creaturesInBattle == null)
            {
                throw new ArgumentNullException("creaturesInBattle");
            }

            if (creatureIdentifier.ArmyNumber == 3)
            {
                this.thirdArmyCreatures.Add(creaturesInBattle);
                return;
            }

            base.AddCreaturesByIdentifier(creatureIdentifier, creaturesInBattle);
        }

        public void DealDamage(ICreaturesInBattle defender)
        {
            if (defender == null)
            {
                throw new ArgumentNullException("defender");
            }

            // Calculate bonus for damage
            decimal attackBonus = 1.00M; // Initially 100%
            if (this.CurrentAttack > defender.CurrentDefense)
            {
                attackBonus += 0.05M * (this.CurrentAttack - defender.CurrentDefense);
            }

            // Calculate damage
            decimal damageToMake = this.Creature.Damage * this.Count;
            damageToMake = damageToMake * attackBonus;

            // Apply battle effects for damage (ChangeDamageWhenAttacking)
            foreach (var speciallity in this.Creature.Specialties)
            {
                damageToMake = speciallity.ChangeDamageWhenAttacking(this, defender, damageToMake);
            }

            // Calculate damage reductions
            if (defender.CurrentDefense > this.CurrentAttack)
            {
                decimal reduceDamage = 0.025M * (defender.CurrentDefense - this.CurrentAttack);
                if (reduceDamage > 0.7M)
                {
                    reduceDamage = 0.7M;
                }

                damageToMake = damageToMake * (1M - reduceDamage);
            }

            this.lastDamage = damageToMake;
            defender.TotalHitPoints -= (int)damageToMake;
        }