Separate engine and game

CMakeLists.txt

@@ -3,35 +3,24 @@ project(PixelDefense C)
 
 set(CMAKE_C_STANDARD 11)
 
-#set(BUILD_EXAMPLES true)
 
-add_subdirectory(libs/raylib-4.5.0)
-
-set(
-        lib_sources
-        libs/cute_tiled.c
-        libs/flecs/flecs.c
-        src/world/map.c
-        src/world/map.h
-        src/world/tileset.c
-        src/world/tileset.h
-)
-
-set(
-        lib_dirs
-        libs/cute_tiled
-        libs/flecs
-)
+set(BUILD_BREEZE_TESTS true)
+add_subdirectory(engine/)
 
 
 add_executable(PixelDefense
         ${lib_sources}
 
-        src/main.c
-        src/common.h
-        src/utils/tokenizer.c
-        src/utils/tokenizer.h
+        game/main.c
+        game/common.h
+        game/world/map.c
+        game/world/map.h
+        game/world/tileset.c
+        game/world/tileset.h
+        game/world/layer.c
+        game/world/layer.h
 )
-target_include_directories(PixelDefense PUBLIC ${lib_dirs})
-target_link_libraries(PixelDefense raylib)
 
+
+
+target_link_libraries(PixelDefense LINK_PRIVATE Breeze)

engine/CMakeLists.txt

@@ -0,0 +1,63 @@
+cmake_minimum_required(VERSION 3.26)
+project(Breeze C)
+
+set(CMAKE_C_STANDARD 11)
+
+set(BUILD_EXAMPLES false)
+add_subdirectory(libs/raylib-4.5.0)
+
+set(
+        lib_sources
+        libs/cute_tiled.c
+        libs/flecs/flecs.c
+)
+
+set(
+        lib_dirs
+        libs/cute_tiled
+        libs/flecs
+)
+
+
+add_library(Breeze STATIC
+        breeze/core/logger.c
+        breeze/core/logger.h
+        breeze/core/logger_module.h
+        breeze/core/module_system.c
+        breeze/core/module_system.h
+
+        breeze/math/vec2i.h
+
+        breeze/utils/tokenizer.c
+        breeze/utils/tokenizer.h
+
+        breeze/defines.h
+        breeze/game.h
+
+        breeze.h
+
+        ${lib_sources}
+)
+
+set(BreezePublicHeaders
+    breeze.h)
+
+set_target_properties(Breeze PROPERTIES
+                      PUBLIC_HEADER ${BreezePublicHeaders})
+
+target_link_libraries(Breeze raylib)
+
+#target_include_directories(Breeze PUBLIC .)
+target_include_directories(Breeze
+        PUBLIC
+        $<INSTALL_INTERFACE:include>
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+        ${lib_dirs})
+
+file(COPY ${BreezePublicHeader} DESTINATION "include")
+
+if (${BUILD_BREEZE_TESTS})
+    MESSAGE(STATUS "Building breeze tests is enabled")
+    add_subdirectory(tests)
+endif()
+

engine/breeze.h

@@ -0,0 +1,15 @@
+#ifndef BREEZE_H
+#define BREEZE_H
+
+#include "breeze/core/logger.h"
+#include "breeze/core/logger_module.h"
+#include "breeze/core/module_system.h"
+
+#include "breeze/math/vec2i.h"
+
+#include "breeze/utils/tokenizer.h"
+
+#include "breeze/defines.h"
+#include "breeze/game.h"
+
+#endif //BREEZE_H

engine/breeze/core/logger.c

