• You've discovered RedGuides 📕 an EverQuest multi-boxing community 🛡️🧙🗡️. We want you to play several EQ characters at once, come join us and say hello! 👋
  • IS THIS SITE UGLY? Change the look. To dismiss this notice, click the X --->

Request for Macro (shaman) (1 Viewer)

Easy_Moder

New member
Joined
Jan 26, 2005
RedCents
Hey, I'm looking for a rather complicated macro. I've got a low lvl shaman I am leveling with. I would love a macro that automates him. I've looked on MQ2 forums, and a lot of them are for 65+. It looks like it would take too much tweaking of which I am not knowledgable enough to do.
What I'd love is this:
Malos - Slows - pet attacks - DoT - Heal any member(or just MT if not possible) - Canni
Any help is apperciated. I do not need anything with buffs. I would rather do that on my own to save his mana.
 
Easy_Moder said:
Hey, I'm looking for a rather complicated macro. I've got a low lvl shaman I am leveling with. I would love a macro that automates him. I've looked on MQ2 forums, and a lot of them are for 65+. It looks like it would take too much tweaking of which I am not knowledgable enough to do.
What I'd love is this:
Malos - Slows - pet attacks - DoT - Heal any member(or just MT if not possible) - Canni
Any help is apperciated. I do not need anything with buffs. I would rather do that on my own to save his mana.
Ok, all i need are the names of all of your spells so i can change the macro that i have.
Slow spell:
Dot spell:
Pet Spell:
Debuff spell:
Cannibilization spell:
Heal over time spell:
Fast Heal spell:
root (if you want to root):
nuke spell (if you want to nuke)
 
Easy_Moder said:
slow spell: walking sleep
Dot spell: Affliction
Pet spell: Don't have it yet
Debuff: Malaise
Canni: Cannibalize
Heal: Healing
nuke: frost strike
Ok, i think i took everything out for the HoT spells here's the macro

Rich (BB code):
|__________________ Shaman Do Stuff Script _____________________| 
| 
| Version: v0.7.2 
| Release Date: 2004-11-09 
|___________________________________________________Hubba_______| 
| 
| Usage: 
| 1. Target player you like to assist (main tank is good) 
| 2. Start the script with: /mac <scriptname> 
| 
| Use "help" for more help ( ! help is incomplete ! ) 
|_______________________________________________________________| 

| -!- This Script Uses spell_routines.inc by Rusty 
| -!- Exptrack snippet from exptracker.mac by Raebis, with tweaks from Phoenix 
| -!- Wait4Rez snippet from wait4rez.mac by fantum409 

#chat group 
#chat tell 

#Event ToggleVariable "[MQ2] Toggle #1#" 
#Event ToggleVariable "[MQ2] Toggle #1# #2#" 
#Event OutDoor "#*#outdoors#*#" 
#Event NoMount "You can not summon a mount here." 
#Event ImDead "You have been slain by#*#" 
#Event Invited "#*#To join the group, click on the 'FOLLOW' option, or 'DISBAND' to 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 , root 
| Gem6 = Heal 
| Gem7 = HoT 
| Gem8 = DoT, Nuke 

| ########### 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 

| The % of your spell duration bonus. I have 30% from AAs and 15% from item. 
/declare SpellDurationBonus outer 45 

|- If you have no focus item, leave it blank. Ring of Firewarding is a 15% spell duration up to 

65spells. 
/declare BuffFocusItem outer  

/declare SpellSlow outer "Walking Sleep" 
/declare SpellDoT outer "Affliction" 
/declare SpellPet outer "True Spirit" 
/declare SpellDeBuff outer "Malaise" 
/declare SpellCanni outer "Cannibalize" 
/declare SpellHoT outer "None" 
/declare SpellHeal outer "Healing" 
/declare SpellRoot outer "None" 
/declare SpellNuke outer "Frost Strike" 
/declare SpellATK outer "None" 
/declare Mount outer "None" 

/declare SpellPetBuff[3] string outer 
/varset SpellPetBuff[1] "Celerity" 
/varset SpellPetBuff[2] "Strength of the Diaku" 
/varset SpellPetBuff[3] "Ferine Avatar" 

