More Intelligent Macros (Macro QoL)

[jumpsplat120]

Macros are neat, but limited in scope, which makes them only usable in minimal situations. This is sort of a collation of a few different ideas I have for macros that I think would increase their functionality.

1. Cleaner pattern syntax: Right now, macro's are awkward to write due to the method of needing to escape brackets. I'm unsure if macro's use regex to determine replacements or something along those lines, but overall a more effective expression/a change in how macro's are parsed would make the experience of writing them easier. My suggestion is to use something like the pattern in template literals, where, instead of {0}, you'd instead do ${0}. This would differentiate the replacement from regular paired brackets, which are pretty much always used in hackmud, and therefore always need escaping.
2. Macro everything: Macro's can only run scripts, and they can only run full script names. This means I can't macro #up my_script public shift, for example. It also means I can't macro my_script { arg:true }. but instead must macro my_user.my_script { arg:true }. These restrictions seem wholly unnecessary, and only limit the power of a macro.
3. Macro multiple things: Macro's run a single script at a time. Thing is, the things I do repetitively often have more than 1 step involved. If a macro could run multiple commands, one after another, I think they'd explode in usefulness. Recently, I was testing something that involved upping a script on userA, running a script to save the new data to the DB, swapping over to userB, then running another script to see the result. If I could've saved all of these steps to a macro, it would've made my life 10x easier. My proposal for adding a new line to a macro is to do something like /my_macro += my_user.my_script { arg:true }. The += syntax should be familiar to script writers, and so should be relatively easy to understand and use for players.
4. Macros running macros: Simple as. Macros can't currently run other macros. I think they should. Especially with the ability to run multiple lines at the same time, the usefulness of a feature can't be understated.
5. Auto macros: You can't auto a macro. I'd like to be able to auto a macro. Right now I have to run the macro, then copy paste the line that actually ran, then auto that.
6. Patterns in patterns: I'd love to be able to put a pattern in a pattern. I imagine it's nearly impossible to differentiate with the current pattern method (double escaping brackets looks similar to one pattern containing another). But if the first proposal is implemented, then I imagine it might be easier to implement this one. I'd love to be able to add a feature like /vol = gui.vol { bgm:${0=5}, sfx:${1=${0=5}} }. If I ran /vol, it sets both parameters to 5, and if I ran /vol 10, it'd set both to 10. If I run /vol 0 10, then it sets the background music to 0, and the sound effects to 10. Being able to set the value of 1 match as the value of another could be really powerful.
7. Named patterns: I'm not saying I want to get rid of numeric matches, but a way to match by name would be nice as well. If I have /macro my_user.my_script { arg1:${0="foo"}, arg2:${1="bar"}, arg3:${2="baz"}, arg4:${3="quux"} } and I want to set just arg4, I'm forced to also set args 1, 2, and 3. I can't use the default values, which means I have to type them in manually, which makes them useless. While I could change the order of the matches to have the most likely one be 0, and the second most likely be 1 and so on, this is still not helpful if there's no clear "most likely" to have first (and changing the order can be confusing as well, if you interpret your k/v pairs always in the same order). Instead, having the ability to name a pattern; /macro = my_user.my_script { my_long_arg_name:${long="foo"}, other_arg:${other="bar"} }, to be called like /macro other="baz". They can also be used in conjunction with indexed patterns, where /macro "foo" arg=1 "bar" would set 0 to "foo" and 1 to "bar", and arg to 1. Effectively, each unnamed value passed gets sent to it's corresponding numerical pattern.

I know that's a lot of stuff; it's my thoughts over nearly the entire time I've been playing! Even if you could only do 1 or 2 of these, I still think there'd be a lot of value in them. Thanks for taking the time to read the request!