GiteaCI (#1)

Reviewed-on: #1
Co-authored-by: Romain BOULLARD <romain.boullard@protonmail.com>
Co-committed-by: Romain BOULLARD <romain.boullard@protonmail.com>

Bigfoot/Sources/CMakeLists.txt

@@ -1,3 +1,3 @@
-add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/System)
 add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/Utils)
+add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/System)
 add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/Engine)

Bigfoot/Sources/Engine/BigFile/BigFileSchema.sql

@@ -1,11 +1,41 @@
 PRAGMA journal_mode=WAL;
+PRAGMA foreign_keys = ON;
+
+DROP TABLE IF EXISTS AssetHeader;
+CREATE TABLE IF NOT EXISTS AssetHeader (
+    UUID              	BLOB        NOT NULL UNIQUE,
+    Name            	TEXT        NOT NULL UNIQUE,
+    TypeID              INTEGER     NOT NULL,
+    TypeName            TEXT        NOT NULL,
+
+    CreateTime      	INTEGER     NOT NULL DEFAULT(CAST(unixepoch('subsec') AS INTEGER) * 1000000),
+    ModificationTime    INTEGER     NOT NULL DEFAULT(CAST(unixepoch('subsec') AS INTEGER) * 1000000),
 
-DROP TABLE IF EXISTS FsEntry;
-CREATE TABLE IF NOT EXISTS FsEntry (
-    UUID              	BLOB NOT NULL UNIQUE,
-    Name            	TEXT NOT NULL UNIQUE,
-    CreateTime      	INTEGER NOT NULL,
-    ModificationTime    INTEGER NOT NULL,
-    Asset               BLOB,
     PRIMARY KEY(UUID)
-);
+);
+
+CREATE TRIGGER IF NOT EXISTS AssetHeader_UpdateTime
+AFTER UPDATE OF Name, TypeID, TypeName ON AssetHeader FOR EACH ROW
+BEGIN
+    UPDATE AssetHeader
+    SET ModificationTime = CAST(unixepoch('subsec') AS INTEGER) * 1000000
+    WHERE UUID = NEW.UUID;
+END;
+
+DROP TABLE IF EXISTS Asset;
+CREATE TABLE IF NOT EXISTS Asset (
+    UUID              	BLOB        NOT NULL UNIQUE,
+
+    Asset               BLOB        NOT NULL,
+
+    PRIMARY KEY(UUID),
+    FOREIGN KEY(UUID) REFERENCES AssetHeader(UUID) ON DELETE CASCADE
+);
+
+CREATE TRIGGER IF NOT EXISTS Asset_UpdateTime
+AFTER UPDATE OF Asset ON Asset FOR EACH ROW
+BEGIN
+    UPDATE AssetHeader
+    SET ModificationTime = CAST(unixepoch('subsec') AS INTEGER) * 1000000
+    WHERE UUID = NEW.UUID;
+END;

Bigfoot/Sources/Engine/BigFile/Database.cpp

@@ -1,12 +0,0 @@
-/*********************************************************************
- * \file   Database.cpp
- *
- * \author Romain BOULLARD
- * \date   October 2025
- *********************************************************************/
-#include <Engine/BigFile/Database.hpp>
-
-namespace Bigfoot
-{
-
-}   // namespace Bigfoot

Bigfoot/Sources/Engine/CMakeLists.txt

@@ -1,9 +1,11 @@
 get_filename_component(PackageName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
+project(${PackageName})
 
 set(PublicDependencies
         SQLite::SQLite3)
 set(PrivateDependencies)
 set(BigfootPublicDependencies
+        System
         Utils)
 set(BigfootPrivateDependencies)
 
@@ -11,12 +13,11 @@ set(BIGFOOT_MAJOR 0)
 set(BIGFOOT_MINOR 1)
 set(BIGFOOT_PATCH 0)
 set(BIGFOOT_NAME "Bigfoot")
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Include/Engine/EngineInfo.generated.hpp.in ${CMAKE_CURRENT_SOURCE_DIR}/Include/Engine/EngineInfo.generated.hpp @ONLY)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Include/Engine/EngineInfo_generated.hpp.in ${CMAKE_CURRENT_SOURCE_DIR}/Include/Engine/EngineInfo_generated.hpp @ONLY)
 
-bigfoot_create_logger(${PackageName})
+bigfoot_create_logger()
 
 bigfoot_create_package_lib(
-    ${PackageName}
     "${PublicDependencies}"
     "${PrivateDependencies}"
     "${BigfootPublicDependencies}"

Bigfoot/Sources/Engine/Include/Engine/BigFile/BigFileInfo_generated.hpp.in

@@ -2,18 +2,18 @@
 
 /*********************************************************************
  * \file   BigFileInfo.generated.hpp
- * 
+ *
  *********************************************************************/
-#ifndef BIGFOOT_ENGINE_BIGFILE_BIGFILEINFO_GENERATED_HPP
-#define BIGFOOT_ENGINE_BIGFILE_BIGFILEINFO_GENERATED_HPP
+#ifndef BIGFOOT_@BIGFILE_NAME@_BIGFILEINFO_GENERATED_HPP
+#define BIGFOOT_@BIGFILE_NAME@_BIGFILEINFO_GENERATED_HPP
 
-#include <string_view>
+#include <EASTL/string_view.h>
 
 namespace Bigfoot
 {
 /*
  * BigFile location
  */
-constexpr std::string_view BIGFILE_@BIGFILE_NAME@_LOCATION{"@BIGFILE_LOCATION@"};
-}
+constexpr eastl::string_view BIGFILE_@BIGFILE_NAME@_LOCATION {"@BIGFILE_LOCATION@"};
+}  // namespace Bigfoot
 #endif

Bigfoot/Sources/Engine/Include/Engine/BigFile/Database.hpp

@@ -1,19 +0,0 @@
-/*********************************************************************
- * \file   Database.hpp
- *
- * \author Romain BOULLARD
- * \date   October 2025
- *********************************************************************/
-#ifndef BIGFOOT_ENGINE_BIGFILE_DATABASE_HPP
-#define BIGFOOT_ENGINE_BIGFILE_DATABASE_HPP
-
-#include <sqlite3.h>
-
-#include <string_view>
-
-namespace Bigfoot
-{
-
-}   // namespace Bigfoot
-
-#endif

Bigfoot/Sources/Engine/Include/Engine/EngineAssertHandler.hpp

@@ -0,0 +1,60 @@
+/*********************************************************************
+ * \file   EngineAssertHandler.hpp
+ *
+ * \author Romain BOULLARD
+ * \date   December 2025
+ *********************************************************************/
+#ifndef BIGFOOT_ENGINE_ENGINEASSERTHANDLER_HPP
+#define BIGFOOT_ENGINE_ENGINEASSERTHANDLER_HPP
+#include <Utils/Assert.hpp>
+
+#include <Engine/EngineLogger_generated.hpp>
+
+#if defined BIGFOOT_NOT_OPTIMIZED
+#include <EASTL/utility.h>
+
+#include <format>
+#include <source_location>
+#include <string_view>
+
+namespace Bigfoot
+{
+class EngineAssertHandler
+{
+  public:
+    EngineAssertHandler() = delete;
+
+    EngineAssertHandler(const EngineAssertHandler& p_handler) = delete;
+    EngineAssertHandler(EngineAssertHandler&& p_handler) = delete;
+
+    ~EngineAssertHandler() = delete;
+
+    /**
+     * Handle an assertion.
+     *
+     * \param p_location Location of the assertion.
+     * \param p_stacktrace The stack trace
+     * \param p_format Format string for the assertion message.
+     * \param p_args Arguments for the format string.
+     */
+    template<typename... ARGS>
+    static void Handle(const std::source_location& p_location,
+                       const std::string_view p_stacktrace,
+                       std::format_string<ARGS...> p_format,
+                       ARGS&&... p_args)
+    {
+        BIGFOOT_LOG_FATAL(ENGINE_LOGGER,
+                          "Assert: {} (File:{}, Line:{}, Function:{}\n{}",
+                          std::format(p_format, eastl::forward<ARGS>(p_args)...),
+                          p_location.file_name(),
+                          p_location.line(),
+                          p_location.function_name(),
+                          p_stacktrace);
+    }
+
+    EngineAssertHandler& operator=(const EngineAssertHandler& p_handler) = delete;
+    EngineAssertHandler& operator=(EngineAssertHandler&& p_handler) = delete;
+};
+}   // namespace Bigfoot
+#endif
+#endif

Bigfoot/Sources/Engine/Include/Engine/EngineInfo_generated.hpp

@@ -1,23 +1,25 @@
 // AUTO-GENERATED DO NOT TOUCH
 
 /*********************************************************************
- * \file   EngineInfo.generated.hpp
- * 
+ * \file   EngineInfo_generated.hpp
+ *
  *********************************************************************/
 #ifndef BIGFOOT_ENGINE_ENGINEINFO_GENERATED_HPP
 #define BIGFOOT_ENGINE_ENGINEINFO_GENERATED_HPP
 #include <Utils/Version.hpp>
 
+#include <EASTL/string_view.h>
+
 namespace Bigfoot
 {
 /*
  * Engine version
  */
-constexpr Version BIGFOOT_VERSION{0, 1, 0};
+constexpr Version BIGFOOT_VERSION {0, 1, 0};
 
 /*
  * Engine name
  */
-constexpr std::string_view BIGFOOT_NAME{"Bigfoot"};
-}
+constexpr eastl::string_view BIGFOOT_NAME {"Bigfoot"};
+}  // namespace Bigfoot
 #endif

Bigfoot/Sources/Engine/Include/Engine/EngineInfo_generated.hpp.in

@@ -1,23 +1,25 @@
 @AUTO_GENERATED_COMMENT@
 
 /*********************************************************************
- * \file   EngineInfo.generated.hpp
- * 
+ * \file   EngineInfo_generated.hpp
+ *
  *********************************************************************/
 #ifndef BIGFOOT_ENGINE_ENGINEINFO_GENERATED_HPP
 #define BIGFOOT_ENGINE_ENGINEINFO_GENERATED_HPP
 #include <Utils/Version.hpp>
 
+#include <EASTL/string_view.h>
+
 namespace Bigfoot
 {
 /*
  * Engine version
  */
-constexpr Version BIGFOOT_VERSION{@BIGFOOT_MAJOR@, @BIGFOOT_MINOR@, @BIGFOOT_PATCH@};
+constexpr Version BIGFOOT_VERSION {@BIGFOOT_MAJOR@, @BIGFOOT_MINOR@, @BIGFOOT_PATCH@};
 
 /*
  * Engine name
  */
-constexpr std::string_view BIGFOOT_NAME{"@BIGFOOT_NAME@"};
-}
+constexpr eastl::string_view BIGFOOT_NAME {"@BIGFOOT_NAME@"};
+}  // namespace Bigfoot
 #endif

Bigfoot/Sources/Engine/Include/Engine/EngineLogger_generated.hpp

@@ -2,11 +2,11 @@
 
 /*********************************************************************
  * \file   EngineLogger.generated.hpp
- * 
+ *
  *********************************************************************/
 #ifndef BIGFOOT_ENGINELOGGER_GENERATED_HPP
 #define BIGFOOT_ENGINELOGGER_GENERATED_HPP
-#include <Utils/Log.hpp>
+#include <System/Log/Log.hpp>
 
 #if defined BIGFOOT_NOT_OPTIMIZED
 
@@ -15,7 +15,7 @@ namespace Bigfoot
 /*
  * Logger
  */
-inline Log::LoggerInfo ENGINE_LOGGER {"ENGINE_LOGGER", Log::LogLevel::Trace};
-}
+inline Log::LoggerInfo ENGINE_LOGGER {"ENGINE_LOGGER", Flat::LogLevel::Trace};
+}  // namespace Bigfoot
 #endif
 #endif

Bigfoot/Sources/Engine/touch.cpp

@@ -0,0 +1 @@
+// to delete when an actual source is in Engine

Bigfoot/Sources/System/CMakeLists.txt

@@ -1,26 +1,28 @@
 get_filename_component(PackageName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
+project(${PackageName})
 
 set(PublicDependencies
+    $<$<CONFIG:Debug,RelWithDebInfo>:quill::quill>
     mimalloc
-    magic_enum::magic_enum
-    unordered_dense::unordered_dense
-    EASTL::EASTL
-    stduuid::stduuid
-    $<$<BOOL:${TRACY}>:Tracy::TracyClient>)
+    stduuid::stduuid)
 set(PrivateDependencies)
-set(BigfootPublicDependencies)
+set(BigfootPublicDependencies
+    Utils)
 set(BigfootPrivateDependencies)
 
 bigfoot_create_package_lib(
-    ${PackageName}
     "${PublicDependencies}"
     "${PrivateLibraries}"
     "${BigfootPublicDependencies}"
     "${BigfootPrivateDependencies}"
     "")
 
-target_compile_definitions(${PackageName}
-        PUBLIC MI_SHARED_LIB
-        PUBLIC $<$<BOOL:${TRACY}>:TRACY>)
+bigfoot_create_logger()
+
+target_compile_definitions(${PROJECT_NAME}
+        PUBLIC $<$<CONFIG:Debug,RelWithDebInfo>:QUILL_NO_EXCEPTIONS>
+        PUBLIC $<$<CONFIG:Debug,RelWithDebInfo>:QUILL_DISABLE_NON_PREFIXED_MACROS>
+
+        PUBLIC MI_SHARED_LIB)
 set_source_files_properties(${CMAKE_CURRENT_SOURCE_DIR}/MimallocImpl.cpp PROPERTIES SKIP_UNITY_BUILD_INCLUSION ON)
 

Bigfoot/Sources/System/File.cpp

@@ -0,0 +1,66 @@
+/*********************************************************************
+ * \file   File.cpp
+ *
+ * \author Romain BOULLARD
+ * \date   December 2025
+ *********************************************************************/
+#include <System/File.hpp>
+
+namespace Bigfoot
+{
+File::File(const eastl::string_view p_path):
+    m_path(p_path.data()),
+    m_pathString(p_path)
+{
+}
+
+/****************************************************************************************/
+
+bool File::IsAbsolute() const
+{
+    return m_path.is_absolute();
+}
+
+/****************************************************************************************/
+
+bool File::IsRelative() const
+{
+    return m_path.is_relative();
+}
+
+/****************************************************************************************/
+
+bool File::Exists() const
+{
+    return std::filesystem::exists(m_path);
+}
+
+/****************************************************************************************/
+
+eastl::string_view File::Path() const
+{
+    return m_pathString;
+}
+
+/****************************************************************************************/
+
+File File::Absolute() const
+{
+    return File {std::filesystem::absolute(m_path)};
+}
+
+/****************************************************************************************/
+
+File File::Relative() const
+{
+    return File {std::filesystem::relative(m_path)};
+}
+
+/****************************************************************************************/
+
+File::File(const std::filesystem::path& p_path):
+    m_path(p_path),
+    m_pathString(m_path.string().c_str())
+{
+}
+}   // namespace Bigfoot

Bigfoot/Sources/System/Include/System/File.hpp

@@ -0,0 +1,103 @@
+/*********************************************************************
+ * \file   File.hpp
+ *
+ * \author Romain BOULLARD
+ * \date   December 2025
+ *********************************************************************/
+#ifndef BIGFOOT_SYSTEM_FILE_HPP
+#define BIGFOOT_SYSTEM_FILE_HPP
+
+#include <EASTL/string.h>
+#include <EASTL/string_view.h>
+
+#include <filesystem>
+
+namespace Bigfoot
+{
+class File
+{
+  public:
+    /**
+     * Constructor
+     *
+     * \param p_path The path
+     */
+    File(const eastl::string_view p_path);
+
+    File(const File& p_path) = default;
+    File(File&& p_path) = default;
+
+    /**
+     * Check if the file is relative to the current executable
+     *
+     * \return True if the file is relative, false otherwise
+     */
+    [[nodiscard]]
+    bool IsRelative() const;
+
+    /**
+     * Check if the file is absolute
+     *
+     * \return True if the file is absolute, false otherwise
+     */
+    [[nodiscard]]
+    bool IsAbsolute() const;
+
+    /**
+     * Check if the file exists
+     *
+     * \return True if it exists, false otherwise
+     */
+    [[nodiscard]]
+    bool Exists() const;
+
+    /**
+     * Get the file path
+     *
+     * \return The path
+     */
+    [[nodiscard]]
+    eastl::string_view Path() const;
+
+    /**
+     * Get the same file, relative to the current executable
+     *
+     * \return The relative file
+     */
+    [[nodiscard]]
+    File Relative() const;
+
+    /**
+     * Get the same file, with an absolute path
+     *
+     * \return The absolute file
+     */
+    [[nodiscard]]
+    File Absolute() const;
+
+    ~File() = default;
+
+    File& operator=(const File& p_path) = default;
+    File& operator=(File&& p_path) = default;
+
+  private:
+    /**
+     * Constructor
+     *
+     * \param p_path The path
+     */
+    File(const std::filesystem::path& p_path);
+
+    /**
+     * The path
+     */
+    std::filesystem::path m_path;
+
+    /*
+     * The path as a string
+     */
+    eastl::string m_pathString;
+};
+}   // namespace Bigfoot
+
+#endif

Bigfoot/Sources/System/Include/System/Log/EASTLFormatters.hpp

