MacroQuest64

Code: Select all

| Shambot Version 1.0c    by Ranma 
|_______________________________________________________________| 
| 
| I started with the Excellent Base routine by Hubba and have  
| added a lot of additional feature and abilities 
| 
| Usage: 
| 1. Target player you like to assist (main tank is good) 
| 2. Start the script with: /mac <scriptname> [main assist] [chat channel] [controller] 
| 3. Parameters are optional defaults are built in 
| 
| 
| Features: commands work in tell or group 
| 
| The following commands will target the sender and cast the spells 
| requested on the sender: [Avatar] [Sta] [Agi] [Dex] [Str] [Cha] [Sow] [lev] 
| [haste] [regen] [see] [pe] [pr] [grow] [shrink] [hot] [heal] 
| 
| The following commands will assist the sender and cast the spells 
| requested on the target: [Slow] [add] [root] [dot] [nuke]  
| 
| The following commands: [buff] [buff me] will rebuff a person 
| 
| The following commands: [Buff them] will rebuff another group 
|  
| The following commands: [Follow me] [end follow] [stop] are for moving shaman 
| 
| The [add] or [slow] command are good in combat when there are adds 
| Target the add and it will be malo and slowed 
| 
| During combat he will only do requests for heals and detrimentals 
| 
| [buff pet] works properly now, targets the senders pet and buffs 
| 
| [gate now] will memorize the gate spell and gate to bind, must be a tell  
| 
| Added a chat channel to echo all non command word tells to controller 
| added a vtell to controller on incomming tells 
| 
| Use "help" for more help ( !help is incomplete! ) 
|_______________________________________________________________| 
| 
| -!- Basis of this script is Version: v0.5c by Hubba 
| Awesome script, I hope you like what I have added 
| 
|_______________________________________________________________| 
| -!- This Script Uses spell_routines.inc by Rusty 
| -!- Exptrack snippet from exptracker.mac by Raebis, with tweaks from Phoenix (not tested) 
| -!- Wait4Rez snippet from wait4rez.mac by fantum409 
| 
|_______________________________________________________________| 

#chat group 
#chat tell 

#Event   ToggleVariable   "[MQ2] Toggle #1#" 
#Event   ToggleVariable   "[MQ2] Toggle #1# #2#" 
#Event   OutDoor          "#*#outdoors#*#" 
#Event   OutDoor          "You can not summon a mount here." 
#Event   Zoning           "You have entered#*#" 
#Event   Hungry           "#*#are hungry#*#" 
| #Event   Enrageon         "#*#ENRAGED#*#" 
| #Event   Enrageoff        "#*#no longer enraged#*#" 
#Event   Thirsty          "#*#are thirsty#*#" 
#Event   ImDead           "You have been slain by#*#" 
#Event   Invited          "#*#To join the group, click on the 'FOLLOW' option, or 'DISBAND' to 

cancel#*#" 

#include Spell_Routines.inc 

Sub Main 

| The spell will be memmed in the listed order. 
| Gem1 = Canni 
| Gem2 = Slow 
| Gem3 = Malo 
| Gem4 = Avatar 
| Gem5 = Pet and buffs 
| Gem6 = Heal 
| Gem7 = HoT 
| Gem8 = DoT 
| Gem9 = root, Nuke, gate 

| ########### Make changes in spells as you need. 
| ########### Obs! This is mainly for a 65+ shaman with Cannibalization ability 
| ########### Set Cannibalization to False if you don't have the ability 
| ########### 

| ########### Default  Channel, Controller 

   /declare CChannel      outer "serverwide.kodd" 
   /declare ChatController outer "   " 
  
| ########### Your Spell List - update as needed  

   /declare SpellSlow          outer "Turgur's Insects" 
   /declare SpellDoT           outer "Bane of Nife" 
   /declare SpellPet           outer "Spirit of the Howler" 
   /declare SpellDeBuff        outer "Malos" 
   /declare SpellCanni         outer "Cannibalize IV" 

   /declare SpellHoT           outer "Stoicism" 
   /declare SpellHeal          outer "Kragg's Mending" 
   /declare SpellRoot          outer "Immobilize" 
   /declare SpellNuke          outer "Ice Strike" 

   /declare SpellATK           outer "" 
   /declare SpellHASTE         outer "Celerity" 
   /declare SpellFOCUS         outer "Harnessing of spirit" 
   /declare SpellCHA           outer "Charisma" 
   /declare SpellDEX           outer "Strength of the Diaku" 
   /declare SpellSTR           outer "Harnessing of spirit" 
   /declare SpellAGI           outer "Talisman of the Cat" 
   /declare SpellSTA           outer "Talisman of the Brute" 
   /declare SpellREGEN         outer "Regrowth of Dar Khura" 
   /declare SpellPE            outer "Primal Essence" 
   /declare SpellPR            outer "Talisman of Epuration" 

   /declare SpellSOW           outer "Spirit of Bih`Li" 
   /declare SpellLEV           outer "Levitation" 
   /declare SpellINV           outer "Invisibility" 
   /declare SpellSHRINK        outer "Shrink" 
   /declare SpellGROW          outer "Grow" 
   /declare SpellSEE           outer "Acumen of Dar Khura" 

   /declare SpellGATE          outer "Gate" 
   /declare SpellFOOD          outer "Summon Food" 
   /declare SpellDRINK         outer "Summon Drink" 

| ########### Mount Type 

   /declare Mount              outer "Small Black Drum" 


| ########### My Pet Buff Spell List 

   /declare SpellPetBuff[2] string outer 
   /varset SpellPetBuff[1] "Celerity" 
   /varset SpellPetBuff[2] "Harnessing of spirit" 

| ########### Other Pet Buff Spell List 

   /declare SpellPetBuffo[2] string outer 
   /varset SpellPetBuff[1] "Celerity" 
   /varset SpellPetBuff[2] "Harnessing of spirit" 

| ############ Group Buff List. 

   /declare SpellGrpBuff[4] string outer 
   /varset SpellGrpBuff[1] "Regrowth of Dar Khura" 
   /varset SpellGrpBuff[2] "Talisman of the Cat" 
   /varset SpellGrpBuff[3] "Talisman of the Brute" 
   /varset SpellGrpBuff[4] "Acumen of Dar Khura"
    
| ############ Single Buff List.    

   /declare SpellSingleBuff[2] string outer 
   /varset SpellSingleBuff[1] "Harnessing of spirit"   
   /varset SpellSingleBuff[2] "Celerity"
