add sdl2 to build.zig

.gitignore

@@ -19,3 +19,8 @@ Makefile
 /stamp-h1
 /*.gz
 /src/urlg
+/.zig-cache/
+/zig-out/
+/ltximg/
+/assets/
+/notes.org

Makefile.am

@@ -1 +0,0 @@
-SUBDIRS = src

build.zig

@@ -0,0 +1,94 @@
+const std = @import("std");
+
+// Although this function looks imperative, note that its job is to
+// declaratively construct a build graph that will be executed by an external
+// runner.
+pub fn build(b: *std.Build) void {
+    // Standard target options allows the person running `zig build` to choose
+    // what target to build for. Here we do not override the defaults, which
+    // means any target is allowed, and the default is native. Other options
+    // for restricting supported target set are available.
+    const target = b.standardTargetOptions(.{});
+
+    // Standard optimization options allow the person running `zig build` to select
+    // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall. Here we do not
+    // set a preferred release mode, allowing the user to decide how to optimize.
+    const optimize = b.standardOptimizeOption(.{});
+
+    const lib = b.addStaticLibrary(.{
+        .name = "urlg",
+        // In this case the main source file is merely a path, however, in more
+        // complicated build scripts, this could be a generated file.
+        .root_source_file = b.path("src/root.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    // This declares intent for the library to be installed into the standard
+    // location when the user invokes the "install" step (the default step when
+    // running `zig build`).
+    b.installArtifact(lib);
+
+    const exe = b.addExecutable(.{
+        .name = "urlg",
+        .root_source_file = b.path("src/main.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+    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
+    // step when running `zig build`).
+    b.installArtifact(exe);
+
+    // This *creates* a Run step in the build graph, to be executed when another
+    // step is evaluated that depends on it. The next line below will establish
+    // such a dependency.
+    const run_cmd = b.addRunArtifact(exe);
+
+    // By making the run step depend on the install step, it will be run from the
+    // installation directory rather than directly from within the cache directory.
+    // This is not necessary, however, if the application depends on other installed
+    // files, this ensures they will be present and in the expected location.
+    run_cmd.step.dependOn(b.getInstallStep());
+
+    // This allows the user to pass arguments to the application in the build
+    // command itself, like this: `zig build run -- arg1 arg2 etc`
+    if (b.args) |args| {
+        run_cmd.addArgs(args);
+    }
+
+    // This creates a build step. It will be visible in the `zig build --help` menu,
+    // and can be selected like this: `zig build run`
+    // This will evaluate the `run` step rather than the default, which is "install".
+    const run_step = b.step("run", "Run the app");
+    run_step.dependOn(&run_cmd.step);
+
+    // Creates a step for unit testing. This only builds the test executable
+    // but does not run it.
+    const lib_unit_tests = b.addTest(.{
+        .root_source_file = b.path("src/root.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const run_lib_unit_tests = b.addRunArtifact(lib_unit_tests);
+
+    const exe_unit_tests = b.addTest(.{
+        .root_source_file = b.path("src/main.zig"),
+        .target = target,
+        .optimize = optimize,
+    });
+
+    const run_exe_unit_tests = b.addRunArtifact(exe_unit_tests);
+
+    // Similar to creating the run step earlier, this exposes a `test` step to
+    // the `zig build --help` menu, providing a way for the user to request
+    // running the unit tests.
+    const test_step = b.step("test", "Run unit tests");
+    test_step.dependOn(&run_lib_unit_tests.step);
+    test_step.dependOn(&run_exe_unit_tests.step);
+}

build.zig.zon

@@ -0,0 +1,72 @@
+.{
+    // This is the default name used by packages depending on this one. For
+    // example, when a user runs `zig fetch --save <url>`, this field is used
+    // as the key in the `dependencies` table. Although the user can choose a
+    // different name, most users will stick with this provided value.
+    //
+    // It is redundant to include "zig" in this name because it is already
+    // within the Zig package namespace.
+    .name = "simple-lib-use",
+
+    // This is a [Semantic Version](https://semver.org/).
+    // In a future version of Zig it will be used for package deduplication.
+    .version = "0.0.0",
+
+    // This field is optional.
+    // This is currently advisory only; Zig does not yet do anything
+    // with this value.
+    //.minimum_zig_version = "0.11.0",
+
+    // This field is optional.
+    // Each dependency must either provide a `url` and `hash`, or a `path`.
+    // `zig build --fetch` can be used to fetch all dependencies of a package, recursively.
+    // Once all dependencies are fetched, `zig build` no longer requires
+    // internet connectivity.
+    .dependencies = .{
+        // See `zig fetch --save <url>` for a command-line interface for adding dependencies.
+        //.example = .{
+        //    // When updating this field to a new URL, be sure to delete the corresponding
+        //    // `hash`, otherwise you are communicating that you expect to find the old hash at
+        //    // the new URL.
+        //    .url = "https://example.com/foo.tar.gz",
+        //
+        //    // This is computed from the file contents of the directory of files that is
+        //    // obtained after fetching `url` and applying the inclusion rules given by
+        //    // `paths`.
+        //    //
+        //    // This field is the source of truth; packages do not come from a `url`; they
+        //    // come from a `hash`. `url` is just one of many possible mirrors for how to
+        //    // obtain a package matching this `hash`.
+        //    //
+        //    // Uses the [multihash](https://multiformats.io/multihash/) format.
+        //    .hash = "...",
+        //
+        //    // When this is provided, the package is found in a directory relative to the
+        //    // build root. In this case the package's hash is irrelevant and therefore not
+        //    // computed. This field and `url` are mutually exclusive.
+        //    .path = "foo",
+
+        //    // When this is set to `true`, a package is declared to be lazily
+        //    // fetched. This makes the dependency only get fetched if it is
+        //    // actually used.
+        //    .lazy = false,
+        //},
+    },
+
+    // Specifies the set of files and directories that are included in this package.
+    // Only files and directories listed here are included in the `hash` that
+    // is computed for this package. Only files listed here will remain on disk
+    // when using the zig package manager. As a rule of thumb, one should list
+    // files required for compilation plus any license(s).
+    // Paths are relative to the build root. Use the empty string (`""`) to refer to
+    // the build root itself.
+    // A directory listed here means that all files within, recursively, are included.
+    .paths = .{
+        "build.zig",
+        "build.zig.zon",
+        "src",
+        // For example...
+        //"LICENSE",
+        //"README.md",
+    },
+}

configure.ac

@@ -1,16 +0,0 @@
-AC_PREREQ([2.65])
-AC_INIT([urlg], [0.0.1-alpha], [jacob.a.s.janzen@gmail.com])
-AC_CONFIG_SRCDIR([src/main.c])
-AC_CONFIG_AUX_DIR([build-aux])
-
-AC_PROG_CC
-AC_CHECK_LIB([ncurses], [initscr])
-AC_CHECK_LIB([tinfo], [stdscr])
-AC_CHECK_HEADERS([ncurses.h])
-
-AM_INIT_AUTOMAKE([foreign -Wall -Werror])
-
-AC_CONFIG_HEADERS([config.h])
-AC_CONFIG_FILES([Makefile src/Makefile])
-
-AC_OUTPUT

src/Makefile.am

@@ -1,13 +0,0 @@
-bin_PROGRAMS = urlg
-
-urlg_SOURCES = \
-		cavegen.c \
-		cavegen.h \
-		display.c \
-		display.h \
-		ht.c \
-		ht.h \
-		common.h \
-		entity.h \
-		main.c
-

src/actions.zig

@@ -0,0 +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/cavegen.c

@@ -1,103 +0,0 @@
-/*
-This file is part of urlg.
-urlg is free software: you can redistribute it and/or modify it under the terms
-of the GNU General Public License as published by the Free Software Foundation,
-either version 3 of the License, or (at your option) any later version. urlg is
-distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
-without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-PURPOSE. See the GNU General Public License for more details. You should have
-received a copy of the GNU General Public License along with urlg. If not, see
-<https://www.gnu.org/licenses/>.
-*/
-#include "cavegen.h"
-
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-#define MAX_STEPS   200
-#define NUM_WALKERS 100
-
-enum direction {
-    UP,
-    LEFT,
-    RIGHT,
-    DOWN,
-    NUM_DIRS,
-};
-
-void create_cave(struct map *map)
-{
-    map->width  = WIDTH;
-    map->height = HEIGHT;
-
-    // create a map consisting entirely of walls
-    map->map = malloc(sizeof(enum tile_type) * HEIGHT * WIDTH);
-    for (int i = 0; i < HEIGHT; ++i) {
-        for (int j = 0; j < WIDTH; ++j) {
-            map->map[i * WIDTH + j] = WALL;
-        }
-    }
-
-    // start in the middle of the screen
-    int start_x = WIDTH / 2;
-    int start_y = HEIGHT / 2;
-
-    // make the starting point GROUND
-    map->map[start_y * WIDTH + start_x] = GROUND;
-
-    // setup the open tiles
-    struct point *open_tiles = malloc(sizeof(struct point) * HEIGHT * WIDTH);
-
-    int num_open_tiles = 1;
-    open_tiles[0].x    = start_x;
-    open_tiles[0].y    = start_y;
-
-    for (int i = 0; i < NUM_WALKERS; ++i) {
-        // get a random open point
-        struct point curr_point = open_tiles[rand() % num_open_tiles];
-
-        int x_pos = curr_point.x;
-        int y_pos = curr_point.y;
-
-        // iterate until the walk exits the array or MAX_STEPS is reached
-        for (int j = 1; j < MAX_STEPS - 1 && x_pos < WIDTH - 1 && x_pos >= 1 &&
-                        y_pos < HEIGHT - 1 && y_pos >= 1;
-             ++j) {
-            // add new open point if the current point is still a wall
-            if (map->map[y_pos * WIDTH + x_pos] == WALL) {
-                open_tiles[num_open_tiles].x = x_pos;
-                open_tiles[num_open_tiles].y = y_pos;
-                ++num_open_tiles;
-            }
-
-            map->map[y_pos * WIDTH + x_pos] = GROUND; // assign ground
-
-            // move in a random direction
-            enum direction dir = rand() % NUM_DIRS;
-            switch (dir) {
-            case UP : --y_pos; break;
-            case LEFT : --x_pos; break;
-            case RIGHT : ++x_pos; break;
-            case DOWN : ++y_pos; break;
-            default : exit(EXIT_FAILURE); // should not occur
-            }
-        }
-    }
-
-    // assign the up stair and remove from open tiles
-    int in           = rand() % num_open_tiles;
-    map->entry_point = open_tiles[in];
-    open_tiles[in]   = open_tiles[num_open_tiles - 1];
-    --num_open_tiles;
-    map->map[map->entry_point.y * WIDTH + map->entry_point.x] = UP_STAIR;
-
-    // assign the down stair and remove from open tiles
-    in                = rand() % num_open_tiles;
-    struct point down = open_tiles[in];
-    open_tiles[in]    = open_tiles[num_open_tiles - 1];
-    --num_open_tiles;
-    map->map[down.y * WIDTH + down.x] = DOWN_STAIR;
-
-    free(open_tiles);
-}

