hi im using this shaman macro which i absolutely love not sure who made it but for some reason it tries to heal and hot the mobs would really appreciate it if someone could take a look at it for me id really appreciate it. Hopefully someone can help me out here its driving me crazy healing mobs and not my own group members.
P.S. this was the shaman mac from i beleive it was siddin's 6 box macros working great other than healing mobs.
P.S. this was the shaman mac from i beleive it was siddin's 6 box macros working great other than healing mobs.
Rich (BB code):
#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 "#*# has become ENRAGED#*#"
#Event Enrageoff "#*# 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#."
#event Talisman "#*#"Your Talisman of the #1# spell has warn off#*#"
#include Spell_Routines.inc
#include Wait4rez.inc
|#include ninjadvloot.inc
Sub Main
/tar someonelse pc
/declare panthertarget string outer someone
/declare mydeaths int outer 0
| ########### 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 "someone"
/declare ChatController outer "someone"
/declare GroupChatRelay outer TRUE
/declare RaidChatRelay outer FALSE
| ########### Your Spell List - update as needed
| ########### Used for miscellaneous spells
/declare MiscGem outer "gem8"
/declare MiscGemNum outer 8
| ########### Normal Spell Set
/declare SpellCanni outer "Ancestral Hearkening Rk. II"
/declare SpellCanniGem outer "gem1"
/declare SpellCanniGemNum outer 1
/declare SpellSlow string outer "Turgur's Swarm"
/declare SpellLongSlow string outer "Turgur's Swarm"
/declare SpellShortSlow string outer "Turgur's Swarm"
/declare SpellSlowGem string outer alt
/declare SpellSlowGemNum outer aa
| /declare SpellSlow outer "Balance of Discord"
| /declare SpellLongSlow outer "Balance of Discord"
| /declare SpellShortSlow outer "Balance of Discord"
| /declare SpellSlowGem outer "gem2
| /declare SpellSlowGemNum outer 2
/declare SpellMalo outer "Malos"
/declare SpellMaloGem outer "gem2"
/declare SpellMaloGemNum outer 2
/declare SpellCripple outer "Feralize"
/declare SpellCrippleGem outer "gem4"
/declare SpellCrippleGemNum outer 4
/declare SpellDoT outer "Juju"
/declare SpellDoTGem outer "gem5"
/declare SpellDoTGemNum outer 5
/declare SpellDoT2 outer "Blood of Yoppa"
/declare SpellDoT2Gem outer "gem3"
/declare SpellDoT2GemNum outer 3
/declare SpellDoT3 outer "Blood of Yoppa"
/declare SpellDoT3Gem outer "gem3"
/declare SpellDoT3GemNum outer 3
/declare SpellNuke outer "Yoppa's Rain of Venom"
/declare SpellNukeGem outer "gem2"
/declare SpellNukeGemNum outer 2
/declare SpellNuke2 outer "Yoppa's Spear of Venom"
/declare SpellNuke2Gem outer "gem3"
/declare SpellNuke2GemNum outer 3
/declare SpellAvatar outer "Champion"
/declare SpellAvatarGem outer "gem9"
/declare SpellAvatarGemNum outer 9
/declare SpellGAvatar outer "Champion"
/declare SpellGAvatarGem outer "gem9"
/declare SpellGAvatarGemNum outer 9
/declare SpellHeal outer "Gemmi's Mending Rk. II"
/declare SpellHealGem outer "gem6"
/declare SpellHealGemNum outer 6
/declare SpellHoT outer "Shade of Renewal"
/declare SpellHoTGem outer "gem7"
/declare SpellHoTGemNum outer 7
/declare SpellPanther outer "Talisman of the Lynx"
/declare SpellPantherGem outer "gem4"
/declare SpellPantherGemNum outer 8
/declare PantherCast outer FALSE
/declare SpellLassitude outer "Lingering Sloth"
/declare SpellLassitudeTimer timer outer 0s
| ########### Miscellaneous Spells (will use MiscGem)
/declare SpellPet outer "Vegu's Faithful rk. ii"
/declare SpellRoot outer "Petrifying Earth"
/declare SpellHASTE outer "Talisman of Celerity"
/declare SpellFOCUS outer "Dire Focusing"
/declare SpellCHA outer "Unfailing Reverence"
/declare SpellDEX outer "Mortal Deftness"
/declare SpellSTR outer "Mammoth's Strength"
/declare SpellAGI outer "Preternatural Foresight"
/declare SpellSTA outer "Spirit of vehemence rk. ii"
/declare SpellREGEN outer "Spirit of the Stoic one"
/declare SpellPE outer "Primal Essence"
/declare SpellPR outer "Talisman of the Tribunal"
/declare SpellAC outer "Ancestral Bulwark"
|- these are group versions of the above spells
/declare SpellGSTR outer "Champion"
/declare SpellGREGEN outer "Talisman of Perseverance"
/declare SpellGAGI outer "talisman of Foresight"
/declare SpellGSTA outer "Talisman of vehemence rk. ii"
/declare SpellGHASTE outer "Talisman of Celerity"
/declare SpellGFOCUS outer "Talisman of the Bloodworg"
/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 "Red Drum"
| ########### Other Pet Buff Spell List
| HASTE handled in Cast_HASTE sub now
| and will be cast on pet
/declare SpellPetBuff[5] string outer
/varset SpellPetBuff[1] ${SpellFOCUS}
/varset SpellPetBuff[2] ${SpellSTR}
/varset SpellPetBuff[3] ${SpellSTA}
/varset SpellPetBuff[4] ${SpellAGI}
/varset SpellPetBuff[5] ${SpellREGEN}
| ############ Group Buff List.
/declare SpellGroupBuff[6] 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}
| ############ 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] ${SpellLassitude}
| ############ Combat Variables
/declare AssistAt int outer 100
/declare CombatAt int outer 98
/declare GroupBuffRange int outer 100
/declare CastDoTat int outer 98
/declare DotMana int outer 40
/declare Rootat int outer 30
/declare RootMana int outer 40
/declare NukeAt int outer 98
/declare NukeMana int outer 30
/declare PantherMana int outer 15
/declare PantherSkip int outer 25
/declare SitAt int outer 20
/declare BuffMana int outer 30
/declare MinMana int outer 15
/declare CanniMinPct int outer 50
/declare AssistDelay int outer 2
/declare CastRetryTime string outer "5s"
/declare pantherdone int outer 0
| ############ Healing Levels
/declare CasterHeal int outer 50
/declare CasterHoT int outer 60
/declare MeleeHeal int outer 60
/declare MeleeHoT int outer 80
/declare TankHeal int outer 60
/declare TankHoT int outer 80
/declare PetHeal int outer 40
/declare PetHoT int outer 70
| ############ Do List
/declare DoMalo bool outer FALSE
/declare DoSlow bool outer TRUE
/declare DoCripple bool outer FALSE
/declare FastSlow bool outer FALSE
/declare DoRoot bool outer FALSE
/declare DoPet bool outer TRUE
/declare DoBuffPet bool outer FALSE
/declare DoDoT bool outer TRUE
/declare DoDoT2 bool outer TRUE
/declare DoDoT3 bool outer FALSE
/declare DoPantherPets bool outer TRUE
/declare DoPantherGroup bool outer TRUE
/declare DoGroupBuffs bool outer TRUE
/declare DoRebuffs bool outer TRUE
/declare DoSow bool outer FALSE
/declare DoNuke bool outer FALSE
/declare DoNuke2 bool outer FALSE
/tgb on
/declare DoGroupCommands bool outer TRUE
/declare panthercast bool outer FALSE
/declare DoHeal bool outer TRUE
/declare DoHoT bool outer TRUE
/declare HealGroup bool outer TRUE
/declare HealPets bool outer TRUE
/declare HealTank bool outer TRUE
/declare DoCanni bool outer TRUE
/declare Cannibalization bool outer TRUE
/declare Verbose bool outer TRUE
/declare VerboseTell bool outer TRUE
/declare DoShrink bool outer FALSE
/declare DoAvatar bool outer FALSE
/declare DoMount bool outer FALSE
/declare DoLoot bool outer TRUE
/declare AutoFollow bool outer FALSE
/declare afdist int outer 25
/declare AutoFollowPC string outer NULL
/declare DoCamp bool outer TRUE
/declare PullPC string outer NULL
| This is a delay for how long Avatar will hold. (8min)
/declare AvatarDelay outer 5350
| This is a delay for how long Panther will hold. (1min about 669)
/declare PantherDelay outer 334
|------------------------------------------------------------
|Loot Array Information.
|------------------------------------------------------------
/declare RV_LootArray[18] string outer
/varset RV_LootArray[1] "Diamond"
/varset RV_LootArray[2] "Legends"
/varset RV_LootArray[3] "nigriventer"
/varset RV_LootArray[4] "sapphire"
/varset RV_LootArray[5] "Spell"
/varset RV_LootArray[6] "Song"
/varset RV_LootArray[7] "Clockwork Gnome Shaft"
/varset RV_LootArray[8] "Clockwork Gnome Spring"
/varset RV_LootArray[9] "Tome"
/varset RV_LootArray[10] "geode"
/varset RV_LootArray[11] "Stabilizer"
/varset RV_LootArray[12] "Clockwork Gnome Bolts"
/varset RV_LootArray[13] "High Quality Steel Gear"
/varset RV_LootArray[14] "Small Clockwork Shaft"
/varset RV_LootArray[15] "Defiant chain"
/varset RV_LootArray[16] "Titanium Gears"
/varset RV_LootArray[17] "Clockwork Gear"
/varset RV_LootArray[18] "Small Clockwork Screws"
| ########### ! 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 /dot3 /echo toggle DoDoT3
/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 /nuke2 /echo toggle DoNuke2
/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 MobDoTed3 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
| ###############
| ############### Main Loop Starts
| ###############
/addmaster someone
/addmaster someone
/addmaster someone
/addmaster someone
/if (!${Target.ID}) /setma someone
: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} && (${Target.Type.Equal[Corpse]}) && (!${Target.Type.Equal["PC"]}) &&(!${Target.Type.Equal["NPC"]}) && !${Me.Moving}) /call Loot
/goto :Main_Loop
/return
| ############### Mem Spells in Spell List
Sub MemSpells
/echo Memming spells. Hang on.
/sit
|** /if (!${Me.Gem[${SpellCanni}]}) {
/memspell ${SpellCanniGemNum} ${SpellCanni}
}
| /if (!${Me.Gem[${SpellSlow}]}) {
| /memspell ${SpellSlowGemNum} ${SpellSlow}
}
/if (!${Me.Gem[${SpellMalo}]} && ${DoMalo}) {
/memspell ${SpellMaloGemNum} ${SpellMalo}
} else /if (!${Me.Gem[${SpellCripple}]}) {
/memspell ${SpellCrippleGemNum} ${SpellCripple}
}
/if (!${Me.Gem[${SpellDoT}]}) {
/memspell ${SpellDoTGemNum} ${SpellDoT}
}
/if (!${Me.Gem[${SpellGAvatar}]} && ${SpellGAvatar.NotEqual[NULL]} && ${DoAvatar}) {
/memspell ${SpellGAvatarGemNum} ${SpellGAvatar}
} else /if (!${Me.Gem[${SpellAvatar}]} && ${DoAvatar}) {
/memspell ${SpellAvatarGemNum} ${SpellAvatar}
} else /if (!${Me.Gem[${SpellNuke}]}) {
/memspell ${SpellNukeGemNum} ${SpellNuke}
}
/if (!${Me.Gem[${SpellHeal}]}) {
/memspell ${SpellHealGemNum} ${SpellHeal}
}
/if (!${Me.Gem[${SpellHoT}]}) {
/memspell ${SpellHoTGemNum} ${SpellHoT}
}
/if (!${Me.Gem[${SpellPanther}]}) {
/memspell ${SpellPantherGemNum} ${SpellPanther}
}
/if (!${Me.Gem[${SpellHASTE}]} && ${MiscGemNum}==9) {
/memspell ${MiscGemNum} ${SpellHASTE}
}
/if (${Window[SpellBookWnd].Open}) /windowstate SpellBookWnd close
**|
/memspellset normal
/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 fast
|- 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} && ${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} && ${MobSlowed} && ${MobCrippled} && ${PantherCast}) /call cast ${SpellNuke} ${SpellNukeGem} ${CastRetryTime}
/if (${CombatOn} && ${DoNuke2} && ${Me.PctMana}>=${NukeMana} && ${Target.PctHPs}<=${NukeAt} && ${MobSlowed} && ${MobCrippled} && ${PantherCast}) /call cast ${SpellNuke2} ${SpellNuke2Gem} ${CastRetryTime}
/if (!${Me.Buff[${SpellPanther}].ID}) /varset PantherCast FALSE
/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 MobDoTed3 FALSE
/varset CombatOn FALSE
/varset Engaged FALSE
/varset pantherdone 0
/pet hold
/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
/if (${DoSlow} && !${MobSlowed}) /return
|- 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 ${SpellDoT2} ${SpellDoT2GemNum}
}
}
/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 ${SpellDoT}${SpellDoTGemNum}
}
}
/if (${Me.PctMana}>=${DotMana} && ${Target.PctHPs}<=${CastDoTat} && ${Target.Distance}<${Spell[${SpellDoT3}].Range} && !${MobDoTed3} && ${DoDoT3}) {
/call cast ${SpellDoT3} ${SpellDoT3Gem} ${CastRetryTime}
/varset MobDoTed3 TRUE
/if (${DoDoT3} && !${Me.Gem[${SpellDoT3}]}) {
/memspell ${SpellDoT3}${SpellDoT3GemNum}
}
}
/return
| ############## CastPanther Line on group
Sub CastPanther
/declare i int local
/if (!${FindItem[Crafted Talisman of Fates].Timer}) /call Cast "Crafted Talisman of Fates" item 0
| /if ((${DoSlow} && !${MobSlowed}) || (${DoCripple} && !${MobCrippled}) || ${Target.Type.NotEqual[NPC]}) /return
/if (${PantherCast}) /return
/if (${Me.CurrentMana}>${Spell[${SpellPanther}].Mana} && ${Target.Distance}<${Spell[${SpellPanther}].Range}) {
:retarget
/target ${panthertarget}
/delay 2
/if (${Target.ID}!=${Spawn[pc ${panthertarget}].ID}) /goto :retarget
/call cast ${SpellPanther} ${SpellPantherGem} ${CastRetryTime}
/varset PanGrp${i} ${PantherDelay}
}
/varset PantherCast TRUE
/varset Engaged True
/return
Sub TryCastPanther
/if (!${FindItem[Crafted Talisman of Fates].Timer}) /call Cast "Crafted Talisman of Fates" item 0
/declare i int local
/for i ${Group.Members} downto ${Group.Members}-1
/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,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}
}
}
/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}
}
}
}
:NEXT
/varset Engaged True
/next i
/return
| ############## Cast_Shrink
Sub Shrink_Group
/if (${Verbose}) /fs 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}) /varset MobCrippled TRUE
/if (${DoCripple} && !${Me.Gem[${SpellCripple}]}) {
/memspell ${SpellCripple} ${SpellCrippleGemNum}
}
} 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]}) {
:Cripple_Loop
/call cast ${SpellCripple} ${SpellCrippleGemNum} 1s
/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}) /fs << %t >> has been CRIPPLED with ${SpellCripple}.
/call Addto_Cripple
/varset MobCrippled TRUE
}
}
}
/if (${DoMalo} && !${Me.Gem[${SpellMalo}]}) {
/memspell ${SpellMalo} ${SpellMaloGemNum}
}
}
/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
/varset Engaged TRUE
/return
}
/next i
:Slow_Loop
/if (${Target.PctHPs}<=${CombatAt} && ${Target.ID}==${TargetArray[4]}) {
| /if (${Me.CurrentMana}<${Spell[${SpellSlow}].Mana}) {
| /echo Not enough mana to --> Slow %t
| } else {
/call cast ${SpellSlow} ${SpellSlowGem} 5s
/if (${Macro.Return.Equal["CAST_INTERRUPTED"]}) /goto :Slow_Loop
/if (${Macro.Return.Equal["CAST_IMMUNE"]}) {
/if (${Verbose}) /fs << %t >> is IMMUNE to slow.
/call Addto_Slow
/varset MobSlowed TRUE
}
/if (${Macro.Return.Equal["CAST_RESISTED"]}) {
/if (!${FastSlow}) {
/if (${Verbose}) /fs << %t >> has RESISTED slow. Trying again.
/goto :Slow_Loop
}
/call Addto_Slow
/varset MobSlowed TRUE
}
/if (${Macro.Return.Equal["CAST_SUCCESS"]}) {
/if (${Verbose}) /fs << %t >> has been SLOWED with ${SpellSlow}.
/call Addto_Slow
/varset MobSlowed TRUE
/varset Engaged 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}-1024)/${Me.MaxHPs}*100<${CanniMinPct}-5) {
/call Interrupt
} else /if (${Me.Casting.Name.Equal[Cannibalization]}&& (${Me.CurrentHPs}-4057)/${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
/declare healgroupdone 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]} && !${npc} && ${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}) /fs << ${SpellHeal} >> on %t
/call cast ${SpellHeal} ${SpellHealGem} 5s
/delay 1s
}
} 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}) /fs << ${SpellHoT} >> on %t
/call cast ${SpellHoT} ${SpellHoTGem} 5s CheckLevels
/delay 1s
/varset healgroupdone 1
/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
}
}
}
/if (${healgroupdone}==1) /return
/next i
/return
|################## Canni 5
Sub Cannibalization
/if ((${Me.CurrentHPs}-4057)/${Me.MaxHPs}*100<${CanniMinPct}) {
/call CheckMyHPs
} else /if (${Cannibalization}) {
/if (${Verbose}) /fs Cannibalization time -- don't be afraid I only eat myself.
/call cast "cannibalization" alt
}
/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}-1024)/${Me.MaxHPs}*100>${CanniMinPct} && !${Engaged}) /call cast ${SpellCanni} ${SpellCanniGem} ${CastRetryTime} CheckLevels
/if (${DoCanni} && ${Cannibalization} && ${Me.AltAbilityReady[47]} && ${Me.CurrentMana}<(${Me.MaxMana}-2248) && ${Me.MaxHPs}>4400) /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}
/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
/return
/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
/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 MobDoTed3 FALSE
/varset AutoFollow FALSE
/return
| ################## Hungry
Sub Event_Hungry
/if (${Engaged}) /return
/echo I am Hungry
/if (${Verbose}) /fs Summoning Food, hold pulls for 30 secs.
/declare i int local
/for i 1 to 8
/autoinventory
/delay 1
/autoinventory
/call cast ${SpellFOOD} ${MiscGem} ${CastRetryTime}
/next i
/autoinventory
/delay 1
/autoinventory
/if (${Verbose}) /fs Ready for pulls again.
/return
| ################## Thirsty
Sub Event_Thirsty
/if (${Engaged}) /return
/echo I am Thirsty
/if (${Verbose}) /fs Summoning Drink, hold pulls for 30 secs.
/declare i int local
/for i 1 to 8
/autoinventory
/delay 1
/autoinventory
/call cast ${SpellDRINK} ${MiscGem} ${CastRetryTime}
/next i
/autoinventory
/delay 1
/autoinventory
/if (${Verbose}) /fs Ready for pulls again.
/return
| ################## ENRAGE ON
Sub Event_Enrageon
/if (${PetOn}) {
/echo Mob is ENRAGED!
/pet back off
/pet hold
}
/return
| ################## ENRAGE OFF
Sub Event_Enrageoff
/if (${PetOn}) {
/echo Mob is no longer Enraged!
/pet attack
}
/doevents flush
/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
:checkdead
/if (${Window[RespawnWnd].Open}) {
/goto :checkdead
} else {
/return
}
/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]},${MasterArray[4]},${MasterArray[5]}]})) /return
| /if (!${BuffBot}) {
| /if (!${Select[${ChatSender},${ChatController},${MasterArray[1]},${MasterArray[2]},${MasterArray[3]},${MasterArray[4]},${MasterArray[5]}]}) {
| /if (${ChatType.Equal[TELL]}) {
| /return
| }
| /if (${ChatType.Equal[GROUP]} && ${GroupChatRelay}) {
| /if (!${DoGroupCommands}) /return
| }
| /if (${ChatType.Equal[RAID]} && ${RaidChatRelay}) {
| /return
| }
| }
| }
/if (${ShamanFD} && (${ChatText.Equal[breakfd]} && ${Select[${ChatSender},${ChatController},${MasterArray[1]},${MasterArray[2]},${MasterArray[3]},${MasterArray[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]},${MasterArray[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} 5s
}
/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} 5s
}
/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},lassitude]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/if (${VerboseTell}) /tell ${ChatSender} ${SpellLassitude} is incoming to you ${ChatSender}.
/call cast ${SpellLassitude} ${MiscGem} ${CastRetryTime}
}
/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
}
/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
}
| ################# autofollow request & MakeCamp
/if (${Select[${ChatText},autofollow]} && ${Select[${ChatSender},${ChatController},${MasterArray[1]},${MasterArray[2]},${MasterArray[3]},${MasterArray[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
}
| ################# All Buffs Request for Target (ChatController or Masters only)
/if (${Select[${ChatText},bufftarget,bufftar]} && ${Select[${ChatSender},${ChatController},${MasterArray[1]},${MasterArray[2]},${MasterArray[3]},${MasterArray[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]},${MasterArray[4]},${MasterArray[5]}]}) {
/call cast ${SpellGATE} ${MiscGem}
/return
}
/if (${ChatType.Equal[TELL]}) {
/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[${SpellDoT}]}) /varset MobDoTed FALSE
/if (${myspell.Equal[${SpellDoT2}]}) /varset MobDoTed2 FALSE
/if (${myspell.Equal[${SpellDoT3}]}) /varset MobDoTed3 FALSE
/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}
/varset i 1
/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}}
/return
}
| ### Customized Commands
/if (${Command.Equal[SetDoCamp]}) {
/if (${DoCamp}) {
/varset DoCamp FALSE
/makecamp off
} else {
/varset DoCamp TRUE
}
/echo 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}
/echo AF Distance: ${afdist}
/return
}
/if (${Command.Equal[SwitchSlow]}) {
/if (${Select[${SpellSlow},${SpellShortSlow}]}) {
/varset SpellSlow ${SpellLongSlow}
} else {
/varset SpellSlow ${SpellShortSlow}
}
/echo Now Slowing with: ${SpellSlow}
/return
}
/if (${Command.Equal[AddMaster]}) {
/for i 1 to 6
/if (${MasterArray[${i}].Equal[NULL]}) {
/varset MasterArray[${i}] ${Command2}
/echo ${Command2} added as a Master
/return
} else /if (${MasterArray[${i}].Equal[${Command2}]}) {
/echo ${Command2} is already a Master
/return
}
/next i
/echo 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.
/return
}
/next i
/echo ${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:
/for i 1 to ${MasterArray.Size}
/if (${MasterArray[${i}].NotEqual[NULL]}) {
/echo ${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.
}
/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>
}
/return
|--------------------------------------------------------------------------------
|SUB: Loot w/ Array
|--------------------------------------------------------------------------------
Sub Loot
/declare LootSlot int inner 0
/declare LootCheck int inner 0
/declare LootTotal int inner 0
:lootstart
/target corpse radius 220
/stick 5 hold
:Moveto
/if (${Target.Distance} > 5) {
/delay 1s
/goto :Moveto
}
/stick off
/loot
/delay 1s
/face fast
/keypress forward
/keypress back
/fastdrop on
/lootn never
/delay 1s
/loot
/delay 1s
/if (!${Corpse.Items}) {
/echo NO LOOT! Cheap Bastard!
/goto :endofloot
}
/varset LootTotal ${Corpse.Items}
/for LootSlot 1 to ${LootTotal}
/nomodkey /shiftkey /itemnotify loot${LootSlot} leftmouseup
/delay 1s
|---------Keep Good Stuff---------------------
/for LootCheck 1 to ${RV_LootArray.Size}
/if (${Cursor.Name.Find[${RV_LootArray[${LootCheck}]}]}) {
/echo Keeping a ${Cursor.Name}... WOOT!
/autoinventory
/delay 1s
}
/next LootCheck
|---------Destroy Bad Stuff-------------------
/if (${Cursor.ID}) {
/echo Destroying a ${Cursor.Name}...
/destroy
/delay 1s
}
/next LootSlot
:endofloot
/notify LootWnd DoneButton leftmouseup
/delay 1s
/target corpse radius 200
/keypress home
/if (${Target.Type.Equal[Corpse]}) {
/goto :lootstart
}
/keypress esc
/delay 3s
/return
Sub CastLassitude
/if (!${SpellLassitudeTimer}) {
/target ${M_Assist}
/call cast "Lassitude Rk. II" gem8 4s
/varset SpellLassitudeTimer 600s
}
/return
sub Event_talisman
/varset PantherCast FALSE
/return
Last edited by a moderator: