Advanced Concepts - mq2melee, mq2events, mq2hud

PeteSampras

Your UI is fucking you. Stop using it.
Joined
Dec 12, 2007
Messages
3,956
Reaction score
49
Points
38
I always see people asking how to do some beyond the basics using holyshits/downshits or events. I thought I would share some things I use and other ideas of what could be done that would normally require a macro to do. The basics are that you need variables, and a method for those variables to change, and then what to do with those variables.

Short version: Almost anything you can do in a macro, you can do using a holy/downshit, mq2events, and your config file.

Configs files:
To automatically create these variables whenever you login to eq, you can use config files to make global variables. If you are loading multiple characters, it may be easiest just to make a single macro and create a config file that simply runs that macro when you log in to the game/zone.

Now you have your variables declared (maybe with a value, maybe not). This means you can use your variables. The most likely variables you would need are timers, integers, floating point numbers, boolean expressions, and strings just like in a macro. What can you do with these things?

Variables:
Timers - useful to space things out, keep track of time, calculate things over time
Integers - store numbers to the nearest whole number, amounts of items/npcs/pcs, etc
Float- decimal point numbers, sometimes needed to be more precise
Bools- TRUE/FALSE, YES/NO, 0/1. Either it is or it isnt.
strings-store names,phrases,keywords,spells,discs,npcs

Mq2events:
events are used that parse lines of text that show up in your eq/mq2 windows. for example: "You have been slain!" You can set up an event in mq2events_charname.ini that will /camp if you die, or send a tell to your cleric to rez you, or automatically return to bind, or many other things. The same idea applies to any other line of text it parses. Maybe it is a request for buffs or an emote that you need to respond to.

mq2melee:
mq2melee interacts with short term reuse abilities, mq2moveutils, and can trigger casting/disc of spells via mq2cast. you can configure these through specific /if statements or using downshits/holyshits depending on if you are in or out of combat. By using the additional global variables youve defined above, you can enhance your holy/downshits to do even more than before.


..and... Now what?

Well now you can do some really cool stuff that you couldnt do before, like only do certain flags if you are actively exping, create list of safe PCs to use things with, identify mobs to kill, set up burn modes to only fire when you say key phrases, cure/heal/request spells and items and much more. It is all the power of macros without using a macro.

Just show me an example already.

Ok, so say I want to self heal using a paladin heal that doesnt require me targeting myself if I am between 20 and 80% hitpoints and the spell is ready. But I only want to do this while I am exping.

Example: To self heal only in exp mode. We are using GBool1 to determine whether or not i am in exp mode.

I have to declare the variable i want to use. So either run the macro to set the initial variables in config file, or make them line by line in config file.
Code:
/declare GBool1 bool global FALSE
in game direct command:
Code:
/varset GBool1 TRUE
/varset GBool2 FALSE
optional mq2event to set up if you dont want to use direct commands:
ie. in /mq2/mq2events_PeteSampras.ini
Code:
[ExpModeOn]
trigger="#*#group, 'exp mode on'"
command=/varset GBool1 TRUE
[ExpModeOff]
trigger="#*#group, 'exp mode off'"
command=/varset GBool1 FALSE
So if i, or someone else in group says "exp mode on", then it will set that flag as TRUE and enable all the flags that go with it to now fire.

downflag to fire the heal and check my hp and only if in exp mode:
Code:
downshit1=/if (${GBool1} && ${Range.Between[2,80:${Me.PctHPs}]} && ${Me.SpellReady[SelfHeal Rk. II]}) /casting "SelfHeal Rk. II"
Optional hotkeys in game:
key 1
/g exp mode on

key 2
/g exp mode off

What if my heal isnt ready and i need one from another toon using /group chat?
Well we would want to put a timer delay in there, an event to reset the timer, and maybe a string to put the request phrase and/or character to request it from.
Declares:
Code:
/declare GTimer1 timer global 5s
/declare GString1 string global ClrHealMe
/declare GString2 string global PeteSampras
event:
Code:
trigger="#*#You tell the group, '|${GString1}|'"
command=/varset GTimer1 ${GTimer1.OriginalValue}
Flag:
Code:
downshit2=/if (${GBool1} && ${Range.Between[2,80:${Me.PctHPs}]}  && !${Me.SpellReady[SelfHeal Rk. II]} && !${GTimer1} && ${SpawnCount[${GString2}]}) /g ${GString1}
Then you can set up an event to target and heal that individual from your healer.

