feat: add language

src/Cleaner.cpp

@@ -5,15 +5,15 @@
 #include <GMLIB/Server/PlayerAPI.h>
 #include <regex>
 
-GMLIB_JsonConfig*   Config   = nullptr;
+GMLIB::Files::JsonConfig* Config = nullptr;
-GMLIB_JsonLanguage* Language = nullptr;
+nlohmann::json            Language;
 
 using namespace ll::schedule;
 using namespace ll::chrono_literals;
 int item_despawn_time = 3000;
 
-//ServerTimeAsyncScheduler scheduler;
+// ServerTimeAsyncScheduler scheduler;
-bool                     auto_clean_triggerred = false;
+bool auto_clean_triggerred = false;
 
 namespace Cleaner {
 
@@ -133,47 +133,39 @@ int CountEntities() {
 void CleanTask(int time, int announce_time) {
     auto time_1 = std::chrono::seconds::duration(time);
     auto time_2 = std::chrono::seconds::duration(time - announce_time);
-    logger.info(Language->translate("cleaner.output.count1", {S(time_1.count())}));
+    logger.info(tr("cleaner.output.count1", {S(time_1.count())}));
-    //scheduler.add<DelayTask>(time_2, [announce_time] {
+    // scheduler.add<DelayTask>(time_2, [announce_time] {
-        logger.info(Language->translate("cleaner.output.count2", {S(announce_time)}));
+    logger.info(tr("cleaner.output.count2", {S(announce_time)}));
     //});
-    //scheduler.add<DelayTask>(time_1, [] {
+    // scheduler.add<DelayTask>(time_1, [] {
-        auto count = ExecuteClean();
+    auto count = ExecuteClean();
-        logger.info(Language->translate("cleaner.output.finish", {S(count)}));
+    logger.info(tr("cleaner.output.finish", {S(count)}));
-        auto_clean_triggerred = false;
+    auto_clean_triggerred = false;
     //});
 }
 
 void AutoCleanTask(int seconds) {
-    auto time      = std::chrono::seconds::duration(seconds);
+    auto time = std::chrono::seconds::duration(seconds);
-    //mAutoCleanTask = scheduler.add<RepeatTask>(time, [] {
+    // mAutoCleanTask = scheduler.add<RepeatTask>(time, [] {
-        CleanTask(Config->getValue<int>({"Basic", "Notice1"}, 20), Config->getValue<int>({"Basic", "Notice2"}, 15));
+    CleanTask(Config->getValue<int>({"Basic", "Notice1"}, 20), Config->getValue<int>({"Basic", "Notice2"}, 15));
     //});
 }
 
 void CheckCleanTask(int max_entities, float min_tps) {
-    //mCheckCleanTask = scheduler.add<RepeatTask>(10s, [max_entities, min_tps] {
+    // mCheckCleanTask = scheduler.add<RepeatTask>(10s, [max_entities, min_tps] {
-        auto count = CountEntities();
+    auto count = CountEntities();
-        if (auto_clean_triggerred == false) {
+    if (auto_clean_triggerred == false) {
-            if (count >= max_entities) {
+        if (count >= max_entities) {
-                auto_clean_triggerred = true;
+            auto_clean_triggerred = true;
-                logger.warn(Language->translate("cleaner.output.triggerAutoCleanCount", {S(count)}));
+            logger.warn(tr("cleaner.output.triggerAutoCleanCount", {S(count)}));
-                CleanTask(
+            CleanTask(Config->getValue<int>({"Basic", "Notice1"}, 20), Config->getValue<int>({"Basic", "Notice2"}, 15));
-                    Config->getValue<int>({"Basic", "Notice1"}, 20),
+        } else if (GMLIB_Level::getLevel()->getServerAverageTps() <= min_tps) {
-                    Config->getValue<int>({"Basic", "Notice2"}, 15)
+            auto_clean_triggerred = true;
-                );
+            logger.warn(tr("cleaner.output.triggerAutoCleanCount", {S(GMLIB_Level::getLevel()->getServerAverageTps())})
-            } else if (GMLIB_Level::getLevel()->getServerAverageTps() <= min_tps) {
+            );
-                auto_clean_triggerred = true;
+            CleanTask(Config->getValue<int>({"Basic", "Notice1"}, 20), Config->getValue<int>({"Basic", "Notice2"}, 15));
-                logger.warn(Language->translate(
-                    "cleaner.output.triggerAutoCleanCount",
-                    {S(GMLIB_Level::getLevel()->getServerAverageTps())}
-                ));
-                CleanTask(
-                    Config->getValue<int>({"Basic", "Notice1"}, 20),
-                    Config->getValue<int>({"Basic", "Notice2"}, 15)
-                );
-            }
         }
+    }
     //});
 }
 
@@ -216,10 +208,13 @@ void reloadCleaner() {
 }
 
 void loadConfig() {
-    Config = new GMLIB_JsonConfig("./plugins/Cleaner/config/config.json", defaultConfig);
+    Config = new GMLIB::Files::JsonConfig("./plugins/Cleaner/config/config.json", defaultConfig);
     Config->initConfig();
-    Language = new GMLIB_JsonLanguage("./plugins/Cleaner/config/language.json", defaultLanguage);
+    if (!std::filesystem::exists("./plugins/Cleaner/config/language.json")) {
-    Language->initConfig();
+        GMLIB::Files::JsonLanguage::writeFile("./plugins/Cleaner/config/language.json", nlohmann::json::parse(defaultLanguage));
+    }
+    GMLIB::Files::JsonLanguage::updateFile("./plugins/Cleaner/config/language.json", defaultLanguage);
+    Language = GMLIB::Files::JsonLanguage::readFromFile("./plugins/Cleaner/config/language.json");
 }
 
 void loadCleaner() {
@@ -242,7 +237,10 @@ void unloadCleaner() {
     mCheckCleanTask->cancel();
     // UnregisterCommands();
     delete Config;
-    delete Language;
 }
 
 } // namespace Cleaner
+
+std::string tr(std::string key, std::vector<std::string> data) {
+    return GMLIB::Files::JsonLanguage::translate(Language, key, data);
+}

src/Global.h

@@ -2,18 +2,17 @@
 #include "Config.h"
 #include "Plugin.h"
 #include "include_all.h"
-#include <GMLIB/Server/ActorAPI.h>
-#include <GMLIB/Server/LevelAPI.h>
 #include <GMLIB/Files/JsonConfig.h>
 #include <GMLIB/Files/JsonLanguage.h>
+#include <GMLIB/Server/ActorAPI.h>
+#include <GMLIB/Server/LevelAPI.h>
 #define S(x) std::to_string(x)
 
 extern ll::Logger logger;
 extern void       RegisterCommands();
 extern void       UnregisterCommands();
 
-extern GMLIB_JsonConfig* Config;
+extern GMLIB::Files::JsonConfig* Config;
-extern GMLIB_JsonLanguage* Language; 
 
 extern int item_despawn_time;
 
@@ -21,6 +20,7 @@ namespace Cleaner {
 
 static std::shared_ptr<ll::schedule::task::Task<ll::chrono::ServerClock>> mAutoCleanTask;
 static std::shared_ptr<ll::schedule::task::Task<ll::chrono::ServerClock>> mCheckCleanTask;
+
 extern void loadConfig();
 extern void loadCleaner();
 extern void unloadCleaner();
@@ -28,3 +28,5 @@ extern void reloadCleaner();
 extern void CleanTask(int time, int announce_time);
 
 } // namespace Cleaner
+
+extern std::string tr(std::string key, std::vector<std::string> data = {});

src/RegisterCommand.cpp

@@ -18,7 +18,7 @@ void RegCleanerCommand(CommandRegistry& registry) {
     auto command = DynamicCommand::createCommand(
         registry,
         Config->getValue<std::string>({"Basic", "Command"}, "cleaner"),
-        Language->translate("cleaner.command.cleaner"),
+        tr("cleaner.command.cleaner"),
         CommandPermissionLevel::GameDirectors
     );
     command->setEnum("Despawn", {"despawn"});
@@ -40,37 +40,35 @@ void RegCleanerCommand(CommandRegistry& registry) {
         if (result["despawn"].isSet && result["target"].isSet) {
             auto ens = result["target"].get<std::vector<Actor*>>();
             if (ens.size() == 0) {
-                return output.error(Language->translate("cleaner.command.error.noTarget"));
+                return output.error(tr("cleaner.command.error.noTarget"));
             }
             for (auto en : ens) {
                 en->despawn();
             }
-            return output.success(Language->translate("cleaner.command.despawnSuccess", {S(ens.size())}));
+            return output.success(tr("cleaner.command.despawnSuccess", {S(ens.size())}));
         } else if (result["action"].isSet) {
             auto act = result["action"].get<std::string>();
             if (act == "tps") {
-                return output.success(Language->translate(
-                    "cleaner.command.tps.output",
-                    {S(GMLIB_Level::getLevel()->getServerCurrentTps()),
-                     S(GMLIB_Level::getLevel()->getServerAverageTps())}
-                ));
-            } else if (act == "mspt") {
                 return output.success(
-                    Language->translate("cleaner.command.mspt.output", {S(GMLIB_Level::getLevel()->getServerMspt())})
+                    tr("cleaner.command.tps.output",
+                       {S(GMLIB_Level::getLevel()->getServerCurrentTps()),
+                        S(GMLIB_Level::getLevel()->getServerAverageTps())})
                 );
+            } else if (act == "mspt") {
+                return output.success(tr("cleaner.command.mspt.output", {S(GMLIB_Level::getLevel()->getServerMspt())}));
             } else if (act == "clean") {
                 Cleaner::CleanTask(
                     Config->getValue<int>({"Basic", "Notice1"}, 20),
                     Config->getValue<int>({"Basic", "Notice2"}, 15)
                 );
-                return output.success(Language->translate("cleaner.output.opClean"));
+                return output.success(tr("cleaner.output.opClean"));
             } else if (act == "reload") {
                 Cleaner::reloadCleaner();
-                return output.success(Language->translate("cleaner.output.reload"));
+                return output.success(tr("cleaner.output.reload"));
             }
         } else if (result["despawntime"].isSet && result["ticks"].isSet) {
             item_despawn_time = result["ticks"].get<int>();
-            return output.success(Language->translate("cleaner.command.despawntime", {S(item_despawn_time)}));
+            return output.success(tr("cleaner.command.despawntime", {S(item_despawn_time)}));
         }
     });
     DynamicCommand::setup(registry, std::move(command));
@@ -78,12 +76,12 @@ void RegCleanerCommand(CommandRegistry& registry) {
 
 void RegisterCommands() {
     auto registry = ll::service::bedrock::getCommandRegistry();
-    // RegCleanerCommand(registry);
+    RegCleanerCommand(registry);
     // RegVoteCommand(registry);
 }
 
 void UnregisterCommands() {
-    // auto registry = ll::service::bedrock::getCommandRegistry();
+    auto registry = ll::service::bedrock::getCommandRegistry();
-    // registry->unregisterCommand(Config->getValue<std::string>({"Basic", "Command"}, "cleaner"));
+    registry->unregisterCommand(Config->getValue<std::string>({"Basic", "Command"}, "cleaner"));
     //  registry->unregisterCommand("voteclean");
 }