src/cavegen.h

@@ -1,37 +0,0 @@
-/*
-This file is part of urlg.
-urlg is free software: you can redistribute it and/or modify it under the terms
-of the GNU General Public License as published by the Free Software Foundation,
-either version 3 of the License, or (at your option) any later version. urlg is
-distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
-without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-PURPOSE. See the GNU General Public License for more details. You should have
-received a copy of the GNU General Public License along with urlg. If not, see
-<https://www.gnu.org/licenses/>.
-*/
-#ifndef CAVEGEN_H_
-#define CAVEGEN_H_
-
-#include "common.h"
-
-#define HEIGHT 100
-#define WIDTH  180
-
-enum tile_type {
-    WALL,
-    GROUND,
-    UP_STAIR,
-    DOWN_STAIR,
-};
-
-struct map {
-    enum tile_type *map;
-    struct point    entry_point;
-
-    int width;
-    int height;
-};
-
-void create_cave(struct map *map);
-
-#endif // CAVEGEN_H_

src/common.h

@@ -1,20 +0,0 @@
-/*
-This file is part of urlg.
-urlg is free software: you can redistribute it and/or modify it under the terms
-of the GNU General Public License as published by the Free Software Foundation,
-either version 3 of the License, or (at your option) any later version. urlg is
-distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
-without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-PURPOSE. See the GNU General Public License for more details. You should have
-received a copy of the GNU General Public License along with urlg. If not, see
-<https://www.gnu.org/licenses/>.
-*/
-#ifndef COMMON_H_
-#define COMMON_H_
-
-struct point {
-    int x;
-    int y;
-};
-
-#endif // COMMON_H_

