path: root/src/eetg.c

/*
 * Copyright (c) 2024 Richard Braun.
 *
 * Permission to use, copy, modify, and/or distribute this software for
 * any purpose with or without fee is hereby granted.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE
 * FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY
 * DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
 * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 *
 * Engine for embedded text-based games.
 */

#include <stdio.h>

#include <assert.h>
#include <limits.h>
#include <stdbool.h>
#include <stddef.h>
#include <string.h>

#include "eetg.h"
#include "macros.h"

#define EETG_RENDERING_DISABLED 0

#define EETG_BG_COLOR EETG_COLOR_BLACK
#define EETG_FG_COLOR EETG_COLOR_WHITE

#define EETG_CSI "\e["

static unsigned int eetg_rand_next = 1;

static void
eetg_object_attach(struct eetg_object *object, struct eetg_world *world,
                   int x, int y, int layer_id)
{
    assert(object);
    assert(!object->world);
    assert(object->layer_id < 0);
    assert(world);
    assert(layer_id >= 0);

    object->world = world;
    object->x = x;
    object->y = y;
    object->layer_id = layer_id;
}

static void
eetg_object_detach(struct eetg_object *object)
{
    assert(object);
    assert(object->world);
    assert(object->layer_id >= 0);

    object->world = NULL;
    object->next = NULL;
    object->layer_id = -1;
}

static signed char
eetg_object_get_char(const struct eetg_object *object, int x, int y)
{
    int index;

    index = eetg_object_get_cell(object, x, y);

    if (index == -1) {
        return index;
    }

    return object->sprite[index];
}

static bool
eetg_object_check_collision(struct eetg_object *object1,
                            struct eetg_object *object2,
                            eetg_handle_collision_fn handle_collision_fn,
                            void *handle_collision_fn_arg)
{
    int o1xbr, o1ybr, o2xbr, o2ybr;
    int xtl, ytl, xbr, ybr;

    assert(object1);
    assert(object2);
    assert(handle_collision_fn);

    o1xbr = object1->x + object1->width - 1;
    o1ybr = object1->y + object1->height - 1;

    o2xbr = object2->x + object2->width - 1;
    o2ybr = object2->y + object2->height - 1;

    if ((object2->x > o1xbr) || (object1->x > o2xbr) ||
        (object2->y > o1ybr) || (object1->y > o2ybr)) {
        return false;
    }

    xtl = (object1->x > object2->x) ? object1->x : object2->x;
    ytl = (object1->y > object2->y) ? object1->y : object2->y;
    xbr = (o1xbr < o2xbr) ? o1xbr : o2xbr;
    ybr = (o1ybr < o2ybr) ? o1ybr : o2ybr;

    assert(xtl <= xbr);
    assert(ytl <= ybr);

    for (int i = xtl; i <= xbr; i++) {
        for (int j = ytl; j <= ybr; j++) {
            signed char c1, c2;
            bool hit;

            c1 = eetg_object_get_char(object1, i, j);
            c2 = eetg_object_get_char(object2, i, j);

            if ((c1 <= 0) || (c2 <= 0)) {
                return false;
            } else if ((c1 == ' ') || (c2 == ' ')) {
                continue;
            }

            hit = handle_collision_fn(object1, object2, i, j,
                                      handle_collision_fn_arg);

            if (hit) {
                return true;
            }

            if ((eetg_object_get_world(object1) == NULL)
                || (eetg_object_get_world(object2) == NULL))
            {
                return false;
            }
        }
    }

    return false;
}

static void
eetg_layer_init(struct eetg_layer *layer)
{
    assert(layer);

    layer->objects = NULL;
}

static struct eetg_object *
eetg_layer_get_objects(const struct eetg_layer *layer)
{
    assert(layer);

    return layer->objects;
}

static void
eetg_layer_clear(struct eetg_layer *layer)
{
    struct eetg_object *object;

    assert(layer);

    object = layer->objects;

    while (object) {
        struct eetg_object *next = object->next;

        eetg_object_detach(object);
        object = next;
    }

    layer->objects = NULL;
}

static void
eetg_layer_add(struct eetg_layer *layer, struct eetg_object *object)
{
    assert(layer);
    assert(object);

    object->next = layer->objects;
    layer->objects = object;
}

