pxl8/src/pxl8.c

#define PXL8_AUTHORS "asrael <asrael@pxl8.org>"
#define PXL8_COPYRIGHT "Copyright (c) 2024-2025 pxl8.org"
#define PXL8_VERSION "0.1.0"

#include <stdlib.h>
#include <string.h>

#include <pthread.h>
#include <sys/stat.h>
#include <unistd.h>

#include "pxl8_cart.h"
#include "pxl8_game.h"
#include "pxl8_hal.h"
#include "pxl8_log.h"
#include "pxl8_repl.h"
#include "pxl8_script.h"
#include "pxl8_sys.h"
#include "pxl8_types.h"

struct pxl8 {
    pxl8_cart* cart;
    pxl8_game* game;
    pxl8_repl* repl;
    pxl8_log log;
    const pxl8_hal* hal;
    void* platform_data;
};

pxl8* pxl8_create(const pxl8_hal* hal) {
    pxl8* sys = (pxl8*)calloc(1, sizeof(pxl8));
    if (!sys) return NULL;

    pxl8_log_init(&sys->log);

    if (!hal) {
        pxl8_error("hal cannot be null");
        free(sys);
        return NULL;
    }

    sys->hal = hal;

    sys->game = (pxl8_game*)calloc(1, sizeof(pxl8_game));
    if (!sys->game) {
        pxl8_error("failed to allocate game");
        free(sys);
        return NULL;
    }

    return sys;
}

void pxl8_destroy(pxl8* sys) {
    if (!sys) return;

    if (sys->game) free(sys->game);
    if (sys->cart) pxl8_cart_destroy(sys->cart);
    if (sys->hal && sys->platform_data) sys->hal->destroy(sys->platform_data);

    free(sys);
}

pxl8_result pxl8_init(pxl8* sys, i32 argc, char* argv[]) {
    if (!sys || !sys->game) return PXL8_ERROR_INVALID_ARGUMENT;

    pxl8_game* game = sys->game;
    pxl8_pixel_mode pixel_mode = PXL8_PIXEL_INDEXED;
    pxl8_resolution resolution = PXL8_RESOLUTION_640x360;
    const char* script_arg = NULL;
    bool bundle_mode = false;
    bool pack_mode = false;
    const char* pack_input = NULL;
    const char* pack_output = NULL;

    for (i32 i = 1; i < argc; i++) {
        if (strcmp(argv[i], "--repl") == 0) {
            game->repl_mode = true;
        } else if (strcmp(argv[i], "--bundle") == 0) {
            bundle_mode = true;
            if (i + 2 < argc) {
                pack_input = argv[++i];
                pack_output = argv[++i];
            } else {
                pxl8_error("--bundle requires <folder|.pxc> <output>");
                return PXL8_ERROR_INVALID_ARGUMENT;
            }
        } else if (strcmp(argv[i], "--pack") == 0) {
            pack_mode = true;
            if (i + 2 < argc) {
                pack_input = argv[++i];
                pack_output = argv[++i];
            } else {
                pxl8_error("--pack requires <folder> <output.pxc>");
                return PXL8_ERROR_INVALID_ARGUMENT;
            }
        } else if (!script_arg) {
            script_arg = argv[i];
        }
    }

    if (bundle_mode) {
        char exe_path[1024];
        ssize_t len = readlink("/proc/self/exe", exe_path, sizeof(exe_path) - 1);
        if (len == -1) {
            pxl8_error("failed to resolve executable path");
            return PXL8_ERROR_SYSTEM_FAILURE;
        }
        exe_path[len] = '\0';
        pxl8_result result = pxl8_cart_bundle(pack_input, pack_output, exe_path);
        return result;
    }

    if (pack_mode) {
        pxl8_result result = pxl8_cart_pack(pack_input, pack_output);
        return result;
    }

    if (game->repl_mode) {
        pxl8_info("starting in REPL mode with script: %s", game->script_path);
    }

    pxl8_info("starting up");

    sys->platform_data = sys->hal->create(pixel_mode, resolution, "pxl8", 1280, 720);
    if (!sys->platform_data) {
        pxl8_error("failed to create platform context");
        return PXL8_ERROR_INITIALIZATION_FAILED;
    }

    game->gfx = pxl8_gfx_create(sys->hal, sys->platform_data, pixel_mode, resolution);
    if (!game->gfx) {
        pxl8_error("failed to create graphics context");
        return PXL8_ERROR_INITIALIZATION_FAILED;
    }

    if (pxl8_gfx_load_font_atlas(game->gfx) != PXL8_OK) {
        pxl8_error("failed to load font atlas");
        return PXL8_ERROR_INITIALIZATION_FAILED;
    }

    game->script = pxl8_script_create(game->repl_mode);
    if (!game->script) {
        pxl8_error("failed to initialize scripting: %s", pxl8_script_get_last_error(game->script));
        return PXL8_ERROR_INITIALIZATION_FAILED;
    }

    bool has_embedded = pxl8_cart_has_embedded(argv[0]);
    const char* cart_path = script_arg;

    if (has_embedded && !script_arg) {
        sys->cart = pxl8_cart_create();
        if (!sys->cart) {
            pxl8_error("failed to create cart");
            return PXL8_ERROR_INITIALIZATION_FAILED;
        }
        if (pxl8_cart_load_embedded(sys->cart, argv[0]) == PXL8_OK) {
            pxl8_cart_mount(sys->cart);
            strncpy(game->script_path, "main.fnl", sizeof(game->script_path) - 1);
            game->script_path[sizeof(game->script_path) - 1] = '\0';
            pxl8_info("running embedded cart");
        } else {
            pxl8_error("failed to load embedded cart");
            return PXL8_ERROR_INITIALIZATION_FAILED;
        }
    } else if (cart_path || !has_embedded) {
        if (!cart_path) cart_path = "demo";

        struct stat st;
        bool is_cart = (stat(cart_path, &st) == 0 && S_ISDIR(st.st_mode)) ||
                       (cart_path && strstr(cart_path, ".pxc"));

        if (is_cart) {
            char* original_cwd = getcwd(NULL, 0);
            sys->cart = pxl8_cart_create();
            if (!sys->cart) {
                pxl8_error("failed to create cart");
                return PXL8_ERROR_INITIALIZATION_FAILED;
            }
            if (pxl8_cart_load(sys->cart, cart_path) == PXL8_OK) {
                pxl8_script_set_cart_path(game->script, pxl8_cart_get_base_path(sys->cart), original_cwd);
                pxl8_cart_mount(sys->cart);
                strncpy(game->script_path, "main.fnl", sizeof(game->script_path) - 1);
                game->script_path[sizeof(game->script_path) - 1] = '\0';
            } else {
                pxl8_error("failed to load cart: %s", cart_path);
                return PXL8_ERROR_INITIALIZATION_FAILED;
            }
            free(original_cwd);
        } else if (script_arg) {
            strncpy(game->script_path, script_arg, sizeof(game->script_path) - 1);
            game->script_path[sizeof(game->script_path) - 1] = '\0';
        }
    }

    pxl8_script_set_gfx(game->script, game->gfx);
    pxl8_script_set_input(game->script, &game->input);
    pxl8_script_set_sys(game->script, sys);

    if (game->script_path[0] != '\0') {
        pxl8_result result = pxl8_script_load_main(game->script, game->script_path);
        game->script_loaded = (result == PXL8_OK);

        if (game->script_loaded && !game->repl_mode) {
            pxl8_script_call_function(game->script, "init");
        }
    }

    game->last_time = sys->hal->get_ticks();
    game->running = true;

    return PXL8_OK;
}

pxl8_result pxl8_update(pxl8* sys) {
    if (!sys || !sys->game) {
        return PXL8_ERROR_INVALID_ARGUMENT;
    }

    pxl8_game* game = sys->game;
    u64 current_time = sys->hal->get_ticks();
    f32 dt = (f32)(current_time - game->last_time) / 1000000000.0f;

    game->last_time = current_time;
    game->time += dt;
    game->fps_accumulator += dt;
    game->fps_frame_count++;

    if (game->fps_accumulator >= 1.0f) {
        game->fps = (f32)game->fps_frame_count / game->fps_accumulator;
        game->fps_accumulator = 0.0f;
        game->fps_frame_count = 0;
    }

    pxl8_script_check_reload(game->script);

    if (game->repl_mode && !game->repl_started) {
        if (game->script_loaded) {
            pxl8_script_call_function(game->script, "init");
        }

        if (pxl8_script_load_module(game->script, "pxl8") != PXL8_OK) {
            const char* err_msg = pxl8_script_get_last_error(game->script);
            pxl8_error("failed to setup pxl8 global: %s", err_msg);
        }

        sys->repl = pxl8_repl_create();
        game->repl_started = true;
    }

    if (game->repl_mode && sys->repl) {
        if (pxl8_repl_should_quit(sys->repl)) game->running = false;

        pxl8_repl_command* cmd = pxl8_repl_pop_command(sys->repl);
        if (cmd) {
            pxl8_result result = pxl8_script_eval_repl(game->script, pxl8_repl_command_buffer(cmd));
            if (result != PXL8_OK) {
                if (pxl8_script_is_incomplete_input(game->script)) {
                    pxl8_repl_signal_complete(sys->repl);
                } else {
                    pxl8_error("%s", pxl8_script_get_last_error(game->script));
                    pxl8_repl_clear_accumulator(sys->repl);
                    pxl8_repl_signal_complete(sys->repl);
                }
            } else {
                pxl8_repl_clear_accumulator(sys->repl);
                pxl8_repl_signal_complete(sys->repl);
            }
        }
    }

    pxl8_gfx_update(game->gfx, dt);

    if (game->script_loaded) {
        pxl8_script_call_function_f32(game->script, "update", dt);
    }

    return PXL8_OK;
}

