MMOBugs MQ2 For EQMac PC Client - Beta Release

eqmule

Developer
Joined
Jul 20, 2006
Messages
342
Reaction score
1
Points
18
I completed the work on the mq2moveutils plugin today so it is ready for release,
as of now /stick in all its forms should work, I haven't tested anything else, Ill rely on the users (yes you guys ;) ) to report if something still needs fixing,

I also fixed keybinds which makes follow.mac work.
All changes/fixes are checked in.

htw will release when he has built the installer.
 
Last edited:

darkeros

New member
Joined
Jan 5, 2008
Messages
40
Reaction score
0
Points
0
Hey guys, my client crashes when I try to run the bot macro. I'm assuming it's doing something not supported by the EQMac version, but nothing jumps out at me. Any suggestions on how to tell what's crashing?

Also, can you guys point me in the direction of any posts showing how to get into plugin work? I've been in the community for a long time and always stuck just with macros. I'd like to get to a point where I can support the EQMac MQ2 release in pulling in some old plugins. I agree that active hacks shouldn't be given to the community, though, as this is the last bastion of "classic".
 

eqmule

Developer
Joined
Jul 20, 2006
Messages
342
Reaction score
1
Points
18
I would start by adding debug spew in the macro to see how far you get in it before the crash. Or simply just post he macro for us to try.

Plugins for eqmac version of mq2 are not that much different from plugins for mq2 for live, if you create one for live I'd be happy to make it work for eqmac as well. In fact the goal is to make mq2 for eqmac 99% compatible with the version for live, so there is no point in dumbing them down to make them work but its our job to make plugins that work on live work on eqmac...
 

darkeros

New member
Joined
Jan 5, 2008
Messages
40
Reaction score
0
Points
0
This one works just far enough to start to mem a spell, then the client crashes *without the mq2 client crash message box*. It crashes right after the spellbook opens up and starts to mem a spell. Not sure what it is... I found this one from back in 2005, so it should work with the current eq client and everything.

Code:
| Rikgauk Sham mod 1.0 
|~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~| 
| Moded this to 6 box with my shm 
| Borrowed scripts from many others. 
| 
| 
| Usage: 
| 1. Target player you like to assist (main tank is good) 
| 2. Start the script with: /mac <scriptname> [main assist] [chat channel] 
[controller] 
| 3. Parameters are optional defaults are built in 
| 
| 
| Features: commands work in tell or group 
| 
| The following commands will target the sender and cast the spells 
| requested on the sender: [Avatar] [Sta] [Forti] [Sos] [Agi] [Dex] [Str] [Cha] 
[Sow] [lev] 
| [haste] [regen] [see] [pe] [pr] [grow] [shrink] [hot] [heal] [Wunshi] 
| 
| The following commands will assist the sender and cast the spells 
| requested on the target: [Slow] [add] [root] [dot] [nuke] 
| 
| The following commands: [buff] [buff me] will rebuff a person 
| 
| The following commands: [Buff them] will rebuff another group 
| 
| The following commands: [Follow me] [end follow] [stop] are for moving shaman 
| 
| The [add] or [slow] command are good in combat when there are adds 
| Target the add and it will be malo and slowed 
| 
| During combat he will only do requests for heals and detrimentals 
| 
| [buff pet] Targets sender pet and buffs 
| 
| [gate now] will memorize the gate spell and gate to bind, must be a tell 
| 
| Added a chat channel to echo all non command word tells to controller 
| added a vtell to controller on incomming tells 
| 
| Use "help" for more help ( !help is incomplete! ) 
|_______________________________________________________________| 
| 
| -!- Basis of this script is Version: v0.5c by Hubba 
| Some other mods and my own changes 
| 
|_______________________________________________________________| 
| -!- This Script Uses spell_routines.inc by Rusty 
| -!- Exptrack snippet from exptracker.mac by Raebis, with tweaks from Phoenix 
(not tested) 
| -!- Wait4Rez snippet from wait4rez.mac by fantum409 
| 
|_______________________________________________________________| 

