• You've discovered RedGuides, an EverQuest multi-boxing and scripting community 🧙‍♀️⚙️. We want you to play several EQ characters at once, come join us and say hello! 👋

  • A TLP without truebox has thawed (Very Vanilla ready)
    Frostreaver

AFCleric.mac

Vegeeter

New member
Joined
Apr 14, 2005
RedCents
11¢
I always seem to never find the macro updated that I want updated after each patch. So I started just fixing them myself. Since I had this issue I decided to post what I worked on. Again this is NOT my work...I just used what I found and fixed it for the 9/23/2005 patch.]
Rich (BB code):
|**---------------------------------------------------------- 
AFCleric.mac 

Run the macro with Main Tank targeted.    
   Usage: /mac AFCleric <%health> <Heal spell> 
   Defaults to casting Complete Healing at 60% 

This Cleric macro operates in 4 modes: 

   autohealmode=0 will watch a single target's health 
   relentlessly. The cleric will not heal self or group, only 
   the specified Tankname at the specified %health. 
   If the Tank takes dmg fast enough that HP is less than 70% 
   of the specified %health, the patchspell will be cast. 
   The Tank does not need to be in your group. 
    
   autohealmode=1 will watch Tank as above, but also heal 
   self and even attempt to cast DA if self HP get too low. 
    
   autohealmode=2 will watch Tank, self, and also the rest of 
   the group. Heals will go first to the person in group with 
   lowest HP percentage. Healtypes for people other than Tank 
   and self will be based on Class and HP percentage. 
    
   autohealmode=3 is exactly the same as mode 2, except that 
   Tank HP and self HP are double checked immediately before 
   healing anyone else. If Tank or self HP are low enough to 
   justify a heal, they get it first even if other group 
   members have lower HP. IE: it tries not to let Tank or 
   self die while healing that overnuking wizard. =) 

Commands to receive the following spells cast upon you are:

   Symbol - sym
   AC Buff - wov
   Conviction - V
   Spell haste - bor
   Remove Greater Curse - rgc
   Pure Blood - pb
   Complete Heal - ch me
   Heal over time - hot me
   Patch Heal - patch me, heal, heal me, heal plz, heal me plz, need heal
  
FaNTuM 
----------------------------------------------------------**| 

#turbo 40 
#include spell_routines.inc 

#Chat Chat 
#Chat tell 

#event MobDead "You gain party experience!!" 
#event ImDead "You have been slain by#*#" 
#event Zoned "LOADING, PLEASE WAIT..." 

Sub Main 

