Shaman slow/heal/dot... well you get the picture :)

[Siddin]

warning its just a TAD messy atm.
and for the basics of what it does. if you uncomment the healloop part it'll quinessence and patch heal. otherwise it just casts malos, then slow. if those land i have it also casting Crippling Spasm, Blood of Saryrn, Pained Memory, and then Quiescence on myself. you can of course change these spells to any you want. its not very user friendly as you have to go in and edit the spells in the right places *shrug* but this was mainly made to box a shammy that my friend usually plays.

#include spell_routines.inc
#event exp "#*#party experience#*#"
Sub Main
/declare HOTtime timer outer 0
/declare M_Assist string outer ${Target.CleanName}
/declare SlowSpell string outer "Turgur's Insects"
/declare HoTSpell string outer Quiescence
/declare Slowed int outer 0
/declare M_Assist_ID int outer ${Target.ID}
/declare healspell string outer "Yoppa's Mending"
/declare Malos int outer 0
/declare MaloSpell string outer "Malos"
/declare Crippled int outer 0
:Start
/doevents
/target ${M_Assist}
/if (!${Target.ID}) /goto :Start
|/call Heal_Loop
/call Malo_Loop
/call Slow_Loop
|/call Spasm_Loop
/goto :Start
/return
Sub Heal_Loop
/if (!${Me.LineOfSight}) /return
/if (${Target.PctHPs} <= 75 && ${HOTtime}==0 && ${Target.ID}==${M_Assist_ID}) {
/g Casting ${HoTSpell} on ${Target.CleanName}
/call cast ${HoTSpell}
/varset HOTtime 30s
}
/if (${Target.PctHPs} <= 50 && ${HOTtime}>=1 && ${HOTtime}<=250 && ${Target.ID}==${M_Assist_ID}) {
/g Casting ${healspell} on ${Target.CleanName}
/call cast ${healspell}
}
/return
Sub Malo_Loop
/if (!${Target.ID}) /return
/if (${Malos} == 1) /return
/assist ${M_Assist}
/delay 5
/if (${Target.Type.Equal[PC]}) /return
/if (${Target.Type.Equal[Corpse]}) {
/squelch /target clear
/return
}
/if (!${Target.LineOfSight} || ${Target.Type.Equal[PC]}) /return
/if (${Target.Distance}>=200) /return
/pet attack
/if (${Malo}==0) /g ***Casting ${MaloSpell} on ${Target.CleanName}***
:MaloLoop2
/if (${Malo}==0) /call cast ${MaloSpell}
/if (${Malo}==0) /if (${Macro.Return.Equal["CAST_INTERRUPTED"]}) {
/g ***${MaloSpell} Interrupted, Casting Again***
/delay 8s
/goto :MaloLoop2
}
/if (${Malo}==0) /if (${Macro.Return.Equal["CAST_RESISTED"]}) {
/g ***${Target.CleanName} RESISTED ${MaloSpell}! Trying again ASAP 
/delay 8s
/return
}
/if (${Malo}==0) /if (${Macro.Return.Equal["CAST_SUCCESS"]}) { 
/g ***${MaloSpell} landed on ${Target.CleanName}***
/varset Malos 1 
/return
}
/return
Sub Slow_Loop
/if (!${Target.ID}) /return
/if (${Slowed} == 1) /return
/if (${Malos} == 0) /return
 
/if (${Target.Type.Equal[Corpse]}) {
/squelch /target clear
/return
}
/if (!${Target.LineOfSight} || ${Target.Type.Equal[PC]}) /return
/g ***Slowing ${Target.CleanName}***
:SlowLoop2
/call cast ${SlowSpell}
/if (${Macro.Return.Equal["CAST_INTERRUPTED"]}) {
/g ***Slow Interrupted, Casting Again***
/delay 3s
/goto :SlowLoop2
}
/if (${Macro.Return.Equal["CAST_RESISTED"]}) {
/g ***${Target.CleanName} RESISTED Slow! Trying again ASAP 
/delay 8s
/return
}
/if (${Macro.Return.Equal["CAST_IMMUNE"]}) { 
/g ***${Target.CleanName} Is IMMUNE To Slow!***
/varset Slowed 1
/return
}
/if (${Macro.Return.Equal["CAST_SUCCESS"]}) { 
/g ***${Target.CleanName} Is SLOWED!***
/varset Slowed 1 
/call cast "Crippling Spasm"
/call cast "Blood of Saryrn"
/call cast "Pained Memory"
/target ${Me}
/call cast "Quiescence"
/if (${Me.AltAbilityReady[47]} && ${Me.CurrentMana} < ${Math.Calc[${Me.MaxMana}-1000]} && ${Me.MaxHPs} > 
2424) /alt activate 47
/return
}
/return
 
sub event_exp
/varset Slowed 0
/varset Malos 0
/varset Crippled 0 
/return

 

[Ravia]

I have a 70 shaman i want to get AA's for any ideas for me to try, also new to this and computer retarted any help would be great thanks so much!

 

[Mustangs]

Would start with buying a new computer with a decent video card and RAM.

 

[Thesalsa]

Any way to loop this so it lasts for more than one mob? As in, each time the puller brings a new mobs in, it resets and casts malos/slow/dot, etc. on the new mob.

 

[Ted]

This is basically the Shaman macros from the MQ forums but I added ini use, toggle echo commands, hot healing, masters lists and a few other things. It has been a while since I have even looked at it since I sold my shaman so its probably broken from the TLO changes. Here's the code anyway for anyone who wants to play with it.

Shambot.mac

| This is modified version of the bases created by Hubba and ranma
| This version has Ini support built into it. More Advanced echo Commands,
| and a RaidBuffing Utility. (unfinished but working)
| ------------------------------------------------------------------------
| Start the macro with your intended Main Assist Targeted or use /mac shambot <Massist>
| Your Ini file will then be created and the macro will shut down.
| Make any needed changes to your Ini regarding spells and others if you wish.
| Once the macro is running any echo command change will automatically be written
| to the Ini file and saved.
| Requires Spell_Routines.inc by ~Rusty

#Event OutDoor "#*#outdoors#*#" 
#Event OutDoor "You can not summon a mount here." 
#Event Zoning "You have entered#*#" 
#Event Enrageon "#*#ENRAGED#*#" 
#Event Enrageoff "#*#no longer enraged#*#"
#Event ImDead "You have been slain by#*#"
#Event Paused "[MQ2] pause#*#"
#Event AstChange "[MQ2] astchange#*#"
#Event Rootchg "[MQ2] root#*#"
#Event Dotchg "[MQ2] dot#*#"
#Event Nukechg "[MQ2] nuke#*#"
#Event Malochg "[MQ2] malo#*#"
#Event Slowchg "[MQ2] slow#*#"
#Event Cripplechg "[MQ2] cripple#*#"
#Event Healchg "[MQ2] healchg#*#"
#Event Verbchg "[MQ2] verbchg#*#"
#Event Atkchg "[MQ2] atk#*#"
#Event SOWchg "[MQ2] sow#*#"
#Event Mountchg "[MQ2] mount#*#"
#Event Sitatchg "[MQ2] sitat#*#"
#Event Petchg "[MQ2] pet#*#"
#Event AutoSit "[MQ2] autosit#*#"
#Event DoBuffs "[MQ2] dobuffs#*#"
#Event PetChg "[MQ2] chgpet#*#"
#Event AddMaster "[MQ2] addmaster#*#"
#Event Shrink "[MQ2] shrink#*#"
#Event HoTchg "[MQ2] hotchg#*#"
#Event RaidBuff "[MQ2] raidbuffchg#*#"

#chat tell 
#include Spell_Routines.inc
#include shamini.inc

Sub Main 

| The spell will be memmed in the listed order. 
| Gem1 = Canni 
| Gem2 = Slow 
| Gem3 = Malo 
| Gem4 = Avatar 
| Gem5 = Pet and buffs 
| Gem6 = Heal 
| Gem7 = HoT 
| Gem8 = DoT 
| Gem9 = root, Nuke, gate 

| ########### Make changes in spells as you need. 
| ########### Obs! This is mainly for a 65+ shaman with Cannibalization ability 
| ########### Set Cannibalization to False if you don't have the ability 
| ########### 
  
| ########### Your Spell List - update as needed  

   /declare SpellSlow          outer "Turgur's Insects" 
   /declare SpellDoT           outer "Blood of Saryrn" 
   /declare SpellPet           outer "True Spirit" 
   /declare SpellDeBuff        outer "Malos" 
   /declare SpellCanni         outer "Cannibalize IV" 
   /declare SpellCripple		 outer "Cripple"

   /declare SpellHoT           outer "Quiescence" 
   /declare SpellHeal          outer "Tnarg`s Mending" 
   /declare SpellRoot          outer "Petrifying Earth" 
   /declare SpellNuke          outer "Velium Strike" 

   /declare SpellATK           outer "Ferine Avatar" 
   /declare SpellHASTE         outer "Talisman of Alacrity" 
   /declare SpellFOCUS         outer "Focus of Soul" 
   /declare SpellCHA           outer "Charisma" 
   /declare SpellDEX           outer "Strength of the Diaku" 
   /declare SpellSTR           outer "Strength of the Diaku" 
   /declare SpellAGI           outer "Agility of the Wrulan" 
   /declare SpellSoS		   	 outer "Spirit of Sense"
   /declare SpellSTA           outer "Endurance of the Boar" 
   /declare SpellREGEN         outer "Replenishment" 
   /declare SpellPE            outer "Primal Essence" 
   /declare SpellPR            outer "Talisman of the Tribunal" 

   /declare SpellSOW           outer "Spirit of Bih`Li" 
   /declare SpellLEV           outer "Levitation" 
   /declare SpellINV           outer "Invisibility" 
   /declare SpellSHRINK        outer "Tiny Terror" 
   /declare SpellGROW          outer "Grow" 
   /declare SpellSEE           outer "Acumen of Dar Khura" 

   /declare SpellGATE          outer "Gate" 
   /declare SpellFOOD          outer "Summon Food" 
   /declare SpellDRINK         outer "Summon Drink" 

| ########### Mount Type 

   /declare Mount              outer "White Rope Bridle" 


| ########### My Pet Buff Spell List 

   /declare SpellPetBuff[4] string outer 
   /varset SpellPetBuff[1] "Celerity" 
   /varset SpellPetBuff[2] "Strength of the Diaku" 
   /varset SpellPetBuff[3] "Ferine Avatar" 
   /varset SpellPetBuff[4] "Focus of Soul" 

| ########### Other Pet Buff Spell List 

   /declare SpellPetBuffo[4] string outer 
   /varset SpellPetBuffo[1] "Celerity" 
   /varset SpellPetBuffo[2] "Strength of the Diaku" 
   /varset SpellPetBuffo[3] "Primal Essence" 
   /varset SpellPetBuffo[4] "Focus of Soul" 

| ############ Group Buff List. 

   /declare SpellGrpBuff[6] string outer 
   /varset SpellGrpBuff[1] "Blessing of Replenishment"
   /varset SpellGrpBuff[2] "Focus of the Seventh"
   /varset SpellGrpBuff[3] "Talisman of Alacrity"
   /varset SpellGrpBuff[4] "Talisman of the Wrulan"
   /varset SpellGrpBuff[5] "Talisman of the Boar"
   /varset SpellGrpBuff[6] "Talisman of the Diaku"
    
