Skip to content

GitLab

VeryVanilla
VeryVanilla
Commit 94571a45 authored by Jack Straw's avatar Jack Straw
Browse files
Options

Added BuffNBurn.mac, refactored version of KeepToonBuffed.mac

parent b47109fa
Hide whitespace changes
Inline Side-by-side
Showing with 666 additions and 0 deletions
Release/Macros/BuffNBurn.mac 0 → 100644
View file @ 94571a45
|---------------------------------------------------------------------------------
|
| BuffNBurn.mac by jackstraw01(mq2war) -- Last Edited 6/20/2017
|
| This macro is designed to allow an out of group PowerLeveling toon
| to be able to target members of a low level group, heal,
| and maintain buffs on them.
| --- Base code was KeepToonBuffed by TreeHuginDruid.
| --- Credit goes out to Maskoi as well, for providing the CreateIni and LoadInI code -
| --- (Ripped from ShamBot)
|
|---------------------------------------------------------------------------------
#turbo 80
#include KeepToonBuffed.inc
#Event SpellBlocked "#*#Your #1# spell did not take hold on #2#. (Blocked by #3#.)#*#"
#Event SpellBlocked "#*#Your #1# spell did not take hold on #2#.#*#"
|---------------------------------------------------------------------------------
Sub Main
|---------------------------------------------------------------------------------
| ---- Turn off melee functions and turn on "Target Group Buff" setting ----------
/if (${Bool[${Plugin[MQ2Melee]}]}) /squelch /melee off
/tgb on
/squelch /target clear
|---------------------------------------------------------------------------------
|==================== DO NOT ALTER THESE VALUES ====================
/declare MacroName string outer KeepToonBuffed
/declare KeepToonBuffVer string outer 1.9.9
/declare IniFileName string outer ${MacroName}_${Me.CleanName}.ini
/call CreateIni
| ################## Set up [General] values
/call LoadIni General MacroVer string ${KeepToonBuffVer}
/call LoadIni General AutoAnnounce bool FALSE
/call LoadIni General Debug bool TRUE
/call LoadIni General AdminDebug bool FALSE
/call LoadIni General DebugINI bool FALSE
/call LoadIni General FollowGroup int 0
/call LoadIni General FollowDist int 30
/declare MyMDist int outer ${FollowDist}-5
/call LoadIni General SpellSetName string NULL
| ################## Set up [Mana] values
/call LoadIni Mana MinManaPct int 20
/call LoadIni Mana MinManaMedPct int 100
| ################## Set up [Heal] values
/call LoadIni Heal HealsOn int 1
/call LoadIni Heal HealSpell string NULL
/call LoadIni Heal HealPct int 60
/declare HealSpellRange int outer ${Spell[${HealSpell}].Range}
| ################## Set up [Toons] values
/call LoadIni Toons NumberOfToons int 6
/declare MyBuffTargetName[${NumberOfToons}] string outer
/call LoadIni Toons MyBuffTargetName string NULL MyBuffTargetName
| ################## Set up [Buffs] values
/call LoadIni Buffs BuffsOn int 1
/call LoadIni Buffs NumberOfBuffs int 5
/call LoadIni Buffs TargetBuffNameHelp string "Name of Spell to Cast|Name of Buff Effect in Buff Window"
/declare TargetBuffName[${NumberOfBuffs}] string outer
/call LoadIni Buffs TargetBuffName string NULL TargetBuffName
| ################## Set up [Assist] values
/call LoadIni Assist AssistOn int 0
/call LoadIni Assist NumberOfSpells int 5
/call LoadIni Assist AssistSpellHelp string "To be used for NON damage ROOT or SNARE spells ONLY!!!!!!"
/call LoadIni Assist MainAssist string ${MyBuffTargetName[1]}
/declare AssistSpell[${NumberOfSpells}] string outer
/call LoadIni Assist AssistSpell string NULL AssistSpell
/declare AssistPct[${NumberOfSpells}] int outer
/call LoadIni Assist AssistPct int 60 AssistPct
/if (${DEBUG}) {
/echo This is Main Assist: ${MainAssist}
/echo This is Number of Spells: ${NumberOfSpells}
}
/call VersionControl
/call CheckPlugin MQ2Cast
/call CheckPlugin MQ2Moveutils
|==================== DO NOT ALTER THESE VALUES ====================
|---------------------------------------------------------------------------------
/echo
/echo KeepToonBuffed.mac - Version: ${MacroVer} by TreeHuginDruid
/echo
|---------------------------------------------------------------------------------
|---------------------------------------------------------------------------------
/if (${Defined[SpellSetName]} || ${SpellSetName.NotEqual[null]}) {
/echo Memming spellset (${SpellSetName}).
/memspellset ${SpellSetName}
/delay 5s
}
|---------------------------------------------------------------------------------
:loop
|| Checking health
/if (${HealsOn}) /call CheckMyHealth
/if (${HealsOn}) /call CheckTargetHealth
/if (${Me.PctMana}<=${MinManaPct}) && !${Me.CombatState.Equal[COMBAT]}) /call CheckMana
/target ${MainAssist}
/delay 1s
/if (${AssistOn} && ${Select[${Me.TargetOfTarget.Type},NPC,PET]}) {
/if ($DEBUG) {
/echo Attack True!
/goto :combat
}
}
/if (${BuffsOn}) /call MaintainTargetBuffs
/if ((${Me.PctMana}<=${MinManaPct}) && !${Me.CombatState.Equal[COMBAT]}) /call CheckMana
/if (${FollowGroup}) /call FollowAround
|Internal second delay to allow for manual moving, prevents constant sit loop if only 1 toon being buffed.
/delay 10
/if (${Me.Standing} && !${Me.Casting.ID} && !${Me.CombatState.Equal[COMBAT]} && !${Me.Moving} && !${Me.Mount.ID}) /sit
/goto :loop
:combat
/target ${MainAssist}
/delay 1s
/echo \ao Calling AssistOnTarget: Target \at (${Target.CleanName})
/call AssistOnTarget
|Check Health
/if (${HealsOn}) /call CheckMyHealth
/if (${HealsOn}) /call CheckTargetHealth
/if (${AssistOn} && ${Select[${Me.TargetOfTarget.Type},NPC,PET]} ) {
/goto :combat
} else {
/goto :loop
}
/return
|---------------------------------------------------------------------------------
|---------------------------------------------------------------------------------
| SUB: Version Control
|---------------------------------------------------------------------------------
Sub VersionControl
/if (${MacroVer.NotEqual[${KeepToonBuffVer}]}) {
/echo Version mismatch detected, please wait until this is corrected.
/ini "${IniFileName}" "General" "MacroVer" "${KeepToonBuffVer}"
/echo Version information updated.
/call LoadIni General MacroVer string ${KeepToonBuffVer}
}
/return
|---------------------------------------------------------------------------------
|---------------------------------------------------------------------------------
| SUB: Check Plugin
|---------------------------------------------------------------------------------
Sub CheckPlugin(string pluginname)
/if (!${Bool[${Plugin[${pluginname}]}]}) {
/squelch /plugin ${pluginname}
/echo ${pluginname} not detected! This macro requires it! Loading ...
}
/return
|---------------------------------------------------------------------------------
|---------------------------------------------------------------------------------
| SUB: CreateIni
|---------------------------------------------------------------------------------
Sub CreateIni
/if (${Ini[${IniFileName}].Length}) /return
/declare a local General|Mana|Heal|Toons|Buffs|
/echo Creating ini file ${IniFileName}
/declare i int local 1
/for i 1 to 5
/ini ${IniFileName} "${a.Arg[${i},|]}" "|===================================" "==================================|"
/next i
/echo Please edit your ini file ${IniFileName} and restart Shambot
/return
|---------------------------------------------------------------------------------
|---------------------------------------------------------------------------------
| SUB: Load Ini
|---------------------------------------------------------------------------------
Sub LoadIni(string sectionName, string varName, string varType, string varValue, string varArray, string FileName)
| Assign ini name to default ini if not defined
/if (${FileName.Length}==0) {
|declaration not needed
| /declare FileName string local
/varset FileName ${IniFileName}
}
/if (${DebugINI}) {
/echo DEBUG LoadIni: enter
/delay 2
/echo \atDebugINI Sub Loadini sectionName=(${sectionName}) varName=(${varName}) varType=(${varType}) varValue=(${varValue}) varArray=(${varArray}) FileName=(${FileName}) \agLine#: ${Macro.CurLine}
}
| Check if ini value is asking for an array ie buff1 to buff20
| /if (!${varArray.Equal[NULL]}) {
|### Changed to check if varArray is defined
/if (${Defined[${varArray}]}) {
| /if (${${varArray}.Size}>0) {
/declare i int local
/for i 1 to ${${varArray}.Size}
/if (!${Ini[${FileName},${sectionName},${varArray}${i}].Length}) {
/if (${DebugINI}) /echo /ini "${FileName}" "${sectionName}" "${varArray}${i}" "${varValue}" ***
/ini "${FileName}" "${sectionName}" "${varArray}${i}" "${varValue}"
}
/if (${Ini[${FileName},${sectionName},${varArray}${i}].Length}) {
/if (${DebugINI}) /echo /varset ${varArray}[${i}] ${Ini[${FileName},${sectionName},${varArray}${i}]} ***
/varset ${varArray}[${i}] ${Ini[${FileName},${sectionName},${varArray}${i}]}
}
/next i
/return
} else {
/if (!${Defined[${varName}]} && ${Defined[varType]}) /declare ${varName} ${varType} outer
/if (!${Ini[${FileName},${sectionName},${varName}].Length}) {
/if (${varValue.Length}) {
/ini "${FileName}" "${sectionName}" "${varName}" "${varValue}"
/varset ${varName} ${varValue}
/if (${Debug}) /echo \atDEBUG Sub Loadini /varset ${varName} ${varValue} \agLine#: ${Macro.CurLine}
}
} else {
/varset ${varName} ${Ini[${FileName},${sectionName},${varName}]}
}
/if (${DebugINI}) /echo DEBUG LoadIni: leave
/return
|---------------------------------------------------------------------------------
Release/Macros/KeepToonBuffed.inc 0 → 100644
View file @ 94571a45
|--------------------------------------------------------------------------------
| SUB: Check My Health
|--------------------------------------------------------------------------------
Sub CheckMyHealth
/if (${Me.PctHPs}<=${HealPct}) {
/if (${Target.ID}!=${Me.ID}) {
/if (${Debug}) /echo Attempting to target (${Me.CleanName}) for heals!
/squelch /target id ${Me.ID} pc targetable
/delay 15 !${Target.ID}
/casting "${HealSpell}" gem8
/call CheckCasting
/call CheckGlobalCooldown
}
}
/return
|---------------------------------------------------------------------------------
|--------------------------------------------------------------------------------
| SUB: Check Target Health
|--------------------------------------------------------------------------------
Sub CheckTargetHealth
/declare j int local
/for j 1 to ${NumberOfToons}
|--------------------------------------------------------------------------------
/if (${Spawn[=${MyBuffTargetName[${j}]}].ID} || (${Spawn[=${MyBuffTargetName[${j}]}].ID} && ${MyBuffTargetName[${j}].NotEqual[null]})) {
/if (${Debug}) /echo \ao Attempting to target \at (${MyBuffTargetName[${j}]}) \ao for \ar health \ao check.
/if (${Target.ID}!=${Spawn[=${MyBuffTargetName[${j}]}].ID}) /squelch /target id ${Spawn[=${MyBuffTargetName[${j}]}].ID} ${Spawn[=${MyBuffTargetName[${j}]}].Type} targetable
/if (${AdminDebug}) /echo /squelch /target id ${Spawn[=${MyBuffTargetName[${j}]}].ID} ${Spawn[=${MyBuffTargetName[${j}]}].Type} targetable
/delay 15 !${Target.ID}
/if (${Target.ID}!=${Spawn[=${MyBuffTargetName[${j}]}].ID} || !${Select[${Target.Type},Mercenary,PC,Pet]}) /next j
|--------------------------------------------------------------------------------
| ADMIN DEBUG FOR HEAL CODE
|--------------------------------------------------------------------------------
/if (${AdminDebug}) {
/echo -----------
/if ((${Target.PctHPs}<=${HealPct}) && (${Target.Distance}<=${HealSpellRange}) && (${Target.Distance}<=${Spell[${HealSpell}].Range} || ${Target.Distance}<=${Spell[${HealSpell}].AERange})) {
/echo TargetType:${Select[${Target.Type},Mercenary,PC,Pet]} HEAL:${HealSpell} MANA:(${Me.CurrentMana}>${Spell[${HealSpell}].Mana}) INRANGE:(${Target.Distance}<=${Spell[${HealSpell}].Range} || ${Target.Distance}<=${Spell[${HealSpell}].AERange})
/echo "${TargetBuffName[${j}]}" = Heal Should Cast
} else {
/echo TargetType:${Select[${Target.Type},Mercenary,PC,Pet]} HEAL:${HealSpell} MANA:(${Me.CurrentMana}>${Spell[${HealSpell}].Mana}) INRANGE:(${Target.Distance}<=${Spell[${HealSpell}].Range} || ${Target.Distance}<=${Spell[${HealSpell}].AERange})
/echo "${TargetBuffName[${j}]}" = Heal will NOT Cast
/echo -----------
/delay 10
}
}
|--------------------------------------------------------------------------------
/if ((${Target.PctHPs}<=${HealPct}) && (${Target.Distance}<=${HealSpellRange})) {
/if (${Debug}) /echo ${MyBuffTargetName[${j}]}'s health at (${Target.PctHPs}), HEAL TIME !!!!
/casting "${HealSpell}" gem8
/call CheckCasting
/call CheckGlobalCooldown
}
}
|--------------------------------------------------------------------------------
/next j
/if (${NumberOfToons}>1) /squelch /target clear
/return
|---------------------------------------------------------------------------------
|--------------------------------------------------------------------------------
| SUB: Maintain Target buffs
|--------------------------------------------------------------------------------
Sub MaintainTargetBuffs
/declare i int local
/declare j int local
/declare SpellToCast string local 0
/declare BuffIDName string local 0
/for j 1 to ${NumberOfToons}
/if (${Spawn[=${MyBuffTargetName[${j}]}].ID} || (${Spawn[=${MyBuffTargetName[${j}]}].ID} && ${MyBuffTargetName[${j}].NotEqual[null]})) {
/if (${Debug}) /echo \ao Attempting to target \at (${MyBuffTargetName[${j}]}) \ao for \ag buff \ao check.
/if (${Target.ID}!=${Spawn[=${MyBuffTargetName[${j}]}].ID}) /squelch /target id ${Spawn[=${MyBuffTargetName[${j}]}].ID} ${Spawn[=${MyBuffTargetName[${j}]}].Type} targetable
/if (${AdminDebug}) /echo /squelch /target id ${Spawn[=${MyBuffTargetName[${j}]}].ID} ${Spawn[=${MyBuffTargetName[${j}]}].Type} targetable
/delay 15 !${Target.ID}
/if (${Target.ID}!=${Spawn[=${MyBuffTargetName[${j}]}].ID} || !${Select[${Target.Type},Mercenary,PC,Pet]}) /next j
/if (${Spawn[=${MyBuffTargetName[${j}]}].ID}!=NULL) /call PopulateBuffs
|--------------------------------------------------------------------------------
/for i 1 to ${NumberOfBuffs}
|--------------------------------------------------------------------------------
|/echo This is target: ${MyBuffTargetName[${j}]}
|/echo ${TargetBuffName[${i}].Arg[3,|]}
|/echo ${TargetBuffName[${i}].Arg[3,|].Find[{MyBuffTargetName[${j}]}]}
/if ( ${TargetBuffName[${i}].Arg[3,|].Length}) {
/echo Buffees set: ${TargetBuffName[${i}].Arg[3,|]}
/if (!${TargetBuffName[${i}].Arg[3,|].Find[${MyBuffTargetName[${j}]}]}) {
/echo not buffing ${MyBuffTargetName[${j}]}
/continue
}
}
|If spell name differs from buff name, use argument seperator to extract and set values.
/if (${TargetBuffName[${i}].Arg[2,|].Length}) {
/varset SpellToCast ${TargetBuffName[${i}].Arg[1,|]}
/varset BuffIDName ${TargetBuffName[${i}].Arg[2,|]}
} else {
/varset SpellToCast ${TargetBuffName[${i}]}
/varset BuffIDName ${TargetBuffName[${i}]}
}
|--------------------------------------------------------------------------------
|--------------------------------------------------------------------------------
| ADMIN DEBUG FOR BUFF CODE
|--------------------------------------------------------------------------------
/if (${AdminDebug}) {
/echo -----------
/if ((${Target.BuffsPopulated}==TRUE) && !${Target.Buff[${BuffIDName}].ID} && ${Select[${Spawn[${MyBuffTargetName[${j}]}].Type},Mercenary,PC,Pet]} && (${Me.CurrentMana}>${Spell[${SpellToCast}].Mana}) && (${Target.Distance}<=${Spell[${SpellToCast}].Range} || ${Target.Distance}<=${Spell[${SpellToCast}].AERange}) && !${Target.Buff[Resurrection Sickness].ID} && !${Target.Buff[Revival Sickness].ID}) {
/echo TargetType:${Select[${Target.Type},Mercenary,PC,Pet]} BUFF:!${Target.Buff[${BuffIDName}].ID} MANA:(${Me.CurrentMana}>${Spell[${SpellToCast}].Mana}) INRANGE:(${Target.Distance}<=${Spell[${SpellToCast}].Range} || ${Target.Distance}<=${Spell[${SpellToCast}].AERange}) RezSick:!${Target.Buff[Resurrection Sickness].ID} RevivSick:!${Target.Buff[Revival Sickness].ID}
/echo "${BuffIDName}" = Buff is Needed
} else {
/echo TargetType:${Select[${Target.Type},Mercenary,PC,Pet]} BUFF:!${Target.Buff[${BuffIDName}].ID} MANA:(${Me.CurrentMana}>${Spell[${SpellToCast}].Mana}) INRANGE:(${Target.Distance}<=${Spell[${SpellToCast}].Range} || ${Target.Distance}<=${Spell[${SpellToCast}].AERange}) RezSick:!${Target.Buff[Resurrection Sickness].ID} RevivSick:!${Target.Buff[Revival Sickness].ID}
/echo "${BuffIDName}" = Buff is NOT Needed
/echo -----------
/delay 10
}
}
|--------------------------------------------------------------------------------
/if (!${Target.Buff[${BuffIDName}].ID} && ${Select[${Spawn[${MyBuffTargetName[${j}]}].Type},Mercenary,PC,Pet]} && (${Me.CurrentMana}>${Spell[${SpellToCast}].Mana}) && (${Target.Distance}<=${Spell[${SpellToCast}].Range} || ${Target.Distance}<=${Spell[${SpellToCast}].AERange}) && !${Target.Buff[Resurrection Sickness].ID} && !${Target.Buff[Revival Sickness].ID}) {
/if (${Debug}) /echo Attempting to cast (${SpellToCast}) on (${MyBuffTargetName[${j}]}).
/casting "${SpellToCast}" gem8
/call CheckCasting
/call CheckGlobalCooldown
/doevents
}
/next i
|--------------------------------------------------------------------------------
|/if (${AssistOn} && ${Spawn[=${MyBuffTargetName[${j}]}].ID}!=NULL) /call AssistOnTarget
}
/next j
/if (${NumberOfToons}>1) /squelch /target clear
/return
|---------------------------------------------------------------------------------
|--------------------------------------------------------------------------------
| SUB: Populate Buffs
|--------------------------------------------------------------------------------
Sub PopulateBuffs
:GetTargetBuffs
/if ((!${Target.BuffsPopulated}==TRUE) && (${NumberOfToons}>1)) {
/if (${AdminDebug}) /echo ${Target.CleanName} {Target.BuffsPopulated}=${Target.BuffsPopulated}
/delay 5
}
/if ((!${Target.BuffsPopulated}==TRUE) && (${NumberOfToons}>1)) /goto :GetTargetBuffs
/if (${AdminDebug}) /echo ${Target.CleanName} {Target.BuffsPopulated}=${Target.BuffsPopulated}
/return
|--------------------------------------------------------------------------------
|--------------------------------------------------------------------------------
| SUB: Assist On Target
|--------------------------------------------------------------------------------
Sub AssistOnTarget
/echo Testing parms: ${Param0}
/declare x int local
/declare SpellToCast string local
/target ${MainAssist}
/delay 6
/if (${Me.TargetOfTarget.CleanName.Equal[NULL]} || ${Me.TargetOfTarget.Type.Equal[CORPSE]}) /return
/for x 1 to ${NumberOfSpells} {
/echo ${NumberOfSpells}
/echo here is spell in loop: ${AssistSpell[${x}].Arg[1,|]}
/next x
}
/if (${Select[${Me.TargetOfTarget.Type},NPC,PET]}) {
/for x 1 to ${NumberOfSpells} {
|--------------------------------------------------------------------------------
| SUB: Multiple Spells On Target
|--------------------------------------------------------------------------------
|--------------------------------------------------------------------------------
| SUB: Multi On Target
|--------------------------------------------------------------------------------
Sub AssistOnTarget
/echo Testing parms: ${Param0}
/declare x int local
/declare SpellToCast string local
/target ${MainAssist}
/delay 1s
/if (${Me.TargetOfTarget.CleanName.Equal[NULL]} || ${Me.TargetOfTarget.Type.Equal[CORPSE]}) /return
/if (${Select[${Me.TargetOfTarget.Type},NPC,PET]}) {
/squelch /target id ${Me.TargetOfTarget.ID} ${Me.TargetOfTarget.Type} targetable
/delay 10
/for x 1 to ${NumberOfSpells} {
/echo ${NumberOfSpells}
/echo ${Target}
/echo here is spell in loop: ${AssistSpell[${x}].Arg[1,|]}
/echo on Spell ${x}
/varset SpellToCast ${AssistSpell[${x}].Arg[1,|]}
/echo ${SpellToCast}
/if (${AssistSpell[${x}].Arg[2,|].Equal[debuff]} && !${Target.Buff[${SpellToCast}].ID} ) {
/echo Is A Debuff
/echo ${AssistPct[${x}]}
/if (${AssistPct[${x}]} > ${Target.PctHPs}) {
/echo casting ${AssistSpell[${x}]}
/call CastIt "${SpellToCast}"
}
}
/if (${AssistSpell[${x}].Arg[2,|].Equal[nuke]} ) {
/echo is a nuke
/if (${AssistPct[${x}]} > ${Target.PctHPs}) {
/echo casting ${AssistSpell[${x}]}
/call CastIt "${SpellToCast}"
}
}
/next x
}
}
/return
|---------------------------------------------------------------------------------
|---------------------------------------------------------------------------------
SUB: CastIt
|---------------------------------------------------------------------------------
Sub CastIt(string SpellName)
/if (${Debug}) /echo Attempting to assist, casting (${SpellName}) on (${Target.CleanName}).
/echo \ao Assisting: casting \at (${SpellName}) \ag on \ar (${Me.TargetOfTarget.CleanName})
/cast "${SpellName}"
/call CheckCasting
}
/return
|---------------------------------------------------------------------------------
| SUB: Check Mana
|---------------------------------------------------------------------------------
Sub CheckMana
/if (${Select[${Me.Class.ShortName},BRD]}) /return
/echo Checking my Mana . . .
/if (${Me.PctMana}<${MinManaMedPct}) {
/echo I'm low on mana (${Me.PctMana}%), medding to (${MinManaMedPct}%).
/if (${AutoAnnounce}) /tell ${MyBuffTargetName[1]} I'm low on mana, medding to full.
/if (${Me.Standing} && !${Me.Mount.ID}) /sit
:KeepMeddingForMana
/if (!${Me.CombatState.Equal[COMBAT]} && (${Me.PctMana}<${MinManaMedPct})) {
/echo Mana now at (${Me.PctMana}%) ...
/if (${Me.AltAbilityReady[Cannibalization]}) /call Cast "Cannibalization" alt
/if (${HealsOn}) /call CheckMyHealth
/if (${HealsOn}) /call CheckTargetHealth
/if (${BuffsOn}) /call MaintainTargetBuffs
/if (${FollowGroup}) /call FollowAround
/delay 6s
/doevents
/if (${Me.Standing} && !${Me.Mount.ID}) /sit
/goto :KeepMeddingForMana
} else {
/if (${Me.Sitting} && !${Me.Mount.ID}) /stand
}
/echo Mana check done . . .
/if (${AutoAnnounce}) /tell ${MyBuffTargetName[1]} Done medding!
}
/return
|---------------------------------------------------------------------------------
|---------------------------------------------------------------------------------
| SUB: Follow Around
|---------------------------------------------------------------------------------
Sub FollowAround
/if (${Target.ID}!=${Spawn[=${MyBuffTargetName[1]}].ID} && ${MyBuffTargetName[1].NotEqual[null]}) {
/squelch /target id ${Spawn[=${MyBuffTargetName[1]}].ID} ${Spawn[=${MyBuffTargetName[1]}].Type} targetable
/delay 10
}
/if (${AdminDebug}) {
/echo \atFollowAround: (${FollowGroup}) FollowDIst: (${FollowDist})
}
:CheckDist
/if (${Target.Distance} > ${FollowDist}) {
/echo *** Moving closer to (${MyBuffTargetName[1]}). ***
/if (${Me.Sitting} && !${Me.Mount.ID}) /stand
/moveto id ${Spawn[=${MyBuffTargetName[1]}].ID} mdist ${MyMDist}
/delay 10
/if (${Target.Distance} > ${FollowDist}) /goto :CheckDist