The (Mostly) Complete Raiding Druid Package v7.23

Post your completed (working) macros here. Only for macros using MQ2Data syntax!

Moderator: MacroQuest Developers

A_Druid_00
Macro Maker Extraordinaire
Posts: 2378
Joined: Tue Jul 13, 2004 12:45 pm
Location: Rolling on the Lawn Farting

The (Mostly) Complete Raiding Druid Package v7.23

Post by A_Druid_00 » Mon Nov 08, 2004 9:39 pm

6/28
v7.23Added very basic master commands. follow XXX tells the bot to follow the designated person, just "follow" will follow the sender. You need to use the "Stop" command to stop following. It's very BETA at the moment now, so please provide suggestions.
Fixed the RefreshBuffs section to actually refresh buffs (Hate when I screw up and use an OR instead of an AND).
Also added the MasterList variable to the ini in order to define masters. The bot will only respond to command tells or irc from the master, but still buffs on request.
Added a couple doevents checks back to allow RootNScoot to fire more often, I'll probably add a couple more before I'm done.
Oh, and RaidDruid will automatically accept group invites from people on your MasterList too.
Maybe I did some other stuff, you decide!
6/27
v7.22 Minor bugfix in the rootnscoot toggle, RDEVents updated
v7.21 Fixed an issue in Dobuffs and replaced a missing /goto in RootNScoot
v7.2Removed the RDPause variable. It really wasn't up to date, and it wasn't all that useful anyway. If enough people bitch I'll put it back in and maybe clean it up, but until then /mqpause works even better anyway.
Cut back on the number of /doevents checks in hopes of getting rid of most of the mistargetting issues that were cropping up on me left and right with events firing all over the place. Won't really change much with the macro's operations, but hopefully will make things behave better.
Revamped my RefreshBuffs code to behave a little more like the DoBuffs. Also added a new variable to each DoBuff called DoBuffRefresh which defaults to 0. Change it to a 1 if you want it to refresh those buffs as they wear off. I did this to prevent things that might not need to be refreshed, like invis, can be controlled.
Fixed a major issue with both DoBuffs and RefreshBuffs. It wasn't taking into account the SitTimer, among other things. The new setup is much cleaner and probably behaves a LOT more reliably.
Also added Root and Scoot code. This code will target the nearest mob if you get hit, root it and then face the Main Assist and run over the top of him in hopes of peeling the mob off if root didn't happen to stick. It stops running after 1 second or until you're out of the mob's melee range. Haven't given this a real run for it's money yet, but it worked OK while single grouping tactics named yesterday. You can toggle it with the /rootnscoot alias, and you need to define a RootSpell and RootGem to cast from in the ini.
Added the new RootNScoot and RefreshBuffs toggles to the HUD for easy reference.
I think that's it, though I may have done some other tweaks in various areas that needed it. As always, keep the bug reports coming.
6/26
v7.1 Fixed the targetting issues by removing all instances fo the MyTarget variable. It used to be useful when this wasn't a full blown automation macro, but it's long since been pretty pointless and it was cuasing targetting issues with healing and buffing/debuffing. It will now always switch back to the MA's target if one exists. If you don't want your target switching on you, then use /mqpause or /rdpause for manual intervention.
Also re-added the MA Healing code that will only fast heal the MA if he is below 50% of your heal threshold instead of the heal threshold to stop from padding the MT at 50% when there's a cleric CHing, so you can start fast heals with enough time on non-MA targets that they won't be dead before it lands.
Refreshbuffs will also wait until it has enough mana to recast the buff before moving on to other duties as well. It still checks the group's HPs while waiting on mana to recover and heals if needed and there's mana to spare.
Only RaidDruid.mac and RDEvents.inc need to be updated for this change.
v7.0 Added auto-rebuffing code based on the new events triggered when your buffs wear off on PCs. It only refreshes single target buffs, so if you actually click off any group buffs like regen etc, it won't refresh them when the rest of the group loses it. /refreshbuffs turns it on, and there's a ini entry for the spell gem called WornOffGem in the ini (Defaults to gem3)
6/25
v6.92 I'm back bitches.... sorta at least Fixed the Group changes for pets that got missed in Fallon's version... also posting a new HUD with the group changes. I plan on adding some other stuff like melee code, root and scoot code, and maybe even HoT handling, though I'll need to find a shaman or something to let me do the testing for that.
1/21
v6.91 Changed up the group checking logic to use the TankHealPct for MA1 even when UseCH is off. It still won't heal the tank if he's above HealPct if you set your tankhealpct to like 90 and still have healpct set to 70. But, if it's set lower than the healpct, say HealPct is 70 and TankHealPct is 50, it won't heal the MA until he falls below 50. I hope that makes sense.
1/20
v6.9 I realized that my HealMeFirst logic was completely neglected to check my mana amount tonight and so was spam attempting to heal me while I was oom. Also realized that my Check4Pad logic wasn't using all my latest enhancements, so I fixed that. WTB a bug tester for my versions. I may have tweaked other things too, but I can't remember what they were.
1/18
v6.8 Added a version check justl ike Rogue Helper's version check to prevent loading the insane amount of aliases associated with RD every time the macro is loaded. CAUTION: Do not delete your Macroquest ini file... If you do, make sure to clear the Version parameter in your RD_XXX.ini file or you will lose all your aliases.
1/17
v6.7 Added HealMeFirst logic to the CheckHP sub. It will now interrupt heals if you are below the healpct. Tweaked /autosit logic so that it won't attempt to sit if there's a mob within 20 feet of you. Also fixed a logic problem with group HP checking. I wasn't resetting the WorstHurt %, so it would double heal the same group member. Buffbeg has also had a buinch of new buffs added, check them out.
v6.61 Fixed RDEvents with the syntax error pointed out by fallon
1/16
v6.6 Beta Added /healmefirst toggle, similar to AFCleric's healing code. If turned on, it will heal you first if you are below the /healpct, hopefully saving your life long enough to save any other who may need it. Essentially the group heal order is now Tank -> You -> Group.
v6.5 Beta Added Beta Pet Healing code. I don't group with many pet classes, so I can't test it out easily. Logic looks sound though, let me know how it works. Also changed up the CheckGroup sub a lot, it will now recheck the group after it heals someone before it moves on to other duties. Also shuffled DoRC around so that it gets checked every time the group does. /healpets turns pet healing on, and /pethealpct will adjust the % you start healing pets at.
v6.4 Cleaned up some other NULL announcements I missed. Also fixed checkgroup to heal the MA normally if /usech is off. *Think* I fixed the moveto after looting. Test it out and let me know if it still behaves oddly. Also fixed it so it wouldn't chain summon a horse if underwater.
1/14
v6.3 Added an extra check to the Heal/Debuff/etc Reports so that you should never be caught casting NULL on NULL.
v6.2 Fixed the /spamdelay toggle to properly set the ini.
v6.1 Minor change to the ReportMana subs, so that it actually works now =D. Also changed up some of the healing logic so that it will wait until your heal spell is ready to cast before announcing it.
v6.0 RaidDruid is no longer mute. Added toggles to chaty about pretty much every function he's capable of. Gonna try to list them all, it's pretty big:
/chatchannel Sets the Chat Channel that RD will talk in (Ex. /chatchannel gsay, echo, rsay, 1, 2, 3, etc.)
/reportdebuffs Toggle reporting of Debuffs on and off RD will report after a debuff has successfully landed, or after DotRecasts has been exceeded
/reportdobuffs Toggles reporting of buff directed to others. It will send the buff recipient a tell, and also announce it in the /chatchannel
/reportdots Same as ReportDebuffs, but for DoTs
/reportepic Same as ReportDebuffs, but for Epic 1.5
/reportheals Will report both CHs and Fast Heals
/reportinterrupts Reports any time you interrupt another spell to heal
/reportmana Reports your mana if you get below /medpct. Will report after every XP message, will also report when it hits FM after reporting LOM.
/reportrc Toggles reporting of Radiant Cure Casting
/reportselfbuffs Toggles reporting of casting buffs on yourself
/reportsnares Same as ReportDebuffs, but for Snare. Will also report if a mob is immune
/reportsotw Toggles reporting of Spirit of the Wood Casting
/reportwow Toggles reporting of Wrath of the Wild Casting
/spamdelay Sets the amount of time it will wait between announcements. This prevents if from spamming your group with 5000 interrupts a minute. Set it to whatever you feel comfortable with. Defaults to 3s.
1/13
v5.4 Beta Autoninja now returns you to your starting loc after looting corpses. Get the most current version of MQ2Moveutils including the fix posted by Cr4zyb4rd, to ensure /moveto works correctly. Only RDEvents needs to be updated for this one. Still Beta since I haven't actually tested it within the macro. I do know the /moveto logic is sound though!
1/10
v5.3 Beta Added /waittocancel alias. When turned on, this will wait until your heals have less than .5 seconds left before making the decison to cancel the heal. This will help out tons in raid situations when a lot of heals are hitting the tank and his HPs are fluctuating wildly above/below the cancelpct. Not 100% tested, but I think my logic is good and I can't play tonight. Oh yeah, and CheckHP now watches your target's state while your heal is casting, and will cancel your heal if the target is a monk/necro/sk and they break FD for whatever reason.
1/8
v5.2 Added ducking and pad healing logic to the UseCH code. If the tank's HPs are less than half of your configured tankhealpct, and there is still more than 5 seconds left on CH, it will duck out of CH and cast a pad heal.
1/5
v5.0 Tank healing is in, turn it on with the /usech alias, and watch it go to town. It will only use CH on the designated MA1 (So make sure MA1 is set to your Main Tank), and what it does is basically the same as Cr4zy's compucleric code. It will monitor the tank's HPs and if he's taking enough damage to be dead in less than 20 seconds, it will duck out of whatever RD is currently doing and start a CH. If the tank's HPs stop falling and level off above the TankHealPct, it will cancel CH and wait until the tank's HPs fall again. Set the TankHealPct to the abslute floor you want to start CH at. I set mine at about 40% today, as that's about the point where I'll land a full CH on the tanks I group with. That way you're pretty much guaranteed to get a full CH no matter what, and you'll start CHs early if your tank is taking a lot of damage pre-slow, pre-mezzes, etc. Worked like a champ in PoFire, but it feels risky at times. Only killed the tank once when I set the TankHealPct to 0, so it's pretty reliable as long as you have a non-retarded TankHealPct configured. Doubt you'll still be able to heal in places like RS reliably, but if you have a solid tank I'm willing to bet most other zones are fairly safe and efficient with this.

I'd like to give special thanks to the following people for giving me the framework with which to build my contribution:
Cr4zyb4rd for taking the time to teach me some of the more complicated features of Macro building. And also for finding new and original ways to break my macros for me. He also wrote the original framework for feedme, though I did a lot of improving to it.
Rusty for building one hell of an inc with Spell_Routines
Fantum409 for writing the original wait4rez and buffbeg macs that I converted into incs here.
Neolesh for spawning this entire thing in the first place with his AEHealer.mac for clerics, which I promptly butchered and put to use for druids.
And whoever I borrowed the self buff checking code from. I snagged it from some mac that I can't remember.
Jerle69 and Azum for giving me the framework for my toggles
NuttsThatKlank for sparking the HUD idea for the toggles
ml2517 for the ini and buff looping code. Very nice shit man, I hope I can wrap my brain around your MDL code enough to get my debuffs to be as cool as yours.

You're also probably going to want a custom bind to toggle between your nukes based on the situation, here's the one I use:

Code: Select all

/custombind add NukeToggle 
/custombind set /varset WhichNuke ${If[${WhichNuke}==1,2,1]} 
/bind WhichNuke ctrl space 
THINGS YOU NEED TO RUN THIS MACRO THAT ARENT CONTAINED IN THIS POST:
All of the below items can be found in the snippets section of these forums
spell_routines.inc
buffbeg.inc
feedme.inc
wait4rez.inc
Last edited by A_Druid_00 on Wed Jun 29, 2005 10:11 am, edited 164 times in total.
[quote]<DigitalMocking> man, A_Druid_00 really does love those long ass if statements
<dont_know_at_all> i don't use his macro because i'm frightened of it[/quote]
[quote][12:45] <dont_know_at_all> never use a macro when you can really fuck up things with a plugin[/quote]

A_Druid_00
Macro Maker Extraordinaire
Posts: 2378
Joined: Tue Jul 13, 2004 12:45 pm
Location: Rolling on the Lawn Farting

RaidDruid.mac

Post by A_Druid_00 » Mon Nov 08, 2004 9:41 pm

Code: Select all

|THE ALL INCLUSIVE RAID DRUID MACRO v7.23
|THIS IS A CULMINATION OF ALL MY RECENT DRUID MACROS COMBINED INTO ONE GRANDDADDY OF A MACRO
|IT'S STILL A WORK IN PROGRESS, BUT IT'S PRETTY MUCH EVERYTHING I'VE ALWAYS WANTED IN A
|DRUID MACRO.
#include Spell_Routines.inc
#include feedme.inc
#include wait4rez.inc
#include Buffbeg.inc
#include RDLoadIni.inc
#include RDEvents.inc
#include RDDeclares.inc
|#CHAT group
|#CHAT guild
#CHAT tell

Sub Main
/echo Uber Raid Druid Macro Online, hold onto your seatbelt!
/call RDDeclares
/if (${RDVersion.NotEqual[${Ini[RD_${Me.CleanName}.ini,Settings,Version]}]}) /call LoadAliases
/call LoadIni
/call BuffBegDeclares
/call FeedMeDeclares
:mainloop
/call FeedMe
/call BuffBeg
/if (${Me.Invis}) {
  /delay 1
  /goto :mainloop
}
/call CheckGroup
/call ClickRods
/call DoWoW
/call CheckBuffs
/if (${SpawnCount[npc radius ${NPCRadius} zradius ${NPCZRadius}]}) {
  /call DoAssistHeal
  /call DoAEHeal
  /call assistMA1
}
/doevents
/call AutoSit
/goto :mainloop
/return

Sub ClickRods
/call CheckGroup
/if (${ClickRods} && ${FindItem[=Rod of Mystical Transvergance].InvSlot} && !${RodTimer} && ${Me.PctMana}<${RodMana}) {
  /call Cast "Rod of Mystical Transvergance" item
  /varset RodTimer 310s
}
/return

Sub DoWoW
/declare i int local
/if (${DoWoW} && ${Me.AltAbilityReady[Wrath of the Wild]}) {
  /for i 1 to 3
  /call CheckGroup
  /if (${Spawn[pc ${MA${i}}].ID} && ${Spawn[pc ${MA${i}}].Distance}<100) {
    /target pc ${MA${i}}
    /delay 5 ${Target.ID}==${Spawn[pc ${MA1}].ID}
    /if (${Target.ID}==${Spawn[pc ${MA${i}}].ID}) {
      /if (${ReportWoW} && !${SpamTimer} && ${Target.CleanName.NotEqual[NULL]}) /${ChatChannel} Wrath of the Wild @ ${Target.CleanName}
      /varset SpamTimer ${SpamDelay}
      /call Cast "Wrath of the Wild" alt
    }
    /if (${Spawn[${MATarget}].ID}) /target id ${MATarget}
    /return
  }
  /next i
}
/return

Sub DoRC
/declare i int local
/for i 1 to 20
/if (${DoRC} && ${Me.AltAbilityReady[${RCAA}]} && ${RCDebuffs.Find[${Me.Buff[${i}].Spell}]} && !${Me.Moving} && !${Me.Casting.ID}) {
  /if (${ReportRC} && !${SpamTimer}) /${ChatChannel} ${RCAA} inc
  /varset SpamTimer ${SpamDelay}
  /call Cast "${RCAA}" alt 10s Check4Pad
}
/next i
/return

Sub DoAssistHeal
/if (${AssistHeal}) {
  /declare index        int local
  /declare NPCArray[50] int local
  /declare NPCsInRange  int local
  /varset NPCsInRange ${SpawnCount[npc radius ${NPCRadius} zradius ${NPCZRadius}]}
  /for index ${NPCsInRange} downto 1
  /if (!${index}) /return
  /varset NPCArray[${index}] ${NearestSpawn[${index}, npc].ID}
  /next index
  /for index ${NPCsInRange} downto 1
  /squelch /target id ${NPCArray[${index}]}
  /if (${Target.LineOfSight}) {
    /assist
    /delay 5 ${Target.Type.Equal[PC]}
    /call ShouldIHeal
    /call AutoSit
  }
  /if (${Spawn[${MATarget}].ID}) /target id ${MATarget}
  /next index
}
/return

Sub DoAEHeal
/if (${AEHeal}) {
  /declare index        int local
  /declare PCArray[100] int local
  /declare PCsInRange   int local
  /varset PCsInRange ${SpawnCount[pc radius ${PCRadius} zradius ${PCZRadius}]}
  /for index ${PCsInRange} downto 1
  /varset PCArray[${index}] ${NearestSpawn[${index}, pc].ID}
  /next index
  /for index ${PCsInRange} downto 1
  /target id ${PCArray[${index}]}
  /delay 2
  /call ShouldIHeal
  /call AutoSit
  /next index
  /if (${Spawn[${MATarget}].ID}) /target id ${MATarget}
}
/return

Sub ShouldIHeal
:ShouldIHealAgain
/if (${HealFD} && ${Target.State.NotEqual["FEIGN"]} && (${String[${Target.Class}].Equal[Monk]} || ${String[${Target.Class}].Equal[Necromancer]} || ${String[${Target.Class}].Equal["Shadow Knight"]})) /return
/if (${Target.Type.Equal[PC]} && ${Target.PctHPs}<${HealPct} && ${Target.Distance}<${Spell[${FastHealID}].Range} && ${Me.CurrentMana}>${Spell[${FastHealID}].Mana}) {
  :ShouldIWait
  /if (${Me.Moving} || ${Me.Casting.ID} || (${Me.Gem[${FastHeal}]} && !${Me.SpellReady[${FastHeal}]})) /goto :ShouldIWait
  /if (${ReportHeals} && !${SpamTimer} && ${Target.CleanName.NotEqual[NULL]}) /${ChatChannel} ${FastHeal} @ ${Target.CleanName} the ${Target.Class}
  /varset SpamTimer ${SpamDelay}
  /call Cast "${FastHeal}" ${FastHealGem} 1s CheckHP
  /varset SitTimer ${SitDelay}
  /goto :ShouldIHealAgain
}
/call CheckGroup
/return

Sub CheckHP
/if (${Me.Casting.ID}==${TankHealID} && ${Target.ID}==${Spawn[pc ${MA1}].ID}) {
  /call CheckPPS
  /if (${Target.PctHPs}>${TankHealPct} && ${TankTTL}>200 && ${castEndTime}<40) {
    /call DoInterrupt
    /return
  }
  /if (${Target.PctHPs}<=${Math.Calc[${TankHealPct}/2]} && ${castEndTime}>=50) {
    /if (${Me.Casting.ID}) {
      /if (!${Me.Mount.ID}) {
        /if (${ReportInterrupts} && !${SpamTimer}) /${ChatChannel} Interrupting ${Me.Casting}
        /varset SpamTimer ${SpamDelay}
        /call Interrupt
        /call Cast "${FastHeal}" ${FastHealGem} 1s CheckHP
      } else {
        /if (${ReportInterrupts} && !${SpamTimer}) /${ChatChannel} Interrupting ${Me.Casting}
        /varset SpamTimer ${SpamDelay}
        /call Interrupt
        /call Cast "${FastHeal}" ${FastHealGem} 1s CheckHP
        /if (${UseMount} && ${Me.PctMana}<${MedPct}) /call Cast "${MountItem}" item
      }
    }
  }
}
/if (${Me.Casting.ID}!=${TankHealID} && ${Target.PctHPs}>=${CancelPct}) {
  /if (${WaitToCancel} && ${castEndTime}>5) /return
  /call DoInterrupt
}
/if (${HealMeFirst} && ${Me.Casting.ID} && ${Me.PctHPs}<=${HealPct} && ${Target.ID}!=${Me.ID}) {
  /if (!${Me.Mount.ID}) {
    /if (${ReportInterrupts} && !${SpamTimer}) /${ChatChannel} Interrupting ${Me.Casting} to heal myself
    /varset SpamTimer ${SpamDelay}
    /call Interrupt
    /target id ${Me.ID}
    /call Cast "${FastHeal}" ${FastHealGem} 1s CheckHP
    /if (${Spawn[${MATarget}].ID}) /target id ${MATarget}
  } else {
    /if (${ReportInterrupts} && !${SpamTimer}) /${ChatChannel} Interrupting ${Me.Casting} to heal myself
    /varset SpamTimer ${SpamDelay}
    /call Interrupt
    /target id ${Me.ID}
    /call Cast "${FastHeal}" ${FastHealGem} 1s CheckHP
    /if (${UseMount} && ${Me.PctMana}<${MedPct}) /call Cast "${MountItem}" item
    /if (${Spawn[${MATarget}].ID}) /target id ${MATarget}
  }
}
/if (${HealFD} && ${Target.State.NotEqual["FEIGN"]} && (${String[${Target.Class}].Equal[Monk]} || ${String[${Target.Class}].Equal[Necromancer]} || ${String[${Target.Class}].Equal["Shadow Knight"]})) /call DoInterrupt
/return

Sub DoInterrupt
/if (${Me.Casting.ID}) {
  /if (!${Me.Mount.ID}) {
    /if (${ReportInterrupts} && !${SpamTimer}) /${ChatChannel} Interrupting ${Me.Casting}
    /varset SpamTimer ${SpamDelay}
    /call Interrupt
  } else {
    /if (${ReportInterrupts} && !${SpamTimer}) /${ChatChannel} Interrupting ${Me.Casting}
    /varset SpamTimer ${SpamDelay}
    /call Interrupt
    /if (${UseMount} && ${Me.PctMana}<${MedPct}) /call Cast "${MountItem}" item
  }
}
/return

