adapt: adapt LeviLamina v0.12.1

manifest.json

@@ -2,7 +2,7 @@
     "name": "${pluginName}",
     "entry": "${pluginFile}",
     "type": "native",
-    "version": "0.11.0",
+    "version": "0.12.0",
     "author": "GroupMountain",
     "description": "Clean Entities",
     "dependencies": [

src/Config.h

@@ -1,38 +1,40 @@
 #pragma once
-#include "Global.h"
+#include <iostream>
+#include <vector>
 
-std::string defaultConfig = R"({
+struct Config {
-    "Basic": {
+    int version = 1;
-        "Language": "en_US",
+
-        "Command": "cleaner",
+    struct basic {
-        "Notice1": 20,
+        std::string Command       = "cleaner";
-        "Notice2": 5,
+        int         Notice1       = 20;
-        "ConsoleLog": true,
+        int         Notice2       = 5;
-        "SendBroadcast": true,
+        bool        ConsoleLog    = true;
-        "SendToast": true
+        bool        SendBroadcast = true;
-    },
+        bool        SendToast     = true;
-    "IgnoreTags": [
+    } Basic;
-        "ignore",
+
-        "不清理"
+    std::vector<std::string> IgnoreTags = {"ignore", "不清理"};
-    ],
+
-    "AutoCleanCount": {
+    struct auto_clean_count {
-        "Enabled": true,
+        bool Enabled      = true;
-        "TriggerCount": 900
+        int  TriggerCount = 900;
-    },
+    } AutoCleanCount;
-    "AutoCleanTPS": {
+
-        "Enabled": false,
+    struct auto_clean_tps {
-        "TriggerTPS": 15
+        bool Enabled    = true;
-    },
+        int  TriggerTPS = 15;
-    "ItemDespawn": {
+    } AutoCleanTPS;
-        "Enabled": true,
+
-        "DespawnTime": 6000,
+    struct item_despawn {
-        "WhiteList": [
+        bool                     Enabled     = true;
-            "minecraft:elytra"
+        int                      DespawnTime = 6000;
-        ]
+        std::vector<std::string> WhiteList   = {"minecraft:elytra"};
-    },
+    } ItemDespawn;
-    "CleanInanimate": {
+
-        "Enabled": true,
+    struct Clean_Inanimate {
-        "Blacklist": [
+        bool                     Enabled   = true;
+        std::vector<std::string> Blacklist = {
             "minecraft:xp_orb",
             "minecraft:arrow",
             "minecraft:fireball",
@@ -40,45 +42,30 @@ std::string defaultConfig = R"({
             "minecraft:wither_skull",
             "minecraft:wither_skull_dangerous",
             "minecraft:dragon_fireball"
-        ]
+        };
-    },
+    } CleanInanimate;
-    "CleanItem": {
+
-        "Enabled": true,
+    struct Clean_Item {
-        "ExistTicks": 0,
+        bool                     Enabled    = true;
-        "Whitelist": [
+        int                      ExistTicks = 0;
-            "minecraft:netherite_helmet",
+        std::vector<std::string> Whitelist  = {
-            "minecraft:netherite_sword",
+            "minecraft:netherite_helmet",   "minecraft:netherite_sword",    "minecraft:netherite_chestplate",
-            "minecraft:netherite_chestplate",
+            "minecraft:diamond_helmet",     "minecraft:netherite_leggings", "minecraft:undyed_shulker_box",
-            "minecraft:diamond_helmet",
+            "minecraft:netherite_boots",    "minecraft:shulker_box",        "minecraft:elytra",
-            "minecraft:netherite_leggings",
+            "minecraft:dragon_egg",         "minecraft:nether_star",        "minecraft:diamond_sword",
-            "minecraft:undyed_shulker_box",
+            "minecraft:diamond_chestplate", "minecraft:diamond_boots",      "minecraft:diamond_leggings",
-            "minecraft:netherite_boots",
+            "minecraft:diamond_hoe",        "minecraft:netherite_hoe",      "minecraft:diamond_axe",
-            "minecraft:shulker_box",
+            "minecraft:netherite_axe",      "minecraft:netherite_pickaxe",  "minecraft:diamond_pickaxe"
-            "minecraft:elytra",
+        };
-            "minecraft:dragon_egg",
+    } CleanItem;
-            "minecraft:nether_star",
+
-            "minecraft:diamond_sword",
+    struct Clean_Mobs {
-            "minecraft:diamond_chestplate",
+        bool                     Enabled           = true;
-            "minecraft:diamond_boots",
+        bool                     CleanMonstors     = true;
-            "minecraft:diamond_leggings",
+        bool                     CleanPeacefulMobs = false;
-            "minecraft:diamond_hoe",
+        bool                     EnableAutoExclude = true;
-            "minecraft:netherite_hoe",
+        std::vector<std::string> BlackList         = {"minecraft:guardian", "minecraft:zombie_pigman"};
-            "minecraft:diamond_axe",
+        std::vector<std::string> Whitelist         = {
-            "minecraft:netherite_axe",
-            "minecraft:netherite_pickaxe",
-            "minecraft:diamond_pickaxe"
-        ]
-    },
-    "CleanMobs": {
-        "Enabled": true,
-        "CleanMonstors": true,
-        "CleanPeacefulMobs": false,
-        "EnableAutoExclude": true,
-        "BlackList": [
-            "minecraft:guardian",
-            "minecraft:zombie_pigman"
-        ],
-        "Whitelist": [
             "minecraft:ender_dragon",
             "minecraft:shulker",
             "minecraft:wither",
@@ -86,17 +73,19 @@ std::string defaultConfig = R"({
             "minecraft:piglin_brute",
             "minecraft:ender_pearl",
             "minecraft:phantom"
-        ]
+        };
-    },
+    } CleanMobs;
-    "ScheduleClean": {
+
-        "Enabled": true,
+    struct Schedule_Clean {
-        "CleanInterval": 3600
+        bool Enabled       = true;
-    },    
+        int  CleanInterval = 3600;
-    "VoteClean": {
+    } ScheduleClean;
-        "Enabled": true,
+
-        "VoteCleanCommand": "voteclean",
+    struct Vote_Clean {
-        "Cooldown": 120,
+        bool        Enabled          = true;
-        "CheckDelay": 30,
+        std::string VoteCleanCommand = "voteclean";
-        "Percentage": 50   
+        int         Cooldown         = 120;
-    }
+        int         CheckDelay       = 30;
-})";
+        int         Percentage       = 50;
+    } VoteClean;
+};

src/Features/Clean.cpp

