• You've discovered RedGuides, an EverQuest multi-boxing and scripting community 🧙‍♀️⚙️. We want you to play several EQ characters at once, come join us and say hello! 👋

  • A TLP without truebox has thawed (Very Vanilla ready)
    Frostreaver

Auto Mage mac - workish but needs updating

ncccippy

New member
Joined
Jan 19, 2006
RedCents
10¢
A friend of mine gave me this mage mac a while back and I'm trying to get it up and running with all the contemporary changes that have been made since it was released. As it is now, the macro will nuke, malo, and send the pet in after the mob but there are some errors. I'm sure one of you uber coders can return it to full functionality and post for my and others use. Thanks.


Rich (BB code):
| magebot.mac 
| by Dragonbutt
| Last update 1/5/2009
|  slash commands:
|  /setma name                             - sets main assist   
|  /setsa name                             - sets secondary assist                                
|  /debuff on|off                          - turns auto debuffing on or off                         
|  /anchor #                               - sets the leash length when using an anchor            
|  /minhp #                                - sets the minimum hp % that you'll begin nuking at  
|  /radius #                               - sets the distance at which you'll engage
|  /nuketype fire|magic|bolt [spellname]   - sets your current nuke to the specified type
|  /ds on|off                              - turns group ds on or off 
|  /pettype ear|air|fir|wat 
|  /nukebranch Fire|Magic|Bane|Rain|Beam|Standard  
 
#include spell_routines.inc
|#include gen_routines.inc 
#include Wait4Rez.inc
#include events.inc
#include general.inc

#event SetVar "[MQ2] set: #1# #2#"

#turbo 40 

#chat group 
#chat tell 
#chat chat 
#chat say 

#event RaidSay "#1# tells the raid,  '#2#'" 
#event ChatTell "#1# told you, '#2#'" 
#event IRC            "<#1#> #2#"
#event DoTell "#1# tells you, '#2#'"
#event DoTell "#1# told you, '#2#'" 
#event Coth "#1# tells you, 'coth'" 
#event Coth "#1# tells you, 'coth #2#'" 
#event Coth "#1# told you, 'coth'" 
#event Coth "#1# told you, 'coth #2#'" 
#event Gate "#1# gates#*#" 
#event PetWeps "#1# #*#'#*#pet weps#*#'" 
#event RageOff "#*#is no longer enraged#*#" 
#event RageOn "#*#has become ENRAGED#*#" 
#event Talk "<#1#> #2#"
#event Invite "#1# invites you to join a group."
#event GiftofMana        "You have been granted a gift of amazing exquisite radiant mana!"
#event FlameOfPower "#*#small flames dance#*#"
#event Burninate "#*#Max Burn#*#"
#event nukebranch        "[MQ2] nukebranch #1#"

Sub Main 
   /call GeneralDeclares 
   /call GeneralDeclares2
   /call IniDeclares
   /declare i int local 
   /declare j int local 
   /declare oldTarget int local 
   /declare tempTimer timer local 0 
   /varset castSub CheckForAdds 


:wait_for_target 
/if ( !${CheckExpTimer} ) /call AutoAdjustExp
/varset MacroState WaitForTarget1
/doevents

   /if ( !${petSpamTimer} ) { 
      /pet ghold on
      /varset petSpamTimer 50 
   } 
   /if (${DoLeash}) /call Leash
   /if ( ${nukeMode} || ${useDebuff} ) /i say Waiting for target... 

/if (${Me.PctMana}<85 && !${Me.Sitting} && !${Me.Moving} && !${Me.Casting.ID} && !${SpawnCount[npc los range 5 110 radius 50 zradius 50]} && !${Me.Invis} && !${following}) /sit

   /varset validTarget 0 
:wait_for_target2 
/varset MacroState WaitForTarget2

/doevents
/if (${following}) /goto :wait_for_target2
/if (!${bufftimer} && ${usebuffs} && !${Me.Moving}) /call CheckIniBuffs
/if (${Me.PctMana}<85 && !${Me.Sitting} && !${Me.Moving} && !${Me.Casting.ID} && !${SpawnCount[npc los range 5 110 radius 50 zradius 50]} && !${Me.Invis} && !${following}) /sit
   /if ( ${Spawn[pc ${secondAssist}].ID} && ( !${Spawn[pc ${mainAssist}].ID} || ${Spawn[corpse ${mainAssist}].ID} ) ) { 
      /varset mainTank ${secondAssist} 
   } else { 
      /varset mainTank ${mainAssist} 
   } 
   /if ( !${Corpse.Open} && ${Spawn[${mainAssist}].NearestSpawn[npc radius ${Math.Calc[${minRadius}*2]}].ID} && ( ${nukeMode} || ${useDebuff} ) ) { 
      /if ( ${Me.Casting.ID} ) /call WaitCast 
      /assist ${mainTank} 
      /varset oldTarget ${Target.ID} 
      /varset tempTimer 5 
   :wait_for_assist1 
/varset MacroState WaitForAssist1
/doevents
/if (${following}) /goto :wait_for_assist1
/doevents
   /if (${DoLeash}) /call Leash
/if (${following}) /goto :wait_for_target2
/if (${Me.PctMana}<85 && !${Me.Sitting} && !${Me.Moving} && !${Me.Casting.ID} && !${SpawnCount[npc los range 5 110 radius 50 zradius 50]} && !${Me.Invis} && !${following} ) /sit
      /call CheckTarget 
      /if ( ${tempTimer} && !${validTarget} ) /goto :wait_for_assist1 
   } 
   /call CheckTarget 
   /if ( !${validTarget} || ( !${nukeMode} && !${useDebuff} ) ) { 
      /call CheckPet 
      /doevents 
	   /if ( !${CheckExpTimer} ) /call AutoAdjustExp
      /goto :wait_for_target2 
   } 
   /i say Target Aquired >> ${Target.DisplayName} << 
   /varset petAttacking false 
   /varset engaged 0 
   /varset nukeWaitTimer 0 
   /varset mobID ${Target.ID} 
   /varset mobHPStart ${Target.PctHPs} 
   /call UpdateMobList 
   /call AddToList mobList ${mobID} 
   /varset nukeWaitTimer 0 
   /if ( ${Defined[waitTimer${mobID}]} ) /deletevar waitTimer${mobID} 
   /declare waitTimer${mobID} int outer -1 
   /varset newAdds 0 

   } 
:nuke_loop 
  /varset MacroState NukeLoop
   /varset addIndex 1 
/doevents
:check_add_loop 
/doevents
   /call CheckForAdds 
   /if ( ${addIndex}>1 ) /goto :check_add_loop 
   /call CheckPet 
   /if ( !${Spawn[${mobID}].Type.Equal[NPC]} && ( !${Spawn[${mobID}].Type.Equal[pet]} || ${Spawn[${mobID}].Master.Type.Equal[pc]} ) ) { 
      /i say Target Dead! 
	   /varset mobID 0
      /if ( ${cleanUp} ) /call CleanUp ${mobID} 
      /goto :wait_for_target 
   } 
   /target id ${mobID} 
   /if ( ( ${Target.PctHPs}>${minHP} && ${waitTimer${mobID}} ) || !${assistWaitTimer} ) { 
      /if ( ${Spawn[pc ${secondAssist}].ID} && ( !${Spawn[pc ${mainAssist}].ID} || ${Spawn[corpse ${mainAssist}].ID} ) ) { 
         /varset mainTank ${secondAssist} 
      } else { 
         /varset mainTank ${mainAssist} 
      } 
      /assist ${mainTank} 
      /varset tempTimer 8 
   :wait_for_assist 
      /call CheckPet 
      /if ( ${tempTimer} && ${Target.ID}==${mobID} ) /goto :wait_for_assist 
      /if ( ${Target.ID} && ${Target.ID}!=${mobID} ) /goto :wait_for_target 
      /varset assistWaitTimer 5s 
      /goto :nuke_loop 
   } 
   /if ( !${engaged} ) { 
      /varset engaged 1 
      /i say Engaging >> ${Target.DisplayName} << 
   } 
   /if ( ${Me.Pet.ID} && !${petAttacking} && ${Target.PctHPs}<=${SendPetPerc} ) { 
      /pet attack 
      /varset petAttacking true 
      }
|	  /call CheckPetBuffs
	  /if ( ${useDebuff} && ${Target.LineOfSight} && ${Target.PctHPs}<=99 && ( ${Target.Type.Equal[NPC]} || ${Target.Type.Equal[pet]} ) ) /call DebuffMobs
 /varset MacroState Blast
      /if ( ${nukeMode} && ${Target.LineOfSight} && ${Target.PctHPs}<=${minHP} && !${Me.TargetOfTarget.Name.Equal[${Me.Name}]} && !${nukeWaitTimer} &&  ( ${Me.PctMana}>=${nukeMana} || ${nukeMode}==2 ) && ( ${Target.Type.Equal[NPC]} || ${Target.Type.Equal[pet]} ) ) {
	    /if ( ${NukeLine}==1 ) /call FireBranch
	    /if ( ${NukeLine}==2 ) /call MagicBranch
		/if ( ${NukeLine}==3 ) /call BaneBranch
		/if ( ${NukeLine}==4 ) /call RainBranch
		/if ( ${NukeLine}==5 ) /call BeamBranch
		/if ( ${NukeLine}==6 ) /call MageDPS  
       }
/doevents
  /if (${Me.Dead}) /call Wait4Rez
/goto :nuke_loop 


/return

