Adding language

assets/en.json

@@ -0,0 +1,7 @@
+{
+  "general": {
+    "test": {
+      "test": "test"
+    }
+  }
+}

src/dawn/CMakeLists.txt

@@ -22,6 +22,7 @@ add_subdirectory(display)
 add_subdirectory(game)
 add_subdirectory(rpg)
 add_subdirectory(ui)
+add_subdirectory(locale)
 
 # Sources
 target_sources(${DAWN_TARGET_NAME}
@@ -31,5 +32,6 @@ target_sources(${DAWN_TARGET_NAME}
 
 # Assets
 tool_copy(testmap testmap.json)
+tool_copy(en en.json)
 
 add_dependencies(${DAWN_TARGET_NAME} dawnassets)

src/dawn/asset/CMakeLists.txt

@@ -10,4 +10,5 @@ target_sources(${DAWN_TARGET_NAME}
     assetarchive.c
     assetjson.c
     assetmap.c
+    assetlanguage.c
 )

src/dawn/asset/assetlanguage.c

@@ -0,0 +1,68 @@
+/**
+ * Copyright (c) 2024 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "assetlanguage.h"
+#include "asset/asset.h"
+#include "assert/assert.h"
+#include "locale/language.h"
+
+void assetLanguageObjectLoad(
+  const char_t *key,
+  assetjson_t *json
+) {
+  char_t tKey[LANGUAGE_STRING_KEY_LENGTH_MAX];
+  size_t keyLength = strlen(key);
+  strcpy(tKey, key);
+  if(keyLength > 0) {
+    tKey[keyLength] = '.';
+    keyLength++;
+  }
+
+  for(int32_t i = 0; i < json->object.length; i++) {
+    const char_t *subKey = json->object.keys[i];
+    assetjson_t *value = json->object.values[i];
+    strcpy(tKey + keyLength, subKey);
+
+    if(json->object.values[i]->type == ASSET_JSON_DATA_TYPE_OBJECT) {
+      assetLanguageObjectLoad(tKey, value);
+      continue;
+    }
+
+    if(json->object.values[i]->type == ASSET_JSON_DATA_TYPE_STRING) {
+      strcpy(LANGUAGE.keys[LANGUAGE.count], tKey);
+      strcpy(LANGUAGE.strings[LANGUAGE.count], value->string);
+      LANGUAGE.count++;
+      continue;
+    }
+
+    assertUnreachable("Language value is not a string or object!");
+  }
+}
+
+void assetLanguageLoad(const char_t *path) {
+  assertNotNull(path, "Path cannot be NULL.");
+
+  assetOpen(path);
+  size_t length = assetGetSize();
+  char_t *buffer = malloc(sizeof(char_t) * (length + 1));
+  buffer[length] = '\0';
+  size_t read = assetRead((uint8_t*)buffer, length);
+  assertTrue(read == length, "Failed to read language file!");
+  assetClose();
+
+  assetjson_t *json;
+  read = assetJsonParse(buffer, &json);
+  free(buffer);
+
+  assertTrue(
+    json->type == ASSET_JSON_DATA_TYPE_OBJECT,
+    "Language file is not an object!"
+  );
+
+  languageInit();
+  assetLanguageObjectLoad("", json);
+}

src/dawn/asset/assetlanguage.h

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) 2024 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "asset/assetjson.h"
+
+/**
+ * Loads a JSON object from the asset file.
+ * 
+ * @param key The key to load.
+ * @param json The value to load into.
+ */
+void assetLanguageObjectLoad(
+  const char_t *key,
+  assetjson_t *json
+);
+
+/**
+ * Loads the language file from the specified path.
+ * 
+ * @param path Path to the language file.
+ */
+void assetLanguageLoad(const char_t *path);

src/dawn/display/animation/animation.h

@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2024 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "animationitem.h"
+
+#define ANIMATION_ITEM_COUNT_MAX 64
+
+typedef struct _animation_t {
+  float_t time;
+  bool_t loop;
+
+  float_t duration;
+  animationitem_t items[ANIMATION_ITEM_COUNT_MAX];
+  uint8_t itemCount;
+} animation_t;
+
+/**
+ * Initializes an animation.
+ * @param anim The animation to initialize.
+ */
+void animationInit(animation_t *anim);
+
+/**
+ * Updates an animation.
+ * @param anim The animation to update.
+ * @param delta The time since the last update.
+ */
+void animationUpdate(animation_t *anim, const float_t delta);
+
+/**
+ * Returns the total duration of the animation.
+ * 
+ * @param anim The animation to get the duration of.
+ * @return The total duration of the animation.
+ */
+float_t animationDurationGet(const animation_t *anim);

src/dawn/display/animation/animationitem.h

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2024 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "dawn.h"
+
+typedef struct _animation_t animation_t;
+
+typedef struct _animationitem_t {
+  float_t time;
+  float_t duration;
+  void *user;
+
+  void (*start)(animation_t *anim, animationitem_t *item);
+  void (*update)(animation_t *anim,animationitem_t *item,const float_t rDelta);
+} animationitem_t;

src/dawn/game/game.c

@@ -19,6 +19,11 @@
 #include "game/state/mapchange.h"
 #include "game/state/overworld.h"
 
+#include "rpg/conversation/conversation.h"
+#include "rpg/conversation/testconversation.h"
+#include "asset/assetlanguage.h"
+#include "locale/language.h"
+
 game_t GAME;
 
 void gameInit() {
@@ -33,6 +38,19 @@ void gameInit() {
   testMenuInit();
   mainMenuInit();
 
+  assetLanguageLoad("en.json");
+
+  char_t buffer[LANGUAGE_STRING_LENGTH_MAX];
+  languageGet(buffer, "general.test.test");
+
+  conversation_t conversation;
+  conversationInit(
+    &conversation,
+    conversationTestInit,
+    conversationTestUpdate
+  );
+  conversationUpdate(&conversation);
+
   GAME.state = GAME_STATE_INITIAL;
 }
 

src/dawn/locale/CMakeLists.txt

@@ -0,0 +1,12 @@
+# Copyright (c) 2024 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Subdirs
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    language.c
+)

src/dawn/locale/language.c

@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2024 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "language.h"
+#include "assert/assert.h"
+
+language_t LANGUAGE;
+
+void languageInit() {
+  memset(&LANGUAGE, 0, sizeof(language_t));
+}
+
+int32_t languageGet(
+  char_t *buffer,
+  const char_t *key,
+  ...
+) {
+  assertNotNull(key, "Key cannot be NULL.");
+
+  int32_t i;
+  while(i < LANGUAGE.count) {
+    if(strcmp(key, LANGUAGE.keys[i]) != 0) {
+      i++;
+      continue;
+    }
+
+    if(buffer != NULL) strcpy(buffer, LANGUAGE.strings[i]);
+    return strlen(LANGUAGE.strings[i]);
+  }
+
+  return -1;
+}

src/dawn/locale/language.h

@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) 2024 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "dawn.h"
+
+#define LANGUAGE_STRING_COUNT_MAX 128
+#define LANGUAGE_STRING_KEY_LENGTH_MAX 64
+#define LANGUAGE_STRING_LENGTH_MAX 1024
+
+typedef struct {
+  const char_t keys[LANGUAGE_STRING_COUNT_MAX][LANGUAGE_STRING_KEY_LENGTH_MAX];
+  const char_t strings[LANGUAGE_STRING_COUNT_MAX][LANGUAGE_STRING_LENGTH_MAX];
+  int32_t count;
+} language_t;
+
+extern language_t LANGUAGE;
+
+/**
+ * Initializes the language system.
+ */
+void languageInit();
+
+/**
+ * Returns the language string for the given key.
+ * 
+ * @param buffer The buffer to write the string to, or NULL to get length.
+ * @param key The key to get the string for.
+ * @param ... The arguments to replace in the string.
+ * @return The length of the string.
+ */
+int32_t languageGet(
+  char_t *buffer,
+  const char_t *key,
+  ...
+);

src/dawn/rpg/CMakeLists.txt

@@ -4,6 +4,7 @@
 # https://opensource.org/licenses/MIT
 
 # Subdirs
+add_subdirectory(conversation)
 add_subdirectory(entity)
 add_subdirectory(world)
 

src/dawn/rpg/conversation/CMakeLists.txt

@@ -0,0 +1,13 @@
+# Copyright (c) 2024 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Subdirs
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    conversation.c
+    testconversation.c
+)

