• You've discovered RedGuides 📕 an EverQuest multi-boxing community 🛡️🧙🗡️. We want you to play several EQ characters at once, come join us and say hello! 👋
  • IS THIS SITE UGLY? Change the look. To dismiss this notice, click the X --->
Resource icon

Skills - auto skill raiser (1 Viewer) 1.4.1

PeteSampras

Active member
Joined
Mar 18, 2012
RedCents
2,143¢
This is part of another macro I wrote for new toons. This mac will use whatever spells you have memmed or abilities you have on your ability keys. It will use your target if you have one and attempt more abilities, else will use yourself as target. It ignores certain spells like gate, DA, and a few others. It should work with vanilla compile, but if some TLO says it doesnt exist, let me know.
skills.mac
Rich (BB code):
Sub Main
/declare AbilityTimer timer outer
/echo ${Macro.Name} loaded.
:mainloop
/call Abilities
/if (${Me.PctMana} && !${Me.Class.ShortName.Equal[brd]}) /call Skills
/if (!${AbilityTimer}) {
/call Abilities
/varset AbilityTimer 7s
}
/goto :mainloop

/return

Sub Abilities
	/if (${Me.Skill[tracking]} < ${Skill[tracking].SkillCap} && ${Me.AbilityReady[tracking]}) /doability "tracking"
	/if (${Window[TrackingWnd].Child[TRW_DoneButton]}) /notify TrackingWnd TRW_DoneButton leftmouseup
	/if (${Me.Skill[feign death]} < ${Skill[feign death].SkillCap} && ${Me.AbilityReady[feign death]}) {
		/doability "feign death"
		/delay 5
		/if (!${Me.Standing}) /stand
	}
	/if (${Me.Skill[hide]} < ${Skill[hide].SkillCap} && ${Me.AbilityReady[hide]}||!${AbilityTimer} && ${Me.Ability[hide]}) /doability "hide"
	/if (${Me.Skill[sneak]} < ${Skill[sneak].SkillCap} && ${Me.AbilityReady[sneak]}||!${AbilityTimer}  && ${Me.Ability[sneak]}) /doability "sneak"
	/if (${Me.Skill[mend]} < ${Skill[mend].SkillCap} && ${Me.AbilityReady[mend]}) /doability "mend"
	/if (!${Target.ID}||${Target.Type.Equal[pc]} && ${Zone.Type}||${Target.Master.Type.Equal[PC]} && ${Zone.Type}||${Target.Type.Equal[corpse]}||${Target.Distance}>${Target.MaxRange}||${Target.ID}==${Me.ID}) /return
	/if (${Me.AbilityReady[flying kick]}) /doability "flying kick"
	/if (${Me.AbilityReady[bash]} && (${InvSlot[offhand].Item.Type.Find[shield]}||${Me.AltAbility[2 Hand Bash]})) /doability "bash"
	/if (${Me.AbilityReady[frenzy]}) /doability "frenzy"
	/if (${Me.AbilityReady[slam]} && !${Me.AbilityReady[bash]}) /doability "slam"
	/if (${Me.AbilityReady[round kick]}) /doability "round kick"
	/if (${Me.AbilityReady[kick]}) /doability "kick"
	/if (${Me.AbilityReady[tiger claw]}) /doability "tiger claw"
	/if (${Target.Distance}<12 && ${Me.AbilityReady[Disarm]}) /doability "Disarm"
	/if (${Me.AbilityReady[Backstab]} && ${Melee.Behind}) /doability "Backstab"
/return

Sub Skills
/if (${Me.Casting.ID} && !${Me.Class.ShortName.Equal[BRD]}||${Me.Hovering}||${Window[tradewnd].Open}||${Window[lootwnd].Open}) /return
     /if (${Me.Skill[Abjuration]} < ${Skill[Abjuration].SkillCap}) /call Raise Abjuration
     /if (${Me.Skill[Alteration]} < ${Skill[Alteration].SkillCap}) /call Raise Alteration
     /if (${Me.Skill[Conjuration]} < ${Skill[Conjuration].SkillCap}) /call Raise Conjuration
     /if (${Me.Skill[Divination]} < ${Skill[Divination].SkillCap}) /call Raise Divination
     /if (${Me.Skill[Evocation]} < ${Skill[Evocation].SkillCap}) /call Raise Evocation
  /if (${Me.Skill[Divination]} >= ${Skill[Divination].SkillCap} && ${Me.Skill[Evocation]} >= ${Skill[Evocation].SkillCap} && ${Me.Skill[Abjuration]} >= ${Skill[Abjuration].SkillCap} && ${Me.Skill[Alteration]} >= ${Skill[Alteration].SkillCap} && ${Me.Skill[Divination]} >= ${Skill[Divination].SkillCap} && ${Me.Skill[Conjuration]} >= ${Skill[Conjuration].SkillCap}) {
   	/echo Skills maxed.
    /end
  }
 /return
 