@@ -0,0 +1,139 @@
+#include "logger.h"
+
+#include "logger_module.h"
+#include "module_system.h"
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <time.h>
+
+#define BZ_GET_LOGGER_MODULE() ((BzLoggerModule *) bzModuleRetrieve(BZ_MODULE_LOGGER))
+
+bool bzLoggerInit() {
+    if (bzModuleIsAllocated(BZ_MODULE_LOGGER))
+        return false;
+
+    BzLoggerModule *logger = bzModuleAllocate(BZ_MODULE_LOGGER, sizeof(*logger));
+    if (logger == NULL)
+        return false;
+
+    logger->level = BZ_LOG_INFO;
+    logger->silent = false;
+
+
+    return true;
+}
+
+void bzLoggerDeinit() {
+    BzLoggerModule *logger = BZ_GET_LOGGER_MODULE();
+    bzModuleFree(BZ_MODULE_LOGGER);
+}
+
+void bzLoggerEnableDefaultLog(bool enable) {
+    BZ_GET_LOGGER_MODULE()->silent = !enable;
+}
+
+void bzLoggerSetLevel(BzLoggerLevel level) {
+    BZ_GET_LOGGER_MODULE()->level = level;
+}
+
+BzLoggerLevel bzLoggerGetLevel() {
+    return BZ_GET_LOGGER_MODULE()->level;
+}
+
+
+static const char *LEVEL_STRINGS[] = {
+        "TRACE",
+        "DEBUG",
+        "INFO",
+        "WARN",
+        "ERROR",
+        "FATAL"
+};
+static const char *LEVEL_COLORS[] = {
+        "\x1b[90m", // TRACE  -> Bright black
+        "\x1b[96m", // DEBUG  -> Bright cyan
+        "\x1b[32m", // INFO   -> Green
+        "\x1b[33m", // WARN   -> Yellow
+        "\x1b[31m", // ERROR  -> Red
+        "\x1b[91m", // FATAL  -> Bright red
+};
+
+static void bzLoggerStdOutCallback(BzLoggerEvent *ev) {
+    va_list *ap = ev->apList;
+    fprintf(stderr, "%s %s%-5s\x1b[0m \x1b[90m%s:%d:\x1b[0m ",
+            ev->time, LEVEL_STRINGS[ev->level], LEVEL_COLORS[ev->level], ev->file, ev->line);
+    vfprintf(stderr, ev->fmt, *ap);
+    fprintf(stderr, "\n");
+    fflush(stderr);
+}
+
+static void bzLoggerFileCallback(BzLoggerEvent *ev) {
+    FILE *fp = ev->userData;
+    va_list *ap = ev->apList;
+    fprintf(fp, "%s %-5s %s:%d: ", ev->time, LEVEL_STRINGS[ev->level], ev->file, ev->line);
+    vfprintf(fp, ev->fmt, *ap);
+    fflush(fp);
+}
+
+void bzLoggerLog(BzLoggerLevel level, const char *file, int line, const char *fmt, ...) {
+    BzLoggerEvent event = {NULL,  NULL, level, file, line, fmt};
+    const int loggerLevel = bzLoggerGetLevel();
+
+    time_t t = time(NULL);
+    struct tm *lt = localtime(&t);
+    char timeBuf[16];
+    size_t lastIdx = strftime(timeBuf, sizeof(timeBuf), "%H:%M:%S", lt);
+    // TODO: Assert
+    timeBuf[lastIdx] = '\0';
+    event.time = timeBuf;
+
+    if (!BZ_GET_LOGGER_MODULE()->silent && level <= loggerLevel) {
+        event.userData = stderr;
+        va_list ap;
+        va_start(ap, fmt);
+
+        event.apList = &ap;
+        bzLoggerStdOutCallback(&event);
+
+        va_end(ap);
+    }
+
+    for (int i = 0; i < BZ_LOGGER_MAX_CALLBACKS; ++i) {
+        BzLoggerCallback cb = BZ_GET_LOGGER_MODULE()->callbacks[i];
+
+        if (level <= cb.level) {
+            event.userData = cb.userData;
+
+            va_list ap;
+            va_start(ap, fmt);
+
+            event.apList = &ap;
+            cb.callback(&event);
+
+            va_end(ap);
+        }
+    }
+
+}
+
+bool bzLoggerAddFP(void *fp, BzLoggerLevel level) {
+    return bzLoggerAddCB(&(BzLoggerCallback) {
+            .callback = bzLoggerFileCallback,
+            .level = level,
+            .userData = fp
+    });
+}
+
+bool bzLoggerAddCB(const BzLoggerCallback *callback) {
+    for (int i = 0; i < BZ_LOGGER_MAX_CALLBACKS; ++i) {
+        BzLoggerCallback *cbSlot = &BZ_GET_LOGGER_MODULE()->callbacks[i];
+
+        if (cbSlot->callback == NULL) {
+            *cbSlot = *callback;
+            return true;
+        }
+    }
+
+    return false;
+}

engine/breeze/core/logger.h

