.gitignore

@@ -21,6 +21,3 @@ Makefile
 /src/urlg
 /.zig-cache/
 /zig-out/
-/ltximg/
-/assets/
-/notes.org

build.zig

@@ -37,7 +37,6 @@ pub fn build(b: *std.Build) void {
     });
     exe.linkSystemLibrary("c");
     exe.linkSystemLibrary("ncurses");
-    exe.linkSystemLibrary("SDL2");
 
     // This declares intent for the executable to be installed into the
     // standard location when the user invokes the "install" step (the default

src/actions.zig

@@ -1,33 +1,13 @@
-//! This module provides an enum of available actions in game including internal signals.
 const std = @import("std");
 
-/// An enum of available actions in the game
 pub const Action = enum {
-    /// Illegal action. Treated as a noop.
     illegal,
-
-    /// One game tick has finished.
     tick,
-
-    /// Exit the game.
     exit,
-
-    /// Move the player character up one tile.
     move_up,
-
-    /// Move the player character down one tile.
     move_down,
-
-    /// Move the player character left one tile.
     move_left,
-
-    /// Move the player character right one tile.
     move_right,
-
-    /// The player character goes down a flight of stairs.
     down_stair,
-
-    /// The player character goes up a flight of stairs.
-    /// (TODO: possibly merge with down_stair)
     up_stair,
 };

src/ecs/component.zig

@@ -1,7 +1,5 @@
-//! This module provides a basic component interface for an Entity Component System
 const std = @import("std");
 