| ############ Combat Variables 

   /declare AssistAt      int   outer 100 
   /declare CombatAt      int   outer 99 

   /declare CastDoTat     int   outer 80 
   /declare DotMana       int   outer 60 

   /declare Rootat        int   outer 40 
   /declare RootMana      int   outer 40 

   /declare NukeAt        int   outer 90 
   /declare NukeMana      int   outer 50 

   /declare SitAt         int   outer 95 
   /declare BuffMana      int   outer 50 
   /declare MinMana       int   outer 15 
    
   /declare following     int   outer 0 
   /declare follname      string outer NULL 

| ############ Heal Priority. 

   /declare CasterHeals   int   outer 80 
   /declare MeleeHeals    int   outer 60 
   /declare TankHeal      int   outer 57 

| ############ To Do List 

   /declare DoMalo             outer FALSE    
   /declare DoSlow             outer TRUE 
   /declare FastSlow           outer FALSE 
   /declare DoRoot             outer FALSE 

   /declare SummonPet          outer TRUE 
   /declare BuffPet            outer TRUE 
  
   /declare DoDoT              outer TRUE 
   /declare DoBuffs            outer TRUE 
   /declare DoSow              outer TRUE 
   /declare DoNuke             outer FALSE 
   /declare DoHeal             outer TRUE 
   /declare Cannibalization    outer FALSE 
   /declare Verbose            outer TRUE

   | This is a delay for how long Avatar will hold. (8min) 
   /declare AvatarDelay       outer 5350 

| ########### ! No Changes From Here Is Needed ! 

   /squelch /alias malo /echo toggle malo 
   /squelch /alias slow /echo toggle slow 
   /squelch /alias fastslow /echo toggle fastslow 
   /squelch /alias root /echo toggle root 
   /squelch /alias pet /echo toggle pet 
   /squelch /alias dot /echo toggle dot 
   /squelch /alias nuke /echo toggle nuke 
   /squelch /alias nukeat /echo toggle nukeat    
   /squelch /alias buffs /echo toggle buffs 
   /squelch /alias sow /echo toggle sow 
   /squelch /alias assistat /echo toggle assistat 
   /squelch /alias dotat /echo toggle dotat 
   /squelch /alias rootat /echo toggle rootat 
   /squelch /alias combatat /echo toggle combatat 
   /squelch /alias healmeleeat /echo toggle healmeleeat 
   /squelch /alias healcastersat /echo toggle healcastersat 
   /squelch /alias healtankat /echo toggle healtankat 
   /squelch /alias assist /echo toggle assist 
   /squelch /alias healat /echo toggle healat 
   /squelch /alias status /echo toggle show 
   /squelch /alias show /echo toggle show    
   /squelch /alias help /echo toggle help 
   /squelch /alias verbose /echo toggle verbose    
    
   /declare TargetArray[4] string outer 
   /declare MobMaloed      outer FALSE 
   /declare MobSlowed      outer FALSE 
   /declare PetOn          outer FALSE 
   /declare MobRooted      outer FALSE 
   /declare MobDoTed       outer FALSE 
   /declare CombatOn       outer TRUE 
   /declare Engaged        outer FALSE  
   /declare LowMana        outer FALSE  

   /declare M_Assist       string outer 
   /declare OutDoors       outer TRUE    

   /declare Exper float outer 
   /declare AAExp float outer 
        
   /varset Exper ${Me.Exp} 
   /varset AAExp ${Me.AAExp} 

   /declare ATKBuffed0 timer outer 0 
   /declare ATKBuffed1 timer outer 0 
   /declare ATKBuffed2 timer outer 0 
   /declare ATKBuffed3 timer outer 0 
   /declare ATKBuffed4 timer outer 0 
   /declare ATKBuffed5 timer outer 0 
    
   /call MemSpells 
    
| ############### Target a player as Main Assist 
    
      /if (${Defined[Param0]}) {  
          /varset M_Assist ${Param0} 
          /echo Assist set to ${M_Assist} 
      } else { 
          /if (!${Target.ID} || ${Target.Type.NotEqual[PC]}) { 
              /echo Your Do not have a main assist, make sure its a player character! 
              /endmacro 
          } 
          /varset M_Assist ${Target.CleanName} 
          /echo Assist set to ${M_Assist} 
      } 

      /assist off 

      /if (${Defined[Param1]}) /varset CChannel ${Param1} 
      /leaveall 
      /join ${CChannel} 
      /1 I am here! 
      /echo Joined channel ${CChannel} 

      /if (${Defined[Param2]}) /varset ChatController ${Param2} 
      /vtell ${ChatController} 005 
      /tell ${ChatController} I am here! 
      /echo My master is ${ChatController} 


| ############### Shrink 

    /target pc ${Me} 
    /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
       /ECHO ${SpellSHRINK} is incomming to you 
       /call cast ${SpellSHRINK} gem5 5s 
       /call cast ${SpellSHRINK} gem5 5s 
    }    
          
    
| ###############    
| ############### Main Loop Starts 
| ###############  

:Main_Loop 

   |- Check for Standing if less than sitat then sit 
   /if ( ${Me.State.Equal[Stand]} && ${Me.PctMana}<${SitAt}) /sit 

   |- Summon Mount if outdoors 
   /if (!${Me.Mount.ID} && ${OutDoors}) /call cast ${Mount} item 4s 
    

   |- Check for low mana state 
   /call Check_Mana 

   |- Check for new events in chat etc etc... 
   /doevents 
    
   |- Do we move? 
   :Hold_Main 
   /if (${Me.Moving}) /goto :Hold_Main 
    
   |- Pet 
   /call PET 
    
   |- Buff Sow 
   /call SOW 
    
   |- Check for mobs and do combat stuff 
   /call GetTarget 
   /if (${CombatOn}) /call Combat        

   |- Group Heals 
   /call Check_grpHPs 

   |- Check for Standing if less than sitat then sit 
   /if ( ${Me.State.Equal[Stand]} && ${Me.PctMana}<${SitAt}) /sit 

   |- Canni 
   /call LOM 

   |- Group Buffs if more than BuffMana mana 
   /if (${Me.PctMana}>=${BuffMana} && ${DoBuffs}) /call GrpBuffs 

   |- Buff Avatar 
   /if (${Me.SpellReady[${SpellATK}]}) /call Cast_Avatar 
    
   |- Group Heals 
   /call Check_grpHPs 

   /goto :Main_Loop 
/return 

| ###############    
| ############### Main Loop Ends 
| ############### 

  
| ############### Mem Spells in Spell List 

