We started a discussion there: #13 (comment)
But it should warrant a discussion of its own and not meddle with producing that very video.

So I found other tools like https://hackmd.io/ for example.
They support markdown and git, login via github, so to me feels more inclined to Mudlet infrastructure than google docs.
What do you think? Got other tools or experience to share?

Need to review https://www.mudlet.org/media/ eventually

Script

first one recorded, had no script.

Link

https://youtu.be/ZYRPZ-8fJWA

Most videos on Mudlet channel currently seem identical and are only distinguishable by reading the video title.

I suggest to put some differentiating item in the thumbnail pictures, while keeping it mostly the same.
This will serve two purposes:

1. The players recognize the video is part of a longer series
2. The players recognize the very video's topic more quickly

While playing around with the idea, I wonder which font we used for the Youtube header image? Did not find in other repo either.

See the latest video thumbnails at the bottom, most (but not all) look just the same.

(They also seem to have a wrong aspect ratio and cut off the top and bottom of the arch alright)

Here is a preliminary mockup how that could look like. I put the wrong font but hey.

If we were to publish another video on triggers, it could gain a second line below and say "Triggers # 2" or alike.

Here's another list I made of all currently published videos in the series, and their short caption for the thumbnail:

1. Scripts: Basic Scripts
2. Windows: Download And Install Mudlet for Windows
3. Linux: Download And Install Mudlet for Linux
4. MacOS: Download And Install Mudlet for MacOS
5. Keys: Keybindings (Keyboard Macros)
6. RegEx: Basic Regular Expressions
7. Aliases: Basic Aliases
8. Triggers: Basic Substring Triggers
9. Profiles: Profile Selection Screen Tour

Script

Hello,

In this tutorial we will be going over the basics of regular expressions. Regular expressions are use repeatedly for triggers and aliases, so I felt it important to cover this topic before those.

This website is regex101.com, and is my favorite website for creating and testing regular expression patterns. It breaks your pattern down and allows you to test it against one or more test strings. It also has a nice reference for what the different wild cards and symbols mean within a regular expression. Mudlet uses the PCRE regular expression engine, so you'll want to select PCRE over here on the left.

In a nutshell, regular expressions allow you to match text which changes, and capture information out of them. For instance, if your game sends "A goblin falls over dead." like so, you can match it with "A (.+) falls over dead". Putting it in parentheses tells it you want to capture that information. Which is why it is called a "capture group". the dot is a wildcard which can stand in for anything, and the + tells it to match one or more. So in "A goblin falls over dead" the first capture group would be "goblin".

This is a very simple way to capture things, but where possible you should try to be more specific. If all mob names are letters or numbers only, you could instead use (\w+) here. \d is used in place of number, and can be used to match something like "You have 100038 gold on you" with "You have (\d+) gold on you". If the number might have a , in it, then you would instead want to use ([\d,]+) The brackets allow you to define your own groups how you want, in this case we add the comma to \d so it will catch any number of digits or commas. \s will match whitespace characters such as spaces or tabs. And it's often good to use the ^ (caret) to anchor to the beginning of the string, so your trigger doesn't match if the text appears in a room description or comes up during conversation. In a similar vein, $ matches the end of the string.

I'll put a link in the description to regex101, and we'll have a future video on more advanced regular expression usage, but these are the basics you'll run into the most while making aliases and triggers using regular expressions.

In today's video, we went over the basics of regular expressions, what they are, and how to use them, and I shared with you my personal favorite site for creating and testing regular expressions. In future videos, we will use this knowledge to create aliases and triggers in order to have Mudlet help you with the interactions between you and your game.

I hope this video was informative and helpful, and I look forward to creating and sharing the next one with you all. Until then, happing MUDding.

Link

https://youtu.be/KFoax1Q0ltw

Script

Hello,

In this tutorial we will be going over creating basic scripts for Mudlet. Mudlet uses Lua for its scripting. Lua is a light weight and speedy scripting language well suited for embedding in other programs.

Specifically, I will be covering how to create a script in Mudlet, how to write a function to group repeated actions together, and how to pass information into functions.

