MacroQuest64

Need to talk about MacroQuest to other MacroQuest users?
https://mq64.org/phpBB3/

Shambot v1.0c

https://mq64.org/phpBB3/viewtopic.php?t=9803

Page 5 of 6

Posted: Tue May 17, 2005 8:25 am
by A_Druid_00
The advbot code stores each mob in an array and uses Macro.Runtime (because you can't have an array of timers) to determine when a slow/malo/etc is scheduled to wear off in order to keep adds debuffed. I bet it's not the only way to handle add debuffing, maybe not even the best way, but it's the only macro out there that I've seen adress add debuffing at all.

Posted: Tue May 17, 2005 9:27 am
by vstratos
Tried Advbot out last night. Seems to do everything I throw at it. I like the ini support.

Posted: Tue May 17, 2005 9:47 am
by A_Druid_00
Yeah, I was trying to pirate the MDL debuffing code and integrate it into RaidDruid before I quit, but I never got it implemented right. It's by far the coolest piece of coding in advbot. Works great for short/medium duration debuffs and whatnot.

I never liked using timers for buffing though, because MQ2 (Maybe it's actually EQ) tends to have issues with timers running faster than they should, and it shows up quite glaringly on long duration buffs like 9/focus/etc. If you let it run long enough, you end up re-buffing way before the buffs are scheduled to wear off. Just seemed wasteful to handle it like that. That's why I took BuffBeg and evolved it into an all encompassing generic buff requesting inc to take care of buffs as needed. Used to see it all the time with AltAbilityReady too on things like SotW/MGB/etc.

Posted: Tue May 17, 2005 3:03 pm
by Everdead
Should be able to use /tell shaman slow and haver the add targeted and he should slow. But also just switching targets will get adds slowed usualy. I need to put out an updated version this has tons of holes but I have been hall busy with new guild and lvling alt char to raid lol.

Posted: Sun May 22, 2005 8:06 pm
by kool23
could some 1 pls post there working macro of this please.ive had so many problems with this macro it isnt funny.as i posted earlier about this macro on healing it still doesnt work for me after i got reply i tired what he said and it still doesnt work.i added the group changes ect those work but now it doesnt cast pet right just keeps casting on me the pet buffs its mems pet spell but when it pops it unmems it then casts on me and there is all kinds of other bugs also i just give up on it trying to fix it.

so could some 1 pls post a current working macro of this pls and ill see if it will work right

id really like to have this macro working for my sham i ran it with bugs b4 now its way off unrunable.oh and says that it cant find talisman of alacrity in my spell book and its there =/ all kinds of things rong with manly healing bugs that will not fix have tried of lota different things from different people and none seems to work. it works fine not fighting but it constantly assisting in combat

i would be very thankfully for a current macro of this that works right...

hate to sound like a whinner but i dont know what else to do about this its been months it wont work right PM to me or something pls

Posted: Mon May 23, 2005 12:25 pm
by DigitalMocking
Kool23, I'll be glad to post my shambot code, but to be honest, this macro has got a lot of bugs in it. I wound up giving up on it and switching over to fearless' version of advbot for my shaman, which works great.

This shambot code works fine, but the healing routines are still wonky. I would have to call for heals still.

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#*#" 
#Event   RegenDrop	      "#*#You have stopped regenerating#*#"
#Event   FocusDrop        "#*#Your focus fades#*#"
#Event   StaDrop          "#*#Your endurance fades#*#"

#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 
| ########### 

/declare NumberOfBuffs int outer 1 
/declare MyBuffs[${NumberOfBuffs}] string outer 
| ########### Default  Channel, Controller 

   /declare CChannel      outer "secrat_channel" 
   /declare ChatController outer "your-ma"
  
| ########### Your Spell List - update as needed  

   /declare SpellSlow          outer "Turgur's Insects" 
   /declare SpellDoT           outer "Blood of Saryrn" 
   /declare SpellDoTD          outer "Breath of Ultor"
   /declare SpellPet           outer "True Spirit" 
   /declare SpellDeBuff        outer "Malosini" 
   /declare SpellCanni         outer "Cannibalize IV" 

   /declare SpellHoT           outer "Quiescence" 
   /declare SpellHeal          outer "Tnarg`s Mending" 
   /declare SpellRoot          outer "Petrifying Earth" 
   /declare SpellNuke          outer "Velium Strike" 

   /declare SpellATK           outer "Ferine Avatar" 
   /declare SpellHASTE         outer "Celerity" 
   /declare SpellFOCUS         outer "Focus of Soul" 
   /declare SpellCHA           outer "Spirit of Snake" 
   /declare SpellDEX           outer "Spirit Monkey" 
   /declare SpellSTR           outer "Spirit Strength" 
   /declare SpellAGI           outer "Agility of the Wrulan" 
   /declare SpellSTA           outer "Endurance of the Boar" 
   /declare SpellREGEN         outer "Replenishment" 
   /declare SpellPE            outer "" 
   /declare SpellPR            outer "Talisman of Epuration" 

   /declare SpellSOW           outer "Spirit of Wolf" 
   /declare SpellLEV           outer "Levitation" 
   /declare SpellINV           outer "Invisibility" 
   /declare SpellSHRINK        outer "Tiny Terror" 
   /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 "" 


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

   /declare SpellPetBuff[2] string outer 
   /varset SpellPetBuff[1] "Celerity" 
   /varset SpellPetBuff[2] "Ferine Avatar" 
|   /varset SpellPetBuff[3] "Focus of Soul" 
|   /varset SpellPetBuff[4] "Endurance of the Boar"

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

   /declare SpellGrpBuff[6] string outer 
   /varset SpellGrpBuff[1] "Focus of the Seventh" 
   /varset SpellGrpBuff[2] "Talisman of the Wrulan" 
   /varset SpellGrpBuff[3] "Acumen of Dar Khura" 
   /varset SpellGrpBuff[4] "Talisman of the Diaku"
   /varset SpellGrpBuff[5] "Talisman of the Brute" 
   /varset SpellGrpBuff[6] "Talisman of Epuration"

| ############ Single Buff List.    

   /declare SpellSingleBuff[6] string outer 
   /varset SpellSingleBuff[1] "Replenishment" 
   /varset SpellSingleBuff[2] "Focus of Soul" 
   /varset SpellSingleBuff[3] "Celerity" 
   /varset SpellSingleBuff[4] "Spirit Strength" 
   /varset SpellSingleBuff[5] "Endurance of the Boar" 
   /varset SpellSingleBuff[6] ${SpellAGI} 

| ############ Self Buff List.    

   /declare SpellSelfBuff[4] string outer 
   /varset SpellSelfBuff[1] "Replenishment" 
   /varset SpellSelfBuff[2] "Focus of Soul" 
   /varset SpellSelfBuff[3] "Endurance of the Boar" 
   /varset SpellSelfBuff[4] "Form of the Great Bear" 
|   /varset SpellSelfBuff[5] "Spirit of Wolf"
   
| ############ Combat Variables 

   /declare AssistAt      int   outer 98 
   /declare CombatAt      int   outer 98

   /declare CastDoTat     int   outer 70 
   /declare DotMana       int   outer 40 
   /declare CastDoTDat    int   outer 90 
   /declare DotDMana      int   outer 50 

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

   /declare NukeAt        int   outer 70 
   /declare NukeMana      int   outer 50 

   /declare SitAt         int   outer 100 
   /declare BuffMana      int   outer 30 
   /declare MinMana       int   outer 15 
   
   /declare following     int   outer 0 
   /declare follname      string outer NULL 

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

   /declare CasterHeals   int   outer 30 
   /declare MeleeHeals    int   outer 50 
   /declare TankHeal      int   outer 25 

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

   /declare DoMalo             outer FALSE    
   /declare DoSlow             outer FALSE
   /declare FastSlow           outer FALSE 
   /declare DoRoot             outer FALSE
   /declare DoShrink           outer FALSE
   /declare SummonPet          outer TRUE
   /declare BuffPet            outer TRUE
   /declare HaveMount          outer FALSE  
   /declare DoDoT              outer TRUE
   /declare DoDoTD             outer FALSE
   /declare DoBuffs            outer FALSE
   /declare DoNuke             outer FALSE 
   /declare DoHeal             outer TRUE
   /declare Cannibalization    outer FALSE
   /declare Verbose            outer FALSE

   | 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 MobDoTDed      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 ${M_Assist} 
    /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100 && ${DoShrink}) { 
       /ECHO ${SpellSHRINK} is incomming to you 
       /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} && ${Target.Distance}>=100) /sit 
   
   |- Monsters are here!  Stand up!
   /if ( ${Me.State.Equal[Sit]} && ${Target.Distance}<=120) /stand
   
   |- Summon Mount if outdoors 
   /if (!${Me.Mount.ID} && ${OutDoors} && ${HaveMount}) /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 
   
   |- Call Self Buff Loop
   /if (!${Engaged}) /call Self_Buff
    
   |- Pet 
   /if (!${Engaged}) /call PET 
    
   |- 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} && ${Target.Distance}>=100) /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} && !${PetOn} && ${Target.ID}==${TargetArray[4]}) { 
      /pet attack 
      /varset PetOn TRUE 
      /varset Engaged TRUE  
   } 
   /if (${CombatOn} && !${MobMaloed} && ${DoMalo} && ${Target.ID}==${TargetArray[4]}) /call DeBuff 
   /if (${CombatOn} && !${MobSlowed} && ${DoSlow} && ${Target.ID}==${TargetArray[4]}) /call Slow 

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

   /if (${CombatOn} && ${DoDoT} && !${MobDoTed} && ${Me.PctMana}>=${DoTMana} && ${Target.PctHPs}<=${CastDoTat}) { 
      /call cast ${SpellDoT} gem8 
      /varset MobDoTed TRUE 
   } 

   /if (${CombatOn} && ${DoDoTD} && !${MobDoTDed} && ${Me.PctMana}>=${DoTDMana} && ${Target.PctHPs}<=${CastDoTDat}) { 
      /call cast ${SpellDoTD} gem8 
      /varset MobDoTDed 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 *** Crap! LOM, Can't 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 Self_Buff
   /declare i int local 1 
   /for i 1 to ${SpellSelfBuff.Size} 
   /if (!${Me.Buff[${SpellSelfBuff[${i}]}].ID}) { 
     /if (${Spell[${SpellSelfBuff[${i}]}].Mana} > ${Me.CurrentMana}) { 
         :Hold_Self_Rebuff 
            /Call LOM 
            /if (${Spell[${SpellSelfBuff[${i}]}].Mana} > ${Me.CurrentMana}) { 
               /goto :Hold_Self_Rebuff              
             } 
      } 
     /target myself
     /delay 1s 
     /call cast ${SpellSelfBuff[${i}]} gem5 5s      
   }
   /next i
/return

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.Member[${i}].Class.Name.Equal[Cleric]} || ${Group.Member[${i}].Class.Name.Equal[Druid]} || ${Group.Member[${i}].Class.Name.Equal[Wizard]} || ${Group.Member[${i}].Class.Name.Equal[Magician]} || ${Group.Member[${i}].Class.Name.Equal[Necromancer]} || ${Group.Member[${i}].Class.Name.Equal[Enchanter]}) /if (${Group.Member[${i}].PctHPs}<=${CasterHeals}) { 
      /target pc ${Group.Member[${i}]} 
      /delay 1
      /if (${Me.CurrentMana}<${Spell[${SpellHeal}].Mana}) { 
      } else /if (${Target.Distance}<=100) { 
         /if (${Verbose}) /gsay *** ${SpellHeal} on %T 
         /call cast ${SpellHeal} gem6 4s 
      } 
   } 
    
   /if (${Group.Member[${i}].Class.Name.Equal[Warrior]} || ${Group.Member[${i}].Class.Name.Equal[Monk]} || ${Group.Member[${i}].Class.Name.Equal[Rouge]} || ${Group.Member[${i}].Class.Name.Equal[Ranger]} || ${Group.Member[${i}].Class.Name.Equal[Beast]} || ${Group.Member[${i}].Class.Name.Equal[Shadow Knight]} || ${Group.Member[${i}].Class.Name.Equal[Paladin]}) /if (${Group.Member[${i}].PctHPs}<=${MeleeHeals} && ${Group.Member[${i}].Name.NotEqual[${M_Assist}]}) { 
      /target pc ${Group.Member[${i}]}
      /delay 1 
      /if (${Me.CurrentMana}<${Spell[${SpellHeal}].Mana}) { 
      } else /if (${Target.Distance}<=100) { 
         /if (${Verbose}) /gsay *** ${SpellHeal} on %T 
         /call cast ${SpellHeal} gem6 4s 
      } 
   } 

   /if (${Group.Member[${i}].Name.Equal[${M_Assist}]} && ${Group.Member[${i}].PctHPs}<=${TankHeal}) { 
      /target pc ${Group.Member[${i}]} 
      /delay 1
      /if (${Me.CurrentMana}<${Spell[${SpellHeal}].Mana}) { 
      } 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 *** I don't have mana to cast ${SpellHoT} 
   } else { 
      /if (${Me.CurrentHPs}>1500) /return
      /target myself 
      /delay 3 
      /if (!${Me.Buff[${SpellHoT}].ID}) /call cast ${SpellHoT} gem7 3s 
   } 
