- Joined
- Aug 7, 2006
- Messages
- 134
- Reaction score
- 0
- Points
- 0
ok found this bot here some where. and i had to move lines up all over the place dont know why they was down 2 lines from where they spose to be.
any way iam haveing targeting issues i think why it keeps casting the same spell over and over on tank...normally i could prolly figure it out but...ive been up for 2 days. i think the problem is here some where.
ty for any help
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 "#*#|${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
| ########### Default Channel, Controller
/declare CChannel outer "esham"
/declare ChatController outer "Malaras"
/declare GroupChatRelay outer FALSE
/declare RaidChatRelay outer FALSE
| ########### Your Spell List - update as needed
| ########### Used for miscellaneous spells
/declare MiscGem outer "gem1"
/declare MiscGemNum outer 1
| ########### Normal Spell Set
/declare SpellCanni outer "Cannibalize IV"
/declare SpellCanniGem outer "gem4"
/declare SpellCanniGemNum outer 4
/declare SpellSlow outer "Turgur's Insects"
/declare SpellLongSlow outer "Turgur's Insects"
/declare SpellShortSlow outer "Turgur's Insects"
/declare SpellSlowGem outer "gem2"
/declare SpellSlowGemNum outer 2
/declare SpellMalo outer "Malos"
/declare SpellMaloGem outer "gem3"
/declare SpellMaloGemNum outer 3
/declare SpellCripple outer "Cripple"
/declare SpellCrippleGem outer "gem3"
/declare SpellCrippleGemNum outer 3
| /declare SpellDoT outer ""
| /declare SpellDoTGem outer "gem4"
| /declare SpellDoTGemNum outer 4
| /declare SpellDoT2 outer ""
| /declare SpellDoT2Gem outer "gem4"
| /declare SpellDoT2GemNum outer 4
| /declare SpellNuke outer ""
| /declare SpellNukeGem outer "gem5"
| /declare SpellNukeGemNum outer 5
/declare SpellHeal outer "Superior Healing"
/declare SpellHealGem outer "gem6"
/declare SpellHealGemNum outer 6
/declare SpellHoT outer "Stoicism"
/declare SpellHoTGem outer "gem7"
/declare SpellHoTGemNum outer 7
/declare SpellPanther outer "True Spirit"
/declare SpellPantherGem outer "gem8"
/declare SpellPantherGemNum outer 8
| ########### Miscellaneous Spells (will use MiscGem)
/declare SpellPet outer "True spirit"
/declare SpellRoot outer "Petrifying Earth"
| /declare SpellAvatar outer ""
/declare SpellHASTE outer "Alacrity"
/declare SpellFOCUS outer "Harnessing of Spirit"
| /declare SpellCHA outer ""
| /declare SpellDEX outer ""
| /declare SpellSTR outer ""
/declare SpellAGI outer "Agility"
/declare SpellSTA outer "Stamina"
/declare SpellREGEN outer "Chloroplast"
| /declare SpellPE outer ""
| /declare SpellPR outer ""
| /declare SpellAC outer ""
|- these are group versions of the above spells
| /declare SpellGSTR outer ""
| /declare SpellGREGEN outer ""
| /declare SpellGAGI outer ""
| /declare SpellGSTA outer ""
| /declare SpellGHASTE outer ""
| /declare SpellGFOCUS outer ""
/declare SpellSOW outer "Spirit of Bih`Li"
/declare SpellLEV outer "Levitation"
| /declare SpellINV outer ""
/declare SpellSHRINK outer "Shrink"
/declare SpellGSHRINK outer "Tiny Terror"
/declare SpellGROW outer "Grow"
| /declare SpellSEE outer ""
/declare SpellGATE outer "Gate"
/declare SpellFOOD outer "Summon Food"
/declare SpellDRINK outer "Summon Drink"
| - comment out ItemClickyHASTE if you do not have a clicky haste item to buff with.
| /declare ItemClickyHASTE outer ""
| /declare ItemClickyDOT outer ""
| ########### 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[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] ${SpellHASTE}
/varset RefreshThisBuff[2] ${SpellFOCUS}
/varset RefreshThisBuff[3] ${SpellSTR}
/varset RefreshThisBuff[4] ${SpellSTA}
/varset RefreshThisBuff[5] ${SpellAGI}
/varset RefreshThisBuff[6] ${SpellREGEN}
| ############ Combat Variables
/declare AssistAt int outer 100
/declare CombatAt int outer 95
/declare CastDoTat int outer 0
/declare DotMana int outer 0
/declare Rootat int outer 22
/declare RootMana int outer 40
/declare NukeAt int outer 0
/declare NukeMana int outer 0
/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 outer "5s"
| ############ Healing Levels
/declare CasterHeal int outer 50
/declare CasterHoT int outer 80
/declare MeleeHeal int outer 40
/declare MeleeHoT int outer 70
/declare TankHeal int outer 40
/declare TankHoT int outer 70
/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 TRUE
/declare FastSlow bool outer FALSE
/declare DoRoot bool outer FALSE
/declare DoPet bool outer TRUE
/declare DoBuffPet bool outer TRUE
/declare DoDoT bool outer FALSE
/declare DoDoT2 bool outer FALSE
/declare DoPantherPets bool outer TRUE
/declare DoPantherGroup bool outer FALSE
/declare DoBuffs bool outer TRUE
/declare DoRebuffs bool outer TRUE
/declare DoSow bool outer TRUE
/declare DoNuke 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 Cannibalization bool outer TRUE
/declare Verbose bool outer TRUE
/declare DoShrink bool outer TRUE
/declare DoAvatar bool outer FALSE
/declare DoMount bool outer TRUE
/declare DoLoot bool outer FALSE
/declare AutoFollow bool outer FALSE
/declare afdist int outer 25
/declare AutoFollowPC string outer NULL
/declare DoCamp bool outer TRUE
| 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 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 DoBuffs
/squelch /alias /docamp /echo toggle DoCamp
/squelch /alias /cripple /echo toggle DoCripple
/squelch /alias /dot /echo toggle DoDoT
/squelch /alias /dot /echo toggle DoDoT2
/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 /dopet /echo toggle DoPet
/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
| ### Toggles with 2nd Command
/squelch /alias /autofollow /echo toggle AutoFollow
/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
| ### Specific Commands
/squelch /alias /addmaster /echo toggle AddMaster
/squelch /alias /camphere /echo toggle CampHere
/squelch /alias /clearmasters /echo toggle ClearMasters
/squelch /alias /help /echo toggle Help
/squelch /alias /longslow /echo toggle LongSlow
/squelch /alias /removemaster /echo toggle RemoveMaster
/squelch /alias /resethot /echo toggle ResetHot
/squelch /alias /shortslow /echo toggle ShortSlow
/squelch /alias /show /echo toggle Show
/squelch /alias /switchslow /echo toggle SwitchSlow
/squelch /alias /status /echo toggle Show
/declare RemoteControl bool outer FALSE
/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 TankHoTWO 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 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
| /call LoadALINIVals
| ############### 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: assist <PC Name>
/varset M_Assist ${ChatController}
} else {
/if (${Target.CleanName.Equal[${Me.CleanName}]}) {
/echo You cannot assist yourself! using default controller:
${ChatController}
/echo To reset MA do: assist <PC Name>
/varset M_Assist ${ChatController}
} else {
/varset M_Assist ${Target.CleanName}
/echo Assist set to ${M_Assist}
}
}
}
/assist off
/if (${Defined[Param1]}) /varset CChannel ${Param1}
/leaveall
/join ${CChannel}
/1 I am here!
/echo Joined channel ${CChannel}
/if (${Defined[Param2]}) /varset ChatController ${Param2}
/vtell ${ChatController} 005
/tell ${ChatController} I am here!
/echo My master is ${ChatController}
| ###############
| ############### Main Loop Starts
| ###############
:Main_Loop
|- If you wish to set bot to buffing only, /echo toggle buffbot
/if (${BuffBot}) {
/doevents
/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
|- Auto Follow
/if (${AutoFollow}) /call AutoFollow
|- 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
|- Canni
/call LowOnMana
|- Checks for Heals/Events
/call CombatChecks
|- Buff Sow
/if (!${Engaged} && ${DoSow}) /call SowGroup
|- Group Buffs if more than BuffMana mana
/if (${Me.PctMana}>=${BuffMana} && ${DoBuffs} && !${Engaged}) /call GroupBuffs
|- Buff Avatar
/if (${DoAvatar} && ${Me.SpellReady[${SpellAvatar}]}) /call Cast_Avatar
|- Pet
/if (!${Engaged} && ${DoPet}) /call PetRoutines
/if (!${Engaged} && ${DoLoot} && !${Me.Moving}) /call LootMobs
/goto :Main_Loop
/return
| ###############
| ############### Main Loop Ends
| ###############
| ############### 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 (${DoAvatar}) {
/if ( !${Me.Gem[${SpellAvatar}]} ) {
/memspell ${SpellDoTGemNum} ${SpellAvatar}
/delay 30
}
} else {
/if ( !${Me.Gem[${SpellDoT}]} ) {
/memspell ${SpellDoTGemNum} ${SpellDoT}
/delay 30
}
}
/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[${SpellAvatar}]} ) {
/memspell ${MiscGemNum} ${SpellAvatar}
/delay 30
}
/if ( ${Window[SpellBookWnd].Open} ) /windowstate SpellBookWnd close
/stand
/echo Spells are memmed.
/return
| ################### Check target and do stuff like slow, dot, pet attack etc.
Sub Combat
/declare i int local 1
/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 Check_TankHPs
|- Heal Group
/if (${HealGroup}) /call Check_GroupHPs
|- Heal Pets
/if (${HealPets}) /call Check_GroupPetHPs
|- 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}) {
/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}) {
/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 0
/if ((${DoSlow} && !${MobSlowed}) || (${DoCripple} && !${MobCrippled}) || ${Target.Type.NotEqual[NPC]}) /return
/for i 0 to ${Group.Members}
/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}) {
/if (${Verbose}) /tell ${Group.Member[${i}]} ${SpellPanther} is incoming to you ${Group.Member[${i}]}.
/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}) { ${Group.Member[${i}].Pet} PET FALSE
/call AcquireTarget
/if (${Me.CurrentMana}>${Spell[${SpellPanther}].Mana}) {
/if (${Verbose}) /tell ${Group.Member[${i}]} ${SpellPanther} is incoming to your Pet ${Group.Member[${i}]}.
/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}) /tell l 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 1
/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 1
/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}) /t << %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 1
/for i 1 to ${TargetSlow.Size}
/if (${Target.ID}==${TargetSlow[${i}]}) {
/echo ${Target.CleanName} has already been slowed with ${SpellSlow}
/varset MobSlowed TRUE
/return
}
/next i
/if (${Target.PctHPs}<=${CombatAt} && ${Target.ID}==${TargetArray[4]}) {
/if (${Me.CurrentMana}<${Spell[${SpellSlow}].Mana}) {
/echo 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}) /tell l << %t >> is IMMUNE to slow.
/call Addto_Slow
/varset MobSlowed TRUE
}
/if (${Macro.Return.Equal["CAST_RESISTED"]}) {
/if (!${FastSlow}) {
/if (${Verbose}) /tell l << %t >> has RESISTED slow. Trying again.
/goto :Slow_Loop
}
/call Addto_Slow
/varset MobSlowed TRUE
}
/if (${Macro.Return.Equal["CAST_SUCCESS"]}) {
/if (${Verbose}) /tell l << %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 1
/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 1
/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 1
/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
/if (${AssistYN}) { (string NewTarget, string TargetType, bool 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 1
/if (!${Select[${Target.Type},PC,PET]}) /return
/if (${Select[${Target.Class.ShortName},BER,BRD,BST,MNK,PAL,RNG,ROG,SHD,WAR]}) {
/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}]}
/tell ${ChatSender} Buffing you with << ${SpellSingleBuff[${i}]} >> now.
/call cast ${SpellSingleBuff[${i}]} ${MiscGem} ${CastRetryTime}
/next i
} else /if (${SpellSingleBuff[${i}].NotEqual[NULL]} && ${Select[${Target.Class.ShortName},CLR,DRU,SHM,ENC,MAG,NEC,WIZ]}) {
/for i 1 to ${SpellSingleBuff.Size}
/if (${i}==2) /next i
/if (${Spell[${SpellSingleBuff[${i}]}].Mana} > ${Me.CurrentMana}) {
/echo DAMN.. LowOnMana... Cannibalizing to rebuff /goto:Hold_Single_Rebuff
/Call LowOnMana
/if (${Spell[${SpellSingleBuff[${i}]}].Mana} > ${Me.CurrentMana}) /goto :Hold_Single_Rebuff
}
/echo >>> Hang on ! Buffing ${SpellSingleBuff[${i}]}
/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 1
/for i 1 to ${SpellGroupBuff.Size}
/doevents
/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 /goto :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 Check_GroupHPs
/call GetTarget
}
/next i
/return
Sub CheckHealLevel
/if (((${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
/return
Sub CheckHoTLevel
/if (((${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 (((${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 if MA needs heal
Sub Check_TankHPs
/declare i int local 1
/if (${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 ${M_Assist}
} else {
/call AcquireTarget ${M_Assist} ${Spawn[${M_Assist}].Type} FALSE
/if (${Target.Type.Equal[CORPSE]}) /return
/if (${Verbose}) /tell l << ${SpellHeal} >> on %t
/call cast ${SpellHeal} ${SpellHealGem} ${CastRetryTime}
}
} else /if (${Spawn[${M_Assist}].ID} && ${Spawn[${M_Assist}].Distance}<=${Spell[${SpellHoT}].Range} && ${Spawn[${M_Assist}].PctHPs}<=${TankHoT} && ${TankHoTWO}==0 && ${DoHoT}) {
/if (${Me.CurrentMana}<${Spell[${SpellHoT}].Mana}) {
/echo >>> Not enough mana to --> HoT ${M_Assist}
} else {
/call AcquireTarget ${M_Assist} ${Spawn[${M_Assist}].Type} FALSE
/if (${Target.Type.Equal[CORPSE]}) /return
/if (${Verbose}) /tell l << ${SpellHoT} >> on %t
/call cast ${SpellHoT} ${SpellHoTGem} ${CastRetryTime}
/if (${Macro.Return.Equal["CAST_SUCCESS"]}) {
/varset TankHoTWO 1
/for i 1 to ${Group.Members}
/if (${Group.Member[${i}].CleanName.Equal[${M_Assist}]}) /varset GroupHoT[${i}] 1
/if (${Group.Member[${i}].Pet.CleanName.Equal[${M_Assist}]}) /varset GroupHoTPet[${i}] 1
/next i
}
}
}
/return
|################### Check if any group member needs heal
Sub Check_GroupHPs
/declare i int local 1
/for i 1 to ${Group.Members}
/if (${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})) && ${DoHeal}) {
/if (${Me.CurrentMana}<${Spell[${SpellHeal}].Mana}) {
/echo >>> Not enough mana to --> heal ${Group.Member[${i}]}
} else {
/call AcquireTarget ${Group.Member[${i}]} PC FALSE
/if (${Verbose}) /tell l << ${SpellHeal} >> on %t
/call cast ${SpellHeal} ${SpellHealGem} ${CastRetryTime} CheckHealLevel
}
} else /if (${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 && ${DoHoT}) {
/if (${Me.CurrentMana}<${Spell[${SpellHoT}].Mana}) {
/echo >>> Not enough mana to --> HoT ${Group.Member[${i}]}
} else {
/call AcquireTarget ${Group.Member[${i}]} PC FALSE
/if (${Verbose}) /tell l << ${SpellHoT} >> on %t
/call cast ${SpellHoT} ${SpellHoTGem} ${CastRetryTime} CheckHoTLevel
/if (${Macro.Return.Equal["CAST_SUCCESS"]}) /varset GroupHoT[${i}] 1
/if (${Macro.Return.Equal["CAST_SUCCESS"]} && ${Group.Member[${i}].CleanName.Equal[${M_Assist}]}) /varset TankHoTWO 1
}
}
/next i
/return
|################### Check if any group member's Pets need healing
Sub Check_GroupPetHPs
/declare i int local 1
/for i 1 to ${Group.Members}
/if (${Group.Member[${i}].Pet.ID} && ${Group.Member[${i}].Pet.Distance}<=${Spell[${SpellHeal}].Range} && ${Group.Member[${i}].Pet.PctHPs}<=${PetHeal}) {
/if (${Me.CurrentMana}<${Spell[${SpellHeal}].Mana}) {
/echo >>> Not enough mana to --> heal ${Group.Member[${i}].Pet}
} else {
/call AcquireTarget ${Group.Member[${i}].Pet} PET FALSE
/if (${Verbose}) /tell l << ${SpellHeal} >> on %t
/call cast ${SpellHeal} ${SpellHealGem} ${CastRetryTime} CheckHealLevel
}
} else /if (${Group.Member[${i}].Pet.ID} && ${Group.Member[${i}].Pet.Distance}<=${Spell[${SpellHoT}].Range} && ${Group.Member[${i}].Pet.PctHPs}<=${PetHoT} && ${GroupHoTPet[${i}]}==0 && ${DoHoT}) {
/if (${Me.CurrentMana}<${Spell[${SpellHoT}].Mana}) {
/echo >>> Not enough mana to --> heal ${Group.Member[${i}].Pet}
} else {
/call AcquireTarget ${Group.Member[${i}].Pet} PET FALSE
/if (${Verbose}) /tell l << ${SpellHoT} >> on %t
/call cast ${SpellHoT} ${SpellHoTGem} ${CastRetryTime} CheckHoTLevel
/if (${Macro.Return.Equal["CAST_SUCCESS"]}) /varset GroupHoTPet[${i}] 1
/if (${Macro.Return.Equal["CAST_SUCCESS"]} && ${Group.Member[${i}].Pet.CleanName.Equal[${M_Assist}]}) /varset TankHoTWO 1
}
}
/next i
/return
|################## Canni 5
Sub Cannibalization
/if ((${Me.CurrentHPs}-1924)/${Me.MaxHPs}*100<${CanniMinPct}) {
/call CheckMyHPs
} else /if (${Cannibalization}) {
/if (${Verbose}) /tell l Cannibalization time -- don't be afraid I only eat myself.
/aa act Cannibalization
/delay ${CastRetryTime}
}
/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 (${Me.CurrentMana}<(${Me.MaxMana}-5) && ${Me.SpellReady[${SpellCanni}]} && (${Me.CurrentHPs}-688)/${Me.MaxHPs}*100>${CanniMinPct}) /call cast ${SpellCanni} ${SpellCanniGem} ${CastRetryTime}
/if (${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}) {
/call cast ${SpellPet} ${MiscGem} ${CastRetryTime}
/delay 30
/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 Cast_Avatar
/declare i int local 0
/for i 0 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}) {
/if (${Verbose}) /tell ${Group.Member[${i}]} ${SpellAvatar} is incoming to you ${Group.Member[${i}]} , Stay in Range .
/call cast ${SpellAvatar} ${SpellDoTGem} ${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 0
| ### HoT variables
/varset TankHoTWO 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}) /tell l Summoning Food, hold pulls for 30 secs.
/declare i int local 1
/for i 1 to 8
/autoinventory
/delay 1
/call cast ${SpellFOOD} ${MiscGem} ${CastRetryTime}
/next i
/autoinventory
/if (${Verbose}) /tell l Ready for pulls again.
/return
| ################## Thirsty
Sub Event_Thirsty
/if (${Engaged}) /return
/echo I am Thirsty
/if (${Verbose}) /tell l Summoning Drink, hold pulls for 30 secs.
/declare i int local 1
/for i 1 to 8
/autoinventory
/delay 1
/call cast ${SpellDRINK} ${MiscGem} ${CastRetryTime}
/next i
/autoinventory
/if (${Verbose}) /tell l 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
/if (${DoShrink}) {
/echo I zoned, time to shrink
/delay 10
/call Shrik_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
/if (${Verbose}) /tell l Ready for res.
/call Wait4Rez
/delay 20
/call MemSpells
/if (${Me.State.Equal[Stand]}) /sit
| We do some short meditate before we start again.
:Meditate
/delay 1s
/if (${Me.CurrentMana}<${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}]}) /return
/if (!${BuffBot}) {
/if (!${Select[${ChatSender},${ChatController},${MasterArray[1]},${MasterArray[2]},${MasterArray[3]},${MasterArray[4]},${MasterArray[5]}]}) {
/if (${ChatType.Equal[TELL]}) /1 <TELL> [${ChatSender}]: ${ChatText}
/if (${ChatType.Equal[GROUP]} && ${GroupChatRelay}) /1 <GROUP CHAT> [${ChatSender}]: ${ChatText}
/if (${ChatType.Equal[RAID]} && ${RaidChatRelay}) /1 <RAID CHAT> [${ChatSender}]: ${ChatText}
/return
}
}
| ################# Heal Requests
/if (${Select[${ChatText},heal,heal me]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/tell ${ChatSender} ${SpellHeal} is incoming !!
/call cast ${SpellHeal} ${SpellHealGem} ${CastRetryTime)
}
/return
}
/if (${Select[${ChatText},hot]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/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}
/call cast ${SpellSlow} ${SpellSlowGem} ${CastRetryTime}
/tell ${ChatSender} %t has had ${SpellMalo} and ${SpellSlow} cast on it.
}
/return
}
/if (${Select[${ChatText},root]}) {
/call AcquireTarget ${ChatSender} NPC TRUE
/if (${Target.Type.Equal[NPC]} && ${Target.Distance}<=${AssistAt}) {
/call cast ${SpellRoot} 5 ${CastRetryTime}
/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}) /Alt activate 447
/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}) {
/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}) /Alt activate 153
/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},res,rez,resme,rezme]} && ${Me.AltAbilityReady[404]}) {
/call AcquireTarget ${ChatSender} CORPSE TRUE
/if (${Target.Type.Equal[CORPSE]} && ${Target.Distance}<=${AssistAt}) {
/tell ${Target.CleanName} incoming SHAMAN rez, DO NOT LOOT ALL OF YOUR CORPSE!
/Alt activate 404
}
/return
}
/if (${Select[${ChatText},avatar,champion,champ]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/tell ${ChatSender} <<< ${SpellAvatar} >> is being cast on you.
/call cast ${SpellAvatar} ${SpellDoTGem} ${CastRetryTime}
}
/return
}
/if (${Select[${ChatText},pr]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/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}) {
/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}) {
/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}) {
/tell ${ChatSender} ${SpellLEV} is incoming to you ${ChatSender}.
/call cast ${SpellLEV} ${MiscGem} ${CastRetryTime}
}
/return
}
/if (${Select[${ChatText},sow,bih'li]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/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}) {
/tell ${ChatSender} ${SpellGROW} is incoming to you ${ChatSender}.
/call cast ${SpellGROW} ${MiscGem} ${CastRetryTime}
}
/return
}
/if (${Select[${ChatText},shrink,shrink me]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/tell ${ChatSender} ${SpellSHRINK} is incoming to you ${ChatSender}.
/call cast ${SpellSHRINK} ${MiscGem} ${CastRetryTime}
}
/return
}
/if (${Select[${ChatText},shrink group,shrink us]}) {
/call Shrink_Group
/return
}
/if (${Select[${ChatText},see,acumen]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/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}) {
/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}) {
/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}) {
/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}) {
/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}) {
/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}) {
/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}) {
/tell ${ChatSender} ${SpellAC} is incoming to you ${ChatSender}.
/call cast ${SpellAC} ${MiscGem} ${CastRetryTime}
}
/return
}
| ################# Group Buff Requests
/if (${Select[${ChatText},ghaste,grouphaste]}) {
/call AcquireTarget ${ChatSender} PC FALSE
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=${AssistAt}) {
/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}) {
/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}) {
/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}) {
/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}) {
/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}) {
/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 Rebuff other group
/if (${Select[${ChatText},buffthem]}) {
/declare i int local 1
/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 (${Verbopse}) /tell ${ChatSender} Buffing ${Target.CleanName}'s group with << ${SpellGroupBuff[${i}]} >> now.
/call cast ${SpellGroupBuff[${i}]} ${CastRetryTime}
/next i
/return
}
| ################# Other Pet Buffing
/if (${Select[${ChatText},buffpet]}) {
/declare i int local 1
/echo Request for Pet Buffs
/call AcquireTarget ${Spawn[pc ${ChatSender}].Pet.Name} PET FALSE
/if (${Target.Type.NotEqual[PET]}) /return
/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}]}
/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]}) {
/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 1
/echo ${myspell} on ${mytarget} has worn off
/if (${myspell.Equal[${SpellHoT}]}) {
/if (${M_Assist.Equal[${mytarget}]}) /varset TankHoTWO 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} || ${Engaged}) /return
/for i 0 to ${RefreshThisBuff.Size}
/if (${myspell.Equal[${RefreshThisBuff[${i}]}]}) {
/varset oldt ${Target.ID}
/call AcquireTarget ${mytarget} PC FALSE
/if (${Target.CleanName.Equal[${mytarget}]}) {
:Hold_cast_Rebuff
/Call LowOnMana
/if (${Spell[${RefreshThisBuff[${i}]}].Mana} > ${Me.CurrentMana}) /goto :Hold_cast_Rebuff
/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}
/echo Set ${Command}: ${${Command}}
/1 Set ${Command}: ${${Command}}
} else /if (${${Command}}) {
/varset ${Command} FALSE
/echo Set ${Command}: ${${Command}}
/1 Set ${Command}: ${${Command}}
} else {
/varset ${Command} TRUE
/echo Set ${Command}: ${${Command}}
/1 Set ${Command}: ${${Command}}
}
/return
}
| ### Specific Commands
/if (${Command.Equal[AutoFollow]}) {
/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 (${SpellSlow.Equal[${SpellShortSlow}]}) {
/varset SpellSlow ${SpellLongSlow}
} else {
/varset SpellSlow ${SpellShortSlow}
}
/echo Now Slowing with: ${SpellSlow}
/1 Now Slowing with: ${SpellSlow}
/return
}
/if (${Command.Equal[LongSlow]}) {
/varset SpellSlow ${SpellLongSlow}
/echo Now Slowing with: ${SpellSlow}
/1 Now Slowing with: ${SpellSlow}
/return
}
/if (${Command.Equal[ShortSlow]}) {
/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[ResetHot]}) {
/varset TankHoTWO 0
/for i 1 to ${GroupHoT.Size}
/varset GroupHoT[${i}] 0
/varset GroupHoTPet[${i}] 0
/next i
/varset RemoteControl TRUE
/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:.............${DoBuffs}
/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:.............${DoBuffs}
/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
Thanks in advance for any help that anyone is able to give. This Macro was taken from the macroquest site and is no work of my own.any way iam haveing targeting issues i think why it keeps casting the same spell over and over on tank...normally i could prolly figure it out but...ive been up for 2 days. i think the problem is here some where.
Code:
Sub AcquireTarget
/if (${AssistYN}) { (string NewTarget, string TargetType, bool 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
/returnty for any help