#chat group 
#chat tell 

#Event ToggleVariable "[MQ2] Toggle #1#" 
#Event ToggleVariable "[MQ2] Toggle #1# #2#" 
#Event OutDoor "#*#outdoors#*#" 
#Event OutDoor "You can not summon a mount here." 
#Event Zoning "You have entered#*#" 
#Event Hungry "#*#are hungry#*#" 
| #Event Enrageon "#*#ENRAGED#*#" 
| #Event Enrageoff "#*#no longer enraged#*#" 
#Event Thirsty "#*#are thirsty#*#" 
#Event ImDead "You have been slain by#*#" 
#Event Invited "#*#To join the group, click on the 'FOLLOW' option, 
or 'DISBAND' to 

cancel#*#" 

#include Spell_Routines.inc 

Sub Main 

| The spell will be memmed in the listed order. 
| Gem1 = Canni 
| Gem2 = Slow 
| Gem3 = Malo 
| Gem4 = Avatar, Cripple 
| 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 
| ########### 

| ########### Default Channel, Controller 

/declare CChannel outer "teamrik" 
/declare ChatController outer "Thornak" 

| ########### Your Spell List - update as needed 

/declare SpellSlow outer "Turgur's Insects" 
| /declare SpellSlow outer "Balance if Nihil" 
/declare SpellDoT outer "Blood of Saryrn" 
| /declare SpellDot outer "Blood of Yoppa" 
/declare SpellCripple "Cripple"
/declare SpellDrDot outer "Breath of Ultor" 
/declare SpellMrDot outer "Bane" 
/declare SpellPet outer "True Spirit" 
/declare SpellDeBuff outer "Malos" 
/declare SpellCanni outer "Cannibalize IV" 
| /declare SpellCanni outer "Pained Memory" 

/declare SpellHoT outer "Quiescence" 
| /declare SpellHoT outer "Spiritual Serenity" 
/declare SpellHeal outer "Tnarg`s Mending" 
| /declare SpellHeal outer "Yoppa's Mending" 
/declare SpellRoot outer "Petrifying Earth" 
/declare SpellNuke outer "Velium Strike" 

/declare SpellATK outer "Ferine Avatar" 
/declare SpellHASTE outer "Swift like the Wind" 
/declare SpellFOCUS outer "Focus of Soul" 
/declare SpellWunshi outer "Wunshi's Focusing" 
/declare SpellCHA outer "Unfailing Reverence" 
/declare SpellDEX outer "Dextorous Aura" 
/declare SpellMight outer "Spirit of Might" 
/declare SpellSTR outer "Agility of the Wrulan" 
/declare SpellSos outer "Spirit of Sense" 
/declare SpellAGI outer "Agility of the Wrulan" 
/declare SpellSTA outer "Endurance of the Boar" 
/declare SpellREGEN outer "Replenishment" 
| /declare SpellREGEN outer "Spirit of Perseverance" 
/declare SpellForti outer "Spirit of Fortitude" 
/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 SpellINV outer "Spirit Veil" 
/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 



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

/declare SpellPetBuff[4] string outer 
/varset SpellPetBuff[1] "Swift like the Wind" 
/varset SpellPetBuff[2] "Agility of the Wrulan" 
/varset SpellPetBuff[3] "Ferine Avatar" 
/varset SpellPetBuff[4] "Focus of Soul" 
| /varset SpellPetBuff[2] "Spirit of Sense" 

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

/declare SpellPetBuffo[3] string outer 
/varset SpellPetBuffo[1] "Swift like the Wind" 
/varset SpellPetBuffo[2] "Primal Essence" 
/varset SpellPetBuffo[3] "Focus of Soul" 

| ############ Group Buff List. Remove the | in front of Buffs when you get the spells to use them. 
| ############ MAKE SURE TO CHANGE /DECLARE sPELLGRPBUFF[#] AND CHANGE THE /VARSET sPELLGRPBUFF[#] 
| ############ SO THEY GO IN ORDER 1-7 SO ALL WILL BE USED PROPERLY!! 

