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