/return 

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

Sub LOM 
   /if (${Me.CurrentHPs} < 800 ) /return
   /if (${Me.CurrentHPs} < ${Math.Calc[${Me.MaxHPs}/2]}) /call CheckMyHPs 
   /if (${Me.CurrentMana} < ${Math.Calc[${Me.MaxMana}-500]} && ${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    

| ################## 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 
   /if (${Engaged}) /return
   /for i 0 to ${Group} 
   /if (${Group.Member[${i}].ID}) { 
      /if (${ATKBuffed${i}}==0) /if (${Group.Member[${i}].Class.Name.Equal[Beastlord]} || ${Group.Member[${i}].Class.Name.Equal[Shadow Knight]} || ${Group.Member[${i}].Class.Name.Equal[Bard]} || ${Group.Member[${i}].Class.Name.Equal[Ranger]} || ${Group.Member[${i}].Class.Name.Equal[Rogue]} || ${Group.Member[${i}].Class.Name.Equal[Paladin]} || ${Group.Member[${i}].Class.Name.Equal[Monk]} || ${Group.Member[${i}].Class.Name.Equal[Warrior]}) { 
         /target pc ${Group.Member[${i}]} 
         /if (${Me.CurrentMana}>${Spell[${SpellATK}].Mana}) { 
            /tell ${Group.Member[${i}]} ${SpellATK} is incomming to you ${Group.Member[${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 

   /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} 
         /delay 3
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellHeal} is incomming !! 
             /call cast ${SpellHeal} 
             } 
      /return 
      } 

      /if (${ChatText.Equal[hot]}) { 
         /target pc ${ChatSender}
         /delay 3
         /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 8s 
						/delay 25
            /call cast ${SpellSlow} gem2 8s 
            /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 
      } 

| ################# 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 3 
    /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 3 
    /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

Posted: Mon May 23, 2005 2:41 pm
by dedpoet
My shaman bot is based on the code that ranma's is based on (hubba's), so it's very similar. Mine doesn't differentiate between classes, and is mainly used when duoing with a monk. It was also specifically written to use a heal over time as a main heal, patch healing when hp gets a bit lower. To do that effectively, it stores the time of the heal in an array slot for that group member, and won't stick another HoT on them until the first one is off. I use 70 for HealAt and 40-ish for PatchAt, depending on what I'm fighting.

If you're lower level, your patch and main heals are probably the same, so just set HealAt high and turn patch healing off. If you're main healing a real tank, you'll probably want to set HealAt to something like 85 or 90, and PatchAt to something like 70. This heal setup is flexible enough to handle anything I can tank with my monk.

You'll need to declare a couple extra things up top:

Code: Select all

/declare PatchAt       int     outer 40
/declare DoPatch      outer TRUE

| This can be the same as your heal spell, or use a HoT for heal and something faster for patching
/declare SpellPatch   outer "Yoppa's Mending"

| The array to store when a group member got healed
/declare GroupHealList[5] int outer 0

| This is the duration of heal spell, in seconds.  Set to 0 if Main heal is not a HoT
/declare HealSpellDuration outer 36
Here is the healing Sub. Change "gem2" to wherever you have your heal spell.

Code: Select all

Sub Check_grpHPs
   | For group members
/if (${DoPatch}==1) /call Patch
/if (${DoHeal}==1) {
   /declare g int local 1
   /for g 1 to ${Group.Members}
      /if (${Group.Member[${g}].ID} && ${Group.Member[${g}].PctHPs}<=${HealAt}) {
         /if (${Macro.RunTime}>=${GroupHealList[${g}]}) {
            /if (${Me.CurrentMana}<${Spell[${SpellHeal}].Mana}) {
               /echo *** Insufficient mana to Heal ${Group.Member[${g}]}
            } else /if (${Target.Distance}<=100) {
             /squelch /target clear
             /delay 3
   	       /target PC ${Group.Member[${g}]}
             /delay 3
      	       /if (${Verbose}==1) /gsay HoT to %T
   	       /call cast ${SpellHeal} gem2 4s
	       /varset GroupHealList[${g}] ${Math.Calc[${Macro.RunTime}+${HealSpellDuration}]}
            }
         } else {
	    /if (${DoPatch}==1) /call Patch
	 }
      }
   /next g
}
/return
You'll want this too. Again, change "gem1" to wherever your patch heal spell is.

Code: Select all

Sub Patch
   /declare g int local 1
   /for g 1 to ${Group.Members}
      /if (${Group.Member[${g}].ID} && ${Group.Member[${g}].PctHPs}<=${PatchAt}) {
         /if (${Me.CurrentMana}<${Spell[${SpellPatch}].Mana}) {
            /echo *** Insufficient mana to Heal ${Group.Member[${g}]}
         } else /if (${Target.Distance}<=100) {
          /squelch /target clear
          /delay 3
   	    /target PC ${Group.Member[${g}]}
          /delay 3
      	    /if (${Verbose}==1) /gsay Patch heal to %T
   	    /call cast ${SpellPatch} gem1 3s
         }
      }
   /next g
   /return

Posted: Mon May 23, 2005 3:20 pm
by kool23
thanks for the replys will try this out,if this dont work for me guess i will be forced to try advbot out looked at it looks lil to complex to me on what i gotta do to get it working but ill give it a shot if this dont work.

thanks again,

HELP PLS

Posted: Fri May 27, 2005 5:29 pm
by kool23
ok iam useing last moded macro posted cause i like some of the fetures in it,but it was buggy as hell for me i finnally got it workable but have some issues atm.and could use some help from some experanced macroers

my biggest problem is my get target sub iam always assisting and its screwing up heals and other stuff ive tried putting in /target clear ect but its still screwing up was wondering if there is anyway to get it to assist one time only for that mob,i think what iam asking is to complex for me to understand i beleave or tottaly easy lol hers what i got on get target

Code: Select all

Sub GetTarget 
   /assist ${M_Assist}
   /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

Code: Select all

:Main_Loop 


   |- Check for Standing if less than sitat then sit 
   /if ( ${Me.State.Equal[Stand]} && ${Me.PctMana}<${SitAt} && ${Target.Distance}>=100) /sit 
    
   |- Monsters are here!  Stand up! 
   /if ( ${Me.State.Equal[Sit]} && ${Target.Distance}<=120) /stand 
    
   |- Summon Mount if outdoors 
   /if (!${Me.Mount.ID} && ${OutDoors} && ${HaveMount}) /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

   |- Check for mobs and do combat stuff
   /Call GetTarget
   /if (${CombatOn}) /call Combat 
 
   |- Group HoT 
   /call Check_grpHPs 
   |- Call Self Buff Loop

   |- Group Heals
   /call Check_grpHPs2
 
   /if (!${Engaged}) /call Self_Buff 
    
   |- Pet 
   /if (!${Engaged}) /call PET 

   |- Check for Standing if less than sitat then sit 
   /if ( ${Me.State.Equal[Stand]} && ${Me.PctMana}<${SitAt} && ${Target.Distance}>=100) /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 HoT 
   /call Check_grpHPs

   |- Group Heals
   /call Check_grpHPs2

   /goto :Main_Loop 
/return

Code: Select all

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

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

   /if (${CombatOn} && ${DoDoT} && !${MobDoTed} && ${Me.PctMana}>=${DoTMana} && ${Target.PctHPs}<=${CastDoTat}) { 
      /call cast ${SpellDoT} gem8 
      /varset MobDoTed TRUE 
   } 

   /if (${CombatOn} && ${DoDoTD} && !${MobDoTDed} && ${Me.PctMana}>=${DoTDMana} && ${Target.PctHPs}<=${CastDoTDat}) { 
      /call cast ${SpellDoTD} gem8 
      /varset MobDoTDed 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
 
   /target clear
  } 
/return
i still want him to slow and stuff he just assisting ma to much its screwing up heals mostly and other things cause he constantly assisting

any help suggestions welcomed thanks in advance

Posted: Fri May 27, 2005 10:59 pm
by Everdead
shrug I will repost mine here shortly I got a little upset and removed mine lol. So I will repost it here soonish.

Posted: Sat May 28, 2005 12:10 am
by Spanky90
Was wondering if anyone has a Working shaman bot, i have tried to fix the ones posted here but i keep having issues. If anyone could post one that works fairly well it would be greatly appreciated.



Thanks
Spanky90

Posted: Wed Jun 01, 2005 12:54 pm
by kool23
hmm iam trying to figure out a way so the macro iam useing dont assist so much.

Code: Select all

Sub GetTarget 
   /assist ${M_Assist}
ok been try trying to think of ways so that it will only assist when the mob is not slowed or something along that line but iam not sure how to go about doing it.is there a way to call back on this?if so i do not know how, i looked threw manual but didnt see anything about it.also dont know what its call if so

Code: Select all

/varset MobMaloed FALSE
hmmm i tried few thinks like /if (${MobSlowed.FALSE}) /assist M_Assist
but didnt work i dont know how to do what iam trying to do
so any help would be great

thanks in advance

Posted: Wed Jun 01, 2005 1:07 pm
by dedpoet
The exclamation point means "not" in many programming languages, including MQ scripting. What you want is something like:

Code: Select all

/if (!${MobSlowed}) /assist M_Assist

Posted: Wed Jun 01, 2005 1:16 pm
by A_Druid_00
I'm pretty sure using ! doesn't work for strings. That's why I always used the integers 1 and 0 to denote true and false. I could be wrong though, wouldn't be the first time. It would be like ${MobSlowed.Equal[FALSE]} or something like that IIRC, but its been a while.

And on the assist thing, there needs to be some amount of assisting happening, or your tank may switch targets and you'll end up dumping your dots and nukes on the wrong mob and getting aggro/breaking mez. While you could set something up to assume that you always have HoTT, I preferred not to tie myself to that requirement. Hell, even before MQ, my nuke hotkey was set to /pause 5, /assist Tankname, nuke, nuke, nuke, nuke (To account for fizzles). The best thing you can do is set up the healing and buffing subs so that there is no way that they will switch targets on you before your spell lands on the intended recipient. I went through great pains with RaidDruid to ensure that things like this were covered.

Posted: Wed Jun 01, 2005 2:15 pm
by dedpoet
Variables default to strings in MQ2, right? The variable is declared as:

Code: Select all

/declare MobSlowed      outer FALSE
Since "bool" or "int" are not specified, that makes it a string, if my understanding is correct. However, !${MobSlowed} is used multiple times in the macro:

Code: Select all

/if (${CombatOn} && !${MobMaloed} && ${DoMalo} && ${Target.ID}==${TargetArray[4]}) /call DeBuff 
   /if (${CombatOn} && !${MobSlowed} && ${DoSlow} && ${Target.ID}==${TargetArray[4]}) /call Slow
My own shaman macro is based on the same original code as this one, and I'm certain I still check for slow that way. It definitely works, even if it's not theoretically the ideal solution.
All times are UTC-05:00
Page 5 of 6
Powered by phpBB® Forum Software © phpBB Limited
https://www.phpbb.com/