From Mudlet
Jump to navigation Jump to search

From Nexus

Trigger patterns
Lets start with triggers. For translating Nexus patterns into Mudlet, use the following table below. Make sure to set the pattern type in Mudlet to be perl regex, because the default substring works differently.

Mudlet Nexus What it does
(\w+) {w} Match one or more non-whitespace characters (a 'word')
(\d+) {d} Match one or more numeric digits (a number)
([abc]) {[abc]} Match one or more of either 'a', 'b' or 'c'. (a character class)
([^abc]) {[^abc]} Match one or more of anything EXCEPT 'a', 'b', or 'c'
(.*) {*} Match zero or more characters (anything)
^ {<} Match the beginning of a line (not the actual newline character)
$ {>} Match the end of a line (not the actual newline character)
If you just have a pattern with a {<} and {>} and nothing else, copy the pattern over without the {<}{>} and select the exact match pattern type. For example {<}You sit down.{>} in Nexus would become You sit down. in Mudlet with the pattern type of exact match. This is easier to read and matches way faster!

Basic scripting
The Nexus way of doing a function is like this: #function stuff it does. In Mudlet, it’s function(stuff it does). Note that if you’d like to give text to a function, you put it inside double or single quotes.

Calling functions

Calling functions
Mudlet Nexus
echo("Hello to me!")

#send hi
#echo Hello to me!


If you’d like to use a variable inside text, you’d put it outside the quotes and glue it together with two dots.

Setting variables

Setting variables
Mudlet Nexus
number = 1234
echo("My number is: " .. number.. "\n")
echo("the " .. number .. " is in the middle of my text\n")
echo(string.format("And here's another - %s - way to format things\n", number))

#set number 1234
#echo My number is: $number
#echo the $number is in the middle of my text

To use the wildcard variable in Nexus, you’d use $1 for the first match, $2 for the second and so on. In Mudlet, the matches[] table contains the matches - and it starts placing the matches from 2. So the Nexus $1 would be matches[2], $2 would be matches[3].
Mudlet Nexus
(\w+) kicks you\.
badguy = matches[2]
echo(badguy .. " kicked me!")

{w} kicks you.
#set badguy $1
#echo $badguy kicked me!

alias pattern: ^t (.*)$
alias script: target = matches[2]

alias name: t
alias script: #set target $1


The reason the first match goes into matches[2] and not matches[1] is because matches[1] contains the part of the line that matched your trigger / alias.

In Nexus, a #wait will freeze the script while it’s executing - such that commands after it are delayed. In Mudlet, we use tempTimer which that works a bit differently - it doesn’t freeze the script, but instead makes it so commands a tempTimer is asked to do will get done in the future. So the difference is that a tempTimer doesn’t freeze the commands following it at all, everything gets done at once as usual. Just things a tempTimer was asked to do get done in the future.
Mudlet Nexus
tempTimer(1, [[send("hi")]])
tempTimer(1.5, [[send("bye")]])

#send hello
#wait 1000
#send hi
#wait 500
#send bye

ifs in Mudlet
Next are the #if statements. Here’s a table comparing the syntaxes of Nexus and Mudlet:

Mudlet Nexus

if <condition> then <text> end

#if <condition> <text> #if <condition> { <script> }

if <condition> then <script> else <script> end

#if <condition> { <script> } else { <script> } #if <condition> { <script> } { <script> }

if <condition> then <script> elseif <condition> then <script> end

#if <condition> { <script> } elsif <condition> { <script> }

if <condition> then <script> elseif <condition> then <script> else <script> end

#if <condition> { <script> } elsif <condition> { <script> } else { <script> }

Here is the sample side-by-side comparison of how you’d use it:

Mudlet Nexus
-- If foo is true, echo that fact.
  if foo then echo ("Foo is true!") end -- If foo is true, echo that fact.

-- A slight modification of the above that illustrates an 'else' clause.
-- Note that the 'then' is always necessary to avoid confusion.
  if foo then echo ("Foo is true!") else echo ("Foo is false!") end