Sub MemSpells 

   /echo Memming spells. Hang on. 
   /if ( !${Me.Gem[${SpellCanni}]} ) { 
      /memspell 1 ${SpellCanni} 
      /delay 25 
   } 
   /if ( !${Me.Gem[${SpellSlow}]} ) { 
      /memspell 2 ${SpellSlow} 
      /delay 20 
   } 
   /if ( !${Me.Gem[${SpellDeBuff}]} ) { 
      /memspell 3 ${SpellDeBuff} 
      /delay 20 
   } 
   /if ( !${Me.Gem[${SpellATK}]} ) { 
      /memspell 4 ${SpellATK} 
      /delay 20 
   } 
   /if ( !${Me.Gem[${SpellPet}]} ) { 
      /memspell 5 ${SpellPet} 
      /delay 20 
   } 
   /if ( !${Me.Gem[${SpellHeal}]} ) { 
      /memspell 6 ${SpellHeal} 
      /delay 20 
   } 
   /if ( !${Me.Gem[${SpellHoT}]} ) { 
      /memspell 7 ${SpellHoT} 
      /delay 20 
   } 
   /if ( !${Me.Gem[${SpellDoT}]} ) { 
      /memspell 8 ${SpellDoT} 
      /delay 30 
   } 
   /if ( !${Me.Gem[${SpellRoot}]} ) { 
      /memspell 9 ${SpellRoot} 
      /delay 30 
   } 

   |/if ( ${Window[SpellBookWnd].Open} ) /windowstate SpellBookWnd close 
   /echo Spells are memmed. 

/return 

| ################### Check target and do stuff like slow, dot, pet attack etc. 

Sub Combat 
   /if (${CombatOn} && !${MobMaloed} && ${DoMalo} && ${Target.ID}==${TargetArray[4]}) /call DeBuff 
   /if (${CombatOn} && !${MobSlowed} && ${DoSlow} && ${Target.ID}==${TargetArray[4]}) /call Slow 
   /if (${CombatOn} && !${PetOn} && ${Target.ID}==${TargetArray[4]}) { 
      /pet attack 
      /varset PetOn TRUE 
      /varset Engaged TRUE  
   } 

   |- Check for new events in chat etc etc... 
   /doevents 

   /if (${CombatOn} && ${DoDoT} && !${MobDoTed} && ${Me.PctMana}>=${RootMana} && ${Target.PctHPs}<=${CastDoTat}) { 
      /call cast ${SpellDoT} gem8 
      /varset MobDoTed TRUE 
   } 
   /if (${CombatOn} && ${DoNuke} && ${Me.PctMana}>=${NukeMana} && ${Target.PctHPs}<=${NukeAt}) { 
      /call cast ${SpellNuke} gem9 
   } 
   /if (${CombatOn} && ${DoRoot} && ${Me.PctMana}>=${RootMana} && ${Target.PctHPs}<=${RootAt}) { 
      /call cast ${SpellRoot} gem9 
      /varset MobRooted TRUE 
   } 

   |- Check for new events in chat etc etc... 
   /doevents 

|- EndCombat 

   /target ${TargetArray[3]} 
    
   /if (!${Target.Name.Equal[${TargetArray[3]}]} || !${Target.ID}) { 
      /echo ${TargetArray[1]} is dead 
      /varset MobRooted FALSE 
      /varset MobMaloed FALSE 
      /varset MobSlowed FALSE 
      /varset PetOn FALSE 
      /varset MobDoTed FALSE 
      /varset CombatOn FALSE 
      /varset Engaged FALSE    
      
      /varset TargetArray[1] NULL 
      /varset TargetArray[2] NULL 
      /varset TargetArray[3] NULL 
      /varset TargetArray[4] NULL 

  } 
/return 
  
| ############### Debuff 

Sub DeBuff 
:DeBuff_Loop 
   /if (${Target.PctHPs}<=${CombatAt} && ${Target.ID}==${TargetArray[4]}) { 
      /if (${Me.CurrentMana}<${Spell[${SpellDeBuff}].Mana}) { 
         /echo *** Shid ! I don't have mana to Malo %T 
      } else { 
         /call cast ${SpellDeBuff} gem3 6s 
         /if (${Macro.Return.Equal["CAST_INTERRUPTED"]}) /goto :DeBuff_Loop 
         /varset MobMaloed TRUE 
      } 
   } 
/return 
  
| ############### Slowing 

Sub Slow 
   /if (${Target.PctHPs}<=${CombatAt} && ${Target.ID}==${TargetArray[4]}) { 
      /if (${Me.CurrentMana}<${Spell[${SpellSlow}].Mana}) { 
         /echo Shid ! I don't have mana to Malo %T 
      } else { 
      :Slow_Loop 
         /call cast ${SpellSlow} gem2 6s 
         /if (${Macro.Return.Equal["CAST_INTERRUPTED"]}) /goto :Slow_Loop 
         /if (${Macro.Return.Equal["CAST_IMMUNE"]}) { 
            /if (${Verbose}) /gsay *** %T is IMMUNE to my slow ! 
          
            /varset MobSlowed TRUE 
         } 
         /if (${Macro.Return.Equal["CAST_RESISTED"]}) { 
            /if (!${FastSlow}) { 
               /if (${Verbose}) /gsay *** %T RESISTED slow ! Trying again asap 
                /goto :Slow_Loop 
             } 
            /varset MobSlowed TRUE 
          } 
         /if (${Macro.Return.Equal["CAST_SUCCESS"]}) { 
            /if (${Verbose}) /gsay *** %T is SLOWED 
            /varset MobSlowed TRUE 
          } 

      } 
   } 
/return 

Sub GetTarget 
   /assist ${M_Assist} 
   /delay 3 
   /if (${Target.Type.Equal[NPC]}) /if (${Target.Distance}<=${AssistAt} && ${Target.ID}!=${TargetArray[4]} && ${Target.PctHPs}<=${CombatAt}) { 
      /varset TargetArray[1] ${Target.CleanName} 
      /varset TargetArray[2] ${Target.Level} 
      /varset TargetArray[3] ${Target.Name} 
      /varset TargetArray[4] ${Target.ID} 
      /varset CombatOn TRUE 
        
      /varset MobRooted FALSE 
      /varset MobMaloed FALSE 
      /varset MobSlowed FALSE 
      /varset PetOn FALSE 
      /varset MobDoTed FALSE 

      /varset AAExp ${Math.Calc[${Me.PctAAExp}-${AAExp}]} 
      /varset Exper ${Math.Calc[${Me.PctExp}-${Exper}]} 

      /echo EXP: ${Exper}:${Me.PctExp}% - AAXP: ${AAExp}:${Me.PctAAExp}% - ${Math.Calc[${Macro.RunTime}/60]} minutes 
      /popup EXP: ${Exper}:${Me.PctExp}% - AAXP: ${AAExp}:${Me.PctAAExp}% - ${Math.Calc[${Macro.RunTime}/60]} minutes 
      /varset Exper ${Me.PctExp} 
      /varset AAExp ${Me.PctAAExp} 
   } 
