Advbot.mac - Advanced Caster Bot - Heal/Debuff/Buff

[fearless]

Again, there was a shammie ini file posted around page 5 or 6, go look for it. Also, reference the post from 2 days ago answering the exact same question.

If once you have found the ini, and you still can't get it to work, then start asking some questions again .

[ViperOne]

Hey ML,

Been having a hard time trying to get the macro working as of the recent patches.. keep falling into the continuous rebuff loop.

I see that some people have posted fixes but i can't get those posted fixes to work.

Great great great macro that i have used since you first made it and really dont want to switch to something else because it used to do everything i needed.

I guess what im asking is are you still keeping this macro up to date?

Help me MLonekenobi your my only hope.

[ml2517]

Unfortunately, no, I don't have any of my EQ accounts any longer. It will be up to someone else to grab my macros and fix them as necessary. I had too much come up with work and RL to mess around with it any longer. Sorry.

[aChallenged1]

Sorry to hear it ML. Best of luck to you.

[mamba666]

This is a fixed version. I use it regularly and haven't had any more problems with the continuous rebuff thing. I hope this helps anyone out there that had the buff loop problems.

|
| advbot.mac
| Advanced Caster Bot macro. This macro lets you specify precise thresholds for debuffing/healing/events etc.
| Version 1.95
| Date:5/16/2004 11:00am
|

#turbo 30

#include advbot.inc
#include advbot2.inc
#include spellcast.inc
#include advpath.inc

| Uncomment these if you'd like commands to work via group and chat channels.
|#chat group
|#chat chat

#chat tell


Sub Main(INI)
/declare a int local
/declare b int local
/call SetupADVars
/call InitAPFVars 1 15 20
/varset IniFile AD_${Me.Name}
/if (${Defined[INI]}) {
/varset IniFile ${IniFile}_${INI}
}
/varset IniFile ${IniFile}.ini
/call Startup


:MainLoop
/call AdvPathCall

/if (!${Zone.Name.Equal["${ZoneName}"]}) {
/for a 1 to ${TrackNumber}
/varset MobList[${a}] 0
/for b 1 to ${DebuffCount}
/varset MDL[${a},${b}] 0
/varset MobAnnounced[${a},${b}] 0
/next b
/next a
/varset VarNpcCount 0
/varset ZoneName ${Zone.Name}
}

/if (${PauseDebuffs}==0 && !${Me.Moving} && ${DebuffTimer}==0) /call DebuffSub

/if (${PauseDebuffs}==0) /call CheckNPC

/if (${PausePet}==0 && ${PetCheckTimer}==0) /call PetCheck

/if (${NoSit}==0 && !${Me.Moving} && ${SitCheckTimer}==0 && !${Me.Mount.ID}>0) /call SitCheck

/doevents

/if (${PauseDebuffs}==0 && !${Me.Moving}) /call IterateNPC

/if (${PauseSelfBuffs}==0 && !${Me.Moving} && ${SelfBuffTimer}==0 && (${VarNpcCount}<2 || ${PauseDebuffs}==1)) /call SelfBuffCheck

/if (${PauseGroupBuffs}==0 && !${Me.Moving} && ${GroupBuffTimer}==0 && (${VarNpcCount}<2 || ${PauseDebuffs}==1)) /call GroupBuffCheck

/if (${PausePet}==0 && !${Me.Moving} && ${PetBuffCheckTimer}==0 && (${VarNpcCount}<2 || ${PauseDebuffs}==1)) /call PetBuffCheck

/if (${PauseEvents}==0 && !${Me.Moving} && ${EventTimer}==0) /call EventCheck

/if (${PauseDebuffs}==0) /call CheckNPC

/if (${NoSit}==0 && !${Me.Moving}) /call SitCheck

/if (${PauseHeals}==0 && ${HealTimer}==0) /call HealCheck

/doevents

/if (${MiscCheckTimer}==0) {
/varset MiscCheckTimer 5s
/if (${Me.Invited}) /timed 20 /disband
/if (${Window[ConfirmationDialogBox].Open}) /notify ConfirmationDialogBox Yes_Button leftmouseup
}
/goto :MainLoop
/return

Sub AdvPathCall
/if (${FollowFlag}==1) {
/if (!${Me.Mount.ID}>0 && !${Me.Standing} && ${Spawn[${FollowID}].Distance3D}>=${FollowDistance}) /stand
/call AdvPathPoll
}
/return

Sub SitCheck
/declare MobHeading int local
/declare MeHeading int local
/declare MiniIterate int local
/declare AggroFlag int local
/declare AggroID int local
/varset SitCheckTimer 2s
/if (${FollowFlag}==1 && ${Spawn[${FollowID}].Distance3D}>${FollowDistance}) /return
/varset MiniIterate 1
/varset AggroFlag 0
/varset AggroID 0
:CheckNext
/varset AggroID ${NearestSpawn[${MiniIterate},npc radius ${SitAggroRadiusCheck} zradius 10].ID}
/if (${AggroID}>0) {
/varset MobHeading ${Spawn[${AggroID}].Heading.Degrees}
/if (${Math.Abs[${Math.Calc[${Spawn[${AggroID}].HeadingTo.Degrees}+180]}]}>=359.99) {
/varset MeHeading ${Math.Calc[(${Spawn[${AggroID}].HeadingTo.Degrees}-180)+360]}
} else {
/varset MeHeading ${Math.Calc[(${Spawn[${AggroID}].HeadingTo.Degrees}+180)+360]}
}
/if ((${Math.Calc[${MobHeading}+360]}>${Math.Calc[${MeHeading}-15]})&&(${Math.Calc[${MobHeading}+360]}<${Math.Calc[${MeHeading}+15]})) {
/varset AggroFlag 1
/if (!${Me.Mount.ID}>0) {
/if (${Me.Sitting}) /stand
}
/goto :BreakOutCheckAggro
}
} else {
/if (${AggroFlag}==0) {
/if (!${Me.Mount.ID}>0) {
/if (${Me.Standing}) /sit on
}
/goto :BreakOutCheckAggro
}
}
/varset MiniIterate ${Math.Calc[${MiniIterate}+1]}
/goto :CheckNext
:BreakOutCheckAggro
/return


Sub IterateNPC
/declare npcid int local
/declare a int local
/declare b int local
/declare compare int local
/declare TempNpcCount int local
/varset npcid 0
/varset TempNpcCount 0
:GetSpawn
/doevents
/varset npcid ${NearestSpawn[${Math.Calc[${TempNpcCount}+1]},npc radius ${Radius} zradius 10 noalert ${AlertList}].ID}
/if (!${String[${npcid}].Equal[NULL]}) {

/varset TempNpcCount ${Math.Calc[${TempNpcCount}+1]}
/if (${TempNpcCount}>${TrackNumber}) /goto oneSearching
/varset compare 0
/for a 1 to ${TrackNumber}
/if (${npcid}==${MobList[${a}]}) {
/varset compare 1
/goto :BreakOutComp
}
/next a
:BreakOutComp
/if (${compare}==0) {
/for a 1 to ${TrackNumber}
/if (${MobList[${a}]}==0) {
/varset VarNpcCount ${Math.Calc[${VarNpcCount}+1]}
/varset MobList[${a}] ${npcid}
/for b 1 to ${DebuffCount}
/varset MDL[${a},${b}] ${Math.Calc[${DebuffStartWait[${b}]}+${Macro.RunTime}]}
/varset MobAnnounced[${a},${b}] 0
/next b
/goto :GetSpawn
}
/next a
}
} else {
/goto oneSearching
}
/goto :GetSpawn
oneSearching
/return