It can be as simple or complicated as you make it. You can automate pretty much every aspect of a macro, but you are limited to the amount of holy/downflags you can create.

You can also add the variables to your hud. So say you want to store a tank rotation, or display a timer that counts down or counts up, display your dot counters, and many many other things.

You can make your global variables be called whatever you want. I was just using GBool1 as an example to remember "global bool 1" .. for the example that i showed, i could just have easily called that /declare ExpMode bool global and use it as /varset ExpMode. Use whatever is easiest for you.

I will add a macro that declares the basics, and as people come with ideas or i get time, I can update the post to show other examples. If anyone has ideas or needs help with more advanced things, feel free to post or contribute to this thread.
 

Attachments

  • Globals.mac
    4.3 KB · Views: 48
Last edited:
  • Like
Reactions: EQDAB
Thank you Pete. I was experimenting with MQ2AdvPath and made a mod that let you execute the comments as commands. With the addition of the info you provided above you could do some very nifty stuff.
 
  • Like
Reactions: EQDAB
This is why this is the best community, hands down.
 
Possible use of the day. You want to afk with a macro running and you want to make sure it hasnt crashed. Or you want to run a macro, but on a delay.

1. Make a global timer for however long you want to delay in your config file.
Code:
/declare tGlobalTimer1 timer global 5m
2. Create a holyshit to check that your mac is still running. and if not, run it!
Code:
holyshit1=/if (${Defined[tGlobalTimer1]} && !${tGlobalTimer1} !${Macro.Name.NotEqual[your macro name.mac]}) /multiline ; /mac macro ; /varset tGlobalTimer1 ${tGlobalTimer1.OriginalValue}
3. AFK Macroers rejoice.
 
Last edited:
Advanced mq2melee

Someone stopped by IRC and asked if mq2 could auto assist and attack. I forgot how such a basic thing typically requires a macro. It occurred to me that it doesnt require a macro running at all if you use .cfg file to create some global variables So I wrote something to auto assist and auto attack based on some conditions. But while I was at it, some other basic things people want to control that are difficult to do without a macro are dots. Nukes are easy, dots notso much. So i wrote up this stuff and did some short testing and everything seemed to work. I could flesh it out more if people have other issues or ideas/goals.

Here is a method to do it using a config file/macro:

Declare your assist parameters:
Code:
/if (!${Defined[AutoAssist]}) /declare AutoAssist bool global TRUE
/if (!${Defined[AutoAssistName]}) /declare AutoAssistName string global PeteSampras
/if (!${Defined[AutoAssistDistance]}) /declare AutoAssistDistance int global 150
Now you could make a hotkey to change assist names on the fly in game:
/varset AutoAssist ${If[${AutoAssist},FALSE,TRUE]}
/varset AutoAssistName ${Target.CleanName}

Declare your attack parameters:
Code:
/if (!${Defined[AutoAttack]}) /declare AutoAttack bool global TRUE
/if (!${Defined[AutoAttackID]}) /declare AutoAttackID string global
/if (!${Defined[AutoAttackPct]}) /declare AutoAttackPct int global 97
/if (!${Defined[AutoAttackDistance]}) /declare AutoAttackDistance int global 50
Make a hotkey or two to toggle it on and off:
/varset AutoAttack ${If[${AutoAttack},FALSE,TRUE]}

Now dots are a little more complicated, and using this method you have to wait until you are loaded into the world. so either put a delay in your macro for ~30 seconds if auto launching via cfg file, or load the macro manually once in world. This will actually work for both dots and nukes/debuffs, so dont mind the naming convention.

Code:
/declare i int local
/if (!${Defined[DotMultiplier]}) /declare DotMultiplier float global 1.5
/if (!${Defined[DetSpellList]}) /declare DetSpellList string global ,2,3,4,11,
/for i 1 to 12
/if (!${Defined[${Me.Gem[${i}].ID}]}) /declare ${Me.Gem[${i}].ID} timer global ${Math.Calc[${DotMultiplier}*${Spell[${Me.Gem[${i}].ID}].Duration.Seconds}].Int}s
/if (!${Defined[${Me.Gem[${i}].ID}ID]}) /declare ${Me.Gem[${i}].ID}ID int global
/next i
Whatever spells you put on the DetSpellList will be used via downflags, regardless of nuke/dot/debuff/etc type. it will use the natural recast of the spell duration times the multiplier that you set. So you would have to do custom holyshits for certain spells with odd recasts.