/return 

| ################### Buff the group with buffs from the SpellGrpBuff array 


Sub GrpBuffs 
   /declare i int local 1 
   /for i 1 to ${SpellGrpBuff.Size} 
      /doevents 
      /if (${Spell[${SpellGrpBuff[${i}]}].Mana} > ${Me.CurrentMana}) /return 
      /if ( !${Me.Buff[${SpellGrpBuff[${i}]}].ID} ) { 
         /target pc ${M_Assist} 
         /delay 3 
         /echo *** Hang on ! Rebuffing ${SpellGrpBuff[${i}]} 
         /call cast ${SpellGrpBuff[${i}]} gem5 5s 
      } 
   /next i 
/return 

|################### Check if any group member needs heal 
Sub Check_grpHPs 
   /declare i int local 1 
    
   /for i 1 to ${Group} 

   /if (${Group[${i}].Class.Name.Equal[Cleric]} || ${Group[${i}].Class.Name.Equal[Druid]} || ${Group[${i}].Class.Name.Equal[Wizard]} || ${Group[${i}].Class.Name.Equal[Magician]} || ${Group[${i}].Class.Name.Equal[Necromancer]} || ${Group[${i}].Class.Name.Equal[Enchanter]}) /if (${Group[${i}].PctHPs}<=${CasterHeals}) { 
      /target pc ${Group[${i}]} 
      /if (${Me.CurrentMana}<${Spell[${SpellHeal}].Mana}) { 
         /echo *** Shid ! I don't have mana to heal ${Group[${i}]} 
      } else /if (${Target.Distance}<=100) { 
         /if (${Verbose}) /gsay *** ${SpellHeal} on %T 
         /call cast ${SpellHeal} gem6 4s 
      } 
   } 
    
   /if (${Group[${i}].Class.Name.Equal[Warrior]} || ${Group[${i}].Class.Name.Equal[Monk]} || ${Group[${i}].Class.Name.Equal[Rouge]} || ${Group[${i}].Class.Name.Equal[Ranger]} || ${Group[${i}].Class.Name.Equal[Beast]} || ${Group[${i}].Class.Name.Equal[Shadow Knight]} || ${Group[${i}].Class.Name.Equal[Paladin]}) /if (${Group[${i}].PctHPs}<=${MeleeHeals} && ${Group[${i}].Name.NotEqual[${M_Assist}]}) { 
      /target pc ${Group[${i}]} 
      /if (${Me.CurrentMana}<${Spell[${SpellHeal}].Mana}) { 
         /echo *** Shid ! I don't have mana to heal ${Group[${i}]} 
      } else /if (${Target.Distance}<=100) { 
         /if (${Verbose}) /gsay *** ${SpellHeal} on %T 
         /call cast ${SpellHeal} gem6 4s 
      } 
   } 

   /if (${Group[${i}].Name.Equal[${M_Assist}]} && ${Group[${i}].PctHPs}<=${TankHeal}) { 
      /target pc ${Group[${i}]} 
      /if (${Me.CurrentMana}<${Spell[${SpellHeal}].Mana}) { 
         /echo *** Shid ! I don't have mana to heal ${Group[${i}]} 
      } else /if (${Target.Distance}<=100) { 
         /if (${Verbose}) /gsay *** ${SpellHeal} on %T 
         /call cast ${SpellHeal} gem6 4s 
      } 
   } 

   /next i 
/return 

| ################### Check Mana level and report it 

Sub Check_Mana 
   /if (${Math.Calc[${Me.MaxMana}*${MinMana}/100]} >= ${Me.CurrentMana} && !${LowMana}) { 
      /varset LowMana TRUE 
      /gsay I am LOM... 
   } else /if (${Math.Calc[${Me.MaxMana}*${BuffMana}/100]} <= ${Me.CurrentMana} && ${LowMana}) { 
      /gsay I am GTG...      
      /varset LowMana FALSE  
   } 
/return 

| ################## Canni 5 

Sub Cannibalization 
   /call CheckMyHPs 
   /if (${Me.CurrentHPs} < 2424) { 
      /call CheckMyHPs 
   } else /if (${Me.Buff[${SpellHoT}].ID}) { 
      /if (${Verbose}) /gsay *** Doing Cannibalization ! 
      /aa act Cannibalization 
      /delay 3s 
   } 
/return 

| ################## This will NOT check self HPs, Only check HoT or recast HoT 

Sub CheckMyHPs 
   /if (${Me.CurrentMana}<${Spell[${SpellHoT}].Mana}) { 
      /echo *** Shit, I don't have mana to cast ${SpellHoT} 
   } else { 
      /target myself 
      /delay 1 
      /if (!${Me.Buff[${SpellHoT}].ID}) /call cast ${SpellHoT} gem7 6s 
   } 
/return 

| ################## This will Check to see if I am Low on Mana 

Sub LOM 
   /if (${Me.CurrentHPs} < ${Math.Calc[${Me.MaxHPs}/2]}) /call CheckMyHPs 
   /if (${Me.CurrentMana} < ${Math.Calc[${Me.MaxMana}-5]} && ${Me.SpellReady[${SpellCanni}]}) /call cast ${SpellCanni} gem1 6s 
   /if (${Cannibalization} && ${Me.AltAbilityReady[47]} && ${Me.CurrentMana} < ${Math.Calc[${Me.MaxMana}-1200]} && ${Me.MaxHPs} > 2424) /call Cannibalization 

/return    

| ################## This will Check to see if I have SOW 