src/display.c

@@ -1,223 +0,0 @@
-/*
-This file is part of urlg.
-urlg is free software: you can redistribute it and/or modify it under the terms
-of the GNU General Public License as published by the Free Software Foundation,
-either version 3 of the License, or (at your option) any later version. urlg is
-distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
-without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-PURPOSE. See the GNU General Public License for more details. You should have
-received a copy of the GNU General Public License along with urlg. If not, see
-<https://www.gnu.org/licenses/>.
-*/
-#include "display.h"
-
-#include <curses.h>
-#include <locale.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "entity.h"
-
-struct windows {
-    WINDOW *main;
-    WINDOW *inst;
-    WINDOW *msgs;
-    WINDOW *stat;
-};
-
-static WINDOW *create_newwin(int height, int width, int y, int x)
-{
-    WINDOW *local_win = newwin(height, width, y, x);
-    box(local_win, 0, 0);
-    wrefresh(local_win);
-
-    return local_win;
-}
-
-static display_t *create_windows(void)
-{
-    display_t *wins = malloc(sizeof(display_t));
-
-    wins->inst = create_newwin(
-        INSTRUCTION_PANEL_HEIGHT, INSTRUCTION_PANEL_WIDTH,
-        (LINES - INSTRUCTION_PANEL_HEIGHT - STATUS_PANEL_HEIGHT) / 2 + 1,
-        (COLS - MAIN_PANEL_WIDTH - INSTRUCTION_PANEL_WIDTH) / 2 +
-            MAIN_PANEL_WIDTH - 1
-    );
-    wins->msgs = create_newwin(
-        MESSAGE_PANEL_HEIGHT, MESSAGE_PANEL_WIDTH,
-        (LINES - MAIN_PANEL_HEIGHT - MESSAGE_PANEL_HEIGHT) / 2 +
-            MAIN_PANEL_HEIGHT,
-        (COLS - MESSAGE_PANEL_WIDTH - INSTRUCTION_PANEL_WIDTH) / 2
-    );
-    wins->stat = create_newwin(
-        STATUS_PANEL_HEIGHT, STATUS_PANEL_WIDTH,
-        (LINES - INSTRUCTION_PANEL_HEIGHT - STATUS_PANEL_HEIGHT) / 2 +
-            INSTRUCTION_PANEL_HEIGHT,
-        (COLS - MAIN_PANEL_WIDTH - INSTRUCTION_PANEL_WIDTH) / 2 +
-            MAIN_PANEL_WIDTH - 1
-    );
-    wins->main = create_newwin(
-        MAIN_PANEL_HEIGHT, MAIN_PANEL_WIDTH,
-        (LINES - MAIN_PANEL_HEIGHT - MESSAGE_PANEL_HEIGHT) / 2 + 1,
-        (COLS - MAIN_PANEL_WIDTH - INSTRUCTION_PANEL_WIDTH) / 2
-    );
-
-    return wins;
-}
-
-display_t *display_init(void)
-{
-    setlocale(LC_ALL, ""); // allow extended ASCII
-
-    initscr(); // initialize curses
-
-    // exit on unsupported consoles
-    if (LINES < MAIN_PANEL_HEIGHT + MESSAGE_PANEL_HEIGHT ||
-        COLS < MAIN_PANEL_WIDTH + INSTRUCTION_PANEL_WIDTH || !has_colors()) {
-        endwin();
-        fprintf(
-            stderr,
-            "a color terminal is required with at least %dx%d characters\n",
-            INSTRUCTION_PANEL_WIDTH + MAIN_PANEL_WIDTH,
-            MAIN_PANEL_HEIGHT + MESSAGE_PANEL_HEIGHT
-        );
-        return NULL;
-    }
-
-    // configure curses if startup was successful
-    raw();                // disable line buffering
-    keypad(stdscr, TRUE); // enable reading function keys
-    noecho();             // don't print input
-    curs_set(0);          // disable the cursor
-    start_color();        // enable colours
-
-    // setup colours
-    init_pair(1, COLOR_WHITE, COLOR_BLACK);
-    init_pair(2, COLOR_BLACK, COLOR_RED);
-    wattron(stdscr, COLOR_PAIR(1));
-    refresh();
-
-    return create_windows();
-}
-
-void display_destroy(display_t *disp)
-{
-    delwin(disp->main);
-    delwin(disp->inst);
-    delwin(disp->msgs);
-    delwin(disp->stat);
-
-    free(disp);
-}
-
-void display_map(display_t *disp, struct map *map, ht_t *entities)
-{
-    // print map
-    struct entity *camera = ht_find(entities, "camera");
-
-    for (int i = 1; i < MAIN_PANEL_HEIGHT - 1; ++i) {
-        for (int j = 1; j < MAIN_PANEL_WIDTH - 1; ++j) {
-            int map_i = i - 1 + camera->p.y;
-            int map_j = j - 1 + camera->p.x;
-
-            if (map_i > map->height || map_j > map->width || map_i < 0 ||
-                map_j < 0) {
-                mvwaddch(disp->main, i, j, ' ');
-            } else {
-                switch (map->map[map_i * map->width + map_j]) {
-                case GROUND : mvwaddch(disp->main, i, j, '.'); break;
-                case UP_STAIR : mvwaddch(disp->main, i, j, '<'); break;
-                case DOWN_STAIR :
-                    wattron(disp->main, COLOR_PAIR(2));
-                    mvwaddch(disp->main, i, j, '>');
-                    wattroff(disp->main, COLOR_PAIR(2));
-                    break;
-                case WALL :
-                    if (map_i > 0 &&
-                        map->map[(map_i - 1) * map->width + map_j] != WALL) {
-                        mvwaddch(disp->main, i, j, ACS_BLOCK);
-                    } else if (map_i < map->width - 1 && map->map[(map_i + 1) * map->width + map_j] != WALL) {
-                        mvwaddch(disp->main, i, j, ACS_BLOCK);
-                    } else if (map_j > 0 && map->map[map_i * map->width + map_j - 1] != WALL) {
-                        mvwaddch(disp->main, i, j, ACS_BLOCK);
-                    } else if (map_j < map->width - 1 && map->map[map_i * map->width + map_j + 1] != WALL) {
-                        mvwaddch(disp->main, i, j, ACS_BLOCK);
-                    } else {
-                        mvwaddch(disp->main, i, j, ' ');
-                    }
-                    break;
-                default : mvwaddch(disp->main, i, j, ' ');
-                }
-            }
-        }
-    }
-
-    // print entities
-    ht_iter_init(entities);
-    struct kvp kvp = ht_iter_next(entities);
-    while (kvp.key) {
-        struct entity *e = kvp.val;
-        if (e->visible) {
-            mvwaddch(
-                disp->main, e->p.y - camera->p.y + 1, e->p.x - camera->p.x + 1,
-                e->disp_ch[0]
-            );
-        }
-
-        kvp = ht_iter_next(entities);
-    }
-
-    wrefresh(disp->main);
-}
-
-void display_instructions(display_t *disp)
-{
-    mvwprintw(disp->inst, 1, 2, "h - move left");
-    mvwprintw(disp->inst, 2, 2, "j - move down");
-    mvwprintw(disp->inst, 3, 2, "k - move up");
-    mvwprintw(disp->inst, 4, 2, "l - move right");
-    mvwprintw(disp->inst, 5, 2, "> - move down staircase");
-    mvwprintw(disp->inst, 6, 2, "< - exit via staircase");
-    wrefresh(disp->inst);
-}
-
-void display_message(display_t *disp, char *msg)
-{
-    for (int i = 1; i < MESSAGE_PANEL_WIDTH - 1; ++i) {
-        mvwaddch(disp->msgs, 1, i, ' ');
-    }
-
-    mvwprintw(disp->msgs, 1, 1, msg);
-    wrefresh(disp->msgs);
-}
-
-void display_status(display_t *disp, struct entity *entity)
-{
-    for (int i = 1; i < STATUS_PANEL_HEIGHT - 1; ++i) {
-        for (int j = 1; j < STATUS_PANEL_WIDTH - 1; ++j) {
-            mvwaddch(disp->stat, i, j, ' ');
-        }
-    }
-
-    mvwprintw(disp->stat, 1, 2, "HP:");
-    mvwprintw(disp->stat, 2, 2, "STAMINA:");
-    mvwprintw(disp->stat, 3, 2, "MANA:");
-
-    wrefresh(disp->stat);
-}
-
-enum action display_process_input(void)
-{
-    int ch = getch();
-    switch (ch) {
-    case 'k' : return ACTION_UP;
-    case 'j' : return ACTION_DOWN;
-    case 'h' : return ACTION_LEFT;
-    case 'l' : return ACTION_RIGHT;
-    case '>' : return ACTION_STAIR_DOWN;
-    case '<' : return ACTION_STAIR_UP;
-    case KEY_F(1) : return ACTION_EXIT;
-    default : return ACTION_NONE;
-    }
-}