Sub Raise(skilltype)
/if (${Me.Casting.ID} && !${Me.Class.ShortName.Equal[BRD]}||${Me.Hovering}||${Window[tradewnd].Open}||${Window[lootwnd].Open}) /return
/declare i int local
:checkcursor
 /if (${Cursor.ID} && !${Cursor.NoRent} && ${skilltype.Equal[Conjuration]}) /autoinv
 /if (${Cursor.ID} && ${Cursor.NoRent} && ${skilltype.Equal[Conjuration]}) /destroy
 /if (${Cursor.ID} && ${skilltype.Equal[Conjuration]}) /goto :checkcursor
 /for i 1 to 12
 /if (${Me.CurrentMana}>${Me.Gem[${i}].Mana} && ${Me.Gem[${i}].Skill.Equal[${skilltype}]} && !${Me.GemTimer[${i}]} && ${Me.SpellReady[${Me.Gem[${i}]}]} && !${Select[${Me.Gem[${i}].Category},Transport,Traps,Aura]} && !${Select[${Me.Gem[${i}].Subcategory},Misc,Invulnerability]} && (!${Me.Gem[${i}].Subcategory.Find[Sum: ]}||!${Me.Pet.ID})) {
	 	/if (${Me.Gem[${i}].TargetType.Equal[Single]} && ${Target.Type.NotEqual[npc]} && ${${Me.Gem[${i}].SpellType.Equal[Detrimental]}}) {
		 	/squelch /tar npc range ${Me.Gem[${i}].MyRange}
		 	/delay 1
		 	/if (!${Target.ID}) /squelch /tar myself
		 	/delay 1
	 	}
	 	/if (${Me.Gem[${i}].TargetType.Equal[Single]} && !${Target.ID} && ${${Me.Gem[${i}].SpellType.NotEqual[Detrimental]}}) {
		 	/if (!${Target.ID}) /squelch /tar myself
		 	/delay 1
	 	}
	 	/if (${Me.Gem[${i}].TargetType.Equal[pet]} && !${Me.Pet.ID}) /goto :skip
	 	/casting "${Me.Gem[${i}]}" gem${i}
	 	/delay 1s
	 	/delay 10s !${Me.Casting.ID}
 	}
 :skip	
 /next i

/return
[/hide][/hide][/hide][/hide]
[hide][hide][hide][hide][/hide][/hide][/hide][/hide]
 
Last edited:
Pete so glad to see you over here a bit man. You are like the only reason I ever missed the other place =). You are one of the best macro writers out there among a few others! Thank you for sharing your knowledge and some macros here bud.
 
Oh, ya it wasnt intended for pure melee, i changed the /call Skills so it only tries it if you have mana and arent a bard. that should solve your issue.
 
What do we type to start this macro? I'm not good at this sort of thing, thank you!
 
It works great untill all casting skills are maxed. Once casting skills are maxed, the macro stops. It won't do Tracking for my ranger after.
 
Rich (BB code):
Sub Main
	/declare AbilityTimer timer outer
	/declare CastingSkillMaxxed bool outer FALSE
	/declare MeleeSkillsMaxxed bool outer FALSE
	/echo ${Macro.Name} loaded.
	:mainloop
	/if (${MeleeSkillsMaxed} && ${CastingSkillMaxed}) {
		/echo \agDone Skilling Up!
		/end
	}
	/call Abilities
	/if (${Me.PctMana} && !${Me.Class.ShortName.Equal[brd]}) /call Skills
	/if (!${AbilityTimer}) {
		/call Abilities
		/varset AbilityTimer 7s
	}
/goto :mainloop


/return


Sub Abilities
	/if (${Me.Skill[tracking]} < ${Skill[tracking].SkillCap} && ${Me.AbilityReady[tracking]}) /doability "tracking"
	/if (${Window[TrackingWnd].Child[TRW_DoneButton]}) /notify TrackingWnd TRW_DoneButton leftmouseup
	/if (${Me.Skill[feign death]} < ${Skill[feign death].SkillCap} && ${Me.AbilityReady[feign death]}) {
		/doability "feign death"
		/delay 5
		/if (!${Me.Standing}) /stand
	}
	/if (${Me.Skill[hide]} < ${Skill[hide].SkillCap} && ${Me.AbilityReady[hide]}||!${AbilityTimer} && ${Me.Ability[hide]}) /doability "hide"
	/if (${Me.Skill[sneak]} < ${Skill[sneak].SkillCap} && ${Me.AbilityReady[sneak]}||!${AbilityTimer}  && ${Me.Ability[sneak]}) /doability "sneak"
	/if (${Me.Skill[mend]} < ${Skill[mend].SkillCap} && ${Me.AbilityReady[mend]}) /doability "mend"
	/if (!${Target.ID}||${Target.Type.Equal[pc]} && ${Zone.Type}||${Target.Master.Type.Equal[PC]} && ${Zone.Type}||${Target.Type.Equal[corpse]}||${Target.Distance}>${Target.MaxRange}||${Target.ID}==${Me.ID}) {
		/if (${Me.Skill[tracking]} >= ${Skill[tracking].SkillCap} && ${Me.Skill[feign death]} >= ${Skill[feign death].SkillCap} && ${Me.Skill[hide]} >= ${Skill[hide].SkillCap} && ${Me.Skill[sneak]} >= ${Skill[sneak].SkillCap} && ${Me.Skill[mend]} >= ${Skill[mend].SkillCap}) {
			/if (!${MeleeSkillsMaxxed}) {
				/echo Melee Skills Maxxed!
				/varset MeleeSkillsMaxxed TRUE
			}
		}
		/return
	}
	
	/if (${Me.AbilityReady[flying kick]}) /doability "flying kick"
	/if (${Me.AbilityReady[bash]} && (${InvSlot[offhand].Item.Type.Find[shield]}||${Me.AltAbility[2 Hand Bash]})) /doability "bash"
	/if (${Me.AbilityReady[frenzy]}) /doability "frenzy"
	/if (${Me.AbilityReady[slam]} && !${Me.AbilityReady[bash]}) /doability "slam"
	/if (${Me.AbilityReady[round kick]}) /doability "round kick"
	/if (${Me.AbilityReady[kick]}) /doability "kick"
	/if (${Me.AbilityReady[tiger claw]}) /doability "tiger claw"
	/if (${Target.Distance}<12 && ${Me.AbilityReady[Disarm]}) /doability "Disarm"
	/if (${Me.AbilityReady[Backstab]} && ${Melee.Behind}) /doability "Backstab"
	
	/if (${Target.ID} && ${Me.Skill[tracking]} >= ${Skill[tracking].SkillCap} && ${Me.Skill[feign death]} >= ${Skill[feign death].SkillCap} && ${Me.Skill[hide]} >= ${Skill[hide].SkillCap} && ${Me.Skill[sneak]} >= ${Skill[sneak].SkillCap} && ${Me.Skill[mend]} >= ${Skill[mend].SkillCap}) {
		/if (${Me.Skill[bash]} >= ${Skill[bash].SkillCap} && ${Me.Skill[frenzy]} >= ${Skill[frenzy].SkillCap} && ${Me.Skill[slam]} >= ${Skill[slam].SkillCap} && ${Me.Skill[round kick]} >= ${Skill[round kick].SkillCap} && ${Me.Skill[kick]} >= ${Skill[kick].SkillCap} && ${Me.Skill[flying kick]} >= ${Skill[flying kick].SkillCap}) {
			/if (${Me.Skill[tiger claw]} >= ${Skill[tiger claw].SkillCap} && ${Me.Skill[disarm]} >= ${Skill[disarm].SkillCap} && ${Me.Skill[backstab]} >= ${Skill[backstab].SkillCap} && ) {
				/if (!${MeleeSkillsMaxxed}) {
					/echo Melee Skills Maxxed!
					/varset MeleeSkillsMaxxed TRUE
				}
			}
		}
	}
