So, you are going to need a number of different things set up to make this work.
First, you are going to need a script, with which everything else will interact (I like to put all the real code in scripts so you can make changes centrally, without having to find little bits in triggers and aliases and such). The script will have all of the functions that I mention later on, and it will also be used to maintain your list of targets, as a table. I'll put together some example code for that toward the bottom of the post.
Second, you will need a trigger that will look for the presence of potential enemies in the room. I don't know exactly how your particular MUD signifies that, but it might have a pattern that looks something like this:
^[aA]n? ([\w\s]+) is here.$
The ^ signifies the beginning of a line of text, and the $ signifies the end. The square brackets group things together into a "class" of characters, any of which can be matched by that position (so the [aA] will match either 'a' or 'A'), the ? means that the preceding character is optional (so there can be a 'n' or no 'n'), and \w signifies a "word" character (letters, numbers, and underscores), and \s signifies a "white space" character, spaces, tabs, etc., and the + means one or more of the preceding characters (so [\w\s]+ will match any number of word and white space characters in a row, up until capturing more will make the pattern not match any more). The parentheses signify a "capture group", which means that whatever is inside them will be available to reference with your code.
The trigger will then call a function, and pass the captured name of whatever enemy to that function for it to do something with. This function will be in the script mentioned above, and we are going to call it: check_enemy. The trigger's code will look like this: check_enemy(matches[2])
That will call the function, and pass along the second match for the trigger (the first match is always the entire text matching the trigger pattern, which in this case would be the whole line).
Then you will need an alias, that will let you capture the names of enemies that you attack, and store in your list. The pattern will look something like this: ^attack (\w+)$
Note that you can change the 'attack' portion to be whatever you want, like 'k' or 'aa', or whatever.
The alias will then call a function we will call: attack_enemy. The alias's code will look like this: attack_enemy(matches[2])
And then you need a key/macro, bound to F1, and it will call a function that we will call next_enemy. And its code will look like this: next_enemy()
Note that you MUST have the parentheses after the function name, even if you aren't giving it any arguments.
And then you need a trigger that will tell your script to clear the list of enemies it sees in the room, so that as you move around, it doesn't continue to think that the enemies in the first room are in the second room, etc. Generally, the easiest thing to trigger off of here is the line that shows the exits in the room you are walking into/looking at. Since you don't need to actually know what the exits are, you can just trigger off the beginning of the line. In the game I play, that line looks like this: [Exits: east west north south]
So, to capture that, I would use a pattern like this: ^\[Exits:
Note the backslash before the square bracket. Any character that would normally have special meaning in a trigger pattern should have a backslash before it to "escape" it, so that the pattern looks for that character, instead of interpreting it in the normal way it is used.
Your exits trigger will then call a function we will call: reset_enemies. And its code will look like this: reset_enemies()
Here is some quickly thrown together code to help fill in the blanks, and get things going for you. Note that I haven't tested this, so there might be typos and bugs and such that I failed to catch.
local my_enemies = my_enemies or {} -- creates a table to store enemies to attack
local enemies_here = {} -- creates a table to store enemies in the room
local enemy_index = 0 -- creates a variable to store the table index you are on
function check_enemy(enemy)
for k,v in ipairs(my_enemies) do -- goes through all known enemies, one at a time
if string.find(enemy,v) then -- looks for the name of an enemy anywhere in the captured text
table.insert(enemies_here,v) -- stores the name of an enemy in the enemies_here list
break -- stops the loop, since each any should only be listed once
end
end
end
function attack_enemy(enemy)
if not table.contains(my_enemies,enemy) then -- checks to make sure the enemy isn't already in the list
table.insert(my_enemies,enemy) -- adds the enemy to the list
end
send("attack " .. enemy) -- sends the actual command to attack the enemy
end
function next_enemy()
enemy_index = (enemy_index or 0) + 1 -- increases the index used in the list of current enemies, so each press will attack the next enemy, in turn
if not enemies_here[enemy_index] then -- checks if there are no more enemies in the list
enemy_index = 1 -- starts over at the beginning
end
send("attack " .. enemies_here[enemy_index]) -- sends the actual command to attack the enemy
end
function reset_enemies()
enemy_index = 0 -- resets the enemy index used by next_enemy
enemies_here = {} -- clears the list of enemies in the room
end
If you have questions about what I did or why, I'd be happy to explain, just try to ask specific questions so I can give clear answers.