Sub SOW 
   /if (!${Me.Buff[Spirit of Eagle].ID} && !${Me.Buff[Flight of Eagles].ID} && !${Me.Buff[Spirit of Bih`Li].ID} && ${DoSow} && ${OutDoors}) { 
      /target pc ${M_Assist} 
      /call cast "Spirit of Bih`Li" gem5 17s 
   } 
/return 

| ################## Summon pet and buff with spells from SpellPetBuff array 

Sub Pet 
   /if (!${Me.Pet.ID} && ${SummonPet} && ${Spell[${SpellPet}].Mana}<=${Me.CurrentMana}) { 
      /call cast ${SpellPet} gem5 25s 
      /echo Buff ${Me.Pet.ID} with ${SpellPet} 
   } 
   /declare i int local 
   /for i 1 to ${SpellPetBuff.Size} 
   /if (!${Me.PetBuff[${SpellPetBuff[${i}]}]} && ${Spell[${SpellPetBuff[${i}]}].Mana}<=${Me.CurrentMana}) { 
      /pet target 
      /delay 2 
      /call cast ${SpellPetBuff[${i}]} gem5 9s          
    } 
   /next i 
/return 


|################### Casting Avatar on all melee classes in group 

Sub Cast_Avatar 
   /declare i int local 0 
   /for i 0 to ${Group} 
   /if (${Group[${i}].ID}) { 
      /if (${ATKBuffed${i}}==0) /if (${Group[${i}].Class.Name.Equal[Beastlord]} || ${Group[${i}].Class.Name.Equal[Shadow Knight]} || ${Group[${i}].Class.Name.Equal[Bard]} || ${Group[${i}].Class.Name.Equal[Ranger]} || ${Group[${i}].Class.Name.Equal[Rogue]} || ${Group[${i}].Class.Name.Equal[Paladin]} || ${Group[${i}].Class.Name.Equal[Monk]} || ${Group[${i}].Class.Name.Equal[Warrior]}) { 
         /target pc ${Group[${i}]} 
         /if (${Me.CurrentMana}>${Spell[${SpellATK}].Mana}) { 
            /tell ${Group[${i}]} ${SpellATK} is incomming to you ${Group[${i}]} , Stay in Range !!! 
            /call cast ${SpellATK} gem4 4s 
            /if (${Macro.Return.Equal["CAST_OUTOFRANGE"]}) /varset ATKBuffed${i} 200 
            /if (${Macro.Return.Equal["CAST_SUCCESS"]}) /varset ATKBuffed${i} ${AvatarDelay} 
            /return 
         } 
      } 
   } 
   /next i 
   /return 
| ################## Hungry 

Sub Event_Hungry 
   /if (${Engaged}) /return    
   /echo I am Hungry 
   /gsay I am summoning food... please hold pulls 
   /declare i int local 1 
   /for i 1 to 8 
      /autoinventory 
      /delay 1 
      /call cast ${SpellFOOD} gem5 5s 
   /next i 
   /autoinventory 
   /gsay GTG now 
/return 

| ################## Thirsty 

Sub Event_Thirsty 
   /if (${Engaged}) /return    
   /echo I am Thirsty    
   /gsay I am summoning drink... please hold pulls 
   /declare i int local 1 
   /for i 1 to 8 
      /autoinventory 
      /delay 1 
      /call cast ${SpellDRINK} gem5 5s 
   /next i 
   /autoinventory 
   /gsay GTG now 
/return 

| ##################  ENRAGE ON 

Sub Event_Enrageon 
    /if (${PetOn}) { 
       /echo Mob is ENRAGED! 
       /pet back off 
    } 
/return 

| ##################  ENRAGE OFF 

Sub Event_Enrageoff 
    /if (${PetOn}) { 
       /echo Mob is no longer Enraged! 
       /pet attack  
    } 
/return 

| ################## Outdoors 

Sub Event_OutDoor 
   /echo This is an indoor zone. Sorry. 
   /varset OutDoors FALSE 
/return 

| ##################  Zoning 

Sub Event_Zoning 
   /echo I zoned, time to shrink 
   /gsay Shrinks incomming Now 
   /delay 10 
   /call cast ${SpellSHRINK} gem5 5s 
   /call cast ${SpellSHRINK} gem5 5s 

   /varset TargetArray[1] ${Target.CleanName} 
   /varset TargetArray[2] ${Target.Level} 
   /varset TargetArray[3] ${Target.Name} 
   /varset TargetArray[4] ${Target.ID} 
   /varset CombatOn TRUE 
        
   /varset MobRooted FALSE 
   /varset MobMaloed FALSE 
   /varset MobSlowed FALSE 
   /varset PetOn FALSE 
   /varset MobDoTed FALSE 

/return 

| ##################  Group Invite 

Sub Event_Invited 
   /invite 
/return 

| ################## I Died 

Sub Event_ImDead 
   /echo Bummer ! 
   :Zone_Loop 
      /if ( ${Me.Bound.ID} != ${Zone.ID} ) /goto :Zone_Loop 
   /delay 5s 
   /consent group 
   /delay 5 
   /gsay Im ready to get rez. 
   /gsay I have consented group. 
   /call Wait4Rez 
   /delay 20 
   /call MemSpells 
   /if (${Me.State.Equal[Stand]}) /sit 

| We do some short meditate before we start again. 

   :Meditate 
      /delay 1s 
      /if (${Me.CurrentMana} < 300) /goto :Meditate 
   /return 

| ################## This part is taken from wait4res. 

Sub Wait4Rez 
   :waitforrez 
      /if (!${Window[ConfirmationDialogBox].Open}) { 
         /delay 5s ${Window[ConfirmationDialogBox].Open} 
         /goto :waitforrez 
      } 
      /if (${Window[ConfirmationDialogBox].Open}) /notify ConfirmationDialogBox Yes_Button  leftmouseup 
      :zonein 
         /delay 5 
         /squelch /target mycorpse 
         /delay 5 
         /if (${Target.CleanName.NotEqual[${Me}'s corpse]}) /goto :zonein 
         /if (${Target.CleanName.Equal[${Me}'s corpse]}) { 
            /delay 3s 
            /call Loot_Corpse 
         } else /goto :zonein 
   /return 

| #################  Looting Corpse 

Sub Loot_Corpse 
   /declare LootTotal int local 0 
   /declare LootSlot int local 
   /squelch /target mycorpse 
   /if (${Target.Type.NotEqual[CORPSE]} || !${Target.ID}) { 
      /echo ** Can't target my corpse. 
      /return 
   }    
   /corpse 
   /delay 1s 
   /loot 
   /delay 1s 
   /if (${Me.State.NotEqual[BIND]}) { 
      /echo ** Massive lag right now... Aborting looting. 
      /return 
   } 
   :LootLag 
      /if (${LootTotal}!=${Corpse.Items}) { 
         /varset LootTotal ${Corpse.Items} 
         /delay 5 
         /goto :LootLag 
      } 
   /for LootSlot 1 to ${LootTotal} 
   :LootItem 
      /itemnotify loot${LootSlot} rightmouseup 
      /delay 3 
      /if (${Corpse.Item[${LootSlot}].ID}) { 
         /delay 2 
         /goto :LootItem 
      } 
   /next LootSlot 
   /delay 5 
   /echo ** Done looting my corpse. 
   /notify LootWnd DoneButton leftmouseup 
   /return 

| ################# 
| ################# Tells n Hells 
| ################# 

Sub Event_Chat(string ChatType,string ChatSender,string ChatText) 

      /if (!${ChatType.Equal[GROUP]} && !${ChatType.Equal[TELL]}) /return 
        
| ################# Heal Requests 
  
     /if (${ChatText.Equal[heal]} || ${ChatText.Equal[heal me]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellHeal} is incomming !! 
             /call cast ${SpellHeal} 
             } 
      /return 
      } 

      /if (${ChatText.Equal[hot]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellHoT} is incomming !! 
             /call cast ${SpellHoT} 
             } 
      /return 
      } 

| ################# Mob Requests      

      /if (${ChatText.Equal[slow]} || ${ChatText.Equal[add]}) { 
         /assist ${ChatSender} 
         /if (${Target.Type.Equal[NPC]} && ${Target.Distance}<=100) { 
            /call cast ${SpellDebuff} gem3 6s 
            /call cast ${SpellSlow} gem2 6s 
            /tell ${ChatSender} %T is ${SpellDeBuff} and slowed with ${SpellSlow} 
            } 
      /return 
      } 

      /if (${ChatText.Equal[root]}) { 
         /assist ${ChatSender} 
         /if (${Target.Type.Equal[NPC]} && ${Target.Distance}<=100) { 
            /call cast ${SpellRoot} gem9 5s 
            /tell ${ChatSender} %T is Rooted with ${SpellRoot} 
            } 
      /return 
      } 


      /if (${ChatText.Equal[nuke]}) { 
         /assist ${ChatSender} 
         /if (${Target.Type.Equal[NPC]} && ${Target.Distance}<=100) { 
            /call cast ${SpellNuke} gem9  
            } 
      /return 
      } 
        
      /if (${ChatText.Equal[dot]}) { 
         /assist ${ChatSender} 
         /if (${Target.Type.Equal[NPC]} && ${Target.Distance}<=100) { 
            /call cast ${SpellDot} gem8 5s 
            } 
      /return 
      } 

      /if (${Engaged}) /return    

| ################# Buff Requests 

      /if (${ChatText.Equal[avatar]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellATK} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellATK} gem4 4s 
        }    
         /return 
      }  
    
      /if (${ChatText.Equal[PR]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellPR} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellPR} gem4 4s 
        }    
         /return 
      }  

      /if (${ChatText.Equal[haste]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellHASTE} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellHASTE} gem5 5s 
        }    
         /return 
      }  

      /if (${ChatText.Equal[focus]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellFOCUS} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellFOCUS} gem5 5s 
        }    
         /return 
      }  

      /if (${ChatText.Equal[cha]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellCHA} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellCHA} gem5 5s 
        }    
         /return 
      }  

      /if (${ChatText.Equal[lev]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellLEV} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellLEV} gem5 5s 
        }    
         /return 
      }  

      /if (${ChatText.Equal[sow]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellSOW} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellSOW} gem5 5s 
        }    
         /return 
      }  
      /if (${ChatText.Equal[grow]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellGROW} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellGROW} gem5 5s 
        }    
         /return 
      } 
  
      /if (${ChatText.Equal[shrink]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellSHRINK} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellSHRINK} gem5 5s 
        }    
         /return 
      }  


      /if (${ChatText.Equal[see]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellSEE} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellSEE} gem5 5s 
        }    
         /return 
      } 


      /if (${ChatText.Equal[str]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellSTR} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellSTR} gem5 5s 
        }    
         /return 
      }  

      /if (${ChatText.Equal[dex]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellDEX} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellDEX} gem5 5s 
        }    
         /return 
      }  

      /if (${ChatText.Equal[sta]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellSTA} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellSTA} gem5 5s 
        }    
         /return 
      }  

      /if (${ChatText.Equal[agi]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellAGI} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellAGI} gem5 5s 
        }    
         /return 
      }  

      /if (${ChatText.Equal[regen]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellREGEN} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellREGEN} gem5 5s 
        }    
         /return 
      }  

      /if (${ChatText.Equal[pe]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellPE} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellPE} gem5 5s 
        }    
         /return 
      } 
      
      /if (${ChatText.Equal[INV]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellINV} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellINV} gem5 5s 
        }    
         /return 
      } 
