/*
Mage routine for ByteBot rev.470 by B7731

Big thanks go to Arbiter for bugreports and suggestions.


Changes:
31.3.2007 - Added Racial 'Gift of the Naaru'
						Added Additional GUI Error Msg Checks

21.3.2007 - Added Line of sight check. (thank Weebs for making it)

20.3.2007 - Lots of bugfixes
					- Seperate console in GUI for bot actions (taken from azeroths code)

19.3.2007 - Fixed mob immunity detection and spell selection based on that
					- Code cleaned up a bit
					- Intelligent strafe spot finding after frost nova (modified bytelock's res spot code)
					- Fixed but in targetting

17.3.2007 - Rewrite of Sheeping routine
					- Rewrite of Pet freeze pull

15.3.2007 - Potions
					- Removed targetting for buffs so turn on auto self cast on wow settings

14.3.2007 - Various bugfixes

12.3.2007 - Fixed a bug where the toon didnt backup from too close melee range
					- Added the use of wand & GUI option for it
					- Now only casts evocation if target is frozen or you have shield spell active
					- Fixed turning problem after kill

11.3.2007 -	Fixed automatic frost & fire ward use.
					- Fixed some double casting issues.
					- Fixed Mana stones
					- Added Scorch use percentage to GUI

10.3.2007	- Seperated Talent based combat code
					- Debug made easier by displaying all combat actions in GUI
					- Heavy modifications to NeedPull as bbot core changed
					- Some tweaking to combat sequence

9.3.2007	- Bug fixes to pulling and AOE use
					- Improments on spell range detection
					- Improved rest pulse

8.3.2007	- Pull range based on spell selection & talents
					- Changed the pull routine to use bbot grind loop
					- Added Sheep adds / stop using AOE spells when sheeped nearby
					- Modified Target priorities to take polymorph and health in account
					- Added Decursing, detection code from Shaman routine by Azeroth

7.3.2007 	- Mage specific GUI for adjusting combat behaviour
					- Improments in Combat logic
					- Forgotten Mana Shield added
					- Variable saving to ToonConfig
					- Added Upper limits for drinking and eating
					- Fixed Mob Level range changing in GUI

Features:
Water, food, mana stone - conjure and use.
- Uses mosts buffs available for mage.
- Detects and uses trinkets.
- Handles Water elemental during combat.
- Prebuff for fight and cast appropriate buffs during fight
- Uses some racial abilities. (mana tap, berserking)
- Chooses damage spell sequence by talents. (room to improve)
- Reactive use of: Frost Ward, Fire Ward & Dampen magic
- Immunity Detection & spell selection (Idea and some of the code from stealthy's routine so big credits to him)

 To Do:	
 					Improve spec detection
					Escaping
					Blink
*/

#define TOON_FROZENBACKUP 20
#define TOON_COMBATBUFF 21
#define TOON_LOWMANA 22
#define TOON_LOWHEALTH 23
#define TOON_RETARGET_SHEEP 24

#define SPEC_FIRE 0
#define SPEC_FROST 1
#define SPEC_ARCANE 2