|------------READ THIS SECTION AND EDIT IF NEEDED-----------| 

   /declare mychannel string outer somechannel 
   /declare autohealmode int outer 2 
   /declare healspell string outer Complete Healing 
   /declare healspellrange int outer 115 
   /declare patchheal string outer Pious Light 
   /declare patchhealrange int outer 115 
   /declare hotspell string outer Pious Elixir 
   /declare hotspellrange int outer 115 
   /declare daspell string outer Divine Barrier 
   /declare yaulpspell string outer Yaulp VII
   /declare usegroupheal int outer 0 
   /declare groupheal string outer Word of Vivication 
   /declare grouphealrange int outer 70 
   /declare usedivarb int outer 1 
   /declare healafterdivarb int outer 0 
   /declare announce int outer 1 
   /declare autosit int outer 1 
   /declare distancetosit int outer 40 
   /declare autointerrupt int outer 1 
   /declare onlyhealfd int outer 0 
   /declare interrupt2healself int outer 1 
   /declare interrupt2healselfhp int outer 50 
   /declare noInvis int outer 1 
   /declare defaultstophealpoint int outer 80 
   /declare trickyda int outer 1 
   /declare acbuff string outer Ward of Gallantry 
   /declare selfbuff string outer Armor of the Zealot 
   /declare longhpbuff string outer Conviction 
   /declare singlesmybuff string outer Symbol of Balikor 
   /declare groupsmybuff string outer Kazad`s Mark 
   /declare spellhastebuff string outer Aura of Devotion 
   /declare rgcspell string outer Remove Greater Curse 
   /declare healpetmode int outer 2 
   /declare pethealpoint int outer 60 
   /declare manatohealpet int outer 60 
   /declare pethealspell string outer Complete Healing 
   /declare pethealspellrange int outer 115 
   /declare nukeone string outer Calamity 
   /declare nuketwo string outer Reproach 
   /declare stunone string outer Shock of Wonder 
   /declare stuntwo string outer Tarnation 
   /declare automount int outer 1 
    

|** Tweak Heals Here - tankhealpoint is for War/Pal/SK other 
than MT, casterhotpoint and casterpatchpoint refer to 
wiz/mag/enc/dru, necshmpatchpoint refers to necros and 
shamans, defaultpatchpoint refers to all other classes.   **| 

   /declare selfhealpoint int outer 70 
   /declare dacastpoint int outer 29 
   /declare divarbpoint int outer 30 
   /declare tankhealpoint int outer 65 
   /declare casterhotpoint int outer 85 
   /declare casterpatchpoint int outer 60 
   /declare necshmpatchpoint int outer 60 
   /declare defaultpatchpoint int outer 70 

|------------------------END EDITING------------------------| 

   /declare healpct int outer 60 
   /declare tankname string outer ${Target} 
   /declare tanknameid int outer 
   /declare tankclass string outer 
   /declare minorhurt int outer 0 
   /declare majorhurt int outer 0 
   /declare worsthurt string outer NULL 
   /declare worsthurtid int outer 
   /declare worsthp int outer 100 
   /declare worstclass string outer NULL 
   /declare gmember int outer 
   /declare nohotforua string outer NULL 
   /declare nohotforub string outer NULL 
   /declare nohotforuc string outer NULL 
   /declare nohotforud string outer NULL 
   /declare rodwait int outer 0 
   /declare following int outer 0 
   /declare follname string outer NULL 
   /declare pallycount int outer 0 
   /declare stophealpoint int outer ${defaultstophealpoint} 
   /declare buffbeg int outer 0 
   /declare oomspam int outer 1 
   /declare lomspam int outer 1 
   /declare duckspam int outer 0 
   /declare duckfdspam int outer 0 
   /declare duckselfspam int outer 0 
   /declare nomtspam int outer 0 
   /declare ghealhurtcount int outer 0 
   /declare divarboor int outer 0 


   /join ${mychannel} 
    
   /if (!${Target.ID}) { 
      /echo Target the Tank when you run this macro to designate him as MT 
      /end 
   } else { 
      /varset tanknameid ${Target.ID} 
      /varset tankclass ${Target.Class.Name} 
   } 

   /if (${Defined[Param0]}) {    
      /varset healpct ${Param0} 
   } else /echo No Heal% specified, defaulting to 60% 
    
   { /if (!${Defined[Param1]}) {    
      /echo Usage: /mac AFCleric % healspell 
      /echo Example: /mac AFCleric 40 Complete Heal 
      /echo Defaulting to ${healspell} at ${healpct}% 
   } else {    
      /if (!${Defined[Param2]}) { 
         /varset healspell ${Param1} 
      } else /if (!${Defined[Param3]}) { 
         /varset healspell ${Param1} ${Param2} 
      } else /if (!${Defined[Param4]}) { 
         /varset healspell ${Param1} ${Param2} ${Param3} 
      } else { 
         /varset healspell ${Param1} ${Param2} ${Param3} ${Param4} 
      } 
   } 
   }
   /echo AFCleric Active, running in Autohealmode ${autohealmode} 
   /echo Casting ${healspell} on ${tankname} at ${healpct}% HP 
   /if (${autohealmode}==0) /echo ONLY ${tankname} will be healed 
   /if (${autohealmode}==1) /echo ONLY ${tankname} and myself will be healed 
   /if (${autohealmode}==2) /echo ${tankname}, myself and my group will be healed 
   /if (${autohealmode}==3) /echo ${tankname} and myself will be healed before the rest of the group 
    
   :tankwatchloop 
   /if (${Spawn[${tanknameid}].Name.NotEqual[${tankname}]}) /varset tanknameid 0 
   /if (!${Spawn[${tanknameid}].ID}) /if (${Spawn[${tankname}].ID}) { 
      /if (${SpawnCount[${tankname} ${tankclass}]}==1) { 
         /varset tanknameid ${Spawn[${tankname} ${tankclass}].ID} 
         /echo ${Spawn[${tankname} ${tankclass}].Name} is the designated MT and has ID# ${tanknameid} 
      } 
      /if (${SpawnCount[${tankname} ${tankclass}]}>1) { 
         /if (${SpawnCount[pc ${tankname} ${tankclass}]}==1) { 
            /beep 
            /varset tanknameid ${Spawn[pc ${tankname} ${tankclass}].ID} 
            /echo Defaulting to PC ${Spawn[pc ${tankname} ${tankclass}].Name} as MT. If incorrect, please restart macro 
         } else { 
            /beep 
            /echo Need to restart macro to correctly identify the MT 
         } 
      } 
   } 
   /if (${Spawn[${tanknameid}].ID}) /if (${Spawn[${tanknameid}].Type.Equal[Corpse]}) { 
      /if (${SpawnCount[pc ${tankname} ${tankclass}]}==1) { 
         /varset tanknameid ${Spawn[pc ${tankname ${tankclass}}].ID} 
         /echo ${Spawn[pc ${tankname} ${tankclass}].Name} is MT and has ID# ${tanknameid}. If incorrect, please restart macro 
      } 
   } 
   /if ((!${Target.ID})||(${Target.ID}!=${tanknameid})) { 
      /if (${Spawn[${tanknameid}].ID}) /if (${Spawn[${tanknameid}].Type.NotEqual[Corpse]}) { 
         /target id ${tanknameid} 
         /delay 6 ${Target.ID}==${tanknameid} 
      } 
   } 
   /if (!${Spawn[${tanknameid}].ID}) { 
      /if (${nomtspam}==1) { 
         /e Warning No Designated MT is available 
         /timed 300 /varset nomtspam 1 
         /varset nomtspam 0 
      } 
   } 
   /if ((${Me.PctMana}<=20)&&(${announce}==1)&&(${lomspam}==1)) { 
      /g ${Me.PctMana}m 
      /varset lomspam 0 
      /timed 300 /varset lomspam 1 
   } 
   /if ((${Me.PctMana}<=7)&&(${announce}==1)&&(${oomspam}==1)) { 
      /g oom 
      /varset oomspam 0 
      /timed 300 /varset oomspam 1 
      /call MedTime 
   } 
   /if (${GameState.Equal[CHARSELECT]}) /end 
   /if (${Target.ID}==${tanknameid}) { 
      /varset stophealpoint ${Math.Calc[${healpct}*1.1]} 
      /if ((${Target.Distance}<=${patchhealrange})&&(${Target.PctHPs}<=${Math.Calc[0.7*${healpct}]})&&(${Target.PctHPs}>=1)) { 
         /if (${announce}==1) /g Casting ${patchheal} on %T 
         /call Cast "${patchheal}" gem2 1s CheckHP 
         /delay 15 ${Me.SpellReady[${patchheal}]} 
      } 
      /if ((${Target.Distance}<=${healspellrange})&&(${Target.PctHPs}<=${healpct})&&(${Target.PctHPs}>=${Math.Calc[0.7*${healpct}]})) { 
         /if (${announce}==1) /g Casting ${healspell} on %T 
         /call Cast "${healspell}" gem1 1s CheckHP 
         /delay 15 ${Me.SpellReady[${healspell}]} 
         |/g CH Done 
      } 
      /varset stophealpoint ${defaultstophealpoint} 
      /call CheckEvents 
   } 
   /if ((${autosit}>=1)&&(${Bool[${Me.Sitting}]})&&(!${Window[SpellBookWnd].Open})) { 
      /if ((${Me.PctMana}>98)||(${Me.PctHPs}<=90)) /stand 
   } 
   /if ((${autosit}==1)&&(${Bool[${Me.Sitting}]})&&(!${Window[SpellBookWnd].Open})) { 
      /if (${NearestSpawn[NPC].Distance}<=${Math.Calc[${NearestSpawn[NPC].MaxRange}+${Math.Calc[${distancetosit}/3]}]}) /stand 
   } 
   /if (${autohealmode}==0) { 
      /call CheckEvents 
      /goto :tankwatchloop 
   } 
   /if ((${autohealmode}>=1)&&(${Me.PctHPs}<=${selfhealpoint})) /call Healself 
   /if (${autohealmode}>=2) { 
      /if ((${Target.PctHPs}>${healpct})||(${Target.Distance}>${healspellrange})||(${Target.PctHPs}<=1)||(!${Target.ID})||(${Target.ID}!=${tanknameid})) { 
         /call Healgroup 
      } 
   } 
   /if ((${autohealmode}<2)&&(${Me.PctHPs}>${selfhealpoint})&&(${Me.PctMana}<=98)) /call MedTime 
   /call CheckEvents 
   /call MaintainSelfBuffs 
   /goto :tankwatchloop 
/return 
    
Sub MaintainSelfBuffs 
/if ((!${Me.Buff[Armor of the Zealot].ID})&&(!${Me.Buff[Blessing of Steeloak].ID})&&(!${Me.Buff[Steeloak].ID})) {
  /echo Buffing Self 
  /call Cast "${selfbuff}" gem4 5s  
}
/if ((!${Me.Buff[Aura of Devotion].ID})&&(!${Me.Buff[Blessing of Devotion].ID})) { 
  /echo Buffing Self 
  /call Cast "${spellhastebuff}" gem5 8s  
} 
/if ((!${Me.Buff[Conviction].ID})&&(!${Me.Buff[Hand of Conviction].ID})&&(!${Me.Buff[Blessing of Steeloak].ID})&&(!${Me.Buff[Steeloak].ID})) {
  /echo Buffing Self 
  /keypress F1
  /call Cast "${longhpbuff}" gem6 14s  
} 
/if ((${Me.Buff[Blessing of Steeloak].ID})&&(${Me.Buff[Steeloak].ID})) {
  /echo Buffing Self 
  /call Cast "${singlesmybuff}" gem7 5s  
}
 
 
/return 

Sub Healself 
   /if (${Me.PctHPs}>${selfhealpoint}) /return 
   /varset stophealpoint ${Math.Calc[${selfhealpoint}+5]} 
   /if ((!${Target.ID})||(${Target.PctHPs}>=${Math.Calc[1.1*${healpct}]})||(${Target.PctHPs}<=1)||(${Target.ID}!=${tanknameid})) { 
      /if ((${Me.PctHPs}<=${selfhealpoint})&&(${Me.PctHPs}>${dacastpoint})) { 
         /target myself 
         /delay 6 ${Target.Name.Equal[${Me}]} 
         /if (${Target.Name.Equal[${Me}]}) { 
            /if (${announce}==1) /g Casting ${patchheal} on %T 
            /call Cast "${patchheal}" gem2 1s CheckHP 
            /delay 15 ${Me.SpellReady[${patchheal}]} 
         } 
      } 
      /if ((${Me.PctHPs}<=${dacastpoint})&&(${Me.SpellReady[${daspell}]})) { 
         /if (${announce}==1) /g Casting DA!! <<WARNING>> DA!! No Heals for 18 SECONDS 
         :retryda 
         /call Cast "${daspell}" 
         /delay 1 
         /if ((!${Me.Buff[${daspell}].ID})&&(${Me.SpellReady[${daspell}]})) /goto :retryda 
         /if ((${trickyda}==1)&&(${Me.Buff[${daspell}].ID})) /call TrickyDA 
         :dawait 
         /if (${Me.Buff[${daspell}].ID}) { 
            /delay 1s !${Me.Buff[${daspell}].ID} 
            /varset stophealpoint ${defaultstophealpoint} 
            /call CheckEvents 
            /goto :dawait 
         } 
      }            
   } 
   /if (${Me.PctHPs}<=${Math.Calc[${selfhealpoint}*0.7]}) { 
      /target myself 
      /delay 6 ${Target.Name.Equal[${Me}]} 
      /if (${Target.Name.Equal[${Me}]}) { 
         /if (${announce}==1) /g Casting ${patchheal} on %T 
         /varset stophealpoint ${Math.Calc[${selfhealpoint}+5]} 
         /call Cast "${patchheal}" gem2 1s CheckHP 
         /delay 15 ${Me.SpellReady[${patchheal}]} 
      } 
   } 
   /varset stophealpoint ${defaultstophealpoint} 
/return 


Sub Healgroup 
   :healgroup 
   /varset worsthurt NULL 
   /varset worsthp 100 
   /varset worstclass NULL 
   /varset minorhurt 0 
   /varset majorhurt 0 
   /varset ghealhurtcount 0 
   /for gmember 0 to ${Group} 
      /if (${onlyhealfd}==0) { 
         /if (${Group.Member[${gmember}].Distance}<=${patchhealrange}) { 
            /if (${Group.Member[${gmember}].PctHPs}<=${worsthp}) { 
               /varset worsthurt ${Group.Member[${gmember}].Name} 
               /varset worsthurtid ${Group.Member[${gmember}].ID} 
               /varset worsthp ${Group.Member[${gmember}].PctHPs} 
               /varset worstclass ${Group.Member[${gmember}].Class.Name} 
            } 
         } 
      } 
      /if (${onlyhealfd}==1) { 
         /if (${Group.Member[${gmember}].Distance}<=${patchhealrange}) { 
            /if ((${Group.Member[${gmember}].Class.Name.NotEqual[Monk]})&&(${Group.Member[${gmember}].Class.Name.NotEqual[Necromancer]})&&(${Group.Member[${gmember}].PctHPs}<=${worsthp})) { 
               /varset worsthurt ${Group.Member[${gmember}].Name} 
               /varset worsthurtid ${Group.Member[${gmember}].ID} 
               /varset worsthp ${Group.Member[${gmember}].PctHPs} 
               /varset worstclass ${Group.Member[${gmember}].Class.Name} 
            } 
            /if ((${Group.Member[${gmember}].Class.Name.Equal[Monk]})||(${Group.Member[${gmember}].Class.Name.Equal[Necromancer]})) { 
               /if ((${Group.Member[${gmember}].State.Equal[feign]})&&(${Group.Member[${gmember}].PctHPs}<=${worsthp})) { 
                  /varset worsthurt ${Group.Member[${gmember}].Name} 
                  /varset worsthurtid ${Group.Member[${gmember}].ID} 
                  /varset worsthp ${Group.Member[${gmember}].PctHPs} 
                  /varset worstclass ${Group.Member[${gmember}].Class.Name} 
               } 
            } 
         } 
      } 
      /if ((${Group.Member[${gmember}].Distance}<=${grouphealrange})&&(${Group.Member[${gmember}].PctHPs}<=85)) /varcalc ghealhurtcount ${ghealhurtcount}+1 
      /if ((${Group.Member[${gmember}].PctHPs}<=85)&&(${Group.Member[${gmember}].PctHPs}>=60)) /varcalc minorhurt ${minorhurt}+1 
      /if ((${Group.Member[${gmember}].PctHPs}<=60)&&(${Group.Member[${gmember}].PctHPs}>=1)) /varcalc majorhurt ${majorhurt}+1 
   /next gmember 
   /if (${autohealmode}==3) { 
      /if ((!${Target.ID})||(${Target.Name.NotEqual[${tankname}]})) /if (${Spawn[${tanknameid}].ID}) { 
         /target id ${tanknameid} 
         /delay 6 ${Target.ID}==${tanknameid} 
         /delay 1 
         /if ((${Target.ID}==${tanknameid})&&(${Target.PctHPs}<=${healpct})&&(${Target.Distance}<=${healspellrange})) /return 
      } 
      /if (${Me.PctHPs}<=${selfhealpoint}) /return 
   } 
   /if ((${majorhurt}==0)&&(${minorhurt}==0)) { 
      /if (${Spawn[${tanknameid}].ID}) { 
         /target id ${tanknameid} 
         /delay 6 ${Target.ID}==${tanknameid} 
         /delay 1 
      } 
      /if (((${Target.ID}==${tanknameid})&&(${Target.PctHPs}>${healpct}))||(!${Spawn[${tanknameid}].ID})||(${Spawn[${tanknameid}].Type.Equal[corpse]})) { 
         /if ((${healpetmode}>0)&&(${Me.PctMana}>=${manatohealpet})) /call HealPet 
         /if (${Me.PctMana}<=98) /call MedTime 
      } 
      /call CheckEvents 
      /return 
   } 
   /if ((${usedivarb}==1)&&(${Target.PctHPs}<=${divarbpoint})&&(${Target.Distance}<=200)&&(${Me.AltAbilityReady[Divine Arbitration]})) { 
      /for gmember 0 to ${Group} 
         /if (${Group.Member[${gmember}].Distance}>200) /varcalc divarboor ${divarboor}+1 
      /next gmember 
      /if ((${Group}>=3)&&(${divarboor}<2)) /call Cast "Divine Arbitration" alt 3s 
      /delay 3 ${Me.AltAbilityReady[Divine Arbitration]} 
      /if ((${healafterdivarb}==1)&&(${Me.PctMana}>40)) { 
         /if (${announce}==1) /g Inc Grp Heal, get close 
         /call Cast "${groupheal}" gem4 1s 
         /delay 15 ${Me.SpellReady[${groupheal}]} 
      } 
      /varset divarboor 0 
      /return 
   } 
   /if ((${Math.Calc[${majorhurt}+${minorhurt}]}>=3)&&(${usegroupheal}==1)) { 
      /if (${announce}==1) /g Inc Grp Heal, get close 
      /call Cast "${groupheal}" gem4 1s 
      /delay 15 ${Me.SpellReady[${groupheal}]} 
      /call CheckEvents 
      /return 
   } 
   /if (${worsthurtid}==${tanknameid}) /return 
   /if (${worsthurtid}==${Me.ID}) { 
      /call Healself 
      /call CheckEvents 
      /return 
   } 
   /if ((${worstclass.Equal[Warrior]})||(${worstclass.Equal[Paladin]})||(${worstclass.Equal[Shadow Knight]})) { 
      /if ((${worsthp}<=${tankhealpoint})&&(${worsthp}>=${Math.Calc[0.7*${tankhealpoint}]})&&(${majorhurt}<=1)&&(${minorhurt}<=1)) { 
         /target id ${worsthurtid} 
    /delay 5 ${Target.ID}==${worsthurtid} 
         /if (!${Target.ID}) /return 
         /if (${Target.ID}!=${worsthurtid}) /return 
         /varset stophealpoint ${Math.Calc[${tankhealpoint}+5]} 
         /if (${announce}==1) /g Casting ${healspell} on %T 
         /call Cast "${healspell}" gem1 1s CheckHP 
         /delay 15 ${Me.SpellReady[${healspell}]} 
         /varset stophealpoint ${defaultstophealpoint} 
         /call CheckEvents 
         /return 
      } 
      /if (${worsthp}<=${tankhealpoint}) { 
         /target id ${worsthurtid} 
    /delay 5 ${Target.ID}==${worsthurtid} 
         /if (!${Target.ID}) /return 
         /if (${Target.ID}!=${worsthurtid}) /return 
         /varset stophealpoint ${Math.Calc[${tankhealpoint}+5]} 
         /if (${announce}==1) /g Casting ${patchheal} on %T 
         /call Cast "${patchheal}" gem2 1s CheckHP 
         /delay 15 ${Me.SpellReady[${patchheal}]} 
         /varset stophealpoint ${defaultstophealpoint} 
         /call CheckEvents 
         /return 
      } 
   } else /if ((${worstclass.Equal[Magician]})||(${worstclass.Equal[Wizard]})||(${worstclass.Equal[Enchanter]})||(${worstclass.Equal[Druid]})) { 
      /if ((${worsthp}<=${casterhotpoint})&&(${worsthp}>${casterpatchpoint})) { 
         /if ((${worsthurt.Equal[${nohotforua}]})||(${worsthurt.Equal[${nohotforub}]})||(${worsthurt.Equal[${nohotforuc}]})||(${worsthurt.Equal[${nohotforud}]})) /return 
         /if (${nohotforua.Equal[NULL]}) { 
            /target id ${worsthurtid} 
       /delay 5 ${Target.ID}==${worsthurtid} 
       /if (!${Target.ID}) /return 
            /if (${Target.ID}!=${worsthurtid}) /return 
            /varset nohotforua ${Target.Name} 
            /if (${announce}==1) /g Casting ${hotspell} on %T 
            /varset stophealpoint ${Math.Calc[${casterhotpoint}+5]} 
            /call Cast "${hotspell}" gem3 1s CheckHP 
            /timed 200 /varset nohotforua NULL 
            /delay 15 ${Me.SpellReady[${hotspell}]} 
         } else /if (${nohotforub.Equal[NULL]}) { 
            /target id ${worsthurtid} 
       /delay 5 ${Target.ID}==${worsthurtid} 
       /if (!${Target.ID}) /return 
            /if (${Target.ID}!=${worsthurtid}) /return 
       /varset nohotforub ${Target.Name} 
            /if (${announce}==1) /g Casting ${hotspell} on %T 
            /varset stophealpoint ${Math.Calc[${casterhotpoint}+5]} 
            /call Cast "${hotspell}" gem3 1s CheckHP 
            /timed 200 /varset nohotforub NULL 
            /delay 15 ${Me.SpellReady[${hotspell}]} 
         } else /if (${nohotforuc.Equal[NULL]}) { 
            /target id${worsthurtid} 
       /delay 5 ${Target.ID}==${worsthurtid} 
       /if (!${Target.ID}) /return 
            /if (${Target.ID}!=${worsthurtid}) /return 
       /varset nohotforuc ${Target.Name} 
            /if (${announce}==1) /g Casting ${hotspell} on %T 
            /varset stophealpoint ${Math.Calc[${casterhotpoint}+5]} 
            /call Cast "${hotspell}" gem3 1s CheckHP 
            /timed 200 /varset nohotforuc NULL 
            /delay 15 ${Me.SpellReady[${hotspell}]} 
         } else /if (${nohotforud.Equal[NULL]}) { 
            /target id ${worsthurtid} 
       /delay 5 ${Target.ID}==${worsthurtid} 
       /if (!${Target.ID}) /return 
            /if (${Target.ID}!=${worsthurtid}) /return 
       /varset nohotforud ${Target.Name} 
            /if (${announce}==1) /g Casting ${hotspell} on %T 
            /varset stophealpoint ${Math.Calc[${casterhotpoint}+5]} 
            /call Cast "${hotspell}" gem3 1s CheckHP 
            /timed 200 /varset nohotforud NULL 
            /delay 15 ${Me.SpellReady[${hotspell}]} 
         } 
         /varset stophealpoint ${defaultstophealpoint} 
         /call CheckEvents 
         /return 
      } 
      /if ((${worsthp}<=${casterpatchpoint})&&(${worsthp}>=1)) { 
         /target id ${worsthurtid} 
    /delay 5 ${Target.ID}==${worsthurtid} 
    /if (!${Target.ID}) /return 
         /if (${Target.ID}!=${worsthurtid}) /return 
         /if (${announce}==1) /g Casting ${patchheal} on %T 
         /call Cast "${patchheal}" gem2 1s CheckHP 
         /varset stophealpoint ${defaultstophealpoint} 
         /call CheckEvents 
         /delay 15 ${Me.SpellReady[${patchheal}]} 
         /return 
      } 
      /varset stophealpoint ${defaultstophealpoint} 
   } else /if ((${worstclass.Equal[Necromancer]})||(${worstclass.Equal[Shaman]})) { 
      /if ((${worsthp}<=${necshmpatchpoint})&&(${worsthp}>=1)) { 
         /target id ${worsthurtid} 
    /delay 5 ${Target.ID}==${worsthurtid} 
    /if (!${Target.ID}) /return 
         /if (${Target.ID}!=${worsthurtid}) /return 
         /varset stophealpoint ${Math.Calc[${necshmpatchpoint}+5]} 
         /if (${announce}==1) /g Casting ${patchheal} on %T 
    /call Cast "${patchheal}" gem2 1s CheckHP 
    /varset stophealpoint ${defaultstophealpoint} 
    /call CheckEvents 
    /delay 15 ${Me.SpellReady[${patchheal}]} 
    /return 
      } 
   } else /if ((${worsthp}<=${defaultpatchpoint})&&(${worsthp}>=1)) { 
      /target id ${worsthurtid} 
      /delay 5 ${Target.ID}==${worsthurtid} 
      /if (!${Target.ID}) /return 
      /if (${Target.ID}!=${worsthurtid}) /return 
      /if (${announce}==1) /g Casting ${patchheal} on %T 
      /varset stophealpoint ${Math.Calc[${defaultpatchpoint}+5]} 
      /call Cast "${patchheal}" gem2 1s CheckHP 
      /varset stophealpoint ${defaultstophealpoint} 
      /call CheckEvents 
      /delay 15 ${Me.SpellReady[${patchheal}]} 
      /return 
   } 
   /varset stophealpoint ${defaultstophealpoint} 
   /if ((${healpetmode}==2)&&(${Me.PctMana}>${manatohealpet})) /call HealPet 
/return 


Sub HealPet 
   /varset worsthurt NULL 
   /varset worsthp 100 
   /for gmember 0 to ${Group} 
      /if (${Group.Member[${gmember}].Pet.ID}) { 
         /if (${Group.Member[${gmember}].Pet.Distance}<=${pethealspellrange}) { 
            /if ((${Group.Member[${gmember}].Pet.PctHPs}<=${worsthp})&&(${Group.Member[${gmember}].Pet.PctHPs}<=${pethealpoint})) { 
               /varset worsthurt ${Group.Member[${gmember}].Pet.Name} 
               /varset worsthurtid ${Group.Member[${gmember}].Pet.ID} 
               /varset worsthp ${Group.Member[${gmember}].Pet.PctHPs} 
            } 
         } 
      } 
   /next gmember 
   /if (${worsthurt.NotEqual[NULL]}) { 
      /target id ${worsthurtid} 
      /delay 5 ${Target.ID}==${worsthurtid} 
      /if (!${Target.ID}) /return 
      /if (${Target.ID}!=${worsthurtid}) /return 
      /delay 3 
      /if (${Target.PctHPs}<=${pethealpoint}) { 
         /if (${announce}==1) /g Casting ${pethealspell} on %T 
         /varset stophealpoint ${Math.Calc[${pethealpoint}+5]} 
         /call Cast "${pethealspell}" spell 1s CheckHP 
         /varset stophealpoint ${defaultstophealpoint} 
         /delay 15 ${Me.SpellReady[${pethealspell}]} 
      } 
   } 
/return 


Sub CheckEvents 
   /delay 1 
   /doevents Chat 
   /doevents tell 
   /doevents 
   /doevents flush 
/return 


Sub MedTime 
   :oomwait 
   /call CheckEvents 
   /If ((${FindItem["Rod of Mystical Transvergance"].InvSlot})&&(${Me.PctMana}<=70)&&(${Me.PctHPs}>=98)&&(${rodwait}==0)) { 
      /call Cast "Rod of Mystical Transvergance" item 
      /varset rodwait 1 
      /timed 3000 /varset rodwait 0 
   } 
   /if ((${autosit}==1)&&(${Me.PctMana}<=98)&&(!${Me.Casting.ID})) { 
      /if ((${Bool[${Me.Standing}]})&&(${NearestSpawn[NPC].Distance}>=${Math.Calc[${NearestSpawn[NPC].MaxRange}+${distancetosit}]})&&(${Me.PctHPs}>90)) /sit 
      /if ((${Bool[${Me.Sitting}]})&&(!${Window[SpellBookWnd].Open})&&(${NearestSpawn[NPC].Distance}<=${Math.Calc[${NearestSpawn[NPC].MaxRange}+${Math.Calc[${distancetosit}/3]}]})) /stand 
   } 
   /if ((${Bool[${Me.Standing}]})&&(${autosit}==2)&&(${Me.PctMana}<=98)&&(${Me.PctHPs}>90)&&(!${Me.Casting.ID})) /sit 
   /if ((${Bool[${Me.Sitting}]})&&(${autosit}>=1)&&(${Me.PctMana}>98)&&(!${Window[SpellBookWnd].Open})) /stand 
   /if ((${Bool[${Me.Standing}]})&&(!${Me.Mount.ID})&&(${Me.SpellReady[${yaulpspell}]})&&(!${Me.Buff[${yaulpspell}].ID})) { 
      /if ((!${Me.Buff[Vallon].ID})&&(!${Me.Buff[Spiritual Vigor].ID})&&(!${Me.Buff[Strength of Tunare].ID})) /call Cast "${yaulpspell}" 
   } 
   /if (${buffbeg}==1) /call Buffbeg 
   /if (${Me.PctHPs}<=${selfhealpoint}) /return 
   /if (${Me.PctMana}<=8) /goto :oomwait 
/return 


Sub CheckHP 
   /if (!${Window[CastingWindow].Open}) /return 
   /if ((${autointerrupt}>=1)&&(${Target.PctHPs}>=${stophealpoint})) { 
      /if ((${announce}==1)&&(${duckspam}==1)) { 
         /g Ducking heal on %T 
         /e Ducking heal on ${Target.Name} 
         /varset duckspam 0 
         /timed 60 /varset duckspam 1 
      } 
      /call Interrupt 
   } 
   /if ((${interrupt2healself}==1)&&(${Target.Name.NotEqual[${Me}]})&&(${Me.PctHPs}<${interrupt2healselfhp})) { 
      /if ((${announce}==1)&&(${duckselfspam}==1)) { 
         /g Ducking heal on %T so I can heal my (ChickenShit) self 
         /e Ducking heal on ${Target} so I can heal myself 
         /varset duckselfspam 0 
         /timed 60 /varset duckselfspam 1 
      } 
      /call Interrupt 
   } 
   /if (${onlyhealfd}==1) { 
      /if ((${Target.Class.Name.Equal[Necromancer]})||(${Target.Class.Name.Equal[Monk]})) { 
         /if (${Target.State.NotEqual[feign]}) { 
            /if ((${announce}==1)&&(${duckfdspam}==1)) { 
               /g Ducking heal on %T because he isn't staying FD 
               /e Ducking heal on ${Target.Name} because he isn't staying FD 
               /varset duckfdspam 0 
               /timed 40 /varset duckfdspam 1 
            } 
            /call Interrupt 
         } 
      } 
   } 
/return 


Sub TrickyDA 
   /if ((${Me.PctHPs}<40)&&(${Me.Buff[Virtue].ID})) /notify BuffWindow Buff${Math.Calc[${Me.Buff[Virtue].ID}-1].Int} leftmouseup 
   /if ((${Me.PctHPs}<40)&&(${Me.Buff[Hand of Virtue].ID})) /notify BuffWindow Buff${Math.Calc[${Me.Buff[Hand of Virtue].ID}-1].Int} leftmouseup 
   /if ((${Me.PctHPs}<40)&&(${Me.Buff[Focus of Soul].ID})) /notify BuffWindow Buff${Math.Calc[${Me.Buff[Focus of Soul].ID}-1].Int} leftmouseup 
   /if ((${Me.PctHPs}<40)&&(${Me.Buff[Focus of the Seventh].ID})) /notify BuffWindow Buff${Math.Calc[${Me.Buff[Focus of the Seventh].ID}-1].Int} leftmouseup 
   /if ((${Me.PctHPs}<40)&&(${Me.Buff[Protection of the 9].ID})) /notify BuffWindow Buff${Math.Calc[${Me.Buff[Protection of the 9].ID}-1].Int} leftmouseup 
   /if ((${Me.PctHPs}<40)&&(${Me.Buff[Blessing of the Nine].ID})) /notify BuffWindow Buff${Math.Calc[${Me.Buff[Blessing of the Nine].ID}-1].Int} leftmouseup 
   /if ((${Me.PctHPs}<40)&&(${Me.Buff[Symbol of Kazad].ID})) /notify BuffWindow Buff${Math.Calc[${Me.Buff[Symbol of Kazad].ID}-1].Int} leftmouseup 
   /if ((${Me.PctHPs}<40)&&(${Me.Buff[Kazad`s Mark].ID})) /notify BuffWindow Buff${Math.Calc[${Me.Buff[Kazad`s Mark].ID}-1].Int} leftmouseup 
   /if ((${Me.PctHPs}<40)&&(${Me.Buff[Brell's Stalwart Shield].ID})) /notify BuffWindow Buff${Math.Calc[${Me.Buff[Brell's Stalwart Shield].ID}-1].Int} leftmouseup 
   /if (${Me.Buff[${daspell}].ID}) { 
      :waitalittle 
      /delay 1s ${Me.Buff[${daspell}].Duration}<2 
      /if (${Me.Buff[${daspell}].Duration}>=2) /goto :waitalittle 
   } 
   /varset buffbeg 1 
   /call Buffbeg 
/return 


Sub Buffbeg 
   /if (${buffbeg}==0) /return 
   /echo Begging for buffs now 
   /if ((!${Me.Buff[Protection of the Nine].ID})&&(!${Me.Buff[Blessing of the Nine].ID})&&(!${Me.Buff[Virtue].ID})&&(!${Me.Buff[Hand of Virtue].ID})) { 
      /if (${NearestSpawn[PC guild druid].Name.NotEqual[NULL]}) /if (${NearestSpawn[PC guild druid].Distance}<=100) { 
         /tell ${NearestSpawn[PC guild druid]} need 9 plz 
         /delay 20 
         /if (${Me.Buff[${daspell}].ID}) /notify BuffWindow Buff${Math.Calc[${Me.Buff[${daspell}].ID}-1].Int} leftmouseup 
      } else /e No guild Druid available for 9 
   } 
   /if ((!${Me.Buff[${daspell}].ID})&&(${Me.PctHPs}<=75)) /call Healself 
   /if ((!${Me.Buff[Focus of the Seventh].ID})&&(!${Me.Buff[Focus of Soul].ID})) { 
      /if (${NearestSpawn[PC guild shaman].Name.NotEqual[NULL]}) /if (${NearestSpawn[PC guild shaman].Distance}<=100) { 
         /tell ${NearestSpawn[PC guild shaman]} need focus plz 
         /delay 20 
         /if (${Me.Buff[${daspell}].ID}) /notify BuffWindow Buff${Math.Calc[${Me.Buff[${daspell}].ID}-1].Int} leftmouseup 
      } else /e No guild Shaman available for Focus 
   } 
   /if ((!${Me.Buff[${daspell}].ID})&&(${Me.PctHPs}<=75)) /call Healself 
   /if ((!${Me.Buff[Brell's Stalwart Shield].ID})&&(!${Me.Buff[Spiritual Vigor].ID})) { 
      /if (${NearestSpawn[PC guild paladin].Name.NotEqual[NULL]}) /if (${NearestSpawn[PC guild paladin].Distance}<=100) { 
         /tell ${NearestSpawn[PC guild paladin]} need BSS plz 
         /delay 20 
         /if (${Me.Buff[${daspell}].ID}) /notify BuffWindow Buff${Math.Calc[${Me.Buff[${daspell}].ID}-1].Int} leftmouseup 
      } else /e No guild Paladin available for BSS 
   } 
   /if ((!${Me.Buff[${daspell}].ID})&&(${Me.PctHPs}<=75)) /call Healself 
   /if ((!${Me.Buff[Voice of Quellious].ID})&&(!${Me.Buff[Tranquility].ID})&&(!${Me.Buff[Koadic's Endless Intellect].ID})) { 
      /if (${NearestSpawn[PC guild enchanter].Name.NotEqual[NULL]}) /if (${NearestSpawn[PC guild enchanter].Distance}<=100) { 
         /tell ${NearestSpawn[PC guild enchanter]} need c5 plz 
         /delay 20 
         /if (${Me.Buff[${daspell}].ID}) /notify BuffWindow Buff${Math.Calc[${Me.Buff[${daspell}].ID}-1].Int} leftmouseup 
      } else /e No guild Enchanter available for C5 
   } 
   /if ((!${Me.Buff[${daspell}].ID})&&(${Me.PctHPs}<=75)) /call Healself 
   /if (!${Me.Buff[Spiritual Dominion].ID}) { 
      /if (${NearestSpawn[PC guild beastlord].Name.NotEqual[NULL]}) /if (${NearestSpawn[PC guild beastlord].Distance}<=100) { 
         /tell ${NearestSpawn[PC guild beastlord]} need SD plz 
         /if (${Me.Buff[${daspell}].ID}) /notify BuffWindow Buff${Math.Calc[${Me.Buff[${daspell}].ID}-1].Int} leftmouseup 
      } else /e No guild Beastlord available for SD 
   } 
   /varset buffbeg 0 
/return 


Sub FindExactPC(string name) 
   /declare nameid int local 
   /declare counter int local 1 
   :FindNext 
   /if (!${NearestSpawn[${counter}, pc ${name}].ID}) /return NOT_FOUND 
   /varset nameid ${NearestSpawn[${counter}, pc ${name}].ID} 
   /if (${Spawn[${nameid}].CleanName.Equal[${name}]}) { 
      /target id ${nameid} 
      /delay 1s ${Target.ID}==${nameid} 
      /if (${Target.ID}==${nameid}) /return TARGET_SUCCESS 
   } 
   /varcalc counter ${counter}+1 
   /if (${NearestSpawn[${counter}, pc ${name}].ID}) /goto :FindNext 
/return NOT_FOUND 


Sub Event_Chat(string ChatType,string Sender,string ChatText) 
   /if ((!${ChatType.Equal[${mychannel}]})&&(!${ChatType.Equal[TELL]})) /return 
   /if (!${Spawn[${Sender}].ID}) { 
      /e ${Sender} is not in the zone 
      /return 
   } 
   /if (${ChatText.Equal[Follow me]}) { 
      /delay 5 
      /if (!${Spawn[${Sender}].ID}) { 
         /e ${Sender} is not in zone for me to follow! 
         /return 
      } 
      /varset follname ${Sender} 
      /varset following 1 
      :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}>10) /keypress forward hold 
      /if (${Target.Distance}<9) /keypress back 
      /if (!${Target.ID}) /varset following 0 
      /call CheckEvents 
      /if ((${Target.Name.Equal[${follname}]})&&(${following}>0)) { 
         /goto :Loop 
      } else { 
         /keypress forward 
         /keypress back 
      } 
   } 
   /if (${ChatText.Equal[End follow]}) { 
      /varset following 0 
      /keypress forward 
      /keypress back 
      /timed 50 /face pc ${follname} 
   } 
   /if (${ChatText.Equal[Gbuff now!]}) { 
      /varset pallycount 0 
      /target myself 
      /call Cast "${acbuff}" gem6 7s 
      /if (${FindItem[Breastplate of Vengeful Fury].ID}) /call Cast "Breastplate of Vengeful Fury" item 
      /if (!${FindItem[Breastplate of Vengeful Fury].ID}) /call Cast "${spellhastebuff}" gem8 5s 
      /for gmember 1 to ${Group} 
         /target id ${Group.Member[${gmember}].ID} 
         /delay 1s ${Target.ID}==${Group.Member[${gmember}].ID} 
         /if (${Target.ID}==${Group.Member[${gmember}].ID}) { 
            /if (${Target.Class.Name.NotEqual[Paladin]}) /call Cast "${acbuff}" gem5 7s 
            /if (${Target.Class.Name.Equal[Paladin]}) { 
               /call Cast "${longhpbuff}" gem4 10s 
               /varcalc pallycount ${pallycount}+1 
            } 
            /if ((${Target.Class.Name.NotEqual[Warrior]})&&(${Target.Class.Name.NotEqual[Monk]})&&(${Target.Class.Name.NotEqual[Rogue]})&&(${Target.Class.Name.NotEqual[Berserker]})&&(${Target.Class.Name.NotEqual[Bard]})) { 
               /if (${FindItem[Breastplate of Vengeful Fury].ID}) /call Cast "Breastplate of Vengeful Fury" item 
               /if (!${FindItem[Breastplate of Vengeful Fury].ID}) /call Cast "${spellhastebuff}" gem8 5s 
            } 
         } 
      /next gmember 
      /if (${Math.Calc[${Group}-${pallycount}]}>=2) /call Cast "${groupsmybuff}" gem5 10s 
      /if (${Math.Calc[${Group}-${pallycount}]}<2) { 
         /for gmember 0 to ${Group} 
            /target id ${Group.Member[${gmember}].ID} 
            /delay 1s ${Target.ID}==${Group.Member[${gmember}].ID} 
            /if (${Target.Class.Name.NotEqual[Paladin]}) /call Cast "${singlesmybuff}" gem5 7s 
         /next gmember 
      } 
   }    
   /if (${ChatText.Equal[BoR now!]}) { 
      /target myself 
      /delay 5 ${Target.Name.Equal[${Me}]} 
      /if (${FindItem[Breastplate of Vengeful Fury].ID}) /call Cast "Breastplate of Vengeful Fury" item 
      /if (!${FindItem[Breastplate of Vengeful Fury].ID}) /call Cast "${spellhastebuff}" gem8 5s 
      /for gmember 1 to ${Group} 
         /target id ${Group.Member[${gmember}].ID} 
         /delay 1s ${Target.ID}==${Group.Member[${gmember}].ID} 
         /if (${Target.ID}==${Group.Member[${gmember}].ID}) { 
            /if ((${Target.Class.Name.NotEqual[Warrior]})&&(${Target.Class.Name.NotEqual[Monk]})&&(${Target.Class.Name.NotEqual[Rogue]})&&(${Target.Class.Name.NotEqual[Berserker]})&&(${Target.Class.Name.NotEqual[Bard]})) { 
               /if (${FindItem[Breastplate of Vengeful Fury].ID}) /call Cast "Breastplate of Vengeful Fury" item 
               /if (!${FindItem[Breastplate of Vengeful Fury].ID}) /call Cast "${spellhastebuff}" gem8 5s 
            } 
         } 
      /next gmember 
   }    
   /if (${ChatText.Equal[nuke]}) { 
      /if (${Me.PctMana}<30) { 
         /chat #${mychannel} Cleric Mana ${Me.PctMana}%, holding on nukes! 
      } else { 
         /assist ${Sender} 
         /delay 5 
         /if (${Target.Type.NotEqual[NPC]}) { 
            /assist ${Sender} 
            /delay 5 ${Target.Type.Equal[NPC]} 
         } 
         /if ((${Target.Type.Equal[NPC]})&&(${Target.PctHPs}<=90)) { 
            /if (${Me.SpellReady[${nukeone}]}) { 
               /if (${announce}==1) /g Casting ${nukeone} on %T 
               /call Cast "${nukeone}" spell 3s 
            } else /if (${Me.SpellReady[${nuketwo}]}) { 
               /if (${announce}==1) /g Casting ${nuketwo} on %T 
               /call Cast "${nuketwo}" spell 3s 
            } else /chat #${mychannel} nukes not ready 
            /if (${Me.PctMana}<=60) /chat #${mychannel} FYI Cleric Mana ${Me.PctMana}% 
         } else /chat #${mychannel} wrong target (${Target.Type} at ${Target.PctHPs}% HP) 
      } 
   } 
   /if (${ChatText.Equal[stun]}) { 
      /assist ${Sender} 
      /delay 5 
      /if (${Target.Type.NotEqual[NPC]}) { 
         /assist ${Sender} 
         /delay 5 ${Target.Type.Equal[NPC]} 
      } 
      /if ((${Target.Type.Equal[NPC]})&&(${Target.PctHPs}<=90)) { 
         /if (${Me.SpellReady[${stunone}]}) { 
            /if (${announce}==1) /g Casting ${stunone} on %T 
            /call Cast "${stunone}" spell 3s 
         } else /if (${Me.SpellReady[${stuntwo}]}) { 
            /if (${announce}==1) /g Casting ${stuntwo} on %T 
            /call Cast "${stuntwo}" spell 3s 
         } else /chat #${mychannel} stuns not ready 
      } else /chat #${mychannel} wrong target (${Target.Type} at ${Target.PctHPs}% HP) 
   } 
   /if (${ChatText.Equal[buffme]}) { 
      /call FindExactPC ${Sender} 
      /if (${Macro.Return.NotEqual[TARGET_SUCCESS]}) /return 
      /if (${Target.Class.Name.Equal[Paladin]}) { 
         /call Cast "${longhpbuff}" gem4 10s 
         /if (${FindItem[Breastplate of Vengeful Fury].ID}) /call Cast "Breastplate of Vengeful Fury" item 
         /if (!${FindItem[Breastplate of Vengeful Fury].ID}) /call Cast "${spellhastebuff}" gem8 5s 
         /return 
      } 
      /if ((${Target.Class.Name.NotEqual[Warrior]})&&(${Target.Class.Name.NotEqual[Monk]})&&(${Target.Class.Name.NotEqual[Rogue]})&&(${Target.Class.Name.NotEqual[Berserker]})&&(${Target.Class.Name.NotEqual[Bard]})) { 
         /if (${FindItem[Breastplate of Vengeful Fury].ID}) /call Cast "Breastplate of Vengeful Fury" item 
         /if (!${FindItem[Breastplate of Vengeful Fury].ID}) /call Cast "${spellhastebuff}" gem8 5s 
      } 
      /call Cast "${acbuff}" gem6 7s 
      /call Cast "${singlesmybuff}" gem5 7s 
   } 
   /if ((${ChatText.Equal[patch me]})||(${ChatText.Equal[heal]})||(${ChatText.Equal[heal me]})||(${ChatText.Equal[heal plz]})||(${ChatText.Equal[heal me plz]})||(${ChatText.Equal[need heal]})) { 
      /call FindExactPC ${Sender} 
      /if (${Macro.Return.NotEqual[TARGET_SUCCESS]}) /return 
      /if (${Target.Distance}<=${patchhealrange}) { 
         /if (${announce}==1) /g Casting ${patchheal} on %T 
         /call Cast "${patchheal}" gem2 2s 
         /delay 15 ${Me.SpellReady[${patchheal}]} 
      } else /tell ${Sender} your OOR 
   } 
   /if ((${ChatText.Equal[sym]})||(${ChatText.Equal[wov]})||(${ChatText.Equal[V]})||(${ChatText.Equal[bor]})||(${ChatText.Equal[rgc]})||(${ChatText.Equal[hot me]})||(${ChatText.Equal[ch me]})||(${ChatText.Equal[pb]})) { 
      /if (${Spawn[pc ${Sender}].Distance}>250) /return 
      /call FindExactPC ${Sender} 
      /if (${Macro.Return.NotEqual[TARGET_SUCCESS]}) /return 
   } 
   /if (${ChatText.Equal[sym]}) /call Cast "${singlesmybuff}" gem5 7s 
   /if (${ChatText.Equal[wov]}) /call Cast "${acbuff}" gem6 7s 
   /if (${ChatText.Equal[V]}) /call Cast "${longhpbuff}" gem4 10s 
   /if (${ChatText.Equal[bor]}) { 
      /if (${FindItem[Breastplate of Vengeful Fury].ID}) /call Cast "Breastplate of Vengeful Fury" item 
      /if (!${FindItem[Breastplate of Vengeful Fury].ID}) /call Cast "${spellhastebuff}" gem8 5s 
   } 
   /if (${ChatText.Equal[rgc]}) { 
      /if (${FindItem[Blackflame Sphere].ID}) { 
         /call Cast "Blackflame Sphere" item 
      } else /if (${FindItem[Wand of Casual Blessings].ID}) { 
         /call Cast "Wand of Casual Blessings" item 
      } else /call Cast "${rgcspell}" gem8 5s 
   } 
   /if (${ChatText.Equal[pb]}) /call Cast "Pure Blood" gem6 10s 
   /if (${ChatText.Equal[hot me]}) { 
      /if (${Target.Distance}<=${hotspellrange}) { 
         /if (${announce}==1) /g Casting ${hotspell} on %T 
         /call Cast "${hotspell}" gem2 2s 
         /delay 15 ${Me.SpellReady[${hotspell}]} 
      } else /tell ${Sender} your OOR 
   } 
   /if (${ChatText.Equal[ch me]}) { 
      /if (${Target.Distance}<=100) { 
         /if (${announce}==1) /g Casting Complete Healing on %T 
         /call Cast "Complete Healing" gem2 5s 
         /delay 15 ${Me.SpellReady[${hotspell}]} 
      } else /tell ${Sender} your OOR 
   } 
   /if (${ChatText.Equal[mana check]}) /chat #${mychannel} Cleric Mana ${Me.PctMana}% 
   /if (${ChatText.Equal[slowcamp]}) { 
      /if (${Me.Standing}) /sit 
      /delay 5m ${Me.PctMana}>=98 
      /camp 
      /end 
   } 
/return 

Sub Event_ImDead 
    /echo ENDING MACRO. WE DIED! 
    /endmacro 
/return 

Sub Event_Zoned 
    /echo ENDING MACRO. We Zoned. 
    /endmacro 
/return
 
Last edited:
Sorry about the long ass code post...I couldnt find the way to make that drop down window in the post to make it smaller.

Veg
 
Also, if anyone is using a macro that CTD's when it goes to cast a spell...check your spell_routines and make sure to make the change from .MyCastTime to .CastTime

Veg
 
thx and its a great macro :)

next step if possible is including click items :)
 
Under:
Sub MaintainSelfBuffs

Rich (BB code):
  /if (!${Me.Buff[Storm Guard].ID})  /call Cast "Stormeye Band" item 1
  /if (!${Me.Buff[Maelin's Methodical Mind].ID})  /call Cast "Girdle of Efficiency" item 3s
  /if (!${Me.Buff[Eternal Ward].ID})		  /call Cast "Prismatic Ring of Resistance" item 3s

Modify Me.Buff[xxxxxxxxx].ID

xxxxxxxxx being the name of the buff you want,

then across from it:
/call Cast "yyyyyyyy" item zz

where yyyyyyyy is the name of the item, and zz is how long the cast time is on it.

Of course this will only work for clickies that you have equipped, if you have a buff that it doesn't stack with on already, you'll also get click after click.. so it's best to use a plugin to click em off..
 
That is when you make a clickie .ini and include it to AFCleric. Have stacking checks and stuff too :P If you don't want an .ini can always make a .inc file. MQ2Exchange is the plugin For the winz ^^ can make this really easy to do.
 
why create another file.. when you could keypress with delay or /call cast the item?

just curious
 
look into rogue.mac ,it works perfectly for me and the some would be nice in the afkleri.mac :)

its only because i forget ever to click :)
 
You don't have to do another file you can even do this :
/if (${Me.Buff[Some Buff].Duration}<=3) {
/exchange Itemname slotname
/delay 1s
/cast item "itemname"
/delay casttime
/exchange Wornitem slotname
}
 
Is it posible to add to the macro to turn on and off the option to click a heal spell if gets to low on hp? seems it would be a lot faster then trying to cast a heal spell maybe going a few xtra seconds for MT to get aggro back? Also think it would be cool ti be able to add it to the rh macro as well.
 
Is this macro still working? I have copied and pasted to notepad and saved as AFCleric.mac when I try to bring this up says not able to load afcleric If someone could help me out I would love to have this on my cleric.
 
No offense Tone, but I tend to agree wi/ Army. Make your click a hotkey and /keypress #.

K.I.S.S
 
Is this macro still working? I have copied and pasted to notepad and saved as AFCleric.mac when I try to bring this up says not able to load afcleric If someone could help me out I would love to have this on my cleric.

When you save the macro in notepad, make sure "All file types" option is on, instead of the default "Text File" . Then save it as AFCleric.mac . The saved file you then put in the Macros folder inside your MQ2 Release folder.
 
did that and getting message couldnt open spell_routines.inc unable to add macro line. Was in group and had tank targeted can someone help me out with this?
 
Last edited:
letmein said:
No offense Tone, but I tend to agree wi/ Army. Make your click a hotkey and /keypress #.

K.I.S.S
None taken I'm lazy when it comes to making hotkeys and stuff I just make macros that do everything for me, so I can write/code stuff while grinding exp or farming my precious crystals. :P When I normally 6 box and actually play I have 5 of my toons on bot macs and then I play my tank or puller and sit and write macros inbetween kills lol.
 
bah /keypress # is for noobs!!! lol just kiddin. I just have very strange habits when I am coding... I tend to make everything very universal so anyone can use my macros, but I don't like to share some of them. So, I really don't know why I do it hehe. Old habits die hard I suppose.

/declare imaretardcoder outer string "Noobhaxor"
/declare iownzuatgettingaaandnotbanned outer string "Noobhaxor"

Laterz,
Noob
 
Im having a problem where all it says is I am buffing self over and over again but not actually doing it or anything else. What am i missing?
 
letmein said:
No offense Tone, but I tend to agree wi/ Army. Make your click a hotkey and /keypress #.

K.I.S.S

The code I posted would autoequip the item, click it for you and requip what was there previously. No exchange etc needed. I'm not sure why hotkeying something would be "simpler" then having it auto.
 
i will post my afcleric.mac after i test it some more. it works pretty good so far. just need to adjust the self buffs.
 
I agree that the /Keypress # is simple, but I have 4 diff computers I box on, and I tend to mix up which one I am using for diff toons. When coded rather than set as a hot key, the macro's can be moved to diff computers without having to worry about having specific hotkeys set up for each macro you run. I do admit I have used /keypress a number of times in the past, but it sure can make for a headache in debugging a macro when something is not working and it is not in the macro.
 
Anyone know of an afcleric that works? I am trying to use this one and all it does is keeps casting conviction over and over
 
Give this a try ....

I haven't tested it much ... but I used to use it all the time. I have added Slot 10 support :D which might be buggy as my cleric doesn't have it yet.

Rich (BB code):
|- healer.mac
|- Author: Alatyami, NotAddicted.com
|- Original Credits: <Attempting to find the original author>
|- Secondary Credits: Alatyami, Crystane
|------------------------------------------------------------------------------|
|- Modifications:
|------------------------------------------------------------------------------|
| Aug 14, 2008 - Alatyami
| * Added Slot 10 Memorization.
|------------------------------------------------------------------------------|
|- [07-14-2005] * Fixed the TLO errors
|-              * Removed trickyda, it didn't really work too well anyways
|- by Crystane  :
|- [01-27-2006] * Fixed some code, which made the macro crash.
|-		* Added Checks, if the Requestor of stuff is inside the Group and therefor allowed to request 
|-		  Buffs, etc from the Cleric Via tells.
|-		* Added Password Check to request Groupinvites, Careful dont post your Password, later on via useing
|-		  my version here to modify further and reposting it.
|- [02-12-2006] * Added AutoNuke feature, with toggle and some logic.
|- [03-17-2006] * Added Groupheal on Gift of Mana Feature.
|-		  Autonuke and Groupheal on GoM are toggled on by default now, but can be turned off via tells.
|-		  Added an Areanuke feature on command, for some AE style farming fun.
|- [07-01-2006] * Added Undead nukes and AAs, Hammer and AA as well as a feature to keep up buffs for grp and emself.
|-		  Keeping a Dmgrune on the Grps Tank.
|-		  Placeing a Reverse Damageshield on Mobs
|- [07-05-2006]	  Implemented checks to prevent long buffcasts when a mob is incomming, so the healer is ready to heal when its needed most.
|- [11-07-2006] * New Expansion implemented, still on test. Promised Renewal instead of CH to be able to spotheal meanwhile PRen is going to land.
|------------------------------------------------------------------------------|

#include spell_routines.inc

#event GoMana		"You have been granted a gift of mana#*#"
#event GoMoff		"Your gift of mana fades."
#event OutofFood	"You are out of #1#."
#Event WornOff		"Your #1# spell has worn off of #2#."
#Event WornOff2		"#*# fades."
#Event GainExp		"You gain party experience!!"
#Event HotonInc		"#1# tells you#*#Incomeing pull.#*#"
#Chat Chat
#Chat tell

Sub Main

|------------------READ THIS SECTION AND EDIT IF NEEDED------------------------|
|- The following declarations are used to determine spell names and spell
|- ranges for the spells you would like to use.

	/declare mychannel string outer pullhealer
	/declare autohealmode int outer 3
	|-Edit this line to change your start message to the primary tank
	/declare tankstartmsg string outer Healer alive and awake .. lets kill stuff

	| Spell Customization:
	/declare healspell string outer Complete Healing
	/declare patchheal string outer Sacred Remedy
	/declare hotspell string outer Sacred Elixir
	/declare daspell string outer Divine Barrier
	/declare yaulpspell string outer Yaulp VII
	/declare groupheal string outer Word of Vivification
	/declare acbuff string outer Ward of Valiance
	/declare longhpbuff string outer Tenacity
	/declare grplonghpbuff string outer Hand of Tenacity
	/declare singlesymbuff string outer Symbol of Elushar
	/declare groupsymbuff string outer Elushar's Mark
	/declare spellhastebuff string outer Aura of Purpose Rk. II
	/declare pethealspell string outer Complete Healing
	/declare HammerPet string outer Unswerving Hammer of Retribution
	/declare nukeone string outer Reproval Rk. II
	/declare nuketwo string outer Desolate Undead
	/declare nukeundead string outer Desolate Undead
	| Stun one is without pushback
	/declare stunone string outer Sound of Zeal
	| Stun two is with pushback
	/declare stuntwo string outer Awestruck
	/declare areanuke string outer Calamity
	/declare rootspellname string outer Petrifying Earth
	/declare reverseDS string outer Mark of the Martyr
	/declare slot10 string outer Gate
	
	
	| Options: 
	/declare usegroupheal int outer 1
	/declare usedivarb int outer 1
	/declare healafterdivarb int outer 0
	/declare announce int outer 0
	/declare autosit int outer 1
	/declare distancetosit int outer 40
	/declare autointerrupt int outer 1
	/declare onlyhealfd int outer 1
	/declare interrupt2healself int outer 1
	/declare interrupt2healselfhp int outer 60
	/declare noInvis int outer 1
	/declare defaultstophealpoint int outer 85	
	
	/declare rgcspell string outer NULL
	/declare healpetmode int outer 2
	/declare pethealpoint int outer 65
	/declare manatohealpet int outer 45
   
	/declare rootspelltime int outer 2
	
	/declare selfhealpoint int outer 70
	/declare dacastpoint int outer 40
	/declare divarbpoint int outer 28
	/declare interrupt2divarb int outer 26
	|- Heal at % for WAR/PAL/SK
	/declare tankhealpoint int outer 69
	|- Heal at % for WIZ/MAG/ENC/DRU
	/declare casterhotpoint int outer 75
	/declare casterpatchpoint int outer 55
	|- Heal at % for NEC/SHM
	/declare necshmpatchpoint int outer 45
	|- Heal at % for all other classes
	/declare defaultpatchpoint int outer 60
	|- Nuke till down to % Mana.
	/declare Manatonuke int outer 70
	|- Customize your Password here
	/declare YourPW string outer YourPassword

|------------------------END EDITING------------------------|
	/declare RevDSon outer FALSE
	/declare PossibleIncom	outer FALSE

	/declare BigHealtimer timer outer
	/declare BigHealtimer2 timer outer
	/declare Bighealtimeramount int outer
	/declare UseingPrRenewal outer FALSE
	/if (${Spell[${healspell}].ID}==${Spell[Complete Healing].ID}) /varset Bighealtimeramount 0
	/if (${Spell[${healspell}].ID}==${Spell[Promised Renewal].ID}) {
		/varset Bighealtimeramount 180
		/varset UseingPrRenewal TRUE
	}
	
	/declare healspellrange int outer ${Spell[${healspell}].Range}
	/declare patchhealrange int outer ${Spell[${patchheal}].Range}
	/declare hotspellrange int outer ${Spell[${hotspell}].Range}	
	/declare grouphealrange int outer ${Spell[${groupheal}].AERange}
	/declare pethealspellrange int outer ${Spell[${pethealspell}].Range}
	
   /declare tankname string outer ${Target}
   /declare tanknameid int outer
   /declare tankclass string outer
   /declare healpct int outer

/if (${Select[${Spawn[${tankname}].Class},Warrior,Palladin,ShadowKnight]}>=1) /varset healpct 78
/if (${Select[${Spawn[${tankname}].Class},Wizard,Druid,Mage]}>=1) {
	/varset healpct 90
	/varset Manatonuke 20
	} else /varset healpct 75
/if (${tankhealpoint}<${healpct}) /varset tankhealpoint ${healpct}

/echo Healpct set to ${healpct}
/echo Manatonuke set to ${Manatonuke}
   /declare minorhurt int outer 0
   /declare majorhurt int outer 0
   /declare worsthurt string outer NULL
   /declare worsthurtid int outer
   /declare worsthp int outer 100
   /declare worstclass string outer NULL
   /declare gmember int outer
   /declare nohotforua string outer NULL
   /declare nohotforub string outer NULL
   /declare nohotforuc string outer NULL
   /declare nohotforud string outer NULL
   /declare rodwait int outer 0
   /declare following int outer 0
   /declare follname string outer NULL
   /declare pallycount int outer 0
   /declare stophealpoint int outer ${defaultstophealpoint}
   /declare buffbeg int outer 0
   /declare oomspam int outer 1
   /declare lomspam int outer 1
   /declare duckspam int outer 0
   /declare duckfdspam int outer 1
   /declare duckselfspam int outer 0
   /declare nomtspam int outer 1
   /declare ghealhurtcount int outer 0
   /declare divarboor int outer 0
   /declare aetime int outer 0
   /declare autonuke int outer 1
   /declare GrpHealonGoM int outer 1
   /declare GoMana int outer 0
   /declare Casttimer timer outer


|-- Group and Self Buffs to keep up!

|- Set to TRUE if you want to keep some buffs on ya automatically.
|- Or FALSE if you want no possible delay in any heals.

	/declare DoAutoBuffs outer TRUE

|----------------------------------------------------------
	/declare Rebuffing outer FALSE
	/declare Rebuffstate outer TRUE
	/declare SpellBufftodo[9] string outer 
	/varset SpellBufftodo[1] "Armor of the Sacred" 
	/varset SpellBufftodo[2] "Aura of Purpose Rk. II"
	/varset SpellBufftodo[3] "Hand of Tenacity"
	/varset SpellBufftodo[4] "Elushar's Mark"
	/varset SpellBufftodo[5] "Rallied Aegis of Vie"
	/varset SpellBufftodo[6] NULL
	/varset SpellBufftodo[7] NULL
	/varset SpellBufftodo[8] NULL
	/varset SpellBufftodo[9] NULL

	/declare TankWornOff[5] outer TRUE
	/declare TankBufftodo[5] string outer 

	/varset TankBufftodo[1] NULL
	/varset TankBufftodo[2] NULL
	/varset TankBufftodo[3] NULL
	/varset TankBufftodo[4] NULL
	/varset TankBufftodo[5] NULL


|-- Uncomment the following line if you want to use a chat channel
  |-- /join ${mychannel}


   /if ((!${Target.ID})||(!${Group.Member[${Target.CleanName}]})) {
      /echo Target the Tank when you run this macro to designate him as MT
      /echo He needs to be in the group as well.
      /end
   } else {
      /varset tanknameid ${Target.ID}
      /varset tankclass ${Target.Class.Name}
   }

   /if (${Defined[Param0]}) {
      /varset healpct ${Param0}
   } else /echo No Heal% specified, defaulting to ${healpct}

   /if (!${Defined[Param1]}) {
      /echo Usage: /mac Healer % healspell
      /echo Example: /mac Healer 40 Complete Heal
      /echo Defaulting to ${healspell} at ${healpct}%
   } else {
      /if (!${Defined[Param2]}) {
         /varset healspell ${Param1}
      } else /if (!${Defined[Param3]}) {
         /varset healspell ${Param1} ${Param2}
      } else /if (!${Defined[Param4]}) {
         /varset healspell ${Param1} ${Param2} ${Param3}
      } else {
         /varset healspell ${Param1} ${Param2} ${Param3} ${Param4}
      }
   }

|   /call ExpPrep  |- Start the xp tracker,

   /echo AutoHealer Active, running in Autohealmode ${autohealmode}
   /echo Casting ${healspell} on ${tankname} at ${healpct}% HP
   /echo Features [autonuke] and [GrpHealonGoM] are enabled. (toggle on/off)
   /delay 2s
|   /tell ${tankname} Do you know the Commandlist for Clr AA's?
   /if (${autohealmode}==0) /echo ONLY ${tankname} will be healed
   /if (${autohealmode}==1) /echo ONLY ${tankname} and myself will be healed
   /if (${autohealmode}==2) /echo ${tankname}, myself and my group will be healed
   /if (${autohealmode}==3) /echo ${tankname} and myself will be healed before the rest of the group

   /call MemSpells

   :tankwatchloop

   /if (${Spawn[${tanknameid}].Name.NotEqual[${tankname}]}) /varset tanknameid 0
   /if (!${Spawn[${tanknameid}].ID}) /if (${Spawn[${tankname}].ID}) {
      /if (${SpawnCount[${tankname} ${tankclass}]}==1) {
         /varset tanknameid ${Spawn[${tankname} ${tankclass}].ID}
         /echo ${Spawn[${tankname} ${tankclass}].Name} is the designated MT and has ID# ${tanknameid}
      }
      /if (${SpawnCount[${tankname} ${tankclass}]}>1) {
         /if (${SpawnCount[pc ${tankname} ${tankclass}]}==1) {
            /beep
            /varset tanknameid ${Spawn[pc ${tankname} ${tankclass}].ID}
            /echo Defaulting to PC ${Spawn[pc ${tankname} ${tankclass}].Name} as MT. If incorrect, please restart macro
         } else {
            /beep
            /echo Need to restart macro to correctly identify the MT
         }
      }
   }
   /if (${Spawn[${tanknameid}].ID}) /if (${Spawn[${tanknameid}].Type.Equal[Corpse]}) {
      /if (${SpawnCount[pc ${tankname} ${tankclass}]}==1) {
         /varset tanknameid ${Spawn[pc ${tankname} ${tankclass}].ID}
         /echo ${Spawn[pc ${tankname} ${tankclass}].Name} is MT and has ID# ${tanknameid}. If incorrect, please restart macro
      }
   }
   /if ((!${Target.ID})||(${Target.ID}!=${tanknameid})) {
      /if (${Spawn[${tanknameid}].ID}) /if (${Spawn[${tanknameid}].Type.NotEqual[Corpse]}) {
         /target id ${tanknameid}
         /delay 6 ${Target.ID}==${tanknameid}
      }
   }
   /if (!${Spawn[${tanknameid}].ID}) {
      /if (${nomtspam}==1) {
         /echo Warning No Designated MT is available
         /timed 300 /varset nomtspam 1
         /varset nomtspam 0
      }
   }
|  /if ((!${Spawn[${tankname}].NearestSpawn[npc radius 40 zradius 15].ID})&&(${Me.Pet.ID}<1)) /varset RevDSon FALSE
   /doevents HotonInc
   /call Nukeing
   /if ((${Me.PctMana}<=50)&&(${announce}==1)&&(${lomspam}==1)) {
      /tell ${tankname} ${Me.PctMana}m
      /varset lomspam 0
      /timed 300 /varset lomspam 1
   }
   /if ((${Me.PctMana}<=7)&&(${announce}==1)&&(${oomspam}==1)) {
      /tell ${tankname} oom
      /varset oomspam 0
      /timed 300 /varset oomspam 1
      /call MedTime
   }
   /if (${GameState.Equal[CHARSELECT]}) /end
   /if (${Target.ID}==${tanknameid}) {
      /varset stophealpoint ${Math.Calc[${healpct}*1.1]}
      /if ((${Target.Distance}<=${patchhealrange})&&(${Target.PctHPs}<=${Math.Calc[0.7*${healpct}]})&&(${Target.PctHPs}>=1)) {
         /if ((${announce}==1)&&(!${Me.Invis})) /tell ${tankname} (${patchheal}) --- %T ---
         /call Cast "${patchheal}" gem2 1s CheckHP
         /delay 15 ${Me.SpellReady[${patchheal}]}
      }
      /if ((${Target.Distance}<=${healspellrange})&&(${Target.PctHPs}<=${healpct})&&(${Target.PctHPs}>=${Math.Calc[0.7*${healpct}]})&&${BigHealtimer}<1) {
         /if ((${announce}==1)&&(!${Me.Invis})) /tell ${tankname} (${healspell}) --- %T ---
         /call Cast "${healspell}" gem1 1s CheckHP
         /delay 15 ${Me.SpellReady[${healspell}]}
	 /if (${UseingPrRenewal} && ${Macro.Return.Equal[CAST_SUCCESS]}) /varset BigHealtimer ${Bighealtimeramount}
        /if ((${announce}==1)&&(!${Me.Invis})) /tell ${tankname} ${Me.PctMana}
      }
      /varset stophealpoint ${defaultstophealpoint}
      /call CheckEvents
   }
   /if ((${autosit}>=1)&&(${Bool[${Me.Sitting}]})&&(!${Window[SpellBookWnd].Open})) {
      /if ((${Me.PctMana}>98)||(${Me.PctHPs}<=90)) /stand
   }
   /if ((${autosit}==1)&&(${Bool[${Me.Sitting}]})&&(!${Window[SpellBookWnd].Open})) {
      /if (${NearestSpawn[NPC].Distance}<=${Math.Calc[${NearestSpawn[NPC].MaxRange}+${Math.Calc[${distancetosit}/3]}]}) /stand
   }
   /if (${autohealmode}==0) {
      /call CheckEvents
      /goto :tankwatchloop
   }
   /if ((${autohealmode}>=1)&&(${Me.PctHPs}<=${selfhealpoint})) /call Healself
   /if (${autohealmode}>=2) {
      /if ((${Target.PctHPs}>${healpct})||(${Target.Distance}>${healspellrange})||(${Target.PctHPs}<=1)||(!${Target.ID})||(${Target.ID}!=${tanknameid}    )) {
         /call Healgroup
      }
   }
   /if ((${autohealmode}<2)&&(${Me.PctHPs}>${selfhealpoint})&&(${Me.PctMana}<=98)) /call MedTime
   /call CheckEvents
   /goto :tankwatchloop
/return

Sub MemSpells 

   /echo Memming spells. Hang on. 
   /if ( !${Me.Gem[${healspell}]} ) { 
	/echo Memming Spell ${healspell}
	/memspell 1 "${healspell}"
	/delay 25 
   } 
   /if ( !${Me.Gem[${patchheal}]} ) { 
	/echo Memming Spell ${patchheal}
      /memspell 2 "${patchheal}"
      /delay 25 
   } 
   /if ( !${Me.Gem[${hotspell}]} ) { 
	/echo Memming Spell ${hotspell}
      /memspell 3 "${hotspell}"
      /delay 25 
   } 
   /if ( !${Me.Gem[${groupheal}]} ) { 
	/echo Memming Spell ${groupheal}
      /memspell 4 "${groupheal}"
      /delay 25
   } 
   /if ( !${Me.Gem[${HammerPet}]} ) { 
	/echo Memming Spell ${HammerPet}
      /memspell 5 "${HammerPet}"
      /delay 20 
   } 
   /if ( !${Me.Gem[${nukeone}]} ) { 
	/echo Memming Spell ${nukeone}
      /memspell 6 "${nukeone}"
      /delay 30 
   }
   /if ( !${Me.Gem[${daspell}]} ) { 
	/echo Memming Spell ${daspell}
      /memspell 7 "${daspell}"
      /delay 20 
   } 
   /if ( !${Me.Gem[${nukeundead}]} ) { 
	/echo Memming Spell ${nukeundead}
      /memspell 8 "${nukeundead}"
      /delay 30 
   } 
   /if ( !${Me.Gem[${reverseDS}]} ) { 
	/echo Memming Spell ${reverseDS}
      /memspell 9 "${reverseDS}"
      /delay 30 
   }
    
   /if ( !${Me.Gem[${slot10}]} ) { 
      /echo Memming Spell ${slot10}
      /memspell 10 "${slot10}"
      /delay 30 
   } 

	/echo Spells are memmed. 
	/if (${Window[SpellBookWnd].Open}) /cleanup
/return 

Sub Event_HotonInc(line, SenderName)
	/if (!${Group.Member[${SenderName.Arg[1]}]}) /return
	/if (${Target.ID}!=${Spawn[${tankname}].ID}) {
		/target ${tankname}
		/delay 1s ${Target.ID}==${Spawn[${tankname}].ID}
	}
	/if (${Me.SpellReady[${hotspell}]} && !${Me.Casting.ID} && ${Target.Distance}<${Spell[${hotspell}].Range}) {
		/call Cast "${hotspell}" gem3 5s
	}
/return

Sub Nukeing
	/if ((${Me.PctMana}>=${Manatonuke})&&(${autonuke}==1)&&(${Spawn[${tankname}].PctHPs}>${tankhealpoint})&&(${Spawn[${tankname}].NearestSpawn[npc radius 30 zradius 15].ID} || ${Select[${Spawn[${tankname}].Class},Wizard,Druid,Necromancer]}>=1)&&(${Me.PctHPs}>80)) {
		/assist ${tankname}
		/delay 1s ${Target.Type.Equal[NPC]}
		/if (${Target.Type.NotEqual[NPC]}) {
			/assist ${tankname}
			/delay 5 ${Target.Type.Equal[NPC]}
		}
		/delay 5
		/if (${Target.Type.Equal[PC]}) /goto :skipautonuke
		/if ((${Target.Type.Equal[NPC]})&&(${Target.PctHPs}<=90)) {
			/if (${Me.Book[${reverseDS}]}>0 && ${Target.PctHPs}>55 && !${RevDSon} && ${Spawn[${tankname}].PctHPs}>${healpct}) {
				/if (${Me.SpellReady[${reverseDS}]}) {
					/call cast "${reverseDS}" gem9 1s NukeBuffCheckHP
					/if (${Macro.Return.Equal[CAST_SUCCESS]}) /varset RevDSon TRUE
					/goto :Nukedone
				} else {
					/if (${Me.Gem[${reverseDS}]}!=9) /memspell 9 "${reverseDS}"
					/delay 4s
					/goto :Nukedone
				}
			}
			/if (${Me.Pet.ID}<1 && ${Me.Book[${HammerPet}]}>0 && ${Spawn[${tankname}].PctHPs}>${healpct}) {
				/if (${Select[${Spawn[${tankname}].Class},Wizard,Druid,Necromancer]}>=1 && ${Target.Speed}<1) /goto :skippet
				/delay 5 ${Me.SpellReady[${HammerPet}]}
				/call cast "${HammerPet}" gem5 1s NukeBuffCheckHP
				/if (${Me.AltAbility[Celestial Hammer]}>0 && ${Me.AltAbilityReady[Celestial Hammer]}) /call cast "Celestial Hammer" alt 1s
				/goto :Nukedone
			}
			:skippet
			/if (${Me.SpellReady[${nukeone}]} && ${Select[${Target.Body},Undead]}!=1 && ${Spawn[${tankname}].PctHPs}>${healpct}) {
				/if ((${announce}==1)&&(!${Me.Invis})) /tell ${tankname} %T shal feel the wrath of Brell! (${nukeone})
				/call Cast "${nukeone}" gem5 1s NukeBuffCheckHP
				/delay 5
			} else /if (${Me.SpellReady[${nukeundead}]} && ${Select[${Target.Body},Undead]}==1 && ${Spawn[${tankname}].PctHPs}>${healpct}) {
				/if ((${announce}==1)&&(!${Me.Invis})) /tell ${tankname} %T shal feel the wrath of Brell! (${nukeundead})
				/if (${Me.AltAbility[Turn Undead]}>0 && ${Me.AltAbilityReady[Turn Undead]} && ${Target.PctHPs}>50) /call cast "Turn Undead" alt 1s
				/delay 3
				/call Cast "${nukeundead}" gem8 1s NukeBuffCheckHP
				/delay 5
			} else {
				/if (${Me.Gem[${nukeundead}]}!=8 && ${Select[${Target.Body},Undead]}==1) {
					/memspell 8 "${nukeundead}"
					/delay 20
				}
				/if (${Me.SpellReady[${stunone}]} && ${Spawn[${tankname}].PctHPs}>${healpct}) {
					/if ((${announce}==1)&&(!${Me.Invis})) /tell ${tankname} %T shal feel the wrath of Brell! (${stunone})
					/call Cast "${stunone}" gem6 1s NukeBuffCheckHP
					/delay 5
				}
			} 
		}
		:Nukedone
		/doevents GoMana
		:skipautonuke
		/target ${tankname}
		/delay 1s ${Target.Type.Equal[PC]}
	}
/return

Sub Healself
   /if (${Me.PctHPs}>${selfhealpoint}) /return
   /varset stophealpoint ${Math.Calc[${selfhealpoint}+5]}
   /if ((!${Target.ID})||(${Target.PctHPs}>=${Math.Calc[1.1*${healpct}]})||(${Target.PctHPs}<=1)||(${Target.ID}!=${tanknameid})) {
      /if ((${Me.PctHPs}<=${selfhealpoint})&&(${Me.PctHPs}>${dacastpoint})) {
         /target myself
         /delay 6 ${Target.Name.Equal[${Me}]}
         /if (${Target.Name.Equal[${Me}]}) {
            /if ((${announce}==1)&&(!${Me.Invis})) /tell ${tankname} (${patchheal}) --- %T ---
            /call Cast "${patchheal}" gem2 1s CheckHP
            /delay 15 ${Me.SpellReady[${patchheal}]}
         }
      }
   }
   /if (${Me.PctHPs}<=${Math.Calc[${selfhealpoint}*0.7]}) {
      /target myself
      /delay 6 ${Target.Name.Equal[${Me}]}
      /if (${Target.Name.Equal[${Me}]}) {
         /if ((${announce}==1)&&(!${Me.Invis})) /tell ${tankname} (${patchheal}) --- %T ---
         /varset stophealpoint ${Math.Calc[${selfhealpoint}+5]}
         /call Cast "${patchheal}" gem2 1s CheckHP
         /delay 15 ${Me.SpellReady[${patchheal}]}
      }
   }
   /varset stophealpoint ${defaultstophealpoint}
/return


Sub Healgroup
   :healgroup
   /varset worsthurt NULL
   /varset worsthp 100
   /varset worstclass NULL
   /varset minorhurt 0
   /varset majorhurt 0
   /varset ghealhurtcount 0
   /for gmember 0 to ${Group}
      /if (${onlyhealfd}==0) {
         /if (${Group.Member[${gmember}].Distance}<=${patchhealrange}) {
            /if (${Group.Member[${gmember}].PctHPs}<=${worsthp}) {
               /varset worsthurt ${Group.Member[${gmember}].Name}
               /varset worsthurtid ${Group.Member[${gmember}].ID}
               /varset worsthp ${Group.Member[${gmember}].PctHPs}
               /varset worstclass ${Group.Member[${gmember}].Class.Name}
            }
         }
      }
      /if (${onlyhealfd}==1) {
         /if (${Group.Member[${gmember}].Distance}<=${patchhealrange}) {
            /if ((${Group.Member[${gmember}].Class.Name.NotEqual[Monk]})&&(${Group.Member[${gmember}].Class.Name.NotEqual[Necromancer]})&&(${Group.Member[${gmember}].PctHPs}<=${worsthp})) {
               /varset worsthurt ${Group.Member[${gmember}].Name}
               /varset worsthurtid ${Group.Member[${gmember}].ID}
               /varset worsthp ${Group.Member[${gmember}].PctHPs}
               /varset worstclass ${Group.Member[${gmember}].Class.Name}
            }
            /if ((${Group.Member[${gmember}].Class.Name.Equal[Monk]})||(${Group.Member[${gmember}].Class.Name.Equal[Necromancer]})) {
               /if ((${Group.Member[${gmember}].State.Equal[feign]})&&(${Group.Member[${gmember}].PctHPs}<=${worsthp})) {
                  /varset worsthurt ${Group.Member[${gmember}].Name}
                  /varset worsthurtid ${Group.Member[${gmember}].ID}
                  /varset worsthp ${Group.Member[${gmember}].PctHPs}
                  /varset worstclass ${Group.Member[${gmember}].Class.Name}
               }
            }
         }
      }
      /if ((${Group.Member[${gmember}].Distance}<=${grouphealrange})&&(${Group.Member[${gmember}].PctHPs}<=85)) /varcalc ghealhurtcount ${ghealhurtcount}+1
      /if ((${Group.Member[${gmember}].PctHPs}<=75)&&(${Group.Member[${gmember}].PctHPs}>=55)) /varcalc minorhurt ${minorhurt}+1
      /if ((${Group.Member[${gmember}].PctHPs}<=55)&&(${Group.Member[${gmember}].PctHPs}>=1)) /varcalc majorhurt ${majorhurt}+1
   /next gmember
   /if (${autohealmode}==3) {
      /if ((!${Target.ID})||(${Target.Name.NotEqual[${tankname}]})) /if (${Spawn[${tanknameid}].ID}) {
         /target id ${tanknameid}
         /delay 6 ${Target.ID}==${tanknameid}
         /delay 1
         /if ((${Target.ID}==${tanknameid})&&((${Target.PctHPs}<=${healpct})||(${GoMana}>0))&&(${Target.Distance}<=${healspellrange})) /return
      }
      /if (${Me.PctHPs}<=${selfhealpoint}) /return
   }
   /if ((${majorhurt}==0)&&(${minorhurt}==0)&&(${GoMana}==0)) {
      /if (${Spawn[${tanknameid}].ID}) {
         /target id ${tanknameid}
         /delay 6 ${Target.ID}==${tanknameid}
         /delay 1
      }
      /if (((${Target.ID}==${tanknameid})&&(${Target.PctHPs}>${healpct}))||(!${Spawn[${tanknameid}].ID})||(${Spawn[${tanknameid}].Type.Equal[corpse]})) {
         /if (${Me.PctMana}<=98) /call MedTime
      }
      /call CheckEvents
      /return
   }
   /if ((${usedivarb}==1)&&(${worsthp}<=${divarbpoint})&&(${Me.AltAbilityReady[divine arbitration]})) /call Divarbcast
   /if ( ((${Math.Calc[${majorhurt}+${minorhurt}]}>=3)&&(${usegroupheal}==1))||((${GoMana}==1)&&(${usegroupheal}==1)) ) {
      /if ((${announce}==1)&&(!${Me.Invis})) /tell ${tankname} Inc Grp Heal, get close
      /call Cast "${groupheal}" gem4 1s
      /delay 15 ${Me.SpellReady[${groupheal}]}
      /call CheckEvents
      /return
   }
   /if (${worsthurtid}==${tanknameid}) /return
   /if (${worsthurtid}==${Me.ID}) {
      /call Healself
      /call CheckEvents
      /return
   }

   /if (${Select[${worstclass},Warrior,Paladin,Shadow Knight]}>0) {
      /if ((${worsthp}<=${tankhealpoint})&&(${worsthp}>=${Math.Calc[0.7*${tankhealpoint}]})&&(${majorhurt}<=1)&&(${minorhurt}<=1)&&${BigHealtimer2}<1) {
         /target id ${worsthurtid}
/echo ${worstclass}
    /delay 5 ${Target.ID}==${worsthurtid}
         /if (!${Target.ID}) /return
         /if (${Target.ID}!=${worsthurtid}) /return
/echo ${Target.Name}
         /varset stophealpoint ${Math.Calc[${tankhealpoint}+5]}
         /if ((${announce}==1)&&(!${Me.Invis})) /tell ${tankname} ((${healspell}) --- %T ---
        /if (${announce}==1) /tell ${tankname} ${Me.PctMana}
/echo Casting ${healspell}
         /call Cast "${healspell}" gem1 1s CheckHP
         /delay 15 ${Me.SpellReady[${healspell}]}
	 /if (${UseingPrRenewal} && ${Macro.Return.Equal[CAST_SUCCESS]}) /varset BigHealtimer2 ${Bighealtimeramount}
         /varset stophealpoint ${defaultstophealpoint}
         /call CheckEvents
         /return
      }
      /if (${worsthp}<=${tankhealpoint}) {
         /target id ${worsthurtid}
    /delay 5 ${Target.ID}==${worsthurtid}
         /if (!${Target.ID}) /return
         /if (${Target.ID}!=${worsthurtid}) /return
         /varset stophealpoint ${Math.Calc[${tankhealpoint}+5]}
         /if ((${announce}==1)&&(!${Me.Invis})) /tell ${tankname} (${patchheal}) --- %T ---
         /call Cast "${patchheal}" gem2 1s CheckHP
         /delay 15 ${Me.SpellReady[${patchheal}]}
         /varset stophealpoint ${defaultstophealpoint}
         /call CheckEvents
         /return
      }
   } else /if (${Select[${worstclass},Magician,Wizard,Enchanter,Druid]}>0) {
      /if ((${worsthp}<=${casterhotpoint})&&(${worsthp}>${casterpatchpoint})) {
         /if (${Select[${worsthurt},${nohotforua},${nohotforub},${nohotforuc},${nohotforud}]}>=1) /return
         /if (${Select[${nohotforua},NULL]}>=1) {
            /target id ${worsthurtid}
       /delay 5 ${Target.ID}==${worsthurtid}
       /if (!${Target.ID}) /return
            /if (${Target.ID}!=${worsthurtid}) /return
            /varset nohotforua ${Target.Name}
            /if ((${announce}==1)&&(!${Me.Invis})) /tell ${tankname} (${hotspell}) --- %T ---
            /varset stophealpoint ${Math.Calc[${casterhotpoint}+5]}
            /call Cast "${hotspell}" gem3 1s CheckHP
            /timed 200 /varset nohotforua NULL
            /delay 15 ${Me.SpellReady[${hotspell}]}
         } else /if (${Select[${nohotforub},NULL]}>=1) {
            /target id ${worsthurtid}
       /delay 5 ${Target.ID}==${worsthurtid}
       /if (!${Target.ID}) /return
            /if (${Target.ID}!=${worsthurtid}) /return
       /varset nohotforub ${Target.Name}
            /if ((${announce}==1)&&(!${Me.Invis})) /tell ${tankname} (${hotspell}) --- %T ---
            /varset stophealpoint ${Math.Calc[${casterhotpoint}+5]}
            /call Cast "${hotspell}" gem3 1s CheckHP
            /timed 200 /varset nohotforub NULL
            /delay 15 ${Me.SpellReady[${hotspell}]}
         } else /if (${Select[${nohotforuc},NULL]}>=1) {
            /target id${worsthurtid}
       /delay 5 ${Target.ID}==${worsthurtid}
       /if (!${Target.ID}) /return
            /if (${Target.ID}!=${worsthurtid}) /return
       /varset nohotforuc ${Target.Name}
            /if ((${announce}==1)&&(!${Me.Invis})) /tell ${tankname} (${hotspell}) --- %T ---
            /varset stophealpoint ${Math.Calc[${casterhotpoint}+5]}
            /call Cast "${hotspell}" gem3 1s CheckHP
            /timed 200 /varset nohotforuc NULL
            /delay 15 ${Me.SpellReady[${hotspell}]}
         } else /if (${Select[${nohotforud},NULL]}>=1) {
            /target id ${worsthurtid}
       /delay 5 ${Target.ID}==${worsthurtid}
       /if (!${Target.ID}) /return
            /if (${Target.ID}!=${worsthurtid}) /return
       /varset nohotforud ${Target.Name}
            /if ((${announce}==1)&&(!${Me.Invis})) /tell ${tankname} (${hotspell}) --- %T ---
            /varset stophealpoint ${Math.Calc[${casterhotpoint}+5]}
            /call Cast "${hotspell}" gem3 1s CheckHP
            /timed 200 /varset nohotforud NULL
            /delay 15 ${Me.SpellReady[${hotspell}]}
         }
         /varset stophealpoint ${defaultstophealpoint}
         /call CheckEvents
         /return
      }
      /if ((${worsthp}<=${casterpatchpoint})&&(${worsthp}>=1)) {
         /target id ${worsthurtid}
    /delay 5 ${Target.ID}==${worsthurtid}
    /if (!${Target.ID}) /return
         /if (${Target.ID}!=${worsthurtid}) /return
         /if ((${announce}==1)&&(!${Me.Invis})) /tell ${tankname} (${patchheal}) --- %T ---
         /call Cast "${patchheal}" gem2 1s CheckHP
         /varset stophealpoint ${defaultstophealpoint}
         /call CheckEvents
         /delay 15 ${Me.SpellReady[${patchheal}]}
         /return
      }
      /varset stophealpoint ${defaultstophealpoint}
   } else /if (${Select[${worstclass},Necromancer,Shaman]}>0) {
      /if ((${worsthp}<=${necshmpatchpoint})&&(${worsthp}>=1)) {
         /target id ${worsthurtid}
    /delay 5 ${Target.ID}==${worsthurtid}
    /if (!${Target.ID}) /return
         /if (${Target.ID}!=${worsthurtid}) /return
         /varset stophealpoint ${Math.Calc[${necshmpatchpoint}+5]}
         /if ((${announce}==1)&&(!${Me.Invis})) /tell ${tankname} (${patchheal}) --- %T ---
    /call Cast "${patchheal}" gem2 1s CheckHP
    /varset stophealpoint ${defaultstophealpoint}
    /call CheckEvents
    /delay 15 ${Me.SpellReady[${patchheal}]}
    /return
      }
   } else /if ((${worsthp}<=${defaultpatchpoint})&&(${worsthp}>=1)) {
      /target id ${worsthurtid}
      /delay 5 ${Target.ID}==${worsthurtid}
      /if (!${Target.ID}) /return
      /if (${Target.ID}!=${worsthurtid}) /return
      /if ((${announce}==1)&&(!${Me.Invis})) /tell ${tankname} (${patchheal}) --- %T ---
      /varset stophealpoint ${Math.Calc[${defaultpatchpoint}+5]}
      /call Cast "${patchheal}" gem2 1s CheckHP
      /varset stophealpoint ${defaultstophealpoint}
      /call CheckEvents
      /delay 15 ${Me.SpellReady[${patchheal}]}
      /return
   }
   /varset stophealpoint ${defaultstophealpoint}
|   /if ((${healpetmode}==2)&&(${Me.PctMana}>${manatohealpet})) /call HealPet
/return


Sub Divarbcast
   /varset divarboor 0
   /for gmember 0 to ${Group}
      /if (${Group.Member[${gmember}].Distance}>200) /varcalc divarboor ${divarboor}+1
   /next gmember
   /if (${Math.Calc[${Group}-${divarboor}]}>=2) {
      /if ((${announce}==1)&&(!${Me.Invis})) /tell ${tankname} Inc Divine Arbitration
      /call Cast "Divine Arbitration" alt 2s
      /if ((${healafterdivarb}==1)&&((${Me.PctMana}>40)||((${Me.PctMana}>20)&&(${GoMana}>0)))) {
         /if ((${announce}==1)&&(!${Me.Invis})) /tell ${tankname} Inc Grp Heal, get close
         /call Cast "${groupheal}" gem4 2s
         /delay 15 ${Me.SpellReady[${groupheal}]}
      }
   }
/return





Sub CheckEvents
   /delay 1
   /doevents GainExp
   /doevents GoMoff
   /doevents GoMana
   /doevents Chat
   /doevents tell
	/doevents
   /doevents flush
   /call Checkbuffs
/return


Sub MedTime
   :oomwait
   /call CheckEvents
   /doevents HotonInc
   /If ((${FindItem["Rod of Mystical Transvergance"].InvSlot})&&(${Me.PctMana}<=70)&&(${Me.PctHPs}>=98)&&(${rodwait}==0)) {
      /call Cast "Rod of Mystical Transvergance" item
      /varset rodwait 1
      /timed 3000 /varset rodwait 0
   }
   /if ((${autosit}==1)&&(${Me.PctMana}<=98)&&(!${Me.Casting.ID})) {
      /if ((${Bool[${Me.Standing}]})&&(${NearestSpawn[NPC].Distance}>=${Math.Calc[${NearestSpawn[NPC].MaxRange}+${distancetosit}]})&&(${Me.PctHPs}>90)) /sit
      /if ((${Bool[${Me.Sitting}]})&&(!${Window[SpellBookWnd].Open})&&(${NearestSpawn[NPC].Distance}<=${Math.Calc[${NearestSpawn[NPC].MaxRange}+${Math.Calc[${distancetosit}/3]}]})) /stand
   }
   /if ((${Bool[${Me.Standing}]})&&(${autosit}==2)&&(${Me.PctMana}<=98)&&(${Me.PctHPs}>90)&&(!${Me.Casting.ID})) /sit
   /if ((${Bool[${Me.Sitting}]})&&(${autosit}>=1)&&(${Me.PctMana}>98)&&(!${Window[SpellBookWnd].Open})) /stand
   /if ((${Bool[${Me.Standing}]})&&(!${Me.Mount.ID})&&(${Me.SpellReady[${yaulpspell}]})&&(!${Me.Buff[${yaulpspell}].ID})) {
      /if ((!${Me.Buff[Vallon].ID})&&(!${Me.Buff[Spiritual Vigor].ID})&&(!${Me.Buff[Strength of Tunare].ID})) /call Cast "${yaulpspell}"
   }
   /if (${buffbeg}==1) /call Buffbeg
   /if (${Me.PctHPs}<=${selfhealpoint}) /return
   /if (${Me.PctMana}<=8) /goto :oomwait
/return

Sub NukeBuffCheckHP
   /if (!${Window[CastingWindow].Open}) /return
   /if ((${autointerrupt}>=1)&&(${Spawn[${tankname}].PctHPs}<${tankhealpoint})) {
      /if ((${announce}==1)&&(${duckspam}==1)) {
         /echo Ducking heal on ${Target.Name}
         /varset duckspam 0
         /timed 60 /varset duckspam 1
      }
      /call Interrupt
      /return
   }
   /if ((${interrupt2healself}==1)&&(${Target.Name.NotEqual[${Me}]})&&(${Me.PctHPs}<${interrupt2healselfhp})) {
      /if ((${usedivarb}==1)&&(${Me.PctHPs}<=${divarbpoint})&&(${Me.AltAbilityReady[Divine Arbitration]})) {
         /call Interrupt
         /call Divarbcast
         /return
      }
      /if ((${announce}==1)&&(${duckselfspam}==1)) {

         /echo Ducking heal or buffspell on ${Target} so I can heal myself
         /varset duckselfspam 0
         /timed 60 /varset duckselfspam 1
      }
      /call Interrupt
      /return
   }
   /for gmember 0 to ${Group}
   /if ((${usedivarb}==1)&&(${Spawn[${Group.Member[${gmember}]}].PctHPs}<=${divarbpoint})&&(${Spawn[${Group.Member[${gmember}]}].Distance}<=200)&&(${Me.AltAbilityReady[Divine Arbitration]})&&(${castEndTime}>=${interrupt2divarb})) {
            /call Interrupt
            /call Divarbcast
            /return
   }
   /next gmember
/return

Sub CheckHP
   /if (!${Window[CastingWindow].Open}) /return
   /if ((${autointerrupt}>=1)&&(${Target.PctHPs}>=${stophealpoint})&&(${Target.Type.Equal[PC]})&&!${Rebuffing}) {
      /if ((${announce}==1)&&(${duckspam}==1)) {
         /echo Ducking heal on ${Target.Name}
         /varset duckspam 0
         /timed 60 /varset duckspam 1
      }
      /call Interrupt
      /return
   }
   /if (${Me.Casting.Name.Equal[${reverseDS}]} && ${Spawn[${tankname}].PctHPs}<${tankhealpoint}) {
	/call Interrupt
	/return
   }
   /if ((${interrupt2healself}==1)&&(${Target.Name.NotEqual[${Me}]})&&(${Me.PctHPs}<${interrupt2healselfhp})) {
      /if ((${usedivarb}==1)&&(${Me.PctHPs}<=${divarbpoint})&&(${Me.AltAbilityReady[Divine Arbitration]})) {
         /call Interrupt
         /call Divarbcast
         /return
      }
      /if ((${announce}==1)&&(${duckselfspam}==1)) {

         /echo Ducking heal or buffspell on ${Target} so I can heal myself
         /varset duckselfspam 0
         /timed 60 /varset duckselfspam 1
      }
      /call Interrupt
      /return
   }
   /if (${onlyhealfd}==1) {
      /if (((${Target.Class.Name.Equal[Necromancer]})||(${Target.Class.Name.Equal[Monk]}))&&((${Target.Name.NotEqual[${tankname}]})||(${Target.Type.NotEqual[NPC]}))) {
         /if (${Target.State.NotEqual[feign]}) {
            /if ((${announce}==1)&&(${duckfdspam}==1)) {

               /echo Ducking heal on ${Target.Name} because he isn't staying FD
               /varset duckfdspam 0
               /timed 40 /varset duckfdspam 1
            }
            /call Interrupt
            /return
         }
      }
   }
   /for gmember 0 to ${Group}
   /if ((${usedivarb}==1)&&(${Spawn[${Group.Member[${gmember}]}].PctHPs}<=${divarbpoint})&&(${Spawn[${Group.Member[${gmember}]}].Distance}<=200)&&(${Me.AltAbilityReady[Divine Arbitration]})&&(${castEndTime}>=${interrupt2divarb})) {
            /call Interrupt
            /call Divarbcast
            /return
   }
   /next gmember
/return


Sub Buffbeg
   /if (${buffbeg}==0) /return
   /echo Begging for buffs now
   /if ((!${Me.Buff[Voice of Quellious].ID})&&(!${Me.Buff[Tranquility].ID})&&(!${Me.Buff[Koadic's Endless Intellect].ID})&&(!${Me.Buff[Clairvoyance].ID})&&(!${Me.Buff[Voice of Clairvoyance].ID})) {
      /if (${NearestSpawn[PC guild enchanter]}.NotEqual[NULL]}) /if (${NearestSpawn[PC guild enchanter].Distance}<=100) {
         /tell ${tankname} ${NearestSpawn[PC guild enchanter]} need C plz
         /delay 20
         /if (${Me.Buff[${daspell}].ID}) /notify BuffWindow Buff${Math.Calc[${Me.Buff[${daspell}].ID}-1].Int} leftmouseup
      } else /echo No guild Enchanter available for C5
   }
   /if ((!${Me.Buff[Protection of the Nine].ID})&&(!${Me.Buff[Blessing of the Nine].ID})&&(!${Me.Buff[Steeloak Skin].ID})&&(!${Me.Buff[Blessing of Steeloak].ID})&&(!${Me.Buff[Virtue].ID})&&(!${Me.Buff[Hand of Virtue].ID})&&(!${Me.Buff[Conviction].ID})&&(!${Me.Buff[Hand of Conviction].ID})) {
      /if (${NearestSpawn[PC guild druid]}.NotEqual[NULL]}) /if (${NearestSpawn[PC guild druid].Distance}<=100) {
         /tell ${tankname} ${NearestSpawn[PC guild druid]} need dru crack plz
         /delay 20
         /if (${Me.Buff[${daspell}].ID}) /notify BuffWindow Buff${Math.Calc[${Me.Buff[${daspell}].ID}-1].Int} leftmouseup
      } else /echo No guild Druid available for DRU crack
   }
   /if ((!${Me.Buff[Spiritual Dominion].ID})&&(!${Me.Buff[Spiritual Ascendance].ID})) {
      /if (${NearestSpawn[PC guild beastlord]}.NotEqual[NULL]}) /if (${NearestSpawn[PC guild beastlord].Distance}<=100) {
         /tell ${tankname} ${NearestSpawn[PC guild beastlord]} need bst crack plz
         /delay 20
         /if (${Me.Buff[${daspell}].ID}) /notify BuffWindow Buff${Math.Calc[${Me.Buff[${daspell}].ID}-1].Int} leftmouseup
      } else /echo No guild Beastlord available for BST crack
   }
   /if ((!${Me.Buff[Kazad`s Mark].ID})&&(!${Me.Buff[Symbol of Kazad].ID})&&(!${Me.Buff[Symbol of Balikor].ID})&&(!${Me.Buff[Balikor's Mark].ID})&&(!${Me.Buff[Virtue].ID})&&(!${Me.Buff[Hand of Virtue].ID})&&(!${Me.Buff[Conviction].ID})&&(!${Me.Buff[Hand of Conviction].ID})) {
      /if (${NearestSpawn[PC guild cleric]}.NotEqual[NULL]}) /if (${NearestSpawn[PC guild cleric].Distance}<=100) {
         /tell ${tankname} ${NearestSpawn[PC guild cleric]} need sym plz
         /delay 20
         /if (${Me.Buff[${daspell}].ID}) /notify BuffWindow Buff${Math.Calc[${Me.Buff[${daspell}].ID}-1].Int} leftmouseup
      } else /echo No guild Cleric available for Symbol
   }
   /if ((!${Me.Buff[Brell's Stalwart Shield].ID})&&(!${Me.Buff[Brell's Brawny Bulwark].ID})&&(!${Me.Buff[Spiritual Vigor].ID})&&(!${Me.Buff[Spiritual Vitality].ID})) {
      /if (${NearestSpawn[PC guild paladin]}.NotEqual[NULL]}) /if (${NearestSpawn[PC guild paladin].Distance}<=100) {
         /tell ${tankname} ${NearestSpawn[PC guild paladin]} need BSS plz
         /delay 20
         /if (${Me.Buff[${daspell}].ID}) /notify BuffWindow Buff${Math.Calc[${Me.Buff[${daspell}].ID}-1].Int} leftmouseup
      } else /echo No guild Paladin available for BSS
   }
   /if ((!${Me.Buff[Shield of Maelin].ID})&&(!${Me.Buff[Focus of the Seventh].ID})&&(!${Me.Buff[Focus of Soul].ID})&&(!${Me.Buff[Wunshi's Focusing].ID})&&(!${Me.Buff[Talisman of Wunshi].ID})) {
      /if (${NearestSpawn[PC guild shaman]}.NotEqual[NULL]}) /if (${NearestSpawn[PC guild shaman].Distance}<=100) {
         /tell ${tankname} ${NearestSpawn[PC guild shaman]} need focus plz
         /delay 20
         /if (${Me.Buff[${daspell}].ID}) /notify BuffWindow Buff${Math.Calc[${Me.Buff[${daspell}].ID}-1].Int} leftmouseup
      } else /echo No guild Shaman available for Focus
   }
   /varset buffbeg 0
/return


Sub FindExactPC(string name)
   /declare nameid int local
   /declare counter int local 1
   :FindNext
   /if (!${NearestSpawn[${counter}, pc ${name}].ID}) /return 2
   /varset nameid ${NearestSpawn[${counter}, pc ${name}].ID}
   /if (${Spawn[${nameid}].CleanName.Equal[${name}]}) {
      /target id ${nameid}
      /delay 1s ${Target.ID}==${nameid}
      /if (${Target.ID}==${nameid}) /return 1
   }
   /varcalc counter ${counter}+1
   /if (${NearestSpawn[${counter}, pc ${name}].ID}) /goto :FindNext
/return 2


Sub Event_Chat(string ChatType,string Sender,string ChatText)
   /if ((!${ChatType.Equal[${mychannel}]})&&(!${ChatType.Equal[TELL]})) /return
   /if (!${Spawn[${Sender}].ID}) {
      /echo ${Sender} is not in the zone
      /return
   }
   /if (${ChatText.Equal[Follow me]}) {
      /if (!${Group.Member[${Sender}]}) /return
      /delay 5
      /if (!${Spawn[${Sender}].ID}) {
         /echo ${Sender} is not in zone for me to follow!
         /return
      }
      /varset follname ${Sender}
      /varset following 1
      :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}>10) /keypress forward hold
      /if (${Target.Distance}<9) /keypress back
      /if (!${Target.ID}) /varset following 0
      /call CheckEvents
      /if ((${Target.Name.Equal[${follname}]})&&(${following}>0)) {
         /goto :Loop
      } else {
         /keypress forward
         /keypress back
      }
   }
   /if (${ChatText.Equal[End follow]}) {
      /if (!${Group.Member[${Sender}]}) /return
      /varset following 0
      /keypress forward
      /keypress back
      /timed 50 /face pc ${follname}
   }
   /if (${ChatText.Equal[Gbuff now!]}) {
      /if (!${Group.Member[${Sender}]}) /return
      /varset pallycount 0
      /target myself
      /call Cast "${acbuff}" gem9 7s
      /if (${FindItem[Breastplate of Vengeful Fury].ID}) /call Cast "Breastplate of Vengeful Fury" item
      /if (!${FindItem[Breastplate of Vengeful Fury].ID}) /call Cast "${spellhastebuff}" gem9 5s
      /for gmember 1 to ${Group}
         /target id ${Group.Member[${gmember}].ID}
         /delay 1s ${Target.ID}==${Group.Member[${gmember}].ID}
         /if (${Target.ID}==${Group.Member[${gmember}].ID}) {
            /if (${Target.Class.Name.NotEqual[Paladin]}) /call Cast "${acbuff}" gem9 7s
            /if (${Target.Class.Name.Equal[Paladin]}) {
               /call Cast "${longhpbuff}" gem9 10s
               /varcalc pallycount ${pallycount}+1
            }
            /if ((${Target.Class.Name.NotEqual[Warrior]})&&(${Target.Class.Name.NotEqual[Monk]})&&(${Target.Class.Name.NotEqual[Rogue]})&&(${Target.Class.Name.NotEqual[Berserker]})&&(${Target.Class.Name.NotEqual[Bard]})) {
               /if (${FindItem[Breastplate of Vengeful Fury].ID}) /call Cast "Breastplate of Vengeful Fury" item
               /if (!${FindItem[Breastplate of Vengeful Fury].ID}) /call Cast "${spellhastebuff}" gem9 5s
            }
         }
      /next gmember
      /if ((${Math.Calc[${Group}-${pallycount}]}>=2)&&(!${Bool[${groupsymbuff}]})) /call Cast "${groupsymbuff}" gem9 10s
      /if ((${Math.Calc[${Group}-${pallycount}]}<2)||(${Bool[${groupsymbuff}]})) {
         /for gmember 0 to ${Group}
            /target id ${Group.Member[${gmember}].ID}
            /delay 1s ${Target.ID}==${Group.Member[${gmember}].ID}
            /if (${Target.Class.Name.NotEqual[Paladin]}) /call Cast "${singlesymbuff}" gem9 7s
         /next gmember
      }
   }
   /if (${ChatText.Equal[BoR now!]}) {
      /if (!${Group.Member[${Sender}]}) /return
      /target myself
      /delay 5 ${Target.Name.Equal[${Me}]}
      /if (${FindItem[Breastplate of Vengeful Fury].ID}) /call Cast "Breastplate of Vengeful Fury" item
      /if (!${FindItem[Breastplate of Vengeful Fury].ID}) /call Cast "${spellhastebuff}" gem8 5s
      /for gmember 1 to ${Group}
         /target id ${Group.Member[${gmember}].ID}
         /delay 1s ${Target.ID}==${Group.Member[${gmember}].ID}
         /if (${Target.ID}==${Group.Member[${gmember}].ID}) {
            /if ((${Target.Class.Name.NotEqual[Warrior]})&&(${Target.Class.Name.NotEqual[Monk]})&&(${Target.Class.Name.NotEqual[Rogue]})&&(${Target.Class.Name.NotEqual[Berserker]})&&(${Target.Class.Name.NotEqual[Bard]})) {
               /if (${FindItem[Breastplate of Vengeful Fury].ID}) /call Cast "Breastplate of Vengeful Fury" item
               /if (!${FindItem[Breastplate of Vengeful Fury].ID}) /call Cast "${spellhastebuff}" gem8 5s
            }
         }
      /next gmember
   }
   /if (${ChatText.Equal[nuke]}) {
      /if (!${Group.Member[${Sender}]}) /return
      /if (${Me.PctMana}<30) {
         /tell ${Sender} Cleric Mana ${Me.PctMana}%, holding on nukes!
      } else {
         /assist ${Sender}
         /delay 5
         /if (${Target.Type.NotEqual[NPC]}) {
            /assist ${Sender}
            /delay 5 ${Target.Type.Equal[NPC]}
         }
         /if ((${Target.Type.Equal[NPC]})&&(${Target.PctHPs}<=90)) {
            /if (${Me.SpellReady[${nukeone}]}) {
               /if (${announce}==1) /tell ${tankname} %T shal feel the wrath of Brell! (${nukeone})
               /call Cast "${nukeone}" spell 3s
            } else /if (${Me.SpellReady[${nuketwo}]}) {
               /if (${announce}==1) /tell ${tankname} %T shal feel the wrath of Brell! (${nuketwo})
               /call Cast "${nuketwo}" spell 3s
            } else /tell ${Sender} nukes not ready
            /if (${Me.PctMana}<=60) /chat #${mychannel} FYI Cleric Mana ${Me.PctMana}%
         } else /tell ${Sender} wrong target (${Target.Type} at ${Target.PctHPs}% HP)
      }
   }
   /if (${ChatText.Equal[stun]}) {
      /if (!${Group.Member[${Sender}]}) /return
      /assist ${Sender}
      /delay 5
      /if (${Target.Type.NotEqual[NPC]}) {
         /assist ${Sender}
         /delay 5 ${Target.Type.Equal[NPC]}
      }
      /if ((${Target.Type.Equal[NPC]})&&(${Target.PctHPs}<=90)) {
         /if (${Me.SpellReady[${stunone}]}) {
            /if (${announce}==1) /tell ${tankname} Casting ${stunone} on %T
            /call Cast "${stunone}" spell 3s
         } else /if (${Me.SpellReady[${stuntwo}]}) {
            /if (${announce}==1) /tell ${tankname} Casting ${stuntwo} on %T
            /call Cast "${stuntwo}" spell 3s
         } else /tell ${Sender} stuns not ready
      } else /tell ${Sender} wrong target (${Target.Type} at ${Target.PctHPs}% HP)
   }
   /if (${ChatText.Equal[areanuke]}) {
      /if (!${Group.Member[${Sender}]}) /return
      /target ${Me.NearestSpawn[npc radius 35 zradius 25]}
      /delay 8
      /if (${Target.Type.NotEqual[NPC]}) {
         /assist ${Sender}
         /delay 8 ${Target.Type.Equal[NPC]}
      }
      /if ((${Target.Type.Equal[NPC]})&&(${Target.PctHPs}<=90)) {
         /if (${Me.SpellReady[${areanuke}]}) {
            /if (${announce}==1) /tell ${Sender} Casting ${areanuke} on %T
            /call Cast "${areanuke}" spell 3s
         } else /tell ${Sender} ${areanuke} not ready.
      } else /tell ${Sender} wrong target (${Target.Type} at ${Target.PctHPs}% HP)
   }
   /if (${ChatText.Equal[buffme]}) {
      /if (!${Group.Member[${Sender}]}) /return
      /call FindExactPC ${Sender}
      /if (${Macro.Return}!=1) /return
      /if (${Target.Class.Name.Equal[Paladin]}) {
         /call Cast "${longhpbuff}" gem9 10s
         /if (${FindItem[Breastplate of Vengeful Fury].ID}) /call Cast "Breastplate of Vengeful Fury" item
         /if (!${FindItem[Breastplate of Vengeful Fury].ID}) /call Cast "${spellhastebuff}" gem9 5s
         /return
      }
      /if ((${Target.Class.Name.NotEqual[Warrior]})&&(${Target.Class.Name.NotEqual[Monk]})&&(${Target.Class.Name.NotEqual[Rogue]})&&(${Target.Class.Name.NotEqual[Berserker]})&&(${Target.Class.Name.NotEqual[Bard]})) {
         /if (${FindItem[Breastplate of Vengeful Fury].ID}) /call Cast "Breastplate of Vengeful Fury" item
         /if (!${FindItem[Breastplate of Vengeful Fury].ID}) /call Cast "${spellhastebuff}" gem9 5s
      }
      /call Cast "${acbuff}" gem9 7s
      /call Cast "${singlesymbuff}" gem9 7s
   }
   /if ((${ChatText.Equal[patch me]})||(${ChatText.Equal[heal]})||(${ChatText.Equal[heal me]})||(${ChatText.Equal[heal plz]})||(${ChatText.Equal[heal me plz]})||(${ChatText.Equal[need heal]})) {
      /if (!${Group.Member[${Sender}]}) /return
      /call FindExactPC ${Sender}
      /if (${Macro.Return}!=1) /return
      /if (${Target.Distance}<=${patchhealrange}) {
         /if ((${announce}==1)&&(!${Me.Invis})) /tell ${tankname} (${patchheal}) --- %T ---
         /call Cast "${patchheal}" gem2 2s
         /delay 15 ${Me.SpellReady[${patchheal}]}
      } else /tell ${tankname} ${Sender} your OOR
   }
   /if ((${ChatText.Equal[sym]})||(${ChatText.Equal[wog]})||(${ChatText.Equal[grpV]})||(${ChatText.Equal[V]})||(${ChatText.Equal[bor]})||(${ChatText.Equal[rgc]})||(${ChatText.Equal[hot me]})||(${ChatText.Equal[ch me]})||(${ChatText.Equal[pb]})) {
      /if (!${Group.Member[${Sender}]}) /return
      /if (${Spawn[pc ${Sender}].Distance}>250) /return
      /call FindExactPC ${Sender}
      /if (${Macro.Return}!=1) /return
   }
   /if (${ChatText.Equal[sym]}) /call Cast "${singlesymbuff}" gem9 7s
   /if (${ChatText.Equal[wog]}) /call Cast "${acbuff}" gem9 7s
   /if (${ChatText.Equal[grpV]}) /call Cast "${grplonghpbuff}" gem9 10s
   /if (${ChatText.Equal[V]}) /call Cast "${longhpbuff}" gem9 10s
   /if (${ChatText.Equal[bor]}) {
      /if (${FindItem[Breastplate of Vengeful Fury].ID}) /call Cast "Breastplate of Vengeful Fury" item
      /if (!${FindItem[Breastplate of Vengeful Fury].ID}) /call Cast "${spellhastebuff}" gem9 5s
   }
   /if (${ChatText.Equal[rgc]}) {
      /if (!${Group.Member[${Sender}]}) /return
      /if (${FindItem[Blackflame Sphere].ID}) {
         /call Cast "Blackflame Sphere" item
      } else /if (${FindItem[Wand of Casual Blessings].ID}) {
         /call Cast "Wand of Casual Blessings" item
      } else /call Cast "${rgcspell}" gem9 5s
   }
   /if (${ChatText.Equal[buff pet]}) {
      /if (!${Group.Member[${Sender}]}) /return
      /target ${Spawn[pc ${Sender}].Pet}
      /delay 8
      /target ${Spawn[pc ${Sender}].Pet}
      /call Cast "${acbuff}" gem9 7s
      /call Cast "${singlesymbuff}" gem9 7s
   }
   /if (${ChatText.Equal[da pet]}) {
      /if (!${Group.Member[${Sender}]}) /return
      /target ${Spawn[pc ${Sender}].Pet}
      /delay 6
      /target ${Spawn[pc ${Sender}].Pet}
      /if (${Me.AltAbilityReady[39]}) /if (${Target.Name}.Equal[${Spawn[pc ${Sender}].Pet.Name}]}) {
         /call Cast "39" alt
      } else {
         /chat #${mychannel} Bestow Divine Aura is not ready, or Target ( %T ) OOR or wrong target
      }
   }
   /if (${ChatText.Equal[pb]}) {
      /if (!${Group.Member[${Sender}]}) /return
      /call Cast "Pure Blood" gem6 10s
   }
   /if (${ChatText.Equal[hot me]}) {
      /if (!${Group.Member[${Sender}]}) /return
      /if (${Target.Distance}<=${hotspellrange}) {
         /if (${announce}==1) /tell ${tankname} (${hotspell}) --- %T ---
         /call Cast "${hotspell}" gem3 2s
         /delay 15 ${Me.SpellReady[${hotspell}]}
      } else /tell ${tankname} ${Sender} your OOR
   }
   /if (${ChatText.Equal[ch me]}) {
      /if (!${Group.Member[${Sender}]}) /return
      /if (${Target.Distance}<=100) {
         /if (${announce}==1) /tell ${tankname} (Complete Heal) --- %T --- 10 secs
         /call Cast "Complete Healing" gem1 5s
         /tell ${tankname} ${Me.PctMana}m
         /delay 15 ${Me.SpellReady[${hotspell}]}
      } else /tell ${tankname} ${Sender} your OOR
   }
   /if (${ChatText.Equal[mana check]}) {
      /if (!${Group.Member[${Sender}]}) /return
      /tell ${Sender} Cleric Mana ${Me.PctMana}%
   }
   /if (${ChatText.Equal[slowcamp]}) {
      /if (!${Group.Member[${Sender}]}) /return
      /if (${Me.Standing}) /sit
      /delay 5m ${Me.PctMana}>=98
      /camp
      /end
   }