So let's get started by clicking on scripts to bring up the script editor. Then we will click on Add Group to create a folder to organize our scripts in. You can put code in these if you like, but I primarily use them to keep things tidy and organized in my script editor. I'll just name this 'Tutorial Scripts' or something obvious, and then we'll click on Save Item.

Then when we click on Add Item it will create the new script object inside of the folder we just created. Let's just give this a name and then save it. Now over here on the left, you can use the dropdown marker to show or hide the scripts in this group, which can make it a lot easier when browsing through things later.

Ok, over here on the right I just want to acknowledge the existence of the "Registered Event Handlers" and "Add User Event Handler" sections. These are used for dealing with events, which are a Mudlet feature which will get their own video soon, but in the meantime we can pretend these don't exist and concern ourselves primarily with this big box down here. This is where we will put all of our Lua instructions. Scripts are run every time you save them, and also once when the profile loads, so they're a great place to put functions which you will use later on in your triggers and aliases so they're already defined and ready to go by the time you connect to your game.

If I type a basic instruction in here, such as send("hello"), and click save, you can see in the main screen here that it's performed that send immediately. Send is the Mudlet's basic function to send something to the game as though you'd typed it in as a command. What we're going to do now is create a function which will perform a couple different tasks and produce output, and which we can reuse any time we want to do that, whether it's in a trigger or alias.

We'll start by creating a table. You can think of a table as kind of like a filing cabinet to hold your stuff. In this case I'm naming the table 'demonnic' because that's my name, but you could use anything you think is unlikely to be used already. I'd steer clear of simple, obvious names like "HP" or "vitals" so you can avoid fighting over the name when you install someone else's scripts. Also, I write it in the form of "demonnic equals demonnic or " so that if the table is already defined, it does not redefine it. This way if I'm working on my scripts while playing I'm not constantly wiping out all the data. So this line says to Lua "create a variable named demonnic, and if demonnic already exists store that there, otherwise store an empty table there". Variables are like labels you put on information so you can find them again later. In this case, we're labeling this table as "demonnic" so when we look for "demonnic" we get this table.

The open and close curly braces tell Lua you're defining a table. When used like this, it creates an empty table. I'll go over other ways to make tables with prefilled data in a later video on tables, but for now just know that we're creating or reusing a table named "demonnic" to hold the function we're about to write.

Now let's define the function. You use the "function" keyword, following by the name you want to store the function under. In this case I use "demonnic dot testFunction" because that tells Lua to put testFunction inside the demonnic table. So it creates a drawer (variable) in the filing cabinet labeled "testFunction" and it will store the function in that drawer for us to get later. The "end" here denotes the end of the function. I go ahead and add it immediately, and then I never have to wonder if I closed the function, as I did it right away. Now whatever we put between this function line and this end line will be stored as "demonnic.testFunction". So let's put some stuff in there.

demonnic = demonnic or {}

function demonnic.testFunction()
local time = getTime(true, "hh:mm:ss")
echo("The time is: " .. time .. "\n")
end

For this first line, we start with the 'local' keyword. This tells Lua that you only care about the variable you're about to define inside this function. It will only exist while this function is running, and will not be accessible to anything outside of this function. But it also means it won't accidentally overwrite any other 'time' variable which has been created. getTime here tells Mudlet to tell us what time it is, and the hh mm ss tells it what format we want to see it in, in this case as hours, minutes, and seconds. I'll put a link to the information on getTime in the description if you're interested in more information on that.

We then take this information and echo it to the main window. The double dots here tells Lua to add these two strings together. So it will add whatever is in the time variable to "The time is" , and then we add a newline, which is what the \n stands for. It's like telling the computer to hit enter in the output for you.

Now when we click save, you'll see nothing happens in the main window. But if I use the built in lua alias to run the function... and there's the output.