@@ -0,0 +1,95 @@
+/*********************************************************************
+ * \file   EASTLFormatters.hpp
+ *
+ * \author Romain BOULLARD
+ * \date   December 2025
+ *********************************************************************/
+#ifndef BIGFOOT_SYSTEM_EASTLFORMATTERS_HPP
+#define BIGFOOT_SYSTEM_EASTLFORMATTERS_HPP
+#include <Utils/TargetMacros.h>
+
+#if defined(BIGFOOT_NOT_OPTIMIZED)
+#include <quill/DeferredFormatCodec.h>
+#endif
+
+#include <format>
+
+#include <EASTL/string.h>
+#include <EASTL/string_view.h>
+
+// STRING
+
+template<>
+struct std::formatter<eastl::string>
+{
+    constexpr auto parse(std::format_parse_context& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(const eastl::string& p_string, FormatContext& ctx) const
+    {
+        return std::format_to(ctx.out(), "{}", p_string.c_str());
+    }
+};
+
+#if defined BIGFOOT_NOT_OPTIMIZED
+template<>
+struct fmtquill::formatter<eastl::string>
+{
+    constexpr auto parse(format_parse_context& ctx)
+    {
+        return ctx.begin();
+    }
+
+    auto format(const eastl::string& p_string, format_context& ctx) const
+    {
+        return fmtquill::format_to(ctx.out(), "{}", p_string.c_str());
+    }
+};
+
+template<>
+struct quill::Codec<eastl::string>: quill::DeferredFormatCodec<eastl::string>
+{
+};
+#endif
+
+// STRING_VIEW
+
+template<>
+struct std::formatter<eastl::string_view>
+{
+    constexpr auto parse(std::format_parse_context& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(const eastl::string_view& p_stringView, FormatContext& ctx) const
+    {
+        return std::format_to(ctx.out(), "{}", p_stringView.data());
+    }
+};
+
+#if defined BIGFOOT_NOT_OPTIMIZED
+template<>
+struct fmtquill::formatter<eastl::string_view>
+{
+    constexpr auto parse(format_parse_context& ctx)
+    {
+        return ctx.begin();
+    }
+
+    auto format(const eastl::string_view& p_stringView, format_context& ctx) const
+    {
+        return fmtquill::format_to(ctx.out(), "{}", p_stringView.data());
+    }
+};
+
+template<>
+struct quill::Codec<eastl::string_view>: quill::DeferredFormatCodec<eastl::string_view>
+{
+};
+#endif
+#endif

Bigfoot/Sources/System/Include/System/Log/Log.fbs

@@ -0,0 +1,16 @@
+namespace Bigfoot.Flat;
+
+enum LogSinkType: byte
+{
+    Console
+}
+
+enum LogLevel: byte
+{
+    Debug,
+    Trace,
+    Info,
+    Warn,
+    Error,
+    Critical
+}

Bigfoot/Sources/System/Include/System/Log/Log.hpp

@@ -4,12 +4,16 @@
  * \author Romain BOULLARD
  * \date   October 2025
  *********************************************************************/
-#ifndef BIGFOOT_UTILS_LOG_HPP
-#define BIGFOOT_UTILS_LOG_HPP
+#ifndef BIGFOOT_SYSTEM_LOG_HPP
+#define BIGFOOT_SYSTEM_LOG_HPP
+#include <System/Log/EASTLFormatters.hpp>
+
 #if defined BIGFOOT_NOT_OPTIMIZED
+#include <System/Log/Log_generated.hpp>
+
 #include <Utils/Singleton.hpp>
 
-#include <magic_enum/magic_enum.hpp>
+#include <EASTL/array.h>
 
 #ifdef BIGFOOT_WINDOWS
 #pragma warning(disable: 4702)
@@ -28,20 +32,10 @@ namespace Bigfoot
 class Log
 {
   public:
-    enum class LogLevel
-    {
-        Debug,
-        Trace,
-        Info,
-        Warn,
-        Error,
-        Critical
-    };
-
     struct LoggerInfo
     {
         std::string m_name;
-        LogLevel m_level;
+        Flat::LogLevel m_level;
     };
 
     Log();
@@ -72,7 +66,7 @@ class Log
      * \param p_loggerInfo The logger to change
      * \param p_level The new level
      */
-    void ChangeLoggerLogLevel(LoggerInfo& p_loggerInfo, const LogLevel p_level);
+    void ChangeLoggerLogLevel(LoggerInfo& p_loggerInfo, const Flat::LogLevel p_level);
 
     ~Log();
 
@@ -87,15 +81,10 @@ class Log
      */
     void SetLoggerLevel(const LoggerInfo& p_loggerInfo);
 
-    enum class SinkType
-    {
-        Console
-    };
-
     /*
      * The sinks
      */
-    std::array<std::shared_ptr<quill::Sink>, magic_enum::enum_count<SinkType>()> m_sinks;
+    eastl::array<std::shared_ptr<quill::Sink>, 1> m_sinks;
 };
 }   // namespace Bigfoot
 
@@ -182,6 +171,12 @@ class Log
                                fmt __VA_OPT__(, ) __VA_ARGS__);                                                        \
         }                                                                                                              \
     } while (0)
-
+#else
+#define BIGFOOT_LOG_DEBUG(loggerName, fmt, ...)
+#define BIGFOOT_LOG_TRACE(loggerName, fmt, ...)
+#define BIGFOOT_LOG_INFO(loggerName, fmt, ...)
+#define BIGFOOT_LOG_WARN(loggerName, fmt, ...)
+#define BIGFOOT_LOG_ERROR(loggerName, fmt, ...)
+#define BIGFOOT_LOG_FATAL(loggerName, fmt, ...)
 #endif
 #endif

Bigfoot/Sources/System/Include/System/Log/Log_generated.hpp