/return


Sub Skills
/if (${Me.Casting.ID} && !${Me.Class.ShortName.Equal[BRD]}||${Me.Hovering}||${Window[tradewnd].Open}||${Window[lootwnd].Open}) /return
     /if (${Me.Skill[Abjuration]} < ${Skill[Abjuration].SkillCap}) /call Raise Abjuration
     /if (${Me.Skill[Alteration]} < ${Skill[Alteration].SkillCap}) /call Raise Alteration
     /if (${Me.Skill[Conjuration]} < ${Skill[Conjuration].SkillCap}) /call Raise Conjuration
     /if (${Me.Skill[Divination]} < ${Skill[Divination].SkillCap}) /call Raise Divination
     /if (${Me.Skill[Evocation]} < ${Skill[Evocation].SkillCap}) /call Raise Evocation
  /if (${Me.Skill[Divination]} >= ${Skill[Divination].SkillCap} && ${Me.Skill[Evocation]} >= ${Skill[Evocation].SkillCap} && ${Me.Skill[Abjuration]} >= ${Skill[Abjuration].SkillCap} && ${Me.Skill[Alteration]} >= ${Skill[Alteration].SkillCap} && ${Me.Skill[Divination]} >= ${Skill[Divination].SkillCap} && ${Me.Skill[Conjuration]} >= ${Skill[Conjuration].SkillCap}) {
   	/if (!${CastingSkillMaxxed}) {
		/echo Skills maxxed.
		/varset CastingSkillMaxxed TRUE
	}
  }
 /return
 
Sub Raise(skilltype)
/if (${Me.Casting.ID} && !${Me.Class.ShortName.Equal[BRD]}||${Me.Hovering}||${Window[tradewnd].Open}||${Window[lootwnd].Open}) /return
/declare i int local
:checkcursor
 /if (${Cursor.ID} && !${Cursor.NoRent} && ${skilltype.Equal[Conjuration]}) /autoinv
 /if (${Cursor.ID} && ${Cursor.NoRent} && ${skilltype.Equal[Conjuration]}) /destroy
 /if (${Cursor.ID} && ${skilltype.Equal[Conjuration]}) /goto :checkcursor
 /for i 1 to 12
 /if (${Me.CurrentMana}>${Me.Gem[${i}].Mana} && ${Me.Gem[${i}].Skill.Equal[${skilltype}]} && !${Me.GemTimer[${i}]} && ${Me.SpellReady[${Me.Gem[${i}]}]} && !${Select[${Me.Gem[${i}].Category},Transport,Traps,Aura]} && !${Select[${Me.Gem[${i}].Subcategory},Misc,Invulnerability]} && (!${Me.Gem[${i}].Subcategory.Find[Sum: ]}||!${Me.Pet.ID})) {
	 	/if (${Me.Gem[${i}].TargetType.Equal[Single]} && ${Target.Type.NotEqual[npc]} && ${${Me.Gem[${i}].SpellType.Equal[Detrimental]}}) {
		 	/squelch /tar npc range ${Me.Gem[${i}].MyRange}
		 	/delay 1
		 	/if (!${Target.ID}) /squelch /tar myself
		 	/delay 1
	 	}
	 	/if (${Me.Gem[${i}].TargetType.Equal[Single]} && !${Target.ID} && ${${Me.Gem[${i}].SpellType.NotEqual[Detrimental]}}) {
		 	/if (!${Target.ID}) /squelch /tar myself
		 	/delay 1
	 	}
	 	/if (${Me.Gem[${i}].TargetType.Equal[pet]} && !${Me.Pet.ID}) /goto :skip
	 	/casting "${Me.Gem[${i}]}" gem${i}
	 	/delay 1s
	 	/delay 10s !${Me.Casting.ID}
 	}
 :skip	
 /next i


