This is the mac I have been using I love it alot. I did make a few minor changes. I added Champion to group bufflist.. So now it will autocast Champion everytime it wears off. just like any other group buff. Which if your a Melee ROCKS>..
Code:
____________________________________________________________________________
|
| Shambot
| Version 3.23 by ioncache, extensively modified shambot.mac
| Laste update: 06/02/19
|____________________________________________________________________________
|
| -!- Basis of this script is Version: v0.5c by Hubba
| -!- Shambot Version 1.0c by Ranma
| -!- Version 2.0c by thread_001
| -!- This script Uses spell_routines.inc by Rusty, as modified by A_Druid_00
| -!- This script uses Wait4rez.inc by A_Druid_00
| -!- This script uses ninjadvloot.inc by A_Druid_00 (based on code from toomanynames)
| -!- This script uses MQ2MoveUtils plugin by outlander
|____________________________________________________________________________
|
| 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 ChatController or any Master or group
| Echos all non command word tells to controller
|
| 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] [focus] [Champ]
|
| The following commands will target the sender and cast the group versions
| on the sender's group: [gsta] [gagi] [gstr] [ghaste] [gregen] [gfocus]
|
| 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] [buffme] will buff a person
|
| The following commands: [bufftarget] will buff another person
|
| The following command: [autofollow] is for moving shaman
|
| The [add] or [slow] command are good in combat when there are adds
| Target the add and it will be malo (of DoMalo TRUE) and slowed
|
| During combat shaman will only do requests for heals, detrimentals, haste and panther
|
| [buffpet] targets the senders pet and buffs
|
| [gatenow] [gate] will memorize the gate spell and gate to bind, must be a tell from controller
|
| Use "help" for more help
|____________________________________________________________________________
#turbo 40
#chat group
#chat tell
#chat raid
#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
#include ninjadvloot.inc
Sub Main
| ########### Make changes in spells as you need.
| ########### This is mainly for a 70th level shaman with Cannibalization ability
| ########### Set Cannibalization to False if you don't have the ability
/if (${Me.Class.ShortName.NotEqual[SHM]}) {
/echo Sorry you are not a Shaman.
/echo I'm afraid this macro to PC relationship just isn't going to work out.
/echo I do hope we can still be friends though.
/endmacro
}
| ########### Default Channel, Controller
/declare CChannel outer "xxxxxx"
/declare ChatController outer "xxxxxxx"
/declare GroupChatRelay outer FALSE
/declare RaidChatRelay outer FALSE
| ########### Your Spell List - update as needed
| ########### Used for miscellaneous spells
/declare MiscGem outer "gem9"
/declare MiscGemNum outer 9
| ########### Normal Spell Set
/declare SpellCanni outer "Ancient: Ancestral Calling"
/declare SpellCanniGem outer "gem1"
/declare SpellCanniGemNum outer 1
/declare SpellSlow outer "Balance of Discord"
/declare SpellLongSlow outer "Turgur's Insects"
/declare SpellShortSlow outer "Balance of Discord"
/declare SpellSlowGem outer "gem2"
/declare SpellSlowGemNum outer 2
/declare SpellMalo outer "Malos"
/declare SpellMaloGem outer "gem3"
/declare SpellMaloGemNum outer 3
/declare SpellCripple outer "Crippling Spasm"
/declare SpellCrippleGem outer "gem4"
/declare SpellCrippleGemNum outer 4
/declare SpellDoT outer "Blood of Yoppa"
/declare SpellDoTGem outer "gem4"
/declare SpellDoTGemNum outer 4
/declare SpellDoT2 outer "Curse of Sisslak"
/declare SpellDoT2Gem outer "gem4"
/declare SpellDoT2GemNum outer 4
/declare SpellNuke outer "Champion"
/declare SpellNukeGem outer "gem5"
/declare SpellNukeGemNum outer 5
/declare SpellAvatar outer "Champion"
/declare SpellAvatarGem outer "gem5"
/declare SpellAvatarGemNum outer 5
/declare SpellGAvatar outer "Champion"
/declare SpellGAvatarGem outer "gem5"
/declare SpellGAvatarGemNum outer 5
/declare SpellHeal outer "Ancient: Wilslik's Mending"
/declare SpellHealGem outer "gem6"
/declare SpellHealGemNum outer 6
/declare SpellHoT outer "Spiritual Serenity"
/declare SpellHoTGem outer "gem7"
/declare SpellHoTGemNum outer 7
/declare SpellPanther outer "Spirit of the Leopard"
/declare SpellPantherGem outer "gem8"
/declare SpellPantherGemNum outer 8
| ########### Miscellaneous Spells (will use MiscGem)
/declare SpellPet outer "Farrel's Companion"
/declare SpellRoot outer "Petrifying Earth"
/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 "CHampion"
/declare SpellPR outer "Talisman of the 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 Celerity"
/declare SpellGFOCUS outer "Talisman of Wunshi"
/declare SpellCHAMP outer "Champion"
/declare SpellSOW outer "Spirit of Bih`Li"
/declare SpellLEV outer "Levitation"
/declare SpellINV outer "Spirit Veil"
/declare SpellSHRINK outer "Shrink"
/declare SpellGSHRINK 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"
/declare SpellInvis outer "Invisibility"
/declare SpellInvisSelf outer "Spirit Veil"
| - comment out any Clicky Item that you do not have
| /declare ItemClickyHASTE string outer "Scaled Avatar's Hauberk"
| /declare ItemClickyDOT string outer "Spear of Fate"
| /declare ItemClickyFD string outer "Vermillion Sky Ring"
/declare ShamanFDLevel int outer 10
/declare ShamanFD bool FALSE
| ########### Mount Type
/declare Mount outer "Small Black Drum"
| ########### My Pet Buff Spell List
| HASTE handled in Cast_HASTE sub now
| and will be cast on pet
/declare SpellPetBuff[6] string outer
/varset SpellPetBuff[1] ${SpellHASTE}
/varset SpellPetBuff[2] ${SpellFOCUS}
/varset SpellPetBuff[3] ${SpellSTR}
/varset SpellPetBuff[4] ${SpellSTA}
/varset SpellPetBuff[5] ${SpellAGI}
/varset SpellPetBuff[6] ${SpellREGEN}
| ########### Other Pet Buff Spell List
| HASTE handled in Cast_HASTE sub now
| and will be cast on pet
/declare SpellPetBuffo[5] string outer
/varset SpellPetBuffo[1] ${SpellFOCUS}
/varset SpellPetBuffo[2] ${SpellSTR}
/varset SpellPetBuffo[3] ${SpellSTA}
/varset SpellPetBuffo[4] ${SpellAGI}
/varset SpellPetBuffo[5] ${SpellREGEN}
| ############ Group Buff List.
/declare SpellGroupBuff[7] string outer
/varset SpellGroupBuff[1] ${SpellGFOCUS}
/varset SpellGroupBuff[2] ${SpellGSTR}
/varset SpellGroupBuff[3] ${SpellGSTA}
/varset SpellGroupBuff[4] ${SpellGAGI}
/varset SpellGroupBuff[5] ${SpellGREGEN}
/varset SpellGroupBuff[6] ${SpellGHASTE}
/varset SpellGroupBuff[7] ${SpellCHAMP}
| ############ Single Buff List.
| HASTE handled in Cast_HASTE sub now
| and will be cast on pc
/declare SpellSingleBuff[5] string outer
/varset SpellSingleBuff[1] ${SpellFOCUS}
/varset SpellSingleBuff[2] ${SpellSTR}
/varset SpellSingleBuff[3] ${SpellSTA}
/varset SpellSingleBuff[4] ${SpellAGI}
/varset SpellSingleBuff[5] ${SpellREGEN}
| ############ Spells to refresh on worn off messages.
/declare RefreshThisBuff[6] string outer
/varset RefreshThisBuff[1] ${SpellFOCUS}
/varset RefreshThisBuff[2] ${SpellSTR}
/varset RefreshThisBuff[3] ${SpellSTA}
/varset RefreshThisBuff[4] ${SpellAGI}
/varset RefreshThisBuff[5] ${SpellREGEN}
/varset RefreshThisBuff[6] ${SpellChamp}
| ############ Combat Variables
/declare AssistAt int outer 98
/declare CombatAt int outer 97
/declare GroupBuffRange int outer 50
/declare CastDoTat int outer 80
/declare DotMana int outer 40
/declare Rootat int outer 30
/declare RootMana int outer 40
/declare NukeAt int outer 70
/declare NukeMana int outer 30
/declare PantherMana int outer 35
/declare PantherSkip int outer 45
/declare SitAt int outer 0
/declare BuffMana int outer 30
/declare MinMana int outer 15
/declare CanniMinPct int outer 35
/declare AssistDelay int outer 3
/declare CastRetryTime string outer "5s"
| ############ Healing Levels
/declare CasterHeal int outer 60
/declare CasterHoT int outer 70
/declare MeleeHeal int outer 50
/declare MeleeHoT int outer 60
/declare TankHeal int outer 50
/declare TankHoT int outer 60
/declare PetHeal int outer 40
/declare PetHoT int outer 50
| ############ Do List
/declare DoMalo bool outer FALSE
/declare DoSlow bool outer TRUE
/declare DoCripple bool outer TRUE
/declare FastSlow bool outer TRUE
/declare DoRoot bool outer FALSE
/declare DoPet bool outer FALSE
/declare DoBuffPet bool outer FALSE
/declare DoDoT bool outer FALSE
/declare DoDoT2 bool outer FALSE
/declare DoPantherPets bool outer TRUE
/declare DoPantherGroup bool outer TRUE
/declare DoGroupBuffs bool outer FALSE
/declare DoRebuffs bool outer FALSE
/declare DoSow bool outer FALSE
/declare DoNuke bool outer FALSE
/declare DoGroupCommands bool outer TRUE
/declare DoHeal bool outer TRUE
/declare DoHoT bool outer TRUE
/declare HealGroup bool outer TRUE
/declare HealPets bool outer FALSE
/declare HealTank bool outer TRUE
/declare DoCanni bool outer TRUE
/declare Cannibalization bool outer TRUE
/declare Verbose bool outer FALSE
/declare VerboseTell bool outer FALSE
/declare DoShrink bool outer FALSE
/declare DoAvatar bool outer FALSE
/declare DoMount bool outer FALSE
/declare DoLoot bool outer FALSE
/declare AutoFollow bool outer FALSE
/declare afdist int outer 25
/declare AutoFollowPC string outer XXXXXX
/declare DoCamp bool outer TRUE
/declare PullPC string outer NULL
| This is a delay for how long Avatar will hold. (10min)
/declare AvatarDelay outer 6689
| This is a delay for how long Panther will hold. (1min about 669)
/declare PantherDelay outer 669
| ########### ! No Changes From Here Are Needed !
| ### Do Toggles
/squelch /alias /avatar /echo toggle DoAvatar
/squelch /alias /buffpet /echo toggle DoBuffPet
/squelch /alias /buffs /echo toggle DoGroupBuffs
/squelch /alias /canni /echo toggle DoCanni
/squelch /alias /cripple /echo toggle DoCripple
/squelch /alias /dopet /echo toggle DoPet
/squelch /alias /dot /echo toggle DoDoT
/squelch /alias /dot2 /echo toggle DoDoT2
/squelch /alias /groupcommands /echo toggle DoGroupCommands
/squelch /alias /heal /echo toggle DoHeal
/squelch /alias /hot /echo toggle DoHoT
/squelch /alias /lootmobs /echo toggle DoLoot
/squelch /alias /malo /echo toggle DoMalo
/squelch /alias /nuke /echo toggle DoNuke
/squelch /alias /panthergroup /echo toggle DoPantherGroup
/squelch /alias /pantherpets /echo toggle DoPantherPets
/squelch /alias /rebuffs /echo toggle DoRebuffs
/squelch /alias /root /echo toggle DoRoot
/squelch /alias /shrink /echo toggle DoShrink
/squelch /alias /slow /echo toggle DoSlow
/squelch /alias /sow /echo toggle DoSow
| ### Misc Toggles
/squelch /alias /buffbot /echo toggle BuffBot
/squelch /alias /fastslow /echo toggle FastSlow
/squelch /alias /groupchat /echo toggle GroupChatRelay
/squelch /alias /healgroup /echo toggle HealGroup
/squelch /alias /healpets /echo toggle HealPets
/squelch /alias /healtank /echo toggle HealTank
/squelch /alias /raidchat /echo toggle RaidChatRelay
/squelch /alias /verbose /echo toggle Verbose
/squelch /alias /verbosetell /echo toggle VerboseTell
| ### Toggles with 2nd Command
/squelch /alias /assistat /echo toggle AssistAt
/squelch /alias /dotat /echo toggle CastDoTat
/squelch /alias /combatat /echo toggle CombatAt
/squelch /alias /healat /echo toggle HealAt
/squelch /alias /healcastersat /echo toggle HealCastersAt
/squelch /alias /healmeleeat /echo toggle HealMeleeAt
/squelch /alias /healpetsat /echo toggle HealPetsAt
/squelch /alias /healtankat /echo toggle HealTankAt
/squelch /alias /hotcastersat /echo toggle HotCastersAt
/squelch /alias /hotmeleeat /echo toggle HotMeleeAt
/squelch /alias /hotpetsat /echo toggle HotPetsAt
/squelch /alias /hottankat /echo toggle HotTankAt
/squelch /alias /nukeat /echo toggle NukeAt
/squelch /alias /rootat /echo toggle RootAt
/squelch /alias /setma /echo toggle M_Assist
/squelch /alias /setpuller /echo toggle PullPC
| ### Customized Commands
/squelch /alias /addmaster /echo toggle AddMaster
/squelch /alias /autofollow /echo toggle SetAutoFollow
/squelch /alias /clearmasters /echo toggle ClearMasters
/squelch /alias /docamp /echo toggle SetDoCamp
/squelch /alias /help /echo toggle Help
/squelch /alias /listmasters /echo toggle ListMasters
/squelch /alias /removemaster /echo toggle RemoveMaster
/squelch /alias /resethot /echo toggle ResetHot
/squelch /alias /show /echo toggle Show
/squelch /alias /switchslow /echo toggle SwitchSlow
/squelch /alias /status /echo toggle Show
/declare BuffBot bool outer FALSE
/declare MasterArray[5] string outer NULL
/declare TargetArray[4] string outer NULL
/declare TargetSlow[5] string outer NULL
/declare TargetDebuff[5] string outer NULL
/declare TargetCrippled[5] string outer NULL
/declare MobMaloed bool outer FALSE
/declare MobSlowed bool outer FALSE
/declare MobCrippled bool outer FALSE
/declare PetOn bool outer FALSE
/declare MobRooted bool outer FALSE
/declare MobDoTed bool outer FALSE
/declare MobDoTed2 bool outer FALSE
/declare CombatOn bool outer TRUE
/declare Engaged bool outer FALSE
/declare LowMana bool outer FALSE
/declare TankHoTOn int outer 0
/declare GroupHoT[6] int outer 0
/declare GroupHoTPet[6] int outer 0
/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 GroupBuffTimer timer outer 0
/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
target
/declare PanGrp0 timer outer 0
/declare PanGrp1 timer outer 0
/declare PanGrp2 timer outer 0
/declare PanGrp3 timer outer 0
/declare PanGrp4 timer outer 0
/declare PanGrp5 timer outer 0
/declare PanPet0 timer outer 0
/declare PanPet1 timer outer 0
/declare PanPet2 timer outer 0
/declare PanPet3 timer outer 0
/declare PanPet4 timer outer 0
/declare PanPet5 timer outer 0
/declare noInvis int outer 1
/call MemSpells
/call SetupAdvLootVars
| ############### Use command 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]} || ${Target.Type.NotEqual[pet]}) {
/echo You do not have a PC or Pet targeted, using default controller: ${ChatController}
/echo To reset MA do: /setma <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: /setma <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}
| ###############
| ############### Main Loop Starts
| ###############
:Main_Loop
|- If you wish to set bot to buffing only, /echo toggle buffbot
/doevents
|- Shaman FD check if item exists
/if (${Me.PctHPs}<=${ShamanFDLevel} && ${Defined[ItemClickyFD]}) /call ShamanFD
|- Auto Follow
/if (${AutoFollow}) /call AutoFollow
|- Canni
/if (!${Me.Invis}) /call LowOnMana
|- Pet
/if (!${Engaged} && ${DoPet} && !${Me.Invis}) /call PetRoutines
/if (${Me.Invis} || ${BuffBot}) /goto :Main_Loop
|- Check for Standing if less than sitat then sit
/if (${Me.State.Equal[Stand]} && ${Me.PctMana}<${SitAt} && !${Engaged}) /sit
|- Summon Mount if outdoors && DoMount=TRUE
/if (!${Me.Mount.ID} && ${OutDoors} && ${DoMount}) /call cast ${Mount} item ${CastRetryTime}
|- Checks for Heals/Events
/call CombatChecks
|- Check for mobs and do combat stuff
/call GetTarget
/if (${CombatOn} && ${TargetArray[4].NotEqual[NULL]}) /call Combat
|- Do we move?
:Hold_Main
/if (${Me.Moving}) /goto :Hold_Main
|- Check for Standing if less than sitat then sit
/if ( ${Me.State.Equal[Stand]} && ${Me.PctMana}<${SitAt}) /sit
|- Checks for Heals/Events
/call CombatChecks
|- Buff Sow
/if (!${Engaged} && ${DoSow}) /call SowGroup
|- Group Buffs if more than BuffMana mana
/if (${Me.PctMana}>=${BuffMana} && ${DoGroupBuffs} && !${Engaged} && ${GroupBuffTimer}==0) /call
GroupBuffs
|- Buff Avatar
/if (${DoAvatar} && ((${Me.SpellReady[${SpellAvatar}]} && ${Engaged}) ||
${Me.SpellReady[${SpellGAvatar}]})) /call CastAvatar
/if (!${Engaged} && ${DoLoot} && !${Me.Moving}) /call LootMobs
/goto :Main_Loop
/return
| ############### Mem Spells in Spell List
Sub MemSpells
/echo Memming spells. Hang on.
/sit
/if (!${Me.Gem[${SpellCanni}]}) {
/memspell ${SpellCanniGemNum} ${SpellCanni}
/delay 30
}
/if (!${Me.Gem[${SpellSlow}]}) {
/memspell ${SpellSlowGemNum} ${SpellSlow}
/delay 30
}
/if (!${Me.Gem[${SpellMalo}]} && ${DoMalo}) {
/memspell ${SpellMaloGemNum} ${SpellMalo}
/delay 30
} else /if (!${Me.Gem[${SpellCripple}]}) {
/memspell ${SpellCrippleGemNum} ${SpellCripple}
/delay 30
}
/if (!${Me.Gem[${SpellDoT}]}) {
/memspell ${SpellDoTGemNum} ${SpellDoT}
/delay 30
}
/if (!${Me.Gem[${SpellGAvatar}]} && ${SpellGAvatar.NotEqual[NULL]} && ${DoAvatar}) {
/memspell ${SpellGAvatarGemNum} ${SpellGAvatar}
/delay 30
} else /if (!${Me.Gem[${SpellAvatar}]} && ${DoAvatar}) {
/memspell ${SpellAvatarGemNum} ${SpellAvatar}
/delay 30
} else /if (!${Me.Gem[${SpellNuke}]}) {
/memspell ${SpellNukeGemNum} ${SpellNuke}
/delay 30
}
/if (!${Me.Gem[${SpellHeal}]}) {
/memspell ${SpellHealGemNum} ${SpellHeal}
/delay 30
}
/if (!${Me.Gem[${SpellHoT}]}) {
/memspell ${SpellHoTGemNum} ${SpellHoT}
/delay 30
}
/if (!${Me.Gem[${SpellPanther}]}) {
/memspell ${SpellPantherGemNum} ${SpellPanther}
/delay 30
}
/if (!${Me.Gem[${SpellHASTE}]} && ${MiscGemNum}==9) {
/memspell ${MiscGemNum} ${SpellHASTE}
/delay 30
}
/if (${Window[SpellBookWnd].Open}) /windowstate SpellBookWnd close
/stand
/echo Spells are memmed.
/return
Sub ShamanFD
/call cast ${ItemClickyFD} item
/echo Was getting beat down, now I'm FD
/beep
/varset ShamanFD TRUE
:FDLoop
/doevents
/if (${ShamanFD}) /goto :FDLoop
/return
| ################### Check target and do stuff like slow, dot, pet attack etc.
Sub Combat
/declare i int local
/if (${Target.ID}==${TargetArray[4]}) {
/face
|- Malo & Slow
/if (${CombatOn} && ((!${MobMaloed} && ${DoMalo}) || (!${MobCrippled} && ${DoCripple} &&
${MobSlowed}))) /call DeBuff
/if (${CombatOn} && !${PetOn} && ${Target.ID}==${TargetArray[4]} &&
${Target.Distance}<=${AssistAt}) {
/squelch /pet attack
/varset PetOn TRUE
/varset Engaged TRUE
}
/if (${CombatOn} && !${MobSlowed} && ${DoSlow}) /call Slow
|- Checks for Heals/Events
/call CombatChecks
|- do panther stuff
/if (${CombatOn} && ${Engaged} && ${Me.PctMana}>=${PantherMana} &&
${Target.PctHPs}>=${PantherSkip} && (${DoPantherPets} || ${DoPantherGroup})) /call CastPanther
|- Checks for Heals/Events
/call CombatChecks
/if (${CombatOn} && ((${DoDoT} && !${MobDoTed}) || (${DoDoT2} && !${MobDoTed2})) &&
${Me.PctMana}>=${DotMana} && ${Target.PctHPs}<=${CastDoTat}) /call CastDoT
|- Checks for Heals/Events
/call CombatChecks
/if (${CombatOn} && ${DoNuke} && ${Me.PctMana}>=${NukeMana} &&
${Target.PctHPs}<=${NukeAt}) /call cast ${SpellNuke} ${SpellNukeGem} ${CastRetryTime}
/if (${CombatOn} && ${DoRoot} && ${Me.PctMana}>=${RootMana} && ${Target.PctHPs}<=${RootAt}
&& !${MobRooted}) {
/call cast ${SpellRoot} ${MiscGem} {$CastRetryTime}
/varset MobRooted TRUE
}
}
|- EndCombat - Check for new events in chat etc etc...
|- Checks for Heals/Events
/call CombatChecks
/target ${TargetArray[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 MobCrippled FALSE
/varset PetOn FALSE
/varset MobDoTed FALSE
/varset MobDoTed2 FALSE
/varset CombatOn FALSE
/varset Engaged FALSE
/for i 1 to ${TargetDebuff.Size}
/if (${Target.ID}==${TargetDebuff[${i}]}) {
/if (${Verbose}) /echo removing ${TargetArray[1]}[${TargetArray[4]}] from Debuff Array
/varset TargetDebuff[${i}] NULL
}
/if (${Target.ID}==${TargetCrippled[${i}]}) {
/if (${Verbose}) /echo removing ${TargetArray[1]}[${TargetArray[4]}] from CrippleArray
/varset TargetCrippled[${i}] NULL
}
/if (${Target.ID}==${TargetSlow[${i}]}) {
/if (${Verbose}) /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
Sub CombatChecks
|- Tank Heals
/if (${HealTank}) /call CheckHPs Tank
|- Heal Group
/if (${HealGroup}) /call CheckHPs Group
|- Heal Pets
/if (${HealPets}) /call CheckHPs Pet
|- Check for new events in chat
/doevents
/call GetTarget
/return
Sub CastDoT
/if (${Target.Type.NotEqual[NPC]}) /return
/if (${Me.PctMana}>=${DotMana} && ${Target.PctHPs}<=${CastDoTat} &&
${Target.Distance}<${Spell[${SpellDoT}].Range} && !${MobDoTed} && ${DoDoT}) {
/call cast ${SpellDoT} ${SpellDoTGem} ${CastRetryTime}
/varset MobDoTed TRUE
/if (${DoDoT2} && !${Me.Gem[${SpellDoT2}]}) {
/memspell ${SpellDoT2GemNum} ${SpellDoT2}
/delay 30
}
} else /if (${Me.PctMana}>=${DotMana} && ${Target.PctHPs}<=${CastDoTat} &&
${Target.Distance}<${Spell[${SpellDoT2}].Range} && !${MobDoTed2} && ${DoDoT2}) {
/call cast ${SpellDoT2} ${SpellDoT2Gem} ${CastRetryTime}
/varset MobDoTed2 TRUE
/if (${DoDoT} && !${Me.Gem[${SpellDoT}]}) {
/memspell ${SpellDoTGemNum} ${SpellDoT}
/delay 30
}
}
/return
| ############## CastPanther Line on group
Sub CastPanther
/declare i int local
/if ((${DoSlow} && !${MobSlowed}) || (${DoCripple} && !${MobCrippled}) ||
${Target.Type.NotEqual[NPC]}) /return
/for i ${Group.Members} downto 0
/if (${Target.PctHPs}<=${PantherSkip}) /return
/if (${Group.Member[${i}].ID}) {
/if (${PanGrp${i}}==0 &&
${Select[${Group.Member[${i}].Class.ShortName},BER,BRD,BST,MNK,PAL,RNG,ROG,SHD,WAR]} &&
${DoPantherGroup}) {
/call AcquireTarget ${Group.Member[${i}]} PC FALSE
/if (${Me.CurrentMana}>${Spell[${SpellPanther}].Mana} &&
${Target.Distance}<${Spell[${SpellPanther}].Range}) {
/call cast ${SpellPanther} ${SpellPantherGem} ${CastRetryTime}
/if (${Macro.Return.Equal["CAST_OUTOFRANGE"]}) /varset PanGrp${i} 200
/if (${Macro.Return.Equal["CAST_SUCCESS"]}) /varset PanGrp${i} ${PantherDelay}
}
/return
}
/if (${PanPet${i}}==0 && ${Group.Member[${i}].Pet.ID} && ${DoPantherPets} &&
${Select[${Group.Member[${i}].Class.ShortName},BST,MAG,NEC,SHM]}) {
/call AcquireTarget ${Group.Member[${i}].Pet} PET FALSE
/if (${Me.CurrentMana}>${Spell[${SpellPanther}].Mana} &&
${Target.Distance}<${Spell[${SpellPanther}].Range}) {
/call cast ${SpellPanther} ${SpellPantherGem} ${CastRetryTime}
/if (${Macro.Return.Equal["CAST_OUTOFRANGE"]}) /varset PanPet${i} 200
/if (${Macro.Return.Equal["CAST_SUCCESS"]}) /varset PanPet${i} ${PantherDelay}
}
/return
}
}
/next i
/return
| ############## Cast_Shrink
Sub Shrink_Group
/if (${Verbose}) /gsay Shrinking Group
/if (${SpellSHRINK.Equal[Shrink]}) {
/declare i int local
/for i 0 to ${Group.Members}
/if (${Group.Member[${i}].ID}) {
/call AcquireTarget ${Group.Member[${i}]} PC FALSE
/if (${Target.Distance}<=${AssistAt}) {
/call cast ${SpellSHRINK} ${MiscGem} ${CastRetryTime}
}
}
/next i
} else {
/call AcquireTarget ${M_Assist} PC FALSE
/if ((${Target.Type.Equal[PC]} || ${Target.Type.Equal[pet]}) && ${Target.Distance}<=${AssistAt}) {
/echo << ${SpellSHRINK} >> is being cast on you now.
/call cast ${SpellSHRINK} ${MiscGem} ${CastRetryTime}
}
}
/return
| ############### Debuff
Sub DeBuff
/if (!${MobMaloed} && ${DoMalo}) {
|- check to see if in TargetDebuff array
/declare i int local
/for i 1 to ${TargetDebuff.Size}
/if (${Target.ID}==${TargetDebuff[${i}]}) {
/echo ${Target.CleanName} has already been debuffed with ${SpellMalo}
/varset MobMaloed TRUE
/return
}
/next i
:DeBuff_Loop
/if (${Target.PctHPs}<=${CombatAt} && ${Target.ID}==${TargetArray[4]}) {
/if (${Me.CurrentMana}<${Spell[${SpellMalo}].Mana}) {
/echo Not enough mana to cast << ${SpellMalo} >> on %t
} else {
/call cast ${SpellMalo} ${SpellMaloGem} ${CastRetryTime}
/if (${Macro.Return.Equal["CAST_INTERRUPTED"]}) /goto :DeBuff_Loop
/call Addto_Debuff
/varset MobMaloed TRUE
}
}
/if (${DoCripple} && !${Me.Gem[${SpellCripple}]}) {
/memspell ${SpellCrippleGemNum} ${SpellCripple}
/delay 30
}
} else /if (!${MobCrippled} && ${DoCripple}) {
|- check to see if in TargetCrippled array
/declare i int local
/for i 1 to ${TargetCrippled.Size}
/if (${Target.ID}==${TargetCrippled[${i}]}) {
/echo ${Target.CleanName} has already been Crippled with ${SpellCripple}
/varset MobCrippled TRUE
/return
}
/next i
/if (${Target.PctHPs}<=${CombatAt} && ${Target.ID}==${TargetArray[4]}) {
/if (${Me.CurrentMana}<${Spell[${SpellCripple}].Mana}) {
/echo Not enough mana to --> Cripple %t
} else {
:Cripple_Loop
/call cast ${SpellCripple} ${SpellCrippleGemNum} ${CastRetryTime}
/if (${Macro.Return.Equal["CAST_INTERRUPTED"]}) /goto :Cripple_Loop
/if (${Macro.Return.Equal["CAST_RESISTED"]}) {
/call Addto_Cripple
/varset MobCrippled TRUE
}
/if (${Macro.Return.Equal["CAST_SUCCESS"]}) {
/if (${Verbose}) /gsay << %t >> has been CRIPPLED with ${SpellCripple}.
/call Addto_Cripple
/varset MobCrippled TRUE
}
}
}
/if (${DoMalo} && !${Me.Gem[${SpellMalo}]}) {
/memspell ${SpellMaloGemNum} ${SpellMalo}
/delay 30
}
}
/return
| ############### Slowing
Sub Slow
|- check to see if in TargetSlow array
/declare i int local
/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 Not enough mana to --> Slow %t
} else {
:Slow_Loop
/call cast ${SpellSlow} ${SpellSlowGem} ${CastRetryTime}
/if (${Macro.Return.Equal["CAST_INTERRUPTED"]}) /goto :Slow_Loop
/if (${Macro.Return.Equal["CAST_IMMUNE"]}) {
/if (${Verbose}) /gsay << %t >> is IMMUNE to slow.
/call Addto_Slow
/varset MobSlowed TRUE
}
/if (${Macro.Return.Equal["CAST_RESISTED"]}) {
/if (!${FastSlow}) {
/if (${Verbose}) /gsay << %t >> has RESISTED slow. Trying again.
/goto :Slow_Loop
}
/call Addto_Slow
/varset MobSlowed TRUE
}
/if (${Macro.Return.Equal["CAST_SUCCESS"]}) {
/if (${Verbose}) /gsay << %t >> has been SLOWED with ${SpellSlow}.
/call Addto_Slow
/varset MobSlowed TRUE
}
}
}
/return
| ############### Add targets to slow array, pushing oldest off bottom of array
Sub Addto_Slow
/declare i int local
/for i 1 to ${TargetSlow.Size}
/if (${Target.ID}==${TargetSlow[${i}]}) /return
/next i
/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 cripple array, pushing oldest off buttom of array
Sub Addto_Cripple
/declare i int local
/for i 1 to ${TargetSCrippled.Size}
/if (${Target.ID}==${TargetCrippled[${i}]}) /return
/next i
/varset TargetCrippled[5] ${TargetCrippled[4]}
/varset TargetCrippled[4] ${TargetCrippled[3]}
/varset TargetCrippled[3] ${TargetCrippled[2]}
/varset TargetCrippled[2] ${TargetCrippled[1]}
/varset TargetCrippled[1] ${Target.ID}
/return
| ############### Add targets to debuff array, pushing oldest off bottom of array
Sub Addto_Debuff
/declare i int local
/for i 1 to ${TargetDebuff.Size}
/if (${Target.ID}==${TargetDebuff[${i}]}) /return
/next i
/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
/call AcquireTarget ${M_Assist} NPC TRUE
/if (${Target.Type.Equal[NPC]} && ${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 MobCrippled FALSE
/varset PetOn FALSE
/varset MobDoTed FALSE
/varset MobDoTed2 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
Sub AcquireTarget(string NewTarget, string TargetType, bool AssistYN)
:LoopAcquireTarget
/if (${AssistYN}) {
/if (!${Spawn[${NewTarget}].ID}) /return
/assist ${NewTarget}
} else {
/if (!${Spawn[${TargetType} ${NewTarget}].ID}) /return
/squelch /target id ${Spawn[${TargetType} ${NewTarget}].ID}
}
/delay ${AssistDelay}
/if (!${AssistYN} && ${Target.ID}!=${Spawn[${TargetType} ${NewTarget}].ID}) /goto :LoopAcquireTarget
/return
Sub SingleBuffs(string ChatSender)
/declare i int local
/if (!${Select[${Target.Type},PC,PET]}) /return
/if (${Select[${Target.Class.ShortName},BER,BRD,BST,MNK,PAL,RNG,ROG,SHD,WAR]}) {
/if (${VerboseTell}) /tell ${ChatSender} Buffing you with << ${SpellHASTE} >> now.
/call Cast_HASTE
/for i 1 to ${SpellSingleBuff.Size}
/if (${SpellSingleBuff[${i}].NotEqual[NULL]} && ${Spell[${SpellSingleBuff[${i}]}].Mana} >
${Me.CurrentMana}) {
/echo DAMN.. LowOnMana... Cannibalizing to rebuff
:Hold_Single_Rebuff
/Call LowOnMana
/if (${Spell[${SpellSingleBuff[${i}]}].Mana} > ${Me.CurrentMana}) /goto :Hold_Single_Rebuff
}
/echo >>> Hang on ! Buffing ${SpellSingleBuff[${i}]}
/if (${VerboseTell}) /tell ${ChatSender} Buffing you with << ${SpellSingleBuff[${i}]} >> now.
/call cast ${SpellSingleBuff[${i}]} ${MiscGem} ${CastRetryTime}
/next i
} else /if (${Select[${Target.Class.ShortName},CLR,DRU,SHM,ENC,MAG,NEC,WIZ]}) {
/for i 1 to ${SpellSingleBuff.Size}
/if (${i}==2) /next i
/if (${SpellSingleBuff[${i}].NotEqual[NULL]} && ${Spell[${SpellSingleBuff[${i}]}].Mana} >
${Me.CurrentMana}) {
/echo DAMN.. LowOnMana... Cannibalizing to rebuff
:Hold_Single_Rebuff
/Call LowOnMana
/if (${Spell[${SpellSingleBuff[${i}]}].Mana} > ${Me.CurrentMana}) /goto :Hold_Single_Rebuff
}
/echo >>> Hang on ! Buffing ${SpellSingleBuff[${i}]}
/if (${VerboseTell}) /tell ${ChatSender} Buffing you with << ${SpellSingleBuff[${i}]} >> now.
/call cast ${SpellSingleBuff[${i}]} ${MiscGem} ${CastRetryTime}
/next i
}
/return
| ################### Buff the group with buffs from the SpellGroupBuff array
Sub GroupBuffs
/declare i int local
/for i 1 to ${Group.Members}
/if (${Group.Member[${i}].Distance}>${GroupBuffRange}) {
/varset GroupBuffTimer 150
/return
}
/next i
/for i 1 to ${SpellGroupBuff.Size}
/if (${Spell[${SpellGroupBuff[${i}].Equal[NULL]}]}) /next i
/if (!${Me.Buff[${SpellGroupBuff[${i}]}].ID}) {
/if (${Spell[${SpellGroupBuff[${i}]}].Mana} > ${Me.CurrentMana}) {
/echo DAMN.. LowOnMana... Cannibalizing to rebuff
:Hold_Group_Rebuff
/Call LowOnMana
/if (${Spell[${SpellGroupBuff[${i}]}].Mana} > ${Me.CurrentMana}) /goto :Hold_Group_Rebuff
}
/call AcquireTarget ${Me} PC FALSE
/delay ${AssistDelay}
/echo Buffing ${SpellGroupBuff[${i}]} on group now.
/call cast ${SpellGroupBuff[${i}]} ${MiscGem} ${CastRetryTime}
/call CombatChecks
}
/next i
/return
|################## Spell Interrupt Subs
Sub CheckLevels
/if (${Me.Casting.Name.Equal[${SpellCanni}]} &&
(${Me.CurrentHPs}-688)/${Me.MaxHPs}*100<${CanniMinPct}-5) {
/call Interrupt
} else /if (${Me.Casting.Name.Equal[Cannibalization]}&&
(${Me.CurrentHPs}-1924)/${Me.MaxHPs}*100<${CanniMinPct}-5) {
/call Interrupt
} else /if (${Me.Casting.Name.Equal[${SpellHeal}]} &&
((${Select[${Target.Class.ShortName},CLR,DRU,SHM,ENC,MAG,NEC,WIZ]} &&
${Target.PctHPs}>=(${CasterHeal}+5)) ||
(${Select[${Target.Class.ShortName},BER,BRD,BST,MNK,PAL,RNG,ROG,SHD,WAR]} &&
${Target.PctHPs}>=(${MeleeHeal}+5)))) {
/call Interrupt
} else /if (${Me.Casting.Name.Equal[${SpellHoT}]} &&
((${Select[${Target.Class.ShortName},CLR,DRU,SHM,ENC,MAG,NEC,WIZ]} &&
${Target.PctHPs}>=(${CasterHoT}+5)) ||
(${Select[${Target.Class.ShortName},BER,BRD,BST,MNK,PAL,RNG,ROG,SHD,WAR]} &&
${Target.PctHPs}>=(${MeleeHoT}+5)))) {
/call Interrupt
} else /if (${Me.Casting.Name.Equal[${SpellHoT}]} &&
((${Select[${Target.Class.ShortName},CLR,DRU,SHM,ENC,MAG,NEC,WIZ]} &&
${Target.PctHPs}<=(${CasterHeal}-3)) ||
(${Select[${Target.Class.ShortName},BER,BRD,BST,MNK,PAL,RNG,ROG,SHD,WAR]} &&
${Target.PctHPs}<=(${MeleeHeal}-3)))) {
/call Interrupt
}
/return
|################## Check for all Healing - pass Tank/Group/Pet parameter to select type
Sub CheckHPs(string HealType)
/declare CheckHPsCounter int local
/declare HealTarget string local
/declare HealTargetType string local
/declare i int local
/declare j int local
/if (${HealType.Equal[Tank]}) {
/varset CheckHPsCounter 1
/varset HealTargetType PC
} else /if (${HealType.Equal[Group]}) {
/varset CheckHPsCounter ${Group.Members}
/varset HealTargetType PC
} else /if (${HealType.Equal[Pet]}) {
/varset CheckHPsCounter ${Group.Members}
/varset HealTargetType PET
} else /return
/for i 1 to ${CheckHPsCounter}
/if (${Target.CleanName.Equal[${PullPC}]} && !${Engaged}) /next i
/if (${HealType.Equal[Tank]}) {
/varset HealTarget ${M_Assist}
} else /if (${HealType.Equal[Group]}) {
/varset HealTarget ${Group.Member[${i}]}
} else {
/varset HealTarget ${Group.Member[${i}].Pet}
}
/if (((${HealType.Equal[Group]} && ${Group.Member[${i}].ID} &&
${Group.Member[${i}].Distance}<${Spell[${SpellHeal}].Range} &&
((${Select[${Group.Member[${i}].Class.ShortName},CLR,DRU,SHM,ENC,MAG,NEC,WIZ]} &&
${Group.Member[${i}].PctHPs}<=${CasterHeal}) ||
(${Select[${Group.Member[${i}].Class.ShortName},BER,BRD,BST,MNK,PAL,RNG,ROG,SHD,WAR]} &&
${Group.Member[${i}].PctHPs}<=${MeleeHeal}))) || (${HealType.Equal[Pet]} &&
${Group.Member[${i}].Pet.ID} && ${Group.Member[${i}].Pet.Distance}<${Spell[${SpellHeal}].Range} &&
${Group.Member[${i}].Pet.PctHPs}<=${PetHeal}) || (${HealType.Equal[Tank]} &&
${Spawn[${M_Assist}].ID} && ${Spawn[${M_Assist}].Distance}<${Spell[${SpellHeal}].Range} &&
${Spawn[${M_Assist}].PctHPs}<=${TankHeal})) && ${DoHeal}) {
/if (${Me.CurrentMana}<${Spell[${SpellHeal}].Mana}) {
/echo >>> Not enough mana to --> heal ${HealTarget}
} else {
/call AcquireTarget ${HealTarget} ${HealTargetType} FALSE
/if (${Verbose}) /gsay << ${SpellHeal} >> on %t
/call cast ${SpellHeal} ${SpellHealGem} ${CastRetryTime} CheckLevels
}
} else /if (((${HealType.Equal[Group]} && ${Group.Member[${i}].ID} &&
${Group.Member[${i}].Distance}<${Spell[${SpellHoT}].Range} &&
((${Select[${Group.Member[${i}].Class.ShortName},CLR,DRU,SHM,ENC,MAG,NEC,WIZ]} &&
${Group.Member[${i}].PctHPs}<=${CasterHoT}) ||
(${Select[${Group.Member[${i}].Class.ShortName},BER,BRD,BST,MNK,PAL,RNG,ROG,SHD,WAR]} &&
${Group.Member[${i}].PctHPs}<=${MeleeHoT})) && ${GroupHoT[${i}]}==0) || (${HealType.Equal[Pet]} &&
${Group.Member[${i}].Pet.ID} && ${Group.Member[${i}].Pet.Distance}<${Spell[${SpellHoT}].Range} &&
${Group.Member[${i}].Pet.PctHPs}<=${PetHoT} && ${GroupHoTPet[${i}]}==0) ||
(${HealType.Equal[Tank]} && ${Spawn[${M_Assist}].ID} &&
${Spawn[${M_Assist}].Distance}<${Spell[${SpellHoT}].Range} &&
${Spawn[${M_Assist}].PctHPs}<=${TankHoT} && ${TankHoTOn}==0)) && ${DoHoT}) {
/if (${Me.CurrentMana}<${Spell[${SpellHoT}].Mana}) {
/echo >>> Not enough mana to --> HoT ${HealTarget}
} else {
/call AcquireTarget ${HealTarget} ${HealTargetType} FALSE
/if (${Verbose}) /gsay << ${SpellHoT} >> on %t
/call cast ${SpellHoT} ${SpellHoTGem} ${CastRetryTime} CheckLevels
/if (${Macro.Return.Equal["CAST_SUCCESS"]} && ${Target.CleanName.Equal[${M_Assist}]}) {
/varset TankHoTOn 1
/for j 1 to ${Group.Members}
/if (${Group.Member[${j}].CleanName.Equal[${M_Assist}]}) /varset GroupHoT[${j}] 1
/if (${Group.Member[${j}].Pet.CleanName.Equal[${M_Assist}]}) /varset GroupHoTPet[${j}] 1
/next j
} else /if (${Macro.Return.Equal["CAST_SUCCESS"]} && ${HealType.Equal[Group]}) {
/varset GroupHoT[${i}] 1
} else /if (${Macro.Return.Equal["CAST_SUCCESS"]} && ${HealType.Equal[Pet]}) {
/varset GroupHoTPet[${i}] 1
}
}
}
/next i
/return
|################## Canni 5
Sub Cannibalization
/if ((${Me.CurrentHPs}-1924)/${Me.MaxHPs}*100<${CanniMinPct}) {
/call CheckMyHPs
} else /if (${Cannibalization}) {
/if (${Verbose}) /gsay Cannibalization time -- don't be afraid I only eat myself.
/call cast "47" alt ${CastRetryTime} CheckLevels
}
/return
| ################## This will NOT check self HPs, Only check HoT or recast HoT
Sub CheckMyHPs
/if (${Me.Buff[${SpellHoT}].ID}) /return
/if (${Me.CurrentMana}<${Spell[${SpellHoT}].Mana}) {
/echo >>> I don't have mana to cast ${SpellHoT} on myself
} else {
/call AcquireTarget ${Me} PC FALSE
/call cast ${SpellHoT} ${SpellHoTGem} ${CastRetryTime}
}
/return
| ################## This will Check to see if I am Low on Mana
Sub LowOnMana
/if (${Me.CurrentHPs}<${Me.MaxHPs}/3*2) /call CheckMyHPs
/if (${DoCanni} && ${Me.CurrentMana}<(${Me.MaxMana}-5) && ${Me.SpellReady[${SpellCanni}]} &&
(${Me.CurrentHPs}-688)/${Me.MaxHPs}*100>${CanniMinPct}) /call cast ${SpellCanni} ${SpellCanniGem}
${CastRetryTime} CheckLevels
/if (${DoCanni} && ${Cannibalization} && ${Me.AltAbilityReady[47]} &&
${Me.CurrentMana}<(${Me.MaxMana}-1200) && ${Me.MaxHPs}>2424) /call Cannibalization
/return
| ################## This will Check to see if I have SOW
Sub SowGroup
/if (!${Me.Buff[Spirit of Eagle].ID} && !${Me.Buff[Flight of Eagles].ID} && !${Me.Buff[Spirit of Bih`Li].ID}
&& ${OutDoors}) {
/call AcquireTarget ${Me} PC FALSE
/call cast ${SpellSOW} ${MiscGem} ${CastRetryTime}
}
/return
| ################## Cast_Haste casts haste spell or item if defined
Sub Cast_HASTE
/if (${Defined[ItemClickyHASTE]}) {
/call cast ${ItemClickyHASTE} item ${CastRetryTime}
} else {
/call cast ${SpellHASTE} ${MiscGem} ${CastRetryTime}
}
/return
| ################## Summon pet and buff with spells from SpellPetBuff array
Sub PetRoutines
/if (!${Me.Pet.ID} && ${Spell[${SpellPet}].Mana}<=${Me.CurrentMana}) {
/delay 3
/if (${Me.Pet.ID}) /return
/call cast ${SpellPet} ${MiscGem} ${CastRetryTime}
/delay 50
/echo My pet is now: ${Me.Pet.CleanName} - ${SpellPet}
} else /if (${DoBuffPet} && ${Me.Pet.ID}) {
/declare i int local
/for i 1 to ${SpellPetBuff.Size}
/if (${Me.Pet.ID} && !${Me.PetBuff[${SpellPetBuff[${i}]}]} &&
${Spell[${SpellPetBuff[${i}]}].Mana}<=${Me.CurrentMana}) {
/call AcquireTarget ${Me.Pet} PET FALSE
/call cast ${SpellPetBuff[${i}]} ${MiscGem} ${CastRetryTime}
}
/next i
}
/return
|################### Casting Avatar on all melee classes in group
Sub CastAvatar
/declare i int local
/if (${SpellGAvatar.NotEqual[NULL]} && !${Me.Buff[${SpellGAvatar}].ID} &&
${Me.CurrentMana}>${Spell[${SpellGAvatar}].Mana}) {
/call AcquireTarget ${Me} PC FALSE
/call cast ${SpellGAvatar} ${SpellGAvatarGem} ${CastRetryTime}
} else {
/for i 1 to ${Group.Members}
/if (${Group.Member[${i}].ID} && ${ATKBuffed${i}}==0 &&
${Select[${Group.Member[${i}].Class.ShortName},BER,BRD,BST,MNK,PAL,RNG,ROG,SHD,WAR]}) {
/call AcquireTarget ${Group.Member[${i}]} PC FALSE
/if (${Me.CurrentMana}>${Spell[${SpellAvatar}].Mana} &&
${Target.Distance}<${Spell[${SpellAvatar}].Range}) {
/if (${Verbose}) /tell ${Group.Member[${i}]} ${SpellAvatar} is incoming to you
${Group.Member[${i}]} , Stay in Range .
/call cast ${SpellAvatar} ${SpellAvatarGem} ${CastRetryTime}
/if (${Macro.Return.Equal["CAST_OUTOFRANGE"]}) /varset ATKBuffed${i} 200
/if (${Macro.Return.Equal["CAST_SUCCESS"]}) /varset ATKBuffed${i} ${AvatarDelay}
/return
}
}
/next i
}
/return
| ################# Autofollow ChatController
Sub AutoFollow
/if (!${Spawn[${AutoFollowPC}].ID} || ${Me.Moving} || ${Spawn[${AutoFollowPC}].Distance}<(${afdist}-1))
/return
/call AcquireTarget ${AutoFollowPC} PC FALSE
/if (${Me.Mount.ID} && ${Spawn[${AutoFollowPC}].Distance}>(${afdist}+1)) /dismount
:FollowLoop
/if (!${Target.Name.Equal[${AutoFollowPC}]}) /call AcquireTarget ${AutoFollowPC} PC FALSE
/face fast
/if (${Spawn[${AutoFollowPC}].Distance}>${afdist}) /keypress forward hold
/if (${Spawn[${AutoFollowPC}].Distance}<(${afdist}-1)) /keypress back
/doevents
/if (${Spawn[${AutoFollowPC}].ID} && ${AutoFollow} &&
${Spawn[${AutoFollowPC}].Distance}>${afdist}) /goto :FollowLoop
/keypress forward
/keypress back
/delay 5
/if (${Spawn[${AutoFollowPC}].Distance}>${afdist}) /goto :FollowLoop
/return
| ################# Resets Variables for Zoning/dying etc.
Sub ResetAllVariables
/declare i int local
| ### HoT variables
/varset TankHoTOn 0
/for i 1 to ${GroupHoT.Size}
/varset GroupHoT[${i}] 0
/varset GroupHoTPet[${i}] 0
/next i
| ### Combat Arrays
/for i 1 to ${DebuffArray.Size}
/varset TargetSlow[${i}] NULL
/varset TargetDebuff[${i}] NULL
/varset TargetCrippled[${i}] NULL
/next i
| ### Misc Variables
/varset TargetArray[1] NULL
/varset TargetArray[2] NULL
/varset TargetArray[3] NULL
/varset TargetArray[4] NULL
/varset CombatOn TRUE
/varset Engaged FALSE
/varset MobRooted FALSE
/varset MobMaloed FALSE
/varset MobSlowed FALSE
/varset MobCrippled FALSE
/varset PetOn FALSE
/varset MobDoTed FALSE
/varset MobDoTed2 FALSE
/varset AutoFollow FALSE
/return
| ################## Hungry
Sub Event_Hungry
/if (${Engaged}) /return
/echo I am Hungry
/if (${Verbose}) /gsay Summoning Food, hold pulls for 30 secs.
/declare i int local
/for i 1 to 8
/autoinventory
/delay 1
/call cast ${SpellFOOD} ${MiscGem} ${CastRetryTime}
/next i
/autoinventory
/if (${Verbose}) /gsay Ready for pulls again.
/return
| ################## Thirsty
Sub Event_Thirsty
/if (${Engaged}) /return
/echo I am Thirsty
/if (${Verbose}) /gsay Summoning Drink, hold pulls for 30 secs.
/declare i int local
/for i 1 to 8
/autoinventory
/delay 1
/call cast ${SpellDRINK} ${MiscGem} ${CastRetryTime}
/next i
/autoinventory
/if (${Verbose}) /gsay Ready for pulls again.
/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
/delay 20
/if (${DoShrink}) {
/echo I zoned, time to shrink
/call Shrink_Group
}
/call ResetAllVariables
/return
| ################## Group Invite
Sub Event_Invited
/invite
/return
| ################## I Died
Sub Event_ImDead
/echo I have died. And the Angels wept.
/call ResetAllVariables
/call MemSpells
/if (${Verbose}) /gsay Ready for res.
/call Wait4Rez
/delay 20
| We do some short meditate before we start again.
/if (${Me.State.Equal[Stand]}) /sit
:Meditate
/delay 1s
/if (${Me.CurrentMana}<${MathCalc[${Spell[${SpellHoT}].Mana}+100]}) /goto :Meditate
/return
| #################
| ################# Tells n Hells
| #################
Sub Event_Chat(string ChatType,string ChatSender,string ChatText)
/if (!${Select[${ChatType},GROUP,TELL,RAID]} || ${ChatSender.Equal[${Me.Pet.CleanName}]} ||
(${Me.Invis} && !${Select[${ChatText},autofollow,breakinvis]}) || ${Select[${ChatText},I,NULL]} ||
(!${Spawn[${ChatSender}].ID} &&
!${Select[${ChatSender},${ChatController},${MasterArray[1]},${MasterArray[2]},${MasterArray[3]},${Maste
rArray[4]},${MasterArray[5]}]})) /return
/if (!${BuffBot}) {
/if
(!${Select[${ChatSender},${ChatController},${MasterArray[1]},${MasterArray[2]},${MasterArray[3]},${Mast
erArray[4]},${MasterArray[5]}]}) {
/if (${ChatType.Equal[TELL]}) {
/1 <TELL> [${ChatSender}]: ${ChatText}
/return
}
/if (${ChatType.Equal[GROUP]} && ${GroupChatRelay}) {
/1 <GROUP CHAT> [${ChatSender}]: ${ChatText}
/if (!${DoGroupCommands}) /return
}
/if (${ChatType.Equal[RAID]} && ${RaidChatRelay}) {
/1 <RAID CHAT> [${ChatSender}]: ${ChatText}
/return
}
}
}
/if (${ShamanFD} && (${ChatText.Equal[breakfd]} &&
${Select[${ChatSender},${ChatController},${MasterArray[1]},${MasterArray[2]},${MasterArray[3]},${Maste
rArray[4]},${MasterArray[5]}]})) {
/varset ShamanFD FALSE
/stand
/return
} else /if (${ShamanFD}) {
/return
}
/if (${Select[${ChatText},breakinvis]} &&
${Select[${ChatSender},${ChatController},${MasterArray[1]},${MasterArray[2]},${MasterArray[3]},${Maste
rArray[4]},${MasterArray[5]}]}) {
/call AcquireTarget ${Me} PC FALSE
/if (${Target.Type.Equal[PC]}) {
/cast ${SpellHoTGemNum}
/call Interrupt
}
/return
}
| ################# Heal Requests
/if (${Select[${ChatText},heal,healme]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/if (${VerboseTell}) /tell ${ChatSender} ${SpellHeal} is incoming !!
/call cast ${SpellHeal} ${SpellHealGem} ${CastRetryTime)
}
/return
}
/if (${Select[${ChatText},hot,hotme]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/if (${VerboseTell}) /tell ${ChatSender} ${SpellHoT} is incoming !!
/call cast ${SpellHoT} ${SpellHoTGem} ${CastRetryTime}
}
/return
}
| ################# Mob Requests
/if (${Select[${ChatText},slow,add]}) {
/call AcquireTarget ${ChatSender} NPC TRUE
/if (${Target.Type.Equal[NPC]} && ${Target.Distance}<=${AssistAt}) {
/if (${DoMalo}) /call cast ${SpellMalo} ${SpellMaloGem} ${CastRetryTime}
/if (${DoMalo} && ${VerboseTell}) /tell ${ChatSender} %t has had ${SpellMalo} cast on it.
:Slow_Loop2
/call cast ${SpellSlow} ${SpellSlowGem} ${CastRetryTime}
/if (${Macro.Return.Equal["CAST_INTERRUPTED"]}) /goto :Slow_Loop2
/if (${Macro.Return.Equal["CAST_IMMUNE"]}) {
/if (${VerboseTell}) /tell ${ChatSender} << %t >> is IMMUNE to slow.
/call Addto_Slow
}
/if (${Macro.Return.Equal["CAST_RESISTED"]}) {
/if (!${FastSlow}) {
/if (${VerboseTell}) /tell ${ChatSender} << %t >> has RESISTED slow..
}
}
/if (${Macro.Return.Equal["CAST_SUCCESS"]}) {
/if (${VerboseTell}) /tell ${ChatSender} << %t >> has had ${SpellSlow} cast on it.
/call Addto_Slow
}
}
/return
}
/if (${Select[${ChatText},root]}) {
/call AcquireTarget ${ChatSender} NPC TRUE
/if (${Target.Type.Equal[NPC]} && ${Target.Distance}<=${AssistAt}) {
/call cast ${SpellRoot} ${MiscGem} ${CastRetryTime}
/if (${VerboseTell}) /tell ${ChatSender} %t is Rooted with ${SpellRoot}
}
/return
}
/if (${Select[${ChatText},nuke,boom]}) {
/call AcquireTarget ${ChatSender} NPC TRUE
/if (${Target.Type.Equal[NPC]} && ${Target.Distance}<=${AssistAt}) /call cast ${SpellNuke}
${SpellNukeGem} ${CastRetryTime}
/return
}
/if (${Select[${ChatText},dot]}) {
/call AcquireTarget ${ChatSender} NPC TRUE
/if (${Target.Type.Equal[NPC]} && ${Target.Distance}<=${AssistAt}) /call cast ${SpellDoT}
${SpellDoTGem} ${CastRetryTime}
/return
}
/if (${Select[${ChatText},dot2]}) {
/call AcquireTarget ${ChatSender} NPC TRUE
/if (${Target.Type.Equal[NPC]} && ${Target.Distance}<=${AssistAt}) /call cast ${SpellDoT2}
${SpellDoT2Gem} ${CastRetryTime}
/return
}
/if (${Select[${ChatText},clicky]}) {
/call AcquireTarget ${ChatSender} NPC TRUE
/if (${Target.Type.Equal[NPC]} && ${Target.Distance}<=${AssistAt}) /call cast ${ItemClickyDot} item
${CastRetryTime}
/return
}
/if (${Select[${ChatText},epic]}) {
/call AcquireTarget ${ChatSender} NPC TRUE
/if (${Target.Type.Equal[NPC]} && ${Target.Distance}<=${AssistAt}) /call cast "Spear of Fate" item
${CastRetryTime}
/return
}
/if (${Select[${ChatText},epic2]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
| - need to check if there
/call cast "Crafted Talisman of Fates" "item" ${CastRetryTime}
}
/return
}
/if (${Select[${ChatText},aid]} && ${Me.AltAbilityReady[447]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) /call cast "447" alt
/return
}
| ################# buffs ok to ask for in combat
/if (${Select[${ChatText},panther,pan]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) /call cast ${SpellPanther}
${MiscGem}
/return
}
/if (${Select[${ChatText},haste]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/if (${VerboseTell}) /tell ${ChatSender} << ${SpellHASTE} >> is being cast on you.
/call Cast_HASTE
}
/return
}
/if (${Select[${ChatText},rc,radiant]} && ${Me.AltAbilityReady[153]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) /call cast "153" alt
/return
}
| ################# autofollow request & MakeCamp
/if (${Select[${ChatText},autofollow]} &&
${Select[${ChatSender},${ChatController},${MasterArray[1]},${MasterArray[2]},${MasterArray[3]},${Maste
rArray[4]},${MasterArray[5]}]}) {
/varset AutoFollowPC ${ChatSender}
/if (${AutoFollow}==0) {
/varset AutoFollow TRUE
/if (${DoCamp}) /makecamp off
} else {
/varset AutoFollow FALSE
/if (${DoCamp}) /makecamp on
}
/echo Auto Follow: ${AutoFollow}
/return
}
/if (${Select[${ChatText},camphere,camp]} && ${ChatSender.Equal[${ChatController}]} && ${DoCamp}) {
/makecamp on
/echo New Camp Set
/return
}
/if (${Engaged}) /return
| ################# Buff Requests
/if (${Select[${ChatText},invis]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/if (${VerboseTell}) /tell ${ChatSender} ${SpellInvis} is incoming to you ${ChatSender}.
/call cast ${SpellInvis} ${MiscGem} ${CastRetryTime}
}
/return
}
/if (${Select[${ChatText},selfinvis]}) {
/call AcquireTarget ${Me} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/call cast ${SpellInvisSelf} ${MiscGem} ${CastRetryTime}
}
/return
}
/if (${Select[${ChatText},res,rez,resme,rezme]} && ${Me.AltAbilityReady[404]}) {
/call AcquireTarget ${ChatSender} CORPSE TRUE
/if (${Target.Type.Equal[CORPSE]} && ${Target.Distance}<=${AssistAt}) {
/if (${VerboseTell}) /tell ${Target.CleanName} incoming SHAMAN rez, DO NOT LOOT ALL OF
YOUR CORPSE!
/call cast "404" alt
}
/return
}
/if (${Select[${ChatText},avatar,champion,champ]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/if (${SpellGAvatar.NotEqual[NULL]}) {
/if (${VerboseTell}) /tell ${ChatSender} <<< ${SpellGAvatar} >> is being cast on the group now.
/call cast ${SpellGAvatar} ${SpellGAvatarGem} ${CastRetryTime}
} else {
/if (${VerboseTell}) /tell ${ChatSender} <<< ${SpellAvatar} >> is being cast on you.
/call cast ${SpellAvatar} ${SpellAvatarGem} ${CastRetryTime}
}
}
/return
}
/if (${Select[${ChatText},pr,tribunal,trib]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/if (${VerboseTell}) /tell ${ChatSender} ${SpellPR} is incoming to you ${ChatSender}.
/call cast ${SpellPR} ${MiscGem} ${CastRetryTime}
}
/return
}
/if (${Select[${ChatText},focus,wunshi]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/if (${VerboseTell}) /tell ${ChatSender} ${SpellFOCUS} is incoming to you ${ChatSender}.
/call cast ${SpellFOCUS} ${MiscGem} ${CastRetryTime}
}
/return
}
/if (${Select[${ChatText},cha]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/if (${VerboseTell}) /tell ${ChatSender} ${SpellCHA} is incoming to you ${ChatSender}.
/call cast ${SpellCHA} ${MiscGem} ${CastRetryTime}
}
/return
}
/if (${Select[${ChatText},lev,levitate]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/if (${VerboseTell}) /tell ${ChatSender} ${SpellLEV} is incoming to you ${ChatSender}.
/call cast ${SpellLEV} ${MiscGem} ${CastRetryTime}
}
/return
}
/if (${Select[${ChatText},sow]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/if (${VerboseTell}) /tell ${ChatSender} ${SpellSOW} is incoming to you ${ChatSender}.
/call cast ${SpellSOW} ${MiscGem} ${CastRetryTime}
}
/return
}
/if (${Select[${ChatText},grow]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/if (${VerboseTell}) /tell ${ChatSender} ${SpellGROW} is incoming to you ${ChatSender}.
/call cast ${SpellGROW} ${MiscGem} ${CastRetryTime}
}
/return
}
/if (${Select[${ChatText},shrink,shrinkme]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/if (${VerboseTell}) /tell ${ChatSender} ${SpellSHRINK} is incoming to you ${ChatSender}.
/call cast ${SpellSHRINK} ${MiscGem} ${CastRetryTime}
}
/return
}
/if (${Select[${ChatText},shrinkgroup,shrinkus]}) {
/call Shrink_Group
/return
}
/if (${Select[${ChatText},acumen]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/if (${VerboseTell}) /tell ${ChatSender} ${SpellSEE} is incoming to you ${ChatSender}.
/call cast ${SpellSEE} ${MiscGem} ${CastRetryTime}
}
/return
}
/if (${Select[${ChatText},str,might,strength]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/if (${VerboseTell}) /tell ${ChatSender} ${SpellSTR} is incoming to you ${ChatSender}.
/call cast ${SpellSTR} ${MiscGem} ${CastRetryTime}
}
/return
}
/if (${Select[${ChatText},dex]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/if (${VerboseTell}) /tell ${ChatSender} ${SpellDEX} is incoming to you ${ChatSender}.
/call cast ${SpellDEX} ${MiscGem} ${CastRetryTime}
}
/return
}
/if (${Select[${ChatText},sta,fort,fortitude]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/if (${VerboseTell}) /tell ${ChatSender} ${SpellSTA} is incoming to you ${ChatSender}.
/call cast ${SpellSTA} ${MiscGem} ${CastRetryTime}
}
/return
}
/if (${Select[${ChatText},sense,agi]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/if (${VerboseTell}) /tell ${ChatSender} ${SpellAGI} is incoming to you ${ChatSender}.
/call cast ${SpellAGI} ${MiscGem} ${CastRetryTime}
}
/return
}
/if (${Select[${ChatText},regen]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/if (${VerboseTell}) /tell ${ChatSender} ${SpellREGEN} is incoming to you ${ChatSender}.
/call cast ${SpellREGEN} ${MiscGem} ${CastRetryTime}
}
/return
}
/if (${Select[${ChatText},pe]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/if (${VerboseTell}) /tell ${ChatSender} ${SpellPE} is incoming to you ${ChatSender}.
/call cast ${SpellPE} ${MiscGem} ${CastRetryTime}
}
/return
}
/if (${Select[${ChatText},ac]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/if (${VerboseTell}) /tell ${ChatSender} ${SpellAC} is incoming to you ${ChatSender}.
/call cast ${SpellAC} ${MiscGem} ${CastRetryTime}
}
/return
}
| ################# Group Buff Requests
/if (${Select[${ChatText},ghaste,grouphaste,marshmallows,marshmallow]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/if (${VerboseTell}) /tell ${ChatSender} ${SpellGHASTE} is incoming to you ${ChatSender}.
/call cast ${SpellGHASTE} ${MiscGem} ${CastRetryTime}
}
/return
}
/if (${Select[${ChatText},gfocus,groupfocus,gwunshi,groupwunshi]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/if (${VerboseTell}) /tell ${ChatSender} ${SpellGFOCUS} is incoming to you ${ChatSender}.
/call cast ${SpellGFOCUS} ${MiscGem} ${CastRetryTime}
}
/return
}
/if (${Select[${ChatText},gsta,groupsta,gfort,groupfort]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/if (${VerboseTell}) /tell ${ChatSender} ${SpellGSTA} is incoming to you ${ChatSender}.
/call cast ${SpellGSTA} ${MiscGem} ${CastRetryTime}
}
/return
}
/if (${Select[${ChatText},gagi,groupagi,gsense,groupsense]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/if (${VerboseTell}) /tell ${ChatSender} ${SpellGAGI} is incoming to you ${ChatSender}.
/call cast ${SpellGAGI} ${MiscGem} ${CastRetryTime}
}
/return
}
/if (${Select[${ChatText},gregen,groupregen]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/if (${VerboseTell}) /tell ${ChatSender} ${SpellGREGEN} is incoming to you ${ChatSender}.
/call cast ${SpellGREGEN} ${MiscGem} ${CastRetryTime}
}
/return
}
/if (${Select[${ChatText},gstr,groupstr,gmight,groupmight]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/if (${VerboseTell}) /tell ${ChatSender} ${SpellGSTR} is incoming to you ${ChatSender}.
/call cast ${SpellGSTR} ${MiscGem} ${CastRetryTime}
}
/return
}
/if (${Select[${ChatText},champ,champion]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/if (${VerboseTell}) /tell ${ChatSender} ${SpellCHAMP} is incoming to you ${ChatSender}.
/call cast ${SpellCHAMP ${MiscGem} ${CastRetryTime}
}
/return
}
| ################# All Buffs Request for Target (ChatController or Masters only)
/if (${Select[${ChatText},bufftarget,bufftar]} &&
${Select[${ChatSender},${ChatController},${MasterArray[1]},${MasterArray[2]},${MasterArray[3]},${Maste
rArray[4]},${MasterArray[5]}]}) {
/echo Request for Buffing Sender's Target
/call AcquireTarget ${ChatSender} PC TRUE
/call SingleBuffs ${ChatSender}
/return
}
| ################# All Buffs Request
/if (${Select[${ChatText},buff,buffme,buffs]}) {
/echo Request for Single Buff
/call AcquireTarget ${ChatSender} PC FALSE
/call SingleBuffs ${ChatSender}
/return
}
| ################# Group Buff other group
/if (${Select[${ChatText},buffthem]}) {
/declare i int local
/echo Request for Single Buff other
/call AcquireTarget ${ChatSender} PC TRUE
/if (${Target.Type.NotEqual[PC]}) /return
/for i 1 to ${SpellGroupBuff.Size}
/if (${SpellGroupBuff[${i}].Equal[NULL]}) /next i
/if (${Spell[${SpellGroupBuff[${i}]}].Mana} > ${Me.CurrentMana}) {
/echo DAMN.. LowOnMana... Cannibalizing to rebuff
:Hold_Group_Rebuff
/Call LowOnMana
/if (${Spell[${SpellGroupBuff[${i}]}].Mana} > ${Me.CurrentMana}) /goto :Hold_Group_Rebuff
}
/delay ${AssistDelay}
/echo >>> Hang on ! Rebuffing ${SpellGroupBuff[${i}]}
/if (${VerboseTell}) /tell ${ChatSender} Buffing ${Target.CleanName}'s group with <<
${SpellGroupBuff[${i}]} >> now.
/call cast ${SpellGroupBuff[${i}]} ${MiscGem} ${CastRetryTime}
/next i
/return
}
| ################# Other Pet Buffing
/if (${Select[${ChatText},buffpet]}) {
/declare i int local
/echo Request for Pet Buffs
/call AcquireTarget ${Spawn[pc ${ChatSender}].Pet.Name} PET FALSE
/if (${Target.Type.NotEqual[PET]}) /return
/if (${VerboseTell}) /tell ${ChatSender} Buffing your pet ${Target.CleanName} with << ${SpellHASTE} >>
now.
/call Cast_HASTE
/call AcquireTarget ${Spawn[pc ${ChatSender}].Pet.Name} PET FALSE
/if (${Target.Type.NotEqual[PET]}) /return
/for i 1 to ${SpellPetBuffo.Size}
/if (${Spell[${SpellPetBuffo[${i}]}].Mana} > ${Me.CurrentMana}) {
/echo DAMN.. LowOnMana... Cannibalizing to rebuff
:Hold_Pet_Rebuff
/Call LowOnMana
/if (${Spell[${SpellPetBuffo[${i}]}].Mana} > ${Me.CurrentMana}) /goto :Hold_Pet_Rebuff
}
/echo >>> Hang on ! Rebuffing ${SpellPetBuffo[${i}]}
/if (${VerboseTell}) /tell ${ChatSender} Buffing your pet ${Target.CleanName} with <<
${SpellPetBuffo[${i}]} >> now.
/call cast ${SpellPetBuffo[${i}]} ${MiscGem} ${CastRetryTime}
/next i
/return
}
| ################### Go Home
/if (${Select[${ChatText},gatenow,gate]} && ${ChatType.Equal[TELL]} &&
${Select[${ChatSender},${ChatController},${MasterArray[1]},${MasterArray[2]},${MasterArray[3]},${Maste
rArray[4]},${MasterArray[5]}]}) {
/call cast ${SpellGATE} ${MiscGem}
/return
}
/if (${ChatType.Equal[TELL]}) {
/1 Command not recognized:
/1 ${ChatText}
/1 Ignoring.
/return
}
/return
| ################### Resets slow/malo arrays - resets HoT flags - rebuffs if DoRebuffs TRUE
Sub Event_Worn_off(string Line, string myspell, string mytarget)
/declare oldt string local
/varset oldt ${Target.ID}
/declare i int local
/echo ${myspell} on ${mytarget} has worn off
/if (${myspell.Equal[${SpellHoT}]}) {
/if (${M_Assist.Equal[${mytarget}]}) /varset TankHoTOn 0
/for i 1 to ${Group.Members}
/if (${Group.Member[${i}].CleanName.Equal[${mytarget}]}) {
/varset GroupHoT[${i}] 0
} else /if (${Group.Member[${i}].Pet.CleanName.Equal[${mytarget}]}) {
/varset GroupHoTPet[${i}] 0
}
/next i
/return
} else /if (${Select[${myspell},${SpellSlow},${SpellMalo},${SpellCripple}]}) {
/if (${myspell.Equal[${SpellMalo}]}) {
/for i 1 to ${TargetDebuff.Size}
/if (${Target.ID}==${TargetDebuff[${i}]}) {
/echo removing ${TargetArray[1]}[${TargetArray[4]}] from Debuff Array
/varset TargetDebuff[${i}] NULL
/varset MobMaloed FALSE
/call DeBuff
/target id ${oldt}
/return
}
/next i
} else /if (${myspell.Equal[${SpellSlow}]}) {
/for i 1 to ${TargetSlow.Size}
/if (${Target.ID}==${TargetSlow[${i}]}) {
/echo removing ${TargetArray[1]}[${TargetArray[4]}] from Slow Array
/varset TargetSlow[${i}] NULL
/varset MobSlowed FALSE
/call Slow
/target id ${oldt}
/return
}
/next i
} else /if (${myspell.Equal[${SpellCripple}]}) {
/for i 1 to ${TargetCripple.Size}
/if (${Target.ID}==${TargetCripple[${i}]}) {
/echo removing ${TargetArray[1]}[${TargetArray[4]}] from Cripple Array
/varset TargetCripple[${i}] NULL
/varset MobCrippleed FALSE
/call Debuff
/target id ${oldt}
/return
}
/next i
}
} else /if (${DoRebuffs} && ${myspell.Equal[${SpellHASTE}]}) {
/varset oldt ${Target.ID}
/call AcquireTarget ${mytarget} PC FALSE
/if (${Target.CleanName.Equal[${mytarget}]} && ${Target.Distance}<${Spell[${SpellHASTE}].Range}) {
/if (${VerboseTell}) /tell ${mytarget} Rebuffing << ${SpellHASTE} >> on you now.
/call cast ${SpellHASTE} ${MiscGem} ${CastRetryTime}
}
/target id ${oldt}
/return
} else {
/if (!${DoRebuffs} || ${Engaged}) /return
/for i 1 to ${RefreshThisBuff.Size}
/if (${myspell.Equal[${RefreshThisBuff[${i}]}]}) {
/varset oldt ${Target.ID}
/call AcquireTarget ${mytarget} PC FALSE
/if (${Target.CleanName.Equal[${mytarget}]} &&
${Target.Distance}<${Spell[${RefreshThisBuff[${i}]}].Range}) {
:Hold_cast_Rebuff
/Call LowOnMana
/if (${Spell[${RefreshThisBuff[${i}]}].Mana} > ${Me.CurrentMana}) /goto :Hold_cast_Rebuff
/if (${VerboseTell}) /tell ${mytarget} Rebuffing << ${RefreshThisBuff[${i}]} >> on you now.
/call cast ${RefreshThisBuff[${i}]} ${MiscGem} ${CastRetryTime}
}
/target id ${oldt}
/return
}
/next i
/target id ${oldt}
/return
}
/return
| ################### This will check whenever the player is changing any variable via /echo
Sub Event_ToggleVariable(string Line, string Command, string Command2)
/declare i int local
| ### Toggle Variables & Set Variables
/if (${Defined[${Command}]}) {
/if (${Command2.NotEqual[NULL]}) {
/varset ${Command} ${Command2}
} else /if (${${Command}}) {
/varset ${Command} FALSE
} else {
/varset ${Command} TRUE
}
/echo Set ${Command}: ${${Command}}
/1 Set ${Command}: ${${Command}}
/return
}
| ### Customized Commands
/if (${Command.Equal[SetDoCamp]}) {
/if (${DoCamp}) {
/varset DoCamp FALSE
/makecamp off
} else {
/varset DoCamp TRUE
}
/echo Set ${Command}: ${${Command}}
/1 Set ${Command}: ${${Command}}
/return
}
/if (${Command.Equal[SetAutoFollow]}) {
/if (${Command2}) {
/if (${Command2}<10) {
/varset afdist 10
} else /if (${Command2}>100) {
/varset afdist 100
} else /if ((${Command2}>9) && (${Command2}<101)) {
/varset afdist ${Command2}
}
} else /if (${AutoFollow}==0) {
/varset AutoFollow TRUE
} else {
/varset AutoFollow FALSE
}
/echo Auto Follow: ${AutoFollow}
/1 Auto Follow: ${AutoFollow}
/echo AF Distance: ${afdist}
/1 AF Distance: ${afdist}
/return
}
/if (${Command.Equal[SwitchSlow]}) {
/if (${Select[${SpellSlow},${SpellShortSlow}]}) {
/varset SpellSlow ${SpellLongSlow}
} else {
/varset SpellSlow ${SpellShortSlow}
}
/echo Now Slowing with: ${SpellSlow}
/1 Now Slowing with: ${SpellSlow}
/return
}
/if (${Command.Equal[AddMaster]}) {
/for i 1 to 5
/if (${MasterArray[${i}].Equal[NULL]}) {
/varset MasterArray[${i}] ${Command2}
/echo ${Command2} added as a Master
/1 ${Command2} added as a Master
/return
} else /if (${MasterArray[${i}].Equal[${Command2}]}) {
/echo ${Command2} is already a Master
/1 ${Command2} is already a Master
/return
}
/next i
/echo Master List full, ${Command2} was not added.
/1 Master List full, ${Command2} was not added.
/return
}
/if (${Command.Equal[RemoveMaster]}) {
/for i 1 to 5
/if (${MasterArray[${i}].Equal[${Command2}]}) {
/varset MasterArray[${i}] NULL
/echo ${Command2} has been removed from the master list.
/1 ${Command2} has been removed from the master list.
/return
}
/next i
/echo ${Command2} was not listed in the master list.
/1 ${Command2} was not listed in the master list.
/return
}
/if (${Command.Equal[ClearMasters]}) {
/for i 1 to ${MasterArray.Size}
/varset MasterArray[${i}] NULL
/next i
/return
}
/if (${Command.Equal[ListMasters]}) {
/echo Current Masters are:
/1 Current Masters are:
/for i 1 to ${MasterArray.Size}
/if (${MasterArray[${i}].NotEqual[NULL]}) {
/echo ${MasterArray[${i}]}
/1 ${MasterArray[${i}]}
}
/next i
/return
}
/if (${Command.Equal[ResetHot]}) {
/varset TankHoTOn 0
/for i 1 to ${GroupHoT.Size}
/varset GroupHoT[${i}] 0
/varset GroupHoTPet[${i}] 0
/next i
/return
}
/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 Cripple:...........${DoCripple} - 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:...............${DoPet}
/echo Do Buffs:.............${DoGroupBuffs}
/echo Do Rebuffs:...........${DoRebuffs}
/echo Do Root:..............${DoRoot} - Casting at: ${Rootat}%
/echo Do Sow:...............${DoSow}
/echo Do Heal:..............${DoHeal}
/echo Do HoT:...............${DoHoT}
/echo Heal Tank:............${HealTank}
/echo Heal Group:...........${HealGroup}
/echo Heal Pets:............${HealPets}
/echo Do Buff Pet:..........${DoBuffPet}
/echo Do Avatar:............${DoAvatar} - Casts ${SpellAvatar} on melee members of group during
combat
/echo Do Shrink:............${DoShrink}
/echo Do Panther:...........${DoPantherPets} - Cast ${SpellPanther} on request during combat
/echo Do Panther Group:.....${DoPantherGroup} - Casts ${SpellPanther} on melee members of
group during combat
/echo Auto Follow:..........${AutoFollow} - Following at distance of: ${afdist}
/echo Do Cannibalization:...${Cannibalization}
/echo Do Mount:.............${DoMount}
/echo ---------------------------
/echo Assist range: ${AssistAt}
/echo Assisting: ${M_Assist}
/echo Heal MA at: ${TankHeal}%
/echo HoT MA at: ${TankHoT}%
/echo Heal Casters at: ${CasterHeal}%
/echo HoT Casters at: ${CasterHoT}%
/echo Heal Melee at: ${MeleeHeal}%
/echo HoT Melee at: ${MeleeHoT}%
/echo Initiate Combat: ${CombatAt}%
/echo Verbose: ${Verbose}
/echo Casting DoTs at: ${CastDoTat}
/echo Stop Casting DoTs at: ${Dotmana}% mana
/echo Root Mob at: ${Rootat}
/echo Nuke Mob at: ${NukeAt}
/echo Stop Nuking at: ${NukeMana}% mana
/echo Stop Casting Panther/Leopard at: ${PantherSkip}% of mobs health
/echo Healing Pets at: ${PetHeal}
/echo HOT Pets at: ${PetHoT}
/echo Autofollow distance is: ${afdist}
/echo
/echo help - Will show help to set variables.
/1 ---------------------------
/1 Do Malo:..............${DoMalo} - Casting at: ${CombatAt}% (Initiate Combat*, higher then 99 is no
good)
/1 Do Slow:..............${DoSlow} - Casting at: ${CombatAt}% (Initiate Combat*, higher then 99 is no
good)
/1 Do Cripple:...........${DoCripple} - Casting at: ${CombatAt}% (Initiate Combat*, higher then 99 is
no good)
/1 Do Fastslow:..........${FastSlow} - (Will only try to slow once!)
/1 Do Nuke:..............${DoNuke} - Casting at: ${NukeAt}% (Will chain nuke mob to death)
/1 Do Dot:...............${DoDoT} - Casting at: ${CastDoTat}%
/1 Do Pet:...............${DoPet}
/1 Do Buffs:.............${DoGroupBuffs}
/1 Do Rebuffs:...........${DoRebuffs}
/1 Do Root:..............${DoRoot} - Casting at: ${Rootat}%
/1 Do Sow:...............${DoSow}
/1 Do Heal:..............${DoHeal}
/1 Do HoT:...............${DoHoT}
/1 Heal Tank:............${HealTank}
/1 Heal Group:...........${HealGroup}
/1 Heal Pets:............${HealPets}
/1 Do Buff Pet:..........${DoBuffPet}
/1 Do Avatar:............${DoAvatar} - Casts ${SpellAvatar} on melee members of group during combat
/1 Do Shrink:............${DoShrink}
/1 Do Panther:...........${DoPantherPets} - Cast ${SpellPanther} on request during combat
/1 Do Panther Group:.....${DoPantherGroup} - Casts ${SpellPanther} on melee members of group
during combat
/1 Auto Follow:..........${AutoFollow} - Following at distance of: ${afdist}
/1 Do Cannibalization:...${Cannibalization}
/1 Do Mount:.............${DoMount}
/1 ---------------------------
/1 Assist range: ${AssistAt}
/1 Assisting: ${M_Assist}
/1 Heal MA at: ${TankHeal}%
/1 HoT MA at: ${TankHoT}%
/1 Heal Casters at: ${CasterHeal}%
/1 HoT Casters at: ${CasterHoT}%
/1 Heal Melee at: ${MeleeHeal}%
/1 HoT Melee at: ${MeleeHoT}%
/1 Initiate Combat: ${CombatAt}%
/1 Verbose: ${Verbose}
/1 Casting DoTs at: ${CastDoTat}
/1 Stop Casting DoTs at: ${Dotmana}% mana
/1 Root Mob at: ${Rootat}
/1 Nuke Mob at: ${NukeAt}
/1 Stop Nuking at: ${NukeMana}% mana
/1 Stop Casting Panther/Leopard at: ${PantherSkip}% of mobs health
/1 Healing Pets at: ${PetHeal}
/1 HOT Pets at: ${PetHoT}
/1 Autofollow distance is: ${afdist}
/1
/1 help - Will show help to set variables.
}
/if (${Command.Equal[help]}) {
/echo <<< Shambot V3.13 Script Help >>>
/echo
/echo Commands that will turn ON or OFF
/echo heal, hot, malo, slow, fastslow, root, pet, buffpet, dot, nuke, buffs, rebuffs, sow, verbose,
shrink
/echo pantherpets, panthergroup, avatar, shrink, resethot, HealGroup, HealPets, HealTank,
lootmobs, group chat
/echo raidchat, cripple, clearmasters
/echo
/echo autofollow #: Will toggle TRUE/FALSE if no paramater is given.
/echo Will set Auto Follow distance if # paramater is given (minimum=100,
maximum=100).
/echo
/echo addmaster <pc name> - adds a person to the master list and this person is able to
manipulate bot
/echo removemaster <pc name> - removes a single person from the master list
/echo
/echo Commands that switch settings or spells
/echo shortslow, longslow, switchslow
/echo
/echo Commands to change values, ie: assistat 50 (Will start the combat routine when mob is in
range 50)
/echo assistat <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 hottankat <% hps>
/echo hotmeeleat <% hps>
/echo hotcastersat <% hps>
/echo setma <PC Name>
/echo nukeat <% hps>
/echo dotat <% hps>
/echo rootat <% hps>
/echo healpetsat <% hps>
/echo hotpetsat <% hps>
/1 <<< Shambot V3.13 Script Help >>>
/1
/1 Commands that will turn ON or OFF
/1 heal, hot, malo, slow, fastslow, root, pet, buffpet, dot, nuke, buffs, rebuffs, sow, verbose, shrink
/1 pantherpets, panthergroup, avatar, shrink, resethot, HealGroup, HealPets, HealTank, lootmobs,
group chat
/1 raidchat, cripple, clearmasters
/1
/1 autofollow #: Will toggle TRUE/FALSE if no paramater is given.
/1 Will set Auto Follow distance if # paramater is given (minimum=10, maximum=100).
/1
/1 addmaster <pc name> - adds a person to the master list and this person is able to manipulate
bot
/1 removemaster <pc name> - removes a single person from the master list
/1
/1 Commands that switch settings or spells
/1 shortslow, longslow, switchslow
/1
/1 Commands to change values, ie: assistat 50 (Will start the combat routine when mob is in range
50)
/1 assistat <range> - Most spells don't go longer then 100
/1 combatat <% hps> - Initiate Combat when mob is at % HPs
/1 healtankat <% hps>
/1 healmeeleat <% hps>
/1 healcastersat <% hps>
/1 hottankat <% hps>
/1 hotmeeleat <% hps>
/1 hotcastersat <% hps>
/1 setma <PC Name>
/1 nukeat <% hps>
/1 dotat <% hps>
/1 rootat <% hps>
/1 healpetsat <% hps>
/1 hotpetsat <% hps>
}
/return
Last edited:
