adapt: adapt LeviLamina v0.9.5

src/Features/CleanTask.cpp

@@ -11,8 +11,9 @@ bool mSendToast  = true;
 
 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>> mAutoCleanTask  = nullptr;
-static std::shared_ptr<ll::schedule::task::Task<ll::chrono::ServerClock>> mCheckCleanTask;
+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;
 
@@ -63,8 +64,8 @@ void AutoCleanTask(int seconds) {
     mAutoCleanTask = scheduler.add<RepeatTask>(time, [] { CleanTask(); });
 }
 
-void CheckCleanTask(int max_entities, float min_tps) {
+void CleanTaskCount(int max_entities) {
-    mCheckCleanTask = scheduler.add<RepeatTask>(10s, [max_entities, min_tps] {
+    mCleanTaskCount = scheduler.add<RepeatTask>(10s, [max_entities] {
         auto count = CountEntities();
         if (auto_clean_triggerred == false) {
             if (count >= max_entities) {
@@ -79,17 +80,25 @@ void CheckCleanTask(int max_entities, float min_tps) {
                     Helper::broadcastToast(tr("cleaner.output.triggerAutoCleanCount", {S(count)}));
                 }
                 CleanTask();
-            } else if (GMLIB_Level::getLevel()->getServerAverageTps() <= min_tps) {
+            }
+        }
+    });
+}
+
+void CleanTaskTPS(float min_tps) {
+    mCleanTaskTPS = scheduler.add<RepeatTask>(10s, [min_tps] {
+        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) {
-                    logger.warn(tr("cleaner.output.triggerAutoCleanCount", {mspt}));
+                    logger.warn(tr("cleaner.output.triggerAutoCleanTps", {mspt}));
                 }
                 if (ConfigFile::mAnnounce) {
-                    Helper::broadcastMessage(tr("cleaner.output.triggerAutoCleanCount", {mspt}));
+                    Helper::broadcastMessage(tr("cleaner.output.triggerAutoCleanTps", {mspt}));
                 }
                 if (ConfigFile::mSendToast) {
-                    Helper::broadcastToast(tr("cleaner.output.triggerAutoCleanCount", {mspt}));
+                    Helper::broadcastToast(tr("cleaner.output.triggerAutoCleanTps", {mspt}));
                 }
                 CleanTask();
             }
@@ -98,8 +107,17 @@ void CheckCleanTask(int max_entities, float min_tps) {
 }
 
 void stopAllTasks() {
-    mCheckCleanTask->cancel();
+    if (!mCleanTaskCount) {
-    mAutoCleanTask->cancel();
+        mCleanTaskTPS->cancel();
+        scheduler.remove(mCleanTaskTPS);
+    }
+    if (mCleanTaskCount) {
+        mCleanTaskCount->cancel();
+        scheduler.remove(mCleanTaskCount);
+    }
+    if (mAutoCleanTask) {
+        mAutoCleanTask->cancel();
+        scheduler.remove(mAutoCleanTask);
+    }
 }
-
 } // namespace Cleaner

src/Features/Cleaner.cpp

@@ -6,12 +6,11 @@ void loadCleaner() {
     if (Config->getValue<bool>({"ScheduleClean", "Enabled"}, false)) {
         Cleaner::AutoCleanTask(Config->getValue<int>({"ScheduleClean", "CleanInterval"}, 3000));
     }
-    if (Config->getValue<bool>({"AutoCleanCount", "Enabled"}, false)
+    if (Config->getValue<bool>({"AutoCleanCount", "Enabled"}, false)) {
-        || Config->getValue<bool>({"AutoCleanTPS", "Enabled"}, false)) {
+        Cleaner::CleanTaskCount(Config->getValue<int>({"AutoCleanCount", "TriggerCount"}, 900));
-        Cleaner::CheckCleanTask(
+    }
-            Config->getValue<int>({"AutoCleanCount", "TriggerCount"}, 900),
+    if (Config->getValue<bool>({"AutoCleanTPS", "Enabled"}, false)) {
-            Config->getValue<int>({"AutoCleanTPS", "TriggerTPS"}, 15)
+        Cleaner::CleanTaskTPS(Config->getValue<float>({"AutoCleanTPS", "TriggerTPS"}, 15.0f));
-        );
     }
     ConfigFile::mItemDespawnTicks = Config->getValue<int>({"ItemDespawn", "DespawnTime"}, 6000);
     ConfigFile::mAnnounce         = Config->getValue<bool>({"Basic", "SendBroadcast"}, true);
@@ -23,9 +22,9 @@ void unloadCleaner() { stopAllTasks(); }
 
 void reloadCleaner() {
     unloadCleaner();
-    Config->init();
+    Config->reload();
     std::string languageCode = Config->getValue<std::string>({"Basic", "Language"}, "en_US");
-    Language->loadAllLanguages();
+    Language->reloadAllLanguages();
     Language->chooseLanguage(languageCode);
     loadCleaner();
 }

src/Features/Cleaner.h

@@ -12,7 +12,8 @@ extern int ExecuteClean();
 extern int CountEntities();
 
 extern void AutoCleanTask(int seconds);
-extern void CheckCleanTask(int max_entities, float min_tps);
+extern void CleanTaskCount(int max_entities);
+extern void CleanTaskTPS(float min_tps);
 extern void ListenEvents();
 extern void stopAllTasks();
 extern void CleanTask();
@@ -20,6 +21,8 @@ extern void reloadCleaner();
 extern void loadCleaner();
 extern void unloadCleaner();
 
+extern bool isMatch(std::string& A, std::string& B);
+
 } // namespace Cleaner
 
 namespace VoteClean {

src/Features/Events.cpp

@@ -29,7 +29,17 @@ void ListenEvents() {
                     return;
                 }
             }
+            if (Config->getValue<bool>({"ItemDespawn", "Enabled"}, true)) {
                 item.lifeTime() = ConfigFile::mItemDespawnTicks;
+                auto list       = Config->getValue<std::vector<std::string>>({"ItemDespawn", "WhiteList"}, {});
+                auto type       = item.item().getTypeName();
+                for (auto& key : list) {
+                    if (isMatch(type, key)) {
+                        return;
+                    }
+                }
+                item.lifeTime() = ConfigFile::mItemDespawnTicks;
+            }
         }
     );
     // MobTakeItemEvent

src/Features/Helper.cpp

@@ -2,13 +2,8 @@
 
 namespace Helper {
 
-void broadcastMessage(std::string msg) {
+void broadcastMessage(std::string_view msg) { GMLIB_Level::broadcast(tr("cleaner.info.prefix") + std::string(msg)); }
-    TextPacket::createRawMessage(tr("cleaner.info.prefix") + msg).sendToClients();
-}
 
-void broadcastToast(std::string msg) {
+void broadcastToast(std::string_view msg) { GMLIB_Level::broadcastToast(tr("cleaner.info.prefix"), msg); }
-    auto pkt = ToastRequestPacket(tr("cleaner.info.prefix"), msg);
-    pkt.sendToClients();
-}
 
 } // namespace Helper

src/Global.h

@@ -21,8 +21,8 @@ extern bool mSendToast;
 } // namespace ConfigFile
 
 namespace Helper {
-extern void broadcastMessage(std::string msg);
+extern void broadcastMessage(std::string_view msg);
-extern void broadcastToast(std::string msg);
+extern void broadcastToast(std::string_view msg);
 } // namespace Helper
 
 extern std::string tr(std::string key, std::vector<std::string> data = {});

tooth.json

@@ -1,19 +1,21 @@
 {
     "format_version": 2,
     "tooth": "github.com/GroupMountain/Cleaner",
-    "version": "0.8.0",
+    "version": "0.9.1",
     "info": {
         "name": "Cleaner",
         "description": "A Powerful Entities Cleaning up Plugin for BDS",
         "author": "GroupMountain",
+        "source": "github.com/GroupMountain/Cleaner",
         "tags": [
-            "LeviLamina",
+            "levilamina",
-            "Cleaner"
+            "cleaner",
+            "gmlib"
         ]
     },
-    "asset_url": "https://github.com/GroupMountain/Cleaner/releases/download/v0.8.0/Cleaner-windows-x64.zip",
+    "asset_url": "https://github.com/GroupMountain/Cleaner/releases/download/v0.9.1/Cleaner-windows-x64.zip",
     "dependencies": {
-        "github.com/GroupMountain/GMLIB": ">=0.8.0"
+        "github.com/GroupMountain/GMLIB": ">=0.9.6"
     },
     "files": {
         "place": [