@@ -0,0 +1,136 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_LOG_BIGFOOT_FLAT_H_
+#define FLATBUFFERS_GENERATED_LOG_BIGFOOT_FLAT_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
+              FLATBUFFERS_VERSION_MINOR == 12 &&
+              FLATBUFFERS_VERSION_REVISION == 19,
+             "Non-compatible flatbuffers version included");
+
+#include "EASTL/unique_ptr.h"
+#include "EASTL/string.h"
+
+namespace Bigfoot {
+namespace Flat {
+
+enum class LogSinkType : int8_t {
+  Console = 0,
+  MIN = Console,
+  MAX = Console
+};
+
+inline const LogSinkType (&EnumValuesLogSinkType())[1] {
+  static const LogSinkType values[] = {
+    LogSinkType::Console
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesLogSinkType() {
+  static const char * const names[2] = {
+    "Console",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameLogSinkType(LogSinkType e) {
+  if (::flatbuffers::IsOutRange(e, LogSinkType::Console, LogSinkType::Console)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesLogSinkType()[index];
+}
+
+enum class LogLevel : int8_t {
+  Debug = 0,
+  Trace = 1,
+  Info = 2,
+  Warn = 3,
+  Error = 4,
+  Critical = 5,
+  MIN = Debug,
+  MAX = Critical
+};
+
+inline const LogLevel (&EnumValuesLogLevel())[6] {
+  static const LogLevel values[] = {
+    LogLevel::Debug,
+    LogLevel::Trace,
+    LogLevel::Info,
+    LogLevel::Warn,
+    LogLevel::Error,
+    LogLevel::Critical
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesLogLevel() {
+  static const char * const names[7] = {
+    "Debug",
+    "Trace",
+    "Info",
+    "Warn",
+    "Error",
+    "Critical",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameLogLevel(LogLevel e) {
+  if (::flatbuffers::IsOutRange(e, LogLevel::Debug, LogLevel::Critical)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesLogLevel()[index];
+}
+
+inline const ::flatbuffers::TypeTable *LogSinkTypeTypeTable() {
+  static const ::flatbuffers::TypeCode type_codes[] = {
+    { ::flatbuffers::ET_CHAR, 0, 0 }
+  };
+  static const ::flatbuffers::TypeFunction type_refs[] = {
+    Bigfoot::Flat::LogSinkTypeTypeTable
+  };
+  static const char * const names[] = {
+    "Console"
+  };
+  static const ::flatbuffers::TypeTable tt = {
+    ::flatbuffers::ST_ENUM, 1, type_codes, type_refs, nullptr, nullptr, names
+  };
+  return &tt;
+}
+
+inline const ::flatbuffers::TypeTable *LogLevelTypeTable() {
+  static const ::flatbuffers::TypeCode type_codes[] = {
+    { ::flatbuffers::ET_CHAR, 0, 0 },
+    { ::flatbuffers::ET_CHAR, 0, 0 },
+    { ::flatbuffers::ET_CHAR, 0, 0 },
+    { ::flatbuffers::ET_CHAR, 0, 0 },
+    { ::flatbuffers::ET_CHAR, 0, 0 },
+    { ::flatbuffers::ET_CHAR, 0, 0 }
+  };
+  static const ::flatbuffers::TypeFunction type_refs[] = {
+    Bigfoot::Flat::LogLevelTypeTable
+  };
+  static const char * const names[] = {
+    "Debug",
+    "Trace",
+    "Info",
+    "Warn",
+    "Error",
+    "Critical"
+  };
+  static const ::flatbuffers::TypeTable tt = {
+    ::flatbuffers::ST_ENUM, 6, type_codes, type_refs, nullptr, nullptr, names
+  };
+  return &tt;
+}
+
+}  // namespace Flat
+}  // namespace Bigfoot
+
+#endif  // FLATBUFFERS_GENERATED_LOG_BIGFOOT_FLAT_H_

Bigfoot/Sources/System/Include/System/Log/TargetLogger_generated.hpp.in

@@ -2,11 +2,11 @@
 
 /*********************************************************************
  * \file   @LOGGER_FILENAME@.generated.hpp
- * 
+ *
  *********************************************************************/
 #ifndef BIGFOOT_@LOGGER_FILENAME_UPPER@_GENERATED_HPP
 #define BIGFOOT_@LOGGER_FILENAME_UPPER@_GENERATED_HPP
-#include <Utils/Log.hpp>
+#include <System/Log/Log.hpp>
 
 #if defined BIGFOOT_NOT_OPTIMIZED
 
@@ -15,7 +15,7 @@ namespace Bigfoot
 /*
  * Logger
  */
-inline Log::LoggerInfo @LOGGER_NAME@ {"@LOGGER_NAME@", Log::LogLevel::Trace};
-}
+inline Log::LoggerInfo @LOGGER_NAME@ {"@LOGGER_NAME@", Flat::LogLevel::Trace};
+}  // namespace Bigfoot
 #endif
 #endif

Bigfoot/Sources/System/Include/System/SystemAssertHandler.hpp

@@ -0,0 +1,60 @@
+/*********************************************************************
+ * \file   SystemAssertHandler.hpp
+ *
+ * \author Romain BOULLARD
+ * \date   January 2026
+ *********************************************************************/
+#ifndef BIGFOOT_SYSTEM_SYSTEMASSERTHANDLER_HPP
+#define BIGFOOT_SYSTEM_SYSTEMASSERTHANDLER_HPP
+#include <Utils/Assert.hpp>
+
+#include <System/SystemLogger_generated.hpp>
+
+#if defined BIGFOOT_NOT_OPTIMIZED
+#include <EASTL/utility.h>
+
+#include <format>
+#include <source_location>
+#include <string_view>
+
+namespace Bigfoot
+{
+class SystemAssertHandler
+{
+  public:
+    SystemAssertHandler() = delete;
+
+    SystemAssertHandler(const SystemAssertHandler& p_handler) = delete;
+    SystemAssertHandler(SystemAssertHandler&& p_handler) = delete;
+
+    ~SystemAssertHandler() = delete;
+
+    /**
+     * Handle an assertion.
+     *
+     * \param p_location Location of the assertion.
+     * \param p_stacktrace The stack trace
+     * \param p_format Format string for the assertion message.
+     * \param p_args Arguments for the format string.
+     */
+    template<typename... ARGS>
+    static void Handle(const std::source_location& p_location,
+                       const std::string_view p_stacktrace,
+                       std::format_string<ARGS...> p_format,
+                       ARGS&&... p_args)
+    {
+        BIGFOOT_LOG_FATAL(SYSTEM_LOGGER,
+                          "Assert: {} (File:{}, Line:{}, Function:{}\n{}",
+                          std::format(p_format, eastl::forward<ARGS>(p_args)...),
+                          p_location.file_name(),
+                          p_location.line(),
+                          p_location.function_name(),
+                          p_stacktrace);
+    }
+
+    SystemAssertHandler& operator=(const SystemAssertHandler& p_handler) = delete;
+    SystemAssertHandler& operator=(SystemAssertHandler&& p_handler) = delete;
+};
+}   // namespace Bigfoot
+#endif
+#endif

Bigfoot/Sources/System/Include/System/SystemLogger_generated.hpp

@@ -1,12 +1,12 @@
 // AUTO-GENERATED DO NOT TOUCH
 
 /*********************************************************************
- * \file   UtilsTestsLogger.generated.hpp
- * 
+ * \file   SystemLogger.generated.hpp
+ *
  *********************************************************************/
-#ifndef BIGFOOT_UTILSTESTSLOGGER_GENERATED_HPP
-#define BIGFOOT_UTILSTESTSLOGGER_GENERATED_HPP
-#include <Utils/Log.hpp>
+#ifndef BIGFOOT_SYSTEMLOGGER_GENERATED_HPP
+#define BIGFOOT_SYSTEMLOGGER_GENERATED_HPP
+#include <System/Log/Log.hpp>
 
 #if defined BIGFOOT_NOT_OPTIMIZED
 
@@ -15,7 +15,7 @@ namespace Bigfoot
 /*
  * Logger
  */
-inline Log::LoggerInfo UTILSTESTS_LOGGER {"UTILSTESTS_LOGGER", Log::LogLevel::Trace};
-}
+inline Log::LoggerInfo SYSTEM_LOGGER {"SYSTEM_LOGGER", Flat::LogLevel::Trace};
+}  // namespace Bigfoot
 #endif
 #endif

Bigfoot/Sources/System/Include/System/Time.hpp

@@ -0,0 +1,68 @@
+/*********************************************************************
+ * \file   Time.hpp
+ *
+ * \author Romain BOULLARD
+ * \date   December 2025
+ *********************************************************************/
+#ifndef BIGFOOT_SYSTEM_TIME_HPP
+#define BIGFOOT_SYSTEM_TIME_HPP
+#include <chrono>
+#include <compare>
+#include <cstdint>
+
+namespace Bigfoot
+{
+class Time
+{
+  public:
+    Time(const std::uint64_t p_epoch);
+
+    Time(const Time& p_time) = default;
+    Time(Time&& p_time) = default;
+
+    [[nodiscard]]
+    std::uint32_t Year() const;
+
+    [[nodiscard]]
+    std::uint32_t Month() const;
+
+    [[nodiscard]]
+    std::uint32_t Day() const;
+
+    [[nodiscard]]
+    std::uint32_t Hour() const;
+
+    [[nodiscard]]
+    std::uint32_t Minute() const;
+
+    [[nodiscard]]
+    std::uint32_t Second() const;
+
+    [[nodiscard]]
+    std::uint32_t Microsecond() const;
+
+    [[nodiscard]]
+    std::uint64_t Epoch() const;
+
+    ~Time() = default;
+
+    Time& operator=(const Time& p_time) = default;
+    Time& operator=(Time&& p_time) = default;
+
+    [[nodiscard]]
+    auto operator<=>(const Time& p_other) const
+    {
+        return m_epoch <=> p_other.m_epoch;
+    }
+
+    [[nodiscard]]
+    static Time Now();
+
+  private:
+    std::uint64_t m_epoch;
+    std::tm m_timeInfo;
+    std::chrono::microseconds m_microseconds;
+};
+}   // namespace Bigfoot
+
+#endif

Bigfoot/Sources/System/Include/System/UUID/FlatUUID.hpp

@@ -0,0 +1,18 @@
+/*********************************************************************
+ * \file   FlatUUID.hpp
+ *
+ * \author Romain BOULLARD
+ * \date   December 2025
+ *********************************************************************/
+#ifndef BIGFOOT_SYSTEM_FLATUUID_HPP
+#define BIGFOOT_SYSTEM_FLATUUID_HPP
+#include <System/UUID/UUID.hpp>
+#include <System/UUID/UUID_generated.hpp>
+
+namespace flatbuffers
+{
+Bigfoot::Flat::UUID Pack(const Bigfoot::UUID& p_uuid);
+Bigfoot::UUID UnPack(const Bigfoot::Flat::UUID& p_flatUUID);
+}   // namespace flatbuffers
+
+#endif

Bigfoot/Sources/System/Include/System/UUID/UUID.fbs

@@ -0,0 +1,8 @@
+native_include "System/UUID/FlatUUID.hpp";
+
+namespace Bigfoot.Flat;
+
+struct UUID (native_type: "::Bigfoot::UUID")
+{
+  bytes:[ubyte:16];
+}

Bigfoot/Sources/System/Include/System/UUID/UUID.hpp

@@ -37,9 +37,12 @@ class UUID
 
     ~UUID() = default;
 
-    [[nodiscard]] operator std::span<const std::byte, UUID_BYTE_SIZE>() const;
-    [[nodiscard]] operator std::string() const;
-    [[nodiscard]] operator bool() const;
+    [[nodiscard]]
+    operator std::span<const std::byte, UUID_BYTE_SIZE>() const;
+    [[nodiscard]]
+    operator std::string() const;
+    [[nodiscard]]
+    operator bool() const;
 
     UUID& operator=(const UUID& p_uuid) = default;
     UUID& operator=(UUID&& p_uuid) noexcept = default;
@@ -103,4 +106,42 @@ struct std::hash<Bigfoot::UUID>
     }
 };
 
+template<>
+struct std::formatter<Bigfoot::UUID, char>
+{
+    constexpr auto parse(std::format_parse_context& ctx)
+    {
+        return ctx.begin();
+    }
+
+    template<typename FormatContext>
+    auto format(const Bigfoot::UUID& p_uuid, FormatContext& ctx) const
+    {
+        return std::format_to(ctx.out(), "{}", static_cast<std::string>(p_uuid));
+    }
+};
+
+#if defined BIGFOOT_NOT_OPTIMIZED
+#include <quill/DeferredFormatCodec.h>
+
+template<>
+struct fmtquill::formatter<Bigfoot::UUID>
+{
+    constexpr auto parse(format_parse_context& ctx)
+    {
+        return ctx.begin();
+    }
+
+    auto format(const Bigfoot::UUID& p_uuid, format_context& ctx) const
+    {
+        return fmtquill::format_to(ctx.out(), "{}", static_cast<std::string>(p_uuid));
+    }
+};
+
+template<>
+struct quill::Codec<Bigfoot::UUID>: quill::DeferredFormatCodec<Bigfoot::UUID>
+{
+};
+#endif
+
 #endif

Bigfoot/Sources/System/Include/System/UUID/UUID_generated.hpp

@@ -0,0 +1,74 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_UUID_BIGFOOT_FLAT_H_
+#define FLATBUFFERS_GENERATED_UUID_BIGFOOT_FLAT_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+// Ensure the included flatbuffers.h is the same version as when this file was
+// generated, otherwise it may not be compatible.
+static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
+              FLATBUFFERS_VERSION_MINOR == 12 &&
+              FLATBUFFERS_VERSION_REVISION == 19,
+             "Non-compatible flatbuffers version included");
+
+#include "System/UUID/FlatUUID.hpp"
+
+#include "EASTL/unique_ptr.h"
+#include "EASTL/string.h"
+
+namespace Bigfoot {
+namespace Flat {
+
+struct UUID;
+
+inline const ::flatbuffers::TypeTable *UUIDTypeTable();
+
+FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1) UUID FLATBUFFERS_FINAL_CLASS {
+ private:
+  uint8_t bytes_[16];
+
+ public:
+  struct Traits;
+  static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
+    return UUIDTypeTable();
+  }
+  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
+    return "Bigfoot.Flat.UUID";
+  }
+  UUID()
+      : bytes_() {
+  }
+  UUID(::flatbuffers::span<const uint8_t, 16> _bytes) {
+    ::flatbuffers::CastToArray(bytes_).CopyFromSpan(_bytes);
+  }
+  const ::flatbuffers::Array<uint8_t, 16> *bytes() const {
+    return &::flatbuffers::CastToArray(bytes_);
+  }
+};
+FLATBUFFERS_STRUCT_END(UUID, 16);
+
+struct UUID::Traits {
+  using type = UUID;
+};
+
+inline const ::flatbuffers::TypeTable *UUIDTypeTable() {
+  static const ::flatbuffers::TypeCode type_codes[] = {
+    { ::flatbuffers::ET_UCHAR, 1, -1 }
+  };
+  static const int16_t array_sizes[] = { 16,  };
+  static const int64_t values[] = { 0, 16 };
+  static const char * const names[] = {
+    "bytes"
+  };
+  static const ::flatbuffers::TypeTable tt = {
+    ::flatbuffers::ST_STRUCT, 1, type_codes, nullptr, array_sizes, values, names
+  };
+  return &tt;
+}
+
+}  // namespace Flat
+}  // namespace Bigfoot
+
+#endif  // FLATBUFFERS_GENERATED_UUID_BIGFOOT_FLAT_H_

Bigfoot/Sources/System/Log/Log.cpp

@@ -4,7 +4,7 @@
  * \author Romain BOULLARD
  * \date   October 2025
  *********************************************************************/
-#include <Utils/Log.hpp>
+#include <System/Log/Log.hpp>
 
 #if defined BIGFOOT_NOT_OPTIMIZED
 
