Here To Slay, part 6: a table that talks
The "I'm ready" button in the lobby and a chat that travels the same path as every play, with a length limit, a rate limit and a history for whoever arrives late.
In the physical game, half the fun happens outside the cards. It’s the complaint from whoever got robbed, the “I’m going to challenge you” before someone plays a hero, the negotiation to gang up on whoever is winning. In the digital version, so far, none of that existed: everyone played in silence, and the only way to talk to the table was through another app.
During the redesign in part 5, it became clear that the conversation had to live inside the game, in two places: in the waiting room, before the match, and at the table itself.
First, “I’m ready”
The waiting room had a problem even before the chat. In the version from parts 2 to 4, the countdown started on its own as soon as the minimum number of players joined, and the match opened five seconds later. There was no time to wait for a friend who was still joining, or to agree on anything.
Now every seat has an “I’m ready” button, and the rule for starting fits in one line:
public boolean isReadyToStart() {
return players.size() >= minPlayers && readyPlayers.containsAll(players);
}
The countdown only starts when the minimum is reached and everyone in the room has marked themselves ready. If someone unmarks, or a new person joins who isn’t ready yet, the countdown stops.
On screen, each seat shows who is already ready. Here João has marked himself ready, Maria hasn’t yet, and the middle of the table says the countdown only starts when both are ready. On the side, the room chat already has its first conversation, a typed message and a “Good luck!” sent with one click:

The same path as every play
The chat didn’t get a server of its own. A message follows exactly the path of any other action, the one from part 3: the client sends it over WebSocket, the gateway publishes it to Kafka, and the service that owns that room answers.
- In the waiting room, the message goes to
lobby-actions-in, keyed by the lobby, and the lobby service handles it. - In a match, it goes to
game-actions-in, keyed by the match, and the engine handles it.
That way, the chat inherited everything the architecture already did for free: messages from the same room always land on the same partition and arrive in the order they were sent, and the one answering is always the same process, which already knows who is at that table.
What the server keeps
Every room and every match has its own chat log, a small class that does three things:
public synchronized JSONObject append(String playerId, String username, String rawText) {
String text = sanitize(rawText);
if (text.isEmpty()) return null;
long now = System.currentTimeMillis();
Long previous = lastSentAt.get(playerId);
if (previous != null && now - previous < MIN_INTERVAL_MS) return null;
// ... stores the message and keeps only the last 40
}
- It cleans the text: control characters and repeated spaces go away, and the message is cut at 200 characters.
- It limits the pace: each player can send at most one message every 0.6 seconds. That’s enough for a normal conversation and stops anyone from flooding the table by pasting text nonstop.
- It keeps a short history: the last 40 messages stay in memory. Whoever joins later, or drops and reconnects mid-match, gets that history and doesn’t lose the thread.
The server never trusts the client for any of this. Even if someone modifies the app, the length and pace limits still apply, because they’re enforced on the other side.
On the screen
Typing in the middle of a match is slow, and the most common lines at a Here To Slay table are always the same. So the chat has quick phrases that go out with one click: “Good luck!”, “Well played”, “Oops…”, “I’ll challenge you” and “GG” in the waiting room. During a match, “Good luck!” gives way to “Help!”.
At the table, the chat sits in a side column that can be collapsed to make room. When collapsed, it becomes a tab with the number of unread messages, so nobody misses a “don’t do that” while picking the target of an effect. That was one of the changes that came from actually playing: conversation matters most exactly at decision time, so it can’t be hidden behind a button.
During a match, the conversation sits in the right column, next to the table:

And with the column collapsed, a new message turns into a number on the side tab:

Messages aren’t translated. The interface shows up in Portuguese, English or Spanish, but whatever players write arrives the way it was written.
In part 7, the biggest change underneath this new interface: the engine that runs the game’s rules.