-- Illustration of putting more than one statement in a block (also
-- spans lines here). Note the if doesn't end until the last 'end' is
-- encountered.
-- We also add a \n at the end of multiple echos so each one is on it's own line.
  if foo then
    echo ("Foo is true!\n")
    echo ("Isn't it grand?\n")
    echo ("These commands are all on separate lines too!\n")

-- This shows how ifs continue (on 'logical' lines) even though the
-- blocks in its constituent clauses may have multiple lines. The
-- following lines are all _one_ single if statement.
  if foo > 50 then
    echo ("Foo is big!\nYes it is.")
  elseif foo > 10 then
    echo ("Foo is pretty big...\n")
    echo ("I've seen bigger.")
    echo ("Foo is actually kind of small.")

-- Ifs can be nested too.
  if foo then
    if bar then
      echo ("Both foo and bar are true.")
      echo ("Foo's true, but bar isn't.")

// If $foo is true, echo that fact.

 #if $foo #echo Foo is true!     // If $foo is true, echo that fact.

// A slight modification of the above that illustrates an 'else' clause.
// The second form shows that the word 'else' is actually optional too.
// (The two lines are functionally the same.)

 #if $foo { #echo Foo is true! } else { #echo Foo is false! }
 #if $foo { #echo Foo is true! } { #echo Foo is false! }

// Illustration of putting more than one statement in a block (also
// spans lines here). Note the if doesn't end until the last '}' is
// encountered.

 #if $foo {
   #echo Foo is true!
   #echo Isn't it grand?
   #echo These commands are all on separate lines too!

