objectdef oClass inherits oBase
{
;----------------------
;--- Rest Variables ---
;----------------------
variable int RestHP = 80
;----------------------
;--- Range Settings ---
;----------------------
variable int PullRange = 25
variable int MaxRanged = 30
variable int MinRanged = 15
variable int MaxMelee = 5
variable int MinMelee = 2
variable string RVersion = 1.0
variable bool HaveEarthTotem = ${Item[-items,-inventory,"Earth Totem"](exists)}
/* Don't touch these */
variable guidlist myTotemList
method Initialize()
{
}
member NeedRest()
{
if ${Me.InCombat}
{
return FALSE
}
if ${Me.Buff[Food](exists)}
{
if ${Me.PctHPs} < 100
{
return TRUE
}
}
if ${Me.Buff[Drink](exists)}
{
if ${Me.PctMana} < 100
{
return TRUE
}
}
if ${Me.PctHPs} < ${RestHP}
{
return TRUE
}
return FALSE
}
method RestPulse()
{
if !${Me.InCombat}
{
; If I am sitting and full stand up
if ${Me.Sitting} && ${Me.PctHPs}==100 && ${Me.PctMana}==100
{
wowpress jump
}
if ${Movement.Speed}
{
Move -stop
}
if ${Me.Target(exists)}
{
WoWScript ClearTarget()
}
if ${Me.PctHPs} < ${RestHP} && ${Consumable.HasFood} && !${Me.Buff[Food](exists)}
{
Consumable:useFood
}
}
}
;------------------
;--- Buff SetUp ---
;------------------
member NeedBuff()
{
return FALSE
}
method BuffPulse()
{
}
;------------------
;--- Pull SetUp ---
;------------------
member NeedPullBuff()
{
return FALSE
}
method PullBuffPulse()
{
}
;------------------------
;--- CombatBuff SetUp ---
;------------------------
member NeedCombatBuff()
{
/* Check for global cooldown */
if !${Me.GlobalCooldown}
{
/* Lightning Shield buff check */
if ${Spell[Lightning Shield](exists)} && !${Me.Buff[Lightning Shield](exists)}
{
echo "Debug: NeedCombatBuff: Lightning Shield"
return TRUE
}
/* If we need a heal, heal */
if ${This.NeedHeal}
{
echo "Debug: NeedCombatBuff: NeedHeal"
return TRUE
}
/* Check totems */
if ${This.GetTotem[0]}
{
echo "DEBUG: NeedCombatBuff: Totem"
return TRUE
}
}
return FALSE
}
/* Moved NeedTotem logic to a member */
member GetTotem(int Which)
{
/* Handle all earth totems */
if ${This.HaveEarthTotem}
{
if ${Spell[Stoneskin Totem](exists)} && !${This.FindTotem[Stoneskin Totem]} && \
${This.GetCurrentTargets} == 1
{
echo "DEBUG: NeedTotem: Returning Stoneskin Totem"
if ${Which} == 1
{
echo "DEBUG: GetTotem(${Which}): Returning Stoneskin Totem"
return "Stoneskin Totem"
}
elseif ${Which} == 0
{
echo "DEBUG: GetTotem(${Which}): Returning TRUE"
return TRUE
}
}
if ${Spell[Stoneclaw Totem](exists)} && !${This.FindTotem[Stoneclaw Totem]} && \
${This.GetCurrentTargets} > 1 && !${Spell[Stoneclaw Totem].Cooldown}
{
if ${Which} == 1
{
echo "DEBUG: GetTotem(${Which}): Returning Stoneclaw Totem"
return "Stoneclaw Totem"
}
elseif ${Which} == 0
{
echo "DEBUG: GetTotem(${Which}): Returning TRUE"
return TRUE
}
}
}
if ${Which} == 1
{
echo "DEBUG: GetTotem(${Which}): Returning FALSE"
return FALSE
}
elseif ${Which} == 0
{
echo "DEBUG: GetTotem(${Which}): Returning NULL"
return NULL
}
}
method CombatBuffPulse()
{
/* Lightning Shield cast */
if ${Spell[Lightning Shield](exists)} && !${Me.Buff[Lightning Shield](exists)}
{
echo "DEBUG: CombatBuffPulse: Casting Lightning Shield"
Toon:CastSpell[Lightning Shield]
return
}
/* do Healing */
if ${This.NeedHeal}
{
echo "DEBUG: CombatBuffPulse: Casting Lightning Shield"
This:DoBestHeal
return
}
/* Cast best totem */
if ${This.GetTotem[0]}
{
echo "DEBUG: CombatBuffPulse: Casting Best Totem"
Toon:CastSpell[${This.GetTotem[1]}]
return
}
}
;------------------
;--- Pull SetUp ---
;------------------
member InRange()
{
if ${Target.Distance} < 25
{
return TRUE
}
return FALSE
}
method PullPulse()
{
if !${Me.Target(exists)}
{
return
}
if ${Me.Target.Dead}
{
WoWScript ClearTarget()
return
}
if !${Me.Target.Attackable}
{
WoWScript ClearTarget()
return
}
if ${Me.Sitting}
{
WoWpress jump
}
if ${Target.Distance} == 0
{
return
}
;This:Output["Facing ${Target.GUID} ${Target.Location}"]
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
; Make sure we are in distance for attacking
; Make sure we are in distance for attacking
/* Also make sure I'm not casting, so I don't interrupt */
if ${Target.Distance} > ${This.MaxRanged} && !${Me.Casting}
{
wowpress -hold moveforward
return
}
; Stop if we are
if ${Target.Distance} > ${MinRanged} && ${Target.Distance} < (${This.PullRange} - 5) && ${Movement.Speed}
{
Move -stop
}
if ${Me.GlobalCooldown}
{
return
}
/* Pull with Lightning Bolt */
if ${Target.Distance} <= ${This.PullRange} && !${Me.Casting}
{
echo "DEBUG: Pull: Casting Lightning Bolt"
Toon:CastSpell[Lightning Bolt]
return
}
/* Make sure we're not currently attacking before we toggle */
if !${Me.Attacking}
{
WoWScript AttackTarget()
}
}
;--------------------
;--- Combat SetUp ---
;--------------------
method AttackPulse()
{
POI.IInteracting:Set[FALSE]
if !${Target(exists)} || ${Target.GUID.Equal[${Me.GUID}]} || ${Target.Dead}
{
This:Output["I need a target"]
Toon:NeedTarget[1]
}
if !${Me.Target(exists)}
{
move -stop
return
}
if ${Me.Target.Dead}
{
WoWScript ClearTarget()
move -stop
return
}
if !${Me.Target.Attackable}
{
WoWScript ClearTarget()
move -stop
return
}
if ${Me.Sitting}
{
WoWpress jump
}
if ${Target.Distance} < 6 && ${Movement.Speed}
{
move -stop
}
if ${Me.Target(exists)} && !${Me.InCombat}
{
; Why do I have a target in attack pulse and am not in combat?
WoWScript ClearTarget()
return
}
;This:Output["Facing ${Target.GUID} ${Target.Location}"]
/* Make sure we're not feared before trying to turn, so the camera doesn't go all fucky */
/* In fact, if we're feared, just return 'til we're not. I'll add de-fear (trinket) use later */
if ${Me.Buff[Fear](exists)} || ${Me.Buff[Death Coil](exists)} || ${Me.Buff[Psychic Scream](exists)} \
|| ${Me.Buff[Intimidation](exists)} || ${Me.Buff[Charge Stun](exists)} || \
${Me.Buff[Cyclone](exists)} || ${Me.Buff[Seduction](exists)}
{
return
}
Navigator:FaceXYZ[${Target.X},${Target.Y},${Target.Z}]
; Make sure we are in distance for attacking
if ${Target.Distance}>${MaxRanged}
{
wowpress -hold moveforward
return
}
; Stop if we are
if ${Target.Distance} > ${MinRanged} && ${Target.Distance}<${MaxRanged} && ${Movement.Speed}
{
Move -stop
}
/* Make sure we're attacking; shamans are nice and melee-ish */
if ${Me.InCombat} && !${Me.Attacking}
{
WoWScript AttackTarget()
}
/* Check for that damn global cooldown */
if ${Me.GlobalCooldown}
{
return
}
/* If there's no cooldown, we're good to continue on */
/* Earth shock? */
if ${Spell[Earth Shock](exists)} && ${Me.CurrentMana} >= ${Spell[Earth Shock].Mana} && ${Target.Distance} < 20
{
Toon:CastSpell[Earth Shock]
return
}
}
/* NeedHeal member - determine if I need a heal in combat */
member NeedHeal()
{
/* If we've got Gift of the Naaru on us, we don't need a heal yet */
if ${Me.Buff[Gift of the Naaru](exists)}
{
echo "DEBUG: NeedHeal: Returning FALSE (Gift of the Naaru)"
return FALSE
}
/* Make sure we need a heal, have a heal spell, and have mana for a heal */
/* Healing Wave */
if ${Me.PctHPs} > 25 && ${Me.PctHPs} <= 75 && ${Spell[Healing Wave](exists)}
{
echo "DEBUG: NeedHeal: Returning TRUE (Healing Wave)"
return TRUE
}
/* If I'm under 25% HP, use lesser healing wave if I have it - don't want to get critkilled or
interrupted to death, now do we? Use normal healing wave if we don't have lesser.*/
if ${Me.PctHPs} <= 25
{
/* Check for Lesser Healing Wave */
if ${Spell[Lesser Healing Wave](exists)}
{
echo "DEBUG: NeedHeal: Returning TRUE (Lesser Healing Wave)"
return TRUE
}
/* Check for Healing Wave */
elseif ${Spell[Healing Wave](exists)}
{
echo "DEBUG: NeedHeal: Returning TRUE (Healing Wave 2)"
return TRUE
}
}
echo "DEBUG: NeedHeal: Returning FALSE (None needed)"
return FALSE
}
/* DoBestHeal method - use the most appropriate heal */
method DoBestHeal()
{
/* Use Gift of the Naaru if we have it, it's free */
if ${Me.PctHPs} <= 75 && ${Spell[Gift of the Naaru](exists)} && !${Spell[Gift of the Naaru].Cooldown}
{
/* Cast Gift of the Naaru */
echo "DEBUG: DoBestHeal: Casting Gift of the Naaru"
Toon:CastSpell[Gift of the Naaru]
return
}
/* If my HP is between 25% and 75%, use normal healing wave */
if ${Me.PctHPs} > 25 && ${Me.PctHPs} <= 75 && ${Spell[Healing Wave](exists)}
{
/* Cast Healing Wave */
echo "DEBUG: DoBestHeal: Casting Healing Wave"
Toon:CastSpell[Healing Wave]
return
}
/* If I'm under 25% HP, use lesser healing wave if I have it - don't want to get critkilled or
interrupted to death, now do we? Use normal healing wave if we don't have lesser.*/
if ${Me.PctHPs} <= 25
{
/* Check for Lesser Healing Wave */
if ${Spell[Lesser Healing Wave](exists)}
{
/* Cast Lesser Healing Wave */
echo "DEBUG: DoBestHeal: Casting Lesser Healing Wave"
Toon:CastSpell[Lesser Healing Wave]
return
}
/* Check for Healing Wave */
elseif ${Spell[Healing Wave](exists)}
{
/* Cast Healing Wave */
echo "DEBUG: DoBestHeal: Casting Healing Wave (2)"
Toon:CastSpell[Healing Wave]
return
}
}
}
/* Member to check for a totem in myTotemList */
member FindTotem(string TotemName)
{
/* The range of effect varies from totem to totem, so set the search range before we search */
variable int searchRange = 0
if ${TotemName.Equal[Stoneskin Totem]}
This.searchRange:Set[20]
elseif ${TotemName.Equal[Earthbind Totem]}
This.searchRange:Set[10]
elseif ${TotemName.Equal[Stoneclaw Totem]}
This.searchRange:Set[15]
/* First off, populate the totem GUIDlist */
myTotemList:Search[-units,-range 0-${This.searchRange},-friendly,-level ${Me.Level}]
/* For every entry in our totem list... */
do
{
/* Make sure the unit is of CreatureType Totem */
if ${Unit[${This.myTotemList.GUID[${myIdx}]}].CreatureType.Equal[Totem]}
{
/* Now check the unit's name against passed name, and owner against Me */
if ${Unit[${This.myTotemList.GUID[${myIdx}]}].Name.Equal[${TotemName}]} && \
${Unit[${myTotemList.GUID[${myIdx}]}].Owner.Name.Equal[${Me}]}
{
This:Output[DEBUG: Returning true to totem check]
return TRUE
}
}
myIdx:Inc
}
while ${myIdx} <= ${myTotemList.Count}
This:Output[Debug: Returning false to totem check]
return FALSE
}
/* Member to check number of current targets, used in determining totems */
member GetCurrentTargets()
{
variable guidlist myHostileList
myHostileList:Search[-units,-range 0-15,-hostile,-targetingme]
echo "DEBUG: GetCurrentTargets: ${myHostileList.Count}"
return ${myHostileList.Count}
}
}