src/display.h

@@ -1,54 +0,0 @@
-/*
-This file is part of urlg.
-urlg is free software: you can redistribute it and/or modify it under the terms
-of the GNU General Public License as published by the Free Software Foundation,
-either version 3 of the License, or (at your option) any later version. urlg is
-distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
-without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-PURPOSE. See the GNU General Public License for more details. You should have
-received a copy of the GNU General Public License along with urlg. If not, see
-<https://www.gnu.org/licenses/>.
-*/
-#ifndef DISPLAY_H_
-#define DISPLAY_H_
-
-#include <stdbool.h>
-
-#include "cavegen.h"
-#include "entity.h"
-#include "ht.h"
-
-#define MAIN_PANEL_WIDTH         100
-#define MAIN_PANEL_HEIGHT        41
-#define INSTRUCTION_PANEL_WIDTH  32
-#define INSTRUCTION_PANEL_HEIGHT 39
-#define MESSAGE_PANEL_WIDTH      100
-#define MESSAGE_PANEL_HEIGHT     3
-#define STATUS_PANEL_WIDTH       32
-#define STATUS_PANEL_HEIGHT      5
-
-typedef struct windows display_t;
-
-enum action {
-    ACTION_NONE,
-    ACTION_EXIT,
-    ACTION_DOWN,
-    ACTION_UP,
-    ACTION_LEFT,
-    ACTION_RIGHT,
-    ACTION_STAIR_DOWN,
-    ACTION_STAIR_UP,
-    NUM_ACTIONS,
-};
-
-display_t *display_init(void);
-void       display_destroy(display_t *disp);
-
-void display_map(display_t *disp, struct map *map, ht_t *entities);
-void display_instructions(display_t *disp);
-void display_message(display_t *disp, char *msg);
-void display_status(display_t *disp, struct entity *entity);
-
-enum action display_process_input(void);
-
-#endif // DISPLAY_H_