/if (${ChatText.Equal[Commandlist]}) {
      /if (!${Group.Member[${Sender}]}) /return
      /tell ${Sender} List of Commands: Autonuke ; areanuke ; GrpHealonGoM ; Follow me ; End follow ; Gbuff now! ; BoR now! ; nuke ; stun ; buffme ; patch me ; sym ; rgc ; buff pet ; da pet ; pb ; hot me ; ch me ; mana check ; Commandlist
   }
/if (${ChatText.Equal[${YourPW}]}) {
      /invite ${Sender}
   }
/if (${ChatText.Equal[autonuke]}) {
      /if (!${Group.Member[${Sender}]}) /return
      /if (${autonuke}>0) { 
	/varset autonuke 0 
	/echo Autonuke Disabled
	/tell ${Sender} Autonuke disabled. 
      } else /if (${autonuke}<1) { 
	/varset autonuke 1 
	/echo Autonuke Enabled 
	/tell ${Sender} Autonuke enabled. 
      }
}
/if (${ChatText.Equal[GrpHealonGoM]}) {
      /if (!${Group.Member[${Sender}]}) /return
      /if (${GrpHealonGoM}>0) { 
	/varset GrpHealonGoM 0 
	/echo Grpheal on GoM off!
	/tell ${Sender} Grpheal on GoM off!
      } else /if (${GrpHealonGoM}<1) { 
	/varset GrpHealonGoM 1 
	/echo Grpheal on GoM on!
	/tell ${Sender} Grpheal on GoM on!
      }
}
/doevents GoMana
/return

