Difference between revisions of "Manual:Supported Protocols"

From Mudlet
Jump to navigation Jump to search
(Supporting Client.Media (https://github.com/Mudlet/Mudlet/pull/3132))
(Supporting Client.Media (https://github.com/Mudlet/Mudlet/pull/3132))
Line 67: Line 67:
 
Want to add accessibility and excitement into your game? How about implementing sound and music via GMCP?
 
Want to add accessibility and excitement into your game? How about implementing sound and music via GMCP?
  
The Client.Media family of GMCP packages provide a way for games to send sound and music events. GMCP events are sent in one direction to game clients and not to game servers.
+
The Client.Media family of GMCP packages provide a way for games to send sound and music events. GMCP media events are sent in one direction to game clients and not to game servers.
  
 
====Client.Media in Mudlet====
 
====Client.Media in Mudlet====
Line 100: Line 100:
 
====Loading Media====
 
====Loading Media====
  
Send '''Client.Media''' GMCP to setup the default URL to load sound or music files from external resources.
+
Send '''Client.Media''' GMCP events to setup the default URL to load sound or music files from external resources.
  
 
* Required: "url" is the location where the file may be downloaded.
 
* Required: "url" is the location where the file may be downloaded.
Line 112: Line 112:
 
</syntaxhighlight>
 
</syntaxhighlight>
  
It is recommended to use Client.Media, set this default URL once, and to download all of your media files from one resource location. Otherwise, explicitly set the "url" parameter on all of your Client.Media.Load GMCP and Client.Media.Play GMCP events to ensure that files are downloaded from the intended servers.
+
If downloading from external resources, it is recommended to use Client.Media, set this default URL once, and to download all of your media files from one resource location. Otherwise, explicitly set the "url" parameter on all of your Client.Media.Load GMCP and Client.Media.Play GMCP events to ensure that files are downloaded from the intended servers.
  
Send '''Client.Media.Load''' GMCP to load sound or music files. This could be done when the player logs into your game or at the beginning of a zone that will need the media.
+
Send '''Client.Media.Load''' GMCP events to load sound or music files. This could be done when the player logs into your game or at the beginning of a zone that will need the media.
  
* Required: "name" is the name of the media file.
+
{| class="wikitable"
* Optional: "url" is the location where the file may be downloaded. Only required if a url was not set above with Client.Media.
+
! Required
* Optional: "tag" stores media in folders and helps categorize media.
+
! Key
 +
! Value
 +
! style="text-align:left;"| Purpose
 +
|- style="color: green;"
 +
| style="text-align:center;"| Yes
 +
| "name"
 +
| <file name>
 +
| style="text-align:left;"|
 +
* Name of the media file.
 +
|- style="color: blue;"
 +
| style="text-align:center;"| Maybe
 +
| "url"
 +
| "sound" or "music"
 +
| style="text-align:left;"|
 +
* Resource location where the media file may be downloaded.
 +
* Only required if a url was not set above with Client.Media.
 +
|-
 +
| style="text-align:center;"| No
 +
| "tag"
 +
| <tag>
 +
| style="text-align:left;"|
 +
* Stores media in folders and helps categorize media.
 +
|-
 +
|}
  
 
For example, to download the sound of a sword swooshing and categorize it in the "combat" folder with the "media" folder:
 
For example, to download the sound of a sword swooshing and categorize it in the "combat" folder with the "media" folder:
Line 132: Line 155:
 
====Playing Media====
 
====Playing Media====
  
Send '''Client.Media.Play''' GMCP to play sound or music files.
+
Send '''Client.Media.Play''' GMCP events to play sound or music files.
  
 
{| class="wikitable"
 
{| class="wikitable"
Line 140: Line 163:
 
! Default
 
! Default
 
! style="text-align:left;"| Purpose
 
! style="text-align:left;"| Purpose
|- style="font-style: italic; color: green;"
+
|- style="color: green;"
 
| style="text-align:center;"| Yes
 
| style="text-align:center;"| Yes
 
| "name"
 
| "name"
 
| <file name>
 
| <file name>
| <none>
+
| &nbsp;
 
| style="text-align:left;"|
 
| style="text-align:left;"|
 
* Name of the media file.
 
* Name of the media file.
 
* Wildcards "*" and "?" may be used within the name to randomize media files selection.
 
* Wildcards "*" and "?" may be used within the name to randomize media files selection.
|-
+
|- style="color: blue;"
| style="text-align:center;"| No
+
| style="text-align:center;"| Maybe
 
| "url"
 
| "url"
 
| <url>
 
| <url>
| <none>
+
| &nbsp;
 
| style="text-align:left;"|
 
| style="text-align:left;"|
 
* Resource location where the media file may be downloaded.
 
* Resource location where the media file may be downloaded.
 +
* Only required if the file is to be downloaded remotely and a url was not set above with Client.Media or Client.Media.Load.
 
|-
 
|-
 
| style="text-align:center;"| No
 
| style="text-align:center;"| No
Line 166: Line 190:
 
| "tag"
 
| "tag"
 
| <tag>
 
| <tag>
| <none>
+
| &nbsp;
 
| style="text-align:left;"|
 
| style="text-align:left;"|
 
* Stores media in folders and helps categorize media.
 
* Stores media in folders and helps categorize media.
Line 187: Line 211:
 
| "priority"
 
| "priority"
 
| 1 to 100
 
| 1 to 100
| <none>
+
| &nbsp;
 
| style="text-align:left;"|
 
| style="text-align:left;"|
 
* Halts the play of current or future played media files with a lower priority.
 
* Halts the play of current or future played media files with a lower priority.
Line 203: Line 227:
 
| "key"
 
| "key"
 
| <key>
 
| <key>
| <none>
+
| &nbsp;
 
| style="text-align:left;"|
 
| style="text-align:left;"|
 
* Uniquely identifies media files with a "key" that is bound to their "name" or "url".
 
* Uniquely identifies media files with a "key" that is bound to their "name" or "url".
Line 219: Line 243:
 
}
 
}
 
</syntaxhighlight>
 
</syntaxhighlight>
 +
 +
The "name" parameter may be used for stopping media with the Client.Media.Stop GMCP event.
  
 
===== url =====
 
===== url =====
Line 241: Line 267:
 
}
 
}
 
</syntaxhighlight>
 
</syntaxhighlight>
 +
 +
The "type" parameter may be used for stopping matching media with the Client.Media.Stop GMCP event.
  
 
===== tag =====
 
===== tag =====
Line 253: Line 281:
 
}
 
}
 