static bool
eetg_layer_remove(struct eetg_layer *layer, struct eetg_object *object)
{
    assert(layer);
    assert(object);

    if (!layer->objects) {
        return false;
    }

    if (layer->objects == object) {
        layer->objects = object->next;
        return true;
    }

    for (struct eetg_object *tmp = layer->objects; tmp->next; tmp = tmp->next) {
        if (tmp->next == object) {
            tmp->next = tmp->next->next;
            return true;
        }
    }

    return false;
}

static struct eetg_object *
eetg_layer_lookup(struct eetg_layer *layer, int x, int y)
{
    assert(layer);

    for (struct eetg_object *object = layer->objects;
         object;
         object = object->next) {
        signed char c;

        c = eetg_object_get_char(object, x, y);

        if ((c > 0) && (c != ' ')) {
            return object;
        }
    }

    return NULL;
}

static void
eetg_view_cell_set(struct eetg_view_cell *view_cell,
                   char c, int color)
{
    assert(view_cell);

    view_cell->c = c;
    view_cell->color = color;
}

static char
eetg_view_cell_get_c(const struct eetg_view_cell *view_cell)
{
    assert(view_cell);

    return view_cell->c;
}

static int
eetg_view_cell_get_color(const struct eetg_view_cell *view_cell)
{
    assert(view_cell);

    return view_cell->color;
}

static struct eetg_view_cell *
eetg_view_row_get_cell(struct eetg_view_row *view_row, int index)
{
    assert(view_row);
    assert(index >= 0);
    assert(index < (int)ARRAY_SIZE(view_row->columns));

    return &view_row->columns[index];
}

static void
eetg_view_row_init(struct eetg_view_row *view_row)
{
    assert(view_row);

    for (size_t i = 0; i < ARRAY_SIZE(view_row->columns); i++) {
        struct eetg_view_cell *view_cell;

        view_cell = eetg_view_row_get_cell(view_row, (int)i);
        eetg_view_cell_set(view_cell, ' ', EETG_BG_COLOR);
    }
}

static struct eetg_view_row *
eetg_view_get_row(struct eetg_view *view, int index)
{
    assert(view);
    assert(index >= 0);
    assert(index < (int)ARRAY_SIZE(view->rows));

    return &view->rows[index];
}

static void
eetg_view_init(struct eetg_view *view)
{
    assert(view);

    for (size_t i = 0; i < ARRAY_SIZE(view->rows); i++) {
        eetg_view_row_init(eetg_view_get_row(view, (int)i));
    }
}

void
eetg_world_init(struct eetg_world *world, eetg_write_fn write_fn, void *arg)
{
    assert(world);
    assert(write_fn);

    world->write_fn = write_fn;
    world->write_fn_arg = arg;

    world->handle_collision_fn = NULL;

    for (size_t i = 0; i < ARRAY_SIZE(world->layers); i++) {
        eetg_layer_init(&world->layers[i]);
    }

    eetg_view_init(&world->views[0]);
    eetg_view_init(&world->views[1]);

    world->view = &world->views[0];
    world->prev_view = &world->views[1];

    world->cursor_row = -1;
    world->cursor_column = -1;
    world->current_color = EETG_FG_COLOR;
    world->handling_collision = false;
}

void
eetg_world_clear(struct eetg_world *world)
{
    assert(world);

    for (size_t i = 0; i < ARRAY_SIZE(world->layers); i++) {
        eetg_layer_clear(&world->layers[i]);
    }
}

void
eetg_world_set_collision_fn(struct eetg_world *world,
                            eetg_handle_collision_fn handle_collision_fn,
                            void *arg)
{
    assert(world);

    world->handle_collision_fn = handle_collision_fn;
    world->handle_collision_fn_arg = arg;
}

