refactor: rewrite all

src/Cleaner.cpp

@@ -1,229 +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;
-
-ServerTimeAsyncScheduler scheduler;
-bool                     auto_clean_triggerred = false;
-
-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"}, 15);
-    auto time_1        = std::chrono::seconds::duration(time);
-    auto time_2        = std::chrono::seconds::duration(time - announce_time);
-    logger.info(tr("cleaner.output.count1", {S(time_1.count())}));
-    scheduler.add<DelayTask>(time_2, [announce_time] { logger.info(tr("cleaner.output.count2", {S(announce_time)})); });
-    scheduler.add<DelayTask>(time_1, [] {
-        auto count = ExecuteClean();
-        logger.info(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;
-                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);
-}
-
-void unloadCleaner() {
-    mAutoCleanTask->cancel();
-    mCheckCleanTask->cancel();
-    delete Config;
-}
-
-} // namespace Cleaner

src/Config.h

@@ -1,16 +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,
+        "ConsoleLog": true,
         "SendBroadcast": true,
-        "SendToast": false
+        "SendToast": true
     },
+    "IgnoreTags": [
+        "ignore",
+        "不清理"
+    ],
     "AutoCleanCount": {
         "Enabled": true,
         "TriggerCount": 900
@@ -27,6 +31,7 @@ inline std::string defaultConfig = R"({
         ]
     },
     "CleanInanimate": {
+        "Enabled": true,
         "Blacklist": [
             "minecraft:xp_orb",
             "minecraft:arrow",
@@ -35,8 +40,7 @@ inline std::string defaultConfig = R"({
             "minecraft:wither_skull",
             "minecraft:wither_skull_dangerous",
             "minecraft:dragon_fireball"
-        ],
+        ]
-        "Enabled": true
     },
     "CleanItem": {
         "Enabled": true,
@@ -66,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",
@@ -89,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,105 @@
+#include "Cleaner.h"
+
+namespace ConfigFile {
+
+bool mConsoleLog = true;
+bool mAnnounce   = true;
+bool mSendToast  = true;
+
+} // namespace ConfigFile
+
+
+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;
+
+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,33 @@
+#include "Cleaner.h"
+
+namespace Cleaner {
+
+void loadCleaner() {
+    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(); }
+
+void reloadCleaner() {
+    unloadCleaner();
+    Config->init();
+    std::string languageCode = Config->getValue<std::string>({"Basic", "Language"}, "en_US");
+    Language->loadAllLanguages();
+    Language->chooseLanguage(languageCode);
+    loadCleaner();
+}
+
+} // namespace Cleaner

src/Features/Cleaner.h

@@ -0,0 +1,29 @@
+#pragma once
+#include "Global.h"
+
+using namespace ll::schedule;
+using namespace ll::chrono_literals;
+
+namespace Cleaner {
+
+extern ServerTimeScheduler scheduler;
+
+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();
+extern void CleanTask();
+extern void reloadCleaner();
+extern void loadCleaner();
+extern void unloadCleaner();
+
+} // namespace Cleaner
+
+namespace VoteClean {
+
+extern void voteCommandExecute(Player* pl);
+
+}

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/Features/VoteClean.cpp

@@ -0,0 +1,138 @@
+#include "Cleaner.h"
+#include "Global.h"
+
+namespace VoteClean {
+
+bool hasVote     = false;
+bool canVote     = true;
+int  playerCount = 0;
+
+std::unordered_map<mce::UUID, bool> voteList;
+
+static std::shared_ptr<ll::schedule::task::Task<ll::chrono::ServerClock>> mAutoCleanTask;
+
+int getPlayerCount() {
+    int result = 0;
+    ll::service::getLevel()->forEachPlayer([&](Player& pl) -> bool {
+        if (!pl.isSimulatedPlayer()) {
+            result++;
+        }
+        return true;
+    });
+    return result;
+}
+
+void sendVoteForm(Player* pl) {
+    auto fm = ll::form::ModalForm(
+        tr("cleaner.vote.title"),
+        tr("cleaner.vote.subtitle", {pl->getRealName()}),
+        tr("cleaner.vote.ok"),
+        tr("cleaner.vote.no")
+    );
+    ll::service::getLevel()->forEachPlayer([&](Player& pl) -> bool {
+        fm.sendTo(pl, [](Player& player, ll::form::ModalForm::SelectedButton button) {
+            switch (button) {
+            case ll::form::ModalForm::SelectedButton::Upper: {
+                voteList[player.getUuid()] = true;
+                player.sendMessage(tr("cleaner.vote.accept"));
+                return;
+            }
+            case ll::form::ModalForm::SelectedButton::Lower: {
+                voteList[player.getUuid()] = false;
+                player.sendMessage(tr("cleaner.vote.deny"));
+                return;
+            }
+            default:
+                return;
+            }
+        });
+        return true;
+    });
+}
+
+void checkVote() {
+    float percentage = Config->getValue<float>({"VoteClean", "Percentage"}, 50.0f) / 100.0f;
+    int   voteCount  = 0;
+    for (auto& key : voteList) {
+        if (key.second == true) {
+            voteCount++;
+        }
+    }
+    float result = ((float)voteCount) / ((float)playerCount);
+    if (result >= percentage) {
+        if (ConfigFile::mAnnounce) {
+            Helper::broadcastMessage(tr("cleaner.vote.succeed"));
+        }
+        if (ConfigFile::mSendToast) {
+            Helper::broadcastToast(tr("cleaner.vote.succeed"));
+        }
+        Cleaner::CleanTask();
+    } else {
+        if (ConfigFile::mAnnounce) {
+            Helper::broadcastMessage(tr("cleaner.vote.failed"));
+        }
+        if (ConfigFile::mSendToast) {
+            Helper::broadcastToast(tr("cleaner.vote.failed"));
+        }
+    }
+    hasVote     = false;
+    playerCount = 0;
+}
+
+void voteClean(Player* pl) {
+    voteList.clear();
+    canVote     = false;
+    hasVote     = true;
+    playerCount = getPlayerCount();
+    if (ConfigFile::mAnnounce) {
+        Helper::broadcastMessage(tr("cleaner.vote.voteMessage", {pl->getRealName()}));
+    }
+    if (ConfigFile::mSendToast) {
+        Helper::broadcastToast(tr("cleaner.vote.voteMessage", {pl->getRealName()}));
+    }
+    sendVoteForm(pl);
+    auto cooldown = std::chrono::seconds::duration(Config->getValue<int>({"VoteClean", "Cooldown"}, 120));
+    auto waitTime = std::chrono::seconds::duration(Config->getValue<int>({"VoteClean", "CheckDelay"}, 30));
+    Cleaner::scheduler.add<DelayTask>(cooldown, [] { canVote = false; });
+    Cleaner::scheduler.add<DelayTask>(waitTime, [] { checkVote(); });
+}
+
+void confirmForm(Player* pl) {
+    auto fm = ll::form::ModalForm(
+        tr("cleaner.vote.title"),
+        tr("cleaner.vote.confirmTubtitle"),
+        tr("cleaner.vote.confirmOk"),
+        tr("cleaner.vote.confirmNo")
+    );
+    fm.sendTo(*pl, [](Player& player, ll::form::ModalForm::SelectedButton button) {
+        switch (button) {
+        case ll::form::ModalForm::SelectedButton::Upper: {
+            return voteClean(&player);
+        }
+        case ll::form::ModalForm::SelectedButton::Lower: {
+            return player.sendMessage(tr("cleaner.vote.cancel"));
+        }
+        default:
+            return;
+        }
+    });
+}
+
+void voteCommandExecute(Player* pl) {
+    if (!hasVote) {
+        if (canVote) {
+            confirmForm(pl);
+        } else {
+            pl->sendMessage(tr("cleaner.vote.cooldown"));
+        }
+    } else {
+        if (voteList.count(pl->getUuid())) {
+            pl->sendMessage(tr("cleaner.vote.voted"));
+        } else {
+            voteList[pl->getUuid()] = true;
+            pl->sendMessage(tr("cleaner.vote.accept"));
+        }
+    }
+}
+
+} // namespace VoteClean

src/Global.h

@@ -1,27 +1,28 @@
 #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 {
+namespace Helper {
-
+extern void broadcastMessage(std::string msg);
-static std::shared_ptr<ll::schedule::task::Task<ll::chrono::ServerClock>> mAutoCleanTask;
+extern void broadcastToast(std::string msg);
-static std::shared_ptr<ll::schedule::task::Task<ll::chrono::ServerClock>> mCheckCleanTask;
+} // namespace Helper
-
-extern void loadCleaner();
-extern void unloadCleaner();
-extern void reloadCleaner();
-extern void CleanTask();
-
-} // namespace Cleaner
 
 extern std::string tr(std::string key, std::vector<std::string> data = {});