</syntaxhighlight>
 
</syntaxhighlight>
 +
 +
The "tag" parameter may be used for stopping matching media with the Client.Media.Stop GMCP event.
  
 
===== type: music =====
 
===== type: music =====
Line 265: Line 295:
 
}
 
}
 
</syntaxhighlight>
 
</syntaxhighlight>
 +
 +
The "type" parameter may be used for stopping matching media with the Client.Media.Stop GMCP event.
  
 
===== volume: 1 to 100 =====
 
===== volume: 1 to 100 =====
Line 332: Line 364:
  
 
Although using the integer type is recommended, Mudlet parses "priority" values of type string ("25") into integers (25) as needed.
 
Although using the integer type is recommended, Mudlet parses "priority" values of type string ("25") into integers (25) as needed.
 +
 +
The "priority" parameter may be used for stopping matching media with the Client.Media.Stop GMCP event.
  
 
===== continue: true or false (for music) =====
 
===== continue: true or false (for music) =====
Line 379: Line 413:
 
</syntaxhighlight>
 
</syntaxhighlight>
  
THIS SECTION IS WORK-IN-PROGRESS!
+
The "key" parameter may be used for stopping matching media with the Client.Media.Stop GMCP event.
 +
 
 +
=====randomization=====
 +
 
 +
Wildcards "*" and "?" may be used within the name to randomize media files selection.
 +
 
 +
Given that media files underdark.wav, underdark.mp3 and underdark_dark_elven_moshpit.mp3 were all present in the media/environment directory under the current game profile, the following Client.Media.Play GMCP event would randomly choose one of those files to play.
 +
 
 +
<syntaxhighlight lang="json">
 +
Client.Media.Play {
 +
  "name": "underdark*",
 +
  "type": "music",
 +
  "tag": "environment",
 +
  "loops": -1,
 +
  "continue": false
 +
}
 +
</syntaxhighlight>
 +
 
 +
If media files sword1.wav, sword2.wav and sword3.wav were all present in the media/combat directory under the current game profile, the following Client.Media.Play GMCP event would randomly choose one of those files to play per each loop.
 +
 
 +
<syntaxhighlight lang="json">
 +
Client.Media.Play {
 +
  "name": "sword?.wav",
 +
  "type": "sound",
 +
  "tag": "combat",
 +
  "loops": 3,
 +
}
 +
</syntaxhighlight>
 +
 
 +
====Stopping Media====
 +
 
 +
Send '''Client.Media.Stop''' GMCP events to stop sound or music media.
 +
 
 +
{| class="wikitable"
 +
! Required
 +
! Key
 +
! Value
 +
! style="text-align:left;"| Purpose
 +
|-
 +
| style="text-align:center;"| Yes
 +
| "name"
 +
| <file name>
 +
| style="text-align:left;"|
 +
* Stops playing media by name matching the value specified.
 +
|-
 +
| style="text-align:center;"| No
 +
| "type"
 +
| "sound" or "music"
 +
| style="text-align:left;"|
 +
* Stops playing media by type matching the value specified.
 +
|-
 +
| style="text-align:center;"| No
 +
| "tag"
 +
| <tag>
 +
| style="text-align:left;"|
 +
* Stops playing media by tag matching the value specified.
 +
|-
 +
| style="text-align:center;"| No
 +
| "priority"
 +
| 1 to 100
 +
| style="text-align:left;"|
 +
* Stops playing media with priority less than or equal to the value.
 +
|-
 +
| style="text-align:center;"| No
 +
| "key"
 +
| <key>
 +
| style="text-align:left;"|
 +
* Stops playing media by key matching the value specified.
 +
|-
 +
|}
 +
 
 +