| ############ The Magic of single spell buffs... 
| ############ 
| ############ /declare SpellBuff[2,2] string outer 
| ############ Do only change the 1st number in [#,#] 
| ############ If you have three single spells to cast change the 1st number to 3. 
| ############ /declare SpellBuff[3,2] string outer 
| ############ 
| ############ /varset SpellBuff[1,1] "Spirit of Sense" 
| ############ This is the 1st line that is needed, Here you write your spell name 
| ############ /varset SpellBuff[1,2] "Warrior,Monk,Cleric,Shaman,Enchanter," 
| ############ The 2nd line is for the classes who gets the buff. 
| ############ NOTE: Only classes in group will get buffed 
| ############ NOTE: End the class line with a , If not you can BLOW up your computer. ;P 

| Turn on or off Single buffs here. 
/declare DoSingleBuffs outer FALSE 

/declare SpellBuff[2,2] string outer 

/varset SpellBuff[1,1] "Spirit of Sense" 
/varset SpellBuff[1,2] "Warrior,Monk,Cleric,Shaman,Enchanter," 

/varset SpellBuff[2,1] "Levitation" 
/varset SpellBuff[2,2] "Monk," 

| ############ Group buffs... 

/declare SpellGrpBuff[4] string outer 
/varset SpellGrpBuff[1] "Blessing of Replenishment" 
/varset SpellGrpBuff[2] "Focus of the Seventh" 
/varset SpellGrpBuff[3] "Talisman of the Wrulan" 
/varset SpellGrpBuff[4] "Talisman of the Boar" 

/declare AssistAt int outer 100 
/declare CombatAt int outer 99 
/declare CastDoTat int outer 99 
/declare Rootat int outer 30 
/declare NukeAt int outer 90 
/declare CasterHeals int outer 90 
/declare MeleeHeals int outer 75 
/declare TankHeal int outer 45 

/declare DoMalo outer TRUE 
/declare DoSlow outer TRUE 
/declare FastSlow outer FALSE 
/declare DoRoot outer FALSE 
/declare SummonPet outer False
/declare BuffPet outer FALSE
/declare DoDoT outer TRUE 
/declare DoBuffs outer TRUE 
/declare DoSow outer TRUE 
/declare DoNuke outer FALSE 
/declare DoHeal outer TRUE 
/declare Cannibalization outer FALSE 
/declare Verbose outer FALSE 

| This is a delay for how long Avatar will hold. (8min) 
/declare AvatarDelay outer 5350 

| ########### ! No Changes From Here Is 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 

/declare M_Assist string outer 
/declare OutDoors outer TRUE 
/declare NoMount outer TRUE 

/declare SpDuration outer 
/declare SpCastTime outer 
/declare SpDurBonus outer 

/declare MainItem outer 

/declare MeLoM outer FALSE 

/declare TargetArray[4] string outer 
/declare MobMaloed outer FALSE 
/declare MobSlowed outer FALSE 
/declare PetOn outer FALSE 
/declare MobRooted outer FALSE 
/declare MobDoTed outer FALSE 
/declare CombatOn outer FALSE 

/declare i int local 
/for i 1 to ${SpellBuff.Size[1]} 
/declare SpellBufftmr${i}0 timer outer 0 
/declare SpellBufftmr${i}1 timer outer 0 
/declare SpellBufftmr${i}2 timer outer 0 
/declare SpellBufftmr${i}3 timer outer 0 
/declare SpellBufftmr${i}4 timer outer 0 
/declare SpellBufftmr${i}5 timer outer 0 
/next i 

/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 

/declare CallManaTmr timer outer 0 

/call MemSpells 

| ############### Target a player as Main Assist 

/if (!${Target.ID} || ${Target.Type.NotEqual[PC]}) { 
/echo Your target is NOT a player, make sure its a player character! 
/endmacro 
} else { 
/varset M_Assist ${Target.CleanName} 
/echo Assist set to ${M_Assist} 
/assist off 
} 

:Main_Loop 

|- Summon drogmore 
/if (!${Me.Mount.ID} && ${OutDoors} && !${NoMount}) /call cast ${Mount} item 4s 

|- Check for new events in chat etc etc... 
/doevents 

|- Do we move? 
:Hold_Main 
/if (${Me.Moving}) /goto :Hold_Main 

|- Pet 
/if (!${Me.Pet.ID} && ${SummonPet} && ${Spell[${SpellPet}].Mana} <= ${Me.CurrentMana}) /call cast 

${SpellPet} gem5 25s 
/if (${Me.Pet.ID} && ${BuffPet}) /call BuffPet 

