added raylib, enet

src/server/main.zig

@@ -1,11 +1,16 @@
 const std = @import("std");
 const zm = @import("zmath");
+const znet = @import("znet");
+
 const shared = @import("shared");
 
+const chunk = @import("chunk.zig");
+const server = @import("server.zig");
+
 var stdout: *std.io.Writer = undefined;
 
 pub fn main() !void {
-    std.log.info("Helllo Server!", .{});
+    std.log.info("Hello Server!", .{});
     var dbg_allocator = std.heap.DebugAllocator(.{}).init;
     defer _ = dbg_allocator.deinit();
     const allocator = dbg_allocator.allocator();
@@ -14,50 +19,76 @@ pub fn main() !void {
     var stdout_writer = std.fs.File.stdout().writer(&stdout_buffer);
     stdout = &stdout_writer.interface;
 
-    std.log.info("{s}", .{@typeName(shared.chunk.Chunk)});
-
     try stdout.flush();
 
-    const address = try std.net.Address.parseIp4("127.0.0.1", shared.protocol.SERVER_PORT);
-    var server = try address.listen(.{});
+    try znet.init();
+    defer znet.deinit();
 
-    defer server.deinit();
+    const host = try znet.Host.init(.{
+        .addr = try .init(.{
+            .ip = .any,
+            .port = .{ .uint = 5000 },
+        }),
+        .peer_limit = 32,
+        .channel_limit = .max,
+        .incoming_bandwidth = .unlimited,
+        .outgoing_bandwidth = .unlimited,
+    });
+
+    // const address = try std.net.Address.parseIp4("127.0.0.1", shared.protocol.SERVER_PORT);
+    // var tcp_server = try address.listen(.{});
+
+    // defer tcp_server.deinit();
 
     var the_chunk = try shared.chunk.initChunk(allocator);
     defer shared.chunk.deinitChunk(&the_chunk, allocator);
 
-    shared.chunk.spawn(&the_chunk, shared.entity.Player, allocator, .{
-        .pos = zm.f32x4(1, 1, 0, 0),
-        .hp = 10,
-    });
-
-    shared.chunk.spawn(&the_chunk, shared.entity.Monster, allocator, .{
-        .pos = zm.f32x4(1, 1, 0, 0),
-        .hp = 20,
-    });
-
-    shared.chunk.spawn(&the_chunk, shared.entity.Projectile, allocator, .{
-        .pos = zm.f32x4(0, 0, 0, 0),
-        .vel = zm.f32x4(0.2, 0, 0, 0),
-    });
-
-    shared.chunk.updateChunk(&the_chunk);
-
     while (true) {
-        const connection = try server.accept();
-        defer connection.stream.close();
+        while (try host.service(500)) |event| switch (event) {
+            .connect => |data| {
+                _ = data;
+                // std.log.info("{}", .{data.peer});
+            },
+            .disconnect => |data| {
+                _ = data;
+                // std.log.info("{}", .{data.peer});
+            },
+            .receive => |data| {
+                std.log.info("{s}", .{data.packet.dataSlice()});
+                defer data.packet.deinit();
+            },
+        };
 
-        std.log.info("Client connected", .{});
+        // const connection = try tcp_server.accept();
+        // defer connection.stream.close();
 
-        var recv_buffer: [4096]u8 = undefined;
-        var send_buffer: [4096]u8 = undefined;
-        var reader = connection.stream.reader(&recv_buffer);
-        var writer = connection.stream.writer(&send_buffer);
+        // var recv_buffer: [4096]u8 = undefined;
+        // var reader = connection.stream.reader(&recv_buffer);
 
-        const line = try shared.protocol.recvLine(reader.interface());
-        std.log.info("Received: {s}", .{line});
+        // const line = try reader.interface().takeDelimiterExclusive('\n');
+        // std.log.info("Received: {s}", .{line});
 
-        try shared.protocol.sendHello(&writer.interface, .{ .msg = "Hello from server!" });
+        // var send_buffer: [4096]u8 = undefined;
+        // var writer = connection.stream.writer(&send_buffer);
+        // const w = &writer.interface;
+        // try shared.protocol.sendHello(w, .{ .msg = "Hello from server!" });
+
+        // try chunk.spawn(&the_chunk, shared.entity.Player, allocator, .{
+        //     .pos = zm.f32x4(1, 1, 0, 0),
+        //     .hp = 10,
+        // }, w);
+
+        // try chunk.spawn(&the_chunk, shared.entity.Monster, allocator, .{
+        //     .pos = zm.f32x4(1, 1, 0, 0),
+        //     .hp = 20,
+        // }, w);
+
+        // try chunk.spawn(&the_chunk, shared.entity.Projectile, allocator, .{
+        //     .pos = zm.f32x4(0, 0, 0, 0),
+        //     .vel = zm.f32x4(0.2, 0, 0, 0),
+        // }, w);
+
+        shared.chunk.updateChunk(&the_chunk);
     }
 }