Utility Schnook.mac - out of grp shm buffer simpleton 1.0

|==========================================================================================
| Down and dirty buff simpleton - 2016 Incognito - I name it: Schnook.mac
| It aint pretty, it aint smart, but it will buff your out-of-group toons (/tgb).
| I wrote this cause I dint want my SHM leaching XP from inside the grp and
| the grp performs much better with his buffs (namely Shm Maw, Haste, etc).
| The Maw line, even with AA's extending it, lasts just under 2 minutes. But
| it procs like a beast for everyone and I've never seen it resisted. It increases
| grp output 30 to 50% (along with haste). I use this for out-of-grp PLing.
|
| This can be adapted for any buff lineup. I separated the Maw proc since it's
| such a short lasting buff and I wanted it always on, always first. You can remove the
| ShortBuff routine if you don't have a need for something like that.
|
| The LongBuff3 is like a 10 second (8? seconds w/AA's) cast so it issues a /bct pullername
| //backoff cmd. THIS MEANS you need eqbc logged in both toons or comment out that
| code. One day I might add a flag or a check but as I am always logged in eqbc it works for me.
| You can comment out the LongBuff3 routine if you don't have something that long. It works
| well, worst case is that there are some 8 seconds of puller dps loss but that is way
| better than the normal 'puller out of range' for buffs scenario. My monk puller very rarely
| gets ANY of the buffs when the SHM is in grp running KA since it is always out of camp
| pulling. I normally see the puller get the LongBuff3 between freshly returning to camp
| and the mob just entering camp, so it works well for me.
|
| Set DebugFlag to 1 to turn on MQ2Win notifications. If your buff spell is multi-word
| surround the name with quotes like I did. It is recommended to send MQ2Cast's /casting
| cmd the gemnumber along with the spell name. Make sure they are correct or go thru the
| code and omit them else MQ2Cast will be trying to mem spells during critical cast times.
| I have not tested MQ2Casts ability to do so. Docos say it will default to Gem5.
|
| MQ2Cast will throw up aborting msgs ocassionally. That's fine, it is self-correcting
| and the code will always catch up next cycle. Its largely due to puller running out of
| range during the cast.

| Use this as an example/template for your out-of-grp buffing needs. An alternative
| would be to use KA, and a raid feature with one of the extended target settings, but
| I have never done that...
|==========================================================================================
Sub Main

    /declare TarName     string     outer     PullerName
    /declare DebugFlag     int      outer     1
    /declare ShortBuff     string     outer     "Talisman of the Lynx"
    /declare LongBuff1    string     outer    Champion
    /declare LongBuff2    string     outer    "Talisman of the Stalwart"
    /declare LongBuff3    string     outer    "Talisman of Unity"
    |/declare 3Dual     int     outer    1
    /declare 3DualName     string    outer    "Mammoth's Strength"
    /declare LongBuff4    string     outer    "Talisman of Celerity"
    /declare LongBuff5    string     outer    "Spirit of Bih`Li"
    /declare LongHeal    string     outer    "Halcyon Whisper"
    /declare Iteration    int        outer    1
    /declare GemNum        int        outer    0
    /declare WhisperFlag int    outer    0
   
    |/declare i          int local       1
    |/for i 1 to ${NumBuffs}
    |    /varset LongBuffs[${i}] |do somethign clever
    |/next i

    /while (1 < 2) {
        /if (!${Target.ID} || ${Target.Name.NotEqual[${TarName}]} && ${DebugFlag}) /echo Target Problems
        /if (!${Target.ID} || ${Target.Name.NotEqual[${TarName}]}) /tar ${TarName}
       
        /if (${Target.Distance} > 50) {
            /varcalc WhisperFlag 0
            /call WaitForPuller
        }
        /if (${Target.ID} && ${Target.Distance} < 50 && !${Target.Buff[${ShortBuff}].ID}) {
            /varcalc GemNum 5
            /call DoShort ${ShortBuff} ${GemNum}
        }
        /if (${Target.ID} && ${Target.Distance} < 50 && !${Target.Buff[${LongHeal}].ID} && !${WhisperFlag}) {
            /varcalc GemNum 10
            /call DoLong ${LongHeal} ${GemNum}
            |Only do this once per pull
            /varcalc WhisperFlag 1
        }
        /if (${Target.ID} && ${Target.Distance} < 50 && !${Target.Buff[${LongBuff1}].ID} && ${Iteration} < 2) {
            /varcalc GemNum 2
            /call DoLong ${LongBuff1} ${GemNum}
            /varcalc Iteration ${Iteration} + 1
        }
        /if (${Target.ID} && ${Target.Distance} < 50 && !${Target.Buff[${LongBuff2}].ID} && ${Iteration} < 2) {
            /varcalc GemNum 6
            /call DoLong ${LongBuff2} ${GemNum}
            /varcalc Iteration ${Iteration} + 1
        }
        /if (${Target.ID} && ${Target.Distance} < 50 && !${Target.Buff[${3DualName}].ID} && ${Iteration} < 2) {
            /bct ${TarName} //backoff
            /delay 10
            /varcalc GemNum 8
            /call DoLong ${LongBuff3} ${GemNum}
            /varcalc Iteration ${Iteration} + 1
            /bct ${TarName} //backoff
        }
        /if (${Target.ID} && ${Target.Distance} < 50 && !${Target.Buff[${LongBuff4}].ID} && ${Iteration} < 2) {
            /varcalc GemNum 9
            /call DoLong ${LongBuff4} ${GemNum}
            /varcalc Iteration ${Iteration} + 1
        }
        /if (${Target.ID} && ${Target.Distance} < 50 && !${Target.Buff[${LongBuff5}].ID} && ${Iteration} < 2) {
            /varcalc GemNum 11
            /call DoLong ${LongBuff5} ${GemNum}
            |/varcalc Iteration ${Iteration} + 1
        }
        /delay 50
        /doevents
        /varcalc GemNum 0
        /varcalc Iteration 1
    }
/Return

Sub WaitForPuller
    /if (${DebugFlag}) /echo Entering WaitForPuller
    /while (${Target.Distance} > 50) {
        /delay 40
        /doevents
    }
    |Puller now in camp - return for buffage
    /if (${DebugFlag}) /echo Exiting WaitForPuller
/return

Sub DoShort(string ShortBuffName, int ShortGem)
    /if (${DebugFlag}) /echo Short Buffing ${ShortBuffName} Gem: ${ShortGem}
    /casting "${ShortBuffName}" ${ShortGem}
    /while (${Cast.Timing}) {
        | I've never seen this fire
        /if (${DebugFlag}) /echo Cast Timing Short
        /delay 5
    }
    /delay 40
/return

Sub DoLong(string BuffSThis, int GemNum)
    /if (${DebugFlag}) /echo Long Buffing ${BuffSThis} Gem: ${GemNum}
    /casting "${BuffSThis}" ${GemNum}
    /while (${Cast.Timing}) {
        | I've never seen this fire
        /if (${DebugFlag}) /echo Cast Timing
        /delay 5
    }
    /delay 80
/return