why won't it receive?

src/client/main.zig

@@ -2,6 +2,7 @@ const std = @import("std");
 const zm = @import("zmath");
 const znet = @import("znet");
 const rl = @import("raylib");
+const bufzilla = @import("bufzilla");
 
 const shared = @import("shared");
 
@@ -100,12 +101,21 @@ pub fn main() !void {
                 // std.log.info("{}", .{data.peer});
             },
             .disconnect => |data| {
-                // _ = data;
+                _ = data;
-                std.log.info("{}", .{data.peer});
+                // std.log.info("{}", .{data.peer});
             },
             .receive => |data| {
-                std.log.info("{s}", .{data.packet.dataSlice()});
                 defer data.packet.deinit();
+
+                const slice = data.packet.dataSlice();
+
+                std.log.info("{s}", .{slice});
+
+                var reader = bufzilla.Reader(.{}).init(slice);
+
+                const id = try reader.readPath("id");
+
+                std.log.info("{any}", .{id});
             },
         };
 

src/server/chunk.zig

@@ -22,24 +22,21 @@ pub fn spawn(chunk: *shared.chunk.Chunk(), comptime T: type, allocator: std.mem.
     }
 
     // serialize entity
-    const messaged = entity.to_message();
+    var buffer: [128]u8 = undefined;
-    var buffer: [64]u8 = undefined;
     var fixed = std.io.Writer.fixed(&buffer);
+
+    const msg = shared.protocol.makeSpawnMessage(T, entity);
+
     var writer = bufzilla.Writer.init(&fixed);
-    try writer.writeAny(messaged);
+    try writer.writeAny(msg);
 
     const encoded = fixed.buffered();
 
-    std.log.info("\nsending the boy ( {s} )\n", .{encoded});
+    const packet = try znet.Packet.init(encoded, 0, .reliable);
-
     var iterator = server.host.iterPeers();
 
-    std.log.info("iterator length?? ({})", .{iterator.peers.len});
-
     while (iterator.next()) |peer| {
         if (peer.state() == .connected) {
-            std.log.info("peer?? ({})", .{peer});
-            const packet = try znet.Packet.init(encoded, 0, .reliable);
             try peer.send(packet);
         }
     }

src/shared/protocol.zig

@@ -6,47 +6,57 @@ const entity = @import("entity.zig");
 
 pub const SERVER_PORT: u16 = 1337;
 