| ############ Single Buff List.    

   /declare SpellSingleBuff[6] string outer 
   /varset SpellSingleBuff[1] "Replenishment" 
   /varset SpellSingleBuff[2] "Focus of Soul" 
   /varset SpellSingleBuff[3] "Talisman of Alacrity" 
   /varset SpellSingleBuff[4] "Agility of the Wrulan" 
   /varset SpellSingleBuff[5] "Endurance of the Boar" 
   /varset SpellSingleBuff[6] "Strength of the Diaku"  

| ############ Combat Variables 

   /declare AssistAt      int   outer 100 
   /declare CombatAt      int   outer 99 

   /declare CastDoTat     int   outer 80 
   /declare DotMana       int   outer 40 

   /declare Rootat        int   outer 40 
   /declare RootMana      int   outer 40 

   /declare NukeAt        int   outer 90 
   /declare NukeMana      int   outer 50 

   /declare SitAt         int   outer 80 
   /declare BuffMana      int   outer 30 
   /declare MinMana       int   outer 15 
    
   /declare following     int   outer 0 
   /declare follname      string outer NULL 

| ############ Heal Priority. 

   /declare CasterHeals   int   outer 30 
   /declare MeleeHeals    int   outer 50 
   /declare TankHeal      int   outer 55
   /declare HoTAt			  int   outer 85 

| ############ To Do List 

   /declare DoMalo             outer TRUE    
   /declare DoSlow             outer TRUE 
   /declare DoCripple		    outer FALSE
   /declare FastCripple		    outer FALSE
   /declare FastSlow           outer FALSE 
   /declare DoRoot             outer TRUE 

   /declare SummonPet          outer FALSE
   /declare BuffPet            outer TRUE 
  
   /declare DoDoT              outer TRUE 
   /declare DoBuffs            outer TRUE 
   /declare DoSow              outer TRUE 
   /declare DoNuke             outer FALSE 
   /declare DoHeal             outer TRUE 
   /declare HoTTank				 outer TRUE
   /declare Cannibalization    outer TRUE 
   /declare Verbose            outer FALSE
   /declare RaidBuff				 outer FALSE

   | This is a delay for how long Avatar will hold. (8min) 
   /declare AvatarDelay       outer 5350
   /declare HoTDelay				outer 350

| ########### ! No Changes From Here Is Needed ! 

/squelch /alias /pause /echo pause
/squelch /alias /autoassist /echo astchange
/squelch /alias /root /echo root
/squelch /alias /dot /echo dot
/squelch /alias /nuke /echo nuke
/squelch /alias /malo /echo malo
/squelch /alias /slow /echo slow
/squelch /alias /cripple /echo cripple
/squelch /alias /heal /echo healchg
/squelch /alias /verbose /echo verbchg
/squelch /alias /attack /echo atk
/squelch /alias /sow /echo sow
/squelch /alias /mount /echo mount
/squelch /alias /sitat /echo sitat
/squelch /alias /autosit /echo autosit
/squelch /alias /dobuff /echo dobuffs
/squelch /alias /chgpet /echo chgpet
/squelch /alias /addmaster /echo addmaster
/squelch /alias /shrink /echo shrink
/squelch /alias /hot /echo hotchg
/squelch /alias /raidbuff /echo raidbuffchg
  
   /declare TargetArray[4] string outer 
   /declare MobMaloed      outer FALSE 
   /declare MobSlowed      outer FALSE 
   /declare MobCrippled    outer FALSE
   /declare PetOn          outer FALSE 
   /declare MobRooted      outer FALSE 
   /declare MobDoTed       outer FALSE 
   /declare CombatOn       outer TRUE 
   /declare Engaged        outer FALSE  
   /declare LowMana        outer FALSE
   /declare AutoSit	   outer TRUE 
   /declare distancetosit  int outer 40 

   /declare M_Assist       string outer 
   /declare OutDoors       outer TRUE    

   /declare Exper float outer 
   /declare AAExp float outer 
        
   /varset Exper ${Me.Exp} 
   /varset AAExp ${Me.AAExp} 

   /declare ATKBuffed0 timer outer 0 
   /declare ATKBuffed1 timer outer 0 
   /declare ATKBuffed2 timer outer 0 
   /declare ATKBuffed3 timer outer 0 
   /declare ATKBuffed4 timer outer 0 
   /declare ATKBuffed5 timer outer 0 
   /declare HoTOn		  timer outer 0
   
   /declare IsPaused outer TRUE
   /declare DoATK outer TRUE
   /declare DoHaste outer FALSE
   /declare DoSOW outer FALSE
   /declare UseMount outer TRUE
   

| ############### Target a player as Main Assist 
    
	/if (!${Ini[ShamBot.ini,General,Made].Equal[TRUE]}) {
		/call CreateIni
	} else {
		/call LoadIni
	}
	

	/if (!${Ini[ShamBot.ini,General,M_Assist].Length}) {
      /if (${Defined[Param0]}) {  
          /varset M_Assist ${Param0} 
          /echo Assist set to ${M_Assist} 
      } else { 
          
	  
	  /if (!${Target.ID} || ${Target.Type.NotEqual[PC]}) { 
              /echo Your Do not have a main assist, make sure its a player character! 
              /endmacro 
          }
	  
          /varset M_Assist ${Target.CleanName} 
          /echo Assist set to ${M_Assist}
          /ini "ShamBot.ini" "General" "M_Assist" ${M_Assist}
           
      }
} 

      /assist off 

  	
   /delay 1
   /cleanup
   /call MemSpells 
    
/echo --------------****Ted's ShamBot****----------------
/echo Assisting ${M_Assist} @ ${CombatAt}% mob HP.
/echo Do Malo - ${DoMalo}
/echo Do Slow - ${DoSlow}
/echo Fast Slow - ${FastSlow}
/echo Cripple - ${DoCripple}
/echo Fast Cripple - ${FastCripple}
/echo Cast Root - ${DoRoot}
/echo Cast Nuke - ${DoNuke}
/echo Cast DoT - ${DoDoT}
/echo Use Pet - ${SummonPet}
/echo Buff Pet - ${BuffPet}
/echo Buff Group - ${DoBuffs}
/echo Heal Group - ${DoHeal}
/echo Avatar Chain - ${DoATK}
/echo Use Mount - ${UseMount}
/echo Verbose - ${Verbose}
/echo ----------------------------------------------------    

| ###############    
| ############### Main Loop Starts 
| ###############  

:Main_Loop 
   /doevents
   /if (${IsPaused}) /goto :Main_Loop
    
   /if (${NearestSpawn[NPC].Distance}>=100) {
   	/if (${Me.State.Equal[Stand]} && ${Me.PctMana}<${SitAt}) /sit
   } else /stand
   
   |- Summon Mount if outdoors 
   /if (!${Me.Mount.ID} && ${OutDoors} && ${UseMount}) /call cast ${Mount} item 4s 
    
   |- Check for low mana state 
   /call Check_Mana 

   |- Check for new events in chat etc etc... 
   /doevents 
    
   |- Do we move? 
   :Hold_Main 
   /if (${Me.Moving}) /goto :Hold_Main 
    
   |- Pet 
   /call PET 
    
   |- Buff Sow 
   /call SOW 
    
   |- Check for mobs and do combat stuff 
   /if (${TargetArray[1].Equal[NULL]}) /call GetTarget 
   /if (${CombatOn}) /call Combat        

   |- Group Heals 
   /if (${DoHeal}) /call Check_grpHPs 

   |- Check for Standing if less than sitat then sit 
   /if (${NearestSpawn[NPC].Distance}>=100) {
   	/if (${Me.State.Equal[Stand]} && ${Me.PctMana}<${SitAt}) /sit
   } else /stand

   |- Canni 
   /call LOM 

   |- Group Buffs if more than BuffMana mana 
   /if (${Me.PctMana}>=${BuffMana} && ${DoBuffs}) /call GrpBuffs 

   |- Buff Avatar 
   /if (${Me.SpellReady[${SpellATK}]} && ${DoATK}) /call Cast_Avatar 
    
   |- Group Heals 
   /if (${DoHeal}) /call Check_grpHPs  

   /goto :Main_Loop 
/return 

| ###############    
| ############### Main Loop Ends 
| ############### 

  
| ############### Mem Spells in Spell List 

Sub MemSpells 

   /echo Memming spells. Hang on. 
   /if ( !${Me.Gem[${SpellCanni}]} ) { 
      /memspell 1 ${SpellCanni} 
      /delay 25 
   } 
   /if ( !${Me.Gem[${SpellSlow}]} ) { 
      /memspell 2 ${SpellSlow} 
      /delay 20 
   } 
   /if ( !${Me.Gem[${SpellDeBuff}]} ) { 
      /memspell 3 ${SpellDeBuff} 
      /delay 20 
   } 
   /if ( !${Me.Gem[${SpellATK}]} ) { 
      /memspell 4 ${SpellATK} 
      /delay 20 
   } 
   /if ( !${Me.Gem[${SpellPet}]} ) { 
      /memspell 5 ${SpellPet} 
      /delay 20 
   } 
   /if ( !${Me.Gem[${SpellHeal}]} ) { 
      /memspell 6 ${SpellHeal} 
      /delay 20 
   } 
   /if ( !${Me.Gem[${SpellHoT}]} ) { 
      /memspell 7 ${SpellHoT} 
      /delay 20 
   } 
   /if ( !${Me.Gem[${SpellDoT}]} ) { 
      /memspell 8 ${SpellDoT} 
      /delay 30 
   } 
   /if ( !${Me.Gem[${SpellRoot}]} ) { 
      /memspell 9 ${SpellRoot} 
      /delay 30 
   } 

   |/if ( ${Window[SpellBookWnd].Open} ) /windowstate SpellBookWnd close 
   /echo Spells are memmed. 

/return 

| ################### Check target and do stuff like slow, dot, pet attack etc. 

Sub Combat 
   /if (${CombatOn} && !${MobMaloed} && ${DoMalo} && ${Target.ID}==${TargetArray[4]}) /call DeBuff 
   /if (${CombatOn} && !${MobSlowed} && ${DoSlow} && ${Target.ID}==${TargetArray[4]}) /call Slow 
   /if (${CombatOn} && !${MobCrippled} && ${DoCripple} && ${Target.ID}==${TargetArray[4]}) /call Cripple
   /if (${CombatOn} && !${PetOn} && ${Target.ID}==${TargetArray[4]}) { 
      /pet attack 
      /varset PetOn TRUE 
      /varset Engaged TRUE  
   } 

   |- Check for new events in chat etc etc... 
   /doevents 

   /if (${CombatOn} && ${DoDoT} && !${MobDoTed} && ${Me.PctMana}>=${RootMana} && ${Target.PctHPs}<=${CastDoTat}) { 
      /call cast ${SpellDoT} gem8 
      /varset MobDoTed TRUE 
   } 
   /if (${CombatOn} && ${DoNuke} && ${Me.PctMana}>=${NukeMana} && ${Target.PctHPs}<=${NukeAt}) { 
      /call cast ${SpellNuke} gem9 6s
   } 
   /if (${CombatOn} && ${DoRoot} && ${Me.PctMana}>=${RootMana} && ${Target.PctHPs}<=${RootAt}) { 
      /call cast ${SpellRoot} gem9 6s
      /varset MobRooted TRUE 
   } 

   |- Check for new events in chat etc etc... 
   /doevents 