Now, let's say we want to have it echo the time in a color we can specify. Going back into the script, we would add what's called a parameter to the function, in this case we'll just call it color. Then we need to change echo to cecho, which allows you to use color names to colorize the echo output. We need to put the color name in angle brackets so that cecho knows it's an instruction to change the color, but otherwise it's still just adding strings together to make a bigger string. Now, let's save this and go back to the main window, where we can use the lua alias again to show what we've made. Notice I'm putting red in quotes here, if I did not put it in quotes it would try to look up the variable named "red" and use that value, but since it's undefined things would go wrong. And then when I hit enter, you see it prints the time in red. I can also use "blue" or "green" as you see here.

In today's video, we went over the basics of script objects in Mudlet, how to create variables and functions in a script, and how to write a function which can change what it does based on the information you pass into it. Future videos in this tutorial series will expand upon this information, but these basics of creating and interacting with Lua variables and functions form the core of what you will need to know when working with other things such as triggers and aliases in order to get the most out of Mudlet's potential. I hope this video was informative and helpful, and I look forward to creating and sharing the next one with you all. Until then, happing MUDding.

Link

https://youtu.be/10mJUh4Hq-A

Script

Hello,

In this tutorial, I will cover all the elements of the profile selection window in Mudlet as of version 4.14, which is the latest release at the time of recording.

When you first open Mudlet, you are presented with the profile selection screen. This is where you select which profile or game you wish to open. The list of profiles is here on the left. If you right click on a profile's icon, you can select to either set an image of your own for the profile, or set a custom color for the profile rather than the one automatically assigned by Mudlet on creation. If you double click on a profile it will open it.

Below that, we have the Remove, Copy, and New buttons. There is a drop down on the copy button which allows you to copy settings only, so you can keep the game information but not necessarily copy all the associated scripts and map files.

Here in the top right, we have the block of required information. This consists of the profile name, the server address for it to connect to, and the port to connect to. If your game uses TLS to encrypt your connection with them, you will also need to check "secure".

Here, we have the Profile history. Every time you save your Mudlet profile a new save file is created. By default, the most recent one is selected, but should something go wrong such as making a major error in your script, or a save file becomes corrupted, you can click to drop this down like so and select any of the previous copies of your profile.

Below that are some additional options. There are fields to store your username and password for the game. If this is done Mudlet will hide them when they're entered. There is also one to enabled Discord integration, one to open the selected profile on Mudlet start, in which case this screen will not be shown and the autostart profile will start instead, and one which will cause it to reconnect automatically if disconnected.

Below that is an information box where you briefly describe the profile or the game it connects to.

Finally, there is the Connect, Offline, or Cancel buttons. Connect will open the profile and connect to the game. Offline will open the profile but not connect to the game, and Cancel will close the profile selection screen, though without a profile open there are limited actions you can take, namely opening a profile, connecting to Discord, or reading the about/help screens.

Let's finish up by briefly walking through creating a new profile. First, you click "New", then enter a name for the profile, in this case "Profile Tutorial". You would then enter a server address and port number. This is information you will generally get from your game. I'll put in mudlet.org, and use port 3000. At this point, you can fill in your username and password or adjust any of the other options below, but enough information has been filled in to click on connect, which will save the new profile with its connection information, open it, and try to connect to the game. In our case, it will fail, as there's no game listening for connections at that address and port combination, but you should be connected to your game and ready to begin at this point.

In today's video, we went over the various elements of the Profile Selection screen and what each of them does, and then quickly created a new example profile. In future videos, we will go over the UI elements of the Main Window, and eventually how to go about creating your own customized User Interface with Mudlet. I hope this video was informative and helpful, and I look forward to creating and sharing the next one with you all. Until then, happing MUDding.

YouTube Links

720p - https://youtu.be/CicyjFoy9q4
1080p - https://youtu.be/Ypwpx0XY94E

Per request from https://www.youtube.com/watch?v=c1Llvwy0Y_Y&lc=UgxOOQJ0ejIHcmY4cpN4AaABAg

Script

Hello,

In this tutorial, I will cover creating a basic alias to perform simple or repetitive tasks for you, as well how to make an alias with an optional argument to cast "cure wounds" on somebody else, or yourself if you don't specify someone.