-/// An empty component for testing purposes
 pub const ComponentStub = struct {
     pub fn init(args: ComponentStub) ComponentStub {
         _ = args;
@@ -13,12 +11,29 @@ pub const ComponentStub = struct {
     }
 };
 
-/// All valid component types are stored in this enum
-pub const ComponentType = enum {
-    component_stub,
+pub const ComponentType = enum(usize) {
+    component_stub = 0,
 };
 
-/// The components are stored as a MultiArrayList over this struct
-pub const Components = struct {
-    component_stub: ?ComponentStub,
+pub const Component = union(ComponentType) {
+    component_stub: ComponentStub,
+
+    pub fn init(t: ComponentType, args: anytype) Component {
+        switch (t) {
+            ComponentType.component_stub => return Component{
+                .component_stub = ComponentStub.init(args),
+            },
+        }
+    }
+
+    pub fn deinit(self: *Component) void {
+        switch (self.*) {
+            .component_stub => |*comp| comp.deinit(),
+        }
+    }
 };
+
+test "stub component" {
+    var stub = Component.init(ComponentType.component_stub, .{});
+    defer stub.deinit();
+}

src/ecs/ecs.zig

@@ -1,162 +1,84 @@
-//! This module provides an implementation of an Entity Component System
 const std = @import("std");
 const component = @import("component.zig");
-const ComponentType = component.ComponentType;
 
-/// EntityComponentSystem keeps track of components in a MultiArrayList of Components.
-/// Each Entity is simply an index into that MultiArrayList of Components.
-/// To save on memory and avoid resizing, ids are recycled upon Entities being deleted.
+const ComponentList = struct {
+    entities: std.AutoHashMap(usize, component.Component),
+};
+
 pub const EntityComponentSystem = struct {
-    /// An allocator for use by the EntityComponentSystem to manage memory
-    allocator: std.mem.Allocator,
-
-    /// The mapping of Components to Entities is in this MultiArrayList
-    components: std.MultiArrayList(component.Components),
-
-    /// Keeps track of ids available for reuse
+    entities: std.ArrayList(usize),
+    components: std.AutoHashMap(usize, ComponentList),
     available_ids: std.ArrayList(usize),
+    next_id: usize,
 
-    fn nullEntity(self: *EntityComponentSystem, entity: usize) void {
-        inline for (std.enums.valuesFromFields(ComponentType, std.meta.fields(ComponentType))) |comp| {
-            self.componentRemoveEntity(comp, entity);
-        }
-    }
-
-    pub fn init(allocator: std.mem.Allocator) EntityComponentSystem {
-        return EntityComponentSystem{
-            .allocator = allocator,
-            .components = .{},
+    pub fn init(allocator: std.mem.Allocator) !EntityComponentSystem {
+        var ecs = EntityComponentSystem{
+            .entities = std.ArrayList(usize).init(allocator),
+            .components = std.AutoHashMap(usize, ComponentList).init(allocator),
             .available_ids = std.ArrayList(usize).init(allocator),
+            .next_id = 0,
         };
+
+        inline for (std.meta.fields(component.ComponentType)) |comp| {
+            try ecs.components.put(comp.value, ComponentList{
+                .entities = std.AutoHashMap(usize, component.Component).init(allocator),
+            });
+        }
+
+        return ecs;
     }
 
     pub fn deinit(self: *EntityComponentSystem) void {
+        self.entities.deinit();
         self.available_ids.deinit();
-        self.components.deinit(self.allocator);
+
+        var component_iterator = self.components.iterator();
+        while (component_iterator.next()) |component_entry| {
+            var comp = component_entry.value_ptr;
+
+            var entity_iterator = comp.entities.iterator();
+            while (entity_iterator.next()) |entity_entry| {
+                var entity = entity_entry.value_ptr;
+
+                entity.deinit();
+            }
+
+            comp.entities.deinit();
+        }
+        self.components.deinit();
     }
 
-    /// Create a new entity (or recycle an old one) and return the id.
-    /// May error if the Allocator runs out of memory.
     pub fn createEntity(self: *EntityComponentSystem) !usize {
-        const id = self.available_ids.popOrNull() orelse noroom: {
-            const id = self.components.len;
-            try self.components.append(self.allocator, undefined);
-            break :noroom id;
-        };
-        self.nullEntity(id);
+        const reuse_id = self.available_ids.popOrNull();
+        if (reuse_id != null and reuse_id.? < self.entities.items.len) {
+            self.entities.items[reuse_id.?] = reuse_id.?;
+            return reuse_id.?;
+        }
+
+        const id = self.next_id;
+        try self.entities.append(id);
+        self.next_id += 1;
         return id;
     }
 
-    /// Add an entity to a component.
-    /// Takes a ComponentType and an entity id along with any arguments needed to initialize the component.
     pub fn componentAddEntity(
         self: *EntityComponentSystem,
         comp: component.ComponentType,
         entity: usize,
         args: anytype,
-    ) void {
-        switch (comp) {
-            ComponentType.component_stub => self.components.items(.component_stub)[entity] = component.ComponentStub.init(args),
-        }
-    }
+    ) !void {
+        var comp_list = self.components.getPtr(@intFromEnum(comp)) orelse return;
 
-    /// Delete an entity and make it ready for recycling by nulling all components.
-    /// Takes an entity id.
-    /// May error if the Allocator runs out of memory.
-    pub fn deleteEntity(self: *EntityComponentSystem, entity: usize) !void {
-        self.nullEntity(entity);
-        try self.available_ids.append(entity);
-    }
-
-    fn componentRemoveEntityGeneric(comp: anytype, entity: usize) void {
-        var fixed_comp = comp[entity] orelse return;
-        fixed_comp.deinit();
-        comp[entity] = null;
-    }
-
-    /// Removes an entity from a component.
-    /// Takes a ComponentType and an entity id.
-    pub fn componentRemoveEntity(
-        self: *EntityComponentSystem,
-        comp: component.ComponentType,
-        entity: usize,
-    ) void {
-        var components = self.components;
-        switch (comp) {
-            ComponentType.component_stub => componentRemoveEntityGeneric(components.items(.component_stub), entity),
-        }
+        try comp_list.entities.put(entity, component.Component.init(comp, args));
     }
 };
 
 test "add entities to components" {
-    var ecs = EntityComponentSystem.init(std.testing.allocator);
-    defer ecs.deinit();
-
-    for (0..100) |i| {
-        const entity = try ecs.createEntity();
-        try std.testing.expectEqual(i, entity);
-        ecs.componentAddEntity(ComponentType.component_stub, entity, .{});
-        try std.testing.expect(ecs.components.items(.component_stub)[entity] != null);
-    }
-}
-
-test "remove entities from components" {
-    var ecs = EntityComponentSystem.init(std.testing.allocator);
+    var ecs = try EntityComponentSystem.init(std.testing.allocator);
     defer ecs.deinit();
 
     const entity = try ecs.createEntity();
-    ecs.componentAddEntity(ComponentType.component_stub, entity, .{});
-    const entity2 = try ecs.createEntity();
-    ecs.componentAddEntity(ComponentType.component_stub, entity2, .{});
+    try std.testing.expectEqual(0, entity);
 
-    try std.testing.expect(ecs.components.items(.component_stub)[entity2] != null);
-    ecs.componentRemoveEntity(ComponentType.component_stub, entity2);
-    try std.testing.expect(ecs.components.items(.component_stub)[entity2] == null);
-}
-
-test "delete entities" {
-    var ecs = EntityComponentSystem.init(std.testing.allocator);
-    defer ecs.deinit();
-
-    const entity = try ecs.createEntity();
-    ecs.componentAddEntity(ComponentType.component_stub, entity, .{});
-    const entity2 = try ecs.createEntity();
-    ecs.componentAddEntity(ComponentType.component_stub, entity2, .{});
-
-    try std.testing.expect(ecs.components.items(.component_stub)[entity2] != null);
-    try ecs.deleteEntity(entity2);
-    try std.testing.expect(ecs.components.items(.component_stub)[entity2] == null);
-    try std.testing.expectEqual(1, ecs.available_ids.items.len);
-}
-
-test "recycle entities" {
-    var ecs = EntityComponentSystem.init(std.testing.allocator);
-    defer ecs.deinit();
-
-    const entity = try ecs.createEntity();
-    ecs.componentAddEntity(ComponentType.component_stub, entity, .{});
-    const entity2 = try ecs.createEntity();
-    ecs.componentAddEntity(ComponentType.component_stub, entity2, .{});
-
-    try ecs.deleteEntity(entity2);
-    try std.testing.expectEqual(1, ecs.available_ids.items.len);
-
-    const entity3 = try ecs.createEntity();
-    try std.testing.expectEqual(1, entity3);
-    try std.testing.expectEqual(0, ecs.available_ids.items.len);
-
-    const entity4 = try ecs.createEntity();
-    try std.testing.expectEqual(2, entity4);
-
-    try ecs.deleteEntity(entity);
-    try std.testing.expectEqual(1, ecs.available_ids.items.len);
-
-    const entity5 = try ecs.createEntity();
-    try std.testing.expectEqual(0, entity5);
-    try std.testing.expectEqual(0, ecs.available_ids.items.len);
-
-    try ecs.deleteEntity(entity5);
-    try ecs.deleteEntity(entity4);
-    try ecs.deleteEntity(entity3);
-    try std.testing.expectEqual(3, ecs.available_ids.items.len);
+    try ecs.componentAddEntity(component.ComponentType.component_stub, entity, .{});
 }

src/frontend/io_interface.zig

@@ -1,50 +0,0 @@
-const std = @import("std");
-const Action = @import("../actions.zig").Action;
-
-pub const IOInterface = struct {
-    ptr: *anyopaque,
-    displayMessageFn: *const fn (ptr: *anyopaque, str: []const u8) anyerror!void,
-    waitForTickFn: *const fn (ptr: *anyopaque) anyerror!Action,
-    deinitFn: *const fn (ptr: *anyopaque) void,
-
-    pub fn init(ptr: anytype) !IOInterface {
-        const T = @TypeOf(ptr);
-        const ptr_info = @typeInfo(T);
-
-        const gen = struct {
-            pub fn displayMessage(pointer: *anyopaque, str: []const u8) anyerror!void {
-                const self: T = @ptrCast(@alignCast(pointer));
-                return ptr_info.Pointer.child.displayMessage(self, str);
-            }
-
-            pub fn waitForTick(pointer: *anyopaque) anyerror!Action {
-                const self: T = @ptrCast(@alignCast(pointer));
-                return ptr_info.Pointer.child.waitForTick(self);
-            }
-
-            pub fn deinit(pointer: *anyopaque) void {
-                const self: T = @ptrCast(@alignCast(pointer));
-                return ptr_info.Pointer.child.deinit(self);
-            }
-        };
-
-        return .{
-            .ptr = ptr,
-            .displayMessageFn = gen.displayMessage,
-            .waitForTickFn = gen.waitForTick,
-            .deinitFn = gen.deinit,
-        };
-    }
-
-    pub fn displayMessage(self: IOInterface, str: []const u8) anyerror!void {
-        return self.displayMessageFn(self.ptr, str);
-    }
-
-    pub fn waitForTick(self: IOInterface) anyerror!Action {
-        return self.waitForTickFn(self.ptr);
-    }
-
-    pub fn deinit(self: IOInterface) void {
-        return self.deinitFn(self.ptr);
-    }
-};

src/frontend/ncurses.zig

@@ -1,5 +1,3 @@
-//! This module provides an implementation of IO using the ncurses library.
-const IOInterface = @import("io_interface.zig").IOInterface;
 const std = @import("std");
 const Action = @import("../actions.zig").Action;
 const ncurses = @cImport({
@@ -19,6 +17,7 @@ const MESSAGE_PANEL_WIDTH = 100;
 const MESSAGE_PANEL_HEIGHT = 3;
 const STATUS_PANEL_WIDTH = 32;
 const STATUS_PANEL_HEIGHT = 5;
+
 const MIN_WIDTH = MAIN_PANEL_WIDTH + INSTRUCTION_PANEL_WIDTH;
 const MIN_HEIGHT = MAIN_PANEL_HEIGHT + MESSAGE_PANEL_HEIGHT;
 
@@ -30,35 +29,30 @@ const KEY_STAIR_UP: i32 = '<';
 const KEY_STAIR_DOWN: i32 = '>';
 const KEY_QUIT: i32 = ncurses.KEY_F(1);
 
-/// Provide an IO struct that manages the state of the display and user input
 pub const IO = struct {
-    allocator: std.mem.Allocator,
     main: ?*ncurses.WINDOW,
     inst: ?*ncurses.WINDOW,
     msgs: ?*ncurses.WINDOW,
     stat: ?*ncurses.WINDOW,
     prev_tick_time: i64,
 
-    fn validTermSize(self: *IO) bool {
-        _ = self; // should be uncallable without initialization
+    fn validTermSize() bool {
         return ncurses.LINES >= MIN_HEIGHT and
             ncurses.COLS >= MIN_WIDTH;
     }
 
-    fn colorSupport(self: *IO) bool {
-        _ = self; // should be uncallable without initialization
+    fn colorSupport() bool {
         return ncurses.has_colors();
     }
 
-    fn createNewWin(self: *IO, height: i32, width: i32, y: i32, x: i32) ?*ncurses.WINDOW {
-        _ = self; // should be uncallable without initialization
+    fn createNewWin(height: i32, width: i32, y: i32, x: i32) ?*ncurses.WINDOW {
         const local_win = ncurses.newwin(height, width, y, x);
         _ = ncurses.box(local_win, 0, 0);
         _ = ncurses.wrefresh(local_win);
         return local_win;
     }
 
-    fn formatInstruction(self: *IO, pos: i32, key: i32, description: [:0]const u8) !void {
+    fn formatInstruction(self: *IO, pos: i32, key: i32, description: [:0]const u8) void {
         const c_description: ?[*:0]const u8 = description.ptr;
 
         if (ncurses.KEY_F0 <= key and key <= ncurses.KEY_F(64)) {
@@ -66,22 +60,11 @@ pub const IO = struct {
         } else if (key < 128) {
             _ = ncurses.mvwprintw(self.inst, pos, 2, "%c - %s", key, c_description);
         } else {
-            const str = std.fmt.allocPrint(self.allocator, "Invalid key name: {d}", .{key}) catch {
-                return error.OutOfMemory;
-            };
-            defer self.allocator.free(str);
-            try self.displayMessage(str);
+            self.displayMessage("Invalid key name: {d}", .{key});
         }
     }
 
-    fn createPanels(self: *IO) !void {
-        try self.createInstructionPanel();
-        self.createMessagePanel();
-        self.createStatisticsPanel();
-        self.createMainPanel();
-    }
-
-    fn handleResize(self: *IO) !Action {
+    fn handleResize(self: *IO) Action {
         const lines = @as(usize, @intCast(ncurses.LINES));
         const cols = @as(usize, @intCast(ncurses.COLS));
         for (0..lines) |i| {
@@ -95,10 +78,14 @@ pub const IO = struct {
 
         self.deleteWindows();
 
-        if (!self.validTermSize()) {
+        if (!validTermSize()) {
             _ = ncurses.mvprintw(0, 0, "Terminal must be at least %dx%d", @as(i32, @intCast(MIN_WIDTH)), @as(i32, @intCast(MIN_HEIGHT)));
         } else {
-            try self.createPanels();
+            self.inst = createInstructionPanel();
+            self.msgs = createMessagePanel();
+            self.stat = createStatisticsPanel();
+            self.main = createMainPanel();
+            self.displayInstructions();
         }
 
         _ = ncurses.refresh();
@@ -106,21 +93,18 @@ pub const IO = struct {
         return Action.illegal;
     }
 
-    fn displayInstructions(self: *IO) !void {
-        try self.formatInstruction(1, KEY_MOVE_LEFT, "move left");
-        try self.formatInstruction(2, KEY_MOVE_DOWN, "move down");
-        try self.formatInstruction(3, KEY_MOVE_UP, "move up");
-        try self.formatInstruction(4, KEY_MOVE_RIGHT, "move right");
-        try self.formatInstruction(5, KEY_STAIR_DOWN, "move down staircase");
-        try self.formatInstruction(6, KEY_STAIR_UP, "move up staircase");
-        try self.formatInstruction(7, KEY_QUIT, "quit");
+    pub fn displayInstructions(self: *IO) void {
+        self.formatInstruction(1, KEY_MOVE_LEFT, "move left");
+        self.formatInstruction(2, KEY_MOVE_DOWN, "move down");
+        self.formatInstruction(3, KEY_MOVE_UP, "move up");
+        self.formatInstruction(4, KEY_MOVE_RIGHT, "move right");
+        self.formatInstruction(5, KEY_STAIR_DOWN, "move down staircase");
+        self.formatInstruction(6, KEY_STAIR_UP, "move up staircase");
+        self.formatInstruction(7, KEY_QUIT, "quit");
         _ = ncurses.wrefresh(self.inst);
     }
 
-    /// Display a message in the message box.
-    /// Takes a pre-formatted null-terminated string
-    /// If the message is too wide for the box, display "Message too long" instead.
-    pub fn displayMessage(self: *IO, str: []const u8) anyerror!void {
+    pub fn displayMessage(self: *IO, comptime fmt: []const u8, args: anytype) void {
         if (self.msgs == null) return;
 
         for (1..MESSAGE_PANEL_WIDTH - 1) |i| {
@@ -128,14 +112,12 @@ pub const IO = struct {
             _ = ncurses.mvwaddch(self.msgs, 1, i_32, ' ');
         }
 
-        if (str.len > MESSAGE_PANEL_WIDTH - 2) {
-            try self.displayMessage("Message too long");
-            return;
-        }
-
         var buf: [MESSAGE_PANEL_WIDTH:0]u8 = undefined;
-        std.mem.copyForwards(u8, &buf, str);
-        buf[str.len] = 0;
+        const data = std.fmt.bufPrint(&buf, fmt, args) catch {
+            self.displayMessage("Message too long", .{});
+            return;
+        };
+        buf[data.len] = 0;
 
         const msg: [:0]u8 = &buf;
 
@@ -144,7 +126,7 @@ pub const IO = struct {
         _ = ncurses.wrefresh(self.msgs);
     }
 
-    fn displayStatus(self: *IO) void {
+    pub fn displayStatus(self: *IO) void {
         for (1..STATUS_PANEL_HEIGHT - 1) |i| {
             for (1..STATUS_PANEL_WIDTH - 1) |j| {
                 const i_32 = @as(i32, @intCast(i));
@@ -153,21 +135,14 @@ pub const IO = struct {
             }
         }
 
-        // TODO: Implement
-
         _ = ncurses.wrefresh(self.stat);
     }
 
-    /// An interface for user input and time processing.
-    /// Waits for the end of a tick and returns a tick action.
-    /// If input is given before the end of the tick, return that instead.
-    pub fn waitForTick(self: *IO) anyerror!Action {
+    pub fn waitForTick(self: *IO) Action {
         var new = std.time.milliTimestamp();
 
         while (new - self.prev_tick_time <= TICK_MS) {
-            const action = self.processInput() catch |err| {
-                return err;
-            };
+            const action = self.processInput();
             if (action != Action.illegal) return action;
 
             new = std.time.milliTimestamp();
@@ -177,10 +152,10 @@ pub const IO = struct {
         return Action.tick;
     }
 
-    fn processInput(self: *IO) !Action {
+    fn processInput(self: *IO) Action {
         const ch = ncurses.getch();
 
-        if (!self.validTermSize()) {
+        if (!validTermSize()) {
             if (ch != KEY_QUIT and ch != ncurses.KEY_RESIZE) return Action.illegal;
         }
 
@@ -197,20 +172,17 @@ pub const IO = struct {
         };
     }
 
-    fn createInstructionPanel(self: *IO) !void {
-        self.inst = self.createNewWin(
+    fn createInstructionPanel() ?*ncurses.WINDOW {
+        return createNewWin(
             INSTRUCTION_PANEL_HEIGHT,
             INSTRUCTION_PANEL_WIDTH,
             @divTrunc(ncurses.LINES - INSTRUCTION_PANEL_HEIGHT - STATUS_PANEL_HEIGHT, 2) + 1,
             @divTrunc(ncurses.COLS - MAIN_PANEL_WIDTH - INSTRUCTION_PANEL_WIDTH, 2) + MAIN_PANEL_WIDTH - 1,
         );
-        if (self.inst != null) {
-            try self.displayInstructions();
-        }
     }
 
-    fn createMessagePanel(self: *IO) void {
-        self.msgs = self.createNewWin(
+    fn createMessagePanel() ?*ncurses.WINDOW {
+        return createNewWin(
             MESSAGE_PANEL_HEIGHT,
             MESSAGE_PANEL_WIDTH,
             @divTrunc(ncurses.LINES - MAIN_PANEL_HEIGHT - MESSAGE_PANEL_HEIGHT, 2) + MAIN_PANEL_HEIGHT,
@@ -218,8 +190,8 @@ pub const IO = struct {
         );
     }
 
-    fn createStatisticsPanel(self: *IO) void {
-        self.stat = self.createNewWin(
+    fn createStatisticsPanel() ?*ncurses.WINDOW {
+        return createNewWin(
             STATUS_PANEL_HEIGHT,
             STATUS_PANEL_WIDTH,
             @divTrunc(ncurses.LINES - INSTRUCTION_PANEL_HEIGHT - STATUS_PANEL_HEIGHT, 2) + INSTRUCTION_PANEL_HEIGHT,
@@ -227,8 +199,8 @@ pub const IO = struct {
         );
     }
 
-    fn createMainPanel(self: *IO) void {
-        self.main = self.createNewWin(
+    fn createMainPanel() ?*ncurses.WINDOW {
+        return createNewWin(
             MAIN_PANEL_HEIGHT,
             MAIN_PANEL_WIDTH,
             @divTrunc(ncurses.LINES - MAIN_PANEL_HEIGHT - MESSAGE_PANEL_HEIGHT, 2) + 1,
@@ -236,22 +208,13 @@ pub const IO = struct {
         );
     }
 
-    pub fn init(allocator: std.mem.Allocator) !IOInterface {
+    pub fn init() !IO {
         _ = locale.setlocale(locale.LC_ALL, "");
-
-        var io = try allocator.create(IO);
-        io.allocator = allocator;
-        io.inst = null;
-        io.msgs = null;
-        io.stat = null;
-        io.main = null;
-        io.prev_tick_time = std.time.milliTimestamp();
-
         if (ncurses.initscr() == null) {
             return error.CursesInitFail;
         }
 
-        if (!io.colorSupport()) {
+        if (!colorSupport()) {
             _ = ncurses.endwin();
             return error.NoColorSupport;
         }
@@ -268,13 +231,29 @@ pub const IO = struct {
         _ = ncurses.wattron(ncurses.stdscr, ncurses.COLOR_PAIR(1));
         _ = ncurses.refresh();
 
-        if (!io.validTermSize()) {
+        var io: IO = undefined;
+
+        if (!validTermSize()) {
             _ = ncurses.mvprintw(0, 0, "Terminal must be at least %dx%d", @as(i32, @intCast(MIN_WIDTH)), @as(i32, @intCast(MIN_HEIGHT)));
+            io = IO{
+                .inst = null,
+                .msgs = null,
+                .stat = null,
+                .main = null,
+                .prev_tick_time = std.time.milliTimestamp(),
+            };
         } else {
-            try io.createPanels();
+            io = IO{
+                .inst = createInstructionPanel(),
+                .msgs = createMessagePanel(),
+                .stat = createStatisticsPanel(),
+                .main = createMainPanel(),
+                .prev_tick_time = std.time.milliTimestamp(),
+            };
+            io.displayInstructions();
         }
 
-        return IOInterface.init(io);
+        return io;
     }
 
     fn deleteWindows(self: *IO) void {
@@ -291,6 +270,5 @@ pub const IO = struct {
     pub fn deinit(self: *IO) void {
         self.deleteWindows();
         _ = ncurses.endwin();
-        self.allocator.destroy(self);
     }
 };

src/frontend/sdl.zig

@@ -1,80 +0,0 @@
-const std = @import("std");
-const sdl = @cImport({
-    @cInclude("SDL.h");
-});
-const Action = @import("../actions.zig").Action;
-const IOInterface = @import("io_interface.zig").IOInterface;
-
-pub const IO = struct {
-    allocator: std.mem.Allocator,
-    screen: ?*sdl.SDL_Window,
-    sprites: std.ArrayList([*c]sdl.SDL_Surface),
-
-    fn loadSprite(self: *IO) !void {
-        const sprite = sdl.SDL_LoadBMP("assets/image.bmp");
-        if (sprite == null) return error.FailedToLoadSprite;
-        try self.sprites.append(sprite);
-    }
-
-    pub fn displayMessage(self: *IO, str: []const u8) anyerror!void {
-        _ = self;
-        _ = str;
-
-        // TODO
-    }
-
-    pub fn waitForTick(self: *IO) anyerror!Action {
-        _ = self;
-
-        var quit = false;
-        var event: sdl.SDL_Event = undefined;
-        while (!quit) {
-            _ = sdl.SDL_WaitEvent(&event);
-            switch (event.type) {
-                sdl.SDL_QUIT => quit = true,
-                else => {},
-            }
-        }
-
-        return Action.exit;
-    }
-
-    pub fn init(allocator: std.mem.Allocator) !IOInterface {
-        var io = try allocator.create(IO);
-        io.allocator = allocator;
-        io.sprites = std.ArrayList([*c]sdl.SDL_Surface).init(allocator);
-
-        if (sdl.SDL_Init(sdl.SDL_INIT_VIDEO) < 0) return error.SDL_Failed;
-
-        io.screen = sdl.SDL_CreateWindow(
-            "urlg",
-            sdl.SDL_WINDOWPOS_UNDEFINED,
-            sdl.SDL_WINDOWPOS_UNDEFINED,
-            640,
-            480,
-            0,
-        );
-
-        io.loadSprite() catch |err| {
-            io.deinit();
-            return err;
-        };
-        const screen_surface = sdl.SDL_GetWindowSurface(io.screen);
-        _ = sdl.SDL_BlitSurface(io.sprites.items[0], null, screen_surface, null);
-        _ = sdl.SDL_UpdateWindowSurface(io.screen);
-
-        return IOInterface.init(io);
-    }
-
-    pub fn deinit(self: *IO) void {
-        for (self.sprites.items) |sprite| {
-            _ = sdl.SDL_FreeSurface(sprite);
-        }
-        self.sprites.deinit();
-
-        _ = sdl.SDL_DestroyWindow(self.screen);
-
-        _ = sdl.SDL_Quit();
-        self.allocator.destroy(self);
-    }
-};

src/frontend/stub.zig

@@ -1,57 +0,0 @@
-const std = @import("std");
-const Action = @import("../actions.zig").Action;
-const IOInterface = @import("io_interface.zig").IOInterface;
-
-pub const ActionStack = struct {
-    stream: std.ArrayList(Action),
-
-    pub fn init(allocator: std.mem.Allocator) ActionStack {
-        return ActionStack{
-            .stream = std.ArrayList(Action).init(allocator),
-        };
-    }
-
-    pub fn deinit(self: *ActionStack) void {
-        self.stream.deinit();
-    }
-
-    pub fn scheduleAction(self: *ActionStack, action: Action) !void {
-        try self.stream.append(action);
-    }
-
-    pub fn next(self: *ActionStack) ?Action {
-        return self.stream.popOrNull();
-    }
-};
-
-pub const IO = struct {
-    allocator: std.mem.Allocator,
-    as: ActionStack,
-    out_as: ActionStack,
-
-    pub fn displayMessage(self: *IO, str: []const u8) anyerror!void {
-        _ = self;
-        std.log.info("{s}\n", .{str});
-    }
-
-    pub fn waitForTick(self: *IO) anyerror!Action {
-        const a = self.as.next() orelse return error.NoAvailableAction;
-
-        try self.out_as.scheduleAction(a);
-
-        return a;
-    }
-
-    pub fn init(allocator: std.mem.Allocator, as: ActionStack) !IOInterface {
-        var io = try allocator.create(IO);
-        io.allocator = allocator;
-        io.as = as;
-        io.out_as = ActionStack.init(allocator);
-        return IOInterface.init(io);
-    }
-
-    pub fn deinit(self: *IO) void {
-        self.out_as.deinit();
-        self.allocator.destroy(self);
-    }
-};

src/main.zig

@@ -1,26 +1,29 @@
 const std = @import("std");
-const IO = @import("frontend/sdl.zig").IO;
-const run = @import("run.zig");
+const IO = @import("frontend/ncurses.zig").IO;
+const Action = @import("actions.zig").Action;
 
 pub fn main() u8 {
-    var status: u8 = 0;
-
-    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
-    const allocator = gpa.allocator();
-    defer {
-        const deinit_status = gpa.deinit();
-        if (deinit_status == .leak) {
-            status = 1;
-        }
-    }
-
-    var io = IO.init(allocator) catch |err| {
-        std.log.err("Failed to initialize: {}", .{err});
+    var io = IO.init() catch |err| {
+        std.log.err("{}", .{err});
         return 1;
     };
     defer io.deinit();
 
-    run.run(allocator, &io) catch return 1;
+    io.displayMessage("Initialized", .{});
 
-    return status;
+    var action = Action.illegal;
+    var tick_count: usize = 0;
+    while (action != Action.exit) {
+        io.displayMessage("{}", .{tick_count});
+        action = io.waitForTick();
+        switch (action) {
+            Action.tick => {
+                io.displayMessage("{}", .{tick_count});
+                tick_count += 1;
+            },
+            else => io.displayMessage("{}", .{tick_count}),
+        }
+    }
+
+    return 0;
 }

src/root.zig

@@ -3,10 +3,8 @@ const testing = std.testing;
 
 const component = @import("ecs/component.zig");
 const ecs = @import("ecs/ecs.zig");
-const run = @import("run.zig");
 
 test {
     _ = component;
     _ = ecs;
-    _ = run;
 }

src/run.zig

@@ -1,93 +0,0 @@
-const std = @import("std");
-const stub = @import("frontend/stub.zig");
-const IO = @import("frontend/io_interface.zig").IOInterface;
-const Action = @import("actions.zig").Action;
-
-pub fn run(allocator: std.mem.Allocator, io: *IO) !void {
-    try io.displayMessage("Initialized");
-
-    var action = Action.illegal;
-    var tick_count: usize = 0;
-    while (action != Action.exit) {
-        const str = try std.fmt.allocPrint(allocator, "{}", .{tick_count});
-        defer allocator.free(str);
-        try io.displayMessage(str);
-
-        action = try io.waitForTick();
-        switch (action) {
-            Action.tick => {
-                tick_count += 1;
-            },
-            else => {},
-        }
-    }
-}
-
-test "can run game" {
-    const allocator = std.testing.allocator;
-
-    var as = stub.ActionStack.init(allocator);
-    defer as.deinit();
-
-    var io = try stub.IO.init(allocator, as);
-    defer io.deinit();
-
-    var res: ?anyerror = null;
-    run(allocator, &io) catch |err| {
-        res = err;
-    };
-    try std.testing.expect(res != null);
-    try std.testing.expectEqual(error.NoAvailableAction, res.?);
-}
-
-test "game exits on Action.exit" {
-    const allocator = std.testing.allocator;
-
-    var as = stub.ActionStack.init(allocator);
-    defer as.deinit();
-    try as.scheduleAction(Action.exit);
-
-    var io = try stub.IO.init(allocator, as);
-    defer io.deinit();
-
-    try run(allocator, &io);
-    const io_obj: *const stub.IO = @ptrCast(@alignCast(io.ptr));
-    var actions = io_obj.out_as;
-
-    const act = actions.next().?;
-    try std.testing.expectEqual(Action.exit, act);
-}
-
-test "game processes stream of actions" {
-    const allocator = std.testing.allocator;
-
-    var as = stub.ActionStack.init(allocator);
-    defer as.deinit();
-
-    try as.scheduleAction(Action.exit);
-    try as.scheduleAction(Action.move_right);
-    try as.scheduleAction(Action.move_left);
-    try as.scheduleAction(Action.move_down);
-    try as.scheduleAction(Action.move_up);
-    try as.scheduleAction(Action.tick);
-
-    var io = try stub.IO.init(allocator, as);
-    defer io.deinit();
-
-    try run(allocator, &io);
-    const io_obj: *const stub.IO = @ptrCast(@alignCast(io.ptr));
-    var actions = io_obj.out_as;
-
-    var act = actions.next().?;
-    try std.testing.expectEqual(Action.exit, act);
-    act = actions.next().?;
-    try std.testing.expectEqual(Action.move_right, act);
-    act = actions.next().?;
-    try std.testing.expectEqual(Action.move_left, act);
-    act = actions.next().?;
-    try std.testing.expectEqual(Action.move_down, act);
-    act = actions.next().?;
-    try std.testing.expectEqual(Action.move_up, act);
-    act = actions.next().?;
-    try std.testing.expectEqual(Action.tick, act);
-}