/declare SpellGrpBuff[5] string outer 
/varset SpellGrpBuff[1] "Blessing of Replenishment" 
| /varset SpellGrpBuff[2] "Talisman of Wunshi" 
/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 Sense" 
| /varset SpellGrpBuff[7] "Talisman of Fortitude" 

| ############ Single Buff List. 

/declare SpellSingleBuff[4] string outer 
/varset SpellSingleBuff[1] "Replenishment" 
| /varset SpellSingleBuff[2] "Wunshi's Focusing" 
/varset SpellSingleBuff[2] "Focus of Soul" 
/varset SpellSingleBuff[3] "Agility of the Wrulan" 
/varset SpellSingleBuff[4] "Endurance of the Boar" 
| /varset SpellSingleBuff[5] "Spirit of Fortitude" 
| /varset SpellSingleBuff[6] "Spirit of Sense" 

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

/declare AssistAt int outer 98 
/declare CombatAt int outer 97 

/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 40 
/declare MeleeHeals int outer 50 
/declare TankHeal int outer 20 

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

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

/declare SummonPet outer TRUE 
/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 Cannibalization outer TRUE 
/declare Verbose outer TRUE 

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

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

/squelch /alias malo /echo toggle malo 
/squelch /alias slow /echo toggle slow 
/squelch /alias fastslow /echo toggle fastslow 
/squelch /alias root /echo toggle root 
/squelch /alias pet /echo toggle pet 
/squelch /alias dot /echo toggle dot 
/squelch /alias nuke /echo toggle nuke 
/squelch /alias nukeat /echo toggle nukeat 
/squelch /alias buffs /echo toggle buffs 
/squelch /alias sow /echo toggle sow 
/squelch /alias assistat /echo toggle assistat 
/squelch /alias dotat /echo toggle dotat 
/squelch /alias rootat /echo toggle rootat 
/squelch /alias combatat /echo toggle combatat 
/squelch /alias healmeleeat /echo toggle healmeleeat 
/squelch /alias healcastersat /echo toggle healcastersat 
/squelch /alias healtankat /echo toggle healtankat 
/squelch /alias assist /echo toggle assist 
/squelch /alias healat /echo toggle healat 
/squelch /alias status /echo toggle show 
/squelch /alias show /echo toggle show 
/squelch /alias help /echo toggle help 
/squelch /alias verbose /echo toggle verbose 

/declare TargetArray[4] string outer 
/declare MobMaloed outer FALSE 
/declare MobSlowed 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 MobCrippled outer FALSE

/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 

/call MemSpells 

| ############### Target a player as Main Assist 

/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} 
} 

/assist off 

/if (${Defined[Param1]}) /varset CChannel ${Param1} 
/leaveall 
/join ${CChannel} 
/1 I am here! 
/echo Joined channel ${CChannel} 

/if (${Defined[Param2]}) /varset ChatController ${Param2} 
/vtell ${ChatController} 005 
/tell ${ChatController} I am here! 
/echo My master is ${ChatController} 


| ############### Shrink 

/target pc ${M_Assist} 
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
/ECHO ${SpellSHRINK} is incomming to you 
/call cast ${SpellSHRINK} gem5 5s 
/call cast ${SpellSHRINK} gem5 5s 
} 


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

:Main_Loop 

|- Check for Standing if less than sitat then sit 
/if ( ${Me.State.Equal[Stand]} && ${Me.PctMana}<${SitAt}) /sit 

|- 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 
/call GetTarget 
/if (${CombatOn}) /call Combat 

|- Group Heals 
/call Check_grpHPs 

|- Check for Standing if less than sitat then sit 
/if ( ${Me.State.Equal[Stand]} && ${Me.PctMana}<${SitAt}) /sit 

|- Canni 
/call LOM 

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

|- Buff Avatar 
/if (${Me.SpellReady[${SpellATK}]}) /call Cast_Avatar 