To start, let's click on Aliases. You can see here on the left that there are several preinstalled aliases which come with Mudlet. I'll go over these in a later video, but for now let's click on "Add Group" and name this group "Alias tutorial", then click on save item. You will then need to click "Activate" in order to activate the group, as they start disabled.

Let's now make our first alias by clicking "Add Item" and naming this alias "check pack". We then give it a pattern, which will determine when this alias is executed. I'm going to use "^cp$" (caret c p dollar sign) because I want to make sure this fires only when I type exactly "c p" as the command. For those who have not watched the basic regular expressions video, the caret matches the beginning of the string, and the dollar sign matches the end.

Then, in the code box here at the bottom I will put send("look in pack") and click "Save Item". The alias itself is automatically activated so long as no issues are found in the pattern or the script at the bottom. Then when I go back to the main window and type "cp" and hit enter, you can see that it sends "look in pack". When an alias matches in this way, the original text, in this case cp, is not sent to the game. So all your game knows is you sent "look in pack" as a command.

For an alias as simple as this, we could just type "look in pack" in this command line here, but for anything more complicated than sending a single command like this you'll need to use the script box, so I recommend getting used to using it from the start.

Now let's look at a slightly more complicated example. I'll click "Add Item" as before, and name this one "cure wounds". The pattern will start similarly, caret, c, w, but then it changes slightly. We'll add an opening parenthesis here to start a capture group, then a space and dot plus, and the closing parenthesis to end the capture group. I briefly touched on capture groups in the basic regular expression video, but this is going to let us use the information later. I'll then finish it with a question mark and a dollar sign. The question mark here is new. In regular expressions, a question mark means "0 or 1 of", so this alias will match on c w all by itself, or cw followed by a space and anything else, which will be the target. If you want the argument to be required, just leave the question mark off.

Here in the script box, we will put this into action. This is covered in the Basic Scripting video, but we start with the keyword local, followed by target. This tells Lua that this target variable is special to this alias, and it won't touch any other target variables or be touched by them. Then we set it equal to matches[2], which stores the the first capture group (`the space and whatever the dot plus matches), or self if the argument wasn't included. The reason it is matches 2 and not matches 1 is that for all aliases and triggers, matches 1 holds the full match, which leaves the first capture group at matches 2, the second capture group at matches 3, and so on.

So this line says "make a special target variable just for me, and put the capture group in it if there is one. Otherwise, set it to self"

Then on the next line, we use send("cast 'cure wounds' on" .. target) to have it actually send the command. The dot dot tells Lua to add the string held in the variable target onto the end of the "cast cure wounds on" string, and then send sends the combined result on to the game.

Moving back to the main window, you can see if I type cw on its own, it casts cure wounds on self
But if I type cw bob then bob is the target of the cure

These two examples should hopefully serve to guide you through many of the aliases you'll need to make in Mudlet.

In today's video, we went over how to create a simple alias, as well as how to create an alias with an optional argument you can pass in to change the alias's behaviour. In future videos we will begin covering the different types of triggers, and how to setup triggers and aliases which do the same things using functions. I hope this video was informative and helpful, and I look forward to creating and sharing the next one with you all. Until then, happing MUDding.

Link

https://youtu.be/Uz6EDvZYNvE

Script

Hello,

In this tutorial, I will cover regular expression, or "perl regex" triggers in Mudlet, how to use them to extract information from your game, and some things to keep in mind when making use of them.

We have a basic regular expressions video as well as a basic substring trigger video which you may find it helpful to view first. There are links in the description for them if you'd like to review them before moving on. There are also links to some helpful resources for learning more about regular expressions, as well as testing and analyzing regular expressions which are touched on in the basic regular expressions video.

Now with the preamble out of the way, let's begin by clicking Triggers to open the script editor up to the Triggers page. I'll start by making a group to keep my triggers organized, call it "Basic Regex Triggers", and click "Save Item". Then let's click "Add Item" and name this one "Regex1". Then let's click the dropdown next to the first pattern and change it from substring to perl regex. The color for this pattern line changes from black to blue to give a visual clue as to what type of trigger it is.