Sub Event_GainExp
/varset RevDSon FALSE
|   /call ExpTrack
/return

Sub Event_GoMana
	/varset GoMana 1
	/timed 180 /varset GoMana 0
	/call Healgroup
/return

Sub Event_OutofFood(Line, MissFoodorDrink)
/if (${NearestSpawn[NPC].Distance}>${Math.Calc[${NearestSpawn[NPC].MaxRange}+${Math.Calc[${distancetosit}/3]}]} && ${Me.PctMana}>40) {
	/if (${MissFoodorDrink.Arg[1].Equal[food]}) {
		/call cast "Abundant Food" gem9 1s
		/delay 5 ${Cursor.ID}
		/if (${Cursor.ID}) /autoinv
	}
	/if (${MissFoodorDrink.Arg[1].Equal[drink]}) {
		/call cast "Abundant Drink" gem9 1s
		/delay 5 ${Cursor.ID}
		/if (${Cursor.ID}) /autoinv
	}
}
/return

Sub Event_GoMoff
/varset GoMana 0
/return

Sub Incomming
/if (!${Window[CastingWindow].Open}||${Casttimer}<20) /return
/declare Spawncounter int local
/declare SpawnTempID int local
/for Spawncounter 1 to ${SpawnCount[NPC radius 450 zradius 30]}
/if (${Spawn[${NearestSpawn[${Spawncounter}, NPC]}].Speed}>150) {
	/if (${SpawnTempID}) {
		/if (${Spawn[${NearestSpawn[${Spawncounter}, NPC]}].Distance}<${Spawn[ID ${SpawnTempID}].Distance}) /varset SpawnTempID ${Spawn[${NearestSpawn[${Spawncounter}, NPC]}].ID}
	} else {
		/varset SpawnTempID ${Spawn[${NearestSpawn[${Spawncounter}, NPC]}].ID}
	}
	/varset PossibleIncom TRUE
}
/next Spawncounter
/if (${PossibleIncom}) {
	/if (${CastTimer}>${Math.Calc[${Spawn[ID ${SpawnTempID}].Distance}/10]}) {
		/echo Interrupting cast.
		/call Interrupt
	}
	/varset PossibleIncom FALSE
}
/return