|- EndCombat 

   /target ${TargetArray[3]} 
    
   /if (!${Target.Name.Equal[${TargetArray[3]}]} || !${Target.ID}) { 
      /echo ${TargetArray[1]} is dead 
      /varset MobRooted FALSE 
      /varset MobMaloed FALSE 
      /varset MobSlowed FALSE 
      /varset MobCrippled FALSE
      /varset PetOn FALSE 
      /varset MobDoTed FALSE 
      /varset CombatOn FALSE 
      /varset Engaged FALSE    
      
      /varset TargetArray[1] NULL 
      /varset TargetArray[2] NULL 
      /varset TargetArray[3] NULL 
      /varset TargetArray[4] NULL 

  } 
/return 
  
| ############### Debuff 

Sub DeBuff 
:DeBuff_Loop 
   /if (${Target.PctHPs}<=${CombatAt} && ${Target.ID}==${TargetArray[4]}) { 
      /if (${Me.CurrentMana}<${Spell[${SpellDeBuff}].Mana}) { 
         /echo *** Shid ! I don't have mana to Malo %T 
      } else { 
         /call cast ${SpellDeBuff} gem3 6s 
         /if (${Macro.Return.Equal["CAST_INTERRUPTED"]}) /goto :DeBuff_Loop 
         /varset MobMaloed TRUE 
      } 
   } 
/return 
  
| ############### Slowing 

Sub Slow 
   /if (${Target.PctHPs}<=${CombatAt} && ${Target.ID}==${TargetArray[4]}) { 
      /if (${Me.CurrentMana}<${Spell[${SpellSlow}].Mana}) { 
         /echo Shid ! I don't have mana to Malo %T 
      } else { 
      :Slow_Loop 
         /call cast ${SpellSlow} gem2 6s 
         /if (${Macro.Return.Equal["CAST_INTERRUPTED"]}) /goto :Slow_Loop 
         /if (${Macro.Return.Equal["CAST_IMMUNE"]}) { 
            /if (${Verbose}) /gsay *** %T is IMMUNE to my slow ! 
          
            /varset MobSlowed TRUE 
         } 
         /if (${Macro.Return.Equal["CAST_RESISTED"]}) { 
            /if (!${FastSlow}) { 
               /if (${Verbose}) /gsay *** %T RESISTED slow ! Trying again asap 
                /if (${DoHeal}) /call Check_grpHPs 
                /goto :Slow_Loop 
             } 
            /varset MobSlowed TRUE 
          } 
         /if (${Macro.Return.Equal["CAST_SUCCESS"]}) { 
            /if (${Verbose}) /gsay *** %T is SLOWED 
            /varset MobSlowed TRUE 
          } 

      } 
   } 
/return 

Sub Cripple 
   /if (${Target.PctHPs}<=${CombatAt} && ${Target.ID}==${TargetArray[4]}) { 
      /if (${Me.CurrentMana}<${Spell[${SpellCripple}].Mana}) { 
         /echo Shid ! I don't have mana to Cripple %T 
      } else { 
      :Slow_Loop 
         /call cast ${SpellCripple} gem9 6s 
         /if (${Macro.Return.Equal["CAST_INTERRUPTED"]}) /goto :Slow_Loop 
         /if (${Macro.Return.Equal["CAST_IMMUNE"]}) { 
            /if (${Verbose}) /gsay *** %T is IMMUNE to my Cripple ! 
          
            /varset MobCrippled TRUE 
         } 
         /if (${Macro.Return.Equal["CAST_RESISTED"]}) { 
            /if (!${FastCripple}) { 
               /if (${Verbose}) /gsay *** %T RESISTED slow ! Trying again asap 
                /if (${DoHeal}) /call Check_grpHPs 
                /goto :Slow_Loop 
             } 
            /varset MobCrippled TRUE 
          } 
         /if (${Macro.Return.Equal["CAST_SUCCESS"]}) { 
            /if (${Verbose}) /gsay *** %T is Crippled 
            /varset MobCripple TRUE 
          } 

      } 
   } 
/return 

Sub GetTarget 
   /assist ${M_Assist} 
   /delay 3 
   /if (${Target.Type.Equal[NPC]}) /if (${Target.Distance}<=${AssistAt} && ${Target.ID}!=${TargetArray[4]} && ${Target.PctHPs}<=${CombatAt}) { 
      /varset TargetArray[1] ${Target.CleanName} 
      /varset TargetArray[2] ${Target.Level} 
      /varset TargetArray[3] ${Target.Name} 
      /varset TargetArray[4] ${Target.ID} 
      /varset CombatOn TRUE 
        
      /varset MobRooted FALSE 
      /varset MobMaloed FALSE 
      /varset MobSlowed FALSE 
      /varset MobCrippled FALSE
      /varset PetOn FALSE 
      /varset MobDoTed FALSE 

      /varset AAExp ${Math.Calc[${Me.PctAAExp}-${AAExp}]} 
      /varset Exper ${Math.Calc[${Me.PctExp}-${Exper}]} 

      /echo EXP: ${Exper}:${Me.PctExp}% - AAXP: ${AAExp}:${Me.PctAAExp}% - ${Math.Calc[${Macro.RunTime}/60]} minutes 
      /popup EXP: ${Exper}:${Me.PctExp}% - AAXP: ${AAExp}:${Me.PctAAExp}% - ${Math.Calc[${Macro.RunTime}/60]} minutes 
      /varset Exper ${Me.PctExp} 
      /varset AAExp ${Me.PctAAExp} 
   } 
/return 

| ################### Buff the group with buffs from the SpellGrpBuff array 


Sub GrpBuffs 
   /declare i int local 1 
   /for i 1 to ${SpellGrpBuff.Size} 
      /doevents 
      /if (${Spell[${SpellGrpBuff[${i}]}].Mana} > ${Me.CurrentMana}) /return 
      /if ( !${Me.Buff[${SpellGrpBuff[${i}]}].ID} ) { 
         /target pc ${M_Assist} 
         /delay 3 
         /echo *** Hang on ! Rebuffing ${SpellGrpBuff[${i}]} 
         /call cast ${SpellGrpBuff[${i}]} gem5 5s 
      } 
   /next i 
/return 

|################### Check if any group member needs heal 
Sub Check_grpHPs 
   /declare i int local 1 
    
   /for i 1 to ${Group} 

   /if (${Group.Member[${i}].Class.Name.Equal[Cleric]} || ${Group.Member[${i}].Class.Name.Equal[Druid]} || ${Group.Member[${i}].Class.Name.Equal[Wizard]} || ${Group.Member[${i}].Class.Name.Equal[Magician]} || ${Group.Member[${i}].Class.Name.Equal[Necromancer]} || ${Group.Member[${i}].Class.Name.Equal[Enchanter]}) /if (${Group.Member[${i}].PctHPs}<=${CasterHeals}) { 
      /target pc ${Group.Member[${i}]} 
      /if (${Me.CurrentMana}<${Spell[${SpellHeal}].Mana}) { 
         /echo *** Shid ! I don't have mana to heal ${Group.Member[${i}]} 
      } else /if (${Target.Distance}<=100) { 
         /if (${Verbose}) /gsay *** ${SpellHeal} on %T 
         /call cast ${SpellHeal} gem6 4s 
      } 
   } 
    
   /if (${Group.Member[${i}].Class.Name.Equal[Warrior]} || ${Group.Member[${i}].Class.Name.Equal[Monk]} || ${Group.Member[${i}].Class.Name.Equal[Rouge]} || ${Group.Member[${i}].Class.Name.Equal[Ranger]} || ${Group.Member[${i}].Class.Name.Equal[Beast]} || ${Group.Member[${i}].Class.Name.Equal[Shadow Knight]} || ${Group.Member[${i}].Class.Name.Equal[Paladin]}) /if (${Group.Member[${i}].PctHPs}<=${MeleeHeals} && ${Group.Member[${i}].Name.NotEqual[${M_Assist}]}) { 
      /target pc ${Group.Member[${i}]}
      /if (${Me.CurrentMana}<${Spell[${SpellHeal}].Mana}) { 
         /echo *** Shid ! I don't have mana to heal ${Group.Member[${i}]} 
      } else /if (${Target.Distance}<=100) { 
         /if (${Verbose}) /gsay *** ${SpellHeal} on %T 
         /call cast ${SpellHeal} gem6 4s 
      } 
   } 

   /if (${Group.Member[${i}].Name.Equal[${M_Assist}]} && ${Group.Member[${i}].PctHPs}<=${TankHeal}) { 
      /target pc ${M_Assist} 
      /if (${Me.CurrentMana}<${Spell[${SpellHeal}].Mana}) { 
         /echo *** Shid ! I don't have mana to heal ${Group.Member[${i}]} 
      } else /if (${Target.Distance}<=100) { 
         /if (${Verbose}) /gsay *** ${SpellHeal} on %T 
         /call cast ${SpellHeal} gem6 4s 
      } 
   }
   
   /if (${Group.Member[${i}].Name.Equal[${M_Assist}]} && ${Group.Member[${i}].PctHPs}<=${HoTAt} && ${HoTOn}<=6) {
   	/target pc ${Group.Member[${i}]}
   	/if (${Me.CurrentMana}>${Spell[${SpellHoT}].Mana}) {
   		/call cast ${SpellHoT} gem4 4s
   		/if (${Macro.Return.Equal["CAST_OUTOFRANGE"]}) /varset HoTOn 60
   		/if (${Macro.Return.Equal["CAST_SUCESS"]}) /varset HoTOn ${HoTDelay}
   		/return
   	}
   }

   /next i 
/return 

| ################### Check Mana level and report it 

Sub Check_Mana 
   /if (${Math.Calc[${Me.MaxMana}*${MinMana}/100]} >= ${Me.CurrentMana} && !${LowMana}) { 
      /varset LowMana TRUE 
      /if (${Verbose}) /gsay I am LOM... 
   } else /if (${Math.Calc[${Me.MaxMana}*${BuffMana}/100]} <= ${Me.CurrentMana} && ${LowMana}) { 
      /gsay I am GTG...      
      /varset LowMana FALSE  
   } 
/return 

| ################## Canni 5 

Sub Cannibalization 
   /call CheckMyHPs 
   /if (${Me.CurrentHPs} < 2424) { 
      /call CheckMyHPs 
   } else {
   	/if (${NearestSpawn[NPC].Distance}>=75) {
   			/if (${Me.Buff[${SpellHoT}].ID}) { 
   		   	/if (${Verbose}) /gsay *** Doing Cannibalization ! 
      			/aa act Cannibalization 
      			/delay 3s
   			}
      }
		/return
   }
   		 
 /return 