|- Group Heals 
/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[${SpellMrDot}]} ) { 
/memspell 9 ${SpellMrDot} 
/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} && !${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 
} 
/if (${CombatOn} && ${DoRoot} && ${Me.PctMana}>=${RootMana} && 
${Target.PctHPs}<=${RootAt}) { 
/call cast ${SpellRoot} gem9 
/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 PetOn FALSE 
/varset MobDoTed FALSE 
/varset CombatOn FALSE 
/varset Engaged FALSE
/varset MobCrippled 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 
} 
:Cripple_Loop
/if (${Me.CurrentMana}<${Spell[${SpellCripple}].Mana}) { 
/echo *** Shid ! I don't have mana to Malo %T 
} else { 
/call cast ${SpellCripple} gem4 2s 
/if (${Macro.Return.Equal["CAST_INTERRUPTED"]}) /goto :Cripple_Loop 
/varset MobCrippled 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 
/goto :Slow_Loop 
} 
/varset MobSlowed TRUE 
} 
/if (${Macro.Return.Equal["CAST_SUCCESS"]}) { 
/if (${Verbose}) /gsay *** %T is SLOWED 
/varset MobSlowed 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 PetOn FALSE 
/varset MobDoTed FALSE
/varest MobCrippled FLASE 

/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[${i}].Class.Name.Equal[Cleric]} || 
${Group[${i}].Class.Name.Equal[Druid]} || 
${Group[${i}].Class.Name.Equal[Wizard]} || 
${Group[${i}].Class.Name.Equal[Magician]} || 
${Group[${i}].Class.Name.Equal[Necromancer]} || 
${Group[${i}].Class.Name.Equal[Enchanter]}) /if 
(${Group[${i}].PctHPs}<=${CasterHeals}) { 
/target pc ${Group[${i}]} 
/if (${Me.CurrentMana}<${Spell[${SpellHeal}].Mana}) { 
/echo *** Shid ! I don't have mana to heal ${Group[${i}]} 
} else /if (${Target.Distance}<=100) { 
/if (${Verbose}) /gsay *** ${SpellHeal} on %T 
/call cast ${SpellHeal} gem6 4s 
} 
} 

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

/if (${Group[${i}].Name.Equal[${M_Assist}]} && 
${Group[${i}].PctHPs}<=${TankHeal}) { 
/target pc ${Group[${i}]} 
/if (${Me.CurrentMana}<${Spell[${SpellHeal}].Mana}) { 
/echo *** Shid ! I don't have mana to heal ${Group[${i}]} 
} else /if (${Target.Distance}<=100) { 
/if (${Verbose}) /gsay *** ${SpellHeal} on %T 
/call cast ${SpellHeal} gem6 4s 
} 
} 

/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 
/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 (${Me.Buff[${SpellHoT}].ID}) { 
/if (${Verbose}) /gsay *** Canni V will Q myself 
/aa act Cannibalization 
/delay 3s 
} 
/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 (${Cannibalization} && ${Me.AltAbilityReady[47]} && ${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 
/echo Buff ${Me.Pet.ID} with ${SpellPet} 
} 
/declare i int local 
/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 0 
/for i 0 to ${Group} 
/if (${Group[${i}].ID}) { 
/if (${ATKBuffed${i}}==0) /if (${Group[${i}].Class.Name.Equal[Beastlord]} 
|| ${Group[${i}].Class.Name.Equal[Shadow Knight]} || 
${Group[${i}].Class.Name.Equal[Bard]} || ${Group[${i}].Class.Name.Equal[Ranger]} 
|| ${Group[${i}].Class.Name.Equal[Rogue]} || 
${Group[${i}].Class.Name.Equal[Paladin]} || 
${Group[${i}].Class.Name.Equal[Monk]} || 
${Group[${i}].Class.Name.Equal[Warrior]}) { 
/target pc ${Group[${i}]} 
/if (${Me.CurrentMana}>${Spell[${SpellATK}].Mana}) { 
/tell ${Group[${i}]} ${SpellATK} is incomming to you ${Group[${i}]} , 
Stay in Range !!! 
/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 
| ################## Hungry 

Sub Event_Hungry 
/if (${Engaged}) /return 
/echo I am Hungry 
/gsay I am summoning food... please hold pulls 
/declare i int local 1 
/for i 1 to 8 
/autoinventory 
/delay 1 
/call cast ${SpellFOOD} gem5 5s 
/next i 
/autoinventory 
/gsay GTG now 
/return 

| ################## Thirsty 

Sub Event_Thirsty 
/if (${Engaged}) /return 
/echo I am Thirsty 
/gsay I am summoning drink... please hold pulls 
/declare i int local 1 
/for i 1 to 8 
/autoinventory 
/delay 1 
/call cast ${SpellDRINK} gem5 5s 
/next i 
/autoinventory 
/gsay GTG now 
/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 
/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 PetOn FALSE 
/varset MobDoTed FALSE
/varset MobCrippled FALSE 

/return 

| ################## Group Invite 

Sub Event_Invited 
/invite 
/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. 
/gsay I have consented group. 
/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) 

/if (!${ChatType.Equal[GROUP]} && !${ChatType.Equal[TELL]}) /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]}) { 
/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[MrDot]}) { 
/assist ${ChatSender} 
/if (${Target.Type.Equal[NPC]} && ${Target.Distance}<=100) { 
/call cast ${MrDot} gem9 5s 
} 
/return 
} 

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