Sub CheckGroup
/declare i           int local
/declare WorstHPs    int local 100
/declare WorstID     int local
/declare WorstMember int local
/declare StartHPs    int local
/if (!${Me.Moving} && !${Me.Casting.ID} && !${CheckGroupTimer}) {
  /doevents ImHit
  /call DoRC
  /call DoSotW
  /if (${UseCH} && ${Spawn[pc ${MA1}].ID}) {
    :RecheckTank
    /target id ${Spawn[pc ${MA1}].ID}
    /delay 5 ${Target.ID}==${Spawn[pc ${MA1}].ID}
    /if (!${Spawn[pc group ${MA1}].ID}) /delay 3
    /call CheckPPS
    /if (${Target.ID}==${Spawn[pc ${MA1}].ID} && (${TankTTL}<250 || ${Target.PctHPs}<${TankHealPct}) && ${Target.Distance}<${Spell[${TankHealID}].Range} && ${Me.CurrentMana}>${Spell[${TankHealID}].Mana}) {
      :ShouldICH
      /if (${Me.Moving} || ${Me.Casting.ID} || (${Me.Gem[${TankHeal}]} && !${Me.SpellReady[${TankHeal}]})) /goto :ShouldICH
      /if (${ReportHeals} && !${SpamTimer} && ${Target.CleanName.NotEqual[NULL]}) /${ChatChannel} ${TankHeal} @ ${Target.CleanName} the ${Target.Class}
      /varset SpamTimer ${SpamDelay}
      /call Cast "${TankHeal}" ${TankHealGem} 1s CheckHP
      /varset SitTimer ${SitDelay}
      /goto :RecheckTank
    }
    /if (${Spawn[${MATarget}].ID}) /target id ${MATarget}
  }
  /if (${HealGroup}) {
    :RecheckGroup
    /for i 0 to ${Group}
    /if (${HealMeFirst} && ${Me.PctHPs}<${HealPct}) {
      /varset WorstHPs 0
      /varset WorstID ${Me.ID}
      /varset WorstMember ${Math.Calc[${i} + 1]}
    }
    /if (${DAArray[${Math.Calc[${i}+1]},2]} && (${Group.Member[${i}].PctHPs}>=${Math.Calc[${DAArray[${Math.Calc[${i}+1]},1]}+5]} || ${DAArray[${Math.Calc[${i}+1]},1]}>${Group.Member[${i}].PctHPs})) {
      /varset DAArray[${Math.Calc[${i}+1]},1] 0
      /varset DAArray[${Math.Calc[${i}+1]},2] 0
    }
    /if (${HealFD} && ${Target.State.NotEqual["FEIGN"]} && (${String[${Target.Class}].Equal[Monk]} || ${String[${Target.Class}].Equal[Necromancer]} || ${String[${Target.Class}].Equal["Shadow Knight"]})) /goto :NextCheckGroup
    /if ((${UseCH} || ${Group.Member[${i}].PctHPs}>${TankHealPct}) && ${Group.Member[${i}].ID}==${Spawn[pc ${MA1}].ID}) /goto :NextCheckGroup
    /if (${Group.Member[${i}].PctHPs}<=${WorstHPs} && ${Group.Member[${i}].ID} && ${Group.Member[${i}].Distance}<${Spell[${FastHealID}].Range}) {
      /varset WorstHPs ${Group.Member[${i}].PctHPs}
      /varset WorstID ${Group.Member[${i}].ID}
      /varset WorstMember ${Math.Calc[${i} + 1]}
    }
    :NextCheckGroup
    /next i
    /if (${WorstHPs}<${HealPct} && !${DAArray[${WorstMember},2]} && ${Me.CurrentMana}>${Spell[${FastHealID}].Mana}) {
      /target id ${WorstID}
      /varset StartHPs ${Target.PctHPs}
      :ShouldIPad
      /if (${Me.Moving} || ${Me.Casting.ID} || (${Me.Gem[${FastHeal}]} && !${Me.SpellReady[${FastHeal}]})) /goto :ShouldIPad
      /if (${ReportHeals} && !${SpamTimer} && ${Target.CleanName.NotEqual[NULL]}) /${ChatChannel} ${FastHeal} @ ${Target.CleanName} the ${Target.Class}
      /varset SpamTimer ${SpamDelay}
      /call Cast "${FastHeal}" ${FastHealGem} 1s CheckHP
      /if (${Group.Member[${Math.Calc[${WorstMember}-1]}].PctHPs}<${Math.Calc[${StartHPs}+5]} && ${Group.Member[${Math.Calc[${WorstMember}-1]}].PctHPs}>=${StartHPs}) {
        /varset DAArray[${WorstMember},1] ${StartHPs}
        /varset DAArray[${WorstMember},2] 1
      }
      /if (${Spawn[${MATarget}].ID}) /target id ${MATarget}
      /varset SitTimer ${SitDelay}
      /varset WorstHPs 100
      /goto :RecheckGroup
    }
  }
  /varset WorstHPs 100
  /if (${HealPets}) {
    :RecheckPets
    /for i 0 to ${Group}
    /if (${Group.Member[${i}].Pet.PctHPs}<=${WorstHPs} && ${Group.Member[${i}].Pet.ID} && ${Group.Member[${i}].Pet.Distance}<${Spell[${PetHealID}].Range}) {
      /varset WorstHPs ${Group.Member[${i}].Pet.PctHPs}
      /varset WorstID ${Group.Member[${i}].Pet.ID}
    }
    /next i
    /if (${WorstHPs}<${PetHealPct} && ${Me.CurrentMana}>${Spell[${PetHealID}].Mana}) {
      /target id ${WorstID}
      :ShouldIPadPet
      /if (${Me.Moving} || ${Me.Casting.ID} || (${Me.Gem[${PetHeal}]} && !${Me.SpellReady[${PetHeal}]})) /goto :ShouldIPadPet
      /if (${ReportHeals} && !${SpamTimer} && ${Target.CleanName.NotEqual[NULL]}) /${ChatChannel} ${PetHeal} @ ${Target.CleanName}
      /varset SpamTimer ${SpamDelay}
      /call Cast "${PetHeal}" ${PetHealGem} 1s CheckHP
      /varset SitTimer ${SitDelay}
      /varset WorstHPs 100
      /goto :RecheckPets
      /if (${Spawn[${MATarget}].ID}) /target id ${MATarget}
    }
  }
  /varset CheckGroupTimer ${CheckGroupInterval}
}
/return

Sub DoSotW
/declare i             int local
/declare GroupMember   int local
/declare GroupTotalHPs int local
/if (!${SotWCheckTimer} && ${DoSotW} && !${Me.Casting.ID} && ${Me.AltAbilityReady[${SotWAA}]}) {
  /varset GroupMember ${Math.Calc[${Group}+1]}
  /for i 0 to ${Group}
  /if (${Group.Member[${i}].ID}) {
    /varset GroupTotalHPs ${Math.Calc[${GroupTotalHPs}+${Group.Member[${i}].PctHPs}]}
  } else {
    /varset GroupTotalHPs ${Math.Calc[${GroupTotalHPs}+100]}
  }
  /next i
  /if (${Math.Calc[${GroupTotalHPs}/${GroupMember}]}<${SotWPct}) {
    /varset SotWCheckTimer 15s
    /varset GroupTotalHPs 0
    /delay 1s
    /if (!${Me.Buff[Celestial Regeneration].ID} && !${Me.Buff[Celestial Rejuvenation].ID} && !${Me.Buff[Ethereal Elixir].ID} && !${Me.Buff[Spirit of the Wood].ID} && !${Me.Buff[Spirit of the Grove].ID} && !${Me.Buff[Ancestral Aid].ID}) {
      /for i 0 to ${Group}
      /if (${Group.Member[${i}].ID}) {
        /varset GroupTotalHPs ${Math.Calc[${GroupTotalHPs}+${Group.Member[${i}].PctHPs}]}
      } else {
        /varset GroupTotalHPs ${Math.Calc[${GroupTotalHPs}+100]}
      }
      /next i
      /if (${Math.Calc[${GroupTotalHPs}/${GroupMember}]}<${SotWPct}) {
        /target id ${Me.ID}
        /delay 1s ${Target.ID}==${Me.ID}
        /if (${ReportSotW} && !${SpamTimer}) /${ChatChannel} ${SotWAA} inc
        /varset SpamTimer ${SpamDelay}
        /call Cast "${SotWAA}" alt 10s
        /if (${Spawn[${MATarget}].ID}) /target id ${MATarget}
      }
    }
  }
}
/varset GroupTotalHPs 0
/return

Sub Check4Pad
/declare i           int local
/declare WorstHPs    int local 100
/declare WorstID     int local
/declare WorstMember int local
/declare StartHPs    int local
/if (!${CheckGroupTimer}) {
  /if (${UseCH} && ${Spawn[pc ${MA1}].ID} && ${Me.Casting.ID}) {
    /target id ${Spawn[pc ${MA1}].ID}
    /delay 5 ${Target.ID}==${Spawn[pc ${MA1}].ID}
    /if (!${Spawn[pc group ${MA1}].ID}) /delay 3
    /call CheckPPS
    /if (${Target.ID}==${Spawn[pc ${MA1}].ID} && (${TankTTL}<150 || ${Target.PctHPs}<${TankHealPct}) && ${Target.Distance}<${Spell[${TankHealID}].Range} && ${Me.CurrentMana}>${Spell[${TankHealID}].Mana}) {
      /if (${Me.Casting.ID}) {
        /if (!${Me.Mount.ID}) {
          /if (${ReportInterrupts} && !${SpamTimer}) /${ChatChannel} Interrupting ${Me.Casting}
          /varset SpamTimer ${SpamDelay}
          /call Interrupt
          /if (${ReportHeals} && ${Target.CleanName.NotEqual[NULL]}) /${ChatChannel} ${TankHeal} @ ${Target.CleanName} the ${Target.Class}
          /varset SpamTimer ${SpamDelay}
          /call Cast "${TankHeal}" ${TankHealGem} 1s CheckHP
          /varset SitTimer ${SitDelay}
          /varset castReturn CAST_INTERRUPTED
        } else {
          /if (${ReportInterrupts} && !${SpamTimer}) /${ChatChannel} Interrupting ${Me.Casting}
          /varset SpamTimer ${SpamDelay}
          /call Interrupt
          /if (${ReportHeals} && ${Target.CleanName.NotEqual[NULL]}) /${ChatChannel} ${TankHeal} @ ${Target.CleanName} the ${Target.Class}
          /varset SpamTimer ${SpamDelay}
          /call Cast "${TankHeal}" ${TankHealGem} 1s CheckHP
          /varset SitTimer ${SitDelay}
          /varset castReturn CAST_INTERRUPTED
          /if (${UseMount} && ${Me.PctMana}<${MedPct}) /call Cast "${MountItem}" item
        }
      }
    }
    /if (${Spawn[${MATarget}].ID}) /target id ${MATarget}
  }
  /if (${Stop4Pad}) {
    /for i 0 to ${Group}
    /if (${HealMeFirst} && ${Me.PctHPs}<${HealPct}) {
      /varset WorstHPs 0
      /varset WorstID ${Me.ID}
      /varset WorstMember ${Math.Calc[${i} + 1]}
    }
    /if (${DAArray[${Math.Calc[${i}+1]},2]} && (${Group.Member[${i}].PctHPs}>=${Math.Calc[${DAArray[${Math.Calc[${i}+1]},1]}+5]} || ${DAArray[${Math.Calc[${i}+1]},1]}>${Group.Member[${i}].PctHPs})) {
      /varset DAArray[${Math.Calc[${i}+1]},1] 0
      /varset DAArray[${Math.Calc[${i}+1]},2] 0
    }
    /if (${HealFD} && ${Target.State.NotEqual["FEIGN"]} && (${String[${Target.Class}].Equal[Monk]} || ${String[${Target.Class}].Equal[Necromancer]} || ${String[${Target.Class}].Equal["Shadow Knight"]})) /goto :NextCheck4Pad
    /if ((${UseCH} || ${Group.Member[${i}].PctHPs}>${TankHealPct}) && ${Group.Member[${i}].ID}==${Spawn[pc ${MA1}].ID}) /goto :NextCheck4Pad
    /if (${Group.Member[${i}].PctHPs}<=${WorstHPs} && ${Group.Member[${i}].ID} && ${Group.Member[${i}].Distance}<${Spell[${FastHealID}].Range}) {
      /varset WorstHPs ${Group.Member[${i}].PctHPs}
      /varset WorstID ${Group.Member[${i}].ID}
      /varset WorstMember ${Math.Calc[${i} + 1]}
    }
    :NextCheck4Pad
    /next i
    /if (${WorstHPs}<${HealPct} && !${DAArray[${WorstMember},2]} && ${Me.CurrentMana}>${Spell[${FastHealID}].Mana}) {
      /if (${Me.Casting.ID}) {
        /if (!${Me.Mount.ID}) {
          /if (${ReportInterrupts} && !${SpamTimer}) /${ChatChannel} Interrupting ${Me.Casting}
          /varset SpamTimer ${SpamDelay}
          /call Interrupt
          /call DoSotW
          /target id ${WorstID}
          /varset StartHPs ${Target.PctHPs}
          /if (${ReportHeals} && ${Target.CleanName.NotEqual[NULL]}) /${ChatChannel} ${FastHeal} @ ${Target.CleanName} the ${Target.Class}
          /varset SpamTimer ${SpamDelay}
          /call Cast "${FastHeal}" ${FastHealGem} 1s CheckHP
          /if (${Group.Member[${Math.Calc[${WorstMember}-1]}].PctHPs}<${Math.Calc[${StartHPs}+5]} && ${Group.Member[${Math.Calc[${WorstMember}-1]}].PctHPs}>=${StartHPs}) {
            /varset DAArray[${WorstMember},1] ${StartHPs}
            /varset DAArray[${WorstMember},2] 1
          }
          /if (${Spawn[${MATarget}].ID}) /target id ${MATarget}
          /varset castReturn CAST_INTERRUPTED
        } else {
          /if (${ReportInterrupts} && !${SpamTimer}) /${ChatChannel} Interrupting ${Me.Casting}
          /varset SpamTimer ${SpamDelay}
          /call Interrupt
          /call DoSotW
          /target id ${WorstID}
          /if (${ReportHeals} && ${Target.CleanName.NotEqual[NULL]}) /${ChatChannel} ${FastHeal} @ ${Target.CleanName} the ${Target.Class}
          /varset SpamTimer ${SpamDelay}
          /call Cast "${FastHeal}" ${FastHealGem} 1s CheckHP
          /if (${Group.Member[${Math.Calc[${WorstMember}-1]}].PctHPs}<${Math.Calc[${StartHPs}+5]} && ${Group.Member[${Math.Calc[${WorstMember}-1]}].PctHPs}>=${StartHPs}) {
            /varset DAArray[${WorstMember},1] ${StartHPs}
            /varset DAArray[${WorstMember},2] 1
          }
          /if (${Spawn[${MATarget}].ID}) /target id ${MATarget}
          /varset castReturn CAST_INTERRUPTED
          /if (${UseMount} && ${Me.PctMana}<${MedPct}) /call Cast "${MountItem}" item
        }
        /varset SitTimer ${SitDelay}
      }
    }
  }
  /varset CheckGroupTimer ${CheckGroupInterval}
}
/return

Sub CheckPPS
/if (${TankLastPct}>${Target.PctHPs} && ${Target.PctHPs}!=100) {
  /varcalc TotalTankHits ${TotalTankHits} + ${Math.Calc[${TankLastPct}-${Target.PctHPs}]}
}
/varset TankPPS ${Math.Calc[${TotalTankHits}/((1001-${TankPPSTimer})/10)]}
/if (${TankPPSTimer}<=900) {
  /varcalc TotalTankHits ${TankPPS}
  /varcalc TankPPSTimer 1000
}
/if (!${TankPPS}) {
  /varset TankTTL 3000
} else {
  /varset TankTTL ${Math.Calc[(${Target.PctHPs}/${TankPPS})*10].Int}
}
/varset TankLastPct ${Target.PctHPs}
/return

Sub assistMA1
/declare i int local
/if (${AssistMA} && !${Me.Casting.ID} && !${Me.Moving}) {
  /for i 1 to 3
  /call CheckGroup
  /if (!${Spawn[pc ${MA${i}}].ID}) /goto :NextMA
  /assist ${Spawn[${MA${i}}].CleanName}
  /delay 5 ${Target.Type.Equal[NPC]}
  /if (${Target.Type.Equal[NPC]}) {
    /varset MATarget ${Target.ID}
    /goto :Stuff
  }
  :NextMA
  /next i
}
:Stuff
/if (${MATarget}!=${DebuffTarget}) {
  /call ResetTimers
  /varset DebuffTarget ${MATarget}
}
/if (${Target.PctHPs}>=${StopHPs} && ${Target.PctHPs}<=${EngageHPs} && ${Target.ID}==${MATarget}) {
  /call ClickEpic
  /call DebuffIt
  /call DoTIt
  /call Nukeit
  /call SnareIt
}
/return