|- Sow Buff 
/if (!${Me.Buff[Spirit of Eagle].ID} && !${Me.Buff[Flight of Eagles].ID}) /if (!${Me.Buff[Spirit 

of Bih`Li].ID} && ${DoSow} && ${OutDoors}) { 
/call EquipItem ${BuffFocusItem} 
/varset MainItem ${Macro.Return} 
/target pc ${M_Assist} 
/call cast "Spirit of Bih`Li" gem5 17s 
/call EquipItem ${MainItem} 
} 

|- Canni 
|/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} > 3200) /call Cannibalization 

|- Let the group know Im LOM 
/if (${Me.PctMana} < 20 && !${CallManaTmr}) { 
/gsay ${Me.PctMana}% Mana 
/varset CallManaTmr 300 
} 

|- Single Buff ! 
/if (${DoSingleBuffs}) /call SingleBuffs 

|- Am I LoM? 
/if (${Me.PctMana} < 25) /varset MeLoM TRUE 
/if (${MeLoM}) /if (${Me.PctMana} > 35) /varset MeLoM FALSE 

|- Group Buffs 
/if (${DoBuffs}) /call GrpBuffs 
/if (${Me.SpellReady[${SpellATK}]}) /call Cast_Avatar 

|- Group Heals 
/call Check_grpHPs 

|- Check for mobs and do combat stuff 
/call GetTarget 
/if (${CombatOn}) /call Combat 

/if (${Me.State.Equal[Stand]}) /sit 

/goto :Main_Loop 
/return 

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[${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 ( ${Window[SpellBookWnd].Open} ) /windowstate SpellBookWnd close 
/echo Spells are memmed. 

/return 

| ################# This will check what Main Assist has in 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 
} 
/return 

| ################### Check target and do stuff like slow, dot, pet attack etc. 

Sub Combat 

/if (${CombatOn} && !${MobMaloed} && ${DoMalo} && ${Target.ID}==${TargetArray[4]}) /call DeBuff 
/if (${CombatOn} && !${MobSlowed} && ${DoSlow} && ${Target.ID}==${TargetArray[4]}) /call Slow 

/if (${CombatOn} && !${PetOn} && ${Target.ID}==${TargetArray[4]}) { 
/pet attack 
/varset PetOn TRUE 
} 

/if (!${MeLoM} && ${CombatOn} && ${DoDoT} && !${MobDoTed} && ${Target.PctHPs}<=${CastDoTat}) { 
/call cast ${SpellDoT} gem8 
/varset MobDoTed TRUE 
} 

/if (${CombatOn} && ${DoNuke} && ${Target.PctHPs}<=${NukeAt}) { 
/call cast ${SpellNuke} gem8 
} 

/if (!${ModRooted} && ${CombatOn} && ${DoRoot} && ${Target.PctHPs}<=${RootAt}) { 
/call cast ${SpellRoot} gem5 
/varset MobRooted TRUE 
} 

|- EndCombat 

/target ${TargetArray[3]} 

/if (!${Target.Name.Equal[${TargetArray[3]}]} || !${Target.ID}) { 
/echo ${TargetArray[1]} is dead 
/varset MobRooted FALSE 
/varset MobMaloed FALSE 
/varset MobSlowed FALSE 
/varset PetOn FALSE 
/varset MobDoTed FALSE 
/varset CombatOn FALSE 

/varset TargetArray[1] NULL 
/varset TargetArray[2] NULL 
/varset TargetArray[3] NULL 
/varset TargetArray[4] NULL 

/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 

Sub DeBuff 
: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 6s 
/if (${Macro.Return.Equal["CAST_INTERRUPTED"]}) /goto :DeBuff_Loop 
/varset MobMaloed TRUE 
} 
} 
/return 

Sub Slow 
/if (${Target.PctHPs}<=${CombatAt} && ${Target.ID}==${TargetArray[4]}) { 
/if (${Me.CurrentMana}<${Spell[${SpellSlow}].Mana}) { 
/echo Shid ! I don't have mana to Malo %T 
} else { 
:Slow_Loop 
/call cast ${SpellSlow} gem2 6s 
/if (${Macro.Return.Equal["CAST_INTERRUPTED"]}) /goto :Slow_Loop 
/if (${Macro.Return.Equal["CAST_IMMUNE"]}) { 
/if (${Verbose}) /gsay *** %T is IMMUNE to my slow ! 

/varset MobSlowed TRUE 
} 
/if (${Macro.Return.Equal["CAST_RESISTED"]}) { 
/if (!${FastSlow}) { 
/if (${Verbose}) /gsay *** %T RESISTED slow ! Trying again asap 
/goto :Slow_Loop 
} 
/varset MobSlowed TRUE 
} 
/if (${Macro.Return.Equal["CAST_SUCCESS"]}) { 
/if (${Verbose}) /gsay *** %T is SLOWED 
/varset MobSlowed TRUE 
} 

} 
} 
/return 