/if (${ChatText.Equal[dot]}) { 
/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[Sos]}) { 
/target pc ${ChatSender} 
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
/tell ${ChatSender} ${SpellSos} is incomming to you ${ChatSender}!!! 
/call cast ${SpellSos} 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[Wunshi]}) { 
/target pc ${ChatSender} 
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
/tell ${ChatSender} ${SpellWunshi} is incomming to you 
${ChatSender}!!! 
/call cast ${SpellWunshi} gem4 4s 
} 
/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[Might]}) { 
/target pc ${ChatSender} 
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
/tell ${ChatSender} ${SpellMight} is incomming to you ${ChatSender}!!! 
/call cast ${SpellMight} 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[Forti]}) { 
/target pc ${ChatSender} 
/if (${Target.Type.Equal[PC]} && ${Target.Distance}<=100) { 
/tell ${ChatSender} ${SpellForti} is incomming to you 
${ChatSender}!!! 
/call cast ${SpellForti} gem4 4s 
} 
/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]}) { 
/delay 5 
/if (!${Spawn[${ChatSender}].ID}) { 
/e ${ChatSender} is not in zone for me to follow! 
/return 
} 
/varset follname ${ChatSender} 
/varset following 1 
/tell ${ChatSender} I am following you!!! 
/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} 
/tell ${ChatSender} I Stopped following you!!! 
/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 



| ################### This will check whenever the player is changing any 
variable via /echo 

Sub Event_ToggleVariable(string Line, string Command, string Command2) 

/if (${Command.Equal[malo]} && ${DoMalo}==0) { 
/varset DoMalo TRUE 
/echo Do Malo: ${DoMalo} 
} else /if (${Command.Equal[malo]}) { 
/varset DoMalo FALSE 
/echo Do Malo: ${DoMalo} 
} 

/if (${Command.Equal[slow]} && ${DoSlow}==0) { 
/varset DoSlow TRUE 
/echo Do Slow: ${DoSlow} 
} else /if (${Command.Equal[slow]}) { 
/varset DoSlow FALSE 
/echo Do Slow: ${DoSlow} 
} 

/if (${Command.Equal[fastslow]} && ${FastSlow}==0) { 
/varset FastSlow TRUE 
/echo Do Fast Slow: ${FastSlow} 
} else /if (${Command.Equal[fastslow]}) { 
/varset FastSlow FALSE 
/echo Do Fast Slow: ${FastSlow} 
} 

/if (${Command.Equal[root]} && ${DoRoot}==0) { 
/varset DoRoot TRUE 
/echo Do Root: ${DoRoot} 
} else /if (${Command.Equal[root]}) { 
/varset DoRoot FALSE 
/echo Do Root: ${DoRoot} 
} 