Sub ClickEpic
/call CheckGroup
/if (${Spawn[${MATarget}].ID}) /target id ${MATarget}
/delay 5 ${Target.ID}==${MATarget}
/if (!${WaitTimer} && ${UseEpic} && !${EpicTimer} && ${Target.ID}==${MATarget} && ${Target.ID}==${NearestSpawn[npc named].ID} && ${Target.LineOfSight} && ${Target.Distance}<${Spell[Nature's Blight].Range} && ${Target.PctHPs}>=${StopHPs} && ${Target.PctHPs}<=${EngageHPs}) {
  /if (${ReportEpic} && !${SpamTimer} && ${Target.CleanName.NotEqual[NULL]}) /${ChatChannel} Clicking Epic on ${Target.CleanName}
  /varset SpamTimer ${SpamDelay}
  /call Cast "Staff of Living Brambles" item 2s Check4Pad
  /varset EpicTimer 605s
  /varset SitTimer ${SitDelay}
}
/return

Sub DebuffIt
/declare ResistCounter int local
/declare i             int local
/if (${DebuffTotal}) {
  /for i 1 to ${DebuffTotal}
  /if ((${Me.PctMana}>${NukePctMana} || ${DebuffGem[${i}].Equal[item]}) && !${WaitTimer} && ${DoDebuffs} && !${Me.Moving} && !${Me.Casting.ID} && ${Target.PctHPs}>=${StopHPs} && ${Target.PctHPs}<=${DebuffHPs}) {
    /if ((${WhichNuke}==${DebuffSpellSet[${i}]} || !${DebuffSpellSet[${i}]}) && !${DebuffTimer${i}}) {
      /varset ResistCounter 0
      :RecastDebuff
      /call CheckGroup
      /if (${Spawn[${MATarget}].ID}) /target id ${MATarget}
      /delay 5 ${Target.ID}==${MATarget}
      /if (${Target.PctHPs}<${SnareHPs} && !${SnareTimer} && ${DoSnare}) /call SnareIt
      /if (${SitTimer} && !${Me.Gem[${Debuff[${i}]}]} && !${Me.Mount.ID} && ${DebuffGem[${i}].NotEqual[item]}) /goto :RecastDebuff
      /if (${Target.Type.Equal[NPC]} && ${Target.ID}==${MATarget} && ${Target.LineOfSight} && ${Target.Distance}<${Spell[${DebuffID[${i}]}].Range}) {
        /call Cast "${Debuff[${i}]}" ${DebuffGem[${i}]} 10s Check4Pad
        /varset SitTimer ${SitDelay}
      } else {
        /return
      }
      /if (${castReturn.Equal[CAST_RESISTED]}) {
        /varset ResistCounter ${Math.Calc[${ResistCounter}+1]}
        /if (${ResistCounter}>=${DebuffRecasts}) {
          /if (${ReportDebuffs} && !${SpamTimer} && ${Target.CleanName.NotEqual[NULL]}) /${ChatChannel} ${Spawn[${MATarget}].CleanName} resisted ${Debuff[${i}]} ${DebuffRecasts} times, giving up
          /varset SpamTimer ${SpamDelay}
          /varset DebuffTimer${i} 10000s
          /goto :NextDebuff
        } else {
          /goto :RecastDebuff
        }
      } else /if (${castReturn.Equal[CAST_INTERRUPTED]}) {
        /goto :RecastDebuff
      } else /if (${castReturn.Equal[CAST_CANCELLED]}) {
        /goto :RecastDebuff
      } else /if (${castReturn.Equal[CAST_SUCCESS]}) {
        /if (${ReportDebuffs} && !${SpamTimer} && ${Target.CleanName.NotEqual[NULL]}) /${ChatChannel} ${Spawn[${MATarget}].CleanName} debuffed with ${Debuff[${i}]}
        /varset SpamTimer ${SpamDelay}
        /varset DebuffTimer${i} ${Math.Calc[${Spell[${DebuffID[${i}]}].Duration.TotalSeconds}-6]}s
      } else /if (${castReturn.Equal[CAST_IMMUNE]}) {
        /varset DebuffTimer${i} 1000s
        /goto :NextDebuff
      } else /if (${SpellNotHold}) {
        /varset DebuffTimer${i} 1000s
        /goto :NextDebuff
      }
    }
  }
  :NextDebuff
  /next i
}
/return

Sub DoTIt
/declare ResistCounter int local
/declare i             int local
/if (${DoTTotal}) {
  /for i 1 to ${DoTTotal}
  /if ((${Me.PctMana}>${NukePctMana} || ${DebuffGem[${i}].Equal[item]}) && !${WaitTimer} && ${DoDoTs} && !${Me.Moving} && !${Me.Casting.ID} &&  ${Target.PctHPs}>${DoTMinHPs} && ${Target.PctHPs}<=${DoTHPs}) {
    /if ((${WhichNuke}==${DoTSpellSet[${i}]} || !${DoTSpellSet[${i}]}) && !${DoTTimer${i}}) {
      /varset ResistCounter 0
      :RecastDoT
      /call CheckGroup
      /if (${Spawn[${MATarget}].ID}) /target id ${MATarget}
      /delay 5 ${Target.ID}==${MATarget}
      /if (${Target.PctHPs}<${SnareHPs} && !${SnareTimer} && ${DoSnare}) /call SnareIt
      /if (${SitTimer} && !${Me.Gem[${DoT[${i}]}]} && !${Me.Mount.ID} && ${DoTGem[${i}].NotEqual[item]}) /goto :RecastDoT
      /if (${Target.Type.Equal[NPC]} && ${Target.ID}==${MATarget} && ${Target.LineOfSight} && ${Target.Distance}<${Spell[${DoTID[${i}]}].Range}) {
        /call Cast "${DoT[${i}]}" ${DoTGem[${i}]} 10s Check4Pad
        /varset SitTimer ${SitDelay}
      } else {
        /return
      }
      /if (${castReturn.Equal[CAST_RESISTED]}) {
        /varset ResistCounter ${Math.Calc[${ResistCounter}+1]}
        /if (${ResistCounter}>=${DoTRecasts}) {
          /if (${ReportDoTs} && !${SpamTimer} && ${Target.CleanName.NotEqual[NULL]}) /${ChatChannel} ${Spawn[${MATarget}].CleanName} resisted ${DoT[${i}]} ${DoTRecasts} times, giving up
          /varset SpamTimer ${SpamDelay}
          /varset DoTTimer${i} 10000s
          /goto :NextDoT
        } else {
          /goto :RecastDoT
        }
      } else /if (${castReturn.Equal[CAST_INTERRUPTED]}) {
        /goto :RecastDoT
      } else /if (${castReturn.Equal[CAST_CANCELLED]}) {
        /goto :RecastDoT
      } else /if (${castReturn.Equal[CAST_SUCCESS]}) {
        /if (${ReportDoTs} && !${SpamTimer} && ${Target.CleanName.NotEqual[NULL]}) /${ChatChannel} ${Spawn[${MATarget}].CleanName} DoTed with ${DoT[${i}]}
        /varset SpamTimer ${SpamDelay}
        /varset DoTTimer${i} ${Math.Calc[${Spell[${DoTID[${i}]}].Duration.TotalSeconds}-6]}s
      } else /if (${castReturn.Equal[CAST_IMMUNE]}) {
        /varset DoTTimer${i} 1000s
        /goto :NextDoT
      } else /if (${SpellNotHold}) {
        /varset DoTTimer${i} 1000s
        /goto :NextDoT
      }
    }
  }
  :NextDoT
  /next i
}
/return

Sub Nukeit
/call CheckGroup
/if (${Spawn[${MATarget}].ID}) /target id ${MATarget}
/delay 5 ${Target.ID}==${MATarget}
/if (${Target.PctHPs}<${SnareHPs} && !${SnareTimer} && ${DoSnare}) /call SnareIt
/if (${Me.PctMana}>${NukePctMana} && !${NukeTimer} && !${WaitTimer} && ${DoNukes} && !${Me.Moving} && !${Me.Casting.ID} && ${Target.PctHPs}>${StopHPs} && ${Target.PctHPs}<${NukeHPs} && (!${SitTimer} || ${Me.Gem[${MyNukes[${WhichNuke}]}]} || ${Me.Mount.ID})) {
  /if (${Target.Type.Equal[NPC]} && ${Target.ID}==${MATarget} && ${Target.LineOfSight} && ${Target.Distance}<${Spell[${MyNukes[${WhichNuke}]}].Range}) {
    /call Cast "${MyNukes[${WhichNuke}]}" ${NukeGem} 5s Check4Pad
    /varset SitTimer ${SitDelay}
    /varset NukeTimer ${NukeDelay}
  }
}
/return

Sub SnareIt
/declare ResistCounter int local
/if (!${WaitTimer} && ${DoSnare} && !${Me.Moving} && !${Me.Casting.ID} && ${Target.PctHPs}<=${SnareHPs}) {
  /if (!${SnareTimer}) {
    /varset ResistCounter 0
    :RecastSnare
    /call CheckGroup
    /if (${Spawn[${MATarget}].ID}) /target id ${MATarget}
    /delay 5 ${Target.ID}==${MATarget}
    /if (${SitTimer} && !${Me.Gem[${SnareSpell}]} && !${Me.Mount.ID}) /goto :RecastSnare
    /if (${Target.Type.Equal[NPC]} && ${Target.ID}==${MATarget} && ${Target.LineOfSight} && ${Target.Distance}<${Spell[${SnareSpellID}].Range}) {
      /call Cast "${SnareSpell}" ${SnareGem} 5s Check4Pad
      /varset SitTimer ${SitDelay}
    } else {
      /return
    }
    /if (${castReturn.Equal[CAST_IMMUNE]}) {
      /if (${ReportSnares} && !${SpamTimer} && ${Target.CleanName.NotEqual[NULL]}) /${ChatChannel} ${Spawn[${MATarget}].CleanName} is IMMUNE to ${SnareSpell}
      /varset SpamTimer ${SpamDelay}
      /varset SnareTimer 10000s
      /return
    } else /if (${SpellNotHold}) {
      /varset SnareTimer 10000s
      /return
    } else /if (${castReturn.Equal[CAST_RESISTED]}) {
      /varset ResistCounter ${Math.Calc[${ResistCounter}+1]}
      /if (${ResistCounter}>=${SnareRecasts}) {
        /if (${ReportSnares} && !${SpamTimer} && ${Target.CleanName.NotEqual[NULL]}) /${ChatChannel} ${Spawn[${MATarget}].CleanName} resisted ${SnareSpell} ${SnareRecasts} times, giving up
        /varset SpamTimer ${SpamDelay}
        /varset SnareTimer 10000s
        /return
      } else {
        /goto :RecastSnare
      }
    } else /if (${castReturn.Equal[CAST_INTERRUPTED]}) {
      /goto :RecastSnare
    } else /if (${castReturn.Equal[CAST_CANCELLED]}) {
      /goto :RecastSnare
    } else /if (${castReturn.Equal[CAST_SUCCESS]}) {
      /if (${ReportSnares} && !${SpamTimer} && ${Target.CleanName.NotEqual[NULL]}) /${ChatChannel} ${Spawn[${MATarget}].CleanName} Snared
      /varset SpamTimer ${SpamDelay}
      /varset SnareTimer ${Math.Calc[${Spell[${SnareSpellID}].Duration.TotalSeconds}-6]}s
    }
  }
}
/return

Sub ResetTimers
/declare i int local
/for i 1 to 5
/varset DebuffTimer${i} 0
/varset DoTTimer${i} 0
/next i
/varset SitTimer 0
/varset SnareTimer 0
/varset WaitTimer 0
/return

Sub TargetGuy
/squelch /target clear
/target id ${BuffGuy}
/delay 1s ${Target.ID}==${BuffGuy}
/if (!${Target.ID}==${BuffGuy}) {
  /varset TargetReturn TARGET_FAILED
  /return
}
/varset TargetReturn TARGET_SUCCESS
/return

Sub CheckBuffs
/declare i        int local
/declare a        int local
/if (${SelfBuffTotal} && ${SelfBuffs} && !${SelfBuffTimer} && !${Me.Moving} && !${Me.Casting.ID} && (!${SitTimer} || ${Me.Gem[${SelfBuff[${i}]}]} || ${Me.Mount.ID})) {
  /for i 1 to ${SelfBuffTotal}
  /call CheckGroup
  /if (${Me.Buff[${SelfBuffIcon[${i}]}].Duration}<10 && ${Me.CountBuffs}<=${SelfBuffCount[${i}]}) {
    /for a 1 to 20
    /if (${SelfBuffBlock[${i}].Find[${Me.Buff[${a}].Spell}]}) /goto :NextSelfBuff
    /next a
    /if (!${Outdoors} && !${SelfBuffIndoors[${i}]}) /goto :NextSelfBuff
    /squelch /target myself
    /if (${ReportSelfBuffs} && !${SpamTimer}) /${ChatChannel} Buffing myself with ${SelfBuff[${i}]}
    /varset SpamTimer ${SpamDelay}
    /if (${SelfBuffGem[${i}].Equal[item]}) {
      /call Cast "${SelfBuff[${i}]}" item 1s Check4Pad
    } else /if (${SelfBuffGem[${i}].Equal[alt]} && ${Me.AltAbilityReady[${SelfBuff[${i}]}]}) {
      /call Cast "${SelfBuff[${i}]}" alt 1s Check4Pad
    } else /if (${Me.CurrentMana}>${Spell[${SelfBuffID[${i}]}].Mana}) {
      /call Cast "${SelfBuff[${i}]}" ${SelfBuffGem[${i}]} 1s Check4Pad
    }
    /if (${Spawn[${MATarget}].ID}) /target id ${MATarget}
  }
  :NextSelfBuff
  /next i
  /varset SelfBuffTimer ${SelfBuffRecheck}
}
/return

Sub AutoSit
/if (!${SpamTimer} && ${Me.PctMana}==100) {
  /if (${ReportFM}) /${ChatChannel} ${Me.PctMana}m, GTG
  /varset SpamTimer ${SpamDelay}
  /varset ReportFM 0
}
/if (!${Me.Casting.ID} && !${Me.Moving} && ${Me.PctMana}<${MedPct} && !${Me.Mount.ID}) {
  /if (${AutoSit} && !${SitTimer} && ${Me.Standing} && !${Spawn[npc radius 20 zradius 100].ID}) {
    /sit
    /varset SitTimer ${SitDelay}
  }
  /if (${UseMount} && !${NoMount}) {
    /call Cast "${MountItem}" item 5s Check4Pad
  }
}
/return

Sub ToggleVar(string Line)
/if (!${Line.Arg[3].Length}) {
  /if (${RDTempVar}) {
    /varset RDTempVar 0
  } else {
    /varset RDTempVar 1
  }
}
/if (${Line.Arg[3].Equal[ON]} || ${Line.Arg[3].Equal[TRUE]} || ${Line.Arg[3].Equal[1]}) {
  /varset RDTempVar 1
}
/if (${Line.Arg[3].Equal[OFF]} || ${Line.Arg[3].Equal[FALSE]} || ${Line.Arg[3].Equal[0]}) {
  /varset RDTempVar 0
}
/return

Sub Event_Chat(string ChatType,string Sender,string ChatText)
/declare a        int local
/declare i        int local
/if (!${DoBuffTotal} || !${DoBuffs}) /return
/for i 1 to ${DoBuffTotal}
/for a 1 to ${DoBuffAliases[${i}].Count[|]}
/if (${ChatText.Find[${DoBuffAliases[${i}].Arg[${a},|]}]}) {
  /echo Found a buff, doing stuff.  Sender is ${Sender}
  :WaitToBuff
  /call CheckGroup
  /if ((!${Outdoors} && !${DoBuffIndoors[${i}]}) || (${Spawn[pc ${Sender}].Distance}>${Spell[${DoBuffID[${i}]}].Range}) && (${Spawn[pc ${Sender}].Distance}>${Spell[${DoBuffID[${i}]}].AERange})) /goto :NextDoBuff
  /echo Not skipping this buff
  /if (${Me.Moving} || ${Me.Casting.ID} || (${Me.Gem[${DoBuff[${i}]}]} && !${Me.SpellReady[${DoBuff[${i}]}]}) || (${SitTimer} && !${Me.Gem[${DoBuff[${i}]}]} && !${Me.Mount.ID})) /goto :WaitToBuff
  /echo Not waiting to buff
  /varset BuffGuy ${Spawn[pc ${Sender}].ID}
  /echo Buffguy is ${Sender}
  /call TargetGuy
  /echo Targetted
  /if (${TargetReturn.Equal[TARGET_SUCCESS]}) {
    /if (${DoBuffTells} && !${SpamTimer}) /tt ${DoBuff[${i}]} inc
    /if (${ReportDoBuffs} && !${SpamTimer} && ${Target.CleanName.NotEqual[NULL]}) /${ChatChannel} Buffing ${Target.CleanName} with ${DoBuff[${i}]}
    /varset SpamTimer ${SpamDelay}
    /if (${DoBuffGem[${i}].Equal[item]}) {
      /call Cast "${DoBuff[${i}]}" item 1s Check4Pad
    }
    /if (${DoBuffGem[${i}].Equal[alt]} && ${Me.AltAbilityReady[${DoBuff[${i}]}]}) {
      /call Cast "${DoBuff[${i}]}" alt 1s Check4Pad
    }
    /if (${Me.CurrentMana}>${Spell[${DoBuffID[${i}]}].Mana}) {
      /call Cast "${DoBuff[${i}]}" ${DoBuffGem[${i}]} 1s Check4Pad
    }
    /varset SitTimer ${SitDelay}
  }
  /if (${Spawn[${MATarget}].ID}) /target id ${MATarget}
}
/next a
:NextDoBuff
/next i
/if (${MasterList.Find[${Sender}]}) {
  /if (${ChatText.Find[follow]}) {
    /if (${Line.Arg[3].Length} && ${Spawn[pc ${Line.Arg[3]}].ID}) {
      /target id ${Spawn[pc ${Line.Arg[3]}].ID}
      /delay 1s ${Target.ID}==${Spawn[pc ${Line.Arg[3]}].ID}
      /stick 10 hold
      /varset FollowOn 1
      /varset FollowGuy ${Spawn[pc ${Line.Arg[3]}].ID}
    } else {
      /target id ${Spawn[pc ${Sender}].ID}
      /delay 1s ${Target.ID}==${Spawn[pc ${Sender}].ID}
      /stick 10 hold
      /varset FollowOn 1
      /varset FollowGuy ${Spawn[pc ${Sender}].ID}
    }
  }
  /if (${ChatText.Find[stop]}) {
    /stick off
  }
}
/return
Last edited by A_Druid_00 on Tue Jun 28, 2005 10:56 pm, edited 87 times in total.
[quote]<DigitalMocking> man, A_Druid_00 really does love those long ass if statements
<dont_know_at_all> i don't use his macro because i'm frightened of it[/quote]
[quote][12:45] <dont_know_at_all> never use a macro when you can really fuck up things with a plugin[/quote]

A_Druid_00
Macro Maker Extraordinaire
Posts: 2378
Joined: Tue Jul 13, 2004 12:45 pm
Location: Rolling on the Lawn Farting

RDLoadIni.inc:

Post by A_Druid_00 » Mon Nov 08, 2004 9:42 pm

Code: Select all

|RDLoadIni.inc v7.23
Sub LoadIni
/declare i int local
/declare IniString string local
/varset MyIni RD_${Me.CleanName}.ini
/varset IniString ${Ini[${MyIni},Settings,NPCRadius,NOTFOUND]}
/varset NPCRadius ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" Settings NPCRadius 200
  /varset NPCRadius 200
}
/varset IniString ${Ini[${MyIni},Settings,NPCZRadius,NOTFOUND]}
/varset NPCZRadius ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" Settings NPCZRadius 30
  /varset NPCZRadius 30
}
/varset IniString ${Ini[${MyIni},Settings,PCRadius,NOTFOUND]}
/varset PCRadius ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" Settings PCRadius 200
  /varset PCRadius 200
}
/varset IniString ${Ini[${MyIni},Settings,PCZRadius,NOTFOUND]}
/varset PCZRadius ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" Settings PCZRadius 30
  /varset PCZRadius 30
}
/varset IniString ${Ini[${MyIni},Settings,AutoNinja,NOTFOUND]}
/varset AutoNinja ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" Settings AutoNinja 0
  /varset AutoNinja 0
}
/varset IniString ${Ini[${MyIni},Settings,AutoSit,NOTFOUND]}
/varset AutoSit ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" Settings AutoSit 0
  /varset AutoSit 0
}
/varset IniString ${Ini[${MyIni},Settings,SitDelay,NOTFOUND]}
/varset SitDelay ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" Settings SitDelay 5s
  /varset SitDelay  5s
}
/varset IniString ${Ini[${MyIni},Settings,UseMount,NOTFOUND]}
/varset UseMount ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" Settings UseMount 0
  /varset UseMount 0
}
/varset MountItem ${Ini[${MyIni},Settings,MountItem,NOTFOUND]}
/if (${MountItem.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" Settings MountItem "Black Rope Bridle"
  /varset MountItem "Black Rope Bridle"
}
/varset IniString ${Ini[${MyIni},Settings,ClickRods,NOTFOUND]}
/varset ClickRods ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" Settings ClickRods 0
  /varset ClickRods 0
}
/varset IniString ${Ini[${MyIni},Settings,MedPct,NOTFOUND]}
/varset MedPct ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" Settings MedPct 50
  /varset MedPct 50
}
/varset IniString ${Ini[${MyIni},Settings,OVHPs,NOTFOUND]}
/varset OVHPs ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" Settings OVHPs 50
  /varset OVHPs 50
}
/varset IniString ${Ini[${MyIni},Settings,RodMana,NOTFOUND]}
/varset RodMana ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" Settings RodMana 80
  /varset RodMana 80
}
/varset IniString ${Ini[${MyIni},Settings,DoWolf,NOTFOUND]}
/varset DoWolf ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" Settings DoWolf 0
  /varset DoWolf 0
}
/varset ChatChannel ${Ini[${MyIni},GeneralStuff,ChatChannel,NOTFOUND]}
/if (${ChatChannel.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" GeneralStuff ChatChannel "echo"
  /varset ChatChannel "echo"
}
/varset IniString ${Ini[${MyIni},GeneralStuff,ReportMana,NOTFOUND]}
/varset ReportMana ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" GeneralStuff ReportMana 0
  /varset ReportMana 0
}
/varset ColdSpells ${Ini[${MyIni},GeneralStuff,ColdSpellSet,NOTFOUND]}
/if (${ColdSpells.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" GeneralStuff ColdSpellSet Cold
  /varset ColdSpells Cold
}
/varset FireSpells ${Ini[${MyIni},GeneralStuff,FireSpellSet,NOTFOUND]}
/if (${FireSpells.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" GeneralStuff FireSpellSet Fire
  /varset FireSpells Fire
}
/varset IniString ${Ini[${MyIni},GeneralStuff,AssistMA,NOTFOUND]}
/varset AssistMA ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" GeneralStuff AssistMA 0
  /varset AssistHeal 0
}
/varset MasterList ${Ini[${MyIni},GeneralStuff,MasterList,NOTFOUND]}
/if (${MasterList.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" GeneralStuff MasterList "Put your list of master bots here"
}
/varset MA1 ${Ini[${MyIni},GeneralStuff,MA1,NOTFOUND]}
/if (${MA1.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" GeneralStuff MA1 "Main Assist 1"
  /varset MA1 "Main Assist 1"
}
/varset MA2 ${Ini[${MyIni},GeneralStuff,MA2,NOTFOUND]}
/if (${MA2.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" GeneralStuff MA2 "Main Assist 2"
  /varset MA2 "Main Assist 2"
}
/varset MA3 ${Ini[${MyIni},GeneralStuff,MA3,NOTFOUND]}
/if (${MA3.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" GeneralStuff MA3 "Main Assist 3"
  /varset MA3 "Main Assist 3"
}
/varset IniString ${Ini[${MyIni},GeneralStuff,DoWoW,NOTFOUND]}
/varset DoWoW ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" GeneralStuff DoWoW 0
  /varset DoWoW 0
}
/varset IniString ${Ini[${MyIni},GeneralStuff,ReportWoW,NOTFOUND]}
/varset ReportWoW ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" GeneralStuff ReportWoW 0
  /varset ReportWoW 0
}
/varset IniString ${Ini[${MyIni},GeneralStuff,EngageHPs,NOTFOUND]}
/varset EngageHPs ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" GeneralStuff EngageHPs 95
  /varset EngageHPs 95
}
/varset IniString ${Ini[${MyIni},GeneralStuff,StopHPs,NOTFOUND]}
/varset StopHPs ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" GeneralStuff StopHPs 10
  /varset StopHPs 10
}
/varset IniString ${Ini[${MyIni},GeneralStuff,StopNukingMana,NOTFOUND]}
/varset NukePctMana ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" GeneralStuff StopNukingMana 50
  /varset NukePctMana 50
}
/varset IniString ${Ini[${MyIni},GeneralStuff,UseEpic,NOTFOUND]}
/varset UseEpic ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" GeneralStuff UseEpic 0
  /varset UseEpic 0
}
/varset IniString ${Ini[${MyIni},GeneralStuff,ReportEpic,NOTFOUND]}
/varset ReportEpic ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" GeneralStuff ReportEpic 0
  /varset ReportEpic 0
}
/varset IniString ${Ini[${MyIni},GeneralStuff,SpamDelay,NOTFOUND]}
/varset SpamDelay ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" GeneralStuff SpamDelay 3s
  /varset SpamDelay 3s
}
/varset IniString ${Ini[${MyIni},HealStuff,ReportHeals,NOTFOUND]}
/varset ReportHeals ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff ReportHeals 0
  /varset ReportHeals 0
}
/varset IniString ${Ini[${MyIni},HealStuff,ReportInterrupts,NOTFOUND]}
/varset ReportInterrupts ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff ReportInterrupts 0
  /varset ReportInterrupts 0
}
/varset IniString ${Ini[${MyIni},HealStuff,HealMeFirst,NOTFOUND]}
/varset HealMeFirst ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff HealMeFirst 0
  /varset HealMeFirst 0
}
/varset IniString ${Ini[${MyIni},HealStuff,GroupHealing,NOTFOUND]}
/varset HealGroup ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff GroupHealing 0
  /varset HealGroup 0
}
/varset IniString ${Ini[${MyIni},HealStuff,CheckGroupInterval,NOTFOUND]}
/varset CheckGroupInterval ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff CheckGroupInterval 3s
  /varset CheckGroupInterval 3s
}
/varset IniString ${Ini[${MyIni},HealStuff,AutoInterrupt,NOTFOUND]}
/varset Stop4Pad ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff AutoInterrupt 0
  /varset Stop4Pad 0
}
/varset IniString ${Ini[${MyIni},HealStuff,RampHealing,NOTFOUND]}
/varset DoRamp ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff RampHealing 0
  /varset DoRamp 0
}
/varset RampTank ${Ini[${MyIni},HealStuff,RampTank,NOTFOUND]}
/if (${RampTank.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff RampTank "Rampage Tank"
  /varset RampTank "Rampage Tank"
}
/varset IniString ${Ini[${MyIni},HealStuff,AEHealing,NOTFOUND]}
/varset AEHeal ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff AEHealing 0
  /varset AEHeal 0
}
/varset IniString ${Ini[${MyIni},HealStuff,AssistHealing,NOTFOUND]}
/varset AssistHeal ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff AssistHealing 0
  /varset AssistHeal 0
}
/varset IniString ${Ini[${MyIni},HealStuff,HealPct,NOTFOUND]}
/varset HealPct ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff HealPct 70
  /varset HealPct 70
}
/varset IniString ${Ini[${MyIni},HealStuff,HealFD,NOTFOUND]}
/varset HealFD ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff HealFD 0
  /varset HealFD 0
}
/varset IniString ${Ini[${MyIni},HealStuff,CancelPct,NOTFOUND]}
/varset CancelPct ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff CancelPct 90
  /varset CancelPct 90
}
/varset IniString ${Ini[${MyIni},HealStuff,WaitToCancel,NOTFOUND]}
/varset WaitToCancel ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff WaitToCancel 0
  /varset WaitToCancel 0
}
/varset FastHeal ${Ini[${MyIni},HealStuff,FastHeal,NOTFOUND]}
/if (${FastHeal.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff FastHeal "Chlorotrope"
  /varset FastHeal "Chlorotrope"
}
/varset FastHealID ${Me.Book[${Me.Book[${FastHeal}]}].ID}
/varset FastHealGem ${Ini[${MyIni},HealStuff,FastHealGem,NOTFOUND]}
/if (${FastHealGem.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff FastHealGem gem2
  /varset FastHealGem gem2
}
/varset IniString ${Ini[${MyIni},HealStuff,UseCH,NOTFOUND]}
/varset UseCH ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff UseCH 0
  /varset UseCH 0
}
/varset IniString ${Ini[${MyIni},HealStuff,TankHealPct,NOTFOUND]}
/varset TankHealPct ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff TankHealPct 70
  /varset TankHealPct 70
}
/varset TankHeal ${Ini[${MyIni},HealStuff,TankHeal,NOTFOUND]}
/if (${TankHeal.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff TankHeal "Karana's Renewal"
  /varset TankHeal "Karana's Renewal"
}
/varset TankHealID ${Me.Book[${Me.Book[${TankHeal}]}].ID}
/varset TankHealGem ${Ini[${MyIni},HealStuff,TankHealGem,NOTFOUND]}
/if (${TankHealGem.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff TankHealGem gem1
  /varset TankHealGem gem1
}
/varset SotWAA ${Ini[${MyIni},HealStuff,SotWAA,NOTFOUND]}
/if (${SotWAA.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff SotWAA "Spirit of the Grove"
  /varset SotWAA "Spirit of the Grove"
}
/varset IniString ${Ini[${MyIni},HealStuff,DoSotW,NOTFOUND]}
/varset DoSotW ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff DoSotW 0
  /varset DoSotW 0
}
/varset IniString ${Ini[${MyIni},HealStuff,ReportSotW,NOTFOUND]}
/varset ReportSotW ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff ReportSotW 0
  /varset ReportSotW 0
}
/varset IniString ${Ini[${MyIni},HealStuff,SotWPct,NOTFOUND]}
/varset SotWPct ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff SotWPct 75
  /varset SotWPct 75
}
/varset RCAA ${Ini[${MyIni},HealStuff,RCAA,NOTFOUND]}
/if (${RCAA.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff RCAA "Resplendent Cure"
  /varset RCAA "Resplendent Cure"
}
/varset IniString ${Ini[${MyIni},HealStuff,DoRC,NOTFOUND]}
/varset DoRC ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff DoRC 0
  /varset DoRC 0
}
/varset IniString ${Ini[${MyIni},HealStuff,ReportRC,NOTFOUND]}
/varset ReportRC ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff ReportRC 0
  /varset ReportRC 0
}
/varset RCDebuffs ${Ini[${MyIni},HealStuff,RCDebuffs,NOTFOUND]}
/if (${RCDebuffs.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff RCDebuffs "Put Debuffs that you want RC to automatically cure here, in between | and |"
  /varset RCDebuffs "Put Debuffs that you want RC to automatically cure here, in between | and |"
}
/varset IniString ${Ini[${MyIni},HealStuff,PetHealing,NOTFOUND]}
/varset HealPets ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff PetHealing 0
  /varset HealPets 0
}
/varset IniString ${Ini[${MyIni},HealStuff,PetHealPct,NOTFOUND]}
/varset PetHealPct ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff PetHealPct 50
  /varset PetHealPct 50
}
/varset PetHeal ${Ini[${MyIni},HealStuff,PetHeal,NOTFOUND]}
/if (${PetHeal.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff PetHeal "Karana's Renewal"
  /varset PetHeal "Karana's Renewal"
}
/varset PetHealID ${Me.Book[${Me.Book[${PetHeal}]}].ID}
/varset PetHealGem ${Ini[${MyIni},HealStuff,PetHealGem,NOTFOUND]}
/if (${PetHealGem.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" HealStuff PetHealGem gem1
  /varset PetHealGem gem1
}
/varset IniString ${Ini[${MyIni},SelfBuffStuff,SelfBuffs,NOTFOUND]}
/varset SelfBuffs ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" SelfBuffStuff SelfBuffs 0
  /varset SelfBuffs 0
}
/varset IniString ${Ini[${MyIni},SelfBuffStuff,ReportSelfBuffs,NOTFOUND]}
/varset ReportSelfBuffs ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" SelfBuffStuff ReportSelfBuffs 0
  /varset ReportSelfBuffs 0
}
/varset SelfBuffRecheck ${Ini[${MyIni},SelfBuffStuff,SelfBuffRecheck,NOTFOUND]}
/if (${SelfBuffRecheck.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" SelfBuffStuff SelfBuffRecheck 60s
  /varset SelfBuffRecheck 60s
}
/varset IniString ${Ini[${MyIni},SelfBuffStuff,SelfBuffTotal,NOTFOUND]}
/varset SelfBuffTotal ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" SelfBuffStuff SelfBuffTotal 0
  /varset SelfBuffTotal 0
}
/varset IniString ${Ini[${MyIni},DoBuffStuff,RefreshBuffs,NOTFOUND]}
/varset RefreshBuffs ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DoBuffStuff RefreshBuffs 0
  /varset RefreshBuffs 0
}
/varset WornOffGem ${Ini[${MyIni},DoBuffStuff,WornOffGem,NOTFOUND]}
/if (${WornOffGem.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DoBuffStuff WornOffGem gem3
  /varset WornOffGem gem3
}
/varset IniString ${Ini[${MyIni},DoBuffStuff,DoBuffs,NOTFOUND]}
/varset DoBuffs ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DoBuffStuff DoBuffs 0
  /varset DoBuffs 0
}
/varset IniString ${Ini[${MyIni},DoBuffStuff,DoBuffTells,NOTFOUND]}
/varset DoBuffTells ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DoBuffStuff DoBuffTells 0
  /varset DoBuffTells 0
}
/varset IniString ${Ini[${MyIni},DoBuffStuff,ReportDoBuffs,NOTFOUND]}
/varset ReportDoBuffs ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DoBuffStuff ReportDoBuffs 0
  /varset ReportDoBuffs 0
}
/varset IniString ${Ini[${MyIni},DoBuffStuff,DoBuffTotal,NOTFOUND]}
/varset DoBuffTotal ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DoBuffStuff DoBuffTotal 0
  /varset DoBuffTotal 0
}
/varset IniString ${Ini[${MyIni},DebuffStuff,DoDebuffs,NOTFOUND]}
/varset DoDebuffs ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DebuffStuff DoDebuffs 0
  /varset DoDebuffs 0
}
/varset IniString ${Ini[${MyIni},DebuffStuff,ReportDebuffs,NOTFOUND]}
/varset ReportDebuffs ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DebuffStuff ReportDebuffs 0
  /varset ReportDebuffs 0
}
/varset IniString ${Ini[${MyIni},DebuffStuff,DebuffHPs,NOTFOUND]}
/varset DebuffHPs ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DebuffStuff DebuffHPs 98
  /varset DebuffHPs 98
}
/varset IniString ${Ini[${MyIni},DebuffStuff,DebuffRecasts,NOTFOUND]}
/varset DebuffRecasts ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DebuffStuff DebuffRecasts 0
  /varset DebuffRecasts 0
}
/varset IniString ${Ini[${MyIni},DebuffStuff,DebuffTotal,NOTFOUND]}
/varset DebuffTotal ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DebuffStuff DebuffTotal 0
  /varset DebuffTotal 0
}
/varset IniString ${Ini[${MyIni},DoTStuff,DoDoTs,NOTFOUND]}
/varset DoDoTs ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DoTStuff DoDoTs 0
  /varset DoDoTs 0
}
/varset IniString ${Ini[${MyIni},DoTStuff,ReportDoTs,NOTFOUND]}
/varset ReportDoTs ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DoTStuff ReportDoTs 0
  /varset ReportDoTs 0
}
/varset IniString ${Ini[${MyIni},DoTStuff,DoTHPs,NOTFOUND]}
/varset DoTHPs ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DoTStuff DoTHPs 95
  /varset DoTHPs 95
}
/varset IniString ${Ini[${MyIni},DoTStuff,DoTRecasts,NOTFOUND]}
/varset DoTRecasts ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DoTStuff DoTRecasts 0
  /varset DoTRecasts 0
}
/varset IniString ${Ini[${MyIni},DoTStuff,DoTTotal,NOTFOUND]}
/varset DoTTotal ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DoTStuff DoTTotal 0
  /varset DoTTotal 0
}
/varset IniString ${Ini[${MyIni},DoTStuff,StopDoTing,NOTFOUND]}
/varset DoTMinHPs ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DoTStuff StopDoTing 50
  /varset DoTMinHPs 50
}
/for i 1 to 10
/varset SelfBuff[${i}] ${Ini[${MyIni},SelfBuffStuff,SelfBuff${i},NOTFOUND]}
/if (${SelfBuff[${i}].Equal["NOTFOUND"]}) {
  /ini "${MyIni}" SelfBuffStuff SelfBuff${i} "Self Buff Item/Spell #${i}"
  /varset SelfBuff[${i}] "Self Buff Item/Spell #${i}"
}
/varset SelfBuffIcon[${i}] ${Ini[${MyIni},SelfBuffStuff,SelfBuffIcon${i},NOTFOUND]}
/if (${SelfBuffIcon[${i}].Equal["NOTFOUND"]}) {
  /ini "${MyIni}" SelfBuffStuff SelfBuffIcon${i} "Self Buff #${i} Buff Icon"
  /varset SelfBuffIcon[${i}] "Self Buff #${i} Buff Icon"
}
/varset SelfBuffGem[${i}] ${Ini[${MyIni},SelfBuffStuff,SelfBuffGem${i},NOTFOUND]}
/if (${SelfBuffGem[${i}].Equal["NOTFOUND"]}) {
  /ini "${MyIni}" SelfBuffStuff SelfBuffGem${i} "Self Buff #${i} Gem or put Item if an item"
  /varset SelfBuffGem[${i}] "Self Buff #${i} Gem or put Item if an item"
}
/varset IniString ${Ini[${MyIni},SelfBuffStuff,SelfBuffIndoors${i},NOTFOUND]}
/varset SelfBuffIndoors[${i}] ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" SelfBuffStuff SelfBuffIndoors${i} 0
  /varset SelfBuffIndoors[${i}] 0
}
/varset SelfBuffBlock[${i}] ${Ini[${MyIni},SelfBuffStuff,SelfBuffBlock${i},NOTFOUND]}
/if (${SelfBuffBlock[${i}].Equal["NOTFOUND"]}) {
  /ini "${MyIni}" SelfBuffStuff SelfBuffBlock${i} "Put Spells that Block This Buff Here, in between | and |"
  /varset SelfBuffBlock[${i}] "Put Spells that Block This Buff Here, in between | and |"
}
/varset IniString ${Ini[${MyIni},SelfBuffStuff,SelfBuffCount${i},NOTFOUND]}
/varset SelfBuffCount[${i}] ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" SelfBuffStuff SelfBuffCount${i} 15
  /varset SelfBuffCount[${i}] 15
}
/varset DoBuff[${i}] ${Ini[${MyIni},DoBuffStuff,DoBuff${i},NOTFOUND]}
/if (${DoBuff[${i}].Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DoBuffStuff DoBuff${i} "Do Buff Item/Spell #${i}"
  /varset DoBuff[${i}] "Do Buff Item/Spell #${i}"
}
/varset DoBuffGem[${i}] ${Ini[${MyIni},DoBuffStuff,DoBuffGem${i},NOTFOUND]}
/if (${DoBuffGem[${i}].Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DoBuffStuff DoBuffGem${i} "Do Buff #${i} Gem or put Item if an item"
  /varset DoBuffGem[${i}] "Do Buff #${i} Gem or put Item if an item"
}
/varset DoBuffIcon[${i}] ${Ini[${MyIni},DoBuffStuff,DoBuffIcon${i},NOTFOUND]}
/if (${DoBuffIcon[${i}].Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DoBuffStuff DoBuffIcon${i} "Do Buff #${i} Buff Icon"
  /varset DoBuffIcon[${i}] "Do Buff #${i} Buff Icon"
}
/varset IniString ${Ini[${MyIni},DoBuffStuff,DoBuffIndoors${i},NOTFOUND]}
/varset DoBuffIndoors[${i}] ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DoBuffStuff DoBuffIndoors${i} 0
  /varset DoBuffIndoors[${i}] 0
}
/varset DoBuffAliases[${i}] ${Ini[${MyIni},DoBuffStuff,DoBuffAliases${i},NOTFOUND]}
/if (${DoBuffAliases[${i}].Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DoBuffStuff DoBuffAliases${i} "Put the keywords you want to respond to for this buff"
  /varset DoBuffAliases[${i}] "Put the keywords you want to respond to for this buff"
}
/varset IniString ${Ini[${MyIni},DoBuffStuff,DoBuffRefresh${i},NOTFOUND]}
/varset DoBuffRefresh[${i}] ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DoBuffStuff DoBuffRefresh${i} 0
  /varset DoBuffRefresh[${i}] 0
}
/next i
/for i 1 to 5
/varset Debuff[${i}] ${Ini[${MyIni},DebuffStuff,Debuff${i},NOTFOUND]}
/if (${Debuff[${i}].Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DebuffStuff Debuff${i} "Debuff Item/Spell #${i}"
  /varset Debuff[${i}] "Debuff Item/Spell #${i}"
}
/varset DebuffIcon[${i}] ${Ini[${MyIni},DebuffStuff,DebuffIcon${i},NOTFOUND]}
/if (${DebuffIcon[${i}].Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DebuffStuff DebuffIcon${i} "Debuff #${i} Effect Name"
  /varset DebuffIcon[${i}] "Debuff #${i} Effect Name"
}
/varset DebuffGem[${i}] ${Ini[${MyIni},DebuffStuff,DebuffGem${i},NOTFOUND]}
/if (${DebuffGem[${i}].Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DebuffStuff DebuffGem${i} "Debuff #${i} Spell Gem or put Item if an item"
  /varset DebuffGem[${i}] "Debuff #${i} Spell Gem or put Item if an item"
}
/varset IniString ${Ini[${MyIni},DebuffStuff,DebuffSpellSet${i},NOTFOUND]}
/varset DebuffSpellSet[${i}] ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DebuffStuff DebuffSpellSet${i} 0
  /varset DebuffSpellSet[${i}] 0
}
/varset DoT[${i}] ${Ini[${MyIni},DoTStuff,DoT${i},NOTFOUND]}
/if (${DoT[${i}].Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DoTStuff DoT${i} "DoT Item/Spell #${i}"
  /varset DoT[${i}] "DoT Item/Spell #${i}"
}
/varset DoTIcon[${i}] ${Ini[${MyIni},DoTStuff,DoTIcon${i},NOTFOUND]}
/if (${DoTIcon[${i}].Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DoTStuff DoTIcon${i} "DoT #${i} Effect Name"
  /varset DoTIcon[${i}] "DoT #${i} Effect Name"
}
/varset DoTGem[${i}] ${Ini[${MyIni},DoTStuff,DoTGem${i},NOTFOUND]}
/if (${DoTGem[${i}].Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DoTStuff DoTGem${i} "DoT #${i} Spell Gem or put Item if an item"
  /varset DoTGem[${i}] "DoT #${i} Spell Gem or put Item if an item"
}
/varset IniString ${Ini[${MyIni},DoTStuff,DoTSpellSet${i},NOTFOUND]}
/varset DoTSpellSet[${i}] ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" DoTStuff DoTSpellSet${i} 0
  /varset DoTSpellSet[${i}] 0
}
/next i
/if (${SelfBuffTotal}) {
  /for i 1 to ${SelfBuffTotal}
  /if (${SelfBuffGem[${i}].Equal[item]}) {
    /varset SelfBuffID[${i}] ${Spell[${SelfBuffIcon[${i}]}].ID}
  } else /if (${SelfBuffGem[${i}].Equal[alt]}) {
    /varset SelfBuffID[${i}] ${Spell[${SelfBuffIcon[${i}]}].ID}
  } else /varset SelfBuffID[${i}] ${Me.Book[${Me.Book[${SelfBuffIcon[${i}]}]}].ID}
  /next i
}
/if (${DoBuffTotal}) {
  /for i 1 to ${DoBuffTotal}
  /if (${DoBuffGem[${i}].Equal[item]}) {
    /varset DoBuffID[${i}] ${Spell[${DoBuffIcon[${i}]}].ID}
  } else /if (${DoBuffGem[${i}].Equal[alt]}) {
    /varset DoBuffID[${i}] ${Spell[${DoBuffIcon[${i}]}].ID}
  } else /varset DoBuffID[${i}] ${Me.Book[${Me.Book[${DoBuff[${i}]}]}].ID}
  /next i
}
/if (${DebuffTotal}) {
  /for i 1 to ${DebuffTotal}
  /if (${DebuffGem[${i}].Equal[item]}) {
    /varset DebuffID[${i}] ${Spell[${DebuffIcon[${i}]}].ID}
  } else /if (${DebuffGem[${i}].Equal[alt]}) {
    /varset DebuffID[${i}] ${Spell[${DebuffIcon[${i}]}].ID}
  } else /varset DebuffID[${i}] ${Me.Book[${Me.Book[${DebuffIcon[${i}]}]}].ID}
  /next i
}
/if (${DoTTotal}) {
  /for i 1 to ${DoTTotal}
  /if (${DoTGem[${i}].Equal[item]}) {
    /varset DoTID[${i}] ${Spell[${DoTIcon[${i}]}].ID}
  } else /if (${DoTGem[${i}].Equal[alt]}) {
    /varset DoTID[${i}] ${Spell[${DoTIcon[${i}]}].ID}
  } else /varset DoTID[${i}] ${Me.Book[${Me.Book[${DoTIcon[${i}]}]}].ID}
  /next i
}
/varset IniString ${Ini[${MyIni},NukeStuff,DoNukes,NOTFOUND]}
/varset DoNukes ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" NukeStuff DoNukes 0
  /varset DoNukes 0
}
/varset IniString ${Ini[${MyIni},NukeStuff,NukeHPs,NOTFOUND]}
/varset NukeHPs ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" NukeStuff NukeHPs 90
  /varset NukeHPs 90
}
/varset NukeDelay ${Ini[${MyIni},NukeStuff,NukeDelay,NOTFOUND]}
/if (${NukeDelay.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" NukeStuff NukeDelay 0
  /varset NukeDelay 0
}
/varset NukeGem ${Ini[${MyIni},NukeStuff,NukeGem,NOTFOUND]}
/if (${NukeGem.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" NukeStuff NukeGem gem7
  /varset NukeGem gem7
}
/varset ColdNuke ${Ini[${MyIni},NukeStuff,ColdNuke,NOTFOUND]}
/if (${ColdNuke.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" NukeStuff ColdNuke "Winter's Frost"
  /varset ColdNuke "Winter's Frost"
}
/varset IniString ${Ini[${MyIni},NukeStuff,WhichNuke,NOTFOUND]}
/varset WhichNuke ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" NukeStuff WhichNuke 1
  /varset WhichNuke 1
}
/varset ColdNukeID ${Me.Book[${Me.Book[${ColdNuke}]}].ID}
/varset MyNukes[2] ${ColdNuke}
/varset FireNuke ${Ini[${MyIni},NukeStuff,FireNuke,NOTFOUND]}
/if (${FireNuke.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" NukeStuff FireNuke "Sylvan Fire"
  /varset FireNuke "Sylvan Fire"
}
/varset FireNukeID ${Me.Book[${Me.Book[${FireNuke}]}].ID}
/varset MyNukes[1] ${FireNuke}
/varset IniString ${Ini[${MyIni},SnareStuff,DoSnare,NOTFOUND]}
/varset DoSnare ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" SnareStuff DoSnare 0
  /varset DoSnare 0
}
/varset IniString ${Ini[${MyIni},RootStuff,RootNScoot,NOTFOUND]}
/varset RootNScoot ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" RootStuff RootNScoot 0
  /varset RootNScoot 0
}
/varset RootGem ${Ini[${MyIni},RootStuff,RootGem,NOTFOUND]}
/if (${RootGem.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" RootStuff RootGem gem4
  /varset RootGem gem4
}
/varset RootSpell ${Ini[${MyIni},RootStuff,RootSpell,NOTFOUND]}
/if (${RootSpell.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" RootStuff RootSpell "Ensnare"
  /varset RootSpell "Ensnare"
}
/varset IniString ${Ini[${MyIni},SnareStuff,ReportSnares,NOTFOUND]}
/varset ReportSnares ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" SnareStuff ReportSnares 0
  /varset ReportSnares 0
}
/varset IniString ${Ini[${MyIni},SnareStuff,SnareHPs,NOTFOUND]}
/varset SnareHPs ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" SnareStuff SnareHPs 50
  /varset SnareHPs 50
}
/varset IniString ${Ini[${MyIni},SnareStuff,SnareRecasts,NOTFOUND]}
/varset SnareRecasts ${IniString}
/if (${IniString.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" SnareStuff SnareRecasts 0
  /varset SnareRecasts 0
}
/varset SnareGem ${Ini[${MyIni},SnareStuff,SnareGem,NOTFOUND]}
/if (${SnareGem.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" SnareStuff SnareGem gem8
  /varset SnareGem gem8
}
/varset SnareSpell ${Ini[${MyIni},SnareStuff,SnareSpell,NOTFOUND]}
/if (${SnareSpell.Equal["NOTFOUND"]}) {
  /ini "${MyIni}" SnareStuff SnareSpell "Ensnare"
  /varset SnareSpell "Ensnare"
}
/varset SnareSpellID ${Me.Book[${Me.Book[${SnareSpell}]}].ID}
/return
Last edited by A_Druid_00 on Tue Jun 28, 2005 10:57 pm, edited 45 times in total.
[quote]<DigitalMocking> man, A_Druid_00 really does love those long ass if statements
<dont_know_at_all> i don't use his macro because i'm frightened of it[/quote]
[quote][12:45] <dont_know_at_all> never use a macro when you can really fuck up things with a plugin[/quote]

A_Druid_00
Macro Maker Extraordinaire
Posts: 2378
Joined: Tue Jul 13, 2004 12:45 pm
Location: Rolling on the Lawn Farting

RDDeclares.inc

Post by A_Druid_00 » Mon Nov 08, 2004 9:45 pm

Code: Select all

|RDDeclares.inc v7.23
Sub RDDeclares
/declare CheckGroupTimer timer outer
/declare DebuffTimer1    timer outer
/declare DebuffTimer2    timer outer
/declare DebuffTimer3    timer outer
/declare DebuffTimer4    timer outer
/declare DebuffTimer5    timer outer
/declare DoTTimer1       timer outer
/declare DoTTimer2       timer outer
/declare DoTTimer3       timer outer
/declare DoTTimer4       timer outer
/declare DoTTimer5       timer outer
/declare EpicTimer       timer outer
/declare NukeTimer       timer outer
/declare RodTimer        timer outer
/declare SelfBuffTimer   timer outer
/declare SitTimer        timer outer
/declare SotWCheckTimer  timer outer
/declare SnareTimer      timer outer
/declare SpamTimer       timer outer
/declare TankPPSTimer    timer outer
/declare WaitTimer       timer outer

/declare AEHeal              int outer
/declare AssistHeal          int outer
/declare AssistMA            int outer
/declare AutoNinja           int outer
/declare AutoSit             int outer
/declare BuffGuy             int outer
/declare CancelPct           int outer
/declare ClickRods           int outer
/declare ColdNukeID          int outer
/declare DAArray[6,2]        int outer
/declare DebuffHPs           int outer
/declare DebuffID[5]         int outer
/declare DebuffRecasts       int outer
/declare DebuffSpellSet[5]   int outer
/declare DebuffTarget        int outer
/declare DebuffTotal         int outer
/declare DoBuffID[11]        int outer
/declare DoBuffIndoors[11]   int outer
/declare DoBuffRefresh[10]   int outer
/declare DoBuffs             int outer
/declare DoBuffTells         int outer
/declare DoBuffTotal         int outer
/declare DoDebuffs           int outer
/declare DoDoTs              int outer
/declare DontLoot            int outer
/declare DoNukes             int outer
/declare DoRamp              int outer
/declare DoRC                int outer
/declare DoSnare             int outer
/declare DoSotW              int outer
/declare DoTHPs              int outer
/declare DoTID[5]            int outer
/declare DoTMinHPs           int outer
/declare DoTRecasts          int outer
/declare DoTSpellSet[5]      int outer
/declare DoTTotal            int outer
/declare DoWolf              int outer
/declare DoWoW               int outer
/declare EngageHPs           int outer
/declare FastHealID          int outer
/declare FireNukeID          int outer
/declare FollowGuy           int outer
/declare FollowOn            int outer
/declare HealFD              int outer
/declare HealMeFirst         int outer
/declare HealPets            int outer
/declare HealGroup           int outer
/declare HealPct             int outer
/declare MATarget            int outer
/declare MedPct              int outer
/declare noInvis             int outer 1
/declare NoMount             int outer
/declare NPCRadius           int outer
/declare NPCZRadius          int outer
/declare NukeHPs             int outer
/declare NukePctMana         int outer
/declare Outdoors            int outer 1
/declare OVHPs               int outer
/declare PCRadius            int outer
/declare PCZRadius           int outer
/declare PetHealID           int outer
/declare PetHealPct          int outer
/declare RDTempVar           int outer
/declare RefreshBuffs        int outer
/declare ReportDebuffs       int outer
/declare ReportDoBuffs       int outer
/declare ReportDoTs          int outer
/declare ReportEpic          int outer
/declare ReportFM            int outer
/declare ReportHeals         int outer
/declare ReportInterrupts    int outer
/declare ReportMana          int outer
/declare ReportRC            int outer
/declare ReportSelfBuffs     int outer
/declare ReportSnares        int outer
/declare ReportSotW          int outer
/declare ReportWoW           int outer
/declare RodMana             int outer
/declare RootNScoot          int outer
/declare SelfBuffCount[10]   int outer
/declare SelfBuffs           int outer
/declare SelfBuffID[10]      int outer
/declare SelfBuffIndoors[10] int outer
/declare SelfBuffTotal       int outer
/declare SnareHPs            int outer
/declare SnareRecasts        int outer
/declare SnareSpellID        int outer
/declare SotWPct             int outer
/declare Stop4Pad            int outer
/declare StopHPs             int outer
/declare TankHealID          int outer
/declare TankHealPct         int outer
/declare TankLastPct         int outer
/declare TankPPS             int outer
/declare TankTTL             int outer
/declare TotalTankHits       int outer
/declare UseCH               int outer
/declare UseMount            int outer
/declare UseEpic             int outer
/declare WhichNuke           int outer
/declare WaitToCancel        int outer

/declare ChatChannel         string outer
/declare CheckGroupInterval  string outer
/declare CHMessage           string outer
/declare ColdNuke            string outer
/declare ColdSpells          string outer
/declare Debuff[5]           string outer
/declare DebuffGem[5]        string outer
/declare DebuffIcon[5]       string outer
/declare DoBuff[10]          string outer
/declare DoBuffAliases[10]   string outer
/declare DoBuffGem[10]       string outer
/declare DoBuffIcon[10]      string outer
/declare DoT[5]              string outer
/declare DoTGem[5]           string outer
/declare DoTIcon[5]          string outer
/declare FastHeal            string outer
/declare FastHealGem         string outer
/declare FireNuke            string outer
/declare FireSpells          string outer
/declare MA1                 string outer
/declare MA2                 string outer
/declare MA3                 string outer
/declare MasterList          string outer
/declare MountItem           string outer
/declare MyIni               string outer
/declare MyNukes[2]          string outer
/declare NukeDelay           string outer
/declare NukeGem             string outer
/declare PetHeal             string outer
/declare PetHealGem          string outer
/declare RampTank            string outer
/declare RCAA                string outer
/declare RCDebuffs           string outer
/declare RDVersion           string outer 7.23
/declare RootGem             string outer
/declare RootSpell           string outer
/declare SelfBuff[10]        string outer
/declare SelfBuffBlock[10]   string outer
/declare SelfBuffGem[10]     string outer
/declare SelfBuffIcon[10]    string outer
/declare SelfBuffRecheck     string outer
/declare SitDelay            string outer
/declare SnareGem            string outer
/declare SnareSpell          string outer
/declare SotWAA              string outer
/declare SpamDelay           string outer
/declare TankHeal            string outer
/declare TankHealGem         string outer
/declare TargetReturn        string outer
/declare WornOffGem          string outer
/return

Sub LoadAliases
/echo Version Mismatch Detected, Loading Aliases
/squelch /alias /aeheal           /echo SetAEHeal
/squelch /alias /assistheal       /echo SetAssistHeal
/squelch /alias /assistma         /echo SetAssistMA
/squelch /alias /autoninja        /echo SetAutoNinja
/squelch /alias /autosit          /echo SetAutoSit
/squelch /alias /cancelpct        /echo SetCancelPct
/squelch /alias /chatchannel      /echo SetChatChannel
/squelch /alias /checkgroup       /echo SetCheckGroup
/squelch /alias /clickrods        /echo SetClickRods
/squelch /alias /cold             /echo SetCold
/squelch /alias /debuff           /echo SetXDebuff
/squelch /alias /debuffhps        /echo SetDebuffHPs
/squelch /alias /debuffrecast     /echo SetDebuffRecasts
/squelch /alias /dobuffs          /echo SetDoBuffs
/squelch /alias /dobufftells      /echo SetDoBuffTells
/squelch /alias /dot              /echo SetXDoT
/squelch /alias /dothps           /echo SetDoTHPs
/squelch /alias /dotpct           /echo SetDoTPct
/squelch /alias /dotrecast        /echo SetDoTRecasts
/squelch /alias /engagehps        /echo SetEngageHPs
/squelch /alias /fire             /echo SetFire
/squelch /alias /healfd           /echo SetHealFD
/squelch /alias /healgroup        /echo SetHealGroup
/squelch /alias /healmefirst      /echo SetHealMeFirst
/squelch /alias /healpct          /echo SetHealPct
/squelch /alias /healpets         /echo SetHealPets
/squelch /alias /healramp         /echo SetHealRamp
/squelch /alias /interrupt        /echo SetInterrupt
/squelch /alias /ma1              /echo SetMA1
/squelch /alias /ma2              /echo SetMA2
/squelch /alias /ma3              /echo SetMA3
/squelch /alias /medpct           /echo SetMedPct
/squelch /alias /pcradius         /echo SetPCRadius
/squelch /alias /pczradius        /echo SetPCZRadius
/squelch /alias /npcradius        /echo SetNPCRadius
/squelch /alias /npczradius       /echo SetNPCZRadius
/squelch /alias /nuke             /echo SetXNuke
/squelch /alias /nukedelay        /echo SetNukeDelay
/squelch /alias /nukehps          /echo SetNukeHPs
/squelch /alias /nukepctmana      /echo SetNukePctMana
/squelch /alias /ovhps            /echo SetOVHPs
/squelch /alias /pethealpct       /echo SetPetHealPct
/squelch /alias /ramptank         /echo SetRampTank
/squelch /alias /rc               /echo SetRC
/squelch /alias /refreshbuffs     /echo SetRefreshBuffs
/squelch /alias /reportdebuffs    /echo SetReportDebuffs
/squelch /alias /reportdobuffs    /echo SetReportDoBuffs
/squelch /alias /reportdots       /echo SetReportDoTs
/squelch /alias /reportepic       /echo SetReportEpic
/squelch /alias /reportheals      /echo SetReportHeals
/squelch /alias /reportinterrupts /echo SetReportInterrupts
/squelch /alias /reportmana       /echo SetReportMana
/squelch /alias /reportrc         /echo SetReportRC
/squelch /alias /reportselfbuffs  /echo SetReportSelfBuffs
/squelch /alias /reportsnares     /echo SetReportSnares
/squelch /alias /reportsotw       /echo SetReportSotW
/squelch /alias /reportwow        /echo SetReportWoW
/squelch /alias /resettanks       /echo ResetTanks
/squelch /alias /rodmana          /echo SetRodMana
/squelch /alias /rootnscoot       /echo SetRootNScoot
/squelch /alias /selfbuff         /echo SetSelfBuff
/squelch /alias /sitdelay         /echo SetSitDelay
/squelch /alias /snare            /echo SetXSnare
/squelch /alias /snarehps         /echo SetSnareHPs
/squelch /alias /snarerecast      /echo SetSnareRecasts
/squelch /alias /sotw             /echo SetSotW
/squelch /alias /sotwpct          /echo SetSotWPct
/squelch /alias /spamdelay        /echo SetSpamDelay
/squelch /alias /stophps          /echo SetStopHPs
/squelch /alias /tankhealpct      /echo SetTankHealPct
/squelch /alias /usech            /echo SetUseCH
/squelch /alias /useepic          /echo SetUseEpic
/squelch /alias /usemount         /echo SetUseMount
/squelch /alias /waittocancel     /echo SetWaitToCancel
/squelch /alias /wolf             /echo SetWolf
/squelch /alias /wow              /echo SetWoW
/ini "RD_${Me.CleanName}.ini" "Settings" "Version" "${RDVersion}"
/return
Last edited by A_Druid_00 on Tue Jun 28, 2005 10:58 pm, edited 52 times in total.
[quote]<DigitalMocking> man, A_Druid_00 really does love those long ass if statements
<dont_know_at_all> i don't use his macro because i'm frightened of it[/quote]
[quote][12:45] <dont_know_at_all> never use a macro when you can really fuck up things with a plugin[/quote]

A_Druid_00
Macro Maker Extraordinaire
Posts: 2378
Joined: Tue Jul 13, 2004 12:45 pm
Location: Rolling on the Lawn Farting

RDEvents.inc

Post by A_Druid_00 » Mon Nov 08, 2004 9:46 pm

Code: Select all

|RDEvents.inc v7.23
#event CantLoot            "#*#may not loot this corpse#*#"
#event Dead                "#*#Returning to home point#*#"
#event RaidExperience      "#*#You gained raid experience#*#"
#event Experience          "#*#You gain party experience#*#"
#event ImHit               "#*#YOU for#*#points of damage."
#event Indoors             "You can only cast this spell in the outdoors#*#"
#event NoMount             "You can not summon a mount#*#"
#event NoMount             "You need to be in a more open area to summon a mount#*#"
#event NoMount             "You can only summon a mount on dry land#*#"
#event Indoors             "This spell does not work here#*#"
#event Invite              "#1# invites you to join a group."
#event IRC                 "<#1#> #2#"
#event NewZone             "You have entered#*#"
#event Rampage             "#*#goes on a RAMPAGE#*#"
#Event SetAEHeal           "[MQ2] SetAEHeal#*#"
#Event SetAssistHeal       "[MQ2] SetAssistHeal#*#"
#Event SetAssistMA         "[MQ2] SetAssistMA#*#"
#Event SetAutoNinja        "[MQ2] SetAutoNinja#*#"
#Event SetAutoSit          "[MQ2] SetAutoSit#*#"
#Event SetCancelPct        "[MQ2] SetCancelPct#*#"
#Event SetChatChannel      "[MQ2] SetChatChannel#*#"
#Event SetCheckGroup       "[MQ2] SetCheckGroup#*#"
#Event SetClickRods        "[MQ2] SetClickRods#*#"
#Event SetCold             "[MQ2] SetCold#*#"
#Event SetDebuff           "[MQ2] SetXDebuff#*#"
#Event SetDebuffHPs        "[MQ2] SetDebuffHPs#*#"
#Event SetDebuffRecasts    "[MQ2] SetDebuffRecasts#*#"
#Event SetDoBuffs          "[MQ2] SetDoBuffs#*#"
#Event SetDoBuffTells      "[MQ2] SetDoBuffTells#*#"
#Event SetDoT              "[MQ2] SetXDoT#*#"
#Event SetDoTHPs           "[MQ2] SetDoTHPs#*#"
#Event SetDoTPct           "[MQ2] SetDoTPct#*#"
#Event SetDoTRecasts       "[MQ2] SetDoTRecasts#*#"
#Event SetEngageHPs        "[MQ2] SetEngageHPs#*#"
#Event SetFire             "[MQ2] SetFire#*#"
#Event SetHealFD           "[MQ2] SetHealFD#*#"
#Event SetHealGroup        "[MQ2] SetHealGroup#*#"
#Event SetHealMeFirst      "[MQ2] SetHealMeFirst#*#"
#Event SetHealPets         "[MQ2] SetHealPets#*#"
#Event SetHealPct          "[MQ2] SetHealPct#*#"
#Event SetHealRamp         "[MQ2] SetHealRamp#*#"
#Event SetInterrupt        "[MQ2] SetInterrupt#*#"
#Event SetMA1              "[MQ2] SetMA1#*#"
#Event SetMA2              "[MQ2] SetMA2#*#"
#Event SetMA3              "[MQ2] SetMA3#*#"
#Event SetMedPct           "[MQ2] SetMedPct#*#"
#Event SetPCRadius         "[MQ2] SetPCRadius#*#"
#Event SetPCZRadius        "[MQ2] SetPCZRadius#*#"
#Event SetNPCRadius        "[MQ2] SetNPCRadius#*#"
#Event SetNPCZRadius       "[MQ2] SetNPCZRadius#*#"
#Event SetXNuke            "[MQ2] SetXNuke#*#"
#Event SetNukeDelay        "[MQ2] SetNukeDelay#*#"
#Event SetNukeHPs          "[MQ2] SetNukeHPs#*#"
#Event SetNukePctMana      "[MQ2] SetNukePctMana#*#"
#Event SetOVHPs            "[MQ2] SetOVHPs#*#"
#Event SetRampTank         "[MQ2] SetRampTank#*#"
#Event SetRC               "[MQ2] SetRC#*#"
#Event SetRefreshBuffs     "[MQ2] SetRefreshBuffs#*#"
#Event SetReportDebuffs    "[MQ2] SetReportDebuffs#*#"
#Event SetReportDoBuffs    "[MQ2] SetReportDoBuffs#*#"
#Event SetReportDoTs       "[MQ2] SetReportDoTs#*#"
#Event SetReportEpic       "[MQ2] SetReportEpic#*#"
#Event SetReportHeals      "[MQ2] SetReportHeals#*#"
#Event SetReportInterrupts "[MQ2] SetReportInterrupts#*#"
#Event SetReportMana       "[MQ2] SetReportMana#*#"
#Event SetReportRC         "[MQ2] SetReportRC#*#"
#Event SetReportSelfBuffs  "[MQ2] SetReportSelfBuffs#*#"
#Event SetReportSnares     "[MQ2] SetReportSnares#*#"
#Event SetReportSotW       "[MQ2] SetReportSotW#*#"
#Event SetReportWoW        "[MQ2] SetReportWoW#*#"
#Event SetRodMana          "[MQ2] SetRodMana#*#"
#Event SetRootNScoot       "[MQ2] SetRootNScoot#*#"
#Event SetSelfBuff         "[MQ2] SetSelfBuff#*#"
#Event SetSitDelay         "[MQ2] SetSitDelay#*#"
#Event SetSnareHPs         "[MQ2] SetSnareHPs#*#"
#Event SetSnare            "[MQ2] SetXSnare#*#"
#Event SetSnareRecasts     "[MQ2] SetSnareRecasts#*#"
#Event SetSotW             "[MQ2] SetSotW#*#"
#Event SetSotWPct          "[MQ2] SetSotWPct#*#"
#Event SetSpamDelay        "[MQ2] SetSpamDelay#*#"
#Event SetStopHPs          "[MQ2] SetStopHPs#*#"
#Event SetTankHealPct      "[MQ2] SetTankHealPct#*#"
#Event SetUseCH            "[MQ2] SetUseCH#*#"
#Event SetUseEpic          "[MQ2] SetUseEpic#*#"
#Event SetUseMount         "[MQ2] SetUseMount#*#"
#Event SetWaitToCancel     "[MQ2] SetWaitToCancel#*#"
#Event SetWolf             "[MQ2] SetWolf#*#"
#Event SetWoW              "[MQ2] SetWoW#*#"
#Event WornOff             "#*#Your #1# spell has worn off of #2#."

Sub Event_CantLoot
/varset DontLoot ${Target.ID}
/return

Sub Event_Dead
/memspellset ${FireSpells}
/call Wait4Rez
/return

Sub Event_RaidExperience
/if (${ReportMana} && ${Me.PctMana}<${MedPct} && !${SpamTimer}) {
  /if (${ReportMana}) /${ChatChannel} Medding, ${Me.PctMana}m
  /varset SpamTimer ${SpamDelay}
  /varset ReportFM 1
}
/return

Sub Event_Experience
/declare Loot int local -1
/declare Slot int local
/declare MyY  int local
/declare MyX  int local
/if (${ReportMana} && ${Me.PctMana}<${MedPct} && !${SpamTimer}) {
  /if (${ReportMana}) /${ChatChannel} Medding, ${Me.PctMana}m
  /varset SpamTimer ${SpamDelay}
  /varset ReportFM 1
}
:TryAgain
/if ((${Me.Casting.ID} || ${Me.Moving}) && ${AutoNinja}) {
  /delay 1s
  /goto :TryAgain
}
/varset MyY ${Int[${Me.Y}]}
/varset MyX ${Int[${Me.X}]}
/if (${AutoNinja} && ${NearestSpawn[npc corpse radius 100 zradius 50].ID}!=${DontLoot} && ${Me.FreeInventory} && ${SpawnCount[npc corpse radius 100 zradius 50]}) {
  /delay 5
  /target ${NearestSpawn[npc corpse radius 100 zradius 50]}
  /stick 10
  /delay 5s ${NearestSpawn[npc corpse radius 10 zradius 50].ID}
  /stick off
  /loot
  /delay 1s ${Window[LootWnd].Open}
  /doevents CantLoot
  /if (${Loot}!=${Corpse.Items}) {
    /varset Loot ${Corpse.Items}
    /delay 5
    /goto :TryAgain
  }
  /if (!${Loot}) /goto :DoneLooting
  /for Slot 1 to ${Loot}
  /if (${Corpse.Item[${Slot}].ID}) {
    /if (!${Corpse.Item[${Slot}].NoDrop}) /goto :LootItem
    /if (${Corpse.Item[${Slot}].NoDrop}) {
      /varset DontLoot ${Target.ID}
      /goto :SkipIt
    }
    :LootItem
    /itemnotify loot${Slot} rightmouseup
    /delay 3
    /if (${Corpse.Item[${Slot}].ID}) {
      /delay 2
      /goto :LootItem
    }
    :SkipIt
    /next Slot
    :DoneLooting
    /delay 5
    /notify LootWnd DoneButton leftmouseup
    /delay 5
  } else /if (!${Me.FreeInventory}) {
    /varset AutoNinja 0
  }
  /keypress esc
  /moveto loc ${MyY} ${MyX}
  /delay 1s
  /stick off
}
/return

Sub Event_ImHit
/declare AggroMob int local
/declare i        int local
/varset WaitTimer 10s
/varset SitTimer 10s
/if (${Me.SpellReady[Oaken Guard]} && ${Me.PctHPs}<${OVHPs}) /call Cast "Oaken Guard" gem9 10s
/if (${RootNScoot} && ${Me.SpellReady[${RootSpell}]}) {
  /varset AggroMob ${NearestSpawn[npc radius 20 zradius 100].ID}
  /target id ${AggroMob}
  /delay 5 ${Target.ID}==${AggroMob}
  /call Cast "${RootSpell}" ${RootGem} 5s
  /for i 1 to 3
  /if (${Spawn[pc ${MA${i}}].ID}) {
    /squelch /face fast nolook id ${NearestSpawn[pc ${MA${i}}].ID}
    /keypress forward hold
    /delay 1s ${Spawn[npc id ${AggroMob}].Distance}>${Math.Calc[${Spawn[npc id ${AggroMob}].MaxRange}+5]}
    /keypress back
    /goto :DoneRooting
  }
  /next i
  :DoneRooting
  /varset AggroMob 0
}
/return

Sub Event_Indoors
/varset Outdoors 0
/return

Sub Event_Invite(string Line,string Inviter)
/if (${MasterList.Find[${Inviter}]}) {
  /invite
}
/return

Sub Event_IRC(string IRCSay,string IRCSender)
/if (${MasterList.Find[${IRCSender}]}) {
  /if (${IRCSay.Find[follow]}) {
    /if (${IRCSay.Arg[3].Length} && ${Spawn[pc ${IRCSay.Arg[3]}].ID}) {
      /target id ${Spawn[pc ${IRCSay.Arg[3]}].ID}
      /delay 1s ${Target.ID}==${Spawn[pc ${IRCSay.Arg[3]}].ID}
      /stick 10 hold
      /varset FollowOn 1
      /varset FollowGuy ${Spawn[pc ${IRCSay.Arg[3]}].ID}
    } else {
      /target id ${Spawn[pc ${IRCSender}].ID}
      /delay 1s ${Target.ID}==${Spawn[pc ${IRCSender}].ID}
      /stick 10 hold
      /varset FollowOn 1
      /varset FollowGuy ${Spawn[pc ${IRCSender}].ID}
    }
  }
  /if (${IRCSay.Find[stop]}) {
    /stick off
  }
}
/return

Sub Event_NewZone
/varset Outdoors 1
/varset NoMount 0
/return

Sub Event_NoMount
/varset NoMount 1
/return

Sub Event_Rampage
/if (${DoRamp}) {
  :WaitForRamp
  /call CheckGroup
  /if (${Me.Moving} || !${Me.Casting.ID}) /goto :WaitForRamp
  /target pc ${RampTank}
  /delay 5
  /if (${Target.ID}==${Spawn[pc ${RampTank}].ID} && ${Target.PctHPs}<${CancelPct} && ${Target.Distance}<${Spell[${FastHealID}].Range} && ${Me.CurrentMana}>${Spell[${FastHealID}].Mana}) {
    :ShouldIRamp
    /if (${Me.Moving} || ${Me.Casting.ID} || (${Me.Gem[${FastHeal}]} && !${Me.SpellReady[${FastHeal}]})) /goto :ShouldIRamp
    /if (${ReportHeals} && !${SpamTimer} && ${Target.CleanName.NotEqual[NULL]}) /${ChatChannel} ${FastHeal} @ ${Target.CleanName} the Rampage Tank
    /varset SpamTimer ${SpamDelay}
    /call Cast "${FastHeal}" ${FastHealGem} 2s CheckHP
    /varset SitTimer ${SitDelay}
  }
  /if (${Spawn[${MATarget}].ID}) /target id ${MATarget}
}
/return

Sub Event_SetAEHeal(string Line)
/varset RDTempVar ${AEHeal}
/call ToggleVar "${Line}"
/varset AEHeal ${RDTempVar}
/ini "${MyIni}" HealStuff AEHealing ${RDTempVar}
/if (!${AEHeal}) {
  /echo Auto AE Healing is now OFF
} else {
  /echo Auto AE Healing is now ON
}
/return

Sub Event_SetAssistHeal(string Line)
/varset RDTempVar ${AssistHeal}
/call ToggleVar "${Line}"
/varset AssistHeal ${RDTempVar}
/ini "${MyIni}" HealStuff AssistHealing ${RDTempVar}
/if (!${AssistHeal}) {
  /echo Auto Assist Healing is now OFF
} else {
  /echo Auto Assist Healing is now ON
}
/return

Sub Event_SetAssistMA(string Line)
/varset RDTempVar ${AssistMA}
/call ToggleVar "${Line}"
/varset AssistMA ${RDTempVar}
/ini "${MyIni}" GeneralStuff AssistMA ${RDTempVar}
/if (!${AssistMA}) {
  /echo Auto Assisting Main Assist is now OFF
} else {
  /echo Auto Assisting Main Assist is now ON
}
/return

Sub Event_SetAutoNinja(string Line)
/varset RDTempVar ${AutoNinja}
/call ToggleVar "${Line}"
/varset AutoNinja ${RDTempVar}
/ini "${MyIni}" Settings AutoNinja ${RDTempVar}
/if (!${AutoNinja}) {
  /echo Auto Ninja Looting is now OFF
} else {
  /echo Auto Ninja Looting is now ON
}
/return

Sub Event_SetAutoSit(string Line)
/varset RDTempVar ${AutoSit}
/call ToggleVar "${Line}"
/varset AutoSit ${RDTempVar}
/ini "${MyIni}" Settings AutoSit ${RDTempVar}
/if (!${AutoSit}) {
  /echo Auto Sitting is now OFF
} else {
  /echo Auto Sitting is now ON
}
/return

Sub Event_SetCancelPct(string Line)
/if (${Line.Arg[3].Length}) {
  /varset CancelPct ${Line.Arg[3]}
  /ini "${MyIni}" HealStuff CancelPct ${Line.Arg[3]}
}
/echo I will cancel heals if my target's HPs go over: ${CancelPct}% HPs
/return

Sub Event_SetChatChannel(string Line)
/if (${Line.Arg[3].Length}) {
  /varset ChatChannel ${Line.Arg[3]}
  /ini "${MyIni}" GeneralStuff ChatChannel ${Line.Arg[3]}
}
/echo I will use ${ChatChannel} to report
/return

Sub Event_SetCheckGroup(string Line)
/if (${Line.Arg[3].Length}) {
  /varset CheckGroupInterval ${Line.Arg[3]}
  /ini "${MyIni}" HealStuff CheckGroupInterval ${Line.Arg[3]}
}
/echo I will check my group's HPs every: ${CheckGroupInterval}
/return

Sub Event_SetClickRods(string Line)
/varset RDTempVar ${ClickRods}
/call ToggleVar "${Line}"
/varset ClickRods ${RDTempVar}
/ini "${MyIni}" Settings ClickRods ${RDTempVar}
/if (!${ClickRods}) {
  /echo Auto Rod Clicking is now OFF
} else {
  /echo Auto Rod Clicking is now ON
}
/return

Sub Event_SetCold(string Line)
/varset WhichNuke 2
/ini "${MyIni}" NukeStuff WhichNuke ${WhichNuke}
/echo Nuking with Cold spells
/return

Sub Event_SetDebuff(string Line)
/varset RDTempVar ${DoDebuffs}
/call ToggleVar "${Line}"
/varset DoDebuffs ${RDTempVar}
/ini "${MyIni}" DebuffStuff DoDebuffs ${RDTempVar}
/if (!${DoDebuffs}) {
  /echo Auto Debuffing is now OFF
} else {
  /echo Auto Debuffing is now ON
}
/return

Sub Event_SetDebuffHPs(string Line)
/if (${Line.Arg[3].Length}) {
  /varset DebuffHPs ${Line.Arg[3]}
  /ini "${MyIni}" DebuffStuff DebuffHPs ${Line.Arg[3]}
}
/echo I will start debuffing the mob at: ${DebuffHPs}% HPs
/return

Sub Event_SetDebuffRecasts(string Line)
/if (${Line.Arg[3].Length}) {
  /varset DebuffRecasts ${Line.Arg[3]}
  /ini "${MyIni}" DebuffStuff DebuffRecasts ${RDTempVar}
}
/echo I will recast debuffs for: ${DebuffRecasts} resists
/return

Sub Event_SetDoBuffs(string Line)
/varset RDTempVar ${DoBuffs}
/call ToggleVar "${Line}"
/varset DoBuffs ${RDTempVar}
/ini "${MyIni}" DoBuffStuff DoBuffs ${RDTempVar}
/if (!${DoBuffs}) {
  /echo Auto Buffing is now OFF
} else {
  /echo Auto Buffing is now ON
}
/return

Sub Event_SetDoBuffTells(string Line)
/varset RDTempVar ${DoBuffTells}
/call ToggleVar "${Line}"
/varset DoBuffTells ${RDTempVar}
/ini "${MyIni}" DoBuffStuff DoBuffTells ${RDTempVar}
/if (!${DoBuffTells}) {
  /echo Auto Buffing Tells are now OFF
} else {
  /echo Auto Buffing Tells are now ON
}
/return

Sub Event_SetDoT(string Line)
/varset RDTempVar ${DoDoTs}
/call ToggleVar "${Line}"
/varset DoDoTs ${RDTempVar}
/ini "${MyIni}" DoTStuff DoDoTs ${RDTempVar}
/if (!${DoDoTs}) {
  /echo Auto DoTing is now OFF
} else {
  /echo Auto DoTing is now ON
}
/return

Sub Event_SetDoTHPs(string Line)
/if (${Line.Arg[3].Length}) {
  /varset DoTHPs ${Line.Arg[3]}
  /ini "${MyIni}" DoTStuff DoTHPs ${Line.Arg[3]}
}
/echo I will start DoTing the mob at: ${DoTHPs}% HPs
/return

Sub Event_SetDoTPct(string Line)
/if (${Line.Arg[3].Length}) {
  /varset DoTMinHPs ${Line.Arg[3]}
  /ini "${MyIni}" DoTStuff StopDoTing ${Line.Arg[3]}
}
/echo I will stop DoTing when the mob is at: ${DoTMinHPs}% HPs
/return

Sub Event_SetDoTRecasts(string Line)
/if (${Line.Arg[3].Length}) {
  /varset DoTRecasts ${Line.Arg[3]}
  /ini "${MyIni}" DoTStuff DoTRecasts ${RDTempVar}
}
/echo I will recast dots for: ${DoTRecasts} resists
/return

Sub Event_SetEngageHPs(string Line)
/if (${Line.Arg[3].Length}) {
  /varset EngageHPs ${Line.Arg[3]}
  /ini "${MyIni}" GeneralStuff EngageHPs ${Line.Arg[3]}
}
/echo I will engage when the mob is at: ${EngageHPs}% HPs
/return

Sub Event_SetFire(string Line)
/varset WhichNuke 1
/ini "${MyIni}" NukeStuff WhichNuke ${WhichNuke}
/echo Nuking with Fire spells
/return

Sub Event_SetHealFD(string Line)
/varset RDTempVar ${HealFD}
/call ToggleVar "${Line}"
/varset HealFD ${RDTempVar}
/ini "${MyIni}" HealStuff HealFD ${RDTempVar}
/if (!${HealFD}) {
  /echo I will always heal FD classes
} else {
  /echo I will only heal FD classes if they are FD
}
/return

Sub Event_SetHealGroup(string Line)
/varset RDTempVar ${HealGroup}
/call ToggleVar "${Line}"
/varset HealGroup ${RDTempVar}
/ini "${MyIni}" HealStuff GroupHealing ${RDTempVar}
/if (!${HealGroup}) {
  /echo Healing Group is now OFF
} else {
  /echo Healing Group is now ON
}
/return

Sub Event_SetHealMeFirst(string Line)
/varset RDTempVar ${HealMeFirst}
/call ToggleVar "${Line}"
/varset HealMeFirst ${RDTempVar}
/ini "${MyIni}" HealStuff HealMeFirst ${RDTempVar}
/if (!${HealMeFirst}) {
  /echo Healing Myself before anyone else is now OFF
} else {
  /echo Healing Myself before anyone else is now ON
}
/return

Sub Event_SetHealPets(string Line)
/varset RDTempVar ${HealPets}
/call ToggleVar "${Line}"
/varset HealPets ${RDTempVar}
/ini "${MyIni}" HealStuff PetHealing ${RDTempVar}
/if (!${HealPets}) {
  /echo pet Healing is now OFF
} else {
  /echo pet Healing is now ON
}
/return

Sub Event_SetHealPct(string Line)
/if (${Line.Arg[3].Length}) {
  /varset HealPct ${Line.Arg[3]}
  /ini "${MyIni}" HealStuff HealPct ${Line.Arg[3]}
}
/echo I will heal anyone I see below: ${HealPct}% HPs
/return

Sub Event_SetHealRamp(string Line)
/varset RDTempVar ${DoRamp}
/call ToggleVar "${Line}"
/varset DoRamp ${RDTempVar}
/ini "${MyIni}" HealStuff RampHealing ${RDTempVar}
/if (!${DoRamp}) {
  /echo Healing Rampage is now OFF
} else {
  /echo Healing Rampage is now ON
}
/return

Sub Event_SetInterrupt(string Line)
/varset RDTempVar ${Stop4Pad}
/call ToggleVar "${Line}"
/varset Stop4Pad ${RDTempVar}
/ini "${MyIni}" HealStuff AutoInterrupt ${RDTempVar}
/if (!${Stop4Pad}) {
  /echo Interrupt to heal is now OFF
} else {
  /echo Interrupt to heal is now ON
}
/return

Sub Event_SetMA1(string Line)
/if (${Line.Arg[3].Length}) {
  /varset MA1 ${NearestSpawn[${Line.Arg[3]} pc].CleanName}
  /ini "${MyIni}" GeneralStuff MA1 ${Spawn[${Line.Arg[3]} pc].CleanName}
}
/echo Main Assist #1 is: ${MA1}
/return

Sub Event_SetMA2(string Line)
/if (${Line.Arg[3].Length}) {
  /varset MA2 ${NearestSpawn[${Line.Arg[3]} pc].CleanName}
  /ini "${MyIni}" GeneralStuff MA2 ${Spawn[${Line.Arg[3]} pc].CleanName}
}
/echo Main Assist #2 is: ${MA2}
/return

Sub Event_SetMA3(string Line)
/if (${Line.Arg[3].Length}) {
  /varset MA3 ${NearestSpawn[${Line.Arg[3]} pc].CleanName}
  /ini "${MyIni}" GeneralStuff MA3 ${Spawn[${Line.Arg[3]} pc].CleanName}
}
/echo Main Assist #3 is: ${MA3}
/return

Sub Event_SetMedPct(string Line)
/if (${Line.Arg[3].Length}) {
  /varset MedPct ${Line.Arg[3]}
  /ini "${MyIni}" Settings MedPct ${Line.Arg[3]}
}
/echo I will start sitting, or summon my horse at: ${MedPct}% Mana
/return

Sub Event_SetNPCRadius(string Line)
/if (${Line.Arg[3].Length}) {
  /varset NPCRadius ${Line.Arg[3]}
  /ini "${MyIni}" Settings NPCRadius ${Line.Arg[3]}
}
/echo I will go live when NPCs are within: ${NPCRadius} feet
/return

Sub Event_SetNPCZRadius(string Line)
/if (${Line.Arg[3].Length}) {
  /varset NPCZRadius ${Line.Arg[3]}
  /ini "${MyIni}" Settings NPCZRadius ${Line.Arg[3]}
}
/echo I will go live when NPCs are within: ${NPCZRadius} feet above or below me
/return

Sub Event_SetXNuke(string Line)
/varset RDTempVar ${DoNukes}
/call ToggleVar "${Line}"
/varset DoNukes ${RDTempVar}
/ini "${MyIni}" NukeStuff DoNukes ${RDTempVar}
/if (!${DoNukes}) {
  /echo Auto Nuking is now OFF
} else {
  /echo Auto Nuking is now ON
}
/return

Sub Event_SetNukeDelay(string Line)
/if (${Line.Arg[3].Length}) {
  /varset NukeDelay ${Line.Arg[3]}
  /ini "${MyIni}" NukeStuff NukeDelay ${Line.Arg[3]}
}
/echo I will wait: ${NukeDelay} between nukes
/return

Sub Event_SetNukeHPs(string Line)
/if (${Line.Arg[3].Length}) {
  /varset NukeHPs ${Line.Arg[3]}
  /ini "${MyIni}" NukeStuff NukeHPs ${Line.Arg[3]}
}
/echo I will start nuking the mob at: ${NukeHPs}% HPs
/return

Sub Event_SetNukePctMana(string Line)
/if (${Line.Arg[3].Length}) {
  /varset NukePctMana ${Line.Arg[3]}
  /ini "${MyIni}" GeneralStuff StopNukingMana ${Line.Arg[3]}
}
/echo I will stop nuking and debuffing at: ${NukePctMana}% Mana
/return

Sub Event_SetOVHPs(string Line)
/if (${Line.Arg[3].Length}) {
  /varset OVHPs ${Line.Arg[3]}
  /ini "${MyIni}" Settings OVHPs ${Line.Arg[3]}
}
/echo I will cast Oaken Vigor at: ${OVHPs}% HPs
/return

Sub Event_SetPCRadius(string Line)
/if (${Line.Arg[3].Length}) {
  /varset PCRadius ${Line.Arg[3]}
  /ini "${MyIni}" Settings PCRadius ${Line.Arg[3]}
}
/echo I will AE Heal PCs within: ${PCRadius} feet
/return

Sub Event_SetPCZRadius(string Line)
/if (${Line.Arg[3].Length}) {
  /varset PCZRadius ${Line.Arg[3]}
  /ini "${MyIni}" Settings PCZRadius ${Line.Arg[3]}
}
/echo I will AE Heal PCs: ${PCZRadius} feet above or below me
/return

Sub Event_SetPetHealPct(string Line)
/if (${Line.Arg[3].Length}) {
  /varset PetHealPct ${Line.Arg[3]}
  /ini "${MyIni}" HealStuff PetHealPct ${Line.Arg[3]}
}
/echo I will heal any pets I see below: ${PetHealPct}% HPs
/return

Sub Event_SetRampTank(string Line)
/if (${Line.Arg[3].Length}) {
  /varset RampTank ${Spawn[${Line.Arg[3]} pc].CleanName}
  /ini "${MyIni}" HealStuff RampTank ${Spawn[${Line.Arg[3]} pc].CleanName}
}
/echo Rampage Tank is: ${RampTank}
/return

Sub Event_SetRC(string Line)
/varset RDTempVar ${DoRC}
/call ToggleVar "${Line}"
/varset DoRC ${RDTempVar}
/ini "${MyIni}" HealStuff DoRC ${RDTempVar}
/if (!${DoRC}) {
  /echo Auto Radiant Cure is now OFF
} else {
  /echo Auto Radiant Cure is now ON
}
/return

Sub Event_SetRefreshBuffs(string Line)
/varset RDTempVar ${RefreshBuffs}
/call ToggleVar "${Line}"
/varset RefreshBuffs ${RDTempVar}
/ini "${MyIni}" DoBuffStuff RefreshBuffs ${RDTempVar}
/if (!${RefreshBuffs}) {
  /echo Auto Buff Refreshing is now OFF
} else {
  /echo Auto Buff Refreshing is now ON
}
/return

Sub Event_SetReportDebuffs(string Line)
/varset RDTempVar ${ReportDebuffs}
/call ToggleVar "${Line}"
/varset ReportDebuffs ${RDTempVar}
/ini "${MyIni}" DebuffStuff ReportDebuffs ${RDTempVar}
/if (!${ReportDebuffs}) {
  /echo Auto Debuff Reporting is now OFF
} else {
  /echo Auto Debuff Reporting is now ON
}
/return

Sub Event_SetReportDoBuffs(string Line)
/varset RDTempVar ${ReportDoBuffs}
/call ToggleVar "${Line}"
/varset ReportDoBuffs ${RDTempVar}
/ini "${MyIni}" DoBuffStuff ReportDoBuffs ${RDTempVar}
/if (!${ReportDoBuffs}) {
  /echo Auto Do Buff Reporting is now OFF
} else {
  /echo Auto Do Buff Reporting is now ON
}
/return

Sub Event_SetReportDoTs(string Line)
/varset RDTempVar ${ReportDoTs}
/call ToggleVar "${Line}"
/varset ReportDoTs ${RDTempVar}
/ini "${MyIni}" DoTStuff ReportDoTs ${RDTempVar}
/if (!${ReportDoTs}) {
  /echo Auto DoT Reporting is now OFF
} else {
  /echo Auto DoT Reporting is now ON
}
/return

Sub Event_SetReportEpic(string Line)
/varset RDTempVar ${ReportEpic}
/call ToggleVar "${Line}"
/varset ReportEpic ${RDTempVar}
/ini "${MyIni}" GeneralStuff ReportEpic ${RDTempVar}
/if (!${ReportEpic}) {
  /echo Auto Epic Reporting is now OFF
} else {
  /echo Auto Epic Reporting is now ON
}
/return

Sub Event_SetReportHeals(string Line)
/varset RDTempVar ${ReportHeals}
/call ToggleVar "${Line}"
/varset ReportHeals ${RDTempVar}
/ini "${MyIni}" HealStuff ReportHeals ${RDTempVar}
/if (!${ReportHeals}) {
  /echo Auto Heal Reporting is now OFF
} else {
  /echo Auto Heal Reporting is now ON
}
/return

Sub Event_SetReportInterrupts(string Line)
/varset RDTempVar ${ReportInterrupts}
/call ToggleVar "${Line}"
/varset ReportInterrupts ${RDTempVar}
/ini "${MyIni}" HealStuff ReportInterrupts ${RDTempVar}
/if (!${ReportInterrupts}) {
  /echo Auto Interrupt Reporting is now OFF
} else {
  /echo Auto Interrupt Reporting is now ON
}
/return

Sub Event_SetReportMana(string Line)
/varset RDTempVar ${ReportMana}
/call ToggleVar "${Line}"
/varset ReportMana ${RDTempVar}
/ini "${MyIni}" GeneralStuff ReportMana ${RDTempVar}
/if (!${ReportMana}) {
  /echo Auto Mana Reporting is now OFF
} else {
  /echo Auto Mana Reporting is now ON
}
/return

Sub Event_SetReportRC(string Line)
/varset RDTempVar ${ReportRC}
/call ToggleVar "${Line}"
/varset ReportRC ${RDTempVar}
/ini "${MyIni}" HealStuff ReportRC ${RDTempVar}
/if (!${ReportRC}) {
  /echo Auto RC Reporting is now OFF
} else {
  /echo Auto RC Reporting is now ON
}
/return

Sub Event_SetReportSelfBuffs(string Line)
/varset RDTempVar ${ReportSelfBuffs}
/call ToggleVar "${Line}"
/varset ReportSelfBuffs ${RDTempVar}
/ini "${MyIni}" SelfBuffStuff ReportSelfBuffs ${RDTempVar}
/if (!${ReportSelfBuffs}) {
  /echo Auto Self Buff Reporting is now OFF
} else {
  /echo Auto Self Buff Reporting is now ON
}
/return

Sub Event_SetReportSnares(string Line)
/varset RDTempVar ${ReportSnares}
/call ToggleVar "${Line}"
/varset ReportSnares ${RDTempVar}
/ini "${MyIni}" SnareStuff ReportSnares ${RDTempVar}
/if (!${ReportSnares}) {
  /echo Auto Snare Reporting is now OFF
} else {
  /echo Auto Snare Reporting is now ON
}
/return

Sub Event_SetReportSotW(string Line)
/varset RDTempVar ${ReportSotW}
/call ToggleVar "${Line}"
/varset ReportSotW ${RDTempVar}
/ini "${MyIni}" HealStuff ReportSotW ${RDTempVar}
/if (!${ReportSotW}) {
  /echo Auto SotW Reporting is now OFF
} else {
  /echo Auto SotW Reporting is now ON
}
/return

Sub Event_SetReportWoW(string Line)
/varset RDTempVar ${ReportWoW}
/call ToggleVar "${Line}"
/varset ReportWoW ${RDTempVar}
/ini "${MyIni}" GeneralStuff ReportWoW ${RDTempVar}
/if (!${ReportWoW}) {
  /echo Auto WoW Reporting is now OFF
} else {
  /echo Auto WoW Reporting is now ON
}
/return

Sub Event_SetRodMana(string Line)
/varset RDTempVar ${RodMana}
/call ToggleVar "${Line}"
/varset RodMana ${RDTempVar}
/ini "${MyIni}" GeneralStuff RodMana ${RDTempVar}
/if (!${RodMana}) {
  /echo Auto Mod Rod Clicking is now OFF
} else {
  /echo Auto Mod Rod Clicking is now ON
}
/return

Sub Event_SetRootNScoot(string Line)
/varset RDTempVar ${RootNScoot}
/call ToggleVar "${Line}"
/varset RootNScoot ${RDTempVar}
/ini "${MyIni}" RootStuff RootNScoot ${RDTempVar}
/if (!${RootNScoot}) {
  /echo Auto Rooting and Scooting is now OFF
} else {
  /echo Auto Rooting and Scooting is now ON
}
/return

Sub Event_SetSelfBuff(string Line)
/varset RDTempVar ${SelfBuffs}
/call ToggleVar "${Line}"
/varset SelfBuffs ${RDTempVar}
/ini "${MyIni}" SelfBuffStuff SelfBuffs ${RDTempVar}
/if (!${SelfBuffs}) {
  /echo Auto Self Buffing is now OFF
} else {
  /echo Auto Self Buffing is now ON
}
/return

Sub Event_SetSitDelay(string Line)
/if (${Line.Arg[3].Length}) {
  /varset SitDelay ${Line.Arg[3]}
  /ini "${MyIni}" Settings SitDelay ${SitDelay}
}
/echo I will sit after: ${SitDelay}
/return

Sub Event_SetSnare(string Line)
/varset RDTempVar ${DoSnare}
/call ToggleVar "${Line}"
/varset DoSnare ${RDTempVar}
/ini "${MyIni}" SnareStuff DoSnare ${RDTempVar}
/if (!${DoSnare}) {
  /echo Auto Snare is now OFF
} else {
  /echo Auto Snare is now ON
}
/return

Sub Event_SetSnareHPs(string Line)
/if (${Line.Arg[3].Length}) {
  /varset SnareHPs ${Line.Arg[3]}
  /ini "${MyIni}" SnareStuff SnareHPs ${Line.Arg[3]}
}
/echo I will snare the mob at: ${SnareHPs}% HPs
/return

Sub Event_SetSnareRecasts(string Line)
/if (${Line.Arg[3].Length}) {
  /varset SnareRecasts ${Line.Arg[3]}
  /ini "${MyIni}" SnareStuff SnareRecasts ${RDTempVar}
}
/echo I will recast snare for: ${SnareRecasts} resists
/return

Sub Event_SetSotW(string Line)
/varset RDTempVar ${DoSotW}
/call ToggleVar "${Line}"
/varset DoSotW ${RDTempVar}
/ini "${MyIni}" HealStuff DoSotW ${RDTempVar}
/if (!${DoSotW}) {
  /echo Auto Spirit of the Wood is now OFF
} else {
  /echo Auto Spirit of the Wood is now ON
}
/return

Sub Event_SetSotWPct(string Line)
/if (${Line.Arg[3].Length}) {
  /varset SotWPct ${Line.Arg[3]}
  /ini "${MyIni}" HealStuff SotWPct ${Line.Arg[3]}
}
/echo I will use SotW if the group average HPs is less than: ${SotWPct}%
/return

Sub Event_SetSpamDelay(string Line)
/if (${Line.Arg[3].Length}) {
  /varset SpamDelay ${Line.Arg[3]}
  /ini "${MyIni}" GeneralStuff SpamDelay ${SpamDelay}
}
/echo I will wait ${SpamDelay} between chat messages
/return

Sub Event_SetStopHPs(string Line)
/if (${Line.Arg[3].Length}) {
  /varset StopHPs ${Line.Arg[3]}
  /ini "${MyIni}" GeneralStuff StopHPs ${Line.Arg[3]}
}
/echo I stop nuking at: ${StopHPs}% of the mob's HPs
/return

Sub Event_SetTankHealPct(string Line)
/if (${Line.Arg[3].Length}) {
  /varset TankHealPct ${Line.Arg[3]}
  /ini "${MyIni}" HealStuff TankHealPct ${Line.Arg[3]}
}
/echo I will CH the MA if he is less than: ${TankHealPct}%
/return

Sub Event_SetUseCH(string Line)
/varset RDTempVar ${UseCH}
/call ToggleVar "${Line}"
/varset UseCH ${RDTempVar}
/ini "${MyIni}" HealStuff UseCH ${RDTempVar}
/if (!${UseCH}) {
  /echo Auto CHing of MA1 is now OFF
} else {
  /echo Auto CHing of MA1 is now ON
}
/return

Sub Event_SetUseEpic(string Line)
/varset RDTempVar ${UseEpic}
/call ToggleVar "${Line}"
/varset UseEpic ${RDTempVar}
/ini "${MyIni}" GeneralStuff UseEpic ${RDTempVar}
/if (!${UseEpic}) {
  /echo Auto Epic Debuffing is now OFF
} else {
  /echo Auto Epic Debuffing is now ON
}
/return

Sub Event_SetUseMount(string Line)
/varset RDTempVar ${UseMount}
/call ToggleVar "${Line}"
/varset UseMount ${RDTempVar}
/ini "${MyIni}" Settings UseMount ${RDTempVar}
/if (!${UseMount}) {
  /echo Auto Mounting is now OFF
} else {
  /echo Auto Mounting is now ON
}
/return

Sub Event_SetWaitToCancel(string Line)
/varset RDTempVar ${WaitToCancel}
/call ToggleVar "${Line}"
/varset WaitToCancel ${RDTempVar}
/ini "${MyIni}" HealStuff WaitToCancel ${RDTempVar}
/if (!${WaitToCancel}) {
  /echo Waiting to Cancel Heals is now OFF
} else {
  /echo Waiting to Cancel Heals is now ON
}
/return

Sub Event_SetWolf(string Line)
/varset RDTempVar ${DoWolf}
/call ToggleVar "${Line}"
/varset DoWolf ${RDTempVar}
/ini "${MyIni}" Settings DoWolf ${RDTempVar}
/if (!${DoWolf}) {
  /echo Auto Wolf is now OFF
} else {
  /echo Auto Wolf is now ON
}
/return

Sub Event_SetWoW(string Line)
/varset RDTempVar ${DoWoW}
/call ToggleVar "${Line}"
/varset DoWoW ${RDTempVar}
/ini "${MyIni}" GeneralStuff DoWoW ${RDTempVar}
/if (!${DoWoW}) {
  /echo Auto WoW is now OFF
} else {
  /echo Auto WoW is now ON
}
/return

Sub Event_WornOff(Line,SpellName,Dude)
/declare i        int local
/if (!${DoBuffTotal} || !${RefreshBuffs}) /return
/for i 1 to ${DoBuffTotal}
:WaitToRefresh
/call CheckGroup
/if ((!${Outdoors} && !${DoBuffIndoors[${i}]}) || (${Spawn[pc ${Dude}].Distance}>${Spell[${DoBuffID[${i}]}].Range} && ${Spawn[pc ${Dude}].Distance}>${Spell[${DoBuffID[${i}]}].AERange}) || ${SpellName.NotEqual[${DoBuffIcon[${i}]}]} || !${DoBuffRefresh[${i}]}) /goto :NextRefresh
/if (${Me.Moving} || ${Me.Casting.ID} || (${Me.Gem[${SpellName}]} && !${Me.SpellReady[${SpellName}]}) || (${SitTimer} && !${Me.Gem[${SpellName}]} && !${Me.Mount.ID}))  /goto :WaitToRefresh
/varset BuffGuy ${Spawn[pc ${Dude}].ID}
/call TargetGuy
/if (${TargetReturn.Equal[TARGET_SUCCESS]}) {
  /if (${DoBuffGem[${i}].Equal[item]}) {
    /call Cast "${DoBuff[${i}]}" item 1s Check4Pad
  }
  /if (${DoBuffGem[${i}].Equal[alt]} && ${Me.AltAbilityReady[${DoBuff[${i}]}]}) {
    /call Cast "${DoBuff[${i}]}" alt 1s Check4Pad
  }
  /if (${Me.CurrentMana}>${Spell[${DoBuffID[${i}]}].Mana}) {
    /call Cast "${DoBuff[${i}]}" ${DoBuffGem[${i}]} 1s Check4Pad
  }
  /varset SitTimer ${SitDelay}
}
/if (${Spawn[${MATarget}].ID}) /target id ${MATarget}
:NextRefresh
/next i
/return
Last edited by A_Druid_00 on Tue Jun 28, 2005 10:59 pm, edited 59 times in total.
[quote]<DigitalMocking> man, A_Druid_00 really does love those long ass if statements
<dont_know_at_all> i don't use his macro because i'm frightened of it[/quote]
[quote][12:45] <dont_know_at_all> never use a macro when you can really fuck up things with a plugin[/quote]

A_Druid_00
Macro Maker Extraordinaire
Posts: 2378
Joined: Tue Jul 13, 2004 12:45 pm
Location: Rolling on the Lawn Farting

Post by A_Druid_00 » Mon Nov 08, 2004 9:47 pm

Here's the HUD, and a screenshot for it:
Image
RaidDruid HUD

Code: Select all

[RaidDruid] 

SpellCast=   3,550,400,255,255,000,${If[${Me.Casting.ID}>0,${Me.Casting} (${Target.CleanName} ),]}
ItemName=    7,-15,-15,255,255,255,${If[${Cursor.ID},${Cursor},]}
TargetDist=  3,005,040,255,255,255,Target Distance: ${Target.Distance}
HP Regen=    3,005,050,255,000,000,HP Regen: ${Me.HPRegen}
Mana Regen=  3,005,060,000,000,255,Mana Regen: ${Me.ManaRegen}
Tribute=     3,005,070,255,255,255,Tribute Points: ${Me.CurrentFavor}
GroupXP=     3,005,080,255,255,255,LAA XP: ${Float[${Me.PctGroupLeaderExp}]}%
Raid=        3,005,090,180,180,180,Raid Leader: ${Raid.Leader}
Tell=        3,005,100,255,255,255,LastTell: ${MacroQuest.LastTell}
Macro=       3,005,110,255,255,000,Macro: ${Macro.Name}
Leader=      3,005,120,180,180,180,Group Leader: ${GroupLeader.Name}
AA=          3,005,130,255,255,255,~~~~~~ Alt Ability ~~~~~~
MGBAA=       3,005,140,255,255,000,Mass Group Buff - - - -
MGBready=    3,120,140,000,255,000,${If[${String[${Me.AltAbilityReady[Mass Group Buff]}].Equal["TRUE"]},Ready,]}
MGBnotready= 3,120,140,255,000,000,${If[${String[${Me.AltAbilityReady[Mass Group Buff]}].Equal["TRUE"]}, ,Available in ${Me.AltAbilityTimer[Mass Group Buff].TimeHMS}]}
SWAAtext=    3,005,150,255,255,000,Spirit of the Wood  - - -
SWready=     3,120,150,000,255,000,${If[${String[${Me.AltAbilityReady[Spirit of the Wood]}].Equal["TRUE"]},Ready,]}
SWnotready=  3,120,150,255,000,000,${If[${String[${Me.AltAbilityReady[Spirit of the Wood]}].Equal["TRUE"]}, ,Available in ${Me.AltAbilityTimer[Spirit of the Wood].TimeHMS}]}
RCAA=        3,005,160,255,255,000,Radiant Cure - - - - - - -
RCready=     3,120,160,000,255,000,${If[${String[${Me.AltAbilityReady[Radiant Cure]}].Equal["TRUE"]},Ready,]}
RCnotready=  3,120,160,255,000,000,${If[${String[${Me.AltAbilityReady[Radiant Cure]}].Equal["TRUE"]}, ,Available in ${Me.AltAbilityTimer[Radiant Cure].TimeHMS}]}
WWAA=        3,005,170,255,255,000,Wrath of the Wild - - - -
WWready=     3,120,170,000,255,000,${If[${String[${Me.AltAbilityReady[Wrath of the Wild]}].Equal["TRUE"]},Ready,]}
WWnotready=  3,120,170,255,000,000,${If[${String[${Me.AltAbilityReady[Wrath of the Wild]}].Equal["TRUE"]}, ,Available in ${Me.AltAbilityTimer[Wrath of the Wild].TimeHMS}]}
DCAA=        3,005,180,255,255,000,Dire Charm  - - - - - - - -
DCready=     3,120,180,000,255,000,${If[${String[${Me.AltAbilityReady[Dire Charm]}].Equal["TRUE"]},Ready,]}
DCnotready=  3,120,180,255,000,000,${If[${String[${Me.AltAbilityReady[Dire Charm]}].Equal["TRUE"]}, ,Available in ${Me.AltAbilityTimer[Dire Charm].TimeHMS}]}
EXAA=        3,005,190,255,255,000,Exodus - - - - - - - - - - -
EXready=     3,120,190,000,255,000,${If[${String[${Me.AltAbilityReady[Exodus]}].Equal["TRUE"]},Ready,]}
EXnotready=  3,120,190,255,000,000,${If[${String[${Me.AltAbilityReady[Exodus]}].Equal["TRUE"]}, ,Available in ${Me.AltAbilityTimer[Exodus].TimeHMS}]}
nukehud1=    3,005,210,255,000,000,${If[${WhichNuke}==1,Nuke Spell: ${MyNukes[1]},]}
nukehud2=    3,005,210,000,000,255,${If[${WhichNuke}==2,Nuke Spell: ${MyNukes[2]},]}
MA1=         3,005,220,255,255,255,${If[${Macro.Name.Equal["raiddruid.mac"]},Main Assist: ${MA1},]}
MA2=         3,005,230,255,255,255,${If[${Macro.Name.Equal["raiddruid.mac"]},Second Assist: ${MA2},]}
MA3=         3,005,240,255,255,255,${If[${Macro.Name.Equal["raiddruid.mac"]},Third Assist: ${MA3},]}
RampTank=    3,005,250,255,255,255,${If[${Macro.Name.Equal["raiddruid.mac"]},Ramp Tank: ${RampTank},]}
AEHealOn=    3,005,260,000,255,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${AEHeal},AE Healing,]},]}
AEHealOff=   3,005,260,255,000,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${AEHeal},,AE Healing]},]}
AssHealOn=   3,005,270,000,255,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${AssistHeal},Assist Healing,]},]}
AssHealOff=  3,005,270,255,000,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${AssistHeal},,Assist Healing]},]}
AssMAOn=     3,005,280,000,255,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${AssistMA},Assist MA,]},]}
AssMAOff=    3,005,280,255,000,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${AssistMA},,Assist MA]},]}
AutoNinjaOn= 3,005,290,000,255,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${AutoNinja},Auto Ninja,]},]}
AutoNinjaOff=3,005,290,255,000,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${AutoNinja},,Auto Ninja]},]}
AutoSitOn=   3,005,300,000,255,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${AutoSit},Auto Sit,]},]}
AutoSitOff=  3,005,300,255,000,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${AutoSit},,Auto Sit]},]}
DebuffOn=    3,005,310,000,255,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DoDebuffs},Debuffing,]},]}
DebuffOff=   3,005,310,255,000,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DoDebuffs},,Debuffing]},]}
DoTOn=       3,005,320,000,255,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DoDoTs},DoTs,]},]}
DoTOff=      3,005,320,255,000,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DoDoTs},,DoTs]},]}
GHealOn=     3,005,330,000,255,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${HealGroup},Group Healing,]},]}
GHealOff=    3,005,330,255,000,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${HealGroup},,Group Healing]},]}
InterruptOn= 3,005,340,000,255,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${Stop4Pad},Interrupts,]},]}
InterruptOff=3,005,340,255,000,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${Stop4Pad},,Interrupts]},]}
NukeOn=      3,005,350,000,255,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DoNukes},Nukes,]},]}
NukeOff=     3,005,350,255,000,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DoNukes},,Nukes]},]}
RampHealOn=  3,005,360,000,255,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DoRamp},Ramp Healing,]},]}
RampHealOff= 3,005,360,255,000,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DoRamp},,Ramp Healing]},]}
RCOn=        3,005,370,000,255,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DoRC},RC,]},]}
RCOff=       3,005,370,255,000,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DoRC},,RC]},]}
RodsOn=      3,005,380,000,255,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${ClickRods},Rod Clicks,]},]}
RodsOff=     3,005,380,255,000,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${ClickRods},,Rod Clicks]},]}
SelfBuffOn=  3,005,390,000,255,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${SelfBuffs},Self Buff,]},]}
SelfBuffOff= 3,005,390,255,000,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${SelfBuffs},,Self Buff]},]}
SnareOn=     3,005,400,000,255,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DoSnare},Snare,]},]}
SnareOff=    3,005,400,255,000,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DoSnare},,Snare]},]}
SotWOn=      3,005,410,000,255,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DoSotW},SotW,]},]}
SotWOff=     3,005,410,255,000,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DoSotW},,SotW]},]}
UseEpicOn=   3,005,420,000,255,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${UseEpic},Use Epic,]},]}
UseEpicOff=  3,005,420,255,000,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${UseEpic},,Use Epic]},]}
UseMountOn=  3,005,430,000,255,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${UseMount},Use Mount,]},]}
UseMountOff= 3,005,430,255,000,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${UseMount},,Use Mount]},]}
WolfOn=      3,005,440,000,255,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DoWolf},Wolf,]},]}
WolfOff=     3,005,440,255,000,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DoWolf},,Wolf]},]}
WoWOn=       3,005,450,000,255,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DoWoW},WoW,]},]}
WoWOff=      3,005,450,255,000,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DoWoW},,WoW]},]}
CancelPct=   3,005,460,255,255,255,${If[${Macro.Name.Equal["raiddruid.mac"]},Cancel Heals: ${CancelPct}% HPs,]}
HealAtPct=   3,005,470,255,255,255,${If[${Macro.Name.Equal["raiddruid.mac"]},Heal At: ${HealPct}% HPs,]}
SotWPct=     3,005,480,255,255,255,${If[${Macro.Name.Equal["raiddruid.mac"]},SotW At: ${SotWPct}% average HPs,]}
MedAtPct=    3,005,490,255,255,255,${If[${Macro.Name.Equal["raiddruid.mac"]},Sit to Med Pct: ${MedPct}% Mana,]}
SitDelay=    3,005,500,255,255,255,${If[${Macro.Name.Equal["raiddruid.mac"]},Delay Before Sitting: ${SitDelay},]}
RodMana=     3,005,510,255,255,255,${If[${Macro.Name.Equal["raiddruid.mac"]},Eat Rods At: ${RodMana}% Mana,]}
StopPct=     3,005,520,255,255,255,${If[${Macro.Name.Equal["raiddruid.mac"]},Stop to Med Pct: ${NukePctMana}% Mana,]}
EngagePct=   3,005,530,255,255,255,${If[${Macro.Name.Equal["raiddruid.mac"]},Engage Pct: ${EngageHPs}% HPs,]}
DoTMinPct=   3,005,540,255,255,255,${If[${Macro.Name.Equal["raiddruid.mac"]},Stop DoTs At: ${DoTMinHPs}% HPs,]}
StopAtPct=   3,005,550,255,255,255,${If[${Macro.Name.Equal["raiddruid.mac"]},Stop Nukes at Pct: ${StopHPs}% HPs,]}
DAList=      3,005,560,255,255,255,${If[${Macro.Name.Equal["raiddruid.mac"]},~~~~~~ DA List ~~~~~~,]}
G1DAOn=      3,005,570,000,255,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DAArray[1,2]},${Group.Member[0].CleanName} DA at ${DAArray[1,1]}% HPs,]},]}
G1DAOff=     3,005,570,255,000,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DAArray[1,2]},,${Group.Member[0].CleanName}]},]}
G2DAOn=      3,005,580,000,255,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DAArray[2,2]},${Group.Member[1].CleanName} DA at ${DAArray[2,1]}% HPs,]},]}
G2DAOff=     3,005,580,255,000,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DAArray[2,2]},,${Group.Member[1].CleanName}]},]}
G3DAOn=      3,005,590,000,255,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DAArray[3,2]},${Group.Member[2].CleanName} DA at ${DAArray[3,1]}% HPs,]},]}
G3DAOff=     3,005,590,255,000,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DAArray[3,2]},,${Group.Member[2].CleanName}]},]}
G4DAOn=      3,005,600,000,255,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DAArray[4,2]},${Group.Member[3].CleanName} DA at ${DAArray[4,1]}% HPs,]},]}
G4DAOff=     3,005,600,255,000,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DAArray[4,2]},,${Group.Member[3].CleanName}]},]}
G5DAOn=      3,005,610,000,255,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DAArray[5,2]},${Group.Member[4].CleanName} DA at ${DAArray[5,1]}% HPs,]},]}
G5DAOff=     3,005,610,255,000,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DAArray[5,2]},,${Group.Member[4].CleanName}]},]}
G6DAOn=      3,005,620,000,255,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DAArray[6,2]},${Group.Member[5].CleanName} DA at ${DAArray[6,1]}% HPs,]},]}
G6DAOff=     3,005,620,255,000,000,${If[${Macro.Name.Equal["raiddruid.mac"]},${If[${DAArray[6,2]},,${Group.Member[5].CleanName}]},]}
BuffBegOn=     3,150,000,000,255,000,${If[${DoBuffBeg},Buff Begging,]}
BuffbegOff=    3,150,000,255,000,000,${If[${DoBuffBeg},,Buff Begging]}
AoRBegOn=      3,150,010,000,255,000,${If[${AoRBeg},AoR,]}
AoRBegOff=     3,150,010,255,000,000,${If[${AoRBeg},,AoR]}
BSSBegOn=      3,150,020,000,255,000,${If[${BSSBeg},BSS,]}
BSSBegOff=     3,150,020,255,000,000,${If[${BSSBeg},,BSS]}
DSBegOn=       3,150,030,000,255,000,${If[${DSBeg},DS,]}
DSBegOff=      3,150,030,255,000,000,${If[${DSBeg},,DS]}
GoDBegOn=      3,150,040,000,255,000,${If[${GoDBeg},GoD,]}
GoDBegOff=     3,150,040,255,000,000,${If[${GoDBeg},,GoD]}
OakBegOn=      3,150,050,000,255,000,${If[${OakBeg},Oak,]}
OakBegOff=     3,150,050,255,000,000,${If[${OakBeg},,Oak]}
SDBegOn=       3,150,060,000,255,000,${If[${SDBeg},SD,]}
SDBegOff=      3,150,060,255,000,000,${If[${SDBeg},,SD]}
SoEBegOn=      3,150,070,000,255,000,${If[${SoEBeg},SoE,]}
SoEBegOff=     3,150,070,255,000,000,${If[${SoEBeg},,SoE]}
SoTBegOn=      3,150,080,000,255,000,${If[${SoTBeg},SoT,]}
SoTBegOff=     3,150,080,255,000,000,${If[${SoTBeg},,SoT]}
SVBegOn=       3,150,090,000,255,000,${If[${SVBeg},SV,]}
SVBegOff=      3,150,090,255,000,000,${If[${SVBeg},,SV]}
SymBegOn=      3,150,100,000,255,000,${If[${SymBeg},Symbol,]}
SymBegOff=     3,150,100,255,000,000,${If[${SymBeg},,Symbol]}
VirtBegOn=     3,150,110,000,255,000,${If[${VirtBeg},Virtue,]}
VirtBegOff=    3,150,110,255,000,000,${If[${VirtBeg},,Virtue]}
VoQBegOn=      3,150,120,000,255,000,${If[${VoQBeg},VoQ,]}
VoQBegOff=     3,150,120,255,000,000,${If[${VoQBeg},,VoQ]}
AvatarBegOn=   3,190,010,000,255,000,${If[${AvatarBeg},Avatar,]}
AvatarBegOff=  3,190,010,255,000,000,${If[${AvatarBeg},,Avatar]}
FerocityBegOn= 3,190,020,000,255,000,${If[${FerocityBeg},Ferocity,]}
FerocityBegOff=3,190,020,255,000,000,${If[${FerocityBeg},,Ferocity]}
FocusBegOn=    3,190,030,000,255,000,${If[${FocusBeg},Focus,]}
FocusBegOff=   3,190,030,255,000,000,${If[${FocusBeg},,Focus]}
FortBegOn=     3,190,040,000,255,000,${If[${FortBeg},Fortitude,]}
FortBegOff=    3,190,040,255,000,000,${If[${FortBeg},,Fortitude]}
HasteBegOn=    3,190,050,000,255,000,${If[${HasteBeg},Haste,]}
HasteBegOff=   3,190,050,255,000,000,${If[${HasteBeg},,Haste]}
LionBegOn=     3,190,060,000,255,000,${If[${LionBeg},Lion,]}
LionBegOff=    3,190,060,255,000,000,${If[${LionBeg},,Lion]}
MightBegOn=    3,190,070,000,255,000,${If[${MightBeg},Might,]}
MightBegOff=   3,190,070,255,000,000,${If[${MightBeg},,Might]}
RegenBegOn=    3,190,080,000,255,000,${If[${RegenBeg},Regen,]}
RegenBegOff=   3,190,080,255,000,000,${If[${RegenBeg},,Regen]}
RodBegOn=      3,190,090,000,255,000,${If[${RodBeg},Mod Rods,]}
RodBegOff=     3,190,090,255,000,000,${If[${RodBeg},,Mod Rods]}
SeasonBegOn=   3,190,100,000,255,000,${If[${SeasonBeg},Season,]}
SeasonBegOff=  3,190,100,255,000,000,${If[${SeasonBeg},,Season]}
SenseBegOn=    3,190,110,000,255,000,${If[${SenseBeg},Sense,]}
SenseBegOff=   3,190,110,255,000,000,${If[${SenseBeg},,Sense]}
TalismanBegOn= 3,190,120,000,255,000,${If[${TalismanBeg},Talisman,]}
TalismanBegOff=3,190,120,255,000,000,${If[${TalismanBeg},,Talisman]}
Last edited by A_Druid_00 on Mon Jun 27, 2005 10:00 pm, edited 18 times in total.
[quote]<DigitalMocking> man, A_Druid_00 really does love those long ass if statements
<dont_know_at_all> i don't use his macro because i'm frightened of it[/quote]
[quote][12:45] <dont_know_at_all> never use a macro when you can really fuck up things with a plugin[/quote]