====all====
 +
 
 +
Send the Client.Media.Stop GMCP event with no parameters to stop all playing media within a given game profile.
 +
 
 +
<syntaxhighlight lang="json">
 +
Client.Media.Stop {}
 +
</syntaxhighlight>
 +
 
 +
====parameters====
 +
 
 +
Send any combination of the name, type, tag, priority or sound parameters and valid corresponding values to stop playing media that matches ANY of the parameters.
 +
 
 +
Stop the rain.
 +
 
 +
<syntaxhighlight lang="json">
 +
Client.Media.Stop {
 +
  "name": "rain.wav"
 +
}
 +
</syntaxhighlight>
 +
 
 +
Stop all media using the "type" of "sound".
 +
 
 +
<syntaxhighlight lang="json">
 +
Client.Media.Stop {
 +
  "type": "sound"
 +
}
 +
</syntaxhighlight>
 +
 
 +
Stop all media categorized with the "tag" of "combat" or that has a "priority" less than or equal to 50.
 +
 
 +
<syntaxhighlight lang="json">
 +
Client.Media.Stop {
 +
  "tag": "combat",
 +
  "priority": 50
 +
}
 +
</syntaxhighlight>
 +
 
 +
Stop all media categorized with the "key" of "area-music".
 +
 
 +
<syntaxhighlight lang="json">
 +
Client.Media.Stop {
 +
  "key": "area-music"
 +
}
 +
</syntaxhighlight>
  
 
===Thorough GMCP tutorial===
 
===Thorough GMCP tutorial===

Revision as of 22:08, 30 November 2019

Supported Protocols

Mudlet supports GMCP, MSSP, MSP, ATCP, Aardwolfs 102, MSDP, and the MXP Protocol. MXP, MSSP, MSP, GMCP and 102 are enabled by default, MSDP can be enabled in settings.

Game protocols toggle.png

GMCP

Generic Mud Communication Protocol, or GMCP, is a protocol for MUD servers to communicate information with MUD clients in a separate channel from the one which carries all of the text that makes up the game itself. Enabling the Debug window will show you GMCP events as they are coming in, and to get an idea of what information is currently stored, hit the Statistics button.

When working with GMCP on IRE games, this GMCP reference is a useful tool.

Using GMCP

Receiving GMCP data

To "trigger" on GMCP messages, you'll need to create an event handler - Mudlet will call it for you whenever relevant GMCP data is received.

As an example, create a new script and give it a name of the function you'd like to be called when the relevant GMCP message is received. Then, add the GMCP event you'd like the function to fire on under the registered event handlers left. Lastly, define the function - either in this or any other script - and you'll be done. The GMCP data received will be stored in the corresponding field of the gmcp table, which your function will read from.

Example:

Using gmcp.png

The test_gmcp() function will be called whenever Char.Vitals is received from the game, and it'll echo the latest data on the screen.

Sending GMCP data

Certain modules will only send data when a request is made by your client. In Mudlet, you can make such a request using the command sendGMCP("command"). Read your MUD's relevant documentation, such as the IRE document on GMCP, for information about specific modules.

See Also: sendGMCP

Managing GMCP modules

While some GMCP modules are enabled by Mudlet by default when you connect with a GMCP enabled MUD, others may not be 'standard' modules and are instead specific to the MUD itself. In order to provide a way to manage GMCP modules without scripts causing modules in use by other scripts to be disabled. Note Note: The gmod lua module has been included with Mudlet (rc2.0+).

Registering user

While this step is no longer strictly required, you can register your 'user' with gmod using

gmod.registerUser("MyUser")

Where MyUser is your plugin/addon/whatever name. However, your user will be automatically registered if you enable or disable any modules using it. Which leads us to...

Enabling modules

Enabling a GMCP module is as easy as:

gmod.enableModule("MyUser", "Module.Name")

If MyUser has not been registered previously, then they will be automatically registered when you call this function. An example of a module which would need to be enabled this way is the IRE.Rift module provided by IRE MUDs.

-- add this to a login trigger, or anything that will get done just once per login
gmod.enableModule("<character name>", "IRE.Rift")

Another example would be the Combat module in Lithmeria, which isn't enabled by default:

-- add this to a login trigger, or anything that will get done just once per login
gmod.enableModule("<character name>", "Combat")

Disabling modules

Disabling a GMCP module is just as easy as enabling it:

gmod.disableModule("MyUser", "Module.Name")

The main difference being that the module will be turned on as soon as you enable it if it is not already enabled. If you disable it, it will not be disabled with the server until every user of that module has disabled it. This prevents script A from disabling modules that script B may still be using.

Client.Media

Want to add accessibility and excitement into your game? How about implementing sound and music via GMCP?

The Client.Media family of GMCP packages provide a way for games to send sound and music events. GMCP media events are sent in one direction to game clients and not to game servers.

Client.Media in Mudlet