| ################# Follow me 

 /if (${ChatText.Equal[Follow me]} || ${ChatText.Equal[Follow]}) { 
    /delay 5 
    /if (!${Spawn[${ChatSender}].ID}) { 
       /e ${ChatSender}  is not in zone for me to follow! 
       /return 
    } 
    /varset follname ${ChatSender}  
    /varset following 1 
    /tell ${ChatSender} I am following you!!! 
    /if ( ${Me.Mount.ID} ) /dismount 
       :targetfoll 
          /target pc ${follname} 
          /delay 1s ${Target.Name.Equal[${follname}]} 
          /if (${Target.Name.Equal[${follname}]}) { 
          /goto :Loop 
    } else /goto :targetfoll 

    :Loop 
    /face fast 
    /if (${Target.Distance}>40) /keypress forward hold 
    /if (${Target.Distance}<39) /keypress back 
    /if (!${Target.ID}) /varset following 0 
    /doevents 
    /if ((${Target.Name.Equal[${follname}]})&&(${following}>0)) { 
       /goto :Loop 
    } else { 
       /keypress forward 
       /keypress back 
    } 
 } 


| ################# Stop Following me 

 /if (${ChatText.Equal[End follow]} || ${ChatText.Equal[stop]}) { 
    /varset following 0 
    /keypress forward 
    /keypress back 
    /timed 50 /face pc ${follname} 
    /tell ${ChatSender} I Stopped following you!!! 
    /return  
 } 

| ################# Single Rebuff 

