OOG_pl.mac

[vsab]

If you happen to have a spare cleric/druid/shammy that's higher level than your PLees, like I did (I just had a high level cleric when I raided), then you don't have all the other options available to PL new toons. I came up with this when I first started using MQ2 - and heroic characters didn't exist.

Compared to other methods though, I like this method for tanks, since they can train defense as well as other skills as they're going along. It's also good for those spots where they're too low to group with your "mains" (e.g. lvl 60ish but your mains are 110), but too high for effective DS PL'ing.

As mentioned in the mac, it

1. Heals the PLees; it tries to keep a HOT on them. Select a level appropriate heal (they don't always stick)
2. MOK's the mobs, this means it should lay a high level reverse DS on them (could be a cripple or slow, but don't use a DoT)
3. Nukes the shit out of mobs under 50% health, so not to KS

To use, load up the mac and let it create an empty ini (there's an example below), fill in the spells and the PC names (e.g. replace "toon1", "toon2", they are separated by "|" ). Then, simply get your PLees to engage mobs as per normal. The cleric (or whatever is running the mac ) will heal the group and then nuke the mobs down. If you're PL'ing healers, you can get them to nuke instead too

Generally it tries to keep a HoT up, and patch heals. Depending on where you're levelling etc this should be enough, but it does include big heals (complete heal is a candidate for that).

Note: I've not used it recently so be aware parts of it might be hokey.

| vsab: PL's using an OOG healer. Or, just assists a group with your healer.
| If you happen to have a spare cleric/druid/shammy that's higher level than your PLees.
| I like this method for tanks, since they can train defense as well as other skills...
| It's also good for those spots where they're too low to group with your "mains" (e.t. lvl 60ish  but you mains are 110)
| But too high for effective DS PL'ing. In other words, let them hit mobs with your PL'er acting as an out of group mercenary.
| This mac :
| 1 - Heals the PLees; it tries to keep a HOT on them. Select a level appropriate heal (they don't always stick)
| 2 - MOK's the mobs, this means it should lay a high level reverse DS on them (could be a cripple or slow, but don't use a DoT)
| 3 - Nukes the shit out of mobs under 50% health, so not to KS
| Version 0.4 - fixed MoK bug
| Version 0.3 - ini driven, Added MOK support (basically a one time, single debuff, needn't be a MOK. Lovin it.
| Version 0.2 - Nukes now.
| Version 0.1 - Healin' it
| =========================
| Example ini
| 
| [General]
| DoHeal=TRUE
| DoNuke=TRUE
| DoMok=TRUE
| PcList=toon1|toon2|
| [Nukes]
| NukeSpell=Reproval
| NukeSpellGem=gem1
| NukeMinMana=50
| [Heals]
| HotHealSpell=Supernal Elixir
| HotHealSpellGem=gem2
| HotSpellDuration=47s
| HotHealHP=85
| BigHealSpell=Supernal Light
| BigHealSpellGem=gem3
| BigHealHP=75
| PatchHealSpell=Supernal Remedy
| PatchHealSpellGem=gem4
| PatchHealHP=40
| [MOK]
| MokSpell=Mark of the Devoted Rk. II
| MokSpellGem=gem5
| MokMinHP=95
| ========================= |
#include Spell_Routines.inc
#turbo 40
#CHAT tell
Sub Main
  /declare Version string outer 0.4
  /declare NukeSpell string outer 
  /declare NukeSpellGem string outer 
  /declare NukeMinMana int outer
  
  /declare HotSpell string outer 
  /declare HotSpellGem string outer 
  | make the timer a few seconds shorter, so we can keep it up
  /declare HotSpellDuration string outer 21s
  /declare HotSpellTimer1 timer outer
  /declare HotSpellTimer2 timer outer
  /declare HotHealHP int outer
  
  /declare BigHealSpell string outer 
  /declare BigHealSpellGem string outer 
  /declare BigHealHP int outer
  
  /declare PatchHealSpell string outer 
  /declare PatchHealSpellGem string outer
  /declare PatchHealHP int outer
  
  /declare MokSpell string outer 
  /declare MokSpellGem string outer 
  /declare MokMinHP int outer
  
  
  /declare MobID[150] int outer
  /declare j int outer
  /declare MinimumHealth int outer 50
  /declare NumMobs int outer 1
  /declare MobAdded int outer 0
  /declare MobRadius int outer 50
  /declare DoHeal bool outer TRUE
  /declare DoNuke bool outer TRUE  
  /declare DoMok bool outer TRUE  
  /declare PcList string outer
  /call LoadIni "PL_${Me.CleanName}.ini" LOAD
  /echo PL mac starting up. Will heal = ${DoHeal} Will nuke = ${DoNuke}
  /if (${DoHeal}) {
    /echo I will cast a patch heal if HPs < ${PatchHealHP} %, do a big heal if they are between ${PatchHealHP} and ${BigHealHP} %, and cast a HoT if they are above ${BigHealHP} % and below ${HotHealHP}%
  }
  /if (!${DoHeal} && !${DoNuke}) {
    /echo Error! Not currently set to nuke OR heal; I have nothing to do so exiting.
    /endmac
  }
  :loop
   /if (${DoHeal}) /call CheckHealth
   /if (${NearestSpawn[1,NPC zradius 20].Distance}>${MobRadius}) /goto :skipNuke
   /if (${DoMok}) /call MokThings
   /if (${DoNuke}) /call NukeIt
   
  :skipNuke
  /doevents
  /delay 1s
  /goto :loop
/return
 Sub CheckHealth
  /declare a        int local
  /declare localPc string local ""
  /declare localPcId int local 0
  /for a 1 to ${PcList.Count[|]}
    /varset localPc ${PcList.Arg[${a},|]}
    /varset localPcId ${Spawn[pc ${localPc}].ID}
    |/echo Checking ${localPc} health (ID = ${localPcId} )
    /target targetable id ${localPcId}
    /delay 1s ${Target.ID}==${localPcId}
    /call HealTarget ${localPcId}
  /next a 
/return
Sub HealTarget(pcId)
  /if (!${Target.ID}) {
    /echo No valid target. 
    /return
  }   
  /if (${Target.PctHPs} < ${PatchHealHP}) {
    /echo Casting patch heal on ${Target.ID} - ${Target.CleanName} 
    /call Cast "${PatchHealSpell}" ${PatchHealSpellGem} 2s CheckForImminentDoom
    /return
  }
  /if (${Target.PctHPs} < ${BigHealHP}) { 
    /echo Casting big heal on ${Target.ID} - ${Target.CleanName} 
    /call Cast "${BigHealSpell}" ${BigHealSpellGem} 5s CheckForImminentDoom
    /return
  }
  /if (${Target.PctHPs} <${HotHealHP}) {
    /if (${Target.ID}==${pcId} && !${HotTimer${pcId}}) {
      /echo Casting HoT on ${pcId} - ${Target.CleanName} 
      /call Cast "${HotHealSpell}" ${HotHealSpellGem} 5s CheckForImminentDoom
      /if (${castReturn.Equal[CAST_SUCCESS]}) {
        
        /if (!${Defined[HotTimer${pcId}]}) {
          /echo HoT declaring HotTimer${pcId}  ${HotSpellDuration}
          /declare HotTimer${pcId} timer outer ${HotSpellDuration}
        } else {
          /echo HoT setting HotTimer${pcId}  ${HotSpellDuration}
          /varset HotTimer${pcId}  ${HotSpellDuration}    
        }
      }
    }
    /return
  } 
/return
Sub CheckForImminentDoom
  /if (!${Target.ID}) /return
  /if (${Target.PctHPs} < ${PatchHealHP}) { 
    /bc Oh shit! patch healing!
    /call Interrupt
    /call Cast "${PatchHealSpell}" ${PatchHealSpellGem}
  }
/return
Sub NukeIt
  /declare myMob int inner
  /for myMob 1 to ${SpawnCount[NPC radius ${MobRadius} zradius 20]}
    /target id ${NearestSpawn[${myMob},NPC zradius 20 radius ${MobRadius}].ID}
    /delay 1s ${Target.ID}==${NearestSpawn[${myMob},NPC zradius 20 radius ${MobRadius}].ID}
    /if (${Target.PctHPs}<${MinimumHealth} && ${Me.PctMana} >= ${NukeMinMana}) {
      /echo Nuking ${Target.CleanName}!
      /call Cast "${NukeSpell}" ${NukeSpellGem}
      /echo Result of Nuke Spell = ${castReturn}
    } 
  /if (${DoHeal}) /call CheckHealth
  /if (${DoMok}) /call MokThings
  /next myMob
/return
Sub MokThings
/declare myMob int inner
   /for myMob 1 to ${SpawnCount[NPC radius ${MobRadius} zradius 20]}
    /varset MobAdded 0  
    /for j 1 to ${NumMobs}
      /if (${MobID[${j}]}==${NearestSpawn[${myMob},NPC zradius 20 radius ${MobRadius}].ID}) /varset MobAdded 1
    /next j
    /if (!${MobAdded}) {
      /target id ${NearestSpawn[${myMob},NPC zradius 20 radius ${MobRadius}].ID}
      /delay 1s ${Target.ID}==${NearestSpawn[${myMob},NPC zradius 20 radius ${MobRadius}].ID}
      /if (${Target.PctHPs}<${MokMinHP}) {
        /echo Casting MOK on ${Target.CleanName}
        /call Cast "${MokSpell}" ${MokSpellGem}
        /echo Result of MOK spell = ${castReturn}
        /if (${castReturn.Equal[CAST_SUCCESS]}) {
        /varcalc NumMobs ${NumMobs}+1
        /varset MobID[${NumMobs}] ${Target.ID}
        /bc Added ${Target.ID} ( ${Target.CleanName} ) to ignore list
      }
    } 
  }
  /if (${DoHeal}) /call CheckHealth
  /next myMob
/return
Sub LoadIni(MyIni,Function)
  /echo Loading variables from ini.
  | General section
  /call LoadVar General DoHeal TRUE DoHeal "${MyIni}" ${Function} bool
  /call LoadVar General DoNuke TRUE DoNuke "${MyIni}" ${Function} bool
  /call LoadVar General DoMok TRUE DoMok "${MyIni}" ${Function} bool
  /call LoadVar General PcList "Put your list of pc's you want to heal here, seperated by a |" PcList "${MyIni}" ${Function} string
  /echo Looking at ${PcList.Count[|]} PC's
  | Nuke section
  /call LoadVar Nukes NukeSpell "Put the name of your Nuke spell here" NukeSpell "${MyIni}" ${Function} string
  /call LoadVar Nukes NukeSpellGem "Put the spell gem you want to cast your nuke from here" NukeSpellGem "${MyIni}" ${Function} string
  /call LoadVar Nukes NukeMinMana 50 NukeMinMana "${MyIni}" ${Function} int
  
  | Heal section
  |--- HoT heals
  /call LoadVar Heals HotHealSpell "Put the name of your heal over time spell here" HotHealSpell "${MyIni}" ${Function} string
  /call LoadVar Heals HotHealSpellGem "Put the spell gem you want to cast your heal over time from here" HotHealSpellGem "${MyIni}" ${Function} string
  /call LoadVar Heals HotSpellDuration "Put the duration of the HoT spell you use here" HotSpellDuration "${MyIni}" ${Function} string
  /call LoadVar Heals HotHealHP 85 HotHealHP "${MyIni}" ${Function} int
  /if (!${Defined[HotTimer]}) /declare HotTimer timer outer 0
  
  |--- Big heals
  /call LoadVar Heals BigHealSpell "Put the name of your BIG heal spell here" BigHealSpell "${MyIni}" ${Function} string
  /call LoadVar Heals BigHealSpellGem "Put the spell gem you want to cast your BIG heal from here" BigHealSpellGem "${MyIni}" ${Function} string
  /call LoadVar Heals BigHealHP 75 BigHealHP "${MyIni}" ${Function} int
  |--- Patch heals
  /call LoadVar Heals PatchHealSpell "Put the name of your patch heal spell here" PatchHealSpell "${MyIni}" ${Function} string
  /call LoadVar Heals PatchHealSpellGem "Put the spell gem you want to cast your patch heal from here" PatchHealSpellGem "${MyIni}" ${Function} string
  /call LoadVar Heals PatchHealHP 40 PatchHealHP "${MyIni}" ${Function} int
  |-- MOK
  /call LoadVar MOK MokSpell "Put the name of your MoK spell here" MokSpell "${MyIni}" ${Function} string
  /call LoadVar MOK MokSpellGem "Put the spell gem you want to cast your MoK from here" MokSpellGem "${MyIni}" ${Function} string
  /call LoadVar MOK MokMinHP 95 MokMinHP "${MyIni}" ${Function} int
  
  
/return
Sub LoadVar(IniSection,IniVar,IniValue,MacroVar,MyIni,Function,VarType)
  /if (!${Defined[${MacroVar}]} && ${Defined[VarType]}) /declare ${MacroVar} ${VarType} outer
  /if (${Function.Equal[LOAD]}) {
    /declare IniString string local ${Ini[${MyIni},${IniSection},${IniVar},NOTFOUND]}
    /varset ${MacroVar} ${IniString}
  }
  /if (${IniString.Equal["NOTFOUND"]} || ${Function.Equal[SAVE]}) {
    /if (${IniString.Equal["NOTFOUND"]} && ${Function.Equal[LOAD]}) /varset ${MacroVar} ${IniValue}
    /ini ${MyIni} "${IniSection}" "${IniVar}" "${${MacroVar}}"
  }
/return

 

[toadwart]

Not to deride your work vsab, it's always helpful to have additional ways to do things. I just wanted to point out that this is totally doable with KA as well. I've PLed quite a few toons and groups using KA and a higher level cle/dru/shm outside of the group. I simply have a set of spell loadouts for that cleric to use temperance up to a point, then Virtue etc. Otherwise I put level appropriate heal spells as if the cleric was of a common level, or slightly higher to the group, then add all group members to the Xtarget list slots 2-7, and have the cleric KA on the main tank at 55%. The cleric buffs and heals as if in the group, summons a hammer at 55%, and nukes at 49 and below. Essentially gives you a 7 man group, with the cleric getting no exp of course, but otherwise in my experience virtually un-noticeable variance. The xtarheal variable needs to be set right, but that's the only other change.

 

[vsab]

Yep, fair enough. To be honest this mac is old. I recall KA being mentioned in the MQ2 forums at the time, but it was "new" and I didn't have access to it. I think it was about the time RoF came out.

 

[mrsmithie]

Im sorry to ask this stupid question but im new at all this and im not for sure what all i need to change in the macro could you either tell me or post a basic overview of what needs to be changed in the macro please

 

[q8reflex]

Just change the General part, add spells you need and your lowbie toon's name that you need to PL. Personally i think Druid would be the best class for this kinda job.

 

[game_sparks]

I am getting this error:

Casting MOK on a mummified corpse
Subroutine 58716 wasn't found
Spell_Routines.inc@478 (WaitCast(mySub,int spellID)): /if (${Bool[${mySub}]}) /call ${mySub} ${spellID}
Spell_Routines.inc@255 (SpellCast(spellType,spellName,mySub,int spellID,giveUpValue)): /call WaitCast ${mySub} ${spellID}
Spell_Routines.inc@204 (Cast(spellName,spellType,giveUpValue,mySub,int ResistTotal)): /if (${spellType.NotEqual[item]} && ${spellType.NotEqual[alt]}) /call SpellCast "${spellType}" "${spellName}" "${mySub}" "${spellID}" "${giveUpValue}"
oog_pl.mac@186 (MokThings): /call Cast "${MokSpell}" ${MokSpellGem}
oog_pl.mac@93 (Main): /if (${DoMok}) /call MokThings
The current macro has ended.


Not sure what I did wrong

 

[BrianGragg]

Not sure about the error but keeptoonbuffed.Mac does almost the same thing and works great. Can find it in the macro resource section.