It needs a pattern, so let's go with something simple for now, You pick up (\d+) gold\.$

We will use this pattern to track the gold we've picked up this play session. Let's click on "Save Item" and get started on the script that will handle the tracking for us. The information in the Basic Scripting video holds true for triggers as well, so let's start this with demonnic = demonnic or {} which creates a table to hold our variables if it hasn't been created yet, or if it has will use the one which has already been created. This keeps us from wiping out the information we've already collected every time the trigger goes off.

We'll then add local gold = tonumber(matches[2]) . Things matched by triggers are text rather than numbers by default, so tonumber gets the number equivalent. This way we avoid potential future issues when we try to do math with it. And we use matches[2] because matches[1] stores the entire match, then matches[2] is the first capture group, matches[3] is the second capture group, and so on. So this line says "Create a local variable named gold, and store the value in the first capture group as a number in that variable"

So on the next line, let's add this number to our total. demonnic.gold = (demonnic.gold or 0) + gold This line tells Lua "take the value from demonnic.gold, or 0 if demonnic.gold doesn't exist yet, add gold to it, and then store the result as demonnic.gold. Let's click "Save Item" again to save our work. Now, I've prepared an alias in advance which will feed that line to the trigger engine with an amount of gold I specify. if we use it to say we picked up 20 gold
(typed)
pug 20

And then check the value using the lua alias
(typed)
lua demonnic.gold

It prints 20. If we pick up another 45 gold and check again
(typed)
pug 45
lua demonnic.gold

It prints 65, so it's keeping track of it for us. But I don't want to have to type that out every time I pick up gold to see the total. Let's go back to the trigger and make it display for us. At the bottom of the current script, let's add cecho(f" <gold>{demonnic.gold}") cecho lets us print color text to the screen, and f is a function which lets you do string interpolation. The value of whatever it finds between the curly brackets in the string you feed to it will be used in that place in the string. Lua allows you to omit the parentheses when you call a function with only a single string or table parameter, but it is generally not considered best practice to do so, and using f for string interpolation like this is the only place I typically use this capability myself.

And now back in the main window, we get the information echoed back to us when we use our alias

(typed)
pug 103

Now for regex triggers if you check off highlight it will highlight the capture groups for the trigger only. If you want to highlight the entire match this way, you can put parentheses around the entire pattern which will make it all a capture group as well, and thus highlighted. This does shift around the location of the captures in your matches table, though. Which leads me to the next feature, named capture groups. To avoid having to change my code if the pattern changes, let's change the pattern to this instead
^you pick up (?<gold>\d+) gold\.$

And now we change matches[2] in the script to matches.gold. This can often make it much easier to work with your capture groups. Let's click "Save Item", then go back to the main window and pick up some gold
(typed)
pug 39

Excellent. Now let's try one more. This one will auto heal us if we're under 50% health. Let's click "Add Item", then name it "Heal self" and put in the pattern ^HP: (\d+)/(\d+)

Then in the script box, let's add some code

local current = tonumber(matches[2])
local max = tonumber(matches[3])
local hpPercent = current / max * 100
if hpPercent <= 50 then
  send("cast 'cure wounds' on self")
end

From the top, we change the first capture group to a number and store it in the local variable current, then store the second capture group in the local variable max. We then get the percentage by dividing the current by the max and multiplying it by 100. Then if that number is less than 50, we cast cure wounds on ourselves.