pxl8_result pxl8_frame(pxl8* sys) {
    if (!sys || !sys->game) return PXL8_ERROR_INVALID_ARGUMENT;

    pxl8_game* game = sys->game;
    pxl8_bounds bounds = pxl8_gfx_get_bounds(game->gfx);

    if (game->script_loaded) {
        pxl8_result frame_result = pxl8_script_call_function(game->script, "frame");
        if (frame_result == PXL8_ERROR_SCRIPT_ERROR) {
            pxl8_error("error calling frame: %s", pxl8_script_get_last_error(game->script));
        }
    } else {
        pxl8_clear(game->gfx, 32);

        i32 render_w = pxl8_gfx_get_width(game->gfx);
        i32 render_h = pxl8_gfx_get_height(game->gfx);

        for (i32 y = 0; y < render_h; y += 24) {
            for (i32 x = 0; x < render_w; x += 32) {
                u32 color = ((x / 32) + (y / 24) + (i32)(game->time * 2)) % 8;
                pxl8_rect_fill(game->gfx, x, y, 31, 23, color);
            }
        }
    }

    pxl8_gfx_set_viewport(game->gfx, pxl8_gfx_viewport(bounds, pxl8_gfx_get_width(game->gfx), pxl8_gfx_get_height(game->gfx)));
    pxl8_gfx_upload_framebuffer(game->gfx);
    pxl8_gfx_upload_atlas(game->gfx);
    pxl8_gfx_present(game->gfx);

    memset(game->input.keys_pressed, 0, sizeof(game->input.keys_pressed));
    memset(game->input.keys_released, 0, sizeof(game->input.keys_released));
    memset(game->input.mouse_buttons_pressed, 0, sizeof(game->input.mouse_buttons_pressed));
    memset(game->input.mouse_buttons_released, 0, sizeof(game->input.mouse_buttons_released));

    game->frame_count++;
    game->input.mouse_dx = 0;
    game->input.mouse_dy = 0;
    game->input.mouse_wheel_x = 0;
    game->input.mouse_wheel_y = 0;

    return PXL8_OK;
}

void pxl8_quit(pxl8* sys) {
    if (!sys || !sys->game) return;

    pxl8_game* game = sys->game;

    pxl8_info("shutting down");

    if (sys->cart) {
        pxl8_cart_unmount(sys->cart);
    }

    pxl8_gfx_destroy(game->gfx);
    pxl8_script_destroy(game->script);
}

bool pxl8_is_running(const pxl8* sys) {
    return sys && sys->game && sys->game->running;
}

void pxl8_set_running(pxl8* sys, bool running) {
    if (sys && sys->game) {
        sys->game->running = running;
        if (!running && sys->repl) {
            pxl8_repl_destroy(sys->repl);
            sys->repl = NULL;
        }
    }
}

f32 pxl8_get_fps(const pxl8* sys) {
    return (sys && sys->game) ? sys->game->fps : 0.0f;
}

pxl8_gfx* pxl8_get_gfx(const pxl8* sys) {
    return (sys && sys->game) ? sys->game->gfx : NULL;
}

pxl8_input_state* pxl8_get_input(const pxl8* sys) {
    return (sys && sys->game) ? &sys->game->input : NULL;
}

void pxl8_center_cursor(pxl8* sys) {
    if (!sys || !sys->hal || !sys->hal->center_cursor) return;
    sys->hal->center_cursor(sys->platform_data);
}

void pxl8_set_cursor(pxl8* sys, pxl8_cursor cursor) {
    if (!sys || !sys->hal || !sys->hal->set_cursor) return;
    sys->hal->set_cursor(sys->platform_data, cursor);
}

void pxl8_set_relative_mouse_mode(pxl8* sys, bool enabled) {
    if (!sys || !sys->hal || !sys->hal->set_relative_mouse_mode) return;
    sys->hal->set_relative_mouse_mode(sys->platform_data, enabled);
    if (sys->game) {
        sys->game->input.mouse_relative_mode = enabled;
    }
}

pxl8_size pxl8_get_resolution_dimensions(pxl8_resolution resolution) {
    switch (resolution) {
        case PXL8_RESOLUTION_240x160: return (pxl8_size){240, 160};
        case PXL8_RESOLUTION_320x180: return (pxl8_size){320, 180};
        case PXL8_RESOLUTION_320x240: return (pxl8_size){320, 240};
        case PXL8_RESOLUTION_640x360: return (pxl8_size){640, 360};
        case PXL8_RESOLUTION_640x480: return (pxl8_size){640, 480};
        case PXL8_RESOLUTION_800x600: return (pxl8_size){800, 600};
        case PXL8_RESOLUTION_960x540: return (pxl8_size){960, 540};
        default: return (pxl8_size){640, 360};
    }
}