/if (${ChatText.Equal[buff me]}) { 
   /echo Request for Single Buff 
   /declare i int local 1 
   /for i 1 to ${SpellSingleBuff.Size} 
   /if (${Spell[${SpellSingleBuff[${i}]}].Mana} > ${Me.CurrentMana}) { 
      /tell ${ChatSender} ${ChatSender} Sorry I am getting LOM        
      /echo DAMN.. LOM... Cannibalizing to rebuff 
       :Hold_Single_Rebuff 
          /Call LOM 
          /if (${Spell[${SpellSingleBuff[${i}]}].Mana} > ${Me.CurrentMana}) { 
             /goto :Hold_Single_Rebuff              
           } 
    } 
   /target pc ${ChatSender} 
   /delay 3 
   /echo *** Hang on ! Buffing ${SpellSingleBuff[${i}]} 
   /tell ${ChatSender} Buffing ${SpellSingleBuff[${i}]} now... 
   /call cast ${SpellSingleBuff[${i}]} gem5 5s      
   /next i 
   /return 
} 

| ################# Single Rebuff other 

 /if (${ChatText.Equal[buff]}) { 
    /echo Request for Single Buff other 
    /assist ${ChatSender} 
    /declare i int local 1 
    /for i 1 to ${SpellSingleBuff.Size} 
    /if (${Spell[${SpellSingleBuff[${i}]}].Mana} > ${Me.CurrentMana}) { 
       /tell ${ChatSender} ${ChatSender} Sorry I am getting LOM        
       /echo DAMN.. LOM... Cannibalizing to rebuff 
       :Hold_Single_Rebuff 
          /Call LOM 
          /if (${Spell[${SpellSingleBuff[${i}]}].Mana} > ${Me.CurrentMana}) { 
             /goto :Hold_Single_Rebuff              
           } 
    } 
    /delay 3 
    /echo *** Hang on ! Rebuffing ${SpellSingleBuff[${i}]} 
    /tell ${ChatSender} Buffing ${SpellSingleBuff[${i}]} now... 
    /call cast ${SpellSingleBuff[${i}]} gem5 7s      
    /next i 
    /return 
 } 

| ################# Group Rebuff other group 

 /if (${ChatText.Equal[buff them]}) { 
    /assist ${ChatSender} 
    /declare i int local 1 
    /for i 1 to ${SpellGrpBuff.Size}        
    /if (${Spell[${SpellGrpBuff[${i}]}].Mana} > ${Me.CurrentMana}) { 
       /tell ${ChatSender} ${ChatSender}, Sorry I am getting LOM                  
       /echo DAMN.. LOM... Cannibalizing to rebuff 
       :Hold_Group_Rebuff 
          /Call LOM 
          /if (${Spell[${SpellGrpBuff[${i}]}].Mana} > ${Me.CurrentMana}) { 
          /goto :Hold_Group_Rebuff              
          } 
    } 
    /delay 3 
    /echo *** Hang on ! Rebuffing ${SpellGrpBuff[${i}]} 
    /tell ${ChatSender} Buffing ${SpellGrpBuff[${i}]} now... 
    /call cast ${SpellGrpBuff[${i}]} gem5 7s      
    /next i 
    /return 
 } 


| ################# Other Pet Buffing 

 /if (${ChatText.Equal[buff pet]}) { 
    /echo Request for Pet Buffs 
    /target id ${Spawn[pc ${ChatSender}].Pet.ID} 
    /delay 5 
    /tell ${ChatSender} Targetting your pet, %T for buffs... 
    /declare i int local 1 
    /for i 1 to ${SpellPetBuffo.Size} 
    /if (${Spell[${SpellPetBuffo[${i}]}].Mana} > ${Me.CurrentMana}) { 
       /tell ${ChatSender} ${ChatSender} Sorry I am getting LOM 
       /echo DAMN.. LOM... Cannibalizing to rebuff 
       :Hold_Pet_Rebuff 
          /Call LOM 
          /if (${Spell[${SpellPetBuffo[${i}]}].Mana} > ${Me.CurrentMana}) { 
             /goto :Hold_Pet_Rebuff 
          }        
    } 
    /delay 5 
    /echo *** Hang on ! Rebuffing ${SpellPetBuffo[${i}]} 
    /tell ${ChatSender} buffing ${SpellPetBuffo[${i}]} now... 
    /call cast ${SpellPetBuffo[${i}]} gem5 5s      
    /next i 
    /return 
 } 

| ################### Go Home 

 /if (${ChatText.Equal[gate now]} && ${ChatType.Equal[TELL]}) { 
    /call cast ${SpellGATE} gem9  
    /return 
    } 

 /if (${ChatType.Equal[TELL]}) { 
    /1 [${ChatSender}]:${ChatText} 
    /vtell ${ChatController} 001 
    /return 
    } 


/return 



| ################### This will check whenever the player is changing any variable via /echo 