@@ -14,16 +14,18 @@ Log::Log()
 {
     quill::Backend::start();
 
-    m_sinks[magic_enum::enum_integer(SinkType::Console)] = quill::Frontend::create_or_get_sink<quill::ConsoleSink>(
-        std::string {magic_enum::enum_name(SinkType::Console)});
+    m_sinks[static_cast<std::size_t>(Flat::LogSinkType::Console)] =
+        quill::Frontend::create_or_get_sink<quill::ConsoleSink>(
+            std::string {Flat::EnumNameLogSinkType(Flat::LogSinkType::Console)});
 }
 
 /****************************************************************************************/
 
 quill::Logger* Log::RegisterLogger(const LoggerInfo& p_loggerInfo)
 {
-    quill::Logger* logger = quill::Frontend::create_or_get_logger(p_loggerInfo.m_name,
-                                                                  m_sinks[magic_enum::enum_integer(SinkType::Console)]);
+    quill::Logger* logger = quill::Frontend::create_or_get_logger(
+        p_loggerInfo.m_name,
+        m_sinks[static_cast<std::size_t>(Flat::LogSinkType::Console)]);
     SetLoggerLevel(p_loggerInfo);
 
     return logger;
@@ -38,7 +40,7 @@ quill::Logger* Log::GetLogger(const LoggerInfo& p_loggerInfo)
 
 /****************************************************************************************/
 
-void Log::ChangeLoggerLogLevel(LoggerInfo& p_loggerInfo, const LogLevel p_level)
+void Log::ChangeLoggerLogLevel(LoggerInfo& p_loggerInfo, const Flat::LogLevel p_level)
 {
     p_loggerInfo.m_level = p_level;
     SetLoggerLevel(p_loggerInfo);
@@ -48,21 +50,21 @@ void Log::ChangeLoggerLogLevel(LoggerInfo& p_loggerInfo, const LogLevel p_level)
 
 void Log::SetLoggerLevel(const LoggerInfo& p_loggerInfo)
 {
-    constexpr auto logLevelToQuillLogLevel = [](const LogLevel p_level) constexpr -> quill::LogLevel
+    constexpr auto logLevelToQuillLogLevel = [](const Flat::LogLevel p_level) constexpr -> quill::LogLevel
     {
         switch (p_level)
         {
-        case LogLevel::Debug:
+        case Flat::LogLevel::Debug:
             return quill::LogLevel::Debug;
-        case LogLevel::Trace:
+        case Flat::LogLevel::Trace:
             return quill::LogLevel::TraceL3;
-        case LogLevel::Info:
+        case Flat::LogLevel::Info:
             return quill::LogLevel::Info;
-        case LogLevel::Warn:
+        case Flat::LogLevel::Warn:
             return quill::LogLevel::Warning;
-        case LogLevel::Error:
+        case Flat::LogLevel::Error:
             return quill::LogLevel::Error;
-        case LogLevel::Critical:
+        case Flat::LogLevel::Critical:
             return quill::LogLevel::Critical;
         }
 

Bigfoot/Sources/System/Time.cpp

@@ -0,0 +1,121 @@
+/*********************************************************************
+ * \file   Time.cpp
+ *
+ * \author Romain BOULLARD
+ * \date   December 2025
+ *********************************************************************/
+#include <System/Time.hpp>
+
+#include <System/SystemAssertHandler.hpp>
+
+namespace
+{
+[[nodiscard]]
+std::tm GetTimeInfo(const std::time_t& p_time)
+{
+    std::tm timeInfo {};
+#ifdef BIGFOOT_WINDOWS
+    [[maybe_unused]]
+    const errno_t error = gmtime_s(&timeInfo, &p_time);
+    if (error != 0)
+    {
+        char errnoStr[256];
+        strerror_s(errnoStr, error);
+
+        CRITICAL_ASSERT(Bigfoot::SystemAssertHandler,
+                        false,
+                        "Failed to convert epoch time to calendar time. {}",
+                        errnoStr);
+    }
+#elif BIGFOOT_LINUX
+    [[maybe_unused]]
+    const std::tm* error = gmtime_r(&p_time, &timeInfo);
+    CRITICAL_ASSERT(Bigfoot::SystemAssertHandler, error, "Failed to convert epoch time to calendar time");
+#else
+    static_assert(false, "not implemented");
+#endif
+
+    return timeInfo;
+}
+}   // namespace
+
+namespace Bigfoot
+{
+Time::Time(const std::uint64_t p_epoch):
+    m_epoch(p_epoch),
+    m_timeInfo(GetTimeInfo(std::chrono::system_clock::to_time_t(
+        std::chrono::time_point<std::chrono::system_clock> {std::chrono::microseconds {m_epoch}}))),
+    m_microseconds(std::chrono::duration_cast<std::chrono::microseconds>(
+        std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::time_point<std::chrono::system_clock> {
+          std::chrono::microseconds {m_epoch}}.time_since_epoch()) %
+        std::chrono::seconds(1)))
+{
+}
+
+/****************************************************************************************/
+
+std::uint32_t Time::Year() const
+{
+    return m_timeInfo.tm_year + 1900;
+}
+
+/****************************************************************************************/
+
+std::uint32_t Time::Month() const
+{
+    return m_timeInfo.tm_mon + 1;
+}
+
+/****************************************************************************************/
+
+std::uint32_t Time::Day() const
+{
+    return m_timeInfo.tm_mday;
+}
+
+/****************************************************************************************/
+
+std::uint32_t Time::Hour() const
+{
+    return m_timeInfo.tm_hour;
+}
+
+/****************************************************************************************/
+
+std::uint32_t Time::Minute() const
+{
+    return m_timeInfo.tm_min;
+}
+
+/****************************************************************************************/
+
+std::uint32_t Time::Second() const
+{
+    return m_timeInfo.tm_sec;
+}
+
+/****************************************************************************************/
+
+std::uint32_t Time::Microsecond() const
+{
+    return static_cast<std::uint32_t>(m_microseconds.count());
+}
+
+/****************************************************************************************/
+
+std::uint64_t Time::Epoch() const
+{
+    return m_epoch;
+}
+
+/****************************************************************************************/
+
+Time Time::Now()
+{
+    const std::chrono::time_point<std::chrono::system_clock> time = std::chrono::system_clock::now();
+    const std::uint64_t epochInMicroSeconds =
+        std::chrono::duration_cast<std::chrono::microseconds>(time.time_since_epoch()).count();
+
+    return Time {epochInMicroSeconds};
+}
+}   // namespace Bigfoot

Bigfoot/Sources/System/UUID/FlatUUID.cpp

@@ -0,0 +1,27 @@
+/*********************************************************************
+ * \file   FlatUUID.cpp
+ *
+ * \author Romain BOULLARD
+ * \date   December 2025
+ *********************************************************************/
+#include <System/UUID/FlatUUID.hpp>
+
+namespace flatbuffers
+{
+Bigfoot::Flat::UUID Pack(const Bigfoot::UUID& p_uuid)
+{
+    const std::span<const std::byte, Bigfoot::UUID::UUID_BYTE_SIZE> bytes = p_uuid;
+    return Bigfoot::Flat::UUID {
+      std::span<const std::uint8_t, Bigfoot::UUID::UUID_BYTE_SIZE> {reinterpret_cast<const std::uint8_t*>(bytes.data()),
+                                                                    bytes.size()}};
+}
+
+/****************************************************************************************/
+
+Bigfoot::UUID UnPack(const Bigfoot::Flat::UUID& p_flatUUID)
+{
+    const std::span<const std::uint8_t, Bigfoot::UUID::UUID_BYTE_SIZE> bytesView {p_flatUUID.bytes()->data(),
+                                                                                  p_flatUUID.bytes()->size()};
+    return Bigfoot::UUID {std::as_bytes(bytesView)};
+}
+}   // namespace flatbuffers

Bigfoot/Sources/System/UUID/UUID.cpp

@@ -4,7 +4,7 @@
  * \author Romain BOULLARD
  * \date   October 2025
  *********************************************************************/
-#include <System/UUID.hpp>
+#include <System/UUID/UUID.hpp>
 
 namespace Bigfoot
 {

Bigfoot/Sources/Utils/CMakeLists.txt

@@ -1,21 +1,15 @@
 get_filename_component(PackageName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
+project(${PackageName})
 
 set(PublicDependencies
-    $<$<CONFIG:Debug,RelWithDebInfo>:quill::quill>
     $<$<CONFIG:Debug,RelWithDebInfo>:cpptrace::cpptrace>)
 set(PrivateDependencies)
-set(BigfootPublicDependencies
-    System)
+set(BigfootPublicDependencies)
 set(BigfootPrivateDependencies)
 
 bigfoot_create_package_lib(
-    ${PackageName}
     "${PublicDependencies}"
     "${PrivateLibraries}"
     "${BigfootPublicDependencies}"
     "${BigfootPrivateDependencies}"
-    "")
-
-target_compile_definitions(${PackageName}
-        PUBLIC $<$<CONFIG:Debug,RelWithDebInfo>:QUILL_NO_EXCEPTIONS>
-        PUBLIC $<$<CONFIG:Debug,RelWithDebInfo>:QUILL_DISABLE_NON_PREFIXED_MACROS>)
+    "")

Bigfoot/Sources/Utils/Include/Utils/Assert.hpp

@@ -11,7 +11,6 @@
 
 #include <cpptrace/cpptrace.hpp>
 
-#include <cstdint>
 #include <source_location>
 #include <string>
 

Bigfoot/Sources/Utils/Include/Utils/Caster.hpp

@@ -6,52 +6,41 @@
  *********************************************************************/
 #ifndef BIGFOOT_UTILS_CASTER_HPP
 #define BIGFOOT_UTILS_CASTER_HPP
-#include <Utils/UtilsAssertHandler.hpp>
-
-#include <type_traits>
+#include <EASTL/type_traits.h>
 
 namespace Bigfoot
 {
-template<class TO, class FROM>
+template<class TO,
+         class FROM,
+         eastl::enable_if_t<eastl::is_base_of_v<FROM, TO> || eastl::is_base_of_v<TO, FROM>, bool> = true>
 constexpr TO* Cast(FROM* p_object)
 {
-    constexpr bool same = std::is_base_of_v<FROM, TO> || std::is_base_of_v<TO, FROM>;
-    static_assert(same, "Trying to cast to an incompatible type!");
     return static_cast<TO*>(p_object);
 }
 
-template<class TO, class FROM>
+template<class TO,
+         class FROM,
+         eastl::enable_if_t<eastl::is_base_of_v<FROM, TO> || eastl::is_base_of_v<TO, FROM>, bool> = true>
 constexpr const TO* Cast(const FROM* p_object)
 {
-    constexpr bool same = std::is_base_of_v<FROM, TO> || std::is_base_of_v<TO, FROM>;
-    static_assert(same, "Trying to cast to an incompatible type!");
     return static_cast<const TO*>(p_object);
 }
 
-template<class TO, class FROM>
+template<class TO,
+         class FROM,
+         eastl::enable_if_t<eastl::is_base_of_v<FROM, TO> || eastl::is_base_of_v<TO, FROM>, bool> = true>
 constexpr TO& Cast(FROM& p_object)
 {
-    constexpr bool same = std::is_base_of_v<FROM, TO> || std::is_base_of_v<TO, FROM>;
-    static_assert(same, "Trying to cast to an incompatible type!");
     return static_cast<TO&>(p_object);
 }
 
-template<class TO, class FROM>
+template<class TO,
+         class FROM,
+         eastl::enable_if_t<eastl::is_base_of_v<FROM, TO> || eastl::is_base_of_v<TO, FROM>, bool> = true>
 constexpr const TO& Cast(const FROM& p_object)
 {
-    constexpr bool same = std::is_base_of_v<FROM, TO> || std::is_base_of_v<TO, FROM>;
-    static_assert(same, "Trying to cast to an incompatible type!");
     return static_cast<const TO&>(p_object);
 }
-
-template<typename TO, typename FROM, std::enable_if_t<std::is_integral_v<FROM> && std::is_integral_v<TO>, bool> = true>
-constexpr TO NumericCast(const FROM& p_from)
-{
-    const TO to = static_cast<TO>(p_from);
-    SOFT_ASSERT(UtilsAssertHandler, static_cast<FROM>(to) == p_from, "We are losing data for this cast!");
-
-    return to;
-}
 }   // namespace Bigfoot
 
 #define BIGFOOT_NUMERIC_CAST(p_to, p_data) Bigfoot::NumericCast<p_to>(p_data)

Bigfoot/Sources/Utils/Include/Utils/Singleton.hpp

@@ -6,10 +6,11 @@
  *********************************************************************/
 #ifndef BIGFOOT_UTILS_SINGLETON_HPP
 #define BIGFOOT_UTILS_SINGLETON_HPP
-#include <array>
-#include <bit>
-#include <type_traits>
-#include <utility>
+
+#include <EASTL/array.h>
+#include <EASTL/bit.h>
+#include <EASTL/type_traits.h>
+#include <EASTL/utility.h>
 
 namespace Bigfoot
 {
@@ -31,7 +32,7 @@ class Singleton
      */
     static constexpr TYPE& Instance()
     {
-        return *std::bit_cast<TYPE*>(ms_instance.data());
+        return *eastl::bit_cast<TYPE*>(ms_instance.data());
     }
 
     class Lifetime
@@ -42,10 +43,11 @@ class Singleton
          *
          * \param p_args Arguments for the singleton
          */
-        template<typename... ARGS, typename = std::enable_if_t<!(std::is_same_v<Lifetime, std::decay_t<ARGS>> || ...)>>
+        template<typename... ARGS,
+                 typename = eastl::enable_if_t<!(eastl::is_same_v<Lifetime, eastl::decay_t<ARGS>> || ...)>>
         explicit Lifetime(ARGS&&... p_args)
         {
-            Initialize(std::forward<ARGS>(p_args)...);
+            Initialize(eastl::forward<ARGS>(p_args)...);
         }
 
         Lifetime(const Lifetime& p_lifetime) = delete;
@@ -76,7 +78,7 @@ class Singleton
     template<typename... ARGS>
     static void Initialize(ARGS&&... p_args)
     {
-        new (ms_instance.data()) TYPE(std::forward<ARGS>(p_args)...);
+        new (ms_instance.data()) TYPE(eastl::forward<ARGS>(p_args)...);
 
         ms_initialized = true;
     }
@@ -87,7 +89,7 @@ class Singleton
      */
     static void Finalize()
     {
-        std::bit_cast<TYPE*>(ms_instance.data())->~TYPE();
+        eastl::bit_cast<TYPE*>(ms_instance.data())->~TYPE();
 
         ms_initialized = false;
     }
@@ -95,7 +97,7 @@ class Singleton
     /**
      * The singleton.
      */
-    alignas(alignof(TYPE)) inline static std::array<std::byte, sizeof(TYPE)> ms_instance;
+    alignas(alignof(TYPE)) inline static eastl::array<std::byte, sizeof(TYPE)> ms_instance;
 
     /**
      * Is the singleton initialized?

Bigfoot/Sources/Utils/Include/Utils/TaggedType.hpp

@@ -0,0 +1,131 @@
+/*********************************************************************
+ * \file   TaggedType.h
+ *
+ * \author Romain BOULLARD
+ * \date   December 2025
+ *********************************************************************/
+#ifndef BIGFOOT_UTILS_TAGGEDTYPE_H
+#define BIGFOOT_UTILS_TAGGEDTYPE_H
+
+#include <compare>
+
+namespace Bigfoot
+{
+template<typename TYPE>
+class TaggedType
+{
+  public:
+    constexpr TaggedType() = default;
+
+    constexpr explicit TaggedType(TYPE p_value):
+        m_value(p_value)
+    {
+    }
+
+    constexpr TaggedType(const TaggedType& p_taggedType) = default;
+    constexpr TaggedType(TaggedType&& p_taggedType) noexcept = default;
+
+    ~TaggedType() = default;
+
+    constexpr TaggedType& operator=(const TaggedType& p_taggedType) = default;
+    constexpr TaggedType& operator=(TaggedType&& p_taggedType) noexcept = default;
+
+    constexpr TaggedType& operator=(const TYPE& p_value)
+    {
+        m_value = p_value;
+        return *this;
+    }
+
+    constexpr explicit operator TYPE() const
+    {
+        return m_value;
+    }
+
+    constexpr TYPE Get() const
+    {
+        return m_value;
+    }
+
+    constexpr auto operator<=>(const TaggedType& p_other) const = default;
+
+    constexpr TaggedType& operator+=(const TYPE& p_value)
+    {
+        m_value += p_value;
+        return *this;
+    }
+
+    constexpr TaggedType& operator-=(const TYPE& p_value)
+    {
+        m_value -= p_value;
+        return *this;
+    }
+
+    constexpr TaggedType& operator*=(const TYPE& p_value)
+    {
+        m_value *= p_value;
+        return *this;
+    }
+
+    constexpr TaggedType& operator/=(const TYPE& p_value)
+    {
+        m_value /= p_value;
+        return *this;
+    }
+
+    constexpr TaggedType& operator+=(const TaggedType& p_other)
+    {
+        m_value += p_other.m_value;
+        return *this;
+    }
+
+    constexpr TaggedType& operator-=(const TaggedType& p_other)
+    {
+        m_value -= p_other.m_value;
+        return *this;
+    }
+
+    constexpr TaggedType& operator*=(const TaggedType& p_other)
+    {
+        m_value *= p_other.m_value;
+        return *this;
+    }
+
+    constexpr TaggedType& operator/=(const TaggedType& p_other)
+    {
+        m_value /= p_other.m_value;
+        return *this;
+    }
+
+    template<typename L, typename R>
+    friend constexpr TaggedType operator+(L p_left, R p_right)
+    {
+        return p_left += p_right;
+    }
+
+    template<typename L, typename R>
+    friend constexpr TaggedType operator-(L p_left, R p_right)
+    {
+        return p_left -= p_right;
+    }
+
+    template<typename L, typename R>
+    friend constexpr TaggedType operator*(L p_left, R p_right)
+    {
+        return p_left *= p_right;
+    }
+
+    template<typename L, typename R>
+    friend constexpr TaggedType operator/(L p_left, R p_right)
+    {
+        return p_left /= p_right;
+    }
+
+  private:
+    /**
+     * The value
+     */
+    TYPE m_value {};
+};
+}   // namespace Bigfoot
+
+#endif

Bigfoot/Sources/Utils/Include/Utils/UtilsAssertHandler.hpp

@@ -1,49 +0,0 @@
-/*********************************************************************
- * \file   UtilsAssertHandler.hpp
- *
- * \author Romain BOULLARD
- * \date   October 2025
- *********************************************************************/
-#ifndef BIGFOOT_UTILS_UTILSASSERTHANDLER_HPP
-#define BIGFOOT_UTILS_UTILSASSERTHANDLER_HPP
-#include <Utils/Assert.hpp>
-
-#include <format>
-#include <source_location>
-#include <string_view>
-
-namespace Bigfoot
-{
-class UtilsAssertHandler
-{
-  public:
-    UtilsAssertHandler() = delete;
-
-    UtilsAssertHandler(const UtilsAssertHandler& p_handler) = delete;
-    UtilsAssertHandler(UtilsAssertHandler&& p_handler) = delete;
-
-    ~UtilsAssertHandler() = delete;
-
-    /**
-     * Handle an assertion.
-     *
-     * \param p_location Location of the assertion.
-     * \param p_stacktrace The stack trace
-     * \param p_format Format string for the assertion message.
-     * \param p_args Arguments for the format string.
-     */
-    template<typename... ARGS>
-    static void Handle([[maybe_unused]] const std::source_location& p_location,
-                       [[maybe_unused]] const std::string_view p_stacktrace,
-                       [[maybe_unused]] std::format_string<ARGS...> p_format,
-                       [[maybe_unused]] ARGS&&... p_args)
-    {
-        // We dont have access to logging capabilities here
-        // So no log
-    }
-
-    UtilsAssertHandler& operator=(const UtilsAssertHandler& p_handler) = delete;
-    UtilsAssertHandler& operator=(UtilsAssertHandler&& p_handler) = delete;
-};
-}   // namespace Bigfoot
-#endif

Bigfoot/Sources/Utils/Include/Utils/Version.hpp

@@ -57,7 +57,7 @@ class Version
     {
         constexpr std::uint32_t mask = 0b00000000111111110000000000000000;
 
-        return BIGFOOT_NUMERIC_CAST(std::uint8_t, (m_combined & mask) >> 16);
+        return static_cast<std::uint8_t>((m_combined & mask) >> 16);
     }
 
     /**
@@ -70,7 +70,7 @@ class Version
     {
         constexpr std::uint32_t mask = 0b00000000000000001111111100000000;
 
-        return BIGFOOT_NUMERIC_CAST(std::uint8_t, (m_combined & mask) >> 8);
+        return static_cast<std::uint8_t>((m_combined & mask) >> 8);
     }
 
     /**
@@ -83,7 +83,7 @@ class Version
     {
         constexpr std::uint32_t mask = 0b00000000000000000000000011111111;
 
-        return BIGFOOT_NUMERIC_CAST(std::uint8_t, (m_combined & mask));
+        return static_cast<std::uint8_t>(m_combined & mask);
     }
 
     [[nodiscard]]
@@ -92,7 +92,8 @@ class Version
         return m_combined;
     }
 
-    [[nodiscard]] operator std::string() const;
+    [[nodiscard]]
+    operator std::string() const;
 
     constexpr Version& operator=(const Version& p_version) = default;
 

Bigfoot/Tests/Engine/BigFile/Database.cpp

@@ -1 +0,0 @@
-

Bigfoot/Tests/Engine/CMakeLists.txt

@@ -1,7 +1,15 @@
 get_filename_component(PackageName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
+project(${PackageName}Tests)
 
-bigfoot_create_bigfile(${PackageName}Tests "Tests/Bigfoot")
+set(BigfootDependencies
+        Engine
+        System
+        Utils)
+
+bigfoot_create_bigfile("Tests/Bigfoot")
 
 bigfoot_create_package_tests(
-    ${PackageName}
-    "")
+    ""
+    "${BigfootDependencies}")
+
+bigfoot_setup_dependencies("Tests/Bigfoot")

Bigfoot/Tests/Engine/Include/Bigfoot/BigFileInfo_generated.hpp

@@ -1,19 +0,0 @@
-// AUTO-GENERATED DO NOT TOUCH
-
-/*********************************************************************
- * \file   BigFileInfo.generated.hpp
- * 
- *********************************************************************/
-#ifndef BIGFOOT_BIGFOOT_BIGFILEINFO_GENERATED_HPP
-#define BIGFOOT_BIGFOOT_BIGFILEINFO_GENERATED_HPP
-
-#include <string_view>
-
-namespace Bigfoot
-{
-/*
- * BigFile location
- */
-constexpr std::string_view BIGFILE_BIGFOOT_LOCATION{"D:/Development/bigfootdev/bigfoot2/build/Bigfoot/Tests/Engine/Bigfoot-bigfile.db"};
-}
-#endif

Bigfoot/Tests/Engine/Include/EngineTests/BigFileInfo.generated.hpp

@@ -1,19 +0,0 @@
-// AUTO-GENERATED DO NOT TOUCH
-
-/*********************************************************************
- * \file   BigFileInfo.generated.hpp
- * 
- *********************************************************************/
-#ifndef BIGFOOT_ENGINE_BIGFILE_BIGFILEINFO_GENERATED_HPP
-#define BIGFOOT_ENGINE_BIGFILE_BIGFILEINFO_GENERATED_HPP
-
-#include <string_view>
-
-namespace Bigfoot
-{
-/*
- * BigFile location
- */
-constexpr std::string_view BIGFILE_ENGINETESTS_LOCATION{"D:/Development/bigfootdev/bigfoot2/build/Bigfoot/Tests/Engine/EngineTests-bigfile.db"};
-}
-#endif

Bigfoot/Tests/Engine/touch.cpp

@@ -0,0 +1 @@
+// to delete when an actual test is in EngineTests

Bigfoot/Tests/System/CMakeLists.txt

@@ -1,7 +1,14 @@
 get_filename_component(PackageName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
+project(${PackageName}Tests)
 
-set(Dependencies)
+set(BigfootDependencies
+        System
+        Utils)
 
 bigfoot_create_package_tests(
-    ${PackageName}
-    "")
+    ""
+    "${BigfootDependencies}")
+
+bigfoot_create_logger()
+
+bigfoot_setup_dependencies("Tests/Bigfoot")

Bigfoot/Tests/System/File.cpp

@@ -0,0 +1,80 @@
+/*********************************************************************
+ * \file   File.cpp
+ *
+ * \author Romain BOULLARD
+ * \date   December 2025
+ *********************************************************************/
+#include <System/File.hpp>
+
+#include <gtest/gtest.h>
+
+namespace Bigfoot
+{
+class FileFixture: public ::testing::Test
+{
+  public:
+    File m_file {eastl::string_view {"Fixture/file"}};
+    File m_nonExistent {eastl::string_view {"Fixture/bigfoot"}};
+};
+
+/****************************************************************************************/
+
+TEST_F(FileFixture, IsRelative_ShouldReturnTrueOnRelativeFile)
+{
+    EXPECT_TRUE(m_file.IsRelative());
+}
+
+/****************************************************************************************/
+
+TEST_F(FileFixture, IsRelative_ShouldReturnFalseOnAbsoluteFile)
+{
+    EXPECT_FALSE(m_file.Absolute().IsRelative());
+}
+
+/****************************************************************************************/
+
+TEST_F(FileFixture, IsAbsolute_ShouldReturnTrueOnAbsoluteFile)
+{
+    EXPECT_TRUE(m_file.Absolute().IsAbsolute());
+}
+
+TEST_F(FileFixture, IsAbsolute_ShouldReturnFalseOnRelativeFile)
+{
+    EXPECT_FALSE(m_file.IsAbsolute());
+}
+
+/****************************************************************************************/
+
+TEST_F(FileFixture, Exists_ShouldReturnTrueOnExistingFile)
+{
+    EXPECT_TRUE(m_file.Exists());
+}
+
+/****************************************************************************************/
+
+TEST_F(FileFixture, Exists_ShouldReturnFalseOnNonExistingFile)
+{
+    EXPECT_FALSE(m_nonExistent.Exists());
+}
+
+/****************************************************************************************/
+
+TEST_F(FileFixture, Path_ShouldReturnThePath)
+{
+    EXPECT_STREQ(m_file.Path().data(), "Fixture/file");
+}
+
+/****************************************************************************************/
+
+TEST_F(FileFixture, Absolute_ShouldReturnTheAbsolutePath)
+{
+    EXPECT_STREQ(std::filesystem::absolute("Fixture/file").string().c_str(), m_file.Absolute().Path().data());
+}
+
+/****************************************************************************************/
+
+TEST_F(FileFixture, Relative_ShouldReturnTheRelativePath)
+{
+    EXPECT_STREQ(std::filesystem::relative("Fixture/file").string().c_str(), m_file.Relative().Path().data());
+}
+}   // namespace Bigfoot

Bigfoot/Tests/System/Include/SystemTests/SystemTestsLogger_generated.hpp

@@ -0,0 +1,21 @@
+// AUTO-GENERATED DO NOT TOUCH
+
+/*********************************************************************
+ * \file   SystemTestsLogger.generated.hpp
+ *
+ *********************************************************************/
+#ifndef BIGFOOT_SYSTEMTESTSLOGGER_GENERATED_HPP
+#define BIGFOOT_SYSTEMTESTSLOGGER_GENERATED_HPP
+#include <System/Log/Log.hpp>
+
+#if defined BIGFOOT_NOT_OPTIMIZED
+
+namespace Bigfoot
+{
+/*
+ * Logger
+ */
+inline Log::LoggerInfo SYSTEMTESTS_LOGGER {"SYSTEMTESTS_LOGGER", Flat::LogLevel::Trace};
+}  // namespace Bigfoot
+#endif
+#endif

Bigfoot/Tests/System/Log/Log.cpp

@@ -4,9 +4,11 @@
  * \author Romain BOULLARD
  * \date   December 2022
  *********************************************************************/
-#include <Utils/Log.hpp>
+#include <System/Log/Log.hpp>
 
-#include <UtilsTests/UtilsTestsLogger.generated.hpp>
+#include <Utils/Singleton.hpp>
+
+#include <SystemTests/SystemTestsLogger_generated.hpp>
 
 #if defined BIGFOOT_NOT_OPTIMIZED
 
@@ -19,51 +21,51 @@ class LogFixture: public ::testing::Test
   protected:
     void SetUp() override
     {
-        UTILSTESTS_LOGGER = {"UTILSTESTS_LOGGER", Log::LogLevel::Trace};
+        SYSTEMTESTS_LOGGER = {"UTILSTESTS_LOGGER", Flat::LogLevel::Trace};
     }
 
-    constexpr Log::LogLevel QuillLogLevelToLogLevel(const quill::LogLevel p_level)
+    static constexpr Flat::LogLevel QuillLogLevelToLogLevel(const quill::LogLevel p_level)
     {
         switch (p_level)
         {
         case quill::LogLevel::Debug:
-            return Log::LogLevel::Debug;
+            return Flat::LogLevel::Debug;
         case quill::LogLevel::TraceL3:
-            return Log::LogLevel::Trace;
+            return Flat::LogLevel::Trace;
         case quill::LogLevel::Info:
-            return Log::LogLevel::Info;
+            return Flat::LogLevel::Info;
         case quill::LogLevel::Warning:
-            return Log::LogLevel::Warn;
+            return Flat::LogLevel::Warn;
         case quill::LogLevel::Error:
-            return Log::LogLevel::Error;
+            return Flat::LogLevel::Error;
         case quill::LogLevel::Critical:
-            return Log::LogLevel::Critical;
+            return Flat::LogLevel::Critical;
         default:
             break;
         }
 
-        return Log::LogLevel::Trace;
+        return Flat::LogLevel::Trace;
     }
 
-    Singleton<Log>::Lifetime m_log;
+    Log m_log;
 };
 
 /****************************************************************************************/
 
 TEST_F(LogFixture, RegisterLogger_ShouldRegisterTheLogger)
 {
-    const quill::Logger* logger = Singleton<Log>::Instance().RegisterLogger(UTILSTESTS_LOGGER);
+    const quill::Logger* logger = m_log.RegisterLogger(SYSTEMTESTS_LOGGER);
     EXPECT_TRUE(logger);
-    EXPECT_EQ(logger, Singleton<Log>::Instance().GetLogger(UTILSTESTS_LOGGER));
-    EXPECT_EQ(logger->get_logger_name(), UTILSTESTS_LOGGER.m_name);
-    EXPECT_EQ(QuillLogLevelToLogLevel(logger->get_log_level()), UTILSTESTS_LOGGER.m_level);
+    EXPECT_EQ(logger, m_log.GetLogger(SYSTEMTESTS_LOGGER));
+    EXPECT_EQ(logger->get_logger_name(), SYSTEMTESTS_LOGGER.m_name);
+    EXPECT_EQ(QuillLogLevelToLogLevel(logger->get_log_level()), SYSTEMTESTS_LOGGER.m_level);
 }
 
 /****************************************************************************************/
 
 TEST_F(LogFixture, GetLogger_ShouldReturnNullptrIfTheLoggerDoesNotExist)
 {
-    EXPECT_FALSE(Singleton<Log>::Instance().GetLogger(UTILSTESTS_LOGGER));
+    EXPECT_FALSE(m_log.GetLogger(SYSTEMTESTS_LOGGER));
 }
 
 /****************************************************************************************/
@@ -71,60 +73,66 @@ TEST_F(LogFixture, GetLogger_ShouldReturnNullptrIfTheLoggerDoesNotExist)
 TEST_F(LogFixture, GetLogger_ShouldReturnTheLoggerIfItExists)
 {
     [[maybe_unused]]
-    const quill::Logger* logger = Singleton<Log>::Instance().RegisterLogger(UTILSTESTS_LOGGER);
-    EXPECT_TRUE(Singleton<Log>::Instance().GetLogger(UTILSTESTS_LOGGER));
+    const quill::Logger* logger = m_log.RegisterLogger(SYSTEMTESTS_LOGGER);
+    EXPECT_TRUE(m_log.GetLogger(SYSTEMTESTS_LOGGER));
 }
 
 /****************************************************************************************/
 
 TEST_F(LogFixture, ChangeLoggerLogLevel_ShouldChangeTheLoggerLogLevel)
 {
-    const quill::Logger* logger = Singleton<Log>::Instance().RegisterLogger(UTILSTESTS_LOGGER);
+    const quill::Logger* logger = m_log.RegisterLogger(SYSTEMTESTS_LOGGER);
 
-    Singleton<Log>::Instance().ChangeLoggerLogLevel(UTILSTESTS_LOGGER, Log::LogLevel::Critical);
-    EXPECT_EQ(QuillLogLevelToLogLevel(logger->get_log_level()), Log::LogLevel::Critical);
+    m_log.ChangeLoggerLogLevel(SYSTEMTESTS_LOGGER, Flat::LogLevel::Critical);
+    EXPECT_EQ(QuillLogLevelToLogLevel(logger->get_log_level()), Flat::LogLevel::Critical);
 }
 
 /****************************************************************************************/
 
 TEST_F(LogFixture, LogDebug)
 {
-    BIGFOOT_LOG_DEBUG(UTILSTESTS_LOGGER, "Hello");
+    Singleton<Log>::Lifetime singletonLifetime;
+    BIGFOOT_LOG_DEBUG(SYSTEMTESTS_LOGGER, "Hello");
 }
 
 /****************************************************************************************/
 
 TEST_F(LogFixture, LogTrace)
 {
-    BIGFOOT_LOG_TRACE(UTILSTESTS_LOGGER, "Hello");
+    Singleton<Log>::Lifetime singletonLifetime;
+    BIGFOOT_LOG_TRACE(SYSTEMTESTS_LOGGER, "Hello");
 }
 
 /****************************************************************************************/
 
 TEST_F(LogFixture, LogInfo)
 {
-    BIGFOOT_LOG_INFO(UTILSTESTS_LOGGER, "Hello");
+    Singleton<Log>::Lifetime singletonLifetime;
+    BIGFOOT_LOG_INFO(SYSTEMTESTS_LOGGER, "Hello");
 }
 
 /****************************************************************************************/
 
 TEST_F(LogFixture, LogWarn)
 {
-    BIGFOOT_LOG_WARN(UTILSTESTS_LOGGER, "Hello");
+    Singleton<Log>::Lifetime singletonLifetime;
+    BIGFOOT_LOG_WARN(SYSTEMTESTS_LOGGER, "Hello");
 }
 
 /****************************************************************************************/
 
 TEST_F(LogFixture, LogError)
 {
-    BIGFOOT_LOG_ERROR(UTILSTESTS_LOGGER, "Hello");
+    Singleton<Log>::Lifetime singletonLifetime;
+    BIGFOOT_LOG_ERROR(SYSTEMTESTS_LOGGER, "Hello");
 }
 
 /****************************************************************************************/
 
 TEST_F(LogFixture, LogFatal)
 {
-    BIGFOOT_LOG_FATAL(UTILSTESTS_LOGGER, "Hello");
+    Singleton<Log>::Lifetime singletonLifetime;
+    BIGFOOT_LOG_FATAL(SYSTEMTESTS_LOGGER, "Hello");
 }
 }   // namespace Bigfoot
 #endif

Bigfoot/Tests/System/Time.cpp

@@ -0,0 +1,67 @@
+/*********************************************************************
+ * \file   Time.cpp
+ *
+ * \author Romain BOULLARD
+ * \date   December 2025
+ *********************************************************************/
+#include <System/Time.hpp>
+
+#include <gtest/gtest.h>
+
+namespace Bigfoot
+{
+class TimeFixture: public ::testing::Test
+{
+  public:
+    Time m_time {1'767'643'746'680'609};
+};
+
+/****************************************************************************************/
+
+TEST_F(TimeFixture, Year_ShouldReturnTheYear)
+{
+    EXPECT_EQ(m_time.Year(), 2026);
+}
+
+/****************************************************************************************/
+
+TEST_F(TimeFixture, Month_ShouldReturnTheMonth)
+{
+    EXPECT_EQ(m_time.Month(), 1);
+}
+
+/****************************************************************************************/
+
+TEST_F(TimeFixture, Day_ShouldReturnTheDay)
+{
+    EXPECT_EQ(m_time.Day(), 5);
+}
+
+/****************************************************************************************/
+
+TEST_F(TimeFixture, Hour_ShouldReturnTheHour)
+{
+    EXPECT_EQ(m_time.Hour(), 20);
+}
+
+/****************************************************************************************/
+
+TEST_F(TimeFixture, Minute_ShouldReturnTheMinute)
+{
+    EXPECT_EQ(m_time.Minute(), 9);
+}
+
+/****************************************************************************************/
+
+TEST_F(TimeFixture, Second_ShouldReturnTheSecond)
+{
+    EXPECT_EQ(m_time.Second(), 6);
+}
+
+/****************************************************************************************/
+
+TEST_F(TimeFixture, Microsecond_ShouldReturnTheMicrosecond)
+{
+    EXPECT_EQ(m_time.Microsecond(), 680'609);
+}
+}   // namespace Bigfoot

Bigfoot/Tests/System/UUID/UUID.cpp

@@ -4,7 +4,7 @@
  * \author Romain BOULLARD
  * \date   October 2025
  *********************************************************************/
-#include <System/UUID.hpp>
+#include <System/UUID/UUID.hpp>
 
 #include <ankerl/unordered_dense.h>
 

Bigfoot/Tests/Utils/CMakeLists.txt

@@ -1,9 +1,11 @@
 get_filename_component(PackageName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
+project(${PackageName}Tests)
 
-set(Dependencies)
-
-bigfoot_create_logger(${PackageName}Tests)
+set(BigfootDependencies
+        Utils)
 
 bigfoot_create_package_tests(
-    ${PackageName}
-    "")
+    ""
+    "${BigfootDependencies}")
+
+bigfoot_setup_dependencies("Tests/Bigfoot")

Bigfoot/Tests/Utils/Caster.cpp

@@ -99,23 +99,4 @@ TEST_F(CasterFixture, ObjectCast)
     const Parent& parent = BIGFOOT_OBJECT_CAST(Parent, m_b);
     EXPECT_EQ(parent.GetParentValue(), 34);
 }
-
-/****************************************************************************************/
-
-TEST_F(CasterFixture, NumericCast)
-{
-    const std::uint32_t a = 128;
-    const std::uint8_t b = BIGFOOT_NUMERIC_CAST(std::uint8_t, a);
-    EXPECT_EQ(a, b);
-}
-
-/****************************************************************************************/
-
-#ifdef BIGFOOT_NOT_OPTIMIZED
-TEST_F(CasterFixture, NumericCast_ShouldAssertIfWeLoseDataDuringTheCast)
-{
-    const std::uint32_t a = 1000;
-    EXPECT_DEATH(BIGFOOT_NUMERIC_CAST(std::uint8_t, a), "");
-}
-#endif
 }   // namespace Bigfoot