| ################## This will NOT check self HPs, Only check HoT or recast HoT 

Sub CheckMyHPs 
   /if (${Me.CurrentMana}<${Spell[${SpellHoT}].Mana}) { 
      /echo *** Shit, I don't have mana to cast ${SpellHoT} 
   } else { 
      /target myself 
      /delay 3 
      /if (!${Me.Buff[${SpellHoT}].ID}) /call cast ${SpellHoT} gem7 3s 
   } 
/return 

| ################## This will Check to see if I am Low on Mana 

Sub LOM 
   /if (${Me.CurrentHPs} < ${Math.Calc[${Me.MaxHPs}/2]}) /call CheckMyHPs 
   /if (${Me.CurrentMana} < ${Math.Calc[${Me.MaxMana}-5]} && ${Me.SpellReady[${SpellCanni}]}) /call cast ${SpellCanni} gem1 6s 
   /if (${Me.AltAbility[Cannibalization]}>0 && ${Me.AltAbilityReady[Cannibalization]} && ${Me.CurrentMana} < ${Math.Calc[${Me.MaxMana}-1200]} && ${Me.MaxHPs} > 2424) /call Cannibalization 

/return    

| ################## This will Check to see if I have SOW 

Sub SOW 
   /if (!${Me.Buff[Spirit of Eagle].ID} && !${Me.Buff[Flight of Eagles].ID} && !${Me.Buff[Spirit of Bih`Li].ID} && ${DoSow} && ${OutDoors}) { 
      /target pc ${M_Assist} 
      /call cast "Spirit of Bih`Li" gem5 17s 
   } 
/return 

| ################## Summon pet and buff with spells from SpellPetBuff array 

Sub Pet 
   /if (!${Me.Pet.ID} && ${SummonPet} && ${Spell[${SpellPet}].Mana}<=${Me.CurrentMana}) { 
      /call cast ${SpellPet} gem5 25s 
      /declare i int local 
   	/if (${BuffPet}) {
      	/for i 1 to ${SpellPetBuff.Size} 
   	  		/if (!${Me.PetBuff[${SpellPetBuff[${i}]}]} && ${Spell[${SpellPetBuff[${i}]}].Mana}<=${Me.CurrentMana}) { 
    	  		/pet target 
      		/delay 2 
      		/call cast ${SpellPetBuff[${i}]} gem5 9s
      	/next i 
   		}
   	}
   }
/return 


| ################### Casting Avatar on all melee classes in group 

Sub Cast_Avatar 
   /declare i int local 
   /for i 1 to ${Group} 
   /if (${Group.Member[${i}].ID}) { 
      /if (${ATKBuffed${i}}==0) /if (${Group.Member[${i}].Class.Name.Equal[Beastlord]} || ${Group.Member[${i}].Class.Name.Equal[Shadow Knight]} || ${Group.Member[${i}].Class.Name.Equal[Bard]} || ${Group.Member[${i}].Class.Name.Equal[Ranger]} || ${Group.Member[${i}].Class.Name.Equal[Rogue]} || ${Group.Member[${i}].Class.Name.Equal[Paladin]} || ${Group.Member[${i}].Class.Name.Equal[Monk]} || ${Group.Member[${i}].Class.Name.Equal[Warrior]}) { 
         /target pc ${Group.Member[${i}]} 
         /if (${Me.CurrentMana}>${Spell[${SpellATK}].Mana}) { 
            /call cast ${SpellATK} gem4 4s 
            /if (${Macro.Return.Equal["CAST_OUTOFRANGE"]}) /varset ATKBuffed${i} 200 
            /if (${Macro.Return.Equal["CAST_SUCCESS"]}) /varset ATKBuffed${i} ${AvatarDelay} 
            /return 
         } 
      } 
   } 
   /next i 
   /return 

| ##################  ENRAGE ON 

Sub Event_Enrageon 
    /if (${PetOn}) { 
       /echo Mob is ENRAGED! 
       /pet back off 
    } 
/return 

| ##################  ENRAGE OFF 

Sub Event_Enrageoff 
    /if (${PetOn}) { 
       /echo Mob is no longer Enraged! 
       /pet attack  
    } 
/return 

| ################## Outdoors 

Sub Event_OutDoor 
   /echo This is an indoor zone. Sorry. 
   /varset OutDoors FALSE 
/return 

| ##################  Zoning 

Sub Event_Zoning 
   /echo I zoned, time to shrink 
   /if (${Verbose}) /gsay Shrinks incomming Now 
   /delay 10 
   /call cast ${SpellSHRINK} gem5 5s 
   /call cast ${SpellSHRINK} gem5 5s 

   /varset TargetArray[1] ${Target.CleanName} 
   /varset TargetArray[2] ${Target.Level} 
   /varset TargetArray[3] ${Target.Name} 
   /varset TargetArray[4] ${Target.ID} 
   /varset CombatOn TRUE 
        
   /varset MobRooted FALSE 
   /varset MobMaloed FALSE 
   /varset MobSlowed FALSE 
   /varset MobCrippled FALSE
   /varset PetOn FALSE 
   /varset MobDoTed FALSE 

/return 

| ################## I Died 

Sub Event_ImDead 
   /echo Bummer ! 
   :Zone_Loop 
      /if ( ${Me.Bound.ID} != ${Zone.ID} ) /goto :Zone_Loop 
   /delay 5s 
   /consent group 
   /delay 5 
   /gsay Im ready to get rez. 
   /call Wait4Rez 
   /delay 20 
   /call MemSpells 
   /if (${Me.State.Equal[Stand]}) /sit 

| We do some short meditate before we start again. 

   :Meditate 
      /delay 1s 
      /if (${Me.CurrentMana} < 300) /goto :Meditate 
   /return 

| ################## This part is taken from wait4res. 

Sub Wait4Rez 
   :waitforrez 
      /if (!${Window[ConfirmationDialogBox].Open}) { 
         /delay 5s ${Window[ConfirmationDialogBox].Open} 
         /goto :waitforrez 
      } 
      /if (${Window[ConfirmationDialogBox].Open}) /notify ConfirmationDialogBox Yes_Button  leftmouseup 
      :zonein 
         /delay 5 
         /squelch /target mycorpse 
         /delay 5 
         /if (${Target.CleanName.NotEqual[${Me}'s corpse]}) /goto :zonein 
         /if (${Target.CleanName.Equal[${Me}'s corpse]}) { 
            /delay 3s 
            /call Loot_Corpse 
         } else /goto :zonein 
   /return 

| #################  Looting Corpse 

Sub Loot_Corpse 
   /declare LootTotal int local 0 
   /declare LootSlot int local 
   /squelch /target mycorpse 
   /if (${Target.Type.NotEqual[CORPSE]} || !${Target.ID}) { 
      /echo ** Can't target my corpse. 
      /return 
   }    
   /corpse 
   /delay 1s 
   /loot 
   /delay 1s 
   /if (${Me.State.NotEqual[BIND]}) { 
      /echo ** Massive lag right now... Aborting looting. 
      /return 
   } 
   :LootLag 
      /if (${LootTotal}!=${Corpse.Items}) { 
         /varset LootTotal ${Corpse.Items} 
         /delay 5 
         /goto :LootLag 
      } 
   /for LootSlot 1 to ${LootTotal} 
   :LootItem 
      /itemnotify loot${LootSlot} rightmouseup 
      /delay 3 
      /if (${Corpse.Item[${LootSlot}].ID}) { 
         /delay 2 
         /goto :LootItem 
      } 
   /next LootSlot 
   /delay 5 
   /echo ** Done looting my corpse. 
   /notify LootWnd DoneButton leftmouseup 
   /return 

| ################# 
| ################# Tells n Hells 
| ################# 

Sub Event_Chat(string ChatType,string ChatSender,string ChatText) 

   /declare i 	int 	local
   /if (!${ChatType.Equal[GROUP]} && !${ChatType.Equal[TELL]}) /return 
     
   |- Authenticate if valid controller
	/declare authorized bool local FALSE
	/for i 1 to 20
		/if (${Ini[ShamBot.ini,Masters,Controller${i}].Equal[${Sender}]}) /varset authorized TRUE
	/next i
	/if (${authorized} && ${ChatText.Left[1].Equal[/]}) {
      /echo ** User ${Sender} Authenticated!
      /echo Action --> "${ChatText}"
      /if (${Me.AFK}) /delay 2s
      	/tell ${Sender} Command received, performing: ${ChatText}
    		/docommand ${ChatText}
  	}

  	/if ${RaidBuff} {
  		/declare focus					string local
		/declare stamina				string local
		/declare sense					string local
		/declare all3					string local
		| Lets Check a few things before we buff
		/if (!${Spawn[${Sender}].ID}) {
			/echo ${Sender} is out of zone Ignoring!
			/return
		}
	
		/if (${Spawn[${Sender}].GM}) {
			/echo ${Sender} is a GM! Fuck Him!
			/return
		}
	
		/if (${Spawn[${Sender}].Guild.NotEqual[${Me.Guild}]} {
			/echo Unauthorized Reqest...Ignoring!
			/return
		}
	
		/if (!${Spawn[${Sender}].LineOfSight}) {
			/echo ${Sender} is not in Line of sight...Ignoring
			/return
		}
		| Ok they're cool...let's find out what they want! And add it to a Queue
		/varset RequestedBuff ${ChatText}
		| Pick out what they want and how many things they want
		| Do they want focus?
		/if (${RequestedBuff.Find[focus]} || ${RequestedBuff.Find[wunsh]} || ${RequestedBuff.Find[wunshi]}) {
			/varset focus TRUE
		} else /varset focus FALSE
		| Do they want stamina?
		/if (${RequestedBuff.Find[sta]} || ${RequestedBuff.Find[forti]} || ${RequestedBuff.Find[fort]}) {
			/varset stamina TRUE
		} else /varset stamina FALSE
		| Do they want sense?
		/if (${RequestedBuff.Find[sense]} || ${RequestedBuff.Find[sta]}) {
		/varset sense TRUE
		} else /varset sense FALSE
		| Are they being gay and just asking for all shaman buffs?
		/if (${RequestedBuff.Find["shaman buffs"]} || ${RequestedBuffs.Find[buffs]}) {
			/varset all3 TRUE
		}
		| Lets Give it to them
		/if (${all3}) {
			/varset focus 		TRUE
			/varset stamina 	TRUE
			/varset sense 		TRUE
		}
		/if (${focus}) {
			/varset focus FALSE
			/call cast ${SpellFOCUS} gem5 6s
		}
		/if (${stamina}) {
			/varset stamina FALSE
			/call cast ${SpellSTA} gem5 6s
		}
		/if (${sense}) {
			/varset sense FALSE
			/call cast ${SpellSoS} gem5 6s
		}
	/return
}        
| ################# Heal Requests 
  
     /if (${ChatText.Equal[heal]} || ${ChatText.Equal[heal me]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellHeal} is incomming !! 
             /call cast ${SpellHeal} 
             } 
      /return 
      } 

      /if (${ChatText.Equal[hot]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellHoT} is incomming !! 
             /call cast ${SpellHoT} 
             } 
      /return 
      } 

| ################# Mob Requests      

      /if (${ChatText.Equal[slow]} || ${ChatText.Equal[add]} && ${authorized}) { 
         /assist ${ChatSender} 
         /if (${Target.Type.Equal[NPC]} && ${Target.Distance}<=100) { 
            /call cast ${SpellDebuff} gem3 6s 
            /call cast ${SpellSlow} gem2 6s 
            /tell ${ChatSender} %T is ${SpellDeBuff} and slowed with ${SpellSlow} 
            } 
      /return 
      } 

      /if (${ChatText.Equal[root]} && ${authorized}) { 
         /assist ${ChatSender} 
         /if (${Target.Type.Equal[NPC]} && ${Target.Distance}<=100) { 
            /call cast ${SpellRoot} gem9 5s 
            /tell ${ChatSender} %T is Rooted with ${SpellRoot} 
            } 
      /return 
      } 


      /if (${ChatText.Equal[nuke]} && ${authorized}) { 
         /assist ${ChatSender} 
         /if (${Target.Type.Equal[NPC]} && ${Target.Distance}<=100) { 
            /call cast ${SpellNuke} gem9  
            } 
      /return 
      } 
        
      /if (${ChatText.Equal[dot]} && ${authorized}) { 
         /assist ${ChatSender} 
         /if (${Target.Type.Equal[NPC]} && ${Target.Distance}<=100) { 
            /call cast ${SpellDot} gem8 5s 
            } 
      /return 
      } 

      /if (${Engaged}) /return    

| ################# Buff Requests 

      /if (${ChatText.Equal[avatar]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellATK} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellATK} gem4 4s 
        }    
         /return 
      }  
    
      /if (${ChatText.Equal[PR]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellPR} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellPR} gem4 4s 
        }    
         /return 
      }  

      /if (${ChatText.Equal[haste]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellHASTE} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellHASTE} gem5 5s 
        }    
         /return 
      }  

      /if (${ChatText.Equal[focus]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellFOCUS} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellFOCUS} gem5 5s 
        }    
         /return 
      }  

      /if (${ChatText.Equal[cha]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellCHA} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellCHA} gem5 5s 
        }    
         /return 
      }  

      /if (${ChatText.Equal[lev]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellLEV} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellLEV} gem5 5s 
        }    
         /return 
      }  

      /if (${ChatText.Equal[sow]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellSOW} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellSOW} gem5 5s 
        }    
         /return 
      }  
      /if (${ChatText.Equal[grow]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellGROW} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellGROW} gem5 5s 
        }    
         /return 
      } 
  
      /if (${ChatText.Equal[shrink]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellSHRINK} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellSHRINK} gem5 5s 
        }    
         /return 
      }  


      /if (${ChatText.Equal[see]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellSEE} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellSEE} gem5 5s 
        }    
         /return 
      } 


      /if (${ChatText.Equal[str]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellSTR} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellSTR} gem5 5s 
        }    
         /return 
      }  

      /if (${ChatText.Equal[dex]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellDEX} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellDEX} gem5 5s 
        }    
         /return 
      }  

      /if (${ChatText.Equal[sta]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellSTA} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellSTA} gem5 5s 
        }    
         /return 
      }  

      /if (${ChatText.Equal[agi]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellAGI} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellAGI} gem5 5s 
        }    
         /return 
      }  

      /if (${ChatText.Equal[regen]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellREGEN} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellREGEN} gem5 5s 
        }    
         /return 
      }  

      /if (${ChatText.Equal[pe]}) { 
         /target pc ${ChatSender} 
         /if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
             /tell ${ChatSender} ${SpellPE} is incomming to you ${ChatSender}!!! 
             /call cast ${SpellPE} gem5 5s 
        }    
         /return 
      } 