Then you would make your downshits/holyshits. I will just show downshits, but you need duplicate holyshits if you use melee.


Code:
downflag0=1
downflag1=1
downflag2=1
downflag3=1
downflag4=1
downflag5=1
downflag6=1
downflag7=1
downflag8=1
downflag9=1
downflag10=1
downflag11=1
downflag12=1
downflag13=1

downshit0=/if (${SpawnCount[${AutoAssistName} radius ${AutoAssistDistance}]} && (!${Target.ID}||${Target.Type.NotEqual[NPC]})) /assist ${AutoAssistName} 
downshit1=/if ((${Target.Type.Equal[npc]}||${Target.Master.Type.Equal[npc]}) && ${Target.PctHPs}<${AutoAttackPct} && ${Target.ID}!=${AutoAttackID}) /varset AutoAttackID ${Target.ID}
downshit2=/if (${Target.ID}==${AutoAttackID} && ${Target.ID} && !${Melee.Combat} && ${AutoAttack} && ${Target.Distance}<=${AutoAttackDistance}) /attack on

downshit3=/if (${Defined[${Me.Casting.ID}ID]} && ${Target.ID} && ${Me.Casting.ID}) /varset ${Me.Casting.ID}ID ${Target.ID}
downshit4=/if (${Defined[${Me.Casting.ID}]} && ${Target.ID} && ${Me.Casting.ID}) /varset ${Me.Casting.ID} ${${Me.Casting.ID}.OriginalValue}

downshit5=/if (${DetSpellList.Find[,1,]} && (!${${Me.Gem[${i}].ID}}||${${Me.Gem[${i}].ID}ID}!=${Target.ID}) && ${Target.ID} && ${Target.ID}==${AutoAttackID}) /casting "${Me.Gem[1]}"
downshit6=/if (${DetSpellList.Find[,2,]} && (!${${Me.Gem[${i}].ID}}||${${Me.Gem[${i}].ID}ID}!=${Target.ID}) && ${Target.ID} && ${Target.ID}==${AutoAttackID}) /casting "${Me.Gem[2]}"
downshit7=/if (${DetSpellList.Find[,3,]} && (!${${Me.Gem[${i}].ID}}||${${Me.Gem[${i}].ID}ID}!=${Target.ID}) && ${Target.ID} && ${Target.ID}==${AutoAttackID}) /casting "${Me.Gem[3]}"
downshit8=/if (${DetSpellList.Find[,4,]} && (!${${Me.Gem[${i}].ID}}||${${Me.Gem[${i}].ID}ID}!=${Target.ID}) && ${Target.ID} && ${Target.ID}==${AutoAttackID}) /casting "${Me.Gem[4]}"
downshit9=/if (${DetSpellList.Find[,5,]} && (!${${Me.Gem[${i}].ID}}||${${Me.Gem[${i}].ID}ID}!=${Target.ID}) && ${Target.ID} && ${Target.ID}==${AutoAttackID}) /casting "${Me.Gem[5]}"
downshit10=/if (${DetSpellList.Find[,6,]} && (!${${Me.Gem[${i}].ID}}||${${Me.Gem[${i}].ID}ID}!=${Target.ID}) && ${Target.ID} && ${Target.ID}==${AutoAttackID}) /casting "${Me.Gem[6]}"
downshit11=/if (${DetSpellList.Find[,7,]} && (!${${Me.Gem[${i}].ID}}||${${Me.Gem[${i}].ID}ID}!=${Target.ID}) && ${Target.ID} && ${Target.ID}==${AutoAttackID}) /casting "${Me.Gem[7]}"
downshit12=/if (${DetSpellList.Find[,8,]} && (!${${Me.Gem[${i}].ID}}||${${Me.Gem[${i}].ID}ID}!=${Target.ID}) && ${Target.ID} && ${Target.ID}==${AutoAttackID}) /casting "${Me.Gem[8]}"

downshit13=/if (${Me.Pet.ID} && !${Me.Pet.Following.ID} && ${AutoAttackID}==${Target.ID} && ${Target.ID}) /pet attack
I threw a /pet attack in there for good measure.