src/dawn/rpg/conversation/conversation.c

@@ -0,0 +1,74 @@
+/**
+ * Copyright (c) 2024 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "conversation.h"
+#include "assert/assert.h"
+
+void conversationInit(
+  conversation_t *conversation,
+  const conversationcallback_t init,
+  const conversationcallback_t update
+) {
+  assertNotNull(conversation, "Conversation is NULL.");
+
+  memset(conversation, 0, sizeof(conversation_t));
+  conversation->init = init;
+  conversation->update = update;
+  conversation->index = CONVERSATION_NOT_INITIALIZED;
+}
+
+void conversationUpdate(conversation_t *conversation) {
+  uint16_t ret;
+
+  assertNotNull(conversation, "Conversation is NULL.");
+
+  // Init or update.
+  switch(conversation->index) {
+    case CONVERSATION_NOT_INITIALIZED:
+      conversation->index = 0;
+      ret = conversation->init(
+        conversation, conversation->index
+      );
+      break;
+    
+    default:
+      ret = conversation->update(conversation, conversation->index);
+      break;
+  }
+
+  // Check ret value and update conversation.
+  switch(ret) {
+    case CONVERSATION_NEXT:
+      conversation->index++;
+      conversation->index = conversation->init(
+        conversation, conversation->index
+      );
+      break;
+    
+    case CONVERSATION_CONTINUE:
+      return;
+    
+    case CONVERSATION_RESTART:
+      conversation->index = 0;
+      conversation->init(conversation, conversation->index);
+      break;
+    
+    case CONVERSATION_INVALID:
+      assertUnreachable("Invalid converstaion retval");
+      break;
+
+    case CONVERSATION_DONE:
+      break;
+    
+    default:
+      conversation->index = ret;
+      conversation->index = conversation->init(
+        conversation, conversation->index
+      );
+      break;
+  }
+}

src/dawn/rpg/conversation/conversation.h

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2024 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "dawn.h"
+
+#define CONVERSATION_NEXT ((uint16_t)-1)
+#define CONVERSATION_CONTINUE ((uint16_t)-2)
+#define CONVERSATION_NOT_INITIALIZED ((uint16_t)-3)
+#define CONVERSATION_RESTART CONVERSATION_NOT_INITIALIZED
+#define CONVERSATION_DONE ((uint16_t)-4)
+#define CONVERSATION_INVALID ((uint16_t)-5)
+
+typedef struct _conversation_t conversation_t;
+
+typedef uint16_t (*conversationcallback_t) (
+  conversation_t *convo, const uint16_t
+);
+
+typedef struct _conversation_t {
+  uint16_t index;
+  conversationcallback_t init;
+  conversationcallback_t update;
+  void *user;
+} conversation_t;
+
+/**
+ * Initializes a conversation object.
+ * 
+ * @param conversation Conversation to initialize.
+ * @param update Function to handle conversation updates.
+ */
+void conversationInit(
+  conversation_t *conversation,
+  const conversationcallback_t init,
+  const conversationcallback_t update
+);
+
+/**
+ * Update a given conversation.
+ * 
+ * @param conversastion Conversation to update.
+ */
+void conversationUpdate(conversation_t *conversation);

src/dawn/rpg/conversation/testconversation.c

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2024 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "testconversation.h"
+
+uint16_t conversationTestInit(conversation_t *convo, const uint16_t i) {
+  switch(i) {
+    case 0:
+      printf("Test conversation start\n");
+      return CONVERSATION_CONTINUE;
+
+    default:
+      return CONVERSATION_INVALID;
+  }
+}
+
+uint16_t conversationTestUpdate(conversation_t *convo, const uint16_t i) {
+  switch(i) {
+    case 0:
+      printf("Conversation update\n");
+      return CONVERSATION_DONE;
+    
+    default:
+      return CONVERSATION_INVALID;
+  }
+}

src/dawn/rpg/conversation/testconversation.h

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) 2024 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+
+#include "conversation.h"
+
+uint16_t conversationTestInit(conversation_t *convo, const uint16_t i);
+uint16_t conversationTestUpdate(conversation_t *convo, const uint16_t i);