About to relearn this version of the language.

assets/en.json

@@ -0,0 +1,42 @@
+{
+  "main_menu": {
+    "new_game": "New Game",
+    "load_game": "Load Game",
+    "options": "Options",
+    "exit": "Exit"
+  },
+  "tiles": {
+    "water": {
+      "interact": "A refreshing body of water."
+    },
+    "lamp": {
+      "interact": "An electric lamp.\nA real lightbulb idea."
+    },
+    "rail": {
+      "interact": "Train tracks.\n...Better not cross them."
+    }
+  },
+  "entities": {
+    "sign": {
+      "name": "Sign"
+    }
+  },
+  "maps": {
+    "testmap": {
+      "bob": "Hello, I am Bob.",
+      "sign": "This is a sign.",
+      "sign2": {
+        "1": "This is another sign.",
+        "2": "It has two lines."
+      }
+    },
+    "train_station": {
+      "stair_sign": {
+        "0": "Stairs slippery when wet.\n\n<- West to Town.\n-> East to lakefront."
+      }
+    }
+  },
+  "battle": {
+    "start": "Battle Start!"
+  }
+}

lib/CMakeLists.txt

@@ -6,12 +6,10 @@
 include(FetchContent)
 
 # GLFW
-if(DAWN_TARGET_GLFW)
+FetchContent_Declare(glfw URL https://github.com/glfw/glfw/releases/download/3.4/glfw-3.4.zip)
-  FetchContent_Declare(glfw URL https://github.com/glfw/glfw/releases/download/3.4/glfw-3.4.zip)
+FetchContent_MakeAvailable(glfw)
-  FetchContent_MakeAvailable(glfw)
 
-  add_subdirectory(glad)
+add_subdirectory(glad)
-endif()
 
 # GLM
 FetchContent_Declare(

src/CMakeLists.txt

@@ -22,11 +22,9 @@ target_link_libraries(${DAWN_TARGET_NAME}
 )
 
 # Compile support targets
-if(DAWN_TARGET_LINUX)
+add_subdirectory(dawnglfw)
-  add_subdirectory(dawnglfw)
+add_subdirectory(dawnopengl)
-  add_subdirectory(dawnopengl)
+add_subdirectory(dawnlinux)
-  add_subdirectory(dawnlinux)
-endif()
 
 # Compress the game assets.
 add_dependencies(${DAWN_TARGET_NAME} dawnassets)

src/dawn/CMakeLists.txt

@@ -36,4 +36,10 @@ add_subdirectory(scene)
 # add_subdirectory(state)
 add_subdirectory(time)
 add_subdirectory(util)
-add_subdirectory(ui)
+add_subdirectory(ui)
+
+
+# Assets
+tool_copy(en en.json)
+
+add_dependencies(${DAWN_TARGET_NAME} dawnassets)

src/dawn/asset/AssetManager.cpp

@@ -4,7 +4,6 @@
 // https://opensource.org/licenses/MIT
 
 #include "AssetManager.hpp"
-#include "loaders/TextureLoader.hpp"
 
 using namespace Dawn;
 

src/dawn/asset/AssetManager.hpp

@@ -83,7 +83,16 @@ namespace Dawn {
        * @return The asset loader for the given asset.
        */
       template<class T>
-      std::shared_ptr<T> get(const std::string filename);
+      std::shared_ptr<T> get(const std::string filename) {
+        auto existing = this->getExisting<T>(filename);
+        if(existing) return existing;
+
+        std::shared_ptr<T> loader = std::make_shared<T>(filename);
+        pendingAssetLoaders.push_back(
+          std::static_pointer_cast<AssetLoader>(loader)
+        );
+        return loader;
+      }
 
       /**
        * Returns the asset loader for the given asset.

src/dawn/asset/CMakeLists.txt

@@ -12,4 +12,4 @@ target_sources(${DAWN_TARGET_NAME}
 )
 
 # Subdirs
-add_subdirectory(loaders)
+add_subdirectory(loader)

src/dawn/game/Game.cpp

@@ -14,6 +14,7 @@ Game::Game() {
 }
 
 void Game::init() {
+  localeManager.init(shared_from_this());
   renderHost.init(shared_from_this());
   inputManager.init(shared_from_this());
   saveManager.init(shared_from_this());

src/dawn/locale/LocaleManager.cpp

@@ -1,8 +1,62 @@
-// Copyright (c) 2023 Dominic Masters
+// Copyright (c) 2024 Dominic Masters
 // 
 // This software is released under the MIT License.
 // https://opensource.org/licenses/MIT
 
 #include "LocaleManager.hpp"
+#include "assert/assert.hpp"
+#include "game/Game.hpp"
+#include "util/String.hpp"
 
-using namespace Dawn;
+using namespace Dawn;
+
+LocaleManager::LocaleManager() {
+}
+
+void LocaleManager::init(const std::shared_ptr<Game> &game) {
+  assertNotNull(game, "Game cannot be null.");
+  this->game = game;
+
+  languageAsset = game->assetManager.get<JSONLoader>("en.json");
+}
+
+std::string LocaleManager::getString(
+  const std::string &key,
+  const std::unordered_map<std::string, std::string> replacements
+) {
+  assertNotNull(languageAsset, "Language asset cannot be null.");
+
+  // Key comes in like "main_menu.new_game", which would be;
+  // data["main_menu"]["new_game"], so we need to split by dot and iterate.
+  auto keyParts = String::split(key, ".");
+  int32_t currentPart = 0;
+  json dataCurrent = languageAsset->data;
+
+  while(currentPart < keyParts.size()) {
+    auto &part = keyParts[currentPart];
+    assertTrue(
+      dataCurrent.contains(part),
+      "Key '%s' does not exist in the language asset.", key.c_str()
+    );
+    dataCurrent = dataCurrent[part];
+    currentPart++;
+  }
+
+  // For each replacement, replace "{{ key }}" with the value.
+  std::string output = dataCurrent.get<std::string>();// overrides?
+  for(auto &replacement : replacements) {
+    std::string key = "{{ " + replacement.first + " }}";
+    size_t pos = 0;
+    while((pos = output.find(key, pos)) != std::string::npos) {
+      output.replace(pos, key.length(), replacement.second);
+      pos += replacement.second.length();
+    }
+  }
+
+  return output;
+}
+
+LocaleManager::~LocaleManager() {
+  languageAsset = nullptr;
+  game.reset();
+}

src/dawn/locale/LocaleManager.hpp

@@ -1,15 +1,48 @@
-// Copyright (c) 2023 Dominic Masters
+// Copyright (c) 2024 Dominic Masters
 // 
 // This software is released under the MIT License.
 // https://opensource.org/licenses/MIT
 
 #pragma once
-#include "dawnlibs.hpp"
+#include "asset/loader/JSONLoader.hpp"
 
 namespace Dawn {
-  class LocaleManager final {
+  class Game;
+
+  class LocaleManager {
     private:
+      std::weak_ptr<Game> game;
+      std::shared_ptr<JSONLoader> languageAsset;
 
     public:
+      /**
+       * Creates a new LocaleManager.
+       */
+      LocaleManager();
+
+      /**
+       * Initializes the LocaleManager.
+       * 
+       * @param game The game to initialize with.
+       */
+      void init(const std::shared_ptr<Game> &game);
+
+      /**
+       * Returns a string from the locale.
+       * 
+       * @param key The key of the string.
+       * @param replacements The replacements to make in the string.
+       * @return The string.
+       */
+      std::string getString(
+        const std::string &key,
+        const std::unordered_map<std::string, std::string> replacements =
+        std::unordered_map<std::string, std::string>()
+      );
+
+      /**
+       * Destroys the LocaleManager.
+       */
+      ~LocaleManager();
   };
 }

src/dawnopengl/CMakeLists.txt

@@ -3,20 +3,10 @@
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 
-if(NOT DEFINED DAWN_OPENGL_EXCLUDE_LIBRARIES)
+# Libraries
-  # Libraries
+target_link_libraries(${DAWN_TARGET_NAME}
-  find_package(OpenGL REQUIRED)
+  PRIVATE
-
+)
-  target_include_directories(${DAWN_TARGET_NAME}
-    PUBLIC
-      ${OPENGL_INCLUDE_DIR}
-  )
-
-  target_link_libraries(${DAWN_TARGET_NAME}
-    PUBLIC
-      ${OPENGL_LIBRARIES}
-  )
-endif()
 
 # Includes
 target_include_directories(${DAWN_TARGET_NAME}
@@ -24,7 +14,7 @@ target_include_directories(${DAWN_TARGET_NAME}
     ${CMAKE_CURRENT_LIST_DIR}
 )
 
+
 # Subdirs
 add_subdirectory(assert)
-add_subdirectory(display)
+add_subdirectory(display)
-# add_subdirectory(scene)

tools/CMakeLists.txt

@@ -3,18 +3,6 @@
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 
-# Tool Level Values
-set(
-  DAWN_TOOL_INCLUDES
-    ${CMAKE_CURRENT_LIST_DIR}
-  CACHE INTERNAL ${DAWN_CACHE_TARGET}
-)
-
-set(
-  DAWN_TOOL_GENERATED_DEPENDENCIES
-  CACHE INTERNAL ${DAWN_CACHE_TARGET}
-)
-
 # Tools
 add_subdirectory(assetstool)
 add_subdirectory(copytool)

tools/assetstool/CMakeLists.txt

@@ -3,10 +3,14 @@
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 
+find_package(Python3 REQUIRED COMPONENTS Interpreter)
+
 add_custom_target(dawnassets
-  COMMAND ${DAWN_TOOLS_DIR}/assetstool/assetstool.py
+  COMMAND
+    ${Python3_EXECUTABLE}
+    ${DAWN_TOOLS_DIR}/assetstool/assetstool.py
     --input=${DAWN_ASSETS_BUILD_DIR}
-    --output=${DAWN_BUILD_DIR}/assets.tar
+    --output=${DAWN_BUILD_DIR}/dawn.tar
   COMMENT "Bundling assets..."
     USES_TERMINAL
     DEPENDS ${DAWN_ASSETS}

tools/copytool/CMakeLists.txt

@@ -3,9 +3,9 @@
 # This software is released under the MIT License.
 # https://opensource.org/licenses/MIT
 
-function(tool_copy target input output)
+function(tool_copy target file)
   add_custom_target(${target}
-    COMMAND ${CMAKE_COMMAND} -E copy ${input} ${output}
+    COMMAND ${CMAKE_COMMAND} -E copy ${DAWN_ASSETS_SOURCE_DIR}/${file} ${DAWN_ASSETS_BUILD_DIR}/${file}
   )
   add_dependencies(dawnassets ${target})
 endfunction()

tools/texturetool/CMakeLists.txt

@@ -1,9 +1,5 @@
-# Copyright (c) 2021 Dominic Msters
+find_package(Python3 REQUIRED COMPONENTS Interpreter)
-# 
-# This software is released under the MIT License.
-# https://opensource.org/licenses/MIT
 
-# Tool Function
 function(tool_texture target)
   # Defaults
   set(FILE "" )
@@ -31,9 +27,9 @@ function(tool_texture target)
     message(FATAL_ERROR "Missing FILE input")
   endif()
   
-  add_custom_target(${target}
+  add_custom_target(${target}_texture
     COMMAND ${DAWN_TOOLS_DIR}/texturetool/texturetool.py
-      --input="${FILE}"
+      --input="${DAWN_ASSETS_SOURCE_DIR}/${FILE}"
       --output="${DAWN_ASSETS_BUILD_DIR}/${target}.texture"
       --wrap-x="${WRAP_X}"
       --wrap-y="${WRAP_Y}"
@@ -46,5 +42,5 @@ function(tool_texture target)
       --crop-end-y="${CROP_END_Y}"
     COMMENT "Generating texture ${target} from ${FILE}"
   )
-  add_dependencies(dawnassets ${target})
+  add_dependencies(dawnassets ${target}_texture)
 endfunction()

tools/truetypetool/CMakeLists.txt

@@ -4,5 +4,5 @@
 # https://opensource.org/licenses/MIT
 
 function(tool_truetype target ttf)
-  tool_copy(${target} ${ttf} ${DAWN_ASSETS_BUILD_DIR}/${target}.ttf)
+  tool_copy(${target} ${ttf} ${target}.ttf)
 endfunction()