/if (${Command.Equal[pet]} && ${SummonPet}==0) { 
/varset SummonPet TRUE 
/echo Summon Pet: ${SummonPet} 
} else /if (${Command.Equal[pet]}) { 
/varset SummonPet FALSE 
/echo Summon Pet: ${SummonPet} 
} 

/if (${Command.Equal[dot]} && ${DoDoT}==0) { 
/varset DoDoT TRUE 
/echo Do DoT: ${DoDoT} 
} else /if (${Command.Equal[dot]}) { 
/varset DoDoT FALSE 
/echo Do DoT: ${DoDoT} 
} 

/if (${Command.Equal[buffs]} && ${DoBuffs}==0) { 
/varset DoBuffs TRUE 
/echo Do Buffs: ${DoBuffs} 
} else /if (${Command.Equal[buffs]}) { 
/varset DoBuffs FALSE 
/echo Do Buffs: ${DoBuffs} 
} 

/if (${Command.Equal[sow]} && ${DoSow}==0) { 
/varset DoSow TRUE 
/echo Do Sow: ${DoSow} 
} else /if (${Command.Equal[sow]}) { 
/varset DoSow FALSE 
/echo Do Sow: ${DoSow} 
} 

/if (${Command.Equal[nuke]} && ${DoNuke}==0) { 
/varset DoNuke TRUE 
/echo Do Nuke: ${DoNuke} 
} else /if (${Command.Equal[nuke]}) { 
/varset DoNuke FALSE 
/echo Do Nuke: ${DoNuke} 
} 

/if (${Command.Equal[heal]} && ${DoHeal}==0) { 
/varset DoHeal TRUE 
/echo Do Heal: ${DoNuke} 
} else /if (${Command.Equal[heal]}) { 
/varset DoHeal FALSE 
/echo Do Heal: ${DoNuke} 
} 

/if (${Command.Equal[verbose]} && ${Verbose}==0) { 
/varset Verbose TRUE 
/echo Verbose: ${Verbose} 
} else /if (${Command.Equal[verbose]}) { 
/varset Verbose FALSE 
/echo Verbose: ${Verbose} 
} 

/if (${Command.Equal[buffpet]} && ${BuffPet}==0) { 
/varset BuffPet TRUE 
/echo Buff Pet: ${BuffPet} 
} else /if (${Command.Equal[buffpet]}) { 
/varset BuffPet FALSE 
/echo Buff Pet: ${BuffPet} 
} 

/if (${Command.Equal[assistat]}) { 
/varset AssistAt ${Command2} 
/echo Assisting at range: ${AssistAt} _ (Longer range then 100 is futile) 
} 

/if (${Command.Equal[dotat]}) { 
/varset CastDoTat ${Command2} 
/echo Casting ${SpellDoT} at ${CastDoTat}% 
} 

/if (${Command.Equal[rootat]}) { 
/varset Rootat ${Command2} 
/echo Rooting Mobs at ${Rootat}% 
} 

/if (${Command.Equal[nukeat]}) { 
/varset NukeAt ${Command2} 
/echo Starting to Nuke Mobs at ${NukeAt}% 
} 

/if (${Command.Equal[combatat]}) { 
/varset CombatAt ${Command2} 
/echo Initiate Combat at ${CombatAt}% (Malo / Slow) 
} 

/if (${Command.Equal[healtankat]}) { 
/varset TankHeal ${Command2} 
/echo Healing ${M_Assist} at ${TankHeal}% 
} 

/if (${Command.Equal[healmeleeat]}) { 
/varset MeleeHeals ${Command2} 
/echo Healing all Melee classes at ${MeleeHeals}% 
} 

/if (${Command.Equal[healcastersat]}) { 
/varset CasterHeals ${Command2} 
/echo Healing all Caster classes at ${CasterHeals}% 
} 

/if (${Command.Equal[assist]}) { 
/varset M_Assist ${Command2} 

/sq /target pc ${M_Assist} 
/if (!${Target.ID}) { 
/echo ${M_Assist} is not here dude ! 
/return 
} 

/echo I will assist: ${M_Assist} 
} 