Mudlet implements Qt's QMediaPlayer to play corresponding Client.Media GMCP events. Media files may be downloaded manually or automatically if certain conditions are met.

Client.Media GMCP packages are available in Mudlet 4.4+

Enabling Media

When a new profile opens, Mudlet adds to the Core.Supports.Set GMCP package "Client.Media 1" to signal to servers that it supports processing media files via GMCP:

Core.Supports.Set ["Client.Media 1", ...]

To process Client.Media GMCP data in Mudlet, these boxes in the Settings window of Mudlet must be checked:

  1. The "Enable GMCP" box in the Miscellaneous section.
  2. The "Allow server to download and play media" box in the Game protocols section.

These boxes are checked by default upon the start of a new profile in Mudlet.

Storing Media

Mudlet plays files cached in the "media" folder within a game's profile. To get files into the "media" folder you could perform either of these options:

  • Copy media files or extract them from an archive (zip)
  • Automatically download them from external resources such as your game's web server on the Internet.

To enable the second option (Internet), use the "url" parameter made available in the "Client.Media", "Client.Media.Load" and "Client.Media.Play" GMCP packages described below.

Loading Media

Send Client.Media GMCP events to setup the default URL to load sound or music files from external resources.

  • Required: "url" is the location where the file may be downloaded.

For example, to setup the default URL for your game:

Client.Media {
  "url": "https://www.example.com/media/"
}

If downloading from external resources, it is recommended to use Client.Media, set this default URL once, and to download all of your media files from one resource location. Otherwise, explicitly set the "url" parameter on all of your Client.Media.Load GMCP and Client.Media.Play GMCP events to ensure that files are downloaded from the intended servers.

Send Client.Media.Load GMCP events to load sound or music files. This could be done when the player logs into your game or at the beginning of a zone that will need the media.

Required Key Value Purpose
Yes "name" <file name>
  • Name of the media file.
Maybe "url" "sound" or "music"
  • Resource location where the media file may be downloaded.
  • Only required if a url was not set above with Client.Media.
No "tag" <tag>
  • Stores media in folders and helps categorize media.

For example, to download the sound of a sword swooshing and categorize it in the "combat" folder with the "media" folder:

Client.Media.Load {
  "name": "sword1.wav",
  "url": "https://www.example.com/media/",
  "tag": "combat"
}

Playing Media

Send Client.Media.Play GMCP events to play sound or music files.

Required Key Value Default Purpose
Yes "name" <file name>  
  • Name of the media file.
  • Wildcards "*" and "?" may be used within the name to randomize media files selection.
Maybe "url" <url>  
  • Resource location where the media file may be downloaded.
  • Only required if the file is to be downloaded remotely and a url was not set above with Client.Media or Client.Media.Load.
No "type" "sound" or "music" "sound"
  • Identifies the media.
No "tag" <tag>  
  • Stores media in folders and helps categorize media.
No "volume" 1 to 100 50
  • Relative to the volume set on the player's client.
No "loops" -1, or >= 1 1
  • Number of iterations that the media plays.
No "priority" 1 to 100  
  • Halts the play of current or future played media files with a lower priority.
No "continue" true or false true
  • Only valid for media files with a "type" of "music".
  • Continues playing matching new music files when true
  • Restarts matching new music files when false.
No "key" <key>  
  • Uniquely identifies media files with a "key" that is bound to their "name" or "url".
  • Halts the play of current media files with the same "key" that have a different "name" or "url".
name

For example, to simply play the sound of a cow mooing already stored in the "media" folder:

Client.Media.Play {
  "name": "cow.wav"
}

The "name" parameter may be used for stopping media with the Client.Media.Stop GMCP event.

url

If you maintain your sound files on the Internet and don't set a default URL with Client.Media, or preload them with Client.Media.Load, include the "url" parameter:

Client.Media.Play {
  "name": "cow.wav",
  "url": "https://www.example.com/media/"
}
type: sound

Media files default to a "type" of "sound" when the "type" parameter is not specified, such as in the example above. It is good practice to specify the "type" parameter to best keep media organized within your implementation:

Client.Media.Play {
  "name": "cow.wav",
  "type": "sound"
}

The "type" parameter may be used for stopping matching media with the Client.Media.Stop GMCP event.

tag

To play the sound of a sword swooshing and categorized in the "combat" folder within the "media" folder:

Client.Media.Play {
  "name": "sword1.wav",
  "type": "sound",
  "tag": "combat"
}

The "tag" parameter may be used for stopping matching media with the Client.Media.Stop GMCP event.

type: music

Add background music to your environment through use of the "music" value set upon the "type" parameter:

Client.Media.Play {
  "name": "river.wav",
  "type": "music",
  "tag": "environment"
}

The "type" parameter may be used for stopping matching media with the Client.Media.Stop GMCP event.

volume: 1 to 100

As the character draws nearer to or farther from the environmental feature, consider adjusting the "volume" parameter. Example values, followed by syntax examples:

  • Maximum: 100 (recommended to use rarely)
  • High: 75
  • Default: 50
  • Low: 25
  • Minimum: 1 (recommended to use rarely)