src/ecs/component.zig

@@ -0,0 +1,24 @@
+//! 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;
+        return .{};
+    }
+
+    pub fn deinit(self: *ComponentStub) void {
+        _ = self;
+    }
+};
+
+/// All valid component types are stored in this enum
+pub const ComponentType = enum {
+    component_stub,
+};
+
+/// The components are stored as a MultiArrayList over this struct
+pub const Components = struct {
+    component_stub: ?ComponentStub,
+};

src/ecs/ecs.zig

@@ -0,0 +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;
+
+/// 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.
+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
+    available_ids: std.ArrayList(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 = .{},
+            .available_ids = std.ArrayList(usize).init(allocator),
+        };
+    }
+
+    pub fn deinit(self: *EntityComponentSystem) void {
+        self.available_ids.deinit();
+        self.components.deinit(self.allocator);
+    }
+
+    /// 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);
+        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),
+        }
+    }
+
+    /// 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 = 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();
+    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);
+    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/entity.h

@@ -1,24 +0,0 @@
-/*
-This file is part of urlg.
-urlg is free software: you can redistribute it and/or modify it under the terms
-of the GNU General Public License as published by the Free Software Foundation,
-either version 3 of the License, or (at your option) any later version. urlg is
-distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
-without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-PURPOSE. See the GNU General Public License for more details. You should have
-received a copy of the GNU General Public License along with urlg. If not, see
-<https://www.gnu.org/licenses/>.
-*/
-#ifndef ENTITY_H_
-#define ENTITY_H_
-
-#include "common.h"
-
-struct entity {
-    struct point p;
-    char        *disp_ch;
-    bool         solid;
-    bool         visible;
-};
-
-#endif // ENTITY_H_

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