/return
[/hide][/hide][/hide][/hide][/hide][/hide][/hide][/hide]
[hide][hide][hide][hide][hide][hide][hide][hide]

I tried to add in logic for both casting and melee skills being maxxed. Untested, lemme know if that works out.[/hide][/hide][/hide][/hide][/hide][/hide][/hide][/hide]
 
Rich (BB code):
Sub Main
    /declare AbilityTimer timer outer
    /declare CastingSkillMaxxed bool outer FALSE
    /declare MeleeSkillsMaxxed bool outer FALSE
    /echo ${Macro.Name} loaded.
    :mainloop
    /if (${MeleeSkillsMaxed} && ${CastingSkillMaxed}) {
        /echo \agDone Skilling Up!
        /end
    }
    /call Abilities
    /if (${Me.PctMana} && !${Me.Class.ShortName.Equal[brd]}) /call Skills
    /if (!${AbilityTimer}) {
        /call Abilities
        /varset AbilityTimer 7s
    }
/goto :mainloop


/return


Sub Abilities
    /if (${Me.Skill[tracking]} < ${Skill[tracking].SkillCap} && ${Me.AbilityReady[tracking]}) /doability "tracking"
    /if (${Window[TrackingWnd].Child[TRW_DoneButton]}) /notify TrackingWnd TRW_DoneButton leftmouseup
    /if (${Me.Skill[feign death]} < ${Skill[feign death].SkillCap} && ${Me.AbilityReady[feign death]}) {
        /doability "feign death"
        /delay 5
        /if (!${Me.Standing}) /stand
    }
    /if (${Me.Skill[Hidden content]
[Hidden content]


It doesn't work for a bard. It goes through once and does casting part and says skills maxed.
 
@GeorgiaGeorgiz I believe the reason for that is because of a built in utility called MQ2Twist which you can run by typing /plugin mq2twist Once you run that command you can then type /twist 1 2 3 4 5 6 etc where the number is the spell gem you want to twist and it will automatically twist the songs for you.
But, the macro will run the other parts I hope.

Unless I've misunderstood the issue and you are saying it will not go through the skill portion of things once it starts playing the song. I could perhaps get it to exclude the bard for the casting portion.
 
I can load the macro, it just doesn't do anything once I do.

Are there instructions for doing something other than looking up your skills? I am trying to raise my alteration/specialize alteration
 
Last edited:
Blasty updated Skills - auto skill raiser with a new update entry:

Skills v1.2 just released

Skills v1.2 Original Author: Blasty
Maintained for RedGuides by Blasty 2021-03-07
This macro was written exclusively for subscribers of Redguides.com
Purpose: To automatically raise all skills
Feature: Target something to use targeted abilities automatically like a healer merc
Recommended: Use a private location for this macro such as a private guild lobby

Changes:
  • Added a control if the current class has the ability before trying to use it
  • Added a control to...

Read the rest of this update entry...
 
Blasty updated Skills - auto skill raiser with a new update entry:

Skills v1.3 just released

Skills v1.3 Original Author: Blasty
Maintained for RedGuides by Blasty 2021-03-07
This macro was written exclusively for subscribers of Redguides.com
Purpose: To automatically raise all skills (Spells and abilities).
Feature: Target something to use targeted abilities automatically like a healer merc.
Recommended: Use a private location for this macro such as a private guild lobby.

Change notes:
This release hold some larger changes and have been tested on multiple classes but...

Read the rest of this update entry...
 
Blasty updated Skills - auto skill raiser with a new update entry:

Skills v1.4 just released

Skills v1.4 Original Author: Blasty
Maintained for RedGuides by Blasty 2021-03-08
This macro was written exclusively for subscribers of Redguides.com
Purpose: To automatically raise all skills (Spells and abilities).
Feature: Target something to use targeted abilities automatically like a healer merc.
Recommended: Use a private location for this macro such as a private guild lobby.

Change notes:
  • Implemented spell specialization skill
  • Implementing .ini file so...

Read the rest of this update entry...
 
Blasty updated Skills - auto skill raiser with a new update entry:

Skills v1.4.1 just released

Skills v1.4.1 Original Author: Blasty
Maintained for RedGuides by Blasty 2021-09-20
This macro was written exclusively for subscribers of Redguides.com
Purpose: To automatically raise all skills (Spells and abilities).
Feature: Target something to use targeted abilities automatically like a healer merc.
Recommended: Use a private location for this macro such as a private guild lobby.

Description:
Added ability "Begging"

Usage:
Get a healer merc and got to a zone that allows you to hit/damage the merc. Greater guildhall also works.
Target the Merc and start the macro and just wait untill it's done.

Read the rest of this update entry...
 
Last edited:
Tested this out. All I get is not a valid target!
TRUE && 1
Maybe something in MQNext?

Edit: Targeted my merc and worked fine, i was just too far away from the merc to beg. Can you even skill up on begging a merc?

Edit: Again. So it was actually a distance issue. when i moved right up on a dummy in guildhall it became a valid target, but at a distance it was not a valid target. :)

Maxed all skills and toon continued to cast root over and over, never ending the macro.

Maybe a /nav spawn ${Target}
to get you close to the target before checking the distance?

INI:
| Check if we are within range or nav to target
    /if (${Target.Distance} > 15) {
        /nav spawn ${Target.CleanName}
        /while (${Target.Distance} > 15) {
            /delay 5s
        }
    }
    /call MemSpells
 
Last edited:
Another thing I noticed is I believe Specialize Abjuration should be Specialize Abjure, Also, note I don't know of any mobs that you beg from in any non combat zone. So with that being said, the macro will finish everything but Begging in a non combat zone.
INI:
|**
    Skills v1.4 Original Author: Blasty
    Maintained for RedGuides by Blasty 2021-03-19
    This macro was written exclusively for subscribers of Redguides.com
    Purpose: To automatically raise all skills
    Feature: Target something to use targeted abilities automatically like a healer merc
    Recommended: Use a private location for this macro such as a private guild lobby
**|
| --------------------------------------------------------------------------------------------
| SUB: Main
| --------------------------------------------------------------------------------------------
Sub Main
    /declare    medTill                     int     outer     100
    /declare     AbilitiesCheckDone            bool       outer    FALSE
    /declare     SpellsCheckDone                bool       outer    FALSE
    /declare     SpecializeSpellCheckDone    bool       outer    FALSE
    /declare     SpecAbjureCap                int     local     ${Me.SkillCap[Specialize Abjure]}
    /declare     SpecAlterationCap            int     local     ${Me.SkillCap[Specialize Alteration]}
    /declare     SpecConjurationCap            int     local     ${Me.SkillCap[Specialize Conjuration]}
    /declare     SpecDivinationCap            int     local     ${Me.SkillCap[Specialize Divination]}
    /declare     SpecEvocationCap            int     local     ${Me.SkillCap[Specialize Evocation]}
    /declare     PracticeSpell[16,8]            string    outer
    /echo Skills macro running.
   
|CLERIC - Confirmed
    /varset PracticeSpell[2,1]      Endure Poison
    /varset PracticeSpell[2,2]      Minor Healing
    /varset PracticeSpell[2,3]      Halo of Light
    /varset PracticeSpell[2,4]      True North
    /varset PracticeSpell[2,5]      Strike

|PALADIN
    /varset PracticeSpell[3,1]      Courage
    /varset PracticeSpell[3,2]      Salve
    /varset PracticeSpell[3,3]      Hammer of Wrath
    /varset PracticeSpell[3,4]      True North
    /varset PracticeSpell[3,5]      Cease

|RANGER - Confirmed
    /varset PracticeSpell[4,1]      Endure Fire
    /varset PracticeSpell[4,2]      Salve
    /varset PracticeSpell[4,3]      Dance of the Fireflies
    /varset PracticeSpell[4,4]      Glimpse
    /varset PracticeSpell[4,5]      Ignite

|SHADOW KNIGHT
    /varset PracticeSpell[5,1]      Endure Cold
    /varset PracticeSpell[5,2]      Siphon Strength
    /varset PracticeSpell[5,3]      Disease Cloud
    /varset PracticeSpell[5,4]      Sense the Dead
    /varset PracticeSpell[5,5]      Ward Undead

|DRUID - Confirmed
    /varset PracticeSpell[6,1]      Skin like Wood
    /varset PracticeSpell[6,2]      Minor Healing
    /varset PracticeSpell[6,3]      Summon Food
    /varset PracticeSpell[6,4]      Sense Animals
    /varset PracticeSpell[6,5]      Burst of Fire

|SHAMAN - Confirmed
    /varset PracticeSpell[10,1]     Endure Cold
    /varset PracticeSpell[10,2]     Minor Healing
    /varset PracticeSpell[10,3]     Summon Drink
    /varset PracticeSpell[10,4]     True North
    /varset PracticeSpell[10,5]     Burst of Flame

|NECROMANCER - Confirmed
    /varset PracticeSpell[11,1]     Minor Shielding
    /varset PracticeSpell[11,2]     Lifetap
    /varset PracticeSpell[11,3]     Coldlight
    /varset PracticeSpell[11,4]     True North
    /varset PracticeSpell[11,5]     Word of Shadow

|WIZARD
    /varset PracticeSpell[12,1]     Minor Shielding
    /varset PracticeSpell[12,2]     Root
    /varset PracticeSpell[12,3]     Halo of Light
    /varset PracticeSpell[12,4]     True North
    /varset PracticeSpell[12,5]     Blast of Cold

|MAGICIAN - Confirmed
    /varset PracticeSpell[13,1]     Minor Shielding
    /varset PracticeSpell[13,2]     Renew Elements
    /varset PracticeSpell[13,3]     Summon Brass Choker
    /varset PracticeSpell[13,4]     True North
    /varset PracticeSpell[13,5]     Burst of Flame

|ENCHANTER - Confirmed
    /varset PracticeSpell[14,1]     Minor Shielding
    /varset PracticeSpell[14,2]     Strengthen
    /varset PracticeSpell[14,3]     Mesmerize
    /varset PracticeSpell[14,4]     True North
    /varset PracticeSpell[14,5]     Chaotic Feedback

|BEASTLORD
    /varset PracticeSpell[15,1]     Endure Cold
    /varset PracticeSpell[15,2]     Salve
    /varset PracticeSpell[15,3]     Summon Drink
    /varset PracticeSpell[15,4]     Sense Animals
    /varset PracticeSpell[15,5]     Blast of Frost
   
| Check if something is in the cursor
    /if (${Cursor.ID}) {
        /echo You are holding something in your cursor... We will put it in your bag for you.
        /while (${Cursor.ID}) {
            /autoinv
            /delay 1
        }
    }
| Check if we are within range and nav to target
    /if (${Target.Distance}>15) {
        /nav id ${Target.ID}
        /while (${Target.Distance}>15) {
            /delay 1s
        }
    }
    /call MemSpells
:mainloop
    /if (${AbilitiesCheckDone} && ${SpellsCheckDone} && ${SpecializeSpellCheckDone}) {
        /echo All skills are maxed out - Thanks for using Skills
        /echo Ending macro...
        /end
    }
    /call Abilities
    /if (${Me.Class.CanCast}) {
        /if (${Me.PctMana} < 10 && !${Me.Sitting}) {
            /sit
            :med
            /if (${Me.PctMana} < ${medTill} && ${Me.Sitting}) /goto :med
        } else {
            /call Spells
            /call SpecializeSpell
        }
    } else /varset SpellsCheckDone TRUE
    /goto :mainloop
/return
| --------------------------------------------------------------------------------------------
| SUB: Abilities
| --------------------------------------------------------------------------------------------
Sub Abilities
    /if (${AbilitiesCheckDone}) /return
        /if (${Me.Skill[tracking]} && ${Me.Skill[tracking]} < ${Me.SkillCap[tracking]} && ${Me.AbilityReady[tracking]}) /doability "tracking"
| Closes the tracking window
        /if (${Window[TrackingWnd].Child[TRW_DoneButton]}) /notify TrackingWnd TRW_DoneButton leftmouseup
        /if (${Me.Skill[feign death]} && ${Me.Skill[feign death]} < ${Me.SkillCap[feign death]} && ${Me.AbilityReady[feign death]}) {
            /doability "feign death"
            /delay 5
            /if (!${Me.Standing}) /stand
        }
        /if (${Me.Skill[hide]} && ${Me.Skill[hide]} < ${Skill[hide].SkillCap}) /doability "hide"
        /if (${Me.Skill[sneak]} && ${Me.Skill[sneak]} < ${Skill[sneak].SkillCap}) /doability "sneak"
        /if (${Me.Skill[mend]} && ${Me.Skill[mend]} < ${Me.SkillCap[mend]} && ${Me.AbilityReady[mend]}) /doability "mend"
        /if (${Me.Skill[forage]} && ${Me.Skill[forage]} < ${Me.SkillCap[forage]} && ${Me.AbilityReady[forage]}) {
            /if (${Me.Sitting}) /stand
            /doability "forage"
        }
        /call checkcursor
|| Check if you have a valid target and not yourself
        /if (!${Target.ID}||${Target.Type.Equal[pc]} && ${Zone.Type}||${Target.Master.Type.Equal[pc]} && ${Zone.Type}||${Target.Type.Equal[corpse]}||${Target.Distance}>${Target.MaxRange}||${Target.ID}==${Me.ID}) {
            /echo ${Target.DisplayName} is not a valid target!
            /echo ${Target.Type.Equal[pc]} && ${Zone.Type}
            /end
        }
        /if (${Me.Skill[flying kick]} && ${Me.AbilityReady[flying kick]} && ${Me.Skill[flying kick]} < ${Me.SkillCap[flying kick]}) /doability "flying kick"
        /if (${Me.Skill[bash]} && ${Me.AbilityReady[bash]} && ${Me.Skill[bash]} < ${Me.SkillCap[bash]} && (${InvSlot[offhand].Item.Type.Find[shield]}||${Me.AltAbility[2 Hand Bash]})) /doability "bash"
        /if (${Me.Skill[frenzy]} && ${Me.AbilityReady[frenzy]} && ${Me.Skill[frenzy]} < ${Me.SkillCap[frenzy]}) /doability "frenzy"
        /if (${Me.Skill[slam]} && ${Me.AbilityReady[slam]} && !${Me.AbilityReady[bash]} && ${Me.Skill[slam]} < ${Me.SkillCap[slam]}) /doability "slam"
        /if (${Me.Skill[round kick]} && ${Me.AbilityReady[round kick]} && ${Me.Skill[round kick]} < ${Me.SkillCap[round kick]}) /doability "round kick"
        /if (${Me.Skill[kick]} && ${Me.AbilityReady[kick]} && ${Me.Skill[kick]} < ${Me.SkillCap[kick]}) /doability "kick"
        /if (${Me.Skill[tiger claw]} && ${Me.AbilityReady[tiger claw]} && ${Me.Skill[tiger claw]} < ${Me.SkillCap[tiger claw]}) /doability "tiger claw"
        /if (${Me.Skill[Disarm]} && ${Target.Distance}<12 && ${Me.AbilityReady[Disarm]} && ${Me.Skill[Disarm]} < ${Me.SkillCap[Disarm]}) /doability "Disarm"
        /if (${Me.Skill[Backstab]} && ${Me.AbilityReady[Backstab]} && ${Melee.Behind} && ${Me.Skill[Backstab]} < ${Me.SkillCap[Backstab]}) /doability "Backstab"
        /if (${Me.Skill[Taunt]} && ${Me.Skill[Taunt]} < ${Me.SkillCap[Taunt]} && ${Me.AbilityReady[Taunt]}) /doability "Taunt"
        /if (${Me.Skill[Begging]} && ${Me.Skill[Begging]} < ${Me.SkillCap[Begging]} && ${Me.AbilityReady[Begging]}) /doability "Begging"
        /if (${Me.Skill[tracking]} >= ${Me.SkillCap[tracking]} && ${Me.Skill[feign death]} >= ${Me.SkillCap[feign death]} && ${Me.Skill[hide]} >= ${Me.SkillCap[hide]} && ${Me.Skill[sneak]} >= ${Me.SkillCap[sneak]} && ${Me.Skill[mend]} >= ${Me.SkillCap[mend]} && ${Me.Skill[forage]} >= ${Me.SkillCap[forage]} && ${Me.Skill[flying kick]} >= ${Me.SkillCap[flying kick]} && (${Me.Skill[bash]} >= ${Me.SkillCap[bash]} || !${InvSlot[offhand].Item.Type.Find[shield]}) && ${Me.Skill[frenzy]} >= ${Me.SkillCap[frenzy]} && ${Me.Skill[slam]} >= ${Me.SkillCap[slam]} && ${Me.Skill[round kick]} >= ${Me.SkillCap[round kick]} && ${Me.Skill[kick]} >= ${Me.SkillCap[kick]} && ${Me.Skill[tiger claw]} >= ${Me.SkillCap[tiger claw]} && ${Me.Skill[Disarm]} >= ${Me.SkillCap[Disarm]} && ${Me.Skill[Backstab]} >= ${Me.SkillCap[Backstab]} && ${Me.Skill[Taunt]} >= ${Me.SkillCap[Taunt]} && ${Me.Skill[Begging]} >= ${Me.SkillCap[Begging]}) {
            /varset AbilitiesCheckDone TRUE
            /popup Abilities are maxed out - Grats!
            /echo Abilities are maxed out - Grats!
            /if (${Me.Skill[bash]} < ${Me.SkillCap[bash]} && !${InvSlot[offhand].Item.Type.Find[shield]}) {
                /echo Note! Your Bash skill is not maxed out! (${Me.Skill[bash]} / ${Me.SkillCap[bash]})
                /echo Equip a shield and run the macro again if needed
            }
        }
/return
| --------------------------------------------------------------------------------------------
| SUB: MemSpells
| --------------------------------------------------------------------------------------------
Sub MemSpells
    /if (${Select[${Me.Class.Name},Warrior,Berserker,Monk,Rogue,Bard]}>=1) /return
    /declare i int local
    /for i 1 to 5
        /if (!${Me.Gem[${PracticeSpell[${Me.Class.ID},${i}]}]}) {
            /echo Memorizing Spell >> ${PracticeSpell[${Me.Class.ID},${i}]} <<
            /memspell ${i} "${PracticeSpell[${Me.Class.ID},${i}]}"
            /delay 10s ${Me.Gem[${PracticeSpell[${Me.Class.ID},${i}]}]}
            /if (!${Select[${PracticeSpell[${Me.Class.ID},${i}]},${Me.Gem[${i}]}]}) /echo Spell mem failed!
        }
    /next i
/return
| --------------------------------------------------------------------------------------------
| SUB: Spells
| --------------------------------------------------------------------------------------------
Sub Spells
    /if (${SpellsCheckDone}) /return
    /if (${Me.Casting.ID} && !${Me.Class.ShortName.Equal[BRD]}||${Me.Hovering}||${Window[tradewnd].Open}||${Window[lootwnd].Open}) /return
    /if (${Me.Skill[Abjuration]} < ${Me.SkillCap[Abjuration]}) /call Raise Abjuration
    /if (${Me.Skill[Alteration]} < ${Me.SkillCap[Alteration]}) /call Raise Alteration
    /if (${Me.Skill[Conjuration]} < ${Me.SkillCap[Conjuration]}) /call Raise Conjuration
    /if (${Me.Skill[Divination]} < ${Me.SkillCap[Divination]}) /call Raise Divination
    /if (${Me.Skill[Evocation]} < ${Me.SkillCap[Evocation]}) /call Raise Evocation
    /if (${Me.Skill[Divination]} >= ${Me.SkillCap[Divination]} && ${Me.Skill[Evocation]} >= ${Me.SkillCap[Evocation]} && ${Me.Skill[Abjuration]} >= ${Me.SkillCap[Abjuration]} && ${Me.Skill[Alteration]} >= ${Me.SkillCap[Alteration]} && ${Me.Skill[Divination]} >= ${Me.SkillCap[Divination]} && ${Me.Skill[Conjuration]} >= ${Me.SkillCap[Conjuration]}) {
        /varset SpellsCheckDone TRUE
        /popup All spell skills are maxed out - Grats!
        /echo All spell skills are maxed out - Grats!
    }
/return
| --------------------------------------------------------------------------------------------
| SUB: SpecializeSpell
| --------------------------------------------------------------------------------------------
Sub SpecializeSpell
    /if (${SpecializeSpellCheckDone}) /return
    /if (${Me.Casting.ID} && !${Me.Class.ShortName.Equal[BRD]}||${Me.Hovering}||${Window[tradewnd].Open}||${Window[lootwnd].Open}) /return
    /if (${Me.Skill[Specialize Abjure]} < ${SpecAbjureCap}) /call Raise Abjuration
    /if (${Me.Skill[Specialize Alteration]} < ${SpecAlterationCap}) /call Raise Alteration
    /if (${Me.Skill[Specialize Conjuration]} < ${SpecConjurationCap}) /call Raise Conjuration
    /if (${Me.Skill[Specialize Divination]} < ${SpecDivinationCap}) /call Raise Divination
    /if (${Me.Skill[Specialize Evocation]} < ${SpecEvocationCap}) /call Raise Evocation
    /if (${Me.Skill[Specialize Evocation]} >= ${SpecEvocationCap} && ${Me.Skill[Specialize Abjure]} >= ${SpecAbjureCap} && ${Me.Skill[Specialize Alteration]} >= ${SpecAlterationCap} && ${Me.Skill[Specialize Divination]} >= ${SpecDivinationCap} && ${Me.Skill[Specialize Conjuration]} >= ${SpecConjurationCap}) {
        /varset SpecializeSpellCheckDone TRUE
        /popup All spell Specialization skills are maxed out - Grats!
        /echo All specialized spell skills are maxed out - Grats!
    }
/return

| --------------------------------------------------------------------------------------------
| SUB: Raise
| --------------------------------------------------------------------------------------------
Sub Raise(skilltype)
    /if (${Me.Casting.ID} && !${Me.Class.ShortName.Equal[BRD]}||${Me.Hovering}||${Window[tradewnd].Open}||${Window[lootwnd].Open}) /return
    /declare i int local
    /call checkcursor
    /for i 1 to 5
        /if (${Me.CurrentMana}>${Me.Gem[${i}].Mana} && ${Me.Gem[${i}].Skill.Equal[${skilltype}]} && !${Me.GemTimer[${i}]} && ${Me.SpellReady[${Me.Gem[${i}]}]} && !${Select[${Me.Gem[${i}].Category},Transport,Traps,Aura]} && !${Select[${Me.Gem[${i}].Subcategory},Invulnerability]} && (!${Me.Gem[${i}].Subcategory.Find[Sum: ]}||!${Me.Pet.ID})) {
            /if (${Me.Gem[${i}].TargetType.Equal[Single]} && ${Target.Type.NotEqual[npc]} && ${${Me.Gem[${i}].SpellType.Equal[Detrimental]}}) {
                /squelch /tar npc range ${Me.Gem[${i}].MyRange}
                /delay 1
                /if (!${Target.ID}) /squelch /tar myself
                /delay 1
            }
            /if (${Me.Gem[${i}].TargetType.Equal[Single]} && !${Target.ID} && ${${Me.Gem[${i}].SpellType.NotEqual[Detrimental]}}) {
                /if (!${Target.ID}) /squelch /tar myself
                /delay 1
            }
            /if (${Me.Gem[${i}].TargetType.Equal[pet]} && !${Me.Pet.ID}) /goto :skip
| Hardcoded due to ranger spell requirement (cast at night only)
            /if (${Spell[${Me.Gem[${i}]}].Name.Equal[Dance of the Fireflies]} && !${GameTime.Night}) /goto :skip
            /casting "${Me.Gem[${i}]}" gem${i}
            /delay 1s
            /delay 10s !${Me.Casting.ID}
        }
    :skip
    /next i
/return

| --------------------------------------------------------------------------------------------
| SUB: checkcursor
| Used in Forage and Conjuration skills
| --------------------------------------------------------------------------------------------
Sub checkcursor
    /while (${Cursor.ID}) {
        /destroy
        /delay 2
    }
/return
 
Last edited:
Just tried this to raise hide and sneak on a baby rogue and had an issue described above where if it was successful the buttons wouldn't refresh so it wouldn't continue to use those skills. I copied and pasted the macro into a new file and on lines 39 /if (${Me.Skill[hide]} < ${Skill[hide].SkillCap} && ${Me.AbilityReady[hide]}) /doability "hide" and 40 /if (${Me.Skill[sneak]} < ${Skill[sneak].SkillCap} && ${Me.AbilityReady[sneak]}) /doability "sneak" I removed the condition to check if the ability is ready again and that has fixed the problem for those abilities at least. Specific portion to remove is && ${Me.AbilityReady[hide]} and && ${Me.AbilityReady[sneak]} It did not however end itself when hide and sneak were at my skill cap which may have been due to not being in a zone where I could train combat skills to their caps or because I was using it on a rogue and not a caster.[/hide][/hide][/hide][/hide]
 
Current macro lines 166/167:
        /if (${Me.Skill[hide]} && ${Me.Skill[hide]} < ${Skill[hide].SkillCap} && ${Me.AbilityReady[hide]}) /doability "hide"
        /if (${Me.Skill[sneak]} && ${Me.Skill[sneak]} < ${Skill[sneak].SkillCap} && ${Me.AbilityReady[sneak]}) /doability "sneak"

stripped out the ability ready checks:
        /if (${Me.Skill[hide]} && ${Me.Skill[hide]} < ${Skill[hide].SkillCap}) /doability "hide"
        /if (${Me.Skill[sneak]} && ${Me.Skill[sneak]} < ${Skill[sneak].SkillCap}) /doability "sneak"
 
Trying to use this on a 65 druid with no success at all. No matter who I target it says that is not a valid target. It memmed the spells started foraging and tracking, cast summon food once and then started with the invalid target. Suggestions? What am I missing?

EDIT: Figured it out...I had to move about 2 steps closer to my merc then it started working.
 
Last edited:
Skills - auto skill raiser

Users who are viewing this thread

Back
Top