public override void AddAura(Aura aura, bool start)
		{
			base.AddAura(aura, start);
			OnAuraAddedOrRemoved();
			if (aura.Spell.IsPassive)
			{
				if (aura.Spell.HasItemRequirements)
				{
					ItemRestrictedAuras.Add(aura);
				}
				if (aura.Spell.IsModalShapeshiftDependentAura)
				{
					ShapeshiftRestrictedAuras.Add(aura);
				}
				if (aura.Spell.RequiredCasterAuraState != 0)
				{
					AuraStateRestrictedAuras.Add(aura);
				}
			}
			if (aura.Spell.HasAuraDependentEffects)
			{
				AurasWithAuraDependentEffects.Add(aura);
			}

		}

		public static AuraRecord ObtainAuraRecord(Aura aura)
		{
			var record = AuraRecordPool.Obtain();
			record.SyncData(aura);

			return record;
		}

		protected internal override void Cancel(Aura aura)
		{
			base.Cancel(aura);
			if (aura.Spell.IsPassive && aura.Spell.HasItemRequirements)
			{
				ItemRestrictedAuras.Remove(aura);
			}
		}

		internal void NotifyAuraRemoved(Aura aura)
		{
			var evt = AuraRemoved;
			if (evt != null)
			{
				evt(aura);
			}
		}

		public override void AddAura(Aura aura, bool update)
		{
			base.AddAura(aura, update);
			if (aura.Spell.IsPassive && aura.Spell.HasItemRequirements)
			{
				ItemRestrictedAuras.Add(aura);
			}
		}

 void Start()
 {
     transform.parent = GameObject.Find ("Baddies").transform;
     Aura tempAura = transform.Find ("Aura").GetComponent<Aura>();
     tempAura.owner = gameObject;
     aura = tempAura;
     gameObject.name = "Bear " + Random.Range (0,99999);
 }

 protected override void Remove(bool cancelled)
 {
     if (activeToggleAura != null)
     {
         // remove aura
         activeToggleAura.Cancel();
         activeToggleAura = null;
     }
 }

		public static void SendAuraUpdate(Unit owner, Aura aura)
		{
			using (var packet = new RealmPacketOut(RealmServerOpCode.SMSG_AURA_UPDATE))
			{
				owner.EntityId.WritePacked(packet);

				WriteAura(aura, packet);

				owner.SendPacketToArea(packet);
			}
		}

 public void AddAura(Aura aura)
 {
     foreach (var oldAura in Auras) {
         if (aura.Name == oldAura.Name && aura.Amount == oldAura.Amount) {
             oldAura.Duration = aura.Duration;
             return;
         }
     }
     Auras.Add(aura);
     RecalculateAttribute(aura.Attribute);
 }

		/// <summary>
		/// Called when this Unit got the given debuff by the given SpellCast
		/// </summary>
		/// <param name="cast"></param>
		internal void OnDebuff(SpellCast cast, Aura debuff)
		{
			// force combat mode
			IsInCombat = true;

			var evt = Debuff;
			if (evt != null)
			{
				evt(this, cast, debuff);
			}
		}

	// Use this for initialization
	void Start () {
		if (target == null) {
			moveToPlayer();
		}
		
		aura = Instantiate(auraPrefab).GetComponent<Aura> ();
		aura.gameObject.transform.SetParent (this.transform);
		aura.transform.localPosition = Vector3.zero;

		setMobSizeAndSprite ();
	}

 void MoveMe(Aura aura)
 {
     movedBy = aura;
     if(attempts < 5){
         Vector3 newPosition = owner.transform.position;
         newPosition.y = Random.Range (-2f, 2f);
         owner.transform.position = newPosition;
         attempts++;
     }else{
         Destroy (owner);
     }
 }

		protected internal override void Cancel(Aura aura)
		{
			base.Cancel(aura);
			if (aura.Spell.IsPassive)
			{
				if (aura.Spell.HasItemRequirements)
				{
					ItemRestrictedAuras.Remove(aura);
				}
				if (aura.Spell.AllowedShapeshiftMask != 0)
				{
					ShapeshiftRestrictedAuras.Add(aura);
				}
			}
		}

		public override void AddAura(Aura aura, bool update)
		{
			base.AddAura(aura, update);
			if (aura.Spell.IsPassive)
			{
				if (aura.Spell.HasItemRequirements)
				{
					ItemRestrictedAuras.Add(aura);
				}
				if (aura.Spell.AllowedShapeshiftMask != 0)
				{
					ShapeshiftRestrictedAuras.Add(aura);
				}
			}
		}

		public override SpellFailedReason CheckValidTarget(WorldObject target)
		{
			if (Effect.Spell.RequiredTargetAuraState == AuraState.RejuvenationOrRegrowth)
			{
				// consume Reju or Regrowth and apply its full effect at once
				toConsume = ((Unit)target).Auras.FindFirst((aura) =>
				{
					return aura.Spell.IsRejuvenationOrRegrowth && toConsume.TimeLeft > 100;
				});
				if (toConsume == null)
				{
					return SpellFailedReason.TargetAurastate;
				}
			}
			return SpellFailedReason.Ok;
		}

		public void SyncData(Aura aura)
		{
			OwnerId = aura.Auras.Owner.EntityId.Low;
			CasterId = (long)aura.CasterReference.EntityId.Full;
			Level = aura.Level;
			m_spell = aura.Spell;
			if (aura.HasTimeout)
			{
				MillisLeft = aura.TimeLeft;
			}
			else
			{
				MillisLeft = -1;
			}
			StackCount = aura.StackCount;
			IsBeneficial = aura.IsBeneficial;
		}

		public override SpellFailedReason CheckValidTarget(WorldObject target)
		{
			var caster = m_cast.Caster.CasterInfo;
			var auras = m_cast.CasterUnit.Auras;
			foreach (var aura in ((Unit)target).Auras)
			{
				// find a stealable positive auras
				if (aura.IsBeneficial && 
					aura.CanBeStolen && 
					aura.TimeLeft > 100 &&
					auras.GetAura(caster, aura.Id, aura.Spell) == null)
				{
					toSteal = aura;
					return SpellFailedReason.Ok;
				}
			}

			return SpellFailedReason.NothingToSteal;
		}

        protected override void Apply()
        {
            // add aura
            // first check, if Aura already exists (eg. because it was loaded from DB)
            if (ToggleAuraSpell == null)
            {
                ToggleAuraSpell = m_spellEffect.TriggerSpell;
            }

            activeToggleAura = Owner.Auras[ToggleAuraSpell];
            if (activeToggleAura == null)
            {
                activeToggleAura = Owner.Auras.CreateAndStartAura(m_aura.CasterReference, ToggleAuraSpell, true);
                activeToggleAura.CanBeSaved = false;
            }
            else
            {
                LogManager.GetCurrentClassLogger().Warn("Tried to toggle on already created Aura \"{0}\" on {1}", activeToggleAura, Owner);
                activeToggleAura.IsActivated = true;
            }
        }

        private static void WriteAura(Aura aura, BinaryWriter packet)
        {
            packet.Write(aura.Index);

            packet.Write(aura.Spell.Id);

            packet.Write((byte)aura.Flags);
            packet.Write(aura.Level);
            packet.Write((byte)aura.StackCount);

            // If the target was not the caster
            if (!aura.Flags.HasFlag(AuraFlags.TargetIsCaster))
            {
                aura.CasterReference.EntityId.WritePacked(packet);
            }

            if (aura.Flags.HasFlag(AuraFlags.HasDuration))
            {
                packet.Write(aura.Duration);
                packet.Write(aura.TimeLeft);
            }
        }

    private void UnTrackAura(Aura aura)
    {
        if ((AuraType)aura.Type == AuraType.Buff)
        {
            _buffs.Remove(aura);
            _buffs.Sort
            (
                delegate(Aura aura1, Aura aura2)
                {
                    return ((aura1.TimeRemaining).CompareTo(aura2.TimeRemaining));
                }
            );
        }

        else
        {
            _debuffs.Remove(aura);
            _debuffs.Sort
            (
                delegate(Aura aura1, Aura aura2)
                {
                    return ((aura1.TimeRemaining).CompareTo(aura2.TimeRemaining));
                }
            );
        }
    }