• 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

Puller/Healer Mod

Status
Not open for further replies.
Regular heal seems to be working fine with this macro.

Unfortunately, that's all I had tested before. I tried testing buffs and replaced all the buff names with my current ones, then did "buffme" and several other commands trying to test and get it to buff.

None of the buffs worked, I got this same message everytime:

Unparsable in Calculation: 'C'
blah
blah
blah
blah
Failed to parse /if condition '(charidhere .Cleanname.equal[buffrequestsender]})', non-numeric encountered

Words in bold were replacements for the buff requester's id and name.

I tried messing with a few things and couldn't get it to work.
 
For the puller macro:

If you want to keep an item click like jboots on, add this line:

Rich (BB code):
/call Cast "Fabled Journeyman's Boots" item

After:

Rich (BB code):
/face fast

Which is in the pull sub. It clicks your item(s) after you pull the mob and get back to camp, but before you start fighting.
 
Nice work on this Crystane! Would love to see a way to:
1. Have heal messages go to group
2. Have cleric nuke/stun the first time she is told to. ((allways returns "wrong target...mob at 100% HP the first time she is told to nuke/stun, even though the mob is not)
3. Still would like to see the puller mac work right, opens corpses but won't loot.

Thanks for all the help!
 
Muff,

look for
Rich (BB code):
/tell ${tankname}

And replace it with
Rich (BB code):
/gsay

Then the healchat goes to grp, beware no one unwanted is in grp.

On the Cleric, he is supposed to not stun or nuke outright when the mob is above a certain percentage health------>to avoid him getting aggro.

To change that however,
look for lines
Rich (BB code):
/if ((${Target.Type.Equal[NPC]})&&(${Target.PctHPs}<=90))

the 90 there is the percentage, change it to whatever and your clr nukes on command once the mob is below or equal to that percentage in health.

Hope that helps, Crys
 
Crystane said:
Rich (BB code):
look for 
/tell ${tankname}On the Cleric, he is supposed to not stun or nuke outright when the mob is above a certain percentage health------>to avoid him getting aggro.
Rich (BB code):
I guess i was not clear in asking about this part, when asking the cleric to stun or nuke she allways says the wrong mob...mob at 100% HP even when the mob is at 20% and i want her to stun to prevent healing or gating. This happens the first time she is told to stun/nuke ON EVERY MOB. the second time I issue the command it works fine.
 
Muff I have had the same problem ... it takes two times for it to register .. to to foresure what causes it.
 
What do you have to do to get the puller macro to loot after you kill something? It just keeps attacking the dead corpse for me.
 
/if (${Target.ID}==Corpse) /return

or something along those lines....

in the combat sub .. right after

/if (!${Target.ID}) /return
 
Gnomesrule said:
What do you have to do to get the puller macro to loot after you kill something? It just keeps attacking the dead corpse for me.

That's very weird. It works for me. Please post the macro you're using in a code window so we can try to figure out what's wrong.
 
OK this is what i have got for the puller code...any help is appreciated///maybe you can post what you are using that does work Dark.

Rich (BB code):
| Puller Macro
| Puller.mac
| Author	  : Alatyami: Ripped by robdawg :Ripped by Jdelpheki :Ripped Again By hakcenter
| Version	 : v3 2004-12-16 5:50pm PST
| Useage	  : /macro pull
| Description : This macro will run your character around Pulling any mobs.
|	  This is definitely a work in progress and I am sure
|	  someone can think of plenty of upgrades for this.
| : Ripped section Jdelpheki
|	  Modified for pull to area where Macro is started.  I have been using this
|	  2 level 45's Cleric Running genbot and Warrior running Pull2.  Ran for 4 hours
|	  Max with one cleric death. Needs Throwing weapon or arch support too
|	  Needs Genbot to announce its getting hit or get a new cleric script
| : Ripped section hakcenter
|	  Pulls Any Mobs within radius (regardless of level)
|	  No Mob Array Required
|	  Looting Added
|	  *Looting -stuck on corpse bug fixed-
|	  Loot Table Array Support
|	  *Puller runs to pull spot after mob looting is finished
|	  *Removed Target Fail Counters
|	  *Checks for mobs every 30seconds, 1second 50radius checks
|	  *Reformated
|	  *On zoning(death whatever), quits everquest
|	  *Added more checks
|
|	  2004-12-11
|
|	  Added some squelching, always looking for mobs within range, 5 distance intervals
|	  Jacked Item Coding from Rogue Helper
|	  Fixed UI locking up
|	  Fixed Long Buff Casts
|	  Added Disarm to the Special Combat abilities
|
|	  2004-12-16
|	  Revamped Close mob checking to 0.1second 100radius squelched
|	  Revamped Item casting to check for local mobs during.. and interupt if mob is near 100radius
|	  Removed mass escaping.. cause its retarded
|	  Fixed cool errors when accidently pushing esc while on a mob
|	  Fixed cool errors when accidently pushing esc while pulling a mob
|	  Added 1second before first item cast, incase item is worn... you get interupted cause its too fast
|
|------------------------------------------------------------------------------------
#turbo 10
#include AutoLooter.inc
#include Exp_Tracking.inc
#Event Slain "#*# slain#*#"
#Event Zoned "LOADING, PLEASE WAIT..."
#Event ItemSet "[MQ2] ItemSet#*#"
#Event ItemBounce "[MQ2] ItemBounce#*#"
#Event ItemCast "[MQ2] ItemCast#*#"
Sub Main
   |------------------------------------------------------------
   |How far would you like to target a mob?
   |------------------------------------------------------------
   /declare RV_MaxRadius		int outer  150
   |------------------------------------------------------------
   |How far is the fast movement range?
   |------------------------------------------------------------
   /declare RV_FastRange		int outer  10
   |------------------------------------------------------------
   |How far is the maximum combat range?
   |------------------------------------------------------------
   /declare RV_RangeMax		 int outer  7
   |------------------------------------------------------------
   |How far is the minimum combat range?
   |------------------------------------------------------------
   /declare RV_RangeMin		 int outer  8
   |------------------------------------------------------------
   |What is the minimum Z Value of mobs I should target?
   |------------------------------------------------------------
   /declare RV_MinZRange		int outer  -1000
   |------------------------------------------------------------
   |What is the maximum Z Value of mobs I should target?
   |------------------------------------------------------------
   /declare RV_MaxZRange		int outer  100
   |------------------------------------------------------------
   |Variables that you don't need to worry about.
   |------------------------------------------------------------
   /declare RV_MyTargetID	   int outer  0
   /declare RV_MyTargetName	 string outer
   /declare RV_MyTargetDead	 int outer  0
   /declare RV_InvalidTargetID  int outer  0
   /declare RV_HasTarget		int outer  0
   /declare RV_RandomWait	   int outer  0
   /declare RV_LootSlot		 int outer  0
   /declare RV_CheckLook		int outer  0
   /declare RV_Fighting		 int outer  0
   /declare RV_TargetDead	   int outer  0
   /declare RV_MyXLOC		   int outer  0
   /declare RV_MyYLOC		   int outer  0
   /declare RV_ObstacleCount	int outer  0
   /declare RV_hitcount		 int outer  0
   /declare RV_healcheck		int outer  0
   /declare RT_MyXLOC		   int outer  ${Me.X}
   /declare RT_MyyLOC		   int outer  ${Me.Y}
   /declare lastevent string outer None
   /declare CheckBuffs int outer 0
   /declare i int outer
   /declare ialias string outer None
   /declare doIclick bool outer FALSE
   /declare bouncenum int outer 1
   /declare ibounce string outer None
   /declare itemspellname string outer None
   /declare clicktimer timer outer 0
   /squelch /alias /iset /echo ItemSet
   /squelch /alias /ibounce /echo ItemBounce
   /squelch /alias /iclick /echo ItemCast
   /varset CheckBuffs 1
   /call ExpPrep
   :Start
	  /doevents
	  /call GMCheck
	  /call GetTarget
	  /if (${RV_HasTarget}) /call Pull
	  /if (${RV_HasTarget}) /call CombatSub
	  /call ResetSub
	  /call MoveToLoc ${RT_MyyLOC} ${RT_MyXLOC}
	  /goto :Start
/return
|--------------------------------------------------------------------------------
|SUB: GMCheck
|--------------------------------------------------------------------------------
Sub GMCheck
   /if (${Spawn[gm].ID}) {
	  /beep
	  /beep
	  /beep
	  /echo GM has entered the zone!
	  /echo FUCK HIM but ending the macro...
	  /keypress forward
	  /keypress back
	  /quit
	  /endmacro
   }
/return
|--------------------------------------------------------------------------------
|SUB: AquireTarget
|--------------------------------------------------------------------------------
Sub GetTarget
   /doevents
   /declare SpawnTimer		 int local
   /declare RV_CurrentRadius   int local
   /declare RV_TargetSub	   int local
   /echo Looking for Close Range Mobs
   :Acquire
	  /doevents
	  /for RV_CurrentRadius 100 to ${RV_MaxRadius} step 5
	  /squelch /target radius ${RV_CurrentRadius} npc
	  /varset RV_MyTargetID ${Target.ID}
	  /varset RV_MyTargetDead 0
	  /if (${Target.ID}) {
		 /if (${Int[${Target.Z}]}<${RV_MinZRange}) {
			/echo Mob is BELOW Min Z Range, picking another...
			/varset RV_InvalidTargetID ${Target.ID}
			/call ResetSub
			/goto :Acquire
		 }
		 /if (${Int[${Target.Z}]}>${RV_MaxZRange}) {
			/echo Mob is ABOVE Max Z Range, picking another...
			/varset RV_InvalidTargetID ${Target.ID}
			/call ResetSub
			/goto :Acquire
		 }
		 /varset RV_HasTarget 1
		 /varset RV_MyTargetName ${Target.Name}
		 /echo Acquired ${Target.Name} at range ${Int[${Target.Distance}]}
		 /return
	  }
	  /next RV_CurrentRadius
	  /goto :Acquire
/return
|--------------------------------------------------------------------------------
|SUB: Pull
|--------------------------------------------------------------------------------
Sub Pull
   /doevents
   /echo Pulling Mob
   /declare TargDist float local
   :PullLoop
	  /doevents
	  /if (!${Me.Combat}) /attack on
	  /call MoveToMob
	  /if (!${Target.ID}) /return
	  /face fast
	  /if (${Target.PctHPs}==100) /goto :PullLoop
	  /if (${Target.PctHPs}<21) /return
	  /call MoveToLoc ${RT_MyyLOC} ${RT_MyXLOC}
	  /if (!${Target.ID}) /return
	  /face fast
   :Engage
	  /varset TargDist ${Math.Distance[${Target.Y},${Target.X},0:${Me.Y},${Me.X},0]}
	  /if ( ${TargDist}<30 ) /return
	  /delay 1s
	  /goto :Engage
/return
|--------------------------------------------------------------------------------
|SUB: MovetoMob
|--------------------------------------------------------------------------------
Sub MoveToMob
   /doevents
   /varset RV_MyXLOC ${Int[${Me.X}]}
   /varset RV_MyYLOC ${Int[${Me.Y}]}
   /varset RV_ObstacleCount 0
   :MovementLoop
	  /doevents
	  /if (!${Target.ID}) /return
	  /face fast
	  /varcalc RV_ObstacleCount ${RV_ObstacleCount}+1
	  /if (${Int[${Target.Distance}]}>${RV_FastRange}) /keypress forward hold
	  /if (${Int[${Target.Distance}]}<${RV_FastRange}&&${Int[${Target.Distance}]}>${RV_RangeMax}) /keypress forward
	  /if (${Int[${Target.Distance}]}<${RV_RangeMin}) /keypress back
	  /if (${RV_ObstacleCount}>=15) {
		 /call CheckObstacle
		 /goto :Movementloop
	  }
	  /if (${Int[${Target.Distance}]}>${RV_FastRange}) /goto :MovementLoop
/return
|--------------------------------------------------------------------------------
|SUB: MoveToLocation
|--------------------------------------------------------------------------------
Sub MoveToLoc(MoveToY, MoveToX)
   /doevents
   /declare running int local
   /declare distanceNow float local
   /declare distanceBefore float local
   /declare distanceModifier int local
   /declare distanceTimer timer 15
   /varset running 0
   /varset distanceBefore ${Math.Distance[${Me.Y},${Me.X}:${MoveToY},${MoveToX}]}
   /varset distanceModifier 1
   /echo Moving to Location: ${MoveToY}, ${MoveToX}.
   /echo Distance: ${distanceBefore}
   :moveToLocation
	  /doevents
	  /face fast nolook loc ${MoveToY},${MoveToX}
	  /if (${Math.Distance[${Me.Y},${Me.X}:${MoveToY},${MoveToX}]}<10) {
		 /keypress forward
		 /return
	  }
	  /if (${distanceTimer}==0) {
		 /if (${Me.Sneaking}) {
			/varset distanceModifier 2
		 } else {
			/varset distanceModifier 1
		 }
		 /varset distanceNow ${Math.Distance[${Me.Y},${Me.X}:${MoveToY},${MoveToX}]}
		 /if (${Math.Calc[${distanceBefore}-${distanceNow}]}<${Math.Calc[10/${distanceModifier}]}) {
		 /call HitObstacle
		 }
		 /varset distanceBefore ${Math.Distance[${Me.Y},${Me.X}:${MoveToY},${MoveToX}]}
		 /varset distanceTimer 15
	  }
	  /if (${running}==0) {
		 /keypress forward
			/if (${Math.Distance[${Me.Y},${Me.X}:${MoveToY},${MoveToX}]}>10) {
			   /varset running 1
			   /keypress forward hold
			}
	  } else {
		 /if (${Math.Distance[${Me.Y},${Me.X}:${MoveToY},${MoveToX}]}<11) {
			/varset running 0
			/keypress forward
		 }
	  }
	  /goto :moveToLocation
/return
|--------------------------------------------------------------------------------
|SUB: ObstacleCheck
|--------------------------------------------------------------------------------
Sub CheckObstacle
   /doevents
   /if ((${RV_MyXLOC}==${Int[${Me.X}]})&&(${RV_MyYLOC}==${Int[${Me.Y}]})) /call HitObstacle
   /varset RV_MyXLOC ${Int[${Me.X}]}
   /varset RV_MyYLOC ${Int[${Me.Y}]}
   /varset RV_ObstacleCount 0
/return
|--------------------------------------------------------------------------------
|SUB: ObstacleAvoidance
|--------------------------------------------------------------------------------
Sub HitObstacle
   /echo Obstacle hit, moving around it...
   /keypress forward
   /keypress back hold
   /delay 3
   /keypress back
   /if (${Math.Rand[2]}) {
	  /keypress strafe_right hold
   } else {
	  /keypress strafe_left hold
   }
   /delay 5
   /keypress strafe_right
   /keypress strafe_left
   /keypress forward hold
/return
|--------------------------------------------------------------------------------
|SUB: Combat
|--------------------------------------------------------------------------------
Sub CombatSub
   /doevents
   /varset RV_Fighting 1
   /varset RV_TargetDead 0
   /echo Attacking Mob NOW!
   :CombatLoop
	  /if (!${Me.Combat}) /attack on
	  /if (!${Target.ID}) /return
	  /call MoveToMob
	  /call SpecialIT
	  /if (!${RV_TargetDead}) /goto :CombatLoop
	  /doevents
/return
|--------------------------------------------------------------------------------
|SUB: SpecialCombat
|--------------------------------------------------------------------------------
Sub SpecialIt
   /doevents
   /declare TempID	int inner  0
   /if (${Target.Distance}<=17 && ${Me.AbilityReady[Kick]}) {
	  /doability "Kick"
   }
   /if (${Target.Distance}<=17 && ${Me.AbilityReady[Disarm]}) {
	  /doability "Disarm"
   }
   /if (${Target.Distance}<=17 && ${Me.AbilityReady[Taunt]}) {
	  /doability "Taunt"
   }
   /if (${Target.Distance}<=17 && ${Me.AbilityReady[Bash]}) {
	  /doability "Bash"
   }
/return
|--------------------------------------------------------------------------------
|SUB: Slain
|--------------------------------------------------------------------------------
Sub Event_Slain
   /varset RV_TargetDead 1
   /varset RV_Fighting 0
   /attack off
   /call ExpTrack
   /target clear
   /keypress forward
   /keypress back
   /squelch /target radius 30 corpse
   /face fast
   /if (${RV_HasTarget}) /call AutoLoot
/return
|--------------------------------------------------------------------------------
|SUB: Zoned
|--------------------------------------------------------------------------------
Sub Event_Zoned
  /echo Zoned
  /delay 60s
  /quit
  /endmacro
|--------------------------------------------------------------------------------
|SUB: Looting
|--------------------------------------------------------------------------------
Sub LootMob
   /doevents
   /call AutoLoot
/return
|--------------------------------------------------------------------------------
|SUB: Reset
|--------------------------------------------------------------------------------
Sub ResetSub
   /doevents
   /varset RV_HasTarget 0
   /varset RV_TargetDead 0
   /varset RV_Fighting 0
/return
 
Ok folks,

I did some more edit and here it is.

The Healer.mac with Autonuke feature.
The PctMana to define how long the healer should nuke, can be customized in the section like all the other settings as usuall.

1. Start the mac as usuall.
2.A groupmember has to tell the Healer: autonuke
This will toggle the Autonuke feature on.
3.Repeat the tell to toggle the feature off.
4.Enjoy.

Rich (BB code):
|- healer.mac
|- Author: Alatyami, Redguides.com Moderator
|- Original Credits:
|- Secondary Credits: Alatyami, Crystane
|------------------------------------------------------------------------------|
|- Modifications:
|- [07-14-2005] * Fixed the TLO errors
|-              * Removed trickyda, it didn't really work to 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.
|------------------------------------------------------------------------------|

#include spell_routines.inc
|#include Exp_Tracking.inc
|#event Exp "You gain#*#"
#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
   /declare healspell string outer Complete Healing
   /declare healspellrange int outer 100
   /declare patchheal string outer Pious Light
   /declare patchhealrange int outer 200
   /declare hotspell string outer Pious Elixir
   /declare hotspellrange int outer 100
   /declare daspell string outer Divine Barrier
   /declare yaulpspell string outer Yaulp VII
   /declare usegroupheal int outer 1
   /declare groupheal string outer Word of Vivification
   /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 1
   /declare interrupt2healself int outer 1
   /declare interrupt2healselfhp int outer 50
   /declare noInvis int outer 1
   /declare defaultstophealpoint int outer 80
   /declare acbuff string outer Ward of Valiance
   /declare longhpbuff string outer Conviction
   /declare singlesymbuff string outer Symbol of Kazad
   /declare groupsymbuff string outer NULL
   /declare spellhastebuff string outer Blessing of Reverence
   /declare rgcspell string outer NULL
   /declare healpetmode int outer 2
   /declare pethealpoint int outer 65
   /declare manatohealpet int outer 25
   /declare pethealspell string outer Complete Healing
   /declare pethealspellrange int outer 100
   /declare nukeone string outer Reproach
   /declare nuketwo string outer Condemnation
   /declare stunone string outer Sound of Divinity
   /declare stuntwo string outer Shock of Wonder
   /declare rootspellname string outer Greater Immobilize
   /declare rootspelltime int outer 2


|------------------------------------------------------------------------------|
   /declare selfhealpoint int outer 70
   /declare dacastpoint int outer 39
   /declare divarbpoint int outer 42
   /declare interrupt2divarb int outer 35
|- Heal at % for WAR/PAL/SK
   /declare tankhealpoint int outer 75
|- Heal at % for WIZ/MAG/ENC/DRU
   /declare casterhotpoint int outer 85
   /declare casterpatchpoint int outer 60
|- Heal at % for NEC/SHM
   /declare necshmpatchpoint int outer 60
|- Heal at % for all other classes
   /declare defaultpatchpoint int outer 70
|- Nuke till down to % Mana.
   /declare Manatonuke int outer 70
|- Customize your Password here
   /declare YourPW string outer Yourpassword
|------------------------END EDITING------------------------|

   /declare healpct int outer 73
   /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 1
   /declare duckfdspam int outer 1
   /declare duckselfspam int outer 1
   /declare nomtspam int outer 1
   /declare ghealhurtcount int outer 0
   /declare divarboor int outer 0
   /declare aetime int outer 0
   /declare autonuke int outer 0

|-- 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 73%

   /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
   /tell ${tankname} You are my primary healing target.
   /delay 2s
   /tell ${tankname} Tell me "Commandlist" if need help.
   /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) {
         /echo Warning No Designated MT is available
         /timed 300 /varset nomtspam 1
         /varset nomtspam 0
      }
   }
   /if ((${Me.PctMana}>=${Manatonuke})&&(${autonuke}==1)&&(${Spawn[${tankname}].PctHPs}<99)&&(${Spawn[${tankname}].PctHPs}>${tankhealpoint})&&(${Spawn[${tankname}].NearestSpawn[npc radius 30 zradius 15].ID})&&(${Me.PctHPs}>85)) {
	/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.SpellReady[${nukeone}]}) {
               /if (${announce}==1) /tell ${tankname} %T shal feel the wrath of Brell! (${nukeone})
               /call Cast "${nukeone}" gem5 3s CheckHP
               /delay 5
	    } else /if (${Me.SpellReady[${stunone}]}) {
               /if (${announce}==1) /tell ${tankname} %T shal feel the wrath of Brell! (${stunone})
               /call Cast "${stunone}" gem8 0s
	       /delay 5
            } else /tell ${tankname} nukes not ready.
         }
   :skipautonuke
   /target ${tankname}
   /delay 1s ${Target.Type.Equal[PC]}
   }
   /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) /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}]})) {
         /if (${announce}==1) /tell ${tankname} (${healspell}) --- %T ---
         /call Cast "${healspell}" gem1 1s CheckHP
         /delay 15 ${Me.SpellReady[${healspell}]}
        /if (${announce}==1) /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 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) /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) /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}<=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 (${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)) {
      /if (${announce}==1) /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 ((${Bool[${worstclass}.Find[Warrior]]})||(${Bool[${worstclass}.Find[Paladin]]})||(${Bool[${worstclass}.Find[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) /tell ${tankname} ((${healspell}) --- %T ---
        /if (${announce}==1) /tell ${tankname} ${Me.PctMana}
         /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) /tell ${tankname} (${patchheal}) --- %T ---
         /call Cast "${patchheal}" gem2 1s CheckHP
         /delay 15 ${Me.SpellReady[${patchheal}]}
         /varset stophealpoint ${defaultstophealpoint}
         /call CheckEvents
         /return
      }
   } else /if ((${Bool[${worstclass}.Find[Magician]]})||(${Bool[${worstclass}.Find[Wizard]]})||(${Bool[${worstclass}.Find[Enchanter]]})||(${Bool[${worstclass}.Find[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) /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 (${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) /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 (${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) /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 (${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) /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) /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 ((${Bool[${worstclass}.Find[Necromancer]]})||(${Bool[${worstclass}.Find[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) /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) /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) /tell ${tankname} Inc Divine Arbitration
      /call Cast "Divine Arbitration" alt 2s
      /if ((${healafterdivarb}==1)&&(${Me.PctMana}>40)) {
         /if (${announce}==1) /tell ${tankname} Inc Grp Heal, get close
         /call Cast "${groupheal}" gem4 2s
         /delay 15 ${Me.SpellReady[${groupheal}]}
      }
   }
/return





Sub CheckEvents
   /delay 1
|   /doevents Exp
   /doevents Chat
   /doevents tell
   /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})&&(${Target.Type.Equal[PC]})) {
      /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 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
         }
      }
   }
   /if ((${usedivarb}==1)&&(${Target.PctHPs}<=${divarbpoint})&&(${Target.Distance}<=200)&&(${Me.AltAbilityReady[Divine Arbitration]})&&(${castEndTime}>=${interrupt2divarb})) {
      /for gmember 0 to ${Group}
         /if (${Target.ID}==${Group.Member[${gmember}].ID}) {
            /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}" 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)&&(!${Bool[${groupsymbuff}]})) /call Cast "${groupsymbuff}" gem5 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}" gem5 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[buffme]}) {
      /if (!${Group.Member[${Sender}]}) /return
      /call FindExactPC ${Sender}
      /if (${Macro.Return}!=1) /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 "${singlesymbuff}" 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]})) {
      /if (!${Group.Member[${Sender}]}) /return
      /call FindExactPC ${Sender}
      /if (${Macro.Return}!=1) /return
      /if (${Target.Distance}<=${patchhealrange}) {
         /if (${announce}==1) /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[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}" gem5 7s
   /if (${ChatText.Equal[wog]}) /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 (!${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}" gem8 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}" gem6 7s
      /call Cast "${singlesymbuff}" gem5 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}" gem2 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" gem2 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 ; 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 
      } else /if (${autonuke}<1) { 
	/varset autonuke 1 
	/echo Autonuke Enabled 
      }
}
/return

Sub Event_Exp
   /call ExpTrack
/return
 
Nice Crystane;
I think i can manage to to change the nuke part to a reverse DS spell for PLing my little toons. Problem is the macro only works if MT is in the group.....NO Exp for the little one that way. Is there a way to fix that.

I guess i really need 2 copies, one as it is and one that will work as a PL healer.

Also can you figure a way to allow me to manually buff someone outside the group, or say, be part of a CH rotation on a raid , without having to stop the macro and then restart it? As it is I can't do anything with the macro going.

Thanks for the help:
 
Sorry Muffin, I got distracted and forgot to look back here. Your macro looks basically just like mine. Do you have the autolooter.inc file in your macro folder?
 
Yes i have autoloot.inc in the macro dir. If it help figure this out.....when running macro puller just stops with loot window open, if I right click the loot for him he starts working again.
 
Hmm, that's weird. You might want to check the autolooter.inc file to make sure it's the same one listed on the first page.
 
Exactly the same......utill the half of the file that I was missing anyway:) Hopefully that will fix it. Thanks
 
