Optimising Network Bandwidth Use: Reusing strings - c++

Question

I'll try to be as brief and to the point as possible..
I currently develop a small, live "MMO" and would like to reduce the bandwidth use of host -> client.
The most costly of this is the use of strings, that, for the most part, are constantly repeated and sent to the clients. They differ only slightly, due to their nature, be it names or values, but the rest is repeated.
I have an idea that I'm sure has already been done, but can't really find any example of it.
Basically, these repeated strings, could be assigned a "stringcode" , then the variables, and then sent to the client. The clients already have enough information to fill in the blanks, so to speak, based on id numbers assigned to each player
So for example, in the case of names of a player..
"Supanova transfers 75 crew to Angus" // 35 bytes
becomes..
1 23 75 8 // only 6 bytes needed
where ..
1, is the "stringcode"
23, is the player ID of Supanova, (the client has the name already for this player
75, is the integer variable.
8, is the other player ID of Angus
In theory, I could find all of the strings sent to the client, and store them on the client, this is what I wish to avoid, as it's a painful process.
OR, create a dictionary of sorts, at runtime, assigning a "stringcode" value to each new string, the amount of variables, and quite possibly the order of the types would be needed. The host will send the packet contain just the "stringcode" and variables, if the client doesn't yet know the context of the string for that "stringcode", request the string, and then it can piece it together.
Not sure if I'm explaining this all too well, it's getting late and it sounds so much better in my head.....

Answer 1

You may be onto something with your "stringcode" idea. It's similar to what's done in some compression algorithms: build a dictionary to represent common strings with short IDs.
However, regarding your actual example:
"Supanova transfers 75 crew to Angus" // 35 bytes
Don't think of this as a "string," think of it as a "command" or "message." Then the message is a struct or class like this:
enum class MessageType : uint8_t { Transfer, /*...*/ };
struct BaseMessage { // message header
MessageType messageType;
} __attribute__((packed));
struct TransferMessage : BaseMessage {
PlayerId playerIdFrom;
PlayerId playerIdTo;
int32_t amount;
} __attribute__((packed));
If PlayerId is four bytes, this entire thing is still 13 bytes (16 if not packed). But PlayerId only needs to be large if it is an "absolute" ID in the entire world. You could also use a "relative" ID within the current game, in which case a single byte is enough for 256 players per game. In that case you can get away with 7 bytes total.
There's nothing novel in the above: it's very typical network message formatting. Be mindful of endianness. You might consider using a suitable library such as Cap'N'Proto.