Mine

objectdef oToon inherits oToonBase
{


	/*
	 * Public var
	 */
	variable int MinCombatRange = 3
	variable int MaxCombatRange = 29
	variable int RepairPct = 10
	variable int MinMana = 70
	variable int MinHealth = 70

	 member NeedBuff()
	  {
	      if !${Me.Buff[Arcane Intellect](exists)} && ${Me.Action[Arcane Intellect].Usable}  || !${Me.Buff[Frost Armor](exists)} && ${Me.Action[Frost Armor].Usable}) && !${Me.Action[Ice Armor].Usable} || !${Me.Buff[Ice Armor](exists)} && ${Me.Action[Ice Armor].Usable})
	      {
	      	return TRUE
	      }
	
	      return FALSE
	  }
	  
	  method BuffPulse()
	  {
	      ;Int
	      if ${Me.Action[Arcane Intellect].Usable} && ${Me.Buff[Arcane Intellect].Duration}<60
	      {
	      	This:CastInstantSpell[Arcane Intellect]
	      }
	      ;Frost/Ice Armor
	      elseif ${Me.Action[Frost Armor].Usable} && ${Me.Buff[Frost Armor].Duration}<60 && !${Me.Action[Ice Armor].Usable}
	      {
	      	This:CastInstantSpell[Frost Armor]
	      }
	      elseif ${Me.Action[Ice Armor].Usable} && ${Me.Buff[Ice Arnir].Duration}<60 
	      {
	      	This:CastInstantSpell[Ice Armor]
	      }
  	  }
	
	member NeedRest()
	{
		if ${Me.PctHPs} < ${This.MinHealth} || ${Me.Buff[Food](exists)} && ${Me.PctHPs}<95
		{
			return TRUE
		}
		
		if ${Me.PctMana} < ${This.MinMana} || ${Me.Buff[Drink](exists)} && ${Me.PctMana}<95
		{
			return TRUE
		}
		
		return FALSE
	}

	method RestPulse()
		{
			if !${Me.Sitting}
			{
				This:Sit
				return
			}
			
			if ${Me.PctHPs} < ${This.MinHealth} && !${Me.Buff[Food](exists)} && ${Consumable.GotFood}
			{
				Consumable:Eat
				return
			}
			
			if ${Me.PctMana} < ${This.MinMana} && !${Me.Buff[Drink](exists)} && ${Consumable.GotDrink}
			{
				Consumable:Drink
				return
			}
			
	}

	method Routine()
	{
		if !${Me.Attacking}
		{
			WoWScript AttackTarget()
		}

		if ${Me.Action[Fireball].Usable} && ${Target.PctHPs}>10
		{
			This:CastSpell[Fireball]
		}
		
	}

	member NeedPull()
	{
		if !${Me.InCombat} && ${Me.Action[Fireball].Usable} && ${Me.Target(exists)} && !${Me.Target.Dead}
		{
			return TRUE
		}
	
		return FALSE
	
	}
	
	method PullPulse()
	{
		if !${Me.Casting} && ${Me.Action[Wrath].Usable} && ${Me.GlobalCooldown}==0
		{
			This:CastSpell[Fireball]
		}
	}

	/*
	 * Attack
	 */
	
	member AttackState()
	{
		if !${This.DoneWaiting}
		{
			return TOON_WAIT
		}
		
		if ${WoWScript[SpellIsTargeting()]}
		{
			return TOON_SPELLTARGET
		}
	
		if ${Me.Casting}
		{
			return TOON_CASTING
		}
	
		if ${Math.Abs[${Me.Heading}-${Me.HeadingTo[${Target.X},${Target.Y}]}]} > 15 && ${Target.Distance} < ${This.MaxCombatRange} && !${Mapper.CollisionTest[${Me.X},${Me.Y},${Me.Z},${Target.X},${Target.Y},${Target.Z}]}
		{
			return TOON_NEEDFACE
		}
	
		if ${ISXWoW.Facing}
		{
			return TOON_FACING
		}

		if ${Target.Dead}
		{
			return TOON_CLEARTARGET
		}
		
		if ${Target.Distance} > ${This.MaxCombatRange}
		{
			return TOON_ENGAGE
		}
		
		if ${Target.Distance} < ${This.MinCombatRange}
		{
			return TOON_BACKUP
		}
		
		if ${Target.Distance} > ${This.MinCombatRange} && ${Target.Distance} < ${This.MaxCombatRange} && ${Movement.Moving}
		{
			return TOON_STOPMOVE
		}
		
		
		if !${Me.Attacking}
		{
		
			return TOON_ATTACK
		}
		
		return TOON_ATTACK
	}
	
	
	method AttackPulse()
	{
		This.CurrentState:Set[${This.AttackState}]
		switch ${This.CurrentState}
		{
			case TOON_CASTING
				Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
				break
			case TOON_NEEDFACE
				Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
				break
			case TOON_FACING
				break
			case TOON_BACKUP
				break
			case TOON_SPELLTARGET
				SpellTarget ${Target.GUID}
				break
			case TOON_ENGAGE
				if !${Navigator.MovingToObject[${Target.GUID}]}
				{
					Navigator:MoveTo[${Target.X}, ${Target.Y}, ${Target.Z}]
				}
				break
			case TOON_PULL
				This:Pull
				break
			case TOON_ATTACK
				This:Routine
				break
			case TOON_STOPMOVE
				Navigator:ResetDestination
				move -stop
				break
			case TOON_CLEARTARGET
				WoWScript ClearTarget()
				break
			case TOON_WAIT
				break
		}
	}
	
	
	member TargetPriority(string GUID, int BasePriority)
		{
			variable objectref Data
			variable int Priority
			Data:Set[${GUID}]
	
			Priority:Set[${BasePriority}]
			
			if ${Me.Target.GUID.Equal[${GUID}]}
	         	{
				Priority:Dec[15]
      			}
			
			if ${Data.Aggro} || ${Environment.ImTheTarget[${GUID}]}
			{
				Priority:Dec[40]
			}
			
			switch ${Data.ReactionLevel}
			{
				case 3
					Priority:Dec[20]
					break
				case 4
					Priority:Inc[20]
					break
			}
			
			Priority:Inc[${Data.Distance}]
			Priority:Dec[${Math.Calc[100-${Data.PctHPs}]}]
			return ${Priority}
	}
}

atom(script) runchecks(string eventid , text, Message)
{
	if ${Message.Find["${Me.Target}"]}&&${Message.Find["attempts to run away"]}
	{
		This:Echo["We make runing flag true now kk"]
		declare Running bool global TRUE
	}
}