@@ -0,0 +1,296 @@
+//! 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({
+    @cInclude("ncurses.h");
+});
+const locale = @cImport({
+    @cInclude("locale.h");
+});
+
+const TICK_MS = 33;
+
+const MAIN_PANEL_WIDTH = 100;
+const MAIN_PANEL_HEIGHT = 41;
+const INSTRUCTION_PANEL_WIDTH = 32;
+const INSTRUCTION_PANEL_HEIGHT = 39;
+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;
+
+const KEY_MOVE_UP: i32 = 'k';
+const KEY_MOVE_DOWN: i32 = 'j';
+const KEY_MOVE_LEFT: i32 = 'h';
+const KEY_MOVE_RIGHT: i32 = 'l';
+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
+        return ncurses.LINES >= MIN_HEIGHT and
+            ncurses.COLS >= MIN_WIDTH;
+    }
+
+    fn colorSupport(self: *IO) bool {
+        _ = self; // should be uncallable without initialization
+        return ncurses.has_colors();
+    }
+
+    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 {
+        const c_description: ?[*:0]const u8 = description.ptr;
+
+        if (ncurses.KEY_F0 <= key and key <= ncurses.KEY_F(64)) {
+            _ = ncurses.mvwprintw(self.inst, pos, 2, "F%d - %s", key - ncurses.KEY_F0, c_description);
+        } 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);
+        }
+    }
+
+    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| {
+            for (0..cols) |j| {
+                const i_32 = @as(i32, @intCast(i));
+                const j_32 = @as(i32, @intCast(j));
+                _ = ncurses.mvaddch(i_32, j_32, ' ');
+            }
+        }
+        _ = ncurses.refresh();
+
+        self.deleteWindows();
+
+        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 {
+            try self.createPanels();
+        }
+
+        _ = ncurses.refresh();
+
+        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");
+        _ = 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 {
+        if (self.msgs == null) return;
+
+        for (1..MESSAGE_PANEL_WIDTH - 1) |i| {
+            const i_32 = @as(i32, @intCast(i));
+            _ = 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 msg: [:0]u8 = &buf;
+
+        const c_msg: ?[*:0]const u8 = msg.ptr;
+        _ = ncurses.mvwprintw(self.msgs, 1, 1, c_msg);
+        _ = ncurses.wrefresh(self.msgs);
+    }
+
+    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));
+                const j_32 = @as(i32, @intCast(j));
+                _ = ncurses.mvwaddch(self.stat, i_32, j_32, ' ');
+            }
+        }
+
+        // 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 {
+        var new = std.time.milliTimestamp();
+
+        while (new - self.prev_tick_time <= TICK_MS) {
+            const action = self.processInput() catch |err| {
+                return err;
+            };
+            if (action != Action.illegal) return action;
+
+            new = std.time.milliTimestamp();
+        }
+
+        self.prev_tick_time = new;
+        return Action.tick;
+    }
+
+    fn processInput(self: *IO) !Action {
+        const ch = ncurses.getch();
+
+        if (!self.validTermSize()) {
+            if (ch != KEY_QUIT and ch != ncurses.KEY_RESIZE) return Action.illegal;
+        }
+
+        return switch (ch) {
+            KEY_MOVE_UP => Action.move_up,
+            KEY_MOVE_DOWN => Action.move_down,
+            KEY_MOVE_LEFT => Action.move_left,
+            KEY_MOVE_RIGHT => Action.move_right,
+            KEY_STAIR_DOWN => Action.down_stair,
+            KEY_STAIR_UP => Action.up_stair,
+            KEY_QUIT => Action.exit,
+            ncurses.KEY_RESIZE => self.handleResize(),
+            else => Action.illegal,
+        };
+    }
+
+    fn createInstructionPanel(self: *IO) !void {
+        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(self: *IO) void {
+        self.msgs = self.createNewWin(
+            MESSAGE_PANEL_HEIGHT,
+            MESSAGE_PANEL_WIDTH,
+            @divTrunc(ncurses.LINES - MAIN_PANEL_HEIGHT - MESSAGE_PANEL_HEIGHT, 2) + MAIN_PANEL_HEIGHT,
+            @divTrunc(ncurses.COLS - MESSAGE_PANEL_WIDTH - INSTRUCTION_PANEL_WIDTH, 2),
+        );
+    }
+
+    fn createStatisticsPanel(self: *IO) void {
+        self.stat = self.createNewWin(
+            STATUS_PANEL_HEIGHT,
+            STATUS_PANEL_WIDTH,
+            @divTrunc(ncurses.LINES - INSTRUCTION_PANEL_HEIGHT - STATUS_PANEL_HEIGHT, 2) + INSTRUCTION_PANEL_HEIGHT,
+            @divTrunc(ncurses.COLS - MAIN_PANEL_WIDTH - INSTRUCTION_PANEL_WIDTH, 2) + MAIN_PANEL_WIDTH - 1,
+        );
+    }
+
+    fn createMainPanel(self: *IO) void {
+        self.main = self.createNewWin(
+            MAIN_PANEL_HEIGHT,
+            MAIN_PANEL_WIDTH,
+            @divTrunc(ncurses.LINES - MAIN_PANEL_HEIGHT - MESSAGE_PANEL_HEIGHT, 2) + 1,
+            @divTrunc(ncurses.COLS - MAIN_PANEL_WIDTH - INSTRUCTION_PANEL_WIDTH, 2),
+        );
+    }
+
+    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 (!io.colorSupport()) {
+            _ = ncurses.endwin();
+            return error.NoColorSupport;
+        }
+
+        _ = ncurses.raw();
+        _ = ncurses.keypad(ncurses.stdscr, true);
+        _ = ncurses.noecho();
+        _ = ncurses.curs_set(0);
+        _ = ncurses.start_color();
+        _ = ncurses.timeout(1);
+
+        _ = ncurses.init_pair(1, ncurses.COLOR_WHITE, ncurses.COLOR_BLACK);
+        _ = ncurses.init_pair(2, ncurses.COLOR_BLACK, ncurses.COLOR_RED);
+        _ = ncurses.wattron(ncurses.stdscr, ncurses.COLOR_PAIR(1));
+        _ = ncurses.refresh();
+
+        if (!io.validTermSize()) {
+            _ = ncurses.mvprintw(0, 0, "Terminal must be at least %dx%d", @as(i32, @intCast(MIN_WIDTH)), @as(i32, @intCast(MIN_HEIGHT)));
+        } else {
+            try io.createPanels();
+        }
+
+        return IOInterface.init(io);
+    }
+
+    fn deleteWindows(self: *IO) void {
+        _ = ncurses.delwin(self.main);
+        self.main = null;
+        _ = ncurses.delwin(self.inst);
+        self.inst = null;
+        _ = ncurses.delwin(self.msgs);
+        self.msgs = null;
+        _ = ncurses.delwin(self.stat);
+        self.stat = null;
+    }
+
+    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/ht.c