@@ -26,25 +26,26 @@ bool shouldIgnore(GMLIB_Actor* ac) {
 
 bool ShouldClean(Actor* actor) {
     // Players
-    auto en = (GMLIB_Actor*)actor;
+    auto& config = Cleaner::Entry::getInstance().getConfig();
+    auto  en     = (GMLIB_Actor*)actor;
     if (en->isPlayer() || shouldIgnore(en)) {
         return false;
     }
     auto type = en->getTypeName();
-    for (auto& tag : ConfigFile::mIgnoreTags) {
+    for (auto& tag : config.IgnoreTags) {
         if (en->hasTag(tag)) {
             return false;
         }
     }
     // Items
     if (en->isItemActor()) {
-        if (Config->getValue<bool>({"CleanItem", "Enabled"}, false)) {
+        if (config.CleanItem.Enabled) {
             auto itac = (ItemActor*)en;
-            if (itac->age() <= Config->getValue<int>({"CleanItem", "ExistTicks"}, 0)) {
+            if (itac->age() <= config.CleanItem.ExistTicks) {
                 return false;
             }
             auto itemType  = itac->item().getTypeName();
-            auto whitelist = Config->getValue<std::vector<std::string>>({"CleanItem", "Whitelist"}, {});
+            auto whitelist = config.CleanItem.Whitelist;
             for (auto& key : whitelist) {
                 if (isMatch(itemType, key)) {
                     return false;
@@ -56,24 +57,23 @@ bool ShouldClean(Actor* actor) {
     }
     // Mobs
     else if (en->isMob()) {
-        if (Config->getValue<bool>({"CleanMobs", "Enabled"}, false)) {
+        if (config.CleanMobs.Enabled) {
-            auto blacklist = Config->getValue<std::vector<std::string>>({"CleanMobs", "BlackList"}, {});
+            auto blacklist = config.CleanMobs.BlackList;
             for (auto& key : blacklist) {
                 if (isMatch(type, key)) {
                     return true;
                 }
             }
-            auto whitelist = Config->getValue<std::vector<std::string>>({"CleanMobs", "Whitelist"}, {});
+            auto whitelist = config.CleanMobs.Whitelist;
             for (auto& key : whitelist) {
                 if (isMatch(type, key)) {
                     return false;
                 }
             }
-            if (Config->getValue<bool>({"CleanMobs", "CleanMonstors"}, false)
+            if (config.CleanMobs.CleanMonstors && en->hasCategory(ActorCategory::Monster)) {
-                && en->hasCategory(ActorCategory::Monster)) {
                 return true;
             }
-            if (Config->getValue<bool>({"CleanMobs", "CleanPeacefulMobs"}, false)) {
+            if (config.CleanMobs.CleanPeacefulMobs) {
                 return true;
             }
         }
@@ -81,8 +81,8 @@ bool ShouldClean(Actor* actor) {
     }
     // Others
     else {
-        if (Config->getValue<bool>({"CleanInanimate", "Enabled"}, false)) {
+        if (config.CleanInanimate.Enabled) {
-            auto blacklist = Config->getValue<std::vector<std::string>>({"CleanInanimate", "Blacklist"}, {});
+            auto blacklist = config.CleanInanimate.Blacklist;
             for (auto& key : blacklist) {
                 if (isMatch(type, key)) {
                     return true;

src/Features/CleanTask.cpp

@@ -1,60 +1,49 @@
 #include "Cleaner.h"
 
-namespace ConfigFile {
-
-bool                     mConsoleLog = true;
-bool                     mAnnounce   = true;
-bool                     mSendToast  = true;
-std::vector<std::string> mIgnoreTags = {};
-
-} // namespace ConfigFile
-
-
 namespace Cleaner {
 
 static std::shared_ptr<ll::schedule::task::Task<ll::chrono::ServerClock>> mAutoCleanTask  = nullptr;
 static std::shared_ptr<ll::schedule::task::Task<ll::chrono::ServerClock>> mCleanTaskCount = nullptr;
 static std::shared_ptr<ll::schedule::task::Task<ll::chrono::ServerClock>> mCleanTaskTPS   = nullptr;
 
-ServerTimeScheduler scheduler;
-
 bool auto_clean_triggerred = false;
 
 void CleanTask() {
-    auto time          = Config->getValue<int>({"Basic", "Notice1"}, 20);
+    auto& config        = Cleaner::Entry::getInstance().getConfig();
-    auto announce_time = Config->getValue<int>({"Basic", "Notice2"}, 5);
+    auto  time          = config.Basic.Notice1;
-    auto time_1        = std::chrono::seconds::duration(time);
+    auto  announce_time = config.Basic.Notice2;
-    auto time_2        = std::chrono::seconds::duration(time - announce_time);
+    auto  time_1        = std::chrono::seconds::duration(time);
-    if (ConfigFile::mConsoleLog) {
+    auto  time_2        = std::chrono::seconds::duration(time - announce_time);
-        logger.info(tr("cleaner.output.count1", {S(time_1.count())}));
+    if (config.Basic.ConsoleLog) {
+        logger.info(I18nAPI::get("cleaner.output.count1", {S(time_1.count())}));
     }
-    if (ConfigFile::mAnnounce) {
+    if (config.Basic.SendBroadcast) {
-        Helper::broadcastMessage(tr("cleaner.output.count1", {S(time_1.count())}));
+        Helper::broadcastMessage(I18nAPI::get("cleaner.output.count1", {S(time_1.count())}));
     }
-    if (ConfigFile::mSendToast) {
+    if (config.Basic.SendToast) {
-        Helper::broadcastToast(tr("cleaner.output.count2", {S(announce_time)}));
+        Helper::broadcastToast(I18nAPI::get("cleaner.output.count2", {S(announce_time)}));
     }
-    scheduler.add<DelayTask>(time_2, [announce_time] {
+    Cleaner::Entry::getInstance().getScheduler().add<DelayTask>(time_2, [announce_time, &config] {
-        if (ConfigFile::mConsoleLog) {
+        if (config.Basic.ConsoleLog) {
-            logger.info(tr("cleaner.output.count2", {S(announce_time)}));
+            logger.info(I18nAPI::get("cleaner.output.count2", {S(announce_time)}));
         }
-        if (ConfigFile::mAnnounce) {
+        if (config.Basic.SendBroadcast) {
-            Helper::broadcastMessage(tr("cleaner.output.count2", {S(announce_time)}));
+            Helper::broadcastMessage(I18nAPI::get("cleaner.output.count2", {S(announce_time)}));
         }
-        if (ConfigFile::mSendToast) {
+        if (config.Basic.SendToast) {
-            Helper::broadcastToast(tr("cleaner.output.count2", {S(announce_time)}));
+            Helper::broadcastToast(I18nAPI::get("cleaner.output.count2", {S(announce_time)}));
         }
     });
-    scheduler.add<DelayTask>(time_1, [] {
+    Cleaner::Entry::getInstance().getScheduler().add<DelayTask>(time_1, [&config] {
         auto count = ExecuteClean();
-        if (ConfigFile::mConsoleLog) {
+        if (config.Basic.ConsoleLog) {
-            logger.info(tr("cleaner.output.finish", {S(count)}));
+            logger.info(I18nAPI::get("cleaner.output.finish", {S(count)}));
         }
-        if (ConfigFile::mAnnounce) {
+        if (config.Basic.SendBroadcast) {
-            Helper::broadcastMessage(tr("cleaner.output.finish", {S(count)}));
+            Helper::broadcastMessage(I18nAPI::get("cleaner.output.finish", {S(count)}));
         }
-        if (ConfigFile::mSendToast) {
+        if (config.Basic.SendToast) {
-            Helper::broadcastToast(tr("cleaner.output.finish", {S(count)}));
+            Helper::broadcastToast(I18nAPI::get("cleaner.output.finish", {S(count)}));
         }
         auto_clean_triggerred = false;
     });
@@ -62,23 +51,24 @@ void CleanTask() {
 
 void AutoCleanTask(int seconds) {
     auto time      = std::chrono::seconds::duration(seconds);
-    mAutoCleanTask = scheduler.add<RepeatTask>(time, [] { CleanTask(); });
+    mAutoCleanTask = Cleaner::Entry::getInstance().getScheduler().add<RepeatTask>(time, [] { CleanTask(); });
 }
 
 void CleanTaskCount(int max_entities) {
-    mCleanTaskCount = scheduler.add<RepeatTask>(10s, [max_entities] {
+    auto& config    = Cleaner::Entry::getInstance().getConfig();
+    mCleanTaskCount = Cleaner::Entry::getInstance().getScheduler().add<RepeatTask>(10s, [max_entities, &config] {
         auto count = CountEntities();
         if (auto_clean_triggerred == false) {
             if (count >= max_entities) {
                 auto_clean_triggerred = true;
-                if (ConfigFile::mConsoleLog) {
+                if (config.Basic.ConsoleLog) {
-                    logger.warn(tr("cleaner.output.triggerAutoCleanCount", {S(count)}));
+                    logger.warn(I18nAPI::get("cleaner.output.triggerAutoCleanCount", {S(count)}));
                 }
-                if (ConfigFile::mAnnounce) {
+                if (config.Basic.SendBroadcast) {
-                    Helper::broadcastMessage(tr("cleaner.output.triggerAutoCleanCount", {S(count)}));
+                    Helper::broadcastMessage(I18nAPI::get("cleaner.output.triggerAutoCleanCount", {S(count)}));
                 }
-                if (ConfigFile::mSendToast) {
+                if (config.Basic.SendToast) {
-                    Helper::broadcastToast(tr("cleaner.output.triggerAutoCleanCount", {S(count)}));
+                    Helper::broadcastToast(I18nAPI::get("cleaner.output.triggerAutoCleanCount", {S(count)}));
                 }
                 CleanTask();
             }
@@ -87,19 +77,20 @@ void CleanTaskCount(int max_entities) {
 }
 
 void CleanTaskTPS(float min_tps) {
-    mCleanTaskTPS = scheduler.add<RepeatTask>(10s, [min_tps] {
+    auto& config  = Cleaner::Entry::getInstance().getConfig();
+    mCleanTaskTPS = Cleaner::Entry::getInstance().getScheduler().add<RepeatTask>(10s, [min_tps, &config] {
         if (auto_clean_triggerred == false) {
             if (GMLIB_Level::getLevel()->getServerAverageTps() <= min_tps) {
                 auto_clean_triggerred = true;
                 auto mspt             = S(GMLIB_Level::getLevel()->getServerAverageTps());
-                if (ConfigFile::mConsoleLog) {
+                if (config.Basic.ConsoleLog) {
-                    logger.warn(tr("cleaner.output.triggerAutoCleanTps", {mspt}));
+                    logger.warn(I18nAPI::get("cleaner.output.triggerAutoCleanTps", {mspt}));
                 }
-                if (ConfigFile::mAnnounce) {
+                if (config.Basic.SendBroadcast) {
-                    Helper::broadcastMessage(tr("cleaner.output.triggerAutoCleanTps", {mspt}));
+                    Helper::broadcastMessage(I18nAPI::get("cleaner.output.triggerAutoCleanTps", {mspt}));
                 }
-                if (ConfigFile::mSendToast) {
+                if (config.Basic.SendToast) {
-                    Helper::broadcastToast(tr("cleaner.output.triggerAutoCleanTps", {mspt}));
+                    Helper::broadcastToast(I18nAPI::get("cleaner.output.triggerAutoCleanTps", {mspt}));
                 }
                 CleanTask();
             }
@@ -110,15 +101,15 @@ void CleanTaskTPS(float min_tps) {
 void stopAllTasks() {
     if (!mCleanTaskCount) {
         mCleanTaskTPS->cancel();
-        scheduler.remove(mCleanTaskTPS);
+        Cleaner::Entry::getInstance().getScheduler().remove(mCleanTaskTPS);
     }
     if (mCleanTaskCount) {
         mCleanTaskCount->cancel();
-        scheduler.remove(mCleanTaskCount);
+        Cleaner::Entry::getInstance().getScheduler().remove(mCleanTaskCount);
     }
     if (mAutoCleanTask) {
         mAutoCleanTask->cancel();
-        scheduler.remove(mAutoCleanTask);
+        Cleaner::Entry::getInstance().getScheduler().remove(mAutoCleanTask);
     }
 }
 } // namespace Cleaner

src/Features/Cleaner.cpp

@@ -3,31 +3,23 @@
 namespace Cleaner {
 
 void loadCleaner() {
-    if (Config->getValue<bool>({"ScheduleClean", "Enabled"}, false)) {
+    auto& config = Cleaner::Entry::getInstance().getConfig();
-        Cleaner::AutoCleanTask(Config->getValue<int>({"ScheduleClean", "CleanInterval"}, 3000));
+    if (config.ScheduleClean.Enabled) {
+        Cleaner::AutoCleanTask(config.ScheduleClean.CleanInterval);
     }
-    if (Config->getValue<bool>({"AutoCleanCount", "Enabled"}, false)) {
+    if (config.AutoCleanCount.Enabled) {
-        Cleaner::CleanTaskCount(Config->getValue<int>({"AutoCleanCount", "TriggerCount"}, 900));
+        Cleaner::CleanTaskCount(config.AutoCleanCount.TriggerCount);
     }
-    if (Config->getValue<bool>({"AutoCleanTPS", "Enabled"}, false)) {
+    if (config.AutoCleanTPS.Enabled) {
-        Cleaner::CleanTaskTPS(Config->getValue<float>({"AutoCleanTPS", "TriggerTPS"}, 15.0f));
+        Cleaner::CleanTaskTPS(config.AutoCleanTPS.TriggerTPS);
     }
-    ConfigFile::mItemDespawnTicks = Config->getValue<int>({"ItemDespawn", "DespawnTime"}, 6000);
-    ConfigFile::mAnnounce         = Config->getValue<bool>({"Basic", "SendBroadcast"}, true);
-    ConfigFile::mConsoleLog       = Config->getValue<bool>({"Basic", "ConsoleLog"}, true);
-    ConfigFile::mSendToast        = Config->getValue<bool>({"Basic", "SendToast"}, true);
-    ConfigFile::mIgnoreTags       = Config->getValue<std::vector<std::string>>({"IgnoreTags"}, {});
 }
 
 void unloadCleaner() { stopAllTasks(); }
 
 void reloadCleaner() {
-    unloadCleaner();
+    Cleaner::Entry::getInstance().disable();
-    Config->reload();
+    Cleaner::Entry::getInstance().enable();
-    std::string languageCode = Config->getValue<std::string>({"Basic", "Language"}, "en_US");
-    Language->reloadAllLanguages();
-    Language->chooseLanguage(languageCode);
-    loadCleaner();
 }
 
 } // namespace Cleaner

src/Features/Cleaner.h

@@ -6,8 +6,6 @@ using namespace ll::chrono_literals;
 
 namespace Cleaner {
 
-extern ServerTimeScheduler scheduler;
-
 extern int ExecuteClean();
 extern int CountEntities();
 

src/Features/Events.cpp

@@ -1,21 +1,15 @@
 #include "Cleaner.h"
 
-namespace ConfigFile {
-
-int mItemDespawnTicks = 3000;
-
-} // namespace ConfigFile
-
-
 namespace Cleaner {
 
 void setShouldIgnore(GMLIB_Actor* ac) { ac->addTag("cleaner:ignore"); }
 
 void ListenEvents() {
     auto& eventBus = ll::event::EventBus::getInstance();
+    auto& config   = Cleaner::Entry::getInstance().getConfig();
     // ItemSpawnEvent
     eventBus.emplaceListener<GMLIB::Event::EntityEvent::ItemActorSpawnAfterEvent>(
-        [](GMLIB::Event::EntityEvent::ItemActorSpawnAfterEvent& event) {
+        [&config](GMLIB::Event::EntityEvent::ItemActorSpawnAfterEvent& event) {
             auto& item = event.getItemActor();
             if (event.getSpawner().has_value()) {
                 auto pl = (GMLIB_Player*)event.getSpawner().as_ptr();
@@ -25,16 +19,16 @@ void ListenEvents() {
                     return;
                 }
             }
-            if (Config->getValue<bool>({"ItemDespawn", "Enabled"}, true)) {
+            if (config.ItemDespawn.Enabled) {
-                item.lifeTime() = ConfigFile::mItemDespawnTicks;
+                item.lifeTime() = config.ItemDespawn.DespawnTime;
-                auto list       = Config->getValue<std::vector<std::string>>({"ItemDespawn", "WhiteList"}, {});
+                auto list       = config.ItemDespawn.WhiteList;
                 auto type       = item.item().getTypeName();
                 for (auto& key : list) {
                     if (isMatch(type, key)) {
                         return;
                     }
                 }
-                item.lifeTime() = ConfigFile::mItemDespawnTicks;
+                item.lifeTime() = config.ItemDespawn.DespawnTime;
             }
         }
     );

src/Features/Helper.cpp

@@ -2,8 +2,8 @@
 
 namespace Helper {
 
-void broadcastMessage(std::string_view msg) { GMLIB_Level::broadcast(tr("cleaner.info.prefix") + std::string(msg)); }
+void broadcastMessage(std::string_view msg) { GMLIB_Level::broadcast(I18nAPI::get("cleaner.info.prefix") + std::string(msg)); }
 
-void broadcastToast(std::string_view msg) { GMLIB_Level::broadcastToast(tr("cleaner.info.prefix"), msg); }
+void broadcastToast(std::string_view msg) { GMLIB_Level::broadcastToast(I18nAPI::get("cleaner.info.prefix"), msg); }
 
 } // namespace Helper

src/Features/VoteClean.cpp

@@ -24,10 +24,10 @@ int getPlayerCount() {
 
 void sendVoteForm(Player* pl) {
     auto fm = ll::form::ModalForm(
-        tr("cleaner.vote.title"),
+        I18nAPI::get("cleaner.vote.title"),
-        tr("cleaner.vote.subtitle", {pl->getRealName()}),
+        I18nAPI::get("cleaner.vote.subtitle", {pl->getRealName()}),
-        tr("cleaner.vote.ok"),
+        I18nAPI::get("cleaner.vote.ok"),
-        tr("cleaner.vote.no")
+        I18nAPI::get("cleaner.vote.no")
     );
     ll::service::getLevel()->forEachPlayer([&](Player& pl) -> bool {
         fm.sendTo(pl, [](Player& player, ll::form::ModalFormResult result, ll::form::FormCancelReason reason) {
@@ -35,12 +35,12 @@ void sendVoteForm(Player* pl) {
                 switch (result.value()) {
                 case ll::form::ModalFormSelectedButton::Upper: {
                     voteList[player.getUuid()] = true;
-                    player.sendMessage(tr("cleaner.vote.accept"));
+                    player.sendMessage(I18nAPI::get("cleaner.vote.accept"));
                     return;
                 }
                 case ll::form::ModalFormSelectedButton::Lower: {
                     voteList[player.getUuid()] = false;
-                    player.sendMessage(tr("cleaner.vote.deny"));
+                    player.sendMessage(I18nAPI::get("cleaner.vote.deny"));
                     return;
                 }
                 default:
@@ -53,7 +53,8 @@ void sendVoteForm(Player* pl) {
 }
 
 void checkVote() {
-    float percentage = Config->getValue<float>({"VoteClean", "Percentage"}, 50.0f) / 100.0f;
+    auto& config     = Cleaner::Entry::getInstance().getConfig();
+    float percentage = config.VoteClean.Percentage / 100.0f;
     int   voteCount  = 0;
     for (auto& key : voteList) {
         if (key.second == true) {
@@ -62,19 +63,19 @@ void checkVote() {
     }
     float result = ((float)voteCount) / ((float)playerCount);
     if (result >= percentage) {
-        if (ConfigFile::mAnnounce) {
+        if (config.Basic.SendBroadcast) {
-            Helper::broadcastMessage(tr("cleaner.vote.succeed"));
+            Helper::broadcastMessage(I18nAPI::get("cleaner.vote.succeed"));
         }
-        if (ConfigFile::mSendToast) {
+        if (config.Basic.SendToast) {
-            Helper::broadcastToast(tr("cleaner.vote.succeed"));
+            Helper::broadcastToast(I18nAPI::get("cleaner.vote.succeed"));
         }
         Cleaner::CleanTask();
     } else {
-        if (ConfigFile::mAnnounce) {
+        if (config.Basic.SendBroadcast) {
-            Helper::broadcastMessage(tr("cleaner.vote.failed"));
+            Helper::broadcastMessage(I18nAPI::get("cleaner.vote.failed"));
         }
-        if (ConfigFile::mSendToast) {
+        if (config.Basic.SendToast) {
-            Helper::broadcastToast(tr("cleaner.vote.failed"));
+            Helper::broadcastToast(I18nAPI::get("cleaner.vote.failed"));
         }
     }
     hasVote     = false;
@@ -82,29 +83,30 @@ void checkVote() {
 }
 
 void voteClean(Player* pl) {
+    auto& config = Cleaner::Entry::getInstance().getConfig();
     voteList.clear();
     canVote     = false;
     hasVote     = true;
     playerCount = getPlayerCount();
-    if (ConfigFile::mAnnounce) {
+    if (config.Basic.SendBroadcast) {
-        Helper::broadcastMessage(tr("cleaner.vote.voteMessage", {pl->getRealName()}));
+        Helper::broadcastMessage(I18nAPI::get("cleaner.vote.voteMessage", {pl->getRealName()}));
     }
-    if (ConfigFile::mSendToast) {
+    if (config.Basic.SendToast) {
-        Helper::broadcastToast(tr("cleaner.vote.voteMessage", {pl->getRealName()}));
+        Helper::broadcastToast(I18nAPI::get("cleaner.vote.voteMessage", {pl->getRealName()}));
     }
     sendVoteForm(pl);
-    auto cooldown = std::chrono::seconds::duration(Config->getValue<int>({"VoteClean", "Cooldown"}, 120));
+    auto cooldown = std::chrono::seconds::duration(config.VoteClean.Cooldown);
-    auto waitTime = std::chrono::seconds::duration(Config->getValue<int>({"VoteClean", "CheckDelay"}, 30));
+    auto waitTime = std::chrono::seconds::duration(config.VoteClean.CheckDelay);
-    Cleaner::scheduler.add<DelayTask>(cooldown, [] { canVote = false; });
+    Cleaner::Entry::getInstance().getScheduler().add<DelayTask>(cooldown, [] { canVote = false; });
-    Cleaner::scheduler.add<DelayTask>(waitTime, [] { checkVote(); });
+    Cleaner::Entry::getInstance().getScheduler().add<DelayTask>(waitTime, [] { checkVote(); });
 }
 
 void confirmForm(Player* pl) {
     auto fm = ll::form::ModalForm(
-        tr("cleaner.vote.title"),
+        I18nAPI::get("cleaner.vote.title"),
-        tr("cleaner.vote.confirmTubtitle"),
+        I18nAPI::get("cleaner.vote.confirmTubtitle"),
-        tr("cleaner.vote.confirmOk"),
+        I18nAPI::get("cleaner.vote.confirmOk"),
-        tr("cleaner.vote.confirmNo")
+        I18nAPI::get("cleaner.vote.confirmNo")
     );
     fm.sendTo(*pl, [](Player& player, ll::form::ModalFormResult result, ll::form::FormCancelReason reason) {
         if (result.has_value()) {
@@ -113,7 +115,7 @@ void confirmForm(Player* pl) {
                 return voteClean(&player);
             }
             case ll::form::ModalFormSelectedButton::Lower: {
-                return player.sendMessage(tr("cleaner.vote.cancel"));
+                return player.sendMessage(I18nAPI::get("cleaner.vote.cancel"));
             }
             default:
                 return;
@@ -127,14 +129,14 @@ void voteCommandExecute(Player* pl) {
         if (canVote) {
             confirmForm(pl);
         } else {
-            pl->sendMessage(tr("cleaner.vote.cooldown"));
+            pl->sendMessage(I18nAPI::get("cleaner.vote.cooldown"));
         }
     } else {
         if (voteList.count(pl->getUuid())) {
-            pl->sendMessage(tr("cleaner.vote.voted"));
+            pl->sendMessage(I18nAPI::get("cleaner.vote.voted"));
         } else {
             voteList[pl->getUuid()] = true;
-            pl->sendMessage(tr("cleaner.vote.accept"));
+            pl->sendMessage(I18nAPI::get("cleaner.vote.accept"));
         }
     }
 }

src/Global.h

@@ -7,23 +7,9 @@
 
 extern ll::Logger logger;
 
-extern GMLIB::Files::JsonConfig*     Config;
-extern GMLIB::Files::I18n::JsonI18n* Language;
-
 extern void RegisterCommands();
-extern void initPlugin();
-
-namespace ConfigFile {
-extern int  mItemDespawnTicks;
-extern bool mConsoleLog;
-extern bool mAnnounce;
-extern bool mSendToast;
-extern std::vector<std::string> mIgnoreTags;
-} // namespace ConfigFile
 
 namespace Helper {
 extern void broadcastMessage(std::string_view msg);
 extern void broadcastToast(std::string_view msg);
-} // namespace Helper
+} // namespace Helper
-
-extern std::string tr(std::string key, std::vector<std::string> data = {});

src/Initialization.cpp

@@ -1,21 +0,0 @@
-#include "Config.h"
-#include "Global.h"
-#include "Language.h"
-
-GMLIB::Files::JsonConfig*     Config                 = nullptr;
-GMLIB::Files::I18n::JsonI18n* Language               = nullptr;
-int                           commandPermissionLevel = 4;
-
-void initPlugin() {
-    Config = new GMLIB::Files::JsonConfig("./plugins/Cleaner/config/config.json", defaultConfig);
-    Config->init();
-    std::string langPath     = "./plugins/Cleaner/language/";
-    std::string languageCode = Config->getValue<std::string>({"Basic", "Language"}, "en_US");
-    Language                 = new GMLIB::Files::I18n::JsonI18n(langPath, languageCode);
-    Language->updateOrCreateLanguage("en_US", defaultLanguage_en_US);
-    Language->updateOrCreateLanguage("zh_CN", defaultLanguage_zh_CN);
-    Language->loadAllLanguages();
-    Language->chooseLanguage(languageCode);
-}
-
-std::string tr(std::string key, std::vector<std::string> data) { return Language->translate(key, data); }

src/Language.h

@@ -1,74 +1,74 @@
 #pragma once
 #include "Global.h"
 
-std::string defaultLanguage_en_US = R"({
+std::string en_US = R"({
-    "cleaner.info.prefix": "§e§l[Cleaner] §r",
+    cleaner.info.prefix=§e§l[Cleaner] §r
-    "cleaner.command.cleaner": "Cleaner admin command.",
+    cleaner.command.cleaner=Cleaner admin command.
-    "cleaner.command.despawnSuccess": "Successfully despawned %1$s entities.",
+    cleaner.command.despawnSuccess=Successfully despawned %1$s entities.
-    "cleaner.command.error.noTarget": "No targets matched the selector.",
+    cleaner.command.error.noTarget=No targets matched the selector.
-    "cleaner.command.error.playerOnly": "This command can only be executed by players!",
+    cleaner.command.error.playerOnly=This command can only be executed by players!
-    "cleaner.command.tps.output": "Current server real-time TPS %1$s §r, average TPS %2$s.",
+    cleaner.command.tps.output=Current server real-time TPS %1$s §r, average TPS %2$s.
-    "cleaner.command.mspt.output": "Current server MSPT %1$s.",
+    cleaner.command.mspt.output=Current server MSPT %1$s.
-    "cleaner.command.clean.output": "Clean task successfully initiated!",
+    cleaner.command.clean.output=Clean task successfully initiated!
-    "cleaner.command.voteclean": "Initiate entity clean vote.",
+    cleaner.command.voteclean=Initiate entity clean vote.
-    "cleaner.command.despawntime": "Despawn time for items set to %1$s game ticks.",
+    cleaner.command.despawntime=Despawn time for items set to %1$s game ticks.
-    "cleaner.output.count1": "The system will automatically clean server entities in %1$s seconds!",
+    cleaner.output.count1=The system will automatically clean server entities in %1$s seconds!
-    "cleaner.output.count2": "Attention! The system will automatically clean server entities in %1$s seconds!",
+    cleaner.output.count2=Attention! The system will automatically clean server entities in %1$s seconds!
-    "cleaner.output.finish": "Cleaning complete! A total of %1$s entities have been cleaned this time.",
+    cleaner.output.finish=Cleaning complete! A total of %1$s entities have been cleaned this time.
-    "cleaner.output.opClean": "Admin has enabled server entity cleaning.",
+    cleaner.output.opClean=Admin has enabled server entity cleaning.
-    "cleaner.output.reload": "Cleaner plugin reloaded. Some configurations may require a server restart to take effect.",
+    cleaner.output.reload=Cleaner plugin reloaded. Some configurations may require a server restart to take effect.
-    "cleaner.output.triggerAutoCleanCount": "Too many server entities detected! There are %1$s cleanable entities currently on the server. Auto-clean program has been activated.",
+    cleaner.output.triggerAutoCleanCount=Too many server entities detected! There are %1$s cleanable entities currently on the server. Auto-clean program has been activated.
-    "cleaner.output.triggerAutoCleanTps": "Low TPS detected! Server average TPS %1$s\nClean program has been initiated.",
+    cleaner.output.triggerAutoCleanTps=Low TPS detected! Server average TPS %1$s\nClean program has been initiated.
-    "cleaner.vote.cooldown": "Vote cleaning cooldown...",
+    cleaner.vote.cooldown=Vote cleaning cooldown...
-    "cleaner.vote.cancel": "Vote canceled!",
+    cleaner.vote.cancel=Vote canceled!
-    "cleaner.vote.confirmNo": "Think again",
+    cleaner.vote.confirmNo=Think again
-    "cleaner.vote.confirmOk": "Initiate vote",
+    cleaner.vote.confirmOk=Initiate vote
-    "cleaner.vote.confirmTubtitle": "Do you want to initiate a clean vote?",
+    cleaner.vote.confirmTubtitle=Do you want to initiate a clean vote?
-    "cleaner.vote.accept": "You have agreed to entity cleaning.",
+    cleaner.vote.accept=You have agreed to entity cleaning.
-    "cleaner.vote.deny": "You have declined entity cleaning.",
+    cleaner.vote.deny=You have declined entity cleaning.
-    "cleaner.vote.no": "Deny",
+    cleaner.vote.no=Deny
-    "cleaner.vote.ok": "Agree",
+    cleaner.vote.ok=Agree
-    "cleaner.vote.subtitle": "%1$s lunched a clean vote.\n\n Do you agree to clean server entities now?",
+    cleaner.vote.subtitle=%1$s lunched a clean vote.\n\n Do you agree to clean server entities now?
-    "cleaner.vote.timeout": "Vote has expired!",
+    cleaner.vote.timeout=Vote has expired!
-    "cleaner.vote.succeed": "Vote cleaning successful!",
+    cleaner.vote.succeed=Vote cleaning successful!
-    "cleaner.vote.failed": "Vote cleaning did not passed!",
+    cleaner.vote.failed=Vote cleaning did not passed!
-    "cleaner.vote.title": "Vote Cleaning",
+    cleaner.vote.title=Vote Cleaning
-    "cleaner.vote.voted": "You have been voted!",
+    cleaner.vote.voted=You have been voted!
-    "cleaner.vote.voteMessage": "%1$s lunched a clean vote. If you agree cleaning entities but did not received a form, please type command /voteclean to vote."
+    cleaner.vote.voteMessage=%1$s lunched a clean vote. If you agree cleaning entities but did not received a form, please type command /voteclean to vote.
 })";
 
-std::string defaultLanguage_zh_CN = R"({
+std::string zh_CN = R"({
-    "cleaner.toast.title": "§e§lCleaner",
+    cleaner.info.prefix=§e§l[Cleaner] §r
-    "cleaner.command.cleaner": "Cleaner管理员命令。",
+    cleaner.command.cleaner=Cleaner管理员命令。
-    "cleaner.command.despawnSuccess": "已成功清除了 %1$s 个实体",
+    cleaner.command.despawnSuccess=已成功清除了 %1$s 个实体
-    "cleaner.command.error.noTarget": "没有与选择器匹配的目标",
+    cleaner.command.error.noTarget=没有与选择器匹配的目标
-    "cleaner.command.error.playerOnly": "该命令只能由玩家执行！",
+    cleaner.command.error.playerOnly=该命令只能由玩家执行！
-    "cleaner.command.tps.output": "当前服务器实时TPS %1$s §r，平均TPS %2$s",
+    cleaner.command.tps.output=当前服务器实时TPS %1$s §r，平均TPS %2$s
-    "cleaner.command.mspt.output": "当前服务器实MSPT %1$s",
+    cleaner.command.mspt.output=当前服务器实MSPT %1$s
-    "cleaner.command.clean.output": "已成功启动清理任务！",
+    cleaner.command.clean.output=已成功启动清理任务！
-    "cleaner.command.voteclean": "发起实体清理投票。",
+    cleaner.command.voteclean=发起实体清理投票。
-    "cleaner.command.despawntime" : "已成功将物品消失时间设置为 %1$s 游戏刻",
+    cleaner.command.despawntime" : "已成功将物品消失时间设置为 %1$s 游戏刻
-    "cleaner.output.count1": "系统将在 %1$s 秒后自动清理服务器实体！",
+    cleaner.output.count1=系统将在 %1$s 秒后自动清理服务器实体！
-    "cleaner.output.count2": "请注意！系统将在 %1$s 秒后自动清理服务器实体！",
+    cleaner.output.count2=请注意！系统将在 %1$s 秒后自动清理服务器实体！
-    "cleaner.output.finish": "清理完成！本次总共清理了 %1$s 个实体。",
+    cleaner.output.finish=清理完成！本次总共清理了 %1$s 个实体。
-    "cleaner.output.opClean": "管理员启用了服务器实体清理。",
+    cleaner.output.opClean=管理员启用了服务器实体清理。
-    "cleaner.output.reload": "已重载Cleaner插件，部分配置可能需要重启服务器才能生效。",
+    cleaner.output.reload=已重载Cleaner插件，部分配置可能需要重启服务器才能生效。
-    "cleaner.output.triggerAutoCleanCount": "检测到服务器实体过多！！当前服务器存在 %1$s 个可清理实体，已启动自动清理程序。",
+    cleaner.output.triggerAutoCleanCount=检测到服务器实体过多！！当前服务器存在 %1$s 个可清理实体，已启动自动清理程序。
-    "cleaner.output.triggerAutoCleanTps": "当前服务器TPS过低！！服务器平均TPS %1$s\n系统已启动清理程序。",
+    cleaner.output.triggerAutoCleanTps=当前服务器TPS过低！！服务器平均TPS %1$s\n系统已启动清理程序。
-    "cleaner.vote.cooldown": "投票清理正在冷却...",
+    cleaner.vote.cooldown=投票清理正在冷却...
-    "cleaner.vote.cancel": "投票已取消！",
+    cleaner.vote.cancel=投票已取消！
-    "cleaner.vote.confirmNo": "我再想想",
+    cleaner.vote.confirmNo=我再想想
-    "cleaner.vote.confirmOk": "发起投票",
+    cleaner.vote.confirmOk=发起投票
-    "cleaner.vote.confirmTubtitle": "你是否要发起投票清理？",
+    cleaner.vote.confirmTubtitle=你是否要发起投票清理？
-    "cleaner.vote.accept": "你已同意实体清理。",
+    cleaner.vote.accept=你已同意实体清理。
-    "cleaner.vote.deny": "你已拒绝实体清理。",
+    cleaner.vote.deny=你已拒绝实体清理。
-    "cleaner.vote.no": "拒绝",
+    cleaner.vote.no=拒绝
-    "cleaner.vote.ok": "同意",
+    cleaner.vote.ok=同意
-    "cleaner.vote.subtitle": "%1$s 发起了服务器实体清理投票！\n\n你是否同意现在清理服务器实体？",
+    cleaner.vote.subtitle=%1$s 发起了服务器实体清理投票！\n\n你是否同意现在清理服务器实体？
-    "cleaner.vote.timeout": "投票已过期！",
+    cleaner.vote.timeout=投票已过期！
-    "cleaner.vote.succeed": "投票清理成功！",
+    cleaner.vote.succeed=投票清理成功！
-    "cleaner.vote.failed": "投票清理未通过。",
+    cleaner.vote.failed=投票清理未通过。
-    "cleaner.vote.title": "投票清理",
+    cleaner.vote.title=投票清理
-    "cleaner.vote.voted": "你已经投过票了！",
+    cleaner.vote.voted=你已经投过票了！
-    "cleaner.vote.voteMessage": "%1$s 发起了服务器实体清理投票！如果同意清理但是未收到表单，请输入命令 /voteclean 投票。拒绝清理请忽略此信息。"
+    cleaner.vote.voteMessage=%1$s 发起了服务器实体清理投票！如果同意清理但是未收到表单，请输入命令 /voteclean 投票。拒绝清理请忽略此信息。
 })";

src/Plugin.cpp

@@ -1,16 +1,25 @@
 #include "Features/Cleaner.h"
 #include "Global.h"
+#include "Language.h"
 
 ll::Logger logger("Cleaner");
 
-namespace plugin {
+namespace Cleaner {
 
-Plugin::Plugin(ll::plugin::NativePlugin& self) : mSelf(self) {
+static std::unique_ptr<Entry> instance;
-    // Code for loading the plugin goes here.
-    initPlugin();
-}
 
-bool Plugin::enable() {
+Entry& Entry::getInstance() { return *instance; }
+
+bool Entry::load() { return true; }
+
+bool Entry::enable() {
+    mConfig.emplace();
+    mScheduler.emplace();
+    ll::config::loadConfig(*mConfig, getSelf().getConfigDir() / "config.json");
+    saveConfig();
+    I18nAPI::updateOrCreateLanguageFile(getSelf().getLangDir(), "en_US", en_US);
+    I18nAPI::updateOrCreateLanguageFile(getSelf().getLangDir(), "zh_CN", zh_CN);
+    I18nAPI::loadLanguagesFromDirectory(getSelf().getLangDir());
     Cleaner::ListenEvents();
     RegisterCommands();
     Cleaner::loadCleaner();
@@ -20,11 +29,19 @@ bool Plugin::enable() {
     return true;
 }
 
-bool Plugin::disable() {
+bool Entry::disable() {
-    // Code for disabling the plugin goes here.
+    mConfig.reset();
     Cleaner::unloadCleaner();
-    logger.info("Cleaner Disabled!");
+    mScheduler.reset();
     return true;
 }
 
-} // namespace plugin
+Config& Entry::getConfig() { return mConfig.value(); }
+
+void Entry::saveConfig() { ll::config::saveConfig(*mConfig, getSelf().getConfigDir() / "config.json"); }
+
+ServerTimeScheduler& Entry::getScheduler() { return mScheduler.value(); }
+
+} // namespace Cleaner
+
+LL_REGISTER_PLUGIN(Cleaner::Entry, Cleaner::instance);

src/Plugin.h

@@ -1,19 +1,24 @@
 #pragma once
 
+#include "Config.h"
 #include <ll/api/plugin/NativePlugin.h>
+#include <ll/api/schedule/Scheduler.h>
 
-namespace plugin {
+namespace Cleaner {
+
+using namespace ll::schedule;
+
+class Entry {
 
-class Plugin {
 public:
-    explicit Plugin(ll::plugin::NativePlugin& self);
+    static Entry& getInstance();
 
-    Plugin(Plugin&&)                 = delete;
+    Entry(ll::plugin::NativePlugin& self) : mSelf(self) {}
-    Plugin(const Plugin&)            = delete;
-    Plugin& operator=(Plugin&&)      = delete;
-    Plugin& operator=(const Plugin&) = delete;
 
-    ~Plugin() = default;
+    [[nodiscard]] ll::plugin::NativePlugin& getSelf() const { return mSelf; }
+
+    /// @return True if the plugin is loaded successfully.
+    bool load();
 
     /// @return True if the plugin is enabled successfully.
     bool enable();
@@ -21,8 +26,20 @@ public:
     /// @return True if the plugin is disabled successfully.
     bool disable();
 
+    // TODO: Implement this method if you need to unload the plugin.
+    // /// @return True if the plugin is unloaded successfully.
+    // bool unload();
+
+    Config& getConfig();
+
+    void saveConfig();
+
+    ServerTimeScheduler& getScheduler();
+
 private:
-    ll::plugin::NativePlugin& mSelf;
+    ll::plugin::NativePlugin&          mSelf;
+    std::optional<Config>              mConfig;
+    std::optional<ServerTimeScheduler> mScheduler;
 };
 
-} // namespace plugin
+} // namespace Cleaner

src/RegisterCommand.cpp

@@ -1,5 +1,5 @@
 #include "Features/Cleaner.h"
-#include "Global.h"
+#include "Plugin.h"
 
 struct CleanerParam {
     enum class Despawn { despawn } despawn;
@@ -10,9 +10,10 @@ struct CleanerParam {
 };
 
 void RegCleanerCommand() {
-    auto& cmd = ll::command::CommandRegistrar::getInstance().getOrCreateCommand(
+    auto& config = Cleaner::Entry::getInstance().getConfig();
-        Config->getValue<std::string>({"Basic", "Command"}, "cleaner"),
+    auto& cmd    = ll::command::CommandRegistrar::getInstance().getOrCreateCommand(
-        tr("cleaner.command.cleaner"),
+        config.Basic.Command,
+        I18nAPI::get("cleaner.command.cleaner"),
         CommandPermissionLevel::GameDirectors
     );
     cmd.overload<CleanerParam>()
@@ -21,12 +22,12 @@ void RegCleanerCommand() {
         .execute<[&](CommandOrigin const& origin, CommandOutput& output, CleanerParam const& param) {
             auto ens = param.entity.results(origin);
             if (ens.empty()) {
-                return output.error(tr("cleaner.command.error.noTarget"));
+                return output.error(I18nAPI::get("cleaner.command.error.noTarget"));
             }
             for (auto en : ens) {
                 en->despawn();
             }
-            return output.success(tr("cleaner.command.despawnSuccess", {S(ens.size())}));
+            return output.success(I18nAPI::get("cleaner.command.despawnSuccess", {S(ens.size())}));
         }>();
     cmd.overload<CleanerParam>()
         .required("action")
@@ -34,30 +35,32 @@ void RegCleanerCommand() {
             switch (param.action) {
             case CleanerParam::Action::clean: {
                 Cleaner::CleanTask();
-                if (ConfigFile::mConsoleLog) {
+                if (Cleaner::Entry::getInstance().getConfig().Basic.ConsoleLog) {
-                    logger.info(tr("cleaner.output.opClean"));
+                    logger.info(I18nAPI::get("cleaner.output.opClean"));
                 }
-                if (ConfigFile::mAnnounce) {
+                if (Cleaner::Entry::getInstance().getConfig().Basic.SendBroadcast) {
-                    Helper::broadcastMessage(tr("cleaner.output.opClean"));
+                    Helper::broadcastMessage(I18nAPI::get("cleaner.output.opClean"));
                 }
-                if (ConfigFile::mSendToast) {
+                if (Cleaner::Entry::getInstance().getConfig().Basic.SendToast) {
-                    Helper::broadcastToast(tr("cleaner.output.opClean"));
+                    Helper::broadcastToast(I18nAPI::get("cleaner.output.opClean"));
                 }
-                return output.success(tr("cleaner.command.clean.output"));
+                return output.success(I18nAPI::get("cleaner.command.clean.output"));
             }
             case CleanerParam::Action::tps: {
-                return output.success(
+                return output.success(I18nAPI::get(
-                    tr("cleaner.command.tps.output",
+                    "cleaner.command.tps.output",
-                       {S(GMLIB_Level::getLevel()->getServerCurrentTps()),
+                    {S(GMLIB_Level::getLevel()->getServerCurrentTps()),
-                        S(GMLIB_Level::getLevel()->getServerAverageTps())})
+                     S(GMLIB_Level::getLevel()->getServerAverageTps())}
-                );
+                ));
             }
             case CleanerParam::Action::mspt: {
-                return output.success(tr("cleaner.command.mspt.output", {S(GMLIB_Level::getLevel()->getServerMspt())}));
+                return output.success(
+                    I18nAPI::get("cleaner.command.mspt.output", {S(GMLIB_Level::getLevel()->getServerMspt())})
+                );
             }
             case CleanerParam::Action::reload: {
                 Cleaner::reloadCleaner();
-                return output.success(tr("cleaner.output.reload"));
+                return output.success(I18nAPI::get("cleaner.output.reload"));
             }
             }
         }>();
@@ -65,16 +68,16 @@ void RegCleanerCommand() {
         .required("despawntime")
         .required("ticks")
         .execute<[&](CommandOrigin const& origin, CommandOutput& output, CleanerParam const& param) {
-            ConfigFile::mItemDespawnTicks = param.ticks;
+            Cleaner::Entry::getInstance().getConfig().ItemDespawn.DespawnTime = param.ticks;
-            Config->setValue({"ItemDespawn", "DespawnTime"}, ConfigFile::mItemDespawnTicks);
+            Cleaner::Entry::getInstance().saveConfig();
-            return output.success(tr("cleaner.command.despawntime", {S(ConfigFile::mItemDespawnTicks)}));
+            return output.success(I18nAPI::get("cleaner.command.despawntime", {S(param.ticks)}));
         }>();
 };
 
 void RegVoteCommand() {
     auto& cmd = ll::command::CommandRegistrar::getInstance().getOrCreateCommand(
-        Config->getValue<std::string>({"VoteClean", "VoteCleanCommand"}, "voteclean"),
+        Cleaner::Entry::getInstance().getConfig().VoteClean.VoteCleanCommand,
-        tr("cleaner.command.voteclean"),
+        I18nAPI::get("cleaner.command.voteclean"),
         CommandPermissionLevel::Any
     );
     cmd.overload().execute<[&](CommandOrigin const& origin, CommandOutput& output) {
@@ -82,13 +85,13 @@ void RegVoteCommand() {
             auto pl = (Player*)origin.getEntity();
             return VoteClean::voteCommandExecute(pl);
         }
-        return output.error(tr("cleaner.command.error.playerOnly"));
+        return output.error(I18nAPI::get("cleaner.command.error.playerOnly"));
     }>();
 }
 
 void RegisterCommands() {
     RegCleanerCommand();
-    if (Config->getValue<bool>({"VoteClean", "Enabled"}, false)) {
+    if (Cleaner::Entry::getInstance().getConfig().VoteClean.Enabled) {
         RegVoteCommand();
     }
 }

src/dllmain.cpp

@@ -1,32 +0,0 @@
-#include <memory>
-
-#include <ll/api/plugin/NativePlugin.h>
-
-#include "Plugin.h"
-
-namespace plugin {
-
-// The global plugin instance.
-std::unique_ptr<Plugin> plugin = nullptr;
-
-extern "C" {
-_declspec(dllexport) bool ll_plugin_load(ll::plugin::NativePlugin& self) {
-    plugin = std::make_unique<plugin::Plugin>(self);
-
-    return true;
-}
-
-/// @warning Unloading the plugin may cause a crash if the plugin has not released all of its
-/// resources. If you are unsure, keep this function commented out.
-// _declspec(dllexport) bool ll_plugin_unload(ll::plugin::Plugin&) {
-//     plugin.reset();
-//
-//     return true;
-// }
-
-_declspec(dllexport) bool ll_plugin_enable(ll::plugin::NativePlugin&) { return plugin->enable(); }
-
-_declspec(dllexport) bool ll_plugin_disable(ll::plugin::NativePlugin&) { return plugin->disable(); }
-}
-
-} // namespace plugin

tooth.json

@@ -1,7 +1,7 @@
 {
     "format_version": 2,
     "tooth": "github.com/GroupMountain/Cleaner",
-    "version": "0.11.0",
+    "version": "0.12.0",
     "info": {
         "name": "Cleaner",
         "description": "A Powerful Entities Cleaning up Plugin for BDS",
@@ -13,9 +13,9 @@
             "gmlib"
         ]
     },
-    "asset_url": "https://github.com/GroupMountain/Cleaner/releases/download/v0.11.0/Cleaner-windows-x64.zip",
+    "asset_url": "https://github.com/GroupMountain/Cleaner/releases/download/v0.12.0/Cleaner-windows-x64.zip",
     "dependencies": {
-        "github.com/GroupMountain/GMLIB": ">=0.10.0"
+        "github.com/GroupMountain/GMLIB": ">=0.12.1"
     },
     "files": {
         "place": [