A_Druid_00
Macro Maker Extraordinaire
Posts: 2378
Joined: Tue Jul 13, 2004 12:45 pm
Location: Rolling on the Lawn Farting

Sample Ini file:

Post by A_Druid_00 » Mon Nov 08, 2004 9:48 pm

Code: Select all

[Settings]
RDPause=1
NPCRadius=200
NPCZRadius=100
PCRadius=200
PCZRadius=100
AutoNinja=1
AutoSit=1
SitDelay=3s
UseMount=1
MountItem=Black Rope Bridle
ClickRods=1
MedPct=50
OVHPs=70
RodMana=80
DoWolf=0
[GeneralStuff]
ChatChannel=gsay
ReportMana=1
ColdSpellSet=Cold
FireSpellSet=Fire
AssistMA=1
MA1=JoMomma
MA2=JoDaddy
MA3=JoBaldHeadedGranny
DoWoW=1
ReportWoW=0
EngageHPs=98
StopHPs=10
StopNukingMana=50
UseEpic=1
ReportEpic=1
SpamDelay=1s
[HealStuff]
ReportHeals=1
ReportInterrupts=1
GroupHealing=1
CheckGroupInterval=1s
AutoInterrupt=1
RampHealing=1
RampTank=JoSomething
AEHealing=1
AssistHealing=0
HealPct=50
HealFD=0
CancelPct=90
WaitToCancel=1
FastHeal=Chlorotrope
FastHealGem=gem2
UseCH=0
TankHealPct=50
TankHeal=Karana's Renewal
TankHealGem=gem1
SotWAA=Spirit of the Grove
DoSotW=0
ReportSotW=1
SotWPct=80
RCAA=Resplendent Cure
DoRC=1
ReportRC=1
RCDebuffs=Hand of Ro|Swarming Death|Black Plague|Deathly Chants|Planeshift|Torrent of Agony|Wind of Tashanian|Phantasmal Torment|Quivering Nightmares|Tallon's Balance|Vallon's Precision|Horrifying Affliction|Aura of Fear|Dragornian Malady|Chaos Claws|Destructive Will|Afterthoughts of Anger|Pyrilen Fury|Discordant Feedback|Chaos Affliction|Cloud of Attrition|Energy Siphon|Unholy Aura|Imprecision|Curse of Misfortune|Sleetstorm|Dark Inferno|
[SelfBuffStuff]
SelfBuffs=1
ReportSelfBuffs=0
SelfBuffRecheck=10s
SelfBuffTotal=9
SelfBuff1=Band of Primordial Energy
SelfBuffIcon1=Form of Defense
SelfBuffGem1=item
SelfBuffIndoors1=1
SelfBuffBlock1=Resurrection Effects
SelfBuffCount1=14
SelfBuff2=Shawl of Eternal Forces
SelfBuffIcon2=Maelin's Methodical Mind
SelfBuffGem2=item
SelfBuffIndoors2=1
SelfBuffBlock2=None
SelfBuffCount2=18
SelfBuff3=Nettle Shield
SelfBuffIcon3=Nettle Shield
SelfBuffGem3=gem3
SelfBuffIndoors3=1
SelfBuffBlock3=None
SelfBuffCount3=11
SelfBuff4=Blessing of Oak
SelfBuffIcon4=Blessing of Oak
SelfBuffGem4=gem3
SelfBuffIndoors4=1
SelfBuffBlock4=Talisman of Perseverance
SelfBuffCount4=13
SelfBuff5=Brackencoat
SelfBuffIcon5=Brackencoat
SelfBuffGem5=gem3
SelfBuffIndoors5=1
SelfBuffBlock5=None
SelfBuffCount5=12
SelfBuff6=Mask of the Forest
SelfBuffIcon6=Mask of the Forest
SelfBuffGem6=gem3
SelfBuffIndoors6=1
SelfBuffBlock6=Poisoned Flames|Withering Destruction
SelfBuffCount6=16
SelfBuff7=Steeloak Skin
SelfBuffIcon7=Steeloak Skin
SelfBuffGem7=gem3
SelfBuffIndoors7=1
SelfBuffBlock7=Cataclysm of Ro|Blessing of Steeloak
SelfBuffCount7=17
SelfBuff8=Protection of Seasons
SelfBuffIcon8=Protection of Seasons
SelfBuffGem8=gem3
SelfBuffIndoors8=1
SelfBuffBlock8=Mala
SelfBuffCount8=15
SelfBuff9=Spirit of Eagle
SelfBuffIcon9=Spirit of Eagle
SelfBuffGem9=gem3
SelfBuffIndoors9=0
SelfBuffBlock9=Flight of Eagles|Form of the Hunter
SelfBuffCount9=19
SelfBuff10=Self Buff Item/Spell #10
SelfBuffIcon10=None
SelfBuffGem10=None
SelfBuffIndoors10=1
SelfBuffBlock10=None
SelfBuffCount10=15
[DoBuffStuff]
DoBuffs=1
ReportDoBuffs=1
DoBuffTotal=10
DoBuff1=Woven Grass Boots
DoBuffGem1=item
DoBuffIcon1=Spirit of Wolf
DoBuffIndoors1=0
DoBuffAliases1=SoW|Spirit|
DoBuff2=Steeloak Skin
DoBuffGem2=gem3
DoBuffIcon2=Steeloak Skin
DoBuffIndoors2=1
DoBuffAliases2=Oak|9|nine|Steel|Skin|
DoBuff3=Protection of Seasons
DoBuffGem3=gem3
DoBuffIcon3=Protection of Seasons
DoBuffIndoors3=1
DoBuffAliases3=seasons|cos|pos|
DoBuff4=Blessing of Oak
DoBuffGem4=gem3
DoBuffIcon4=Blessing of Oak
DoBuffIndoors4=1
DoBuffAliases4=regen|boa|bor|
DoBuff5=Nettle Shield
DoBuffGem5=gem3
DoBuffIcon5=Nettle Shield
DoBuffIndoors5=1
DoBuffAliases5=DS|thorns|damage|
DoBuff6=Circle of Summer
DoBuffGem6=gem3
DoBuffIcon6=Circle of Summer
DoBuffIndoors6=1
DoBuffAliases6=summer|circle|
DoBuff7=Spirit of Eagle
DoBuffGem7=gem3
DoBuffIcon7=Spirit of Eagle
DoBuffIndoors7=0
DoBuffAliases7=soe|eagle|
DoBuff8=Lion's Strength
DoBuffGem8=gem3
DoBuffIcon8=Nature's Might
DoBuffIndoors8=1
DoBuffAliases8=str|lion|
DoBuff9=Pure Blood
DoBuffGem9=gem3
DoBuffIcon9=Pure Blood
DoBuffIndoors9=1
DoBuffAliases9=pb|poison|disease|pure|
DoBuff10=Remove Greater Curse
DoBuffGem10=gem3
DoBuffIcon10=Remove Greater Curse
DoBuffIndoors10=1
DoBuffAliases10=grc|rgc|curse|
[DebuffStuff]
DoDebuffs=1
ReportDebuffs=1
DebuffHPs=98
DebuffRecasts=3
DebuffTotal=3
Debuff1=Hand of Ro
DebuffIcon1=Hand of Ro
DebuffGem1=gem5
DebuffSpellSet1=1
Debuff2=Sun's Corona
DebuffIcon2=Sun's Corona
DebuffGem2=gem6
DebuffSpellSet2=1
Debuff3=Glacier Breath
DebuffIcon3=Glacier Breath
DebuffGem3=gem5
DebuffSpellSet3=2
Debuff4=None
DebuffIcon4=None
DebuffGem4=None
DebuffSpellSet4=0
Debuff5=None
DebuffIcon5=None
DebuffGem5=None
DebuffSpellSet5=0
[DoTStuff]
DoDoTs=1
ReportDoTs=1
DoTHPs=95
DoTRecasts=2
DoTTotal=3
StopDoTing=30
DoT1=Immolation of the Sun
DoTIcon1=Immolation of the Sun
DoTGem1=gem3
DoTSpellSet1=1
DoT2=Orb of Clinging Death
DoTIcon2=Swarming Death
DoTGem2=item
DoTSpellSet2=0
DoT3=Nature Walkers Scimitar
DoTIcon3=Wrath of Nature
DoTGem3=item
DoTSpellSet3=0
DoT4=None
DoTIcon4=None
DoTGem4=None
DoTSpellSet4=0
DoT5=None
DoTIcon5=None
DoTGem5=None
DoTSpellSet5=0
[NukeStuff]
DoNukes=1
NukeHPs=90
NukeDelay=0
NukeGem=gem7
ColdNuke=Winter's Frost
WhichNuke=1
FireNuke=Solstice Strike
[SnareStuff]
DoSnare=0
ReportSnares=1
SnareHPs=50
SnareRecasts=5
SnareGem=gem8
SnareSpell=Ensnare
Last edited by A_Druid_00 on Fri Jan 14, 2005 9:51 pm, edited 14 times in total.
[quote]<DigitalMocking> man, A_Druid_00 really does love those long ass if statements
<dont_know_at_all> i don't use his macro because i'm frightened of it[/quote]
[quote][12:45] <dont_know_at_all> never use a macro when you can really fuck up things with a plugin[/quote]