@@ -1,235 +0,0 @@
-/*
-This file is part of urlg.
-urlg is free software: you can redistribute it and/or modify it under the terms
-of the GNU General Public License as published by the Free Software Foundation,
-either version 3 of the License, or (at your option) any later version. urlg is
-distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
-without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-PURPOSE. See the GNU General Public License for more details. You should have
-received a copy of the GNU General Public License along with urlg. If not, see
-<https://www.gnu.org/licenses/>.
-*/
-#include "ht.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-struct node {
-    char        *key;
-    void        *val;
-    struct node *next;
-};
-
-struct hash_table {
-    struct node **vals;
-    int           max_size;
-    int           size;
-
-    int          curr_index;
-    struct node *curr_node;
-    bool         iterating;
-};
-
-static void rehash(ht_t *h, int newsize)
-{
-    ht_t *new_h = ht_create(newsize);
-
-    ht_iter_init(h);
-
-    struct kvp kvp = ht_iter_next(h);
-    while (kvp.key) {
-        ht_insert(new_h, kvp.key, kvp.val);
-        kvp = ht_iter_next(h);
-    }
-
-    // only destroy vals if it isn't NULL
-    if (h->vals) {
-        // iterate through the hash values
-        for (int i = 0; i < h->max_size; ++i) {
-            // iterate through the linked list and remove the value
-            struct node *curr = h->vals[i];
-            struct node *prev;
-            while (curr) {
-                prev = curr;
-                curr = curr->next;
-                free(prev->key);
-                free(prev);
-            }
-        }
-        free(h->vals);
-    }
-
-    h->max_size   = newsize;
-    h->vals       = new_h->vals;
-    h->curr_index = 0;
-    h->curr_node  = NULL;
-    h->iterating  = false;
-
-    free(new_h);
-}
-
-static unsigned long djb2_hash(char *str)
-{
-    unsigned long hash = 5381;
-    int           c;
-
-    // hash * 33 + c
-    while ((c = *str++)) hash = ((hash << 5) + hash) + c;
-
-    return hash;
-}
-
-ht_t *ht_create(int max_size)
-{
-    ht_t *h       = malloc(sizeof(ht_t));
-    h->max_size   = max_size;
-    h->size       = 0;
-    h->vals       = malloc(sizeof(struct node) * max_size);
-    h->curr_index = 0;
-    h->curr_node  = NULL;
-    h->iterating  = false;
-
-    return h;
-}
-
-void ht_destroy(ht_t *h)
-{
-    // only destroy if h isn't NULL
-    if (h) {
-        // only destroy vals if it isn't NULL
-        if (h->vals) {
-            // iterate through the hash values
-            for (int i = 0; i < h->max_size; ++i) {
-                // iterate through the linked list and remove the value
-                struct node *curr = h->vals[i];
-                struct node *prev;
-                while (curr) {
-                    prev = curr;
-                    curr = curr->next;
-                    free(prev->key);
-                    free(prev);
-                }
-            }
-            free(h->vals);
-        }
-        free(h);
-    }
-}
-
-void *ht_find(ht_t *h, char *key)
-{
-    unsigned int hash = djb2_hash(key) % h->max_size;
-
-    // exit early if hash isn't in table
-    if (!h->vals[hash])
-        return NULL;
-
-    // iterate through values stored at `hash`; exit early if found
-    struct node *curr = h->vals[hash];
-    while (curr) {
-        if (strcmp(key, curr->key) == 0)
-            return curr->val;
-        curr = curr->next;
-    }
-
-    return NULL;
-}
-
-void ht_insert(ht_t *h, char *key, void *val)
-{
-    if (h->size > h->max_size * 0.75)
-        rehash(h, h->max_size * 2);
-
-    unsigned int hash = djb2_hash(key) % h->max_size;
-
-    // create a node
-    int len          = strlen(key);
-    struct node *new = malloc(sizeof(struct node));
-    new->key         = malloc(sizeof(char) * (len + 1));
-    for (int i = 0; i < len; ++i) {
-        new->key[i] = key[i];
-    }
-    new->key[len] = 0;
-    new->val      = val;
-
-    // insert node at beginning of list
-    if (h->vals[hash]) {
-        new->next = h->vals[hash];
-    }
-    h->vals[hash] = new;
-
-    ++(h->size);
-}
-
-void ht_delete(ht_t *h, char *key)
-{
-    if (h->size < h->max_size * 0.25)
-        rehash(h, h->max_size * 0.5);
-
-    unsigned int hash = djb2_hash(key) % h->max_size;
-
-    if (!h->vals[hash])
-        return; // exit if the hash is not found
-
-    // remove the key from the front of the list if it's there
-    if (strcmp(key, h->vals[hash]->key) == 0) {
-        struct node *temp = h->vals[hash];
-        h->vals[hash]     = h->vals[hash]->next;
-        free(temp->key);
-        free(temp);
-    } else {
-        // iterate through list and remove once a match is found
-        struct node *prev = h->vals[hash];
-        struct node *curr = h->vals[hash]->next;
-        while (curr) {
-            if (strcmp(key, curr->key) == 0) {
-                prev->next = curr->next;
-                free(curr->key);
-                free(curr);
-                return;
-            }
-
-            prev = curr;
-            curr = curr->next;
-        }
-    }
-}
-
-int ht_size(ht_t *h)
-{
-    return h->size;
-}
-
-void ht_iter_init(ht_t *h)
-{
-    h->curr_index = 0;
-    h->curr_node  = h->vals[0];
-}
-
-struct kvp ht_iter_next(ht_t *h)
-{
-    struct kvp out = {
-        .key = NULL,
-        .val = NULL,
-    };
-
-    // return NULL if we've reached the end
-    if (!h->curr_node && h->curr_index >= h->max_size)
-        return out;
-
-    // look for next index with node if current node is NULL
-    if (!h->curr_node) {
-        while (!h->curr_node) {
-            h->curr_node = h->vals[h->curr_index++];
-            if (h->curr_index >= h->max_size)
-                return out;
-        }
-    }
-
-    // get the value and move to the next node
-    out.key      = h->curr_node->key;
-    out.val      = h->curr_node->val;
-    h->curr_node = h->curr_node->next;
-    return out;
-}

src/ht.h

@@ -1,40 +0,0 @@
-/*
-This file is part of urlg.
-urlg is free software: you can redistribute it and/or modify it under the terms
-of the GNU General Public License as published by the Free Software Foundation,
-either version 3 of the License, or (at your option) any later version. urlg is
-distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
-without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-PURPOSE. See the GNU General Public License for more details. You should have
-received a copy of the GNU General Public License along with urlg. If not, see
-<https://www.gnu.org/licenses/>.
-*/
-#ifndef HT_H_
-#define HT_H_
-
-#include <stdbool.h>
-
-typedef struct hash_table ht_t;
-
-struct kvp {
-    char *key;
-    void *val;
-};
-
-// construct and destructor
-ht_t *ht_create(int size);
-void  ht_destroy(ht_t *h);
-
-// accessors
-void *ht_find(ht_t *h, char *key);
-void  ht_insert(ht_t *h, char *key, void *val);
-void  ht_delete(ht_t *h, char *key);
-
-// queries
-int ht_size(ht_t *h);
-
-// iterator
-void       ht_iter_init(ht_t *h);
-struct kvp ht_iter_next(ht_t *h);
-
-#endif // HT_H_

src/main.c

