Read the whole config

Author: pwalig

src/client.zig

@@ -3,8 +3,10 @@ const Stream = std.net.Stream;
 const Allocator = std.mem.Allocator;
 const print = std.debug.print;
 const Message = @import("message.zig");
-const Game = @import("game.zig").Game;
-const Unit = @import("game.zig").Unit;
+const game = @import("game.zig");
+const Game = game.Game;
+const Unit = game.Unit;
+const Config = game.Config;
 const coordOps = @import("coordinateOps.zig");
 
 const singleReadSize = 50;
@@ -61,12 +63,22 @@ pub const Client = struct {
         switch (t) {
             @intFromEnum(Message.Type.config) => {
                 if (self.state == State.Connected) {
-                    var it = std.mem.tokenizeAny(u8, buff[1..], " ");
-                    _ = it.next(); // skip millis
-                    _ = it.next(); // skip max players
-                    const x = try std.fmt.parseUnsigned(u32, it.next().?, 10);
-                    const y = try std.fmt.parseUnsigned(u32, it.next().?, 10);
-                    self.game = try Game.init(x, y, allocator);
+                    var it = std.mem.tokenizeAny(u8, buff[1..], " \n");
+
+                    const c = Config{
+                        .millis = try std.fmt.parseUnsigned(u32, it.next().?, 10),
+                        .maxPlayers = try std.fmt.parseUnsigned(u32, it.next().?, 10),
+                        .boardX = try std.fmt.parseUnsigned(u32, it.next().?, 10),
+                        .boardY = try std.fmt.parseUnsigned(u32, it.next().?, 10),
+                        .unitsToWin = try std.fmt.parseUnsigned(u32, it.next().?, 10),
+                        .startResources = try std.fmt.parseUnsigned(u32, it.next().?, 10),
+                        .resourceHp = try std.fmt.parseUnsigned(u32, it.next().?, 10),
+                        .unitHp = try std.fmt.parseUnsigned(u32, it.next().?, 10),
+                        .unitDamage = try std.fmt.parseUnsigned(u32, it.next().?, 10),
+                        .allowedNameCharacters = it.next().?,
+                    };
+
+                    self.game = try Game.init(c, allocator);
                     try self.send("n");
                     try self.send(&(self.name));
                     try self.send("\n");

src/game.zig

@@ -4,9 +4,18 @@ const print = std.debug.print;
 const distance = @import("coordinateOps.zig").distance;
 const coords = @import("coordinateOps.zig").coords;
 
-pub const Unit = struct { id: u32 = undefined, hp: u32 = undefined, x: u32 = undefined, y: u32 = undefined, owner: ?*Player = undefined };
+pub const Unit = struct {
+    id: u32 = undefined,
+    hp: u32 = undefined,
+    x: u32 = undefined,
+    y: u32 = undefined,
+    owner: ?*Player = undefined,
+};
 
-pub const Field = struct { unit: ?*Unit, res_hp: ?u32 };
+pub const Field = struct {
+    unit: ?*Unit,
+    res_hp: ?u32,
+};
 
 pub const Board = struct {
     fields: []Field,
@@ -109,14 +118,52 @@ pub const Player = struct {
     }
 };
 
+pub const Config = struct {
+    millis: u32,
+    maxPlayers: u32,
+    boardX: u32,
+    boardY: u32,
+    startResources: u32,
+    unitsToWin: u32,
+    resourceHp: u32,
+    unitHp: u32,
+    unitDamage: u32,
+    allowedNameCharacters: []const u8,
+};
+
 pub const Game = struct {
     board: Board,
     players: std.ArrayList(*Player),
     units: std.AutoHashMap(u32, *Unit),
+
+    unitsToWin: u32,
+    resourceHp: u32,
+    unitHp: u32,
+    unitDamage: u32,
+    allowedNameCharacters: []const u8,
+
     allocator: std.mem.Allocator,
 
-    pub fn init(x: u32, y: u32, allocator: std.mem.Allocator) !Game {
-        return Game{ .board = try Board.init(x, y, allocator), .units = std.AutoHashMap(u32, *Unit).init(allocator), .players = std.ArrayList(*Player).init(allocator), .allocator = allocator };
+    pub fn init(config: Config, allocator: std.mem.Allocator) !Game {
+        var b = try Board.init(config.boardX, config.boardY, allocator);
+        errdefer b.deinit();
+
+        var p = try std.ArrayList(*Player).initCapacity(allocator, config.maxPlayers);
+        errdefer p.deinit();
+
+        return Game{
+            .board = b,
+            .units = std.AutoHashMap(u32, *Unit).init(allocator),
+            .players = p,
+
+            .unitsToWin = config.unitsToWin,
+            .resourceHp = config.resourceHp,
+            .unitHp = config.unitHp,
+            .unitDamage = config.unitDamage,
+            .allowedNameCharacters = try allocator.dupe(u8, config.allowedNameCharacters),
+
+            .allocator = allocator,
+        };
     }
 
     pub fn findPlayer(self: *Game, playerName: []const u8) ?*Player {