Back in the main window, we can test it using
`echo HP: 39/100
`echo HP: 83/100
`echo HP: 1283/2000

And only the first one makes it cast, as it's the only one which is under half full on HP.

In today's video, we went over how to create a basic regular expression trigger and use it to store information captured from your game. We also went over some of the differences between a regex trigger and the substring trigger types, and how to use named capture groups for easier access to your information and easier to read code. I hope this video was informative and helpful, and I look forward to creating and sharing the next one with you all. Until then, happing MUDding.

Links

Regular Expression analysis and test         : regex101.com
Good site for learning regular expressions: regexlearn.com
Basic Regex video                                       : https://youtu.be/KFoax1Q0ltw
Basic Substring Triggers video                    : <tbd>

Script

Hello,

In this tutorial, I will cover the three different types of substring triggers in Mudlet and what the differences between them are, as well as some of the basic overall trigger features.

Let's start by clicking on Triggers to bring up the trigger editor. Then let's click "Add Group" and name this group "Tutorial Triggers" and click save. Then we'll click on "Add Item" to make a new trigger. Let's name this "Enemy Highlight"

We'll use this trigger to highlight our enemies, as the name implies. We really want them to stand out, so let's check off highlight here in the bottom right. We'll accept the defaults, red on yellow is VERY easy to see.

Now, let's imagine that Bob was recently caught stealing a cow from our farm, and boy does that make us mad. Bob is now our enemy! So let's add Bob's name to pattern 1 here of this trigger. Now let's click "Save Item"

In the Mudlet main window, we'll use the `echo alias which comes preinstalled in Mudlet profiles for testing triggers to show the highlight.

`echo Bob appears from across the horizon

As you can see, Bob is highlighted and his name just leaps out of the text at you. Let's try another one.

`echo Bob and Bob Jr. appear from across the horizon

Oh dear, we see here that it's only highlighted the first instance of Bob. His son, Bob Jr, is likely to be caught up in this feud as well so we want to make sure he is also highlighted.

Going back to the editor, if we check off "match all" here, then it will match for every instance on the line.

If we click save, then go back to the main window and repeat the previous echo, you can see that both Bob's are now highlighted.

You can add another substring pattern below that for Jr. and save it. Now let's repeat the previous echo.
Hmmm. What if we try instead with

`echo Jr. is a common suffix

It does highlight it.

Going back into the editor, I can explain why. When a trigger has multiple patterns in it, and multi-line AND is not checked, then it will check each of its patterns in order from top to bottom, and stops when it finds the first one that matches and fires on that. In this case, it encountered 'Bob' before 'Jr.' and fires for all instances of Bob on the line, but didn't keep checking any of the patterns after that.

These patterns are both substring patterns, which means if the text in the box appears exactly like that anywhere in a line, it will be highlighted.

Going back to the main window, we can see that

`echo Bobbin bobbed for apples

Highlights the Bob in Bobbin, but not the one in bobbed, because of the lowercase b.

Heading back to the editor, the other substring triggers are "Start of line" , which is the same as substring but it must start the at the beginning of the line only. There is also "Exact Match", which must match the entire line exactly from start to finish.

These three trigger types collectively are the fastest ones in Mudlet, and useful when you know exactly what text you're trying to match.