Sub CheckBuffs
/if (${Rebuffstate} && ${DoAutoBuffs} && ${NearestSpawn[NPC].Distance}>=75 && ${Me.PctMana}>50) {
/declare i int local 1 
/for i 1 to ${SpellBufftodo.Size} 
	/doevents 
	/if (${Spell[${SpellBufftodo[${i}]}].Mana}>${Me.CurrentMana}) /goto :skipbuff
	/if (${Me.Book[${SpellBufftodo[${i}]}]}==0) /goto :skipbuff
	/if (!${Me.Buff[${SpellBufftodo[${i}]}].ID} && ${Spell[${SpellBufftodo[${i}]}].Stacks}) { 
		/keypress TAB
		/delay 3 
		/target myself
		/delay 3 
		/varset Rebuffing TRUE
		/varset Casttimer ${Math.Calc[${Spell[${SpellBufftodo[${i}]}].MyCastTime}*10]}
		/call cast ${SpellBufftodo[${i}]} gem9 5s Incomming
		/if (${Macro.Return.Equal[CAST_SUCCESS]}) /varset Rebuffstate FALSE
		/keypress TAB
		/varset Rebuffing FALSE
	} 
   :skipbuff
   /next i 
/for i 1 to ${TankBufftodo.Size} 
	/doevents 
	/if (${Spell[${TankBufftodo[${i}]}].Mana}>${Me.CurrentMana}) /goto :skipbuff2
	/if (${Me.Book[${TankBufftodo[${i}]}]}==0) /goto :skipbuff2
	/if (${TankWornOff[${i}]}) {
		/target ${tankname}
		/delay 3
		/varset Rebuffing TRUE
		/varset Casttimer ${Math.Calc[${Spell[${TankBufftodo[${i}]}].MyCastTime}*10]}
		/call cast ${TankBufftodo[${i}]} gem9 5s Incomming
		/if (${Macro.Return.Equal[CAST_SUCCESS]}) {
			/varset TankWornOff[${i}] FALSE
			/varset Rebuffstate FALSE
		}
		/varset Rebuffing FALSE	
	} else /varset Rebuffstate FALSE
   :skipbuff2
   /next i 
}  
/if (${Me.Gem[${reverseDS}]}!=9) {
	/memspell 9 "${reverseDS}"
	/delay 4s
}
/return
  
