add sdl2 to build.zig

.gitignore

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

build.zig

@@ -37,6 +37,7 @@ 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,13 +1,33 @@
+//! 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,5 +1,7 @@
+//! 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;
@@ -11,29 +13,12 @@ pub const ComponentStub = struct {
     }
 };
 
-pub const ComponentType = enum(usize) {
+/// All valid component types are stored in this enum
-    component_stub = 0,
+pub const ComponentType = enum {
+    component_stub,
 };
 
-pub const Component = union(ComponentType) {
+/// The components are stored as a MultiArrayList over this struct
-    component_stub: ComponentStub,
+pub const Components = struct {
-
+    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,84 +1,162 @@
+//! This module provides an implementation of an Entity Component System
 const std = @import("std");
 const component = @import("component.zig");
+const ComponentType = component.ComponentType;
 
-const ComponentList = struct {
+/// EntityComponentSystem keeps track of components in a MultiArrayList of Components.
-    entities: std.AutoHashMap(usize, component.Component),
+/// 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.
-
 pub const EntityComponentSystem = struct {
-    entities: std.ArrayList(usize),
+    /// An allocator for use by the EntityComponentSystem to manage memory
-    components: std.AutoHashMap(usize, ComponentList),
+    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
     available_ids: std.ArrayList(usize),
-    next_id: usize,
 
-    pub fn init(allocator: std.mem.Allocator) !EntityComponentSystem {
+    fn nullEntity(self: *EntityComponentSystem, entity: usize) void {
-        var ecs = EntityComponentSystem{
+        inline for (std.enums.valuesFromFields(ComponentType, std.meta.fields(ComponentType))) |comp| {
-            .entities = std.ArrayList(usize).init(allocator),
+            self.componentRemoveEntity(comp, entity);
-            .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 init(allocator: std.mem.Allocator) EntityComponentSystem {
+        return EntityComponentSystem{
+            .allocator = allocator,
+            .components = .{},
+            .available_ids = std.ArrayList(usize).init(allocator),
+        };
     }
 
     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 reuse_id = self.available_ids.popOrNull();
+        const id = self.available_ids.popOrNull() orelse noroom: {
-        if (reuse_id != null and reuse_id.? < self.entities.items.len) {
+            const id = self.components.len;
-            self.entities.items[reuse_id.?] = reuse_id.?;
+            try self.components.append(self.allocator, undefined);
-            return reuse_id.?;
+            break :noroom id;
-        }
+        };
-
+        self.nullEntity(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 {
+    ) void {
-        var comp_list = self.components.getPtr(@intFromEnum(comp)) orelse return;
+        switch (comp) {
+            ComponentType.component_stub => self.components.items(.component_stub)[entity] = component.ComponentStub.init(args),
+        }
+    }
 
-        try comp_list.entities.put(entity, component.Component.init(comp, args));
+    /// 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),
+        }
     }
 };
 
 test "add entities to components" {
-    var ecs = try EntityComponentSystem.init(std.testing.allocator);
+    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);
     defer ecs.deinit();
 
     const entity = try ecs.createEntity();
-    try std.testing.expectEqual(0, entity);
+    ecs.componentAddEntity(ComponentType.component_stub, entity, .{});
+    const entity2 = try ecs.createEntity();
+    ecs.componentAddEntity(ComponentType.component_stub, entity2, .{});
 
-    try ecs.componentAddEntity(component.ComponentType.component_stub, 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);
 }

src/frontend/io_interface.zig

@@ -0,0 +1,50 @@
+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,3 +1,5 @@
+//! 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({
@@ -17,7 +19,6 @@ 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;
 
@@ -29,30 +30,35 @@ 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() bool {
+    fn validTermSize(self: *IO) bool {
+        _ = self; // should be uncallable without initialization
         return ncurses.LINES >= MIN_HEIGHT and
             ncurses.COLS >= MIN_WIDTH;
     }
 
-    fn colorSupport() bool {
+    fn colorSupport(self: *IO) bool {
+        _ = self; // should be uncallable without initialization
         return ncurses.has_colors();
     }
 
-    fn createNewWin(height: i32, width: i32, y: i32, x: i32) ?*ncurses.WINDOW {
+    fn createNewWin(self: *IO, height: i32, width: i32, y: i32, x: i32) ?*ncurses.WINDOW {
+        _ = self; // should be uncallable without initialization
         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)) {
@@ -60,11 +66,22 @@ pub const IO = struct {
         } else if (key < 128) {
             _ = ncurses.mvwprintw(self.inst, pos, 2, "%c - %s", key, c_description);
         } else {
-            self.displayMessage("Invalid key name: {d}", .{key});
+            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);
         }
     }
 
-    fn handleResize(self: *IO) Action {
+    fn createPanels(self: *IO) !void {
+        try self.createInstructionPanel();
+        self.createMessagePanel();
+        self.createStatisticsPanel();
+        self.createMainPanel();
+    }
+
+    fn handleResize(self: *IO) !Action {
         const lines = @as(usize, @intCast(ncurses.LINES));
         const cols = @as(usize, @intCast(ncurses.COLS));
         for (0..lines) |i| {
@@ -78,14 +95,10 @@ pub const IO = struct {
 
         self.deleteWindows();
 
-        if (!validTermSize()) {
+        if (!self.validTermSize()) {
             _ = ncurses.mvprintw(0, 0, "Terminal must be at least %dx%d", @as(i32, @intCast(MIN_WIDTH)), @as(i32, @intCast(MIN_HEIGHT)));
         } else {
-            self.inst = createInstructionPanel();
+            try self.createPanels();
-            self.msgs = createMessagePanel();
-            self.stat = createStatisticsPanel();
-            self.main = createMainPanel();
-            self.displayInstructions();
         }
 
         _ = ncurses.refresh();
@@ -93,18 +106,21 @@ pub const IO = struct {
         return Action.illegal;
     }
 
-    pub fn displayInstructions(self: *IO) void {
+    fn displayInstructions(self: *IO) !void {
-        self.formatInstruction(1, KEY_MOVE_LEFT, "move left");
+        try self.formatInstruction(1, KEY_MOVE_LEFT, "move left");
-        self.formatInstruction(2, KEY_MOVE_DOWN, "move down");
+        try self.formatInstruction(2, KEY_MOVE_DOWN, "move down");
-        self.formatInstruction(3, KEY_MOVE_UP, "move up");
+        try self.formatInstruction(3, KEY_MOVE_UP, "move up");
-        self.formatInstruction(4, KEY_MOVE_RIGHT, "move right");
+        try self.formatInstruction(4, KEY_MOVE_RIGHT, "move right");
-        self.formatInstruction(5, KEY_STAIR_DOWN, "move down staircase");
+        try self.formatInstruction(5, KEY_STAIR_DOWN, "move down staircase");
-        self.formatInstruction(6, KEY_STAIR_UP, "move up staircase");
+        try self.formatInstruction(6, KEY_STAIR_UP, "move up staircase");
-        self.formatInstruction(7, KEY_QUIT, "quit");
+        try self.formatInstruction(7, KEY_QUIT, "quit");
         _ = ncurses.wrefresh(self.inst);
     }
 
-    pub fn displayMessage(self: *IO, comptime fmt: []const u8, args: anytype) void {
+    /// 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 {
         if (self.msgs == null) return;
 
         for (1..MESSAGE_PANEL_WIDTH - 1) |i| {
@@ -112,12 +128,14 @@ pub const IO = struct {
             _ = ncurses.mvwaddch(self.msgs, 1, i_32, ' ');
         }
 
-        var buf: [MESSAGE_PANEL_WIDTH:0]u8 = undefined;
+        if (str.len > MESSAGE_PANEL_WIDTH - 2) {
-        const data = std.fmt.bufPrint(&buf, fmt, args) catch {
+            try self.displayMessage("Message too long");
-            self.displayMessage("Message too long", .{});
             return;
-        };
+        }
-        buf[data.len] = 0;
+
+        var buf: [MESSAGE_PANEL_WIDTH:0]u8 = undefined;
+        std.mem.copyForwards(u8, &buf, str);
+        buf[str.len] = 0;
 
         const msg: [:0]u8 = &buf;
 
@@ -126,7 +144,7 @@ pub const IO = struct {
         _ = ncurses.wrefresh(self.msgs);
     }
 
-    pub fn displayStatus(self: *IO) void {
+    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));
@@ -135,14 +153,21 @@ pub const IO = struct {
             }
         }
 
+        // TODO: Implement
+
         _ = ncurses.wrefresh(self.stat);
     }
 
-    pub fn waitForTick(self: *IO) Action {
+    /// 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 {
         var new = std.time.milliTimestamp();
 
         while (new - self.prev_tick_time <= TICK_MS) {
-            const action = self.processInput();
+            const action = self.processInput() catch |err| {
+                return err;
+            };
             if (action != Action.illegal) return action;
 
             new = std.time.milliTimestamp();
@@ -152,10 +177,10 @@ pub const IO = struct {
         return Action.tick;
     }
 
-    fn processInput(self: *IO) Action {
+    fn processInput(self: *IO) !Action {
         const ch = ncurses.getch();
 
-        if (!validTermSize()) {
+        if (!self.validTermSize()) {
             if (ch != KEY_QUIT and ch != ncurses.KEY_RESIZE) return Action.illegal;
         }
 
@@ -172,17 +197,20 @@ pub const IO = struct {
         };
     }
 
-    fn createInstructionPanel() ?*ncurses.WINDOW {
+    fn createInstructionPanel(self: *IO) !void {
-        return createNewWin(
+        self.inst = self.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() ?*ncurses.WINDOW {
+    fn createMessagePanel(self: *IO) void {
-        return createNewWin(
+        self.msgs = self.createNewWin(
             MESSAGE_PANEL_HEIGHT,
             MESSAGE_PANEL_WIDTH,
             @divTrunc(ncurses.LINES - MAIN_PANEL_HEIGHT - MESSAGE_PANEL_HEIGHT, 2) + MAIN_PANEL_HEIGHT,
@@ -190,8 +218,8 @@ pub const IO = struct {
         );
     }
 
-    fn createStatisticsPanel() ?*ncurses.WINDOW {
+    fn createStatisticsPanel(self: *IO) void {
-        return createNewWin(
+        self.stat = self.createNewWin(
             STATUS_PANEL_HEIGHT,
             STATUS_PANEL_WIDTH,
             @divTrunc(ncurses.LINES - INSTRUCTION_PANEL_HEIGHT - STATUS_PANEL_HEIGHT, 2) + INSTRUCTION_PANEL_HEIGHT,
@@ -199,8 +227,8 @@ pub const IO = struct {
         );
     }
 
-    fn createMainPanel() ?*ncurses.WINDOW {
+    fn createMainPanel(self: *IO) void {
-        return createNewWin(
+        self.main = self.createNewWin(
             MAIN_PANEL_HEIGHT,
             MAIN_PANEL_WIDTH,
             @divTrunc(ncurses.LINES - MAIN_PANEL_HEIGHT - MESSAGE_PANEL_HEIGHT, 2) + 1,
@@ -208,13 +236,22 @@ pub const IO = struct {
         );
     }
 
-    pub fn init() !IO {
+    pub fn init(allocator: std.mem.Allocator) !IOInterface {
         _ = 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 (!colorSupport()) {
+        if (!io.colorSupport()) {
             _ = ncurses.endwin();
             return error.NoColorSupport;
         }
@@ -231,29 +268,13 @@ pub const IO = struct {
         _ = ncurses.wattron(ncurses.stdscr, ncurses.COLOR_PAIR(1));
         _ = ncurses.refresh();
 
-        var io: IO = undefined;
+        if (!io.validTermSize()) {
-
-        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 {
-            io = IO{
+            try io.createPanels();
-                .inst = createInstructionPanel(),
-                .msgs = createMessagePanel(),
-                .stat = createStatisticsPanel(),
-                .main = createMainPanel(),
-                .prev_tick_time = std.time.milliTimestamp(),
-            };
-            io.displayInstructions();
         }
 
-        return io;
+        return IOInterface.init(io);
     }
 
     fn deleteWindows(self: *IO) void {
@@ -270,5 +291,6 @@ pub const IO = struct {
     pub fn deinit(self: *IO) void {
         self.deleteWindows();
         _ = ncurses.endwin();
+        self.allocator.destroy(self);
     }
 };

src/frontend/sdl.zig

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,57 @@
+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,29 +1,26 @@
 const std = @import("std");
-const IO = @import("frontend/ncurses.zig").IO;
+const IO = @import("frontend/sdl.zig").IO;
-const Action = @import("actions.zig").Action;
+const run = @import("run.zig");
 
 pub fn main() u8 {
-    var io = IO.init() catch |err| {
+    var status: u8 = 0;
-        std.log.err("{}", .{err});
+
+    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});
         return 1;
     };
     defer io.deinit();
 
-    io.displayMessage("Initialized", .{});
+    run.run(allocator, &io) catch return 1;
 
-    var action = Action.illegal;
+    return status;
-    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,8 +3,10 @@ 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

@@ -0,0 +1,93 @@
+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);
+}