src/Initialization.cpp

@@ -12,10 +12,9 @@ void initPlugin() {
     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("en_US", defaultLanguage_en_US);
     Language->updateOrCreateLanguage("zh_CN", defaultLanguage_zh_CN);
     Language->loadAllLanguages();
-    logger.warn("language {}", languageCode);
     Language->chooseLanguage(languageCode);
 }
 

src/Language.h

@@ -1,13 +1,51 @@
 #pragma once
 #include "Global.h"
 
+std::string defaultLanguage_en_US = R"({
+    "cleaner.info.prefix": "§e§l[Cleaner] §r",
+    "cleaner.command.cleaner": "Cleaner admin command.",
+    "cleaner.command.despawnSuccess": "Successfully despawned %1$s entities.",
+    "cleaner.command.error.noTarget": "No targets matched the selector.",
+    "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.mspt.output": "Current server MSPT %1$s.",
+    "cleaner.command.clean.output": "Clean task successfully initiated!",
+    "cleaner.command.voteclean": "Initiate entity clean vote.",
+    "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.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.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.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.vote.cooldown": "Vote cleaning cooldown...",
+    "cleaner.vote.cancel": "Vote canceled!",
+    "cleaner.vote.confirmNo": "Think again",
+    "cleaner.vote.confirmOk": "Initiate vote",
+    "cleaner.vote.confirmTubtitle": "Do you want to initiate a clean vote?",
+    "cleaner.vote.accept": "You have agreed to entity cleaning.",
+    "cleaner.vote.deny": "You have declined entity cleaning.",
+    "cleaner.vote.no": "Deny",
+    "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.timeout": "Vote has expired!",
+    "cleaner.vote.succeed": "Vote cleaning successful!",
+    "cleaner.vote.failed": "Vote cleaning did not passed!",
+    "cleaner.vote.title": "Vote Cleaning",
+    "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."
+})";
+
 std::string defaultLanguage_zh_CN = R"({
