A wrapper for a vector of bytes (ByteArray) that allows easy bit-level manipulations for use in databases, real-time multiplayer, or anything where byte size is a concern. This is just my little creation and I don't recommend its use in production projects, I haven't thoroughly tested and vetted it.
Although this is C++, think of it as pseudo-code. I haven't actually compiled this, so it could have an error.
#include "serializer.hpp"
...
void serializePlayer(Serializer* arr, Player player) {
arr->addBit(player.dead);
arr->addFloat(player.pos.x); // or addDouble(double)
arr->addFloat(player.pos.y);
arr->addString(player.name);
// Dead players don't have health or weapons, do they?
if (!player.dead) {
arr->addUint(player.health, 7); // Max health is 100, which can fit in 7 bits (2^7 = 128)
arr->addUint(player.curWeapId, 5); // Only 30 weapons in the game, which can fit in 5 bits.
arr->addBit(player.isDeveloper); // Special developer-only skin?
arr->addInt(player.someInt, 12); // Couldn't think of an int property a player would have :)
}
}
Serializer::ByteArray serializePlayers(PlayerVector players) {
Serializer arr;
arr.addUint(game.version, 8); // make sure client and server are compatible
arr.addUint(players.length, 6); // max players is 50, which fits in 6 bits
for (int i = 0; i < players.size(); ++i) {
serializePlayer(&arr, players[i]);
}
return arr.byteArray;
}
Player deserializePlayer(Serializer* barr) {
Player player;
// basically the serialization code, but "read" instead of "add"
player.dead = arr->readBit();
player.pos.x = arr->readFloat();
player.pos.y = arr->readFloat();
player.name = arr->readString();
if (!player.dead) {
player.health = arr->readUint(7);
player.curWeapId = arr->readUint(5);
player.isDeveloper = arr->readBit();
player.someInt = arr->readInt(12);
}
return player;
}
PlayerVector deserializePlayers(Serializer::ByteArray barr) {
Serializer arr(barr);
PlayerVector players;
auto version = arr.readUint(8);
auto length = arr.readUint(6);
for (int i = 0; i < length; ++i) {
players.push_back(deserializePlayer(&arr));
}
return players;
}If you have a boolean value, why send it as 8 bits? If you know an integer will only ever go up to a certain value, why serialize it as something that can be way larger? This C++ code makes size optimization for messages and data easier. Why not?
This code inputs and outputs a Serializer::ByteArray (under the hood it is an std::vector<uint8_t>, a vector of bytes). I suppose it could just be an std::string, but it is also not too hard to convert between the two.