/if (${Command.Equal[healat]}) { 
/varset HealGRPat ${Command2} 
/echo Healing any group member below ${HealGRPat}% HPs 
} 

/if (${Command.Equal[Show]}) { 

/echo --------------------------- 
/echo Do Malo:..............${DoMalo} - Casting at: ${CombatAt}% (Initiate Combat*, higher then 99 is no good) 
/echo Do Slow:..............${DoSlow} - Casting at: ${CombatAt}% (Initiate Combat*, higher then 99 is no good) 
/echo Do Fastslow:......${FastSlow} - (Will only try to slow once!) 
/echo Do Nuke:.............${DoNuke} - Casting at: ${NukeAt}% (Will chain nuke mob to death) 
/echo Do Dot:................${DoDoT} - Casting at: ${CastDoTat}% 
/echo Do Pet:................${SummonPet} 
/echo Do Buffs:.............${DoBuffs} 
/echo Do Root:..............${DoRoot} - Casting at: ${Rootat}% 
/echo Do Sow:...............${DoSow} 
/echo Do Heal:..............${DoHeal} 
/echo Buff Pet:.............${BuffPet} 
/echo --------------------------- 
/echo Assist range: ${AssistAt} 
/echo Assisting: ${M_Assist} 
/echo Healing Casters: ${CasterHeals}% Melees: ${MeleeHeals}% 
/echo ${M_Assist} get heals at ${TankHeal} 
/echo Initiate Combat: ${CombatAt}% 
/echo Verbose: ${Verbose} 
/echo 
/echo help - Will show help to set variables. 

} 

/if (${Command.Equal[help]}) { 
/echo ___ Shaman Do Stuff Script ___ 
/echo 
/echo Commands that will turn ON or OFF 
/echo malo, slow, fastslow, root, pet, dot, buffs, sow, nuke, heal, buffpet 
/echo 
/echo fastslow will NOT check if the slow is landed or not. Good to have on 
when you skip maloing. 
/echo Commands to change values, ie: assistat 50 (Will start the combat 
routine when mob is in range 50) 
/echo assisat <range> - Most spells don't go longer then 100 
/echo combatat <% hps> - Initiate Combat when mob is at % HPs 
/echo healtankat <% hps> 
/echo healmeeleat <% hps> 
/echo healcastersat <% hps> 
/echo assist <PC Name> 
} 

/return
 
Last edited:

eqmule

Developer
Joined
Jul 20, 2006
Messages
342
Reaction score
1
Points
18
if the macro works on live without a crash, I should be able to make it work on eqmac without a crash...
 

htw

Developer
Joined
Aug 27, 2006
Messages
12,983
Reaction score
101
Points
63
Location
Albuquerque, NM
Update pushed. Includes mrwizeman's core updates as of 8/18/13, as well as addition of MQ2MoveUtils, MQ2GMCheck, MQ2Exchange, and MQ2Twist.

htw
 

eqmacjunkie

New member
Joined
Aug 7, 2013
Messages
21
Reaction score
0
Points
0
strange, i checked for updates it updated something i cant remember, but still none of the plugins u mentioned above.


__________________


was able to fix this by uninstalling and reinstalling via loader.
 
Last edited:

eqmacjunkie

New member
Joined
Aug 7, 2013
Messages
21
Reaction score
0
Points
0
ok, as of now with the updates, game will crash upon launching if mq2moveutils is enabled.
 

Makkli

New member
Joined
Aug 9, 2013
Messages
12
Reaction score
0
Points
0
Thank you again for all the work you are doing. How far down the to do list might MQ2EQBC be? Alt Tab can kiss my ass.
 

htw

Developer
Joined
Aug 27, 2006
Messages
12,983
Reaction score
101
Points
63
Location
Albuquerque, NM
It is indeed on the list.

Patched: MQ2Map, MQ2MapWnd, MQ2MoveUtils. Update please. :D

htw
 

Aanorok