static bool
eetg_world_scan_collisions(struct eetg_world *world, struct eetg_object *object)
{
    bool hit = false;

    assert(world);
    assert(!world->handling_collision);

    if (!world->handle_collision_fn) {
        return false;
    }

    world->handling_collision = true;

    for (size_t i = 0; i < ARRAY_SIZE(world->layers); i++) {
        struct eetg_layer *layer;
        struct eetg_object *tmp;

        layer = &world->layers[i];
        tmp = eetg_layer_get_objects(layer);

        while (tmp) {
            struct eetg_object *next;

            next = tmp->next;

            if (tmp != object) {
                hit = eetg_object_check_collision(object, tmp,
                          world->handle_collision_fn,
                          world->handle_collision_fn_arg);

                if (hit || (eetg_object_get_world(object) == NULL)) {
                    goto out;
                }
            }

            tmp = next;
        }
    }

out:
    world->handling_collision = false;

    return hit;
}

bool
eetg_world_add(struct eetg_world *world, struct eetg_object *object,
               int x, int y, int layer_id)
{
    struct eetg_layer *layer;
    bool hit;

    assert(world);
    assert(eetg_object_get_world(object) == NULL);
    assert(layer_id < (int)ARRAY_SIZE(world->layers));

    layer = &world->layers[layer_id];
    eetg_layer_add(layer, object);

    eetg_object_attach(object, world, x, y, layer_id);
    hit = eetg_world_scan_collisions(world, object);

    if (hit && (eetg_object_get_world(object) != NULL)) {
        eetg_world_remove(world, object);
    }

    return hit;
}

struct eetg_object *
eetg_world_lookup(struct eetg_world *world, int x, int y, int layer_id)
{
    assert(world);

    for (int i = ARRAY_SIZE(world->layers) - 1; i >= 0; i--) {
        if ((layer_id < 0) || (i == layer_id)) {
            struct eetg_layer *layer = &world->layers[i];
            struct eetg_object *object;

            object = eetg_layer_lookup(layer, x, y);

            if (object) {
                return object;
            }
        }
    }

    return NULL;
}

void
eetg_world_remove(struct eetg_world *world, struct eetg_object *object)
{
    bool removed = false;

    assert(world);
    assert(eetg_object_get_world(object) == world);

    for (size_t i = 0; i < ARRAY_SIZE(world->layers); i++) {
        struct eetg_layer *layer = &world->layers[i];

        removed = eetg_layer_remove(layer, object);

        if (removed) {
            break;
        }
    }

    assert(removed);

    eetg_object_detach(object);
}

static void
eetg_object_render_row(struct eetg_object *object, int row,
                       struct eetg_view_row *view_row)
{
    const char *line;

    assert(object);
    assert(row < object->height);

    line = &object->sprite[(object->width + 1) * row];

    for (int obj_column = 0; obj_column < object->width; obj_column++) {
        int column = object->x + obj_column;
        char c;

        if ((column < 0) || (column >= EETG_COLUMNS)) {
            continue;
        }

        c = line[obj_column];

        if (c != ' ') {
            struct eetg_view_cell *view_cell;

            view_cell = eetg_view_row_get_cell(view_row, column);
            eetg_view_cell_set(view_cell, c, object->color);
        }
    }
}

static void
eetg_object_render(struct eetg_object *object, struct eetg_view *view)
{
    assert(object);

    for (int obj_row = 0; obj_row < object->height; obj_row++) {
        int row = object->y + obj_row;

        if ((row < 0) || (row >= EETG_ROWS)) {
            continue;
        }

        eetg_object_render_row(object, obj_row, eetg_view_get_row(view, row));
    }
}

static void
eetg_world_write(struct eetg_world *world, const void *buffer, size_t size)
{
    assert(world);
    assert(world->write_fn);
    assert(buffer);

#if EETG_RENDERING_DISABLED
    (void)buffer;
    (void)size;
#else
    world->write_fn(buffer, size, world->write_fn_arg);
#endif
}

static void
eetg_world_write_str(struct eetg_world *world, const char *str)
{
    eetg_world_write(world, str, strlen(str));
}

static void
eetg_world_set_cursor(struct eetg_world *world, int row, int column)
{
    char str[32];

    assert(world);
    assert(row >= 0);
    assert(row < EETG_ROWS);
    assert(column >= 0);
    assert(column < EETG_COLUMNS);

    if ((world->cursor_row == row) && (world->cursor_column == column)) {
        return;
    }

    snprintf(str, sizeof(str), EETG_CSI "%d;%dH", row + 1, column + 1);
    eetg_world_write_str(world, str);

    world->cursor_row = row;
    world->cursor_column = column;
}

