rendered paste body;-----------------------------------------------|
; Shaman Routine by Swolbyn v0.5 |
;-----------------------------------------------/
;
; - Added Swimming checks in buff pulse, if your toon is swimming it will jump and try to
; move towards the current target to melee range. To Prevent drowning.
; - Various tweaks to combat and pull logic
;
; - Removed flee, when I turned it on it was bugging stuff up big time.
; - Many combat tweaks
; - Added Shamanistic Focus Support
; - Under Spells tab you can choose "Save Shocks For Shamanistic Focus"
; When this is selected you will not use shocks regularly unless you have the focused effect after a crit attack
; - Immunities and Running Mobs Redesign
; - Now Mob Immunities and fleeing creatures are stored in MobData.xml in the routines folder
;
; - Reinarcation code reworked some. Still a little flaky there is a rare occurance when you reincarnate and then die quickly after that it doesn't detect you are dead again thus sitting at graveyard. It's rare. but happens. Due to this I have implemented a checkbox on main class configuration tab you can turn it off or on as you like.
; - Further adjustments to the attacking routines. FINALLY if a caster is shooting at you from afar, you'll shoot at him from afar. until he runs too close for your ranged spells, then you run to melee range as well. Works quite nicely.
; - Immunities should finally work. Took a bit of work this was a bitch :)
;
; - Reincarnation logic modifications
; - Further tweaks to combat / pull logic
;
; - Completely overhauled the Pull routine. Much smoother now.
; - Added in Disease Cleansing Totem logic to Mimic Poison Totem Logic
; - Added in the ressurection logic. (needs testing, not sure if it works)
; - Fixed some typos i found in the shielding logic
; - Fixed the Water Walking logic
;
; Thanks to all the many shaman routine writers out there in the openbot forums!
; This bot is a giant merged hybrid of shamany goodness. It includes some modified
; functions from all the many different bots that I have come across; as well as some
; custom stuff that I wrote in (and continue to do so) as I botted my shaman
; and notice changes that I wish to see.
;
; GUI kept from APOC's shaman routine, just took out some checkboxes that I found
; useless, i've integrated the logic into the system so there was no need for checkboxes.
;
; Overall my goal with this bot was to make it smarter. Less configuration is needed
; for certain aspects of it.
;
; You milage may vary. But I basically set it to use random shocks. I put my primary
; totem for combat set. leave the other totem boxes blank. (I used magma totem).
; Bot will automatically throw down stoneclaw totems on adds and uses the primary
; totem (magma for me) if the danger lvl is high enough or there's adds. This results
; in easier fights not wasting mana on totems.
;
; Curing poison and disease has been reworked. Will attempt to throw down a cure
; Totem if poisoned too soon after the first cure poison (20 seconds).
;
; I will continue updating the bot as I level and gain access to higher lvl spells.
; My shaman is currently in the 30's so if you are trying to bot higher lvl stuff
; You *may* find the luxury items not working. (Ex. I don't have dual wield or
; elementals to test yet.) I will get to them as I level and discover them. :)
;
objectdef oClass inherits oBase
{
/**************************************/
/************ VARIABLES ***************/
variable bool UsePull = TRUE
variable string PullSpell = "None"
variable int RestHP = 50
variable int RestMP = 50
variable int StandHP = 80
variable int StandMP = 80
variable string EarthTotem = ""
variable string FireTotem = ""
variable string AirTotem = ""
variable string WaterTotem = ""
variable bool UseEarthElementa = FALSE
variable bool UseFireElemental = FALSE
variable bool UseEarthShock = FALSE
variable bool UseFlameShock = FALSE
variable bool UseFrostShock = FALSE
variable bool RandomShock = FALSE
variable bool SaveShocks = FALSE
variable int ConserveMana = 40
variable bool UseLBolt = FALSE
variable bool UseChainLight = FALSE
variable string MainHand = "None"
variable string OffHand = "None"
variable string Shield = "None"
variable bool ShieldOnPull = FALSE
variable bool DW = FALSE
variable int HealWave = 20
variable int LHealWave = 50
variable int ChainHeal = 50
variable int GOTN = 60
variable bool Output = TRUE
variable int MaxCastRange = 20
variable int MaxShockRange = 20
variable bool HasEarthTotem = FALSE
variable bool HasFireTotem = FALSE
variable bool HasWaterTotem = FALSE
variable bool HasWindTotem = FALSE
variable bool UseReincarnation = FALSE
variable bool UseHPot = FALSE
variable bool UseMPot = FALSE
variable bool UseBandages = FALSE
variable int HPot = 25
variable int MPot = 25
variable int Bandage = 25
variable int restWaitTimer = 0
variable int buffWaitTimer = 0
variable int healWaitTimer = 0
variable int curePoisonTimer = 0
variable int cureDiseaseTimer = 0
variable int jumpTimer = 0
variable int PotTimer = 0
variable int DangerMedium = 15
variable int DangerHigh = 30
variable int DangerVeryHigh = 45
variable int DangerLevel = 0
variable int Dangerlvl = 0
variable int BuffNum = 0
variable bool debuffStatus = FALSE
variable string RealmChar = "${ISXWoW.RealmName}_${Me.Name}_${Me.Class}"
variable bool MeleeOnly = FALSE
variable bool RunnerDealtWith = FALSE
variable bool Revived = FALSE
variable int ReincarnateCount = 0
variable int BackupAttempts = 0
variable string MobDataStorage = "./routines/MobData.xml"
variable set MobDataImmunities
variable set MobDataRunners
variable collection:index:string RandomCast
variable collection:int RandomCastCount
/**************************************/
/***********Init & Shutdown************/
method Initialize()
{
LavishSettings:AddSet[MobData]
LavishSettings[MobData]:Import[${MobDataStorage}]
This:LoadConfig
This:InitShamanGUI
if ${Me.Action[Gift of the Naaru].Usable}
{
UIElement -toggle GOTN@Heals@Pages@ClassGUI
UIElement -toggle lblGOTN@Heals@Pages@ClassGUI
}
This:SetDistances
This:CreateUIErrorStrings
This:SetTotems
This:InitRandoms
This:InitTriggers
This.MobDataImmunities:Clear
This.MobDataRunners:Clear
This:LoadList[MobDataImmunities]
This:LoadList[MobDataRunners]
Bot:AddPulse["Class","Pulse",10,TRUE,TRUE]
UIElement[ClassGUI].FindChild[Console]:Echo["^_^=================================^_^"]
UIElement[ClassGUI].FindChild[Console]:Echo[" Swolbyn's Shaman Routine v0.5"]
UIElement[ClassGUI].FindChild[Console]:Echo["^_^=================================^_^"]
}
method Shutdown()
{
This:SaveConfig
This:RemoveTriggers
This:ExportList[MobDataImmunities]
This:ExportList[MobDataRunners]
LavishSettings[MobData]:Export[${MobDataStorage}]
}
method Pulse()
{
ExecuteQueued
}
method SetDistances()
{
if ${This.GetSpellRange[30, "elemental"]}
{
This.MaxCastRange:Set[${This.GetSpellRange[30, "elemental"]}]
This:CustOutput["Setting New MaxRange to ${This.MaxCastRange}"]
This.MaxShockRange:Set[${This.GetSpellRange[20, "elemental"]}]
This:CustOutput["Setting New MaxShockRange to ${This.MaxShockRange}"]
}
}
member GetSpellRange(int base, string spellTree)
{
if ${spellTree.Equal[elemental]}
return ${Math.Calc[${base}*(1+(0.1*${Me.Talent[Storm Reach]}))-1].Round}
return ${base}
}
/**************************************/
/**********UI Error Strings************/
variable collection:string UIErrorMsgStrings
method CreateUIErrorStrings()
{
This.UIErrorMsgStrings:Set["You are facing the wrong way!","backward"]
This.UIErrorMsgStrings:Set["Target too close","backward"]
This.UIErrorMsgStrings:Set["You are too far away!","forward"]
This.UIErrorMsgStrings:Set["Out of range.","forward"]
}
variable bool needUIHook = TRUE
method UIErrorMessage(string Id, string Msg)
{
if ${This.UIErrorMsgStrings.Element[${Msg}](exists)} && !${Bot.PauseFlag} && ${This.crazyWaitTimer} < ${LavishScript.RunningTime}
{
if ${Msg.Equal["Target too close"]} || (${Target.Distance} < 5 && ${Me.InCombat}) || ${This.UIErrorMsgStrings.Element[${Msg}].Equal["forward"]} && !${Me.Casting}
{
This:Debug[${Msg}]
This:CustOutput["Moving ${This.UIErrorMsgStrings.Element[${Msg}]} - UI Error: ${Msg}"]
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
This.attackWaitTimer:Set[${This.InMilliseconds[25]}]
This.pullWaitTimer:Set[${This.InMilliseconds[25]}]
move ${This.UIErrorMsgStrings.Element[${Msg}]} 1000
wowpress JUMP
return
}
}
}
/**************************************/
/*********External Mob Data************/
method LoadList(string loadingList)
{
variable iterator i
if !${LavishSettings[MobData].FindSet[${loadingList}](exists)}
LavishSettings[MobData]:AddSet[${loadingList}]
LavishSettings[MobData].FindSet[${loadingList}]:GetSettingIterator[i]
i:First
while ${i.IsValid}
{
${loadingList}:Add[${i.Key}]
i:Next
}
}
method ExportList(string loadingList)
{
variable iterator i
LavishSettings[MobData].FindSet[${loadingList}]:Clear
${loadingList}:GetIterator[i]
i:First
while ${i.IsValid}
{
LavishSettings[MobData].FindSet[${loadingList}]:AddSetting[${i.Key},${i.Key}]
i:Next
}
}
/**************************************/
/**************Triggers****************/
method InitTriggers()
{
AddTrigger DetectRunner "[Event:@eventid@:CHAT_MSG_MONSTER_EMOTE](\"%%s attempts to run away in fear!\",\"@Mob@\",@*@"
AddTrigger DetectImmune "[Event:@eventid@:CHAT_MSG_SPELL_SELF_DAMAGE](\"Your @FailedSpell@ failed. @Mob*@ is immune.@*@"
}
method RemoveTriggers()
{
RemoveTrigger DetectRunner
RemoveTrigger DetectImmune
}
function DetectRunner(string Line, int eventid, string Mob)
{
if !${This.MobDataRunners.Contains[${Mob}]}
{
This:CustOutput["Added ${Mob} to the runner list"]
This.MobDataRunners:Add[${Mob}]
}
}
function DetectImmune(string Line, int eventid, string FailedSpell, string Mob)
{
variable string MobId
MobId:Set[${Mob}#${FailedSpell}]
if !${This.MobDataImmunities.Contains[${MobId}]}
{
This:CustOutput["Added ${MobId} to the mob immune list"]
This.MobDataImmunities:Add[${MobId}]
}
}
/**************************************/
/***********Character States***********/
member isRunner()
{
if ${This.MobDataRunners.Contains[${Target.Name}]}
return TRUE
return FALSE
}
member isImmune(string SpellName)
{
if ${This.MobDataImmunities.Contains[${Target.Name}#${SpellName}]}
return TRUE
return FALSE
}
member isPoisoned()
{
BuffNum:Set[1]
while ${BuffNum} < 16
{
BuffNum:Inc
if ${Me.Buff[${BuffNum}].DispelType.Equal[Poison]}
{
return TRUE
}
}
return FALSE
}
member isDiseased()
{
BuffNum:Set[1]
while ${BuffNum} < 16
{
BuffNum:Inc
if ${Me.Buff[${BuffNum}].DispelType.Equal[Disease]}
{
return TRUE
}
}
return FALSE
}
/**************************************/
/************Reincarnation*************/
member NeedDead()
{
if !${This.Revived} && ${This.ReincarnateCount} < 10 && (${Me.Dead} || ${Me.Ghost}) && ${This.UseReincarnation}
{
return TRUE
}
else
{
return FALSE
}
}
method DeadPulse()
{
This:Output["Bad Shaman! you died?!"]
Bot.RandomPause:Set[25]
This.ReincarnateCount:Inc
if ${This.CanUseAnkh}
{
if ${WoWScript[StaticPopup1:IsVisible()]}
{
This:CustOutput["Reincarnation REPOPPING!"]
This.Revived:Set[TRUE]
This.ReincarnateCount:Set[0]
WoWScript UseSoulstone()
WoWScript RepopMe()
}
}
return
}
member CanUseAnkh()
{
if ${Navigator.PointIsSafe[${Me.X},${Me.Y},${Me.Z}]}
{
if ${Item[-inventory,"Ankh"](exists)} && ${Spell[Reincarnation](exists)} && !${Spell[Reincarnation].Cooldown}
{
This:CustOutput["We can use Reincarnation here."]
return TRUE
}
else
{
This:CustOutput["Can't self res!"]
}
}
else
{
This:CustOutput["Not a safe spot to use Reincarnation"]
}
return FALSE
}
/**************************************/
/****************Rest******************/
member NeedRest()
{
if ${Me.InCombat} || ${Targeting.realAgg}
return FALSE
if ${This.LootFirst}
return FALSE
if ${Me.Buff[Resurrection Sickness](exists)}
return TRUE
if ${Me.PctHPs} < ${This.RestHP}
return TRUE
if ${Me.PctMana} < ${This.RestMP}
return TRUE
if ${Me.PctHPs} < ${This.StandHP} && ${Me.Sitting}
return TRUE
if ${Me.PctMana} < ${This.StandMP} && ${Me.Sitting}
return TRUE
return FALSE
}
method RestPulse()
{
if ${Me.InCombat} || ${Targeting.realAgg}
return
if ${Me.Casting}
return
if ${Movement.Speed} || ${Movement.Forward} || ${Movement.Backward}
{
Toon:Stop
return
}
if ${Me.Buff[Resurrection Sickness](exists)}
{
Toon:Sitdown
return
}
if !${Me.Dead} && !${Me.Ghost}
This:Revived:Set[FALSE]
if ${This.ShouldCallTotems}
{
Toon:CastSpell["Totemic Call"]
This:CustOutput["Calling my totems back"]
return
}
if ((${Me.PctMana} >= ${This.StandMP}) && (${Me.PctHPs} >= ${This.StandHP})) && ${Me.Sitting}
{
Toon:Standup
This:Output["Standing."]
return
}
This:debuffAll
if ${Me.PctHPs} < ${This.RestHP} && ${Spell[Cannibalize](exists)} && !${Me.Buff[Food](exists)} && !${Me.Buff[Drink](exists)} && !${Me.Swimming} && !${Me.Sitting} && !${Me.InCombat} && !${Spell[Cannibalize].Cooldown} && (${Object[-dead,-humanoid,-range 0-5](exists)} || ${Object[-dead,-undead,-range 0-5](exists)}) && !${Me.Casting}
{
variable string corpseTarget
if ${Object[-dead,-undead,-range 0-5](exists)}
{
corpseTarget:Set[${Object[-dead,-undead,-range 0-5].GUID}]
}
if ${Object[-dead,-humanoid,-range 0-5](exists)}
{
corpseTarget:Set[${Object[-dead,-humanoid,-range 0-5].GUID}]
}
if ${Object[${corpseTarget}].Distance} > 2
{
Navigator:MoveToMob[${corpseTarget}]
return
}
else
{
This:Output["Cannibalizing Corpse."]
Toon:CastSpell[Cannibalize]
return
}
}
if !${Consumable.HasFood} && ${Me.PctHPs} < ${RestHP} && !${Me.Buff[Drink](exists)} && !${Me.Casting} && ${This.buffWaitTimer} < ${LavishScript.RunningTime}
{
if ${Toon.canCast[Lesser Healing Wave]}
{
Toon:CastSpell[Lesser Healing Wave]
This:CustOutput["Casting Lesser Healing Wave - Rest"]
This.buffWaitTimer:Set[${This.InSeconds[20]}]
return
}
elseif ${Toon.canCast[Healing Wave]}
{
Toon:CastSpell[Healing Wave]
This:CustOutput["Casting Healing Wave - Rest"]
This.buffWaitTimer:Set[${This.InSeconds[20]}]
return
}
}
if ${Me.PctHPs} < ${This.Bandage} && ${Toon.canBandage} && !${Me.Sitting} && ${This.UseBandages}
{
Toon:Bandage
This:CustOutput["Bandaging...."]
return
}
if ${Me.PctHPs} < ${This.RestHP} && ${Consumable.HasFood} && !${Me.Buff[Food](exists)} && !${Me.Swimming} && !${Me.InCombat} && !${Me.Casting} && !${This.isPoisoned} && !${This.isDiseased} && !${Me.Sitting}
{
Consumable:useFood
This:CustOutput["Eating..."]
return
}
if ${Me.PctMana} < ${This.RestMP} && ${Consumable.HasDrink} && !${Me.Buff[Drink](exists)} && !${Me.Swimming} && !${Me.InCombat} && !${Me.Casting} && !${This.isPoisoned} && !${This.isDiseased} && !${Me.Sitting}
{
Consumable:useDrink
This:CustOutput["Drinking..."]
return
}
if ${Me.PctMana} < ${This.RestMP} && ${Toon.canCast[Mana Spring Totem]} && !${This.OwnedTotemsCheck[Mana Spring Totem]} && ${This.HasWaterTotem} && !${Consumable.HasDrink} && !${Me.Buff[Drink](exists)} && !${Me.Swimming} && !${Me.InCombat} && !${Me.Casting}
{
Toon:CastSpell[Mana Spring Totem]
This:CustOutput["Casting Mana Spring Totem"]
}
if ${Me.PctMana} >= ${This.StandMP} && !${Me.Casting} && !${Me.Buff[Resurrection Sickness](exists)}
{
Toon:Standup
This:CustOutput["Done Resting!"]
return
}
}
/**************************************/
/****************Buff******************/
member NeedBuff()
{
if ${Me.Swimming}
return TRUE
if ${Me.InCombat} || ${Targeting.realAgg}
return FALSE
if ${Mount.IsMounted}
return FALSE
if ${Me.Swimming} && ${Toon.canCast[Water Walking]} && ${Item[-inventory,"Fish Oil"](exists)} && !${Me.Buff[Water Walking](exists)}
{
This:CustOutput["Swimming, need water walking"]
return TRUE
}
if ${Me.Swimming} && !${Me.Race.Find[Undead]} && ${Toon.canCast[Water Breathing]} && ${Item[-inventory,"Shiny Fish Scales"](exists)} && !${Me.Buff[Water Breathing](exists)}
{
This:CustOutput["Swimming, need water breathing"]
return TRUE
}
if ${Toon.canUseScroll}
{
This:CustOutput["Need a scroll buff"]
return TRUE
}
if !${Me.Equip[mainhand].Enchantment[${This.MainHand}](exists)} && ${Toon.canCast["${This.MainHand} Weapon"]} && ${This.buffWaitTimer} < ${LavishScript.RunningTime} && !${This.MainHand.Equal[None]}
{
This:CustOutput["Need Mainhand Buff - ${This.MainHand}"]
return TRUE
}
if !${Me.Equip[offhand].Enchantment[${This.OffHand}](exists)} && ${Toon.canCast["${This.OffHand} Weapon"]} && ${This.DW} && !${This.OffHand.Equal[None]}
{
This:CustOutput["Need Offhand Buff - ${This.OffHand}"]
return TRUE
}
if !${Me.Buff[${Shield}](exists)} && ${This.canBuff[${This.Shield}]}
return TRUE
return FALSE
}
method BuffPulse()
{
if ${Me.Swimming}
{
if ${This.jumpTimer} < ${LavishScript.RunningTime}
{
wowpress JUMP
This.jumpTimer:Set[${This.InSeconds[5]}]
}
if ${Target(exists)}
{
Toon:ToMelee
}
return
}
if ${Me.InCombat} || ${Targeting.realAgg}
return
if ${Me.Casting}
return
if ${Me.Sitting}
Toon:Standup
if ${Movement.Speed} || ${Movement.Forward} || ${Movement.Backward}
{
Move -stop
return
}
if ${Me.Swimming} && ${Toon.canCast[Water Walking]} && ${Item[-inventory,"Fish Oil"](exists)} && !${Me.Buff[Water Walking](exists)}
{
Toon:CastSpell[Water Walking]
This:CustOutput["Casting Water Walking"]
return
}
if ${Me.Swimming} && !${Me.Race.Find[Undead]} && ${Toon.canCast[Water Breathing]} && ${Item[-inventory,"Shiny Fish Scales"](exists)} && !${Me.Buff[Water Breathing](exists)}
{
Toon:CastSpell[Water Breathing]
This:CustOutput["Casting Water Breathing"]
return
}
if ${Toon.canUseScroll}
{
Toon:UseScroll
This:CustOutput["Using a scroll"]
return
}
if !${Me.Equip[mainhand].Enchantment[${This.MainHand}](exists)} && ${Toon.canCast[${This.MainHand} Weapon]} && ${This.buffWaitTimer} < ${LavishScript.RunningTime} && !${This.MainHand.Equal[None]}
{
Toon:CastSpell[${This.MainHand} Weapon]
This:CustOutput["Casting ${This.MainHand} Weapon"]
This.buffWaitTimer:Set[${This.InSeconds[20]}]
return
}
if !${Me.Equip[offhand].Enchantment[${This.OffHand}](exists)} && ${Toon.canCast[${This.OffHand} Weapon]} && ${This.DW} && !${This.OffHand.Equal[None]}
{
Toon:CastSpell[${This.OffHand} Weapon]
This:CustOutput["Casting ${This.OffHand} Weapon"]
return
}
if !${Me.Buff[${Shield}](exists)} && ${This.canBuff[${This.Shield}]}
{
Toon:CastSpell[${This.Shield}]
return
}
}
/**************************************/
/**************Pull Buff***************/
member NeedPullBuff()
{
if !${Me.Buff[${This.Shield}](exists)} && ${This.canBuff[${This.Shield}]} && !${This.isImmune[${This.Shield}]}
return TRUE
return FALSE
}
method PullBuffPulse()
{
if ${Me.Sitting}
Toon:Standup
if ${Movement.Speed} || ${Movement.Forward} || ${Movement.Backward}
{
Toon:Stop
return
}
if !${Me.Buff[${This.Shield}](exists)} && ${This.canBuff[${This.Shield}]} && !${This.isImmune[${This.Shield}]}
{
Toon:CastSpell[${Shield}]
This:CustOutput["Casting ${This.Shield}"]
return
}
return
}
/**************************************/
/*************Combat Buff**************/
member NeedCombatBuff()
{
if ${Me.Sitting}
Toon:Standup
if ${Me.PctHPs} < ${This.GOTN} && ${Toon.canCast[Gift of the Naaru]}
return TRUE
if ${This.canBuff[${This.Shield}]} && ${Target.PctHPs} > 30 && !${This.isImmune[${This.Shield}]}
return TRUE
if ${Toon.canCast[Shamanistic Rage]} && ${Me.PctMana} < 30 && ${Target.PctHPs} > 85
return TRUE
if ${Toon.canCast[Elemental Mastery]} && ${Me.PctMana} < 30
return TRUE
if ${Toon.canCast[Mana Spring Totem]} && ${Me.PctMana} < 30
return TRUE
if ${Toon.canCast[Heroism]} && ${Me.PctHPs} < 30 && ${Target.PctHPs} > 70
return TRUE
if ${Toon.canCast[Bloodlust]} && ${Me.PctHPs} < 30 && ${Target.PctHPs} > 70
return TRUE
return FALSE
}
method CombatBuffPulse()
{
if ${Me.Sitting}
Toon:Standup
if ${Toon.canCast["Nature's Swiftness"]}
{
Toon:CastSpell["Nature's Swiftness"]
return
}
if ${Me.PctHPs} < ${This.GOTN} && ${Toon.canCast[Gift of the Naaru]} && !${Me.Casting}
{
Toon:CastSpell[Gift of the Naaru]
This:CustOutput["Casting Gift of the Naaru"]
return
}
if ${This.canBuff[${This.Shield}, ${Me.GUID}]} && !${Me.Buff[${This.Shield}](exists)} && !${Me.Casting} && !${This.isImmune[${This.Shield}]}
{
Toon:CastSpell[${Shield}]
This:CustOutput["Casting ${Shield}"]
return
}
if ${Toon.canCast[Elemental Mastery]} && ${Me.PctMana} < 30
{
Toon:CastSpell[Elemental Mastery]
This:CustOutput["Casting Elemental Mastery!!!"]
return
}
if ${Toon.canCast[Mana Spring Totem]} && ${Me.PctMana} < 30 && !${This.OwnedTotemsCheck[Mana Spring Totem]}
{
Toon:CastSpell[Mana Spring Totem]
This:CustOutput["Casting Mana Spring Totem!!!"]
return
}
if ${Toon.canCast[Heroism]} && ${Me.PctHPs} < 30 && ${Target.PctHPs} > 70
{
Toon:CastSpell[Heroism]
This:CustOutput["Casting Heroism!!!"]
return
}
if ${Toon.canCast[Bloodlust]} && ${Me.PctHPs} < 30 && ${Target.PctHPs} > 70
{
Toon:CastSpell[Bloodlust]
This:CustOutput["Casting Bloodlust!!!"]
return
}
}
/**************************************/
/****************Pull******************/
method PullPulse()
{
if ${Me.Sitting}
Toon:Standup
if !${Toon.ValidTarget[${Target.GUID}]} || ${Target.Dead}
{
Toon:NeedTarget[1]
return
}
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
if ${Me.Casting} || ${Me.GlobalCooldown}
return
if !${Me.Attacking} && ${Target.Distance} <= ${Toon.MaxMelee}
{
WoWScript AttackTarget()
This:CustOutput["Turning on autoattack"]
return
}
if ${Target.PctHPs} == 100
{
; Creature is 100% life, assuming new target resetting runner logic
This.RunnerDealtWith:Set[FALSE]
This.BackupAttempts:Set[0]
}
if ${Me.PctHPs} < ${This.HealWave} && ${Toon.canCast[Healing Wave]} && !${Me.Casting} && ${This.healWaitTimer} < ${LavishScript.RunningTime}
{
Toon:CastSpell[Healing Wave]
This:CustOutput["Casting Healing Wave"]
This.healWaitTimer:Set[${This.InSeconds[4]}]
return
}
if ${Me.PctHPs} < ${This.LHealWave} && ${Toon.canCast[Lesser Healing Wave]} && !${Me.Casting} && ${This.healWaitTimer} < ${LavishScript.RunningTime}
{
Toon:CastSpell[Lesser Healing Wave]
This:CustOutput["Casting Lesser Healing Wave"]
This.healWaitTimer:Set[${This.InSeconds[4]}]
return
}
if ${Me.PctHPs} < ${This.ChainHeal} && ${Toon.canCast[Chain Heal]} && !${Me.Casting} && ${This.healWaitTimer} < ${LavishScript.RunningTime}
{
Toon:CastSpell[Chain Heal]
This:CustOutput["Casting Chain Heal"]
This.healWaitTimer:Set[${This.InSeconds[4]}]
return
}
if ${Target.Distance} < ${Toon.MinRanged} || ${This.isImmune[${This.PullSpell}]} && !${Me.Casting}
{
WoWScript AttackTarget()
This:CustOutput["Turning on autoattack"]
Toon:ToMelee
return
}
if !${This.UsePull}
{
if !${Toon.withinMelee}
{
Toon:ToMelee
This:CustOutput["Melee Pulling ${Target.Name}"]
return
}
}
if ${This.UsePull}
{
if ${Toon.withinRanged}
{
if ${Movement.Speed} || ${Movement.Forward} || ${Movement.Backward}
{
Toon:Stop
return
}
if ${Target.Distance} >= ${Toon.MinRanged} && ${Me.PctMana} > ${This.ConserveMana}
{
if ${Toon.canCast[${This.PullSpell}]}
{
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
Toon:CastSpell[${This.PullSpell}]
This:CustOutput["Pulling With: ${This.PullSpell}"]
return
}
}
}
elseif !${Me.Casting}
{
if ${Target.Distance} > ${Toon.MaxRanged}
{
This:CustOutput["Target too far away. Moving closer."]
Toon:ToRanged
}
elseif ${Target.Distance} < ${Toon.MinRanged}
{
WoWScript AttackTarget()
This:CustOutput["Turning on autoattack"]
This:AttackPulse
}
}
}
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
return
}
/**************************************/
/***************Attack*****************/
method AttackPulse()
{
if ${Me.Sitting}
Toon:Standup
if !${Toon.ValidTarget[${Target.GUID}]} || ${Target.Dead}
{
Toon:NeedTarget[1]
return
}
if !${Toon.TargetIsBestTarget} || ${Target.IsTotem}
Toon:BestTarget
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
if !${Me.Attacking} && ${Target.Distance} <= ${Toon.MaxMelee}
{
WoWScript AttackTarget()
This:CustOutput["Turning on autoattack"]
}
if ${Target.Distance} >= ${Toon.MinRanged} && ${Me.PctMana} > ${This.ConserveMana}
{
This:PullPulse
}
This:SetDanger
if ${This.HaveAdds} && ${Toon.canCast[War Stomp]} && !${Me.Casting}
{
Toon:CastSpell[War Stomp]
}
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
This:debuffAll
if ${Target.Distance} < ${Toon.MinMelee} && ${This.BackupAttempts} < 6 && !${Me.Casting}
{
This:Output["Backing up... wtf"]
This.BackupAttempts:Inc
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
Navigator:MoveBackward[200]
return
}
if ${Target.Distance} > ${Toon.MaxMelee} && !${Me.Casting}
{
This:Output["Chasing down ${Target.Name}"]
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
wowpress -hold moveforward
return
}
else
{
Toon:Stop
}
if ${Target.Dead}
return
if !${This.RunnerDealtWith} && ${Target.PctHPs} < 40 && ${This.isRunner}
{
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
if ${Toon.canCast[Frost Shock]} && !${This.isImmune[Frost Shock]}
{
Toon:CastSpell[Frost Shock]
This:CustOutput["Casting Frost Shock on a runner"]
This.RunnerDealtWith:Set[TRUE]
return
}
if ${Toon.canCast[Earthbind Totem]} && !${This.OwnedTotemsCheck[Earthbind Totem]} && ${This.HasEarthTotem}
{
Toon:CastSpell[Earthbind Totem]
This:CustOutput["Casting Earthbind Totem to catch a runner"]
This.RunnerDealtWith:Set[TRUE]
return
}
}
if ${Me.PctHPs} < ${This.HealWave} && ${Toon.canCast[Healing Wave]} && !${Me.Casting} && ${This.healWaitTimer} < ${LavishScript.RunningTime}
{
Toon:CastSpell[Healing Wave]
This:CustOutput["Casting Healing Wave"]
This.healWaitTimer:Set[${This.InSeconds[4]}]
return
}
if ${Me.PctHPs} < ${This.LHealWave} && ${Toon.canCast[Lesser Healing Wave]} && !${Me.Casting} && ${This.healWaitTimer} < ${LavishScript.RunningTime}
{
Toon:CastSpell[Lesser Healing Wave]
This:CustOutput["Casting Lesser Healing Wave"]
This.healWaitTimer:Set[${This.InSeconds[4]}]
return
}
if ${Me.PctHPs} < ${This.ChainHeal} && ${Toon.canCast[Chain Heal]} && !${Me.Casting} && ${This.healWaitTimer} < ${LavishScript.RunningTime}
{
Toon:CastSpell[Chain Heal]
This:CustOutput["Casting Chain Heal"]
This.healWaitTimer:Set[${This.InSeconds[4]}]
return
}
if ${Me.PctHPs} < ${This.HPot} && ${This.UseHPot} && ${Consumable.HasHPot} && ${This.PotTimer} < ${LavishScript.RunningTime}
{
Consumable:useHPot
This:CustOutput["Quaffing a health pot"]
This.PotTimer:Set[${This.InSeconds[120]}]
return
}
if ${Me.PctMana} < ${This.MPot} && ${This.UseMPot} && ${Consumable.HasMPot} && ${This.PotTimer} < ${LavishScript.RunningTime}
{
Consumable:useMPot
This:CustOutput["Quaffing a mana pot"]
This.PotTimer:Set[${This.InSeconds[120]}]
return
}
if ${Target.Dead}
return
if ${Dangerlvl} >= 1
{
if ${Target.PctHPs} > 50 || ${This.HaveAdds}
{
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
if ${This.HaveAdds} && ${Toon.canCast[Stoneclaw Totem]} && !${This.OwnedTotemsCheck[Stoneclaw Totem]}
{
Toon:CastSpell[Stoneclaw Totem]
This:CustOutput["Casting Stoneclaw Totem because of Add!"]
return
}
if ${This.canCastTotem[Earth]} && ${This.HasEarthTotem}
{
Toon:CastSpell[${This.EarthTotem}]
This:CustOutput["Casting ${This.EarthTotem}"]
return
}
if ${This.canCastTotem[Air]} && ${This.HasAirTotem}
{
Toon:CastSpell[${This.AirTotem}]
This:CustOutput["Casting ${This.AirTotem}"]
return
}
if ${This.canCastTotem[Fire]} && ${This.HasFireTotem}
{
Toon:CastSpell[${This.FireTotem}]
This:CustOutput["Casting ${This.FireTotem}"]
return
}
if ${This.canCastTotem[Water]} && ${This.HasWaterTotem}
{
Toon:CastSpell[${This.WaterTotem}]
This:CustOutput["Casting ${This.WaterTotem}"]
return
}
if ${This.AirTotem.Equal["Random"]} && ${Me.PctMana} > 10 && ${This.HasAirTotem}
{
Toon:CastRandom[AirTotems]
This:CustOutput["Casting a random Air Totem"]
This.AirTotemTimer:Set[${This.InSeconds[80]}]
return
}
if ${This.EarthTotem.Equal["Random"]} && ${Me.PctMana} > 10 && ${This.HasEarthTotem}
{
Toon:CastRandom[EarthTotems]
This:CustOutput["Casting a random Earth Totem"]
This.EarthTotemTimer:Set[${This.InSeconds[80]}]
return
}
if ${This.WaterTotem.Equal["Random"]} && ${Me.PctMana} > 10 && ${This.HasWaterTotem}
{
Toon:CastRandom[WaterTotems]
This:CustOutput["Casting a random Water Totem"]
This.WaterTotemTimer:Set[${This.InSeconds[80]}]
return
}
if ${This.FireTotem.Equal["Random"]} && ${Me.PctMana} > 10 && ${This.HasFireTotem}
{
Toon:CastRandom[FireTotems]
This:CustOutput["Casting a random Fire Totem"]
This.FireTotemTimer:Set[${This.InSeconds[80]}]
return
}
}
}
if ${Target.Dead}
return
if ${This.HaveAdds} && ${Toon.canCast[Shamanistic Rage]}
{
Toon:CastSpell[Shamanistic Rage]
This:CustOutput["Casting Shamanistic Rage!!!"]
return
}
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
if ${This.HaveAdds} && ${Toon.canCast[Chain Lightning]} && ${Me.PctMana} > ${This.ConserveMana} && !${This.MeleeOnly}
{
Toon:CastSpell[Chain Lightning]
This:CustOutput["Casting Chain Lightning due to an add!"]
return
}
if ${Toon.canCast[Earth Shock]} && !${This.isImmune[Earth Shock]} && ${Target.Casting(exists)}
{
This:StopCast
This:CustOutput["Silencing ${Target} - Attack"]
Toon:CastSpell[Earth Shock]
}
if ${Toon.canCast[Stormstrike]} && !${Target.Buff[Stormstrike](exists)} && ${Target.Distance} < ${This.MaxShockRange}
{
Toon:CastSpell[Stormstrike]
This:CustOutput["Casting Stormstrike"]
return
}
if ${Target.Dead}
return
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
if !${This.SaveShocks} || (${This.SaveShocks} && ${Me.Buff[Focused](exists)})
{
if ${Toon.canCast[Earth Shock]} && !${This.isImmune[Earth Shock]} && ${Target.Buff[Stormstrike](exists)} && ${Target.Distance} < ${This.MaxShockRange}
{
Toon:CastSpell[Earth Shock]
This:CustOutput["Casting Earth Shock on Stormstruck ${Target}!"]
return
}
if ${This.RandomShock} && !${Target.Buff[Stormstrike](exists)} && ${Target.Distance} < ${This.MaxShockRange}
{
if (${Me.PctMana} > ${This.ConserveMana}) || ${This.SaveShocks}
{
This:CastRandom[Shocks,"Target"]
return
}
}
if ${This.canBuff[Flame Shock, ${Target.GUID}]} && !${This.isImmune[Flame Shock]} && ${This.UseFlameShock} && !${This.RandomShock} && !${Target.Buff[Stormstrike](exists)} && ((${Me.PctMana} > ${This.ConserveMana}) || ${This.SaveShocks}) && ${Target.Distance} < ${This.MaxShockRange}
{
Toon:CastSpell[Flame Shock]
This:CustOutput["Casting Flame Shock"]
return
}
if ${Toon.canCast[Earth Shock]} && !${This.isImmune[Earth Shock]} && ${This.UseEarthShock} && !${This.RandomShock} && ((${Me.PctMana} > ${This.ConserveMana}) || ${This.SaveShocks}) && ${Target.Distance} < ${This.MaxShockRange}
{
Toon:CastSpell[Earth Shock]
This:CustOutput["Casting Earth Shock"]
return
}
if ${Toon.canCast[Frost Shock]} && !${This.isImmune[Frost Shock]} && ${This.UseFrostShock} && !${This.RandomShock} && !${Target.Buff[Stormstrike](exists)} && ((${Me.PctMana} > ${This.ConserveMana}) || ${This.SaveShocks}) && ${Target.Distance} < ${This.MaxShockRange}
{
Toon:CastSpell[Frost Shock]
This:CustOutput["Casting Frost Shock"]
return
}
if ${Toon.canCast[Lightning Bolt]} && !${This.isImmune[Lightning Bolt]} && ${This.UseLBolt} && ${Me.PctMana} > ${This.ConserveMana} && !${This.MeleeOnly}
{
Toon:CastSpell[Lightning Bolt]
This:CustOutput["Casting Lightning Bolt"]
return
}
}
}
/**************************************/
/***************Totems*****************/
method SetTotems()
{
if ${Item[-items,-inventory,"Earth Totem"](exists)}
{
This.HasEarthTotem:Set[TRUE]
This:CustOutput["We have an Earth Totem in our bags, we can use them now!"]
}
else
{
This.HasEarthTotem:Set[FALSE]
This:CustOutput["No Earth Totem found! Not using them."]
}
if ${Item[-items,-inventory,"Fire Totem"](exists)}
{
This.HasFireTotem:Set[TRUE]
This:CustOutput["We have an Fire Totem in our bags, we can use them now!"]
}
else
{
This.HasFireTotem:Set[FALSE]
This:CustOutput["No Fire Totem found! Not using them."]
}
if ${Item[-items,-inventory,"Water Totem"](exists)}
{
This.HasWaterTotem:Set[TRUE]
This:CustOutput["We have an Water Totem in our bags, we can use them now!"]
}
else
{
This.HasWaterTotem:Set[FALSE]
This:CustOutput["No Water Totem found! Not using them."]
}
if ${Item[-items,-inventory,"Wind Totem"](exists)}
{
This.HasWindTotem:Set[TRUE]
This:CustOutput["We have an Wind Totem in our bags, we can use them now!"]
}
else
{
This.HasWindTotem:Set[FALSE]
This:CustOutput["No Wind Totem found! Not using them."]
}
return
}
member canCastTotem(string totemType)
{
if ${Toon.canCast[${This.${totemType}Totem}]} && !${This.OwnedTotemsCheck[${This.${totemType}Totem}]} && !${This.${totemType}Totem.Equal["Random"]} && !${This.${totemType}Totem.Equal["None"]}
return TRUE
return FALSE
}
member OwnedTotemsCheck(string totem)
{
if ${Unit[-units, -owner, -range 0-20, ${totem}](exists)}
{
return TRUE
TotemList:Clear
}
return FALSE
}
member ShouldCallTotems()
{
if ${This.OwnedTotemsCheck[totem]} && !${This.OwnedTotemsCheck[Mana Spring Totem]} && !${This.OwnedTotemsCheck[Poison Cleansing Totem]} && !${Me.Target(exists)} && ${Toon.canCast[Totemic Call]}
return TRUE
return FALSE
}
/**************************************/
/*************Aggro & Adds*************/
method SetDanger()
{
variable guidlist Aggros
Aggros:Search[-units,-nearest,-aggro,-alive,-targetingme,-range 0-40]
This.DangerLevel:Set[${DangerLevel} * 0.5]
This.DangerLevel:Set[${DangerLevel} + ${Aggros.Count}*6.5]
This.DangerLevel:Set[${DangerLevel} + ((100 - ${Me.PctMana})*0.10)]
if ${Target.Level} > ${Me.Level}
{
This.DangerLevel:Set[${DangerLevel} + ((${Target.Level} - ${Me.Level})*2)]
}
elseif ${Me.Level} > ${Target.Level}
{
This.DangerLevel:Set[${DangerLevel} + ((${Target.Level} - ${Me.Level})*1)]
}
if ${Target.Classification.Equal[Elite]} || ${Target.Classification.Equal[RareElite]}
This.DangerLevel:Set[${DangerLevel} + 20]
if ${Target.PctHPs} < 25
This.DangerLevel:Set[${DangerLevel} - 10]
if ${DangerLevel} < 0
This.DangerLevel:Set[0]
UIElement[DangerLevel@Titlebar@ClassGUI]:SetValue[${DangerLevel}]
if ${DangerLevel} >= ${DangerVeryHigh}
{
This:CustOutput["Danger - Very High ${DangerLevel}"]
This.Dangerlvl:Set[3]
return
}
elseif ${DangerLevel} > ${DangerHigh}
{
This:CustOutput["Danger - High ${DangerLevel}"]
This.Dangerlvl:Set[2]
return
}
elseif ${DangerLevel} > ${DangerMedium}
{
;This:CustOutput["Danger - Medium ${DangerLevel}"]
This.Dangerlvl:Set[1]
return
}
else
{
;This:CustOutput["Danger - Low ${DangerLevel}"]
This.Dangerlvl:Set[0]
return
}
}
member HaveAdds()
{
variable guidlist AggroList
AggroList:Clear
AggroList:Search[-units,-nearest,-nopets,-aggro,-alive,-range 0-30]
if ${AggroList.Count} >= 2
{
return TRUE
}
else
{
return FALSE
}
}
/**************************************/
/***********Spells & Casting***********/
method InitRandoms()
{
This:SetRandoms["Earth Shock","Shocks"]
This:SetRandoms["Flame Shock","Shocks"]
This:SetRandoms["Frost Shock","Shocks"]
This:SetRandoms["Lightning Bolt","Attacks"]
This:SetRandoms["Chain Lightning","Attacks"]
This:SetRandoms["Lightning Shield","Shields"]
This:SetRandoms["Water Shield","Shields"]
This:SetRandoms["Earth Shield","Shields"]
This:SetRandoms["Earthbind Totem","EarthTotems"]
This:SetRandoms["Stoneskin Totem","EarthTotems"]
This:SetRandoms["Stoneclaw Totem","EarthTotems"]
This:SetRandoms["Strength of Earth Totem","EarthTotems"]
This:SetRandoms["Tremor Totem","EarthTotems"]
This:SetRandoms["Searing Totem","FireTotems"]
This:SetRandoms["Fire Nova Totem","FireTotems"]
This:SetRandoms["Magma Totem","FireTotems"]
This:SetRandoms["Totem of Wrath","FireTotems"]
This:SetRandoms["Windwall Totem","AirTotems"]
This:SetRandoms["Grounding Totem","AirTotems"]
This:SetRandoms["Grace of Air Totem","AirTotems"]
This:SetRandoms["Wrath of Air Totem","AirTotems"]
This:SetRandoms["Healing Stream Totem","WaterTotems"]
This:SetRandoms["Mana Spring Totem","WaterTotems"]
}
method SetRandoms(string SpellName, string RandomSet)
{
if ${Spell[${SpellName}](exists)}
{
This:AddRandom[${RandomSet},${SpellName}]
}
else
{
This:CustOutput["Couldn't add ${SpellName} into ${RandomSet} because we don't have the spell!"]
}
}
method AddRandom(string spellGroup, string spellName)
{
if !${This.RandomCast.Element[${spellGroup}](exists)} && ${Bot.Started}
{
This.RandomCast:Set[${spellGroup}]
This.RandomCastCount:Set[${spellGroup},0]
}
This.RandomCast.Element[${spellGroup}]:Insert[${spellName}]
This.RandomCastCount.Element[${spellGroup}]:Inc
}
member CastRandom(string spellGroup, string checkBuff=NULL)
{
variable int attempts = 0
variable int spellNum = 1
spellNum:Inc[${Math.Rand[${This.RandomCastCount.Element[${spellGroup}]}]}]
do
{
if ${spellNum} > ${This.RandomCastCount.Element[${spellGroup}]}
{
spellNum:Inc
}
if ${Toon.canCast[${This.RandomCast.Element[${spellGroup}].Get[${spellNum}]}]} && !${This.isImmune[${This.RandomCast.Element[${spellGroup}].Get[${spellNum}]}]}
{
if ${checkBuff.Equal[Target]} || ${checkBuff.Equal[Me]}
{
if !${${checkBuff}.Buff[${This.RandomCast.Element[${spellGroup}].Get[${spellNum}]}](exists)}
{
Toon:CastSpell[${This.RandomCast.Element[${spellGroup}].Get[${spellNum}]}]
This:Output["Casting Random Buff#${spellNum}:${This.RandomCast.Element[${spellGroup}].Get[${spellNum}]}"]
return TRUE
}
}
else
{
Toon:CastSpell[${This.RandomCast.Element[${spellGroup}].Get[${spellNum}]}]
This:Output["Casting Random#${spellNum}:${This.RandomCast.Element[${spellGroup}].Get[${spellNum}]}"]
return TRUE
}
}
spellNum:Inc
}
while ${attempts:Inc} <= ${This.RandomCastCount.Element[${spellGroup}]}
return FALSE
}
method CastRandom(string spellGroup, string checkBuff=NULL)
{
if !${This.CastRandom[${spellGroup},${checkBuff}]}
{
This:Debug[RandomCast ${spellGroup} failed]
}
}
member canBuff(string buffName, string theGUID=NULL, string spellName=NULL)
{
if ${spellName.Equal[NULL]}
spellName:Set[${buffName}]
if ${theGUID.Equal[NULL]}
theGUID:Set[${Me.GUID}]
if !${Object[${theGUID}].Buff[${buffName}](exists)} && ${Toon.canCast[${spellName}]}
return TRUE
return FALSE
}
member ShouldConserveMana()
{
if ${Me.PctMana} > ${This.ConserveMana}
return TRUE
return FALSE
}
method debuffAll()
{
if ${Me.PctMana} < 15 || ${Me.Casting}
return
BuffNum:Set[1]
while ${BuffNum} < 16
{
BuffNum:Inc
if ${Target.Buff.DispelType.Equal[Magic]} && !${Target.Buff.Harmful}
{
if ${Toon.canCast[Purge]} && !${Me.Casting}
{
This:CustOutput["Purging a buff on ${Target}"]
Toon:CastSpell[Purge]
return
}
}
if ${Me.Buff[${BuffNum}].Harmful}
{
if ${Me.Buff[${BuffNum}].DispelType.Equal[Disease]}
{
if ${Toon.canCast[Cure Disease]} && ${This.cureDiseaseTimer} < ${LavishScript.RunningTime}
{
This:CustOutput["Curing a disease"]
Toon:CastSpell[Cure Disease]
This.cureDiseaseTimer:Set[${This.InSeconds[20]}]
return
}
elseif ${Toon.canCast[Disease Cleansing Totem]} && !${This.OwnedTotemsCheck[Disease Cleansing Totem]} && ${This.HasWaterTotem}
{
Toon:CastSpell[Disease Cleansing Totem]
This:CustOutput["Casting Disease Cleansing Totem"]
}
}
if ${Me.Buff[${BuffNum}].DispelType.Equal[Poison]}
{
if ${Toon.canCast[Cure Poison]} && ${This.curePoisonTimer} < ${LavishScript.RunningTime}
{
This:CustOutput["Curing a poison"]
Toon:CastSpell[Cure Poison]
This.curePoisonTimer:Set[${This.InSeconds[20]}]
return
}
elseif ${Toon.canCast[Poison Cleansing Totem]} && !${This.OwnedTotemsCheck[Poison Cleansing Totem]} && ${This.HasWaterTotem}
{
Toon:CastSpell[Poison Cleansing Totem]
This:CustOutput["Casting Poison Cleansing Totem"]
}
}
}
}
return
}
member LootFirst()
{
if ${Me.Sitting} || ${Me.Casting}
return FALSE
if ${Unit[-dead,-lootable,-range 0-10](exists)}
return TRUE
if ${Toon.HasSkill[Skinning]}
{
if ${Unit[-dead,-skinnable,-range 0-10](exists)} && ${Item[-inventory,"Skinning Knife"](exists)}
return TRUE
}
if ${LavishScript.RunningTime} <= ${State.LOOTState_Loot_Wait_Until}
return TRUE
return FALSE
}
/**************************************/
/*************Other Misc***************/
method CustOutput(string myMessage)
{
if ${This.Output}
UIElement[ClassGUI].FindChild[Console]:Echo["${Time.Time24}: ${myMessage}"]
return
}
/**************************************/
/***********GUI Load & Save************/
method SaveConfig()
{
Config:SetSetting["${RealmChar}","UsePull",${This.UsePull}]
Config:SetSetting["${RealmChar}","PullSpell",${This.PullSpell}]
Config:SetSetting["${RealmChar}","RestMP",${This.RestMP}]
Config:SetSetting["${RealmChar}","RestHP",${This.RestHP}]
Config:SetSetting["${RealmChar}","StandMP",${This.StandMP}]
Config:SetSetting["${RealmChar}","StandHP",${This.StandHP}]
Config:SetSetting["${RealmChar}","EarthTotem",${This.EarthTotem}]
Config:SetSetting["${RealmChar}","AirTotem",${This.AirTotem}]
Config:SetSetting["${RealmChar}","FireTotem",${This.FireTotem}]
Config:SetSetting["${RealmChar}","WaterTotem",${This.WaterTotem}]
Config:SetSetting["${RealmChar}","UseEarthElemental",${This.UseEarthElemental}]
Config:SetSetting["${RealmChar}","UseFireElemental",${This.UseFireElemental}]
Config:SetSetting["${RealmChar}","UseEarthShock",${This.UseEarthShock}]
Config:SetSetting["${RealmChar}","UseFlameShock",${This.UseFlameShock}]
Config:SetSetting["${RealmChar}","UseFrostShock",${This.UseFrostShock}]
Config:SetSetting["${RealmChar}","RandomShock",${This.RandomShock}]
Config:SetSetting["${RealmChar}","SaveShocks",${This.SaveShocks}]
Config:SetSetting["${RealmChar}","ConserveMana",${This.ConserveMana}]
Config:SetSetting["${RealmChar}","UseLBolt",${This.UseLBolt}]
Config:SetSetting["${RealmChar}","UseChainLight",${This.UseChainLight}]
Config:SetSetting["${RealmChar}","MainHand",${This.MainHand}]
Config:SetSetting["${RealmChar}","OffHand",${This.OffHand}]
Config:SetSetting["${RealmChar}","DW",${This.DW}]
Config:SetSetting["${RealmChar}","ShieldOnPull",${This.ShieldOnPull}]
Config:SetSetting["${RealmChar}","HealWave",${This.HealWave}]
Config:SetSetting["${RealmChar}","LHealWave",${This.LHealWave}]
Config:SetSetting["${RealmChar}","ChainHeal",${This.ChainHeal}]
Config:SetSetting["${RealmChar}","GOTN",${This.GOTN}]
Config:SetSetting["${RealmChar}","Output",${This.Output}]
Config:SetSetting["${RealmChar}","UseReincarnation",${This.UseReincarnation}]
Config:SetSetting["${RealmChar}","UseMPot",${This.UseMPot}]
Config:SetSetting["${RealmChar}","UseHPot",${This.UseHPot}]
Config:SetSetting["${RealmChar}","UseBandages",${This.UseBandages}]
Config:SetSetting["${RealmChar}","MPot",${This.MPot}]
Config:SetSetting["${RealmChar}","HPot",${This.HPot}]
Config:SetSetting["${RealmChar}","Bandage",${This.Bandage}]
Config:SetSetting["${RealmChar}","Shield",${This.Shield}]
Config:SetSetting["${RealmChar}","MeleeOnly",${This.MeleeOnly}]
}
method LoadConfig()
{
This.UsePull:Set[${Config.GetSetting["${RealmChar}","UsePull"]}]
This.PullSpell:Set[${Config.GetSetting["${RealmChar}","PullSpell"]}]
This.RestMP:Set[${Config.GetSetting["${RealmChar}","RestMP"]}]
This.RestHP:Set[${Config.GetSetting["${RealmChar}","RestHP"]}]
This.StandMP:Set[${Config.GetSetting["${RealmChar}","StandMP"]}]
This.StandHP:Set[${Config.GetSetting["${RealmChar}","StandHP"]}]
This.EarthTotem:Set[${Config.GetSetting["${RealmChar}","EarthTotem"]}]
This.AirTotem:Set[${Config.GetSetting["${RealmChar}","AirTotem"]}]
This.WaterTotem:Set[${Config.GetSetting["${RealmChar}","WaterTotem"]}]
This.FireTotem:Set[${Config.GetSetting["${RealmChar}","FireTotem"]}]
This.UseEarthElemental:Set[${Config.GetSetting["${RealmChar}","UseEarthElemental"]}]
This.UseFireElemental:Set[${Config.GetSetting["${RealmChar}","UseFireElemental"]}]
This.UseEarthShock:Set[${Config.GetSetting["${RealmChar}","UseEarthShock"]}]
This.UseFlameShock:Set[${Config.GetSetting["${RealmChar}","UseFlameShock"]}]
This.UseFrostShock:Set[${Config.GetSetting["${RealmChar}","UseFrostShock"]}]
This.RandomShock:Set[${Config.GetSetting["${RealmChar}","RandomShock"]}]
This.SaveShocks:Set[${Config.GetSetting["${RealmChar}","SaveShocks"]}]
This.ConserveMana:Set[${Config.GetSetting["${RealmChar}","ConserveMana"]}]
This.UseLBolt:Set[${Config.GetSetting["${RealmChar}","UseLBolt"]}]
This.UseChainLight:Set[${Config.GetSetting["${RealmChar}","UseChainLight"]}]
This.MainHand:Set[${Config.GetSetting["${RealmChar}","MainHand"]}]
This.OffHand:Set[${Config.GetSetting["${RealmChar}","OffHand"]}]
This.DW:Set[${Config.GetSetting["${RealmChar}","DW"]}]
This.ShieldOnPull:Set[${Config.GetSetting["${RealmChar}","ShieldOnPull"]}]
This.HealWave:Set[${Config.GetSetting["${RealmChar}","HealWave"]}]
This.LHealWave:Set[${Config.GetSetting["${RealmChar}","LHealWave"]}]
This.ChainHeal:Set[${Config.GetSetting["${RealmChar}","ChainHeal"]}]
This.GOTN:Set[${Config.GetSetting["${RealmChar}","GOTN"]}]
This.Output:Set[${Config.GetSetting["${RealmChar}","Output"]}]
This.UseReincarnation:Set[${Config.GetSetting["${RealmChar}","UseReincarnation"]}]
This.UseMPot:Set[${Config.GetSetting["${RealmChar}","UseMPot"]}]
This.UseHPot:Set[${Config.GetSetting["${RealmChar}","UseHPot"]}]
This.UseBandages:Set[${Config.GetSetting["${RealmChar}","UseBandages"]}]
This.MPot:Set[${Config.GetSetting["${RealmChar}","MPot"]}]
This.HPot:Set[${Config.GetSetting["${RealmChar}","HPot"]}]
This.Bandage:Set[${Config.GetSetting["${RealmChar}","Bandage"]}]
This.Shield:Set[${Config.GetSetting["${RealmChar}","Shield"]}]
This.MeleeOnly:Set[${Config.GetSetting["${RealmChar}","MeleeOnly"]}]
}
method InitShamanGUI()
{
if ${This.UsePull}
UIElement[UsePull@Main@Pages@ClassGUI]:SetChecked
if ${This.UseReincarnation}
UIElement[UseReincarnation@Main@Pages@ClassGUI]:SetChecked
if ${This.UseMPot}
UIElement[UseMPot@Main@Pages@ClassGUI]:SetChecked
if ${This.UseHPot}
UIElement[UseHPot@Main@Pages@ClassGUI]:SetChecked
if ${This.UseBandages}
UIElement[UseBandages@Main@Pages@ClassGUI]:SetChecked
if ${This.MeleeOnly}
UIElement[MeleeOnly@Main@Pages@ClassGUI]:SetChecked
if ${This.UseEarthElemental}
UIElement[EarthElemental@Totems@Pages@ClassGUI]:SetChecked
if ${This.UseFireElemental}
UIElement[FireElemental@Totems@Pages@ClassGUI]:SetChecked
if ${This.UseEarthShock}
UIElement[EarthShock@Spells@Pages@ClassGUI]:SetChecked
if ${This.UseFlameShock}
UIElement[FlameShock@Spells@Pages@ClassGUI]:SetChecked
if ${This.UseFrostShock}
UIElement[FrostShock@Spells@Pages@ClassGUI]:SetChecked
if ${This.RandomShock}
UIElement[RandomShock@Spells@Pages@ClassGUI]:SetChecked
if ${This.SaveShocks}
UIElement[SaveShocks@Spells@Pages@ClassGUI]:SetChecked
if ${This.UseLBolt}
UIElement[LightBolt@Spells@Pages@ClassGUI]:SetChecked
if ${This.UseChainLight}
UIElement[UseChainLight@Spells@Pages@ClassGUI]:SetChecked
if ${This.DW}
UIElement[DW@Buffs@Pages@ClassGUI]:SetChecked
if ${This.ShieldOnPull}
UIElement[ShieldOnPull@Buffs@Pages@ClassGUI]:SetChecked
if ${This.Output}
UIElement[EnableOutput@Other@Pages@ClassGUI]:SetChecked
variable int i = 1
for (i:Set[1] ; ${i} <= ${UIElement[PullSpell@Main@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.PullSpell.Equal["${UIElement[PullSpell@Main@Pages@ClassGUI].Item[${i}].Text}"]}
UIElement[PullSpell@Main@Pages@ClassGUI]:SelectItem[${i}]
}
for (i:Set[1] ; ${i} <= ${UIElement[EarthTotem@Totems@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.EarthTotem.Equal["${UIElement[EarthTotem@Totems@Pages@ClassGUI].Item[${i}].Text}"]}
UIElement[EarthTotem@Totems@Pages@ClassGUI]:SelectItem[${i}]
}
for (i:Set[1] ; ${i} <= ${UIElement[WaterTotem@Totems@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.WaterTotem.Equal["${UIElement[WaterTotem@Totems@Pages@ClassGUI].Item[${i}].Text}"]}
UIElement[WaterTotem@Totems@Pages@ClassGUI]:SelectItem[${i}]
}
for (i:Set[1] ; ${i} <= ${UIElement[FireTotem@Totems@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.FireTotem.Equal["${UIElement[FireTotem@Totems@Pages@ClassGUI].Item[${i}].Text}"]}
UIElement[FireTotem@Totems@Pages@ClassGUI]:SelectItem[${i}]
}
for (i:Set[1] ; ${i} <= ${UIElement[AirTotem@Totems@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.AirTotem.Equal["${UIElement[AirTotem@Totems@Pages@ClassGUI].Item[${i}].Text}"]}
UIElement[AirTotem@Totems@Pages@ClassGUI]:SelectItem[${i}]
}
for (i:Set[1] ; ${i} <= ${UIElement[MainHand@Buffs@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.MainHand.Equal["${UIElement[MainHand@Buffs@Pages@ClassGUI].Item[${i}].Text}"]}
UIElement[MainHand@Buffs@Pages@ClassGUI]:SelectItem[${i}]
}
for (i:Set[1] ; ${i} <= ${UIElement[OffHand@Buffs@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.OffHand.Equal["${UIElement[OffHand@Buffs@Pages@ClassGUI].Item[${i}].Text}"]}
UIElement[OffHand@Buffs@Pages@ClassGUI]:SelectItem[${i}]
}
for (i:Set[1] ; ${i} <= ${UIElement[Shield@Buffs@Pages@ClassGUI].Items} ; i:Inc)
{
if ${This.Shield.Equal["${UIElement[Shield@Buffs@Pages@ClassGUI].Item[${i}].Text}"]}
UIElement[Shield@Buffs@Pages@ClassGUI]:SelectItem[${i}]
}
if ${This.RestMP} != ${UIElement[RestMP@Main@Pages@ClassGUI].Value}
UIElement[RestMP@Main@Pages@ClassGUI]:SetValue[${This.RestMP}]
if ${This.RestHP} != ${UIElement[RestHP@Main@Pages@ClassGUI].Value}
UIElement[RestHP@Main@Pages@ClassGUI]:SetValue[${This.RestHP}]
if ${This.StandMP} != ${UIElement[StandMP@Main@Pages@ClassGUI].Value}
UIElement[StandMP@Main@Pages@ClassGUI]:SetValue[${This.StandMP}]
if ${This.StandHP} != ${UIElement[StandHP@Main@Pages@ClassGUI].Value}
UIElement[StandHP@Main@Pages@ClassGUI]:SetValue[${This.StandHP}]
if ${This.ConserveMana} != ${UIElement[ConserveMana@Main@Pages@ClassGUI].Value}
UIElement[ConserveMana@Main@Pages@ClassGUI]:SetValue[${This.ConserveMana}]
if ${This.MPot} != ${UIElement[MPot@Main@Pages@ClassGUI].Value}
UIElement[MPot@Main@Pages@ClassGUI]:SetValue[${This.MPot}]
if ${This.HPot} != ${UIElement[HPot@Main@Pages@ClassGUI].Value}
UIElement[HPot@Main@Pages@ClassGUI]:SetValue[${This.HPot}]
if ${This.Bandage} != ${UIElement[Bandage@Main@Pages@ClassGUI].Value}
UIElement[Bandage@Main@Pages@ClassGUI]:SetValue[${This.Bandage}]
if ${This.HealWave} != ${UIElement[HealWave@Heals@Pages@ClassGUI].Value}
UIElement[HealWave@Heals@Pages@ClassGUI]:SetValue[${This.HealWave}]
if ${This.LHealWave} != ${UIElement[LHealWave@Heals@Pages@ClassGUI].Value}
UIElement[LHealWave@Heals@Pages@ClassGUI]:SetValue[${This.LHealWave}]
if ${This.ChainHeal} != ${UIElement[ChainHeal@Heals@Pages@ClassGUI].Value}
UIElement[ChainHeal@Heals@Pages@ClassGUI]:SetValue[${This.LHealWave}]
if ${This.GOTN} != ${UIElement[GOTN@Heals@Pages@ClassGUI].Value}
UIElement[GOTN@Heals@Pages@ClassGUI]:SetValue[${This.GOTN}]
}
method ClassGUIChange(string Action)
{
switch ${Action}
{
case PullSpell
if ${UIElement[PullSpell@Main@Pages@ClassGUI].SelectedItem.Value(exists)}
This.PullSpell:Set[${UIElement[PullSpell@Main@Pages@ClassGUI].SelectedItem}]
break
case EarthTotem
if ${UIElement[EarthTotem@Totems@Pages@ClassGUI].SelectedItem.Value(exists)}
This.EarthTotem:Set[${UIElement[EarthTotem@Totems@Pages@ClassGUI].SelectedItem}]
break
case FireTotem
if ${UIElement[FireTotem@Totems@Pages@ClassGUI].SelectedItem.Value(exists)}
This.FireTotem:Set[${UIElement[FireTotem@Totems@Pages@ClassGUI].SelectedItem}]
break
case AirTotem
if ${UIElement[AirTotem@Totems@Pages@ClassGUI].SelectedItem.Value(exists)}
This.AirTotem:Set[${UIElement[AirTotem@Totems@Pages@ClassGUI].SelectedItem}]
break
case WaterTotem
if ${UIElement[WaterTotem@Totems@Pages@ClassGUI].SelectedItem.Value(exists)}
This.WaterTotem:Set[${UIElement[WaterTotem@Totems@Pages@ClassGUI].SelectedItem}]
break
case MainHand
if ${UIElement[MainHand@Buffs@Pages@ClassGUI].SelectedItem.Value(exists)}
This.MainHand:Set[${UIElement[MainHand@Buffs@Pages@ClassGUI].SelectedItem}]
break
case OffHand
if ${UIElement[OffHand@Buffs@Pages@ClassGUI].SelectedItem.Value(exists)}
This.OffHand:Set[${UIElement[OffHand@Buffs@Pages@ClassGUI].SelectedItem}]
break
case Shield
if ${UIElement[Shield@Buffs@Pages@ClassGUI].SelectedItem.Value(exists)}
This.Shield:Set[${UIElement[Shield@Buffs@Pages@ClassGUI].SelectedItem}]
break
/* checkboxes */
case UsePull
if ${UIElement[UsePull@Main@Pages@ClassGUI].Checked}
This.UsePull:Set[TRUE]
if !${UIElement[UsePull@Main@Pages@ClassGUI].Checked}
This.UsePull:Set[FALSE]
break
case UseReincarnation
if ${UIElement[UseReincarnation@Main@Pages@ClassGUI].Checked}
This.UseReincarnation:Set[TRUE]
if !${UIElement[UseReincarnation@Main@Pages@ClassGUI].Checked}
This.UseReincarnation:Set[FALSE]
break
case UseHPot
if ${UIElement[UseHPot@Main@Pages@ClassGUI].Checked}
This.UseHPot:Set[TRUE]
if !${UIElement[UseHPot@Main@Pages@ClassGUI].Checked}
This.UseHPot:Set[FALSE]
break
case UseMPot
if ${UIElement[UseMPot@Main@Pages@ClassGUI].Checked}
This.UseMPot:Set[TRUE]
if !${UIElement[UseMPot@Main@Pages@ClassGUI].Checked}
This.UseMPot:Set[FALSE]
break
case UseBandages
if ${UIElement[UseBandages@Main@Pages@ClassGUI].Checked}
This.UseBandages:Set[TRUE]
if !${UIElement[UseBandages@Main@Pages@ClassGUI].Checked}
This.UseBandages:Set[FALSE]
break
case MeleeOnly
if ${UIElement[MeleeOnly@Main@Pages@ClassGUI].Checked}
This.MeleeOnly:Set[TRUE]
if !${UIElement[MeleeOnly@Main@Pages@ClassGUI].Checked}
This.MeleeOnly:Set[FALSE]
break
case EarthElemental
if ${UIElement[EarthElemental@Totems@Pages@ClassGUI].Checked}
This.UseEarthElemental:Set[TRUE]
if !${UIElement[EarthElemental@Totems@Pages@ClassGUI].Checked}
This.UseEarthElemental:Set[FALSE]
break
case FireElemental
if ${UIElement[FireElemental@Totems@Pages@ClassGUI].Checked}
This.UseFireElemental:Set[TRUE]
if !${UIElement[FireElemental@Totems@Pages@ClassGUI].Checked}
This.UseFireElemental:Set[FALSE]
break
case FlameShock
if ${UIElement[FlameShock@Spells@Pages@ClassGUI].Checked}
This.UseFlameShock:Set[TRUE]
if !${UIElement[FlameShock@Spells@Pages@ClassGUI].Checked}
This.UseFlameShock:Set[FALSE]
break
case EarthShock
if ${UIElement[EarthShock@Spells@Pages@ClassGUI].Checked}
This.UseEarthShock:Set[TRUE]
if !${UIElement[EarthShock@Spells@Pages@ClassGUI].Checked}
This.UseEarthShock:Set[FALSE]
break
case FrostShock
if ${UIElement[FrostShock@Spells@Pages@ClassGUI].Checked}
This.UseFrostShock:Set[TRUE]
if !${UIElement[FrostShock@Spells@Pages@ClassGUI].Checked}
This.UseFrostShock:Set[FALSE]
break
case RandomShock
if ${UIElement[RandomShock@Spells@Pages@ClassGUI].Checked}
This.RandomShock:Set[TRUE]
if !${UIElement[RandomShock@Spells@Pages@ClassGUI].Checked}
This.RandomShock:Set[FALSE]
break
case SaveShocks
if ${UIElement[SaveShocks@Spells@Pages@ClassGUI].Checked}
This.SaveShocks:Set[TRUE]
if !${UIElement[SaveShocks@Spells@Pages@ClassGUI].Checked}
This.SaveShocks:Set[FALSE]
break
case UseLBolt
if ${UIElement[LightBolt@Spells@Pages@ClassGUI].Checked}
This.UseLBolt:Set[TRUE]
if !${UIElement[LightBolt@Spells@Pages@ClassGUI].Checked}
This.UseLBolt:Set[FALSE]
break
case UseChainLight
if ${UIElement[UseChainLight@Spells@Pages@ClassGUI].Checked}
This.UseChainLight:Set[TRUE]
if !${UIElement[UseChainLight@Spells@Pages@ClassGUI].Checked}
This.UseChainLight:Set[FALSE]
break
case DW
if ${UIElement[DW@Buffs@Pages@ClassGUI].Checked}
This.DW:Set[TRUE]
if !${UIElement[DW@Buffs@Pages@ClassGUI].Checked}
This.DW:Set[FALSE]
break
case ShieldOnPull
if ${UIElement[ShieldOnPull@Buffs@Pages@ClassGUI].Checked}
This.ShieldOnPull:Set[TRUE]
if !${UIElement[ShieldOnPull@Buffs@Pages@ClassGUI].Checked}
This.ShieldOnPull:Set[FALSE]
break
case EnableOutput
if ${UIElement[EnableOutput@Other@Pages@ClassGUI].Checked}
This.Output:Set[TRUE]
if !${UIElement[EnableOutput@Other@Pages@ClassGUI].Checked}
This.Output:Set[FALSE]
break
/* sliders */
case RestMP
if ${UIElement[RestMP@Main@Pages@ClassGUI].Value(exists)}
This.RestMP:Set[${UIElement[RestMP@Main@Pages@ClassGUI].Value}]
break
case RestHP
if ${UIElement[RestHP@Main@Pages@ClassGUI].Value(exists)}
This.RestHP:Set[${UIElement[RestHP@Main@Pages@ClassGUI].Value}]
break
case StandHP
if ${UIElement[StandHP@Main@Pages@ClassGUI].Value(exists)}
This.StandHP:Set[${UIElement[StandHP@Main@Pages@ClassGUI].Value}]
break
case StandMP
if ${UIElement[StandMP@Main@Pages@ClassGUI].Value(exists)}
This.StandMP:Set[${UIElement[StandMP@Main@Pages@ClassGUI].Value}]
break
case ConserveMana
if ${UIElement[ConserveMana@Main@Pages@ClassGUI].Value(exists)}
This.ConserveMana:Set[${UIElement[ConserveMana@Main@Pages@ClassGUI].Value}]
break
case MPot
if ${UIElement[MPot@Main@Pages@ClassGUI].Value(exists)}
This.MPot:Set[${UIElement[MPot@Main@Pages@ClassGUI].Value}]
break
case HPot
if ${UIElement[HPot@Main@Pages@ClassGUI].Value(exists)}
This.HPot:Set[${UIElement[HPot@Main@Pages@ClassGUI].Value}]
break
case Bandage
if ${UIElement[Bandage@Main@Pages@ClassGUI].Value(exists)}
This.Bandage:Set[${UIElement[Bandage@Main@Pages@ClassGUI].Value}]
break
case HealWave
if ${UIElement[HealWave@Heals@Pages@ClassGUI].Value(exists)}
This.HealWave:Set[${UIElement[HealWave@Heals@Pages@ClassGUI].Value}]
break
case LHealWave
if ${UIElement[LHealWave@Heals@Pages@ClassGUI].Value(exists)}
This.LHealWave:Set[${UIElement[LHealWave@Heals@Pages@ClassGUI].Value}]
break
case ChainHeal
if ${UIElement[ChainHeal@Heals@Pages@ClassGUI].Value(exists)}
This.ChainHeal:Set[${UIElement[ChainHeal@Heals@Pages@ClassGUI].Value}]
break
case GOTN
if ${UIElement[GOTN@Heals@Pages@ClassGUI].Value(exists)}
This.GOTN:Set[${UIElement[GOTN@Heals@Pages@ClassGUI].Value}]
break
}
}
}