Select name from only allowed characters while trying to be as close to zigbot as possible

Author: pwalig

src/Config.zig

@@ -0,0 +1,10 @@
+millis: u32,
+maxPlayers: u32,
+boardX: u32,
+boardY: u32,
+startResources: u32,
+unitsToWin: u32,
+resourceHp: u32,
+unitHp: u32,
+unitDamage: u32,
+allowedNameCharacters: []const u8,

src/NameIterator.zig

@@ -0,0 +1,75 @@
+const std = @import("std");
+const Self = @This();
+
+const prefferedChars = [_][]const u8{
+    "zZ2sS", "iI1lL", "gGqQ", "bB", "oO0Q", "tT7",
+};
+
+name: [9]u8 = [9]u8{ 'z', 'i', 'g', 'b', 'o', 't', '!', '!', '!' },
+allowedChars: []const u8,
+prefferedPos: [6]u8 = [6]u8{ 0, 0, 0, 0, 0, 0 },
+allowedPos: [9]u8 = [9]u8{ 0, 0, 0, 0, 0, 0, 0, 0, 0 },
+charId: u4 = 6,
+nameLen: u4 = 6,
+
+fn in(char: u8, allowed: []const u8) bool {
+    for (allowed) |c| {
+        if (char == c) return true;
+    }
+    return false;
+}
+
+fn fail(self: *Self) bool {
+    for (self.allowedPos) |pos| {
+        if (pos != self.allowedChars.len) return false;
+    }
+    return true;
+}
+
+pub fn init(allowed: []const u8) ?Self {
+    var nameIter = Self{ .allowedChars = allowed };
+
+    for (0..6) |i| {
+        while (!in(nameIter.name[i], allowed)) {
+            nameIter.prefferedPos[i] += 1;
+            if (nameIter.prefferedPos[i] >= prefferedChars[i].len) break;
+            nameIter.name[i] = prefferedChars[i][nameIter.prefferedPos[i]];
+        }
+
+        while (!in(nameIter.name[i], allowed)) {
+            nameIter.allowedPos[i] += 1;
+            if (nameIter.allowedPos[i] >= allowed.len) return null;
+            nameIter.name[i] = allowed[nameIter.allowedPos[i]];
+        }
+    }
+    return nameIter;
+}
+
+pub fn current(self: *Self) []const u8 {
+    return self.name[0..self.nameLen];
+}
+
+pub fn next(self: *Self) ?[]const u8 {
+    if (self.fail()) return null;
+    if (self.charId < prefferedChars.len and self.prefferedPos[self.charId] < prefferedChars[self.charId].len) {
+        self.name[self.charId] = prefferedChars[self.charId][self.prefferedPos[self.charId]]; // TO DO omit unallowed characters
+        self.prefferedPos[self.charId] += 1;
+        self.charId = 6;
+    } else if (self.allowedPos[self.charId] < self.allowedChars.len) {
+        self.nameLen = self.charId + 1;
+        self.name[self.charId] = self.allowedChars[self.allowedPos[self.charId]];
+        self.allowedPos[self.charId] += 1;
+    } else {
+        self.charId += 1;
+        if (self.charId >= self.name.len) {
+            self.charId = 0;
+            self.allowedPos[6] = 0;
+            self.allowedPos[7] = 0;
+            self.allowedPos[8] = 0;
+            self.nameLen = 6;
+        }
+        return self.next();
+    }
+
+    return self.current();
+}

src/client.zig

@@ -6,8 +6,9 @@ const Message = @import("message.zig");
 const game = @import("game.zig");
 const Game = game.Game;
 const Unit = game.Unit;
-const Config = game.Config;
+const Config = @import("Config.zig");
 const coordOps = @import("coordinateOps.zig");
+const NameIterator = @import("NameIterator.zig");
 
 const singleReadSize = 50;
 