But those are the basics. Like I said, it worked for me in limited testing, without using a macro other than to load the variables.

All code/examples are in the attached file. Feel free to post ideas/requests for automation via plugins.
 

Attachments

  • global.mac
    3.1 KB · Views: 8
MQ2 Auto assist for casters / melee

There are so many ways to do it easier...

Code:
downshit0=/if (${Target.ID}==NULL && ${Me.XTarget[1].ID}) /target id ${Me.XTarget[1].ID}
downshit1=/if (!${Me.CombatState.Equal[COMBAT]} && ${Target.PctHPs}<97) /pet attack
Those two lines start combat state for a caster, then just...

Code:
downshit2+=/if (${Me.CombatState.Equal[COMBAT]} && ${Cast.Ready[whatever]} && ${Target.PctHPs}<97) /casting "stuff" gemX | alt
For a melee...

Code:
downshit0=/if (${Target.ID}==NULL && ${Me.XTarget[1].ID}) /target id ${Me.XTarget[1].ID}
downshit1=/if (${Target.ID}==${Me.XTarget[1].ID} && !${Me.XTarget[1].ID}==NULL) /keypress 1
downshit2=/if (${Target.ID}==${Me.Pet.ID} && ${Me.Casting.ID}==NULL) /target clear
keypress 1 is my attack, lets the holyshits start. The downshit2 is for if you were auto-buffing a pet, clears it.

Code:
downshit3=/if (${Target.Type.Equal[Corpse]} && ${Me.XTarget[1].ID}) /target clear
For those times you get stuck targetting a body after the kill.

No macros needed, or .cfgs.

If you have raid or group MA defined with the standard EQ interface, substitute /assist raid (or /assist group) instead of the /target XTarget.
 
Last edited:
Oh, and DoTs...

Used old shaman.ini for example

Code:
downshit2=/if (${Me.AltAbilityReady[Malosinete]} && !${Target.Buff[Malosinete].ID}) /casting "Malosinete" alt
downshit3=/if (${Cast.Ready[Balance of Discord]} && !${Target.Buff[Balance of Discord].ID} && ${Target.Buff[Malosinete].ID}) /casting "Balance of Discord" Gem1
downshit4=/if (${Cast.Ready[Blood of Jaled'Dar Rk. II]} && !${Target.Buff[Blood of Jaled'Dar Rk. II].ID} && ${Target.Buff[Malosinete].ID}) /casting "Blood of Jaled'Dar Rk. II" Gem3
downshit5=/if (${Cast.Ready[Nectar of the Slitheren Rk. II]} && !${Target.Buff[Nectar of the Slitheren Rk. II].ID} && ${Target.Buff[Malosinete].ID}) /casting "Nectar of the Slitheren Rk. II" Gem5
downshit6=/if (${Cast.Ready[Juju Rk. II]} && !${Target.Buff[Juju Rk. II].ID} && ${Target.Buff[Malosinete].ID}) /casting "Juju Rk. II" Gem7

These take for granted that you have the leader AA for inspect buffs so you can see what's been thrown.
 
Last edited:
So I had been working on making a lite version of bot.mac several months ago before scrapping it. The gist was to take your already made INI and allow it to preload via cfg or whatever and then use a combo of mq2melee/minimalist macro to function. Some things just absolutely require a macro to do effectively. But you can get a 95% solution without.

Here is an example of how to use an INI into your down/holyshits. I will use the bot.mac INI as example.

Relevant section:
Code:
[Dot]
DotTotal=${If[${Group}>2,3,6]}
DotTotalIfNamed=${If[${Raid.Members},11,6]}
ForceMemDot=TRUE
DotAnnounce=FALSE