Client.Media.Play {
  "name": "river.wav",
  "type": "music",
  "tag": "environment",
  "volume": 75
}

Although using the integer type is recommended, Mudlet parses "volume" values of type string ("75") into integers (75) as needed.

loops: -1, 1 or more

The "loops" parameter controls how many times the sound will repeats and defaults to 1 if not specified. A value of -1 will loop the file indefinitely.

Client.Media.Play {
  "name": "hour_bell.wav",
  "type": "sound",
  "loops": 3
}

Client.Media.Play {
  "name": "underdark.mp3",
  "type": "music",
  "tag": "environment",
  "loops": -1
}

Although using the integer type is recommended, Mudlet parses "loops" values of type string ("-1") into integers (-1) as needed.

priority: 1 to 100

The "priority" parameter sets precedence for Client.Media.Play GMCP events that include a "priority" setting. The values for the "priority" parameter range between 1 and 100. Given that two Client.Media.Play GMCP events have the same priority, the media already playing will continue playing. In Mudlet, media without priority set is not included comparisons based on priority.

A common place to find priority implemented is with combat. In the following example, imagine a combat scenario where some sounds of sword thrusts were interrupted by a successful blocking maneuver.

Client.Media.Play {
  "name": "sword1.wav",
  "type": "sound",
  "tag": "combat",
  "loops": 3,
  "priority": 60
}

Client.Media.Play {
  "name": "block1.wav",
  "type": "sound",
  "tag": "combat",
  "priority": 70
}

Although using the integer type is recommended, Mudlet parses "priority" values of type string ("25") into integers (25) as needed.

The "priority" parameter may be used for stopping matching media with the Client.Media.Stop GMCP event.

continue: true or false (for music)

Typically sent with the "type" of "music" is the parameter "continue", which presents the following values:

  • true: continues music that is already playing if it is requested again through a new Client.Media.Play GMCP event
  • false: restarts music if it is requested again through a new Client.Media.Play GMCP event
Client.Media.Play {
  "name": "city.mp3",
  "type": "music",
  "tag": "environment",
  "continue": true
}

If the "continue" parameter is not specified, behavior will default to true for music.

Although using the boolean type is recommended, Mudlet parses "continue" values of type string ("true" and "false") into boolean (true and false) as needed, as not all game drivers support a boolean type.

key

The "key" parameter enables media categorization, similar to the "tag" parameter, however it adds a feature of uniqueness that halts media currently playing with the same key, replacing it with the media that arrived from a new Client.Media.Play GMCP event. This update will only occur if the "name" or "url" associated with the currently playing media does not match the new media, while the key is identical.

In the example below, consider that a player moves from a sewer area to a village. The "key" parameter is used to stop the previously playing sewer.mp3 and start playing village.mp3 within the second Client.Media.Play GMCP event.

Client.Media.Play {
  "name": "sewer.mp3",
  "type": "music",
  "tag": "environment",
  "loops": -1,
  "continue": true,
  "key": "area-music"
}

Client.Media.Play {
  "name": "village.mp3",
  "type": "music",
  "tag": "environment",
  "loops": -1,
  "continue": true,
  "key": "area-music"
}

The "key" parameter may be used for stopping matching media with the Client.Media.Stop GMCP event.

randomization

Wildcards "*" and "?" may be used within the name to randomize media files selection.

Given that media files underdark.wav, underdark.mp3 and underdark_dark_elven_moshpit.mp3 were all present in the media/environment directory under the current game profile, the following Client.Media.Play GMCP event would randomly choose one of those files to play.

Client.Media.Play {
  "name": "underdark*",
  "type": "music",
  "tag": "environment",
  "loops": -1,
  "continue": false
}

If media files sword1.wav, sword2.wav and sword3.wav were all present in the media/combat directory under the current game profile, the following Client.Media.Play GMCP event would randomly choose one of those files to play per each loop.

Client.Media.Play {
  "name": "sword?.wav",
  "type": "sound",
  "tag": "combat",
  "loops": 3,
}

Stopping Media

Send Client.Media.Stop GMCP events to stop sound or music media.

Required Key Value Purpose
Yes "name" <file name>
  • Stops playing media by name matching the value specified.
No "type" "sound" or "music"
  • Stops playing media by type matching the value specified.
No "tag" <tag>
  • Stops playing media by tag matching the value specified.
No "priority" 1 to 100
  • Stops playing media with priority less than or equal to the value.
No "key" <key>
  • Stops playing media by key matching the value specified.

all

Send the Client.Media.Stop GMCP event with no parameters to stop all playing media within a given game profile.

Client.Media.Stop {}

parameters

Send any combination of the name, type, tag, priority or sound parameters and valid corresponding values to stop playing media that matches ANY of the parameters.

Stop the rain.

Client.Media.Stop {
  "name": "rain.wav"
}

Stop all media using the "type" of "sound".

Client.Media.Stop {
  "type": "sound"
}

Stop all media categorized with the "tag" of "combat" or that has a "priority" less than or equal to 50.

Client.Media.Stop {
  "tag": "combat",
  "priority": 50
}