// This shows how ifs continue (on 'logical' lines) even though the
// blocks in its constituent clauses may have multiple lines. The
// following lines are all _one_ single if statement.

 #if $foo > 50 {
   #echo Foo is big!
   #echo Yes it is.
 } elsif $foo > 10 {
   #echo Foo is pretty big...
   #echo I've seen bigger.
 } else {
   #echo Foo is actually kind of small.

// Ifs can be nested too.

 #if $foo {
   #if $bar {
     #echo Both foo and bar are true.
   } else {
     #echo Foo's true, but bar isn't.

Mudlet equivalents of Nexus functions

Now that we got the ifs covered, lets go over the Mudlet equivalents of other Nexus functions. Note that this is a direct Nexus→Mudlet comparison; certain functions in Mudlet have much more capability.

Mudlet Nexus
<variable name> = "<text value>" #set <variable name> <text value>
<variable name> = <expression> #set <variable name> = <expression>
<variable name> = nil #unset <variable name>
<variable> = <variablename> <+ - / *> <number or variable> #add <variablename> <expression>
echo "text\n" or echo("text\n") #echo <text>
echo "text" or echo("text") #echo_ <text>
enableAlias("<group name>")/enableTrigger()/enableKey()/enableTimer() #groupon <group name>
disableAlias("<group name>")disableTrigger()disableKey()disableTimer() #groupoff <group name>
selectString (line, 1) bg("<color>") resetFormat() #highlight <color>
deleteLine() #gag
openUrl("<url>") #openurl <url>
send("<stuff>") #send <text>
sendAll("hi", "hello", "bye") #send_ hi #send_ hello #send bye
tempTimer(<time in s>, [[ <lua code to do once time is up> ]]) #wait <milliseconds>

How to call aliases in Mudlet
The typical workflow in Nexus is that you’d define the aliases for yourself to use, and also use aliases for system-related things (things like checking if you’d need to eat a herb, etc).

While the first use is good, the second isn’t - because the user can also run this alias at an inopportune time, because if you want to call an alias it has to match all alises again, and so on.

Now, while in Mudlet you can call another alias with the expandAlias() function, this is strongly discouraged. What you do instead if create a function (for example, send() and echo() are functions) that you can then call from your alias or trigger. This has many advantages - it’s faster, you can easily give your function values, and your function can return you values, too.

To make a function, you go to the Scripts section, create a new script, and write in your function:

  function <name> ()
    <stuff it does>

For example, if we want to make a function that does two things for us at once, we’d do this:

  function eat_bloodroot()
    send ("outr bloodroot")
    send ("eat bloodroot")

Then just do this in our alias or trigger to outr and eat bloodroot:


As mentioned, you can also give things to functions - in this case lets expand the function to eat any herb for us we tell it:

  function eat (what)
    send ("outr " .. what)
    send ("eat " .. what)
  eat ("bloodroot")
  eat ("kelp")
  eat ("ginseng")

Lastly, functions can also give you data back. One useful example for this is to break down tasks into functions, which will help your code readability:

  function can_i_stand()
    if not paralyzed and not prone and not stunned then
      return true
      return false
  if can_i_stand() and have_balance and have_equilibrium then
    send ("stand")

Notes to be aware of

To finish off, a couple of points that should be remembered:

  • Mudlet does profile snapshots (nexus archives) automatically - to load a different one, select it from the list when connecting
  • Mudlet can import and export xml
  • Mudlet and Nexus xml formats aren’t compatible
  • Mudlet can do nexus graphics, here is a package for - Achaea, Lusternia
  • Mudlet has a ton more features such as more speed, less bugs, copy from the normal window, replay logging, color html logging, more powerful scripting, and the list goes on.

From MUSHclient

  • Mudlet doesn't use %#'s - uses matches[] instead. "%1" or %1 would be matches[2], "%2" or %2 would be matches[3] and so on
  • No variables in trigger patterns - but you can check against your variables in scripts, or lua function pattern types
  • Send() in MUSHclient is called send() with a lower S in Mudlet - in Lua, capitalization matters! To send a command without echoing it on the screen, use:
send("my text", false)
  • While MUSHclient uses AnsiNote to write colorful text, Mudlet offers different ways as well: cecho() works with the name of a color. You can find lots of predefined colors with showColors(). You can also style foreground and background seperately with fg() and bg(). To keep your original ANSI colors, use ansi2decho(). If you need more colors, decho() will take rgb numbers, hecho() uses hex codes.
  • Mudlet does not offer 'GetConnectDuration()' or 'isConnected' but you could create a script to connect to the connection event (and maybe sysDisconnectionEvent) and in that function start a stopwatch to keep count of how long you've been connected for. See Manual:Event Engine on how to use events in Mudlet.
  • Mudlet does not have lpeg built-in but you can include the lpeg library installed on your system in your lua code. On Windows, you can choose to put the lpeg.dll file into Mudlet's install folder if that's simpler for you.
  • If you used OnPluginPartialLine to match "partial lines" such as prompts, please note that any type of Mudlet triggers should work with such lines so you can just use them for your purpose. For prompts specifically, try tempPromptTrigger.
  • If you used OnPluginTick, you can use a GUI timer in Mudlet for essentially the same functionality.
  • If you used OnPluginCommandEntered, you can use a "catch all" alias (with a pattern like "^.+") to send all user commands to your script.
  • If you have an existing database you'd like to use and don't want to put it into the profile folder, you can use the standard luaSQL interface to load and use it. Some basic examples can be found at

Converting MUSHclient triggers into Mudlet triggers

The following scripts by Discord user Buck allow you to paste a MUSHclient trigger and automatically have a corresponding Mudlet trigger created.

First, create a new script with this:

TRIGGER_GROUP_NAME = "mushtriggers"

function getAvailableMushTriggerID()
  local n=1

  while exists( MUSHTRIGGER_PREFIX..tostring( n), 'trigger')>0 do

  return MUSHTRIGGER_PREFIX..tostring( n)

function addMushTrigger( pattern, actions)
  pattern = string.gsub( pattern, '%.', '\\.')
  pattern = string.gsub( pattern, '*', '(.+)')
  actions_regex = string.gsub( actions, '%%(%d)', function(x) return ']]..matches['..tostring(x+1)..']..[[' end)

  local id = getAvailableMushTriggerID()

  createTriggerGroup( TRIGGER_GROUP_NAME)
    'for _, cmd in ipairs( splitCommands( [['..actions_regex..']])) do expandAlias( cmd) end')