| ################# Follow me 

 /if (${ChatText.Equal[Follow me]} || ${ChatText.Equal[Follow]} && ${authorized}) { 
    /delay 5 
    /if (!${Spawn[${ChatSender}].ID}) { 
       /e ${ChatSender}  is not in zone for me to follow! 
       /return 
    } 
    /varset follname ${ChatSender}  
    /varset following 1 
    /if ( ${Me.Mount.ID} ) /dismount 
       :targetfoll 
          /target pc ${follname} 
          /delay 1s ${Target.Name.Equal[${follname}]} 
          /if (${Target.Name.Equal[${follname}]}) { 
          /goto :Loop 
    } else /goto :targetfoll 

    :Loop 
    /face fast 
    /if (${Target.Distance}>40) /keypress forward hold 
    /if (${Target.Distance}<39) /keypress back 
    /if (!${Target.ID}) /varset following 0 
    /doevents 
    /if ((${Target.Name.Equal[${follname}]})&&(${following}>0)) { 
       /goto :Loop 
    } else { 
       /keypress forward 
       /keypress back 
    } 
 } 


| ################# Stop Following me 

 /if (${ChatText.Equal[End follow]} || ${ChatText.Equal[stop]}) { 
    /varset following 0 
    /keypress forward 
    /keypress back 
    /timed 50 /face pc ${follname} 
    /return  
 } 

| ################# Single Rebuff 

/if (${ChatText.Equal[buff me]}) { 
   /echo Request for Single Buff 
   /declare i int local 1 
   /for i 1 to ${SpellSingleBuff.Size} 
   /if (${Spell[${SpellSingleBuff[${i}]}].Mana} > ${Me.CurrentMana}) { 
      /tell ${ChatSender} ${ChatSender} Sorry I am getting LOM        
      /echo DAMN.. LOM... Cannibalizing to rebuff 
       :Hold_Single_Rebuff 
          /Call LOM 
          /if (${Spell[${SpellSingleBuff[${i}]}].Mana} > ${Me.CurrentMana}) { 
             /goto :Hold_Single_Rebuff              
           } 
    } 
   /target pc ${ChatSender} 
   /delay 3 
   /echo *** Hang on ! Buffing ${SpellSingleBuff[${i}]} 
   /tell ${ChatSender} Buffing ${SpellSingleBuff[${i}]} now... 
   /call cast ${SpellSingleBuff[${i}]} gem5 5s      
   /next i 
   /return 
} 

| ################# Single Rebuff other 

 /if (${ChatText.Equal[buff]}) { 
    /echo Request for Single Buff other 
    /assist ${ChatSender} 
    /declare i int local 1 
    /for i 1 to ${SpellSingleBuff.Size} 
    /if (${Spell[${SpellSingleBuff[${i}]}].Mana} > ${Me.CurrentMana}) { 
       /tell ${ChatSender} ${ChatSender} Sorry I am getting LOM        
       /echo DAMN.. LOM... Cannibalizing to rebuff 
       :Hold_Single_Rebuff 
          /Call LOM 
          /if (${Spell[${SpellSingleBuff[${i}]}].Mana} > ${Me.CurrentMana}) { 
             /goto :Hold_Single_Rebuff              
           } 
    } 
    /delay 3 
    /echo *** Hang on ! Rebuffing ${SpellSingleBuff[${i}]} 
    /tell ${ChatSender} Buffing ${SpellSingleBuff[${i}]} now... 
    /call cast ${SpellSingleBuff[${i}]} gem5 7s      
    /next i 
    /return 
 } 

| ################# Group Rebuff other group 

 /if (${ChatText.Equal[buff them]}) { 
    /assist ${ChatSender} 
    /declare i int local 1 
    /for i 1 to ${SpellGrpBuff.Size}        
    /if (${Spell[${SpellGrpBuff[${i}]}].Mana} > ${Me.CurrentMana}) { 
       /tell ${ChatSender} ${ChatSender}, Sorry I am getting LOM                  
       /echo DAMN.. LOM... Cannibalizing to rebuff 
       :Hold_Group_Rebuff 
          /Call LOM 
          /if (${Spell[${SpellGrpBuff[${i}]}].Mana} > ${Me.CurrentMana}) { 
          /goto :Hold_Group_Rebuff              
          } 
    } 
    /delay 3 
    /echo *** Hang on ! Rebuffing ${SpellGrpBuff[${i}]} 
    /tell ${ChatSender} Buffing ${SpellGrpBuff[${i}]} now... 
    /call cast ${SpellGrpBuff[${i}]} gem5 7s      
    /next i 
    /return 
 } 


| ################# Other Pet Buffing 

 /if (${ChatText.Equal[buff pet]}) { 
    /echo Request for Pet Buffs 
    /target id ${Spawn[pc ${ChatSender}].Pet.ID} 
    /delay 3 
    /tell ${ChatSender} Targetting your pet, %T for buffs... 
    /declare i int local 1 
    /for i 1 to ${SpellPetBuffo.Size} 
    /if (${Spell[${SpellPetBuffo[${i}]}].Mana} > ${Me.CurrentMana}) { 
       /tell ${ChatSender} ${ChatSender} Sorry I am getting LOM 
       /echo DAMN.. LOM... Cannibalizing to rebuff 
       :Hold_Pet_Rebuff 
          /Call LOM 
          /if (${Spell[${SpellPetBuffo[${i}]}].Mana} > ${Me.CurrentMana}) { 
             /goto :Hold_Pet_Rebuff 
          }        
    } 
    /delay 3 
    /echo *** Hang on ! Rebuffing ${SpellPetBuffo[${i}]} 
    /tell ${ChatSender} buffing ${SpellPetBuffo[${i}]} now... 
    /call cast ${SpellPetBuffo[${i}]} gem5 5s      
    /next i 
    /return 
 } 

| ################### Go Home 

 /if (${ChatText.Equal[gate now]} && ${ChatType.Equal[TELL]}) { 
    /call cast ${SpellGATE} gem9  
    /return 
    } 

 /if (${ChatType.Equal[TELL]}) { 
    /1 [${ChatSender}]:${ChatText} 
    /vtell ${ChatController} 001 
    /return 
    } 


/return 

| ################## Echo Changes

Sub Event_Paused
	/if (${IsPaused}) {
		/varset IsPaused FALSE
		/echo ShamBot is now RESUMING!
	} else {
		/varset IsPaused TRUE
		/echo ShamBot is now PAUSED!
	}
/return

Sub Event_AstChange(string Line) 
	/if (${Line.Arg[3].Length}) /varset M_Assist ${Line.Arg[3]} 
	/if (${Line.Arg[4]} > 0) /varset CombatAt ${Line.Arg[4]}  
	/echo ** Assisting: ${M_Assist} @${CombatAt}% target health 
	/ini "ShamBot.ini" "General" "M_Assist" "${M_Assist}"
	/ini "ShamBot.ini" "Combat" "CombatAt" "${CombatAt}"
/return

Sub Event_Rootchg(string Line)
	/if (${Line.Arg[3].Equal[off]}) {
		/varset DoRoot FALSE
		/echo No longer Rooting!
		/return
	} else {
		/varset DoRoot TRUE
		/if (${Line.Arg[3].Length}) {
			/varset Rootat ${Line.Arg[3]}
		}		
		/if (${Line.Arg[4].Length}) {
			/varset RootMana ${Line.Arg[4]}
		}
		/echo Now Rooting @ ${Rootat}% NPC Health!
		/echo Minimum Mana to root is ${RootMana}%.
	}
	/ini "ShamBot.ini" "Combat" "Rootat" ${Rootat}
	/ini "ShamBot.ini" "Combat" "RootMana" ${RootMana}
	/ini "ShamBot.ini" "ToDo" "DoRoot" ${DoRoot}