A_Druid_00
Macro Maker Extraordinaire
Posts: 2378
Joined: Tue Jul 13, 2004 12:45 pm
Location: Rolling on the Lawn Farting

Post by A_Druid_00 » Mon Nov 08, 2004 9:49 pm

Here's an HTML version put together by fallon. Many thanks to him for taking some of the upkeep for this monster out of my hands.

>>>>> Fallon's RaidDruidDoc <<<<<

Code: Select all

RaidDruid documentation
RaidDruidDoc.txt v5.3
by: A_Druid_00
updates by: Fallon

Welcome to the complete druid raiding package created and maintained by A_Druid_00. First, let me preface this by saying that this macro was originally conceived due to the fact that there was nothing that fit my play style as a druid available here when I made this macro. The generic bot macros were good for a time; but as I ended up learning more and more about macros, I realized that there were a number of things that could stand to be improved on and more functionality could be added. Upon realizing this fact, I decided to take a crack at making my very first macro, which at the time was a combination of Neolesh's AEHeal macro and some other basic functionality such as self buffing and responding to buff requests. With a bit of help from Cr4zyb4rd, I started adding and improving on my basic functionality to the point that I had a pretty respectable mac to handle AE healing and Assist healing on raids, thereby taking a lot of the general tedium out of raiding that had gotten old to me a long time ago. At that point I thought to myself, 'Why stop there? You can easily carry this over into a lot of your other druidly routines.'

