BlackPower
New member
- Joined
- Nov 17, 2005
- RedCents
- 21¢
Hi I had some questions in regards to a macro.
I am trying to add the Time's Antithsis as the slow and the Pendant of Malosini for the Malo but all I keep getting is cannot find item or Time's Antithsis not found in spell book.
Could anyone shedd some light on to has I should be adding it in. I had added a declare for a clicky slow but i lack the knowhow to make it work. I have below basic knowledge of writing macros and after 3 days I cant go on anymore heh.
If anyone knows how I can add this in it would be much appreciated.
Rich (BB code):
| Shambot
|____________________________________________________________________________
|
| Usage:
| 1. Target player you like to assist (main tank is good)
| 2. Start the script with: /mac <scriptname> [main assist] [chat channel]
[controller]
| 3. Parameters are optional defaults are built in,
| will default to controller as assist with no target or parameter
|
|
| Features: Commands work in tells from "Chat Controller" or group
| Echos all non command word tells to controller
| Vtells controller on incomming tells
|
| The following commands will target the sender and cast the spells
| requested on the sender: [Avatar] [Sta] [Agi] [Dex] [Str] [Cha] [Sow] [lev] [ac]
| [haste] [regen] [see] [pe] [pr] [grow] [shrink] [hot] [heal] [panther] [pan]
|
| The following commands will assist the sender and cast the spells
| requested on the target: [Slow] [add] [root] [dot] [nuke] [dot2]
|
| The following commands: [buff] [buff me] will rebuff a person
|
| The following commands: [Buff them] will rebuff another group
|
| The following commands: [Follow me] [end follow] [stop] are for moving shaman
|
| The [add] or [slow] command are good in combat when there are adds
| Target the add and it will be malo and slowed
|
| During combat he will only do requests for heals, detrimentals, haste and
panther
|
| [buff pet] works properly now, targets the senders pet and buffs
|
| [gate now] will memorize the gate spell and gate to bind, must be a tell
|
| Use "help" for more help
|____________________________________________________________________________
#chat group
#chat tell
#Event ToggleVariable "[MQ2] Toggle #1#"
#Event ToggleVariable "[MQ2] Toggle #1# #2#"
#Event OutDoor "#*#outdoors#*#"
#Event OutDoor "You can not summon a mount here."
#Event Zoning "You have entered#*#"
#Event Hungry "#*#are hungry#*#"
#Event Enrageon "#*#|${Target.CleanName}| has become ENRAGED#*#"
#Event Enrageoff "#*#|${Target.CleanName}| is no longer enraged#*#"
#Event Thirsty "#*#are thirsty#*#"
#Event ImDead "You have been slain by#*#"
#Event ImDead "You died."
#Event Invited "#*#To join the group, click on the 'FOLLOW' option, or
'DISBAND' to cancel#*#"
#Event Worn_off "Your #1# spell has worn off of #2#."
#include Spell_Routines.inc
#include Wait4rez.inc
Sub Main
| The spell will be memmed in the listed order.
| Gem1 = Canni
| Gem2 = Slow
| Gem3 = Malo
| Gem4 = Avatar or DOT2 if DoAvatar False
| Gem5 = Pet and buffs and panther
| Gem6 = Heal
| Gem7 = HoT
| Gem8 = DoT
| Gem9 = root, Nuke, gate
| ########### Make changes in spells as you need.
| ########### Obs! This is mainly for a 65+ shaman with Cannibalization ability
| ########### Set Cannibalization to False if you don't have the ability
| ###########
| ########### Default Channel, Controller
/declare CChannel outer "yourchannelhere"
/declare ChatController outer "yourbosshere"
| ########### Your Spell List - update as needed
/declare SpellSlow outer "Turgur's Insects"
/declare SpellDoT outer "Crippling Spasm"
/declare SpellDoT2 outer "Curse of Sisslak"
/declare SpellPet outer "Farrel's Companion"
/declare SpellDeBuff outer "Balance of Discord"
/declare SpellCanni outer "Ancient: Ancestral CAlling"
/declare SpellHoT outer "Spiritual Serenity"
/declare SpellHeal outer "Ancient: Wilslik's Mending"
/declare SpellRoot outer "Greater Immobilize"
/declare SpellNuke outer "Ice Age"
/declare SpellPanther outer "Spirit of the Panther"
/declare SpellATK outer "Champion"
/declare SpellHASTE outer "Swift like the Wind"
/declare SpellFOCUS outer "Wunshi's Focusing"
/declare SpellCHA outer "Unfailing Reverence"
/declare SpellDEX outer "Mortal Deftness"
/declare SpellSTR outer "Spirit of Might"
/declare SpellAGI outer "Spirit of Sense"
/declare SpellSTA outer "Spirit of Fortitude"
/declare SpellREGEN outer "Spirit of Perseverance"
/declare SpellPE outer "Primal Essence"
/declare SpellPR outer "Talisman of Tribunal"
/declare SpellAC outer "Ancestral Bulwark"
|- these are group versions of the above spells
/declare SpellGSTR outer "Talisman of Might"
/declare SpellGREGEN outer "Talisman of Perseverance"
/declare SpellGAGI outer "Talisman of Sense"
/declare SpellGSTA outer "Talisman of Fortitude"
/declare SpellGHASTE outer "Talisman of Alacrity"
/declare SpellGFOCUS outer "Talisman of Wunshi"
/declare SpellSOW outer "Spirit of Bih`Li"
/declare SpellLEV outer "Levitation"
/declare SpellINV outer "Invisibility"
/declare SpellSHRINK outer "Tiny Terror"
/declare SpellGROW outer "Grow"
/declare SpellSEE outer "Acumen of Dar Khura"
/declare SpellGATE outer "Gate"
/declare SpellFOOD outer "Summon Food"
/declare SpellDRINK outer "Summon Drink"
| - comment out ItemClickyHASTE if you do not have a clicky haste item to buff
with.
| /declare ItemClickyHASTE outer "Scaled Avatar's Hauberk"
| /declare ItemClickyDOT outer "Spear of Fate"
| ########### Mount Type
/declare Mount outer "Giant White Drum"
| ########### My Pet Buff Spell List
| HASTE handled in Cast_HASTE sub now
| and will be cast on pet
/declare SpellPetBuff[1] string outer
/varset SpellPetBuff[1] ${SpellStr}
| ########### Other Pet Buff Spell List
| HASTE handled in Cast_HASTE sub now
| and will be cast on pet
/declare SpellPetBuffo[2] string outer
/varset SpellPetBuffo[1] ${SpellAC}
/varset SpellPetBuffo[2] ${SpellFOCUS}
| ############ Group Buff List.
/declare SpellGrpBuff[7] string outer
/varset SpellGrpBuff[1] ${SpellGSTA}
/varset SpellGrpBuff[2] ${SpellGFOCUS}
/varset SpellGrpBuff[3] ${SpellGSTR}
/varset SpellGrpBuff[4] ${SpellGAGI}
/varset SpellGrpBuff[5] ${SpellGREGEN}
/varset SpellGrpBuff[6] ${SpellGHASTE}
/varset SpellGrpBuff[7] ${SpellGATK}
| ############ Single Buff List.
| HASTE handled in Cast_HASTE sub now
| and will be cast on pc
/declare SpellSingleBuff[5] string outer
/varset SpellSingleBuff[1] ${SpellSTA}
/varset SpellSingleBuff[2] ${SpellFOCUS}
/varset SpellSingleBuff[3] ${SpellSTR}
/varset SpellSingleBuff[4] ${SpellAGI}
/varset SpellSingleBuff[5] ${SpellREGEN}
| ############ Spells to refresh on worn off messages.
/declare RefreshThisBuff[6] string outer
/varset RefreshThisBuff[1] ${SpellHASTE}
/varset RefreshThisBuff[2] ${SpellFOCUS}
/varset RefreshThisBuff[3] ${SpellREGEN}
/varset RefreshThisBuff[4] ${SpellSTA}
/varset RefreshThisBuff[5] ${SpellAGI}
/varset RefreshThisBuff[6] ${SpellSlow}
| ############ Combat Variables
/declare AssistAt int outer 100
/declare CombatAt int outer 99
/declare CastDoTat int outer 80
/declare DotMana int outer 40
/declare Rootat int outer 40
/declare RootMana int outer 40
/declare NukeAt int outer 90
/declare NukeMana int outer 50
/declare PantherSkip int outer 35
/declare SitAt int outer 80
/declare BuffMana int outer 30
/declare MinMana int outer 15
/declare following int outer 0
/declare follname string outer NULL
| ############ Heal Priority.
/declare CasterHeals int outer 30
/declare MeleeHeals int outer 40
/declare TankHeal int outer 50
/declare TankHoT int outer 80
| ############ To Do List
/declare DoMalo outer TRUE
/declare DoSlow outer TRUE
/declare FastSlow outer FALSE
/declare DoRoot outer FALSE
/declare SummonPet outer TRUE
/declare BuffPet outer FALSE
/declare DoDoT outer TRUE
/declare DoPanther outer TRUE
/declare DoPantherGROUP outer TRUE
/declare DoBuffs outer TRUE
/declare DoSow outer TRUE
/declare DoNuke outer FALSE
/declare DoHeal outer TRUE
/declare Cannibalization outer TRUE
/declare Verbose outer TRUE
/declare DoShrink outer FALSE
/declare DoAvatar outer FALSE
| This is a delay for how long Avatar will hold. (8min)
/declare AvatarDelay outer 6300
| This is a delay for how long Panther will hold. (1min about 669)
/declare PantherDelay outer 900
/declare HealSpellDuration outer 480
/declare TankHealTimer timer outer
| ########### ! No Changes From Here Are Needed !
/squelch /alias malo /echo toggle malo
/squelch /alias slow /echo toggle slow
/squelch /alias fastslow /echo toggle fastslow
/squelch /alias root /echo toggle root
/squelch /alias pet /echo toggle pet
/squelch /alias dot /echo toggle dot
/squelch /alias nuke /echo toggle nuke
/squelch /alias nukeat /echo toggle nukeat
/squelch /alias buffs /echo toggle buffs
/squelch /alias sow /echo toggle sow
/squelch /alias assistat /echo toggle assistat
/squelch /alias dotat /echo toggle dotat
/squelch /alias rootat /echo toggle rootat
/squelch /alias combatat /echo toggle combatat
/squelch /alias healmeleeat /echo toggle healmeleeat
/squelch /alias healcastersat /echo toggle healcastersat
/squelch /alias healtankat /echo toggle healtankat
/squelch /alias assist /echo toggle assist
/squelch /alias healat /echo toggle healat
/squelch /alias status /echo toggle show
/squelch /alias show /echo toggle show
/squelch /alias help /echo toggle help
/squelch /alias verbose /echo toggle verbose
/squelch /alias shrink /echo toggle shrink
/squelch /alias avatar /echo toggle avatar
/squelch /alias panther /echo toggle panther
/squelch /alias panthergroup /echo toggle panthergroup
/declare TargetArray[4] string outer
/varset TargetArray[1] NULL
/varset TargetArray[2] NULL
/varset TargetArray[3] NULL
/varset TargetArray[4] NULL
/declare TargetSlow[5] string outer
/varset TargetSlow[1] NULL
/varset TargetSlow[2] NULL
/varset TargetSlow[3] NULL
/varset TargetSlow[4] NULL
/varset TargetSlow[5] NULL
/declare TargetDebuff[5] string outer
/varset TargetDebuff[1] NULL
/varset TargetDebuff[2] NULL
/varset TargetDebuff[3] NULL
/varset TargetDebuff[4] NULL
/varset TargetDebuff[5] NULL
/declare MobMaloed outer FALSE
/declare MobSlowed outer FALSE
/declare PetOn outer FALSE
/declare MobRooted outer FALSE
/declare MobDoTed outer FALSE
/declare CombatOn outer TRUE
/declare Engaged outer FALSE
/declare LowMana outer FALSE
/declare M_Assist string outer
/declare OutDoors outer TRUE
/declare Exper float outer
/declare AAExp float outer
/varset Exper ${Me.Exp}
/varset AAExp ${Me.AAExp}
/declare ATKBuffed0 timer outer 0
/declare ATKBuffed1 timer outer 0
/declare ATKBuffed2 timer outer 0
/declare ATKBuffed3 timer outer 0
/declare ATKBuffed4 timer outer 0
/declare ATKBuffed5 timer outer 0
| ## may remove panther timers soon or make adjustments so only cast once per
fight unless raid tgt
/declare PANBuffed0 timer outer 0
/declare PANBuffed1 timer outer 0
/declare PANBuffed2 timer outer 0
/declare PANBuffed3 timer outer 0
/declare PANBuffed4 timer outer 0
/declare PANBuffed5 timer outer 0
/call MemSpells
| ############### , Use comand line parameter, target a player as Main Assist, or
fallback to default
/if (${Defined[Param0]}) {
/varset M_Assist ${Param0}
/echo Assist set to ${M_Assist}
} else {
/if (!${Target.ID} || ${Target.Type.NotEqual[PC]}) {
/echo You do not have a PC targeted, using default controller:
${ChatController}
/echo To reset MA do: assist <PC Name>
/varset M_Assist ${ChatController}
} else {
/if (${Target.CleanName.Equal[${Me.CleanName}]}) {
/echo You cannot assist yourself! using default controller:
${ChatController}
/echo To reset MA do: assist <PC Name>
/varset M_Assist ${ChatController}
} else {
/varset M_Assist ${Target.CleanName}
/echo Assist set to ${M_Assist}
}
}
}
/assist off
/if (${Defined[Param1]}) /varset CChannel ${Param1}
/leaveall
/join ${CChannel}
/1 I am here!
/echo Joined channel ${CChannel}
/if (${Defined[Param2]}) /varset ChatController ${Param2}
/vtell ${ChatController} 005
/tell ${ChatController} I am here!
/echo My master is ${ChatController}
| ############### Shrink
/call Cast_Shrink
| ###############
| ############### Main Loop Starts
| ###############
:Main_Loop
|- Check for Standing if less than sitat then sit
/if ( ${Me.State.Equal[Stand]} && ${Me.PctMana}<${SitAt}) /sit
|- Summon Mount if outdoors
/if (!${Me.Mount.ID} && ${OutDoors}) /call cast ${Mount} item 5s
|- Check for low mana state
/call Check_Mana
|- Check for new events in chat etc etc...
/doevents
|- Do we move?
:Hold_Main
/if (${Me.Moving}) /goto :Hold_Main
|- Pet
/if (!${Engaged}) /call PET
|- check pets health if we have a pet and cast a hot if below 30%
/if (${Me.Pet.ID} && ${SummonPet} &&
${Spell[${SpellHoT}].Mana}<=${Me.CurrentMana} && ${Me.Pet.PctHPs}<=30) {
/target id ${Me.Pet.ID}
/delay 5 ${Target.ID}==${Me.Pet.ID}
/call cast ${SpellHoT} gem7 3s
}
|- Buff Sow
/if (!${Engaged}) /call SOW
|- Check for mobs and do combat stuff
/call GetTarget
/if (${CombatOn} && ${TargetArray[4].NotEqual[NULL]}) /call Combat
|- Group Heals
/call Check_grpHPs
|- Check for Standing if less than sitat then sit
/if ( ${Me.State.Equal[Stand]} && ${Me.PctMana}<${SitAt}) /sit
|- Canni
/call LOM
|- Group Buffs if more than BuffMana mana
/if (${Me.PctMana}>=${BuffMana} && ${DoBuffs}) /call GrpBuffs
|- Buff Avatar
/if (${DoAvatar}) {
/if (${Me.SpellReady[${SpellATK}]}) /call Cast_Avatar
}
|- Group Heals
/call Check_grpHPs
/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[${SpellPanther}]} ) {
/memspell 2 ${SpellPanther}
/delay 20
}
/if ( !${Me.Gem[${SpellDeBuff}]} ) {
/memspell 3 ${SpellDeBuff}
/delay 20
}
/if (${DoAvatar}) {
/if ( !${Me.Gem[${SpellATK}]} ) {
/memspell 4 ${SpellATK}
/delay 20
}
} else {
/if ( !${Me.Gem[${SpellDoT2}]} ) {
/memspell 4 ${SpellDoT2}
/delay 20
}
}
/if (!${Me.Pet.ID} && ${SummonPet}) {
/if ( !${Me.Gem[${SpellPet}]} ) {
/memspell 5 ${SpellPet}
/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
| ################### Check target and do stuff like slow, dot, pet attack etc.
Sub Combat
/if (${Target.ID}==${TargetArray[4]}) {
/if (${CombatOn} && !${MobMaloed} && ${DoMalo}) /call DeBuff
/if (${CombatOn} && !${PetOn} && ${Target.ID}==${TargetArray[4]} &&
${Target.Distance}<150) {
/squelch /pet attack
/varset PetOn TRUE
/varset Engaged TRUE
}
/if (${CombatOn} && !${MobSlowed} && ${DoSlow}) /call Slow
|- Check for new events in chat and maybe new target
/doevents
|- do panther stuff
/if (${CombatOn} && ${DoPanther} && ${Engaged} && ${Me.PctMana}>=${RootMana}
${Target.ID}==${TargetArray[4]}) {
/if (${Me.Pet.ID}) {
/if (!${Me.PetBuff[${SpellPanther}]}) {
/pet target
/call cast ${SpellPanther} gem2 3s
}
}
/if (${DoPantherGROUP}) /call Cast_Panther
/if (${Target.ID}!=${TargetArray[4]}) /target id ${TargetArray[4]}
}
/if (${CombatOn} && ${DoDoT} && !${MobDoTed} && ${Me.PctMana}>=${RootMana} &&
${Target.PctHPs}<=${CastDoTat}) {
/call cast ${SpellDoT} gem8
/if (!${DoPanther} && !${DoAvatar}) /call cast ${SpellDoT2} gem4
/doevents
/if (${Target.ID}!=${TargetArray[4]}) /target id ${TargetArray[4]}
/if (${Defined[ItemClickyDOT]}) /call cast ${ItemClickyDOT} item 3s
/varset MobDoTed TRUE
}
/if (${CombatOn} && ${DoNuke} && ${Me.PctMana}>=${NukeMana} &&
${Target.PctHPs}<=${NukeAt}) {
/call cast ${SpellNuke} gem9
}
/if (${CombatOn} && ${DoRoot} && ${Me.PctMana}>=${RootMana} &&
${Target.PctHPs}<=${RootAt}) {
/call cast ${SpellRoot} gem9
/varset MobRooted TRUE
}
}
|- EndCombat - Check for new events in chat etc etc...
/doevents
/squelch /target ${TargetArray[3]}
/delay 3
/if (!${Target.Name.Equal[${TargetArray[3]}]} || !${Target.ID}) {
/if (${TargetArray[1].NotEqual[NULL]}) /echo ${TargetArray[1]} is dead
/varset MobRooted FALSE
/varset MobMaloed FALSE
/varset MobSlowed FALSE
/varset PetOn FALSE
/varset MobDoTed FALSE
/varset CombatOn FALSE
/varset Engaged FALSE
/declare i int local 1
/for i 1 to ${TargetDebuff.Size}
/if (${Target.ID}==${TargetDebuff[${i}]}) {
/echo removing ${TargetArray[1]}_${TargetArray[4]} from Debuff Array
/varset TargetDebuff[${i}] NULL
}
/next i
/varset i 1
/for i 1 to ${TargetSlow.Size}
/if (${Target.ID}==${TargetSlow[${i}]}) {
/echo removing ${TargetArray[1]}_${TargetArray[4]} from Slow Array
/varset TargetSlow[${i}] NULL
}
/next i
/varset TargetArray[1] NULL
/varset TargetArray[2] NULL
/varset TargetArray[3] NULL
/varset TargetArray[4] NULL
}
/return
| ############## Cast_Panther Line on group
Sub Cast_Panther
/target id ${TargetArray[4]}
/delay 5
/if (${Target.PctHPs}>=${PantherSkip}) {
/declare i int local 1
/for i 1 to ${Group.Members}
/if (${Group.Member[${i}].ID}) {
/if (${PANBuffed${i}}==0) /if
(${Group.Member[${i}].Class.Name.Equal[Beastlord]} ||
${Group.Member[${i}].Class.Name.Equal[Shadow Knight]} ||
${Group.Member[${i}].Class.Name.Equal[Bard]} ||
${Group.Member[${i}].Class.Name.Equal[Ranger]} ||
${Group.Member[${i}].Class.Name.Equal[Rogue]} ||
${Group.Member[${i}].Class.Name.Equal[Paladin]} ||
${Group.Member[${i}].Class.Name.Equal[Monk]} ||
${Group.Member[${i}].Class.Name.Equal[Warrior]}) {
/if (${Me.CurrentMana}>${Spell[${SpellPanther}].Mana}) {
/target pc ${Group.Member[${i}]}
/delay 5
/tell ${Group.Member[${i}]} ${SpellPanther} is incomming to you
${Group.Member[${i}]} , Stay in Range !!!
/call cast ${SpellPanther} gem2 3s
/if (${Macro.Return.Equal["CAST_OUTOFRANGE"]}) /varset PANBuffed${i}
200
/if (${Macro.Return.Equal["CAST_SUCCESS"]}) /varset PANBuffed${i}
${PantherDelay}
/return
}
}
}
/next i
/target id ${TargetArray[4]}
/delay 1s
}
/return
| ############## Cast_Shrink
Sub Cast_Shrink
/if (${DoShrink}) {
/gsay Shrinking Group
/if (${SpellSHRINK.Equal[Shrink]}) {
/declare i int local 0
/for i 0 to ${Group.Members}
/if (${Group.Member[${i}].ID}) {
/target pc ${Group.Member[${i}]}
/if (${Target.Distance}<=100) {
/call cast ${SpellSHRINK} gem5 5s
}
}
/next i
} else {
/target pc ${M_Assist}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/ECHO ${SpellSHRINK} is incomming to you
/call cast ${SpellSHRINK} gem5 5s
}
}
}
/return
| ############### Debuff
Sub DeBuff
|- check to see if in TargetDebuff array
/declare i int local 1
/for i 1 to ${TargetDebuff.Size}
/if (${Target.ID}==${TargetDebuff[${i}]}) {
/echo ${Target.CleanName} has already been debuffed with ${SpellDeBuff}
/varset MobMaloed TRUE
/return
}
/next i
:DeBuff_Loop
/if (${Target.PctHPs}<=${CombatAt} && ${Target.ID}==${TargetArray[4]}) {
/if (${Me.CurrentMana}<${Spell[${SpellDeBuff}].Mana}) {
/echo *** Shid ! I don't have mana to Malo %T
} else {
/call cast ${SpellDeBuff} gem3 2s
/if (${Macro.Return.Equal["CAST_INTERRUPTED"]}) /goto :DeBuff_Loop
/call Addto_Debuff
/varset MobMaloed TRUE
}
}
/return
| ############### Slowing
Sub Slow
|- check to see if in TargetSlow array
/declare i int local 1
/for i 1 to ${TargetSlow.Size}
/if (${Target.ID}==${TargetSlow[${i}]}) {
/echo ${Target.CleanName} has already been slowed with ${SpellSlow}
/varset MobSlowed TRUE
/return
}
/next i
/if (${Target.PctHPs}<=${CombatAt} && ${Target.ID}==${TargetArray[4]}) {
/if (${Me.CurrentMana}<${Spell[${SpellSlow}].Mana}) {
/echo Shid ! I don't have mana to Slow %T
} else {
:Slow_Loop
/call cast "Time's Antithesis" item 3s
/if (${Macro.Return.Equal["CAST_INTERRUPTED"]}) /goto :Slow_Loop
/if (${Macro.Return.Equal["CAST_IMMUNE"]}) {
/if (${Verbose}) /gsay *** %T is IMMUNE to my slow !
/call Addto_Slow
/varset MobSlowed TRUE
}
/if (${Macro.Return.Equal["CAST_RESISTED"]}) {
/if (!${FastSlow}) {
/if (${Verbose}) /gsay *** %T RESISTED slow ! Trying again asap
/goto :Slow_Loop
}
/call Addto_Slow
/varset MobSlowed TRUE
}
/if (${Macro.Return.Equal["CAST_SUCCESS"]}) {
/if (${Verbose}) /gsay *** %T is SLOWED
/call Addto_Slow
/varset MobSlowed TRUE
}
}
}
/return
| ############### Add targets to slow array, pushing oldest off bottom of array
Sub Addto_Slow
/varset TargetSlow[5] ${TargetSlow[4]}
/varset TargetSlow[4] ${TargetSlow[3]}
/varset TargetSlow[3] ${TargetSlow[2]}
/varset TargetSlow[2] ${TargetSlow[1]}
/varset TargetSlow[1] ${Target.ID}
/return
| ############### Add targets to debuff array, pushing oldest off bottom of array
Sub Addto_Debuff
/varset TargetDebuff[5] ${TargetDebuff[4]}
/varset TargetDebuff[4] ${TargetDebuff[3]}
/varset TargetDebuff[3] ${TargetDebuff[2]}
/varset TargetDebuff[2] ${TargetDebuff[1]}
/varset TargetDebuff[1] ${Target.ID}
/return
| ############### GetTarget - Grab the MAs target
Sub GetTarget
/assist ${M_Assist}
/delay 3
/if (${Target.Type.Equal[NPC]}) /if (${Target.Distance}<=${AssistAt} &&
${Target.ID}!=${TargetArray[4]} && ${Target.PctHPs}<=${CombatAt}) {
/varset TargetArray[1] ${Target.CleanName}
/varset TargetArray[2] ${Target.Level}
/varset TargetArray[3] ${Target.Name}
/varset TargetArray[4] ${Target.ID}
/varset CombatOn TRUE
/varset MobRooted FALSE
/varset MobMaloed FALSE
/varset MobSlowed FALSE
/varset PetOn FALSE
/varset MobDoTed FALSE
/varset AAExp ${Math.Calc[${Me.PctAAExp}-${AAExp}]}
/varset Exper ${Math.Calc[${Me.PctExp}-${Exper}]}
/echo EXP: ${Exper}:${Me.PctExp}% - AAXP: ${AAExp}:${Me.PctAAExp}% -
${Math.Calc[${Macro.RunTime}/60]} minutes
/popup EXP: ${Exper}:${Me.PctExp}% - AAXP: ${AAExp}:${Me.PctAAExp}% -
${Math.Calc[${Macro.RunTime}/60]} minutes
/varset Exper ${Me.PctExp}
/varset AAExp ${Me.PctAAExp}
}
/return
| ################### Buff the group with buffs from the SpellGrpBuff array
Sub GrpBuffs
/declare i int local 1
/for i 1 to ${SpellGrpBuff.Size}
/doevents
/if (${Spell[${SpellGrpBuff[${i}]}].Mana} > ${Me.CurrentMana}) /return
/if ( !${Me.Buff[${SpellGrpBuff[${i}]}].ID} ) {
/target pc ${M_Assist}
/delay 3
/echo *** Hang on ! Rebuffing ${SpellGrpBuff[${i}]}
/call cast ${SpellGrpBuff[${i}]} gem5 5s
/call Check_grpHPs
/call GetTarget
}
/next i
/return
|################### Check if any group member needs heal, including self
Sub Check_grpHPs
/declare i int local
/for i 0 to ${Group.Members}
/if (${Group.Member[${i}].Class.Name.Equal[Cleric]} ||
${Group.Member[${i}].Class.Name.Equal[Druid]} ||
${Group.Member[${i}].Class.Name.Equal[Wizard]} ||
${Group.Member[${i}].Class.Name.Equal[Magician]} ||
${Group.Member[${i}].Class.Name.Equal[Necromancer]} ||
${Group.Member[${i}].Class.Name.Equal
[Enchanter]}) /if (${Group.Member[${i}].PctHPs}<=${CasterHeals}) {
/squelch /target pc ${Group.Member[${i}]}
/delay 5
/if (${Target.Type.Equal[PC]} &&
${Target.Distance}<=${Spell[${SpellHeal}].Range}) {
/if (${Me.CurrentMana}<${Spell[${SpellHeal}].Mana}) {
/echo *** Shid ! I don't have mana to heal ${Group.Member[${i}]}
} else /if (${Target.Distance}<=100) {
/if (${Verbose}) /gsay *** ${SpellHeal} on %T
/call cast ${SpellHeal} gem6 4s
}
}
}
/if (${Group.Member[${i}].Class.Name.Equal[Warrior]} ||
${Group.Member[${i}].Class.Name.Equal[Monk]} ||
${Group.Member[${i}].Class.Name.Equal[Rouge]} ||
${Group.Member[${i}].Class.Name.Equal[Ranger]} ||
${Group.Member[${i}].Class.Name.Equal[Beast]} ||
${Group.Member[${i}].Class.Name.Equal[Shadow Knight]} ||
${Group.Member[${i}].Class.Name.Equal[Paladin]}) /if
(${Group.Member[${i}].PctHPs}<=${MeleeHeals} &&
${Group.Member[${i}].Name.NotEqual[${M_Assist}]}) {
/squelch /target pc ${Group.Member[${i}]}
/delay 5
/if (${Target.Type.Equal[PC]} &&
${Target.Distance}<=${Spell[${SpellHeal}].Range}) {
/if (${Me.CurrentMana}<${Spell[${SpellHeal}].Mana}) {
/echo *** Shid ! I don't have mana to heal ${Group.Member[${i}]}
} else /if (${Target.Distance}<=100) {
/if (${Verbose}) /gsay *** ${SpellHeal} on %T
/call cast ${SpellHeal} gem6 4s
}
}
}
/if (${Group.Member[${i}].Name.Equal[${M_Assist}]} &&
${Group.Member[${i}].PctHPs}<=${TankHeal}) {
/squelch /target pc ${Group.Member[${i}]}
/delay 5
/if (${Target.Type.Equal[PC]} &&
${Target.Distance}<=${Spell[${SpellHeal}].Range}) {
/if (${Me.CurrentMana}<${Spell[${SpellHeal}].Mana}) {
/echo *** Shid ! I don't have mana to heal ${Group.Member[${i}]}
} else /if (${Target.Distance}<=100) {
/if (${Verbose}) /gsay *** ${SpellHeal} on %T
/call cast ${SpellHeal} gem6 4s
}
}
}
/if (${Group.Member[${i}].Name.Equal[${M_Assist}]} &&
${Group.Member[${i}].PctHPs}<=${TankHoT} && ${TankHealTimer} <= 50) {
/sq /target clear
/delay 2
/target pc ${Group.Member[${i}]}
/if (${Me.CurrentMana}<${Spell[${SpellHoT}].Mana}) {
/echo *** Shid ! I don't have mana to heal ${Group.Member[${i}]}
} else /if (${Target.Distance}<=110) {
/if (${Verbose}) /gsay *** ${SpellHoT} on %T
/varset TankHealTimer ${HealSpellDuration}
/call cast ${SpellHoT} gem7 3s
}
}
/next i
/return
| ################### Check Mana level and report it
Sub Check_Mana
/if (${Math.Calc[${Me.MaxMana}*${MinMana}/100]} >= ${Me.CurrentMana} &&
!${LowMana}) {
/varset LowMana TRUE
/gsay I am LOM...
} else /if (${Math.Calc[${Me.MaxMana}*${BuffMana}/100]} <= ${Me.CurrentMana} &&
${LowMana}) {
/gsay I am GTG...
/varset LowMana FALSE
}
/return
| ################## Canni 5
Sub Cannibalization
/call CheckMyHPs
/if (${Me.CurrentHPs} < 2424) {
/call CheckMyHPs
} else /if (${Me.Buff[${SpellHoT}].ID}) {
/call CheckMyHPs
/if (${Verbose}) /gsay *** Doing Cannibalization !
/aa act Cannibalization
/delay 3s
}
/return
| ################## This will NOT check self HPs, Only check HoT or recast HoT
Sub CheckMyHPs
/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}/2]}) /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
| ################## This will Check to see if I have SOW
Sub SOW
/if (!${Me.Buff[Spirit of Eagle].ID} && !${Me.Buff[Flight of Eagles].ID} &&
!${Me.Buff[Spirit of Bih`Li].ID} && ${DoSow} && ${OutDoors}) {
/target pc ${M_Assist}
/call cast ${SpellSOW} gem5 17s
}
/return
| ################## Cast_Haste casts haste spell or item if defined
Sub Cast_HASTE
/if (${Defined[ItemClickyHASTE]}) {
/call cast ${ItemClickyHASTE} item 5s
} else {
/call cast ${SpellHASTE} gem5 5s
}
/return
| ################## Summon pet and buff with spells from SpellPetBuff array
Sub Pet
/if (!${Me.Pet.ID} && ${SummonPet} && !${Engaged} &&
${Spell[${SpellPet}].Mana}<=${Me.CurrentMana}) {
/delay 2
/call cast ${SpellPet} gem5 30s
/echo Buff ${Me.Pet.ID} with ${SpellPet}
}
/if (!${Engaged}) {
/declare i int local
/for i 1 to ${SpellPetBuff.Size}
/if (!${Me.PetBuff[${SpellPetBuff[${i}]}]} &&
${Spell[${SpellPetBuff[${i}]}].Mana}<=${Me.CurrentMana}) {
/pet target
/delay 2
/call cast ${SpellPetBuff[${i}]} gem5 9s
/doevents
/if (${Engaged}) /return
}
/next i
}
/if (!${Me.PetBuff[${SpellHASTE}]}) {
/pet target
/call Cast_HASTE
}
/return
|################### Casting Avatar on all melee classes in group
Sub Cast_Avatar
/declare i int local 0
/for i 0 to ${Group.Members}
/if (${Group.Member[${i}].ID}) {
/if (${ATKBuffed${i}}==0) /if
(${Group.Member[${i}].Class.Name.Equal[Shaman]}) {
/target pc ${Group.Member[${i}]}
/if (${Me.CurrentMana}>${Spell[${SpellATK}].Mana}) {
/tell ${Group.Member[${i}]} ${SpellATK} is incomming to you
${Group.Member[${i}]} , Stay in Range !!!
/call cast ${SpellATK} gem4 4s
/if (${Macro.Return.Equal["CAST_OUTOFRANGE"]}) /varset ATKBuffed${i}
200
/if (${Macro.Return.Equal["CAST_SUCCESS"]}) /varset ATKBuffed${i}
${AvatarDelay}
/return
}
}
}
/next i
/return
| ################## Hungry
Sub Event_Hungry
/if (${Engaged}) /return
/echo I am Hungry
/gsay I am summoning food... please hold pulls
/declare i int local 1
/for i 1 to 8
/autoinventory
/delay 1
/call cast ${SpellFOOD} gem5 5s
/next i
/autoinventory
/gsay GTG now
/return
| ################## Thirsty
Sub Event_Thirsty
/if (${Engaged}) /return
/echo I am Thirsty
/gsay I am summoning drink... please hold pulls
/declare i int local 1
/for i 1 to 8
/autoinventory
/delay 1
/call cast ${SpellDRINK} gem5 5s
/next i
/autoinventory
/gsay GTG now
/return
| ################## ENRAGE ON
Sub Event_Enrageon
/if (${PetOn}) {
/echo Mob is ENRAGED!
/pet back off
}
/return
| ################## ENRAGE OFF
Sub Event_Enrageoff
/if (${PetOn}) {
/echo Mob is no longer Enraged!
/pet attack
}
/return
| ################## Outdoors
Sub Event_OutDoor
/echo This is an indoor zone. Sorry.
/varset OutDoors FALSE
/return
| ################## Zoning
Sub Event_Zoning
/if (${DoShrink}) {
/echo I zoned, time to shrink
/delay 10
/call Cast_Shrink
}
/varset TargetArray[1] ${Target.CleanName}
/varset TargetArray[2] ${Target.Level}
/varset TargetArray[3] ${Target.Name}
/varset TargetArray[4] ${Target.ID}
/varset CombatOn TRUE
/varset MobRooted FALSE
/varset MobMaloed FALSE
/varset MobSlowed FALSE
/varset PetOn FALSE
/varset MobDoTed FALSE
/return
| ################## Group Invite
Sub Event_Invited
/invite
/return
| ################## I Died
Sub Event_ImDead
/echo Bummer !
/gsay Im ready to get rez.
/call Wait4Rez
/delay 20
/call MemSpells
/if (${Me.State.Equal[Stand]}) /sit
| We do some short meditate before we start again.
:Meditate
/delay 1s
/if (${Me.CurrentMana} < 300) /goto :Meditate
/return
| #################
| ################# Tells n Hells
| #################
Sub Event_Chat(string ChatType,string ChatSender,string ChatText)
/if (!${ChatType.Equal[GROUP]} && !${ChatType.Equal[TELL]}) /return
/if (${ChatType.Equal[TELL]} && !${ChatSender.Equal[${ChatController}]}) {
/if (${ChatSender.Equal[${Me.Pet.CleanName}]}) /return
/1 [${ChatSender}]:${ChatText}
/vtell ${ChatController} 001
/return
}
| ################# Heal Requests
/if (${ChatText.Equal[heal]} || ${ChatText.Equal[heal me]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/tell ${ChatSender} ${SpellHeal} is incomming !!
/call cast ${SpellHeal}
}
/return
}
/if (${ChatText.Equal[hot]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/tell ${ChatSender} ${SpellHoT} is incomming !!
/call cast ${SpellHoT}
}
/return
}
| ################# Mob Requests
/if (${ChatText.Equal[slow]} || ${ChatText.Equal[add]}) {
/assist ${ChatSender}
/if (${Target.Type.Equal[NPC]} && ${Target.Distance}<=100) {
/call cast ${SpellDebuff} gem3 2s
/call cast ${SpellSlow} gem2 6s
/tell ${ChatSender} %T is ${SpellDeBuff} and slowed with ${SpellSlow}
}
/return
}
/if (${ChatText.Equal[root]}) {
/assist ${ChatSender}
/if (${Target.Type.Equal[NPC]} && ${Target.Distance}<=100) {
/call cast ${SpellRoot} gem9 5s
/tell ${ChatSender} %T is Rooted with ${SpellRoot}
}
/return
}
/if (${ChatText.Equal[nuke]}) {
/assist ${ChatSender}
/if (${Target.Type.Equal[NPC]} && ${Target.Distance}<=100) {
/call cast ${SpellNuke} gem9
}
/return
}
/if (${ChatText.Equal[dot]}) {
/assist ${ChatSender}
/if (${Target.Type.Equal[NPC]} && ${Target.Distance}<=100) {
/call cast ${SpellDoT} gem8 5s
}
/return
}
/if (${ChatText.Equal[dot2]}) {
/assist ${ChatSender}
/if (${Target.Type.Equal[NPC]} && ${Target.Distance}<=100) {
/call cast ${SpellDoT2} gem4 5s
}
/return
}
/if (${ChatText.Equal[clicky]}) {
/assist ${ChatSender}
/if (${Target.Type.Equal[NPC]} && ${Target.Distance}<=100) {
/call cast ${ItemClickyDot} item 5s
}
/return
}
/if (${ChatText.Equal[epic]}) {
/assist ${ChatSender}
/if (${Target.Type.Equal[NPC]} && ${Target.Distance}<=100) {
/call cast "Spear of Fate" item 5s
}
/return
}
/if (${ChatText.Equal[epic2]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
| - need to check if there
/call cast "Crafted Talisman of Fates" "item" 3s
}
/return
}
/if (${ChatText.Equal[aid]} && ${Me.AltAbilityReady[447]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/Alt activate 447
}
/return
}
| ################# buffs ok to ask for in combat
/if (${ChatText.Equal[panther]} || ${ChatText.Equal[pan]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/call cast ${SpellPanther} gem2
}
/return
}
/if (${ChatText.Equal[haste]}) {
/target pc ${ChatSender}
/delay 1
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/tell ${ChatSender} ${SpellHASTE} is incomming to you
${ChatSender}!!!
/call Cast_HASTE
}
/return
}
/if (${ChatText.Equal[rc]} && ${Me.AltAbilityReady[153]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/Alt activate 153
}
/return
}
/if (${Engaged}) /return
| ################# Buff Requests
/if (${ChatText.Equal[rez]} && ${Me.AltAbilityReady[404]}) {
/target clear
/assist ${ChatSender}
/if (${Target.Type.Equal[CORPSE]} && ${Target.Distance}<=100) {
/tell ${Target.CleanName} Incomming SHAMAN rez, DO NOT LOOT ALL OF
YOUR CORPSE!
/Alt activate 404
}
/return
}
/if (${ChatText.Equal[avatar]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/tell ${ChatSender} ${SpellATK} is incomming to you ${ChatSender}!!!
/call cast ${SpellATK} gem4 4s
}
/return
}
/if (${ChatText.Equal[PR]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/tell ${ChatSender} ${SpellPR} is incomming to you ${ChatSender}!!!
/call cast ${SpellPR} gem4 4s
}
/return
}
/if (${ChatText.Equal[focus]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/tell ${ChatSender} ${SpellFOCUS} is incomming to you
${ChatSender}!!!
/call cast ${SpellFOCUS} gem5 5s
}
/return
}
/if (${ChatText.Equal[cha]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/tell ${ChatSender} ${SpellCHA} is incomming to you ${ChatSender}!!!
/call cast ${SpellCHA} gem5 5s
}
/return
}
/if (${ChatText.Equal[lev]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/tell ${ChatSender} ${SpellLEV} is incomming to you ${ChatSender}!!!
/call cast ${SpellLEV} gem5 5s
}
/return
}
/if (${ChatText.Equal[sow]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/tell ${ChatSender} ${SpellSOW} is incomming to you ${ChatSender}!!!
/call cast ${SpellSOW} gem5 5s
}
/return
}
/if (${ChatText.Equal[grow]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/tell ${ChatSender} ${SpellGROW} is incomming to you ${ChatSender}!!!
/call cast ${SpellGROW} gem5 5s
}
/return
}
/if (${ChatText.Equal[shrink]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/tell ${ChatSender} ${SpellSHRINK} is incomming to you
${ChatSender}!!!
/call cast ${SpellSHRINK} gem5 5s
}
/return
}
/if (${ChatText.Equal[see]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/tell ${ChatSender} ${SpellSEE} is incomming to you ${ChatSender}!!!
/call cast ${SpellSEE} gem5 5s
}
/return
}
/if (${ChatText.Equal[str]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/tell ${ChatSender} ${SpellSTR} is incomming to you ${ChatSender}!!!
/call cast ${SpellSTR} gem5 5s
}
/return
}
/if (${ChatText.Equal[dex]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/tell ${ChatSender} ${SpellDEX} is incomming to you ${ChatSender}!!!
/call cast ${SpellDEX} gem5 5s
}
/return
}
/if (${ChatText.Equal[sta]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/tell ${ChatSender} ${SpellSTA} is incomming to you ${ChatSender}!!!
/call cast ${SpellSTA} gem5 5s
}
/return
}
/if (${ChatText.Equal[agi]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/tell ${ChatSender} ${SpellAGI} is incomming to you ${ChatSender}!!!
/call cast ${SpellAGI} gem5 5s
}
/return
}
/if (${ChatText.Equal[regen]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/tell ${ChatSender} ${SpellREGEN} is incomming to you
${ChatSender}!!!
/call cast ${SpellREGEN} gem5 5s
}
/return
}
/if (${ChatText.Equal[pe]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/tell ${ChatSender} ${SpellPE} is incomming to you ${ChatSender}!!!
/call cast ${SpellPE} gem5 5s
}
/return
}
/if (${ChatText.Equal[ac]}) {
/target pc ${ChatSender}
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
/tell ${ChatSender} ${SpellAC} is incomming to you ${ChatSender}!!!
/call cast ${SpellPE} gem5 5s
}
/return
}
| ################# Follow me
/if (${ChatText.Equal[Follow me]} || ${ChatText.Equal[Follow]} ||
${ChatText.Equal[follow]} || ${ChatText.Equal[follow me]}) {
/delay 5
/if (!${Spawn[${ChatSender}].ID}) {
/e ${ChatSender} is not in zone for me to follow!
/return
}
/varset follname ${ChatSender}
/varset following 1
/tell ${ChatSender} I am following you!!!
/if ( ${Me.Mount.ID} ) /dismount
:targetfoll
/target pc ${follname}
/delay 1s ${Target.Name.Equal[${follname}]}
/if (${Target.Name.Equal[${follname}]}) {
/goto :Loop
} else /goto :targetfoll
:Loop
/face fast
/if (${Target.Distance}>40) /keypress forward hold
/if (${Target.Distance}<39) /keypress back
/if (!${Target.ID}) /varset following 0
/doevents
/if ((${Target.Name.Equal[${follname}]})&&(${following}>0)) {
/goto :Loop
} else {
/keypress forward
/keypress back
}
}
| ################# Stop Following me
/if (${ChatText.Equal[End follow]} || ${ChatText.Equal[stop]}) {
/varset following 0
/keypress forward
/keypress back
/timed 50 /face pc ${follname}
/tell ${ChatSender} I Stopped following you!!!
/return
}
| ################# Single Rebuff
/if (${ChatText.Equal[buff me]}) {
/echo Request for Single Buff
/target pc ${ChatSender}
/delay 3
/tell ${ChatSender} buffing ${SpellHASTE} now...
/call Cast_HASTE
/declare i int local 1
/for i 1 to ${SpellSingleBuff.Size}
/if (${Spell[${SpellSingleBuff[${i}]}].Mana} > ${Me.CurrentMana}) {
/tell ${ChatSender} ${ChatSender} Sorry I am getting LOM
/echo DAMN.. LOM... Cannibalizing to rebuff
:Hold_Single_Rebuff
/Call LOM
/if (${Spell[${SpellSingleBuff[${i}]}].Mana} > ${Me.CurrentMana}) {
/goto :Hold_Single_Rebuff
}
}
/target pc ${ChatSender}
/delay 3
/echo *** Hang on ! Buffing ${SpellSingleBuff[${i}]}
/tell ${ChatSender} Buffing ${SpellSingleBuff[${i}]} now...
/call cast ${SpellSingleBuff[${i}]} gem5 5s
/next i
/return
}
| ################# Single Rebuff other
/if (${ChatText.Equal[buff]}) {
/echo Request for Single Buff other
/assist ${ChatSender}
/tell ${ChatSender} buffing ${SpellHASTE} now...
/call Cast_HASTE
/declare i int local 1
/for i 1 to ${SpellSingleBuff.Size}
/if (${Spell[${SpellSingleBuff[${i}]}].Mana} > ${Me.CurrentMana}) {
/tell ${ChatSender} ${ChatSender} Sorry I am getting LOM
/echo DAMN.. LOM... Cannibalizing to rebuff
:Hold_Single_Rebuff
/Call LOM
/if (${Spell[${SpellSingleBuff[${i}]}].Mana} > ${Me.CurrentMana}) {
/goto :Hold_Single_Rebuff
}
}
/delay 3
/echo *** Hang on ! Rebuffing ${SpellSingleBuff[${i}]}
/tell ${ChatSender} Buffing ${SpellSingleBuff[${i}]} now...
/call cast ${SpellSingleBuff[${i}]} gem5 7s
/next i
/return
}
| ################# Group Rebuff other group
/if (${ChatText.Equal[buff them]}) {
/assist ${ChatSender}
/declare i int local 1
/for i 1 to ${SpellGrpBuff.Size}
/if (${Spell[${SpellGrpBuff[${i}]}].Mana} > ${Me.CurrentMana}) {
/tell ${ChatSender} ${ChatSender}, Sorry I am getting LOM
/echo DAMN.. LOM... Cannibalizing to rebuff
:Hold_Group_Rebuff
/Call LOM
/if (${Spell[${SpellGrpBuff[${i}]}].Mana} > ${Me.CurrentMana}) {
/goto :Hold_Group_Rebuff
}
}
/delay 3
/echo *** Hang on ! Rebuffing ${SpellGrpBuff[${i}]}
/tell ${ChatSender} Buffing ${SpellGrpBuff[${i}]} now...
/call cast ${SpellGrpBuff[${i}]} gem5 7s
/next i
/return
}
| ################# Other Pet Buffing
/if (${ChatText.Equal[buff pet]}) {
/echo Request for Pet Buffs
/target id ${Spawn[pc ${ChatSender}].Pet.ID}
/delay 3
/tell ${ChatSender} Targetting your pet, %T for buffs...
/tell ${ChatSender} buffing ${SpellHASTE} now...
/call Cast_HASTE
/declare i int local 1
/for i 1 to ${SpellPetBuffo.Size}
/if (${Spell[${SpellPetBuffo[${i}]}].Mana} > ${Me.CurrentMana}) {
/tell ${ChatSender} ${ChatSender} Sorry I am getting LOM
/echo DAMN.. LOM... Cannibalizing to rebuff
:Hold_Pet_Rebuff
/Call LOM
/if (${Spell[${SpellPetBuffo[${i}]}].Mana} > ${Me.CurrentMana}) {
/goto :Hold_Pet_Rebuff
}
}
/delay 3
/echo *** Hang on ! Rebuffing ${SpellPetBuffo[${i}]}
/tell ${ChatSender} buffing ${SpellPetBuffo[${i}]} now...
/call cast ${SpellPetBuffo[${i}]} gem5 5s
/next i
/return
}
| ################### Go Home
/if (${ChatText.Equal[gate now]} && ${ChatType.Equal[TELL]}) {
/call cast ${SpellGATE} gem9
/return
}
/if (${ChatType.Equal[TELL]}) {
/1 HUH?????
/1 ${ChatText}
/1 HUH?????
/return
}
/return
| ################### Refresh spell if worn off and in RefreshThisBuff array
Sub Event_Worn_off(string Line, string myspell, string mytarget)
/declare oldt string local
/declare i int local 1
/declare j int local 1
/echo ${myspell} on ${mytarget} has worn off
/for i 1 to ${RefreshThisBuff.Size}
/if (${myspell.Equal[${RefreshThisBuff[${i}]}]}) {
/varset oldt ${Target.ID}
/target ${mytarget}
/delay 5
/if (${Target.CleanName.Equal[${mytarget}]}) {
/if (${myspell.Equal[${SpellDeBuff}]} && ${Target.Type.Equal[NPC]}) {
/for j 1 to ${TargetDebuff.Size}
/if (${Target.ID}==${TargetDebuff[${j}]}) {
/echo removing ${TargetArray[1]}[${TargetArray[4]}] from Debuff
Array
/varset TargetDebuff[${j}] NULL
/varset MobMaloed FALSE
/call DeBuff
/target id ${oldt}
/delay 5
/return
}
/next j
} else /if (${myspell.Equal[${SpellSlow}]} && ${Target.Type.Equal[NPC]}) {
/for j 1 to ${TargetSlow.Size}
/if (${Target.ID}==${TargetSlow[${j}]}) {
/echo removing ${TargetArray[1]}[${TargetArray[4]}] from Slow Array
/varset TargetSlow[${j}] NULL
/varset MobSlowed FALSE
/call Slow
/target id ${oldt}
/delay 5
/return
}
/next j
} else /if (${myspell.Equal[${SpellHASTE}]}) {
/tell ${mytarget} ${SpellHASTE} is incomming to you ${mytarget}!!!
/call Cast_HASTE
} else {
|- no rebuffing below here if fighting or have group buffs enabled
/if (${Engaged} || ${DoBuffs}) /return
:Hold_cast_Rebuff
/Call LOM
/if (${Spell[${myspell}].Mana} > ${Me.CurrentMana}) {
/goto :Hold_cast_Rebuff
}
/if ( !${Me.Gem[${myspell}]} ) {
/memspell 5 "${myspell}"
/delay 20
}
/tell ${mytarget} rebuffing ${myspell} now... Please stay in range!
/delay 1
/call cast "${myspell}" gem5 5s
}
/target id ${oldt}
/delay 5
/return
} else {
/echo Unable to target ${mytarget} to refresh ${myspell}!!
/1 Unable to target ${mytarget} to refresh ${myspell}!!
/target id ${oldt)
/delay 5
/return
}
}
/next i
/return
| ################### This will check whenever the player is changing any variable
via /echo
Sub Event_ToggleVariable(string Line, string Command, string Command2)
/if (${Command.Equal[malo]} && ${DoMalo}==0) {
/varset DoMalo TRUE
/echo Do Malo: ${DoMalo}
} else /if (${Command.Equal[malo]}) {
/varset DoMalo FALSE
/echo Do Malo: ${DoMalo}
}
/if (${Command.Equal[slow]} && ${DoSlow}==0) {
/varset DoSlow TRUE
/echo Do Slow: ${DoSlow}
} else /if (${Command.Equal[slow]}) {
/varset DoSlow FALSE
/echo Do Slow: ${DoSlow}
}
/if (${Command.Equal[fastslow]} && ${FastSlow}==0) {
/varset FastSlow TRUE
/echo Do Fast Slow: ${FastSlow}
} else /if (${Command.Equal[fastslow]}) {
/varset FastSlow FALSE
/echo Do Fast Slow: ${FastSlow}
}
/if (${Command.Equal[root]} && ${DoRoot}==0) {
/varset DoRoot TRUE
/echo Do Root: ${DoRoot}
} else /if (${Command.Equal[root]}) {
/varset DoRoot FALSE
/echo Do Root: ${DoRoot}
}
/if (${Command.Equal[pet]} && ${SummonPet}==0) {
/varset SummonPet TRUE
/echo Summon Pet: ${SummonPet}
} else /if (${Command.Equal[pet]}) {
/varset SummonPet FALSE
/echo Summon Pet: ${SummonPet}
}
/if (${Command.Equal[dot]} && ${DoDoT}==0) {
/varset DoDoT TRUE
/echo Do DoT: ${DoDoT}
} else /if (${Command.Equal[dot]}) {
/varset DoDoT FALSE
/echo Do DoT: ${DoDoT}
}
/if (${Command.Equal[buffs]} && ${DoBuffs}==0) {
/varset DoBuffs TRUE
/echo Do Buffs: ${DoBuffs}
} else /if (${Command.Equal[buffs]}) {
/varset DoBuffs FALSE
/echo Do Buffs: ${DoBuffs}
}
/if (${Command.Equal[sow]} && ${DoSow}==0) {
/varset DoSow TRUE
/echo Do Sow: ${DoSow}
} else /if (${Command.Equal[sow]}) {
/varset DoSow FALSE
/echo Do Sow: ${DoSow}
}
/if (${Command.Equal[nuke]} && ${DoNuke}==0) {
/varset DoNuke TRUE
/echo Do Nuke: ${DoNuke}
} else /if (${Command.Equal[nuke]}) {
/varset DoNuke FALSE
/echo Do Nuke: ${DoNuke}
}
/if (${Command.Equal[heal]} && ${DoHeal}==0) {
/varset DoHeal TRUE
/echo Do Heal: ${DoHeal}
} else /if (${Command.Equal[heal]}) {
/varset DoHeal FALSE
/echo Do Heal: ${DoHeal}
}
/if (${Command.Equal[panther]} && ${DoPanther}==0) {
/varset DoPanther TRUE
/echo Do Panther: ${DoPanther}
} else /if (${Command.Equal[panther]}) {
/varset DoPanther FALSE
/echo Do Panther: ${DoPanther}
}
/if (${Command.Equal[shrink]} && ${DoShrink}==0) {
/varset DoShrink TRUE
/echo Do Shrink: ${DoShrink}
} else /if (${Command.Equal[shrink]}) {
/varset DoShrink FALSE
/echo Do Shrink: ${DoShrink}
}
/if (${Command.Equal[avatar]} && ${DoAvatar}==0) {
/varset DoAvatar TRUE
/echo Do Avatar: ${DoAvatar}
} else /if (${Command.Equal[avatar]}) {
/varset DoAvatar FALSE
/echo Do Avatar: ${DoAvatar}
}
/if (${Command.Equal[panthergroup]} && ${DoPantherGROUP}==0) {
/varset DoPantherGROUP TRUE
/echo Panther Group: ${DoPantherGROUP}
} else /if (${Command.Equal[panthergroup]}) {
/varset DoPantherGROUP FALSE
/echo Panther Group: ${DoPantherGROUP}
}
/if (${Command.Equal[verbose]} && ${Verbose}==0) {
/varset Verbose TRUE
/echo Verbose: ${Verbose}
} else /if (${Command.Equal[verbose]}) {
/varset Verbose FALSE
/echo Verbose: ${Verbose}
}
/if (${Command.Equal[buffpet]} && ${BuffPet}==0) {
/varset BuffPet TRUE
/echo Buff Pet: ${BuffPet}
} else /if (${Command.Equal[buffpet]}) {
/varset BuffPet FALSE
/echo Buff Pet: ${BuffPet}
}
/if (${Command.Equal[assistat]}) {
/varset AssistAt ${Command2}
/echo Assisting at range: ${AssistAt} _ (Longer range then 100 is futile)
}
/if (${Command.Equal[dotat]}) {
/varset CastDoTat ${Command2}
/echo Casting ${SpellDoT} at ${CastDoTat}%
}
/if (${Command.Equal[rootat]}) {
/varset Rootat ${Command2}
/echo Rooting Mobs at ${Rootat}%
}
/if (${Command.Equal[nukeat]}) {
/varset NukeAt ${Command2}
/echo Starting to Nuke Mobs at ${NukeAt}%
}
/if (${Command.Equal[combatat]}) {
/varset CombatAt ${Command2}
/echo Initiate Combat at ${CombatAt}% (Malo / Slow)
}
/if (${Command.Equal[healtankat]}) {
/varset TankHeal ${Command2}
/echo Healing ${M_Assist} at ${TankHeal}%
}
/if (${Command.Equal[healmeleeat]}) {
/varset MeleeHeals ${Command2}
/echo Healing all Melee classes at ${MeleeHeals}%
}
/if (${Command.Equal[healcastersat]}) {
/varset CasterHeals ${Command2}
/echo Healing all Caster classes at ${CasterHeals}%
}
/if (${Command.Equal[assist]}) {
/squelch /target pc ${M_Assist}
/if (!${Target.ID}) {
/echo ${M_Assist} is not here dude !
/return
}
/varset M_Assist ${Command2}
/echo I will assist: ${M_Assist}
}
/if (${Command.Equal[healat]}) {
/varset HealGRPat ${Command2}
/echo Healing any group member below ${HealGRPat}% HPs
}
/if (${Command.Equal[Show]}) {
/echo ---------------------------
/echo Do Malo:..............${DoMalo} - Casting at: ${CombatAt}% (Initiate
Combat*, higher then 99 is no good)
/echo Do Slow:..............${DoSlow} - Casting at: ${CombatAt}% (Initiate
Combat*, higher then 99 is no good)
/echo Do Fastslow:..........${FastSlow} - (Will only try to slow once!)
/echo Do Nuke:..............${DoNuke} - Casting at: ${NukeAt}% (Will chain
nuke mob to death)
/echo Do Dot:...............${DoDoT} - Casting at: ${CastDoTat}%
/echo Do Pet:...............${SummonPet}
/echo Do Buffs:.............${DoBuffs}
/echo Do Root:..............${DoRoot} - Casting at: ${Rootat}%
/echo Do Sow:...............${DoSow}
/echo Do Heal:..............${DoHeal}
/echo Buff Pet:.............${BuffPet}
/echo Do Avatar:............${DoAvatar} - Casts ${SpellATK} on melee members
of group during combat
/echo Do Shrink:............${DoShrink}
/echo Do Panther:...........${DoPanther} - Cast ${SpellPanther} on DogDog
during combat
/echo Panther Group:........${DoPantherGROUP} - Casts ${SpellPanther} on
melee members of group during combat
/echo ---------------------------
/echo Assist range: ${AssistAt}
/echo Assisting: ${M_Assist}
/echo Healing Casters: ${CasterHeals}% Melees: ${MeleeHeals}%
/echo ${M_Assist} get heals at ${TankHeal}
/echo Initiate Combat: ${CombatAt}%
/echo Verbose: ${Verbose}
/echo
/echo help - Will show help to set variables.
}
/if (${Command.Equal[help]}) {
/echo ___ Shaman Do Stuff Script ___
/echo
/echo Commands that will turn ON or OFF
/echo malo, slow, fastslow, root, pet, dot, buffs, sow, nuke, heal, buffpet,
panther, panthergroup, avatar, shrink
/echo
/echo fastslow will NOT check if the slow is landed or not. Good to have on
when you skip maloing.
/echo Commands to change values, ie: assistat 50 (Will start the combat
routine when mob is in range 50)
/echo assisat <range> - Most spells don't go longer then 100
/echo combatat <% hps> - Initiate Combat when mob is at % HPs
/echo healtankat <% hps>
/echo healmeeleat <% hps>
/echo healcastersat <% hps>
/echo assist <PC Name>
}
/returnI am trying to add the Time's Antithsis as the slow and the Pendant of Malosini for the Malo but all I keep getting is cannot find item or Time's Antithsis not found in spell book.
Could anyone shedd some light on to has I should be adding it in. I had added a declare for a clicky slow but i lack the knowhow to make it work. I have below basic knowledge of writing macros and after 3 days I cant go on anymore heh.
If anyone knows how I can add this in it would be much appreciated.
