refactor: refactoring skeleton

src/Cleaner.cpp

@@ -1,254 +0,0 @@
-#include "Config.h"
-#include "Global.h"
-#include <GMLIB/Event/Entity/ItemActorSpawnEvent.h>
-#include <GMLIB/Event/Entity/MobPickupItemEvent.h>
-#include <GMLIB/Server/PlayerAPI.h>
-#include <regex>
-
-using namespace ll::schedule;
-using namespace ll::chrono_literals;
-
-int item_despawn_time = 3000;
-
-ServerTimeScheduler scheduler;
-bool                auto_clean_triggerred = false;
-
-bool ConsoleLog = true;
-bool Announce   = true;
-
-namespace Cleaner {
-
-bool isMatch(std::string& A, std::string& B) {
-    // 如果B是正则表达式
-    if (B.find_first_of(".*+?()[]{}|^$") != std::string::npos) {
-        try {
-            std::regex regex(B);
-            return std::regex_match(A, regex);
-        } catch (...) {
-            return false;
-        }
-    }
-    return (A == B);
-}
-
-bool shouldIgnore(GMLIB_Actor* ac) {
-    if (ac->isMob() || ac->isItemActor()) {
-        if (ac->isTame() || ac->isTrusting() || ac->getNameTag() != "") {
-            return true;
-        }
-        auto nbt = ac->getNbt();
-        if (nbt->getByte("ShowBottom") == 1) { // End Crystal Used Only, if has this tag 1b, it is modified by cleaner.
-            return true;
-        }
-    }
-    return false;
-}
-
-bool ShouldClean(Actor* actor) {
-    // Players
-    auto en = (GMLIB_Actor*)actor;
-    if (en->isPlayer() || shouldIgnore(en)) {
-        return false;
-    }
-    auto type = en->getTypeName();
-    // Items
-    if (en->isItemActor()) {
-        if (Config->getValue<bool>({"CleanItem", "Enabled"}, false)) {
-            auto itac = (ItemActor*)en;
-            if (itac->age() <= Config->getValue<int>({"CleanItem", "ExistTicks"}, 0)) {
-                return false;
-            }
-            auto itemType  = itac->item().getTypeName();
-            auto whitelist = Config->getValue<std::vector<std::string>>({"CleanItem", "Whitelist"}, {});
-            for (auto& key : whitelist) {
-                if (isMatch(itemType, key)) {
-                    return false;
-                }
-            }
-            return true;
-        }
-        return false;
-    }
-    // Mobs
-    else if (en->isMob()) {
-        if (Config->getValue<bool>({"CleanMobs", "Enabled"}, false)) {
-            auto blacklist = Config->getValue<std::vector<std::string>>({"CleanMobs", "Blacklist"}, {});
-            for (auto& key : blacklist) {
-                if (isMatch(type, key)) {
-                    return true;
-                }
-            }
-            auto whitelist = Config->getValue<std::vector<std::string>>({"CleanMobs", "Whitelist"}, {});
-            for (auto& key : whitelist) {
-                if (isMatch(type, key)) {
-                    return false;
-                }
-            }
-            if (Config->getValue<bool>({"CleanMobs", "CleanMonstors"}, false)
-                && en->hasCategory(ActorCategory::Monster)) {
-                return true;
-            }
-            if (Config->getValue<bool>({"CleanMobs", "CleanPeacefulMobs"}, false)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    // Others
-    else {
-        if (Config->getValue<bool>({"CleanInanimate", "Enabled"}, false)) {
-            auto blacklist = Config->getValue<std::vector<std::string>>({"CleanInanimate", "Blacklist"}, {});
-            for (auto& key : blacklist) {
-                if (isMatch(type, key)) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-}
-
-int ExecuteClean() {
-    int  clean_count  = 0;
-    auto all_entities = GMLIB_Level::getLevel()->getAllEntities();
-    for (auto entity : all_entities) {
-        if (ShouldClean(entity)) {
-            entity->despawn();
-            clean_count++;
-        }
-    }
-    return clean_count;
-}
-
-int CountEntities() {
-    int  clean_count  = 0;
-    auto all_entities = GMLIB_Level::getLevel()->getAllEntities();
-    for (auto entity : all_entities) {
-        if (ShouldClean(entity)) {
-            clean_count++;
-        }
-    }
-    return clean_count;
-}
-
-void CleanTask() {
-    auto time          = Config->getValue<int>({"Basic", "Notice1"}, 20);
-    auto announce_time = Config->getValue<int>({"Basic", "Notice2"}, 5);
-    auto time_1        = std::chrono::seconds::duration(time);
-    auto time_2        = std::chrono::seconds::duration(time - announce_time);
-    if (ConsoleLog) {
-        logger.info(tr("cleaner.output.count1", {S(time_1.count())}));
-    }
-    if (Announce) {
-        TextPacket::createRawMessage(tr("cleaner.info.prefix") + tr("cleaner.output.count1", {S(time_1.count())}))
-            .sendToClients();
-    }
-    scheduler.add<DelayTask>(time_2, [announce_time] {
-        if (ConsoleLog) {
-            logger.info(tr("cleaner.output.count2", {S(announce_time)}));
-        }
-        if (Announce) {
-            TextPacket::createRawMessage(tr("cleaner.info.prefix") + tr("cleaner.output.count2", {S(announce_time)}))
-                .sendToClients();
-        }
-    });
-    scheduler.add<DelayTask>(time_1, [] {
-        auto count = ExecuteClean();
-        if (ConsoleLog) {
-            logger.info(tr("cleaner.output.finish", {S(count)}));
-        }
-        if (Announce) {
-            TextPacket::createRawMessage(tr("cleaner.info.prefix") + tr("cleaner.output.finish", {S(count)}))
-                .sendToClients();
-        }
-        auto_clean_triggerred = false;
-    });
-}
-
-void AutoCleanTask(int seconds) {
-    auto time      = std::chrono::seconds::duration(seconds);
-    mAutoCleanTask = scheduler.add<RepeatTask>(time, [] { CleanTask(); });
-}
-
-void CheckCleanTask(int max_entities, float min_tps) {
-    mCheckCleanTask = scheduler.add<RepeatTask>(10s, [max_entities, min_tps] {
-        auto count = CountEntities();
-        if (auto_clean_triggerred == false) {
-            if (count >= max_entities) {
-                auto_clean_triggerred = true;
-                logger.warn(tr("cleaner.output.triggerAutoCleanCount", {S(count)}));
-                CleanTask();
-            } else if (GMLIB_Level::getLevel()->getServerAverageTps() <= min_tps) {
-                auto_clean_triggerred = true;
-                logger.warn(
-                    tr("cleaner.output.triggerAutoCleanCount", {S(GMLIB_Level::getLevel()->getServerAverageTps())})
-                );
-                CleanTask();
-            }
-        }
-    });
-}
-
-void setShouldIgnore(GMLIB_Actor* ac) {
-    auto nbt = ac->getNbt();
-    nbt->put("ShowBottom", ByteTag(1));
-    ac->setNbt(*nbt);
-}
-
-void ListenEvents() {
-    auto eventBus = &ll::event::EventBus::getInstance();
-    // ItemSpawnEvent
-    eventBus->emplaceListener<GMLIB::Event::EntityEvent::ItemActorSpawnAfterEvent>(
-        [](GMLIB::Event::EntityEvent::ItemActorSpawnAfterEvent& event) {
-            auto& item = event.getItemActor();
-            auto  pl   = (GMLIB_Player*)event.getSpawner();
-            if (pl) {
-                if (pl->isPlayer() && !pl->isAlive()) { // Death Drop
-                    auto ac = (GMLIB_Actor*)&item;
-                    setShouldIgnore(ac);
-                    return;
-                }
-            }
-            item.lifeTime() = item_despawn_time;
-        }
-    );
-    // MobTakeItemEvent
-    eventBus->emplaceListener<GMLIB::Event::EntityEvent::MobPickupItemAfterEvent>(
-        [](GMLIB::Event::EntityEvent::MobPickupItemAfterEvent& event) {
-            // auto item = event.getItemActor().item().getTypeName();
-            auto mob = (GMLIB_Actor*)&event.self();
-            setShouldIgnore(mob);
-        }
-    );
-}
-
-void reloadCleaner() {
-    unloadCleaner();
-    loadCleaner();
-}
-
-void loadCleaner() {
-    ListenEvents();
-    RegisterCommands();
-    if (Config->getValue<bool>({"ScheduleClean", "Enabled"}, false)) {
-        Cleaner::AutoCleanTask(Config->getValue<int>({"ScheduleClean", "CleanInterval"}, 3000));
-    }
-    if (Config->getValue<bool>({"AutoCleanCount", "Enabled"}, false)
-        || Config->getValue<bool>({"AutoCleanTPS", "Enabled"}, false)) {
-        Cleaner::CheckCleanTask(
-            Config->getValue<int>({"AutoCleanCount", "TriggerCount"}, 900),
-            Config->getValue<int>({"AutoCleanTPS", "TriggerTPS"}, 15)
-        );
-    }
-    item_despawn_time = Config->getValue<int>({"ItemDespawn", "DespawnTime"}, 6000);
-    Announce          = Config->getValue<bool>({"Basic", "SendBroadcast"}, true);
-    ConsoleLog        = Config->getValue<bool>({"Basic", "ConsoleLog"}, true);
-}
-
-void unloadCleaner() {
-    mAutoCleanTask->cancel();
-    mCheckCleanTask->cancel();
-    delete Config;
-}
-
-} // namespace Cleaner

src/Config.h

@@ -1,15 +1,20 @@
 #pragma once
 #include "Global.h"
 
-inline std::string defaultConfig = R"({
+std::string defaultConfig = R"({
     "Basic": {
         "Language": "en_US",
-        "ConsoleLog": true,
         "Command": "cleaner",
         "Notice1": 20,
         "Notice2": 5,
-        "SendBroadcast": true
+        "ConsoleLog": true,
+        "SendBroadcast": true,
+        "SendToast": true
     },
+    "IgnoreTags": [
+        "ignore",
+        "不清理"
+    ],
     "AutoCleanCount": {
         "Enabled": true,
         "TriggerCount": 900
@@ -26,6 +31,7 @@ inline std::string defaultConfig = R"({
         ]
     },
     "CleanInanimate": {
+        "Enabled": true,
         "Blacklist": [
             "minecraft:xp_orb",
             "minecraft:arrow",
@@ -34,8 +40,7 @@ inline std::string defaultConfig = R"({
             "minecraft:wither_skull",
             "minecraft:wither_skull_dangerous",
             "minecraft:dragon_fireball"
-        ],
+        ]
-        "Enabled": true
     },
     "CleanItem": {
         "Enabled": true,
@@ -65,17 +70,13 @@ inline std::string defaultConfig = R"({
         ]
     },
     "CleanMobs": {
-        "BlackList": [
+        "Enabled": true,
-            "minecraft:guardian",
-            "minecraft:zombie_pigman"
-        ],
         "CleanMonstors": true,
         "CleanPeacefulMobs": false,
         "EnableAutoExclude": true,
-        "Enabled": true,
+        "BlackList": [
-        "IgnoreTags": [
+            "minecraft:guardian",
-            "ignore",
+            "minecraft:zombie_pigman"
-            "不清理"
         ],
         "Whitelist": [
             "minecraft:ender_dragon",
@@ -88,14 +89,14 @@ inline std::string defaultConfig = R"({
         ]
     },
     "ScheduleClean": {
-        "CleanInterval": 3600,
-        "Enabled": true
-        },    
-    "VoteClean": {
-        "CD": 120,
-        "Delay": 30,
         "Enabled": true,
-        "Percentage": 50,
+        "CleanInterval": 3600
-        "VoteCleanCommand": "voteclean"
+    },    
+    "VoteClean": {
+        "Enabled": true,
+        "VoteCleanCommand": "voteclean",
+        "Cooldown": 120,
+        "CheckDelay": 30,
+        "Percentage": 50   
     }
 })";

src/Features/Clean.cpp

@@ -0,0 +1,124 @@
+#include "Cleaner.h"
+
+namespace Cleaner {
+
+bool isMatch(std::string& A, std::string& B) {
+    // 如果B是正则表达式
+    if (B.find_first_of(".*+?()[]{}|^$") != std::string::npos) {
+        try {
+            std::regex regex(B);
+            return std::regex_match(A, regex);
+        } catch (...) {
+            return false;
+        }
+    }
+    return (A == B);
+}
+
+bool shouldIgnore(GMLIB_Actor* ac) {
+    if (ac->isMob() || ac->isItemActor()) {
+        if (ac->isTame() || ac->isTrusting() || ac->getNameTag() != "") {
+            return true;
+        }
+        auto nbt = ac->getNbt();
+        if (nbt->getByte("ShowBottom") == 1) { // End Crystal Used Only, if has this tag 1b, it is modified by cleaner.
+            return true;
+        }
+    }
+    return false;
+}
+
+bool ShouldClean(Actor* actor) {
+    // Players
+    auto en = (GMLIB_Actor*)actor;
+    if (en->isPlayer() || shouldIgnore(en)) {
+        return false;
+    }
+    auto type = en->getTypeName();
+    auto tags = Config->getValue<std::vector<std::string>>({"IgnoreTags"}, {});
+    for (auto& tag : tags) {
+        if (en->hasTag(tag)) {
+            return false;
+        }
+    }
+    // Items
+    if (en->isItemActor()) {
+        if (Config->getValue<bool>({"CleanItem", "Enabled"}, false)) {
+            auto itac = (ItemActor*)en;
+            if (itac->age() <= Config->getValue<int>({"CleanItem", "ExistTicks"}, 0)) {
+                return false;
+            }
+            auto itemType  = itac->item().getTypeName();
+            auto whitelist = Config->getValue<std::vector<std::string>>({"CleanItem", "Whitelist"}, {});
+            for (auto& key : whitelist) {
+                if (isMatch(itemType, key)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    // Mobs
+    else if (en->isMob()) {
+        if (Config->getValue<bool>({"CleanMobs", "Enabled"}, false)) {
+            auto blacklist = Config->getValue<std::vector<std::string>>({"CleanMobs", "Blacklist"}, {});
+            for (auto& key : blacklist) {
+                if (isMatch(type, key)) {
+                    return true;
+                }
+            }
+            auto whitelist = Config->getValue<std::vector<std::string>>({"CleanMobs", "Whitelist"}, {});
+            for (auto& key : whitelist) {
+                if (isMatch(type, key)) {
+                    return false;
+                }
+            }
+            if (Config->getValue<bool>({"CleanMobs", "CleanMonstors"}, false)
+                && en->hasCategory(ActorCategory::Monster)) {
+                return true;
+            }
+            if (Config->getValue<bool>({"CleanMobs", "CleanPeacefulMobs"}, false)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // Others
+    else {
+        if (Config->getValue<bool>({"CleanInanimate", "Enabled"}, false)) {
+            auto blacklist = Config->getValue<std::vector<std::string>>({"CleanInanimate", "Blacklist"}, {});
+            for (auto& key : blacklist) {
+                if (isMatch(type, key)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}
+
+int ExecuteClean() {
+    int  clean_count  = 0;
+    auto all_entities = GMLIB_Level::getLevel()->getAllEntities();
+    for (auto entity : all_entities) {
+        if (ShouldClean(entity)) {
+            entity->despawn();
+            clean_count++;
+        }
+    }
+    return clean_count;
+}
+
+int CountEntities() {
+    int  clean_count  = 0;
+    auto all_entities = GMLIB_Level::getLevel()->getAllEntities();
+    for (auto entity : all_entities) {
+        if (ShouldClean(entity)) {
+            clean_count++;
+        }
+    }
+    return clean_count;
+}
+
+} // namespace Cleaner

src/Features/CleanTask.cpp

@@ -0,0 +1,108 @@
+#include "Cleaner.h"
+
+namespace ConfigFile {
+
+bool mConsoleLog = true;
+bool mAnnounce   = true;
+bool mSendToast  = true;
+
+} // namespace ConfigFile
+
+
+namespace Cleaner {
+
+using namespace ll::schedule;
+using namespace ll::chrono_literals;
+
+static std::shared_ptr<ll::schedule::task::Task<ll::chrono::ServerClock>> mAutoCleanTask;
+static std::shared_ptr<ll::schedule::task::Task<ll::chrono::ServerClock>> mCheckCleanTask;
+
+ServerTimeScheduler scheduler;
+
+bool auto_clean_triggerred = false;
+
+void CleanTask() {
+    auto time          = Config->getValue<int>({"Basic", "Notice1"}, 20);
+    auto announce_time = Config->getValue<int>({"Basic", "Notice2"}, 5);
+    auto time_1        = std::chrono::seconds::duration(time);
+    auto time_2        = std::chrono::seconds::duration(time - announce_time);
+    if (ConfigFile::mConsoleLog) {
+        logger.info(tr("cleaner.output.count1", {S(time_1.count())}));
+    }
+    if (ConfigFile::mAnnounce) {
+        Helper::broadcastMessage(tr("cleaner.output.count1", {S(time_1.count())}));
+    }
+    if (ConfigFile::mSendToast) {
+        Helper::broadcastToast(tr("cleaner.output.count2", {S(announce_time)}));
+    }
+    scheduler.add<DelayTask>(time_2, [announce_time] {
+        if (ConfigFile::mConsoleLog) {
+            logger.info(tr("cleaner.output.count2", {S(announce_time)}));
+        }
+        if (ConfigFile::mAnnounce) {
+            Helper::broadcastMessage(tr("cleaner.output.count2", {S(announce_time)}));
+        }
+        if (ConfigFile::mSendToast) {
+            Helper::broadcastToast(tr("cleaner.output.count2", {S(announce_time)}));
+        }
+    });
+    scheduler.add<DelayTask>(time_1, [] {
+        auto count = ExecuteClean();
+        if (ConfigFile::mConsoleLog) {
+            logger.info(tr("cleaner.output.finish", {S(count)}));
+        }
+        if (ConfigFile::mAnnounce) {
+            Helper::broadcastMessage(tr("cleaner.output.finish", {S(count)}));
+        }
+        if (ConfigFile::mSendToast) {
+            Helper::broadcastToast(tr("cleaner.output.finish", {S(count)}));
+        }
+        auto_clean_triggerred = false;
+    });
+}
+
+void AutoCleanTask(int seconds) {
+    auto time      = std::chrono::seconds::duration(seconds);
+    mAutoCleanTask = scheduler.add<RepeatTask>(time, [] { CleanTask(); });
+}
+
+void CheckCleanTask(int max_entities, float min_tps) {
+    mCheckCleanTask = scheduler.add<RepeatTask>(10s, [max_entities, min_tps] {
+        auto count = CountEntities();
+        if (auto_clean_triggerred == false) {
+            if (count >= max_entities) {
+                auto_clean_triggerred = true;
+                if (ConfigFile::mConsoleLog) {
+                    logger.warn(tr("cleaner.output.triggerAutoCleanCount", {S(count)}));
+                }
+                if (ConfigFile::mAnnounce) {
+                    Helper::broadcastMessage(tr("cleaner.output.triggerAutoCleanCount", {S(count)}));
+                }
+                if (ConfigFile::mSendToast) {
+                    Helper::broadcastToast(tr("cleaner.output.triggerAutoCleanCount", {S(count)}));
+                }
+                CleanTask();
+            } else if (GMLIB_Level::getLevel()->getServerAverageTps() <= min_tps) {
+                auto_clean_triggerred = true;
+                auto mspt             = S(GMLIB_Level::getLevel()->getServerAverageTps());
+                if (ConfigFile::mConsoleLog) {
+                    logger.warn(tr("cleaner.output.triggerAutoCleanCount", {mspt}));
+                }
+                if (ConfigFile::mAnnounce) {
+                    Helper::broadcastMessage(tr("cleaner.output.triggerAutoCleanCount", {mspt}));
+                }
+                if (ConfigFile::mSendToast) {
+                    Helper::broadcastToast(tr("cleaner.output.triggerAutoCleanCount", {mspt}));
+                }
+                CleanTask();
+            }
+        }
+    });
+}
+
+void stopAllTasks() {
+    mCheckCleanTask->cancel();
+    mAutoCleanTask->cancel();
+}
+
+} // namespace Cleaner

src/Features/Cleaner.cpp

@@ -0,0 +1,36 @@
+#include "Cleaner.h"
+
+namespace Cleaner {
+
+void loadCleaner() {
+    ListenEvents();
+    RegisterCommands();
+    if (Config->getValue<bool>({"ScheduleClean", "Enabled"}, false)) {
+        Cleaner::AutoCleanTask(Config->getValue<int>({"ScheduleClean", "CleanInterval"}, 3000));
+    }
+    if (Config->getValue<bool>({"AutoCleanCount", "Enabled"}, false)
+        || Config->getValue<bool>({"AutoCleanTPS", "Enabled"}, false)) {
+        Cleaner::CheckCleanTask(
+            Config->getValue<int>({"AutoCleanCount", "TriggerCount"}, 900),
+            Config->getValue<int>({"AutoCleanTPS", "TriggerTPS"}, 15)
+        );
+    }
+    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);
+}
+
+void unloadCleaner() {
+    stopAllTasks();
+    delete Config;
+    delete Language;
+}
+
+void reloadCleaner() {
+    unloadCleaner();
+    initPlugin();
+    loadCleaner();
+}
+
+} // namespace Cleaner

src/Features/Cleaner.h

@@ -0,0 +1,14 @@
+#pragma once
+#include "Global.h"
+
+namespace Cleaner {
+
+extern int ExecuteClean();
+extern int CountEntities();
+
+extern void AutoCleanTask(int seconds);
+extern void CheckCleanTask(int max_entities, float min_tps);
+extern void ListenEvents();
+extern void stopAllTasks();
+
+} // namespace Cleaner

src/Features/Events.cpp

@@ -0,0 +1,44 @@
+#include "Cleaner.h"
+
+namespace ConfigFile {
+
+int mItemDespawnTicks = 3000;
+
+} // namespace ConfigFile
+
+
+namespace Cleaner {
+
+void setShouldIgnore(GMLIB_Actor* ac) {
+    auto nbt = ac->getNbt();
+    nbt->put("ShowBottom", ByteTag(1));
+    ac->setNbt(*nbt);
+}
+
+void ListenEvents() {
+    auto& eventBus = ll::event::EventBus::getInstance();
+    // ItemSpawnEvent
+    eventBus.emplaceListener<GMLIB::Event::EntityEvent::ItemActorSpawnAfterEvent>(
+        [](GMLIB::Event::EntityEvent::ItemActorSpawnAfterEvent& event) {
+            auto& item = event.getItemActor();
+            auto  pl   = (GMLIB_Player*)event.getSpawner();
+            if (pl) {
+                if (pl->isPlayer() && !pl->isAlive()) { // Death Drop
+                    auto ac = (GMLIB_Actor*)&item;
+                    setShouldIgnore(ac);
+                    return;
+                }
+            }
+            item.lifeTime() = ConfigFile::mItemDespawnTicks;
+        }
+    );
+    // MobTakeItemEvent
+    eventBus.emplaceListener<GMLIB::Event::EntityEvent::MobPickupItemAfterEvent>(
+        [](GMLIB::Event::EntityEvent::MobPickupItemAfterEvent& event) {
+            auto mob = (GMLIB_Actor*)&event.self();
+            setShouldIgnore(mob);
+        }
+    );
+}
+
+} // namespace Cleaner

src/Features/Helper.cpp

@@ -0,0 +1,14 @@
+#include "Global.h"
+
+namespace Helper {
+
+void broadcastMessage(std::string msg) {
+    TextPacket::createRawMessage(tr("cleaner.info.prefix") + msg).sendToClients();
+}
+
+void broadcastToast(std::string msg) {
+    auto pkt = ToastRequestPacket(tr("cleaner.info.prefix"), msg);
+    pkt.sendToClients();
+}
+
+} // namespace Helper

src/Global.h

@@ -1,27 +1,35 @@
 #pragma once
 #include "Plugin.h"
 #include <include_all.h>
+#include <regex>
 
 #define S(x) std::to_string(x)
 
-extern ll::Logger                logger;
+extern ll::Logger logger;
-extern GMLIB::Files::JsonConfig* Config;
+
+extern GMLIB::Files::JsonConfig*     Config;
+extern GMLIB::Files::I18n::JsonI18n* Language;
 
 extern void RegisterCommands();
 extern void initPlugin();
 
-extern int item_despawn_time;
+namespace ConfigFile {
+extern int  mItemDespawnTicks;
+extern bool mConsoleLog;
+extern bool mAnnounce;
+extern bool mSendToast;
+} // namespace ConfigFile
 
 namespace Cleaner {
-
+extern void CleanTask();
-static std::shared_ptr<ll::schedule::task::Task<ll::chrono::ServerClock>> mAutoCleanTask;
+extern void reloadCleaner();
-static std::shared_ptr<ll::schedule::task::Task<ll::chrono::ServerClock>> mCheckCleanTask;
-
 extern void loadCleaner();
 extern void unloadCleaner();
-extern void reloadCleaner();
-extern void CleanTask();
-
 } // namespace Cleaner
 
+namespace Helper {
+extern void broadcastMessage(std::string msg);
+extern void broadcastToast(std::string msg);
+} // namespace Helper
+
 extern std::string tr(std::string key, std::vector<std::string> data = {});

src/Initialization.cpp

@@ -15,7 +15,6 @@ void initPlugin() {
     Language->updateOrCreateLanguage("en_US", defaultLanguage_en_US);
     Language->updateOrCreateLanguage("zh_CN", defaultLanguage_zh_CN);
     Language->loadAllLanguages();
-    logger.warn("language {}", languageCode);
     Language->chooseLanguage(languageCode);
 }
 

src/RegisterCommand.cpp

@@ -33,11 +33,14 @@ void RegCleanerCommand() {
             switch (param.action) {
             case CleanerParam::Action::clean: {
                 Cleaner::CleanTask();
-                if (Config->getValue<bool>({"Basic", "ConsoleLog"}, true)) {
+                if (ConfigFile::mConsoleLog) {
                     logger.info(tr("cleaner.output.opClean"));
                 }
-                if (Config->getValue<bool>({"Basic", "SendBroadcast"}, true)) {
+                if (ConfigFile::mAnnounce) {
-                    TextPacket::createRawMessage(tr("cleaner.info.prefix") + tr("cleaner.output.opClean")).sendToClients();
+                    Helper::broadcastMessage(tr("cleaner.output.opClean"));
+                }
+                if (ConfigFile::mSendToast) {
+                    Helper::broadcastToast(tr("cleaner.output.opClean"));
                 }
                 return output.success(tr("cleaner.command.clean.output"));
             }
@@ -61,19 +64,19 @@ void RegCleanerCommand() {
         .required("despawntime")
         .required("ticks")
         .execute<[&](CommandOrigin const& origin, CommandOutput& output, CleanerParam const& param) {
-            item_despawn_time = param.ticks;
+            ConfigFile::mItemDespawnTicks = param.ticks;
-            Config->setValue({"ItemDespawn", "DespawnTime"}, item_despawn_time);
+            Config->setValue({"ItemDespawn", "DespawnTime"}, ConfigFile::mItemDespawnTicks);
-            return output.success(tr("cleaner.command.despawntime", {S(item_despawn_time)}));
+            return output.success(tr("cleaner.command.despawntime", {S(ConfigFile::mItemDespawnTicks)}));
         }>();
 };
 
 void RegisterCommands() {
     RegCleanerCommand();
-    // RegVoteCommand(registry);
+    // RegVoteCommand();
 }
 
 /*
-void RegVoteCommand(CommandRegistry& registry) {
+void RegVoteCommand() {
     auto command = DynamicCommand::createCommand(registry, "voteclean", "Clean entities", CommandPermissionLevel::Any);
     command->addOverload();
     command->setCallback([](DynamicCommand const&                                    cmd,