And so RaidDruid was born. At first it was very tailored to me, the spells and items I have, and the way I played. I found this to be unsatisfactory, as if I was going to be sharing this with the rest of the MQ2 community, it would have to be easily customizable to our less than proficient macro users. So, I slowly moved all of the originally declared variables into an ini file, which is easily tailored to whoever happens to be using this mac. With this doc, I hope to impart upon its readers a decent understanding of every function of RaidDruid, and what each command is used for. This is very much not an AFK macro, as I never intended it to be as such, but what it does do is free you up to spend more time chatting instead of frantically mashing keys and opening bags/clicking items in order to keep your myriad self buffs, AAs, and other druidly duties used to their fullest extent. It also makes it easier for you to bot other classes in the event you need to fill gaps in your group; as I often do with tanks, slowers, clerics, and sometimes even other DPS classes. It wouldn't be hard to move this from its current for to a full blown afk macro, but I'd prefer not to.

Other required components
spell_routines.inc 
buffbeg.inc 
feedme.inc 
wait4rez.inc 

HUD
The HUD code goes into the MQ2HUD.ini file in the root of your MQ2 directory (not the macros directory). If the file doesn't exist, it needs to be created.

RaidDruid commands
First off, I am going to go through every alias available in RD, and give an explanation of what each of them does, to the best of my ability. After that, I will go through each ini entry and explain them as well.