Sub Event_ToggleVariable(string Line, string Command, string Command2) 

   /if (${Command.Equal[malo]} && ${DoMalo}==0) { 
      /varset DoMalo TRUE 
      /echo Do Malo:   ${DoMalo} 
   } else /if (${Command.Equal[malo]}) { 
      /varset DoMalo FALSE 
      /echo Do Malo:   ${DoMalo} 
   } 

   /if (${Command.Equal[slow]} && ${DoSlow}==0) { 
      /varset DoSlow TRUE 
      /echo Do Slow:   ${DoSlow} 
   } else /if (${Command.Equal[slow]}) { 
      /varset DoSlow FALSE 
      /echo Do Slow:   ${DoSlow} 
   } 
    
   /if (${Command.Equal[fastslow]} && ${FastSlow}==0) { 
      /varset FastSlow TRUE 
      /echo Do Fast Slow:   ${FastSlow} 
   } else /if (${Command.Equal[fastslow]}) { 
      /varset FastSlow FALSE 
      /echo Do Fast Slow:   ${FastSlow} 
   } 
    
   /if (${Command.Equal[root]} && ${DoRoot}==0) { 
      /varset DoRoot TRUE 
      /echo Do Root:   ${DoRoot} 
   } else /if (${Command.Equal[root]}) { 
      /varset DoRoot FALSE 
      /echo Do Root:   ${DoRoot} 
   }    
    
   /if (${Command.Equal[pet]} && ${SummonPet}==0) { 
      /varset SummonPet TRUE 
      /echo Summon Pet:   ${SummonPet} 
   } else /if (${Command.Equal[pet]}) { 
      /varset SummonPet FALSE 
      /echo Summon Pet:   ${SummonPet} 
   }    
    
   /if (${Command.Equal[dot]} && ${DoDoT}==0) { 
      /varset DoDoT TRUE 
      /echo Do DoT:   ${DoDoT} 
   } else /if (${Command.Equal[dot]}) { 
      /varset DoDoT FALSE 
      /echo Do DoT:   ${DoDoT} 
   } 
    
   /if (${Command.Equal[buffs]} && ${DoBuffs}==0) { 
      /varset DoBuffs TRUE 
      /echo Do Buffs:   ${DoBuffs} 
   } else /if (${Command.Equal[buffs]}) { 
      /varset DoBuffs FALSE 
      /echo Do Buffs:   ${DoBuffs} 
   } 
    
   /if (${Command.Equal[sow]} && ${DoSow}==0) { 
      /varset DoSow TRUE 
      /echo Do Sow:   ${DoSow} 
   } else /if (${Command.Equal[sow]}) { 
      /varset DoSow FALSE 
      /echo Do Sow:   ${DoSow} 
   } 
    
   /if (${Command.Equal[nuke]} && ${DoNuke}==0) { 
      /varset DoNuke TRUE 
      /echo Do Nuke:   ${DoNuke} 
   } else /if (${Command.Equal[nuke]}) { 
      /varset DoNuke FALSE 
      /echo Do Nuke:   ${DoNuke} 
   } 
    
   /if (${Command.Equal[heal]} && ${DoHeal}==0) { 
      /varset DoHeal TRUE 
      /echo Do Heal:   ${DoNuke} 
   } else /if (${Command.Equal[heal]}) { 
      /varset DoHeal FALSE 
      /echo Do Heal:   ${DoNuke} 
   } 

   /if (${Command.Equal[verbose]} && ${Verbose}==0) { 
      /varset Verbose TRUE 
      /echo Verbose:   ${Verbose} 
   } else /if (${Command.Equal[verbose]}) { 
      /varset Verbose FALSE 
      /echo Verbose:   ${Verbose} 
   } 

   /if (${Command.Equal[buffpet]} && ${BuffPet}==0) { 
      /varset BuffPet TRUE 
      /echo Buff Pet:   ${BuffPet} 
   } else /if (${Command.Equal[buffpet]}) { 
      /varset BuffPet FALSE 
      /echo Buff Pet:   ${BuffPet} 
   } 
    
   /if (${Command.Equal[assistat]}) { 
      /varset AssistAt ${Command2} 
      /echo Assisting at range:   ${AssistAt} _ (Longer range then 100 is futile) 
   } 
    
   /if (${Command.Equal[dotat]}) { 
      /varset CastDoTat ${Command2} 
      /echo Casting ${SpellDoT} at ${CastDoTat}% 
   } 
    
   /if (${Command.Equal[rootat]}) { 
      /varset Rootat ${Command2} 
      /echo Rooting Mobs at ${Rootat}% 
   } 
    
   /if (${Command.Equal[nukeat]}) { 
      /varset NukeAt ${Command2} 
      /echo Starting to Nuke Mobs at ${NukeAt}% 
   } 
    
   /if (${Command.Equal[combatat]}) { 
      /varset CombatAt ${Command2} 
      /echo Initiate Combat at ${CombatAt}% (Malo / Slow) 
   } 
    
   /if (${Command.Equal[healtankat]}) { 
      /varset TankHeal ${Command2} 
      /echo Healing ${M_Assist} at ${TankHeal}% 
   } 
    
   /if (${Command.Equal[healmeleeat]}) { 
      /varset MeleeHeals ${Command2} 
      /echo Healing all Melee classes at ${MeleeHeals}% 
   } 
    
   /if (${Command.Equal[healcastersat]}) { 
      /varset CasterHeals ${Command2} 
      /echo Healing all Caster classes at ${CasterHeals}% 
   } 
    
   /if (${Command.Equal[assist]}) { 
      /varset M_Assist ${Command2} 

      /sq /target pc ${M_Assist} 
      /if (!${Target.ID}) { 
         /echo ${M_Assist} is not here dude ! 
         /return 
      } 
        
      /echo I will assist:   ${M_Assist} 
   } 
    
   /if (${Command.Equal[healat]}) { 
      /varset HealGRPat ${Command2} 
      /echo Healing any group member below ${HealGRPat}% HPs 
   } 

   /if (${Command.Equal[Show]}) { 
    
      /echo --------------------------- 
      /echo Do Malo:..............${DoMalo} - Casting at: ${CombatAt}% (Initiate Combat*, higher then 99 is no good) 
      /echo Do Slow:..............${DoSlow} - Casting at: ${CombatAt}% (Initiate Combat*, higher then 99 is no good) 
      /echo Do Fastslow:......${FastSlow} - (Will only try to slow once!) 
      /echo Do Nuke:.............${DoNuke} - Casting at: ${NukeAt}% (Will chain nuke mob to death) 
      /echo Do Dot:................${DoDoT} - Casting at: ${CastDoTat}% 
      /echo Do Pet:................${SummonPet} 
      /echo Do Buffs:.............${DoBuffs} 
      /echo Do Root:..............${DoRoot} - Casting at: ${Rootat}% 
      /echo Do Sow:...............${DoSow} 
      /echo Do Heal:..............${DoHeal} 
      /echo Buff Pet:.............${BuffPet} 
      /echo --------------------------- 
      /echo Assist range: ${AssistAt} 
      /echo Assisting: ${M_Assist} 
      /echo Healing Casters: ${CasterHeals}% Melees: ${MeleeHeals}% 
      /echo ${M_Assist} get heals at ${TankHeal} 
      /echo Initiate Combat: ${CombatAt}% 
      /echo Verbose: ${Verbose} 
      /echo 
      /echo help - Will show help to set variables. 
        
   } 
    
   /if (${Command.Equal[help]}) { 
      /echo ___ Shaman Do Stuff Script ___ 
      /echo 
      /echo Commands that will turn ON or OFF 
      /echo malo, slow, fastslow, root, pet, dot, buffs, sow, nuke, heal, buffpet 
      /echo 
      /echo fastslow will NOT check if the slow is landed or not. Good to have on when you skip maloing. 
      /echo Commands to change values, ie: assistat 50 (Will start the combat routine when mob is in range 50) 
      /echo assisat <range> - Most spells don't go longer then 100 
      /echo combatat <% hps> - Initiate Combat when mob is at % HPs 
      /echo healtankat <% hps> 
      /echo healmeeleat <% hps> 
      /echo healcastersat <% hps> 
      /echo assist <PC Name> 
   } 
    
/return