-pub const MessageType = enum(u8) {
+pub const Message = union(enum) {
-    spawn_entity = 1,
+    spawn_entity: SpawnEntity,
     // later: despawn_entity, update_entity, snapshot, etc.
 };
 
-pub const SpawnEntity = struct {
+pub const SpawnEntity = union(enum) {
-    id: entity.entity_id,
+    elf_v1: Elf_v1,
-    kind: entity.EntityKind,
+    monster_v1: Monster_v1,
-    payload: []const u8,
+    projectile_v1: Projectile_v1,
 };
 
-pub fn write_message(writer: *std.Io.Writer, msg_type: MessageType, payload: []const u8) !void {
+pub fn makeSpawnMessage(comptime T: type, e: T) Message {
-    try writer.writeByte(@intFromEnum(msg_type));
+    if (T == entity.Elf) {
-    try writer.writeInt(u32, @intCast(payload.len), .little);
+        return .{ .spawn_entity = .{ .elf_v1 = Elf_v1.init(e) } };
-    try writer.writeAll(payload);
+    } else if (T == entity.Monster) {
+        return .{ .spawn_entity = .{ .monster_v1 = Monster_v1.init(e) } };
+    } else if (T == entity.Projectile) {
+        return .{ .spawn_entity = .{ .projectile_v1 = Projectile_v1.init(e) } };
+    }
 }
 
-pub fn read_message(reader: *std.Io.Reader, allocator: std.mem.Allocator) !struct {
+// pub fn write_message(writer: *std.Io.Writer, msg_type: MessageType, payload: []const u8) !void {
-    msg_type: MessageType,
+//     try writer.writeByte(@intFromEnum(msg_type));
-    payload: []u8,
+//     try writer.writeInt(u32, @intCast(payload.len), .little);
-} {
+//     try writer.writeAll(payload);
-    const msg_type = try reader.readByte();
+// }
-    const size = try reader.readInt(u32, .little);
 
-    const payload = try allocator.alloc(u8, size);
+// pub fn read_message(reader: *std.Io.Reader, allocator: std.mem.Allocator) !struct {
-    errdefer allocator.free(payload);
+//     msg_type: MessageType,
+//     payload: []u8,
+// } {
+//     const msg_type = try reader.readByte();
+//     const size = try reader.readInt(u32, .little);
 
-    try reader.readNoEof(payload);
+//     const payload = try allocator.alloc(u8, size);
+//     errdefer allocator.free(payload);
 
-    return .{
+//     try reader.readNoEof(payload);
-        .msg_type = @enumFromInt(msg_type),
+
-        .payload = payload,
+//     return .{
-    };
+//         .msg_type = @enumFromInt(msg_type),
-}
+//         .payload = payload,
+//     };
+// }
 
 pub const Elf_v1 = struct {
     id: entity.id = entity.INVALID_ID,
     pos: zm.Vec,
     hp: i32,
 
-    pub fn init(elf: *entity.Elf) Elf_v1 {
+    pub fn init(elf: entity.Elf) Elf_v1 {
         return .{
             .id = elf.id,
             .pos = elf.pos,
@@ -54,17 +64,12 @@ pub const Elf_v1 = struct {
         };
     }
 
-    pub fn encode(self: Elf_v1, w: bufzilla.Writer) !void {
+    pub fn decode(r: *bufzilla.Reader) !Elf_v1 {
-        try w.write(self.id, entity.id);
+        _ = r;
-        //try w.write(self.pos, zm.Vec);
-        try w.write(self.hp, i32);
-    }
-
-    pub fn decode(r: *std.Io.Reader) !Elf_v1 {
         return .{
-            .id = try r.readInt(u64, .little),
+            // .id = try r.readInt(u64, .little),
-            .pos = try readVec4(r),
+            // .pos = try readVec4(r),
-            .vel = try readVec4(r),
+            // .vel = try readVec4(r),
         };
     }
 };
@@ -74,12 +79,20 @@ pub const Monster_v1 = struct {
     pos: zm.Vec,
     hp: i32,
 
-    pub fn encode(self: Monster_v1, w: *std.Io.Writer) !void {
+    pub fn init(monster: entity.Monster) Monster_v1 {
-        try w.writeInt(u64, self.id, .little);
+        return .{
-        try writeVec4(w, self.pos);
+            .id = monster.id,
-        try writeVec4(w, self.vel);
+            .pos = monster.pos,
+            .hp = monster.hp,
+        };
     }
 
+    // pub fn encode(self: Monster_v1, w: *std.Io.Writer) !void {
+    //     try w.writeInt(u64, self.id, .little);
+    //     try writeVec4(w, self.pos);
+    //     try writeVec4(w, self.vel);
+    // }
+
     pub fn decode(r: *std.Io.Reader) !Monster_v1 {
         return .{
             .id = try r.readInt(u64, .little),
@@ -94,12 +107,20 @@ pub const Projectile_v1 = struct {
     pos: zm.Vec,
     vel: zm.Vec,
 
-    pub fn encode(self: Projectile_v1, w: *std.Io.Writer) !void {
+    pub fn init(projectile: entity.Projectile) Projectile_v1 {
-        try w.writeInt(u64, self.id, .little);
+        return .{
-        try writeVec4(w, self.pos);
+            .id = projectile.id,
-        try writeVec4(w, self.vel);
+            .pos = projectile.pos,
+            .vel = projectile.vel,
+        };
     }
 
+    // pub fn encode(self: Projectile_v1, w: *std.Io.Writer) !void {
+    //     try w.writeInt(u64, self.id, .little);
+    //     try writeVec4(w, self.pos);
+    //     try writeVec4(w, self.vel);
+    // }
+
     pub fn decode(r: *std.Io.Reader) !Projectile_v1 {
         return .{
             .id = try r.readInt(u64, .little),