| ################### Buff the group with buffs from the SpellGrpBuff array 
| ################### It will NOT cast any singel target spells 

Sub GrpBuffs 
/declare i int local 1 
/for i 1 to ${SpellGrpBuff.Size} 
/if (${Spell[${SpellGrpBuff[${i}]}].Mana} > ${Me.CurrentMana}) /return 
/if ( !${Me.Buff[${SpellGrpBuff[${i}]}].ID} ) { 
/target pc ${M_Assist} 
/delay 1s ${Target.ID} 
/echo *** Hang on ! Rebuffing ${SpellGrpBuff[${i}]} 
/call EquipItem ${BuffFocusItem} 
/varset MainItem ${Macro.Return} 
/call cast ${SpellGrpBuff[${i}]} gem5 5s 
/call EquipItem ${MainItem} 
} 
/next i 
/return 

|################### Check if any group member needs heal 

Sub Check_grpHPs 
/declare i int local 1 

/for i 1 to ${Group} 

/if (${Group[${i}].Class.Name.Equal[Cleric]} || ${Group[${i}].Class.Name.Equal[Druid]} || 

${Group[${i}].Class.Name.Equal[Wizard]} || ${Group[${i}].Class.Name.Equal[Magician]} || 

${Group[${i}].Class.Name.Equal[Necromancer]} || ${Group[${i}].Class.Name.Equal[Enchanter]}) /if 

(${Group[${i}].PctHPs}<=${CasterHeals}) { 
/target pc ${Group[${i}]} 
/if (${Me.CurrentMana}<${Spell[${SpellHeal}].Mana}) { 
/echo *** Shid ! I don't have mana to heal ${Group[${i}]} 
} else /if (${Target.Distance}<=100) { 
/if (${Verbose}) /gsay *** ${SpellHeal} on %T 
/call cast ${SpellHeal} gem6 4s 
} 
} 

/if (${Group[${i}].Class.Name.Equal[Warrior]} || ${Group[${i}].Class.Name.Equal[Monk]} || 

${Group[${i}].Class.Name.Equal[Rouge]} || ${Group[${i}].Class.Name.Equal[Ranger]} || 

${Group[${i}].Class.Name.Equal[Beast]} || ${Group[${i}].Class.Name.Equal[Shadow Knight]} || 

${Group[${i}].Class.Name.Equal[Paladin]}) /if (${Group[${i}].PctHPs}<=${MeleeHeals} && 

${Group[${i}].Name.NotEqual[${M_Assist}]}) { 
/target pc ${Group[${i}]} 
/if (${Me.CurrentMana}<${Spell[${SpellHeal}].Mana}) { 
/echo *** Shid ! I don't have mana to heal ${Group[${i}]} 
} else /if (${Target.Distance}<=100) { 
/if (${Verbose}) /gsay *** ${SpellHeal} on %T 
/call cast ${SpellHeal} gem6 4s 
} 
} 

/if (${Group[${i}].Name.Equal[${M_Assist}]}) /if (${Group[${i}].PctHPs}<=${TankHeal}) { 
/target pc ${Group[${i}]} 
/if (${Me.CurrentMana}<${Spell[${SpellHeal}].Mana}) { 
/echo *** Shid ! I don't have mana to heal ${Group[${i}]} 
} else /if (${Target.Distance}<=100) { 
/if (${Verbose}) /gsay *** ${SpellHeal} on %T 
/call cast ${SpellHeal} gem6 4s 
} 
} 

/next i 
/return 

| ################## Canni 5 

Sub Cannibalization 

|/call CheckMyHPs 
/if ${Me.PctHPs} > ${CanniPct}) { 
/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 1s ${Me.ID}==${Target.ID} 
/if (!${Me.Buff[${SpellHoT}].ID} && ${Target.ID}==${Me.ID}) /call cast ${SpellHoT} gem7 3s 
} 

/return 

| ################## Buff pet with spells from SpellPetBuff array 

Sub BuffPet 

/declare i int local 
/for i 1 to ${SpellPetBuff.Size} 
/if (!${Me.PetBuff[${SpellPetBuff[${i}]}]} && ${Spell[${SpellPetBuff[${i}]}].Mana} <= 

${Me.CurrentMana}) { 
/pet target 
/delay 1s ${Me.Pet.ID}==${Target.ID} 
/call EquipItem ${BuffFocusItem} 
/varset MainItem ${Macro.Return} 
/call cast ${SpellPetBuff[${i}]} gem5 9s 
/call EquipItem ${MainItem} 
} 
/next i 
/return 