Stop all media categorized with the "key" of "area-music".

Client.Media.Stop {
  "key": "area-music"
}

Thorough GMCP tutorial

A good GMCP tutorial that walks you through receiving and sending GMCP data is available here - take a read!

MSDP

MSDP is a protocol for MUD servers to communicate information with MUD clients in a separate channel from the one which carries all of the text that makes up the game itself. Mudlet can be configured to use MSDP by clicking on the Settings button (or Options->Preferences in the menu, or <alt>p). The option is on the General tab.

Once MSDP is enabled, you will need to reconnect to the MUD so that Mudlet can inform the server it is ready to receive GMCP information. Please note that some servers don't both send MSDP and GMCP at the same time, so even if you enable both in Mudlet, the server will choose to send only one of them.

Enabling the Debug window will show you MSDP events as they are coming in, and to get an idea of what information is currently stored, hit the Statistics button. Also see MSDP reference for some of the commands and values your server might support.

Using MSDP

Receiving MSDP data

To "trigger" on MSDP messages, you'll need to create an event handler - Mudlet will call it for you whenever relevant MSDP data is received.

As an example, lets create a script that'll track whenever we move - that is, the room number changes. To begin with, we need to ask the game to be sending us updates whenever we move - so do:

lua sendMSDP("REPORT", "ROOM_VNUM")

in the command-line first to enable reporting of the room number and name. Then, create a new script and give it a name of the function you'd like to be called when the relevant MSDP message is received. Add the MSDP event you'd like the function to fire on under the registered event handlers - in our case, msdp.ROOM_VNUM. Lastly, define the function - either in this or any other script - and you'll be done. The MSDP data received will be stored in the corresponding field of the msdp table, which your function will read from.

Example:

Using msdp.png

The test_msdp() function will be called whenever ROOM_VNUM is received from the game, and it'll echo the latest data on the screen.

Sending MSDP data

You can use sendMSDP to send information via MSDP back to the game. The first parameter to the function is the MSDP variable, and all the subsequent ones are values. See the MSDP documentation for some examples of data that you can send:

-- ask the server to report your health changes to you. Result will be stored in msdp.HEALTH in Mudlet
sendMSDP("REPORT", "HEALTH")

-- client - IAC SB MSDP MSDP_VAR "SEND" MSDP_VAL "AREA NAME" MSDP_VAL "ROOM NAME" IAC SE in the documentation translates to the following in Mudlet:
sendMSDP("SEND", "AREA NAME", "ROOM NAME")
See Also: sendMSDP

MSSP

Mud Server Status Protocol, or MSSP, provides a way for MUD crawlers (i.e. MSSP Mud Crawler) and MUD listing sites (search for Listings here) to gather detailed information about a game, including dynamic information like boot time and the current amount of online players. It also makes submitting a new game entry very simple on MUD listing sites. A player or administrator is only required to fill in the hostname and port and other information is gathered from behind the scenes.

MSSP in Mudlet

The MSSP data presented in Mudlet will enable MSSP standard data fields to be made accessible for scripting. Some useful fields include the game name, number of players, uptime, game hostname, game port, codebase, admin contact, Discord invite URL, year created, link to an icon, ip address, primary language, game location, website and several others may be available. It is up to the game in question to populate the data, so don't expect all fields to be filled in.

MSSP is available in Mudlet 4.1+.

Receiving MSSP Data

To receive MSSP data in Mudlet, these conditions must be met:

  1. The Enable MSSP box in the Settings window of Mudlet must be checked.
  2. The game must negotiate MSSP with clients like Mudlet at its login screen. Details here.

To see whether your game supports MSSP, after connecting, type lua mssp. If the game does not support MSSP, you will see an empty table mssp = {}. If it does you will see information similar to the example below. The data may be accessed in a similar way to the instructions for GMCP listed above. Typically, MSSP data is only sent once per connection.

mssp = {
  HOSTNAME = "stickmud.com",
  VT100 = "1",
  UPTIME = "1565657220",
  MSDP = "0",
  MCP = "0",
  GMCP = "1",
  PORT = "7680",
  ["MINIMUM AGE"] = "13",
  PUEBLO = "0",
  INTERMUD = "-1",
  SKILLS = "100",
  ["HIRING BUILDERS"] = "0",
  PLAYERS = "6",
  CONTACT = "[email protected]",
  CODEBASE = "LDMud 3.5.0 (3.5.1)",
  ["HIRING CODERS"] = "0",
  ["PAY FOR PERKS"] = "0",
  LOCATION = "Canada",
  GAMESYSTEM = "Custom",
  MCCP = "0",
  SUBGENRE = "Medieval Fantasy",
  ROOMS = "10000",
  STATUS = "Live",
  FAMILY = "LPMud",
  LEVELS = "150",
  CREATED = "1991",
  ["PAY TO PLAY"] = "0",
  IP = "24.138.28.11",
  MOBILES = "-1",
  GAMEPLAY = "Hack and Slash",
  CLASSES = "8",
  NAME = "StickMUD",
  SSL = "0",
  ANSI = "1",
  ICON = "https://www.stickmud.com/favicon.ico",
  RACES = "12",
  UTF-8 = "0",
  AREAS = "-1",
  MXP = "0",
  HELPFILES = "-1",
  ["XTERM 256 COLORS"] = "0",
  MSP = "1",
  OBJECTS = "9780",
  WEBSITE = "https://www.stickmud.com",
  GENRE = "Fantasy",
  DISCORD = "https://discord.gg/erBBxt",
  LANGUAGE = "English"
}

