Topic: Client Protocols

General

Modern mud clients can receive extra, structured data from 3S
alongside the normal game text: your vitals, who is attacking you,
room and map data for mappers, chat lines, and guild status. None of
it changes gameplay - it exists so your client can draw gauges, maps,
and status windows. Clients that do not speak these protocols see the
same text as always.

Everything here is negotiated automatically by the client. There is
nothing to turn on in the game itself.

GMCP

GMCP is the standard most clients support (Mudlet, TinTin++,
Mushclient, Blightmud, and others). Your client subscribes to the
data it wants with Core.Supports, using either a root name
("Char 1", "Room 1") or an exact package ("Char.Vitals 1"). The
server answers with Core.Supported, listing every package it
can send and whether you are subscribed. All packages are version 1.

  Char.Vitals     { hp, maxhp, sp, maxsp, enc, coffin, coffin_max,
                    guild, qp, qp_required }
                  Your health and spell points, encumbrance as a
                  percentage of what you can carry, and your morgue
                  coffin's corpse count and capacity (0/0 without one).

  Char.Combat     { attacker, attacker_hp, rounds, target }
                  Who is attacking you, their health percentage, how
                  long they have fought, and who they are attacking:
                  the literal string "you" when that is you, otherwise
                  that victim's name. When combat ends one empty
                  snapshot arrives and the stream goes quiet.

  Room.Info       { num, name, area, exits }
                  The room you are in, for mappers. Hidden exits are
                  not included.

  Room.Contents   { items: [ { name, type, count, ... } ], entry? }
                  What you can see in the room, stacked with counts.
                  A monster's health and target appear only if your
                  skills would show them in the normal look text.
                  Sent on every room entry, even if empty or unchanged.
                  Entry lists carry entry: 1 on every page; refresh
                  and subscription snapshots omit that marker. Wait
                  for all pages before using a list to make decisions.

  Room.Map        { kind, w, h, rows, legend, up, down, enter }
                  A glyph grid of the surroundings. Below cartography
                  skill 1 it is a small compass of the room's exits;
                  with the skill trained it is the line-of-sight map.

  Room.Refresh    { packages? }          (you ask, server answers)
                  The one package your client SENDS rather than
                  receives. It re-sends the three Room packages above
                  for the room you are standing in, whether or not
                  anything has changed - a GMCP 'look'. Send it with
                  no body for all three, or name a subset:
                  { "packages": [ "Room.Info", "Room.Map" ] }. Only
                  packages you are subscribed to come back. A couple
                  of requests a second are answered and the rest are
                  dropped without a reply, so send one when you need
                  a resync, not on a timer.

  Room.Death      { name, killer, npc, corpse }
                  Something in your room died. Everyone standing
                  there is told, including you when the death is
                  your own. 'name' is the dead thing as the room
                  saw it, and is the same name Char.Combat used for
                  it while you fought. 'killer' is whoever the mud
                  named out loud, and is empty when it named nobody
                  - that means uncredited, not unkilled. 'npc' is 0
                  when a player died. 'corpse' says whether a
                  corpse was left behind.
                  Unlike the packages above this is an event, not a
                  snapshot: two identical kills send two frames,
                  and hiding the kill line with your colour
                  settings does not suppress it.

  Comm.Channel    Comm.Channel.Text { channel, talker, text }
                  Chat lines, tells, and souls, delivered after the
                  same filters as the text you see.

  Guild.Info / Guild.State / Guild.Extra
                  Guild identity and rank, live resources, lingers and
                  cooldowns, and guild-specific data, where your guild
                  provides them.

Packages only flow while you are subscribed. Most snapshots are sent
only when their values change, but Room.Contents is sent on every
entry. Room.Death and chat messages are events and may repeat.
Typing 'look' does not resend Room data; your client can request it
with Room.Refresh, which also resends unchanged snapshots. A
refresh is not a room entry and carries no entry marker.

MXP and Pueblo

Clients with MXP (or the older Pueblo) get clickable room exits and
clickable web links. This too is negotiated automatically.

The 3K Client

The old 3K client uses its own protocol (MIP) for the same kind of
data. GMCP is the modern route and carries everything MIP does.

For setting up gauges, mappers, or scripts around this data, see your
client's own GMCP documentation.

← back to help