|################### Casting Avatar on all melee classes in group 

Sub Cast_Avatar 

/declare i int local 0 
/for i 0 to ${Group} 
/if (${Group[${i}].ID}) { 
/if (${ATKBuffed${i}}==0) /if (${Group[${i}].Class.Name.Equal[Beastlord]} || 

${Group[${i}].Class.Name.Equal[Shadow Knight]} || ${Group[${i}].Class.Name.Equal[Bard]} || 

${Group[${i}].Class.Name.Equal[Ranger]} || ${Group[${i}].Class.Name.Equal[Rogue]} || 

${Group[${i}].Class.Name.Equal[Paladin]} || ${Group[${i}].Class.Name.Equal[Monk]} || 

${Group[${i}].Class.Name.Equal[Warrior]}) { 
/target pc ${Group[${i}]} 
/delay 1s ${Group[${i}].ID}==${Target.ID} 
/if (${Me.CurrentMana}>${Spell[${SpellATK}].Mana}) { 
/call EquipItem ${BuffFocusItem} 
/varset MainItem ${Macro.Return} 
/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}' 
/call EquipItem ${MainItem} 
/return 
} 
} 
} 
/next i 
/return 

| #################### The Single boofs stuff routine kinda 
| Im sure there is a better way to do this. 
| But this is what I could crackup at work. 

Sub SingleBuffs 

/declare i int local 1 
/declare g int local 0 
/declare h int local 1 
/declare Classes int local 0 
/for i 1 to ${SpellBuff.Size[1]} 
/if (${Spell[${SpellBuff[${i}]},1].Mana} > ${Me.CurrentMana}) /return 
/varset Classes ${String[${SpellBuff[${i},2]}].Count[,]} 
/for g 0 to ${Group} 
/if (${SpellBufftmr${i}${g}}) /next g 
/for h 1 to ${Classes} 
/if (${Group[${g}].Class.Name.Equal[${String[${SpellBuff[${i},2]}].Arg[${h},,]}]}) { 
/target pc ${Group[${g}]} 
/delay 1s ${Target.ID}==${Group[${g}].ID} 
/call SpellInformation ${SpellBuff[${i},1]} 
/call EquipItem ${BuffFocusItem} 
/varset MainItem ${Macro.Return} 
/call cast ${SpellBuff[${i},1]} gem5 ${SpCastTime} 
/varset SpellBufftmr${i}${g} ${SpDuration} 
/call EquipItem ${MainItem} 
/return 
} 
/next h 
/next g 
/next i 
/return 

| ################### Get some information of the spell to be used. 

Sub SpellInformation(string SpellName) 

/varset SpDurBonus ${Math.Calc[${SpellDurationBonus}/100+1]} 

/varset SpDuration ${Math.Calc[${Spell[${SpellName}].Duration}/10*60*${SpDurBonus}]} 
/varset SpCastTime ${Math.Calc[${Spell[${SpellName}].CastTime}*10].Int} 

/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: ${DoNuke} 
} else /if (${Command.Equal[heal]}) { 
/varset DoHeal FALSE 
/echo Do Heal: ${DoNuke} 
} 

/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]}) { 
/varset M_Assist ${Command2} 

/sq /target pc ${M_Assist} 
/if (!${Target.ID}) { 
/echo ${M_Assist} is not here dude ! 
/return 
} 

/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 --------------------------- 
/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 
/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> 
} 

/return 

| 

##################################################################################################

#### 

Sub Event_OutDoor 

/echo This is an indoor zone. Sorry. 
/varset OutDoors FALSE 

/return 

| 

##################################################################################################

#### 

Sub Event_NoMount 

/echo No mount in this zone. Sorry. 
/varset NoMount TRUE 

/return 

| 

##################################################################################################

#### 

Sub Event_Invited 
/invite 
/return 

| ################## 

Sub Event_ImDead 

/echo Bummer ! 
:Zone_Loop 
/if ( ${Me.Bound.ID} != ${Zone.ID} ) /goto :Zone_Loop 
/delay 5s 
/consent group 
/delay 5 
/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 


| ################## This part is taken from wait4res. 

Sub Wait4Rez 

:waitforrez 
/if (!${Window[ConfirmationDialogBox].Open}) { 
/delay 5s ${Window[ConfirmationDialogBox].Open} 
/goto :waitforrez 
} 
/if (${Window[ConfirmationDialogBox].Open}) /notify ConfirmationDialogBox Yes_Button leftmouseup 
:zonein 
/delay 5 
/squelch /target mycorpse 
/delay 5 
/if (${Target.CleanName.NotEqual[${Me}'s corpse]}) /goto :zonein 
/if (${Target.CleanName.Equal[${Me}'s corpse]}) { 
/delay 3s 
/call Loot_Corpse 
} else /goto :zonein 

/return 

Sub Loot_Corpse 

/declare LootTotal int local 0 
/declare LootSlot int local 

/squelch /target mycorpse 
/if (${Target.Type.NotEqual[CORPSE]} || !${Target.ID}) { 
/echo ** Can't target my corpse. 
/return 
} 
/corpse 
/delay 1s 
/loot 
/delay 1s 
/if (${Me.State.NotEqual[BIND]}) { 
/echo ** Massive lag right now... Aborting looting. 
/return 
} 

:LootLag 
/if (${LootTotal}!=${Corpse.Items}) { 
/varset LootTotal ${Corpse.Items} 
/delay 5 
/goto :LootLag 
} 

/for LootSlot 1 to ${LootTotal} 
:LootItem 
/itemnotify loot${LootSlot} rightmouseup 
/delay 3 
/if (${Corpse.Item[${LootSlot}].ID}) { 
/delay 2 
/goto :LootItem 
} 
/next LootSlot 
/delay 5 
/echo ** Done looting my corpse. 
/notify LootWnd DoneButton leftmouseup 

/return 

| ################# Tells n Hells 

Sub Event_Chat(string ChatType,string ChatSender,string ChatText) 
/if (!${ChatType.Equal[GROUP]} && !${ChatType.Equal[TELL]}) /return 

/if (${ChatText.Equal[heal]}) { 
/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 
|} 

/if (${ChatText.Equal[slow]}) { 
/assist ${ChatSender} 
/if (${Target.Type.Equal[NPC]} && ${Target.Distance}<=100) { 
/call cast ${SpellMalo} gem3 6s 
/call cast ${SpellSlow} gem2 6s 
/tell ${ChatSender} %T is SLOWED 
} 
/return 
} 

/return
 
np, but remember there's a patch tomorrow morning, prolly about 3 am as usual and mq2 will be down untill at least friday most likely. Although the devs do have a beta account so it might be up a little earlier than that.
 
If updating this to bot my 65 shammy would it buch more then just looking through it and adjusting the spell names? IE does it need to know the casting time/refresh times? the Shammy has all spells to 65 save GRC and the GoD spells. Looking for something right along the lines of the above...I have a 65 sk and 63 cleric. I'd like to be boting the cleric and shammy...cleric on heals/buffage(going to try afcleric once i can get MQ2 complined for me) shamy on slows/buffage/and dots if doable.

On a side note is there a macro avail or could one be written to pull in a mob with a bow and then auto attack it? I'm sure the pull is easy but keeping the mob infront of me in order to tank it down and then pull the next in range...as well as dealing with any roamer, has me thinking that this would be more of a headache then any real boon. Was thinking of doing something like this in say Chardok B.
 
nope, all you'll really need to do is change spell names

btw a pull macro wouldn't be hard, you'd just need to change around a few things in the tank/healer mac that i have poster (don't remember the exact name)
 
Good to hear the the macro is that easily changed.

I came across the tank/healer macro later on last night, it looks pretty promising for my current set up. I'll have to touch base with the boards after i get MQ2 up and running and try my luck out with it. You mentioned that some changes to the tank macro would allow for pulls, would that be able to be done with arrows/spells? I've been reading a lot and know that bard is prob gonna be my fastest way but I want to try and make my current set up work rather then upping yet another alt.

Also, would that sham bot work ok on a necro? In an undead area my 65 necro could handle the slows well enuf, but add in the dps of pet/dots. I have the 63 cleric to handle the heals and hopefull toss in his click legs for pet, and his undead dot.
 
currently the tank part of the macro walks up to the mob to pull it. all you'd really need to do is change the distance that it walks up to the mob and instead of "/attack on" do whatever command is needed to fire arrows.
dunno about shambot, i think i can find a few necro bots for ya though
 
I need some help I changed the parts i was told to but kept getting errors further down the line... can anyone put this in word and color what needs to be changed for me please? :) :o
 
Request for Macro (shaman)

Users who are viewing this thread

Back
Top