Optimized for Berserker / Shammy combo. If you are using another class you will have to edit some of the SpecialIT Subroutine. As it uses Berserker Discs and combat abilitys.
afkpov.mac (AFK TANK PORTION)
noobsham.mac (AFK Shaman PORTION)
Include Files in case you don't have them from macroquest forums/snippits
Exp_Tracking.inc
spell_routines.inc
afkpov.mac (AFK TANK PORTION)
Rich (BB code):
|--------Noob haxors ULTIMATE Tank/Shammy combo macro
|Version 1.0 - PoV automation with noob's shambot for shammy macro
|-------------------
|Average exp with 100 to 200 DPS is around 2.0 exp per minute in lvl
|ranges 62 to 67. 68 to 70 is around 1.0. What that translates in simple
|english is an AA every 50 minutes at 62 to 67 and an AA every 100
|minutes at 68 to 70. Also this is Version 1.0 so expect bugs and please
|report them to me so I can fine tune the macro to you.
|-------------------
|###FYI: Where I run this is Escape tunnel from AD to Halls of honor###
|Use:
|make sure you have spell_routines.inc and Exp_Tracking.inc in macros folder
|Add the waypoints listed to you waypoint file, or create your own
|if you don't like mine(just remember to # them wp1 to wp10)
|Target Tank and start noobsham.mac first
|Then start this macro. Make sure you have a clear inventory to. You will fill
|all 8 slots of BP's in about a day.
|-------------------
#Event Snareage "#*#legs buckle."
#Event Snareage2 "Your target is immune#*#"
#include Exp_Tracking.inc
#include spell_routines.inc
#turbo 10
Sub Main
/declare HealerName string outer Shammy_name
/declare myzone int outer ${Zone.ID}
|------------------------------------------------------------
|Declare Safe Players.
|------------------------------------------------------------
/alert add 2 pc ${HealerName}
/alert add 2 pc ${Me}
|------------------------------------------------------------
|Loot Array Information.
|------------------------------------------------------------
/declare RV_LootArray[5] string outer
/varset RV_LootArray[1] "Rocks"
/varset RV_LootArray[2] "Formation"
/varset RV_LootArray[3] "Brick"
/varset RV_LootArray[4] "Strand"
/varset RV_LootArray[5] "Stone"
/declare RV_MyTargetID int outer 0
/declare RV_MyTargetName string outer
/declare RV_MyTargetDead int outer 0
/declare RV_InvalidTargetID int outer 0
/declare RV_HasTarget int outer 0
/declare RV_LootSlot int outer 0
/declare RV_CheckLook int outer 0
/declare RV_Fighting int outer 0
/declare RV_TargetDead int outer 0
/declare wpsave int outer 0
/declare slowonce bool outer TRUE
/declare dotonce bool outer TRUE
/declare snareonce bool outer TRUE
/declare playernearby bool outer FALSE
/declare Spawnloc[10] string outer
/varset Spawnloc[1] "wp1"
/varset Spawnloc[2] "wp2"
/varset Spawnloc[3] "wp3"
/varset Spawnloc[4] "wp4"
/varset Spawnloc[5] "wp5"
/varset Spawnloc[6] "wp6"
/varset Spawnloc[7] "wp7"
/varset Spawnloc[8] "wp8"
/varset Spawnloc[9] "wp9"
/varset Spawnloc[10] "wp10"
/call ExpPrep
:Start
/doevents
/call GMCheck
/if (!${Spawn[${HealerName}].ID}) {
/warp succor
/quit
/endmacro
}
/call GetTarget
:KillAdds
/if (${RV_HasTarget}) /call MoveToMob
/if (${RV_HasTarget}) /call CombatSub
/if (${RV_HasTarget}) /call MoveToMob
/if (${RV_HasTarget}) /call LootMob
/if (${Target.ID}) {
/echo Looks like something is attacking us, killing it...
/delay 1s
/varset RV_HasTarget 1
/varset RV_Fighting 1
/goto :KillAdds
}
/goto :Start
/return
|--------------------------------------------------------------------------------
|SUB: Aquire Target
|--------------------------------------------------------------------------------
Sub GetTarget
/keypress esc
/if (${Spawn[${HealerName}].ID} && (${wpsave}>9)) /varset wpsave 0
/varset wpsave ${Math.Calc[${wpsave}+1]}
/if (${Target.Type.NotEqual[NPC]} || !${Target.ID}) /warp wp ${Spawnloc[${wpsave}]}
/delay 30
/if (${NearestSpawn[NPC].Distance}>40) {
/return
} else {
/target ${NearestSpawn[NPC]}
/varset RV_HasTarget 1
/return
}
/return
|--------------------------------------------------------------------------------
|SUB: Moving
|--------------------------------------------------------------------------------
Sub MoveToMob
/if (${Int[${Target.Distance}]}>25) {
/delay 30
/warp target
}
/return
|--------------------------------------------------------------------------------
|SUB: Combat
|--------------------------------------------------------------------------------
Sub CombatSub
/varset RV_Fighting 1
/varset RV_TargetDead 0
/stick 13 moveback
:CombatLoop
/doevents
/delay 15
/attack on
/if (${Window[ConfirmationDialogBox].Open}) /notify ConfirmationDialogBox Yes_Button
leftmouseup
/if (${Target.Distance}>16) /stick 13 moveback
/if (!${Target.Type.Equal["NPC"]}) /keypress esc
/if (${Target.ID}) /face fast
/if (${Target.ID}) /call SpecialIT
/if (!${Target.ID}) {
/call GMCheck
/attack off
/keypress forward
/keypress back
/varset RV_TargetDead 1
/varset RV_Fighting 0
/delay 30
/target radius 30 corpse
/varset snareonce TRUE
/varset slowonce TRUE
/varset dotonce TRUE
/if (!${Spawn[${HealerName}].ID}) {
/gate
/quit
/endmacro
}
/if ((${Me.PctHPs}>60)&&(${Me.Buff["Swift like the Wind"].Duration}<=30)) {
/tell ${HealerName} haste
:wait4haste
/if (${Me.Buff["Swift like the Wind"].Duration}>30) /goto :nextbuff1
/goto :wait4haste
}
:nextbuff1
/if (${Me.Buff["Wunshi's Focusing"].Duration}<=100) {
/tell ${HealerName} focus
:wait4focus
/if (${Me.Buff["Wunshi's Focusing"].Duration}>100) /goto :nextbuff2
/goto :wait4focus
}
:nextbuff2
/if (${Me.Buff["Spirit of Might"].Duration}<=50) {
/tell ${HealerName} str
:wait4str
/if (${Me.Buff["Spirit of Might"].Duration}>50) /return
/goto :wait4str
}
/return
}
}
/goto :CombatLoop
/return
|--------------------------------------------------------------------------------
|SUB: Special Combat
|--------------------------------------------------------------------------------
Sub SpecialIt
|------Auto-Frenzy and Stun on low health
/if ((${Target.Distance}<17)&&(${Me.AbilityReady["Frenzy"]})) /doability "Frenzy"
/if ((${Me.PctHPs}<25)&&(${Me.CombatAbilityReady["Head Crush"]})) /disc Head Crush
/if (${Me.PctHPs}<10) {
/warp succor
/mqlog LOW HP Succored
/quit
/endmacro
}
|------Slows and DoTs to decrease mobs DPS
/if ((${Me.PctHPs}>60)&&(${Target.PctHPs}<50)&&(${dotonce})) {
/tell ${HealerName} dot
/varset dotonce FALSE
}
/if ((${Me.PctHPs}>60)&&(${Target.PctHPs}<90)&&(${slowonce})) {
/tell ${HealerName} slow
/varset slowonce FALSE
}
|------Disciplines to increase DPS---------
/if ((${Me.CombatAbilityReady["Reckless Discipline"]})&&(${Target.PctHPs}>95)) /disc
Reckless Discipline
/if ((${Me.CombatAbilityReady["Rage Volley"]})&&(${Me.Endurance}>3000)) /disc Rage
Volley
/if ((${Me.CombatAbilityReady["Blind Rage Discipline"]})&&(${Target.PctHPs}>94))
/disc Blind Rage Discipline
|------Snaremob
/if ((${Target.PctHPs}>20)&&(${Target.PctHPs}<26)&&(${snareonce})) /call snaremob
/return
|--------------------------------------------------------------------------------
|SUB: Reset
|--------------------------------------------------------------------------------
Sub ResetSub
/call ExpTrack
/delay 30
/keypress esc
/keypress esc
/keypress esc
/keypress esc
/varset RV_HasTarget 0
/varset RV_TargetDead 0
/varset RV_Fighting 0
/return
|--------------------------------------------------------------------------------
|SUB: GM Check ----Player Checks
|--------------------------------------------------------------------------------
Sub GMCheck
/if (${Zone.ID}!=${myzone}) {
/quit
/endmacro
}
/if (${Spawn[gm].ID}) {
/mqlog GM ENTERED ZONE!!!
/keypress forward
/keypress back
/quit
/endmacro
/unload
}
/return
|--------------------------------------------------------------------------------
|SUB: Looting
|--------------------------------------------------------------------------------
Sub LootMob
/declare LootSlot int inner 0
/declare LootCheck int inner 0
/declare LootTotal int inner 0
/face fast
/keypress forward
/keypress back
/fastdrop on
/lootn never
/delay 1s
/loot
/delay 1s
/if (!${Corpse.Items}) {
/echo NO LOOT! Cheap Bastard!
/call ResetSub
/return
}
/varset LootTotal ${Corpse.Items}
/for LootSlot 1 to ${LootTotal}
/itemnotify loot${LootSlot} leftmouseup
/delay 1s
|---------Keep Good Stuff---------------------
/for LootCheck 1 to ${RV_LootArray.Size}
/if (${Cursor.Name.Find[${RV_LootArray[${LootCheck}]}]}) {
/echo Keeping a ${Cursor.Name}... WOOT!
/autoinventory
/delay 1s
}
/next LootCheck
|---------Destroy Bad Stuff-------------------
/if (${Cursor.ID}) {
/echo Destroying a ${Cursor.Name}...
/destroy
/delay 1s
}
/next LootSlot
/notify LootWnd DoneButton leftmouseup
/delay 1s
/call ResetSub
/return
|--------------------------------------------------------------------------------
|SUB: Playercheck
|--------------------------------------------------------------------------------
Sub playercheck
|-----------Player Check-------Anyone comes near you jet!
/if (${Spawn[pc noalert 2 radius 500].ID}) {
/warp succor
/mqlog Player near
/quit
/endmacro
/return
|--------------------------------------------------------------------------------
|SUB: Snaremob
|--------------------------------------------------------------------------------
Sub snaremob
:Snare_Loop
/delay 1s
/if (${Me.CombatAbilityReady["Leg Slice"]}) /disc Leg Slice
/doevents
/if ((!${snareonce})&&(${Zone.ID})) /return
/goto :Snare_Loop
/return
Sub Event_Snareage
/varset snareonce FALSE
/return
Sub Event_Snareage2
/varset snareonce FALSE
/returnnoobsham.mac (AFK Shaman PORTION)
Rich (BB code):
|---Noobsham.mac-------
|---Version 1.0
#chat group
#chat tell
#Event OutDoor "#*#outdoors#*#"
#Event OutDoor "You can not summon a mount here."
#Event Zoning "You have entered#*#"
#Event ImDead "You have been slain by#*#"
#Event NoobExp "You gain experience!!"
cancel#*#"
#include Spell_Routines.inc
Sub Main
| The spell will be memmed in the listed order.
| Gem1 = Canni
| Gem2 = Slow
| Gem3 = Malo
| Gem4 = Avatar
| Gem5 = Pet and buffs
| Gem6 = Heal
| Gem7 = HoT
| Gem8 = DoT
| Gem9 = root, Nuke, gate
| ########### Declares Zone which you start macro
/declare myzone int outer ${Zone.ID}
| ########### Your Spell List - update as needed
/declare SpellSlow outer "Turgur's Insects"
/declare SpellDoT outer "Blood of Yoppa"
/declare SpellPet outer "True Spirit"
/declare SpellDeBuff outer "Malos"
/declare SpellCanni outer "Pained Memory"
/declare SpellHoT outer "Breath of Trushar"
/declare SpellHeal outer "Yoppa's Mending"
/declare SpellRoot outer "Petrifying Earth"
/declare SpellNuke outer "Velium Strike"
/declare SpellATK outer "Ferine Avatar"
/declare SpellHASTE outer "Swift like the Wind"
/declare SpellFOCUS outer "Wunshi's Focusing"
/declare SpellCHA outer "Charisma"
/declare SpellDEX outer "Spirit of Might"
/declare SpellSTR outer "Spirit of Might"
/declare SpellAGI outer "Agility of the Wrulan"
/declare SpellSTA outer "Endurance of the Boar"
| ########### Mount Type
/declare Mount outer "Tan Rope Bridle"
| ############ To Do List
/declare Cannibalization outer TRUE
/declare AvatarDelay timer outer 0
/declare LowMana outer FALSE
/declare M_Assist string outer
/declare OutDoors outer TRUE
|############# Noob EXP setup
/declare Exper float outer ${Me.PctExp}
/declare AAExp float outer ${Me.PctAAExp}
/declare TotalAAExp float outer 0.00
/declare TotalExp float outer 0.00
/call MemSpells
| ############### Target a player as Main Assist
/varset M_Assist ${Target.CleanName}
/echo Assist set to ${M_Assist}
/leaveall
|- Summon Mount if outdoors
| /if (!${Me.Mount.ID} && ${OutDoors}) /call cast ${Mount} item 4s
| ###############
| ############### Main Loop Starts
| ###############
:Main_Loop
/if (${Zone.ID}!=${myzone}) {
/quit
/endmacro
}
/if (${Me.PctHPs}<15) {
/warp succor
/delay 10
/quit
/endmacro
}
/if (!${Spawn[${M_Assist}].ID}) {
/warp succor
/delay 10
/quit
/end
}
| - Warps to main tank if to far...
/target pc ${M_Assist}
/delay 10
/if ((${Target.Distance}>20)&&(!${Me.Casting})) /warp target
/if ((${Target.PctHPs} < 65)&&(${Target.Distance}<90)) /call cast ${SpellHeal} gem6 4s
|- Check LOM and Events
/call Check_Mana
/doevents
| /if (!${Me.Mount.ID} && ${OutDoors}) /call cast ${Mount} item 4s
|- Hold Macro on Casting and Moving
:Hold_Main
/if (${Me.Moving}) /goto :Hold_Main
/if (${Me.Casting}) /goto :Hold_Main
|- Canni
/call LOM
|- Buff Avatar
/if (${Me.SpellReady[${SpellATK}]} && !${AvatarDelay}) {
/target pc ${M_Assist}
/delay 10
/call cast ${SpellATK} gem4 4s
/varset AvatarDelay 8m
}
/goto :Main_Loop
/return
| ###############
| ############### Main Loop Ends
| ###############
| ############### Mem Spells in Spell List
Sub MemSpells
/echo Memming spells. Hang on.
/if ( !${Me.Gem[${SpellCanni}]} ) {
/memspell 1 ${SpellCanni}
/delay 25
}
/if ( !${Me.Gem[${SpellSlow}]} ) {
/memspell 2 ${SpellSlow}
/delay 20
}
/if ( !${Me.Gem[${SpellDeBuff}]} ) {
/memspell 3 ${SpellDeBuff}
/delay 20
}
/if ( !${Me.Gem[${SpellATK}]} ) {
/memspell 4 ${SpellATK}
/delay 20
}
/if ( !${Me.Gem[${SpellHaste}]} ) {
/memspell 5 ${SpellHaste}
/delay 20
}
/if ( !${Me.Gem[${SpellHeal}]} ) {
/memspell 6 ${SpellHeal}
/delay 20
}
/if ( !${Me.Gem[${SpellHoT}]} ) {
/memspell 7 ${SpellHoT}
/delay 20
}
/if ( !${Me.Gem[${SpellDoT}]} ) {
/memspell 8 ${SpellDoT}
/delay 30
}
| /if ( !${Me.Gem[${SpellRoot}]} ) {
| /memspell 9 ${SpellRoot}
| /delay 30
| }
|/if ( ${Window[SpellBookWnd].Open} ) /windowstate SpellBookWnd close
/echo Spells are memmed.
/return
| ############### Slowing
Sub Slow
:Slow_Loop
/call cast "Time's Antithesis" item 4s
/if (${Macro.Return.Equal["CAST_INTERRUPTED"]}) /goto :Slow_Loop
/if (${Macro.Return.Equal["CAST_RESISTED"]}) /goto :Slow_Loop
/return
| ################### Check Mana level and report it
Sub Check_Mana
/if (${Math.Calc[${Me.MaxMana}*${MinMana}/100]} >= ${Me.CurrentMana} && !${LowMana}) {
/varset LowMana TRUE
} else /if (${Math.Calc[${Me.MaxMana}*${BuffMana}/100]} <= ${Me.CurrentMana} && ${LowMana}) {
/varset LowMana FALSE
}
/return
| ################## Canni 5
Sub Cannibalization
/call CheckMyHPs
/if (${Me.CurrentHPs} < 2424) {
/call CheckMyHPs
} else /if (${Me.Buff[${SpellHoT}].ID}) {
/aa act Cannibalization
/delay 3s
}
/return
| ################## This will NOT check self HPs, Only check HoT or recast HoT
Sub CheckMyHPs
/if (${Me.PctHPs}<15) {
/warp succor
/delay 10
/quit
/endmacro
}
/if (${Me.CurrentMana}<${Spell[${SpellHoT}].Mana}) {
/echo *** Shit, I don't have mana to cast ${SpellHoT}
} else {
/target myself
/delay 3
/if (!${Me.Buff[${SpellHoT}].ID}) /call cast ${SpellHoT} gem7 3s
}
/return
| ################## This will Check to see if I am Low on Mana
Sub LOM
/if (${Me.CurrentHPs} < ${Math.Calc[${Me.MaxHPs}/1.3]}) /call CheckMyHPs
/if ((${Me.CurrentMana} < ${Math.Calc[${Me.MaxMana}-5]}) && (${Me.SpellReady[${SpellCanni}]})) /call cast ${SpellCanni} gem1 6s
/if (${Cannibalization} && ${Me.AltAbilityReady[47]} && ${Me.CurrentMana} < ${Math.Calc[${Me.MaxMana}-1200]} && ${Me.MaxHPs} > 2424) /call Cannibalization
/return
| ################## Outdoors
Sub Event_OutDoor
/echo This is an indoor zone. Sorry.
/varset OutDoors FALSE
/return
| ################## Zoning
Sub Event_Zoning
/quit
/unload
/end
/return
| ################## NoobExp
Sub Event_NoobExp
/varset TotalExp ${Math.Calc[${Me.PctExp}-Exper]}
/varset TotalAAExp ${Math.Calc[${Me.PctAAExp}-AAExp]}
/echo Experience Gained ***** ${TotalExp}
/echo AA Experience Gained ** ${TotalAAExp}
/varset Exper ${TotalExp}
/varset AAExp ${TotalAAExp}
/return
| ################## I Died
Sub Event_ImDead
/quit
/endmacro
/return
| #################
| ################# Tells n Hells
| #################
Sub Event_Chat(string ChatType,string ChatSender,string ChatText)
/if ((!${ChatType.Equal[TELL]})&&(!${ChatSender.Equal[${M_Assist}]})) /return
| ################# Heal Requests
/if (${ChatText.Equal[heal]} || ${ChatText.Equal[heal me]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/call cast ${SpellHeal}
}
/return
}
/if (${ChatText.Equal[hot]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/call cast ${SpellHoT}
}
/return
}
| ################# Mob Requests
/if (${ChatText.Equal[slow]} || ${ChatText.Equal[add]}) {
/assist ${ChatSender}
/delay 1s
/if (${Target.Type.Equal[NPC]} && ${Target.Distance}<=100) {
/call Slow
}
/return
}
/if (${ChatText.Equal[dot]}) {
/assist ${ChatSender}
/delay 1s
/if (${Target.Type.Equal[NPC]} && ${Target.Distance}<=100) {
/call cast ${SpellDoT} gem8 5s
}
/return
}
| ################# Buff Requests
/if (${ChatText.Equal[haste]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/call cast ${SpellHASTE} gem5 5s
}
/return
}
/if (${ChatText.Equal[focus]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/call cast ${SpellFOCUS} gem5 5s
}
/return
}
/if (${ChatText.Equal[cha]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/call cast ${SpellCHA} gem5 5s
}
/return
}
/if (${ChatText.Equal[str]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/call cast ${SpellSTR} gem5 5s
}
/return
}
/if (${ChatText.Equal[dex]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/call cast ${SpellDEX} gem5 5s
}
/return
}
/if (${ChatText.Equal[sta]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/call cast ${SpellSTA} gem5 5s
}
/return
}
/if (${ChatText.Equal[agi]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/call cast ${SpellAGI} gem5 5s
}
/return
}
/returnInclude Files in case you don't have them from macroquest forums/snippits
Exp_Tracking.inc
Rich (BB code):
|**********************
Exp_Tracking.inc
Version 2.0
This include will track your exp in various forms.
You can track Total Exp Gained, Total AA Exp Gained, Total Run Time, Exp Gained Per Minute,
AA Exp Gained Per Minute, Aproximate Time Till Ding, and Aproximate Time Till AA Ding.
Some of this came from the current "perfect xptracker" macro however I wanted to display
more usefull information.
To use simply /call ExpPrep during a part of your macro that is only called once.
Then /call ExpTrack at any moment you wish to check your exp stats.
***********************|
Sub ExpPrep
/declare Exper float outer ${Me.PctExp}
/declare AAExp float outer ${Me.PctAAExp}
/declare TotalAAExp float outer 0.00
/declare TotalExp float outer 0.00
/declare GAAExp float outer 0.00
/declare GExper float outer 0.00
|*********************************************************************
Edit these values as you see fit. If you set to 1 the information will
show each call. Set to 0 and it will not show.
**********************************************************************|
||Show Total Exp Gained?||
/declare ShowTEG bool outer TRUE
||Show Total AA Exp Gained?||
/declare ShowTAAEG bool outer TRUE
||Show Total Run Time?||
/declare ShowTRT bool outer TRUE
||Show Exp Gained Per Minute?||
/declare ShowEGPM bool outer TRUE
||Show AA Exp Gained Per Minute?||
/declare ShowAAEGPM bool outer TRUE
||Show Aproximate Time Till Ding?||
/declare ShowATTD bool outer TRUE
||Show Aproximate Time Till AA Ding?||
/declare ShowATTAAD bool outer TRUE
/return
Sub ExpTrack
/if (${Me.PctAAExp}>=${AAExp}) {
/varset AAExp ${Math.Calc[${Me.PctAAExp}-${AAExp}]}
} else {
/varset AAExp ${Math.Calc[${Me.PctAAExp}-${AAExp}+100]}
}
/if (${Me.PctExp}>=${Exper}) {
/varset Exper ${Math.Calc[${Me.PctExp}-${Exper}]}
} else {
/varset Exper ${Math.Calc[${Me.PctExp}-${Exper}+100]}
}
/varcalc TotalAAExp ${TotalAAExp}+${AAExp}
/varcalc TotalExp ${TotalExp}+${Exper}
/echo ***************************************
/if (${ShowTEG}) /echo Total Gained: ${Exper}% / ${AAExp}%
/if (${ShowTEG}) /echo Total Exp Gained: ${TotalExp}% / ${TotalAAExp}%
/if (${ShowTRT}) /echo Total Running Time: ${Math.Calc[${Macro.RunTime}/60]} minutes
/if (${ShowEGPM}) /echo Exp Gained Per Minute: ${Math.Calc[${TotalExp}/${Math.Calc[${Macro.RunTime}/60]}]} / ${Math.Calc[${TotalAAExp}/${Math.Calc[${Macro.RunTime}/60]}]}
/if (${ShowATTD}) {
/if (${TotalExp}==0) {
/echo Aprox Time till Ding: Forever!!
} else {
/echo Aprox Time till Ding: ${Math.Calc[${Math.Calc[${Math.Calc[${Macro.RunTime}/60]}/${TotalExp}]}*${Math.Calc[100-${Me.PctExp}]}]} minutes
}
}
/if (${ShowATTAAD}) {
/if (${TotalAAExp}==0) {
/echo Aprox Time till AA Ding: Forever!!
} else {
/echo Aprox Time till AA Ding: ${Math.Calc[${Math.Calc[${Math.Calc[${Macro.RunTime}/60]}/${TotalAAExp}]}*${Math.Calc[100-${Me.PctAAExp}]}]} minutes
}
}
/echo ***************************************
/varset GExper ${Exper}
/varset GAAExp ${AAExp}
/varset Exper ${Me.PctExp}
/varset AAExp ${Me.PctAAExp}
/returnspell_routines.inc
Rich (BB code):
|http://www.macroquest2.com/phpBB2/viewtopic.php?t=7568
| spell_routines.inc
|
| Written by Rusty~
| Last Modified 11/07/2004
|
| Features:
| - Casts spells, clicks items, or uses AA abilities for you
| - Allows back to back casting without waiting on spell gems to pop all the way up
| - Will interrupt spell if target dies while casting. If on a mount, it will dismount and duck if the time left
| is greater than 7 seconds, else it will move forward a bit to interrupt, then move you back
| ** IMPORTANT: if you don't want to interrupt a spell while mounted, put this at the top of your macro: **
| ** /declare noInterrupt int outer 1 **
| - Allows you to use items in bags. Equips item, clicks it, then returns it to its previous location
| - Lets you set how long you want to keep trying to cast the spell (defaults to 0)
| If the spell is interrupted before the given time, it will recast, else it will return CAST_INTERRUPTED
| - Lets you call a custom subroutine while waiting for spell to finish casting
| Try to keep custom subroutines very small. A common use would be to interrupt the spell if a certain condition is true
| - This file also includes a sub named Interrupt. You can call this to interrupt any spell you're casting instantly.
| - You can also use the SwapItem sub included in this to swap items to certain slots
| - Added EquipItem sub to easily equip items in your main Inventory slots.
| - Note: if you don't want this to cast spells while you're invis, in your main macro have this at the top:
| /declare noInvis int outer 1
| This will make it return CAST_INVIS if you're invis
|
| Below is a list of outer scope variables you can access in your macros:
| refreshTime - How much time is left till you're done recovering from casting
| castEndTime - How much time left till you're done casting the current spell... usable in custom spell Subs
| spellNotHold - 1 if your last spell didn't take hold, 0 otherwise
| spellRecastTime1-9 - How much time left till that spell is back up
|
|======================================================================================================================
| EquipItem: An easier way to equip items you have in bags ( useful for weapons or focus items )
| slot name is optional. If not given, it will equip it in the first possible spot
|
| Usage:
| /call EquipItem "item name|slotname"
|
| Returns: "old item name|slotname"
| Examples:
|
| To Equip Sharp Ended Broken Lever when you have Serpent of Vindication equiped:
| /call EquipItem "Sharp Ended Broken Lever"
| It will return "Staff of Vindication|mainhand"
| To reequip the original item, you can save the return in a variable, and then use it later like this:
| /varset oldPrimary ${Macro.Return}
| | ... do stuff here with your new item equiped
| /call EquipItem ${oldPrimary}
|
|======================================================================================================================
| SwapItem: a subroutine which is used in the Cast sub itself. You don't need to do this to cast an item in a bag
| but you can call it in your macro to SwapItems (such as weapons or focus items)
| Usage:
| /call SwapItem "item name" slotname|slotID
| Examples:
|
| To swap Darkblade of the Warlord to your main hand:
| /call SwapItem "Darkblade of the Warlord" mainhand
|
| To swap stat food in one bag with other food in another bag:
| /call SwapItem "Bristlebanes Party Platter" ${FindItem[halas 10lb meat pie].InvSlot}
|
|======================================================================================================================
| Cast: the main subroutine that casts spells or items for you
| Usage:
| /call Cast "spellname|itemname|AAname|AA#" [item|alt|gem#] [give up time][s|m] [custom subroutine name]
| Examples:
|
| To cast Howl of Tashan and mem it in slot 3 if not memmed:
| /call Cast "Howl of Tashan" gem3
|
| To cast Arcane Rune and keep trying for 7 seconds, in case of interrupts.
| /call Cast "Arcane Rune" gem5 7s
|
| To click Grim Aura earring that's in a bag:
| /call Cast "Shrunken Goblin Skull Earring" item
|
| To use AA ability Eldritch Rune:
| /call Cast "Eldritch Rune" alt
| or
| /call Cast "173" alt
|
| To call a subroutine that interrupts CH if target gets healed before it lands:
| /call Cast "Complete Healing" gem1 0 CheckHP
| Then in your macro have somewhere:
| Sub CheckHP
| /if ( ${Target.PctHPs}>=80 ) /call Interrupt
| /return
|
| Returns these values:
|----------------------+----------------------------------------------------------------------+
| CAST_CANCELLED | Spell was cancelled by ducking (either manually or because mob died) |
| CAST_CANNOTSEE | You can't see your target |
| CAST_IMMUNE | Target is immune to this spell |
| CAST_INTERRUPTED | Casting was interrupted and exceeded the given time limit |
| CAST_INVIS | You were invis, and noInvis is set to true |
| CAST_NOTARGET | You don't have a target selected for this spell |
| CAST_NOTMEMMED | Spell is not memmed and you gem to mem was not specified |
| CAST_NOTREADY | AA ability or spell is not ready yet |
| CAST_OUTOFMANA | You don't have enough mana for this spell! |
| CAST_OUTOFRANGE | Target is out of range |
| CAST_RESISTED | Your spell was resisted! |
| CAST_SUCCESS | Your spell was cast successfully! (yay) |
| CAST_UNKNOWNSPELL | Spell/Item/Ability was not found |
|----------------------+----------------------------------------------------------------------+
#event BeginCast "You begin casting#*#"
#event Collapse "Your gate is too unstable, and collapses.#*#"
#event FDFail "#1# has fallen to the ground.#*#"
#event Fizzle "Your spell fizzles#*#"
#event Immune "Your target is immune to changes in its attack speed#*#"
#event Immune "Your target is immune to changes in its run speed#*#"
#event Immune "Your target cannot be mesmerized#*#"
#event Interrupt "Your casting has been interrupted#*#"
#event Interrupt "Your spell is interrupted#*#"
#event NoHold "Your spell did not take hold#*#"
#event NoLOS "You cannot see your target.#*#"
#event NoTarget "You must first select a target for this spell!#*#"
#event NotReady "Spell recast time not yet met.#*#"
#event OutOfMana "Insufficient Mana to cast this spell!#*#"
#event OutOfRange "Your target is out of range, get closer!#*#"
#event Recover "You haven't recovered yet...#*#"
#event Recover "Spell recovery time not yet met#*#"
#event Resisted "Your target resisted the #1# spell#*#"
#event Resisted2 "You resist the #1# spell#*#"
#event Standing "You must be standing to cast a spell#*#"
#event Stunned "You are stunned#*#"
#event Stunned "You can't cast spells while stunned!#*#"
#event Stunned "You *CANNOT* cast spells, you have been silenced!#*#"
Sub Cast(string spellName,string spellType,timer giveUpTimer,string mySub)
/declare castTime float local
/if ( ${spellType.Equal[item]} ) {
/varset castTime ${FindItem[${spellName}].CastTime}
} else /if ( ${spellType.Equal[alt]} ) {
/varset castTime ${AltAbility[${spellName}].Spell.MyCastTime}
} else {
/varset castTime ${Spell[${spellName}].MyCastTime}
}
/if ( ${Me.Invis} && ${noInvis} ) {
/return
}
:wait_for_stop
/if ( !${Defined[spellType]} ) /declare spellType string local spell
/if ( ${Me.Casting.ID} ) {
/if ( ${Defined[mySub]} ) /call ${mySub}
/goto :wait_for_stop
}
/if ( ${Me.Speed} ) {
:wait_for_stop2
/if ( ${Defined[mySub]} ) /call ${mySub}
/if ( ${Me.Moving} && ${castTime}>0.1 ) /goto :wait_for_stop2
}
/if ( !${Defined[giveUpTimer]} ) /declare giveUpTimer timer local 0
/if ( !${Defined[spellRecastTime1]} ) {
/if ( !${Defined[noInterrupt]} ) /declare noInterrupt int outer 0
/declare moveBack bool outer false
/declare selfResist int outer
/declare selfResistSpell string outer
/declare castEndTime timer outer
/declare refreshTime timer outer 0
/declare itemRefreshTime float outer 0
/declare startCastingLoc string outer
/declare i int local
/declare castReturn string outer
/declare spellNotHold string outer
/delay 5
/for i 1 to 9
/declare spellRecastTime${i} timer outer
/if ( ${Me.SpellReady[${i}]} ) {
/varset spellRecastTime${i} 0
} else {
/varcalc spellRecastTime${i} 10*${Me.Gem[${i}].RecastTime}
}
/next i
}
/varset spellNotHold 0
/varset selfResist 0
/declare delayTime timer local
/declare swapItemBack bool local false
/declare slotName int local
/declare oldItemName string local
/declare slotID int local
/declare oldSlotID int local
/declare spellID int local
/declare charges int local
/if ( ${Window[SpellBookWnd].Open} ) /keypress spellbook
/if ( ${Me.Ducking} ) /keypress duck
/if ( !${Me.Standing} ) /stand
/doevents Recover
/doevents BeginCast
/doevents Fizzle
/doevents Interrupt
/doevents Standing
/doevents FDFail
/doevents OutOfRange
/doevents OutOfMana
/doevents NoLOS
/doevents Resisted2
/doevents Resisted
/doevents Immune
/doevents Stunned
/doevents Collapse
/doevents NoTarget
/doevents NotReady
/varset castReturn CAST_SUCCESS
/if ( ${spellType.Equal[item]} ) /goto :cast_item
/if ( ${spellType.Equal[alt]} ) /goto :cast_alt
:cast_spell
/if ( !${Int[${Me.Book[${spellName}]}]} ) {
/echo Spell: "${spellName}" was not found in your book
/return CAST_UNKNOWNSPELL
}
/if ( !${Me.Gem[${spellName}]} ) {
:mem_spell
/if ( ${Cursor.ID} ) {
/autoinventory
/delay 5
/goto :mem_spell
}
/if ( ${spellType.Left[3].Equal[gem]} ) {
/memspell ${spellType.Right[1]} "${spellName}"
} else {
/return CAST_NOTMEMMED
}
/delay 6s ( ${Me.Gem[${spellName}]} || !${Window[SpellBookWnd].Open} )
:close_spell_book
/if ( ${Window[SpellBookWnd].Open} ) {
/echo *** SpellBookWnd Stuck Open ***
/notify SpellBookWnd DoneButton leftmouseup
/goto :close_spell_book
}
/if ( ${Me.Sitting} ) {
/sit
}
/if ( !${Me.Gem[${spellName}]} ) {
/echo Spell mem interrupted...
/return CAST_INTERRUPTED
}
:wait_for_mem
/delay 15s ${Me.SpellReady[${spellName}]}
/if ( !${Me.SpellReady[${spellName}]} ) {
/if ( ${giveUpTimer} ) /goto :wait_for_mem
/return CAST_NOTREADY
}
}
/varset spellType spell
/if ( ${spellName.Find[illusion: ]} && ${Me.AltAbilityReady[project illusion]} ) /call Cast "project illusion" alt
/varset giveUpTimer ${giveUpTimer.OriginalValue}
/declare recoverWaitTime timer local 30
:cast_spell_loop
:wait_for_spell
/if ( ${Me.SpellReady[${spellName}]} ) {
/varset spellRecastTime${Me.Gem[${spellName}]} 0
/goto :skip_delay
}
/if ( ${spellRecastTime${Me.Gem[${spellName}]}} ) {
/if ( !${giveUpTimer} ) /return CAST_NOTREADY
/if ( ${Defined[mySub]} ) /call ${mySub}
/goto :wait_for_spell
}
/if ( !${refreshTime} ) /goto :skip_delay
:wait_on_refresh
/if ( ${Me.SpellReady[${spellName}]} ) /varset refreshTime 0
/if ( ${refreshTime}>0 ) {
/if ( ${Defined[mySub]} ) /call ${mySub}
/goto :wait_on_refresh
}
/varcalc delayTime 10*(1.5-${Spell[${spellName}].MyCastTime})
:cast_delay_loop
/if ( ${delayTime}>0 ) {
/if ( ${Defined[mySub]} ) /call ${mySub}
/goto :cast_delay_loop
}
:skip_delay
/varset startCastingLoc ${Me.X} ${Me.Y} ${Me.Z}
/cast "${spellName}"
/if ( ${Me.Casting.ID} ) {
/varset spellID ${Me.Casting.ID}
/varcalc castEndTime ${Me.Casting.MyCastTime}*10
/if ( ${castEndTime}<${Math.Calc[${Me.Casting.CastTime}*5]} ) /varcalc castEndTime ${Me.Casting.CastTime}*5
/echo Casting: ${Me.Casting.Name}${If[!${Me.Casting.TargetType.Equal[PB AE]} && !${Me.Casting.TargetType.Equal[self]} && ${Target.ID}, on >> ${Target.CleanName} <<,]}
}
/varset moveBack false
/call WaitCast ${mySub}
/if ( ${moveBack} ) {
/keypress back hold
/delay 4
/keypress back
/delay 15 !${Me.Moving}
}
/if ( ${castReturn.Equal[CAST_CANCELLED]} ) {
/echo Spell was cancelled...
/return CAST_CANCELLED
}
/doevents Recover
/doevents BeginCast
/doevents Fizzle
/doevents Interrupt
/doevents Standing
/doevents FDFail
/doevents OutOfRange
/doevents OutOfMana
/doevents NoLOS
/doevents Resisted2
/doevents Resisted
/doevents Immune
/doevents Stunned
/doevents Collapse
/doevents NoTarget
/doevents NotReady
/if ( !${spellID} ) /varset spellID ${Spell[${spellName}].ID}
/if ( !${castReturn.Equal[CAST_SUCCESS]} ) {
/if ( ${castReturn.Equal[CAST_NOTREADY]} ) /return CAST_NOTREADY
/if ( ${castReturn.Equal[CAST_FIZZLE]} ) {
/echo Spell Fizzled. Recasting...
/goto :cast_spell_loop
}
/if ( ${castReturn.Equal[CAST_RECOVER]} ) {
/if ( !${recoverWaitTime} ) {
/varcalc spellRecastTime${Me.Gem[${spellName}]} 10*${Spell[${spellID}].RecastTime}
/if ( !${giveUpTimer} ) /return CAST_NOTREADY
}
/goto :cast_spell_loop
}
/if ( ${castReturn.Equal[CAST_RESTART]} ) /goto :cast_spell_loop
/if ( ${castReturn.Equal[CAST_STUNNED]} ) {
/if ( ${Me.Stunned} ) {
/delay 3s !${Me.Stunned}
} else {
/delay 7
}
/goto :cast_spell_loop
}
/if ( ${castReturn.Equal[CAST_INTERRUPTED]} ) {
/if ( ${giveUpTimer} ) {
/echo Spell was interrupted. Recasting...
/goto :cast_spell_loop
}
/echo Spell was interrupted...
/return CAST_INTERRUPTED
}
}
/if ( !${castReturn.Equal[CAST_CANNOTSEE]} && !${castReturn.Equal[CAST_OUTOFRANGE]} && !${castReturn.Equal[CAST_OUTOFMANA]} && !${castReturn.Equal[CAST_NOTARGET]} ) {
/varcalc refreshTime 10*${Spell[${spellID}].RecoveryTime}
/varcalc spellRecastTime${Me.Gem[${spellName}]} 10*${Spell[${spellID}].RecastTime}
}
/if ( ${castReturn.Equal[CAST_COLLAPSE]} ) {
/varset giveUpTimer 200
/goto :cast_spell_loop
}
/return ${castReturn}
:cast_item
|martin added + fixme: check if inventory is full too
/if (${Cursor.ID} && ${Cursor.NoDrop}) {
/echo You have a no-drop item on cursor please bag it first.
/return CAST_CANCELLED
}
/if ( !${FindItem[${spellName}].InvSlot} ) {
/echo Cannot find item: ${spellName}
/return CAST_UNKNOWNSPELL
}
/if ( ${FindItem[${spellName}].InvSlot}>21 ) {
/varset swapItemBack true
/if ( ${FindItem[${spellName}].WornSlot[1]} && ${FindItem[${spellName}].EffectType.Find[worn]} ) {
/varset slotName ${FindItem[${spellName}].WornSlot[1]}
} else /if ( ${FindItem[${spellName}].InvSlot}>29 ) {
/varset slotName 29
} else {
/varset slotName ${FindItem[${spellName}].InvSlot}
}
/varset slotID ${InvSlot[${slotName}].ID}
/varset oldSlotID ${FindItem[${spellName}].InvSlot.ID}
/varset oldItemName ${InvSlot[${slotID}].Item.Name}
/call SwapItem "${spellName}" ${slotID}
}
:cast_item_loop
:wait_item_loop
/if ( ${itemRefreshTime} > ${MacroQuest.Running} ) {
/delay 1
/goto :wait_item_loop
}
/varset itemRefreshTime ${Math.Calc[${MacroQuest.Running}+000]}
/varset charges ${FindItem[${spellName}].Charges}
/varset startCastingLoc ${Me.X} ${Me.Y} ${Me.Z}
/cast item "${spellName}"
/if ( ${Me.Casting.ID} ) {
/varcalc castEndTime ${FindItem[${spellName}].CastTime}*10
/echo Casting: ${FindItem[${spellName}].Spell.Name}${If[!${FindItem[${spellName}].Spell.TargetType.Equal[PB AE]} && !${FindItem[${spellName}].Spell.TargetType.Equal[self]} && ${Target.ID}, on >> ${Target.CleanName} <<,]}
}
/if ( ${charges}>0 ) /delay 1s ${FindItem[${spellName}].Charges}!=${charges}
/call WaitCast ${mySub}
/if ( ${swapItemBack} ) {
/if ( ${FindItem[${spellName}].ID} ) {
/call SwapItem "${spellName}" ${oldSlotID}
} else /if ( ${FindItem[${oldItemName}].ID} ) {
/call SwapItem "${oldItemName}" ${slotID}
}
/if ( ${Cursor.Container} ) /autoinventory
}
/if ( ${castReturn.Equal[CAST_CANCELLED]} ) {
/echo Spell was cancelled...
/return CAST_CANCELLED
}
/doevents BeginCast
/doevents Interrupt
/doevents Standing
/doevents FDFail
/doevents OutOfRange
/doevents NoLOS
/doevents Resisted2
/doevents Resisted
/doevents Immune
/doevents Stunned
/doevents Collapse
/doevents NoTarget
/doevents NotReady
/if ( !${castReturn.Equal[CAST_SUCCESS]} ) {
/if ( ${castReturn.Equal[CAST_NOTREADY]} ) /return CAST_NOTREADY
/if ( ${castReturn.Equal[CAST_RESTART]} ) /goto :cast_item
/if ( ${castReturn.Equal[CAST_STUNNED]} ) {
/if ( ${Me.Stunned} ) {
/delay 3s !${Me.Stunned}
} else {
/delay 7
}
/goto :cast_item
}
/if ( ${castReturn.Equal[CAST_INTERRUPTED]} ) {
/if ( ${giveUpTimer} ) {
/echo Spell was interrupted. Recasting...
/goto :cast_item
}
/echo Spell was interrupted...
/return CAST_INTERRUPTED
}
}
/if ( ${castReturn.Equal[CAST_COLLAPSE]} ) {
/varset giveUpTimer 200
/goto :cast_item
}
/return ${castReturn}
:cast_alt
/if ( !${Me.AltAbilityReady[${spellName}]} ) /return CAST_NOTREADY
/echo Using AA Ability: ${AltAbility[${spellName}].Name}
/alt activate ${AltAbility[${spellName}].ID}
/if ( ${AltAbility[${spellName}].Spell.MyCastTime}>=0.5 ) /delay 1s ${Me.Casting.ID}
/call WaitCast ${mySub}
/if ( ${castReturn.Equal[CAST_CANCELLED]} ) {
/echo Spell was cancelled...
/return CAST_CANCELLED
}
/doevents BeginCast
/doevents Interrupt
/doevents Standing
/doevents FDFail
/doevents OutOfRange
/doevents NoLOS
/doevents Resisted2
/doevents Resisted
/doevents Immune
/doevents Stunned
/doevents NoTarget
/if ( !${castReturn.Equal[CAST_SUCCESS]} ) {
/if ( ${castReturn.Equal[CAST_RESTART]} ) /goto :cast_alt
/if ( ${castReturn.Equal[CAST_STUNNED]} ) {
/if ( ${Me.Stunned} ) {
/delay 3s !${Me.Stunned}
} else {
/delay 7
}
/goto :cast_alt
}
/if ( ${castReturn.Equal[CAST_INTERRUPTED]} ) {
/if ( ${giveUpTimer} ) {
/echo Spell was interrupted. Recasting...
/goto :cast_alt
}
/echo Spell was interrupted...
/return CAST_INTERRUPTED
}
}
/return ${castReturn}
Sub EquipItem(string WhatWhere)
/declare DestName string local
/declare ItemName string local ${WhatWhere.Arg[1,|]}
/declare SlotName string local ${WhatWhere.Arg[2,|]}
/if (${SlotName.Equal[NULL]}) /varset SlotName ${InvSlot[${FindItem[=${ItemName}].WornSlot[1]}].Name}
/if (${FindItem[=${ItemName}].InvSlot}<22 || !${FindItem[=${ItemName}].WornSlot[${SlotName}]}) /return
/if (!${InvSlot[${SlotName}].Item.Name.Equal[NULL]}) /varset DestName "${InvSlot[${SlotName}].Item.Name}|${SlotName}"
/call SwapItem "${ItemName}" "${SlotName}"
/return ${DestName}
| Sub EquipItem(string itemName,string slotName)
/if ( !${Defined[slotName]} ) /declare slotName string local ${FindItem[${itemName}].WornSlot[1]}
/declare oldItem string local ${Me.Inventory[${slotName}].Name}
/call SwapItem "${itemName}" ${slotName}
/return "${oldItem}" ${slotName}
Sub SwapItem(string itemName,string slotName)
/if ( ${InvSlot[${slotName}].Item.Name.Equal[${itemName}]} ) /return
/declare slotID int local
/declare oldSlotID int local
/declare oldItem string local
/declare i int local
/varset slotID ${InvSlot[${slotName}].ID} | slotID = slot you're swapping item to
/varset oldSlotID ${FindItem[${itemName}].InvSlot.ID} | oldSlotID = slot the item was originally in
/varset oldItem ${InvSlot[${slotName}].Item.Name} | oldItem = name of item in the slot you're swapping WITH
/if ( !${slotID} ) {
/echo Invalid slot name: ${slotName}
/return
}
/if ( !${oldSlotID} ) {
/echo Could not find item ${itemName}
/return
}
:auto_inv
/if ( ${Cursor.ID} && !${Cursor.Name.Equal[${itemName}]} ) {
/if ( ${Cursor.Container} ) {
/for i 1 to 8
/if ( !${InvSlot[pack${i}].Item.Container} ) {
/nomodkey /itemnotify pack${i} leftmouseup
}
/next i
} else {
/autoinventory
}
/goto :auto_inv
}
:pick_up_item
| if the item is in a bag and it's not open, then open it!
/if ( ${InvSlot[${oldSlotID}].Pack} && !${Window[${InvSlot[${oldSlotID}].Pack.Name}].Open} ) /nomodkey /itemnotify ${InvSlot[${oldSlotID}].Pack} rightmouseup
| if the slot you're putting it in is inside a bag and it's not open, then open it!
/if ( ${InvSlot[${slotID}].Pack} && !${Window[${InvSlot[${slotID}].Pack.Name}].Open} ) /nomodkey /itemnotify ${InvSlot[${slotID}].Pack} rightmouseup
| ok.. pick up the item now!
/squelch /nomodkey /shiftkey /itemnotify ${InvSlot[${oldSlotID}]} leftmouseup
| if item isn't on your cursor, try again!
/if ( !${Cursor.Name.Equal[${itemName}]} ) {
/if ( ${Cursor.ID} && !${Cursor.Container} ) /autoinventory
/goto :pick_up_item
}
:exchange_items
/if ( ${InvSlot[${oldSlotID}].Pack} && !${Window[${InvSlot[${oldSlotID}].Pack.Name}].Open} ) /nomodkey /itemnotify ${InvSlot[${oldSlotID}].Pack} rightmouseup
/if ( ${InvSlot[${slotID}].Pack} && !${Window[${InvSlot[${slotID}].Pack.Name}].Open} ) /nomodkey /itemnotify ${InvSlot[${slotID}].Pack} rightmouseup
| put the item in the new slot, and pick up whatever item was there
/squelch /nomodkey /shiftkey /itemnotify ${slotID} leftmouseup
| if it didnt get exchanged, try again!
/if ( ${Cursor.ID} && !${Cursor.Name.Equal[${oldItem}]} && !${Cursor.Name.Equal[${itemName}]} && !${Cursor.Container} ) /autoinventory
/if ( !${InvSlot[${slotID}].Item.Name.Equal[${itemName}]} ) /goto :exchange_items
:drop_item
/if ( !${Cursor.Container} || ( ${InvSlot[${oldSlotID}]}<30 && ${InvSlot[${oldSlotID}]}>=22 ) ) {
/if ( ${InvSlot[${oldSlotID}].Pack} && !${Window[${InvSlot[${oldSlotID}].Pack.Name}].Open} ) /nomodkey /itemnotify ${InvSlot[${oldSlotID}].Pack} rightmouseup
/if ( ${InvSlot[${slotID}].Pack} && !${Window[${InvSlot[${slotID}].Pack.Name}].Open} ) /nomodkey /itemnotify ${InvSlot[${slotID}].Pack} rightmouseup
/squelch /nomodkey /itemnotify ${oldSlotID} leftmouseup
/if ( ${Cursor.ID} ) {
/if ( !${Cursor.Name.Equal[${oldItem}]} ) /autoinventory
/goto :drop_item
}
}
:close_pack
/if ( ${InvSlot[${oldSlotID}].Pack} && ${Window[${InvSlot[${oldSlotID}].Pack.Name}].Open} && ( ${Cursor.Name.Equal[${itemName}]} || ${FindItem[${itemName}].ID} ) ) {
/squelch /nomodkey /itemnotify ${InvSlot[${oldSlotID}].Pack} rightmouseup
/goto :close_pack
}
/if ( ${InvSlot[${slotID}].Pack} && ${Window[${InvSlot[${slotID}].Pack.Name}].Open} && ( ${Cursor.Name.Equal[${itemName}]} || ${FindItem[${itemName}].ID} ) ) {
/squelch /nomodkey /itemnotify ${InvSlot[${slotID}].Pack} rightmouseup
/goto :close_pack
}
/return
Sub Interrupt
/if ( ${Me.Mount.ID} ) /dismount
/stopcast
/if ( ${Defined[castReturn]} ) /varset castReturn CAST_CANCELLED
/return ${Macro.Return}
Sub WaitCast(string mySub)
/declare currentTarget int local ${Target.ID}
/declare currentTargetType string local ${Target.Type}
:wait_cast_loop
/if ( ${Bool[${mySub}]} ) /call ${mySub}
/if ( ${Me.Casting.ID} ) {
/if ( ${currentTarget} && !${Spawn[${currentTarget}].Type.Equal[${currentTargetType}]} ) {
/if ( !${Me.Casting.TargetType.Equal[PB AE]} && !${Me.Casting.TargetType.Equal[self]} && !${moveBack} && ( !${Me.Mount.ID} || !${noInterrupt} ) ) {
/if ( !${Me.Mount.ID} || ${castEndTime}>70 ) {
/call Interrupt
} else /if ( ${Me.Casting.RecastTime}>3 ) {
/varset castReturn CAST_CANCELLED
/keypress forward hold
/delay 6
/keypress forward
/varset moveBack true
}
}
}
/if ( ${Me.State.Equal[DUCK]} ) /varset castReturn CAST_CANCELLED
/delay 1
/goto :wait_cast_loop
}
/return
Sub Event_Fizzle
/if ( ${Defined[castReturn]} ) /varset castReturn CAST_FIZZLE
/return
Sub Event_Resisted(string line,string name)
/if ( ${selfResist} && ${name.Equal[${selfResistSpell}]} ) {
/varset selfResist 0
/return
}
/if ( ${Defined[castReturn]} ) /varset castReturn CAST_RESISTED
/return
Sub Event_Resisted2(string line,string name)
/if ( ${Defined[selfResist]} ) {
/varset selfResist 1
/varset selfResistSpell ${name}
}
/return
Sub Event_Interrupt
/if ( ${Defined[castReturn]} ) /varset castReturn CAST_INTERRUPTED
/return
Sub Event_Recover
/if ( ${Defined[castReturn]} ) /varset castReturn CAST_RECOVER
/return
Sub Event_Immune
/if ( ${Defined[castReturn]} ) /varset castReturn CAST_IMMUNE
/return
Sub Event_Stunned
/if ( ${Defined[castReturn]} ) /varset castReturn CAST_STUNNED
/return
Sub Event_NoLOS
/if ( ${Defined[castReturn]} ) /varset castReturn CAST_CANNOTSEE
/return
Sub Event_Standing
/if ( ${Defined[castReturn]} ) /varset castReturn CAST_RESTART
/return
Sub Event_Collapse
/if ( ${Defined[castReturn]} ) /varset castReturn CAST_COLLAPSE
/return
Sub Event_OutOfMana
/if ( ${Defined[castReturn]} ) /varset castReturn CAST_OUTOFMANA
/return
Sub Event_OutOfRange
/if ( ${Defined[castReturn]} ) /varset castReturn CAST_OUTOFRANGE
/return
Sub Event_NoTarget
/if ( ${Defined[castReturn]} ) /varset castReturn CAST_NOTARGET
/return
Sub Event_NotReady
/if ( ${Defined[castReturn]} ) /varset castReturn CAST_NOTREADY
/return
Sub Event_NoHold
/if ( ${Defined[spellNotHold]} ) /varset spellNotHold 1
/return
Sub Event_BeginCast
/if ( ${Defined[castReturn]} ) /varset castReturn CAST_SUCCESS
/return
Sub Event_FDFail(string line,string name)
/if ( ${name.Equal[${Me.Name}]} && ${Defined[castReturn]} ) {
/if ( !${Me.Standing} ) /stand
/varset castReturn CAST_RESTART
}
/return
Last edited:
