Necro mac

PeteSampras

PeteSampras

Your UI is fucking you. Stop using it.
Joined
Dec 12, 2007
Messages
3,956
Reaction score
49
Points
38
Necro Mac v1.0


REQUIREMENTS:
spell_routines.inc, mq2cast, mq2eqbc, mq2debuffs, mq2moveutils, mq2melee, Mob_Ignore_List.ini, <yourcharactername>_NEC.ini


USAGE:
You must place this macro, Mob_Ignore_List.ini, and <yourcharactername>_NEC.ini in the "/mq2/macro/" folder.

/target your main tank, and then /mac necro <second assist name if applicable>
Option 1: /mac necro
Option 2: /mac necro PeteSampras

GENERAL NOTES:
-The Mob_Ignore_List.ini is designed to add mobs to certain kind of immunity lists without lumping them into a generic immune list. I think the issues with it adding mobs multiple times is corrected, but either way it still works, it just adds extra spam to the file that you can remove later.
-I made it separate from the .ini so that you are able to reference this list via other macros/toons if you so choose.
-Snare/Mez immune mobs should auto add (can still do manually) to the list. The rest need to be manually added.

-To add mobs use the event triggers below followed by the mobs name. ie. /bc ignoremob %T should add that mob to the ignore list.
-Ignoremob list completely ignores that mob.
-The snare/slow/mez/charm represent actually immunity to spells and will not try to use them.
-The Fire/Cold/Disease/Poison/Magic currently are actual immunity, but the macro can be modded to reflect a -resistadjust at a later date

- #event balance info: Type into EQBC: balancefight 84
- This will make it so balance is automatically turned on, and you wont nuke below 84%.
- Typing whatever you make as your ${BalanceOffTrigger} will manually turn balance on. Alternatively you can BalanceAt 0 or 1 and Necro will nuke until then.

@SmartDPS: These settings are designed to calculate how soon a mob will die. Turning this feature off will result in wasteful use of your mana overall, but will chain dots as they wear off until mob is dead.
This is used primarily to figure out whether or not to cast a dot. After the initial engagement on mob, this is very accurate for me. I have it set so that if the mob is a named or if the fight is going to be over 3 minutes, you will use your full set of dots (@DotTotalIfNamed), otherwise it uses your smaller set of dots. This results in very little wasted mana overall.

DotSmartStopPercent=75 means if dot won't do 75% of it's damage, it won't cast it. <- .MyDuration was having some issues, removed this check for now
Alternatively it will check @DotStopAtSeconds=15 and @DoNukesIfMobDeadSoon=TRUE
In that example, if only 15 seconds remain it will nuke instead of dot.

If @UseNukeIfAllDotsOn=TRUE, if all dots are applied to mob or mob is immune, it will nuke in the mean time
Misc commands:
- /bc manacheck - performs a mana check on all toons running mac
- /bc expreport - reports back all AA and regular exp earned while running back
- /bc invisoff or /bc invison - takes off or casts invis spell
- /bc balancefight 85 - /bc balancefight off .. first option would stop nuking mob at 85, second option disables balancing

**Lifetaps note**
There are 2 ways to handle lifetaps, use it as a nuke or set it as an AA. The AA option allows for the checking of your HPs and then will nuke if engaged onto a mob.

**AAs note**
Most AAs you will not need to change, if you don't have them it simply skips them without error. There are default values automatically set if you leave something blank, so you only need to set the fields with no default values for it to work. Some AAs required corpses / amounts of corpses/npcs, self PctHPs to fire so I had to include those as possible options.

Example:
AA0=EXAMPLE NAME ONLY
AAGem0=alt/gem#
UseAA0=TRUE (Default TRUE)
UseAA0At=95 (Default 95 or less)
NamedOnlyUseAA0=FALSE
UseAA0IfNearby=npc (Default npc) - pet / pc / mercenary / npc / corpse / etc
UseAA0IfNearbyAmt=1 (Default is 1)
UseAA0AtMyHPs=100 (Default is 100 or less)
StopAA0At=25 (Default is 25 or less)

v1.0 Notes:
- Initial release
- Flexible Tank / SA delegation
- Support for: Dots, Nukes, AAs, Self/clicky Buffs, Clicky Nukes/Dots/Items/Epics, Pets, Pet Buffs, Snare, FD, DA, Mod Rods, Auto Inv Essences / Orbs, Auto accept rezzes, invis, invis off, Lifetaps, medding, watching for enrage/gate/completeheal, multiple mobs/corpse required AA or spells
- Nec should auto feign death after x amounts of casts using @FDCount variable. Unfortunately I don't think it remounts yet due to how ${Outdoors} functions and how i wrote in the check.

- buffs / spells of any kind can be requested via eqbc and the @DoBuffs / @Buff1 + @BuffTrigger1 commands as long as you set the triggers/buffs/count.
- Sometimes you have to ask twice.

Known Issues / Comments
- CHANGE THE SPELLS / ITEMS / AAs / SETTINGS / PET HEALS / DOTS / TOTALS to match yours or it won't work.
- Sometimes you have to ask for buffs twice.
- Remounting doesn't always seem to work right
- The order of your AAs are important. If you have harmshield as the last AA, it will process the others before it. Be smart!
- RNG combod with lifetap/DA has gotten the better of me a couple times. You may want to use FD also as an AA setting.
-MQ2Melee default value for feign death is 30. if you dont want to feign death at 30, change that amount via /melee feigndeath=10 or whatever
-If anyone makes a full Mob_Ignore_List for all of SoD / SoF, please feel free to send it to me and I can hang it on here. I only included lobby/hall and 2 SoD zones with 1 snare immune mob each as an example.
-Most the testing was conducted with low level dots for mana purposes, so that is the <character_name>_NEC.ini i posted. If someone wants to send me a fully loaded level 85 with all the bells and whistles, i can post that.
 

Attachments

  • Mob_Ignore_List.ini
    1.9 KB · Views: 203
  • necro.mac
    67 KB · Views: 276
  • YourCharName_NEC.ini
    5.6 KB · Views: 246
Thanks Pete,

Pete does great work and puts a lot of time into his macros of which we benefit, free of charge.

If you need to test-drive an 85 necro with all the bells and whistles Pete, pm me as I mentioned before and you can have at it with mine for a night or two.
 
assuming this is for boting a necro in a group yes? will give it a go see how it works for my 82 necro.

Edit: for this section
Code: 
InvisSpell=Cloak of Shadows
IG=alt
InvisTrigger=invison
InvisOffTrigger=invisoff
any chance it can use a click item (pre-nerf cos)?
 
in a group, out of a group, whatever.
Code: 
InvisSpell=Circlet of Shadow
IG=item
InvisTrigger=invison
InvisOffTrigger=invisoff

That may work. If it doesnt, id have to add a line of code to check for items.
 
will try it out, thx

EDIT: ok got it working for the most part. That worked for making it use the item to invis.

Notes:
1) For some reason if you spell "Putrescent Servant" wrong it will try to cast Suspend companion. not a big deal if you spell it write just thought I'd note it ;p

2) It has me chain casting tiny companion. I use the item "Algae Covered Stiletto" to shrink my pet so not sure if that is why. It does shrink the pet and cast dots and such, just will recast pet shrink between spells and every few sec's if no mob in the camp.

3) Any chance you can put a check before trying to mount up that looks to see if your in an outdoors zone or not? Not too big of a deal but would help speed up the macro and save spam for the user ;p
 
Thunder:

1. Yes, if you spell pet name wrong, it is going to mess up. No way around that.

2. I never actually use the shrink, but it does a calculation to see if your pet is already shrunk based on physical size of pet. That was a copy/paste job from a previous mac i used that worked. I can take a look at it.

3. Unfortunately, unless it has been changed and i don't know about it, there is no ${Me.Outdoors} type command. So you have to try to mount once. I guess technically i can add an Outdoors option to the mob ignore list so it checks, but that is really more elaborate than it needs to be. Someone needs to make this into a plugin. I'll suggest it.
 
For some reason I cannot download the attached files
 
Downloads didn't work for me either when I just tried. Reloaded them. give it a whirl and please post an comments/issues with the mac as you find them.
 
Thanks was able to download now to give it a whirl on my 77 necro ;)
 
ThunderStruck said:
2) It has me chain casting tiny companion. I use the item "Algae Covered Stiletto" to shrink my pet so not sure if that is why. It does shrink the pet and cast dots and such, just will recast pet shrink between spells and every few sec's if no mob in the camp.
Click to expand...

I don't believe it has any way to tell if your pet has already been shrunk so it keeps recasting. Shrink isn't a buff that is visible. If you were doing it to your toon it would behave in the same manner. I haven't found a way to correct this, so if someone has one, would love to see it.
 
My necro wants to keep going up and meleeing when running this macro and only casts 1 dot
 
I don't believe it has any way to tell if your pet has already been shrunk so it keeps recasting. Shrink isn't a buff that is visible. If you were doing it to your toon it would behave in the same manner. I haven't found a way to correct this, so if someone has one, would love to see it.
Click to expand...

The check goes by model size actually. it works for my other classes, but i only copied and pasted the code for this version. I've never bothered using it. Necro pet doesn't bother/clutter too much for me.

The snippet of code for model size is highlighted:
Code: 
  /if (${ShrinkPet} && ${Me.Pet.ID} && ([COLOR=yellow]${Me.Pet.Height}-.25>1[/COLOR])) {
   /if (${Target.ID}!=${Me.Pet.ID}) /target id ${Me.Pet.ID}
   /delay 3s ${Target.ID}==${Me.Pet.ID}
   /call Cast "${ShrinkPetSpell}" ${ShrinkPetSpellGem} 3s
    [COLOR=lime]}[/COLOR]
 /if (${Spawn[${TarID}].ID}) {
      /if (${Target.ID}!=${Spawn[${TarID}].ID}) /call CheckTarget
    [COLOR=red]}[/COLOR] 
    /delay 1
    /if (${Target.ID}==${Me.Pet.ID}) /squelch /target clear
 }
   /if (!${Defined[PetBuffRecheck]}) /declare PetBuffRecheck timer outer ${Ini[MyIni,Pet,PetBuffRecheck,10s]}
   /if (!${PetBuffRecheck}) /varset PetBuffRecheck ${PetBuffRecheck.OriginalValue}
What might need to be done is delete the brace highlighted in red and move it to the spot where i made a green one.

only casts 1 dot
Click to expand...

My guess for this is: Your "DotTotal=1" in your .ini. or you spelled the name of the additional dots incorrectly. Also, make sure your "DotTotalIfNamed=" is equal to or higher than your DotTotal if you want it to function correctly on named mobs.
 
do I need to use bc etc

I am really sorry for this newbie type question (but it is closer than you think to being true ) but do I have to use the /bc EQBC stuff or can I change my channel to /group ? Also do I have to physically type in the name of the MT or can I also use the /group function and the macro will see who is assigned the duties of main tank and main assist?

I have been looking for a necro mac that uses ini settings. This looks like a good one. ))
 
You can change the /bc to whatever you want. I am actually about to update this macro in the next couple weeks. I wanted to get the mage one working properly before i start heavy testing on the wizard and necro. And theres a couple settings on bard one i need to work out and an XTarget shaman/cleric one im working. So many macros, so little play time.

I think on this one you have to target the MA prior to running the macro. The new version will be able to use the /ass group option amongst some other tweaks.

I publish these macros then i make modifcations to my private ones as i get to test new skills/spells/AAs. so sometimes the functions arent the same when people ask questions i have to go back and look at what is posted here.
 
Thanx for the comeback and the answers. If you've time for one more, I 'll ask anyways ))). Is there something I need to do inorder to get the Soul Orb that is summoned when I cast it to automatically inventory? I use the Soul Orb as my nuke spell but I end up with them on my cursor and can complicate things when I want to swap out quickly. )

Thanx again for the macs...I will definately check out your others. )))

Most respectfully,
militarebear
 
Ya, i might not have coded for the newest orb yet.. the command is:

/autoinventory


It should automatically put those in your pack, but its been awhile since i poked around in the code.
 
just throw a /if (${Cursor.ID}) /autoinv

that'll do'er
 
just throw a /if (${Cursor.ID}) /autoinv
Click to expand...

The reasoni dont do that any more is because you have to pause the macro to pick up anything out of your inv.. it gets so annoying. if you specify by item name it works better for me at least.
 
tried using this mac for my lvl 80 necro..it starts and then just FD over and over, any reason why it's doing it?
Here is my mac:
|**
Necro Bot v1.0 by PeteSampras
Some event code used from Nils' macs

@@@Requirements: spell_routines.inc, mq2cast, mq2eqbc, mq2debuffs, mq2moveutils, mq2melee, Mob_Ignore_List.ini, <yourcharactername>_NEC.ini

@@@You must place this macro, Mob_Ignore_List.ini, and <yourcharactername>_NEC.ini in the "/mq2/macro/" folder.

@@@How to use:
/target your main tank, and then /mac necro <second assist name if applicable>
Option 1: /mac necro
Option 2: /mac necro PeteSampras

You should only have to define the spells you want to use in your <yourcharactername>_NEC.ini and never touch inside this .mac

The Mob_Ignore_List.ini is designed to add mobs to certain kind of immunity lists without lumping them into a generic immune list.
-I made it separate from the .ini so that you are able to reference this list via other macros/toons if you so choose.
-Snare/Mez immune mobs should auto add (can still do manually) to the list. The rest need to be manually added.

@@@-To add mobs use the event triggers below followed by the mobs name. ie. /bc ignoremob %T should add that mob to the ignore list.
-Ignoremob list completely ignores that mob.
-The snare/slow/mez/charm represent actually immunity to spells and will not try to use them.
-The Fire/Cold/Disease/Poison/Magic currently are actual immunity, but the macro can be modded to reflect a -resistadjust at a later date


- #event balance info: Type into EQBC: balancefight 84
- This will make it so balance is automatically turned on, and you wont nuke below 84%.
- Typing whatever you make as your ${BalanceOffTrigger} will manually turn balance on. Alternatively you can BalanceAt 0 or 1 and Necro will nuke until then.


@SmartDPS: These settings are designed to calculate how soon a mob will die.
This is used primarily to figure out whether or not to cast a dot
DotSmartStopPercent=75 means if dot won't do 75% of it's damage, it won't cast it. <- .MyDuration was having some issues, removed this check for now
Alternatively it will check @DotStopAtSeconds=15) and @DoNukesIfMobDeadSoon=TRUE
In that example, if only 15 seconds remain it will nuke instead of dot.

If @UseNukeIfAllDotsOn=TRUE, if all dots are applied to mob or mob is immune, it will nuke in the mean time

Misc commands:
- /bc manacheck - performs a mana check on all toons running mac
- /bc expreport - reports back all AA and regular exp earned while running back
- /bc invisoff or /bc invison - takes off or casts invis spell
- /bc balancefight 85 - /bc balancefight off .. first option would stop nuking mob at 85, second option disables balancing
- /bc evacnow - causes immediate use of Exodus AA if available

v1.0 Notes:
- Initial release
- Flexible Tank / SA delegation
- Tested for nec / wiz / mag, but should work (for nukes / dots / assist) for all classes other than bard if combod with mq2melee. but it won't be as effective as a mac designed for them
- Support for: Dots, Nukes, AAs, Self/clicky Buffs, Clicky Nukes/Dots/Items/Epics,
Pets, Pet Buffs, Snare, FD, DA, Mod Rods, Auto Inv Essences / Orbs, Auto accept rezzes, invis, invis off
Lifetaps, medding, watching for enrage/gate/completeheal, multiple mobs/corpse required AA or spells

- Nec should auto feign death after x amounts of casts using @FDCount variable. Unfortunately I don't think it remounts yet due to how ${Outdoors} functions.

- buffs / spells of any kind can be requested via eqbc and the @DoBuffs / @Buff1 + @BuffTrigger1 commands as long as you set the triggers/buffs/count.
- Sometimes you have to ask twice.
**|




#include spell_routines.inc

#Turbo 40

#define MyIni ${Me.CleanName}_${Me.Class.ShortName}.ini

#event IgnoreMob "#*# ignoremob #1#"
#event StunImmuneMob "#*# stunimmunemob #1#"
#event SnareImmuneMob "#*# snareimmunemob #1#"
#event SlowImmuneMob "#*# slowimmunemob #1#"
#event CharmImmuneMob "#*# charmimmunemob #1#"
#event MezImmuneMob "#*# mezimmunemob #1#"
#event FireImmuneMob "#*# fireimmunemob #1#"
#event ColdImmuneMob "#*# coldimmunemob #1#"
#event MagicImmuneMob "#*# magicimmunemob #1#"
#event PoisonImmuneMob "#*# poisonimmunemob #1#"
#event DiseaseImmuneMob "#*# diseaseimmunemob #1#"
#event SlowImmune "Your target is immune to changes in its attack speed#*#"
#event SnareImmune "Your target is immune to changes in its run speed#*#"
#event MezImmune "Your target cannot be mesmerized#*#"
#event ExpReport "#*#expreport#*#"
#event Balance "#*# balancefight #1#"
#event Debuffed "#1# looks very uncomfortable#*#"
#event DebuffResist "#*#Your target resisted the |${DebuffSpell}|#*#"
#event DotResist1 "#*#Your target resisted the |${Dot1}|#*#"
#event DotResist2 "#*#Your target resisted the |${Dot2}|#*#"
#event DotResist3 "#*#Your target resisted the |${Dot3}|#*#"
#event DotResist4 "#*#Your target resisted the |${Dot4}|#*#"
#event DotResist5 "#*#Your target resisted the |${Dot5}|#*#"
#event DotResist6 "#*#Your target resisted the |${Dot6}|#*#"
#event DotResist7 "#*#Your target resisted the |${Dot7}|#*#"
#event DotResist8 "#*#Your target resisted the |${Dot8}|#*#"
#event DotOff1 "#*#Your |${Dot1}| spell has worn off#*#"
#event DotOff2 "#*#Your |${Dot2}| spell has worn off#*#"
#event DotOff3 "#*#Your |${Dot3}| spell has worn off#*#"
#event DotOff4 "#*#Your |${Dot4}| spell has worn off#*#"
#event DotOff5 "#*#Your |${Dot5}| spell has worn off#*#"
#event DotOff6 "#*#Your |${Dot6}| spell has worn off#*#"
#event DotOff7 "#*#Your |${Dot7}| spell has worn off#*#"
#event DotOff8 "#*#Your |${Dot8}| spell has worn off#*#"

#event EQBC "<#1#> #2#"
#event EQBC "[#1#(msg)] #2#"
#event InDoors "#*#You can only cast this spell in the outdoors#*#"
#event InDoors "#*#This spell does not work here#*#"
#event InDoors "#*#You are already on a mount#*#"
#event InDoors "#*#You can not summon a mount here#*#"
#event Slow "#1#is hindered by a shackle of spirit#*#"
#event SlowResist "#*#Your target resisted the |${Slow}|#*#"
#event SnareImmune "#*#is immune to changes in its#*#"
#event Snareon "#*#damage by your |${Snare}|#*#"
#event Snareon "#*#engulfed by darkness#*#"
#event Snareon "#*#engulfed in an embracing darkness#*#"
#event Snareon "#*#is shackled to the ground#*#"
#event Snareon "#*#has been ensnared#*#"
#event Snareon "#*#movements slow as their feet are covered in tangling weeds#*#"
#event Snareon "#*#has been entangled#*#"
#event Snareon "#*#has been entrapped in living earth#*#"
#event Snareon "#*##covered in coruscating black shadows#*#"
#event SnareResist "#*#Your target resisted the |${Snare}|#*#"
#event SnareWornOff "Your |${Snare}| spell has worn off#*#"
#event RageOff "#*#is no longer enraged#*#"
#event RageOn "#*#has become ENRAGED#*#"
#event Zoned "You have entered#*#"
#event Zoned "LOADING, PLEASE WAIT..."


Sub Main
/call Initialize
/echo Assisting >> ${Spawn[${MainTank}].CleanName} <<

:MainLoop
/if (${GameState.Equal[CHARSELECT]}) /end
/call AcceptRez
/doevents
/if (${Me.Casting.ID}||${FDTimer} && ${FDAggro}||${Me.Feigning} && !${FDAggro}||${Me.Hovering}||${Window[tradewnd].Open}||${Window[lootwnd].Open}) /goto :MainLoop

/call CheckTarget


/if (${Balance} && ${Target.PctHPs}<${BalanceAt}) /goto :MainLoop
/if (${Zone.ID}!=345 && ${Zone.ID}!=344 && !${Me.Song[Elevator Music].ID} && !${Me.Moving} && !${Me.Invis}) /call CheckBuffs
/call CheckTarget

/call DPS
/call FDCheck
/call Debuff
|/call Slow
/call PetAttack
/call AAs
/call CheckNamed
/call Aura
/call PetHeal
/call Dot
/call Snare
/call ClickyNuke
/call DA
/call OrbHeal
/call Nuke
/call PetBuffs
/call CheckMana
/call Recourse
/doevents
/goto :MainLoop
/return


/return


Sub AAs
/if (${Balance} && ${Target.ID}==${TarID} && ${Target.PctHPs}<${BalanceAt}||${Me.Invis}||${Me.Moving}||${Me.Feigning}||${IgnoreList.Find[${Spawn[${Target.CleanName}]}]}) /return
/declare a int local
/for a 1 to ${AATotal} {
/if (${Target.PctHPs}<${StopAA${a}At}) /return
/if ((${Me.AltAbility[${AA${a}}].ID} && ${Me.AltAbilityReady[${AA${a}}]}||${Me.SpellReady[${AA${a}}]}) && ${UseAA${a}} && ${Target.ID}==${TarID} && ${Target.PctHPs}<${UseAA${a}At} && (${Target.ID}==${NearestSpawn[npc named].ID}||!${NamedOnlyUseAA${a}}) && ${SpawnCount[${UseAA${a}IfNearby} radius 70 zradius 15]}>=${UseAA${a}IfNearbyAmt} && ${Me.PctHPs}<=${UseAA${a}AtMyHPs}) {
/call Cast "${AA${a}}" ${AAGem${a}}
}
}
/next a
/return

Sub AcceptRez
/if (!${Window[ConfirmationDialogBox].Open}||${Window[lootwnd].Open}||!${AutoAcceptRez}) /return
/if (${Me.Hovering} && ${Window[RespawnWnd].Open}) {
/nomodkey /notify RespawnWnd RW_OptionsList listselect 2
/delay 1s
/nomodkey /notify RespawnWnd RW_SelectButton leftmouseup
/delay 1s
}

/if (${Me.State.Equal[BIND]} && ${Window[ConfirmationDialogBox].Open}) {
/nomodkey /notify ConfirmationDialogBox Yes_Button leftmouseup
/delay 1s
}
/if (${Window[ConfirmationDialogBox].Open}) {
/delay 1
/notify ConfirmationDialogBox Yes_Button leftmouseup
}
/return

Sub Attacking
/if (${Me.Invis}||${Me.Feigning}||!${UseMelee}||${IgnoreList.Find[${Spawn[${Target.CleanName}]}]}) /return
/if (${Balance} && ${Target.ID}==${TarID} && ${Target.PctHPs}<${BalanceAt}) {
/attack off
/return
}
/if (!${Me.Combat} && ${Me.Standing} && !${Raged} && ${Target.ID}==${TarID} && ${Target.PctHPs}<${MeleeAt}) {
/attack on
/echo Attacking ${Target.DisplayName}
}

/return

Sub Aura
/if (${Me.Invis} ||${Me.Feigning}||${Me.CombatState.Equal[COMBAT]}) /return
/if (!${Me.Aura[${Aura1}].ID} && !${Me.Song[${Aura1}].ID} && ${UseAura1}) {
/call Cast "${Aura1}" ${AuraGem1}
}
/if (!${Me.Aura[${Aura2}].ID} && !${Me.Song[${Aura2}].ID} && ${UseAura2}) {
/call Cast "${Aura2}" ${AuraGem2}
}
/return

Sub CheckBuffs
/if (${Me.Invis} ||${Me.Feigning}|| ${Me.CombatState.Equal[COMBAT]}) /return
/if (${UseMount} && ${Outside} && !${Me.Mount.ID}) /call Cast "${MountName}" item

/if (${SelfBuffTotal}) {
/declare sb int local
/for sb 1 to ${SelfBuffTotal} {
/if (${Spell[${SelfBuff${sb}}].Stacks} && !${Me.Buff[${SelfBuff${sb}}].ID}) {
/call Cast "${SelfBuffSpell${sb}}" ${SelfBuffGem${sb}}
/delay 3s !${Me.Casting.ID}
}
}
/next sb
}
/return


Sub CheckMana
/if (${Me.Song[${GoM}].ID}) /return
/if (!${Me.Invis} && ${Me.PctMana}<90 && ${FindItem[Wand of Ethereal Transvergance].InvSlot} && !${FindItem[Wand of Ethereal Transvergance].TimerReady}) /call Cast "Wand of Ethereal Transvergance" item
/if (!${Me.Invis} && ${Me.PctMana}<90 && ${FindItem[Wand of Elemental Transvergance].InvSlot} && !${FindItem[Wand of Elemental Transvergance].TimerReady}) /call Cast "Wand of Elemental Transvergance" item
/if (!${Me.Invis} && ${Me.PctMana}<90 && ${FindItem[Rod of Mystical Transvergance].InvSlot} && !${FindItem[Rod of Mystical Transvergance].TimerReady}) /call Cast "Rod of Mystical Transvergance" item
/if (!${Me.Invis} && ${Me.PctMana}<90 && ${FindItem[Summoned: Modulating Rod].InvSlot} && !${FindItem[Summoned: Modulating Rod].TimerReady}) /call Cast "Summoned: Modulating Rod" item
/if (${SitTimer}) /return
/if (!${Me.Invis} && ${Me.PctMana}<90 && !${MedTimer} && !${Me.Mount.ID} && !${Me.Moving} && ${Me.State.Equal[STAND]} && !${Me.Invis} && (!${Target.Type.Equal[NPC]} || !${Target.ID})) /sit
/if (${Me.PctMana}<${MedAt} && !${Target.Type.Equal[NPC]} && !${Me.Mount.ID} && ${Me.State.Equal[STAND]} && ${Me.CombatState.NotEqual[COMBAT]}) /sit
/if (!${SitTimer} && ${Me.Sitting}) /varset SitTimer ${SitTimer.OriginalValue}
/return

Sub CheckNamed
/if (${CheckNamed}) {
/declare tempID int local
/declare beeped bool local false
:check_named
/varset tempID ${Spawn[npc named noalert 6].ID}
/if (${tempID}) {
/squelch /alert add 6 id ${tempID}
/if (!${Spawn[${tempID}].CleanName.Find[eye of]} && ${SpawnCount[npc "${Spawn[${tempID}].CleanName}"]}==1 && !${SpawnCount[merc ${tempID}]}) {
/echo Named Detected: ${Spawn[${tempID}].DisplayName}
/bc ${Spawn[${tempID}].DisplayName} popped, ${Spawn[${tempID}].Distance3D} feet ${Spawn[${tempID}].HeadingTo} of here.
/if (!${beeped} && ${UseBeep}) /beep
/varset beeped true
}
/goto :check_named
}
}
/return

Sub CheckTarget
/if ((!${Target.ID} || ${Target.Type.NotEqual[NPC]} || !${ReAssist}) && ${Spawn[id ${MainTank} radius 75].ID}) {
/assist ${Spawn[id ${MainTank}]}
/varset ReAssist ${ReAssist.OriginalValue}

}
/if ((!${Target.ID} || ${Target.Type.NotEqual[NPC]} || !${ReAssist}) && !${Spawn[id ${MainTank} radius 75].ID} && ${Spawn[corpse ${MainTank} radius 200]} && ${Spawn[id ${SecondAssist} radius 75].ID}) {
/assist ${Spawn[id ${SecondAssist}]}
/varset ReAssist ${ReAssist.OriginalValue}

}
/if (${Target.ID} && ${Target.Type.Equal[NPC]} && ${Target.ID}!=${TarID}) {
/varset TarID ${Target.ID}
/declare i int local
/for i 1 to 8 {
/varset DotResisted${i} 0
/varset DotOn${i} FALSE
}
/next i
/varset FDC 0
/varset Snared FALSE
/varset Debuffed 0
/varset DebuffedTimer 10s
/varset PetAttacking FALSE
/varset FightStartTime 0
/varset MobDeadSoon FALSE

}

/if (${Cursor.Name.Equal[Wand of Ethereal Transvergance]}||${Cursor.Name.Equal[Rod of Mystical Transvergance]}||${Cursor.Name.Equal[Wand of Elemental Transvergance]}||${Cursor.Name.Equal[Summoned: Modulating Rod]}) /autoinventory

/return

Sub ClickyNuke
/if (${Me.Casting.ID} || ${Me.Moving} || ${Me.Invis} || ${Me.Feigning}||${IgnoreList.Find[${Spawn[${Target.CleanName}]}]}) /return
/declare i int local
/for i 1 to ${ClickyNukeTotal} {
/if (${Target.PctHPs}<=${UseClickyNuke${i}At} && ${Target.PctHPs}>=${StopClickyNuke${i}At} && ${Target.ID} && !${Me.Casting.ID} && ${Target.Type.Equal[NPC]}) {
/if ((!${NamedOnlyClickyNuke${oc}}||${Target.ID}==${NearestSpawn[named npc].ID}) && !${FindItem[${ClickyNuke${i}}].Timer}) {
/if (${FindItem[${ClickyNuke${i}}].InvSlot}) {
/call Cast "${ClickyNuke${i}}" item 2s
}
}
}
}
/next i
/return

Sub DA
/if (${Me.Casting.ID} || ${Me.Moving} || ${Me.Invis} || ${Me.Feigning}) /return
/if ((${UseDAWhileFD}||!${Me.Feigning}) && ${UseDA} && (${Me.SpellReady[${DASpell}]}||${Me.AltAbilityReady[${DASpell}]}) && ${Me.PctHPs}<${UseDAAt}) /call Cast "${DaSpell}" ${DASpellGem}
/return

Sub Debuff
/if (!${Target.ID} || ${Debuffed}||${IgnoreList.Find[${Spawn[${Target.CleanName}]}]}) /return
/if (${Target.PctHPs}<=${DotStartAt} && ${UseDebuff} && !${Debuffed} && !${DebuffedTimer} && ${Target.ID}==${TarID}) /call Cast "${DebuffSpell}" ${DebuffGem}
/return

Sub Dot
/if (${Me.Casting.ID} || ${Me.Moving} || ${Me.Invis} || ${Me.Feigning}||${IgnoreList.Find[${Spawn[${Target.CleanName}]}]}) /return
/if (!${Defined[DotAmt]}) /declare DotAmt int outer
/varset DotAmt ${DotTotal}
/if ((${Target.ID}==${NearestSpawn[npc named].ID}||${FightRemainingTime}>180) && ${TarID}==${Target.ID}) /varset DotAmt ${DotTotalIfNamed}


/if (${UseSmartDPS} && ${FightStartTime} && ${FightRemainingTime}<${DotStopAtSeconds} && ${Target.PctHPs}<90) {
/varset MobDeadSoon TRUE
/return
}
/if (${Target.PctHPs}<=${DotStartAt} && ${Target.ID} && ${Target.Type.Equal[NPC]} && ${Me.PctMana}>=${MinManaToDot}) {
/if (${Me.Song[${GoM}].ID} && ${Me.CurrentMana}>=${Spell[${GoMSpell}].Mana} && ${Me.SpellReady[${GoMSpell}]} && ${Target.Distance}<=${Spell[${GoMSpell}].Range} && ${Target.LineOfSight}) {
/call Cast "${GoMSpell}" ${GoMSpellGem}
/varcalc FDC ${FDC}+1
}

/declare i int local
/for i 1 to ${DotAmt} {
/if (${Spell[${Dot{i}].ResistType}ImmuneList.Find[${Spawn[${Target.CleanName}]}]}) /return
/if (!${DotOn${i}} && ${Target.PctHPs}<=${DotStartAt} && ${Target.PctHPs}>=${DotStopAt}) {
/if (${DotMaxTries${i}}>${DotResisted${i}} && ${Me.CurrentMana}>=${Spell[${Dot${i}}].Mana} && ${Me.SpellReady[${Dot${i}}]} && ${Target.Distance}<=${Spell[${Dot${i}}].Range} && ${Target.LineOfSight}) {
/call Cast "${Dot${i}}" ${DotGem${i}}
/if (${Macro.Return.Equal[CAST_SUCCESS]} || ${Macro.Return.Equal[CAST_RESISTED]}) {
/varset BetweenDotDelay ${BetweenDotDelay.OriginalValue}
/varset MedTimer ${MedTimer.OriginalValue}
/varcalc FDC ${FDC}+1
/varset DotOn${i} TRUE
/if (!${FightStartTime}) /varset FightStartTime ${MacroQuest.Running}
}
}
}
}
/next i

}

/return

Sub FDCheck
/if (${Me.Invis}||${Me.Moving}||!${UseFD}) /return
/if (${UseFD} && ${Me.Standing} && (${FDC}>=${FDCount}||${Me.PctHPs}<${FDat})) {
/call Cast "${FDSpell}" ${FDSpellGem}
/varset FDTimer ${FDTimer.OriginalValue}
/varset FDC 0
/varset FDAggro TRUE
}
/if (${Me.PctHPs}>${FDStandAt} && ${Me.Feigning} && !${FDTimer} && ${FDAggro}) {
/stand
/varset FDAggro FALSE
}
/return

Sub Nuke
/if (${BetweenNukeDelay} || ${Me.PctMana}<${MinManaToNuke} || ${Me.Invis} || ${Me.Moving}||${Me.Feigning}||${IgnoreList.Find[${Spawn[${Target.CleanName}]}]}) /return
/if (${UseNukeIfAllDotsOn}) {
/varset AllDotsOn TRUE
/declare i int local
/for i 1 to ${DotAmt} {
/if (!${DotOn${i}}) /varset AllDotsOn FALSE
}
/next i
}

/if (${UseNuke2} && (${Target.PctHPs}<=${Nuke2At}||(${AllDotsOn}||${MobDeadSoon} && ${Target.PctHPs}<95) && ${DotStartAt}) && ${Target.ID} && ${Target.Type.Equal[NPC]}) {
/if (${Me.Song[${GoM}].ID} && ${Me.CurrentMana}>=${Spell[${GoMSpell}].Mana} && ${Me.SpellReady[${GoMSpell}]} && ${Target.Distance}<=${Spell[${GoMSpell}].Range} && ${Target.LineOfSight}) {
/call Cast "${GoMSpell}" ${GoMSpellGem}

}
/if (${Me.CurrentMana}>=${Spell[${Nuke2}].Mana} && ${Me.SpellReady[${Nuke2}]} && ${Target.Distance}<=${Spell[${Nuke2}].Range} && ${Target.LineOfSight}) {
/call Cast "${Nuke2}" ${NukeGem2}
/varset BetweenNukeDelay ${BetweenNukeDelay.OriginalValue}
/varset MedTimer ${MedTimer.OriginalValue}
}
}

/if (${UseNuke1} && (${Target.PctHPs}<=${Nuke1At}||(${AllDotsOn}||${MobDeadSoon} && ${Target.PctHPs}<95) && ${DotStartAt}) && ${Target.ID} && ${Target.Type.Equal[NPC]}) {
/if (${Me.Song[${GoM}].ID} && ${Me.CurrentMana}>=${Spell[${GoMSpell}].Mana} && ${Me.SpellReady[${GoMSpell}]} && ${Target.Distance}<=${Spell[${GoMSpell}].Range} && ${Target.LineOfSight}) {
/call Cast "${GoMSpell}" ${GoMSpellGem}

}
/if (${Me.CurrentMana}>=${Spell[${Nuke1}].Mana} && ${Me.SpellReady[${Nuke1}]} && ${Target.Distance}<=${Spell[${Nuke1}].Range} && ${Target.LineOfSight}) {
/call Cast "${Nuke1}" ${NukeGem1}
/varset BetweenNukeDelay ${BetweenNukeDelay.OriginalValue}
/varset MedTimer ${MedTimer.OriginalValue}
}
}

/return

Sub OrbHeal
/if (!${GroupHeal} ||${Me.Moving}||${Me.Invis}||${Me.Feigning}) /return
/if (${Cursor.Name.Equal[Shade Orb]}||${Cursor.Name.Equal[Soul Orb]}||${Cursor.Name.Equal[Shadow Orb]}||${Cursor.Name.Equal[Umbra Orb]}) /autoinventory
/for i 1 to ${Group} {
/if (${Group.Member[${i}].PctHPs}<${GroupHealAt}) {
/for a 1 to ${OrbTotal} {
/if (${FindItem[${Orb${a}}].InvSlot} && !${FindItem[${Orb${a}}].Timer} {
/target ${Group.Member[${i}].ID}
/call Cast "${Orb${a}}" item
/call CheckTarget
}
}
/next a
}
}
/next i
/return

Sub PetAttack
/if (${Me.Pet.ID} && !${PetAttacking} && ${Target.ID}==${TarID} && ${Target.PctHPs}<${PetAttackAt} && ${Target.Distance}<=100) {
/pet attack
/if (${UsePetFocusAA} && ${Me.AltAbility[Advanced Pet Discipline]}) /pet focus on
/varset PetAttacking TRUE
}
/return

Sub PetBuffs
/if (${Me.Pet.ID} && ${Me.Pet.Name.Find[familiar]}) /pet get lost
/if (${Me.Invis} || ${Me.Moving} || ${PetBuffRecheck}) /return
/if (!${Me.Pet.ID} && ${UsePet}) {
/if (${Me.AltAbility[Suspended Minion]}) /alt activate 176
/delay 5s !${Me.Casting.ID}
/delay 3s ${Me.Pet.ID}
/if (!${Me.Pet.ID}) {
/call Cast "${PetSpell}" ${PetSpellGem} 5s
}
/if (${Me.Pet.ID} && ${Me.AltAbility[Pet Discipline]}) /pet hold on
}

/if (${DoPetBuffs} && ${Me.Pet.ID} && !${PetBuffRecheck} && ${Me.Pet.Distance}<100) {
/if (!${Me.PetBuff[${PetBuffName1}]} && ${PetBuffTotal}>=1) /call Cast "${PetBuffSpell1}" ${PetBuffGem1}
/if (!${Me.PetBuff[${PetBuffName2}]} && ${PetBuffTotal}>=2) /call Cast "${PetBuffSpell2}" ${PetBuffGem2}
/if (!${Me.PetBuff[${PetBuffName3}]} && ${PetBuffTotal}>=3) /call Cast "${PetBuffSpell3}" ${PetBuffGem3}
/if (!${Me.PetBuff[${PetBuffName4}]} && ${PetBuffTotal}>=4) /call Cast "${PetBuffSpell4}" ${PetBuffGem4}
/if (!${Me.PetBuff[${PetBuffName5}]} && ${PetBuffTotal}>=5) /call Cast "${PetBuffSpell5}" ${PetBuffGem5}
/if (!${Me.PetBuff[${PetBuffName6}]} && ${PetBuffTotal}>=6) /call Cast "${PetBuffSpell6}" ${PetBuffGem6}
}



/if (${ShrinkPet} && ${Me.Pet.ID} && (${Me.Pet.Height}-.25>1)) {
/if (${Target.ID}!=${Me.Pet.ID}) /target id ${Me.Pet.ID}
/delay 3s ${Target.ID}==${Me.Pet.ID}
/call Cast "${ShrinkPetSpell}" ${ShrinkPetSpellGem} 3s
/if (${Spawn[${TarID}].ID}) {
/if (${Target.ID}!=${Spawn[${TarID}].ID}) /call CheckTarget
}
/delay 1
/if (${Target.ID}==${Me.Pet.ID}) /squelch /target clear
}
/if (!${Defined[PetBuffRecheck]}) /declare PetBuffRecheck timer outer ${Ini[MyIni,Pet,PetBuffRecheck,10s]}
/if (!${PetBuffRecheck}) /varset PetBuffRecheck ${PetBuffRecheck.OriginalValue}

/return

Sub PetHeal
/if (!${DoPetHeals} || ${Me.Invis} || ${Me.Moving} || ${Me.Song[${GoM}].ID} || !${Me.Pet.ID}||${PetHealZoneTimer}) /return
/if (${Me.Pet.ID} && ${Me.AltAbility[Mend Companion]} && ${Me.AltAbilityReady[Mend Companion]} && ${Me.Pet.PctHPs}<=${PetAAHealAt}) /call Cast "Mend Companion" alt
/if (${Me.Pet.ID} && ${Me.Pet.PctHPs}<=${PetHealAt}) /call Cast "${PetHealSpell}" ${PetHealSpellGem}
/if (${Me.Pet.ID} && ${Me.Pet.PctHPs}<=${PetDelayHealAt} && !${PetDelayUsed} && ${UsePetDelayHeal}) {
/call Cast "${PetDelayHealSpell}" PetDelayHealSpellGem
/Varset PetDelayUsed ${PetDelayUsed.OriginalValue}
}
/if (${Spawn[${TarID}].ID}) {
/if (${Target.ID}!=${Spawn[${TarID}].ID}) /call CheckTarget
}
/return


Sub Recourse
/if (!${RecourseTotal} ||${Me.Invis}||${IgnoreList.Find[${Spawn[${Target.CleanName}]}]}) /return
/declare x int local
/for x 1 to ${RecourseTotal} {
/declare i int local
/for i 0 to ${Group} {
/if (${UseRecourse${x}} && ${Group.Member[${i}].PctHPs}<${Recourse${x}HPAt} && ${Group.Member[${i}].ID}||${Group.Member[${i}].PctMana}<${Recourse${x}ManaAt} && ${Group.Member[${i}].Class.ShortName.NotEqual[MNK||ROG||WAR||BER||BRD]} && ${Group.Member[${i}].Type.Equal[PC]} && ${Group.Member[${i}].ID}) {
/if (!${Me.Buff[${RecourseName${x}}].ID} && ${Me.SpellReady[${Recourse${x}Name}]}) {
/call Cast "${Recourse${x}SpellName}" ${Recourse${x}Gem}
}
}

}
/next i
}
/next x
/return

Sub RefreshAlerts
/declare i int local
/declare NPCAlertList int local ${Math.Calc[${IgnoreList.Count[|]}-1].Int}
/squelch /alert clear 1
/if (${NPCAlertList}>0) {
/for i 1 to ${NPCAlertList}
/squelch /alert add 1 ${IgnoreList.Arg[${i},|]}
/next i
}
/return

Sub Snare
/if (${Me.Invis}||${Me.Moving}|| ${Me.Song[${GoM}].ID}||${SnareImmuneList.Find[${Spawn[${Target.CleanName}]}]}||${IgnoreList.Find[${Spawn[${Target.CleanName}]}]}) /return
/if (${Target.PctHPs}<=${SnareAt} && ${Target.ID} && ${Target.Type.Equal[NPC]} && !${Snared} && ${UseSnare} && ${SpawnCount[npc radius 50 zradius 10]}<=${MaxNPCs}) /call Cast "${Snare}" ${SnareGem} {
/if (${Macro.Return.Equal[CAST_SUCCESS]}) {
/varset Snared TRUE
}
/if (${Macro.Return.Equal[CAST_IMMUNE]}) {
/ini "${IniFile}" "SnareImmunes.${Zone.ShortName}" "SnareImmune" "${SnareImmuneList}${Target.CleanName}|"
/varset SnareImmuneList ${Ini[${IniFile},"SnareImmunes.${Zone.ShortName}","SnareImmune"]}
/varset Snared TRUE
}
}

/return

Sub DPS
/if (${TarID}!=${Target.ID}||!${UseSmartDPS}||${Target.PctHPs}>99) /return
/if (!${FightStartTime}) /varset FightStartTime ${MacroQuest.Running}
/varcalc FightTotalTime (${MacroQuest.Running}-${FightStartTime})/1000
/varcalc FightRemainingTime (100/((100-${Target.PctHPs})/(${FightTotalTime}+.0001))-${FightTotalTime})
/if (${AnnounceTimeRemaining} && !${AnnouncedTimer} && ${FightRemainingTime}>1) {
/echo ~ ${FightRemainingTime} Seconds remaining
/varset AnnouncedTimer ${AnnouncedTimer.OriginalValue}
}

/return


Sub Initialize
|-----------------|
|-- Declares --|
|-----------------|
/declare IniFile string outer Mob_Ignore_List.ini

/if (!${Target.ID} || ${Target.Type.NotEqual[${AssistType}]} || ${Target.ID}==${Me.ID}) {
/echo Please target the main tank before running the macro
/beep
}

/declare TarID int outer


/declare MyChannel string outer ${Ini[MyIni,Settings,MyChannel,bc]}

/declare MainTank string outer ${Target.ID}
/declare TankName string outer ${Target.CleanName}
/declare DefaultMainTank string outer ${Ini[MyIni,Settings,DefaultMainTank]}
/declare AssistType string outer ${Ini[MyIni,Settings,AssistType,pc]}
/declare SecondAssistType string outer ${Ini[MyIni,Settings,SecondAssistType,pc]}
/if (${Target.ID}==NULL) /varset MainTank ${Spawn[${AssistType} ${DefaultMainTank}].ID}
/declare SecondAssist string outer ${Spawn[${SecondAssistType} ${Param0}].ID}

/declare aastart float outer 0
/declare expstart float outer 0
/varcalc aastart (${Me.AAPointsTotal} * 100) + ${Me.PctAAExp}
/varcalc expstart (${Me.Level} * 100) + ${Me.PctExp}

|-- Nuke basics - When to use nukes and what nukes and the delay between them.
/declare BetweenNukeDelay timer outer ${Ini[MyIni,Spells,BetweenNukeDelay,2s]}
/declare MinManaToNuke int outer ${Ini[MyIni,Spells,MinManaToNuke,10]}

/declare UseNuke1 bool outer ${Ini[MyIni,Spells,UseNuke1,FALSE]}
/declare Nuke1 string outer ${Ini[MyIni,Spells,Nuke1]}
/declare NukeGem1 string outer ${Ini[MyIni,Spells,NukeGem1]}
/declare Nuke1At int outer ${Ini[MyIni,Spells,Nuke1At]}

/declare UseNuke2 bool outer ${Ini[MyIni,Spells,UseNuke2,FALSE]}
/declare Nuke2 string outer ${Ini[MyIni,Spells,Nuke2]}
/declare NukeGem2 string outer ${Ini[MyIni,Spells,NukeGem2]}
/declare Nuke2At int outer ${Ini[MyIni,Spells,Nuke2At]}

/declare UseNukeIfAllDotsOn bool outer ${Ini[MyIni,Spells,UseNukeIfAllDotsOn,TRUE]}
/declare AllDotsOn bool outer FALSE

|-- Lifetaps
/declare UseLifeTap1 bool outer ${Ini[MyIni,Spells,UseLifeTap1,FALSE]}
/declare LifeTap1 string outer ${Ini[MyIni,Spells,LifeTap1]}
/declare LifeTapGem1 string outer ${Ini[MyIni,Spells,LifeTapGem1]}
/declare LifeTap1At int outer ${Ini[MyIni,Spells,LifeTap1At]}

/declare UseLifeTap2 bool outer ${Ini[MyIni,Spells,UseLifeTap2,FALSE]}
/declare LifeTap2 string outer ${Ini[MyIni,Spells,LifeTap2]}
/declare LifeTapGem2 string outer ${Ini[MyIni,Spells,LifeTapGem2]}
/declare LifeTap2At int outer ${Ini[MyIni,Spells,LifeTap2At]}


|--Name of best gift of mana line + spell to use when it triggers
/declare GoM string outer ${Ini[MyIni,Spells,GoM]}
/declare GoMSpell string outer ${Ini[MyIni,Spells,GoMSpell]}
/declare GoMSpellGem string outer ${Ini[MyIni,Spells,GoMSpellGem]}


|-- Divine Aura
/declare UseDA bool outer ${Ini[MyIni,Spells,UseDA,FALSE]}
/declare UseDAAt int outer ${Ini[MyIni,Spells,UseDAAt]}
/declare UseDAWhileFD bool outer ${Ini[MyIni,Spells,UseDAWhileFD,FALSE]}
/declare DASpell string outer ${Ini[MyIni,Spells,DASpell]}
/declare DASpellGem string outer ${Ini[MyIni,Spells,DASpellGem]}

|-- FD
/declare UseFD bool outer ${Ini[MyIni,Spells,UseFD,TRUE]}
/declare FDC int outer 0
/declare FDCount int outer ${Ini[MyIni,Spells,FDCount]}
/declare FDat int outer ${Ini[MyIni,Spells,FDat]}
/declare FDSpell string outer ${Ini[MyIni,Spells,FDSpell,Death Peace]}
/declare FDSpellGem string outer ${Ini[MyIni,Spells,FDSpellGem,alt]}
/declare FDTimer timer outer 3s
/declare FDStandAt int outer ${Ini[MyIni,Spells,FDStand]}
/declare FDAggro bool outer FALSE

|-- Dots -

/declare UseDots bool outer ${Ini[MyIni,Dots,UseDots,TRUE]}
/declare DotStartAt int outer ${Ini[MyIni,Dots,DotStartAt]}
/declare DotStopAt int outer ${Ini[MyIni,Dots,DotStopAt]}
/declare BetweenDotDelay timer outer ${Ini[MyIni,Dots,BetweenDotDelay,1s]}
/declare MinManaToDot int outer ${Ini[MyIni,Dots,MinManaToDot]}

/declare DotAmt int outer

/declare DotTotal int outer ${Ini[MyIni,Dots,DotTotal]}
/declare DotTotalIfNamed int outer ${Ini[MyIni,Dots,DotTotalIfNamed]}

/declare Dot1 string outer ${Ini[MyIni,Dots,Dot1]}
/declare DotGem1 string outer ${Ini[MyIni,Dots,DotGem1]}
/declare DotResisted1 int outer 0
/declare DotMaxTries1 int outer ${Ini[MyIni,Dots,DotMaxTries1]}
/declare DotOn1 bool outer FALSE

/declare Dot2 string outer ${Ini[MyIni,Dots,Dot2]}
/declare DotGem2 string outer ${Ini[MyIni,Dots,DotGem2]}
/declare DotResisted2 int outer 0
/declare DotMaxTries2 int outer ${Ini[MyIni,Dots,DotMaxTries2]}
/declare DotOn2 bool outer FALSE

/declare Dot3 string outer ${Ini[MyIni,Dots,Dot3]}
/declare DotGem3 string outer ${Ini[MyIni,Dots,DotGem3]}
/declare DotResisted3 int outer 0
/declare DotMaxTries3 int outer ${Ini[MyIni,Dots,DotMaxTries3]}
/declare DotOn3 bool outer FALSE

/declare Dot4 string outer ${Ini[MyIni,Dots,Dot4]}
/declare DotGem4 string outer ${Ini[MyIni,Dots,DotGem4]}
/declare DotResisted4 int outer 0
/declare DotMaxTries4 int outer ${Ini[MyIni,Dots,DotMaxTries4]}
/declare DotOn4 bool outer FALSE

/declare Dot5 string outer ${Ini[MyIni,Dots,Dot5]}
/declare DotGem5 string outer ${Ini[MyIni,Dots,DotGem5]}
/declare DotResisted5 int outer 0
/declare DotMaxTries5 int outer ${Ini[MyIni,Dots,DotMaxTries5]}
/declare DotOn5 bool outer FALSE

/declare Dot6 string outer ${Ini[MyIni,Dots,Dot6]}
/declare DotGem6 string outer ${Ini[MyIni,Dots,DotGem6]}
/declare DotResisted6 int outer 0
/declare DotMaxTries6 int outer ${Ini[MyIni,Dots,DotMaxTries6]}
/declare DotOn6 bool outer FALSE

/declare Dot7 string outer ${Ini[MyIni,Dots,Dot7]}
/declare DotGem7 string outer ${Ini[MyIni,Dots,DotGem7]}
/declare DotResisted7 int outer 0
/declare DotMaxTries7 int outer ${Ini[MyIni,Dots,DotMaxTries7]}
/declare DotOn7 bool outer FALSE

/declare Dot8 string outer ${Ini[MyIni,Dots,Dot8]}
/declare DotGem8 string outer ${Ini[MyIni,Dots,DotGem8]}
/declare DotResisted8 int outer 0
/declare DotMaxTries8 int outer ${Ini[MyIni,Dots,DotMaxTries8]}
/declare DotOn8 bool outer FALSE

|-- Snare name, snare gem set to alt, would need changed to gem1, gem3 etc if using a spellgem, % to snare at, and how many NPCs can be nearby since it is AE
/declare Snare string outer ${Ini[MyIni,Spells,Snare]}
/declare SnareGem string outer ${Ini[MyIni,Spells,SnareGem]}
/declare SnareAt int outer ${Ini[MyIni,Spells,SnareAt]}
/declare MaxNPCs int outer ${Ini[MyIni,Spells,MaxNPCs]}
/declare Snared bool outer FALSE
/declare UseSnare bool outer ${Ini[MyIni,Spells,UseSnare,FALSE]}
/declare SnareCounter int outer 0

|------------------|
|---- Pet info ----|
|------------------|

/if (${Me.Pet.ID} && ${Me.AltAbility[Pet Discipline]}) /pet hold on
/declare UsePetFocusAA bool outer ${Ini[MyIni,Pet,UsePetFocusAA]}
/declare UsePet bool outer ${Ini[MyIni,Pet,UsePet,FALSE]}
/declare DoPetHeals bool outer ${Ini[MyIni,Pet,DoPetHeals,FALSE]}
/declare PetHealZoneTimer timer outer 10s
/declare PetHealAt int outer ${Ini[MyIni,Pet,PetHealAt]}
/declare PetHealSpell string outer ${Ini[MyIni,Pet,PetHealSpell]}
/declare PetHealSpellGem string outer ${Ini[MyIni,Pet,PetHealSpellGem]}
/declare UseAAPetHeal bool outer ${Ini[MyIni,Pet,UseAAPetHeal,FALSE]}
/declare PetAAHealAt int outer ${Ini[MyIni,Pet,PetAAHealAt,FALSE]}
/declare UsePetDelayHeal bool outer ${Ini[MyIni,Pet,UsePetDelayHeal,FALSE]}
/declare PetDelayHealSpell string outer ${Ini[MyIni,Pet,PetDelayHealSpell]}
/declare PetDelayHealAt int outer ${Ini[MyIni,Pet,PetDelayHealAt]}
/declare PetDelayHealGem string outer ${Ini[MyIni,Pet,PetDelayHealGem]}
/declare PetDelayUsed timer outer 24s
/declare ShrinkPet bool outer ${Ini[MyIni,Pet,ShrinkPet,FALSE]}
/declare ShrinkPetSpell string outer ${Ini[MyIni,Pet,ShrinkPetSpell]}
/declare ShrinkPetSpellGem string outer ${Ini[MyIni,Pet,ShrinkPetSpellGem]}
/declare PetAttacking bool outer FALSE
/declare PetAttackAt int outer ${Ini[MyIni,Pet,PetAttackAt]}
/declare PetSpellGem string outer ${Ini[MyIni,Pet,PetSpellGem]}
/declare PetSpell string outer ${Ini[MyIni,Pet,PetSpell]}

|-------------------|
|-- Pet Buff info --|
|-------------------|

/declare PetBuffRecheck timer outer ${Ini[MyIni,Pet,PetBuffRecheck,10s]}
/declare DoPetBuffs bool outer ${Ini[MyIni,Pet,DoPetBuffs,FALSE]}
/declare PetMana int outer ${Ini[MyIni,Pet,PetMana]}

/declare PetBuffTotal int outer ${Ini[MyIni,Pet,PetBuffTotal,0]}

/declare PetBuffName1 string outer ${Ini[MyIni,Pet,PetBuffName1]}
/declare PetBuffSpell1 string outer ${Ini[MyIni,Pet,PetBuffSpell1]}
/declare PetBuffGem1 string outer ${Ini[MyIni,Pet,PetBuffGem1]}

/declare PetBuffName2 string outer ${Ini[MyIni,Pet,PetBuffName2]}
/declare PetBuffSpell2 string outer ${Ini[MyIni,Pet,PetBuffSpell2]}
/declare PetBuffGem2 string outer ${Ini[MyIni,Pet,PetBuffName2]}

/declare PetBuffName3 string outer ${Ini[MyIni,Pet,PetBuffName3]}
/declare PetBuffSpell3 string outer ${Ini[MyIni,Pet,PetBuffSpell3]}
/declare PetBuffGem3 string outer ${Ini[MyIni,Pet,PetBuffName3]}

/declare PetBuffName4 string outer ${Ini[MyIni,Pet,PetBuffName4]}
/declare PetBuffSpell4 string outer ${Ini[MyIni,Pet,PetBuffSpell4]}
/declare PetBuffGem4 string outer ${Ini[MyIni,Pet,PetBuffName4]}


|--------------------|
|-- Self Buff info --|
|--------------------|

|- selfbuffs
/declare SelfBuffTotal int outer ${Ini[MyIni,SelfBuffs,SelfBuffTotal]}
/declare sb int local
/for sb 1 to ${SelfBuffTotal} {
/declare SelfBuff${sb} string outer ${Ini[MyIni,SelfBuffs,SelfBuff${sb}]}
/declare SelfBuffSpell${sb} string outer ${Ini[MyIni,SelfBuffs,SelfBuffSpell${sb}]}
/declare SelfBuffGem${sb} string outer ${Ini[MyIni,SelfBuffs,SelfBuffGem${sb}]}
}
/next sb


|-----------------------|
|-- Summon Orb / Heal --|
|-----------------------|

/declare HealGroup bool outer ${Ini[MyIni,Settings,HealGroup,FALSE]}
/declare HealGroupAt int outer ${Ini[MyIni,Settings,HealGroupAt]}

/declare OrbTotal int outer 4
/declare Orb1 string outer Shade Orb
/declare Orb2 string outer Umbra Orb
/declare Orb3 string outer Shadow Orb
/declare Orb4 string outer Soul Orb

|---------------|
|--Click items--|
|---------------|

|- OffensiveClickies
/declare ClickyNukeTotal int outer ${Ini[MyIni,OffensiveClickies,clickyNukeTotal,0]}
/declare oc int local
/for oc 1 to ${ClickyNukeTotal} {
/declare ClickyNuke${oc} string outer ${Ini[MyIni,OffensiveClickies,ClickyNuke${oc}]}
/declare UseClickyNuke${oc}At int outer ${Ini[MyIni,OffensiveClickies,UseClickyNuke${oc}At]}
/declare StopClickyNuke${oc}At int outer ${Ini[MyIni,OffensiveClickies,StopClickyNuke${oc}At]}
/declare NamedOnlyClickyNuke${oc} bool outer ${Ini[MyIni,OffensiveClickies,NamedOnlyClickyNuke${oc}]}
}
/next oc

|-------------------|
|---Spell infos-----|
|-------------------|

|-- AAs
/declare AATotal int outer ${Ini[MyIni,AA,AATotal]}
/declare aa int local
/for aa 1 to ${AATotal} {
/declare AA${aa} string outer ${Ini[MyIni,AA,AA${aa}]}
/declare AAGem${aa} string outer ${Ini[MyIni,AA,AAGem${aa}]}
/declare UseAA${aa} bool outer ${Ini[MyIni,AA,UseAA${aa}]}
/declare UseAA${aa}At int outer ${Ini[MyIni,AA,UseAA${aa}At,95]}
/declare StopAA${aa}At int outer ${Ini[MyIni,AA,StopAA${aa}At,25]}
/declare NamedOnlyUseAA${aa} bool outer ${Ini[MyIni,AA,NamedOnlyUseAA${aa}]}
/declare UseAA${aa}IfNearby string outer ${Ini[MyIni,AA,UseAA${aa}IfNearby,npc]}
/declare UseAA${aa}IfNearbyAmt int outer ${Ini[MyIni,AA,UseAA${aa}IfNearbyAmt,1]}
/declare UseAA${aa}AtMyHPs int outer ${Ini[MyIni,AA,UseAA${aa}AtMyHPs,100]}
}
/next aa


|-- Debuff related - Use debuff? spell name? timer to retry

/declare UseSlow bool outer ${Ini[MyIni,Spells,UseSlow,FALSE]}
/declare Slow string outer ${Ini[MyIni,Slow,Shackle of Spirit]}
/declare SlowGem int outer ${Ini[MyIni,Spells,SlowGem]}
/declare Slowed bool outer FALSE
/declare SlowResist int outer 0

/declare UseDebuff bool outer ${Ini[MyIni,Spells,UseDebuff,FALSE]}
/declare DebuffSpell string outer ${Ini[MyIni,Spells,DebuffSpell]}
/declare DebuffGem string outer ${Ini[MyIni,Spells,DebuffGem]}
/declare Debuffed bool outer FALSE
/declare DebuffedTimer timer outer ${Ini[MyIni,Spells,DebuffTimer,10s]}
/declare DebuffResist int outer 0

|-- invis info
/declare InvisSpell string outer ${Ini[MyIni,Spells,InvisSpell]}
/declare IG string outer ${Ini[MyIni,Spells,IG]}
/declare InvisTrigger string outer ${Ini[MyIni,Spells,InvisTrigger]}
/declare InvisOffTrigger string outer ${Ini[MyIni,Spells,InvisOffTrigger]}


|- buff others
/declare DoBuffs bool outer ${Ini[MyIni,Buffs,DoBuffs,FALSE]}
/declare BuffGemDefault int outer ${Ini[MyIni,Buffs,BuffGemDefault,10]}
/declare BuffTotal int outer ${Ini[MyIni,Buffs,BuffTotal]}
/declare b int local
/for b 1 to ${BuffTotal} {
/declare BuffTrigger${b} string outer ${Ini[MyIni,Buffs,BuffTrigger${b}]}
/declare Buff${b} string outer ${Ini[MyIni,Buffs,Buff${b}]}
}
/next b

|-- #event balance info: Type into EQBC: balancefight 84
|-- This will make it so balance is automatically turned on, and you wont nuke below 84%.
|-- Typing whatever you make as your ${BalanceOffTrigger} will manually turn balance on. Alternatively you can BalanceAt 0 or 1 and Necro will nuke until then.

/declare Balance bool outer ${Ini[MyIni,Misc,Balance,FALSE]}
/declare BalanceOnTrigger string outer ${Ini[MyIni,Misc,BalanceOnTrigger]}
/declare BalanceOffTrigger string outer ${Ini[MyIni,Misc,BalanceOffTrigger]}
/declare BalanceAt int outer ${Ini[MyIni,Misc,BalanceAt,0]}

|------------|
|---MISC-----|
|------------|
/declare SitTimer timer outer ${Ini[MyIni,Settings,SitTimer,10s]}
/declare MedTimer timer outer ${Ini[MyIni,Settings,MedTimer,45s]}
/declare MedAt int outer ${Ini[MyIni,Settings,MedAt,0]}
/declare ReAssist timer outer ${Ini[MyIni,Settings,ReAssist,5s]}
/declare UseMount bool outer ${Ini[MyIni,Settings,UseMount,FALSE]}
/declare MountName string outer ${Ini[MyIni,Settings,MountName]}
/declare Outside bool outer TRUE
/declare AutoAcceptRez bool outer ${Ini[MyIni,Settings,AutoAcceptRez,FALSE]}
/declare Raged bool outer FALSE

/declare XLOC int outer ${Me.X}
/declare YLOC int outer ${Me.Y}
/declare MyHeading int outer ${Me.Heading.DegreesCCW}
/declare Camp_Zone int outer ${Zone.ID}
/declare UseCamp bool outer ${Ini[MyIni,Settings,UseCamp,FALSE]}


|-- DPS Stuff --|
/declare UseSmartDPS bool outer ${Ini[MyIni,Misc,UseSmartDPS,TRUE]}
/declare FightStartTime float outer
/declare FightTotalTime float outer
/declare FightRemainingTime float outer
|-- this is saying to stop dots if mob will be dead before __%. ie. DotSmartStopPercent 75 = if dot won't do 75% of it's damage, don't cast it.
/declare DotSmartStopPercent int outer ${Ini[MyIni,Misc,DotSmartStopPercent]}
/declare DotStopAtSeconds int outer ${Ini[MyIni,Misc,DotStopAtSeconds]}
/declare DoNukesIfMobDeadSoon bool outer ${Ini[MyIni,Misc,DoNukesIfMobDeadSoon,TRUE]}
/declare MobDeadSoon bool outer FALSE
/declare AnnounceTimeRemaining bool outer ${Ini[MyIni,Misc,AnnounceTimeRemaining,FALSE]}
/declare AnnouncedTimer timer outer ${Ini[MyIni,Misc,AnnouncedTimer]}


|- Aura
/declare UseAura1 bool outer ${Ini[MyIni,Spells,UseAura1,FALSE]}
/declare Aura1 string outer ${Ini[MyIni,Spells,Aura1]}
/declare AuraGem1 string outer ${Ini[MyIni,Spells,AuraGem1]}

/declare UseAura2 bool outer ${Ini[MyIni,Spells,UseAura2,FALSE]}
/declare Aura2 string outer ${Ini[MyIni,Spells,Aura2]}
/declare AuraGem2 string outer ${Ini[MyIni,Spells,AuraGem2]}

/declare RecourseTotal int outer ${Ini[MyIni,Spells,RecourseTotal]}
/declare rc int local
/for rc 1 to ${RecourseTotal} {
/declare UseRecourse${rc} bool outer ${Ini[MyIni,Spells,UseRecourse${rc}]}
/declare Recourse${rc}HPAt int outer ${Ini[MyIni,Spells,Recourse${rc}HPAt]}
/declare Recourse${rc}ManaAt int outer ${Ini[MyIni,Spells,Recourse${rc}ManaAt]}
/declare Recourse${rc}SpellName string outer ${Ini[MyIni,Spells,Recourse${rc}SpellName]}
/declare Recourse${rc}Name string outer ${Ini[MyIni,Spells,Recourse${rc}Name]}
/declare Recourse${rc}Gem string outer ${Ini[MyIni,Spells,Recourse${rc}Gem]}

}
/next rc

|- immunity / ignore checks:

/declare IgnoreList string outer ${Ini[${IniFile},"Ignores.${Zone.ShortName}","Ignore"]}
/declare StunImmuneList string outer ${Ini[${IniFile},"StunImmunes.${Zone.ShortName}","StunImmune"]}
/declare CharmImmuneList string outer ${Ini[${IniFile},"CharmImmunes.${Zone.ShortName}","CharmImmune"]}
/declare DiseaseImmuneList string outer ${Ini[${IniFile},"DiseaseImmunes.${Zone.ShortName}","DiseaseImmune"]}
/declare ColdImmuneList string outer ${Ini[${IniFile},"ColdImmunes.${Zone.ShortName}","ColdImmune"]}
/declare FireImmuneList string outer ${Ini[${IniFile},"FireImmunes.${Zone.ShortName}","FireImmune"]}
/declare MagicImmuneList string outer ${Ini[${IniFile},"MagicImmunes.${Zone.ShortName}","MagicImmune"]}
/declare PoisonImmuneList string outer ${Ini[${IniFile},"PoisonImmunes.${Zone.ShortName}","PoisonImmune"]}
/declare MezImmuneList string outer ${Ini[${IniFile},"MezImmunes.${Zone.ShortName}","MezImmune"]}
/declare SnareImmuneList string outer ${Ini[${IniFile},"SnareImmunes.${Zone.ShortName}","SnareImmune"]}
/declare SlowImmuneList string outer ${Ini[${IniFile},"SlowImmunes.${Zone.ShortName}","SlowImmune"]}

/declare resistfire string outer Fire
/declare resistcold string outer Cold
/declare resistdisease string outer Disease
/declare resistpoison string outer Poison
/declare resistmagic string outer Magic



/if (${IgnoreList.Equal[NULL]}) {
/ini "${IniFile}" "Ignores.${Zone.ShortName}" "Ignore" "|"
/varset IgnoreList ${Ini[${IniFile},"Ignores.${Zone.ShortName}","Ignore"]}
/echo IgnoreList: ${IgnoreList}
} else {
/varset IgnoreList ${Ini[${IniFile},"Ignores.${Zone.ShortName}","Ignore"]}
/echo IgnoreList: ${IgnoreList}
}
/call RefreshAlerts
}