Also create an alias with this:

-- ^/trigger '([^']+)' (.+)$
local pattern = matches[2]
local actions = matches[3]

addMushTrigger(pattern, actions)

cecho("<green>New trigger added")

Now you can transfer your MUSH triggers like so:

/trigger 'A wild * enters the room' hit %1 

/trigger '%d/%dhp %d/%dmn' /checkhealth %1


Changing over to Mudlet requires learning some simple syntax changes and some general concept changes:

In a mudlet trigger for example: Name is just the name you want to use to label the trigger. It doesn't effect the actual firing of the trigger. The trigger fires based on the "pattern" and you can have multiple patterns for a single piece of code. You can also have a multi-line trigger, where the entire trigger must see all the patterns to fire. Example #1 - Using a variable and a temp trigger Cmud:

^A (.*) shard appears and clatters to the ground\.$

#IF (@autogold) {
#temp {You have recovered balance on all limbs.} 
{get shard}

Mudlet Example:

^A (.*) shard appears and clatters to the ground\.$

if autogold then
shardtrigger = tempTrigger("You have recovered balance on all limbs.", [[send("get shard") killTrigger(shardtrigger)]])

Example #2 - Doing Math: Cmud:

^You put (\d+) gold sovereigns in (.*)\.$

#ADD goldcounter %1


^You put (\d+) gold sovereigns in (.*)\.$

goldcounter = goldcounter + tonumber(matches[2])

Example #3 - Replacing Text Cmud

^You raze (\w+) magical shield with (.*)\.$

#sub {%ansi(yellow,cyan,bold)(*X*)%ansi(white) RAZED %ansi(red)%1's %ansi(white)Shield %ansi(yellow,cyan,bold)(*X*)}


^You raze (\w+) magical shield with (.*)\.$

cecho("<yellow:cyan>You RAZED " .. matches[2] .. " shield")

Example #4 - Enable/Disable Classes


#T+ ClassFolderName



-- Note: Alias can be an alias, trigger (enableTrigger), timer (enableTimer), key (enableKey), etc. 
-- You can disable entire classes or just single triggers.

Example 5 - Multi-action Commands Let's say we create an alias called silly



look;ct Hello City;pt Hello Party;laugh

-- Now in cmud if we called this alias from a trigger or another alias,
-- we would just call sillyAction



sendAll("look","ct Hello City","pt Hello Party", "laugh")

-- Now, in mudlet, if we want to call on that alias, we need to tell mudlet that we want to execute the alias sillyAction rather than sending "sillyAction" directly to the mud. To do that we would do:


Example 6 - Using if statements with and, or and nil.

Cmud Code:

#IF (@myclass="knight" & !(@pets))
say cool

Mudlet Code:

if myclass == "knight" and not pets then
  send("say cool")

Example 7 - Hitting your target OR your first argument. This is for when you want to either hit the person you have targeted, or the name you type.

For example, to kick Das you'd type: kk Das

Or if Das is your target, just typing kk


Pattern: ^kk ?(\w+)?$
#VAR target Das
if (@target) {
kick @target
if (%1) {
kick %1


^kk ?(\w+)?$

target = "Das"
send("kick "..(matches[2] or target))

Example #7 - Two Pattern Examples

-- This would let you do rzDas to raze Das for example.


^rz ?(\w+)?$ 
-- This would require you to do rz Das with a space between rz and Das.

Example #8 - Repeat Commands a number of times i.e., #12 kill bug

--Pattern: ^\#(\d+)\s(.+)$
for i=1, tonumber(matches[2]), 1 do

From zMUD

Pretty similar to CMUD - see above.