static int
eetg_convert_fg_color(int color)
{
    return color + 30;
}

static int
eetg_convert_bg_color(int color)
{
    return eetg_convert_fg_color(color) + 10;
}

static void
eetg_world_set_color(struct eetg_world *world, int color, bool force)
{
    char str[16];

    if ((color == world->current_color) && !force) {
        return;
    }

    snprintf(str, sizeof(str), EETG_CSI "%d;%dm",
             eetg_convert_fg_color(color),
             eetg_convert_bg_color(EETG_BG_COLOR));

    eetg_world_write_str(world, str);

    world->current_color = color;
}

static void
eetg_world_write_char(struct eetg_world *world, char c)
{
    eetg_world_write(world, &c, sizeof(c));

    world->cursor_column++;

    if (world->cursor_column == EETG_COLUMNS) {
        if (world->cursor_row == EETG_ROWS) {
            world->cursor_column = EETG_COLUMNS - 1;
        } else {
            world->cursor_column = 0;
            world->cursor_row++;
        }
    }
}

static void
eetg_world_swap_views(struct eetg_world *world)
{
    struct eetg_view *tmp;

    assert(world);

    tmp = world->view;
    world->view = world->prev_view;
    world->prev_view = tmp;
}

static void
eetg_world_render_sync(struct eetg_world *world)
{
    assert(world);

    eetg_world_write_str(world, EETG_CSI "?25l"); /* cursor invisible */
    eetg_world_set_color(world, EETG_FG_COLOR, true);
    eetg_world_write_str(world, EETG_CSI "2J"); /* clear screen */
    eetg_world_set_cursor(world, 0, 0);

    for (int row = 0; row < EETG_ROWS; row++) {
        struct eetg_view_row *view_row;

        view_row = eetg_view_get_row(world->view, row);

        for (int column = 0; column < EETG_COLUMNS; column++) {
            struct eetg_view_cell *view_cell;
            int color;
            char c;

            view_cell = eetg_view_row_get_cell(view_row, column);
            color = eetg_view_cell_get_color(view_cell);
            c = eetg_view_cell_get_c(view_cell);

            if (c == ' ') {
                continue;
            }

            eetg_world_set_cursor(world, row, column);
            eetg_world_set_color(world, color, false);
            eetg_world_write_char(world, c);
        }
    }
}

static void
eetg_world_render_delta(struct eetg_world *world)
{
    assert(world);

    for (int row = 0; row < EETG_ROWS; row++) {
        struct eetg_view_row *view_row, *prev_view_row;

        view_row = eetg_view_get_row(world->view, row);
        prev_view_row = eetg_view_get_row(world->prev_view, row);

        for (int column = 0; column < EETG_COLUMNS; column++) {
            struct eetg_view_cell *view_cell, *prev_view_cell;
            int color, prev_color;
            char c, prev_c;

            view_cell = eetg_view_row_get_cell(view_row, column);
            color = eetg_view_cell_get_color(view_cell);
            c = eetg_view_cell_get_c(view_cell);

            prev_view_cell = eetg_view_row_get_cell(prev_view_row, column);
            prev_color = eetg_view_cell_get_color(prev_view_cell);
            prev_c = eetg_view_cell_get_c(prev_view_cell);

            if ((color != prev_color) || (c != prev_c)) {
                eetg_world_set_cursor(world, row, column);
                eetg_world_set_color(world, color, false);
                eetg_world_write_char(world, c);
            }
        }
    }
}

void
eetg_world_render(struct eetg_world *world, bool sync)
{
    for (int row = 0; row < EETG_ROWS; row++) {
        struct eetg_view_row *view_row;

        view_row = eetg_view_get_row(world->view, row);

        for (int column = 0; column < EETG_COLUMNS; column++) {
            struct eetg_view_cell *view_cell;

            view_cell = eetg_view_row_get_cell(view_row, column);
            eetg_view_cell_set(view_cell, ' ', EETG_FG_COLOR);
        }
    }

    for (size_t i = 0; i < ARRAY_SIZE(world->layers); i++) {
        struct eetg_layer *layer;
        struct eetg_object *object;

        layer = &world->layers[i];
        object = eetg_layer_get_objects(layer);

        while (object) {
            eetg_object_render(object, world->view);
            object = object->next;
        }
    }

    if (sync) {
        eetg_world_render_sync(world);
    } else {
        eetg_world_render_delta(world);
    }

    eetg_world_set_cursor(world, 0, 0);
    eetg_world_swap_views(world);
}