/if (${StunImmuneList.Equal[NULL]}) {
/ini "${IniFile}" "StunImmunes.${Zone.ShortName}" "StunImmune" "|"
/varset StunImmuneList ${Ini[${IniFile},"StunImmunes.${Zone.ShortName}","StunImmune"]}
/echo StunImmuneList: ${StunImmuneList}
} else {
/varset StunImmuneList ${Ini[${IniFile},"StunImmunes.${Zone.ShortName}","StunImmune"]}
/echo StunImmuneList: ${StunImmuneList}
}
/call RefreshAlerts
}

/if (${CharmImmuneList.Equal[NULL]}) {
/ini "${IniFile}" "CharmImmunes.${Zone.ShortName}" "CharmImmune" "|"
/varset CharmImmuneList ${Ini[${IniFile},"CharmImmunes.${Zone.ShortName}","CharmImmune"]}
/echo CharmImmuneList: ${CharmImmuneList}
} else {
/varset CharmImmuneList ${Ini[${IniFile},"CharmImmunes.${Zone.ShortName}","CharmImmune"]}
/echo CharmImmuneList: ${CharmImmuneList}
}
}
/if (${DiseaseImmuneList.Equal[NULL]}) {
/ini "${IniFile}" "DiseaseImmunes.${Zone.ShortName}" "DiseaseImmune" "|"
/varset DiseaseImmuneList ${Ini[${IniFile},"DiseaseImmunes.${Zone.ShortName}","DiseaseImmune"]}
/echo DiseaseImmuneList: ${DiseaseImmuneList}
} else {
/varset DiseaseImmuneList ${Ini[${IniFile},"DiseaseImmunes.${Zone.ShortName}","DiseaseImmune"]}
/echo DiseaseImmuneList: ${DiseaseImmuneList}
}
}
/if (${ColdImmuneList.Equal[NULL]}) {
/ini "${IniFile}" "ColdImmunes.${Zone.ShortName}" "ColdImmune" "|"
/varset ColdImmuneList ${Ini[${IniFile},"ColdImmunes.${Zone.ShortName}","ColdImmune"]}
/echo ColdImmuneList: ${ColdImmuneList}
} else {
/varset ColdImmuneList ${Ini[${IniFile},"ColdImmunes.${Zone.ShortName}","ColdImmune"]}
/echo ColdImmuneList: ${ColdImmuneList}
}
}
/if (${FireImmuneList.Equal[NULL]}) {
/ini "${IniFile}" "FireImmunes.${Zone.ShortName}" "FireImmune" "|"
/varset FireImmuneList ${Ini[${IniFile},"FireImmunes.${Zone.ShortName}","FireImmune"]}
/echo FireImmuneList: ${FireImmuneList}
} else {
/varset FireImmuneList ${Ini[${IniFile},"FireImmunes.${Zone.ShortName}","FireImmune"]}
/echo FireImmuneList: ${FireImmuneList}
}
}
/if (${MagicImmuneList.Equal[NULL]}) {
/ini "${IniFile}" "MagicImmunes.${Zone.ShortName}" "MagicImmune" "|"
/varset MagicImmuneList ${Ini[${IniFile},"MagicImmunes.${Zone.ShortName}","MagicImmune"]}
/echo MagicImmuneList: ${MagicImmuneList}
} else {
/varset MagicImmuneList ${Ini[${IniFile},"MagicImmunes.${Zone.ShortName}","MagicImmune"]}
/echo MagicImmuneList: ${MagicImmuneList}
}
}
/if (${PoisonImmuneList.Equal[NULL]}) {
/ini "${IniFile}" "PoisonImmunes.${Zone.ShortName}" "PoisonImmune" "|"
/varset PoisonImmuneList ${Ini[${IniFile},"PoisonImmunes.${Zone.ShortName}","PoisonImmune"]}
/echo PoisonImmuneList: ${PoisonImmuneList}
} else {
/varset PoisonImmuneList ${Ini[${IniFile},"PoisonImmunes.${Zone.ShortName}","PoisonImmune"]}
/echo PoisonImmuneList: ${PoisonImmuneList}
}
}
/if (${MezImmuneList.Equal[NULL]}) {
/ini "${IniFile}" "MezImmunes.${Zone.ShortName}" "MezImmune" "|"
/varset MezImmuneList ${Ini[${IniFile},"MezImmunes.${Zone.ShortName}","MezImmune"]}
/echo MezImmuneList: ${MezImmuneList}
} else {
/varset MezImmuneList ${Ini[${IniFile},"MezImmunes.${Zone.ShortName}","MezImmune"]}
/echo MezImmuneList: ${MezImmuneList}
}
}
/if (${SnareImmuneList.Equal[NULL]}) {
/ini "${IniFile}" "SnareImmunes.${Zone.ShortName}" "SnareImmune" "|"
/varset SnareImmuneList ${Ini[${IniFile},"SnareImmunes.${Zone.ShortName}","SnareImmune"]}
/echo SnareImmuneList: ${SnareImmuneList}
} else {
/varset SnareImmuneList ${Ini[${IniFile},"SnareImmunes.${Zone.ShortName}","SnareImmune"]}
/echo SnareImmuneList: ${SnareImmuneList}
}
}
/if (${SlowImmuneList.Equal[NULL]}) {
/ini "${IniFile}" "SlowImmunes.${Zone.ShortName}" "SlowImmune" "|"
/varset SlowImmuneList ${Ini[${IniFile},"SlowImmunes.${Zone.ShortName}","SlowImmune"]}
/echo SlowImmuneList: ${SlowImmuneList}
} else {
/varset SlowImmuneList ${Ini[${IniFile},"SlowImmunes.${Zone.ShortName}","SlowImmune"]}
/echo SlowImmuneList: ${SlowImmuneList}
}
}