OK we are getting warmer....Now puller gets a mob, kills it, loots and says :

Rich (BB code):
 Flow ran into another subroutine. 
puller.mac@399 (HandleItem): sub HandleItem
puller.mac@ 124 (Main): /call ResetSub
the current macro has ended

HELP! lol
 
How would I add the AA ability "call of challenge" to this? Would like my warrior to pull and basicly just spam this ability since the refresh is pretty quick and has a chance to be avoided. Thanks :)
 
buckeyesfan1 said:
How would I add the AA ability "call of challenge" to this? Would like my warrior to pull and basicly just spam this ability since the refresh is pretty quick and has a chance to be avoided. Thanks :)

Wow gratz on using the search tool, haven't seen this thread in a long time.

Put it into the "Sub SpecialIt" and it will fire off every combat round.
 
I had this working fine a week or so ago but now I get "unable to add macro line" when I try to run it. This still working for anyone else?
 
I am having problems with healer atm, it does commands and such loads fine but just spams me what mana hes at and never casts
 
Last edited:
Aye puller working ok now but healer just not healing. I am using a druid with the simple Heal spell at 60%
 
Please help me modify healer...

I have been using Healer.mac a long time and it has worked so well I have not had to change much. I can't actually remember changing anything but spells.

What I would like to add is something to keep me on my horse more and I would like to keep Conviction on my tank. I have tried a couple of different ways to do this but I am having some problems with the /doevents handler in this macro.

Any help with this would be greatly appreciated...
 
Everytime I use the puller macro I CTD. Any ideas on how to fix this? I hadnt tried it since the new expansion, but was working right before. Thanks =)
 
Hate to keep asking, but is someone able to take a look at this and see if it can be fixed? The puller part of the macro is the one I need. This is great for afk PLing with a higher lvl Healer. ) Thanks..
 
Probably has something to do with MQ2 VIP forums, as all pulling type macs seem to have been removed or might be just a bug, because alot of old stuff seems to have just disappeared.
 
It's bugged, don't know why, but the udpate soon should fix it.

Temp fix:

quote the post.
 
Puller/Healer Mod
Status
Not open for further replies.

Users who are viewing this thread

Back
Top
Cart