static void
eetg_object_compute_dimensions(struct eetg_object *object)
{
    size_t width;
    char *ptr;

    assert(object);

    ptr = strchr(object->sprite, '\n');
    assert(ptr);

    width = ptr - object->sprite;
    assert(width <= INT_MAX);

    object->width = (int)width;
    object->height = 1;

    for (;;) {
        char *next;

        ptr = &ptr[1];
        next = strchr(ptr, '\n');

        if (!next) {
            break;
        }

        width = next - ptr;
        assert(width <= INT_MAX);
        assert((int)width == object->width);

        assert(object->height < INT_MAX);
        object->height++;

        ptr = next;
    }
}

void
eetg_object_init(struct eetg_object *object, int type, const char *sprite)
{
    assert(object);

    object->world = NULL;
    object->next = NULL;
    object->sprite = sprite;
    object->color = EETG_FG_COLOR;
    object->type = type;
    object->x = 0;
    object->y = 0;
    object->layer_id = -1;

    eetg_object_compute_dimensions(object);
}

void
eetg_object_set_color(struct eetg_object *object, int color)
{
    assert(object);

    object->color = color;
}

int
eetg_object_get_type(const struct eetg_object *object)
{
    assert(object);

    return object->type;
}

const char *
eetg_object_get_sprite(const struct eetg_object *object)
{
    assert(object);

    return object->sprite;
}

int
eetg_object_get_x(const struct eetg_object *object)
{
    assert(object);

    return object->x;
}

int
eetg_object_get_y(const struct eetg_object *object)
{
    assert(object);

    return object->y;
}

int
eetg_object_get_width(const struct eetg_object *object)
{
    assert(object);

    return object->width;
}

int
eetg_object_get_height(const struct eetg_object *object)
{
    assert(object);

    return object->height;
}

bool
eetg_object_is_empty(const struct eetg_object *object)
{
    assert(object);

    for (const char *ptr = object->sprite; ptr; ptr++) {
        char c = *ptr;

        if (c == '\0') {
            break;
        } else if ((c != ' ') && (c != '\n')) {
            return false;
        }
    }

    return true;
}

bool
eetg_object_move(struct eetg_object *object, int x, int y)
{
    bool hit = false;
    int prev_x, prev_y;

    assert(object);

    prev_x = object->x;
    prev_y = object->y;
    object->x = x;
    object->y = y;

    if (object->world) {
        hit = eetg_world_scan_collisions(object->world, object);

        if (hit && object->world) {
            object->x = prev_x;
            object->y = prev_y;
        }
    }

    return hit;
}

bool
eetg_object_update(struct eetg_object *object)
{
    assert(object);

    eetg_object_compute_dimensions(object);
    return eetg_object_move(object, object->x, object->y);
}

int
eetg_object_get_cell(const struct eetg_object *object, int x, int y)
{
    assert(object);
    assert(object->world);

    x -= object->x;
    y -= object->y;

    if ((x < 0) || (x >= object->width) || (y < 0) || (y >= object->height)) {
        return -1;
    }

    return ((object->width + 1) * y) + (x % object->width);
}

struct eetg_world *
eetg_object_get_world(const struct eetg_object *object)
{
    assert(object);

    return object->world;
}

bool
eetg_object_has_type(const struct eetg_object *object1,
                     const struct eetg_object *object2,
                     int type)
{
    return (eetg_object_get_type(object1) == type)
           || (eetg_object_get_type(object2) == type);
}

void eetg_init_rand(unsigned int seed)
{
    eetg_rand_next = seed;
}

int eetg_rand(void)
{
    eetg_rand_next = (eetg_rand_next * 1103515245) + 12345;
    return (eetg_rand_next / 65536) % (EETG_RAND_MAX + 1);
}