/return


|------------------------|
|---EVENTS BELOW HERE ---|
|------------------------|

Sub Event_Balance(string Sender,int BalanceAtPercent)
/varset Balance TRUE
/varset BalanceAt ${BalanceAtPercent}
/bc Balancing ${Target.CleanName} at ${BalanceAt}%
/return

Sub Event_Chat(string ChatType,string Sender,string ChatText)
/if ((!${ChatType.Equal[EQBC]})&&(!${ChatType.Equal[${MyChannel}]})&&(!${ChatType.Equal[TELL]})) /return
/if (${Spawn[${Sender}].ID}==${Me.ID}) /return
/if (${ChatText.Equal[${EvacTrigger}]} && ${Me.AltAbility[Exodus].ID} && ${Me.AltAbilityReady[Exodus]}) /call Cast "Exodus" alt
/if (${ChatText.Equal[${InvisTrigger}]}) /call Cast "${InvisSpell}" ${IG}
/if (${ChatText.Equal[${BalanceOnTrigger}]}) /varset Balance TRUE
/if (${ChatText.Equal[${BalanceOffTrigger}]}) /varset Balance FALSE
/if (${ChatText.Equal[${InvisOffTrigger}]}) {
/if (${Me.Buff[Camouflage].ID}) /nomodkey /notify BuffWindow Buff${Math.Calc[${Me.Buff[Camouflage].ID}-1].Int} leftmouseup
/if (${Me.Buff[Shared Camouflage].ID}) /nomodkey /notify BuffWindow Buff${Math.Calc[${Me.Buff[Shared Camouflage].ID}-1].Int} leftmouseup
/if (${Me.Buff[Sun Cloak].ID}) /nomodkey /notify BuffWindow Buff${Math.Calc[${Me.Buff[Sun Cloak].ID}-1].Int} leftmouseup
/if (${Me.Buff[${InvisSpell}].ID}) /nomodkey /notify BuffWindow Buff${Math.Calc[${Me.Buff[${InvisSpell}].ID}-1].Int} leftmouseup
/if (${Me.Buff[Group Perfected Invisibility].ID}) /nomodkey /notify BuffWindow Buff${Math.Calc[${Me.Buff[Group Perfected Invisibility].ID}-1].Int} leftmouseup
/if (${Me.Buff[Group Perfected Invisibility to Undead].ID}) /nomodkey /notify BuffWindow Buff${Math.Calc[${Me.Buff[Group Perfected Invisibility to Undead].ID}-1].Int} leftmouseup

}
/if (${ChatText.Equal[manacheck]}) /bc ${Me.CleanName} - Mana ${Me.PctMana}%


/if (!${Spawn[${Sender}].ID}) {
/echo ${Sender} is not in the Zone
/return
}
/declare i int local
/if (${DoBuffs} && ${Sender.NotEqual[${Me.CleanName}]} && ${Spawn[pc ${Sender}].ID}) {
/for i 1 to ${BuffTriggerTotal}
/if (${ChatText.Find["${BuffTrigger${i}}"]}) {
/squelch /target clear
/target ${Spawn[${Sender}]}
/call Cast "${Buff${i}}" gem${BuffGemDefault}
}
}
/next i
}

/return

Sub Event_Debuffed(string Line, string MobName)
/varset Debuffed TRUE
/varset DebuffedTimer 120s
/return

Sub Event_DebuffResist1
/varcalc DebuffResist1 ${DebuffResist1}+1
/if (${DebuffResist1}>3) /varset Debuffed1 TRUE
/return

Sub Event_DebuffResist2
/varcalc DebuffResist2 ${DebuffResist1}+2
/if (${DebuffResist2}>3) /varset Debuffed2 TRUE
/return

Sub Event_DebuffResist3
/varcalc DebuffResist3 ${DebuffResist3}+1
/if (${DebuffResist3}>3) /varset Debuffed3 TRUE
/return

Sub Event_DebuffResist4
/varcalc DebuffResist4 ${DebuffResist4}+1
/if (${DebuffResist4}>3) /varset Debuffed4 TRUE
/return

Sub Event_DebuffResist5
/varcalc DebuffResist5 ${DebuffResist1}+5
/if (${DebuffResist5}>3) /varset Debuffed5 TRUE
/return

Sub Event_DotResist1
/varcalc DotResisted1 ${DotResisted1}+1
/varset DotOn1 FALSE
/return

Sub Event_DotResist2
/varcalc DotResisted2 ${DotResisted2}+1
/varset DotOn2 FALSE
/return

Sub Event_DotResist3
/varcalc DotResisted3 ${DotResisted3}+1
/varset DotOn3 FALSE
/return

Sub Event_DotResist4
/varcalc DotResisted4 ${DotResisted4}+1
/varset DotOn4 FALSE
/return

Sub Event_DotResist5
/varcalc DotResisted5 ${DotResisted5}+1
/varset DotOn5 FALSE
/return

Sub Event_DotResist6
/varcalc DotResisted6 ${DotResisted6}+1
/varset DotOn6 FALSE
/return

Sub Event_DotResist7
/varcalc DotResisted7 ${DotResisted7}+1
/varset DotOn7 FALSE
/return

Sub Event_DotResist8
/varcalc DotResisted8 ${DotResisted8}+1
/varset DotOn8 FALSE
/return



Sub Event_DotOff1
/varset DotOn1 FALSE
/return

Sub Event_DotOff2
/varset DotOn2 FALSE
/return

Sub Event_DotOff3
/varset DotOn3 FALSE
/return

Sub Event_DotOff4
/varset DotOn4 FALSE
/return

Sub Event_DotOff5
/varset DotOn5 FALSE
/return

Sub Event_DotOff6
/varset DotOn6 FALSE
/return

Sub Event_DotOff7
/varset DotOn7 FALSE
/return

Sub Event_DotOff8
/varset DotOn8 FALSE
/return

Sub Event_EQBC(EQBCSay,EQBCSender,EQBCCommand)
/if (${EQBCCommand.Left[1].Equal[/]}) {
/docommand ${EQBCCommand}
} else {
/call Event_Chat "EQBC" "${EQBCSender}" "${EQBCCommand}"
}
/return

Sub Event_ExpReport
/declare exp float local 0
/declare aas float local 0
/declare aanow float local 0
/declare expnow float local 0
/declare aahr float local 0
/declare exphr float local 0

/varcalc expnow (${Me.Level} * 100) + ${Me.PctExp}
/varcalc aanow (${Me.AAPointsTotal} * 100) + ${Me.PctAAExp}
/varcalc aas ${aanow} - ${aastart}
/varcalc exp ${expnow} - ${expstart}

/varcalc aahr ${aas} / (${Macro.RunTime} / 36)
/varcalc exphr ${exp} / (${Macro.RunTime} / 3600)

/bc AA Exp: ${aas} AA/Hour: ${aahr} Exp: ${exp} Exp/Hour: ${exphr}

/return

Sub Event_Gate(string Line,string MobName)
/if (${StopMobGate}) && ${Target.ID}==${TarID} && ${Me.AltAbilityReady[Translocational Anchor]} && ${Me.AltAbility[Translocational Anchor]}) {
/bc Translocational Anchor on ${Target.CleanName}
/call Cast "Translocational Anchor" alt
}
/return

Sub Event_Hit
/if (${Me.Class.ShortName.NotEqual[ENC]}) /return