Sub DebuffMobs 
   /declare i int local 
   /declare tempID string local 
   /if ( ${mobList.Find[[]} ) { 
      /for i 1 to ${mobList.Count[[]} 
         /if ( ${mobList.Find[[]}>1 ) /varset mobList ${mobList.Right[-${Math.Calc[${mobList.Find[[]}-1]}]} 
         /varset tempID ${mobList.Arg[${i},[].Left[-1]} 
         /if ( !${Defined[maloTimer${tempID}]} ) { 
            /if ( !${Spawn[${tempID}].Type.Equal[npc]} ) { 
               /declare maloTimer${tempID} int outer -1 
            } else /if ( ( !${waitTimer${tempID}} && ( ${maloTimer${mobID}} || ${waitTimer${mobID}} ) ) || ${tempID}==${mobID} ) { 
               /call UpdateMobList 
               /target id ${tempID} 
               /call Malo 
            } 
         } 
      /next i 
   } 
/return 

Sub Malo 
   /declare tempID int local ${Target.ID} 
   /if ( !${Defined[maloResists${tempID}]} ) /declare maloResists${tempID} int outer 0 
   /if ( ${maloResists${tempID}}==${resistsTillMala} ) /call Cast "${malaSpell}" ${malaType} 5s CheckPet 
   /if ( ${maloResists${tempID}}==${resistsTillQuit} ) { 
      /deletevar maloTimer${tempID} 
      /declare maloTimer${tempID} int outer -1 
      /return 
   } 
   /call Cast "${malosiniaSpell}" ${malosiniaType} 0 CheckPet 
   /if ( !${Defined[maloTimer${tempID}]} ) /declare maloTimer${tempID} timer outer 
   /if ( ${Macro.Return.Equal[CAST_SUCCESS]} ) { 
      /varset maloTimer${tempID} 25m | ${maloDuration} 
      /varset maloResists${tempID} 0 
   } else /if ( ${Macro.Return.Equal[CAST_OUTOFMANA]} || ${Macro.Return.Equal[CAST_OUTOFRANGE]} || ${Macro.Return.Equal[CAST_CANNOTSEE]} ) { 
      /varset maloTimer${tempID} 50      
   } else { 
      /if ( ${Macro.Return.Equal[CAST_RESISTED]} ) /varcalc maloResists${tempID} ${maloResists${tempID}}+1 
      /varset maloTimer${tempID} 1 
   } 
/return ${Macro.Return} 

Sub GetTarget

/return


Sub CheckPet 
/doevents
   /if ( ${Zone.ID}!=${currentZone} ) { 
      /varset currentZone ${Zone.ID} 
      /varset mobList 
      /varset addList 
      /varset buffQueue 
      /varset mobID 0 
      /varset petID 0 
|      /squelch alert clear 6 
      /call ClearMobList  
   } 
   /call CheckForAdds 
   /declare i int local 
   /declare tempID int local 
   /if ( ${petOff} && ${Me.Pet.ID} ) { 
      /varset petOff 0 
   } 
   /if ( ${Spawn[${petID}].Type.Equal[NPC]} && !${petOff} ) { 
      /i say Pet Off!
      /i say Pet Off!
      /varset petAttacking false 
      /varset petOff 1 
   } 

   /if ( ${petOff} && ${Me.Casting.ID} && !( ${Me.Casting.Name.Equal[malosinia]} && ${Target.ID}==${petID} ) && !${Me.Casting.Name.Equal[Elemental Silence]} && !${Me.Casting.Name.Equal[call of the arch mage]} ) /call Interrupt 
   /doevents gate 
   /doevents rageon 
   /doevents rageoff 
   /doevents setvar 
   /if ( ${castWaitTime}>5 ) /doevents chat 
/return 

Sub CheckPet2 

/return 

Sub CheckForAdds 
:check_add_loop 
/doevents
   /if ( !${Spawn[${mobID}].Type.Equal[npc]} && !${Spawn[${mobID}].Type.Equal[pet]} ) { 
      /varset addIndex 1 
      /return 
   } 
   /varset addID ${NearestSpawn[${addIndex},npc radius ${minRadius}].ID} 
   /if ( ${addID} ) { 
      /if ( ${Spawn[${addID}].Distance3D}<=${minRadius} && ${addID}!=${petID} && ${Spawn[${addID}].LineOfSight} && ${aggroAnim.Find[|${Spawn[${addID}].Animation}|]} && ${mezTimer${addID}}!=-1 && ${Spawn[${addID}].Type.Equal[NPC]} ) { 
         /call AddToList mobList ${addID} 
         /if ( ${Macro.Return.Equal[1]} ) { 
            /if ( !${Defined[waitTimer${addID}]} ) /declare waitTimer${addID} timer outer ${engageDelay} 
            /i say Add detected! >> ${Spawn[${addID}].DisplayName} << 
         } 
         /varset newAdds 1 
      } 
      /varcalc addIndex ${addIndex}+1 
   } else { 
      /varset addIndex 1 
   } 
/return 

Sub CheckPeteBuffs 
/doevents
      /if (${Me.State.Equal[Hover]}) /call Wait4Rez
   /if (!${InvSlot[chest].Item.ID} && !${Me.Platinum}) /call Wait4Rez
  /if (${Me.Dead}) /call Wait4Rez

  /declare i int local 
   /declare j int local 
   /declare buffText string local 
   /declare targetName string local 
   /declare spellName2 string local 
   /declare spellType string local 
   /declare spellRange int local 118 
   /declare spellName string local 
   /declare buffName string local 
   /declare focusList string local Dire Focusing,Talisman of the Dire,Wunshi's Focusing,Focus of Alladnu,Focus of Soul,Talisman of Kragg,Focus of the Seventh,Talisman of Wunshi,Darkpaw Focusing, Talisman of the Bloodworg, Bloodworg Focusing, Bloodworg Focusing Rk. II, Talisman of the Bloodworg Rk. II
   /declare shaman bool local false 
   /declare targetType string local 

   /if (${Me.Pet.ID} && !${Me.PetBuff[${auraName}]}) /call cast "${auraBuff}" ${auraBuffGem} 
   /if ( !${petID} && ${Me.Pet.ID} ) /varset petID ${Me.Pet.ID} 
   /if ( !${Me.Pet.ID} && ${usePet} && !${petOff} && ${Me.CurrentMana}>=400 ) /call SumPet 
      
   /if ( ${Cursor.Name.Equal[${ModRodName}]} ) /autoinventory 
   /if ( ${Cursor.Name.Equal[${ParadoxRodName}]} ) /autoinventory
   /if ( !${Bool[${FindItem[${ParadoxRodName}]}]} && ${Me.PctMana}>=100 ) /call Cast "${ParadoxSpell}" ${ParadoxSpellType}
   /if ( !${FindItem[${ModRodName}].ID} ) /call AddToQueue "rod,${Me.Name}" 
   /if ( ${FindItem[${ModRodName}].ID} && !${FindItem[${ModRodName}].Timer} && ${Me.PctHPs}>50 && ${Me.PctMana}<=90 ) { 
      /call Cast "${ModRodName}" item 
   } 
   /if ( ${useMount} && !${Me.Mount.ID} ) /call Cast "${mountItem}" item  
    
   /if ( ${Me.Pet.ID} ) { 
            /if ( !${Me.PetBuff[${petHaste}]} && !${Me.PetBuff[call of the arch mage]} && ${Me.Pet.Distance3D}<=100 ) /call Cast "${petHaste}" ${petHasteType} 2s 
			 /delay 5s !${Me.Casting.ID}
   /if ( !${Target.ID} && !${Me.Buff[${SiphonBuffName}].ID} && !${Me.PetBuff[call of the arch mage]} && !${Me.Buff[Mental Vivisection Recourse].ID} && !${Me.Buff[Mental Vivisection Recourse Rk. II].ID} && !${Me.Buff[Mental Vivisection Recourse Rk. III].ID} && !${Me.Buff[Mind Decomposition Recourse].ID} && !${Me.Buff[Mind Decomposition Recourse Rk. II].ID} && !${Me.Buff[Mind Decomposition Recourse Rk. III].ID} && ${Me.Pet.ID} && ${Me.Pet.Distance3D}<=100 && ${Me.Book[${siphonSpell}]} ) /call cast "${siphonSpell}" gem8 0 CheckPet 

      /if ( !${Me.PetBuff[${PetProc}]} && !${Me.PetBuff[call of the arch mage]} ) /call cast "${PetProc}" gem8 2s
	       /delay 5s !${Me.Casting.ID}
      /if ( !${Me.PetBuff[Grounded Stance]} && !${Me.PetBuff[${PetRune}]} && ${PetTank} && ${Me.SpellReady[${PetRune}]}) /call cast "${PetRune}" gem6 2s
	       /delay 5s !${Me.Casting.ID}
      /if ( !${Me.PetBuff[Elemental Conjunction]} && !${Me.PetBuff[Primal Fusion]} && !${FindItem[${EpicClick}].Timer} && ${FindItem[${EpicClick}].ID}) /call cast "${EpicClick}" item 2s
	           /delay 5s !${Me.Casting.ID}
      /if ( !${Me.PetBuff[${PetBlock}]} && ${PetTank} ) /call cast "${PetBlock}" gem9 2s
	           /delay 5s !${Me.Casting.ID}
  } 
   /if ( !${Me.Buff[${groupDSSpell}].ID} && ${useGroupDS} ) { 
      /if ( ${Spawn[pc ${mainAssist}].ID} ) { 
         /call AddToQueue "${groupDSSpell},${mainAssist}" 
      } else { 
         /call AddToQueue "${groupDSSpell},${Me.Name}" 
      } 
   } 
   /if ( !${autoBuff} ) /goto :skip_buffs 
   /if ( ${Me.PctHPs}<=${runeHP} ) { 
      /if ( ${Me.Book[${runeSpell}]} ) { 
         /if ( !${Me.Buff[${runeSpell}].ID} ) /call cast "${runeSpell}" ${runeType} 0 CheckPet 
      } else /if ( ${FindItem[${runeSpell}].ID} ) { 
         /if ( !${Me.Buff[${FindItem[${runeSpell}].Spell.Name}].ID} ) /call cast "${runeSpell}" ${runeType} 0 CheckPet 
      } 
   } 
   /doevents Indoors 
   /if ( !${Me.Casting.ID} ) /call CheckIniBuffs 
   /if ( ${Spawn[pc class shaman].ID} ) { 
      /if ( ${Raid.Members} ) { 
         /varset shaman true      
      } else { 
         /for i 1 to ${Group} 
            /if ( ${Group.Member[${i}].Class.Name.Equal[shaman]} ) /varset shaman true 
         /next i 
      } 
   } 
  
   /if ( ${shaman} ) { 
      /if ( ${Me.Buff["${shielding}"].ID} ) /call ClickOffBuff "${shielding}" 
   } else { 
      /for i 1 to ${focusList.Length} 
         /if ( ${Me.Buff[${focusList.Arg[${i},,]}].ID} ) /goto :skip_buffs 
      /next i 
      /if ( !${Me.Buff[${shielding}].ID} ) /call AddToQueue "${shielding}" 
   } 
:skip_buffs 
   /if ( ${Target.Name.Equal[${Me.Pet.Name}]} ) { 
      /if ( ${Spawn[${oldTarget}].ID} && ${Spawn[${oldTarget}].Dead} ) { 
         /target id ${oldTarget} 
      } else { 
         /keypress clear_target 
      } 
   } 
   /if ( ${buffQueue.Find[[]} ) { 
      /if ( ${buffQueue.Find[[]}>1 ) /varset buffQueue ${buffQueue.Right[-${Math.Calc[${buffQueue.Find[[]}-1]}]} 
      /for i 1 to ${buffQueue.Count[[]} 
         /varset buffText [${buffQueue.Arg[${i},[]} 
         /varset spellName ${buffText.Arg[1,,].Right[-1]} 
         /if ( ${spellName.Right[1].Equal["]"]} ) /varset spellName ${spellName.Left[-1]} 
         /varset targetName ${buffText.Arg[2,,].Left[-1]} 
         /call GetBuffName "${spellName}" 
         /varset spellName ${Macro.Return.Arg[1,,]} 
         /varset spellType ${Macro.Return.Arg[2,,]} 
         /if ( ${spellType.Equal[item]} ) { 
            /varset spellName2 ${FindItem[${spellName}].Spell.Name} 
         } else { 
            /varset spellName2 ${spellName} 
         } 
         /if ( ${Spell[${spellName2}].TargetType.Equal[Group v2]} ) { 
            /varcalc spellRange 1.18*${Spell[${spellName2}].AERange} 
         } else { 
            /varcalc spellRange 1.18*${Spell[${spellName2}].Range} 
         } 
         /varset targetType pc 
         /if ( !${Spawn[pc ${targetName}].ID} ) /varset targetType pet          
         /if ( ${Bool[${spellName}]} ) { 
            /if ( ${Me.CurrentMana}>=${Math.Calc[${Spell[${spellName}].Mana}+${Me.ManaRegen}]} || ${spellType.Equal[item]} || ${spellType.Equal[alt]} ) { 
               /if ( !${Bool[${targetName}]} ) { 
                  /call Cast "${spellName}" ${spellType} 4s CheckForAdds 
               } else /if ( ${Spawn[${targetType} ${targetName}].ID} && ( ${Spawn[pc ${targetName}].Distance3D}<=${spellRange} || !${spellRange} ) ) { 
                  /target ${targetType} ${targetName} 
                  /call Cast "${spellName}" ${spellType} 4s CheckForAdds 
                  /if ( ${Spawn[${oldTarget}].ID} ) { 
                     /if ( ${Target.Name.Equal[${targetName}]} ) /target id ${oldTarget} 
                  } else { 
                     /keypress clear_target 
                  }    
               } 
               /if ( ${Macro.Return.Equal[CAST_SUCCESS]} || ${Macro.Return.Equal[CAST_UNKNOWNSPELL]} || ${Macro.Return.Equal[CAST_NOTARGET]} || ( ${Macro.Return.Equal[CAST_CANCELLED]} && ( !${newAdds} || !${useMez} ) ) ) { 
                  /call DeleteFromQueue "${buffText}" 
                  /varcalc i ${i}-1 
               } 
            } 
         } else { 
            /call DeleteFromQueue "${buffText}" 
            /varcalc i ${i}-1 
         } 
      /next i 
   } 
   /return 
   :dead 
   /declare i int local 
   /varset mobList 
   /varset addList 
   /varset buffQueue 
   /varset mobID 0 
   /varset petID 0 
   /varset useAnchor 0 
   /squelch alert clear 6 
   /call ClearMobList 
   /if (${Me.State.Equal[Hover]}) /call Wait4Rez
   /if (!${InvSlot[chest].Item.ID} && !${Me.Platinum}) /call Wait4Rez
  /if (${Me.Dead}) /call Wait4Rez

:wait_for_loot 
   /varset deathFlag ${Math.Calc[${Me.MaxHPs}<2000]} 
   /if ( ${Spawn[corpse radius 100 ${Me.Name}].ID} && ${deathFlag} ) { 
      /target mycorpse 
      /call LootCorpse 
      /delay 5 
      /goto :wait_for_loot 
   } 
   /if ( ${deathFlag} ) { 
      /memspellset ${spellSet} 
      /i say You're dead! Consenting and waiting for rez... 
      /consent guild 
      /delay 25 
      /consent raid 
      /delay 25 
      /consent group 
   :wait_for_rez 
      /doevents 
      /delay 1s 
      /if ( !${Window[ConfirmationDialogBox].Open} ) /goto :wait_for_rez 
      /delay 18s ${Me.Gem[8].ID} 
      /i say Yay a rez! 
   :wait_for_rez2 
      /delay 1 
      /notify ConfirmationDialogBox Yes_Button leftmouseup 
      /if ( ${Window[ConfirmationDialogBox].Open} ) /goto :wait_for_rez2 
      /delay 5s ${Spawn[corpse radius 100 ${Me.Name}].ID} 
      /goto :wait_for_loot 
   } 
/return 

Sub SumPet 
   /declare i int local 
   /if (${Me.State.Equal[Hover]}) /call Wait4Rez
   /if (!${InvSlot[chest].Item.ID} && !${Me.Platinum}) /call Wait4Rez
  /if (${Me.Dead}) /call Wait4Rez
   /if ( ${Me.AltAbilityReady[suspended minion]} ) /call Cast "suspended minion" alt 2s 
   /delay 1s ${Me.Pet.ID} 
     /if (${Me.Pet.ID}) /return
   /if ( !${Me.Pet.ID}) { 
   /if (${PetType.Equal[air]} || ${PetType.Equal[wind]}) /call cast "${windPet}" gem6 5s 
   /if (${PetType.Equal[ear]} || ${PetType.Equal[earth]}) /call cast "${earthPet}" gem6 5s
   /if (${PetType.Equal[wat]} || ${PetType.Equal[water]}) /call Cast "${waterPet}" gem6 5s
   /if (${PetType.Equal[fir]} || ${PetType.Equal[fire]}) /call Cast "${firePet}" gem6 5s
   } 
   /delay 10s !${Me.Casting.ID}
   /delay 5
   /if ( !${Me.Pet.ID} ) /return
      /tar id ${Me.Pet.ID}
      /delay 5
      /call SumWeps
      /delay 2s
      /call Cast "${petShrinkSpell}" ${petShrinkType} 3s 
      /delay 1s
      /call Cast "${petShrinkSpell}" ${petShrinkType} 3s 
      /delay 1s
      /call Cast "${petShrinkSpell}" ${petShrinkType} 3s
      /delay 1s
      /call Cast "${petShrinkSpell}" ${petShrinkType} 3s
      /delay 2s
      /pet ghold on
/return 

Sub SumWeps 
   /if ( ${Target.Pet.ID} ) /target id ${Target.Pet.ID} 
   /if ( !${Target.Type.Equal[pet]} ) /return 
    /if ( !${UseSummonWeps} ) /return
     /if ( ${UseSummonWeps} && !${FindItem[Phantom Satchel].InvSlot} && ${PetType.Find[wat]} ) {
   /call Cast "${summonedWepSpell}" ${summonedWepType} 3s 
   /delay 3s
   /autoinventory
   /delay 3s 
   /nomodkey /itemnotify ${FindItem[Phantom Satchel].InvSlot} rightmouseup
   /delay 1s
   /nomodkey /itemnotify ${FindItem[Summoned: Winterbane].InvSlot} leftmouseup
   /delay 1s 
   /call GiveToPet 
   /delay 2s 
   /nomodkey /itemnotify ${FindItem[Summoned: Tonfa of the North Wind].InvSlot} leftmouseup 
   /delay 1s
   /call GiveToPet
   /delay 2s
   /nomodkey /itemnotify ${FindItem[Phantom Satchel].InvSlot} rightmouseup
   } else { 
		/if ( ${UseSummonWeps} && ${FindItem[Phantom Satchel].InvSlot} && ${FindItem[Summoned: Winterbane].InvSlot} && ${PetType.Find[wat]} ) {
		/nomodkey /itemnotify ${FindItem[Phantom Satchel].InvSlot} rightmouseup
		/delay 1s
		/nomodkey /itemnotify ${FindItem[Summoned: Winterbane].InvSlot} leftmouseup
		/delay 1s 
		/call GiveToPet 
		/delay 2s 
		/nomodkey /itemnotify ${FindItem[Summoned: Tonfa of the North Wind].InvSlot} leftmouseup 
		/delay 1s
		/call GiveToPet
		/delay 2s
		/nomodkey /itemnotify ${FindItem[Phantom Satchel].InvSlot} rightmouseup
		}
   }
   /call Cast "${petShrinkSpell}" ${petShrinkType} 3s
/return 


Sub GiveToPet 
   /declare i int local 
   /varset i 1 
:give_item 
   /delay 5 ${Cursor.ID} 
   /if ( ${Cursor.ID} && !${InvSlot[trade4].Item.ID} ) { 
      /if ( ${Cursor.Name.Find[summoned:]} ) { 
         /click left target 
         /delay 1s ${InvSlot[trade${i}].Item.ID} 
      } else { 
         /autoinventory 
      } 
      /goto :give_item 
   } 
   /for i 1 to 4 
      /if ( ${InvSlot[trade${i}].Item.ID} && !${InvSlot[trade${i}].Item.Name.Find[summoned:]} ) /notify GiveWnd GVW_Cancel_Button leftmouseup 
   /next i 
   /if ( ${Window[GiveWnd].Open} ) { 
      /notify GiveWnd GVW_Give_Button leftmouseup 
      /delay 5s !${Window[GiveWnd].Open} 
   } 
   /if ( ${Window[InventoryWindow].Open} ) /keypress inventory 
/return 

Sub Event_RageOn(string line) 
   /declare tempID int local ${Target.ID} 
   /if ( ${Spawn[${mobID}].ID} ) /varset tempID ${mobID} 
   /if ( ${line.Find[${Spawn[${tempID}].DisplayName}]} && ${Me.Pet.ID} ) { 
      /i say calling off pet... 
      /pet back off 
   } 
/return 

Sub Event_RageOff(string line) 
   /declare tempID int local ${Target.ID} 
   /if ( ${Spawn[${mobID}].ID} ) /varset tempID ${mobID} 
   /if ( ${line.Find[${Spawn[${tempID}].DisplayName}]} && ${Me.Pet.ID} ) { 
      /target id ${tempID} 
      /pet attack 
   } 
/return 

Sub Event_Gate(string line) 
   /if ( ${line.Find[${Spawn[${mobID}].DisplayName}]} && ${Me.Pet.ID} ) { 
      /varset mobID 0 
   } 
/return 


Sub Event_Coth(string line,string sender,string name) 
   /if ( !${Defined[name]} ) /declare name string local 
   /declare i int local 
   /declare inGroup bool local false 
   /if ( !${Spawn[pc ${name}].ID} ) { 
      /if ( ${Spawn[pc ${sender}].ID} ) { 
         /varset name ${sender} 
      } else { 
         /return 
      } 
   } 
   /for i 1 to 5 
      /if ( ${Group[${i}].Name.Find[${name}]} ) /varset inGroup true 
   /next i 
   /if ( ${inGroup} ) { 
      /call AddToQueue "coth,${name}" 
   } else /if ( ${Group.Leader.ID}==${Me.ID} ) { 
      /target pc ${name} 
      /keypress invite_follow 
      /delay 5s ${Group[1].Name.Equal[${name}]} || ${Group[2].Name.Equal[${name}]} || ${Group[3].Name.Equal[${name}]} || ${Group[4].Name.Equal[${name}]} || ${Group[5].Name.Equal[${name}]} 
      /for i 1 to 5 
         /if ( ${Group[${i}].Name.Equal[${name}]} ) /varset inGroup true 
      /next i 
      /if ( ${inGroup} ) /call AddToQueue "coth,${name}" 
   } 
/return 

Sub Event_Timer(string timerName,int timerValue) 
   /if ( !${Defined[${timerName}]} ) /return 
   /declare tempID int local 0 
   /declare oldTargetID int local ${Target.ID} 
   /if ( ${timerName.Left[9].Equal[maloTimer]} ) { 
      /varset tempID ${timerName.Right[-9]} 
      /if ( ${Spawn[${tempID}].Type.Equal[NPC]} ) { 
         /target id ${tempID} 
         /call Malo 
      } else { 
         /deletevar ${timerName} 
      } 
   } else { 
      /return ${Macro.Return} 
   } 
   /if ( ${Target.ID}==${tempID} ) { 
      /if ( ${Spawn[${oldTargetID}].ID} ) { 
         /target id ${oldTargetID} 
      } else { 
         /keypress clear_target 
      } 
   } 
/return ${Macro.Return} 

Sub Event_PetWeps(string line,string sender) 
   /declare tempID int local ${Spawn[pc ${sender}].Pet.ID} 
   /if ( !${tempID} || ${Spawn[${tempID}].Distance3D}>250 || !${Spawn[${tempID}].LineOfSight} ) /return 
   /target id ${tempID} 
   /if ( ${Stick.Status.Length} ) { 
      /stick 10 
      /delay 5s ${Target.Distance3D}<=10 
   } else { 
      /declare tempTimer timer local 5s 
   :move_to_pet 
      /face fast nolook 
      /keypress forward hold 
      /if ( ${tempTimer} && ${Target.Distance3D}<=20 ) /goto :move_to_pet 
      /keypress forward 
   } 
   /call SumWeps 
   /if ( ${Spawn[pc ${followName} radius 150].ID} && ${Stick.Status.Equal[off]} ) { 
      /target pc ${followName} 
      /stick hold 10 
   } 
/return

Sub Event_PetType(string line,string pet)
/echo set: PetType ${pet}
/return

Sub Event_SetVar(string line,string varName,string value)
   /if ( ${value.Equal[on]} ) /varset value 1
   /if ( ${value.Equal[off]} ) /varset value 0
   /if ( ${value.Equal[fir]} && ${PetType.Equal[fir]} || ${value.Equal[fire]} && ${PetType.Equal[fire]} ) /return
   /if ( ${value.Equal[wat]} && ${PetType.Equal[wat]} ||  ${value.Equal[water]} && ${PetType.Equal[water]}  ) /return
   /if ( ${value.Equal[air]} && ${PetType.Equal[air]} || ${value.Equal[wind]} && ${PetType.Equal[wind]}) /return
   /if ( ${value.Equal[ear]} && ${PetType.Equal[ear]} || ${value.Equal[earth]} && ${PetType.Equal[earth]}) /return
   /if ( ${Defined[${varName}]} && ${value.Equal[ear]} || ${value.Equal[air]} || ${value.Equal[wat]} || ${value.Equal[fir]} ||  ${value.Equal[earth]} || ${value.Equal[wind]} || ${value.Equal[water]} || ${value.Equal[fire]} ) {

       /varset ${varName} ${value}
       /popup ${varName} is set to ${value} now.
	   /ini "${iniName}" Settings ${varName} "${value}"
      /return
}  else /if ( ${Defined[${varName}]} && !${varName.Equal[PetType]} ) {
      /varset ${varName} ${value}
     /popup ${varName} is set to ${value} now.
      /ini "${iniName}" Settings "${varName.Left[1].Upper}${varName.Right[-1]}" "${value}"
	  /echo part2,  /ini "${iniName}" Settings "${varName.Left[1].Upper}${varName.Right[-1]}" "${value}"
   }
/return

Sub Event_Invite(string line,string sender)
/if (${announce}) /${mychannel} i've been invited by ${sender}
/declare Master string local
/varset Master ${Ini[${iniName},Settings,MasterList,NOTFOUND]}
/if (${Master.Find[${sender}]}) /squelch /invite
/return

Sub Event_Burninate
/call NamedBurn
/return

Sub NamedBurn
/varset OldState ${MacroState}
/varset MacroState NamedBurn
/echo Named is here, Burn Baby Burn! Raging Pet away!
/if ( ${Target.LineOfSight} && ${Target.Type.Equal[NPC]} ) {
  /declare MyTarget int local
  /varset MyTarget ${Target.ID}
    /pet attack
   /call Cast "${ServantNuke}" gem4 2s CheckEvents
  /delay 1s
:namedburnloop
/varset MacroState NamedBurnLoop
/if ( ${Me.AltAbilityReady[Frenzied Burnout]} ) /casting "Frenzied Burnout" Alt 2s CheckPet
/if ( ${Me.SpellReady[${TwincastSpell}]} && ${Me.PctMana}>=30 && ${Target.Named}) /casting "${TwincastSpell}" gem0 2s CheckEvents 
    /if ( ( !${Me.SpellReady[${nuke1}]} || !${Me.SpellReady[${nuke2}]} ) && !${Bool[${FindItem[${ParadoxRodName}].Timer}]} )  /call PotionCast "${ParadoxRodName}" ${ParadoxPotionSlot}

      /if  ( ${Me.SpellReady[${nuke1}]} && ${Me.CurrentMana}>=${Spell[${nuke1}].Mana}) /call Cast "${nuke1}" gem1 2s CheckEvents

       /if ( ${Me.SpellReady[${nuke2}]} && ${Me.CurrentMana}>=${Spell[${nuke2}].Mana} ) /call Cast "${nuke2}" gem4 2s CheckEvents

      /if ( ${Me.SpellReady[${nuke3}]} && ${Me.CurrentMana}>=${Spell[${nuke3}].Mana} ) /call Cast "${nuke3}" gem5 2s CheckEvents

     /if  ( ${Me.SpellReady[${ServantNuke}]} && ${Me.CurrentMana}>=${Spell[${ServantNuke}].Mana} ) /call Cast "${ServantNuke}" gem4 2s CheckEvents
           /if  (${Target.ID}==${MyTarget} ) /goto :namedburnloop
}
/echo Named is toast, returning to ${OldState}
/return

Sub Event_FlameOfPower
/if ( ${Me.Song[Gift of Amazing Exquisite Radiant Mana].ID} ) /call Event_GiftofMana
/if ( !${Me.Song[Flames of Power].ID} ) /return
/varset OldState ${MacroState}
/varset MacroState FlameOfPower
:stillhavepower
/if ( !${Target.Type.Equal[NPC]} ) /return
/if (${Me.Song[Flames of Power].ID} && ${Me.CurrentMana}>=${Spell[${boltNuke}].Mana}) {
 /call Cast "${boltNuke}" gem2 CheckEvents
}
/if  ( !${Target.ID} ) /return
/if (${Me.Song[Flames of Power].ID}) /goto :stillhavepower
/echo Flame of Power Done returning to ${OldState}
/return

Sub Event_GiftOfMana
/if ( !${Me.Song[Gift of Amazing Exquisite Radiant Mana].ID} ) /return
/if ( ${Target.ID} == ${Me.Pet.ID} ) /target id ${mobID}
/varset OldState ${MacroState}
/varset MacroState GoMSub
/echo GoM, Attempting to Send the Raging Pet or casting ${GoMNuke}!
/delay 2s
:StayInGoM
/if (${Me.Song[Gift of Amazing Exquisite Radiant Mana].ID} && ${Me.SpellReady[${ServantNuke}]} && ${Me.CurrentMana}>=${Spell[${ServantNuke}].Mana} ) /call Cast "${ServantNuke}" gem5 2s CheckEvents
/if (${Me.Song[Gift of Amazing Exquisite Radiant Mana].ID} && ${Me.AltAbilityReady[Forceful Rejuvenation]} && !${Me.SpellReady[${ServantNuke}]} ) /casting "Forceful Rejuvenation" alt 2s
/if (${Me.Song[Gift of Amazing Exquisite Radiant Mana].ID} && !${Me.SpellReady[${ServantNuke}]} && ${Me.CurrentMana}>=${Spell[${GoMNuke}].Mana} && ${Me.SpellReady[${GoMNuke}]}   ) /call Cast "${GoMNuke}" gem2 2s CheckEvents
/if ( !${Target.Type.Equal[NPC]} ) /return
/if ( ${Me.Song[Gift of Amazing Exquisite Radiant Mana].ID} ) /goto :StayInGoM
/echo GoM done returning to ${OldState}
/return

Sub event_nukebranch(Line, Command)
	/if (!${Command.Equal[fire]} && !${Command.Equal[bane]} && !${Command.Equal[magic]} && !${Command.Equal[rain]} && !${Command.Equal[beam]} && !${Command.Equal[standard]}) {
		/echo Invalid selection. Valid options are Fire, Magic, Bane, Rain, Beam, or Standard (original style!)
		/return
	}
	/ini "${iniName}" Settings NukeBranch "${Command}"
	/varset NukeBranch ${Command}
	/call SpellBranch
	/echo Spellset changed to ${Command}
	/popup NukeBranch changed to ${Command}
/return

Sub SpellBranch
	/if (${NukeBranch.Equal[fire]}) {
		/echo nukes set to fire
        /varset NukeLine 1
		/call InitializeNukes
	}
	/if (${NukeBranch.Equal[magic]}) {
		/echo nukes set to magic
	    /varset NukeLine 2
		/call InitializeNukes
	}
	/if (${NukeBranch.Equal[bane]}) {
		/echo nukes set to bane
        /varset NukeLine 3
		/call InitializeNukes
	}
		/if (${NukeBranch.Equal[rain]}) {
		/echo nukes set to rain
        /varset NukeLine 4
		/call InitializeNukes
	}
		/if (${NukeBranch.Equal[beam]}) {
		/echo nukes set to beam
        /varset NukeLine 5
		/call InitializeNukes
	}
	/if (${NukeBranch.Equal[standard]}) {
		/echo nukes set to standard
        /varset NukeLine 6
		/call InitializeNukes
	}
/return

Sub InitializeNukes
/varset MacroState InitializeNukes
/if ( ${NukeLine}==1 || ${NukeLine}==6 ) {
  /varset MacroState InitializeFireOrStandard
   /if ( !${Me.Gem[${nuke1}]} ) {
      /memspell 1 "${nuke1}"
      /delay 10s ${Me.Gem[${nuke1}]}
	}

     	/if ( !${Me.Gem[${nuke2}]} ) {
         /memspell 4 "${nuke2}"
         /delay 10s ${Me.Gem[${nuke2}]}
     	}	

			/if ( !${Me.Gem[${nuke3}]} ) {
			 /memspell 5 "${nuke3}"
			 /delay 10s ${Me.Gem[${nuke3}]}
			}
				/if ( !${Me.Gem[${boltNuke}]} ) {
				 /memspell 2 "${boltNuke}"
				 /delay 10s ${Me.Gem[${boltNuke}]}
				}
					/if ( !${Me.Gem[${ServantNuke}]} ) {
					 /memspell 3 "${ServantNuke}"
					 /delay 10s ${Me.Gem[${ServantNuke}]}
					}
/return 
}

/if ( ${NukeLine}==2 ) {
  /varset MacroState InitializeMagic
    /if ( !${Me.Gem[${magicNuke}]} ) {
      /memspell 1 "${magicNuke}"
      /delay 10s ${Me.Gem[${magicNuke}]}
	}
		/if ( !${Me.Gem[${magicNuke2}]} ) {
         /memspell 4 "${magicNuke2}"
         /delay 10s ${Me.Gem[${magicNuke2}]}
     	}	

			/if ( !${Me.Gem[${malosiniaSpell}]} ) {
			 /memspell 5 "${malosiniaSpell}"
			 /delay 10s ${Me.Gem[${malosiniaSpell}]}
			}
					/if ( !${Me.Gem[${ServantNuke}]} ) {
					 /memspell 3 "${ServantNuke}"
					 /delay 10s ${Me.Gem[${ServantNuke}]}
					}
/return
}

/if ( ${NukeLine}==3 ) {
   /varset MacroState InitializeBane
    /if ( !${Me.Gem[${annihilateNuke}]} ) {
      /memspell 1 "${annihilateNuke}"
      /delay 10s ${Me.Gem[${annihilateNuke}]}
	}
		/if  !${Me.Gem[${annihilateNuke2}]} ) {
         /memspell 4 "${annihilateNuke2}"
         /delay 10s ${Me.Gem[${annihilateNuke2}]}
     	}	

			/if ( !${Me.Gem[${malosiniaSpell}]} ) {
			 /memspell 5 "${malosiniaSpell}"
			 /delay 10s ${Me.Gem[${malosiniaSpell}]}
			}
					/if ( !${Me.Gem[${ServantNuke}]} ) {
					 /memspell 3 "${ServantNuke}"
					 /delay 10s ${Me.Gem[${ServantNuke}]}
					}
/return
}
/if ( ${NukeLine}==4 ) {
   /varset MacroState InitializeRain
    /if ( !${Me.Gem[${rainNuke}]} ) {
      /memspell 1 "${rainNuke}"
      /delay 10s ${Me.Gem[${rainNuke}]}
	}
		/if ( !${Me.Gem[${rainNuke2}]} ) {
         /memspell 4 "${rainNuke2}"
         /delay 10s ${Me.Gem[${rainNuke2}]}
     	}	

			/if ( !${Me.Gem[${malosiniaSpell}]} ) {
			 /memspell 5 "${malosiniaSpell}"
			 /delay 10s ${Me.Gem[${malosiniaSpell}]}
			}
					/if ( !${Me.Gem[${ServantNuke}]} ) {
					 /memspell 3 "${ServantNuke}"
					 /delay 10s ${Me.Gem[${ServantNuke}]}
					}
/return
}

/if ( ${NukeLine}==5 ) {
   /varset MacroState InitializeBeam
    /if ( !${Me.Gem[${BeamNuke}]} ) {
      /memspell 1 "${BeamNuke}"
      /delay 10s ${Me.Gem[${BeamNuke}]}
	}
			/if ( !${Me.Gem[${malosiniaSpell}]} ) {
			 /memspell 5 "${malosiniaSpell}"
			 /delay 10s ${Me.Gem[${malosiniaSpell}]}
			}
					/if ( !${Me.Gem[${ServantNuke}]} ) {
					 /memspell 3 "${ServantNuke}"
					 /delay 10s ${Me.Gem[${ServantNuke}]}
					}
/return
}
/return

Sub Irc
/Call DeclareIniVar IRCServer string Settings ""
/Call DeclareIniVar IRCChannel string Settings ""
	 /i quit
	 /iconnect ${IRCServer} ${IRCCchannel} ${Me}
 	/timed 30 /i join #${IRCChannel}
	/varset irctimer 30s
/return

Sub CheckEvents
   /doevents
   /doevents IRC
   /doevents Chat
   /doevents tell
/return


Sub MageDPS
   /if (${Zone.ShortName.Equal[crystallos_raid]} && ${Spawn[Tempest of Vyskudra].ID} && ${Spawn[Tempest of Vyskudra].Distance}>30) /call MoveToTornado
     /if ( ${Me.Song[Gift of Amazing Exquisite Radiant Mana].ID} ) /call Event_GiftOfMana
|	  /call CheckBuffs
             /varset MacroState MageDPS
             /call CheckEvents
                   /varset MacroState MageTwinCastCheck
                /if ( ${Me.SpellReady[${TwincastSpell}]} && ${Me.PctMana}>=30 ) {
                   /casting "${TwincastSpell}" gem10 2s CheckEvents
                   /varset MacroState MageTwinCastCheckExit
               } else {
                /varset MacroState PetRejuv
                 /if ( ${Me.Pet.PctHPs}<=95 && ${PetTank} && !${Me.PetBuff[${PetRenewalSpell}]} ) {
                     /call Cast "${PetRenewalSpell}" ${PetRenewalType} 2s CheckEvents
                  /varset MacroState PetRejuvExit
               } else {
                 /varset MacroState CheckHealPet
                /if ( ${Me.Pet.PctHPs}<=60 && ${PetTank} ) {
                   /call Cast "${PetHealSpell}" ${PetHealType} 2s CheckEvents
                   /varset MacroState CheckHealPetExit
                } else {
                  /varset MacroState IceSliver
                 /if ( !${Me.SpellReady[${nuke2}]} && ${FindItem[${ParadoxRodName}].ID} && !${Bool[${FindItem[${ParadoxRodName}].Timer}]} ) {
                 /echo Casting: ${ParadoxRodName} on >> ${Target.CleanName} <<
                 /call PotionCast "${ParadoxRodName}" ${ParadoxPotionSlot}
                     /varset MacroState IceSliverExit
               } else {
                  /varset MacroState Annihilate
                               /if ( !${Me.SpellReady[${nuke1}]} && !${Me.SpellReady[${nuke2}]} && ${Me.CurrentMana}>=${Spell[${nuke3}].Mana} && ${Me.SpellReady[${nuke3}]} ) /call Cast "${nuke3}" gem5 15 CheckEvents
                /if ( ${Me.Gem[${annihilateNuke}]} && ${Me.CurrentMana}>=${Spell[${annihilateNuke}].Mana} && ${Me.SpellReady[${annihilateNuke}]} && ( ${Target.Body.ID}==24 || ${Target.Body.ID}==5 )) /call Cast "${annihilateNuke}" gem5 2s CheckEvents
                 /if ( ${Me.Gem[${annihilateNuke2}]} && !${Me.SpellReady[${annihilateNuke}]} && ${Me.SpellReady[${annihilateNuke2}]} && ( ${Target.Body.ID}==24 || ${Target.Body.ID}==5 )) /call Cast "${annihilateNuke2}" gem1 2s CheckEvents
               /if ( ${Me.CurrentMana}>=${Spell[${nuke1}].Mana} && ${Me.SpellReady[${nuke1}]}) /call Cast "${nuke1}" gem1 2s CheckEvents
                   /varset MacroState AnnihilateExit
                /call CheckEvents
               /if ( !${Me.SpellReady[${nuke1}]} && ${Me.Gem[${nuke2}]} && ${Me.CurrentMana}>=${Spell[${nuke2}].Mana} && ${Me.SpellReady[${nuke2}]} && ( ${Target.Body.ID}!=24 || ${Target.Body.ID}!=5 )) /call Cast "${nuke2}" gem5 0 CheckEvents

                  /call CheckEvents
               /if ( ${Macro.Return.Equal[CAST_SUCCESS]} || ${Macro.Return.Equal[CAST_RESISTED]} ) { 
                 
                  /if ( ${nukeMode}==1 ) { 
                     /varcalc nukeWaitMod 2*(90 - ${Me.PctMana}) 
                  } else { 
                     /varset nukeWaitMod 0                
                  } 
                  /if ( ${nukeDelay}>${nukeWaitMod} ) { 
                     /varset nukeWaitTimer ${nukeDelay} 
                  } else { 
                     /varset nukeWaitTimer ${nukeWaitMod} 
                  } 
            } 
          }
      } 
   }
 }
        /if ( !${Me.Pet.ID} && ${usePet} && !${petOff} && ${Me.CurrentMana}>=400 ) /call SumPet 
/return

Sub MagicBranch
/varset MacroState Magic
    /declare MyTarget int local
  /varset MyTarget ${Target.ID}
    :KeepMagic
|	/call CheckBuffs
	    /if ( !${Me.Pet.ID} && ${usePet} && !${petOff} && ${Me.CurrentMana}>=400 ) /call SumPet 
  /if (${Zone.ShortName.Equal[crystallos_raid]} && ${Spawn[Tempest of Vyskudra].ID} && ${Spawn[Tempest of Vyskudra].Distance}>30) /call MoveToTornado
  /if ( ${Me.Song[Gift of Amazing Exquisite Radiant Mana].ID} ) /call Event_GiftOfMana
	 /if ( ${Me.SpellReady[${TwincastSpell}]} && ${Me.PctMana}>=30 ) /casting "${TwincastSpell}" gem10 2s
   /if ( ${Me.Pet.PctHPs}<=95 && !${Me.PetBuff[${PetRenewalSpell}]} ) /call Cast "${PetRenewalSpell}" ${PetRenewalType} 2s CheckEvents
  /if ( ${Me.Gem[${magicNuke}]} && ${Me.CurrentMana}>=${Spell[${magicNuke}].Mana} && ${Me.SpellReady[${magicNuke}]} ) /call Cast "${magicNuke}" gem1 2s CheckEvents
      /if ( !${Me.SpellReady[${magicNuke}]} && !${Me.SpellReady[${magicNuke2}]} && ${FindItem[${ParadoxRodName}].ID} && !${Bool[${FindItem[${ParadoxRodName}].Timer}]} ) {
                 /echo Casting: ${ParadoxRodName} on >> ${Target.CleanName} <<
                 /call PotionCast "${ParadoxRodName}" ${ParadoxPotionSlot}
               }
   /if ( ${Me.Gem[${magicNuke2}]} && ${Me.CurrentMana}>=${Spell[${magicNuke2}].Mana} && ${Me.SpellReady[${magicNuke2}]} && !${Me.SpellReady[${magicNuke}]} ) /call Cast "${magicNuke2}" gem2 2s CheckEvents
     /if ( ${Target.ID}==${MyTarget} ) /goto :KeepMagic
   /return

Sub FireBranch
    /declare MyTarget int local
  /varset MyTarget ${Target.ID}
  /if ( !${Me.Gem[${nuke1}]} ) /memspell 5 "${nuke1}"
    /delay 10s ${Me.Gem[${nuke1}]}
  /if ( !${Me.Gem[${nuke2}]} ) /memspell 4 "${nuke2}"
     /delay 10s ${Me.Gem[${nuke2}]}
  /if ( !${Me.Gem[${nuke3}]} ) /memspell 1 "${nuke3}"
     /delay 10s ${Me.Gem[${nuke3}]}
  /if ( !${Me.Gem[${boltNuke}]} ) /memspell 2 "${boltNuke}"
     /delay 10s ${Me.Gem[${boltNuke}]}
	 :KeepFireBranch
|	   /call CheckBuffs
	   /if ( !${Me.Pet.ID} && ${usePet} && !${petOff} && ${Me.CurrentMana}>=400 ) /call SumPet 
  /if (${Zone.ShortName.Equal[crystallos_raid]} && ${Spawn[Tempest of Vyskudra].ID} && ${Spawn[Tempest of Vyskudra].Distance}>30) /call MoveToTornado
  /if ( ${Me.Song[Gift of Amazing Exquisite Radiant Mana].ID} ) /call Event_GiftOfMana
  /varset MacroState FireBranch
|  /if (!${FindItem[${ModRodName}].ID}) /call CheckBuffs
    /if ( !${Target.ID} ) /return
  /if ( ${Me.SpellReady[${TwincastSpell}]} && ${Me.PctMana}>=20 ) {
  /casting "${TwincastSpell}" gem10 2s CheckEvents
  /delay 2s ${Me.SpellReady[${nuke1}]}
  }
  /if ( ${Me.Pet.PctHPs}<=95 && !${Me.PetBuff[${PetRenewalSpell}]} ) /call Cast "${PetRenewalSpell}" ${PetRenewalType} 2s CheckEvents
  	 /if ( ${dorain} && ${Target.ID}==${MyTarget} && ${Me.CurrentMana}>=${Spell[${FireRainNuke}].Mana} && !${FireRainTimer}) {
	 /delay 2s ${Me.SpellReady[${FireRainNuke}]}
	 /call Cast "${FireRainNuke}" gem7 2s CheckEvents
	 /varset FireRainTimer 14s	 
	 }
  /if ( !${Me.SpellReady[${nuke2}]} && !${Me.SpellReady[${nuke1}]} && ${FindItem[${ParadoxRodName}].ID} && !${Bool[${FindItem[${ParadoxRodName}].Timer}]} && ${Target.ID}==${MyTarget} ) {
                 /echo Casting: ${ParadoxRodName} on >> ${Target.CleanName} <<
                 /call PotionCast "${ParadoxRodName}" ${ParadoxPotionSlot}
               }
     /if ( ${Me.CurrentMana}>=${Spell[${nuke1}].Mana} && ${Me.SpellReady[${nuke1}]} && ${Target.ID}==${MyTarget}) {
   	 /call Cast "${nuke1}" gem1 2s CheckEvents
	  /echo nuke1 done
	 /delay 5s !${Me.Casting.ID}
	    /if ( ${FindItem[${ParadoxRodName}].ID} && !${Bool[${FindItem[${ParadoxRodName}].Timer}]} && ${Target.ID}==${MyTarget}) {
		/call PotionCast "${ParadoxRodName}" ${ParadoxPotionSlot}
		/echo paradox cast from nuke1
		}
		 /echo waiting for nuke2
		/delay 5s ${Me.SpellReady[${nuke2}]}
	 }
	}
	 /if ( !${Target.ID} ) /return
     /if ( ${Me.Gem[${nuke2}]} && ${Me.CurrentMana}>=${Spell[${nuke2}].Mana} && ${Me.SpellReady[${nuke2}]} && ${Target.ID}==${MyTarget} ) {
   	 /call Cast "${nuke2}" gem2 1s CheckEvents
	 /delay 5s !${Me.Casting.ID}
	   /echo nuke2 done
	    /if ( ${FindItem[${ParadoxRodName}].ID} && !${Bool[${FindItem[${ParadoxRodName}].Timer}]} && ${Target.ID}==${MyTarget}) {
		/call PotionCast "${ParadoxRodName}" ${ParadoxPotionSlot}
             /echo Paradox cast from nuke2	
	}
	   /echo waiting for nuke3
	/delay 5s ${Me.SpellReady[${nuke3}]}
	 
	}
	/if ( !${Target.ID} ) /return
     /if ( ${Me.CurrentMana}>=${Spell[${nuke3}].Mana} && ${Target.ID}==${MyTarget}) {
	 /call Cast "${nuke3}" gem4 1s CheckEvents
	 /delay 5s !${Me.Casting.ID}
	    /if ( ${FindItem[${ParadoxRodName}].ID} && !${Bool[${FindItem[${ParadoxRodName}].Timer}]} && ${Target.ID}==${MyTarget}) {
		/call PotionCast "${ParadoxRodName}" ${ParadoxPotionSlot}
		 /echo Paradox cast from nuke3
	 }
	 }
	 /if ( !${Target.ID} ) /return
	 /if ( ${Me.CurrentMana}>=${Spell[${manyNuke}].Mana} && !${ManyTimer} && ${Target.ID}==${MyTarget} ) {
	 /delay 2s ${Me.SpellReady[${manyNuke}]}
	 /call Cast "${manyNuke}" gem5 2s CheckEvents
	 /varset ManyTimer 10s
	 }
	 /delay 5s !${Me.Casting.ID}
	    /if ( ${FindItem[${ParadoxRodName}].ID} && !${Bool[${FindItem[${ParadoxRodName}].Timer}]} && ${Target.ID}==${MyTarget} ) {
		/call PotionCast "${ParadoxRodName}" ${ParadoxPotionSlot}
		/echo Paradox cast from END
	 }
	 /if ( !${Target.ID} ) /return
	 /if ( ${Me.AltAbilityReady[Servant of Ro]} && ${Target.ID}==${MyTarget} ) {
	  /if ( ${Me.Casting.ID} ) /delay 5s !${Me.Casting.ID} 
	 /call Cast "Servant of Ro" Alt
	  /echo Servant of Ro!!!! PWN3D!
	 }
	 /if (${Me.Dead}) /call Wait4Rez
  /if ( ${Target.ID}==${MyTarget} ) /goto :KeepFireBranch	   
/return

Sub BaneBranch
    /declare MyTarget int local
  /varset MyTarget ${Target.ID}
  /if ( ${Me.Song[Gift of Amazing Exquisite Radiant Mana].ID} ) /call Event_GiftOfMana
  :KeepBane
|    /call CheckBuffs
  /varset MacroState BaneBranch
     /if ( !${Me.Pet.ID} && ${usePet} && !${petOff} && ${Me.CurrentMana}>=400 ) /call SumPet 
  /if ( ${Me.SpellReady[${TwincastSpell}]} && ${Me.PctMana}>=30 ) /casting "${TwincastSpell}" gem10 2s
  /if ( ${Me.Pet.PctHPs}<=95 && !${Me.PetBuff[${PetRenewalSpell}]} ) /call Cast "${PetRenewalSpell}" ${PetRenewalType} 2s CheckEvents
  /if ( ${Me.Gem[${annihilateNuke}]} && ${Me.CurrentMana}>=${Spell[${annihilateNuke}].Mana} && ${Me.SpellReady[${annihilateNuke}]} ) /call Cast "${annihilateNuke}" gem1 2s CheckEvents
   /if ( ${Me.Gem[${annihilateNuke2}]} && ${Me.CurrentMana}>=${Spell[${annihilateNuke2}].Mana} && ${Me.SpellReady[${annihilateNuke2}]} ) /call Cast "${annihilateNuke2}" gem4 2s CheckEvents
/if ( ${Target.ID}==${MyTarget} ) /goto :KeepBane
/return

Sub RainBranch
    /declare MyTarget int local
  /varset MyTarget ${Target.ID}
	 :KeepRain
|	 /call CheckBuffs
	 /if ( !${Me.Pet.ID} && ${usePet} && !${petOff} && ${Me.CurrentMana}>=400 ) /call SumPet 
   /if (${Zone.ShortName.Equal[crystallos_raid]} && ${Spawn[Tempest of Vyskudra].ID} && ${Spawn[Tempest of Vyskudra].Distance}>30) /call MoveToTornado
   /if ( ${Me.Song[Gift of Amazing Exquisite Radiant Mana].ID} ) /call Event_GiftOfMana
   /varset MacroState RainBranch
   /if ( ${Me.Pet.PctHPs}<=95 && !${Me.PetBuff[${PetRenewalSpell}]} ) /call Cast "${PetRenewalSpell}" ${PetRenewalType} 2s CheckEvents
   /if ( ${Me.Gem[${rainNuke}]} && ${Me.CurrentMana}>=${Spell[${rainNuke}].Mana} && ${Me.SpellReady[${rainNuke}]} ) /call Cast "${rainNuke}" gem1 2s CheckEvents
   /if ( ${Me.Gem[${rainNuke2}]} && ${Me.CurrentMana}>=${Spell[${rainNuke2}].Mana} && ${Me.SpellReady[${rainNuke2}]} ) /call Cast "${rainNuke2}" gem1 2s CheckEvents
    /if ( ${Target.ID}==${MyTarget} ) /goto :KeepRain
/return

Sub BeamBranch
    /declare MyTarget int local
  /varset MyTarget ${Target.ID}
	 :KeepBeam
|	  /call CheckBuffs
	 /face fast
	/if ( !${Me.Pet.ID} && ${usePet} && !${petOff} && ${Me.CurrentMana}>=400 ) /call SumPet  
   /if (${Zone.ShortName.Equal[crystallos_raid]} && ${Spawn[Tempest of Vyskudra].ID} && ${Spawn[Tempest of Vyskudra].Distance}>30) /call MoveToTornado
   /if ( ${Me.Song[Gift of Amazing Exquisite Radiant Mana].ID} ) /call Event_GiftOfMana
   /varset MacroState BeamBranch
   /if ( ${Me.Pet.PctHPs}<=95 && !${Me.PetBuff[${PetRenewalSpell}]} ) /call Cast "${PetRenewalSpell}" ${PetRenewalType} 2s CheckEvents
   /if  ( ${Me.Gem[${BeamNuke}]} && ${Me.CurrentMana}>=${Spell[${BeamNuke}].Mana} && ${Me.SpellReady[${BeamNuke}]} ) /call Cast "${BeamNuke}" gem1 2s CheckEvents
     /if ( ${Target.ID}==${MyTarget} &&  ${Target.ID}<>${Me.Pet.ID} ) /goto :KeepBeam
/return

Sub PotionCast(string ItemName, int Slot)
/varset MacroState PotionCast
/if ( !${Defined[CastSlot]} ) /declare CastSlot int local ${Slot}
/varcalc Slot (${Slot}-1)
 /if ( ${Window[PotionBeltWnd].Child[PW_PotionSlot${Slot}_Button].Tooltip.Equal[${ItemName}]} && !${Bool[${FindItem[${ItemName}].Timer}]} && ${Bool[${FindItem[${ItemName}]}]}) /potionbelt Activate ${CastSlot}
/return



Sub IniDeclares   
/Call DeclareIniVar UseIRC string Settings 0
/if (${UseIRC}) /call Irc
   /Call DeclareIniVar mychannel string Settings "" /mychannel
   /Call DeclareIniVar MasterList string Settings ""
   /Call DeclareIniVar announce int Settings 0 /useannounce
   
   /call DeclareIniVar dorain int Settings 0 /dorain
   /call DeclareIniVar DoLeash int Settings 0
   /call DeclareIniVar useEpic int Settings 1
   /call DeclareIniVar mainAssist string Settings 
   /call DeclareIniVar secondAssist string Settings 
   /call DeclareIniVar minRadius int Settings 150 /radius 
   /call DeclareIniVar engageDelay int Settings 55 /engagedelay 
   /call DeclareIniVar minHP int Settings 95 /minhp 
   /call DeclareIniVar autosit int Settings 1
   /call DeclareIniVar autoBuff int Settings 1 /buff 
   /call DeclareIniVar useMount int Settings 1 /mount 
   /call DeclareIniVar useDebuff int Settings 1 /debuff 
   /call DeclareIniVar nukeMode int Settings 1 /nuke 
   /call DeclareIniVar useCharm int Settings 0 /charm 
   /call DeclareIniVar useDPS int Settings 0 /dps 
   /call DeclareIniVar usePet int Settings 1 /companion 
   /call DeclareIniVar privateChannel string Settings "/i say" 
   /call DeclareIniVar channelAnnounce int Settings 1 
   /call DeclareIniVar autoAnnounce string Settings 1  
   /call DeclareIniVar noInterrupt int Settings 0 
   /call DeclareIniVar useManaStone int Settings 0 
   /call DeclareIniVar checkNamed int Settings 0 /checknamed 
   /call DeclareIniVar noInvis int Settings 1 
   /call DeclareIniVar useManaRobe int Settings 0 
   /call DeclareIniVar manaRobeMode int Settings 0 
   /call DeclareIniVar manaRobeMinMana int Settings 10 
   /call DeclareIniVar manaRobeMaxMana int Settings 94 
   /call DeclareIniVar nukeMana int Settings 25 /nukemana 
   /call DeclareIniVar nukeDelay int Settings 10 /nukedelay 
   /call DeclareIniVar nukeMode int Settings 1 /nukemode 
   /call DeclareIniVar ignoreList string Settings 
   /call DeclareIniVar runeHP int Settings 70 
   /call DeclareIniVar cleanUp int Settings 0 /cleanup 
   /call DeclareIniVar useGroupDS int Settings 0 /ds    
   /call DeclareIniVar clarityBitch string Settings 
   /call DeclareIniVar spellSet string Settings "default" 
   /call DeclareIniVar maloDuration string Settings 19m 
   /call DeclareIniVar resistsTillMala int Settings 3 
   /call DeclareIniVar resistsTillQuit int Settings 4 
   /call DeclareIniVar NukeBranch string Settings "fire"
   /call DeclareIniVar UseSummonWeps string Settings "1"   

   /call DeclareIniVar nuke1 string Spells "Fickle Blaze Rk. II" /nuke1
   /call DeclareIniVar nuke2 string Spells "Torrid Sands Rk. II" /nuke2
   /call DeclareIniVar nuke3 string Spells "Jolt of Many Rk. III" /nuke3
   /call DeclareIniVar magicNuke string Spells "Shock of Cineral Steel Rk. II" 
   /call DeclareIniVar magicNuke2 string Spells "Shock of Discordant Steel Rk. III"
   /call DeclareIniVar fireNuke string Spells "Fickle Blaze Rk. II" 
   /call DeclareIniVar boltNuke string Spells "Bolt of Molten Scoria Rk. II"
   /call DeclareIniVar manyNuke string Spells "Jolt of Many Rk. III"
   /call DeclareIniVar rainNuke string Spells "Deluge of Thunderbolts Rk. II"
   /call DeclareIniVar rainNuke2 string Spells "Shock of Discordant Steel Rk. II"
   /call DeclareIniVar FireRainNuke string Spells "Rain of molten Scoria Rk. II"
   /call DeclareIniVar BeamNuke string Spells "Beam of Molten Scoria Rk. II" 
   /call DeclareIniVar annihilateNuke string Spells "Annihilate the Anomalous"
   /call DeclareIniVar annihilateNuke2 string Spells "Annihilate the Aberrant"
   /call DeclareIniVar ServantNuke string Spells "Rumbling Servant Rk. II"
   /call DeclareIniVar shielding string spells "Prime Shielding Rk. II"
   /call DeclareInivar GoMNuke string Spells "Bolt of Molten Scoria Rk. II"

   /call DeclareIniVar windPet string Spells "Aspect of Air" 
   /call DeclareIniVar earthPet string Spells "Aspect of Earth" 
   /call DeclareIniVar firePet string Spells "Aspect of Fire" 
   /call DeclareIniVar waterPet string Spells "Aspect of Water" 

   /call DeclareIniVar malosiniaSpell string Spells "Malosenea Rk. II" 
   /call DeclareIniVar malosiniaType string Spells "gem6" 
   /call DeclareIniVar malaSpell string Spells "Malosinia" 
   /call DeclareIniVar malaType string Spells "item" 
   /call DeclareIniVar summonedWepSpell string Spells "Summon Prime Armaments" 
   /call DeclareIniVar summonedWepType string Spells "gem8" 
   /call DeclareIniVar summonedBeltSpell string Spells "Summon Plate of the Prime" 
   /call DeclareIniVar summonedBeltType string Spells "gem8" 
   /call DeclareIniVar summonedMaskSpell string Spells "Muzzle of Mardu" 
   /call DeclareIniVar summonedMaskType string Spells "gem8" 
   /call DeclareIniVar groupDSSpell string Spells "" 
   /call DeclareIniVar UseBurstDS int settings 0
   /call DeclareIniVar singleDSSpell string Spells "" 
   /call DeclareIniVar siphonSpell string Spells "Elemental Symbiosis Rk. II" 
   /call DeclareIniVar runeSpell string Spells " " 
   /call DeclareIniVar runeType string Spells " " 
   /call DeclareIniVar pethpSpell string Spells " " 
   /call DeclareIniVar pethpBuff string Spells "item" 
   /call DeclareIniVar pethpType string Spells "" 
   /call DeclareIniVar petHaste string Spells "Burnout VIII" 
   /call DeclareIniVar petHasteType string Spells "gem8"
   /call DeclareIniVar petShrinkSpell string Spells "Tiny Companion" 
   /call DeclareIniVar petShrinkType string Spells "item" 
   /call DeclareIniVar PetProc string Spells "Iceflame Efflux Rk. II"
   /call DeclareIniVar PetProcType string Spells "gem8"
   /call DeclareIniVar SendPetPerc int Settings 99
   /call DeclareIniVar EpicClick string spells "Focus of Primal Elements"
   /call DeclareIniVar EpicPetBuff string Spells "Primal Fusion"
   /call DeclareIniVar rodSpell string Spells "Wand of Ethereal Transvergence"
   /call DeclareIniVar rodType string Spells "gem6"
   /call DeclareIniVar PetTank int Settings 1 /pettank
   /call DeclareIniVar PetType string Settings "air" /pettype
   /call DeclareIniVar PetRune string spells "Grounded Stance Rk. II"
   /call DeclareIniVar PetBlock string spells "Aegis of Kildrukaun"
   /call DeclareIniVar PetHealSpell string Spells "Renewal of Cadwin Rk. II"
   /call DeclareIniVar PetHealType string Spells "gem9"
   /call DeclareIniVar TwincastSpell string Spells "Twincast Rk. II"
   /call DeclareIniVar TwincastType string Spells "gem10"
   /call DeclareIniVar PetRenewalSpell string Spells "Promised Renewal Rk. III"
   /call DeclareIniVar PetRenewalType string Spells "gem7"
   /call DeclareIniVar ParadoxSpell string Spells "Summon Frigid Paradox"
   /call DeclareIniVar ParadoxSpellType string Spells "gem6"
   /call DeclareIniVar ParadoxRodName string Spells "Summoned: Elemental Ice Sliver"
   /call DeclareIniVar ParadoxPotionSlot string Spells "1"

   /call DeclareIniVar selfBuff1 string Buffs "Empyrean Guardian Rk. II" 
   /call DeclareIniVar selfBuffNoStack1 string Buffs "Protection of the Nine,Blessing of the Nine,Steeloak Skin,Blessing of Steeloak" 
   /call DeclareIniVar selfBuff2 string Buffs " " 
   /call DeclareIniVar selfBuffNoStack2 string Buffs " " 
   /call DeclareIniVar selfBuff3 string Buffs " " 
   /call DeclareIniVar selfBuffNoStack3 string Buffs " " 
   /call DeclareIniVar selfBuff4 string Buffs " " 
   /call DeclareIniVar selfBuffNoStack4 string Buffs " " 
   /call DeclareIniVar selfBuff5 string Buffs " " 
   /call DeclareIniVar selfBuffNoStack5 string Buffs " " 
   /call DeclareIniVar buffList1 string Buffs "rod,modrod" 
   /call DeclareIniVar buffName1 string Buffs "Wand of Ethereal Transvergence" 
   /call DeclareIniVar buffType1 string Buffs "gem5" 
   /call DeclareIniVar buffList2 string Buffs "ds,dmg shield,damage shield" 
   /call DeclareIniVar buffName2 string Buffs "ds" 
   /call DeclareIniVar buffType2 string Buffs "gem5" 
   /call DeclareIniVar buffList3 string Buffs " " 
   /call DeclareIniVar buffName3 string Buffs " " 
   /call DeclareIniVar buffType3 string Buffs " " 
   /call DeclareIniVar buffList4 string Buffs " " 
   /call DeclareIniVar buffName4 string Buffs " " 
   /call DeclareIniVar buffType4 string Buffs " " 
   /call DeclareIniVar buffList5 string Buffs " " 
   /call DeclareIniVar buffName5 string Buffs " " 
   /call DeclareIniVar buffType5 string Buffs " " 

   /call DeclareIniVar mountItem string Items "Bridle of the Bloodied Sokokar"
   /call DeclareIniVar hpRobe string Items "${InvSlot[chest].Item.Name}" 
   /call DeclareIniVar clicky1 string Items " " 
   /call DeclareIniVar clickyNoStack1 string Items " " 
   /call DeclareIniVar clicky2 string Items " " 
   /call DeclareIniVar clickyNoStack2 string Items " " 
   /call DeclareIniVar clicky3 string Items " " 
   /call DeclareIniVar clickyNoStack3 string Items " " 
   /call DeclareIniVar clicky4 string Items " " 
   /call DeclareIniVar clickyNoStack4 string Items " " 
   /call DeclareIniVar clicky5 string Items " " 
   /call DeclareIniVar clickyNoStack5 string Items " " 

   /call DeclareIniVar invisItem string Items " " 
   /call DeclareIniVar dispellItem string Items " " 
   /call DeclareIniVar normalMainhand string Items "${InvSlot[mainhand].Item.Name}" 
   /call DeclareIniVar normalOffhand string Items "${InvSlot[offhand].Item.Name}" 
   /call DeclareIniVar hpMask string Items "${InvSlot[face].Item.Name}" 
   /call DeclareIniVar ModRodName string Items "Rod of Ethereal Transvergence"
   /call DeclareIniVar MalosiniaList string Debuff "Malosenea Rk. III|"
   
   /call DeclareIniVar auraName string Aura "Rathe's Strength effect"
   /call DeclareIniVar auraBuff string Aura "Rathe's Strength"
   /call DeclareIniVar auraBuffGem string Aura "gem8"
   /call DeclareIniVar DoBcBuffTotal int BCBuffs 0
   /call DeclareIniVar DoBuffTotal int Buff 0
   /call DeclareIniVar usebuffs int Buff 1
   
   /call BuffQueue
   /call BCBuffs
   
   /squelch /custombind add ma 
   /squelch /custombind add sa 
   /squelch /alias /anchor /echo SetAnchor 
   /squelch /alias /manarobe /echo Mana Robe 
   /squelch /alias /nuketype /echo NukeType 
   /squelch /alias /pettype /echo set: PetType 
   /squelch /alias /setma /custombind set ma /assist 
   /squelch /alias /setsa /custombind set sa /assist 
   /squelch /alias /changebranch /echo changebranch
   /squelch /alias /nukebranch /echo nukebranch
   
      /declare SiphonBuffName string outer
   /declare OldState string outer
   /declare NukeLine int outer
   /declare following int outer 0
   /declare follname string outer NULL
   /declare ManyTimer timer outer 0s
   /declare FireRainTimer timer outer 0s
   /call SpellBranch
   /if (${UseIRC} && !${Irc} && !${irctimer}) /call Irc
   /if (${siphonSpell.Find[Rk. II]} && !${siphonSpell.Find[Rk. III]}) {
     /varset SiphonBuffName "${siphonSpell.Left[-7]} Recourse Rk. II"
   } else /if (${siphonSpell.Find[Rk. III]}) {
     /varset SiphonBuffName "${siphonSpell.Left[-8]}  Recourse Rk. III"
   } else /if (!${siphonSpell.Find[Rk. II]} && !${siphonSpell.Find[Rk. III]}) {
     /varset SiphonBuffName "${siphonSpell} Recourse"
   }
   /if ( ${autoAnnounce} ) /announce on 
   /i say Auto Mage Mode Activated 
   /if ( ${nukeMode} || ${useDebuff} ) { 
      /i say Main Assist: ${mainAssist} 
      /if ( ${Bool[${secondAssist}]} ) /i say Secondary Assist: ${secondAssist} (if ${mainAssist} dies) 
   } 
   /if ( ${nukeMode} || ${useDebuff} ) /i say Will ${If[${useDebuff},malosenea ,]}${If[${nukeMode} && ${useDebuff},then ,]}${If[${nukeMode},start nuking ,]}at ${minHP}% 
   /if ( ${autoBuff} ) /i say Auto Buff is enabled. 
   /if ( ${useMount} ) /i say Mount is enabled. 
/return

Sub ClearMobList 
   /declare i int local 
   /declare mobListID string local 
   /if ( ${mobList.Find[[]} ) { 
      /if ( ${mobList.Find[[]}>1 ) /varset mobList ${mobList.Right[-${Math.Calc[${mobList.Find[[]}-1]}]} 
      /for i 1 to ${mobList.Count[[]} 
         /varset mobListID ${mobList.Arg[${i},[].Left[-1]} 
         /if ( ${Defined[mezTimer${mobListID}]} ) /deletevar mezTimer${mobListID} 
         /if ( ${Defined[slowTimer${mobListID}]} ) /deletevar slowTimer${mobListID} 
         /if ( ${Defined[tashTimer${mobListID}]} ) /deletevar tashTimer${mobListID} 
         /if ( ${Defined[maloTimer${mobListID}]} ) /deletevar maloTimer${mobListID} 
         /if ( ${Defined[waitTimer${mobListID}]} ) /deletevar waitTimer${mobListID} 
         /if ( ${Defined[maloTimer${mobListID}]} ) /deletevar maloTimer${mobListID} 
         /if ( ${Defined[maloResists${mobListID}]} ) /deletevar maloResists${mobListID} 
         /call DeleteFromList mobList ${mobListID} 
         /call DeleteFromList addList ${mobListID} 
      /next i 
   } 
/return

Sub GeneralDeclares 
   /declare bufftimer timer outer 0s
   /declare BcClients string outer
   /declare BcClients2 int outer
   /declare aggroTimer timer outer 
   /declare followName string outer null 
   /declare totalKills int outer 0 
   /declare iniName string outer Auto_${Me.Name}.ini 
   /declare buffQueue string outer 
   /declare normalOffhand string outer ${InvSlot[offhand].Item.Name} 
   /declare uquaAETime float outer 
   /declare totalMeleeDmg int outer 
   /declare totalNonMeleeDmg int outer 
   /declare fightStartTime float outer 
   /declare fightTotalTime float outer 
   /declare deathFlag bool outer ${Math.Calc[!(${InvSlot[chest].Item.ID}>0)]} 
   /declare mobID int outer 0 
   /declare addID int outer 0 
   /declare petAttacking bool outer false 
   /declare i int local 
   /declare j int local 
   /declare addIndex int outer 
   /declare tempStr string local 
   /declare mobList string outer 
   /declare addList string outer 
   /declare newAdds int outer 0 
   /declare assistWaitTimer timer outer 0 
   /declare aggroAnim string outer |5|8|12|17|18|42|44|80|106|144| 
   /declare petCheck bool outer false 
   /declare petID int outer 0 
   /declare tempTimer timer local 0 
   /declare petOff int outer 0 
   /declare useAnchor int outer 
   /declare anchorX float outer 
   /declare anchorY float outer 
   /declare anchorHeading float outer 
   /declare leashLength int outer 
   /declare oldTarget int local 
   /declare modRodTimer timer outer 
   /declare nukeWaitTimer timer outer 0 
   /declare nukeWaitMod int outer 0 
   /declare mainTank string outer 
   /declare castSub string outer 
   /declare validTarget int outer 
   /declare engaged int outer 
   /declare mobHPStart int outer 
   /declare askedForRodTimer timer outer 0 
   /declare petSpamTimer timer outer 
   /declare petMaloTimer timer outer 0 
   /declare maloed bool outer 
   /declare snared bool outer 
   /declare rockNuke string outer 
   /declare fireNuke string outer 
   /declare magicNuke string outer 
   /declare boltNuke string outer 
   /declare coldNuke string outer 
   /declare c6Timer timer outer 
   /declare petMaloTimer2 timer outer 0 
   /declare petOff2 int outer 0 
   /declare irctimer timer outer 0s
/return 

Sub Event_Chat(string ChatType,string Sender,string ChatText)
   /if ((!${ChatType.Equal[${mychannel}]})&&(!${ChatType.Equal[TELL]})&&(!${ChatType.Equal[group]})) /return
   /if (${usegroupchat}==0) /if (${ChatType.Equal[group]}) /return
   /call Event_IRC ${ChatType} ${Sender.Right[-2].Left[-1]} "${ChatText}"
/return

Sub AddToQueue(int Buffee,int BuffNumber)
    /declare a           int local
    /declare Compare     int local
    /if (${QueueCount}<25 && !${Spawn[${Buffee}].Type.Equal[corpse]} && ${Spawn[${Buffee}].ID}) {
       /varset Compare 0
       /for a 1 to 25
          /if ((${Buffee}==${DoBuffQueue[${a},1]} || (${Select[${Spell[${DoBuffID[${DoBuffQueue[${a},2]}]}].TargetType},"Group v2","AE PC v2","Group v1","AE PC v1"]} && (${Group.Member[${Spawn[${Buffee}].CleanName}]} || ${Group.Member[${Spawn[${Buffee}].Master.CleanName}]}) && ${Group.Member[${Spawn[${DoBuffQueue[${a},1]}].CleanName}]})) && ${BuffNumber}==${DoBuffQueue[${a},2]}) /varset Compare 1
       /next a
       /if (!${Compare}) {
          /for a 1 to 25
             /if (!${DoBuffQueue[${a},1]}) {
                /varset DoBuffQueue[${a},1] ${Buffee}
                /varset DoBuffQueue[${a},2] ${BuffNumber}
                /echo ${BuffNumber}
                /varcalc QueueCount ${QueueCount}+1
                /return
             }
          /next a
       }
    }
    /return
   
    Sub RemoveFromQueue(int Buffee,int BuffNumber)
    /doevents IRC
    /doevents Chat
    /declare a int local
    /for a 1 to 25
       /if (((${Spawn[${DoBuffQueue[${a},1]}].State.Equal["DEAD"]} || !${Spawn[${DoBuffQueue[${a},1]}].ID}) || ((${DoBuffQueue[${a},1]}==${Buffee} || (!${Buffee} && (${Group.Member[${Spawn[${DoBuffQueue[${a},1]}].CleanName}]} || ${Group.Member[${Spawn[${DoBuffQueue[${a},1]}].Master.CleanName}]}))) && (${DoBuffID[${DoBuffQueue[${a},2]}]}==${BuffNumber} || ${DoBuffQueue[${a},2]}==${BuffNumber}))) && ${DoBuffQueue[${a},1]}) {
          /varset DoBuffQueue[${a},1] 0
          /varset DoBuffQueue[${a},2] 0
          /varcalc QueueCount ${QueueCount}-1
       }
    /next a
    /return

    Sub DoBuffEvents
    /varset MacroState DoBuffEvents
    /declare a       int local
    /declare TempVar int local ${Math.Calc[${DoBuffTotal}+1]}
    /declare TempGuy int local 0
    /for a 1 to 25
       /if (${DoBuffQueue[${a},2]}<${TempVar} && ${Spawn[${DoBuffQueue[${a},1]}].ID} && ${Spawn[${DoBuffQueue[${a},1]}].Type.NotEqual[corpse]} && (${Spawn[${DoBuffQueue[${a},1]}].Distance}<${Spell[${DoBuffID[${DoBuffQueue[${a},2]}]}].MyRange} || ${Spawn[${DoBuffQueue[${a},1]}].Distance}<${Spell[${DoBuffID[${DoBuffQueue[${a},2]}]}].AERange})) {
          /varset TempGuy ${DoBuffQueue[${a},1]}
          /varset TempVar ${DoBuffQueue[${a},2]}
       }
    /next a
   
    |/if (${Select[${DoBuffGem${TempVar}},item,alt]} || ${Me.Gem[${DoBuff${TempVar}}]}) {
    |   /if (${TempGuy}) /if (((${Me.SpellReady[${DoBuff${TempVar}}]} || !${Me.Gem[${DoBuff${TempVar}}]} || ${Spell[${DoBuffID[${TempVar}]}].RecastTime}<30) && ${Me.CurrentMana}>${Spell[${DoBuffID[${TempVar}]}].Mana} && ${Me.PctMana}>=${DoBuffMana${TempVar}}) || (${DoBuffGem${TempVar}.Equal[item]} && ${FindItem[${DoBuff${TempVar}}].TimerReady}<30) || (${DoBuffGem${TempVar}.Equal[alt]} && ${Me.AltAbilityReady[${DoBuff${TempVar}}]}<30 )) {
          /if (${Spawn[${TempGuy}].Distance}>=100) /return
          /squelch /target id ${TempGuy}
          /delay 1s ${Target.ID}==${TempGuy}
          /if (${Target.ID}==${TempGuy}) {
             /call Cast "${DoBuff${TempVar}}" ${DoBuffGem${TempVar}} 3s CheckHP2
             |/call DoRestrictedEvents ${DoBuffID[${TempVar}]}
             /if (${castReturn.Equal[CAST_SUCCESS]} || ${spellNotHold}) /call RemoveFromQueue ${TempGuy} ${TempVar}
             |/call AutoSit
          }
       }
   
    /return

Sub CheckDoBuffs(Sender,ChatText)
    /declare a        int local
    /declare i        int local
    /for i 1 to ${DoBuffTotal}
       /for a 1 to ${DoBuffAliases${i}.Count[|]}
          /if (${ChatText.Find["${DoBuffAliases${i}.Arg[${a},|]}"]}) {
             /if (${ChatText.Find[" pet "]} || ${ChatText.Find[${Spawn[pc ${Sender}].Pet.CleanName}]} || ${Spawn[pet ${Sender}].ID}) {
                /call AddToQueue ${Spawn[pc ${Sender}].Pet.ID} ${i}
             } else {
                /call AddToQueue ${Spawn[pc ${Sender}].ID} ${i}
             }
          }
       /next a
    /next i
    /return
   
    Sub BuffQueue
    /declare i int local
         /if (${DoBuffTotal}) {
       /if (!${Defined[DoBuffID]})       /declare DoBuffID[${DoBuffTotal}] int   outer
       /if (!${Defined[DoBuffQueue]})    /declare DoBuffQueue[25,2]        int   outer
       /if (!${Defined[QueueCount]})     /declare QueueCount               int   outer
       /if (!${Defined[DoBuffLowest]})   /declare DoBuffLowest             int   outer 100
       /if (!${Defined[DoBuffTimer]})    /declare DoBuffTimer              timer outer
       /for i 1 to ${DoBuffTotal}
          /call DeclareIniVar DoBuff${i} string Buff NULL
          /call DeclareIniVar DoBuffGem${i} string Buff null
          /call DeclareIniVar DoBuffAliases${i} string Buff NULL
          /call DeclareIniVar DoBuffMana${i} int Buff NULL
          /if (${Me.AltAbility[${DoBuff${i}}]}) /varset DoBuffID[${i}] ${Me.AltAbility[${DoBuff${i}}].Spell.ID}
          /if (${FindItem[${DoBuff${i}}].ID}) /varset DoBuffID[${i}] ${FindItem[${DoBuff${i}}].Spell.ID}
          /if (${Me.Book[${DoBuff${i}}]}) /varset DoBuffID[${i}] ${Me.Book[${Me.Book[${DoBuff${i}}]}].ID}
          /if (${Ini[Cleric_${Me.CleanName}.ini,Buff,DoBuffIcon${i},NOTFOUND].NotEqual[NOTFOUND]}) /varset DoBuffID[${i}] ${Spell[${Ini[Cleric_${Me.CleanName}.ini,Buff,DoBuffIcon${i},NOTFOUND]}].ID}
          /if (${DoBuffLowest}>${DoBuffMana${i}}) /varset DoBuffLowest ${DoBuffMana${i}}
       /next i
    }
    /return
   
    Sub BCBuffs
    /declare i int local
    /if (${DoBcBuffTotal}) {
       /for i 1 to ${DoBcBuffTotal}
          /call DeclareIniVar DoBCBuff${i} string BCBuffs NULL
          /call DeclareIniVar DoBCBuffMana${i} int BCBuffs NULL
          /call DeclareIniVar DoBCBuffMobRange${i} int BCBUffs NULL
          /call DeclareIniVar DoBCBuffIgnoreClass${i} string BCBuffs "Use the Class's full Name and seperate with commas"
       /next i
    }
    /return

Sub DeclareIniVar(string name,string varType,string section,string value,string alias) 
   /if ( !${Defined[${name}]} ) /declare ${name} ${varType} outer 
   /varset ${name} ${Ini[${iniName},${section},${name.Left[1].Upper}${name.Right[-1]},"${value}"]} 
   /ini "${iniName}" "${section}" "${name.Left[1].Upper}${name.Right[-1]}" "${${name}}" 
   /if ( ${Defined[alias]} ) /squelch /alias ${alias} /echo set: ${name} 
/return 

Sub SetIniVar(string name,string section,string value) 
   /varset ${name} ${value} 
   /ini "${iniName}" "${section}" "${name.Left[1].Upper}${name.Right[-1]}" "${${name}}" 
/return 

Sub CheckTarget 
   /declare tempID int local ${Target.ID} 
   /if ( ( ${Spawn[${tempID}].Type.Equal[npc]} || ( ${Spawn[${tempID}].Type.Equal[pet]} && !${Spawn[${tempID}].Master.Type.Equal[pc]} ) ) && ( ( ${Spawn[pc ${mainTank}].NearestSpawn[radius ${Math.Calc[${minRadius}*2]} id ${tempID}].ID} && ${Spawn[pc ${mainTank}].Distance3D}<=${minRadius} ) || !${Spawn[pc ${mainTank}].ID} || ${Spawn[pc ${mainTank}].Distance3D}>200 ) && ${tempID}!=${petID} && ( ${aggroAnim.Find[|${Spawn[${tempID}].Animation}|]} || ${Spawn[${tempID}].PctHPs}<100 || ${Me.TargetOfTarget.Type.Equal[pc]} || ${Me.TargetOfTarget.Master.Type.Equal[pc]} ) ) { 
      /varset validTarget 1 
   } else { 
      /varset validTarget 0 
   } 
/return 

Sub CheckiniBuffs
/varset MacroState CheckIniBuffs
/if (${Zone.ID}!=${currentZone}) /call Event_Zone
   /if (${Me.Invis}) /return
   /varset BcClients ${NetBots.Client}
   /varset BcClients2 ${Math.Calc[${BcClients.Count[ ]}+1]}
   /declare stacks bool true
   /declare buffs string local
   /declare ignorelist string local
   /declare c int local
  /declare i int local
  /declare X int local
  /declare j int local
  /declare b int local
  /varset  b 1
  /declare spellName string local
  /declare buffName string local
  /for i 1 to 8
    /if ( ${FindItem[=${clicky${i}}].ID} ) {
      /varset spellName ${FindItem[=${clicky${i}}].Spell.Name}
      /if ( !${Me.Buff[${spellName}].ID} || ${Me.Buff[${spellName}].Duration}<=4 ) {
        /varset j 1
     
:check_nostack
/if (!${Spell[${spellName}].Stacks[2]}) /goto :skip_clicky

        /varset buffName ${clickyNoStack${i}.Arg[${j},,]}
        /if ( ${Bool[${buffName}]} ) {
          /if ( ${Me.Buff[${buffName}].ID} ) /goto :skip_clicky
          /varcalc j ${j}+1
          /goto :check_nostack
        }

/call Cast "${clicky${i}}" item 0 ${If[${Bool[${castSub}]},${castSub},]} CheckHP2
:skip_clicky
      }
    }
/varcalc b ${b}+1
  /next i
 
  /for i 1 to 5
    /if ( ${Me.Book[${selfBuff${i}}]} ) {
      /varset spellName ${selfBuff${i}}
         
      /if ( !${Me.Buff[${spellName}].ID} || ${Me.Buff[${spellName}].Duration}<=4 && ${Spell[${spellName}].Mana} < ${Me.CurrentMana} ) {
        /varset j 1
:check_nostack2
/if (!${Spell[${spellName}].Stacks[2]}) /goto :skip_self_buff
        /varset buffName ${selfBuffNoStack${i}.Arg[${j},,]}
        /if ( ${Bool[${buffName}]} ) {
          /if ( ${Me.Buff[${buffName}].ID} ) /goto :skip_self_buff
          /varcalc j ${j}+1
          /goto :check_nostack2

        }
        /target myself
/call Cast "${selfBuff${i}}" ${BuffGem} 0 ${If[${Bool[${castSub}]},${castSub},]} CheckHP2
:skip_self_buff
      }
    }
    /next i

   /if (!${Window[AuraWindow].Child[AW_AuraList].List[1,3]}&&${Me.CurrentMana} > ${Spell[${AuraSpell} Effect].Mana} && ${Me.Book[${AuraSpell}]}) {
    /call Cast "${AuraSpell}" ${BuffGem} 6s CheckHP2
  }
  /if (${Me.Song[gift of mana].ID} || ${Me.Song[gift of radiant mana].ID} || ${Me.Song[Gift of Exquisite Radiant Mana].ID}) /call Event_GiftofMana
 
  :end
  
|Start Of the BC buffing Routine
/varset MacroState BCBuffs
  /varset BcClients ${NetBots.Client} 
  /varset BcClients2 ${Math.Calc[${BcClients.Count[ ]}+1]}
  /varset buffs ${NetBots[${BcClients.Arg[${X}]}].Buff} 
    /if (${UseReverseBcOrder}) /goto :Reverse
    /if (${UseMidBcOrder}) /goto :Reverse2
    /if (${UseMidReverseOrder}) /goto :Reverse3
          /for X 1 to ${BcClients2}
             /for b 1 to ${DoBcBuffTotal}  
             	 /varset ignorelist ${Ini[${iniName},"BCBuffs","DoBCBuffIgnoreClass${b}"]}
       /if (!${NetBots[${BcClients.Arg[${X}]}].Buff.Find[${Spell[${DoBCBuff${b}}].ID}]} && ${NetBots[${BcClients.Arg[${X}]}].InZone} && ${Spawn[${BcClients.Arg[${X}]}].ID} && ${Spawn[${BcClients.Arg[${X}]}].Distance}<=100 && ${Me.PctMana}> ${DoBCBuffMana${b}} && !${SpawnCount[npc radius ${DoBCBuffMobRange${b}} Range 30 1000]} && !${ignorelist.Find[${NetBots[${BcClients.Arg[${X}]}].Class}]} && ${Me.CurrentMana}>${Spell[${DoBCBuff${b}}].Mana} && ${NetBots[${BcClients.Arg[${X}]}].Stacks[${Spell[${DoBCBuff${b}}].ID}]}) {     
              /echo buffing ${NetBots[${BcClients.Arg[${X}]}].Name} with ${DoBCBuff${b}}
          /call CastSpell "${DoBCBuff${b}}" ${BuffGem} ${NetBots[${BcClients.Arg[${X}]}].ID} CheckAll         
    }
  /next b
    /next X
      /goto :end2
      :Reverse
       /for X ${BcClients2} downto 1      	
             /for b 1 to ${DoBcBuffTotal}  
             	 /varset ignorelist ${Ini[${iniName},"BCBuffs","DoBCBuffIgnoreClass${b}"]}
       /if (!${NetBots[${BcClients.Arg[${X}]}].Buff.Find[${Spell[${DoBCBuff${b}}].ID}]} && ${NetBots[${BcClients.Arg[${X}]}].InZone} && ${Spawn[${BcClients.Arg[${X}]}].ID} && ${Spawn[${BcClients.Arg[${X}]}].Distance}<=100 && ${Me.PctMana}> ${DoBCBuffMana${b}} && !${SpawnCount[npc radius ${DoBCBuffMobRange${b}} Range 30 1000]} && !${ignorelist.Find[${NetBots[${BcClients.Arg[${X}]}].Class}]} && ${Me.CurrentMana}>${Spell[${DoBCBuff${b}}].Mana} && ${NetBots[${BcClients.Arg[${X}]}].Stacks[${Spell[${DoBCBuff${b}}].ID}]}) {     
              /echo buffing ${NetBots[${BcClients.Arg[${X}]}].Name} with ${DoBCBuff${b}}
          /call CastSpell "${DoBCBuff${b}}" ${BuffGem} ${NetBots[${BcClients.Arg[${X}]}].ID} CheckAll         
    }
  /next b
    /next X
    /goto :end2
    :reverse2
     /for X  ${Math.Calc[${BcClients2} /2]} to ${BcClients2}      	
             /for b 1 to ${DoBcBuffTotal}  
             	 /varset ignorelist ${Ini[${iniName},"BCBuffs","DoBCBuffIgnoreClass${b}"]}
       /if (!${NetBots[${BcClients.Arg[${X}]}].Buff.Find[${Spell[${DoBCBuff${b}}].ID}]} && ${NetBots[${BcClients.Arg[${X}]}].InZone} && ${Spawn[${BcClients.Arg[${X}]}].ID} && ${Spawn[${BcClients.Arg[${X}]}].Distance}<=100 && ${Me.PctMana}> ${DoBCBuffMana${b}} && !${SpawnCount[npc radius ${DoBCBuffMobRange${b}} Range 30 1000]} && !${ignorelist.Find[${NetBots[${BcClients.Arg[${X}]}].Class}]} && ${Me.CurrentMana}>${Spell[${DoBCBuff${b}}].Mana} && ${NetBots[${BcClients.Arg[${X}]}].Stacks[${Spell[${DoBCBuff${b}}].ID}]}) {     
              /echo buffing ${NetBots[${BcClients.Arg[${X}]}].Name} with ${DoBCBuff${b}}
          /call CastSpell "${DoBCBuff${b}}" ${BuffGem} ${NetBots[${BcClients.Arg[${X}]}].ID} CheckAll         
    }
  /next b
    /next X
    /goto :end2
    :reverse3
     /for X ${BcClients2} downto ${Math.Calc[${BcClients2} /2]}     	
             /for b 1 to ${DoBcBuffTotal}  
             	 /varset ignorelist ${Ini[${iniName},"BCBuffs","DoBCBuffIgnoreClass${b}"]}
       /if (!${NetBots[${BcClients.Arg[${X}]}].Buff.Find[${Spell[${DoBCBuff${b}}].ID}]} && ${NetBots[${BcClients.Arg[${X}]}].InZone} && ${Spawn[${BcClients.Arg[${X}]}].ID} && ${Spawn[${BcClients.Arg[${X}]}].Distance}<=100 && ${Me.PctMana}> ${DoBCBuffMana${b}} && !${SpawnCount[npc radius ${DoBCBuffMobRange${b}} Range 30 1000]} && !${ignorelist.Find[${NetBots[${BcClients.Arg[${X}]}].Class}]} && ${Me.CurrentMana}>${Spell[${DoBCBuff${b}}].Mana} && ${NetBots[${BcClients.Arg[${X}]}].Stacks[${Spell[${DoBCBuff${b}}].ID}]}) {     
              /echo buffing ${NetBots[${BcClients.Arg[${X}]}].Name} with ${DoBCBuff${b}}
          /call CastSpell "${DoBCBuff${b}}" ${BuffGem} ${NetBots[${BcClients.Arg[${X}]}].ID} CheckAll         
    }
  /next b
    /next X
      |end bc buffing
:end2
  /varset bufftimer 10s
  /return
  
  Sub UpdateMobList 
   /declare i int local 
   /declare mobListID string local 
   /if ( ${mobList.Find[[]} ) { 
      /if ( ${mobList.Find[[]}>1 ) /varset mobList ${mobList.Right[-${Math.Calc[${mobList.Find[[]}-1]}]} 
      /for i 1 to ${mobList.Count[[]} 
         /varset mobListID ${mobList.Arg[${i},[].Left[-1]} 
         /if ( ( !${Spawn[${mobListID}].Type.Equal[NPC]} && !${Spawn[${mobListID}].Master.Type.Equal[NPC]} ) || ${Spawn[${mobListID}].Type.Equal[corpse]} ) { 
            /if ( ${Defined[mezTimer${mobListID}]} ) /deletevar mezTimer${mobListID} 
            /if ( ${Defined[slowTimer${mobListID}]} ) /deletevar slowTimer${mobListID} 
            /if ( ${Defined[tashTimer${mobListID}]} ) /deletevar tashTimer${mobListID} 
            /if ( ${Defined[waitTimer${mobListID}]} ) /deletevar waitTimer${mobListID} 
            /if ( ${Defined[maloTimer${mobListID}]} ) /deletevar maloTimer${mobListID} 
            /if ( ${Defined[maloResists${mobListID}]} ) /deletevar maloResists${mobListID} 
            /call DeleteFromList mobList ${mobListID} 
            /call DeleteFromList addList ${mobListID} 
         } 
      /next i 
   } 
/return 

Sub ClearMobList 
   /declare i int local 
   /declare mobListID string local 
   /if ( ${mobList.Find[[]} ) { 
      /if ( ${mobList.Find[[]}>1 ) /varset mobList ${mobList.Right[-${Math.Calc[${mobList.Find[[]}-1]}]} 
      /for i 1 to ${mobList.Count[[]} 
         /varset mobListID ${mobList.Arg[${i},[].Left[-1]} 
         /if ( ${Defined[mezTimer${mobListID}]} ) /deletevar mezTimer${mobListID} 
         /if ( ${Defined[slowTimer${mobListID}]} ) /deletevar slowTimer${mobListID} 
         /if ( ${Defined[tashTimer${mobListID}]} ) /deletevar tashTimer${mobListID} 
         /if ( ${Defined[maloTimer${mobListID}]} ) /deletevar maloTimer${mobListID} 
         /if ( ${Defined[waitTimer${mobListID}]} ) /deletevar waitTimer${mobListID} 
         /if ( ${Defined[maloTimer${mobListID}]} ) /deletevar maloTimer${mobListID} 
         /if ( ${Defined[maloResists${mobListID}]} ) /deletevar maloResists${mobListID} 
         /call DeleteFromList mobList ${mobListID} 
         /call DeleteFromList addList ${mobListID} 
      /next i 
   } 
/return 

  Sub AddToList(string listName,string tempID) 
   /varset tempID [${tempID}] 
   /if ( !${${listName}.Find[${tempID}]} ) { 
      /varset ${listName} ${${listName}}${tempID} 
      /return 1 
   } 
/return 0 

Sub DeleteFromList(string listName,string tempID) 
   /varset tempID [${tempID}] 
   /declare a int local 
   /declare b int local 
   /declare strLeft string local 
   /declare strRight string local 
   /varcalc a ${${listName}.Find[${tempID}]}-1 
   /varcalc b ${${listName}.Length}-${tempID.Length}-${a} 
   /if ( ${a}>0 ) /varset strLeft ${${listName}.Left[${a}]} 
   /if ( ${b}>0 ) /varset strRight ${${listName}.Right[${b}]} 
   /varset ${listName} ${strLeft}${strRight} 
/return
 
Thats a big macro. Do you have the inc files mainly

events.inc
general.inc
 
oh i just made a mage yesterday and PLd him to 60/200 to box with my beast/SK. This would be great *_*
 
I played with this mac briefly, Its a pretty complex macro. I wouldn't be able to update unless I spent a lot time on it which unfortunately I don't have right now. Thanks for sharing though.
 
at least it wouldn't be as hard to update as ~rusty's mage.mac lol
 
The events.inc is an old raid emote file and not needed. Delete or comment out that line.
spell_routines.inc is included in the compile macro folder.
wait4Rez.inc and general.inc attached
 

Attachments

Last edited:
Auto Mage mac - workish but needs updating

Users who are viewing this thread

Back
Top
Cart