MSP

Want to add accessibility and excitement into your game? How about implementing sound and music triggers?

Mud Sound Protocol, or MSP, provides a way for games to send sound and music triggers to clients. Clients have the option to implement a framework where the corresponding triggers play. MSP triggers are sent in one direction to game clients and not to game servers. Sounds may be downloaded manually or automatically if conditions are met.

Games could use telnet option negotiation to signal clients support for MSP (WILL, WONT), and toggling MSP processing on and off (DO, DONT). This is communicated using TELOPT 90, which is reserved (unofficially) for the MSP protocol by our community. Games that do not support telnet option negotiation for MSP should provide a means for their players to toggle this feature on and off.

The latest specification for MSP is located here.

MSP in Mudlet

Mudlet processes MSP sound and music triggers in two ways:

  1. MSP for Lua - Mudlet triggers may capture and invoke the receiveMSP function available through the Lua interpreter of Mudlet to process MSP.
  2. MSP over OOB - Mudlet is capable of receiving hidden, out-of-band telnet sound and music triggers from game servers via messaging with TELOPT 90.

Sound or music triggers that contain a media file name will be searched for in the media folder of the corresponding Mudlet profile that matches the host for the game. If the media folder and the file are found by Mudlet, it will be played, given the host's operating system supports playing that type of media file. If the file is not found, Mudlet could initiate a download of the media file when provided a URL to find the file. Alternatively, game administrators may instruct players on other ways to transfer media files by 1) creating a media folder in their game's Mudlet profile and 2) copying files or extracting them from an archive (zip).

MSP is available in Mudlet 4.4+

Receiving MSP Data

Processing of MSP is enabled by default on new game profiles. Control whether the processing is on or off through the Settings menu in Mudlet.

MSP for Lua

Check for MSP support with your game and enable any options that allow sound and music triggers to be sent to your screen.

Create a sound trigger to invoke the Lua interpreter:

  • Name: Sound Trigger
  • Text: ^!!SOUND\((\S+?)(?: (.+))?\)$
  • Type: perl regex
  • Script: deleteLine() receiveMSP(matches[1])

Create a music trigger to invoke the Lua interpreter:

  • Name: Music Trigger
  • Text: ^!!MUSIC\((\S+?)(?: (.+))?\)$
  • Type: perl regex
  • Script: deleteLine() receiveMSP(matches[1])

MSP over OOB

Game administrators may send sound and music triggers over the out-of-bounds (hidden) telnet channel encoded with TELOPT 90 after performing telnet negotiation with Mudlet. The advantage to this is that all of the communication is behind the scenes with no additional trigger requirements for the player (see MSP over Lua). Games will send the bytes of out-of-band messages to Mudlet in a format like this:

IAC SB TELOPT_MSP !!SOUND(cow.wav L=2 V=100) IAC SE

MSP Troubleshooting

  • Wildcards ? or * within the file name do not trigger automatic sound or music downloads. Ensure the sound was downloaded previously prior to using a wildcard.

MSP Specification

For more insight into the syntax of sound and music triggers, please reference the specification.

ATCP

Since version 1.0.6, Mudlet includes support for ATCP. This is primarily available on IRE-based MUDs, but Mudlet's implementation is generic enough such that any it should work on others.

The latest ATCP data is stored in the atcp table. Whenever new data arrives, the previous is overwritten. An event is also raised for each ATCP message that arrives. To find out the available messages available in the atcp table and the event names, you can use display(atcp).

Note that while the typical message comes in the format of Module.Submodule, ie Char.Vitals or Room.Exits, in Mudlet the dot is removed - so it becomes CharVitals and RoomExits.

Example
room_number = tonumber(atcp.RoomNum)
echo(room_number)

Triggering on ATCP events

If you’d like to trigger on ATCP messages, then you need to create scripts to attach handlers to the ATCP messages. The ATCP handler names follow the same format as the atcp table - RoomNum, RoomExits, CharVitals and so on.

While the concept of handlers for events is to be explained elsewhere in the manual, the quick rundown is this - place the event name you’d like your script to listen to into the Add User Defined Event Handler: field and press the + button to register it. Next, because scripts in Mudlet can have multiple functions, you need to tell Mudlet which function should it call for you when your handler receives a message. You do that by setting the Script name: to the function name in the script you’d like to be called.

For example, if you’d like to listen to the RoomExits event and have it call the process_exits() function - register RoomExits as the event handler, make the script name be process_exits, and use this in the script:

function process_exits(event, args)
    echo("Called event: " .. event .. "\nWith args: " .. args)