/declare q int local 0
/declare r int local 0
/declare tempID int local
/varset r ${SpawnCount[npc radius 15]}
/if (${r}) {
/for q 1 to ${r}
/varset tempID ${NearestSpawn[${q},npc radius 15].ID}
/if (!${NearestSpawn[${q},npc radius 15].ID}) /next q
/squelch /target id ${tempID}
/delay 5 ${Target.ID}==${tempID}
/delay 1
/if (${Me.TargetOfTarget.ID}==${Me.ID} && ${Target.ID} && ${Target.ID}!=${Me.ID} && (!${MezImmuneList.Find[${Target.CleanName}]} || ${MezTimer${Target.ID}} > 0)) {
/call CheckAttacking ${NearestSpawn[${q},npc radius 15].ID}
/if (${Macro.Return}) {
/if (${Me.SpellReady[${stunSpell}]}) /call Cast "${stunSpell}" ${stunSpellGem} 2s
/if (${Me.PctHPs}<=80 && ${Me.AltAbilityReady[Color Shock]}) /call Cast "Color Shock" alt
/if (${Me.PctHPs}<=80 && ${Me.SpellReady[${runeSpell}]} && ${Spell[${runeSpell}].Stacks[0]}) /call AddToQueue "${runeSpell},${Me.Name}"
/if (${Me.PctHPs}<=75 && ${Me.AltAbility[Veil of Mindshadow]} && ${Me.AltAbilityReady[Veil of Mindshadow]}) /call Cast "Veil of Mindshadow" alt
/if (${Me.PctHPs}<=90 && !${Me.Buff[${selfRune}].ID} && !${Me.Buff[${selfAARune}].ID} && ${Me.AltAbilityReady[${selfAARune}]}) /call Cast "${selfAARune}" alt
/if (${Me.PctHPs}<=60 && ${Me.AltAbilityReady[Doppelganger]}) /call Cast "Doppelganger" alt
/if (${Me.PctHPs}<=50 && ${Me.AltAbilityReady[Beguiler's Banishment]} && ${SpawnCount[npc radius 20 zradius 20]}>2) /call Cast "Beguiler's Banishment" alt
/if (${Me.PctHPs}<=40 && ${Me.AltAbilityReady[Mind Over Matter]}) /call Cast "Mind Over Matter" alt
/if (${Me.PctHPs}<=85 && ${Me.AltAbilityReady[Beguiler's Directed Banishment]}) /call Cast "Beguiler's Directed Banishment" alt
/if (${Me.PctHPs}<=20 && ${Me.AltAbilityReady[Nightmare Stasis]} && ${Target.Level}<76) /call Cast "Nightmare Stasis" alt
/if (${Me.PctHPs}<=10 && ${Me.AltAbilityReady[Dimensional Instability]}) /call Cast "Dimensional Instability" alt
/if (${Defined[MezTimer${Target.ID}]} && ${MezTimer${Target.ID}} != -1) {
/varset MezTimer${Target.ID} 20
} else /if (!${Defined[MezTimer${Target.ID}]}) {
/declare MezTimer${Target.ID} 20
}
}
}
/next q
}

/return

Sub Event_InDoors
/varset Outside FALSE
/return

Sub Event_MezImmune

/${MyChannel} mezimmunemob ${Target.CleanName}
/return

Sub Event_Override(string Sender,int OverrideID)
/declare Override${OverrideID} int outer 1
/bc Overriding debuff max try limits on ${Target.CleanName}
/return

Sub Event_RageOff(string line)
/if ((${line.Find[${Spawn[${TarID}].DisplayName}]} || ${line.Find[${Target.DisplayName}]}) && ${Me.Pet.ID}) {
/target id ${TarID}
/pet attack
/varset Raged FALSE
}
/return

Sub Event_RageOn(string line)
/if (((${line.Find[${Spawn[${TarID}].DisplayName}]} || ${line.Find[${Target.DisplayName}]}) && ${Me.Pet.ID}) && !${Me.PetBuff[Master's Aura Effect]}) {
/echo Enrage detected! Backing pet off.
/pet back off
/varset Raged TRUE
/if (!${Me.Buff[Master's Aura Effect]} && !${Me.Song[Master's Aura Effect]} && ${UseMelee}) /attack off
}
/return

Sub Event_Slow(string Line, string MobName)
/varset Slowed TRUE
/if (${UseSlow}) /${MyChannel} ${Target.CleanName} has been slowed!
/return

Sub Event_SlowImmune
/varset Slowed TRUE
/${MyChannel} slowimmunemob ${Target.CleanName}
/echo slowimmunemob ${Target.CleanName}
/return

Sub Event_SlowResist
/varcalc SlowResist ${SlowResist}+1
/if (${SlowResist}>${SlowMaxTries}) /varset Slowed TRUE
/return

Sub Event_SnareImmune
/varset Snared TRUE
/${MyChannel} snareimmunemob ${Target.CleanName}
/return

Sub Event_Snareon
/varset Snared TRUE
/if (${UseSnare}) /${MyChannel} ${Target.CleanName} has been snared!
/return

Sub Event_SnareResist
/if (${SnareCounter}>2) {
/varset Snared TRUE
/if (${useSnare}) /${MyChannel} Snare resisted 3 times, giving up!
/varset SnareCounter 0
/return
}
/if (${SnareCounter}<3) {
/varset Snared FALSE
/varcalc SnareCounter ${SnareCounter}+1
/if (${UseSnare}) /${MyChannel} Snare resisted, trying again!
}
/return

Sub Event_SnareWornOff
/varset Snared FALSE
/return

Sub Event_SpellResistMindfreeze
/varcalc MindfreezeResist ${MindfreezeResist}+1
/return

Sub Event_Zoned
/varset Outside TRUE
/varset PetHealZoneTimer ${PetHealZoneTimer.OriginalTimer}

/varset IgnoreList ${Ini[${IniFile},"Ignores.${Zone.ShortName}","Ignore"]}
/if (${IgnoreList.Equal[NULL]}) {
/ini "${IniFile}" "Ignores.${Zone.ShortName}" "Ignore" "|"
/varset IgnoreList ${Ini[${IniFile},"Ignores.${Zone.ShortName}","Ignore"]}
/echo IgnoreList: ${IgnoreList}
} else {
/varset IgnoreList ${Ini[${IniFile},"Ignores.${Zone.ShortName}","Ignore"]}
/echo IgnoreList: ${IgnoreList}
}
/varset CharmImmuneList ${Ini[${IniFile},"CharmImmunes.${Zone.ShortName}","CharmImmune"]}
/if (${CharmImmuneList.Equal[NULL]}) {
/ini "${IniFile}" "CharmImmunes.${Zone.ShortName}" "CharmImmune" "|"
/varset CharmImmuneList ${Ini[${IniFile},"CharmImmunes.${Zone.ShortName}","CharmImmune"]}
/echo CharmImmuneList: ${CharmImmuneList}
} else {
/varset CharmImmuneList ${Ini[${IniFile},"CharmImmunes.${Zone.ShortName}","CharmImmune"]}
/echo CharmImmuneList: ${CharmImmuneList}
}
/varset SnareImmuneList ${Ini[${IniFile},"SnareImmunes.${Zone.ShortName}","SnareImmune"]}
/if (${SnareImmuneList.Equal[NULL]}) {
/ini "${IniFile}" "SnareImmunes.${Zone.ShortName}" "SnareImmune" "|"
/varset SnareImmuneList ${Ini[${IniFile},"SnareImmunes.${Zone.ShortName}","SnareImmune"]}
/echo SnareImmuneList: ${SnareImmuneList}
} else {
/varset SnareImmuneList ${Ini[${IniFile},"SnareImmunes.${Zone.ShortName}","SnareImmune"]}
/echo SnareImmuneList: ${SnareImmuneList}
}
/varset SlowImmuneList ${Ini[${IniFile},"SlowImmunes.${Zone.ShortName}","SlowImmune"]}
/if (${SlowImmuneList.Equal[NULL]}) {
/ini "${IniFile}" "SlowImmunes.${Zone.ShortName}" "SlowImmune" "|"
/varset SlowImmuneList ${Ini[${IniFile},"SlowImmunes.${Zone.ShortName}","SlowImmune"]}
/echo SlowImmuneList: ${SlowImmuneList}
} else {
/varset SlowImmuneList ${Ini[${IniFile},"SlowImmunes.${Zone.ShortName}","SlowImmune"]}
/echo SlowImmuneList: ${SlowImmuneList}
}
/varset MezImmuneList ${Ini[${IniFile},"MezImmunes.${Zone.ShortName}","MezImmune"]}
/if (${MezImmuneList.Equal[NULL]}) {
/ini "${IniFile}" "MezImmunes.${Zone.ShortName}" "MezImmune" "|"
/varset MezImmuneList ${Ini[${IniFile},"MezImmunes.${Zone.ShortName}","MezImmune"]}
/echo MezImmuneList: ${MezImmuneList}
} else {
/varset MezImmuneList ${Ini[${IniFile},"MezImmunes.${Zone.ShortName}","MezImmune"]}
/echo MezImmuneList: ${MezImmuneList}
}
/varset ColdImmuneList ${Ini[${IniFile},"ColdImmunes.${Zone.ShortName}","ColdImmune"]}
/if (${ColdImmuneList.Equal[NULL]}) {
/ini "${IniFile}" "ColdImmunes.${Zone.ShortName}" "ColdImmune" "|"
/varset ColdImmuneList ${Ini[${IniFile},"ColdImmunes.${Zone.ShortName}","ColdImmune"]}
/echo ColdImmuneList: ${ColdImmuneList}
} else {
/varset ColdImmuneList ${Ini[${IniFile},"ColdImmunes.${Zone.ShortName}","ColdImmune"]}
/echo ColdImmuneList: ${ColdImmuneList}
}
/varset DiseaseImmuneList ${Ini[${IniFile},"DiseaseImmunes.${Zone.ShortName}","DiseaseImmune"]}
/if (${DiseaseImmuneList.Equal[NULL]}) {
/ini "${IniFile}" "DiseaseImmunes.${Zone.ShortName}" "DiseaseImmune" "|"
/varset DiseaseImmuneList ${Ini[${IniFile},"DiseaseImmunes.${Zone.ShortName}","DiseaseImmune"]}
/echo DiseaseImmuneList: ${DiseaseImmuneList}
} else {
/varset DiseaseImmuneList ${Ini[${IniFile},"DiseaseImmunes.${Zone.ShortName}","DiseaseImmune"]}
/echo DiseaseImmuneList: ${DiseaseImmuneList}
}
/varset FireImmuneList ${Ini[${IniFile},"FireImmunes.${Zone.ShortName}","FireImmune"]}
/if (${FireImmuneList.Equal[NULL]}) {
/ini "${IniFile}" "FireImmunes.${Zone.ShortName}" "FireImmune" "|"
/varset FireImmuneList ${Ini[${IniFile},"FireImmunes.${Zone.ShortName}","FireImmune"]}
/echo FireImmuneList: ${FireImmuneList}
} else {
/varset FireImmuneList ${Ini[${IniFile},"FireImmunes.${Zone.ShortName}","FireImmune"]}
/echo FireImmuneList: ${FireImmuneList}
}
/varset MagicImmuneList ${Ini[${IniFile},"MagicImmunes.${Zone.ShortName}","MagicImmune"]}
/if (${MagicImmuneList.Equal[NULL]}) {
/ini "${IniFile}" "MagicImmunes.${Zone.ShortName}" "MagicImmune" "|"
/varset MagicImmuneList ${Ini[${IniFile},"MagicImmunes.${Zone.ShortName}","MagicImmune"]}
/echo MagicImmuneList: ${MagicImmuneList}
} else {
/varset MagicImmuneList ${Ini[${IniFile},"MagicImmunes.${Zone.ShortName}","MagicImmune"]}
/echo MagicImmuneList: ${MagicImmuneList}
}
/varset PoisonImmuneList ${Ini[${IniFile},"PoisonImmunes.${Zone.ShortName}","PoisonImmune"]}
/if (${PoisonImmuneList.Equal[NULL]}) {
/ini "${IniFile}" "PoisonImmunes.${Zone.ShortName}" "PoisonImmune" "|"
/varset PoisonImmuneList ${Ini[${IniFile},"PoisonImmunes.${Zone.ShortName}","PoisonImmune"]}
/echo PoisonImmuneList: ${PoisonImmuneList}
} else {
/varset PoisonImmuneList ${Ini[${IniFile},"PoisonImmunes.${Zone.ShortName}","PoisonImmune"]}
/echo PoisonImmuneList: ${PoisonImmuneList}
}

/varset StunImmuneList ${Ini[${IniFile},"StunImmunes.${Zone.ShortName}","StunImmune"]}
/if (${StunImmuneList.Equal[NULL]}) {
/ini "${IniFile}" "StunImmunes.${Zone.ShortName}" "StunImmune" "|"
/varset StunImmuneList ${Ini[${IniFile},"StunImmunes.${Zone.ShortName}","StunImmune"]}
/echo StunImmuneList: ${StunImmuneList}
} else {
/varset StunImmuneList ${Ini[${IniFile},"StunImmunes.${Zone.ShortName}","StunImmune"]}
/echo StunImmuneList: ${StunImmuneList}
}
/call RefreshAlerts

/return


Sub Event_IgnoreMob(string line,string MobName)
/if (!${IgnoreList.Find[${MobName}]}) {
/ini "${IniFile}" "Ignores.${Zone.ShortName}" "Ignore" "${MobName}|"
} else }
/ini "${IniFile}" "Ignores.${Zone.ShortName}" "Ignore" "${IgnoreList}${MobName}|"
}
/varset IgnoreList ${Ini[${IniFile},"Ignores.${Zone.ShortName}","Ignore"]}
/echo IgnoreList: ${IgnoreList}
/call RefreshAlerts
/return

Sub Event_StunImmuneMob(string line,string MobName)
/if (!${StunImmuneList.Find[${MobName}]}) {
/ini "${IniFile}" "StunImmunes.${Zone.ShortName}" "StunImmune" "${MobName}|"
} else }
/ini "${IniFile}" "StunImmunes.${Zone.ShortName}" "StunImmune" "${StunImmuneList}${MobName}|"
}
/varset StunImmuneList ${Ini[${IniFile},"StunImmunes.${Zone.ShortName}","StunImmune"]}
/echo StunImmuneList: ${StunImmuneList}
/call RefreshAlerts
/return

Sub Event_SnareImmuneMob(string line,string MobName)
/if (!${SnareImmuneList.Find[${MobName}]}) {
/ini "${IniFile}" "SnareImmunes.${Zone.ShortName}" "SnareImmune" "${MobName}|"
} else }
/ini "${IniFile}" "SnareImmunes.${Zone.ShortName}" "SnareImmune" "${SnareImmuneList}${MobName}|"
}
/varset SnareImmuneList ${Ini[${IniFile},"SnareImmunes.${Zone.ShortName}","SnareImmune"]}
/echo SnareImmuneList: ${SnareImmuneList}
/return

Sub Event_SlowImmuneMob(string line,string MobName)
/if (!${SlowImmuneList.Find[${MobName}]}) {
/ini "${IniFile}" "SlowImmunes.${Zone.ShortName}" "SlowImmune" "${MobName}|"
} else }
/ini "${IniFile}" "SlowImmunes.${Zone.ShortName}" "SlowImmune" "${SlowImmuneList}${MobName}|"
}
/varset SlowImmuneList ${Ini[${IniFile},"SlowImmunes.${Zone.ShortName}","SlowImmune"]}
/echo SlowImmuneList: ${SlowImmuneList}
/return