+    "cleaner.toast.title": "§e§lCleaner",
     "cleaner.command.cleaner": "Cleaner管理员命令。",
     "cleaner.command.despawnSuccess": "已成功清除了 %1$s 个实体",
     "cleaner.command.error.noTarget": "没有与选择器匹配的目标",
     "cleaner.command.error.playerOnly": "该命令只能由玩家执行！",
     "cleaner.command.tps.output": "当前服务器实时TPS %1$s §r，平均TPS %2$s",
     "cleaner.command.mspt.output": "当前服务器实MSPT %1$s",
+    "cleaner.command.clean.output": "已成功启动清理任务！",
     "cleaner.command.voteclean": "发起实体清理投票。",
     "cleaner.command.despawntime" : "已成功将物品消失时间设置为 %1$s 游戏刻",
     "cleaner.output.count1": "系统将在 %1$s 秒后自动清理服务器实体！",
@@ -17,7 +55,7 @@ std::string defaultLanguage_zh_CN = R"({
     "cleaner.output.reload": "已重载Cleaner插件，部分配置可能需要重启服务器才能生效。",
     "cleaner.output.triggerAutoCleanCount": "检测到服务器实体过多！！当前服务器存在 %1$s 个可清理实体，已启动自动清理程序。",
     "cleaner.output.triggerAutoCleanTps": "当前服务器TPS过低！！服务器平均TPS %1$s\n系统已启动清理程序。",
-    "cleaner.vote.cooldown": "投票清理冷却...",
+    "cleaner.vote.cooldown": "投票清理正在冷却...",
     "cleaner.vote.cancel": "投票已取消！",
     "cleaner.vote.confirmNo": "我再想想",
     "cleaner.vote.confirmOk": "发起投票",
