Maskoi
old and salty
- Joined
- Sep 28, 2005
- RedCents
- 82,796¢
KissAssist.mac v3.9 Updated 07/20/2011
Instructions/Settings Info Click Here
K.I.S.S. Assist is the base macro for a new macro system we are developing at RedGuides/NotAddicted.com. The idea is develop a macro that is well documented and easy to use. We will be adding features to the macro after each phase is well tested.
KissAssist is designed as a stand alone multi class macro. Its main purpose is to get your toon assisting and DPSing mobs in as little time as possible. The macro tries to utilize the features common to all or most classes while ditching the micro managing settings and class specific features that make such macros confusing and complicated. The idea is utilize the full potential of plugins to keep code and settings lite and friendly. This is a work in progress and will grow and evolve over the next few months.
Requires plugins* MQ2Cast, MQ2Exchange, MQ2Melee, MQ2MoveUtils, Mq2Rez, & MQ2Twist (Bards) , Extended Target Window and ninjadvloot.inc file.
* All plugins are included in both our NA Very Vanilla & Official Compile.
Examples of the KissAsisst 3.4 ini file [/SIZE]
Feel free to test it and post suggestions for improvements or features.
To Do List
Fix looting while mounted
Add pet heals
Add Autofire/Range attacks
Add GoM feature
Rich (BB code):
| - kissassist.mac v3.9 by Maskoi 07/20/2011
| - KISS Asisst - A simple multi class assist macro
| Requires MQ2Cast, MQ2Exchange. MQ2Melee, MQ2MoveUtils, MQ2Rez ninjadvloot inc file and Extended target window
| Usage - /mac kissassist TankName 95
| or target Main Tank and /mac kissassist
| This macro was written exclusively for subscribers of Redguides/NotAddicted.com
|
| Casters should turn off melee in ini file. MeleeOn=0
|
|-------------------------------------------------------------------------------------
#turbo 40
#include ninjadvloot.inc
#define DEBUG "/squelch /echo"
#define DEBUG1 "/squelch /echo"
#define DEBUG2 "/squelch /echo"
#Event ToggleVariable "[MQ2] Toggle #1#"
#Event ToggleVariable "[MQ2] Toggle #1# #2#"
|-------------------------------------------------------------------------------------
| Sub Main
|-------------------------------------------------------------------------------------
Sub Main
/declare MacroName string outer KissAssist
/declare MacroVer string outer 3.9
/declare IniFileName string outer ${MacroName}_${Me.CleanName}.ini
| Edit settings in your KissAssist_ToonName.ini file
/call LoadIni General KissAssistVer string ${MacroVer}
/call LoadIni General Role string Assist
/call LoadIni General XTSlot int 1
/call LoadIni General CampRadius int 30
/call LoadIni General CampRadiusExceed int 400
/call LoadIni General ReturnToCamp int 0
/call LoadIni General ChaseAssist int 0
/call LoadIni General ChaseDistance int 25
/call LoadIni General MedOn int 0
/call LoadIni General MedStart int 20
/call LoadIni General MedCombat int 0
/call LoadIni General LootOn int 0
/call LoadIni General RezAcceptOn int 0
/call LoadIni General AcceptInvitesOn int 1
/call LoadIni Melee AssistAt int 95
/call LoadIni Melee MeleeOn int 0
/call LoadIni Melee FaceMobOn int 1
/call LoadIni Melee MeleeDistance int 75
/call LoadIni Melee StickHow string snaproll rear
/call LoadIni Buffs BuffsOn int 0
/declare Buffs[15] string outer
/call LoadIni Buffs Buffs string NULL Buffs
/call LoadIni DPS DPSOn int 0
/call LoadIni DPS DPSSkip int 20
/call LoadIni DPS DPSInterval int 2
/if (${Me.Class.Name.Equal[Bard]}) {
/call LoadIni General TwistOn int 0
/call LoadIni General TwistWhat string "Twist order here"
/call LoadIni Melee MeleeTwistOn int 0
/call LoadIni Melee MeleeTwistWhat string "DPS twist order here"
}
| Pull variables for future use not implemented yet.
| /call LoadIni Pull MaxRadius int 350
| /call LoadIni Pull MaxZRange int 50
| /call LoadIni Pull FailMax int 3
/declare DPS[8] string outer
/call LoadIni DPS DPS string NULL DPS
/call LoadIni Heals Help string "Format Spell|% to heal at i.e. Devout Light Rk. II|50"
/call LoadIni Heals HealsOn int 0
/declare Heals[8] string outer
/call LoadIni Heals Heals string NULL Heals
/if (${Select[${Me.Class.ShortName},SHM,BST,ENC,MAG,NEC,SHD,WIZ]}) {
/call LoadIni Pet PetOn int 0
/call LoadIni Pet PetSpell string "YourPetSpell"
/call LoadIni Pet PetShrinkOn int 0
/call LoadIni Pet PetShrinkSpell string "Tiny Companion"
/call LoadIni Pet PetBuffsOn int 0
/declare PetBuffs[8] string outer
/call LoadIni Pet PetBuffs string NULL PetBuffs
}
/if (${Select[${Me.Class.ShortName},BRD,ENC]}) {
/declare MezMob[5] int outer
/call LoadIni Mez MezOn int 0
/call LoadIni Mez MezRadius int 50
/call LoadIni Mez MezMinLevel int 65
/call LoadIni Mez MezMaxLevel int 85
/call LoadIni Mez MezStopHPs int 80
/call LoadIni Mez MezSpell string "Your Mez Spell"
}
| Do Not Edit These
/declare MainAssist string outer
/declare CampZone int outer ${Zone.ID}
/declare CampXLoc int outer ${Me.X}
/declare CampYLoc int outer ${Me.Y}
/declare LookForward int outer ${Me.Heading.DegreesCCW}
/declare Attacking int outer 0
/declare PetAttack int outer 0
/declare MedStat string outer
/declare PetShrunk int outer 0
/declare MiscGem string outer 8
/declare Twisting int outer 0
/declare DPSTwisting int outer 0
/declare AddsInCamp int outer 0
/declare OldAssistAt int outer 0
/declare MyTargetID int outer 0
/declare MyTargetName string outer 0
/declare ValidTarget int outer 0
/declare MountOn int outer 1
/declare WasTwisting int outer 0
/declare CastResult string outer
/declare TanksMob int outer 0
/declare AggroCheck string outer
/declare AggroTargetID string outer
/declare FailCounter int outer 0
/declare BuffQue[60] int outer 0
| Compensate for Progression servers not having Extended Target Window
/if (${Select[${MacroQuest.Server},fippy,vulak]}) {
/noparse /varset AggroCheck ${SpawnCount[npc radius ${MeleeDistance}]}
/noparse /varset AggroTargetID ${NearestSpawn[1,npc radius 20].ID}
} else {
/noparse /varset AggroCheck ${Me.XTarget[${XTSlot}].ID}
/noparse /varset AggroTargetID ${Me.XTarget[${XTSlot}].ID}
/call LoadIni Merc Help string "To use: Turn off Auto Assist in Manage Mercenary Window"
/call LoadIni Merc MercOn int 0
/call LoadIni Merc MercAssistAt int 92
}
/if (${Select[${Me.Class.ShortName},BST,BRD,CLR,DRU,ENC,MAG,NEC,PAL,RNG,SHM,SHD,WIZ]}) /varset MedStat Mana
/if (${Select[${Me.Class.ShortName},BER,MNK,ROG,WAR]}) /varset MedStat Endurance
/declare i int local
| Declare timers for DPS duration spells
/for i 1 to ${DPS.Size}
/declare DPSTimer${i} timer outer 5
/next i
| Declare timers for Heal duration spells
/declare j int local
/declare k int local
| Declare timers for Heal duration spells
/for j 1 to ${Heals.Size}
/declare SpellGH${j} timer outer 0
/for k 0 to 5
/declare Spell${j}GM${k} timer outer 0
DEBUG Spell${j}GM${k} ${Spell${j}GM${k}}
/next k
/next j
| Declare timers for mezzing
/declare l int local
/for l 1 to 5
/declare MezTimer${l} timer outer 0
/next l
/if (${KissAssistVer.NotEqual[${MacroVer}]}) {
/echo Version Mismatch Detected, Loading Aliases this can take up to 1 min
/squelch /alias /looton /echo toggle LootOn
/squelch /alias /buffson /echo toggle BuffsOn
/squelch /alias /dpson /echo toggle DPSOn
/squelch /alias /meleeon /echo toggle MeleeOn
/squelch /alias /healson /echo toggle HealsOn
/squelch /alias /peton /echo toggle PetOn
/squelch /alias /mezon /echo toggle MezOn
/squelch /alias /chase /echo toggle ChaseAssist
/squelch /alias /camphere /echo toggle ReturnToCamp
/ini "${IniFileName}" "General" "KissAssistVer" "${MacroVer}"
}
|-------------------------------------------------------------------------------------
| Check if required plugins are loaded and settings
|-------------------------------------------------------------------------------------
/call CheckPlugin MQ2Cast
/call CheckPlugin MQ2Exchange
/call CheckPlugin MQ2Melee
/call CheckPlugin MQ2Moveutils
/call CheckPlugin MQ2Rez
| Turn aggro mode off and turn on melee mode in MQ2Melee
/if (${MeleeOn}) {
/squelch /melee aggro=0
/squelch /melee melee=1
/squelch /melee stickbreak=1
}
| Set MQ2moveutils variables
/stick set verbflags 0
/stick set breakonkb on
/stick set breakonmouse on
/stick set breakdist ${CampRadiusExceed}
/stick set breakonwarp on
| Set up MQ2rez if RezAcceptOn=1
/if (${RezAcceptOn}) {
/squelch /rez accept on
/squelch /rez loot off
} else /squelch /rez accept off
| Initialize variables for ninjadvloot.inc include file
/call SetupAdvLootVars
|-------------------------------------------------------------------------------------
| Check and set roles
|-------------------------------------------------------------------------------------
/if (${Role.Equal[tank]}) {
/echo Looks like I am Main Tank. Wish me luck.
/varset MainAssist ${Me}
/squelch /melee aggro=1
/varset AssistAt 100
/varset StickHow front
}
|-------------------------------------------------------------------------------------
| - Assign Main Tank from command line parameter or targeted player, merc or pet
|-------------------------------------------------------------------------------------
/if (!${Defined[Param0]}) {
/varset MainAssist ${Target.CleanName}
}
| Check command line for tank name
/if (${Defined[Param0]}) {
/varset MainAssist ${Param0}
/delay 10
/target id ${Spawn[${MainAssist}].ID}
}
| Error control no tank selected end macro
/if (!${Spawn[${Target}].ID} || !${Select[${Target.Type},Mercenary,PC,Pet]}) {
/echo You do not have a Mercenary, PC or Pet targeted. Please target Main Tank and restart macro.
/end
}
| Targeted myself end macro
/if (${Target.CleanName.Equal[${Me.CleanName}]} && ${Role.NotEqual[tank]}) {
/echo You cannot assist yourself! Please target Main Tank and restart macro.
/end
}
/if (${Defined[Param1]} && ${Role.NotEqual[tank]}) {
/varset AssistAt ${Param1}
}
/echo ================================
/echo Redguides/NotAddicted.com presents
/echo ${MacroName} v.${MacroVer} by Maskoi
/echo ================================
/if (${Role.Equal[tank]} && ${MainAssist.Equal[${Me}]}) {
/echo I am Main Tank and Main Assist
} else {
/echo KissAssisting >> ${MainAssist} << at ${AssistAt}%
}
/squelch /target clear
/squelch /assist off
|-------------------------------------------------------------------------------------
| Main Loop
|-------------------------------------------------------------------------------------
:MainLoop
/doevents
/call DoMiscStuff
/call EndMacroIf
/call CheckForAdds
/call DoMezStuff
/call DoPetStuff
/call CheckBuffs
/call DoWeMed
/call DoHealStuff
/call DoBardStuff
/call Assist
/call Combat
/call LootStuff
/call DoWeMove
/goto :MainLoop
/return
|-------------------------------------------------------------------------------------
| SUB: Assist - Get Main Tank's target
|-------------------------------------------------------------------------------------
Sub Assist
:AssistAgain
/doevents
/if (${AggroCheck} < 1) /return
DEBUG Assist: Enter
/if (${ChaseAssist}) /call DoWeMove
/if (${Spawn[${MainAssist}].ID} && ${MainAssist.NotEqual[${Me}]} && ${Spawn[${MainAssist}].Distance}<200) {
/assist ${MainAssist}
/delay 3s ${Target.ID}
} else {
/if (!${Spawn[${MainAssist}].ID} || ${Spawn[${MainAssist}].Type.Equal[corpse]} || (${MainAssist.Equal[${Me}]} && !${Me.Hovering})) /squelch /target id ${AggroTargetID}
/delay 3s ${Target.ID}
}
/varset MyTargetID ${Target.ID}
/varset MyTargetName ${Target.CleanName}
/call ValidateTarget
/if (${ValidTarget}==0) {
/goto :AssistAgain
/squelch /target clear
}
/delay 1
DEBUG Assist: Leave
/return
|-------------------------------------------------------------------------------------
| SUB: Validate Target
|-------------------------------------------------------------------------------------
Sub ValidateTarget
DEBUG ValidateTarget Enter
/varset ValidTarget 0
/if (${Select[${Target.Type},PC,Pet,CORPSE,CHEST,TRIGGER,TRAP,TIMER,ITEM,MOUNT,Mercenary]}) /return
/if (${Target.ID}==${Me.Pet.ID} || !${Target.ID}) /return
/varset ValidTarget 1
DEBUG ValidateTarget: Leave
/return
|-------------------------------------------------------------------------------------
| SUB: Combat
|-------------------------------------------------------------------------------------
Sub Combat
/doevents
/call CanIDoStuff
/if ((!${DPSOn} && !${MeleeOn}) || !${Target.ID} || ${AggroCheck} < 1 || ${Target.Type.Equal[Corpse]}) /return
DEBUG Combat: Enter
| Check Target Hps and type NPC or NPC Pet
/if (${Target.PctHPs}<=${AssistAt} && ${Target.Type.Equal[NPC]} && ${Target.Distance}<${MeleeDistance}) {
/if (${ChaseAssist}) /call DoWeMove
/if (!${Attacking}) /echo ATTACKING -> ${Target.CleanName} <-
/if (${FaceMobOn}) /face
/if (${MeleeOn} && !${Attacking}) {
/moveto id ${MyTargetID} mdist 15
/if (${StickHow.NotEqual[0]}) /stick ${StickHow}
/killthis
/varset Attacking 1
}
:Attack
/doevents
/if (${Me.Pet.ID} && !${PetAttack}) {
/squelch /pet attack
/varset PetAttack 1
}
/if (${HealsOn}) /call DoHealStuff
/if (${MercOn}) /call MercsDoWhat
/if (${Me.Class.Name.Equal[Bard]}) /call DoBardStuff
/if (${MezOn}) /call DoMezStuff
/call CombatTargetCheck
/if (${Attacking} && ${MeleeOn} && ${Target.PctHPs}<=${AssistAt} && ${Target.Distance}<${MeleeDistance}) {
/if (!${Me.Combat}) /killthis
/if (${StickHow.NotEqual[0]} && !${Stick.Active} && ${Target.Distance}>15) /stick ${StickHow}
}
/if (${DPSOn}) /call CombatCast
/delay 5
/if (${Spawn[${MyTargetID}].Type.Equal[Corpse]}) {
/call CombatReset
/return
}
/if (${MyTargetID}==${Target.ID} && ${Spawn[${MyTargetID}].Type.NotEqual[Corpse]}) /goto :Attack
}
DEBUG Combat: Leave
/return
|-------------------------------------------------------------------------------------
| SUB: CombatTargetCheck
|-------------------------------------------------------------------------------------
Sub CombatTargetCheck
/if (${Target.ID}!=${MyTargetID} && ${Spawn[${MyTargetID}].ID}) {
/squelch /target id ${MyTargetID}
/delay 3s ${Target.ID}==${MyTargetID}
}
/return
|-------------------------------------------------------------------------------------
| SUB: Combat Cast
|-------------------------------------------------------------------------------------
Sub CombatCast
/if (${Target.PctHPs}<${DPSSkip}) /return
DEBUG CombatCast: Enter
/declare i int local 0
/declare DPSText string local
/declare DPSAt int local ${AssistAt}
/for i 1 to ${DPS.Size}
/doevents
/if (${MezOn}) /call DoMezStuff
/if (${HealsOn}) /call DoHealStuff
/call CombatTargetCheck
/if (${Spawn[${MyTargetID}].Type.Equal[Corpse]}) {
/call CombatReset
/return
}
| - Check for 2nd value in dps for mob health
/if (${DPS[${i}].Arg[2,|].Length}) {
/varset DPSText ${DPS[${i}]}
/varset DPS[${i}] ${DPSText.Arg[1,|]}
/varset DPSAt ${DPSText.Arg[2,|]}
}
/if (${Target.PctHPs}>${DPSAt} || ${Target.PctHPs}<${DPSSkip} || ${DPS[${i}].Equal[NULL]} || ${DPSTimer${i}} || ${Target.Type.NotEqual[NPC]}) /goto :skipcast
DEBUG1 CombatCast: "${DPS[${i}]}" Target: ${Target.ID} Timer: ${DPSTimer${i}}
/call CastWhat "${DPS[${i}]}" ${Target.ID}
DEBUG1 CombatCast: ${Macro.Return}
/if (${Macro.Return.Equal[CAST_SUCCESS]}) {
/echo ** ${DPS[${i}]} on >> ${Target.CleanName} <<
/if (${Me.Book[${DPS[${i}]}]}) {
| - Custom timer for cleric pets
/if (${Me.Class.Name.Equal[Cleric]} && (${DPS[${i}].Find[Zeal]} || ${DPS[${i}].Find[Unswerving]})) {
/varset DPSTimer${i} 5m
} else /if (${Spell[${DPS[${i}]}].Duration}>0) {
/varcalc DPSTimer${i} ${Spell[${DPS[${i}]}].Duration}*60
}
/goto :skipcast
} else /if (${FindItem[=${DPS[${i}]}]}) {
/varcalc DPSTimer${i} ${FindItem[=${DPS[${i}]}].Spell.Duration}*60
/goto :skipcast
} else /if (${Spell[${DPS[${i}]}].Duration}>0) {
/varcalc DPSTimer${i} ${Spell[${DPS[${i}]}].Duration}*60
/goto :skipcast
}
}
:skipcast
DEBUG1 ${DPS[${i}]} ${Macro.Return} DPSTimer${i} ${DPSTimer${i}}
| Reset values if 2nd value in dps for mob health exists
/if (${DPSText.Arg[2,|].Length}) {
/varset DPS[${i}] ${DPSText}
/varset DPSAt ${AssistAt}
/varset DPSText
}
/delay ${DPSInterval}s
/next i
DEBUG CombatCast: Leave
/return
|-------------------------------------------------------------------------------------
| SUB: CombatReset
|-------------------------------------------------------------------------------------
Sub CombatReset
DEBUG CombatReset: Enter
/echo SLAIN >> ${MyTargetName} <<
/varset MyTargetID 0
/varset MyTargetName
/varset ValidTarget 0
/squelch /target clear
/declare i int
/declare j int local
/varset Attacking 0
/for i 1 to ${DPS.Size}
/varset DPSTimer${i} 0
/next i
/for j 1 to 5
/varset MezTimer${j} 0
/next j
/squelch /alert clear 3
/if (${Me.Class.Name.Equal[Bard]}) /call DoBardStuff
/if (${Me.Pet.ID}) {
/varset PetAttack 0
/pet back off
/if (${PetHoldOn} && ${Me.AltAbility[Pet Discipline]}) /pet hold on
}
/call LootStuff
DEBUG CombatReset: Leave
/return
|-------------------------------------------------------------------------------------
| SUB: CastWhat
|-------------------------------------------------------------------------------------
Sub CastWhat(string castWhat,int castTargetID)
DEBUG CastWhat: Enter castWhat - ${castWhat} castTargetID - ${castTargetID}
/declare OldTarget int local ${Target.ID}
/varset CastResult CAST_FAIL
| - Check & cast if combat ability
/if (${Me.CombatAbility[${castWhat}]} && !${Me.CombatAbilityTimer[${castWhat}]}) {
/docommand /disc ${castWhat}
}
| - Check & cast if item
/if (${FindItem[=${castWhat}].ID} && ${FindItem[${castWhat}].Timer}==0) {
/casting "${castWhat}"|item -targetid|${castTargetID}
/delay 2s
/varset CastResult ${Cast.Result}
}
| - Check & cast if AA
/if (${Me.AltAbility[${castWhat}]} && ${Me.AltAbilityReady[${castWhat}]}) {
/casting "${castWhat}"|alt -targetid|${castTargetID}
:WaitOnAA
/if (${Cast.Status.NotEqual}) /goto :WaitOnAA
/varset CastResult ${Cast.Result}
}
| - Check & cast if spell
/if (${Me.Book[${castWhat}]} && ${Spell[${castWhat}].Mana}<=${Me.CurrentMana}) {
| Mem spell if not memmed
/if (!${Me.Gem[${castWhat}]}) {
/memorize "${castWhat}" 8
/delay 15s ${Cast.Ready[${castWhat}]}
}
/if (${Cast.Ready[${castWhat}]}) {
/casting "${castWhat}" -maxtries|2 -targetid|${castTargetID}
/delay 10s !${Me.Casting.ID}
/varset CastResult ${Cast.Result}
}
}
/squelch /target id ${OldTarget}
/delay 3s ${Target.ID}==${OldTarget}
DEBUG CastWhat: Leave
/return ${CastResult}
|-------------------------------------------------------------------------------------
| SUB: Check for adds
|-------------------------------------------------------------------------------------
Sub CheckForAdds
/doevents
/if (${AggroCheck} < 1) /return
DEBUG CheckForAdds: Enter
/varset AddsInCamp 1
/varset OldAssistAt ${AssistAt}
:moreadds
/call Assist
/call Combat
/if (${AggroCheck} > 0) /goto :moreadds
/varset AssistAt ${OldAssistAt}
/varset AddsInCamp 0
DEBUG CheckForAdds: Leave
/return
|-------------------------------------------------------------------------------------
| SUB: Do We Move
|-------------------------------------------------------------------------------------
Sub DoWeMove
/if ((!${ReturnToCamp} && !${ChaseAssist})) /return
/call EndMacroIf
/declare CloseEnuf int local ${Math.Calc[${ChaseDistance}/1.5]}
DEBUG DoWeMove: Enter
| - Shuts off ReturnToCamp if a toon moves a big distance defined by CampRadiusExceed ie CoH
/if (${ReturnToCamp}) {
/if (${Math.Distance[${CampYLoc}, ${CampXLoc}]} > ${CampRadiusExceed}) {
/varset ReturnToCamp 0
/echo Leashing exceeded distance of ${CampRadiusExceed} turning off ReturnToCamp
/return
}
/if (${Math.Distance[${CampYLoc}, ${CampXLoc}]} > ${CampRadius} && !${AddsInCamp}) {
/moveto loc ${CampYLoc} ${CampXLoc} mdist 10
:InCampYet
/delay 10
/if (${Math.Distance[${CampYLoc},${CampXLoc}]} > ${CampRadius}) /goto :InCampYet
/face heading ${LookForward}
}
}
/if (${ChaseAssist}) {
DEBUG ChaseAssist
/if (!${Spawn[${MainAssist}].ID} || ${Spawn[${MainAssist}].Distance} > ${CampRadiusExceed} || ${Math.Calc[${Spawn[${MainAssist}].Z}-${Me.Z}]}>100) {
DEBUG ChaseAssist exceed camp check
/varset ChaseAssist 0
/echo ChaseAssist distance exceeded: Turning off ChaseAssist
}
/if (${Spawn[${MainAssist}].Distance} > ${ChaseDistance} && ${Spawn[${MainAssist}].Distance} < ${CampRadiusExceed}) {
DEBUG ChaseAssist MA distance check
/stick ${ChaseDistance} id ${Spawn[${MainAssist}].ID} loose
:AreWeThere
/delay 10
/if (${Me.Moving}) /goto :AreWeThere
}
}
DEBUG DoWeMove: Leave
/return
|-------------------------------------------------------------------------------------
| SUB: DoWeMed
|-------------------------------------------------------------------------------------
Sub DoWeMed
/if (!${MedOn}) /return
DEBUG DoWeMed enter
/if (!${Me.Moving}) {
/if (${Me.Pct${MedStat}}<${MedStart}) {
/squelch target clear
/echo MEDDING-> ${MedStart}% ${MedStat} time to med.
:wait_for_resume
/doevents
/if (!${Me.Sitting}) /sit
/delay 5
/if (!${MedCombat}) {
/call CheckForAdds
/if (${AggroCheck} > 0) /return
}
/if (${Me.PctMana}<100 ) /goto :wait_for_resume
:done_medding
/if (${Me.Sitting}) /stand
}
}
DEBUG DoWeMed leave
/return
|-------------------------------------------------------------------------------------
| SUB: CheckBuffs #define Time_Seconds "${Int[${Math.Calc[ ( 86400 * ${Time.Day} ) + ${Time.SecondsSinceMidnight} ]}]}"
|-------------------------------------------------------------------------------------
Sub CheckBuffs
/doevents
/call CanIDoStuff
/if (!${BuffsOn} || ${AggroCheck} > 0) /return
DEBUG CheckBuffs: enter
/if (${ChaseAssist}) /call DoWeMove
/declare i int local
/declare j int local
/declare FullText string local 0
/declare 1stPart string local 0
/declare 2ndPart string local 0
/declare 3rdPart string local 0
/declare 4thPart string local 0
| Group Buffs
/for i 1 to ${Buffs.Size}
/delay 1
| If Buffs=NULL skip to next buff
/if (${Buffs[${i}].Equal[Null]}) /goto :SkipBuff
DEBUG2 ${i} ${Buffs[${i}]}
| Check for spells with 2 parts such as Exigent Focusing Rk. II,Talisman of Soul's Unity Rk. II - Set Buffs to the buff
/if (${Buffs[${i}].Arg[2,|].Length}) {
/varset FullText ${Buffs[${i}]}
/varset 1stPart ${Buffs[${i}].Arg[1,|]}
/varset 2ndPart ${Buffs[${i}].Arg[2,|]}
/varset 3rdPart ${Buffs[${i}].Arg[3,|]}
/varset 4thPart ${Buffs[${i}].Arg[4,|]}
/varset Buffs[${i}] ${Buffs[${i}].Arg[1,|]}
/if (${FullText.Arg[2,|].Find[Mana]}) /varset 2ndPart Mana
/if (${FullText.Arg[2,|].Find[Aura]}) /varset 2ndPart Aura
/if (${FullText.Arg[2,|].Find[Mount]}) /varset 2ndPart Mount
/if (${FullText.Arg[2,|].Find[Dual]}) /varset 2ndPart Dual
}
DEBUG2 -- 1st assigned: ${2ndPart} ${Buffs[${i}]}
| Check if aura is up and if it stacks with existing buffs
/if (${2ndPart.Equal[Aura]}) {
/if (!${Me.Song[${3rdPart}].ID} && ${Spell[${3rdPart}].Stacks[0]}) {
/echo Casting Aura >> ${1stPart} <<
| - Mutant Bards do this
/if (${Me.Class.ShortName.Equal[BRD]}) {
/if (!${Me.Gem[${1stPart}]}) {
/memorize "${1stPart}"|8
/delay 30
}
/squelch /twist once ${Me.Gem[${1stPart}]}
/delay 5s
/goto :SkipBuff
}
| - Normal casting
/if (${Select[${Me.Class.ShortName},BER,MNK,ROG,WAR]}) {
/disc ${1stPart}
} else {
/casting "${1stPart}"|${MiscGem}
}
/delay 5s
}
/goto :SkipBuff
}
| Cast mount
/if (${2ndPart.Equal[Mount]} && ${3rdPart.Length} && !${Me.Mount.ID} && !${Attacking} && ${MountOn}) {
/call CastWhat "${1stPart}" ${Me.ID}
/if (${Macro.Return.NotEqual[CAST_SUCCESS]}) /varset MountOn 0
/goto :SkipBuff
}
| Check and Cast mana type spells/aas/items - Canni/Paragon/Harvest
/if (${2ndPart.Equal[Mana]} && ${Me.PctMana}<${Int[${3rdPart}]} && ${Me.PctHPs}>${Int[${4thPart}]} && !${Attacking}) {
/call CastWhat "${1stPart}" ${Me.ID}
/if (${Macro.Return.Equal[CAST_SUCCESS]}) /echo Casting >> ${1stPart} << for mana
/goto :SkipBuff
}
| Check if buff is up and if it stacks with existing buffs
/if ((!${Me.Buff[${Buffs[${i}]}].ID} || !${Me.Song[${Buffs[${i}]}].ID}) && ${Spell[${Buffs[${i}]}].Stacks[0]} && ${Select[${2ndPart},Aura,Mount,Mana]}<1) {
| Check for spells with 2 parts such as Exigent Focusing Rk. II,Talisman of Soul's Unity Rk. II - Set Buffs to actual spell
/if (${FullText.Arg[2,|].Equal[Dual]}) /varset Buffs[${i}] ${3rdPart}
DEBUG2 -- 2nd asssigned: ${Buffs[${i}]}
| If Target.Type=Group then buff self with group buff
/if (${Spell[${Buffs[${i}]}].TargetType.Find[group]}>=1) {
/call CastWhat "${Buffs[${i}]}" ${Me.ID}
/if (${Macro.Return.Equal[CAST_SUCCESS]}) /echo Buffing >> ${Buffs[${i}]} <<
/delay 20
}
| If Target.Type=Single then buff each party member with single buff
/if (${Spell[${Buffs[${i}]}].TargetType.Find[single]}) {
/if (${Group}) {
/for j 0 to ${Group}
| Varset single buff array to keep track if group member was buffed or not.
| /varset BuffCounter${j}${i}
| Check if party member is in zone and within spell range
/if (!${Group.Member[${j}].ID} || ${Spawn[${Group.Member[${j}]}].Distance}>=${Spell[${Buffs[${i}]}].Range}) /goto :nextmember
/call CastWhat "${Buffs[${i}]}" ${Group.Member[${j}].ID}
/if (${Macro.Return.Equal[CAST_SUCCESS]}) {
/echo Buffing ${Buffs[${i}]} on ${Group.Member[${j}].CleanName}
/delay 60 ${Me.SpellReady[${Buffs[${i}]}]}
}
/delay 20
:nextmember
/next j
} else {
/call CastWhat "${Buffs[${i}]}" ${Me.ID}
/delay 20
}
}
| If Target.Type=self then buff self
/if (${Spell[${Buffs[${i}]}].TargetType.Find[self]}) {
/call CastWhat "${Buffs[${i}]}" ${Me.ID}
/delay 20
}
}
| If buff is an item click it
/if (${FindItem[${Buffs[${i}]}].Spell.Stacks[0]} && (!${Me.Buff[${FindItem[${Buffs[${i}]}].Spell}].ID} || !${Me.Buff[${FindItem[${Buffs[${i}]}].Spell}].ID}) && ${FindItem[${Buffs[${i}]}].Timer}==0) {
/if (${Twist}) /multiline ; /squelch /twist off ; /varset Twisting 0
/echo Clicking > ${Buffs[${i}]} <
/call CastWhat "${Buffs[${i}]}" ${Me.ID}
/delay 15s !${Me.Casting.ID}
}
:SkipBuff
| Reset spell vars
/if (${FullText.Arg[2,|].Length}) {
/varset Buffs[${i}] ${FullText}
/varset FullText 0
/varset 1stPart 0
/varset 2ndPart 0
/varset 3rdPart 0
/varset 4thPart 0
}
/next i
DEBUG CheckBuffs leave
/return
|-------------------------------------------------------------------------------------
| SUB: DoPetStuff
|-------------------------------------------------------------------------------------
Sub DoPetStuff
/doevents
/call CanIDoStuff
/if (!${PetOn}) /return
/call EndMacroIf
DEBUG DoPetStuff: enter
/declare i int local
/if (${Me.Pet.CleanName.Equal[${Me.Name}`s familiar]}) /pet get lost
/if (!${Me.Pet.ID} && ${Spell[${PetSpell}].Mana}<=${Me.CurrentMana}) {
/delay 3
/casting "${PetSpell}"|8 -maxtries|2
/delay 350 ${Cast.Ready[${PetSpell}]}
/echo My pet is now: ${Me.Pet.CleanName} from ${PetSpell}
}
/if (${Me.Pet.ID}) {
/if (${PetShrinkOn} && !${PetShrunk}) {
/call CastWhat "${PetShrinkSpell}" ${Me.Pet.ID}
/varset PetShrunk 1
/delay 20
/squelch /target clear
}
| Pet Buffs
/if (${PetBuffsOn}) {
/for i 1 to ${PetBuffs.Size}
/if (${PetBuffs[${i}].Equal[Null]}) /goto :SkipPetBuff
DEBUG ${i} ${Me.PetBuff[${PetBuffs[${i}]}]} ${PetBuffs[${i}]}
/if (!${Me.PetBuff[${PetBuffs[${i}]}]}) {
/call CastWhat "${PetBuffs[${i}]}" ${Me.Pet.ID}
/delay 20
}
/if (${FindItem[=${PetBuffs[${i}]}].ID} && !${Me.PetBuff[${FindItem[${PetBuffs[${i}]}].Spell}]}) {
/call CastWhat "${PetBuffs[${i}]}" ${Me.Pet.ID}
}
:SkipPetBuff
/next i
}
}
DEBUG DoPetStuff: leave
/return
|----------------------------------------------------------------------------
| SUB: Check Plugin
|----------------------------------------------------------------------------
Sub CheckPlugin(string pluginname)
DEBUG CheckPlugin: enter
/if (!${Bool[${Plugin[${pluginname}]}]}) {
/squelch /plugin ${pluginname}
/echo ${pluginname} not detected! This macro requires it! Loading ...
}
DEBUG CheckPlugin: leave
/return
|----------------------------------------------------------------------------
| SUB: Load Ini
|----------------------------------------------------------------------------
Sub LoadIni(string sectionName, string varName, string varType, string varValue, string varArray)
DEBUG Sub Loadini ${sectionName} ${varName} ${varType} ${varValue} ${varArray}
/if (${${varArray}.Size}>0) {
/declare i int local
/for i 1 to ${${varArray}.Size}
/if (!${Ini[${IniFileName},${sectionName},${varArray}${i}].Length}) /ini "${IniFileName}" "${sectionName}" "${varArray}${i}" "${varValue}"
/if (${Ini[${IniFileName},${sectionName},${varArray}${i}].Length}) /varset ${varArray}[${i}] ${Ini[${IniFileName},${sectionName},${varArray}${i}]}
/next i
/return
} else {
/if (!${Defined[${varName}]} && ${Defined[varType]}) /declare ${varName} ${varType} outer
/if (!${Ini[${IniFileName},${sectionName},${varName}].Length}) {
/if (${varValue.Length}) {
/ini "${IniFileName}" "${sectionName}" "${varName}" "${varValue}"
/varset ${varName} ${varValue}
DEBUG Sub Loadini /varset ${varName} ${varValue}
}
} else {
/varset ${varName} ${Ini[${IniFileName},${sectionName},${varName}]}
}
}
DEBUG LoadIni: leave
/return
|----------------------------------------------------------------------------
| SUB: End Mac If
|----------------------------------------------------------------------------
Sub EndMacroIf
/doevents
DEBUG EndMacroIf: Enter
| I died wait for rez loop
:WaitOnRez
/if ((${Me.Hovering} || ${CampZone} != ${Zone.ID}) && ${RezAcceptOn}) {
/if (${Attacking}) /call CombatReset
/delay 10
/goto :WaitOnRez
}
/if (${GameState.Equal[CHARSELECT]}) /endmac
/if (!${RezAcceptOn} && ${CampZone} != ${Zone.ID}) /endmac
DEBUG EndMacroIf: leave
/return
|----------------------------------------------------------------------------
| SUB: Do Bard Stuff
|----------------------------------------------------------------------------
Sub DoBardStuff
/if (${Me.Class.Name.NotEqual[Bard]}) /return
DEBUG DoBardStuff: Enter
/if (${MeleeTwistOn} && ${Attacking} && !${DPSTwisting}) {
/varset DPSTwisting 1
/varset Twisting 0
/squelch /twist ${MeleeTwistWhat}
/echo == Starting melee twist
}
/if (${TwistOn} && !${Attacking} && !${Twisting}) {
/varset DPSTwisting 0
/varset Twisting 1
/squelch /twist ${TwistWhat}
/echo == Starting normal twist
}
/if (!${TwistOn} && !${Attacking} && ${Twist}) /squelch /twist off
| - Mutant Bards do this
DEBUG DoBardStuff: leave
/return
|----------------------------------------------------------------------------
| SUB: Do Heal Stuff
|----------------------------------------------------------------------------
Sub DoHealStuff
/if (!${HealsOn} || ${Target.Type.Equal[corpse]} || ${Me.Moving}) /return
DEBUG DoHealStuff: Enter
/declare i int local
/declare j int local
/declare HealSpell string local
/declare HealPct string local
/declare HealFirst int local 0
/declare DurationMod float local 1
/declare GroupHealth string local 1
/declare NotDead int local 0
/if (${AltAbility[Spell Casting Reinforcement]}>3) /varset DurationMod 1.7
/for j 1 to ${Heals.Size}
/if (${Heals[${j}].Equal[NULL]} || ${Heals[${j}].Arg[2,|].Equal[0]}) /goto :NextHeal
/varset HealSpell ${Heals[${j}].Arg[1,|]}
/varset HealPct ${Heals[${j}].Arg[2,|]}
/varset HealFirst 0
/if (${Heals[${j}].Arg[3,|].Find[MA]}) /varset HealFirst ${Spawn[${MainAssist}].ID}
/for i 0 to ${Group}
| Check for Main Assist heal priority
/if (${HealFirst} && ${Group.Member[${i}].ID}!=${HealFirst}) /goto :nextmember
| Check for player hovering or corpse and skip heal if true
/if (${Group.Member[${i}].Type.NotEqual[Mercenary]} && (${Group.Member[${i}].Hovering} || ${Spawn[${Group.Member[${i}]}].Type.Equal[Corpse]})) /goto :nextmember
DEBUG (${Spell${j}GM${i}}>=1) ${i} ${Group.Member[${i}]} ${j} ${HealSpell} ${HealPct} Spell${j}GM${i} ${Spell${j}GM${i}}
| Check conditons for heals
/if ((${Select[${Spell[${HealSpell}].TargetType},Single,Self]} || ${Spell[${FindItem[${HealSpell}].Spell}].TargetType.Find[self]}) && ${Group.Member[${i}].PctHPs}<=${HealPct} && ${Group.Member[${i}].ID} && ${Group.Member[${i}].Distance}<=${Spell[${HealSpell}].MyRange} && ${Spell${j}GM${i}}==0 && ${HealPct}>=1) {
/attack off
/delay 3s !${Me.Combat}
/call CastWhat "${HealSpell}" ${Group.Member[${i}].ID}
/delay 10s !${Me.Casting.ID}
/if (${Macro.Return.Equal[CAST_SUCCESS]}) {
/echo -- ${HealSpell} on >> ${Group.Member[${i}].CleanName} <<
/varcalc Spell${j}GM${i} (${Spell[${HealSpell}].Duration}*${DurationMod})*60
DEBUG Spell${j}GM${i} (${Spell[${HealSpell}].Duration}*${DurationMod})*60 ${Spell${j}GM${i}}
}
}
:nextmember
| Check if my pet needs healing
/if (${Heals[${j}].Arg[3,|].Find[PET]} && ${Group.Member[${i}].ID}==${Me.ID} && ${Me.Pet.PctHPs}<=${HealPct} && ${Me.Pet.ID} && ${Me.Pet.Distance}<${Spell[${HealSpell}].MyRange}) {
DEBUG PET (${Heals[${j}].Arg[3,|].Find[PET]} && ${Group.Member[${i}].ID}==${Me.ID} && ${Me.Pet.PctHPs}<=${HealPct} && ${Me.Pet.ID} && ${Me.Pet.Distance}<${Spell[${HealSpell}].MyRange})
/call CastWhat "${PetHealSpell}" ${Me.Pet.ID}
/if (${Macro.Return.Equal[CAST_SUCCESS]}) {
/echo -- ${HealSpell} on >> ${Me.Pet.CleanName} <<
/varcalc Spell${j}GM${i} (${Spell[${HealSpell}].Duration}*${DurationMod})*60
}
}
| Calculate total group health for group heal spells
/if (${Group.Member[${i}].ID} && ${Group.Member[${i}].Type.NotEqual[corpse]} && ${Group.Member[${i}].Distance}<100) {
DEBUG ${i} ${Group.Member[${i}].PctHPs}
/varcalc GroupHealth ${GroupHealth}+${Group.Member[${i}].PctHPs}
/varcalc NotDead ${NotDead}+1
}
/delay 1
/next i
| Use Group Heals if total group health % below assigned group heal %
/if (!${Group}) /varset NotDead 100
DEBUG (${Spell[${HealSpell}].TargetType.Find[group]} || ${Spell[${FindItem[${HealSpell}].Spell}].TargetType.Find[group]}) && ${Math.Calc[${GroupHealth}/${NotDead}]}<=${HealPct} && ${Spell${j}GM${i}}==0 && ${HealPct}>=1)
/if (${Group} && (${Spell[${HealSpell}].TargetType.Find[group]} || ${Spell[${FindItem[${HealSpell}].Spell}].TargetType.Find[group]}) && ${Math.Calc[${GroupHealth}/${NotDead}]}<=${HealPct} && ${Spell${j}GM${i}}==0 && ${HealPct}>=1) {
/call CastWhat "${HealSpell}" ${Me.ID}
/delay 10s !${Me.Casting.ID}
/if (${Macro.Return.Equal[CAST_SUCCESS]}) {
/echo -- ${HealSpell} on >> Group <<
/varcalc SpellGH${i} (${Spell[${HealSpell}].Duration}*${DurationMod})*60
DEBUG SpellGH${i} (${Spell[${HealSpell}].Duration}*${DurationMod})*60 ${SpellGH${i}}
}
}
:NextHeal
/delay 1
/next j
DEBUG DoHealStuff: Leave
/return
|-------------------------------------------------------------------------------------
| SUB: Loot Stuff
|-------------------------------------------------------------------------------------
Sub LootStuff
/if (!${LootOn}) /return
DEBUG LootStuff: Enter
/if (${Me.FreeInventory}==0) {
/echo Inventory is full. Looting OFF
/varset LootOn 0
}
/doevents
| Reset mdist for ninjadvloot
/squelch /moveto mdist 5
/call LootMobs
/if (${Debug}) /echo leave LootStuff
DEBUG LootStuff: Leave
/return
|-------------------------------------------------------------------------------------
| SUB: Do Mez Stuff
|-------------------------------------------------------------------------------------
Sub DoMezStuff
/if (!${MezOn}) /return
DEBUG DoMezStuff: Enter
/declare i int local
/declare AddCount int local
/declare NextMob int local
:top
/varset AddCount ${SpawnCount[npc radius ${MezRadius} range ${MezMinLevel} ${MezMaxLevel} zradius 50]}
/if (${AddCount}>1) {
| Grab Main Assist's target and ignore it for mez purposes
/if (${Spawn[${MainAssist}].ID}) /squelch /alert add 3 id ${MyTargetID}
| /echo I am not mezzing MA's mob ${MyTargetName}
/for i 1 to ${SpawnCount[npc radius ${MezRadius} range ${MezMinLevel} ${MezMaxLevel} zradius 50 noalert 3]}
/varset NextMob ${NearestSpawn[${i},npc radius ${MezRadius} range ${MezMinLevel} ${MezMaxLevel} zradius 50 noalert 3].ID}
/if (${Spawn[${MezMob[${i}]}].ID}!=${NextMob}) {
/varset MezMob[${i}] ${NextMob}
DEBUG MezMob[${i}]=${Spawn[${MezMob[${i}]}].CleanName}
}
/if (${MezTimer${i}}==0 && ${Spawn[${MezMob[${i}]}].ID} && ${Spawn[${MezMob[${i}]}].PctHPs}>${MezStopHPs}) /call MezMobs ${MezMob[${i}]} ${i}
/next i
}
DEBUG DoMezStuff: Leave
/return
|-------------------------------------------------------------------------------------
| SUB: Mez Mobs
|-------------------------------------------------------------------------------------
Sub MezMobs(int MobID, int TimerNum)
DEBUG ${MobID} ${TimerNum}
/declare MezFail int local 0
/target id ${MobID}
/delay 3s ${Target.ID}==${MobID}
/if (${Target.ID}) {
/echo Mezzing ${Spawn[${MobID}].CleanName}
| Chanter mez code
/if (${Me.Class.Name.Equal[Enchanter]}) {
:retrymez
/delay 1
/call CastWhat "${MezSpell}" ${MobID}
/delay 30
/varcalc MezFail ${MezFail}+1
/if (${Macro.Return.Equal[CAST_RESIST]} && ${MezFail}<3) /goto :retrymez
/if (${Select[${Cast.Result},CAST_TAKEHOLD,CAST_IMMUNE]}) /squelch /alert add 3 id ${Target.ID}
/if (${Macro.Return.Equal[CAST_SUCCESS]}) /varset MezTimer${TimerNum} ${Math.Calc[(${Spell[${MezSpell}].Duration}*60)*.9]}
}
| Bard mez code
/if (${Me.Class.Name.Equal[Bard]}) {
/delay 1
/squelch /twist once ${Me.Gem[${MezSpell}]}
/delay 35
/varset MezTimer${TimerNum} 120
}
}
/return
|-------------------------------------------------------------------------------------
| SUB: GetTarget
|-------------------------------------------------------------------------------------
Sub GetTarget
/if (${Role.NotEqual[Puller]}) /return
DEBUG GetTarget enter
/doevents
/declare CurrentRadius int local
/echo Looking for Close Range Mobs
:Acquire
/doevents
/call CheckForAdds
| Auto add any untargetable npc, aura etc to ignore alert list
/squelch /alert add 1 untargetable
/for CurrentRadius 0 to ${MaxRadius} step 10
/squelch /target npc radius ${CurrentRadius} zradius ${MaxZRange} noalert 1
/if (${Target.ID}) {
/call ValidateTarget
/if (${Debug}) /echo ${Target.CleanName} ${ValidTarget}
/if (${ValidTarget}==0) {
/squelch /alert add 1 id ${Target.ID}
/goto :Acquire
}
/echo Got target >> ${Target.CleanName} << at range ${Int[${Target.Distance}]}
/return
}
/next CurrentRadius
/if (!${Target.ID}) {
/delay 5
/varcalc FailCounter ${FailCounter}+1
/echo Failed to Acquire Target in Range ${MaxRadius} ${FailCounter} Time(s)
/call AlertClear
/if (${FailCounter}>=${FailMax}) {
/echo Waiting for Respawns, Resetting Failure Counter...
/moveto loc ${CampYLoc} ${CampXLoc} mdist 10
/varset FailCounter 0
}
/goto :Acquire
}
DEBUG GetTarget leave
/return
|-------------------------------------------------------------------------------------
| SUB: DoMiscStuff
|-------------------------------------------------------------------------------------
Sub DoMiscStuff
| Accept trades
/if (${Window[TradeWnd].Open} && ${Window[TradeWnd].HisTradeReady}) /notify TradeWnd TRDW_Trade_Button leftmouseup
/if (${Window[GroupWindow].Child[GW_FollowButton]} && ${AcceptInvitesOn}) /invite
/return
|-------------------------------------------------------------------------------------
| SUB: Event_ToggleVariable Check whenever the player is changing any variable via /echo
|-------------------------------------------------------------------------------------
Sub Event_ToggleVariable(string Line, string Command, string Command2)
/declare i int local
| Toggle Variables & Set Variables
/if (${Defined[${Command}]}) {
/declare OnOff local
/if (${Command2.NotEqual[NULL]}) {
/varset ${Command} ${Command2}
} else /if (${${Command}}) {
/varset ${Command} 0
/varset OnOff Off
} else {
/varset ${Command} 1
/varset OnOff On
/if (${Command.Equal[ChaseAssist]}) {
/if (${ReturnToCamp}) /varset ReturnToCamp 0
}
| Turn on return to camp & set new y,x coord
/if (${Command.Equal[ReturnToCamp]}) {
/varset CampXLoc ${Me.X}
/varset CampYLoc ${Me.Y}
/varset LookForward ${Me.Heading.DegreesCCW}
| Turn off ChaseAssit if on
/if (${ChaseAssist}) {
/varset ChaseAssist 0
/echo >> ChaseAssist Off
}
/echo >> New camp set ${Me.Y}, ${Me.X}
}
}
| /ini "${IniFileName}" "${sectionName}" "${varName}" "${varValue}"
/echo >> Set ${Command}: ${OnOff}
/return
}
/return
|-------------------------------------------------------------------------------------
| SUB: Can I do Stuff - Check if invis moving ducked etc
|-------------------------------------------------------------------------------------
Sub CanIDoStuff
:IAmBusy
/call EndMacroIf
/delay 2
/if (${Me.Moving} || (!${ChaseAssist} && !${AggroCheck} && ${Me.Invis}) || ${Me.Stunned} || ${Me.Ducking} || ${Cast.Status.NotEqual} || ${Me.State.Equal[BIND]} ) /goto :IAmBusy
/if (${Window[MerchantWnd]} || ${Window[TradeWnd]} || ${Window[GiveWnd]} || ${Window[LootWnd]} || ${Window[SpellBookWnd]} || ${Window[BigBankWnd]} || ${Window[LootWnd]} || ${Window[BankWnd]} || ${Window[TributeMasterWnd]} || ${Window[GuildTributeMasterWnd]}) /goto :IAmBusy
/return
|-------------------------------------------------------------------------------------
| SUB: Mercs Do What
|-------------------------------------------------------------------------------------
Sub MercsDoWhat
/if (${MercAssistAt}>${Spawn[${MyTargetID}].PctHPs} && ${Me.Mercenary.Equal[Active]}) {
/mercassist
}
/return
|-------------------------------------------------------------------------------------
| SUB: EquipRanged
|-------------------------------------------------------------------------------------
Sub EquipRanged
DEBUG /echo EquipRanged
/if (${String[${Me.Inventory[ranged]}].NotEqual[${PullRangedItem}]}) {
/exchange "${PullRangedItem}" ranged
/varset Exchanged 1
}
/delay 5s
/if (${Exchanged}) /exchange "${EquippedRangedItem}" ranged
DEBUG /echo leave EquipRanged
/return
Ninjadvloot.ini is included with NA Official Compile or get it here
Last edited:
.