DotUse1=TRUE
DotSpellName1=Osalur's Flashblaze
DotSpellGem1=gem4
DotUseAtMobPctHP1=99
DotStopAtMobPctHP1=5
DotRecast1=1s
DotMaxTries1=2
DotConditions1=((!${DebuffUse1}||${Debuff1${Target.ID}}||!${Me.AltAbilityReady[Death's Malaise]} && ${Me.GemTimer[${NukeSpellName1}]}||${Me.GemTimer[${NukeSpellName1}]} && !${Target.Body.Name.NotEqual[undead]}) && (!${Me.Song[Deathly Resolve].ID} && (${Target.Named}||${Target.Name.Find[#]}||${Target.PctHPs}>20)))

DotUse2=TRUE
DotSpellName2=Itkari's Swift Lifedraw
DotSpellGem2=gem3
DotUseAtMobPctHP2=99
DotStopAtMobPctHP2=5
DotRecast2=1s
DotMaxTries2=2
DotConditions2=((!${DebuffUse1}||${Debuff1${Target.ID}}||!${Me.AltAbilityReady[Death's Malaise]} && ${Me.GemTimer[${NukeSpellName1}]}||${Me.GemTimer[${NukeSpellName1}]} && !${Target.Body.Name.NotEqual[undead]}) && (!${Me.Song[Deathly Resolve].ID} && (${Target.Named}||${Target.Name.Find[#]}||${Target.PctHPs}>20)))

DotUse3=TRUE
DotSpellName3=Bora's Swift Sickness
DotSpellGem3=gem2
DotUseAtMobPctHP3=99
DotStopAtMobPctHP3=5
DotRecast3=1s
DotMaxTries3=2
DotConditions3=((!${DebuffUse1}||${Debuff1${Target.ID}}||!${Me.AltAbilityReady[Death's Malaise]} && ${Me.GemTimer[${NukeSpellName1}]}||${Me.GemTimer[${NukeSpellName1}]} && !${Target.Body.Name.NotEqual[undead]}) && (!${Me.Song[Deathly Resolve].ID} && (${Target.Named}||${Target.Name.Find[#]}||${Target.PctHPs}>20)))

DotUse4=TRUE
DotSpellName4=Pyre of Marnek
DotSpellGem4=gem12
DotUseAtMobPctHP4=98
DotStopAtMobPctHP4=30
DotRecast4=300s
DotMaxTries4=2
DotConditions4=((!${DebuffUse1}||${Debuff1${Target.ID}}||!${Me.AltAbilityReady[Death's Malaise]} && ${Me.GemTimer[${NukeSpellName1}]}) && (!${Me.Buff[Gift of Deathly Resolve].ID} && (${Target.Named}||${Target.Name.Find[#]}||${Target.PctHPs}>30))||${Me.Song[Deathly Resolve].ID})

DotUse5=TRUE
DotSpellName5=Termination
DotSpellGem5=gem12
DotUseAtMobPctHP5=98
DotStopAtMobPctHP5=10
DotRecast5=300s
DotMaxTries5=2
DotConditions5=((!${Me.Buff[Gift of Deathly Resolve].ID} && (${Target.Named}||${Target.Name.Find[#]}||${Target.PctHPs}>30))||${Me.Song[Deathly Resolve].ID})

DotUse6=TRUE
DotSpellName6=Ignite Thoughts
DotSpellGem6=gem12
DotUseAtMobPctHP6=98
DotStopAtMobPctHP6=20
DotRecast6=300s
DotMaxTries6=2
DotConditions6=((!${DebuffUse1}||${Debuff1${Target.ID}}||!${Me.AltAbilityReady[Death's Malaise]} && ${Me.GemTimer[${NukeSpellName1}]}) && (!${Me.Buff[Gift of Deathly Resolve].ID} && (${Target.Named}||${Target.Name.Find[#]}||${Target.PctHPs}>30))||${Me.Song[Deathly Resolve].ID})
Now, I dont use 100% of that entry, but I pull most of it.

Relevant macro/cfg:
Code:
#define MyIni Bot_${Me.CleanName}_${Me.Class}.ini
#turbo 500
Sub Main

|Spell related
/if (!${Defined[AutoCast]}) /declare AutoCast bool global FALSE

/if (${Defined[ValidCast]}) /deletevar ValidCast
/noparse /declare ValidCast string global (${AutoCast} && !${Me.Casting.ID} && ${Target.Distance}<${AutoAssistDistance} && ${Target.LineOfSight} && ${Target.ID} && ${Target.ID}==${AutoAttackID})


/declare SectionList string outer Dot,Nuke,Aura
|                1    2    3    4    5        6    7    8    9    10    11
/declare KeyList string outer Use,SpellName,SpellGem,Name,UseAtMobPctHP,StopAtMobPctHP,Recast,SpellIcon,UseAt,StopAt,UseAtMyHP,
|                   1    2    3    4    5     6    7    8       9   10  11
/declare KeyListType string outer bool,string,string,string,int,int,string,string,int,int,int,


/call IniLoad Dot 1|2|3|5|6|7|
/call IniLoad Nuke 1|2|3|5|6|7|
/call IniLoad Aura 1|2|3|4|8|
/return


Sub IniLoad(section,keys)
/declare i int local
/declare x int local
/if (!${Defined[${section}Total]}) /declare ${section}Total int global 
/varset ${section}Total ${Ini[MyIni,${section},${section}Total,0]}
/if (!${${section}Total}) /return
/if (!${Defined[Current${section}]}) /declare Current${section} int global
/for i 1 to ${${section}Total}
    /for x 1 to ${keys.Count[|]}
        /if (!${Defined[${section}${KeyList.Arg[${keys.Arg[${x},|]},,]}${i}]}) /declare ${section}${KeyList.Arg[${keys.Arg[${x},|]},,]}${i} ${KeyListType.Arg[${keys.Arg[${x},|]},,]} global 
        /varset ${section}${KeyList.Arg[${keys.Arg[${x},|]},,]}${i} ${Ini[MyIni,${section},${section}${KeyList.Arg[${keys.Arg[${x},|]},,]}${i}]}
    /next x
/if (!${Defined[${section}RecastTimer${i}]}) /declare ${section}RecastTimer${i} timer global
/if (!${Defined[${section}LastID${i}]}) /declare ${section}LastID${i} int global
/next i
/return
That mac loads the Dot, Nuke, and Aura sections with the designated variables. Just focused on [Dot] section atm for example.

Now onto the mq2melee portion, in /mq2/server_name.ini:
I need something to check for and cast the spell, and I need something to cycle through the dots unless I want to make them all 1 by 1. No thanks to that!
Code:
downshit3=/if (${AutoCast} && !${Me.Casting.ID} && ${DotUse${CurrentDot}} && ${Me.SpellReady[${DotSpellName${CurrentDot}}]} && ${ValidCast} && ${Target.PctHPs}<=${DotUseAtMobPctHP${CurrentDot}} && (!${DotRecastTimer${CurrentDot}}||${DotLastID${CurrentDot}}!=${Target.ID}) && (${DotConditions${CurrentDot}}||!${Defined[DotConditions${CurrentDot}]})) /echo CastSpell Dot ${CurrentDot} ${Target.ID}
downshit4=/varset CurrentDot ${If[${CurrentDot}>=${DotTotal},1,${Math.Calc[${CurrentDot}+1]}]}
Now that launches an event to cast the spell and set a bunch of variables. I am doing an echo for the event name, the section, the number, and the desired target.
/echo CastSpell Dot 3 1234 = will cast [Dot] DotSpellName3 on Target.ID 1234

This is so you can use heals with the same function.

Here is the event that goes into /mq2/mq2events_name.ini
Code:
[CastSpell]
trigger=#*#CastSpell #1# #2# #3#
command=/multiline ; /if (${EventArg3}) /squelch /tar id ${EventArg3} /timed 3 ; /cast ${${EventArg1}SpellGem${EventArg2}.Replace[gem,]} ; /varset ${EventArg1}RecastTimer${EventArg2} ${${EventArg1}Recast${EventArg2}} ; /varset ${EventArg1}LastID${EventArg2} ${Target.ID}
And that is it. After that, I could hardcode in some additional conditions that were ignored in the INI by adding in some /noparse declares in the global/cfg load file.

Code:
/noparse /declare DotConditions1 string global ((!${Me.AltAbilityReady[Death's  Malaise]} &&  ${Me.GemTimer[${NukeSpellName1}]}||${Me.GemTimer[${NukeSpellName1}]}  && !${Target.Body.Name.NotEqual[undead]}) &&  (!${Me.Song[Deathly Resolve].ID} &&  (${Target.Named}||${Target.Name.Find[#]}||${Target.PctHPs}>20)))
I tested this in game for a few mobs, and once again, everything seemed to work as intended. Let me reiterate that using this ghetto version is nowhere near as efficient as what a macro can do, but it should be a lot less resources used and also free you up from using macros.

I can turn it on and off by /varset AutoCast TRUE/FALSE. or a hotkey:
Code:
/varset AutoCast ${If[${AutoCast},FALSE,TRUE]}
 

Attachments

  • global.mac
    4.8 KB · Views: 8
Last edited:
  • Love
Reactions: EQDAB