The Commodore protocol
This is the protocol between a Commodore program and the hub: version 1. It
is built so that BASIC can read every line the hub sends with a single
INPUT#. playlib speaks it for you, but the protocol is the
contract, and anything that can open a TCP connection can use it.
Transport
| Point | What |
|---|---|
| Address | play.commodoreonline.com, TCP port 6502 |
| Encryption | None. Commodores can't do TLS |
| Content | Text lines, and binary frames for clients that ask for them. Either may follow the other at any time |
| Who speaks first | The client, with HELLO, within 30 seconds of connecting |
| Answers the hub needs | None. There is no ping that a game loop must answer |
Lines
A line is a verb, then fields separated by commas, then a carriage return
($0D):
VERB,FIELD,FIELD,"FREE TEXT"
| Rule | Why |
|---|---|
A line ends with CR. The hub accepts CR, LF or CRLF from clients, and sends CR, or CRLF if the client asks (flag L) |
PRINT# sends CR, and INPUT# stops at CR. With CRLF, INPUT# would leave the LF at the start of the next line, so L is for ASCII clients |
At most 80 bytes, CR included, both ways. Flag X raises the limit for lines from the hub to 160 bytes |
INPUT# reads up to 88 characters, then stops with ?STRING TOO LONG |
| The hub pads each line it sends with empty fields, up to the client's field count | INPUT# with more variables than the line has fields takes the rest from the next line, swallowing it |
| No line the hub makes has more than 5 fields, verb included. Lists come one item per line | They fit the default field count of 6 |
| The hub never sends an empty line | INPUT# skips empty lines, and a lone CR at the end can hang it |
| Verbs are 2-7 uppercase letters | The same bytes in ASCII and PETSCII |
| Numbers are decimal, with no leading space | VAL() reads them. Read fields into strings: a non-number in a numeric variable stops a BASIC program with ?FILE DATA ERROR |
Free text (chat, descriptions) is always in double quotes, and is the last field with content. The hub turns " inside text into ', or doubles it ("") for a client with flag Q |
INPUT# keeps commas and colons inside quotes, and drops the quotes |
| Handles and ids never contain commas, quotes, colons or spaces | They are safe as unquoted fields |
| No verb is used both by clients and by the hub | A transcript reads unambiguously |
Field count. The flags of HELLO may hold one digit: the field count, 5
to 9, or 0 for no padding. Without a digit it is 6 for U and M clients
and 0 for A clients. The hub pads every line to exactly that many fields,
so with the default GO arrives as GO,,,,,, and a BASIC program always
reads with the same six variables:
input#2,v$,a$,b$,c$,d$,e$
Fields beyond the variables are dropped silently. A relayed line that would
have more fields than a receiver's field count is refused: the sender gets
ERR,10, and nothing is delivered.
Whole lines. The hub writes each line in one TCP segment. INPUT# on a
Flyer's tcp: returns a partly arrived line as if it were complete, so a
BASIC program without a library should read only when a few bytes are
waiting (see getting started).
playlib only hands over whole lines.
Binary frames
A client that sets flag B in HELLO may send and receive binary frames:
$00, length, seat, data...
| Byte | Meaning |
|---|---|
$00 |
The marker. A text line never contains $00 |
| length | The bytes that follow: 1-128 (the seat byte and 0-127 data bytes) |
| seat | Sending: the destination, 0 for the game server or $FF for everyone else. Receiving: the sender's seat, 0 for the game server |
| data | 0-127 bytes, passed through unchanged |
Frames are for machine-language and cc65 games that send state often. A game
may mix lines and frames. A client without B never receives a frame: a
frame that would reach one, directly or through $FF, is refused as a whole
with ERR,13. A client without B that sends a frame gets ERR,12.
Character sets
HELLO declares how the client encodes text:
| Flag | Client | The hub reads | The hub sends |
|---|---|---|---|
U |
PETSCII, uppercase/graphics set (a C64's or a PET's power-on mode) | $41-$5A as A-Z |
Text in uppercase, as $41-$5A |
M |
PETSCII, mixed case (lowercase/uppercase set) | $41-$5A as a-z, $C1-$DA as A-Z |
Lowercase as $41-$5A, uppercase as $C1-$DA |
A |
ASCII (cc65 programs, terminals, test tools) | As is | As is |
- Verbs, handles, ids and numbers use only
A-Z,0-9and-, which are the same bytes in all three. Compare them byte for byte. - Free text (chat, the hub's notices, a game server's text) is converted
through Unicode. PETSCII graphics characters survive from one Commodore to
another. Characters a client can't show become
?. - From
Aclients, verbs and ids may be in any case:hello,1,tictac,...works from a terminal. - In a
petcatlisting, lowercase letters are$41-$5A. In cc65 string literals, lowercase is also$41-$5A. So protocol words are written in lowercase in both.
Logging in: HELLO
HELLO,1,TICTAC,K7Q2M9XP,UB
The fields are the protocol version (1), the game's id, the play token and
the flags. The reply is OK,<handle>, then a TURNS line for each
turn-based match waiting on you.
| Flag | Meaning |
|---|---|
U, M or A |
The character set (one of them is required) |
B |
Binary frames, both ways |
L |
Lines from the hub end in CRLF (for ASCII clients) |
| A digit | The field count: 5-9, or 0 for no padding |
N |
A narrow screen: 22 columns (the VIC-20) |
W |
A wide screen: 80 columns (an 80-column PET, a C128 in 80 columns) |
X |
Long lines: lines from the hub up to 160 bytes. For machine-language and cc65 clients that don't read with INPUT# |
Q |
Quotes: a quote inside free text from the hub comes doubled (""), as in CSV, instead of as an apostrophe. A game server's 10 PRINT "HELLO" arrives as FROM,0,"10 PRINT ""HELLO""". For clients that split lines themselves; INPUT# can't read it. Quotes players type are still made apostrophes |
Without N or W the screen is 40 columns. The hub uses the width to wrap a
game server's text. Before HELLO succeeds, the hub writes as if to a U
client with field count 6, so even an ERR reads cleanly with INPUT#.
Client to hub
| Verb | Fields | Where | Meaning |
|---|---|---|---|
HELLO |
version, game, token, flags | First | Log in to a game |
SAY |
"text" | Anywhere | Chat to everyone in the same room: the lobby, the match, or your place in a world |
WHO |
Anywhere | List the players in the same room | |
MATCH |
[players] | Lobby | Quick match: join the queue for a match of that size (default: the game's minimum) |
HOST |
[max] | Lobby | Open a table others can join |
TABLES |
Lobby | List the open tables | |
JOIN |
table | Lobby | Join an open table |
INVITE |
handle | Lobby | Invite a player in the lobby to a match with you |
ACCEPT |
match | Lobby | Accept an invitation |
DECLINE |
match | Lobby | Decline an invitation, or leave a saved party for good |
CANCEL |
Lobby | Leave the queue, close your table, or withdraw your invitation | |
BEGIN |
Hosting | Start your table now. It needs at least the game's minimum | |
READY |
After START |
Your program has loaded and is ready to play | |
ALL |
payload | Match, world | Relay the payload to every other seat (in authority mode: to the game server) |
TELL |
seat, payload | Match, world | Relay to one seat. Seat 0 is the game server |
TURN |
payload | Turn-based, your turn | Make a move. The hub stores it, relays it and passes the turn |
END |
result | Match | Report the result: the winning seat, or 0 for a draw |
LEAVE |
Match, world | Go back to the lobby | |
WORLD |
Lobby | Enter the game's shared world | |
MINE |
Lobby | List your turn-based matches and saved parties | |
RESUME |
match | Lobby | Reopen a turn-based match or a saved party |
SCORE |
board, value | Anywhere | Submit a score |
TOP |
board, [count] | Anywhere | The top of a leaderboard: 1-40 entries, 10 by default |
PUT |
key, value | Anywhere | Save a value for you in this game |
GET |
key | Anywhere | Read a saved value |
NOP |
Anywhere | Nothing: a keep-alive. The hub doesn't answer. Before HELLO it doesn't extend the login deadline |
|
BYE |
Anywhere | Log out. The hub closes the connection |
Payloads. A payload is the rest of the line after the verb's own fields,
commas included. ALL,MARK,5 from seat 1 reaches the others as
FROM,1,MARK,5, which BASIC reads as four fields.
- Payloads are relayed byte for byte, without character set conversion. Every player of a game runs the same program, so they agree on its encoding.
- The
FROMline a receiver gets must fit in 80 bytes (160 withX), padding included, and in the receiver's field count. Otherwise the relay is refused withERR,10. With the default count of 6, a one-field payload from seats 1-9 can be 69 bytes. - Quotes in a payload must open and close a whole field (
ALL,MOVE,"A, B"), or the relay is refused withERR,10. - Free text from a client (
SAY) needn't be quoted:SAY,HIworks. Control codes in it become?, so chat can't clear a screen or change colors.
Replies
Every command either gets a reply, or is silent unless it fails:
| Command | Reply |
|---|---|
HELLO |
OK,<handle>, then any TURNS lines |
MATCH, JOIN, ACCEPT |
WAIT |
WORLD |
START |
HOST, INVITE |
OK,<id>. A table or invitation keeps its id when it becomes a match: INVITED,7,... leads to START,7,... |
BEGIN |
START and the SEAT lines |
DECLINE, CANCEL, LEAVE |
OK |
WHO, TABLES, MINE, TOP |
The list, then LIST,<verb>. A list stops at 40 entries |
SCORE |
RANK |
GET |
VAL |
PUT |
OK |
SAY, READY, ALL, TELL, TURN, END, NOP |
Nothing, unless they fail. SAY isn't echoed to the speaker |
BYE |
Nothing: the hub closes the connection |
Any command can fail with ERR,<code>,"<text>" (see error codes).
Hub to client
| Verb | Fields | Meaning |
|---|---|---|
OK |
[handle or detail] | The last command worked. After HELLO: OK,BRANDON |
ERR |
code, "text" | The last command failed |
ARRIVE, DEPART |
handle | Someone entered or left the lobby (sent only to players in the lobby) |
SAID |
handle, "text" | Chat |
USER |
handle, state | One per player, in reply to WHO. State: LOBBY, WAIT or PLAY |
TABLE |
table, host, players, max | One per open table, in reply to TABLES |
LIST |
verb | The end of a list: LIST,WHO, LIST,TABLES, LIST,TOP, LIST,MINE |
WAIT |
You are queued for a match | |
INVITED |
match, handle | Someone invited you |
JOINED |
table, handle | Someone joined your table (sent to the players already at it). A full table starts by itself |
DECLINED |
match, handle | Sent to the inviter: someone declined. The invitation goes on with the others, if any |
CLOSED |
id, "reason" | Your table or invitation closed before it started. You are back in the lobby |
START |
match, seat, players, host | A match formed. SEAT lines follow. Load what you need, then send READY |
SEAT |
seat, handle | After START: one per player, your own seat included |
GO |
Everyone is ready: play | |
NEXT |
seat | Turn-based: it is this seat's turn |
FROM |
seat, payload | A relayed message. Seat 0 is the game server |
HIST |
count | Resuming a turn-based match: this many stored moves follow as FROM lines, then NEXT |
DROP, BACK |
seat | A player lost the connection, or came back within the grace period |
GONE |
seat | A player left for good |
NEWHOST |
seat | The host changed, because the old host left |
OVER |
result, "reason" | The match ended and you are back in the lobby. The result is the winning seat, 0 for a draw, or -1 for none |
RANK |
board, rank, handle, value | A leaderboard entry. Also the reply to SCORE, with your rank |
VAL |
key, value | The reply to GET |
TURNS |
match, handle, state | A turn-based match or saved party. State: YOU, THEM, OVER, or PARTY |
ENTER |
seat, handle | Worlds: a player arrived in your place |
EXIT |
seat | Worlds: a player left your place |
NOTE |
"text" | A notice from the hub, such as a maintenance warning |
Matches
Example: live tic-tac-toe
Padding is left out. With the default field count, GO arrives as GO,,,,,.
C> HELLO,1,TICTAC,K7Q2M9XP,U
S> OK,BRANDON
S> SAID,ALICE,"ANYONE FOR A GAME?"
C> MATCH
S> WAIT
S> START,4420,1,2,1 (match 4420; you are seat 1 of 2; seat 1 hosts)
S> SEAT,1,BRANDON
S> SEAT,2,ALICE
C> READY
S> GO
C> ALL,MARK,5
S> FROM,2,MARK,1
...
C> END,1 (seat 1 won; Alice reports the same)
S> OVER,1,"BRANDON WINS"
How a match runs
- Forming. A match forms by quick match (
MATCH), at a table (HOST, then othersJOIN; the host starts it withBEGIN, or it starts when full), or by invitation (INVITE, thenACCEPT). - Starting.
STARTgives each player the roster and their seat. Each program loads what it needs and sendsREADY. When everyone is ready, the hub sendsGO. A player who doesn't sendREADYwithin 60 seconds is dropped, and the match starts without them if it still has the minimum. - Seats. Seats are numbered from 1. Seat 0 is the game server, or the hub
for its own notices. In a live match without a game server, seat 1 is the
host: the player whose program settles disputes.
NEWHOSTnames a new one if the host leaves. - Results. Each player reports
ENDwith the winning seat, or 0 for a draw, afterGO. The match ends when every seat still in it has reported, or 60 seconds after the firstEND. When the reports agree, the hub records the result for the wins board and sendsOVER. When they disagree, the match is recorded as disputed. In a game with a server (observeorauthority), the server decides the result, and players'ENDonly asks it to. - Dropped players. If a player's connection drops, the others get
DROP. A player who logs in to the same game within the grace period (2 minutes) is put back in their seat: they getSTARTand theSEATlines again, thenGO, and the others getBACK. After the grace period the others getGONE. A live match that falls below its minimum ends withOVER. - Changing programs. A game with a separate lobby program can disconnect
after
STARTand log in again from the game program. The grace period covers the gap, and the hub puts the new connection in its seat. The lobby works this way. - Quiet during play. While you are in a match, the hub sends only that
match's traffic,
NOTE, and replies to your own commands. There is no lobby chat or arrivals.
Turn-based matches
A turn-based match is stored on the hub, so players can take their turns days apart, logging in for each one.
- After
GO, and after eachTURN, the hub sendsNEXTwith the seat to move. Turns go round the seats in order, unless a game server sets them. ATURNout of turn getsERR,33. - Every
TURNis stored.RESUMEgivesSTART, theSEATlines,HIST, the stored moves asFROMlines, thenNEXT. A program rebuilds its board by replaying the moves. - At login, the hub lists the matches of this game waiting on you as
TURNSlines.MINElists all of yours. - A match can also start on the website: a member invites friends on the
game's page, and once they accept, the hub creates the match already
started, with nobody connected. Its players find it at login (
TURNS) and inMINE, and open it withRESUME, which givesHIST,0andNEXT. A program that can resume a match needs nothing more. The seats are in a random order.
| Point | Rule |
|---|---|
Until GO |
The match behaves like a live one (the READY timeout, the grace period). At GO it is stored, and seat 1 (or the first still in) moves first |
| Your own move | The hub stores a move before it tells anyone. The mover gets no FROM, only the NEXT that follows: put your move on the board then. An ERR instead (such as ERR,50) means it wasn't stored, and it is still your turn |
READY |
Send it after every roster. A new match waits for it; a resumed one ignores it, so a program needn't tell the two apart |
MINE |
Wait for LIST,MINE before deciding between resuming and a new MATCH: other replies can overtake the list |
| Stepping away | LEAVE, or a lost connection after the grace period, takes you out of the match but not out of your seat. The others get DROP, and later BACK. Log in again within the grace period and you are put straight back, with the history |
RESUME |
Any seat still in can resume an active match. Resuming a finished one shows it: START, the SEAT lines, HIST and the moves, then OVER, and you stay in the lobby. At most once every 5 seconds (ERR,40) |
| The turn passes to you while you are in the lobby | You get TURNS,<match>,<handle>,YOU |
END |
Reports are stored. The match ends when every seat still in it has reported. A seat that is away reports when it comes back |
| Turn limit | Set when the game is registered: whole minutes, from 1 minute to a year. The seat to move forfeits when it runs out. With one seat left, it wins (OVER,<seat>,"<HANDLE> WINS BY FORFEIT"). Below the game's minimum the match ends without a result. A connected seat that forfeits gets OVER,-1,"OUT OF TIME" |
| No turn limit | 90 days without a move ends the match: OVER,-1,"ABANDONED" |
| Moves | At most 1000 per match (ERR,12,"TOO MANY MOVES"). A move must fit every seat's line limit and field count, the mover's included, because it comes back to everyone in HIST. Flag X doesn't raise this |
What MINE lists |
Active matches, those waiting on you first, then those that ended in the last 30 days; at most 40 |
TURNS handle |
For THEM, the player to move. For YOU and OVER, the next player after you in seat order. A deleted player shows as - |
A later session, resuming match 601:
C> HELLO,1,TICTURN,K7Q2M9XP,U
S> OK,ALICE
S> TURNS,601,BRANDON,YOU (at login: a match waiting on you)
C> RESUME,601
S> START,601,2,2,1
S> SEAT,1,BRANDON
S> SEAT,2,ALICE
C> READY (ignored: the match is under way)
S> HIST,1
S> FROM,1,MARK,5 (the history, one line a move)
S> NEXT,2 (your turn)
C> TURN,MARK,1
S> NEXT,1 (stored: put the move on the board)
C> LEAVE
S> OK
C> BYE
Leaderboards and saved data
| Point | Rule |
|---|---|
| Scores | Whole numbers from 0 to 999,999,999, so BASIC reads them exactly. A total board stops at the top |
| Ranks | Equal values share a rank, and the next takes its own position: 1, 2, 2, 4. On the wins board the value is wins, and equal wins rank by fewer losses |
SCORE,<board>,<value> |
Answers RANK with your kept value and its rank, which may be an earlier, better score. A board that doesn't exist, the wins board, or a board only the server may submit to is ERR,34 |
TOP,<board>,<count> |
RANK lines, then LIST,TOP |
PUT,<key>,<value> |
The key is 1-8 of A-Z and 0-9. The value is the rest of the line, byte for byte, up to 64 bytes. It must come back whole as VAL,<key>,<value>: within your field count, with whole quotes, and within the line limit |
GET,<key> |
VAL,<key>,<value>. A key that isn't set answers VAL,<key> and nothing more |
| Space | 64 KB per player in a game, 4 MB per game. Over it: ERR,35 |
| When the hub's storage is unreachable | A command that needs it gets ERR,50,"TRY AGAIN LATER" |
Your saved data is per game, keyed by your permanent player id, so renaming your handle keeps it. A game server can read and write it too.
Worlds
A world game always has a game server, which runs all its rules. The hub
provides seats, places and fan-out. A session in a text adventure might
look like this:
C> HELLO,1,DUNGEON,K7Q2M9XP,M
S> OK,BRANDON
S> START,1,7,0,0 (world 1, seat 7; worlds have no fixed count or host)
C> READY
S> GO
S> FROM,0,"YOU ARE IN THE TAVERN. EXITS: NORTH."
S> ENTER,3,ALICE
C> SAY,"HI ALICE" (reaches players in the tavern)
C> TELL,0,GO NORTH
S> FROM,0,"YOU ARE ON THE ROAD. EXITS: SOUTH."
S> ENTER,5,BOB
A world game's registration offers a shared world, party instances, or both:
| Shared world | Party instance | |
|---|---|---|
| What it is | One world everyone enters. Players come and go at any time | A group's own copy of the world, saved between sessions. Others can't wander in |
| Getting in | A game with only a shared world puts you in it straight after HELLO. A game with both starts in the lobby, and WORLD enters |
Formed in the lobby like a match (MATCH, HOST, INVITE). Later, any member's RESUME |
START |
START,<id>,<seat>,0,0, no SEAT lines |
START,<id>,<seat>,<members>,0 and a SEAT line per member |
| Seats | Per visit: the lowest free one, up to the game's maximum. Full: ERR,31,"WORLD FULL" |
The members, fixed when it forms: at most 16 |
| Lifetime | Open while anyone is in it, and a minute after. The next to enter opens a new one, with a new id | Saved. It closes when the server ends it, when its last member leaves it for good, or after 90 days nobody has entered it |
- Entering. Players come and go one at a time. Each gets
START, sendsREADYonce their program is loaded, and getsGOat once. A player who doesn't sendREADYwithin 60 seconds is back in the lobby withOVER,-1,"NOT READY".LEAVEgoes back to the lobby. - Places. The game server moves players between places. With presence
hub, those left behind getEXIT,<seat>, those at the new place getENTER,<seat>,<handle>, and the arriving player gets anENTERfor each player already there (at most 40). With presenceserver, the server narrates arrivals itself, and there are noENTERorEXITlines. A server can also move a player quietly, unseen. - Talking.
SAYreaches the players in your place, and the server hears it.WHOlists the players in your place that you can see, asUSER,<handle>,PLAY.ALL,TELLand frames go to the server:TELLto any seat, taken or free, so the hub's answer doesn't show who is in the world. - The server's voice. Everything the server sends arrives as
FROM,0. The server can't speak as a player or use control codes, so a player can always tell another player's voice from the game's. - No match events. There is no
DROP,BACK,GONEorNEWHOSTin a world. A dropped player's seat is kept for 2 minutes; when a seat is freed, its place getsEXIT. BeforeREADY,SAY,ALL,TELLand frames getERR,12;ENDandTURNalways do. - Saved parties.
MINElists your open parties asTURNS,<id>,<handle>,PARTY, the handle being the player who formed it. When a member resumes one, the other members in the lobby get the same line, and join withRESUME.DECLINE,<id>leaves a party for good (OK, orERR,30if you don't belong to it). You can belong to at most 20 open parties of a game; past that, a new one is refused:ERR,12,"TOO MANY PARTIES"afterMATCH, andCLOSED,<id>,"TOO MANY PARTIES"at a table or invitation. - When the server is away. Players stay in the world. They get
NOTE,"THE GAME SERVER IS AWAY", messages for the server getERR,51, and chat goes on. Forming a party needs the server (ERR,51). When it comes back, players getNOTE,"THE GAME SERVER IS BACK".
The text client is a ready-made Commodore program for text worlds, so an author can write only the server.
Idle connections
- After
HELLOthere is no idle limit: a Commodore may sit in the lobby. - The hub turns on TCP keep-alive. After 30 seconds of quiet it sends probes,
which the device's own TCP stack answers, so nothing reaches the Commodore.
A connection whose device stops answering is closed about 90 seconds after
it was last heard from. A player in a match then goes through the usual
DROPand grace period. - In the other direction, a client should send something now and then so that
its device notices a hub that has gone.
NOPis for that: the hub ignores it. playlib sends one after a minute without sending.
Limits
| Limit | Value | Over it |
|---|---|---|
| A line from the client | 80 bytes, CR included | ERR,10 |
| A line from the hub | 80 bytes, or 160 with flag X |
The hub cuts chat text to fit |
| A frame | Length 1-128: the seat and 0-127 data bytes | ERR,10 |
| Messages | 10 lines or frames a second, bursting to 20 | ERR,40, once per burst; the extra messages are dropped |
| Logging in | Within 30 seconds of connecting | Closed without a reply |
| Failed logins | 3 on one connection | Closed |
| Bad tokens or unknown games from one address | 10 in 10 minutes | ERR,50,"TOO MANY FAILED LOGINS", until 10 minutes after the first |
| Connections per player | 3 | ERR,41 |
| Connections per address | 32, of which 4 not yet logged in | ERR,50 |
| Players per match | As registered (8 if not set) | ERR,31 |
| Seats in a world | 254; a party has at most 16 | ERR,31 |
| Lists | 40 entries | Cut |
| A saved value | 64 bytes; 64 KB per player in a game, 4 MB per game | ERR,35 |
| Moves in a turn-based match | 1000 | ERR,12 |
| Open parties per player, per game | 20 | ERR,12 or CLOSED |
RESUME |
Once every 5 seconds | ERR,40 |
Chat is best effort: a client that reads too slowly misses chat rather than being disconnected. Protocol lines are never dropped. A client that stops reading altogether is disconnected once too much is waiting for it.
Error codes
ERR,<code>,"<text>". The codes are two digits, as Commodore DOS uses.
| Code | Meaning |
|---|---|
| 10 | Line too long or badly formed; or a relay that doesn't fit a receiver |
| 11 | Unknown verb |
| 12 | Not allowed now (wrong state) |
| 13 | That seat can't receive binary frames |
| 20 | Bad or revoked token |
| 21 | Unknown game, or one you aren't allowed to play |
| 22 | Protocol version not supported |
| 23 | Logged in to this game elsewhere: sent to the older connection, which is then closed |
| 24 | Game suspended |
| 25 | You are banned. The text says until when, such as BANNED UNTIL 2026-11-10 12:00 UTC, or BANNED for good. HELLO is refused, and a session is disconnected |
| 26 | You are muted: your SAY is refused and nobody hears it. Game traffic still works. MUTED UNTIL ... or MUTED |
| 27 | Disconnected by the site's moderators. You may log in again |
| 30 | No such player, table or match |
| 31 | Table, match or world full |
| 33 | Not your turn |
| 34 | No such leaderboard, or not one you may submit to |
| 35 | Saved data full |
| 40 | Too many messages: slow down |
| 41 | Too many connections for this player |
| 50 | Hub busy, shutting down, storage unreachable, or too many connections or failed logins from this address |
| 51 | The game's server is not connected |