If you wanted to also have it play a sound, you could click the "play sound" checkbox here on the right, then "Choose file" and select the file you want to use. And if I resend the last `echo in the main window

And the sound is played.

The rest of the options in the trigger editor here we will go over in future videos, but they do not apply to the majority of triggers. In fact, for the majority of triggers you can click this arrow here and it will remove the options from the view and leave primarily the patterns, and the code block at the bottom.

Which brings us to the code block. Any code which you put in here is executed when the trigger matches. So if we wanted to add an additional message echoed to the end of the line to -really- make sure we notice that dastardly Bob, we could add code in here like cecho(f"<red>{matches[1]} is here! ") so. Cecho is the function which you can use to echo coloured text to the console by color name, such as red in this instance. the F here is a function which allows you to insert the contents of a variable or outcome of a statement inside of text. To do so, you precede the string with f as shown, and then include the variables you want to have expanded into the string between the curly brackets as shown. matches[1] holds the text which the trigger matched, so if it matches on Bob, then it will says "Bob is here!" in red.

So let's hit "Save Item", then go back to the main window, and retry the last echo.

And now it shows that Bob is highlighted in Bobbin, the sound is played, and it tells us Bob is here as "Bob" is the text which was matched in the trigger pattern.

A couple last notes about triggers in general. Mudlet evaluates triggers from top to bottom in order. This doesn't turn out to be important often, but it can occasionally be helpful when troubleshooting issues when you're modifying the line in the main console in multiple triggers, and is a question we get asked a lot. Also, triggers are checked against the line as it came in from your game originally. Modifying the line via cecho as we did earlier will not change how any later triggers match. We could not make a trigger to match the "Bob is here" text we added in our example, for instance, as it's only added to the display.

In today's video, we went over how to create a substring trigger, the three types of substring trigger and what the differences are, as well as the basic trigger options. In future videos, we'll go over regular expression triggers which allow you to match text which changes very accurately, and extract pieces of it for use in the trigger's code block. We'll also go over the remaining types of trigger patterns which Mudlet supports, and even further down the line we'll explore some of the more advanced capabilities of Mudlet's Trigger engine. I hope this video was informative and helpful, and I look forward to creating and sharing the next one with you all. Until then, happing MUDding.

YouTube Description

A tutorial for basic substring triggers.

Download Mudlet at https://www.mudlet.org

YouTube Link

https://youtu.be/jYjop54-Y3I

Hello,

In this tutorial, I will cover all the elements of the Mudlet main window as of Mudlet 4.14, which is the latest release at the time of recording.

Starting at the top, there is the menu bar. As you look through them, notice they will point out the shortcut keys which perform the same function as the menu item.

Under games there is Play, which opens the profile selection screen, Disconnect, and Reconnect.

The toolbox menu contains entries to open the script editor, as well as show the map, change the input line to compact mode which removes all the stuff to the right of the input line, open the notepad for taking notes, open up a connection to IRC, provide access to the package manager, load a replay (which is a diagnostic tool the developers use to troubleshoot issues), open the module manager, or open the package exporter. The package manager, module manager, and package exporter will be covered in their own video.

Options allows you to open the profile preferences, or if you have more than one profile open set it to multiview, which instead of having each profile be a tab splits the space vertically like so. (open a second profile and set multiview to show it, then close second profile.)

The Help menu contains links to helpful webpages for working with Mudlet, as well as our Discord help channel, the IRC client again, and our online forums.

In About, you can open the About Mudlet window (open the window for a moment, then close again), or check for updates (click, see no updates, click ok).

Beneath that, there is the Main Toolbar. This has buttons for largely the same things that the main menu bar has items for. On the left we have Connect, which opens the profile selection screen. You can click this arrow to drop down for the disconnect option as well.

The next 7 buttons on the toolbar open the script editor to specific sections, Triggers, Aliases, Timers, Buttons, Scripts, Keys, and Variables respectively.

Then there's the Discord button. If your game has discord integration and has told Mudlet about it, then this button will take you to the discord for your game. If not, it will take you to the Mudlet discord. If you click this drop down, there is also another way to open the IRC chat window. Before Mudlet had a Discord, we used IRC for support and announcements, but it isn't used so much these days. To the right of this button is the Mudlet Chat button, which takes you to the Mudlet Discord. This button is only active if your game has its own discord, otherwise the Discord button serves that function.

Beside that we have Map, which will show or hide the map for Mudlet. The Manual button will open up the Mudlet manual on our wiki. Settings takes you to preferences, which will get its own video tour. Notepad opens the notepad for taking down notes.

Moving on, we come to the Packages button. Clicking this button will open the package manager. Clicking this drop down will provide access to the module manager and the package exporter. As I said earlier, these will get their own video, but for now just know they are a way of sharing code and functionality with other Mudlet users.

The Replay button lets you load a replay, same as the menu bar option. Reconnect will reconnect you to your game, and Multiview turns on multiview. Report issue will open your web browser to our github to tell us what you found so we can take a look, and the about button opens the About Mudlet dialog.

At the bottom of the screen is the input line. Starting on the left, we have the input line itself, where you type your commands and aliases for interacting with your game. You can cycle through your command history using the up and down arrows, and if you type the beginning of a command, it will cycle through commands in the history which start with the same text. It stretches most of the way across the window, until you get to the search box over here on the right. This allows you to search your main window for specific words or phrases to make finding things in the backscroll easier. To the right of that we have the buttons to show earlier or later results for the search. By default it will show the most recent result. This search is case sensitive.

Next to that is the timestamp button, which toggles timestamp visibility on and off, like so (demonstrate). Then there's the button to record a replay. What this does is record the information coming from your game, which can sometimes be useful to help the developers fix an issue. Most of the time, though, even we don't use them.

Next up is the logging button, which toggles logging on and off. And last but not least, we come to the emergency stop button. This halts all triggers and timers from running, which is useful for if you have a trigger which is causing an infinite loop or something like that. Hopefully you never need to hit this, but it's good to know where it is, just in case.

In today's video, we went over the UI for Mudlet's main window and briefly touched on what each item does. In future videos, we'll go over the Mudlet preferences window, the features of Mudlet's script editor, and ways to add your own custom interface elements to Mudlet. I hope this video was informative and helpful, and I look forward to creating and sharing the next one with you all. Until then, happing MUDding.

2-3min video showing how to convert an alias into a function would be good, so people have guidance on how to avoid expandAlias() which is arguably far easier to get started with.

Script TBD.

Script

Hello,

In this tutorial, I will cover how to download and install Mudlet for MacOS.

First, you'll need to open your web browser and navigate to https://www.mudlet.org/download , which will bring up the Mudlet download page. It should pre-select the proper tab for your operating system, but if not you can click on it here to bring it up.

Then click here to download the latest release, or here to download the latest Public Test Build, or PTB. The release is the current stable version of Mudlet, and good for most users. The PTB is our nightly build, and has all the latest features and updates but may be slightly less stable, and updates as often as once a day.

Once the download is complete, open the dmg, and then drag the Mudlet icon over to Applications. Then open the Applications folder and open Mudlet. It will bring up a dialog asking if you are sure because it was downloaded from the internet, click 'open' and Mudlet will start, allowing you to select a game and start playing.

In today's video, we went over how to download and install Mudlet on MacOS. In future videos, we will explore the basics of scripting and interacting with your game via Lua, as well as the many other features Mudlet has. I hope this video was informative and helpful, and I look forward to creating and sharing the next one with you all. Until then, happing MUDding.

Link

https://youtu.be/Ug4I8gNUhdg

Script

Hello,

In this tutorial, I will cover how to download and install Mudlet for Linux.

First, you'll need to open your web browser and navigate to https://www.mudlet.org/download , which will bring up the Mudlet download page. It should pre-select the proper tab for your operating system, but if not you can click on it here to bring it up.

Then click here to download the latest release, or here to download the latest Public Test Build, or PTB. The release is the current stable version of Mudlet, and good for most users. The PTB is our nightly build, and has all the latest features and updates but may be slightly less stable, and updates as often as once a day.

Once the download is complete, open the archive and extract the file somewhere easy to run it, I like to use the desktop. Then you can just double click to open Mudlet, then open a profile and begin playing.

In today's video, we went over how to download and install Mudlet on Linux. In future videos, we will explore the basics of scripting and interacting with your game via Lua, as well as the many other features Mudlet has. I hope this video was informative and helpful, and I look forward to creating and sharing the next one with you all. Until then, happing MUDding.

Link

https://youtu.be/LIJuFra-KKc

Script

Hello,

In this tutorial, I will cover how to download and install Mudlet for Windows.

First, you'll need to open your web browser and navigate to https://www.mudlet.org/download , which will bring up the Mudlet download page. It should pre-select the proper tab for your operating system, but if not you can click on it here to bring it up.

Then click here to download the latest release, or here to download the latest Public Test Build, or PTB. The release is the current stable version of Mudlet, and good for most users. The PTB is our nightly build, and has all the latest features and updates but may be slightly less stable, and updates as often as once a day.

Once the download is complete, click here to run the installer, and then let it do its thing.

Once it's done, it will open Mudlet and you can open a profile and begin playing.

In today's video, we went over how to download and install Mudlet on Windows. In future videos, we will explore the basics of scripting and interacting with your game via Lua, as well as the many other features Mudlet has. I hope this video was informative and helpful, and I look forward to creating and sharing the next one with you all. Until then, happing MUDding.

Link

https://youtu.be/BLem0ZD6yRo