Sub Event_WornOff(string line, TempSpellname, TempName)
/declare i int local 1 
/for i 1 to ${TankBufftodo.Size} 
/if (${TempSpellname.Equal[${TankBufftodo[${i}]}]} && ${TempName.Equal[${tankname}]}) {
	/varset Rebuffstate TRUE
	/varset TankWornOff[${i}] TRUE
}
/next i 
/return

Sub Event_WornOff2
/declare i int local 1 
/for i 1 to ${SpellBufftodo.Size} 
/if (!${Me.Buff[${SpellBufftodo[${i}]}].ID} && ${Spell[${SpellBufftodo[${i}]}].Stacks}) /varset Rebuffstate TRUE
/next i 
/return
 
crystane is reworking and updating alot of her macros.... might check hers for updates also
 
So this might be a dumb question but at any rate, is this AFcleric macro better than having a merc?
 
Ok now for the followup, is there a link or guide or can someone tell me how to use this as I have searched the forum and can't find what I am looking for. I am really new to macros that are as complicated to me as this one, I have used MQ for a few years but mainly for simple TS stuff, languages, cast skills, etc. I am pretty good with coding and don't have a problem changing anything that needs changed but I would like some background.
 
you target the player you want to be healed... type
/macro afcleric 80 solemen light rk. ii

/macro macro name (percentage you want it to heal at) (spell you want it to cast)

it should build a ini file... open back up the macros folder and look for the .ini with you clerics name on it... open that up and customize it with your spell lists... and your off and running...
 
AFCleric.mac

Users who are viewing this thread

Back
Top
Cart