@@ -17,7 +18,7 @@ pub const Client = struct {
     stream: Stream,
     state: State,
     game: ?Game = null,
-    name: [7]u8 = [7]u8{ 'z', 'i', 'g', 'b', 'o', 't', '!' },
+    nameIter: NameIterator = undefined,
 
     /// sets up TCP connection
     /// after init .game is still null, .game will be initialized in .parse() if client recieves c message from server
@@ -79,29 +80,34 @@ pub const Client = struct {
                     };
 
                     self.game = try Game.init(c, allocator);
+
+                    self.nameIter = NameIterator.init(self.game.?.allowedNameCharacters).?;
+
                     try self.send("n");
-                    try self.send(&(self.name));
+                    try self.send(self.nameIter.current());
+                    print("requested name: {s}\n", .{self.nameIter.current()});
                     try self.send("\n");
                 }
             },
             @intFromEnum(Message.Type.yes) => {
                 if (self.state == State.Connected) {
                     self.state = State.Ready;
-                    try std.io.getStdOut().writer().print("named self: {s}\njoining...\n", .{self.name});
+                    try std.io.getStdOut().writer().print("named self: {s}\njoining...\n", .{self.nameIter.current()});
                     try self.send("j\n");
                 }
             },
             @intFromEnum(Message.Type.no) => {
                 if (self.state == State.Connected) {
-                    const last = self.name.len - 1;
-                    if (self.name[last] == '~') {
+                    const newName = self.nameIter.next();
+                    if (newName) |name| {
+                        try self.send("n");
+                        try self.send(name);
+                        try self.send("\n");
+                        print("requested name: {s}\n", .{name});
+                    } else {
                         try std.io.getStdOut().writer().print("unable to set a name\nlook into mini-rts-server .config file and make sure characters z, i, g, b, o, t are set as valid name characters or contact your mini-rts-server administrator\nalso make sure not too many zigbots are playing at the same time\n", .{});
                         return error.UnableToNameSelf;
                     }
-                    self.name[last] += 1;
-                    try self.send("n");
-                    try self.send(&self.name);
-                    try self.send("\n");
                 }
             },
             @intFromEnum(Message.Type.queue) => {
@@ -169,11 +175,11 @@ pub const Client = struct {
                 const x = try std.fmt.parseUnsigned(u32, it.next().?, 10);
                 const y = try std.fmt.parseUnsigned(u32, it.next().?, 10);
 
-                try self.game.?.newUnit(playerName, Unit{ .id = id, .x = x, .y = y, .hp = 100 });
+                try self.game.?.newUnit(playerName, Unit{ .id = id, .x = x, .y = y, .hp = self.game.?.unitHp });
             },
             @intFromEnum(Message.Type.leave) => {
                 const playerName = buff[1..]; // player name
-                if (std.mem.eql(u8, playerName, &self.name)) {
+                if (std.mem.eql(u8, playerName, self.nameIter.current())) {
                     try std.io.getStdOut().writer().print("lost all units\nrejoining...\n", .{});
                     self.game.?.clear();
                     self.state = State.Ready;
@@ -191,7 +197,7 @@ pub const Client = struct {
             },
             @intFromEnum(Message.Type.win) => {
                 const playerName = buff[1..]; // player name
-                std.debug.assert(std.mem.eql(u8, playerName, &self.name));
+                std.debug.assert(std.mem.eql(u8, playerName, self.nameIter.current()));
                 try std.io.getStdOut().writer().print("won the game\nrejoining...\n", .{});
                 self.game.?.clear();
                 self.state = State.Ready;
@@ -236,7 +242,7 @@ pub const Client = struct {
                 try self.game.?.newPlayer(buff[1..]);
             },
             @intFromEnum(Message.Type.tick) => {
-                const player = self.game.?.findPlayer(&self.name).?;
+                const player = self.game.?.findPlayer(self.nameIter.current()).?;
                 var it = player.units.valueIterator();
                 while (it.next()) |unit| {
                     const max_len = 10; // TO DO figure out max_len from config sent by server
@@ -273,6 +279,7 @@ pub const Client = struct {
 
     pub fn deinit(self: *Client) void {
         self.stream.close();
+        self.game.?.deinit();
     }
 };
 

src/game.zig

@@ -3,6 +3,7 @@ const testing = std.testing;
 const print = std.debug.print;
 const distance = @import("coordinateOps.zig").distance;
 const coords = @import("coordinateOps.zig").coords;
+const Config = @import("Config.zig");
 
 pub const Unit = struct {
     id: u32 = undefined,
@@ -118,19 +119,6 @@ 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),
@@ -275,6 +263,7 @@ pub const Game = struct {
         self.units.deinit();
 
         self.board.deinit();
+        self.allocator.free(self.allowedNameCharacters);
     }
 };