Update to latest Zig.

Signed-off-by: moderation <[e-mail]>

build.zig

···
 
     const exe = b.addExecutable(.{
         .name = "DOOM-fire",
-        .root_source_file = b.path("src/main.zig"),
-        .target = target,
-        .optimize = optimize,
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("src/main.zig"),
+            .target = target,
+            .optimize = optimize,
+        }),
     });
 
     //libc linking

build.zig.zon

···
 
     // This is a [Semantic Version](https://semver.org/).
     // In a future version of Zig it will be used for package deduplication.
-    .version = "0.14.0",
+    .version = "0.16.0-dev.1364+f0a3df98d",
 
     // Together with name, this represents a globally unique package
     // identifier. This field is generated by the Zig toolchain when the
···
 
     // Tracks the earliest Zig version that the package considers to be a
     // supported use case.
-    .minimum_zig_version = "0.14.0",
+    .minimum_zig_version = "0.16.0-dev.1364+f0a3df98d",
 
     // This field is optional.
     // Each dependency must either provide a `url` and `hash`, or a `path`.

src/main.zig

···
 
 const allocator = std.heap.page_allocator;
 
-var stdout: std.fs.File.Writer = undefined;
-var stdin: std.fs.File.Reader = undefined;
+var stdout_file: std.fs.File = undefined;
+var stdin_file: std.fs.File = undefined;
 var g_tty_win: win32.HANDLE = undefined;
 
 ///////////////////////////////////
···
         }
         return;
     } else {
-        const sz = try stdout.write(s);
-        if (sz == 0) {
-            return;
-        } // cauze I c
+        const sz = try stdout_file.writeAll(s);
+        _ = sz; // ignore return value
         return;
     }
 }
···
 
 pub fn getTermSzWin() !TermSz {
     //Microsoft Windows Case
-    var info: win32.CONSOLE_SCREEN_BUFFER_INFO = .{ .dwSize = .{ .X = 0, .Y = 0 },
-                                                    .dwCursorPosition = .{.X= 0, .Y= 0},
-                                                    .wAttributes= 0,
-                                                    .srWindow = .{ .Left = 0, .Top = 0, .Right = 0, .Bottom = 0},
-                                                    .dwMaximumWindowSize = .{.X = 0, .Y = 0} };
+    var info: win32.CONSOLE_SCREEN_BUFFER_INFO = .{ .dwSize = .{ .X = 0, .Y = 0 }, .dwCursorPosition = .{ .X = 0, .Y = 0 }, .wAttributes = 0, .srWindow = .{ .Left = 0, .Top = 0, .Right = 0, .Bottom = 0 }, .dwMaximumWindowSize = .{ .X = 0, .Y = 0 } };
 
     if (0 == win32.GetConsoleScreenBufferInfo(g_tty_win, &info)) switch (std.os.windows.kernel32.GetLastError()) {
         else => |e| return std.os.windows.unexpectedError(e),
···
     //Linux-MacOS Case
 
     //base case - invoked from cmd line
-    const tty_nix = stdout.context.handle;
+    const tty_nix = std.fs.File.stdout().handle;
     var winsz = std.c.winsize{ .col = 0, .row = 0, .xpixel = 0, .ypixel = 0 };
     const rv = std.c.ioctl(tty_nix, TIOCGWINSZ, @intFromPtr(&winsz));
     const err = std.posix.errno(rv);
···
 
     try emit(color_reset);
     try emit("Press return to continue...");
-    var b: u8 = undefined;
-    b = stdin.readByte() catch undefined;
+    var buffer: [1]u8 = undefined;
+    _ = stdin_file.read(buffer[0..]) catch undefined;
+    const b = buffer[0];
 
     if (b == 'q') {
         //exit cleanly
···
             try emit(line_clear_to_eol);
             try emit(nl);
 
-            std.time.sleep(10 * std.time.ns_per_ms);
+            std.posix.nanosleep(0, 10 * std.time.ns_per_ms);
         }
 
         //let quote chill for a second
-        std.time.sleep(1000 * std.time.ns_per_ms);
+        std.posix.nanosleep(1, 0);
 
         //fade out
         fade_idx = fade_len - 1;
···
             try emit(txt[txt_idx * 2 + 1]);
             try emit(line_clear_to_eol);
             try emit(nl);
-            std.time.sleep(10 * std.time.ns_per_ms);
+            std.posix.nanosleep(0, 10 * std.time.ns_per_ms);
         }
         try emit(nl);
     }
···
 var bs_sz_max: u64 = 0;
 var bs_sz_avg: u64 = 0;
 var bs_frame_tic: u64 = 0;
-var t_start: i64 = 0;
-var t_now: i64 = 0;
+var timer: std.time.Timer = undefined;
 var t_dur: f64 = 0.0;
 var fps: f64 = 0.0;
 
···
     const bs_sz: u64 = screen_sz + overflow_sz;
 
     bs = try allocator.alloc(u8, bs_sz * 2);
-    t_start = std.time.milliTimestamp();
+    timer = try std.time.Timer.start();
     resetBuf();
 }
 
···
 //print buffer to string...can be a decent amount of text!
 pub fn paintBuf() !void {
     try emit(bs[0 .. bs_len - 1]);
-    t_now = std.time.milliTimestamp();
+    const elapsed_ns = timer.read();
     bs_frame_tic += 1;
     if (bs_sz_min == 0) {
         //first frame
···
         bs_sz_avg = bs_sz_avg * (bs_frame_tic - 1) / bs_frame_tic + bs_len / bs_frame_tic;
     }
 
-    t_dur = @as(f64, @floatFromInt(t_now - t_start)) / 1000.0;
+    t_dur = @as(f64, @floatFromInt(elapsed_ns)) / @as(f64, std.time.ns_per_s);
     fps = @as(f64, @floatFromInt(bs_frame_tic)) / t_dur;
 
     try emit(fg[0]);
-    try emitFmt("mem: {s:.2} min / {s:.2} avg / {s:.2} max [ {d:.2} fps ]", .{ std.fmt.fmtIntSizeBin(bs_sz_min), std.fmt.fmtIntSizeBin(bs_sz_avg), std.fmt.fmtIntSizeBin(bs_sz_max), fps });
+    try emitFmt("mem: {d} min / {d} avg / {d} max [ {d:.2} fps ]", .{ bs_sz_min, bs_sz_avg, bs_sz_max, fps });
 }
 
 // initBuf(); defer freeBuf();
···
 ///////////////////////////////////
 
 pub fn main() anyerror!void {
-    stdout = std.io.getStdOut().writer();
-    stdin = std.io.getStdIn().reader();
+    stdout_file = std.fs.File.stdout();
+    stdin_file = std.fs.File.stdin();
 
     try initTerm();
     defer complete() catch {};