@@ -1,192 +0,0 @@
-/*
-This file is part of urlg.
-urlg is free software: you can redistribute it and/or modify it under the terms
-of the GNU General Public License as published by the Free Software Foundation,
-either version 3 of the License, or (at your option) any later version. urlg is
-distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
-without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
-PURPOSE. See the GNU General Public License for more details. You should have
-received a copy of the GNU General Public License along with urlg. If not, see
-<https://www.gnu.org/licenses/>.
-*/
-#include <curses.h>
-#include <getopt.h>
-#include <locale.h>
-#include <stdlib.h>
-#include <time.h>
-
-#include "../config.h"
-#include "cavegen.h"
-#include "common.h"
-#include "display.h"
-#include "entity.h"
-#include "ht.h"
-
-bool entity_set_pos(struct entity *e, struct point p, struct map *map)
-{
-    if (e->solid) {
-        if (p.y < 0 || p.x < 0 || p.y >= map->height || p.x >= map->width) {
-            return false;
-        }
-        if (map->map[p.y * map->width + p.x] == WALL) {
-            return false;
-        }
-    }
-
-    e->p = p;
-
-    return true;
-}
-
-bool game_update(
-    display_t *disp, enum action action, ht_t *entities, struct map *map
-)
-{
-    struct entity *player = ht_find(entities, "player");
-    struct entity *camera = ht_find(entities, "camera");
-
-    struct point newp     = player->p;
-    struct point newp_cam = camera->p;
-    switch (action) {
-    case ACTION_EXIT : return true;
-    case ACTION_UP :
-        --newp.y;
-        --newp_cam.y;
-        display_message(disp, "moving up");
-        break;
-    case ACTION_DOWN :
-        ++newp.y;
-        ++newp_cam.y;
-        display_message(disp, "moving down");
-        break;
-    case ACTION_LEFT :
-        --newp.x;
-        --newp_cam.x;
-        display_message(disp, "moving left");
-        break;
-    case ACTION_RIGHT :
-        ++newp.x;
-        ++newp_cam.x;
-        display_message(disp, "moving right");
-        break;
-    case ACTION_STAIR_DOWN :
-        if (map->map[player->p.y * map->width + player->p.x] == DOWN_STAIR) {
-            free(map->map);
-            create_cave(map);
-
-            newp       = map->entry_point;
-            newp_cam.x = map->entry_point.x - MAIN_PANEL_WIDTH / 2 + 1;
-            newp_cam.y = map->entry_point.y - MAIN_PANEL_HEIGHT / 2 + 1;
-            display_message(disp, "moving down stairs");
-        } else {
-            display_message(disp, "no stairs to go down");
-        }
-        break;
-    case ACTION_STAIR_UP :
-        if (map->map[player->p.y * WIDTH + player->p.x] == UP_STAIR) {
-            display_message(disp, "moving up stairs");
-            return true;
-        } else {
-            display_message(disp, "no stairs to go up");
-        }
-        break;
-    default : display_message(disp, "unrecognized command"); break;
-    }
-
-    if (entity_set_pos(player, newp, map))
-        entity_set_pos(camera, newp_cam, map);
-
-    return false;
-}
-
-void print_version(void)
-{
-    printf("%s\n", PACKAGE_STRING);
-    printf("Copyright (C) 2024  Jacob Janzen\n");
-    printf("This is free software; see the source for copying conditions.\n");
-    printf(
-        "There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A\n"
-    );
-    printf("PARTICULAR PURPOSE.\n");
-}
-
-int main(int argc, char **argv)
-{
-    int           option_index = 0;
-    int           ch;
-    int           version_flag = 0;
-    struct option longopts[]   = {
-        {"version", no_argument, &version_flag, 'v'},
-    };
-    while ((ch = getopt_long(argc, argv, ":v", longopts, &option_index)) != -1
-    ) {
-        switch (ch) {
-        case 'v' : version_flag = 1; break;
-        case 0 : break;
-        default : break;
-        }
-    }
-    if (version_flag) {
-        print_version();
-        return EXIT_SUCCESS;
-    }
-
-    unsigned int seed = time(NULL);
-    srand(seed);
-
-    display_t *disp = display_init();
-
-    if (!disp) {
-        return EXIT_FAILURE;
-    }
-
-    // create the map
-    struct map map;
-    create_cave(&map);
-
-    // create the entity map
-    ht_t *entities = ht_create(1);
-
-    // create the camera
-    struct entity camera;
-    camera.disp_ch = " ";
-    camera.solid   = false;
-    camera.visible = false;
-    ht_insert(entities, "camera", &camera);
-
-    // create the player
-    struct entity player;
-    player.disp_ch = "@";
-    player.solid   = true;
-    player.visible = true;
-    ht_insert(entities, "player", &player);
-
-    // set starting point
-    struct point cam_p = {
-        .x = map.entry_point.x - MAIN_PANEL_WIDTH / 2 + 1,
-        .y = map.entry_point.y - MAIN_PANEL_HEIGHT / 2 + 1,
-    };
-    entity_set_pos(&player, map.entry_point, &map);
-    entity_set_pos(&camera, cam_p, &map);
-
-    // start displaying things
-    display_map(disp, &map, entities);
-    display_instructions(disp);
-    display_status(disp, &player);
-    display_message(disp, "");
-
-    bool done = false;
-    while (!done) {
-        enum action action = display_process_input();
-        done               = game_update(disp, action, entities, &map);
-        display_map(disp, &map, entities);
-    }
-
-    free(map.map);
-    ht_destroy(entities);
-    display_destroy(disp);
-
-    endwin();
-
-    return 0;
-}

src/main.zig

@@ -0,0 +1,26 @@
+const std = @import("std");
+const IO = @import("frontend/sdl.zig").IO;
+const run = @import("run.zig");
+
+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});
+        return 1;
+    };
+    defer io.deinit();
+
+    run.run(allocator, &io) catch return 1;
+
+    return status;
+}

src/root.zig

@@ -0,0 +1,12 @@
+const std = @import("std");
+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);
+}