Sub Event_MezImmuneMob(string line,string MobName)
/if (!${MezImmuneList.Find[${MobName}]}) {
/ini "${IniFile}" "MezImmunes.${Zone.ShortName}" "MezImmune" "${MobName}|"
} else }
/ini "${IniFile}" "MezImmunes.${Zone.ShortName}" "MezImmune" "${MezImmuneList}${MobName}|"
}
/varset MezImmuneList ${Ini[${IniFile},"MezImmunes.${Zone.ShortName}","MezImmune"]}
/echo MezImmuneList: ${MezImmuneList}
/return

Sub Event_FireImmuneMob(string line,string MobName)
/if (!${FireImmuneList.Find[${MobName}]}) {
/ini "${IniFile}" "FireImmunes.${Zone.ShortName}" "FireImmune" "${MobName}|"
} else }
/ini "${IniFile}" "FireImmunes.${Zone.ShortName}" "FireImmune" "${FireImmuneList}${MobName}|"
}
/varset FireImmuneList ${Ini[${IniFile},"FireImmunes.${Zone.ShortName}","FireImmune"]}
/echo FireImmuneList: ${FireImmuneList}
/return

Sub Event_ColdImmuneMob(string line,string MobName)
/if (!${ColdImmuneList.Find[${MobName}]}) {
/ini "${IniFile}" "ColdImmunes.${Zone.ShortName}" "ColdImmune" "${MobName}|"
} else }
/ini "${IniFile}" "ColdImmunes.${Zone.ShortName}" "ColdImmune" "${ColdImmuneList}${MobName}|"
}
/varset ColdImmuneList ${Ini[${IniFile},"ColdImmunes.${Zone.ShortName}","ColdImmune"]}
/echo ColdImmuneList: ${ColdImmuneList}
/return

Sub Event_MagicImmuneMob(string line,string MobName)
/if (!${MagicImmuneList.Find[${MobName}]}) {
/ini "${IniFile}" "MagicImmunes.${Zone.ShortName}" "MagicImmune" "${MobName}|"
} else }
/ini "${IniFile}" "MagicImmunes.${Zone.ShortName}" "MagicImmune" "${MagicImmuneList}${MobName}|"
}
/varset MagicImmuneList ${Ini[${IniFile},"MagicImmunes.${Zone.ShortName}","MagicImmune"]}
/echo MagicImmuneList: ${MagicImmuneList}
/return

Sub Event_PoisonImmuneMob(string line,string MobName)
/if (!${PoisonImmuneList.Find[${MobName}]}) {
/ini "${IniFile}" "PoisonImmunes.${Zone.ShortName}" "PoisonImmune" "${MobName}|"
} else }
/ini "${IniFile}" "PoisonImmunes.${Zone.ShortName}" "PoisonImmune" "${PoisonImmuneList}${MobName}|"
}
/varset PoisonImmuneList ${Ini[${IniFile},"PoisonImmunes.${Zone.ShortName}","PoisonImmune"]}
/echo PoisonImmuneList: ${PoisonImmuneList}
/return

Sub Event_DiseaseImmuneMob(string line,string MobName)
/if (!${DiseaseImmuneList.Find[${MobName}]}) {
/ini "${IniFile}" "DiseaseImmunes.${Zone.ShortName}" "DiseaseImmune" "${MobName}|"
} else }
/ini "${IniFile}" "DiseaseImmunes.${Zone.ShortName}" "DiseaseImmune" "${DiseaseImmuneList}${MobName}|"
}
/varset DiseaseImmuneList ${Ini[${IniFile},"DiseaseImmunes.${Zone.ShortName}","DiseaseImmune"]}
/echo DiseaseImmuneList: ${DiseaseImmuneList}
/return


Sub Event_CharmImmuneMob(string line,string MobName)
/if (!${CharmImmuneList.Find[${MobName}]}) {
/ini "${IniFile}" "CharmImmunes.${Zone.ShortName}" "CharmImmune" "${MobName}|"
} else }
/ini "${IniFile}" "CharmImmunes.${Zone.ShortName}" "CharmImmune" "${CharmImmuneList}${MobName}|"
}
/varset CharmImmuneList ${Ini[${IniFile},"CharmImmunes.${Zone.ShortName}","CharmImmune"]}
/echo CharmImmuneList: ${CharmImmuneList}
/return

Also here is my Nec ini :
[Settings]
MyChannel=bc
DefaultMainTank=
AssistType=pc
SecondAssistType=pc
SitTimer=10s
MedTimer=45s
MedAt=30
ReAssist=10s
UseMount=TRUE
MountName=Ornate Barding
NecroHealGroup=TRUE
NecroHealGroupAt=30
AutoAcceptRez=TRUE
UseCamp=FALSE
UseMelee=FALSE
MeleeAt=0

CheckNamed=TRUE
UseBeep=TRUE


[Spells]
ImmunityCheck=FALSE
BetweenNukeDelay=8s
MinManaToNuke=10

NukeTotal=1

UseNuke1=TRUE
Nuke1=Supplication of Blood Rk. II
NukeGem1=gem10
Nuke1At=40

UseNuke2=FALSE
Nuke2=Siphon Essence Rk. II
NukeGem2=gem1
Nuke2At=40

GoM=Gift of Amazing Exquisite Radiant Mana
GoMSpell=Siphon Essence Rk. II
GoMSpellGem=gem1
GoMAt=95

UseSnare=TRUE
Snare=Encroaching Darkness
SnareGem=alt
SnareAt=25
MaxNPCs=99

InvisSpell=Cloak of Shadows
IG=alt
InvisTrigger=invison
InvisOffTrigger=invisoff

UseFD=TRUE
FDCount=10
FDat=25
FDSpell=Death Peace
FDSpellGem=alt
FDStandAt=40

RecourseTotal=0

UseRecourse1=TRUE
Recourse1HPAt=100
Recourse1ManaAt=80
Recourse1SpellName=Mind Decomposition Rk. II
Recourse1Name=Mind Decomposition Recourse
Recourse1Gem=gem9

UseDebuff=FALSE
DebuffAt=95
DebuffSpell=Scent of Afterlife Rk. II
DebuffGem=gem2

UseAura1=FALSE
Aura1=
AuraGem1=

UseAura2=FALSE
Aura2=
AuraGem2=

[OffensiveClickies]
ClickyNukeTotal=5

ClickyNuke1=Dagger of Death
UseClickyNuke1At=95
StopClickyNuke1At=25
NamedOnlyClickyNuke1=FALSE

ClickyNuke2=Blightbringer's Tunic of the Grave
UseClickyNuke2At=95
StopClickyNuke2At=25
NamedOnlyClickyNuke2=TRUE

ClickyNuke3=Shadow-Vexed Silk Robe
UseClickyNuke3At=95
StopClickyNuke3At=25
NamedOnlyClickyNuke3=FALSE

ClickyNuke4=Tainted Lifefalter Silk Robe
UseClickyNuke4At=95
StopClickyNuke4At=25
NamedOnlyClickyNuke4=FALSE

ClickyNuke5=Deathwhisper
UseClickyNuke5At=95
StopClickyNuke5At=25
NamedOnlyClickyNuke5=FALSE

[AA]
AATotal=10

AA0=EXAMPLE ONLY - "AA0" will never fire and doesnt count towards the AATotal
AAGem0=alt/gem#
UseAA0=TRUE (Default TRUE)
UseAA0At=95 (Default 95 or less)
NamedOnlyUseAA0=FALSE
UseAA0IfNearby=npc (Default npc) - pet / pc / mercenary / npc / corpse / etc
UseAA0IfNearbyAmt=1 (Default is 1)
UseAA0AtMyHPs=100 (Default is 100 or less)
StopAA0At=25 (Default is 25 or less)

AA1=Whisperwind
AAGem1=alt
UseAA1=TRUE
NamedOnlyUseAA1=FALSE
UseAA1AtMyHPs=20

AA2=Army of the Dead
AAGem2=alt
UseAA2=TRUE
NamedOnlyUseAA2=FALSE
UseAA2IfNearby=corpse
UseAA2IfNearbyAmt=4
StopAA2At=50

AA3=Siphon Essence Rk. II
AAGem3=gem1
UseAA3=TRUE
NamedOnlyUseAA3=FALSE
UseAA3AtMyHPs=80

AA4=Quivering Veil of Xarn
AAGem4=alt
UseAA4=TRUE
NamedOnlyUseAA4=FALSE
UseAA4AtMyHPs=10

AA5=Swarm of Decay
AAGem5=alt
UseAA5=TRUE
NamedOnlyUseAA5=FALSE
StopAA5At=50

AA6=Rise of Bones
AAGem6=alt
UseAA6=TRUE
NamedOnlyUseAA6=FALSE
UseAA6IfNearby=corpse
UseAA6IfNearbyAmt=3
StopAA6At=50

AA7=Silent Casting
AAGem7=alt
UseAA7=TRUE
NamedOnlyUseAA7=TRUE

AA8=Gathering Dusk
AAGem8=alt
UseAA8=TRUE
NamedOnlyUseAA8=FALSE

AA9=Focus of Arcanum
AAGem9=alt
UseAA9=TRUE
NamedOnlyUseAA9=FALSE

AA10=Fundament: Third Spire of Necromancy
AAGem10=alt
UseAA10=TRUE
NamedOnlyUseAA10=FALSE

AA11=
AAGem11=
UseAA11=TRUE
UseAA11At=95
NamedOnlyUseAA11=FALSE
UseAA11IfNearby=npc
UseAA11IfNearbyAmt=1
UseAA11AtMyHPs=100
StopAA11At=25



[Dots]
DotTotal=2
DotTotalIfNamed=5
UseDots=TRUE

DotStartAt=95
DotStopAt=20
BetweenDotDelay=1s
MinManaToDot=10

Dot1=Searing Shadow
DotGem1=gem7
DotMaxTries1=2

Dot2=Eranon's Decay Rk. II
DotGem2=gem5
DotMaxTries2=2

Dot3=Venonscale Venom
DotGem3=gem6
DotMaxTries3=2

Dot4=Anthema of Life
DotGem4=gem2
DotMaxTries4=2

Dot5=Visziaj's Pallid Haze
DotGem5=gem4
DotMaxTries5=2

Dot6=Ashengate Pyre
DotGem6=gem3
DotMaxTries6=2

Dot7=
DotGem7=
DotMaxTries7=

Dot8=
DotGem8=
DotMaxTries8=

[SelfBuffs]
SelfBuffTotal=3

SelfBuff1=Spectralside
SelfBuffSpell1=Spectralside
SelfBuffGem1=gem3

SelfBuff2=Aura of Eternity
SelfBuffSpell2=Lost Boots of Flowing Slime
SelfBuffGem2=item

SelfBuff3=Shield of Dreams
SelfBuffSpell3=Glowing Gossamer Robe
SelfBuffGem3=item

SelfBuff4=
SelfBuffSpell4=
SelfBuffGem4=

SelfBuff5=Reyfin's Racing Thoughts
SelfBuffSpell5=
SelfBuffGem5=item

SelfBuff6=NameOfBuff
SelfBuffSpell6=Spell/item name
SelfBuffGem6=gem#/alt/item

SelfBuff7=NameOfBuff
SelfBuffSpell7=Spell/item name
SelfBuffGem7=gem#/alt/item

SelfBuff8=NameOfBuff
SelfBuffSpell8=Spell/item name
SelfBuffGem8=gem#/alt/item

[Buffs]
DoBuffs=TRUE
BuffGemDefault=3
BuffTriggerTotal=2
BuffTotal=2

Buff1=Dead Man Floating
BuffTrigger1=DMF me
Buff2=Dead Men Floating
BuffTrigger2=DMF all
Buff3=
BuffTrigger3=
Buff4=
BuffTrigger4=

[Pet]
UsePet=TRUE
PetAttackAt=95
PetSpellGem=gem3
PetSpell=Noxious Servant

ShrinkPet=FALSE
ShrinkPetSpell=
ShrinkPetSpellGem=gem3

PetBuffRecheck=10s
DoPetBuffs=TRUE
PetMana=20
UsePetFocusAA=TRUE
DoPetHeals=TRUE
UseAAPetHeal=TRUE
PetAAHealAt=10

PetHealAt=20
PetHealSpell=Wintry Revival Rk. II
PetHealSpellGem=gem6

UsePetDelayHeal=FALSE
PetDelayHealSpell=Promised Rejuvenation Rk. II
PetDelayHealAt=60
PetDelayHealGem=gem10

PetBuffTotal=1

PetBuffName1=Sigil of the Aberrant Rk. II
PetBuffSpell1=Sigil of the Aberrant Rk. II
PetBuffGem1=gem3

PetBuffName2=Aegis of Kildrukaun
PetBuffSpell2=Aegis of Kildrukaun
PetBuffGem2=gem3

PetBuffName3=
PetBuffSpell3=
PetBuffGem3=

PetBuffName4=
PetBuffSpell4=
PetBuffGem4=

PetBuffName5=
PetBuffSpell5=
PetBuffGem5=

PetBuffName6=
PetBuffSpell6=
PetBuffGem6=


[Misc]
UseSmartDPS=TRUE
DotSmartStopPercent=35
DotStopAtSeconds=15
DoNukesIfMobDeadSoon=TRUE
AnnounceTimeRemaining=TRUE
AnnouncedTimer=5s

Balance=FALSE
BalanceOnTrigger=balancefight on
BalanceOffTrigger=balancefight off
BalanceAt=0
 
Last edited:
You must log in or register to reply here.

Similar threads

W
Enchanter Macro?
Replies
2
Views
433
EverQuest MacroQuest Macros, HUDS & UI's
warking
W
C
Need a Macro that i can chain cast over many different accounts.
Replies
4
Views
512
EverQuest MacroQuest Macros, HUDS & UI's
Spiken
Spiken
M
Bot Questions and Suggestions
Replies
0
Views
370
MQ2Bot - Botting Plugin
maximoh
M
snoopy3525
Two Basic Questions regarding Bot Melee'ing
Replies
3
Views
450
EverQuest General Chat, Requests & Questions
htw
htw
C
Ranger soloing macro?
Replies
4
Views
811
EverQuest MacroQuest Macros, HUDS & UI's
HateofAB
H