@@ -26,9 +64,11 @@ std::string defaultLanguage_zh_CN = R"({
     "cleaner.vote.deny": "你已拒绝实体清理。",
     "cleaner.vote.no": "拒绝",
     "cleaner.vote.ok": "同意",
-    "cleaner.vote.Subtitle": "你是否同意现在清理服务器实体？",
+    "cleaner.vote.subtitle": "%1$s 发起了服务器实体清理投票！\n\n你是否同意现在清理服务器实体？",
-    "cleaner.vote.Timeout": "投票已过期！",
+    "cleaner.vote.timeout": "投票已过期！",
     "cleaner.vote.succeed": "投票清理成功！",
+    "cleaner.vote.failed": "投票清理未通过。",
     "cleaner.vote.title": "投票清理",
-    "cleaner.vote.toastNotice": "通知"
+    "cleaner.vote.voted": "你已经投过票了！",
+    "cleaner.vote.voteMessage": "%1$s 发起了服务器实体清理投票！如果同意清理但是未收到表单，请输入命令 /voteclean 投票。拒绝清理请忽略此信息。"
 })";

src/Plugin.cpp

@@ -1,3 +1,4 @@
+#include "Features/Cleaner.h"
 #include "Global.h"
 
 ll::Logger logger("Cleaner");
@@ -10,6 +11,8 @@ Plugin::Plugin(ll::plugin::NativePlugin& self) : mSelf(self) {
 }
 
 bool Plugin::enable() {
+    Cleaner::ListenEvents();
+    RegisterCommands();
     Cleaner::loadCleaner();
     logger.info("Cleaner Loaded!");
     logger.info("Author: GroupMountain");

src/RegisterCommand.cpp

@@ -1,3 +1,4 @@
+#include "Features/Cleaner.h"
 #include "Global.h"
 
 struct CleanerParam {
@@ -33,7 +34,16 @@ void RegCleanerCommand() {
             switch (param.action) {
             case CleanerParam::Action::clean: {
                 Cleaner::CleanTask();
-                return output.success(tr("cleaner.output.opClean"));
+                if (ConfigFile::mConsoleLog) {
+                    logger.info(tr("cleaner.output.opClean"));
+                }
+                if (ConfigFile::mAnnounce) {
+                    Helper::broadcastMessage(tr("cleaner.output.opClean"));
+                }
+                if (ConfigFile::mSendToast) {
+                    Helper::broadcastToast(tr("cleaner.output.opClean"));
+                }
+                return output.success(tr("cleaner.command.clean.output"));
             }
             case CleanerParam::Action::tps: {
                 return output.success(
@@ -55,27 +65,30 @@ 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() {
+void RegVoteCommand() {
-    RegCleanerCommand();
+    auto& cmd = ll::command::CommandRegistrar::getInstance().getOrCreateCommand(
-    // RegVoteCommand(registry);
+        Config->getValue<std::string>({"VoteClean", "VoteCleanCommand"}, "voteclean"),
+        tr("cleaner.command.voteclean"),
+        CommandPermissionLevel::Any
+    );
+    cmd.overload().execute<[&](CommandOrigin const& origin, CommandOutput& output) {
+        if (origin.getOriginType() == CommandOriginType::Player) {
+            auto pl = (Player*)origin.getEntity();
+            return VoteClean::voteCommandExecute(pl);
+        }
+        return output.error(tr("cleaner.command.error.playerOnly"));
+    }>();
 }
 
-/*
+void RegisterCommands() {
-void RegVoteCommand(CommandRegistry& registry) {
+    RegCleanerCommand();
-    auto command = DynamicCommand::createCommand(registry, "voteclean", "Clean entities", CommandPermissionLevel::Any);
+    if (Config->getValue<bool>({"VoteClean", "Enabled"}, false)) {
-    command->addOverload();
+        RegVoteCommand();
-    command->setCallback([](DynamicCommand const&                                    cmd,
+    }
-                            CommandOrigin const&                                     origin,
+}
-                            CommandOutput&                                           output,
-                            std::unordered_map<std::string, DynamicCommand::Result>& result) {
-        // vote clean command
-    });
-    DynamicCommand::setup(registry, std::move(command));
-}
-*/