Member
Joined
Mar 15, 2010
Messages
140
Reaction score
0
Points
16
Moveutils seems to be fixed, but I cant open the map anymore. =-P

I thought it was some setting i had changed or UI problem, but I did a full reinstall back to default everything and its still not working.
 

Kilo

Premium Member
Joined
Jul 21, 2011
Messages
6
Reaction score
0
Points
1
For mq2moveutils, the breakonkb option isn't working for me. breakonmouse is working fine, however.
 

Kilo

Premium Member
Joined
Jul 21, 2011
Messages
6
Reaction score
0
Points
1
Cool features added with the compile (which are not noted):
No longer need to push stand prior to casting, camping, moving forwards etc
Auto standing when moving forward is a really nice feature. Currently, however, it only works when using the 'up arrow' key, regardless of if the 'up arrow' key is actually bound to move the character forward. Is there any way we could have the stand functionality tied to the actual move forward key-binds? (Or if it's a lot easier, could we just get a WASD option?)
 

eqmule

Developer
Joined
Jul 20, 2006
Messages
342
Reaction score
1
Points
18
I'll look into it key binds in eqmac has been a personal nightmare for me but I'll see what I can do cause I agree it should be for moving, not about a specific key being pressed.
 
Last edited:

eqmacjunkie

New member
Joined
Aug 7, 2013
Messages
21
Reaction score
0
Points
0
ok most recent update has fixed the crash issue. moveutils no longer crashes the game. stick is working as intended, makecamp also. stick behind and stick pin not working for me. may just need to set it up?

anyways anyone out there currently have some advice for where to start with a macro? i want it to /assist and /stick pulls inc to camp. possible taunt if that can be included.

also healer macro, look at MT or Charm pet health, cast a heal at a certain %. not sure if the dependencies are needed or completed for these type of macros. some general guidance is all im requesting unless someone already has a template or working macro.
 

eqmule

Developer
Joined
Jul 20, 2006
Messages
342
Reaction score
1
Points
18
speaking for myself, im not about to write any macros, there are so many different ones posted here for different scenarios (and on other sites as well macroquest2.com for example), but if you are using one that doesn't work on eqmac AND it works on LIVE, id be happy to add any missing functionality to our mq2 version for eqmac. in fact its how I expect most bugs/missing features to be found/reported, so please knock yourself out guys, download as many different macros as you can and run them and let us know which ones work.

I just ran the hunter.mac for an hour and it hunted nicely, from a programmer point of view though, there where a couple things I would do different, I might have to post that one with my changes but notably if you are running it: remove these two lines and put them somewhere before any loops so they only get called once...:
Code:
   /fastdrop on 
   /lootn never
cause they get called EVERY %^#^# time your char loots, and I can guarantee it slows your loot sub down...

Also I checked in a fix for looting so ${Corpse.Items} now return the correct number.
I expect it to be out next time htw updates the installer if it isn't already.
 
Last edited by a moderator:

eqmacjunkie

New member
Joined
Aug 7, 2013
Messages
21
Reaction score
0
Points
0
speaking for myself, im not about to write any macros, there are so many different ones posted here for different scenarios (and on other sites as well macroquest2.com for example), but if you are using one that doesn't work on eqmac AND it works on LIVE, id be happy to add any missing functionality to our mq2 version for eqmac. in fact its how I expect most bugs/missing features to be found/reported, so please knock yourself out guys, download as many different macros as you can and run them and let us know which ones work.

I just ran the hunter.mac for an hour and it hunted nicely, from a programmer point of view though, there where a couple things I would do different, I might have to post that one with my changes but notably if you are running it: remove these two lines and put them somewhere before any loops so they only get called once...:
Code:
   /fastdrop on 
   /lootn never
cause they get called EVERY %^#^# time your char loots, and I can guarantee it slows your loot sub down...

Also I checked in a fix for looting so ${Corpse.Items} now return the correct number.
I expect it to be out next time htw updates the installer if it isn't already.
thank you. i wasnt sure if the macros here worked. i noticed alot of them require other plugins.