/return
	
Sub Event_Dotchg(string Line)
	/if (${Line.Arg[3].Equal[off]}) {
		/varset DoDoT FALSE
		/echo No longer DoT'ing!
		/return
	} else {
		/varset DoDoT TRUE
		/if (${Line.Arg[3].Length}) {
			/varset CastDoTat ${Line.Arg[3]}
		}		
		/if (${Line.Arg[4].Length}) {
			/varset DotMana ${Line.Arg[4]}
		}
		/echo Now DoT'ing @ ${Rootat}% NPC Health!
		/echo Minimum Mana to cast DoT is ${DotMana}%.
	}
	/ini "ShamBot.ini" "Combat" "Dotat" ${CastDoTat}
	/ini "ShamBot.ini" "Combat" "DotMana" ${DotMana}
	/ini "ShamBot.ini" "ToDo" "DoDoT" ${DoDoT}
/return

Sub Event_Nukechg(string Line)
	/if (${Line.Arg[3].Equal[off]}) {
		/varset DoNuke FALSE
		/echo No longer Nukeing!
		/return
	} else {
		/varset DoNuke TRUE
		/if (${Line.Arg[3].Length}) {
			/varset NukeAt ${Line.Arg[3]}
		}		
		/if (${Line.Arg[4].Length}) {
			/varset NukeMana ${Line.Arg[4]}
		}
		/echo Now Nukeing @ ${Rootat}% NPC Health!
		/echo Minimum Mana to Nuke is ${NukeMana}%.
	}
	/ini "ShamBot.ini" "Combat" "Rootat" ${NukeAt}
	/ini "ShamBot.ini" "Combat" "RootMana" ${NukeMana}
	/ini "ShamBot.ini" "ToDo" "DoRoot" ${DoNuke}
/return
	

Sub Event_Malochg
	/if (${DoMalo}) {
		/varset DoMalo FALSE
		/echo No longer casting Malo!
	} else {
		/varset DoMalo TRUE
		/echo Now casting Malo!
	}
	/ini "Shambot.ini" "ToDo" "DoMalo" ${DoMalo}
/return

