Protocol Struct Interface

Every generated protocol struct and packet type implements the EoSerialize interface (and packets also implement EoPacket). This gives a uniform API for all ~400 generated types without individual exported serialize/deserialize/free symbols per type.

Initialization

Every type has a static inline TypeName_init() function declared in protocol.h. It returns a zero-initialized struct with its internal vtable pointer already set:

Coords coords         = Coords_init();          // plain struct
LoginRequestClientPacket pkt = LoginRequestClientPacket_init(); // packet
Eif eif               = Eif_init();             // pub/map file struct

Note

Never use = {0} to initialize a generated struct. That zeroes the vtable pointer, which will cause a null-pointer dereference the first time any eo_* function is called on it.

Dispatch Functions

All operations go through the EoSerialize vtable via the following inline dispatch helpers declared in data.h:

Function	Description
eo_deserialize()	Read fields from an EoReader
eo_serialize()	Write fields to an EoWriter
eo_get_size()	Return the exact serialized byte count
eo_free()	Release any heap-allocated fields

All four accept a pointer-to-EoSerialize as their first argument. Cast any generated struct or packet to (EoSerialize *) (or (const EoSerialize *) for read-only operations):

LoginRequestClientPacket pkt = LoginRequestClientPacket_init();
 
// Deserialize
EoResult r = eo_deserialize((EoSerialize *)&pkt, &reader);
 
// Query size
size_t sz = eo_get_size((const EoSerialize *)&pkt);
 
// Serialize
EoWriter writer = eo_writer_init_with_capacity(sz);
eo_serialize((const EoSerialize *)&pkt, &writer);
 
// Free heap fields when done
eo_free((EoSerialize *)&pkt);
eo_writer_free(&writer);

Packet-Specific Dispatch

Packet types additionally implement EoPacket, which carries a second vtable with get_family and get_action slots. Use the packet dispatch helpers to query the hard-coded family/action values without inspecting enum constants manually:

LoginRequestClientPacket pkt = LoginRequestClientPacket_init();
 
uint8_t family = eo_packet_get_family((const EoPacket *)&pkt);
uint8_t action = eo_packet_get_action((const EoPacket *)&pkt);
// family == PACKET_FAMILY_LOGIN, action == PACKET_ACTION_REQUEST

Writing Generic Code

Because every struct shares the EoSerialize base, you can write helpers that operate on any struct without knowing its concrete type:

// Serialize any struct to a newly-allocated byte buffer.
static uint8_t *to_bytes(const EoSerialize *s, size_t *out_len) {
    size_t sz = eo_get_size(s);
    EoWriter writer = eo_writer_init_with_capacity(sz);
    if (eo_serialize(s, &writer) != EO_SUCCESS) {
        eo_writer_free(&writer);
        return NULL;
    }
    uint8_t *buf = malloc(writer.length);
    if (buf) {
        memcpy(buf, writer.data, writer.length);
        *out_len = writer.length;
    }
    eo_writer_free(&writer);
    return buf;
}
 
// Usage with any generated type:
LoginRequestClientPacket pkt = LoginRequestClientPacket_init();
pkt.username = "Admin";
pkt.password = "hunter2";
 
size_t len;
uint8_t *bytes = to_bytes((const EoSerialize *)&pkt, &len);
// use bytes...
free(bytes);
eo_free((EoSerialize *)&pkt);

Memory Layout

The C "inheritance by first-member" rule guarantees the casts above are safe. The generated struct layout is:

// Plain struct (e.g. Coords):
typedef struct Coords {
    EoSerialize _eo;  // vtable pointer — must be first
    int32_t x;
    int32_t y;
} Coords;
 
// Packet (e.g. LoginRequestClientPacket):
typedef struct LoginRequestClientPacket {
    EoPacket _eo;   // EoPacket.base is EoSerialize — must be first
    char *username;
    char *password;
} LoginRequestClientPacket;

Since _eo is always the first member, a pointer to the struct and a pointer to its _eo field have the same address. For packets the chain is LoginRequestClientPacket → EoPacket → EoSerialize, so (EoSerialize *)&pkt resolves all three levels correctly.

Note

The _eo member is an implementation detail. Do not read or write it directly — always use the _init() function and the eo_* dispatch helpers.