Commit 94571a45 authored by Jack Straw's avatar Jack Straw

Added BuffNBurn.mac, refactored version of KeepToonBuffed.mac

parent b47109fa
|---------------------------------------------------------------------------------
|
| 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
|---------------------------------------------------------------------------------
|--------------------------------------------------------------------------------
| 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