Sub DebuffSub
/call IterateNPC
/varset DebuffTimer ${DebuffCheckTime}
/declare a int local
/declare b int local
/declare c int local
/declare MATarget int local 0
/if (${PauseAssist}==0) {
/if (${TankName.Length}>0 && !${TankName.Equal[Main Assist Name]}) {
/if (${Spawn[pc ${TankName}].Distance}<200) {
/squelch /target myself
/delay 1s ${Target.ID}==${Me.ID}
/assist ${TankName}
/delay 1s ${Target.ID}!=${Me.ID}
/varset MATarget ${Target.ID}
}
}
}
/for a 1 to ${TrackNumber}
/doevents Enraged
/call AdvPathCall
/if (${PauseDebuffs}==0 && !${Me.Moving}) {
/if (${MobList[${a}]}!=0) {
/for b 1 to ${DebuffCount}
/doevents Enraged
/if (${MobList[${a}]}!=${MATarget} && ${DebuffOnMATarget[${b}]}==1 && ${PauseAssist}==0) /goto :BreakOutDebuff
/if (${VarNpcCount}<${DebuffMinMobsInArea[${b}]}) /goto :BreakOutDebuff

/call AdvPathCall
/squelch /target id ${MobList[${a}]}
/delay 1s ${Target.ID}==${MobList[${a}]}
/if (!${Target.Type.Equal["NPC"]}) /goto :NotNPC
/if (${Spawn[${MobList[${a}]}].Distance}>${Radius}) /goto :NotNPC
/if (((${MDL[${a},${b}]}==0)||(${MDL[${a},${b}]}<${Math.Calc[${Macro.RunTime}]}))&&(${Spawn[${MobList[${a}]}].PctHPs}<=${DebuffMinHealth[${b}]})&&(${Spawn[${MobList[${a}]}].PctHPs}>${DebuffMinHealthNoCast[${b}]})&&(!${Spawn[${MobList[${a}]}].State.Equal["DEAD"]})&&(${Me.PctMana}>${DebuffMinMana[${b}]})) {
/if (((!${Debuff[${b}].Find["item"]})&&(!${Debuff[${b}].Find["activate"]}))&&((!${Me.SpellReady["${Debuff[${b}]}"]})&&(${Me.Gem["${Debuff[${b}]}"]}))) {
/for c 1 to 30
/delay 1
/if (${Me.SpellReady["${Debuff[${b}]}"]}) {
/goto :ContinueDebuff
}
/next c
/if (!${Me.SpellReady["${Debuff[${b}]}"]}) /goto :BreakOutDebuff
}
:ContinueDebuff
/if (!${Target.ID}>0) /goto :NotNPC
/echo Debuffing: -[ ${Spawn[${MobList[${a}]}].CleanName} ]- with ${Debuff[${b}]}.
/if (${FaceBeforeDebuff}==1) /face
/if (${Announce}==1) {
/call Debuff ${MobList[${a}]} "${Debuff[${b}]}" "${DebuffAnnounce[${b}]}" ${a} ${b} "${DebuffMemToSlot[${b}]}"
} else {
/call Debuff ${MobList[${a}]} "${Debuff[${b}]}" "NULL" ${a} ${b} "${DebuffMemToSlot[${b}]}"
}

/if (${Macro.Return.Equal["CAST_LOSTTARGET"]}) {
/delay 5
/return
}
/if (${Macro.Return.Equal["NODELAY"]}) {
/if (${DebuffDuration[${b}]}==99999) {
/varset MDL[${a},${b}] ${Math.Calc[99999+${Macro.RunTime}]}
} else /if (${DebuffDuration[${b}]}==0) {
/if (${Spell[${DebuffID[${b}]}].Duration.TotalSeconds}==0) {
/varset MDL[${a},${b}] ${Math.Calc[(1+${Macro.RunTime}-5]}
} else {
/varset MDL[${a},${b}] ${Math.Calc[${Spell[${DebuffID[${b}]}].Duration.TotalSeconds}+${Macro.RunTime}-5]}
}
} else {
/varset MDL[${a},${b}] ${Math.Calc[${DebuffDuration[${b}]}+${Macro.RunTime}-5]}
}
} else {
/varset MDL[${a},${b}] ${Math.Calc[15+${Macro.RunTime}]}
}
/if (${PauseHeals}==0 && ${HealTimer}==0) /call HealCheck
/if (${PausePet}==0 && ${PetCheckTimer}==0) /call PetCheck
}
:BreakOutDebuff
/next b
/if (${PauseEvents}==0 && ${EventTimer}==0 && !${Me.Moving}) /call EventCheck
/if (${PauseHeals}==0 && ${HealTimer}==0) /call HealCheck
}
}
:NotNPC
/doevents
/next a
/return


Sub CheckNPC
/declare a int local
/declare b int local
/for a 1 to ${TrackNumber}
/if (${MobList[${a}]}!=0) {
/if ((${Spawn[${MobList[${a}]}].State.Equal["DEAD"]})||(!${Spawn[${MobList[${a}]}].ID})||(${Spawn[${MobList[${a}]}].Distance}>${Radius})) {
/varset MobList[${a}] 0
/varset VarNpcCount ${Math.Calc[${VarNpcCount}-1]}
/for b 1 to ${DebuffCount}
/varset MDL[${a},${b}] 0
/varset MobAnnounced[${a},${b}] 0
/next b
}
}
/next a
/return


Sub Debuff(mobid,debname,debannounce,a,b,memtoslot)
/declare resistcount int local
/declare retrytimer int local
/declare ParseAnnounceChannels string local
/declare TempHoldAnnounce string local

/varset resistcount 1
:RecastDebuff
/if (${PauseDebuffs}==1) /return
/if (${Me.Sitting}) /stand
/if (${debname.Left[4].Equal["item"]}) {
/call Cast "${debname.Right[-5]}" "item" "${Dismount}"
} else /if (${debname.Left[8].Equal["activate"]}) {
/if (!${Me.AltAbilityReady[${debname.Right[-9]}]}) /return DELAY
/call Cast "${debname.Right[-9]}" "activate" "${Dismount}"
} else {
/call Cast "${debname}" "gem${memtoslot}" "${Dismount}"
}
/if (${Macro.Return.Equal["CAST_LOSTTARGET"]}) /return CAST_LOSTTARGET

/if (${Macro.Return.Equal["CAST_TOOK2LONG"]}) /return DELAY

/if (${Macro.Return.Equal["CAST_RESISTED"]}) {
/if (${Spell["${debname}"].RecastTime}) {
/if (${Spell["${debname}"].RecastTime}<=10) {
/varset retrytimer ${Math.Calc[${Spell["${debname}"].RecastTime}+1+${Macro.RunTime}]}
} else {
/return NODELAY
}
}
/if (${resistcount}<${RetryCount}) {
/varset resistcount ${Math.Calc[${resistcount}+1]}
:WaitForGem
/call AdvPathCall
/delay 1
/if (${debname.Left[4].Equal["item"]}) {
/squelch /target id ${mobid}
/delay 1s ${Target.ID}==${mobid}
/goto :RecastDebuff
} else /if (${debname.Left[8].Equal["activate"]}) {
/squelch /target id ${mobid}
/delay 1s ${Target.ID}==${mobid}
/goto :RecastDebuff
} else {
/if (${retrytimer}<${Math.Calc[${Macro.RunTime}]}) {
/return NODELAY
}
/if (!${Me.SpellReady["${debname}"]}) {
/goto :WaitForGem
}
}
/squelch /target id ${mobid}
/delay 1s ${Target.ID}==${mobid}
/goto :RecastDebuff
} else {
/return NODELAY
}
}
/if ((${Macro.Return.Equal["CAST_CANNOTSEE"]})||(${Macro.Return.Equal["CAST_OUTOFRANGE"]})) {
/echo -(( Mob out of range or cannot be seen. Waiting 15 seconds and trying again. ))-
/return DELAY
}
/if ((${Macro.Return.Equal["CAST_SUCCESS"]})&&(${Announce}==1)&&(!${debannounce.Equal["NULL"]})&&(${MobAnnounced[${a},${b}]}==0)) {
/if (${AnnounceChannel.Length}>0) {
/if (${AnnounceChannel.Find[;]}) {
/varset TempHoldAnnounce ${AnnounceChannel}
arseNext
/varset ParseAnnounceChannels ${TempHoldAnnounce.Arg[1,;]}
/varset TempHoldAnnounce ${TempHoldAnnounce.Right[-${TempHoldAnnounce.Find[;]}]}
:SendIt
/if (${ParseAnnounceChannels.Equal[gsay]} && ${Group}>0) {
/gsay ${debannounce}
} else /if (!${ParseAnnounceChannels.Equal[gsay]}) {
/docommand /${ParseAnnounceChannels} ${debannounce}
}
/if (${TempHoldAnnounce.Length}>0) {
/if (${TempHoldAnnounce.Find[;]}>0) {
/goto arseNext
} else {
/varset ParseAnnounceChannels ${TempHoldAnnounce}
/varset TempHoldAnnounce
/goto :SendIt
}
}
} else {
/if (${AnnounceChannel.Equal[gsay]} && ${Group}>0) {
/gsay ${debannounce}
} else /if (!${AnnounceChannel.Equal[gsay]}) {
/docommand /${AnnounceChannel} ${debannounce}
}
}
}
/varset MobAnnounced[${a},${b}] 1
}
/return NODELAY


Sub SelfBuffCheck
/varset SelfBuffTimer ${SelfBuffCheckTime}
/declare a int local
/declare f int local
/declare RetryBuffCount int local
/if (${SelfBuffCount}>0) {
/for a 1 to ${SelfBuffCount}
/if (${PauseSelfBuffs}==1 || ${Me.Moving}) /return
/if (${PauseHeals}==0 && ${HealTimer}==0) /call HealCheck
/varset RetryBuffCount 0
/call AdvPathCall
/if ((${SelfBuffedList[${a}]}<${Math.Calc[${Macro.RunTime}]})||((${SelfBuffIconCheck[${a}]}==1)&&(!${Me.Buff["${SelfBuffIconName[${a}]}"].Duration})&&(${SelfBuffedList[${a}]}!=99999))) {
:RetryBuff
/if (${PauseSelfBuffs}==1) /return

/if ((!${SelfBuff[${a}].Find["item"]}>0)&&(!${SelfBuff[${a}].Find["activate"]}>0)) {
/if (${Me.Gem[${SelfBuff[${a}]}]}) {
/for f 1 to 30
/delay 1
/if (${Me.SpellReady["${SelfBuff[${a}]}"]}) {
/goto :ContinueSelfBuff
}
/next f
/if (!${Me.SpellReady["${SelfBuff[${a}]}"]}) /goto :BreakOutSelf
}
}
:ContinueSelfBuff
/if ((${Me.Gem[${SelfBuff[${a}]}]})||(${SelfBuff[${a}].Find["item"]})||(${SelfBuff[${a}].Find["activate"]})||(${SelfBuffMemToSlot[${a}]}>0)) {
/if (${Me.Sitting}) /stand
/squelch /target myself
/delay 1s ${Target.ID}==${Me.ID}
/if (${SelfBuff[${a}].Left[4].Equal["item"]}) {
/echo -[ Casting Self Buff : ${SelfBuff[${a}]} ]-
/call Cast "${SelfBuff[${a}].Right[-5]}" "item" "${Dismount}"
} else /if (${SelfBuff[${a}].Left[8].Equal["activate"]}) {
/if (!${Me.AltAbilityReady[${SelfBuff[${a}].Right[-9]}]}) /goto :BreakOutSelf
/echo -[ Casting Self Buff : ${SelfBuff[${a}]} ]-
/call Cast "${SelfBuff[${a}].Right[-9]}" "activate" "${Dismount}"
} else {
/echo -[ Casting Self Buff : ${SelfBuff[${a}]} ]-
/call Cast "${SelfBuff[${a}]}" "gem${SelfBuffMemToSlot[${a}]}" "${Dismount}"
}
/if (${Macro.Return.Equal["CAST_LOSTTARGET"]}) {
/delay 5
/varset SelfBuffTimer 0
/return
}
/if (${Macro.Return.Equal["CAST_TOOK2LONG"]}) {
/varset SelfBuffedList[${a}] ${Math.Calc[15+${Macro.RunTime}]}
/goto :BreakOutSelf
}
/if (${SelfBuffDuration[${a}]}==99999) {
/varset SelfBuffedList[${a}] ${Math.Calc[99999+${Macro.RunTime}]}
} else /if (${SelfBuffDuration[${a}]}==0) {

/if (${Spell[${SelfBuffID[${a}]}].Duration.TotalSeconds}==0) {
/varset SelfBuffedList[${a}] ${Math.Calc[1+${Macro.RunTime}-5]}
} else {
/varset SelfBuffedList[${a}] ${Math.Calc[${Spell[${SelfBuffID[${a}]}].Duration.TotalSeconds}+${Macro.RunTime}-5]}
}
} else {
/varset SelfBuffedList[${a}] ${Math.Calc[${SelfBuffDuration[${a}]}+${Macro.RunTime}-5]}
}
} else {
/if (${RetryBuffCount}==0) {
/if (!${Me.SpellReady["${SelfBuff[${a}]}"]}) {
/call Delay 3s
/varset RetryBuffCount ${Math.Calc[${RetryBuffCount}+1]}
/goto :RetryBuff
}
}
/echo -(( Self Buff:${SelfBuff[${a}]} not memmed or not ready. ))-
/echo -(( Waiting 60 seconds before retrying buff. ))-
/varset SelfBuffedList[${a}] ${Math.Calc[60+${Macro.RunTime}]}
}
}
:BreakOutSelf
/next a
}
/return


Sub PetCheck
/varset PetCheckTimer ${PetCheckTime}
/declare PetTarget int local 0
/if (${PauseAssist}==0) {
/if (${Me.Pet.ID}>0 && !${TankName.Equal[Main Assist Name]} && ${TankName.Length}>0) {
/if (${Spawn["${TankName}"].Distance}<150) {
/squelch /target id ${Me.Pet.ID}
/delay 1s ${Target.ID}==${Me.Pet.ID}
/assist
/delay 1s ${Target.ID}!=${Me.Pet.ID}
/if ((${Target.ID}>0) && (${Target.ID}!=${Me.Pet.ID}) && (!${Target.Type.Equal[CORPSE]})) {
/varset PetTarget ${Target.ID}
} else {
/varset PetTarget 0
}
/assist ${TankName}
/delay 7
/if (${Target.ID}>0 && ${Target.Type.Equal[NPC]} && ${Target.PctHPs}<=${PetAssistOnHPPct}) {
/if (${PetTarget}==0) {
/pet attack
} else /if (${PetTarget}!=${Target.ID}) {
/pet back off
/delay 2
/pet attack
}
}
}
}
}
/return


Sub PetBuffCheck
/declare a int local
/declare f int local
/declare RetryPetBuffCount int local
/varset PetBuffCheckTimer ${PetBuffCheckTime}
/if (${Me.Pet.ID}>0 && ${PetBuffCount}>0) {
/for a 1 to ${PetBuffCount}
/varset RetryPetBuffCount 0
/if (!${Me.PetBuff["${PetBuffIconName[${a}]}"]}>0 && ${Me.Pet.Distance}<100) {
/if (${PausePet}==1) /return

:RetryPetBuff
/if ((!${PetBuff[${a}].Find["item"]}>0)&&(!${PetBuff[${a}].Find["activate"]}>0)) {
/if (${Me.Gem[${PetBuff[${a}]}]}) {
/for f 1 to 30
/delay 1
/if (${Me.SpellReady["${PetBuff[${a}]}"]}) {
/goto :ContinuePetBuff
}
/next f
/if (!${Me.SpellReady["${PetBuff[${a}]}"]}) /goto :BreakOutPetBuff
}
}
:ContinuePetBuff
/if ((${Me.Gem[${PetBuff[${a}]}]})||(${PetBuff[${a}].Find["item"]})||(${PetBuff[${a}].Find["activate"]})||(${PetBuffMemToSlot[${a}]}>0)) {
/if (${Me.Sitting}) /stand
/squelch /target id ${Me.Pet.ID}
/delay 1s ${Target.ID}==${Me.Pet.ID}
/if (${PetBuff[${a}].Left[4].Equal["item"]}) {
/echo -[ Casting Pet Buff : ${PetBuff[${a}]} ]-
/call Cast "${PetBuff[${a}].Right[-5]}" "item" "${Dismount}"
} else /if (${PetBuff[${a}].Left[8].Equal["activate"]}) {
/if (!${Me.AltAbilityReady[${PetBuff[${a}].Right[-9]}]}) /goto :BreakOutPetBuff
/echo -[ Casting Pet Buff : ${PetBuff[${a}]} ]-
/call Cast "${PetBuff[${a}].Right[-9]}" "activate" "${Dismount}"
} else {
/echo -[ Casting Pet Buff : ${PetBuff[${a}]} ]-
/call Cast "${PetBuff[${a}]}" "gem${PetBuffMemToSlot[${a}]}" "${Dismount}"
}
} else {
/if (${RetryPetBuffCount}==0) {
/if (!${Me.SpellReady["${PetBuff[${a}]}"]}) {
/call Delay 3s
/varset RetryPetBuffCount ${Math.Calc[${RetryPetBuffCount}+1]}
/goto :RetryPetBuff
}
}
}


}
:BreakOutPetBuff
/next a
}
/return


Sub EventCheck
/varset EventTimer ${EventCheckTime}
/declare a int local
/declare c int local
/declare RetryEventCount int local
/if (${EventCount}>0) {
/for a 1 to ${EventCount}
/call AdvPathCall
/if (${PauseEvents}==1 || ${Me.Moving}) /return
/if (${PauseHeals}==0 && ${HealTimer}==0) /call HealCheck
/varset RetryEventCount 0
/if ((${Me.PctMana}<=${EventMinMana[${a}]})&&(${Me.PctMana}>=${EventMaxMana[${a}]})&&(${Me.PctHPs}<=${EventMinHP[${a}]})&&(${Me.PctHPs}>=${EventMaxHP[${a}]})) {
/if (${EventList[${a}]}<${Math.Calc[${Macro.RunTime}]}) {
:RetryEvent
/if (${PauseEvents}==1) /return

/if ((!${EventSpell[${a}].Find["item"]}>0)&&(!${EventSpell[${a}].Find["activate"]}>0)) {
/if (${Me.Gem[${EventSpell[${a}]}]}) {
/for c 1 to 30
/delay 1
/if (${Me.SpellReady["${EventSpell[${a}]}"]}) {
/goto :ContinueEvent
}
/next c
/if (!${Me.SpellReady["${EventSpell[${a}]}"]}) /goto :BreakOutEvent
}
}
:ContinueEvent
/if ((${Me.Gem[${EventSpell[${a}]}]})||(${EventSpell[${a}].Find["item"]})||(${EventSpell[${a}].Find["activate"]})||(${EventMemToSlot[${a}]}>0)) {
/if (${Me.Sitting}) /stand
/squelch /target myself
/delay 1s ${Target.ID}==${Me.ID}
/if (${EventSpell[${a}].Left[4].Equal["item"]}) {
/echo -[ Casting Event Spell : ${EventSpell[${a}]} ]-
/call Cast "${EventSpell[${a}].Right[-5]}" "item" "${Dismount}"
} else /if (${EventSpell[${a}].Left[8].Equal["activate"]}) {
/if (!${Me.AltAbilityReady[${EventSpell[${a}].Right[-9]}]}) /goto :BreakOutEvent
/echo -[ Casting Event Spell : ${EventSpell[${a}]} ]-
/call Cast "${EventSpell[${a}].Right[-9]}" "activate" "${Dismount}"
} else {
/echo -[ Casting Event Spell : ${EventSpell[${a}]} ]-
/call Cast "${EventSpell[${a}]}" "gem${EventMemToSlot[${a}]}" "${Dismount}"
}
/if (${Macro.Return.Equal["CAST_LOSTTARGET"]}) {
/delay 5
/varset EventTimer 0
/return
}
/if (${Macro.Return.Equal["CAST_TOOK2LONG"]}) {
/varset EventList[${a}] ${Math.Calc[15+${Macro.RunTime}]}
/goto :BreakOutEvent
}

/if (${EventDuration[${a}]}==99999) {
/varset EventList[${a}] ${Math.Calc[99999+${Macro.RunTime}]}
} else /if (${EventDuration[${a}]}==0) {
/if (${Spell[${EventSpellID[${a}]}].Duration.TotalSeconds}==0) {
/varset EventList[${a}] ${Math.Calc[1+${Macro.RunTime}-5]}
} else {
/varset EventList[${a}] ${Math.Calc[${Spell[${EventSpellID[${a}]}].Duration.TotalSeconds}+${Macro.RunTime}-5]}
}
} else {
/varset EventList[${a}] ${Math.Calc[${EventDuration[${a}]}+${Macro.RunTime}-5]}
}

} else {
/if (${RetryEventCount}==0) {
/if (!${Me.SpellReady["${EventSpell[${a}]}"]}) {
/call Delay 3s
/varset RetryEventCount ${Math.Calc[${RetryEventCount}+1]}
/goto :RetryEvent
}
}
/echo -(( Event Spell:${EventSpell[${a}]} not memmed or not ready. ))-
/echo -(( Waiting 60 seconds before retrying event. ))-
/varset EventList[${a}] ${Math.Calc[60+${Macro.RunTime}]}
}
}
}
:BreakOutEvent
/next a
}
/return


Sub GroupBuffCheck
/varset GroupBuffTimer ${GroupBuffCheckTime}
/declare a int local
/declare b int local
/declare c int local
/declare f int local
/declare RetryBuffCount int local
/declare ParseAnnounceChannels string local
/declare TempHoldAnnounce string local
/if (${GroupBuffCount}>0) {
/for a 1 to ${GroupBuffCount}
/if (${PauseGroupBuffs}==1 || ${Me.Moving}) /return
/if (${PauseHeals}==0 && ${HealTimer}==0) /call HealCheck
/call AdvPathCall
/for b 0 to ${Group}
/call AdvPathCall
/varset RetryBuffCount 0
/if (${Me.PctMana}>=${GroupBuffMinMana[${a}]}) {

/if (${GBL[${a},${Math.Calc[${b}+1]}]}<${Math.Calc[${Macro.RunTime}]}) {

/if (${Math.Calc[${Group}+1]}<${GroupBuffMinGroupCount[${a}]}) /goto :BreakOutBuff

/if (((${Spell[${GroupBuffID[${a}]}].TargetType.Find["Group"]})&&(${b}!=0))||((${GroupBuffMinGroupCount[${a}]}>0)&&(${b}!=0))) /goto :BreakOutBuff

/if ((${b}>0)&&(!${GroupBuffClass[${a}].Find["${Group[${b}].Class.ShortName}"]})) /goto :BreakOutMember

/if ((${b}==0)&&(!${GroupBuffClass[${a}].Find["${Me.Class.ShortName}"]})&&((!${Spell[${GroupBuffID[${a}]}].TargetType.Find["Group"]})||(${GroupBuffMinGroupCount[${a}]}==0))) /goto :BreakOutMember

:RetryBuff
/if (${PauseGroupBuffs}==1 || ${Me.Moving}) /return
/if ((${Me.Gem[${GroupBuff[${a}]}]})||(${GroupBuff[${a}].Find["item"]})||(${GroupBuff[${a}].Find["activate"]})||(${GroupBuffMemToSlot[${a}]}>0)) {

/if ((${GroupBuff[${a}].Find["activate"]})&&(!${Me.AltAbilityReady[${GroupBuff[${a}].Right[-9]}]})) /goto :BreakOutBuff

/if ((!${GroupBuff[${a}].Find["item"]}>0)&&(!${GroupBuff[${a}].Find["activate"]}>0)) {
/if (${Me.Gem[${GroupBuff[${a}]}]}) {
/for f 1 to 30
/delay 1
/if (${Me.SpellReady["${GroupBuff[${a}]}"]}) {
/goto :ContinueGroupBuff
}
/next f
/if (!${Me.SpellReady["${GroupBuff[${a}]}"]}) /goto :BreakOutBuff
}
}
:ContinueGroupBuff
/if (${Spell[${GroupBuffID[${a}]}].TargetType.Find["Group"]} || ${b}==0) {
/squelch /target myself
/delay 1s ${Target.ID}==${Me.ID}
} else {
/squelch /target id ${Group[${b}].ID}
/delay 1s ${Target.ID}==${Group[${b}].ID}
}
/if (!${Target.CleanName.Equal[${Group[${b}]}]}) {
/echo -(( Target not in zone. Waiting 30 seconds and trying again. ))-
/varset GBL[${a},${Math.Calc[${b}+1]}] ${Math.Calc[30+${Macro.RunTime}]}
/goto :BreakOutMember
}
/if (!${GroupBuff[${a}].Find[Item]} && !${GroupBuff[${a}].Find[Activate]} && ${Target.Distance3D}>${Spell[${GroupBuffID[${a}]}].Range}) /goto :BreakOutMember
/if ((${Announce}==1)&&(!${GroupBuffAnnounce[${a}].Equal["NULL"]})) {
/if (${AnnounceChannel.Length}>0) {
/if (${AnnounceChannel.Find[;]}) {
/varset TempHoldAnnounce ${AnnounceChannel}
arseNext
/varset ParseAnnounceChannels ${TempHoldAnnounce.Arg[1,;]}
/varset TempHoldAnnounce ${TempHoldAnnounce.Right[-${TempHoldAnnounce.Find[;]}]}
:SendIt
/if (${ParseAnnounceChannels.Equal[gsay]} && ${Group}>0) {
/gsay ${GroupBuffAnnounce[${a}]}
} else /if (!${ParseAnnounceChannels.Equal[gsay]}) {
/docommand /${ParseAnnounceChannels} ${GroupBuffAnnounce[${a}]}
}
/if (${TempHoldAnnounce.Length}>0) {
/if (${TempHoldAnnounce.Find[;]}>0) {
/goto arseNext
} else {
/varset ParseAnnounceChannels ${TempHoldAnnounce}
/varset TempHoldAnnounce
/goto :SendIt
}
}
} else {
/if (${AnnounceChannel.Equal[gsay]} && ${Group}>0) {
/gsay ${GroupBuffAnnounce[${a}]}
} else /if (!${AnnounceChannel.Equal[gsay]}) {
/docommand /${AnnounceChannel} ${GroupBuffAnnounce[${a}]}
}
}
}
}
/if (${Me.Sitting}) /stand
/if (${GroupBuff[${a}].Left[4].Equal["item"]}) {
/echo -[ Casting Group Buff : ${GroupBuff[${a}]} ]-
/call Cast "${GroupBuff[${a}].Right[-5]}" "item" "${Dismount}"
} else /if (${GroupBuff[${a}].Left[8].Equal["activate"]}) {
/echo -[ Casting Group Buff : ${GroupBuff[${a}]} ]-
/call Cast "${GroupBuff[${a}].Right[-9]}" "activate" "${Dismount}"
} else {
/echo -[ Casting Group Buff : ${GroupBuff[${a}]} ]-
/call Cast "${GroupBuff[${a}]}" "gem${GroupBuffMemToSlot[${a}]}" "${Dismount}"
}
/if (${Macro.Return.Equal["CAST_TOOK2LONG"]}) {
/varset GBL[${a},${Math.Calc[${b}+1]}] ${Math.Calc[15+${Macro.RunTime}]}
/goto :BreakOutBuff
}
/if (${Macro.Return.Equal["CAST_LOSTTARGET"]}) {
/delay 5
/varset GroupBuffTimer 0
/return
}
/if ((${Macro.Return.Equal["CAST_CANNOTSEE"]})||(${Macro.Return.Equal["CAST_OUTOFRANGE"]})) {
/echo -(( Out of range or cannot be seen. Waiting 20 seconds and trying again. ))-
/varset GBL[${a},${Math.Calc[${b}+1]}] ${Math.Calc[20+${Macro.RunTime}]}
/goto :BreakOutMember
}
/if (${GroupBuffDuration[${a}]}==99999) {
/varset GBL[${a},${Math.Calc[${b}+1]}] ${Math.Calc[99999+${Macro.RunTime}]}
} else /if (${GroupBuffDuration[${a}]}==0) {

/if (${Spell[${GroupBuffID[${a}]}].Duration.TotalSeconds}==0) {
/varset GBL[${a},${Math.Calc[${b}+1]}] ${Math.Calc[1+${Macro.RunTime}-5]}
} else {
/varset GBL[${a},${Math.Calc[${b}+1]}] ${Math.Calc[${Spell[${GroupBuffID[${a}]}].Duration.TotalSeconds}+${Macro.RunTime}-5]}
}
} else {
/varset GBL[${a},${Math.Calc[${b}+1]}] ${Math.Calc[${GroupBuffDuration[${a}]}+${Macro.RunTime}-5]}
}
} else {
/if (${RetryBuffCount}==0) {
/if (!${Me.SpellReady["${GroupBuff[${a}]}"]}) {
/call Delay 3s
/varset RetryBuffCount ${Math.Calc[${RetryBuffCount}+1]}
/goto :RetryBuff
}
}
/echo -(( Group Buff:${GroupBuff[${a}]} not memmed or not ready. ))-
/echo -(( Waiting 60 seconds before retrying buff. ))-
/varset GBL[${a},${Math.Calc[${b}+1]}] ${Math.Calc[60+${Macro.RunTime}]}
}
}
}
:BreakOutMember
/next b
:BreakOutBuff
/next a
}
/return


Sub HealCheck
/varset HealTimer ${HealCheckTime}
/declare a int local
/declare b int local
/declare c int local
/declare d int local
/declare e int local
/declare f int local
/declare RetryHealCount int local
/declare GroupHPTotal int local
/declare GroupHealFlag int local
/declare TempIndex int local
/declare TempGroupCount int local
/declare ParseAnnounceChannels string local
/declare TempHoldAnnounce string local
/declare PetHealFlag int local 0
/declare TempGrpCt int local 0
/declare TempClass string local Nothing
/declare TempHealth int local 0
/declare TempTargetType string local
/varset TempGroupCount ${Group}

/if (${HealCount}>0) {
/for a 1 to ${HealCount}
/doevents Enraged
/call AdvPathCall
/if (${PauseHeals}==1) /return
/if (${Group}!=${TempGroupCount}) /return
/varset GroupHealFlag 0
/if (${Me.PctMana}>=${HealMinMana[${a}]}) {
/varset GroupHPTotal 0
/for b 0 to ${Math.Calc[${Group}+${WatchListCount}]}
/varset PetHealFlag 0
/call AdvPathCall
/if (${b}>${Group}) {
/varset d ${Math.Calc[${b}-${Group}]}
/if (!${WatchList[${d}].Equal[Empty]}) {
/for e 0 to 5
/if (${WatchList[${d}].Equal[${Group[${e}]}]}) {
/goto :BreakOutHoT
}
/next e
}
}
/if (${Group}!=${TempGroupCount}) /return
/varset TempIndex ${Math.Calc[${b}-${Group}]}
/if (${b}>${Group}) {
/if (!${WatchList[${TempIndex}].Equal[Empty]}) {
/if (${Spawn[${WatchList[${TempIndex}]}].ID}) {
/if (${Spawn[${WatchList[${TempIndex}]}].Distance}<250) {
/if (${Math.Calc[${Macro.RunTime}]}>${WatchTimer[${TempIndex}]}) {
/if (${Target.ID}!=${Spawn[${WatchList[${TempIndex}]}].ID}) {
/squelch /target id ${Spawn[${WatchList[${TempIndex}]}].ID}
/delay 1s ${Target.ID}==${Spawn[${WatchList[${TempIndex}]}].ID}
}
/if (${Spawn[${WatchList[${TempIndex}]}].Pet.ID}>0 && ${HealPets}==1) {
/squelch /target id ${Spawn[${WatchList[${TempIndex}]}].Pet.ID}
/delay 1s ${Target.ID}==${Spawn[${WatchList[${TempIndex}]}].Pet.ID}
}
/varset WatchTimer[${Math.Calc[${TempIndex}]}+1]}] ${Math.Calc[${Macro.RunTime}+2]}
}
}
}
}
}
/varset RetryHealCount 0
/if (${Math.Calc[${Group}+1]}<${HealMinGroupCount[${a}]}) /goto :BreakOutHeal

/varset TempTargetType ${Spell[${HealSpellID[${a}]}].TargetType}
/if ((${TempTargetType.Find["Group"]})||(${HealMinGroupCount[${a}]}>0)) {
/if (${b}<=${Group}) {
/if (${Group[${b}].ID}>0) /varset GroupHPTotal ${Math.Calc[${GroupHPTotal}+${Group[${b}].PctHPs}]}
/goto :BreakOutHoT
} else {
/goto :BreakOutHoT
}
}

/if (${b}<=${Group}) {
/varset TempClass ${Group[${b}].Class.ShortName}
/varset TempHealth ${Group[${b}].PctHPs}
/if (${String["WIZ|MAG|ENC|NEC"].Find["${TempClass}"]}>0) {
/if (${TempHealth}>${HealMinHP[${a}]} && ${TempHealth}<${Math.Calc[${HealMaxHP[${a}]}+${WussyFactor}]}) /goto :ContinueHeal
} else /if (${String["SHM|CLR|DRU"].Find["${TempClass}"]}>0) {
/if (${TempHealth}>${HealMinHP[${a}]} && ${TempHealth}<${Math.Calc[${HealMaxHP[${a}]}+(${WussyFactor}/2)]}) /goto :ContinueHeal
} else {
/if (${TempHealth}>${HealMinHP[${a}]} && ${TempHealth}<${HealMaxHP[${a}]}) /goto :ContinueHeal
}
/if (${HealPets}==1) {
/varset TempHealth ${Group[${b}].Pet.PctHPs}
/if (${TempHealth}>${HealMinHP[${a}]} && ${TempHealth}<${HealMaxHP[${a}]}) {
/varset PetHealFlag 1
/goto :ContinueHealPet
}
}
} else {
/varset TempClass ${Spawn[${WatchList[${TempIndex}]}].Class.ShortName}
/varset TempHealth ${Spawn[${WatchList[${TempIndex}]}].PctHPs}
/if (${String["WIZ|MAG|ENC|NEC"].Find["${TempClass}"]}>0) {
/if (${TempHealth}>${HealMinHP[${a}]} && ${TempHealth}<${Math.Calc[${HealMaxHP[${a}]}+${WussyFactor}]}) /goto :ContinueHeal
} else /if (${String["SHM|CLR|DRU"].Find["${TempClass}"]}>0) {
/if (${TempHealth}>${HealMinHP[${a}]} && ${TempHealth}<${Math.Calc[${HealMaxHP[${a}]}+(${WussyFactor}/2)]}) /goto :ContinueHeal
} else {
/if (${TempHealth}>${HealMinHP[${a}]} && ${TempHealth}<${HealMaxHP[${a}]}) /goto :ContinueHeal
}
/if (${HealPets}==1) {
/varset TempHealth ${Spawn[${WatchList[${TempIndex}]}].Pet.PctHPs}
/if (${TempHealth}>${HealMinHP[${a}]} && ${TempHealth}<${HealMaxHP[${a}]}) {
/varset PetHealFlag 1
/goto :ContinueHealPet
}
}
}

/goto :BreakOutHoT

:ContinueHeal
/call AdvPathCall
/if (!${HealClass[${a}].Find["${TempClass}"]}>0) /goto :BreakOutHoT

:ContinueHealPet
/if (${PetHealFlag}==0 && ${Math.Calc[${Macro.RunTime}]}<${HoTList[${Math.Calc[${b}+1]},1]} && ${TempTargetType.Find["Single"]}) /goto :BreakOutHoT
/if (${PetHealFlag}==1 && ${Math.Calc[${Macro.RunTime}]}<${HoTList[${Math.Calc[${b}+1]},2]} && ${TempTargetType.Find["Single"]}) /goto :BreakOutHoT

:RetryHeal
/if (${PauseHeals}==1) /return
/if (${Me.Gem[${HealSpell[${a}]}]} || ${HealSpell[${a}].Find["item"]} || ${HealSpell[${a}].Find["activate"]} || ${HealMemToSlot[${a}]}>0) {

/if (${HealSpell[${a}].Find["activate"]} && !${Me.AltAbilityReady[${HealSpell[${a}].Right[-9]}]}) /goto :BreakOutHeal

/if (!${HealSpell[${a}].Find["item"]}>0 && !${HealSpell[${a}].Find["activate"]}>0) {
/if (${Me.Gem[${HealSpell[${a}]}]}) {
/for f 1 to 30
/delay 1
/if (${Me.SpellReady["${HealSpell[${a}]}"]}) {
/goto :ContinueHeal2
}
/next f
/if (!${Me.SpellReady["${HealSpell[${a}]}"]}) /goto :BreakOutHeal
}
}
:ContinueHeal2

/if (${b}<=${Group} && !${Group[${b}].ID}>0) /goto :BreakOutHoT
/if (${b}>${Group} && !${Spawn[${WatchList[${TempIndex}]}].ID}>0) /goto :BreakOutHoT

/if ((${TempTargetType.Find["Group"]} || ${b}==0) && ${PetHealFlag}==0) {
/squelch /target myself
/delay 1s ${Target.ID}==${Me.ID}
} else /if (${b}<=${Group} && ${PetHealFlag}==0) {
/squelch /target id ${Group[${b}].ID}
/delay 1s ${Target.ID}==${Group[${b}].ID}
} else /if (${PetHealFlag}==1) {
/if (${b}<=${Group}) {
/squelch /target id ${Group[${b}].Pet.ID}
/delay 1s ${Target.ID}==${Group[${b}].Pet.ID}
} else {
/squelch /target id ${Spawn[${WatchList[${TempIndex}]}].Pet.ID}
/delay 1s ${Target.ID}==${Spawn[${WatchList[${TempIndex}]}].Pet.ID}
}
} else {
/squelch /target id ${Spawn[${WatchList[${TempIndex}]}].ID}
/delay 1s ${Target.ID}==${Spawn[${WatchList[${TempIndex}]}].ID}
}

/if (${Target.CleanName.Equal[${Group[${b}]}]}) /goto :TargetInZone
/if (${Target.CleanName.Equal[${WatchList[${TempIndex}]}]}) /goto :TargetInZone
/if (${Target.CleanName.Equal[${Group[${b}].Pet.CleanName}]}) /goto :TargetInZone
/if (${Target.CleanName.Equal[${Spawn[${WatchList[${TempIndex}]}].Pet.CleanName}]}) /goto :TargetInZone

/echo -(( Target not in zone. Waiting 10 seconds and trying again. ))-
/if (${PetHealFlag}==0) /varset HoTList[${Math.Calc[${b}+1]},1] ${Math.Calc[10+${Macro.RunTime}]}
/if (${PetHealFlag}==1) /varset HoTList[${Math.Calc[${b}+1]},2] ${Math.Calc[10+${Macro.RunTime}]}
/goto :BreakOutHoT

:TargetInZone
/if (!${HealSpell[${a}].Find[Item]} && !${HealSpell[${a}].Find[Activate]} && ${Target.Distance3D}>${Spell[${HealSpellID[${a}]}].Range}) /goto :BreakOutHoT
/if (${Announce}==1 && !${HealAnnounce[${a}].Equal["NULL"]}) {
/if (${AnnounceChannel.Length}>0) {
/if (${AnnounceChannel.Find[;]}) {
/varset TempHoldAnnounce ${AnnounceChannel}
arseNext
/varset ParseAnnounceChannels ${TempHoldAnnounce.Arg[1,;]}
/varset TempHoldAnnounce ${TempHoldAnnounce.Right[-${TempHoldAnnounce.Find[;]}]}
:SendIt
/if (${ParseAnnounceChannels.Equal[gsay]} && ${Group}>0) {
/gsay ${HealAnnounce[${a}]}
} else /if (!${ParseAnnounceChannels.Equal[gsay]}) {
/docommand /${ParseAnnounceChannels} ${HealAnnounce[${a}]}
}
/if (${TempHoldAnnounce.Length}>0) {
/if (${TempHoldAnnounce.Find[;]}>0) {
/goto arseNext
} else {
/varset ParseAnnounceChannels ${TempHoldAnnounce}
/varset TempHoldAnnounce
/goto :SendIt
}
}
} else {
/if (${AnnounceChannel.Equal[gsay]} && ${Group}>0) {
/gsay ${HealAnnounce[${a}]}
} else /if (!${AnnounceChannel.Equal[gsay]}) {
/docommand /${AnnounceChannel} ${HealAnnounce[${a}]}
}
}
}
}
/if (${Me.Sitting}) /stand
/if (${HealSpell[${a}].Left[4].Equal["item"]}) {
/echo -[ Casting Heal Spell : ${HealSpell[${a}]} ]-
/call Cast "${HealSpell[${a}].Right[-5]}" "item" "${Dismount}"
} else /if (${HealSpell[${a}].Left[8].Equal["activate"]}) {
/echo -[ Casting Heal Spell : ${HealSpell[${a}]} ]-
/call Cast "${HealSpell[${a}].Right[-9]}" "activate" "${Dismount}"
} else {
/echo -[ Casting Heal Spell : ${HealSpell[${a}]} ]-
/call Cast "${HealSpell[${a}]}" "gem${HealMemToSlot[${a}]}" "${Dismount}"
}

/if (${Macro.Return.Equal["CAST_LOSTTARGET"]}) {
/delay 5
/varset HealTimer 0
/return
}
/if (${Macro.Return.Equal["CAST_CANNOTSEE"]} || ${Macro.Return.Equal["CAST_OUTOFRANGE"]}) {
/echo -(( Out of range or cannot be seen. Waiting 10 seconds and trying again. ))-
/if (${PetHealFlag}==0) /varset HoTList[${Math.Calc[${b}+1]},1] ${Math.Calc[10+${Macro.RunTime}]}
/if (${PetHealFlag}==1) /varset HoTList[${Math.Calc[${b}+1]},2] ${Math.Calc[10+${Macro.RunTime}]}
/goto :BreakOutHoT
}
/if (${GroupHealFlag}==1) {
/delay 15
/varset GroupHealFlag 0
}
/if (${Spell[${HealSpellID[${a}]}].Duration}>0 && ${Macro.Return.Equal["CAST_SUCCESS"]}) {
/if (${PetHealFlag}==0) /varset HoTList[${Math.Calc[${b}+1]},1] ${Math.Calc[${Spell[${HealSpellID[${a}]}].Duration.Seconds}+${Macro.RunTime}]}
/if (${PetHealFlag}==1) /varset HoTList[${Math.Calc[${b}+1]},2] ${Math.Calc[${Spell[${HealSpellID[${a}]}].Duration.Seconds}+${Macro.RunTime}]}
/if (${Spell[${HealSpellID[${a}]}].Duration}>0 && ${Macro.Return.Equal["CAST_SUCCESS"]} && (${TempTargetType.Find["Group"]} || ${HealMinGroupCount[${a}]}>0)) {
/for c 0 to ${Group}
/varset HoTList[${Math.Calc[${c}+1]},1] ${Math.Calc[${Spell[${HealSpellID[${a}]}].Duration.Seconds}+${Macro.RunTime}]}
/next c
/varset GroupHPTotal ${Math.Calc[100*${Math.Calc[${Group}+1]}]}
/goto :BreakOutHeal
}
}
/varset GroupHPTotal ${Math.Calc[100*${Math.Calc[${Group}+1]}]}
} else {
/if (${RetryHealCount}==0) {
/if (!${Me.SpellReady["${HealSpell[${a}]}"]}) {
/call Delay 3s
/varset RetryHealCount ${Math.Calc[${RetryHealCount}+1]}
/goto :RetryHeal
}
}
/echo -(( Heal Spell:${HealSpell[${a}]} not memmed or not ready. ))-
/goto :BreakOutHeal
}
:BreakOutHoT
/next b
/if (${TempTargetType.Find["Group"]} || ${HealMinGroupCount[${a}]}>0) {
/varset TempGrpCt 0
/for c 0 to ${Group}
/if (${Group[${c}].ID}>0) /varset TempGrpCt ${Math.Calc[${TempGrpCt}+1]}
/next c
/if (${Math.Calc[${GroupHPTotal}\${TempGrpCt}]}>${HealMinHP[${a}]} && ${Math.Calc[${GroupHPTotal}\${TempGrpCt}]}<${HealMaxHP[${a}]}) {
/for c 0 to ${Group}
/if (${Math.Calc[${Macro.RunTime}]}<${HoTList[${Math.Calc[${c}+1]},1]}) /goto :BreakOutHeal
/next c
/varset GroupHealFlag 1
/varset b 0
/goto :RetryHeal
}
}
}
:BreakOutHeal
/next a
}
/return