end

Feel free to experiment with this to achieve the desired results. A ATCP demo package is also available on the forums for using event handlers and parsing its messages into Lua datastructures.

Mudlet-specific ATCP

See ATCP Extensions for ATCP extensions that have been added to Mudlet.

Aardwolf’s 102 subchannel

Similar to ATCP, Aardwolf includes a hidden channel of information that you can access in Mudlet since 1.1.1. Mudlet deals with it in the same way as with ATCP, so for full usage instructions see the ATCP section. All data is stored in the channel102 table, such that you can do:

display(channel102)

... to see all the latest information that has been received. The event to create handlers on is titled channel102Message, and you can use the sendTelnetChannel102(msg) function to send text via the 102 channel back to Aardwolf.

-- Function for detecting AFK status on Aardwolf mud.
function amIafk()
   for k,v in pairs(channel102) do
      if k==100 and v==4 then
         return true
      end
   end
   return false
end

MXP

MXP is based loosely on the HTML and XML standards supported by modern web browsers. It is only "loosely" based upon these standards because MUDs require dynamic, streaming text, rather than the page-oriented view of web browsers. Also, the existing standards are needlessly verbose for use on a MUD where text efficiency is important.

In addition, there are additional security concerns to worry about with MXP. While support for HTML tags within a line is desired, players on a MUD can exploit this power and cause problems. Certain HTML functions need to be restricted so that MUD players cannot abuse them. For example, while it might be desirable to allow players to change the font or color of their chat messages, you would not want to allow them to display a large graphics image, or execute script commands on the client of other users. MXP handles this by grouping the various tags and commands into secure and open categories, and preventing the secure tags from being used by MUD players.

Mudlet implements a subset of MXP features - the most popular ones that are actually in use. Mudlet supports MXP links (including send to prompt and open in browser (Mudlet 3.17+)), pop-up menus, creation of custom elements, and line modes.

Secure connection (TLS)

To connect to a game securely, tick the 'Secure' box in the profile connection settings:

Secure-connection.png

Note that the game must support a secure (TLS) connection in order for this to work, and this feature is available in Mudlet 3.17+.

If you are a games admin/developer, check out this or this example on how to setup a secure connection to your game.

Adding support for a telnet protocol

In addition to supporting ATCP, GMCP, Aardwolf's 102 and MXP, Mudlet has open telnet support - meaning that for any telnet protocol it doesn't support, it has the tools you can use to build the support for. This does not mean Mudlet supports other protocols "out of the box" - you will either have to get code that adds the support, or you could create it yourself.

The basic tools that you need are addSupportedTelnetOption(), sendSocket() and the sysTelnetEvent.

Create an event handler that goes off on sysTelnetEvent - which is raised whenever an unsupported telnet option is encountered. Your logic handling will start in this event handler. Once you decide what you'd like to send to the MUD, use sendSocket() to send raw data as-is. Finally, when your logic is done, use addSupportedTelnetOption() to register your telnet option with Mudlet, so it will respond with telnet DO on a query from the MUD server. See this MSDP snippet for a barebones example.

API philosophy

Adding a support for a new telnet protocol will involve adding the user-facing API. It best for users if it was in the same style as Mudlets handling of other protocols. To see how it's done exactly, check out GMCP, ATCP or Aardwolf 102 examples - but the gist of it is provided below.

Mudlet has a built-in event system, which is used to broadcast messages in an independent way. With it, people can "trigger" on 102, ATCP or GMCP events with Lua functions that get called whenever an event they're interested in is raised. Use the event system to provide your users with a way to react to new protocol data.

Events have names, and optionally, any amount of data with them. For protocol support, Mudlet prefixes the relevant message received name with the protocol name in lowercase. For example, an ATCP Char.Vitals getting updated would raise an event titled "atcp.Char.Vitals". A GMCP Room.Info message would raise a "gmcp.Room.Info" message.

Additionally, Mudlet also allows catch-all event - in case the user wants to use one event handler for a variety of sub-events (it's not uncommon for MUDs to use Main.Sub.Add, Main.Sub.Remove, Main.Sub.List to keep track of a list, for example, while conserving data). To accomplish this, it raises events for every relevant namespace - that is, a Main.Sub.Add event will raise protocol.Main.Sub and protocol.Main.Sub.Add events. While it is entirely possible for one event handler to react to multiple events, this is provided for convenience.

For storing protocol data, Mudlet uses an aptly named global table - gmcp for GMCP data, atcp for ATCP data. Data is stored in the same way it is received and the event is raised for - so a Char.Vitals message's contents will be stored in gmcp.Char.Vitals, a Room.Info's contents in gmcp.Room.Info. If there were was any nested data within the message, it is stored as a table within the proper namespace - ie, a "details" JSON array of a GMCP Room.Info message would be stored in gmcp.Room.Info.details. Use a global table with the protocol name in lowerspace for storing permanent data that your users will read from.

That's it! If you'll need any Mudlet-related help, feel free to post on our forums. Once you're done, package your work for distribution which you can optionally post in the finished scripts section.