Aliases (Each toggle alias works by itself, or will take an argument of ON/OFF, TRUE/FALSE, or 1/0):

Genaral
/rdpause - Toggles pausing of all active RD functions such as Assists Healing, AE Healing, Assisting the MA, etc. Basically puts anything that actively targets anybody but your current target on hold.
/assistma - Toggles assisting of your designated MA1, MA2, and MA3. Turning this off essentially disables Nuking, DoTing, and Debuffing
/autoninja - Toggles auto looting of the nearest corpse after each XP gained message. Will only loot droppable items. Must have the MQ2MoveUtils plugin for this to work.
/autosit - Toggles auto sitting to med. Not much to say here.
/clickrods - Toggles auto clicking of Mage Rods. Not much to say about this one either
/engagehps - Sets the % of the mobs HPs you want to start debuffing/dotting/nuking (Ex. /engagehps 95)
/interrupt - Toggles interrupting debuffs/nukes/dots to heal groupmembers. Some people like to just let their groupmembers die instead of ducking a nuke to heal them.. this is for those people!
/ma1 - Assigns a PC as Main Assist 1. (Ex. /ma1 BoDuke)
/ma2 - Assigns a PC as Main Assist 2. (Ex. /ma2 LukeDuke)
/ma3 - Assigns a PC as Main Assist 3. (Ex. /ma3 DaisyDuke)
/stophps - Sets the % of the mob's HPs you want to stop nuking and debuffing. (Ex. /stophps 10)
/rodmana - Sets the % of mana you want to start clicking Mage Rods at. (Ex. /rodmana 80)
/sitdelay - Sets the amount of time you want to wait before sitting after casting any spell that might be considered aggro. (Ex. /sitdelay 5s)
/medpct - Sets the % of Mana you want to sit or summon your horse at. (Ex. /medpct 50)
/npcradius - Sets the Radius (in feet) around you that you want to watch NPCs using Assist healing and Assisting the MA (Ex. /npcradius 200)
/npczradius - Sets the Radius (in feet) above/below you that you want to watch NPCs using Assist healing and Assisting the MA (Ex. /npczradius 200)
/ovhps - Sets the % of HPs you want to cast Oaken Guard at. Find a delicate balance here based on your total HPs and the amount of damage the mobs you're fighting put out. (Ex. /ovhps 70)
/feedme – Toggles on and off force feeding of non-stat food (related to feedme.inc & feedme.ini)