[ViperOne]

Has anyone got AA Abilities to work in a indoors zone with this macro? If so can you post your working code?

Would be much appreciated.

[fearless]

And you have it working in an outdoor zone?

[ViperOne]

yes it works fine outside

[shaman001]

i am getting error

Code: Select all

subroutine Main wasn't found

any ideas why i got most uptodate everthing

[frabtik]

Double check your advbot.mac file, redownload etc. Make sure you are using the right command to start it etc. You ever had it working? That code you pasted still has some ${Math.Calc statements with the parenthesis in it. Mostly minor ones in the sit code part that I don't even use but just thought would point out you missed a couple.

[ViperOne]

Anyone had any luck geeting this to mez without recasting according to the debuff check timer (default of 3s)

I tried setting the duration of bliss to 54 but it still debuffs according to the debuff check timer of 3s. It's almost like its not paying attention to the duration timer of the debuffs anyone else have this problem and know a fix?

[A Troll]

Whats wrong with th is ? Wont use cannii disci

[Events]
EventCount=1
EventSpell1=activate 47
EventSpell2=Event Spell Name
EventSpell3=Event Spell Name
EventSpell4=Event Spell Name
EventSpell5=Event Spell Name
EventSpell6=Event Spell Name
EventSpell7=Event Spell Name
EventSpell8=Event Spell Name
EventMinMana1=10
EventMinMana2=100
EventMinMana3=100
EventMinMana4=100
EventMinMana5=100
EventMinMana6=100
EventMinMana7=100
EventMinMana8=100
EventMaxMana1=80
EventMaxMana2=0
EventMaxMana3=0
EventMaxMana4=0
EventMaxMana5=0
EventMaxMana6=0
EventMaxMana7=0
EventMaxMana8=0
EventMinHP1=100
EventMinHP2=100
EventMinHP3=100
EventMinHP4=100
EventMinHP5=100
EventMinHP6=100
EventMinHP7=100
EventMinHP8=100
EventMaxHP1=70
EventMaxHP2=0
EventMaxHP3=0
EventMaxHP4=0
EventMaxHP5=0
EventMaxHP6=0
EventMaxHP7=0
EventMaxHP8=0
EventDuration1=10
EventDuration2=0
EventDuration3=0
EventDuration4=0
EventDuration5=0
EventDuration6=0
EventDuration7=0
EventDuration8=0
EventMemToSlot1=0
EventMemToSlot2=0
EventMemToSlot3=0
EventMemToSlot4=0
EventMemToSlot5=0
EventMemToSlot6=0
EventMemToSlot7=0
EventMemToSlot8=0
EventCheckTime=1s

[fearless]

I believe advbot relies on AltAbilityReady and or AltAbiltyActivate. Seeing as both of those are broken / disabled, Advbot has no AA capabilities at the moment.

[Likwid]

I never had a problem pre omens of war patch but now this macro will not debuff. I don't know if it's link directly to macroquest but it sounds like it or if it's the macro itself. Can anyone fix this or find out what the problem is and let a dev know?

It does everything else from what I can tell but debuff.

Thanks

[JimJohnson]

This macro actually been broken for awhile. It has been redone and works but you need to donate to get into VIP access were its posted.