@@ -0,0 +1,53 @@
+#ifndef BREEZE_LOGGER_H
+#define BREEZE_LOGGER_H
+
+#include "../defines.h"
+
+typedef enum BzLoggerLevel {
+    BZ_LOG_TRACE,
+    BZ_LOG_DEBUG,
+    BZ_LOG_INFO,
+    BZ_LOG_WARN,
+    BZ_LOG_ERROR,
+    BZ_LOG_FATAL,
+} BzLoggerLevel;
+
+typedef struct BzLoggerEvent {
+    void *userData;
+
+    const char *time;
+    BzLoggerLevel level;
+    const char *file;
+    int line;
+
+    const char *fmt;
+    void *apList;
+} BzLoggerEvent;
+
+typedef struct BzLoggerCallback {
+    void (*callback)(BzLoggerEvent *ev);
+    enum BzLoggerLevel level;
+    void *userData;
+} BzLoggerCallback;
+
+bool bzLoggerInit();
+void bzLoggerDeinit();
+
+void bzLoggerEnableDefaultLog(bool enable);
+
+void bzLoggerSetLevel(BzLoggerLevel level);
+BzLoggerLevel bzLoggerGetLevel();
+
+void bzLoggerLog(BzLoggerLevel level, const char *file, int line, const char *fmt, ...);
+
+bool bzLoggerAddFP(void *fp, BzLoggerLevel level);
+bool bzLoggerAddCB(const BzLoggerCallback *callback);
+
+#define bzLogTrace(...) bzLoggerLog(BZ_LOG_TRACE, __FILE__, __LINE__, __VA_ARGS__)
+#define bzLogDebug( ...) bzLoggerLog(BZ_LOG_DEBUG, __FILE__, __LINE__, __VA_ARGS__)
+#define bzLogInfo(...) bzLoggerLog(BZ_LOG_INFO, __FILE__, __LINE__, __VA_ARGS__)
+#define bzLogWarn(...) bzLoggerLog(BZ_LOG_WARN, __FILE__, __LINE__, __VA_ARGS__)
+#define bzLogError(...) bzLoggerLog(BZ_LOG_ERROR, __FILE__, __LINE__, __VA_ARGS__)
+#define bzLogFatal(...) bzLoggerLog(BZ_LOG_FATAL, __FILE__, __LINE__, __VA_ARGS__)
+
+#endif //BREEZE_LOGGER_H

engine/breeze/core/logger_module.h

@@ -0,0 +1,15 @@
+#ifndef BREEZE_LOGGER_MODULE_H
+#define BREEZE_LOGGER_MODULE_H
+
+#include "logger.h"
+
+#define BZ_LOGGER_MAX_CALLBACKS 32
+
+typedef struct BzLoggerModule {
+    BzLoggerCallback callbacks[BZ_LOGGER_MAX_CALLBACKS];
+
+    int level;
+    bool silent;
+} BzLoggerModule;
+
+#endif //BREEZE_LOGGER_MODULE_H

engine/breeze/core/module_system.c

@@ -0,0 +1,27 @@
+#include "module_system.h"
+
+#include <malloc.h>
+
+void *BZ_MODULES[BZ_ENGINE_MODULE_COUNT] = {NULL,};
+
+bool bzModuleIsAllocated(BzModule module) {
+    return BZ_MODULES[module] != NULL;
+}
+
+void *bzModuleRetrieve(BzModule module) {
+    return BZ_MODULES[module];
+}
+
+void *bzModuleAllocate(BzModule module, size_t sizeBytes) {
+    if (bzModuleIsAllocated(module)) {
+        bzModuleFree(module);
+    }
+    BZ_MODULES[module] = calloc(1, sizeBytes);
+    return BZ_MODULES[module];
+}
+
+void bzModuleFree(BzModule module) {
+    if (bzModuleIsAllocated(module))
+        free(BZ_MODULES[module]);
+    BZ_MODULES[module] = NULL;
+}

engine/breeze/core/module_system.h

@@ -0,0 +1,18 @@
+#ifndef BREEZE_MODULE_H
+#define BREEZE_MODULE_H
+
+#include "../defines.h"
+
+typedef enum BzModule {
+    BZ_MODULE_LOGGER,
+    BZ_MODULE_APPLICATION,
+    BZ_MODULE_INPUT,
+    BZ_ENGINE_MODULE_COUNT
+} BzModule;
+
+bool bzModuleIsAllocated(BzModule module);
+void *bzModuleRetrieve(BzModule module);
+void *bzModuleAllocate(BzModule module, size_t sizeBytes);
+void bzModuleFree(BzModule module);
+
+#endif //BREEZE_MODULE_H