Healing
/usech - Toggles using your Cheal spell on MA1 on or off. It will monitor the tank's HPs and if he's taking enough damage to be dead in less than 20 seconds, it will duck out of whatever RD is currently doing and start a CH. If the tank's HPs stop falling and level off above the TankHealPct, it will cancel CH and wait until the tank's HPs fall again. 
/TankHealPct – Sets the % you start Chealing. Due to some predictive logic the Cheal may start earlier. Set this to the abslute floor you want to start CH at. 
/aeheal - Toggles on AE Healing. This creates an array of every PC within PCRadius, and cycles through every one of them, checking their HPs against your defined HealPct, and casts heals if appropriate. Super handy on mobs with AE Rampage or AE Damage effects.
/assistheal - Toggles on Assist Healing. This creates an array of every NPC within NPCRadius, and assists them to find the target of their aggression, and heals that target if necessary. Super handy for general clearing on raids before getting to named. Also causes target to constantly ping-pong wildly all over the place trying to find a target to heal
/cancelpct - Set this to the percentage of HPs you want RaidDruid to cancel heals at. (Ex. /cancelpct 90)
/healgroup - Toggles healing of your group. With this on, it will heal groupmembers that are below HealPct
/healpct - Sets the % of HPs you want to heal other PCs at. (ex. /healpct 70)
/healramp - Toggles automatic healing of your Rampage tank anytime a RAMPAGE message is detected.
/ramptank - Sets the Rampage Tank that you check whenever a RAMPAGE message is seen with /healramp on. (Ex. /ramptank UncleJesse)
/sotw - Toggle auto casting of Spirit of the Wood
/sotwpct - Set this to the average group HP percentage you want it to auto cast Spirit of the Wood at. (Ex. /sotwpct 75)
/rc - Toggles Auto Radiant Cure
/pcradius - Sets the Radius (in feet) around you that you want to watch PC HPs using AE healing (Ex. /pcradius 200)
/pczradius - Sets the Radius (in feet) above and below you that you want to watch PC HPs using AE healing (Ex. /pczradius 50)
/waittocancel – Toggle. When turned on, this will wait until your heals have less than .5 seconds left before making the decison to cancel the heal.

Buffing

/buffbeg – Toggles on/off groveling of the nearby appropiate class for their buffs (associated with BuffBeg.inc & BB_charname.ini)
/dobuffs - Toggles automatic replying to buff requests made via /tell
/selfbuff - Toggles Self Buffing. Useful if you happen to be in an environment where having all your self buffs up puts you over the limit
/checkgroup - Sets the number of seconds you'd like to wait between HP evaluations 
/wow - Toggles automatic casting of Wrath of the Wild on your designated MA. I figure an extra 650 damage every 4 minutes cant hurt, since its mana free and all.

Nuking

/nuke - Toggles Auto Nuking the MA's target.
/nukehps – Seth the HP % on when to start nuking.
/nukepctmana - Sets the % of mana you want to stop nuking/debuffing at. (ex. /nukepctmana 50)
/NukeDelay – Sets the delay between chain nuking. If your tank sucks, or are in a kite group rais this delay to prevent agro.

Create a custom hotkey with the following code to toggle between fire and ice nukes:
/custombind add NukeToggle 
/custombind set /varset WhichNuke ${If[${WhichNuke}==1,2,1]} 
/bind WhichNuke ctrl space 

Dotting

/dot - Toggle Auto DoTing of mobs
/dothps – Sets the HP % on when to start dotting
/dotpct - Sets the % of the mob's HPs you want to stop recasting DoTs. (Ex. /dotpct 50)
/dotrecast - Sets the number of resists it will recast each dot for. (Ex. /dotrecast 5)
/usemount - Toggles automatic mount summoning at your /medpct, if this is off and /autosit is on, it will sit to med instead of summoning a mount.

Debuffing

/debuff - Toggles Auto debuffing. Pretty much all there is to say about that
/debuffhps – Sets the HP % to start debuffing at
/debuffrecast - Sets the number of resists it will recast each debuff for. (Ex. /debuffrecast 5)
/useepic - Toggles automatic clicking of Epic 1.5 on named NPCs. Will not cast on normal NPCs unless you modify the macro.

Snare

/snare - Toggles Auto Snaring of your MA's target.
/snarehps – Sets the HP % to start casting snares at.
/snarerecast - Toggles the number of times you recast snare upon being resisted (Ex. /snarerecast 3)





Ini Entries:
.ini files will be automatically created and populated with default values if they do not exist.

BB_charactername.ini

Any entry with a 1 will cause your character to start groveling to the nearest appropiate class (under 100 range from you) for the buff when yours is about to fade. If turned on for druid buffs, you'll start getting weird talking to yourself messages. This has nothing to to with you automatically handing out buffs when receiving tells.

[Settings]
RDPause=1 (Set by /rdpause, 0=paused and 1=active)
NPCRadius=200 (Set by /npcradius)
NPCZRadius=50 (Set by /npczradius)
PCRadius=200 (Set by /pcradius)
PCZRadius=50 (Set by /pczradius)
AutoSit=1 (Set by /autosit, 0=off and 1=on)
ClickRods=1 (Set by /clickrods, 0=off and 1=on)
MedPct=50 (Set by /medpct)
OVHPs=70 (Set by /ovhps)
DoWolf=0 (Set by /wolf, 0=off and 1=on)
SitDelay=5s (Set by /sitdelay)
RodMana=80 (Set by /rodmana)
UseMount=1 (Set by /usemount, 0=off and 1=on)
MountItem=Black Rope Bridle (This is the item you use to summon your mount)
AutoNinja=0 (Set by /autoninja, 0=off and 1=on)

[GeneralStuff]
AssistMA=1 (Set by /assistma, 0=off and 1=on)
MA1=HappyGilmore (Set by /ma1)
MA2=BillyMadison (Set by /ma2)
MA3=MrDeeds (Set by /ma2)
EngageHPs=95 (Set by /engagehps)
DoWoW=1 (Set by /wow, 0=off and 1=on)
StopNukingMana=20 (Set by /nukepctmana)
StopHPs=20 (Set by /stophps)
ColdSpellSet=Cold (This is the spell set you use to mem cold spells)
FireSpellSet=Fire (This is the spell set you use to mem fire spells)
UseEpic=1 (Set by /useepic, 0=off and 1=on)

[HealStuff]
GroupHealing=1 (Set by /healgroup, 0=off and 1=on)
AutoInterrupt=1 (Set by /interrupt, 0=off and 1=on)
RampHealing=0 (Set by /healramp, 0=off and 1=on)
RampTank=BigDaddy (Set by /ramptank)
AEHealing=0 (Set by /aeheal, 0=off and 1=on)
AssistHealing=0 (Set by /assistheal, 0=off and 1=on)
HealPct=30 (Set by /healpct)
CancelPct=90 (Set by /cancelpct)
FastHeal=Chlorotrope (This is your fast healing spell)
FastHealGem=gem2 (This is the gem you cast your Fast Heal from if it's not memmed already
TankHealPct=70 (This is the % you heal tank classes at, which is not yet implemented, so feel free to ignore it)
SotWAA=Spirit of the Grove (This is the ACtual Alt ability you have, set it to whichever one you have)
DoSotW=1 (Set by /sotw, 0=off and 1=on)
SotWPct=80 (Set by /sotwpct)
RCAA=Resplendent Cure (Change this to whatever RC you have)
DoRC=1 (Set by /rc)
RCDebuffs=Hand of Ro|Swarming Death|Black Plague|Deathly Chants|Planeshift|Torrent of Agony| (Add all known debuffs that your RC cures)
HealFD=0 (set by /healFD, 1 only heals FD classes while FD, 0 heals normally).
CheckGroupInterval=3 (Set by /checkgroup, and sets how often you check group HP levels for healing)
TankHeal=Karana's Renewal (Heal spell to use on the tank... usually your Cheal)
TankHealGem=gem8 (spell slot for your tank heal spell)
CheckGroupInterval=3s (delay for checking when to heal the group, to avoid performance issues)
UseCH=1 (Use Chealing... or not, 1 for on, 0 for not)

[SelfBuffStuff]
SelfBuffs=1 (Set by /selfbuff, 0=off and 1=on)
SelfBuffRecheck=10s (Sets how often you check to see if your self buffs are going to fade)
SelfBuffTotal=9 (Put your total number of self buffs here)

SelfBuff1=Shrunken Goblin Skull Earring (This is the name of the item or spell you use for self buff 1)
SelfBuffIcon1=Grim Aura (This is the name of self buff 1 as it shows up in your buff window)
SelfBuffGem1=item (This is the gem you cast self buff 1 from, if it's an item put item, if it's an AA put alt)
SelfBuffIndoors1=1 (This denotes whether self buff 1 is outdoors only or indoors/outdoors, 0=outdoor only, 1=indoors/outdoors)
SelfBuffBlock1=Resurrection Effects (This is the list of effects which block your self buff, separate them with a |)

[DoBuffStuff]
DoBuffs=1 (Set by /dobuffs, 0=off and 1=on)
DoBuffTotal=10 (Put the total number of DoBuff entries you have here)
DoBuff1=Woven Grass Boots (Put the name of the item, aa, or spell you cast this buff with here)
DoBuffGem1=item (This is the gem you cast dobuff 1 from, if it's an item put item, if it's an AA put alt)
DoBuffIcon1=Spirit of Wolf (This is the name of dobuff 1 as it would show up in your buff window)
DoBuffIndoors1=0 (This denotes whether dobuff 1 is outdoors only or indoors/outdoors, 0=outdoor only, 1=indoors/outdoors)
DoBuffAliases1=SoW|Spirit| (This is the string of different buff messages you want the druid bot to respond to, separated by the |. Make sure to have a | for each buff, as it needs to count them to find out how many buff request strings to check for.)

[DebuffStuff]
DoDebuffs=1 (Set by /debuff, 0=off and 1=on)
DebuffRecasts=3 (Set by /debuffrecast)
DebuffTotal=3 (Put the total number of Debuff entries you have here)
Debuff1=Hand of Ro (Put the name of the item, aa, or spell you cast this debuff with here)
DebuffIcon1=Hand of Ro (This is the name of debuff 1 as it would show up in your buff window)
DebuffGem1=gem5 (This is the gem you cast debuff 1 from, if it's an item put item, if it's an AA put alt)
DebuffSpellSet1=1 (This is the spell set you want to cast this debuff with. 0=both, 1=fire, and 2=cold.)

[DoTStuff]
DoDoTs=1 (Set by /dot, 0=off and 1=on)
StopDoTing=50 (Set by /dotpcthps)
DoTRecasts=2 (Set by /dotrecast)
DoTTotal=3 (Put the total number of DoT entries you have here)
DoT1=Sylvan Embers (Put the name of the item, aa, or spell you cast this dot with here)
DoTIcon1=Sylvan Embers (This is the name of dot 1 as it would show up in your buff window)
DoTGem1=gem3 (This is the gem you cast dot 1 from, if it's an item put item, if it's an AA put alt)
DoTSpellSet1=1 (This is the spell set you want to cast this dot with. 0=both, 1=fire, and 2=cold.)

[NukeStuff]
DoNukes=1 (Set by /nuke, 0=off and 1=on)
ColdNuke=Winter's Frost (This is the name of your cold nuke spell)
FireNuke=Sylvan Fire (This is the name of your fire nuke spell)
NukeGem=gem7 (This is the gem you cast your fire nuke from)
WhichNuke=1 (sets which nuke to use 1=fire, 2=cold)
NukeDelay =1 (Sets the delay in re-casting nukes, usefull when you have sucky tanks with low agro)

[SnareStuff]
DoSnare=1 (Set by /snare, 0=off and 1=on)
SnareSpell=Ensnare (This is the name of your snare spell)
SnareGem=gem8 (This is the gem you cast your snare from)
SnareRecasts=5 (Set by /snarerecast)
Last edited by A_Druid_00 on Thu Jan 13, 2005 4:16 pm, edited 18 times in total.
[quote]<DigitalMocking> man, A_Druid_00 really does love those long ass if statements
<dont_know_at_all> i don't use his macro because i'm frightened of it[/quote]
[quote][12:45] <dont_know_at_all> never use a macro when you can really fuck up things with a plugin[/quote]

A_Druid_00
Macro Maker Extraordinaire
Posts: 2378
Joined: Tue Jul 13, 2004 12:45 pm
Location: Rolling on the Lawn Farting

Post by A_Druid_00 » Mon Nov 08, 2004 9:50 pm

This sure doesn't look like ROFL to me
Image
Last edited by A_Druid_00 on Sat Nov 20, 2004 2:51 am, edited 8 times in total.
[quote]<DigitalMocking> man, A_Druid_00 really does love those long ass if statements
<dont_know_at_all> i don't use his macro because i'm frightened of it[/quote]
[quote][12:45] <dont_know_at_all> never use a macro when you can really fuck up things with a plugin[/quote]

A_Druid_00
Macro Maker Extraordinaire
Posts: 2378
Joined: Tue Jul 13, 2004 12:45 pm
Location: Rolling on the Lawn Farting

Post by A_Druid_00 » Sun Nov 14, 2004 10:21 am

For all you foil lovers
Image
Last edited by A_Druid_00 on Sat Nov 20, 2004 2:55 am, edited 13 times in total.
[quote]<DigitalMocking> man, A_Druid_00 really does love those long ass if statements
<dont_know_at_all> i don't use his macro because i'm frightened of it[/quote]
[quote][12:45] <dont_know_at_all> never use a macro when you can really fuck up things with a plugin[/quote]

A_Druid_00
Macro Maker Extraordinaire
Posts: 2378
Joined: Tue Jul 13, 2004 12:45 pm
Location: Rolling on the Lawn Farting

Post by A_Druid_00 » Sun Nov 14, 2004 10:22 am

Looking for WTF provided me with this gem
Image
Last edited by A_Druid_00 on Thu Dec 02, 2004 4:30 pm, edited 2 times in total.
[quote]<DigitalMocking> man, A_Druid_00 really does love those long ass if statements
<dont_know_at_all> i don't use his macro because i'm frightened of it[/quote]
[quote][12:45] <dont_know_at_all> never use a macro when you can really fuck up things with a plugin[/quote]

I_Luv_Dr00ds
decaying skeleton
decaying skeleton
Posts: 1
Joined: Wed Nov 17, 2004 9:14 pm

Post by I_Luv_Dr00ds » Wed Nov 17, 2004 10:28 pm

Nice Mac :D :D

A_Druid_00
Macro Maker Extraordinaire
Posts: 2378
Joined: Tue Jul 13, 2004 12:45 pm
Location: Rolling on the Lawn Farting

Post by A_Druid_00 » Thu Nov 18, 2004 8:55 pm

I always wanted to know who the mac daddy was
Image
Last edited by A_Druid_00 on Sat Nov 20, 2004 3:03 am, edited 2 times in total.
[quote]<DigitalMocking> man, A_Druid_00 really does love those long ass if statements
<dont_know_at_all> i don't use his macro because i'm frightened of it[/quote]
[quote][12:45] <dont_know_at_all> never use a macro when you can really fuck up things with a plugin[/quote]

A_Druid_00
Macro Maker Extraordinaire
Posts: 2378
Joined: Tue Jul 13, 2004 12:45 pm
Location: Rolling on the Lawn Farting

Post by A_Druid_00 » Fri Nov 19, 2004 9:09 pm

THis is what you find on google if you look up weird shit
Image
Last edited by A_Druid_00 on Sun Nov 21, 2004 12:44 am, edited 1 time in total.
[quote]<DigitalMocking> man, A_Druid_00 really does love those long ass if statements
<dont_know_at_all> i don't use his macro because i'm frightened of it[/quote]
[quote][12:45] <dont_know_at_all> never use a macro when you can really fuck up things with a plugin[/quote]

User avatar
Cr4zyb4rd
Plugins Czar
Posts: 1449
Joined: Tue Jul 20, 2004 11:46 am

Post by Cr4zyb4rd » Sat Nov 20, 2004 2:03 am

See top post?