objectdef oToon inherits oToonBase
{
	/*
	 * Public var
	 */
	 
	variable int MinCombatRange = 3
	variable int MaxCombatRange = 29
	variable int PrimaryStat = STAT_INT
	variable int SecondaryStat = STAT_STA
	variable bool DismountOnAggro = TRUE
	
	variable bool UseFireWard = FALSE
	variable bool UseFrostWard = FALSE
	variable bool NeedDampenMagic = FALSE
	
	variable string PullSpell = "Automatic"
	variable string ArmorSpell = "Automatic"
	variable string ShieldSpell = "Automatic"
	variable string Wards = "Automatic"
	variable string DampenMagic = "Automatic"
	variable int ShieldPCT = 110
	variable int PullRange = -1
	variable int ScorchPCT = 110
	variable int WandPCT = 10
	variable bool UseAOE = TRUE
	variable bool Trinkets = TRUE
	variable bool Racials = TRUE
	variable bool Sheep = TRUE
	
	variable int MinMana = 60
	variable int MaxMana = 95
	variable int MinHealth = 60
	variable int MaxHealth = 95
	variable int LevelBelow = 4
	variable int LevelAbove = 2
	
	variable int RepairPct = 20
	variable int KeepFreeSlots = 3
	variable bool AutoPvP = TRUE
	variable bool AutoTrainSkills = TRUE
	variable bool DismountOnAggro = FALSE
	
	variable string SheepTarget = ""
	
	variable index:string FireResistant
	variable index:string FrostResistant
	variable index:string ArcaneResistant
	
	/*
	 * Botnet 
	 */
	
	variable int TankRating = 0
	variable int HealRating = 0
	variable int DpsRating = 10
	variable int CanResurrect = 0
	
	
	/****************************************************************
	 *    Targetting Start
	 ***************************************************************/
	member WantTarget(string GUID)
	{
		variable objectref Obj
		Obj:Set[${GUID}]
		
		if ${Obj.GUID.Equal[${Me.GUID}]}
		{
			return FALSE
		}
		
		/*
		* Keep aggro related first!
		*/
		if ${Environment.ImTheTarget[${GUID}]}
		{
			return TRUE
		}

		switch ${Obj.Type}
		{
			case Player
				if ${Obj.Level} > ${This.TargetMaxLevel}
				{
					return FALSE
				}
				
				return TRUE
				break
			default
				;Keep first
				if !${Grind.InRoamRange[${GUID}]}
				{
					echo "Dont want ${GUID} ${Obj.Name} (out of roam range)"
					return FALSE
				}
				if ${Obj.Tapped} && !${Party.Members}
				{
					return FALSE
				}

				if ${Environment.NeutralNPC[${GUID}]}
				{
					return FALSE
				}
	      
				if ${Math.Distance[${Me.Z},${Obj.Z}]} > 5 && ${Math.Distance[${Me.Location},${Obj.Location}]} < 20
				{
					return FALSE
				}

				if ${Obj.Level} < ${Math.Calc[${Me.Level} - ${LevelBelow}]}
				{
					return FALSE
				}

				if ${Obj.Level} > ${Math.Calc[${Me.Level} + ${LevelAbove}]}
				{
					return FALSE
				}

				if ${Obj.FactionGroup.Equal[${Me.FactionGroup}]}
				{
					return FALSE
				}

		/*	if ${Environment.TargetFriendCount[${Obj.GUID}]} > ${Party.Members}
				{
					return FALSE
				}
			
				if !${Target.LineOfSight}
				{
					return FALSE
					echo "Dont want ${GUID} ${Obj.Name} (not in line of sight)"
				}
		*/		
		
				;Keep last
				if ${Environment.WillCollide[${Me.X},${Me.Y},${Math.Calc[${Me.Z} + 1]}],${Obj.X},${Obj.Y},${Math.Calc[${Obj.Z} + 1]}}
				{
					return FALSE
				}
				break
		}

		return TRUE
	}

	member TargetPriority(string GUID, int BasePriority)
	{
		variable objectref Data
		variable int Priority
		Data:Set[${GUID}]

		Priority:Set[${BasePriority}]
		
		if ${Environment.ImTheTarget[${GUID}]} || ${Data.Aggro}
		{
			Priority:Dec[50]
		}
		
		switch ${Data.Type}
		{
			case Player
				break
			default
				switch ${Data.ReactionLevel}
				{
					case 2
						Priority:Dec[20]
						break
					case 3
						Priority:Dec[10]
						break
					case 4
						Priority:Inc[20]
						break
				}
				break
		}

		Priority:Inc[${Data.Distance}]
		Priority:Dec[${Math.Calc[(100 - ${Data.PctHPs}) * 2]}] 
		
		if ${Target(exists)} && (${Target.GUID.Equal[${Data.GUID}]} || ${Me.Pet.Target.GUID.Equal[${Data.GUID}]})
		{
			Priority:Dec[5]
		}
		
		/* Last target of our spells get more priority, fix for target switching on pulls */
		if ${Data.GUID.Equal[${SpellTargetGUID}]}
		{
			Priority:Dec[20]
		}
		
		/* Keep the sheeped last  */
		if ${Data.Buff[Polymorph](exists)}
		{
			Priority:Inc[40]
		}	
		
		/* just a precautio */
		if ${Data.GUID.Equal[${Me.GUID}]}
		{
			Priority:Inc[1000]
		}
		
		return ${Priority}
	}
	
	method TargetSwitched()
	{
		if ${Me.Pet(exists)}
		{	
	  	WoWScript PetStopAttack()
	  }
	  if ${Me.Casting}
		{ 
	  	WoWScript SpellStopCasting()
	  }
	}
	/****************************************************************
	 *    Targetting end
	 ***************************************************************/
	 
	

	/****************************************************************
	 *    Buff start
	 ***************************************************************/	 
	member NeedBuff()
	{	
		if ${Me.Casting}
		{
			return FALSE
		}
		if !${Me.Buff[Arcane Intellect](exists)} && ${Spell[Arcane Intellect](exists)}
    { 
			return TRUE
    }
    if !${Me.Buff[Ice Barrier](exists)} && ${Spell[Ice Barrier](exists)} && (${This.ShieldSpell.Equal[Automatic]} || ${This.ShieldSpell.Equal[Ice Barrier]}) && ${This.ShieldPCT} == 110
    { 
			return TRUE
    }
     if !${Me.Buff[Mana Shield](exists)} && ${Spell[Mana Shield](exists)} && ((${This.ShieldSpell.Equal[Automatic]} && !${Spell[Ice Barrier](exists)}) || ${This.ShieldSpell.Equal[Mana Shield]}) && ${This.ShieldPCT} == 110 && !${This.ShieldSpell.Equal[Ice Barrier]}
    { 
			return TRUE
    }
    if !${Me.Buff[Molten Armor](exists)} && !${Me.Buff[Ice Armor](exists)} && !${Me.Buff[Frost Armor](exists)}
    { 
			return TRUE
    }
    if ${Me.Action["Conjure ${This.GetManaStone}"].Usable} && !${Item[${This.GetManaStone}](exists)}
    { 
			return TRUE
    }
    if ${Me.Action[Dampen Magic].Usable} && !${Me.Buff[Dampen Magic](exists)} && ${This.DampenMagic.Equal[Always On]}
    { 
			return TRUE
    }
    if ${Spell[Remove Lesser Curse](exists)} && ${This.NeedDecurse}
    { 
			return TRUE
    }
    
    
		return FALSE 
	}

	method BuffPulse()
	{
		if ${Target(exists)}
		{
			WoWScript ClearTarget()
		}
		elseif ${Me.Action[Remove Lesser Curse].Usable} && ${This.NeedDecurse}
    { 
    	This:Echo["Buff Pulse Casting: Remove Lesser Curse -> Self"]
			This:CastInstantSpell[Remove Lesser Curse, ${Me.GUID}]
    }   
		elseif ${Me.Action[Arcane Intellect].Usable} && !${Me.Buff[Arcane Intellect](exists)}
    {
    	This:Echo["Buff Pulse Casting: Arcane Intellect"]
			This:CastInstantSpell[Arcane Intellect, ${Me.GUID}]
    }  
    elseif ${Me.Action[Molten Armor].Usable} && !${Me.Buff[Molten Armor](exists)} && (${This.ArmorSpell.Equal[Automatic]} || ${This.ArmorSpell.Equal[Molten Armor]})
    { 
    	This:Echo["Buff Pulse Casting: Molten Armor"]
			This:CastInstantSpell[Molten Armor]
    }
    elseif ${Me.Action[Ice Armor].Usable} && !${Me.Buff[Ice Armor](exists)} && ((!${Spell[Molten Armor](exists)} && ${This.ArmorSpell.Equal[Automatic]}) || ${This.ArmorSpell.Equal[Ice Armor]})
    { 
    	This:Echo["Buff Pulse Casting: Ice Armor"]
			This:CastInstantSpell[Ice Armor]
    }
    elseif ${Me.Action[Frost Armor].Usable} && !${Me.Buff[Frost Armor](exists)} && ((!${Spell[Molten Armor](exists)} && !${Spell[Ice Armor](exists)} && ${This.ArmorSpell.Equal[Automatic]}) || ${This.ArmorSpell.Equal[Frost Armor]})
    { 
    	This:Echo["Buff Pulse Casting: Frost Armor"]
			This:CastInstantSpell[Frost Armor]
    }
    elseif ${Me.Action[Dampen Magic].Usable} && !${Me.Buff[Dampen Magic](exists)} && ${This.DampenMagic.Equal[Always On]}
    {
    	This:Echo["Buff Pulse Casting: Dampen Magic"]
			This:CastInstantSpell[Dampen Magic, ${Me.GUID}]
    }
    elseif ${Me.Action[Ice Barrier].Usable} && !${Me.Buff[Ice Barrier](exists)} && (${This.ShieldSpell.Equal[Automatic]} || ${This.ShieldSpell.Equal[Ice Barrier]}) && ${This.ShieldPCT} == 110
    { 
    	This:Echo["Buff Pulse Casting: Ice Barrier"]
			This:CastInstantSpell[Ice Barrier]
    }
    elseif ${Me.Action[Mana Shield].Usable} && !${Me.Buff[Mana Shield](exists)} && ((${This.ShieldSpell.Equal[Automatic]} && !${Spell[Ice Barrier](exists)}) || ${This.ShieldSpell.Equal[Mana Shield]}) && ${This.ShieldPCT} == 110 && !${This.ShieldSpell.Equal[Ice Barrier]}
    { 
    	This:Echo["Buff Pulse Casting: Mana Shield"]
			This:CastInstantSpell[Mana Shield]
    }
    elseif ${Me.Action["Conjure ${This.GetManaStone}"].Usable} && !${Item[${This.GetManaStone}](exists)}
    {    	
    	This:Echo["Buff Pulse Conjuring Manastone"]
			This:CastInstantSpell[Conjure ${This.GetManaStone}]
    }     
	}
	
	member NeedCombatBuff()
	{
    if ${Me.Action[Dampen Magic].Usable} && !${Me.Buff[Dampen Magic](exists)} && ((${This.DampenMagic.Equal[Automatic]} && ${This.NeedDampenMagic}) || ${This.DampenMagic.Equal[Always On]})
    { 
			return TRUE
    } 
    if ${Me.Action[Cold Snap].Usable} && !${Me.Buff[Ice Barrier](exists)} && ${Spell[Ice Barrier](exists)} && !${This.ShieldSpell.Equal[Off]} && !${This.ShieldSpell.Equal[Mana Barrier]} && ${This.ShieldPCT} > ${Me.PctHPs} && ${Me.PctHPs} < 50
    { 
			return TRUE
    }
   	if ${Me.Action[Ice Barrier].Usable} && !${Me.Buff[Ice Barrier](exists)} && (${This.ShieldSpell.Equal[Automatic]} || ${This.ShieldSpell.Equal[Ice Barrier]}) && ${This.ShieldPCT} > ${Me.PctHPs} 
    { 
			return TRUE
    }
    if ${Me.Action[Mana Shield].Usable} && !${Me.Buff[Mana Shield](exists)} && ((${This.ShieldSpell.Equal[Automatic]} && ${Me.PctHPs} < 30 && ${Me.PctMana} > 30) || ${This.ShieldSpell.Equal[Mana Shield]}) && ${This.ShieldPCT} > ${Me.PctHPs} && !${This.ShieldSpell.Equal[Ice Barrier]}
    { 
			return TRUE
    }
    if ${This.TrinketUsable} && ${Target.PctHPs} > 50 && ${This.Trinkets}
    { 
			return TRUE
    }
    if ${Me.Action[Combustion].Usable} && !${Me.Buff[Combustion](exists)}
    { 
			return TRUE
    }
    if ${Me.Action[Presence of Mind].Usable} && !${Me.Buff[Presence of Mind](exists)}
    { 
			return TRUE
    }
    if ${Me.Action[Berserking].Usable} && ${Me.PctHPs} < 30 && ${Target.PctHPs} > 20 && ${This.Racials}
    { 
			return TRUE
    }
    if ${Me.Action[Frost Ward].Usable} && !${Me.Buff[Frost Ward](exists)} && ((${This.UseFrostWard} && ${This.Wards.Equal[Automatic]}) || ${This.Wards.Equal[Frost On]})
		{ 
			return TRUE
		}
		if ${Me.Action[Fire Ward].Usable} && !${Me.Buff[Fire Ward](exists)} && ((${This.UseFireWard} && ${This.Wards.Equal[Automatic]}) || ${This.Wards.Equal[Fire On]})
		{ 
			return TRUE
		} 
    if ${Me.Action[Gift of the Naaru].Usable} && ${Me.PctHPs} < 40 && ${Target.PctHPs} > 20 && ${This.Racials}
    { 
			return TRUE
    }
		return FALSE 
	}

	method CombatBuffPulse()
	{
   if ${Me.Action[Dampen Magic].Usable} && !${Me.Buff[Dampen Magic](exists)} && ((${This.DampenMagic.Equal[Automatic]} && ${This.NeedDampenMagic}) || ${This.DampenMagic.Equal[Always On]})
   {
   		This:Echo["Combat Buff Casting: Dampen Magic"]
			This:CastInstantSpell[Dampen Magic, ${Me.GUID}]
    }
 	 	elseif ${Me.Action[Cold Snap].Usable} && !${Me.Action[Ice Barrier].Usable} && !${Me.Buff[Ice Barrier](exists)} && !${This.ShieldSpell.Equal[Off]} && !${This.ShieldSpell.Equal[Mana Shield]} && ${This.ShieldPCT} > ${Me.PctHPs} && ${Me.PctHPs} < 50
		{
			This:Echo["Combat Buff Casting: Cold Snap"]
			This:CastInstantSpell[Cold Snap]
		}
		elseif ${Me.Action[Ice Barrier].Usable} && !${Me.Buff[Ice Barrier](exists)} && (${This.ShieldSpell.Equal[Automatic]} || ${This.ShieldSpell.Equal[Ice Barrier]}) && ${This.ShieldPCT} > ${Me.PctHPs}
		{
			This:Echo["Combat Buff Casting: Ice Barrier"]
			This:CastInstantSpell[Ice Barrier]
		}
		elseif ${Me.Action[Mana Shield].Usable} && !${Me.Buff[Mana Shield](exists)} && ((${This.ShieldSpell.Equal[Automatic]} && ${Me.PctHPs} < 30 && ${Me.PctMana} > 30) || ${This.ShieldSpell.Equal[Mana Shield]}) && ${This.ShieldPCT} > ${Me.PctHPs} && !${This.ShieldSpell.Equal[Ice Barrier]}
    { 
    	This:Echo["Combat Buff Casting: Mana Shield"]
			This:CastInstantSpell[Mana Shield]
    }		
		elseif ${Me.Action[Fire Ward].Usable} && !${Me.Buff[Fire Ward](exists)} && ((${This.UseFireWard} && ${This.Wards.Equal[Automatic]}) || ${This.Wards.Equal[Fire On]})
		{ 
			This:Echo["Fire damage detected. Casting:Fire Ward"]
			This:CastInstantSpell[Fire Ward]
		} 
		elseif ${Me.Action[Frost Ward].Usable} && !${Me.Buff[Frost Ward](exists)} && ((${This.UseFrostWard} && ${This.Wards.Equal[Automatic]}) || ${This.Wards.Equal[Frost On]})
		{ 
			This:Echo["Frost damage detected. Casting:Frost Ward"]
			This:CastInstantSpell[Frost Ward]
		} 
		elseif ${This.TrinketUsable} && ${Target.PctHPs} > 50 && ${This.Trinkets}
		{
			This:Echo["Combat Buff: Using Trinket"]
			This:UseTrinket
		}
		elseif ${Me.Action[Combustion].Usable} && !${Me.Buff[Combustion](exists)}
		{	
			This:Echo["Combat Buff Casting: Combustion"]
			This:CastInstantSpell[Combustion]
		}
		elseif ${Me.Action[Presence of Mind].Usable} && !${Me.Buff[Presence of Mind](exists)}
		{
			This:Echo["Combat Buff Casting: Presence of Mind"]
			This:CastInstantSpell[Presence of Mind]
	 	}
	 	elseif ${Me.Action[Berserking].Usable} && ${Me.PctHPs} < 30 && ${Target.PctHPs} > 20 && ${This.Racials}
		{
			This:Echo["Combat Buff Casting: Berserking"]
			This:CastInstantSpell[Berserking]
		}	 
	 	elseif ${Me.Action[Gift of the Naaru].Usable} && ${Me.PctHPs} < 40 && ${Target.PctHPs} > 20 && ${This.Racials}
		{
			This:Echo["Combat Buff Casting: Gift of the Naaru"]
			This:CastSpell[Gift of the Naaru]
		}	 
	}	
	/****************************************************************
	 *    Buff end
	 ***************************************************************/
	 
	
	/****************************************************************
	 *    Rest start
	 ***************************************************************/	
	member NeedRest()
	{
		if ${Me.PctMana} > ${This.MaxMana} && ${Me.PctHPs} > ${This.MaxHealth}
		{
			return FALSE
		}
		elseif ${Me.PctHPs} < ${This.MinHealth} || ${Me.PctMana} < ${This.MinMana} || ${Me.Buff[Drink](exists)} || ${Me.Buff[Food](exists)}
		{
			return TRUE
		}
		return FALSE
	}

	method RestPulse()
	{
		if ${Me.Action[Conjure Food].Usable} && !${Me.Buff[Drink](exists)} && !${Me.Buff[Food](exists)} && !${Consumable.GotFood} && !${Me.Casting}
		{
			This:Echo["Rest Pulse: Conjure Food"]
	    This:CastSpell[Conjure Food]
		}
		elseif ${Me.Action[Conjure Water].Usable} && !${Me.Buff[Drink](exists)} && !${Me.Buff[Food](exists)} && !${Consumable.GotDrink} && !${Me.Casting}
		{
			This:Echo["Rest Pulse: Conjure Water"]
	    This:CastSpell[Conjure Water]
		}
		elseif !${Me.Buff[Drink](exists)} && (${Me.PctMana} < ${This.MinMana} || (${Me.Buff[Food](exists)} && ${Me.PctMana} < ${This.MaxMana})) && ${Consumable.GotDrink} && !${Me.Casting}
		{
			This:Echo["Rest Pulse: Drink"]
	    Consumable:Drink
		}
		elseif !${Me.Buff[Food](exists)} && (${Me.PctHPs} < ${This.MinHealth} || (${Me.Buff[Drink](exists)} && ${Me.PctHPs} < ${This.MaxHealth})) && ${Consumable.GotFood} && !${Me.Casting}
		{
			This:Echo["Rest Pulse: Eat"]
	  	Consumable:Eat
	  }
	}
	/****************************************************************
	 *    Rest end
	 ***************************************************************/
	 
	
	/****************************************************************
	 *    Pull selection start
	 ***************************************************************/
	 
	member NeedPull()
	{
		if ${This.NeedBuff} || ${This.NeedRest} || ${Target.Dead} || !${Target(exists)} || ${Target.Tapped} || ${Me.InCombat} || ${Movement.Moving} || !${Target.LineOfSight}
		{
			return FALSE
		} 
		elseif ${Target.Distance} < ${This.GetPullRange}
		{
			return TRUE
		}
		return FALSE
	}
	
	method PullPulse()
	{
		if ${This.TrinketUsable} && ${This.Trinkets}
		{
			This:Echo["Pulling: Use Trinket"]
			This:UseTrinket
		}
		elseif !${This.isResistant[arcane]} && ((${This.PullSpell.Equal[Automatic]} && ${This.GetSpec} == SPEC_ARCANE) || ${This.PullSpell.Equal[Arcane Missiles]} || ${This.PullSpell.Equal[Arcane Blast]} || (${This.isResistant[frost]} && ${This.isResistant[fire]}))
		{
			This:ArcanePull
		}
		elseif !${This.isResistant[fire]} && ((${This.PullSpell.Equal[Automatic]} && ${This.GetSpec} == SPEC_FIRE) || ${This.PullSpell.Equal[Fireball]} || ${This.PullSpell.Equal[Pyroblast]} || ${This.isResistant[frost]} || ${This.isResistant[arcane]})
		{
			This:FirePull			
		}
		elseif !${This.isResistant[frost]} && ((${This.PullSpell.Equal[Automatic]} && ${This.GetSpec} == SPEC_FROST) || ${This.PullSpell.Equal[Frostbolt]} || ${This.isResistant[fire]})
		{
			This:FrostPull			
		}				
	}
	
	method ArcanePull()
	{
		if ${Me.Action[Arcane Power].Usable}
		{
			This:Echo["Pulling: Arcane Power"]
			This:CastInstantSpell[Arcane Power]
		}
	  elseif ${Me.Action[Arcane Blast].Usable} && (${This.PullSpell.Equal[Automatic]} || ${This.PullSpell.Equal[Arcane Blast]})
		{
			This:Echo["Pulling: Arcane Blast"]
			This:CastSpell[Arcane Blast]
		}
		elseif ${Me.Action[Arcane Missiles].Usable}
		{
			This:Echo["Pulling: Arcane Missiles"]
			This:CastSpell[Arcane Missiles]
		}
	}
	
	method FirePull()
	{
		if ${Me.Action[Pyroblast].Usable} && (${This.PullSpell.Equal[Automatic]} || ${This.PullSpell.Equal[Pyroblast]}) && ${Target.Distance} > 15
		{
			This:Echo["Pulling: Pyroblast"]
			This:CastSpell[Pyroblast]
		}
		elseif ${Me.Action[Fireball].Usable}
		{
			This:Echo["Pulling: Fireball"]
			This:CastSpell[Fireball]
		}
	}
	
	method FrostPull()
	{
		if ${Me.Action[Summon Water Elemental].Usable} && !${Me.Pet(exists)}
		{
			This:Echo["Pulling: Summon Water Elemental"]
			This:CastInstantSpell[Summon Water Elemental]
		}
		elseif ${Me.Pet(exists)} && ${Target.Distance} < 35 && ${This.UseAOE} && ${Me.Pet.Casting.Name.NotEqual[Freeze]}
		{
			This:Echo["Pulling: Pet Nova"]	
			
			This:CastPetNova	
	  	
	  	WoWScript PetAttack()
			WoWScript AttackTarget()
	  }
	 	elseif ${Me.Action[Frostbolt].Usable}
		{
			This:Echo["Pulling: Frostbolt"]
			This:CastSpell[Frostbolt]
		}	
	}
	
	method CastPetNova()
	{
		variable float X
		variable float Y
		variable float Z
		
		X:Set[${Target.X}]
		Y:Set[${Target.Y}]
		Z:Set[${Target.Z}]

		This.SpellTargetType:Set[SPELL_TARGET_GROUND]
		
		This.SpellTargetLocation.X:Set[${X}]
		This.SpellTargetLocation.Y:Set[${Y}]
		This.SpellTargetLocation.Z:Set[${Z}]
		
		WoWPress BONUSACTIONBUTTON5
		This:Wait[100]
	}
	
	/****************************************************************
	 *    Pull end
	 ***************************************************************/
	
	method Routine()
	{	
		variable string CurrentTarget
		
		if !${Me.Attacking} && ${Me.Target(exists)}
		{
			This:Echo["Attack: Autoattack"]
			WoWScript AttackTarget()			
		}				
	 	elseif ${Me.Buff[Presence of Mind](exists)}
	 	{
	 		This:Echo["Attack cast: Pyroblast"]
			if ${Me.Action[Pyroblast].Usable} && ${Target.Distance} < ${This.GetSpellRange[35, "fire"]} && !${This.isResistant[fire]}
			{
				This:Echo["Attack cast: POM Pyroblast"]
				This:CastInstantSpell[Pyroblast]
			}
			elseif ${Me.Action[Arcane Missiles].Usable} && ${Target.Distance} < ${This.GetSpellRange[30, "arcane"]} && !${This.isResistant[arcane]}
			{
				This:Echo["Attack cast: POM Arcane Missiles"]
				This:CastInstantSpell[Arcane Missiles]
			}
		}				
		elseif ${Me.Action[Counterspell].Usable} && ${Target.Casting.ID(exists)} && ${Target.CurrentMana} > 0 && !${This.isResistant[arcane]}
		{
			This:Echo["Attack cast: Counterspell"]
			This:CastInstantSpell[Counterspell]
		}			
		elseif ${Me.Buff[Clearcast](exists)} && ${Target.Distance} < ${This.GetSpellRange[30, "arcane"]} && ${Me.Action[Arcane Missiles].Usable} && !${This.isResistant[arcane]}
		{
			This:Echo["Attack cast: Clearcast Arcane Missiles"]
			This:CastSpell[Arcane Missiles]
		}		
		elseif ${Me.Action[Polymorph].Usable} && !${This.SheepTarget.Equal[""]} && !${Unit[${This.SheepTarget}].Buff[Polymorph](exists)} && ${Target.PctHPs} > 50 && ${This.Sheep}
		{
			This:Echo["Attack cast: Polymorph"]
			/* Fix by Weebs */
			CurrentTarget:Set[${Me.Target.GUID}]
			target ${This.SheepTarget}			
			This:CastSpell[Polymorph]
			target ${CurrentTarget}
		}		
		elseif ${Me.Action[Mana Tap].Usable} && ${Target.PctMana} > 0 && ${Target.Distance} < 30
  	{
  		This:Echo["Attack cast: Mana Tap"]
	    This:CastInstantSpell[Mana Tap]
	  }
	  elseif ${Me.Action[Arcane Torrent].Usable} && ${Me.PctMana} < 50 && ${Me.Buff[Mana Tap](exists)}
	  {
	  	This:Echo["Attack cast: Arcane Torrent"]
	    This:CastInstantSpell[Arcane Torrent]
	  }		
		elseif ${Me.Action[Fire Blast].Usable} && ${Target.Distance} < ${This.GetSpellRange[20, "fire"]} && !${This.isResistant[fire]}
		{
			This:Echo["Attack cast: Fire Blast"]
			This:CastInstantSpell[Fire Blast]
		}
		elseif ${Me.Action[Frost Nova].Usable} && ${Target.Distance} < ${This.GetSpellRange[10, "frost"]} && ${This.UseAOE} && ${This.SheepTarget.Equal[""]} && !${This.isFrozen} && !${This.isResistant[frost]}
		{
			This:Echo["Attack cast: Frost Nova"]
			This:CastInstantSpell[Frost Nova]
		}
		elseif ${Me.Action["Shoot"].Usable} && !${Me.Action["Shoot"].AutoRepeat} && ${Me.PctMana} < ${This.WandPCT}
   	{
   	This:Echo["Attack cast: Wand"]
      Me.Action["Shoot"]:Use
   	}   
		elseif ${This.GetSpec} == SPEC_ARCANE && !${This.isResistant[arcane]}
		{			
			This:ArcaneAttack
		}
		elseif ${This.isResistant[frost]}
		{
			This:FireAttack
		}
		elseif ${This.isResistant[fire]}
		{
			This:FrostAttack
		}	
		elseif ${This.GetSpec} == SPEC_FIRE 
		{
			This:FireAttack
		}
		elseif ${This.GetSpec} == SPEC_FROST
		{
			This:FrostAttack
		}	
		else
		{
			This:FireAttack
		}
	}
	
	method FrostAttack()
	{
		if !${Me.Pet.Target(exists)} && ${Me.Pet(exists)} && ${Me.Target(exists)}
		{
			This:Echo["Attack: Command Elemental to Attack"]
			WoWScript PetAttack()
		}
		elseif ${Me.Action[Ice Lance].Usable} && ${This.isFrozen} && ${Target.Distance} < ${This.GetSpellRange[30, "frost"]}
		{
			This:Echo["Attack cast: Ice Lance"]
			This:CastInstantSpell[Ice Lance]
		}
		elseif ${Me.Action[Cone of Cold].Usable} && ${Target.Distance} < ${This.GetSpellRange[10, "frost"]} && ${This.UseAOE} && ${This.SheepTarget.Equal[""]}
		{
			This:Echo["Attack cast: Cone of Cold"]
			This:CastInstantSpell[Cone of Cold]
		}
		elseif ${Me.Action[Frostbolt].Usable} && ${Target.Distance} < ${This.GetSpellRange[30, "frost"]}
		{
			This:Echo["Attack cast: Frostbolt"]
			This:CastSpell[Frostbolt]
		}
	}
	
	method FireAttack()
	{
		if ${Me.Action[Dragon's Breath].Usable} && ${Target.Distance} < ${This.GetSpellRange[10, "fire"]} && ${This.UseAOE} && ${This.SheepTarget.Equal[""]}
		{  
			This:Echo["Attack cast: Dragon's Breath"]
			This:CastInstantSpell[Dragon's Breath]
		} 
		elseif ${Me.Action[Scorch].Usable} && ${Target.Distance} < 10 && ${Target.PctHPs} < ${This.ScorchPCT}
		{
			This:Echo["Attack cast: Scorch"]
			This:CastSpell[Scorch]
		}
		elseif ${Me.Action[Fireball].Usable} && ${Target.Distance} < ${This.GetSpellRange[35, "fire"]}
		{
			This:Echo["Attack cast: Fireball"]
			This:CastSpell[Fireball]
		}
	}
	
	method ArcaneAttack()
	{
		if ${Me.Action[Arcane Blast].Usable} && ${Target.Distance} < ${This.GetSpellRange[30, "arcane"]}
		{
			This:Echo["Attack cast: Arcane Blast"]
			This:CastSpell[Arcane Blast]
		}		
		elseif ${Me.Action[Arcane Missiles].Usable} && ${Target.Distance} < ${This.GetSpellRange[30, "arcane"]}
		{
			This:Echo["Attack cast: Arcane Missiles"]
			This:CastSpell[Arcane Missiles]
		}
	}
	
	/*
	 * Attack
	 */
	
	member AttackState()
	{
		if ${This.Sheep}
		{
			This.SheepTarget:Set[${This.GetSheepTarget}]
		}
		
		if !${This.DoneWaiting}
		{
			This:SetStatus["Waiting"]
			return TOON_WAIT
		}

		if !${Me.Target(exists)} && ${Me.Pet.Target(exists)}
		{
			This:SetStatus["Assisting Pet"]
			return TOON_ASSIST_PET 
		}
			
		if ${This.ValidTarget} && !${Target.Dead} && ${Target.Distance} < 9 && ${This.isFrozen}
		{
			This:SetStatus["Creating some distance to frozen mob"]
			return TOON_FROZENBACKUP
		}

		if ${Target(exists)} && ${Math.Abs[${Me.Heading}-${Me.HeadingTo[${Target.X},${Target.Y}]}]} > ${Navigator.FacePercision} && ${Target.Distance} < ${This.GetPullRange}
		{
			This:SetStatus["Facing target"]
			return TOON_NEEDFACE
		}
		
		if ${WoWScript[SpellIsTargeting()]}
		{
			This:SetStatus["Spell waiting for target"]
			return TOON_SPELLTARGET
		}
				
		if ${Me.Casting} && !${This.NeedCastInterupt}
		{
			This:SetStatus["Casting a Spell"]
			return TOON_CASTING
		}
		
		if ${This.PreviousTarget.NotEqual[""]} && ${Object[${This.PreviousTarget}](exists)} 
		{
			This:SetStatus["Retargetting last mob"]
			return TOON_TARGETPREVIOUS
		}

		if ${Target.Dead}
		{
			This:SetStatus["Target dead. Cleanup."]
			return TOON_CLEARTARGET
		}
		
		if ${This.ValidTarget} && ${This.NeedPull} && !${Me.InCombat} && ${Target.Distance} <= ${This.GetPullRange}
		{
			This:SetStatus["Pulling"]
			return TOON_PULL
		}
		
		if ${This.ValidTarget} && ${Target.Distance} >= ${This.GetPullRange}
		{
			This:SetStatus["Closing distance"]
			return TOON_ENGAGE
		}
		
		if ${This.ValidTarget} && ${Target.Distance} < ${This.MinCombatRange}
		{
			This:SetStatus["Keeping minium combat range"]
			return TOON_BACKUP
		}		
		
		if ${Target(exists)} && ${Target.Distance} > ${This.MinCombatRange} && ${Movement.Moving} && ${Target.Distance} <= ${This.GetPullRange}
		{
			This:SetStatus["Stopping movement"]
			return TOON_STOPMOVE
		}		
		
		if ${This.NeedCombatBuff}
		{
			This:SetStatus["Combat Buffs"]
			return TOON_COMBATBUFF
		}
		
		if ${Me.InCombat} && ${Me.PctMana} < 10 && ${This.IsEmergencyMana} && ${This.ValidTarget}
		{
			This:SetStatus["Low on mana. Try to get more"]
			return TOON_LOWMANA
		}
		
		if ${This.ValidTarget} && ${Me.InCombat} && ${Me.PctHPs} < 10 && ${Consumable.GotHealPotion}
		{
			This:SetStatus["Low on health. Try to get more"]
			return TOON_LOWHEALTH
		}
							
		if ${ISXWoW.Facing}
		{
			This:SetStatus["Toon turning"]
			return TOON_FACING
		}
		This:SetStatus["Attacking"]
		return TOON_ATTACK		
	}

	method AttackPulse()
	{				
		This.CurrentState:Set[${This.AttackState}]
		; echo ${This.CurrentState}
		switch ${This.CurrentState}
		{
			case TOON_CASTING
				break		
			case TOON_NEEDFACE
				Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
				break
			case TOON_FACING
				break
			case TOON_BACKUP
			  Navigator:Backup[100]
				break
			case TOON_FROZENBACKUP
				if !${Movement.Moving}
				{
					Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
					This:MoveToNovaSpot
				}
				break
			case TOON_PULL
				This:PullPulse
				break
			case TOON_ASSIST_PET
				Target ${Me.Pet.Target.GUID}
				break
			case TOON_SPELLTARGET
				switch ${This.SpellTargetType}
				{
					case SPELL_TARGET_GUID
						SpellTarget ${This.SpellTargetGUID}
						if ${WoWScript[SpellIsTargeting()]}
						{
							WoWScript SpellStopTargeting()
						}
						break
					case SPELL_TARGET_GROUND
						if ${This.SpellTargetLocation.X} != 0 && ${This.SpellTargetLocation.Y} != 0 && ${This.SpellTargetLocation.Z} != 0
						{
							ISXWoW:ClickTerrain[${This.SpellTargetLocation.X},${This.SpellTargetLocation.Y},${This.SpellTargetLocation.Z}]
							This.SpellTargetLocation.X:Set[0]
							This.SpellTargetLocation.Y:Set[0]
							This.SpellTargetLocation.Z:Set[0]
						}
						break
				}
				break
			case TOON_ENGAGE
				if !${Navigator.MovingToObject[${Target.GUID},${This.GetPullRange}]}
				{
					Navigator:MoveTo[${Target.X}, ${Target.Y}, ${Target.Z}]
				}
				break
			case TOON_COMBATBUFF
				This:CombatBuffPulse
				break
			case TOON_LOWMANA
				This:ActivateEmergencyMana
				break
			case TOON_LOWHEALTH
				Consumable:UseHealPotion
				break			
			case TOON_ATTACK
				if ${Target(exists)}
				{
					This:Routine
				}
				break
			case TOON_TARGETPREVIOUS
				Target ${This.PreviousTarget}
				This.PreviousTarget:Set[""]
				break
			case TOON_STOPMOVE
				Navigator:ResetDestination
				move -stop
				break
			case TOON_CLEARTARGET
				This:ResetReactive
				WoWScript ClearTarget()
				break
			case TOON_WAIT
				break
		}
	}
	
	/****************************************************************
	 *    Target info start
	 ***************************************************************/
	member isFrozen()
	{
		if ${Target.Buff[Frostbite](exists)} || ${Target.Buff[Freeze](exists)} || ${Target.Buff[Frost Nova](exists)}
		{
			return TRUE
		}
		else
		{
			return FALSE
		}
	}	

	member GetSheepTarget()
	{
		variable guidlist Aggros
		variable int Idx = 1
		variable int LowestHpTarget = -1
		variable int HighLevelTarget = -1
		
		/* Addtional search for untapped mobs that are sheeped */
		Aggros:Search[-units,-nearest,-aggro,-alive,-range 0-35]
		if ${Aggros.Count} == 1
		{
			if ${Aggros.Object[1].Buff[Polymorph](exists)}
			{
				echo last mob & its a sheep triggered!
				Target ${Aggros.Object[1].GUID}
				return ${Aggros.Object[1].GUID}
			}			
		}		
		Aggros:Clear
		
		Aggros:Search[-units,-nearest,-aggro,-alive,-tappedbyme,-range 0-35]

		if ${Aggros.Count} > 1
		{
			Idx:Set[1]
			do
			{
				if (${Aggros.Object[${Idx}].CreatureType.Equal[Humanoid]} || ${Aggros.Object[${Idx}].CreatureType.Equal[Beast]}) && !${Aggros.Object[${Idx}].GUID.Equal[${Target.GUID}]}
				{
					LowestHpTarget:Set[${Idx}]
					HighLevelTarget:Set[${Idx}]
				}
			}
			while ${Idx:Inc} <= ${Aggros.Count}
			
			Idx:Set[1]
			do
			{
				if ${Aggros.Object[${Idx}].Buff[Polymorph](exists)}
				{
					return ${Aggros.Object[${Idx}].GUID}
				}
				elseif ${Aggros.Object[${Idx}].CreatureType.Equal[Humanoid]} || ${Aggros.Object[${Idx}].CreatureType.Equal[Beast]}
				{
					if ${Aggros.Object[${Idx}].PctHPs} < ${Aggros.Object[${LowestHpTarget}].PctHPs} && !${Aggros.Object[${Idx}].GUID.Equal[${Target.GUID}]}
					{
						LowestHpTarget:Set[${Idx}]
					}
					if ${Aggros.Object[${Idx}].Level} > ${Aggros.Object[${HighLevelTarget}].Level} && !${Aggros.Object[${Idx}].GUID.Equal[${Target.GUID}]}
					{
						HighLevelTarget:Set[${Idx}]
					}
				}				
			}
			while ${Idx:Inc} <= ${Aggros.Count}
			
			if ${Aggros.Object[${LowestHpTarget}].PctHPs} == 100 && ${HighLevelTarget} > 0
			{
				return ${Aggros.Object[${HighLevelTarget}].GUID}
			}
			elseif ${LowestHpTarget} > 0
			{
				return ${Aggros.Object[${LowestHpTarget}].GUID}
			}
			else
			{
				return ""
			}
		}
		elseif ${Aggros.Count} == 1 && ${Aggros.Object[1].Buff[Polymorph](exists)}
		{
			return ${Aggros.Object[1].GUID}
		}
		else
		{
			return ""
		}		
	}	
	/****************************************************************
	 *    Target info end
	 ***************************************************************/
	 
	 
	/****************************************************************
	 *    Spec & spell selection start
	 ***************************************************************/
	member GetPullRange()
	{
		if ${This.PullRange} == -1
		{
			switch ${This.PullSpell}
			{
				case "Automatic"
					if ${This.GetSpec} == SPEC_ARCANE
					{
						return 29
					}
					elseif ${This.GetSpec} == SPEC_FIRE
					{
						return ${This.GetSpellRange[35, "fire"]}
					}
				case "Frostbolt"
					return ${This.GetSpellRange[30, "fost"]}
					break
				case "Fireball"
				case "Pyroblast"
					return ${This.GetSpellRange[35, "fire"]}
					break
				case "Arcane Blast"
				case "Arcane Missiles"
					return 29
					break
			}		
			return 29
		}
		else
		{
			return ${This.PullRange}
		}
	}
	
	member GetSpellRange(int base, string spellTree)
	{
		if ${spellTree.Equal[fire]}
		{
			return ${Math.Calc[${base}+(3*${Me.Talent[Flame Throwing]})-1].Round}
		}
		elseif ${spellTree.Equal[frost]}
		{
			return ${Math.Calc[${base}*(1+(0.1*${Me.Talent[Arctic Reach]}))-1].Round}
		}
		return ${base}
	}
	
	member GetSpec()
	{	
		if ${Me.Talent[Improved Arcane Missiles]} > ${Me.Talent[Improved Fireball]} && ${Me.Talent[Improved Arcane Missiles]} > ${Me.Talent[Improved Frostbolt]}
		{
			return SPEC_ARCANE
		}
		elseif ${Me.Talent[Improved Frostbolt]} > ${Me.Talent[Improved Fireball]}
		{
			return SPEC_FROST
		}		
		return SPEC_FIRE
	}
	/****************************************************************
	 *    Spec & spell selection end
	 ***************************************************************/
	 
	 
	/****************************************************************
	 *    Trinkets & emergency selection start
	 ***************************************************************/
	member TrinketUsable()
	{	
		if ${Me.Action[${Me.Equip[trinket1]}].Usable} || ${Me.Action[${Me.Equip[trinket2]}].Usable}
		{
			return TRUE			
		}
		return FALSE
	}
	
	method UseTrinket()
	{
		if ${Me.Action[${Me.Equip[trinket1]}].Usable}
		{
			Item[${Me.Equip[trinket1]}]:Use
		}
		elseif ${Me.Action[${Me.Equip[trinket2]}].Usable}
		{
			Item[${Me.Equip[trinket2]}]:Use
		}
	}
	
	member IsEmergencyMana()
	{
		if ${Item[${This.GetManaStone}].Usable}
	  {    
	  	return TRUE
	  }
	  elseif ${Me.Action[Evocation].Usable} && (${This.isFrozen} || ${Me.Buff[Ice Barrier](exists)} || ${Me.Buff[Mana Shield](exists)} || ${Me.Buff[Polymorph](exists)})
	  {
	  	return TRUE
	  }
	  elseif ${Consumable.GotManaPotion}
	  {
	  	return TRUE
	  }
	  return FALSE
	}
	
	method ActivateEmergencyMana()
	{
		if ${Item[${This.GetManaStone}].Usable}
	  {    
	  	Item[${This.GetManaStone}]:Use
	  } 
	  elseif ${Me.Action[Evocation].Usable}
	  {    
	  	This:CastSpell[Evocation]
	  }
	  elseif ${Consumable.GotManaPotion}
	  {    
	  	Consumable:UseManaPotion
	  }
	}
	
	member GetManaStone()
	{
		if ${Spell[Conjure Mana Emerald](exists)}
	  {    
	  	return "Mana Emerald"
	  } 
	  elseif ${Spell[Conjure Mana Ruby](exists)}
	  {    
	  	return "Mana Ruby"
	  }
	  elseif ${Spell[Conjure Mana Citrine](exists)}
	  {    
	  	return "Mana Citrine"
	  } 
	  elseif ${Spell[Conjure Mana Jade](exists)}
	  {    
	  	return "Mana Jade"
	  } 
	  elseif ${Spell[Conjure Mana Agate](exists)}
	  {    
	  	return "Mana Agate"
	  }
	  else
	  {
	 		return NULL
		}
	}
	
	member NeedDecurse()
	{			
		if ${BuffNum} > 56
		{
			buffNum:Set[1]
		}

		if !${Me.Buff[${BuffNum}](exists)}
		{
			return FALSE
		}
				
		if ${Me.Buff[${BuffNum}].Harmful}
		{
			if ${Me.Buff[${BuffNum}].DispelType.Equal[Curse]} && ${Spell[Remove Lesser Curse](exists)}
			{
				return TRUE
			}
		}
		BuffNum:Inc
		
		return FALSE
	}
		
	method MoveToNovaSpot()
	{
		variable guidlist MobList
		variable point3f SafeSpot
		variable point3f SafeSpotByPlayer
		variable objectref Data
		variable int Range = 9
		variable int AggroRange = 0
		variable int Degrees = 185
		variable int Idx = 1
		variable bool Orgasm = FALSE
		
		SafeSpot.X:Set[${Me.X}]
		SafeSpot.Y:Set[${Me.Y}]
		SafeSpot.Z:Set[${Me.Z}]
		
		SafeSpotByPlayer.X:Set[0]
		SafeSpotByPlayer.Y:Set[0]
		SafeSpotByPlayer.Z:Set[0]
		
		if ${Target.Distance} > 7 && ${Target.Distance} < 9
		{
			SafeSpot.X:Set[${Target.X} + ${Range}*${Math.Cos[180]}]
			SafeSpot.Y:Set[${Target.Y} - ${Range}*${Math.Sin[180]}]
			SafeSpot.Z:Set[${Target.Z} + 0.9]
			
			if !${Me.IsPathObstructed[${SafeSpot.X},${SafeSpot.Y},${SafeSpot.Z}]}
			{
				Navigator:Backup[1000]
				return
			}			
		}
		else
		{
			SafeSpot.X:Set[${Me.X}]
			SafeSpot.Y:Set[${Me.Y}]
			SafeSpot.Z:Set[${Me.Z}]
			
			MobList:Search[-units,-nonfriendly,-nocritters,-nopets,-alive,-nearest,-untapped,-range 0-40] 
			do
			{
				Degrees:Set[95]
				Degrees:Inc[${Math.Rand[170]}]
				do
				{
					SafeSpot.X:Set[${Target.X} + ${Range}*${Math.Cos[${Degrees}]}]
					SafeSpot.Y:Set[${Target.Y} - ${Range}*${Math.Sin[${Degrees}]}]
					SafeSpot.Z:Set[${Target.Z} + 0.9]
					
					Orgasm:Set[TRUE]
					Idx:Set[1]
					if ${MobList.Count}
					{
						do
						{
							Data:Set[${MobList.GUID[${Idx}]}]
							AggroRange:Set[${Environment.AggroRange[${Data.GUID}]}]
							if ${Math.Distance[${SafeSpot.X},${SafeSpot.Y},${Data.X},${Data.Y}]} < ${AggroRange}
							{
								Orgasm:Set[FALSE]
							}
						}
						while ${Idx:Inc} <= ${MobList.Count}
					}
					
					if ${Math.Distance[${SafeSpot.X},${SafeSpot.Y},${Me.X},${Me.Y}]} > 11
					{
						Orgasm:Set[FALSE]
					}
	
					if ${Orgasm}
					{
						if !${Me.IsPathObstructed[${SafeSpot.X},${SafeSpot.Y},${SafeSpot.Z}]}
						{
							if ${SafeSpot.X} >= ${Me.X}
							{
								SafeSpotByPlayer.X:Set[${Math.Calc[${SafeSpot.X} - ${Me.X}]}]
							}
							else
							{
								SafeSpotByPlayer.X:Set[${Math.Calc[${SafeSpot.X} + ${Me.X}]}]
							}
							if ${SafeSpot.Y} >= ${Me.Y}
							{
								SafeSpotByPlayer.Y:Set[${Math.Calc[${SafeSpot.Y} - ${Me.Y}]}]
							}
							else
							{
								SafeSpotByPlayer.Y:Set[${Math.Calc[${SafeSpot.Y} + ${Me.Y}]}]
							}	
							
							This:Debug["Found safespot at ${Math.Distance[${Target.X},${Target.Y},${SafeSpot.X},${SafeSpot.Y}].Int} yards from frozen target: ${SafeSpot.X} ${SafeSpot.Y} ${SafeSpot.Z}"]
							if ${SafeSpotByPlayer.Y} > 0
							{
								Navigator:FaceXYZ[${Math.Calc[(${SafeSpotByPlayer.X} * -1) + ${Me.X}]},${SafeSpot.Y},${SafeSpot.Z}]										
							}
							else
							{
								Navigator:FaceXYZ[${SafeSpot.X},${Math.Calc[(${SafeSpotByPlayer.Y} * -1) + ${Me.Y}]},${SafeSpot.Z}]
							}
							
							if (${SafeSpotByPlayer.X} > 0
							{
								Navigator:StrafeRight[5000]							
							}
							else
							{
								Navigator:StrafeLeft[5000]							
							}
							return
						}
						;Fake orgasm
						Orgasm:Set[FALSE]
					}
				}
				while ${Degrees:Inc[5]} <= 450
			}
			while ${Range:Inc[1]} <= 15
		}
		This:Debug["Could not find a decent safespot. you are screwed."]
	}
	/****************************************************************
	 *    Trinkets & emergency selection end
	 ***************************************************************/
	
	
	/****************************************************************
	 *    Reactive stuff start
	 ***************************************************************/
	member isResistant(string sDamageType)
	{
		variable uint idx = 1
		variable bool found = FALSE
		
		if ${Target(exists)} && ${Target.Type.NotEqual[Player]}
		{
			if ${sDamageType.Equal[frost]}
			{
				while ${FrostResistant.Next[${idx}](exists)}
				{
					if ${FrostResistant.Get[${idx}].Equal[${Target.Name}]}
					{
						return TRUE					
					}
					idx:Set[${FrostResistant.Next[${idx}]}]				
				}
			}
			elseif ${sDamageType.Equal[fire]}
			{
				while ${FireResistant.Next[${idx}](exists)}
				{
					if ${FireResistant.Get[${idx}].Equal[${Target.Name}]}
					{
						return TRUE				
					}
					idx:Set[${FireResistant.Next[${idx}]}]				
				}
			}
			elseif ${sDamageType.Equal[arcane]}
			{
				while ${ArcaneResistant.Next[${idx}](exists)}
				{
					if ${ArcaneResistant.Get[${idx}].Equal[${Target.Name}]}
					{
						return TRUE				
					}
					idx:Set[${ArcaneResistant.Next[${idx}]}]				
				}
			}
		}
		return FALSE
	}
	
	method ImmuneCheck(string eventid , text, Message)
	{		
		variable uint idx = 1
		variable bool found = FALSE
		
		if ${Target.Type.NotEqual[Player]}
		{
			if (${Message.Find[Frost Nova]} || ${Message.Find[Ice Lance]} || ${Message.Find[Frostbolt]} || ${Message.Find[Cone of Cold]}) && ${Message.Find[failed]} && ${Message.Find[immune]}
			{
				while ${FrostResistant.Next[${idx}](exists)}
				{
					if ${FrostResistant.Get[${idx}].Equal[${Target.Name}]}
					{
						found:Set[TRUE]					
					}
					idx:Set[${FrostResistant.Next[${idx}]}]				
				}
				
				if !${found}
				{
					This.FrostResistant:Insert[${Target.Name}]
				}
			}
			elseif (${Message.Find[Molten Armor]} || ${Message.Find[Pyroblast]} || ${Message.Find[Fireball]} || ${Message.Find[Fire Blast]}) && ${Message.Find[failed]} && ${Message.Find[immune]}
			{			
				while ${FireResistant.Next[${idx}](exists)}
				{
					if ${FireResistant.Get[${idx}].Equal[${Target.Name}]}
					{
						found:Set[TRUE]					
					}
					idx:Set[${FireResistant.Next[${idx}]}]
				}
				
				if !${found}
				{
					This.FireResistant:Insert[${Target.Name}]
				}
			}
			elseif (${Message.Find[Counterspell]} || ${Message.Find[Arcane Missiles]} || ${Message.Find[Arcane Blast]}) && ${Message.Find[failed]} && ${Message.Find[immune]}
			{			
				while ${ArcaneResistant.Next[${idx}](exists)}
				{
					if ${ArcaneResistant.Get[${idx}].Equal[${Target.Name}]}
					{
						found:Set[TRUE]					
					}
					idx:Set[${ArcaneResistant.Next[${idx}]}]
				}
				
				if !${found}
				{
					This.ArcaneResistant:Insert[${Target.Name}]
				}
			}
		}
	}
	
	method DamageCheck(string eventid , text, Message)
	{
		if ${Message.Find[hits you]} && ${Message.Find[Frost damage]}
		{
			This.UseFrostWard:Set[TRUE]
		}
		if ${Message.Find[hits you]} && !${Message.Find[Frost damage]}
		{
			This.UseFrostWard:Set[FALSE]
		}
		if ${Message.Find[hits you]} && ${Message.Find[Fire damage]}
		{
			This.UseFireWard:Set[TRUE]
		}
		if ${Message.Find[hits you]} && !${Message.Find[Fire damage]}
		{
			This.UseFireWard:Set[FALSE]
		}
	}
	
	method DampenCheck(string eventid , text, Message)
	{
		if ${Message.Find[hits you for]} && ${Message.Find[Nature damage]} || ${Message.Find[Shadow damage]} || ${Message.Find[Holy damage]} || ${Message.Find[Fire damage]} || ${Message.Find[Frost damage]}
		{
			This.NeedDampenMagic:Set[TRUE]
		}
		if ${Message.Find[hits you for]} && !${Message.Find[Nature damage]} || ${Message.Find[Shadow damage]} || ${Message.Find[Holy damage]} || ${Message.Find[Fire damage]} || ${Message.Find[Frost damage]}
		{
			This.NeedDampenMagic:Set[FALSE]
		}
	}
	
	/* Idea by Weebs */
	method LineOfSightCheck(string eventid, text, Message) 
	{ 
  	This:Debug["Message received: ${Message}"]      
  	
  	if ${Message.Equal["Target not in line of sight"]} 
    { 
	    This:Debug["Target not in line of sight. Add to Blacklist GUID: ${Target.GUID}"]      
	    Environment:BlackListGUID[${Target.GUID}]
	    Environment:ClearTarget 
	    return 
    } 
    if ${Message.Equal["Evade"]} 
    { 
	    This:Debug["Evade. Add to Blacklist GUID: ${Target.GUID}"]      
	    Environment:BlackListGUID[${Target.GUID}] 
	    Environment:ClearTarget
	    return 
    }
    if ${Message.Equal["You cannot attack that target"]} 
    { 
	    This:Debug["You cannot attack that target. Add to Blacklist GUID: ${Target.GUID}"]      
	    Environment:BlackListGUID[${Target.GUID}] 
	    Environment:ClearTarget
	    return 
    }
    if ${Message.Equal["Invalid target"]} 
    { 
	    This:Debug["Invalid target. Add to Blacklist GUID: ${Target.GUID}"]      
	    Environment:BlackListGUID[${Target.GUID}] 
	    Environment:ClearTarget
	    return 
    }
	}
	
	method ResetReactive()
	{
		This.NeedDampenMagic:Set[FALSE]
		This.UseFireWard:Set[FALSE]
		This.UseFrostWard:Set[FALSE]
	}	
	/****************************************************************
	 *    Reactive stuff end
	 ***************************************************************/
	 
	 
	/****************************************************************
	 *    ui start
	 ***************************************************************/
	method GUIToonInfo(string newmsg)
	{
		UIElement[lblLastAction@Generic@Pages@ToonGUI]:SetText[${newmsg}]
	}
				
	method ToonGUIChange(string Action)
	{
		switch ${Action}
		{
			case pull
				if ${UIElement[cmbPullSpell@Spells@Pages@ToonGUI].SelectedItem.Text(exists)}
				{
					This.PullSpell:Set[${UIElement[cmbPullSpell@Spells@Pages@ToonGUI].SelectedItem.Text}]
				}
				break
			case armor
				if ${UIElement[cmbArmorSpell@Spells@Pages@ToonGUI].SelectedItem.Text(exists)}
				{
					This.ArmorSpell:Set[${UIElement[cmbArmorSpell@Spells@Pages@ToonGUI].SelectedItem.Text}]
				}
				break
			case shield
				if ${UIElement[cmbShieldSpell@Spells@Pages@ToonGUI].SelectedItem.Text(exists)}
				{
					This.ShieldSpell:Set[${UIElement[cmbShieldSpell@Spells@Pages@ToonGUI].SelectedItem.Text}]
				}
				break
			case pullrange
				if ${UIElement[cmbPullRange@Spells@Pages@ToonGUI].SelectedItem.Text(exists)}
				{	
					if ${UIElement[cmbPullRange@Spells@Pages@ToonGUI].SelectedItem.Text.Equal[Auto]}
					{
						This.PullRange:Set[-1]
					}
					else
					{
						This.PullRange:Set[${UIElement[cmbPullRange@Spells@Pages@ToonGUI].SelectedItem.Value}]
					} 
				}
				break
			case shieldpct
				if ${UIElement[cmbShieldPCT@Spells@Pages@ToonGUI].SelectedItem.Text(exists)}
				{
					if ${UIElement[cmbShieldPCT@Spells@Pages@ToonGUI].SelectedItem.Text.Equal[Always On]}
					{
						This.ShieldPCT:Set[110]
					}
					elseif ${UIElement[cmbShieldPCT@Spells@Pages@ToonGUI].SelectedItem.Text.Equal[Before Pull]}
					{
						This.ShieldPCT:Set[105]
					}
					else
					{
						This.ShieldPCT:Set[${UIElement[cmbShieldPCT@Spells@Pages@ToonGUI].SelectedItem.Value}]
					}
				}
				break
			case dampen
				if ${UIElement[cmbDampenMagic@Spells@Pages@ToonGUI].SelectedItem.Text(exists)}
				{					
					This.DampenMagic:Set[${UIElement[cmbDampenMagic@Spells@Pages@ToonGUI].SelectedItem.Text}]
				}
				break
			case wards
				if ${UIElement[cmbWards@Spells@Pages@ToonGUI].SelectedItem.Text(exists)}
				{
					This.Wards:Set[${UIElement[cmbWards@Spells@Pages@ToonGUI].SelectedItem.Text}]
				}
				break
			case aoe
				if ${UIElement[cmbUseAOE@Spells@Pages@ToonGUI].SelectedItem.Text(exists)}
				{
					if ${UIElement[cmbUseAOE@Spells@Pages@ToonGUI].SelectedItem.Text.Equal[No]}
					{
						This.UseAOE:Set[FALSE]
					}
					else
					{
						This.UseAOE:Set[TRUE]
					}
				}
				break
			case trinkets
				if ${UIElement[cmbTrinkets@Spells@Pages@ToonGUI].SelectedItem.Text(exists)}
				{
					if ${UIElement[cmbTrinkets@Spells@Pages@ToonGUI].SelectedItem.Text.Equal[No]}
					{
						This.Trinkets:Set[FALSE]
					}
					else
					{
						This.Trinkets:Set[TRUE]
					}
				}
				break
			case racials
				if ${UIElement[cmbRacials@Spells@Pages@ToonGUI].SelectedItem.Text(exists)}
				{
					if ${UIElement[cmbRacials@Spells@Pages@ToonGUI].SelectedItem.Text.Equal[No]}
					{
						This.Racials:Set[FALSE]
					}
					else
					{
						This.Racials:Set[TRUE]
					}
				}
				break
			case sheep
				if ${UIElement[cmbSheep@Spells@Pages@ToonGUI].SelectedItem.Text(exists)}
				{
					if ${UIElement[cmbSheep@Spells@Pages@ToonGUI].SelectedItem.Text.Equal[No]}
					{
						This.Sheep:Set[FALSE]
					}
					else
					{
						This.Sheep:Set[TRUE]
					}
				}
				break
				case scorch
				if ${UIElement[cmbScorch@Spells@Pages@ToonGUI].SelectedItem.Text(exists)}
				{
					This.ScorchPCT:Set[${UIElement[cmbScorch@Spells@Pages@ToonGUI].SelectedItem.Value}]
				}
				break		
				case wand
				if ${UIElement[cmbWandPCT@Spells@Pages@ToonGUI].SelectedItem.Text(exists)}
				{
					This.WandPCT:Set[${UIElement[cmbWandPCT@Spells@Pages@ToonGUI].SelectedItem.Value}]
				}
				break			
			case defaultspells
				This.PullSpell:Set["Automatic"]
				This.ArmorSpell:Set["Automatic"]
				This.ShieldSpell:Set["Automatic"]				
				This.Wards:Set["Automatic"]
				This.DampenMagic:Set["Automatic"]
				This.ShieldPCT:Set[110]
				This.PullRange:Set[-1]
				This.UseAOE:Set[TRUE]
				This.Trinkets:Set[TRUE]
				This.Racials:Set[TRUE]
				This.Sheep:Set[TRUE]		
				This.ScorchPCT:Set[110]
				This.WandPCT:Set[10]	
						
				This:InitMageGui[spells]
				break
		/** Generic **/
			case minmana
				if ${UIElement[cmbMinMana@Generic@Pages@ToonGUI].SelectedItem.Value(exists)}
				{	
							This.MinMana:Set[${UIElement[cmbMinMana@Generic@Pages@ToonGUI].SelectedItem.Value}]
				}
				break	
			case maxmana
				if ${UIElement[cmbMaxMana@Generic@Pages@ToonGUI].SelectedItem.Value(exists)}
				{	
							This.MaxMana:Set[${UIElement[cmbMaxMana@Generic@Pages@ToonGUI].SelectedItem.Value}]
				}
				break	
			case minhealth
				if ${UIElement[cmbMinHealth@Generic@Pages@ToonGUI].SelectedItem.Value(exists)}
				{	
							This.MinHealth:Set[${UIElement[cmbMinHealth@Generic@Pages@ToonGUI].SelectedItem.Value}]
				}
				break
			case maxhealth
				if ${UIElement[cmbMaxHealth@Generic@Pages@ToonGUI].SelectedItem.Value(exists)}
				{	
							This.MaxHealth:Set[${UIElement[cmbMaxHealth@Generic@Pages@ToonGUI].SelectedItem.Value}]
				}
				break
			case levelbelow
				if ${UIElement[cmbLevelBelow@Generic@Pages@ToonGUI].SelectedItem.Value(exists)}
				{	
							This.LevelBelow:Set[${UIElement[cmbLevelBelow@Generic@Pages@ToonGUI].SelectedItem.Value}]
				}
				break
			case levelabove
				if ${UIElement[cmbLevelAbove@Generic@Pages@ToonGUI].SelectedItem.Value(exists)}
				{	
							This.LevelAbove:Set[${UIElement[cmbLevelAbove@Generic@Pages@ToonGUI].SelectedItem.Value}]
				}
				break
			case defaultgeneric
				This.MinMana:Set[60]
				This.MaxMana:Set[95]
				This.MinHealth:Set[60]
				This.MaxHealth:Set[90]
				This.LevelBelow:Set[4]
				This.LevelAbove:Set[2]		
						
				This:InitMageGui[generic]
				break
		}
	}
	 
	method InitMageGui(string tab)
	{		
		variable int i = 1
		for (i:Set[1] ; ${i}<=${UIElement[cmbPullSpell@Spells@Pages@ToonGUI].Items} ; i:Inc)
		{
		  if ${This.PullSpell.Equal[${UIElement[cmbPullSpell@Spells@Pages@ToonGUI].Item[${i}].Text}]}
			{
				UIElement[cmbPullSpell@Spells@Pages@ToonGUI]:SelectItem[${i}]
			}
		}
		for (i:Set[1] ; ${i}<=${UIElement[cmbArmorSpell@Spells@Pages@ToonGUI].Items} ; i:Inc)
		{
		  if ${This.ArmorSpell.Equal[${UIElement[cmbArmorSpell@Spells@Pages@ToonGUI].Item[${i}].Text}]}
			{
				UIElement[cmbArmorSpell@Spells@Pages@ToonGUI]:SelectItem[${i}]
			}
		}
		for (i:Set[1] ; ${i}<=${UIElement[cmbShieldSpell@Spells@Pages@ToonGUI].Items} ; i:Inc)
		{
		  if ${This.ShieldSpell.Equal[${UIElement[cmbShieldSpell@Spells@Pages@ToonGUI].Item[${i}].Text}]}
			{
				UIElement[cmbShieldSpell@Spells@Pages@ToonGUI]:SelectItem[${i}]
			}
		}
		for (i:Set[1] ; ${i}<=${UIElement[cmbWards@Spells@Pages@ToonGUI].Items} ; i:Inc)
		{
		  if ${This.Wards.Equal[${UIElement[cmbWards@Spells@Pages@ToonGUI].Item[${i}].Text}]}
			{
				UIElement[cmbWards@Spells@Pages@ToonGUI]:SelectItem[${i}]
			}
		}
		for (i:Set[1] ; ${i}<=${UIElement[cmbDampenMagic@Spells@Pages@ToonGUI].Items} ; i:Inc)
		{
		  if ${This.DampenMagic.Equal[${UIElement[cmbDampenMagic@Spells@Pages@ToonGUI].Item[${i}].Text}]}
			{
				UIElement[cmbDampenMagic@Spells@Pages@ToonGUI]:SelectItem[${i}]
			}
		}
		for (i:Set[1] ; ${i}<=${UIElement[cmbShieldPCT@Spells@Pages@ToonGUI].Items} ; i:Inc)
		{
			if ${This.ShieldPCT} == 110
			{
				UIElement[cmbShieldPCT@Spells@Pages@ToonGUI]:SelectItem[1]
			}
			elseif ${This.ShieldPCT} == 105
			{
				UIElement[cmbShieldPCT@Spells@Pages@ToonGUI]:SelectItem[2]
			}
			elseif ${This.ShieldPCT} == ${UIElement[cmbShieldPCT@Spells@Pages@ToonGUI].Item[${i}].Value}
			{
				UIElement[cmbShieldPCT@Spells@Pages@ToonGUI]:SelectItem[${i}]
			} 
		}
		for (i:Set[1] ; ${i}<=${UIElement[cmbPullRange@Spells@Pages@ToonGUI].Items} ; i:Inc)
		{
			if ${This.PullRange} == -1
			{
				UIElement[cmbPullRange@Spells@Pages@ToonGUI]:SelectItem[1]
			}
			elseif ${This.PullRange} == ${UIElement[cmbPullRange@Spells@Pages@ToonGUI].Item[${i}].Value}
			{
				UIElement[cmbPullRange@Spells@Pages@ToonGUI]:SelectItem[${i}]
			} 
		}
		if ${This.UseAOE}
		{
			UIElement[cmbUseAOE@Spells@Pages@ToonGUI]:SelectItem[1]
		}
		else
		{
			UIElement[cmbUseAOE@Spells@Pages@ToonGUI]:SelectItem[2]
		}
		if ${This.Trinkets}
		{
			UIElement[cmbTrinkets@Spells@Pages@ToonGUI]:SelectItem[1]
		}
		else
		{
			UIElement[cmbTrinkets@Spells@Pages@ToonGUI]:SelectItem[2]
		}
	  if ${This.Racials}
		{
			UIElement[cmbRacials@Spells@Pages@ToonGUI]:SelectItem[1]
		}
		else
		{
			UIElement[cmbRacials@Spells@Pages@ToonGUI]:SelectItem[2]
		}
		if ${This.Sheep}
		{
			UIElement[cmbSheep@Spells@Pages@ToonGUI]:SelectItem[1]
		}
		else
		{
			UIElement[cmbSheep@Spells@Pages@ToonGUI]:SelectItem[2]
		}		
		for (i:Set[1] ; ${i}<=${UIElement[cmbScorch@Spells@Pages@ToonGUI].Items} ; i:Inc)
		{
			if ${This.ScorchPCT} == ${UIElement[cmbScorch@Spells@Pages@ToonGUI].Item[${i}].Value}
			{
				UIElement[cmbScorch@Spells@Pages@ToonGUI]:SelectItem[${i}]
			} 
		}
		for (i:Set[1] ; ${i}<=${UIElement[cmbWandPCT@Spells@Pages@ToonGUI].Items} ; i:Inc)
		{
			if ${This.WandPCT} == ${UIElement[cmbWandPCT@Spells@Pages@ToonGUI].Item[${i}].Value}
			{
				UIElement[cmbWandPCT@Spells@Pages@ToonGUI]:SelectItem[${i}]
			} 
		}
		
/** Generic **/
		for (i:Set[1] ; ${i}<=${UIElement[cmbMinMana@Generic@Pages@ToonGUI].Items} ; i:Inc)
		{
		  if ${This.MinMana} == ${UIElement[cmbMinMana@Generic@Pages@ToonGUI].Item[${i}].Value}
			{
				UIElement[cmbMinMana@Generic@Pages@ToonGUI]:SelectItem[${i}]
			}
		}		
		for (i:Set[1] ; ${i}<=${UIElement[cmbMaxMana@Generic@Pages@ToonGUI].Items} ; i:Inc)
		{
		  if ${This.MaxMana} == ${UIElement[cmbMaxMana@Generic@Pages@ToonGUI].Item[${i}].Value}
			{
				UIElement[cmbMaxMana@Generic@Pages@ToonGUI]:SelectItem[${i}]
			}
		}
		for (i:Set[1] ; ${i}<=${UIElement[cmbMinHealth@Generic@Pages@ToonGUI].Items} ; i:Inc)
		{
		  if ${This.MinHealth} == ${UIElement[cmbMinHealth@Generic@Pages@ToonGUI].Item[${i}].Value}
			{
				UIElement[cmbMinHealth@Generic@Pages@ToonGUI]:SelectItem[${i}]
			}
		}
		for (i:Set[1] ; ${i}<=${UIElement[cmbMaxHealth@Generic@Pages@ToonGUI].Items} ; i:Inc)
		{
		  if ${This.MaxHealth} == ${UIElement[cmbMaxHealth@Generic@Pages@ToonGUI].Item[${i}].Value}
			{
				UIElement[cmbMaxHealth@Generic@Pages@ToonGUI]:SelectItem[${i}]
			}
		}
		for (i:Set[1] ; ${i}<=${UIElement[cmbLevelBelow@Generic@Pages@ToonGUI].Items} ; i:Inc)
		{
		  if ${This.LevelBelow} == ${UIElement[cmbLevelBelow@Generic@Pages@ToonGUI].Item[${i}].Value}
			{
				UIElement[cmbLevelBelow@Generic@Pages@ToonGUI]:SelectItem[${i}]
			}
		}
		for (i:Set[1] ; ${i}<=${UIElement[cmbLevelAbove@Generic@Pages@ToonGUI].Items} ; i:Inc)
		{
		  if ${This.LevelAbove} == ${UIElement[cmbLevelAbove@Generic@Pages@ToonGUI].Item[${i}].Value}
			{
				UIElement[cmbLevelAbove@Generic@Pages@ToonGUI]:SelectItem[${i}]
			}
		}
	}
	
	method Echo(string Text)
	{
		if ${UIElement[ConsoleGUI](exists)}
		{
			UIElement[Console@Console@Pages@ToonGUI]:Echo["${Time.Time24} ${Text.Escape}"]
		}
		else
		{
			echo "${Time.Time24} ${Text}"
		}
	}
	
	method SetStatus(string Text)
	{
		UIElement[Status@Console@Pages@ToonGUI]:SetText[${Text.Escape}]
	}
	/****************************************************************
	 *    ui end
	 ***************************************************************/
	
		
	
	/****************************************************************
	 *    Config
	 ***************************************************************/
	 
	method LoadConfig()
	{
		This.MinCombatRange:Set[${This.ToonConfig.FindSetting["MinCombatRange",2]}]
		This.MaxCombatRange:Set[${This.ToonConfig.FindSetting["MaxCombatRange",30]}]
		This.RepairPct:Set[${This.ToonConfig.FindSetting["RepairPct",20]}]
		This.KeepFreeSlots:Set[${This.ToonConfig.FindSetting["KeepFreeSlots",3]}]
		This.MountDistance:Set[${This.ToonConfig.FindSetting["MountDistance",400]}]
		This.Loot:Set[${This.ToonConfig.FindSetting["Loot",TRUE]}]
		This.CorpseCampLimit:Set[${This.ToonConfig.FindSetting["CorpseCampLimit",3]}]
		This.ExitOnStuck:Set[${This.ToonConfig.FindSetting["ExitOnStuck",0]}]
		This.PrimaryStat:Set[${This.ToonConfig.FindSetting["PrimaryStat",STAT_INT]}]
		This.SecondaryStat:Set[${This.ToonConfig.FindSetting["SecondaryStat",STAT_STA]}]
		This.AutoEquip:Set[${This.ToonConfig.FindSetting["AutoEquip",FALSE]}]
		This.MinMuleItems:Set[${This.ToonConfig.FindSetting["MinMuleItems",5]}]
		This.AutoPvP:Set[${This.ToonConfig.FindSetting["AutoPvP",FALSE]}]		
		This.AutoTrainSkills:Set[${This.ToonConfig.FindSetting["AutoTrainSkills",TRUE]}]
		This.DismountOnAggro:Set[${This.ToonConfig.FindSetting["DismountOnAggro",TRUE]}]

		This.PullSpell:Set[${This.ToonConfig.FindSetting["PullSpell","Automatic"]}]
		This.ArmorSpell:Set[${This.ToonConfig.FindSetting["ArmorSpell","Automatic"]}]
		This.ShieldSpell:Set[${This.ToonConfig.FindSetting["ShieldSpell","Automatic"]}]
		
		This.Wards:Set[${This.ToonConfig.FindSetting["Wards","Automatic"]}]
		This.DampenMagic:Set[${This.ToonConfig.FindSetting["DampenMagic","Automatic"]}]
		This.ShieldPCT:Set[${This.ToonConfig.FindSetting["ShieldPCT",110]}]
		This.PullRange:Set[${This.ToonConfig.FindSetting["PullRange",-1]}]		
		This.UseAOE:Set[${This.ToonConfig.FindSetting["UseAOE",TRUE]}]
		This.Trinkets:Set[${This.ToonConfig.FindSetting["Trinkets",TRUE]}]
		This.Racials:Set[${This.ToonConfig.FindSetting["Racials",TRUE]}]
		This.Sheep:Set[${This.ToonConfig.FindSetting["Sheep",TRUE]}]
		This.ScorchPCT:Set[${This.ToonConfig.FindSetting["ScorchPCT",110]}]
		This.WandPCT:Set[${This.ToonConfig.FindSetting["WandPCT",10]}]
		
		This.MinMana:Set[${This.ToonConfig.FindSetting["MinMana",60]}]	
		This.MaxMana:Set[${This.ToonConfig.FindSetting["MaxMana",95]}]	
		This.MinHealth:Set[${This.ToonConfig.FindSetting["MinHealth",60]}]	
		This.MaxHealth:Set[${This.ToonConfig.FindSetting["MaxHealth",95]}]	
		This.LevelBelow:Set[${This.ToonConfig.FindSetting["LevelBelow",4]}]	
		This.LevelAbove:Set[${This.ToonConfig.FindSetting["LevelAbove",2]}]	
	}
	
	method SaveConfig()
	{
		This.ToonConfig.FindSetting["MinCombatRange"]:Set[${This.MinCombatRange}]
		This.ToonConfig.FindSetting["MaxCombatRange"]:Set[${This.MaxCombatRange}]
		This.ToonConfig.FindSetting["RepairPct"]:Set[${This.RepairPct}]
		This.ToonConfig.FindSetting["KeepFreeSlots"]:Set[${This.KeepFreeSlots}]
		This.ToonConfig.FindSetting["MountDistance"]:Set[${This.MountDistance}]
		This.ToonConfig.FindSetting["Loot"]:Set[${This.Loot}]
		This.ToonConfig.FindSetting["CorpseCampLimit"]:Set[${This.CorpseCampLimit}]
		This.ToonConfig.FindSetting["ExitOnStuck"]:Set[${This.ExitOnStuck}]
		This.ToonConfig.FindSetting["PrimaryStat"]:Set[${This.PrimaryStat}]
		This.ToonConfig.FindSetting["SecondaryStat"]:Set[${This.SecondaryStat}]
		This.ToonConfig.FindSetting["AutoEquip"]:Set[${This.AutoEquip}]
		This.ToonConfig.FindSetting["AutoPvP"]:Set[${This.AutoPvP}]
		This.ToonConfig.FindSetting["MinMuleItems"]:Set[${This.MinMuleItems}]
		This.ToonConfig.FindSetting["AutoTrainSkills"]:Set[${This.AutoTrainSkills}]
		This.ToonConfig.FindSetting["DismountOnAggro"]:Set[${This.DismountOnAggro}]
	
		This.ToonConfig.FindSetting["PullSpell"]:Set[${This.PullSpell}]
		This.ToonConfig.FindSetting["ArmorSpell"]:Set[${This.ArmorSpell}]	
		This.ToonConfig.FindSetting["ShieldSpell"]:Set[${This.ShieldSpell}]
		
		This.ToonConfig.FindSetting["Wards"]:Set[${This.Wards}]
		This.ToonConfig.FindSetting["DampenMagic"]:Set[${This.DampenMagic}]
		This.ToonConfig.FindSetting["ShieldPCT"]:Set[${This.ShieldPCT}]
		This.ToonConfig.FindSetting["PullRange"]:Set[${This.PullRange}]		
		This.ToonConfig.FindSetting["UseAOE"]:Set[${This.UseAOE}]
		This.ToonConfig.FindSetting["Trinkets"]:Set[${This.Trinkets}]
		This.ToonConfig.FindSetting["Racials"]:Set[${This.Racials}]
		This.ToonConfig.FindSetting["Sheep"]:Set[${This.Sheep}]
		This.ToonConfig.FindSetting["ScorchPCT"]:Set[${This.ScorchPCT}]
		This.ToonConfig.FindSetting["WandPCT"]:Set[${This.WandPCT}]
		
		This.ToonConfig.FindSetting["MinMana"]:Set[${This.MinMana}]
		This.ToonConfig.FindSetting["MaxMana"]:Set[${This.MaxMana}]
		This.ToonConfig.FindSetting["MinHealth"]:Set[${This.MinHealth}]		
		This.ToonConfig.FindSetting["MaxHealth"]:Set[${This.MaxHealth}]
		This.ToonConfig.FindSetting["LevelBelow"]:Set[${This.LevelBelow}]
		This.ToonConfig.FindSetting["LevelAbove"]:Set[${This.LevelAbove}]
	}
	/****************************************************************
	 *    config end
	 ***************************************************************/
		
	method InitToon()
	{		
	  This:Debug["MAGE.ISS REGISTER Events"]
		LavishScript:RegisterEvent[TOON_GUI_CHANGE]
		Event[TOON_GUI_CHANGE]:AttachAtom[${This.ObjectName}:ToonGUIChange]	
		Event[CHAT_MSG_SPELL_SELF_DAMAGE]:AttachAtom[${This.ObjectName}:ImmuneCheck]
		Event[CHAT_MSG_COMBAT_CREATURE_VS_SELF_HITS]:AttachAtom[${This.ObjectName}:DamageCheck]
		Event[CHAT_MSG_SPELL_CREATURE_VS_SELF_DAMAGE]:AttachAtom[${This.ObjectName}:DampenCheck]
		Event[UI_ERROR_MESSAGE]:AttachAtom[${This.ObjectName}:LineOfSightCheck] /* Weebs */
		This:InitMageGui[spells]
	}
	
	method Shutdown()
	{		
		This:Debug["MAGE.ISS UN-REGISTER Events"]
		
		This:SaveConfig
		
		LavishSettings["Class"]:Export["etc/class.xml"]
		Event[UI_ERROR_MESSAGE]:DetachAtom[${This.ObjectName}:ErrorMessage]		
		Event[UNIT_SPELLCAST_SUCCEEDED]:DetachAtom[${This.ObjectName}:SpellCastSucceeded]
		Event[TOON_GUI_VISIBLE]:Unregister
		
		ui -unload "class/${Me.Class}.xml"		
		
		/* Added */
		Event[TOON_GUI_CHANGE]:DetachAtom[${This.ObjectName}:ToonGUIChange]
		Event[TOON_GUI_CHANGE]:Unregister		
		Event[CHAT_MSG_SPELL_SELF_DAMAGE]:DetachAtom[${This.ObjectName}:ImmuneCheck]
		Event[CHAT_MSG_COMBAT_CREATURE_VS_SELF_HITS]:DetachAtom[${This.ObjectName}:DamageCheck]
		Event[CHAT_MSG_SPELL_CREATURE_VS_SELF_DAMAGE]:DetachAtom[${This.ObjectName}:DampenCheck]		
		Event[UI_ERROR_MESSAGE]:DetachAtom[${This.ObjectName}:LineOfSightCheck] /* Weebs */
	}
}