engine/breeze/defines.h

@@ -0,0 +1,29 @@
+#ifndef BREEZE_DEFINES_H
+#define BREEZE_DEFINES_H
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stddef.h>
+
+typedef uint8_t u8;
+typedef uint16_t u16;
+typedef uint32_t u32;
+typedef uint64_t u64;
+
+typedef int8_t i8;
+typedef int16_t i16;
+typedef int32_t i32;
+typedef int64_t i64;
+
+typedef float f32;
+typedef double f64;
+
+#define BZ_ASSERT(e) assert(e)
+
+#ifndef DEBUG_MODE
+#undef BZ_ASSERT
+#define BZ_ASSERT(e) (void)(e)
+#endif
+
+#endif //BREEZE_DEFINES_H

engine/breeze/game.h

@@ -0,0 +1,80 @@
+#ifndef BREEZE_GAME_H
+#define BREEZE_GAME_H
+
+#include "core/logger.h"
+
+typedef bool (*BzAppInitFunc)(void *);
+typedef void (*BzAppUpdateFunc)(float, void *);
+typedef void (*BzAppRenderFunc)(float, void *);
+typedef void (*BzAppDeinitFunc)(void *);
+
+typedef struct BzAppDesc {
+    int32_t    width;
+    int32_t    height;
+    const char *title;
+
+    BzAppInitFunc   init;
+    BzAppUpdateFunc update;
+    BzAppRenderFunc render;
+    BzAppDeinitFunc deinit;
+
+    void *userData;
+} BzAppDesc;
+
+extern bool bzMain(BzAppDesc *appDesc, int argc, const char **argv);
+
+#ifdef BZ_GAME_ENTRYPOINT
+
+
+#include <raylib.h>
+
+
+int main(int argc, const char **argv) {
+    if (!bzLoggerInit())
+        return 1;
+    bzLoggerSetLevel(BZ_LOG_INFO);
+    bzLogInfo("[Breeze] Logger initialized successfully.");
+
+    BzAppDesc appDesc = {
+            1280,
+            720,
+            "Breeze Engine"
+    };
+
+    bool successful = bzMain(&appDesc, argc, argv);
+    if (!successful) return 1;
+
+    // Validate
+    if (!appDesc.render) {
+        bzLogFatal("[Breeze] No render function specifies.");
+        return 1;
+    }
+    bzLogInfo("[Breeze] User initialization (bzMain) successful.");
+
+    // Initialize modules
+
+    // User initialize
+    if (appDesc.init && !appDesc.init(appDesc.userData)) {
+        return 1;
+    }
+
+    while (!WindowShouldClose()) {
+        if (appDesc.update)
+            appDesc.update(0.0f, appDesc.userData);
+        if (appDesc.render)
+            appDesc.render(0.0f, appDesc.userData);
+    }
+
+    // User deinitialize
+    if (appDesc.deinit)
+        appDesc.deinit(appDesc.userData);
+
+    // Deinitialize modules
+
+    bzLoggerDeinit();
+
+    return 0;
+}
+#endif
+
+#endif //BREEZE_GAME_H

engine/breeze/math/vec2i.h

@@ -0,0 +1,11 @@
+#ifndef BREEZE_VEC2_H
+#define BREEZE_VEC2_H
+
+#include "breeze/defines.h"
+
+typedef struct Vec2i {
+    int32_t x;
+    int32_t y;
+} Vec2i;
+
+#endif //BREEZE_VEC2_H

engine/breeze/utils/tokenizer.h

@@ -1,7 +1,7 @@
-#ifndef PIXELDEFENSE_TOKENIZER_H
-#define PIXELDEFENSE_TOKENIZER_H
+#ifndef BREEZE_TOKENIZER_H
+#define BREEZE_TOKENIZER_H
 
-#include "../common.h"
+#include "../defines.h"
 
 typedef struct Token {
     const char *start;
@@ -17,4 +17,4 @@ typedef struct Tokenizer {
 Tokenizer initTokenizer(const char *source);
 Token scanToken(Tokenizer *tokenizer);
 
-#endif //PIXELDEFENSE_TOKENIZER_H
+#endif //BREEZE_TOKENIZER_H