Sub  Event_Slowchg(string Line)
	/if (${DoSlow} {
		/varset DoSlow FALSE
		/echo No longer casting Slow!
	} else {
		/varset DoSlow TRUE
		/echo Now casting Slow!
		/if ({Line.Arg[3].Equal[fast]} && !${FastSlow}) {
			/varset FastSlow TRUE
			/echo Fast Slow is now ON! (Only attempting to slow ONCE!)
		} else {
			/varset FastSlow FALSE
			/echo Fast Slow is now OFF!
		}
	}
	/ini "ShamBot.ini" "ToDo" "DoSlow" ${DoSlow}
	/ini "ShamBot.ini" "ToDo" "FastSlow" ${FastSlow}
/return

Sub  Event_Cripplechg(string Line)
	/if (${DoCripple} {
		/varset DoCripple FALSE
		/echo No longer casting Cripple!
	} else {
		/varset DoCripple TURE
		/echo Now casting Cripple!
		/if ({Line.Arg[3].Equal[fast]} && !${FastCripple}) {
			/varset FastSlow TRUE
			/echo Fast Cripple is now ON! (Only attempting to Cripple ONCE!)
		} else {
			/varset FastCripple FALSE
			/echo Fast Cripple is now OFF!
		}
	}
	/ini "ShamBot.ini" "ToDo" "DoCripple" ${DoCripple}
	/ini "ShamBot.ini" "ToDo" "FastCripple" ${FastCripple}
/return

Sub Event_Healchg(string Line)
	/if (${Line.Arg[3].Equal[off]}) {
		/varset DoHeal FALSE
		/echo Healing is now OFF!
	} else {
		/varset DoHeal TRUE
		/echo Now HEALING!
		/if (${Line.Arg[3].Equal[caster]}) {
			/varset CasterHeals ${Line.Arg[4]}
			/echo Now Healing Casters at ${CasterHeals}% HP!
		}
		/if (${Line.Arg[3].Equal[melee]}) {
			/varset MeleeHeals ${Line.Arg[4]}
			/echo Now Healing Melee at ${MeleeHeals}% HP!
		}
		/if (${Line.Arg[3].Equal[tank]}) {
			/varset TankHeal ${Line.Arg[4]}
			/echo Now Healing the Tank at ${TankHeal}% HP!
		}
	}
	/ini "ShamBot.ini" "ToDo" "DoHeal" ${DoHeal}
	/ini "ShamBot.ini" "HealsPri" "CasterHeals" ${CasterHeals}
	/ini "ShamBot.ini" "HealsPri" "MeleeHeals" ${MeleeHeals}
	/ini "ShamBot.ini" "HealsPri" "TankHeal" ${TankHeal}
/return

Sub Event_Verbchg
	/if (${Verbose}) {
		/varset Verbose FALSE
		/echo Verbose is now OFF!
	} else {
		/varset Verbose TRUE
		/echo Verbose is now ON!
	}
	/ini "ShamBot.ini" "ToDo" "Verbose" ${Verbose}
/return

Sub Event_Atkchg
	/if (${DoATK}) {
		/varset DoATK FALSE
		/echo No longer casting FA on melee in group!
	} else {
		/varset DoATK TRUE
		/echo Now casting FA on melee in group!
	}
	/ini "ShamBot.ini" "ToDo" "DoATK" ${DoATK}
/return

Sub Event_SOWchg
	/if (${DoSOW}) {
		/varset DoSOW FALSE
		/echo No longer casting SOW!
	} else {
		/varset DoSOW TRUE
		/echo Now casting SOW!
	}
	/ini "ShamBot.ini" "ToDo" "DoATK" ${DoATK}
/return

Sub Event_Mountchg
	/if (${UseMount}) {
		/varset UseMount FALSE
		/echo No longer using a mount!
	} else {
		/varset UseMount TRUE
		/echo Now using a mount!
	}
	/ini "ShamBot.ini" "General" "UseMount" ${UseMount}
/return

Sub Event_sitatchg(string Line)
	/if (${Line.Arg[3].Length}) {
		/varset SitAt ${Line.Arg[3]}
	}
	/ini "ShamBot.ini" "Combat" "SitAt" ${SitAt}
/return

Sub Event_AutoSit
	/if ${AutoSit} {
		/varset AutoSit FALSE
		/echo No longer Sitting!
	} else {
		/varset AutoSit TRUE
		/echo Now AUTOSITTING!
	}
	/ini "ShamBot.ini" "ToDo" "AutoSit" ${AutoSit}
/return
	
Sub Event_DoBuffs
	/if (${DoBuffs}) {
		/varset DoBuffs FALSE
		/echo No longer Buffing the group!
	} else {
		/varset DoBuffs TRUE
		/echo Now Buffing the group!
	}
	/ini "ShamBot.ini" "ToDo" "DoBuffs" ${DoBuffs}
/return

Sub Event_PetChg(string Line)
	/if (${Line.Arg[3].Equal[off]}) {
		/varset SummonPet FALSE
		/echo No lonnger using a PET!
	} else {
		/if (${Line.Arg[3].Equal[buff]}) {
			/varset SummonPet TRUE
			/varset BuffPet TRUE
			/echo Now using a PET and BUFFING it!
		}
		/if (${Line.Arg[3].Equal[nobuff]}) {
			/varset SummonPet TRUE
			/varset BuffPet FALSE
			/echo Now using a PET but NOT BUFFING it!
		}
		/varset SummonPet TRUE
	}
	/ini "ShamBot.ini" "ToDo" "SummonPet" ${SummonPet}
	/ini "ShamBot.ini" "ToDo" "BuffPet" ${BuffPet}
/return

Sub Event_AddMaster(string Line)
  /declare index int local
  /if (${Line.Arg[3].Length}) {
    /for index 1 to 20
      /if (${Ini[ShamBot.ini,Masters,Controller${index}].Equal[Nobody]}) {
        /ini "ShamBot.ini" "Masters" "Controller${index}" "${Line.Arg[3]}"
        /echo ** ${Line.Arg[3]} added as a controller...
        /goto :FallOut
      }
    /next index
    /echo ** Master controller slots all filled! Get rid of some!
  } else {
    /echo ** Huh?
  }
  :FallOut
/return  

Sub Event_Shrink
	/target pc ${M_Assist}
	/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) {
		/echo Shrinkin j00 mother fuckers!
		/call cast ${SpellSHRINK} gem5 5s
		/cass cast ${SpellSHRINK} gem5 5s
	}
/return

Sub Event_HoTchg(string Line)
	/if (${Line.Arg[3].Equal[off]}) {
		/varset HoTTank FALSE
		/echo No longer using HOT to help heal Tank!
	} else {
		/varset HoTTank TRUE
		/if (${Line.Arg[3].Length}) {
			/varset HoTAt ${Line.Arg[3]}
			/echo HOT is now ON!
			/echo Now Casting HOT at ${HoTAt}% Tank HP!
			/return
		}
		/echo Now Casting HOT on the Tank at ${HoTAt}% HP!
	}
	/ini "ShamBot.ini" "HealsPri" "HoTAt" ${HoTAt}
	/ini "ShamBot.ini" "ToDo" "HoTTank" ${HoTTank}
/return
		
Sub Event_RaidBuff
	/if (${RaidBuff} {
		/varset RaidBuff FALSE
		/echo Raid Buffing Mode is now OFF!
	} else {
		/varset RaidBuff TRUE
		/echo Raid Buffing Mode is now ON!
	}
/return

Shamini.inc

|ShamBot.inc

Sub CreateIni
  /declare i int local
  /ini "ShamBot.ini" "General" "M_Assist" ${M_Assist}
  /ini "ShamBot.ini" "General" "Made" TRUE  
  /ini "ShamBot.ini" "General" "UseMount" FALSE
  /ini "ShamBot.ini" "Spells" "SpellSlow" ${SpellSlow}
  /ini "ShamBot.ini" "Spells" "SpellDebuff" ${SpellDeBuff}
  /ini "ShamBot.ini" "Spells" "SpellCripple" ${SpellCripple}
  /ini "ShamBot.ini" "Spells" "SpellHeal" ${SpellHeal}
  /ini "ShamBot.ini" "Spells" "SpellHoT" ${SpellHoT}
  /ini "ShamBot.ini" "Spells" "SpellRoot" ${SpellRoot}
  /ini "ShamBot.ini" "Spells" "SpellNuke" ${SpellNuke}
  /ini "ShamBot.ini" "Spells" "SpellDoT" ${SpellDoT}
  /ini "ShamBot.ini" "Spells" "SpellATK" ${SpellATK}  
  /ini "ShamBot.ini" "Spells" "SpellHASTE" ${SpellHASTE}
  /ini "ShamBot.ini" "Spells" "SpellFOCUS" ${SpellFOCUS}
  /ini "ShamBot.ini" "Spells" "SpellCHA" ${SpellCHA}
  /ini "ShamBot.ini" "Spells" "SpellDEX" ${SpellDEX}
  /ini "ShamBot.ini" "Spells" "SpellSTR" ${SpellSTR}
  /ini "ShamBot.ini" "Spells" "SpellAGI" ${SpellAGI}
  /ini "ShamBot.ini" "Spells" "SpellSoS" ${SpellSoS}
  /ini "ShamBot.ini" "Spells" "SpellSTA" ${SpellSTA}
  /ini "ShamBot.ini" "Spells" "SpellREGEN" ${SpellREGEN}
  /ini "ShamBot.ini" "Spells" "SpellPE" ${SpellPE}
  /ini "ShamBot.ini" "Spells" "SpellPR" ${SpellPR}
  /ini "ShamBot.ini" "Spells" "SpellSOW" ${SpellSOW}
  /ini "ShamBot.ini" "Spells" "SpellLEV" ${SpellLEV}
  /ini "ShamBot.ini" "Spells" "SpellINV" "${SpellINV}"
  /ini "ShamBot.ini" "Spells" "SpellSHRINK" ${SpellSHRINK}
  /ini "ShamBot.ini" "Spells" "SpellGROW" ${SpellGROW}
  /ini "ShamBot.ini" "Spells" "SpellGATE" ${SpellGATE}
  /for i 1 to ${SpellGrpBuff.Size}
	/ini "ShamBot.ini" "Spells" "SpellGrpBuff[${i}]" ${SpellGrpBuff[${i}]}
  /next i
  /for i 1 to ${SpellSingleBuff.Size}
  	/ini "ShamBot.ini" "Spells" "SpellSingleBuff[${i}]" ${SpellSingleBuff[${i}]}
  /next i
  /for i 1 to ${SpellPetBuff.Size}
  	/ini "ShamBot.ini" "Spells" "SpellPetBuff[${i}]" ${SpellPetBuff[${i}]}
  /next i
  /for i 1 to ${SpellPetBuffo.Size}
  	/ini "ShamBot.ini" "Spells" "SpellPetBuffo[${i}]" ${SpellPetBuffo[${i}]}
  /next i
  /ini "ShamBot.ini" "Combat" "AssistAt" ${AssistAt}
  /ini "ShamBot.ini" "Combat" "CombatAt" ${CombatAt}
  /ini "ShamBot.ini" "Combat" "CastDoTat" ${CastDoTat}
  /ini "ShamBot.ini" "Combat" "DotMana" ${DotMana}
  /ini "ShamBot.ini" "Combat" "Rootat" ${Rootat}
  /ini "ShamBot.ini" "Combat" "RootMana" ${RootMana}
  /ini "ShamBot.ini" "Combat" "NukeAt" ${NukeAt}
  /ini "ShamBot.ini" "Combat" "NukeMana" ${NukeMana}
  /ini "ShamBot.ini" "Combat" "SitAt" ${SitAt}

  /ini "ShamBot.ini" "ToDo" "DoMalo" ${DoMalo}
  /ini "ShamBot.ini" "ToDo" "DoSlow" ${DoSlow}
  /ini "ShamBot.ini" "ToDo" "FastSlow" ${FastSlow}
  /ini "ShamBot.ini" "ToDo" "DoCripple" ${DoCripple}
  /ini "ShamBot.ini" "ToDo" "FastCripple" ${FastCripple}
  /ini "ShamBot.ini" "ToDo" "DoRoot" ${DoRoot}
  /ini "ShamBot.ini" "ToDo" "DoDot" ${DoDoT}
  /ini "ShamBot.ini" "ToDo" "DoNuke" ${DoNuke}
  /ini "ShamBot.ini" "ToDo" "DoHeal" ${DoHeal}
  /ini "ShamBot.ini" "ToDo" "HoTTank" ${HoTTank}
  /ini "ShamBot.ini" "ToDo" "DoATK" ${DoATK}
  /ini "ShamBot.ini" "ToDo" "DoBuffs" ${DoBuffs}
  /ini "ShamBot.ini" "ToDo" "SummonPet" ${SummonPet}
  /ini "ShamBot.ini" "ToDo" "BuffPet" ${BuffPet}
  /ini "ShamBot.ini" "ToDo" "DoSow"	
  /ini "ShamBot.ini" "ToDo" "Verbose" ${Verbose}

  /ini "ShamBot.ini" "HealsPri" "CasterHeals" ${CasterHeals}
  /ini "ShamBot.ini" "HealsPri" "MeleeHeals" ${MeleeHeals}
  /ini "ShamBot.ini" "HealsPri" "TankHeal" ${TankHeal}
  /ini "ShamBot.ini" "HealsPri" "HoTAt" ${HoTAt}
 |- Build Empty master list in ShamBot.ini file if it doesn't exist
  /if (!${Ini[ShamBot.ini,Masters,Controller1].Length}) {
    |- It's not in there yet
    /for i 1 to 20
      /ini "ShamBot.ini" "Masters" "Controller${i}" "Nobody"
    /next i
		/echo Ini is now Created. Make needed changes and restart the Macro.  
    /endmacro
  }
/return

Sub LoadIni
	/echo Loading from the Ini File!
	/if (${Ini[ShamBot.ini,General,M_Assist].NotEqual[NULL]}) /varset M_Assist ${Ini[ShamBot.ini,General,M_Assist]}
	/if (${Ini[ShamBot.ini,General,DoHaste].NotEqual[NULL]}) /varset DoHaste ${Ini[ShamBot.ini,General,DoHaste]}
	/if (${Ini[ShamBot.ini,General,DoSOW].NotEqual[NULL]}) /varset DoSOW ${Ini[ShamBot.ini,General,DoSOW]}
	/if (${Ini[ShamBot.ini,General,DoPet].NotEqual[NULL]}) /varset SummonPet ${Ini[ShamBot.ini,General,DoPet]}
	/if (${Ini[ShamBot.ini,General,UseMount].NotEqual[NULL]}) /varset UseMount ${Ini[ShamBot.ini,General,UseMount]}
	/if (${Ini[ShamBot.ini,Spells,SpellSlow].NotEqual[NULL]}) /varset SpellSlow "${Ini[ShamBot.ini,Spells,SpellSlow]}"
	/if (${Ini[ShamBot.ini,Spells,SpellDebuff].NotEqual[NULL]}) /varset SpellDeBuff "${Ini[ShamBot.ini,Spells,SpellDebuff]}"
	/if (${Ini[ShamBot.ini,Spells,SpellCripple].NotEqual[NULL]}) /varset SpellCripple "${Ini[ShamBot.ini,Spells,SpellCripple]}"
	/if (${Ini[ShamBot.ini,Spells,SpellHeal].NotEqual[NULL]}) /varset SpellHeal "${Ini[ShamBot.ini,Spells,SpellHeal]}"
	/if (${Ini[ShamBot.ini,Spells,SpellHoT].NotEqual[NULL]}) /varset SpellHoT "${Ini[ShamBot.ini,Spells,SpellHoT]}"
	/if (${Ini[ShamBot.ini,Spells,SpellRoot].NotEqual[NULL]}) /varset SpellRoot "${Ini[ShamBot.ini,Spells,SpellRoot]}"
	/if (${Ini[ShamBot.ini,Spells,SpellpDoT].NotEqual[NULL]}) /varset SpellDoT "${Ini[ShamBot.ini,Spells,SpellpDoT]}"
	/if (${Ini[ShamBot.ini,Spells,SpellATK].NotEqual[NULL]}) /varset SpellATK "${Ini[ShamBot.ini,Spells,SpellATK]}"
	/if (${Ini[ShamBot.ini,Spells,SpellHASTE].NotEqual[NULL]}) /varset SpellHASTE "${Ini[ShamBot.ini,Spells,SpellHASTE]}"
	/if (${Ini[ShamBot.ini,Spells,SpellFOCUS].NotEqual[NULL]}) /varset SpellFOCUS "${Ini[ShamBot.ini,Spells,SpellFOCUS]}"
	/if (${Ini[ShamBot.ini,Spells,SpellCHA].NotEqual[NULL]}) /varset SpellCHA "${Ini[ShamBot.ini,Spells,SpellCHA]}"
	/if (${Ini[ShamBot.ini,Spells,SpellDEX].NotEqual[NULL]}) /varset SpellDEX "${Ini[ShamBot.ini,Spells,SpellDEX]}"
	/if (${Ini[ShamBot.ini,Spells,SpellSTR].NotEqual[NULL]}) /varset SpellSTR "${Ini[ShamBot.ini,Spells,SpellSTR]}"
	/if (${Ini[ShamBot.ini,Spells,SpellAGI].NotEqual[NULL]}) /varset SpellAGI "${Ini[ShamBot.ini,Spells,SpellAGI]}"
	/if (${Ini[ShamBot.ini,Spells,SpellREGEN].NotEqual[NULL]}) /varset SpellREGEN "${Ini[ShamBot.ini,Spells,SpellREGEN]}"
	/if (${Ini[ShamBot.ini,Spells,SpellPE].NotEqual[NULL]}) /varset SpellPE "${Ini[ShamBot.ini,Spells,SpellPE]}"
	/if (${Ini[ShamBot.ini,Spells,SpellPR].NotEqual[NULL]}) /varset SpellPR "${Ini[ShamBot.ini,Spells,SpellPR]}"
	/if (${Ini[ShamBot.ini,Spells,SpellSOW].NotEqual[NULL]}) /varset SpellSOW "${Ini[ShamBot.ini,Spells,SpellSOW]}"
	/if (${Ini[ShamBot.ini,Spells,SpellLEV].NotEqual[NULL]}) /varset SpellLEV "${Ini[ShamBot.ini,Spells,SpellLEV]}"
	/if (${Ini[ShamBot.ini,Spells,SpellINV].NotEqual[NULL]}) /varset SpellINV "${Ini[ShamBot.ini,Spells,SpellINV]}"
	/if (${Ini[ShamBot.ini,Spells,SpellSHRINK].NotEqual[NULL]}) /varset SpellSHRINK "${Ini[ShamBot.ini,Spells,SpellSHRINK]}"
	/if (${Ini[ShamBot.ini,Spells,SpellGROW].NotEqual[NULL]}) /varset SpellGROW "${Ini[ShamBot.ini,Spells,SpellGROW]}"
	/if (${Ini[ShamBot.ini,Spells,SpellSEE].NotEqual[NULL]}) /varset SpellSEE "${Ini[ShamBot.ini,Spells,SpellSEE]}"
	/if (${Ini[ShamBot.ini,Spells,SpellPetBuff[1]].NotEqual[NULL]}) /varset SpellPetBuff[1] "${Ini[ShamBot.ini,Spells,SpellPetBuff[1]]}"
	/if (${Ini[ShamBot.ini,Spells,SpellPetBuff[2]].NotEqual[NULL]}) /varset SpellPetBuff[2] "${Ini[ShamBot.ini,Spells,SpellPetBuff[2]]}"
	/if (${Ini[ShamBot.ini,Spells,SpellPetBuff[3]].NotEqual[NULL]}) /varset SpellPetBuff[3] "${Ini[ShamBot.ini,Spells,SpellPetBuff[3]]}"
	/if (${Ini[ShamBot.ini,Spells,SpellPetBuff[4]].NotEqual[NULL]}) /varset SpellPetBuff[4] "${Ini[ShamBot.ini,Spells,SpellPetBuff[4]]}"
	/if (${Ini[ShamBot.ini,Spells,SpellPetBuffo[1]].NotEqual[NULL]}) /varset SpellPetBuffo[1] "${Ini[ShamBot.ini,Spells,SpellPetBuffo[1]]}"
	/if (${Ini[ShamBot.ini,Spells,SpellPetBuffo[2]].NotEqual[NULL]}) /varset SpellPetBuffo[2] "${Ini[ShamBot.ini,Spells,SpellPetBuffo[2]]}"
	/if (${Ini[ShamBot.ini,Spells,SpellPetBuffo[3]].NotEqual[NULL]}) /varset SpellPetBuffo[3] "${Ini[ShamBot.ini,Spells,SpellPetBuffo[3]]}"
	/if (${Ini[ShamBot.ini,Spells,SpellPetBuffo[4]].NotEqual[NULL]}) /varset SpellPetBuffo[4] "${Ini[ShamBot.ini,Spells,SpellPetBuffo[4]]}"
	/if (${Ini[ShamBot.ini,Spells,SpellGrpBuff[1]].NotEqual[NULL]}) /varset SpellGrpBuff[1] "${Ini[ShamBot.ini,Spells,SpellGrpBuff[1]]}"
	/if (${Ini[ShamBot.ini,Spells,SpellGrpBuff[2]].NotEqual[NULL]}) /varset SpellGrpBuff[2] "${Ini[ShamBot.ini,Spells,SpellGrpBuff[2]]}"
	/if (${Ini[ShamBot.ini,Spells,SpellGrpBuff[3]].NotEqual[NULL]}) /varset SpellGrpBuff[3] "${Ini[ShamBot.ini,Spells,SpellGrpBuff[3]]}"
	/if (${Ini[ShamBot.ini,Spells,SpellGrpBuff[4]].NotEqual[NULL]}) /varset SpellGrpBuff[4] "${Ini[ShamBot.ini,Spells,SpellGrpBuff[4]]}"
	/if (${Ini[ShamBot.ini,Spells,SpellGrpBuff[5]].NotEqual[NULL]}) /varset SpellGrpBuff[5] "${Ini[ShamBot.ini,Spells,SpellGrpBuff[5]]}"
	/if (${Ini[ShamBot.ini,Spells,SpellGrpBuff[6]].NotEqual[NULL]}) /varset SpellGrpBuff[6] "${Ini[ShamBot.ini,Spells,SpellGrpBuff[6]]}"	
	/if (${Ini[ShamBot.ini,Spells,SpellSingleBuff[1]].NotEqual[NULL]}) /varset SpellSingleBuff[1] "${Ini[ShamBot.ini,Spells,SpellSingleBuff[1]]}"
	/if (${Ini[ShamBot.ini,Spells,SpellSingleBuff[2]].NotEqual[NULL]}) /varset SpellSingleBuff[2] "${Ini[ShamBot.ini,Spells,SpellSingleBuff[2]]}"
	/if (${Ini[ShamBot.ini,Spells,SpellSingleBuff[3]].NotEqual[NULL]}) /varset SpellSingleBuff[3] "${Ini[ShamBot.ini,Spells,SpellSingleBuff[3]]}"
	/if (${Ini[ShamBot.ini,Spells,SpellSingleBuff[4]].NotEqual[NULL]}) /varset SpellSingleBuff[4] "${Ini[ShamBot.ini,Spells,SpellSingleBuff[4]]}"
	/if (${Ini[ShamBot.ini,Spells,SpellSingleBuff[5]].NotEqual[NULL]}) /varset SpellSingleBuff[5] "${Ini[ShamBot.ini,Spells,SpellSingleBuff[5]]}"
	/if (${Ini[ShamBot.ini,Spells,SpellSingleBuff[6]].NotEqual[NULL]}) /varset SpellSingleBuff[6] "${Ini[ShamBot.ini,Spells,SpellSingleBuff[6]]}"
	/if (${Ini[ShamBot.ini,Combat,AssistAt].NotEqual[NULL]}) /varset AssistAt ${Ini[ShamBot.ini,Combat,AssistAt]}
	/if (${Ini[ShamBot.ini,Combat,CombatAt].NotEqual[NULL]}) /varset CombatAt ${Ini[ShamBot.ini,Combat,CombatAt]}
	/if (${Ini[ShamBot.ini,Combat,CastDoTat].NotEqual[NULL]}) /varset CastDoTat ${Ini[ShamBot.ini,Combat,CastDoTat]}
	/if (${Ini[ShamBot.ini,Combat,DotMana].NotEqual[NULL]}) /varset DotMana ${Ini[ShamBot.ini,Combat,DotMana]}
	/if (${Ini[ShamBot.ini,Combat,Rootat].NotEqual[NULL]}) /varset Rootat ${Ini[ShamBot.ini,Combat,Rootat]}
	/if (${Ini[ShamBot.ini,Combat,RootMana].NotEqual[NULL]}) /varset RootMana ${Ini[ShamBot.ini,Combat,RootMana]}
	/if (${Ini[ShamBot.ini,Combat,NukeAt].NotEqual[NULL]}) /varset NukeAt ${Ini[ShamBot.ini,Combat,NukeAt]}
	/if (${Ini[ShamBot.ini,Combat,NukeMana].NotEqual[NULL]}) /varset NukeMana ${Ini[ShamBot.ini,Combat,NukeMana]}
	/if (${Ini[ShamBot.ini,Combat,SitAt].NotEqual[NULL]}) /varset SitAt ${Ini[ShamBot.ini,Combat,SitAt]}
	/if (${Ini[ShamBot.ini,ToDo,DoMalo].NotEqual[NULL]}) /varset DoMalo ${Ini[ShamBot.ini,ToDo,DoMalo]}  
	/if (${Ini[ShamBot.ini,ToDo,DoSlow].NotEqual[NULL]}) /varset DoSlow ${Ini[ShamBot.ini,ToDo,DoSlow]}  
	/if (${Ini[ShamBot.ini,ToDo,FastSlow].NotEqual[NULL]}) /varset FastSlow ${Ini[ShamBot.ini,ToDo,FastSlow]}
	/if (${Ini[ShamBot.ini,ToDo,DoCripple].NotEqual[NULL]}) /varset DoCripple ${Ini[ShamBot.ini,ToDo,Cripple]}
	/if (${Ini[ShamBot.ini,ToDo,FastCripple].NotEqual[NULL]}) /varset FastCripple ${Ini[ShamBot.ini,ToDo,FastCripple]}
	/if (${Ini[ShamBot.ini,ToDo,DoRoot].NotEqual[NULL]}) /varset DoRoot ${Ini[ShamBot.ini,ToDo,DoRoot]}
	/if (${Ini[ShamBot.ini,ToDo,DoDot].NotEqual[NULL]}) /varset DoDoT ${Ini[ShamBot.ini,ToDo,DoDot]}
	/if (${Ini[ShamBot.ini,ToDo,DoNuke].NotEqual[NULL]}) /varset DoNuke ${Ini[ShamBot.ini,ToDo,DoNuke]}
	/if (${Ini[ShamBot.ini,ToDo,DoHeal].NotEqual[NULL]}) /varset DoHeal ${Ini[ShamBot.ini,ToDo,DoHeal]}
	/if (${Ini[ShamBot.ini,ToDo,HoTTank].NotEqual[NULL]}) /varset HoTTank ${Ini[ShamBot.ini,ToDo,HoTTank]}
	/if (${Ini[ShamBot.ini,ToDo,DoATK].NotEqual[NULL]}) /varset DoATK ${Ini[ShamBot.ini,ToDo,DoATK]}
	/if (${Ini[ShamBot.ini,ToDo,DoBuffs.NotEqual[NULL]}) /varset DoBuffs ${Ini[ShamBot.ini,ToDo,DoBuffs]}
	/if (${Ini[ShamBot.ini,ToDo,SummonPet.NotEqual[NULL]}) /varset SummonPet ${Ini[ShamBot.ini,ToDo,SummonPet]}
	/if (${Ini[ShamBot.ini,ToDo,BuffPet.NotEqual[NULL]}) /varset BuffPet ${Ini[ShamBot.ini,ToDo,BuffPet]}
	/if (${Ini[ShamBot.ini,ToDo,Verbose].NotEqual[NULL]}) /varset Verbose ${Ini[ShamBot.ini,ToDo,Verbose]}
	/if (${Ini[ShamBot.ini,HealsPri,CasterHeals].NotEqual[NULL]}) /varset CasterHeals ${Ini[ShamBot.ini,HealsPri,CasterHeals]}
	/if (${Ini[ShamBot.ini,HealsPri,MeleeHeals].NotEqual[NULL]}) /varset MeleeHeals ${Ini[ShamBot.ini,HealsPri,MeleeHeals]}
	/if (${Ini[ShamBot.ini,HealsPri,TankHeal].NotEqual[NULL]}) /varset TankHeal ${Ini[ShamBot.ini,HealsPri,TankHeal]}
	/if (${Ini[ShamBot.ini,HealsPri,HoTAt].NotEqual[NULL]}) /varset HoTAt ${Ini[ShamBot.ini,HealsPri,HoTAt]}
/return

This was my first attempt at most of the things I added in here so it probably looks messy as hell. Do with it what you wish

 

[lonestand]

i really would like to run sham bot, but it dose not work is there anyone that could mabey fix it? pls

 

[darkeros]

The shambot.mac from the mq2 vip boards works. Might try that one.

 

[iceman_001]

I have been using the one from the MQ boards. I modified it for my shaman however:

1. When I die, it goes into a loop that never ends and eventually crashes EQ.
2. Does anyone know how to set the shaman to slow sooner? When I start it i say "SLOW" and the programs puts the value TRUE to slow and will start by itself, however, sometimes it does not kick in till about 50% of the NPC hps. A little to late sometimes. Any help would be greatly appreciated.

Thanks
Ice.

 

[darkeros]

1. I don't have that problem, you might want to check the code.
2. Set the assist and combat variable to something like 95. This variable is the % of the mob's hp your shaman will start his work.

 

[Gnomesrule]

Know of a Shaman Macro that will work for when my level 41 Shammy reachs level 60 in a few days? With the exp bonus I should be 47 by tonight.. then the rest of the time will be with the 70 Warrior and 70 Cleric getting it exp. I would love something that would even work before i hit level 60ish.

 

[iridini]

I have Tried this out and all it does to me is target the MT then repeatly vast daiku spell over and over and thats about it. Maybe i have somethinf set up wrong. Do i have to manually set the spells up or will it mem the spells on its own. Also I tried changing some of the spells like the healing and slow to maybe get the better versions to work but Im not exactly sure where to change them. If I send him a tell for the buff I want the macro just ends and he does nothing.