feat: adapt levlamina 1.6.x

feat: adapt to gmlib 1.5.0

.clangd

@@ -1,5 +1,23 @@
 Diagnostics:
-  Suppress: ["-Wmicrosoft-enum-forward-reference", "-Wc++11-narrowing", "-Wc++2b-extensions", "-Wmicrosoft-cast"]
+  Suppress:
+    - "-Wmicrosoft-enum-forward-reference"
+    - "-Wc++11-narrowing"
+    - "-Wc++2b-extensions"
+    - "-Wmicrosoft-cast"
+    - "-Wcxx20_deducing_this"
+    - "-Wundefined_internal_type"
+    - "-Wincomplete_member_access"
+    - "-Wsizeof_alignof_incomplete_or_sizeless_type"
+    - "-Wexplicit_spec_non_template"
+    - "-Wovl_no_viable_function_in_init"
 CompileFlags:
-  Add: ["-ferror-limit=0", "-D__FUNCTION__=\"dummy\"", "-D_CRT_USE_BUILTIN_OFFSETOF", "-std=c++23"]
-  Remove: ["/Yu_HeaderOutputPredefine.h", "/FI_HeaderOutputPredefine.h"]
+  Add:
+    - "-Xclang"
+    - "-triple=x86_64-windows-msvc"
+    - "-ferror-limit=0"
+    - '-D__FUNCTION__="dummy"'
+    - "-Dnsel_CONFIG_SELECT_EXPECTED=nsel_EXPECTED_NONSTD"
+    - "-Xclang"
+    - "-std=c++23"
+  Remove:
+    - "-std"

.github/workflows/build.yml

@@ -16,7 +16,8 @@ jobs:
 
       - uses: xmake-io/github-action-setup-xmake@v1
         with:
-          xmake-version: latest
+          xmake-version: 3.0.0
+          
       - run: |
           xmake repo -u
 
@@ -26,7 +27,7 @@ jobs:
       - run: |
           xmake -w -y
 
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           name: ${{ github.event.repository.name }}-windows-x64-${{ github.sha }}
           path: |

.github/workflows/release.yml

@@ -16,7 +16,8 @@ jobs:
 
       - uses: xmake-io/github-action-setup-xmake@v1
         with:
-          xmake-version: latest
+          xmake-version: 3.0.0
+          
       - run: |
           xmake repo -u
 
@@ -26,7 +27,7 @@ jobs:
       - run: |
           xmake -w -y
 
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           name: ${{ github.event.repository.name }}-windows-x64-${{ github.sha }}
           path: |
@@ -41,7 +42,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
         with:
           name: ${{ github.event.repository.name }}-windows-x64-${{ github.sha }}
           path: release/

README.md

@@ -101,6 +101,13 @@
         "Cooldown": 120, // 投票冷却时间 单位:秒
         "CheckDelay": 30, // 投票时长 单位:秒
         "Percentage": 50 // 投票百分比(大于此值则清理)
+    },
+    "UnloadActorClean": { // 离线实体清理
+        "Enabled": false, // 是否启用
+        "CleanList": [ // 清理实体列表
+            "minecraft:iron_golem", // 铁傀儡
+            "minecraft:zombie_pigman" // 僵尸猪灵
+        ]
     }
 }
 ```

manifest.json

@@ -2,12 +2,20 @@
     "name": "${modName}",
     "entry": "${modFile}",
     "type": "native",
-    "version": "0.13.2",
+    "version": "0.15.0",
     "author": "GroupMountain",
     "description": "Clean Entities",
     "dependencies": [
         {
             "name": "GMLIB"
+        },
+        {
+            "name": "iListenAttentively"
+        }
+    ],
+    "optionalDependencies": [
+        {
+            "name": "ModAPI"
         }
     ]
-}
+}

src/Config.h

@@ -1,7 +1,8 @@
 #pragma once
-#include <iostream>
+#include <string>
 #include <vector>
 
+namespace Cleaner {
 struct Config {
     int version = 2;
 
@@ -90,4 +91,10 @@ struct Config {
         int         CheckDelay       = 30;
         int         Percentage       = 50;
     } VoteClean;
+
+    struct Unload_Actor_Clean {
+        bool                     Enabled   = false;
+        std::vector<std::string> CleanList = {"minecraft:iron_golem", "minecraft:zombie_pigman"};
+    } UnloadActorClean;
 };
+} // namespace Cleaner

src/Features/Clean.cpp

@@ -1,5 +1,6 @@
 #include "Cleaner.h"
-
+#include "mc/world/actor/provider/SynchedActorDataAccess.h"
+#include "gmlib/mc/world/actor/Actor.h"
 namespace Cleaner {
 
 bool isMatch(std::string& A, std::string& B) {
@@ -15,9 +16,11 @@ bool isMatch(std::string& A, std::string& B) {
     return (A == B);
 }
 
-bool shouldIgnore(GMLIB_Actor* ac) {
-    if (ac->isMob() || ac->isItemActor()) {
-        if (ac->isTame() || ac->isTrusting() || ac->getNameTag() != "" || ac->hasTag("cleaner:ignore")) {
+bool isTrust(Actor* ac) { return SynchedActorDataAccess::getActorFlag(ac->getEntityContext(), ::ActorFlags::Trusting); }
+
+bool shouldIgnore(gmlib::GMActor* ac) {
+    if (ac->hasCategory(::ActorCategory::Mob) || ac->hasCategory(::ActorCategory::Item)) {
+        if (ac->isTame() || isTrust(ac) || ac->getNameTag() != "" || ac->hasTag("cleaner:ignore")) {
             return true;
         }
     }
@@ -27,7 +30,7 @@ bool shouldIgnore(GMLIB_Actor* ac) {
 bool ShouldClean(Actor* actor) {
     // Players
     auto& config = Cleaner::Entry::getInstance().getConfig();
-    auto  en     = (GMLIB_Actor*)actor;
+    auto  en     = (gmlib::GMActor*)actor;
     if (en->isPlayer() || shouldIgnore(en)) {
         return false;
     }
@@ -38,7 +41,7 @@ bool ShouldClean(Actor* actor) {
         }
     }
     // Items
-    if (en->isItemActor()) {
+    if (en->hasCategory(::ActorCategory::Item)) {
         if (config.CleanItem.Enabled) {
             auto itac = (ItemActor*)en;
             if (itac->age() <= config.CleanItem.ExistTicks) {
@@ -56,7 +59,7 @@ bool ShouldClean(Actor* actor) {
         return false;
     }
     // Mobs
-    else if (en->isMob()) {
+    else if (en->hasCategory(::ActorCategory::Mob)) {
         if (config.CleanMobs.Enabled) {
             auto blacklist = config.CleanMobs.BlackList;
             for (auto& key : blacklist) {
@@ -94,8 +97,9 @@ bool ShouldClean(Actor* actor) {
 }
 
 int ExecuteClean() {
+    auto level        = ll::service::getLevel();
     int  clean_count  = 0;
-    auto all_entities = GMLIB_Level::getLevel()->getRuntimeActorList();
+    auto all_entities = level->getRuntimeActorList();
     for (auto entity : all_entities) {
         if (ShouldClean(entity)) {
             entity->despawn();
@@ -106,8 +110,9 @@ int ExecuteClean() {
 }
 
 int CountEntities() {
+    auto level        = ll::service::getLevel();
     int  clean_count  = 0;
-    auto all_entities = GMLIB_Level::getLevel()->getRuntimeActorList();
+    auto all_entities = level->getRuntimeActorList();
     for (auto* entity : all_entities) {
         if (ShouldClean(entity)) {
             clean_count++;

src/Features/CleanTask.cpp

@@ -1,21 +1,25 @@
 #include "Cleaner.h"
-
+#include <memory>
+#include "gmlib/mc/world/Level.h"
+#include "gmlib/gm/data/TpsStatus.h"
 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;
+static std::shared_ptr<bool> mAutoCleanTask  = std::make_shared<bool>(false);
+static std::shared_ptr<bool> mCleanTaskCount = std::make_shared<bool>(false);
+static std::shared_ptr<bool> mCleanTaskTPS   = std::make_shared<bool>(false);
 
 bool auto_clean_triggerred = false;
 
 void CleanTask() {
-    auto& config        = Cleaner::Entry::getInstance().getConfig();
-    auto  time          = config.Basic.Notice1;
-    auto  announce_time = config.Basic.Notice2;
-    auto  time_1        = std::chrono::seconds::duration(time);
-    auto  time_2        = std::chrono::seconds::duration(time - announce_time);
+    auto&                config        = Cleaner::Entry::getInstance().getConfig();
+    auto                 time          = config.Basic.Notice1;
+    auto                 announce_time = config.Basic.Notice2;
+    std::chrono::seconds time_1(time);
+    std::chrono::seconds time_2(time - announce_time);
     if (config.Basic.ConsoleLog) {
-        logger.info(tr("cleaner.output.count1", {S(time_1.count())}));
+        ll::io::LoggerRegistry::getInstance().getOrCreate("Cleaner")->info(
+            tr("cleaner.output.count1", {S(time_1.count())})
+        );
     }
     if (config.Basic.SendBroadcast) {
         Helper::broadcastMessage(tr("cleaner.output.count1", {S(time_1.count())}));
@@ -23,9 +27,12 @@ void CleanTask() {
     if (config.Basic.SendToast) {
         Helper::broadcastToast(tr("cleaner.output.count2", {S(announce_time)}));
     }
-    Cleaner::Entry::getInstance().getScheduler().add<DelayTask>(time_2, [announce_time, &config] {
+    ll::coro::keepThis([announce_time, &config, time_2]() -> ll::coro::CoroTask<> {
+        co_await time_2;
         if (config.Basic.ConsoleLog) {
-            logger.info(tr("cleaner.output.count2", {S(announce_time)}));
+            ll::io::LoggerRegistry::getInstance().getOrCreate("Cleaner")->info(
+                tr("cleaner.output.count2", {S(announce_time)})
+            );
         }
         if (config.Basic.SendBroadcast) {
             Helper::broadcastMessage(tr("cleaner.output.count2", {S(announce_time)}));
@@ -33,11 +40,13 @@ void CleanTask() {
         if (config.Basic.SendToast) {
             Helper::broadcastToast(tr("cleaner.output.count2", {S(announce_time)}));
         }
-    });
-    Cleaner::Entry::getInstance().getScheduler().add<DelayTask>(time_1, [&config] {
+        co_return;
+    }).launch(ll::thread::ServerThreadExecutor::getDefault());
+    ll::coro::keepThis([announce_time, &config, time_1]() -> ll::coro::CoroTask<> {
+        co_await time_1;
         auto count = ExecuteClean();
         if (config.Basic.ConsoleLog) {
-            logger.info(tr("cleaner.output.finish", {S(count)}));
+            ll::io::LoggerRegistry::getInstance().getOrCreate("Cleaner")->info(tr("cleaner.output.finish", {S(count)}));
         }
         if (config.Basic.SendBroadcast) {
             Helper::broadcastMessage(tr("cleaner.output.finish", {S(count)}));
@@ -46,70 +55,92 @@ void CleanTask() {
             Helper::broadcastToast(tr("cleaner.output.finish", {S(count)}));
         }
         auto_clean_triggerred = false;
-    });
+        co_return;
+    }).launch(ll::thread::ServerThreadExecutor::getDefault());
 }
 
 void AutoCleanTask(int seconds) {
-    auto time      = std::chrono::seconds::duration(seconds);
-    mAutoCleanTask = Cleaner::Entry::getInstance().getScheduler().add<RepeatTask>(time, [] { CleanTask(); });
+    std::chrono::seconds time(seconds);
+    *mAutoCleanTask = true;
+    ll::coro::keepThis([time]() -> ll::coro::CoroTask<> {
+        while (true) {
+            co_await time;
+            if (*mAutoCleanTask == false) co_return;
+            CleanTask();
+        }
+        co_return;
+    }).launch(ll::thread::ServerThreadExecutor::getDefault());
 }
 
 void CleanTaskCount(int 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 (config.Basic.ConsoleLog) {
-                    logger.warn(tr("cleaner.output.triggerAutoCleanCount", {S(count)}));
+    auto& config     = Cleaner::Entry::getInstance().getConfig();
+    *mCleanTaskCount = true;
+    ll::coro::keepThis([max_entities, &config]() -> ll::coro::CoroTask<> {
+        while (true) {
+            co_await 10s;
+            if (*mCleanTaskCount == false) co_return;
+            auto count = CountEntities();
+            if (auto_clean_triggerred == false) {
+                if (count >= max_entities) {
+                    auto_clean_triggerred = true;
+                    if (config.Basic.ConsoleLog) {
+                        ll::io::LoggerRegistry::getInstance().getOrCreate("Cleaner")->warn(
+                            tr("cleaner.output.triggerAutoCleanCount", {S(count)})
+                        );
+                    }
+                    if (config.Basic.SendBroadcast) {
+                        Helper::broadcastMessage(tr("cleaner.output.triggerAutoCleanCount", {S(count)}));
+                    }
+                    if (config.Basic.SendToast) {
+                        Helper::broadcastToast(tr("cleaner.output.triggerAutoCleanCount", {S(count)}));
+                    }
+                    CleanTask();
                 }
-                if (config.Basic.SendBroadcast) {
-                    Helper::broadcastMessage(tr("cleaner.output.triggerAutoCleanCount", {S(count)}));
-                }
-                if (config.Basic.SendToast) {
-                    Helper::broadcastToast(tr("cleaner.output.triggerAutoCleanCount", {S(count)}));
-                }
-                CleanTask();
             }
         }
-    });
+        co_return;
+    }).launch(ll::thread::ServerThreadExecutor::getDefault());
 }
 
 void CleanTaskTPS(float 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 (config.Basic.ConsoleLog) {
-                    logger.warn(tr("cleaner.output.triggerAutoCleanTps", {mspt}));
+    auto& config   = Cleaner::Entry::getInstance().getConfig();
+    *mCleanTaskTPS = true;
+    ll::coro::keepThis([min_tps, &config]() -> ll::coro::CoroTask<> {
+        while (true) {
+            co_await 10s;
+            if (*mCleanTaskTPS == false) co_return;
+            if (auto_clean_triggerred == false) {
+                if (gmlib::TpsStatus::getInstance().getLevelAverageTps() <= min_tps) {
+                    auto_clean_triggerred = true;
+                    auto mspt             = S(gmlib::TpsStatus::getInstance().getLevelAverageTps());
+                    if (config.Basic.ConsoleLog) {
+                        ll::io::LoggerRegistry::getInstance().getOrCreate("Cleaner")->warn(
+                            tr("cleaner.output.triggerAutoCleanTps", {mspt})
+                        );
+                    }
+                    if (config.Basic.SendBroadcast) {
+                        Helper::broadcastMessage(tr("cleaner.output.triggerAutoCleanTps", {mspt}));
+                    }
+                    if (config.Basic.SendToast) {
+                        Helper::broadcastToast(tr("cleaner.output.triggerAutoCleanTps", {mspt}));
+                    }
+                    CleanTask();
                 }
-                if (config.Basic.SendBroadcast) {
-                    Helper::broadcastMessage(tr("cleaner.output.triggerAutoCleanTps", {mspt}));
-                }
-                if (config.Basic.SendToast) {
-                    Helper::broadcastToast(tr("cleaner.output.triggerAutoCleanTps", {mspt}));
-                }
-                CleanTask();
             }
         }
-    });
+        co_return;
+    }).launch(ll::thread::ServerThreadExecutor::getDefault());
 }
 
 void stopAllTasks() {
     if (!mCleanTaskCount) {
-        mCleanTaskTPS->cancel();
-        Cleaner::Entry::getInstance().getScheduler().remove(mCleanTaskTPS);
+        *mCleanTaskTPS = false;
     }
     if (mCleanTaskCount) {
-        mCleanTaskCount->cancel();
-        Cleaner::Entry::getInstance().getScheduler().remove(mCleanTaskCount);
+        *mCleanTaskCount = false;
     }
     if (mAutoCleanTask) {
-        mAutoCleanTask->cancel();
-        Cleaner::Entry::getInstance().getScheduler().remove(mAutoCleanTask);
+        *mAutoCleanTask = false;
     }
 }
 } // namespace Cleaner

src/Features/Cleaner.cpp

@@ -4,6 +4,9 @@ namespace Cleaner {
 
 void loadCleaner() {
     auto& config = Cleaner::Entry::getInstance().getConfig();
+    if(config.UnloadActorClean.Enabled){
+        UnloadActorClean::cleanUnloadActor();
+    }
     if (config.ScheduleClean.Enabled) {
         Cleaner::AutoCleanTask(config.ScheduleClean.CleanInterval);
     }

src/Features/Cleaner.h

@@ -1,7 +1,6 @@
 #pragma once
 #include "Global.h"
 
-using namespace ll::schedule;
 using namespace ll::chrono_literals;
 
 namespace Cleaner {
@@ -27,4 +26,10 @@ namespace VoteClean {
 
 extern void voteCommandExecute(Player* pl);
 
+}
+
+namespace UnloadActorClean {
+
+extern void cleanUnloadActor();
+
 }

src/Features/Events.cpp

@@ -1,44 +1,40 @@
 #include "Cleaner.h"
-
+#include "gmlib/mc/world/Level.h"
+#include "gmlib/mc/world/actor/Player.h"
 namespace Cleaner {
-
-void setShouldIgnore(GMLIB_Actor* ac) { ac->addTag("cleaner:ignore"); }
+void setShouldIgnore(gmlib::GMActor* 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>(
-        [&config](GMLIB::Event::EntityEvent::ItemActorSpawnAfterEvent& event) {
-            auto& item = event.getItemActor();
-            if (event.getSpawner().has_value()) {
-                auto pl = (GMLIB_Player*)event.getSpawner().as_ptr();
-                if (pl->isPlayer() && !pl->isAlive()) { // Death Drop
-                    auto ac = (GMLIB_Actor*)&item;
-                    setShouldIgnore(ac);
+    eventBus.emplaceListener<ila::mc::SpawnItemActorAfterEvent>([&config](ila::mc::SpawnItemActorAfterEvent& event) {
+        auto& item = event.itemActor();
+        if (event.spawner()) {
+            auto pl = (gmlib::GMPlayer*)event.spawner();
+            if (pl->isPlayer() && !pl->isAlive()) { // Death Drop
+                auto ac = (gmlib::GMActor*)&item;
+                setShouldIgnore(ac);
+                return;
+            }
+        }
+        if (config.ItemDespawn.Enabled) {
+            // item.lifeTime() = config.ItemDespawn.DespawnTime;
+            auto list        = config.ItemDespawn.WhiteList;
+            auto type        = item.item().getTypeName();
+            for (auto& key : list) {
+                if (isMatch(type, key)) {
                     return;
                 }
             }
-            if (config.ItemDespawn.Enabled) {
-                item.lifeTime() = config.ItemDespawn.DespawnTime;
-                auto list       = config.ItemDespawn.WhiteList;
-                auto type       = item.item().getTypeName();
-                for (auto& key : list) {
-                    if (isMatch(type, key)) {
-                        return;
-                    }
-                }
-                item.lifeTime() = config.ItemDespawn.DespawnTime;
-            }
+            item.lifeTime() = config.ItemDespawn.DespawnTime;
         }
-    );
+    });
     // MobTakeItemEvent
-    eventBus.emplaceListener<GMLIB::Event::EntityEvent::MobPickupItemAfterEvent>(
-        [](GMLIB::Event::EntityEvent::MobPickupItemAfterEvent& event) {
-            auto mob = (GMLIB_Actor*)&event.self();
-            setShouldIgnore(mob);
-        }
-    );
+    eventBus.emplaceListener<ila::mc::ActorPickupItemAfterEvent>([](ila::mc::ActorPickupItemAfterEvent& event) {
+        auto mob = (gmlib::GMActor*)&event.self();
+        setShouldIgnore(mob);
+    });
 }
 
 } // namespace Cleaner

src/Features/Helper.cpp

@@ -1,13 +1,13 @@
 #include "Global.h"
-
+#include "gmlib/mc/world/Level.h"
 namespace Helper {
 
 void broadcastMessage(std::string_view msg) {
-    GMLIB_Level::getInstance()->broadcast(tr("cleaner.info.prefix") + std::string(msg));
+    gmlib::GMLevel::getInstance()->broadcast(tr("cleaner.info.prefix") + std::string(msg));
 }
 
 void broadcastToast(std::string_view msg) {
-    GMLIB_Level::getInstance()->broadcastToast(tr("cleaner.info.prefix"), msg);
+    gmlib::GMLevel::getInstance()->broadcastToast(tr("cleaner.info.prefix"), msg);
 }
 
 } // namespace Helper

src/Features/UnloadActorClean.cpp

@@ -0,0 +1,19 @@
+#include "Cleaner.h"
+#include "Global.h"
+#include "gmlib/mc/world/actor/UnloadedActor.h"
+
+namespace UnloadActorClean {
+void cleanUnloadActor() {
+    auto& config = Cleaner::Entry::getInstance().getConfig();
+    gmlib::UnloadedActor::foreachUnloadedActor(
+        [config](gmlib::UnloadedActor& actor) -> bool {
+            for (auto& actorname : config.UnloadActorClean.CleanList) {
+                if (actor.getTypeName() == actorname) {
+                    actor.remove();
+                }
+            }
+            return true;
+        }
+    );
+}
+} // namespace UnloadActorClean

src/Features/VoteClean.cpp

@@ -9,8 +9,6 @@ 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 {
@@ -95,10 +93,16 @@ void voteClean(Player* pl) {
         Helper::broadcastToast(tr("cleaner.vote.voteMessage", {pl->getRealName()}));
     }
     sendVoteForm(pl);
-    auto cooldown = std::chrono::seconds::duration(config.VoteClean.Cooldown);
-    auto waitTime = std::chrono::seconds::duration(config.VoteClean.CheckDelay);
-    Cleaner::Entry::getInstance().getScheduler().add<DelayTask>(cooldown, [] { canVote = false; });
-    Cleaner::Entry::getInstance().getScheduler().add<DelayTask>(waitTime, [] { checkVote(); });
+    ll::coro::keepThis([&config]() -> ll::coro::CoroTask<> {
+        co_await std::chrono::seconds(config.VoteClean.Cooldown);
+        canVote = true;
+        co_return;
+    }).launch(ll::thread::ServerThreadExecutor::getDefault());
+    ll::coro::keepThis([&config]() -> ll::coro::CoroTask<> {
+        co_await std::chrono::seconds(config.VoteClean.CheckDelay);
+        checkVote();
+        co_return;
+    }).launch(ll::thread::ServerThreadExecutor::getDefault());
 }
 
 void confirmForm(Player* pl) {

src/Global.h

@@ -1,12 +1,14 @@
 #pragma once
+// IWYU pragma: begin_exports
 #include "Mod.h"
-#include <include_all.h>
+
+#include "gmlib/include_ll.h"
+#include "ila/include_all.h"
 #include <regex>
+// IWYU pragma: end_exports
 
 #define S(x) std::to_string(x)
 
-extern ll::Logger logger;
-
 extern void RegisterCommands();
 
 namespace Helper {

src/Mod.cpp

@@ -1,38 +1,41 @@
+#include "Mod.h"
 #include "Features/Cleaner.h"
 #include "Global.h"
 #include "Language.h"
-
-ll::Logger logger("Cleaner");
-
+#include "ll/api/utils/ErrorUtils.h"
+#include "gmlib/mc/locale/I18nAPI.h"
 namespace Cleaner {
 
-static std::unique_ptr<Entry> instance;
-
-Entry& Entry::getInstance() { return *instance; }
+Entry& Entry::getInstance() {
+    static Entry instance;
+    return instance;
+}
 
 bool Entry::load() { return true; }
 
 bool Entry::enable() {
     mConfig.emplace();
-    mScheduler.emplace();
-    ll::config::loadConfig(*mConfig, getSelf().getConfigDir() / "config.json");
+    try {
+        ll::config::loadConfig(*mConfig, getSelf().getConfigDir() / "config.json");
+    } catch (...) {
+        ll::error_utils::printCurrentException(getSelf().getLogger());
+    }
     saveConfig();
-    I18nAPI::updateOrCreateLanguageFile(getSelf().getLangDir(), "en_US", en_US);
-    I18nAPI::updateOrCreateLanguageFile(getSelf().getLangDir(), "zh_CN", zh_CN);
-    I18nAPI::loadLanguagesFromDirectory(getSelf().getLangDir());
+    gmlib::I18nAPI::updateOrCreateLanguageFile(getSelf().getLangDir(), "en_US", en_US);
+    gmlib::I18nAPI::updateOrCreateLanguageFile(getSelf().getLangDir(), "zh_CN", zh_CN);
+    gmlib::I18nAPI::loadLanguagesFromDirectory(getSelf().getLangDir());
     Cleaner::ListenEvents();
     RegisterCommands();
     Cleaner::loadCleaner();
-    logger.info("Cleaner Loaded!");
-    logger.info("Author: GroupMountain");
-    logger.info("Repository: https://github.com/GroupMountain/Cleaner");
+    getSelf().getLogger().info("Cleaner Loaded!");
+    getSelf().getLogger().info("Author: GroupMountain");
+    getSelf().getLogger().info("Repository: https://github.com/GroupMountain/Cleaner");
     return true;
 }
 
 bool Entry::disable() {
     mConfig.reset();
     Cleaner::unloadCleaner();
-    mScheduler.reset();
     return true;
 }
 
@@ -40,12 +43,10 @@ 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_MOD(Cleaner::Entry, Cleaner::instance);
+LL_REGISTER_MOD(Cleaner::Entry, Cleaner::Entry::getInstance());
 
 std::string tr(std::string const& key, std::vector<std::string> const& params) {
-    return I18nAPI::get(key, params, Cleaner::Entry::getInstance().getConfig().language);
+    return gmlib::I18nAPI::get(key, params);
 }

src/Mod.h

@@ -2,18 +2,15 @@
 
 #include "Config.h"
 #include <ll/api/mod/NativeMod.h>
-#include <ll/api/schedule/Scheduler.h>
 
 namespace Cleaner {
 
-using namespace ll::schedule;
-
 class Entry {
 
 public:
     static Entry& getInstance();
 
-    Entry(ll::mod::NativeMod& self) : mSelf(self) {}
+    Entry() : mSelf(*ll::mod::NativeMod::current()) {}
 
     [[nodiscard]] ll::mod::NativeMod& getSelf() const { return mSelf; }
 
@@ -34,12 +31,9 @@ public:
 
     void saveConfig();
 
-    ServerTimeScheduler& getScheduler();
-
 private:
-    ll::mod::NativeMod&                mSelf;
-    std::optional<Config>              mConfig;
-    std::optional<ServerTimeScheduler> mScheduler;
+    ll::mod::NativeMod&   mSelf;
+    std::optional<Config> mConfig;
 };
 
 } // namespace Cleaner

src/RegisterCommand.cpp

@@ -1,6 +1,6 @@
 #include "Features/Cleaner.h"
-#include "Mod.h"
-
+#include "gmlib/mc/world/Level.h"
+#include "gmlib/gm/data/TpsStatus.h"
 struct CleanerParam {
     enum class Despawn { despawn } despawn;
     enum class Action { tps, clean, reload, mspt } action;
@@ -16,10 +16,8 @@ void RegCleanerCommand() {
         tr("cleaner.command.cleaner"),
         CommandPermissionLevel::GameDirectors
     );
-    cmd.overload<CleanerParam>()
-        .required("despawn")
-        .required("entity")
-        .execute<[&](CommandOrigin const& origin, CommandOutput& output, CleanerParam const& param) {
+    cmd.overload<CleanerParam>().required("despawn").required("entity").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"));
@@ -28,15 +26,15 @@ void RegCleanerCommand() {
                 en->despawn();
             }
             return output.success(tr("cleaner.command.despawnSuccess", {S(ens.size())}));
-        }>();
-    cmd.overload<CleanerParam>()
-        .required("action")
-        .execute<[&](CommandOrigin const& origin, CommandOutput& output, CleanerParam const& param) {
+        }
+    );
+    cmd.overload<CleanerParam>().required("action").execute(
+        [&](CommandOrigin const& origin, CommandOutput& output, CleanerParam const& param) {
             switch (param.action) {
             case CleanerParam::Action::clean: {
                 Cleaner::CleanTask();
                 if (Cleaner::Entry::getInstance().getConfig().Basic.ConsoleLog) {
-                    logger.info(tr("cleaner.output.opClean"));
+                    ll::io::LoggerRegistry::getInstance().getOrCreate("Cleaner")->info(tr("cleaner.output.opClean"));
                 }
                 if (Cleaner::Entry::getInstance().getConfig().Basic.SendBroadcast) {
                     Helper::broadcastMessage(tr("cleaner.output.opClean"));
@@ -47,15 +45,15 @@ void RegCleanerCommand() {
                 return output.success(tr("cleaner.command.clean.output"));
             }
             case CleanerParam::Action::tps: {
-                return output.success(tr(
-                    "cleaner.command.tps.output",
-                    {S(GMLIB_Level::getLevel()->getServerCurrentTps()),
-                     S(GMLIB_Level::getLevel()->getServerAverageTps())}
-                ));
+                return output.success(
+                    tr("cleaner.command.tps.output",
+                       {S(gmlib::GMLevel::getInstance()->getServerCurrentTps()),
+                        S(gmlib::TpsStatus::getInstance().getLevelAverageTps())})
+                );
             }
             case CleanerParam::Action::mspt: {
                 return output.success(
-                    tr("cleaner.command.mspt.output", {S(GMLIB_Level::getLevel()->getServerMspt())})
+                    tr("cleaner.command.mspt.output", {S(gmlib::GMLevel::getInstance()->getServerMspt())})
                 );
             }
             case CleanerParam::Action::reload: {
@@ -63,15 +61,16 @@ void RegCleanerCommand() {
                 return output.success(tr("cleaner.output.reload"));
             }
             }
-        }>();
+        }
+    );
     cmd.overload<CleanerParam>()
         .required("despawntime")
         .required("ticks")
-        .execute<[&](CommandOrigin const& origin, CommandOutput& output, CleanerParam const& param) {
+        .execute([&](CommandOrigin const& origin, CommandOutput& output, CleanerParam const& param) {
             Cleaner::Entry::getInstance().getConfig().ItemDespawn.DespawnTime = param.ticks;
             Cleaner::Entry::getInstance().saveConfig();
             return output.success(tr("cleaner.command.despawntime", {S(param.ticks)}));
-        }>();
+        });
 };
 
 void RegVoteCommand() {
@@ -80,13 +79,13 @@ void RegVoteCommand() {
         tr("cleaner.command.voteclean"),
         CommandPermissionLevel::Any
     );
-    cmd.overload().execute<[&](CommandOrigin const& origin, CommandOutput& output) {
+    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() {

tooth.json

@@ -1,28 +1,54 @@
 {
-    "format_version": 2,
-    "tooth": "github.com/GroupMountain/Cleaner",
-    "version": "0.13.2",
-    "info": {
-        "name": "Cleaner",
-        "description": "A Powerful Entities Cleaning up Mod for BDS",
-        "author": "GroupMountain",
-        "source": "github.com/GroupMountain/Cleaner",
-        "tags": [
-            "levilamina",
-            "cleaner",
-            "gmlib"
-        ]
-    },
-    "asset_url": "https://github.com/GroupMountain/Cleaner/releases/download/v0.13.2/Cleaner-windows-x64.zip",
-    "dependencies": {
-        "github.com/GroupMountain/GMLIB": ">=0.13.7"
-    },
-    "files": {
-        "place": [
+  "format_version": 3,
+  "format_uuid": "289f771f-2c9a-4d73-9f3f-8492495a924d",
+  "tooth": "github.com/GroupMountain/Cleaner",
+  "version": "0.15.0",
+  "info": {
+    "name": "Cleaner",
+    "description": "A Powerful Entities Cleaning up Mod for BDS",
+    "tags": [
+      "levilamina",
+      "cleaner",
+      "gmlib"
+    ],
+    "avatar_url": ""
+  },
+  "variants": [
+    {
+      "label": "",
+      "platform": "win-x64",
+      "dependencies": {
+        "github.com/GroupMountain/GMLIB-Release": ">=1.6.0",
+        "github.com/GroupMountain/ModAPI-Release": ">=0.2.0",
+        "github.com/MiracleForest/iListenAttentively-Release": ">=0.9.0"
+      },
+      "assets": [
+        {
+          "type": "zip",
+          "urls": [
+            "https://github.com/GroupMountain/Cleaner/releases/download/v{{version}}/Cleaner-windows-x64.zip"
+          ],
+          "placements": [
             {
-                "src": "Cleaner/*",
-                "dest": "mods/Cleaner"
+              "type": "dir",
+              "src": "Cleaner/",
+              "dest": "plugins/Cleaner"
             }
-        ]
+          ]
+        }
+      ],
+      "preserve_files": [],
+      "remove_files": [],
+      "scripts": {
+        "pre_install": [],
+        "install": [],
+        "post_install": [],
+        "pre_pack": [],
+        "post_pack": [],
+        "pre_uninstall": [],
+        "uninstall": [],
+        "post_uninstall": []
+      }
     }
+  ]
 }

xmake.lua

@@ -2,14 +2,17 @@ add_rules("mode.debug", "mode.release", "mode.releasedbg")
 
 add_repositories("liteldev-repo https://github.com/LiteLDev/xmake-repo.git")
 add_repositories("groupmountain-repo https://github.com/GroupMountain/xmake-repo.git")
+add_repositories("miracleforest https://github.com/MiracleForest/xmake-repo")
 
 if not has_config("vs_runtime") then
     set_runtimes("MD")
 end
 
 -- Option 1: Use the latest version of LeviLamina released on GitHub.
-add_requires("levilamina")
-add_requires("gmlib 0.13.7")
+add_requires("levilamina 1.6.1")
+add_requires("levibuildscript 0.5.2")
+add_requires("gmlib 1.6.0")
+add_requires("ilistenattentively 0.9.0")
 
 target("Cleaner") -- Change this to your mod name.
     add_cxflags(
@@ -24,14 +27,19 @@ target("Cleaner") -- Change this to your mod name.
     )
     add_packages(
         "levilamina",
-        "gmlib"
+        "gmlib",
+        "ilistenattentively"
     )
-    add_shflags(
-        "/DELAYLOAD:bedrock_server.dll"
+    add_defines(
+        "NOMINMAX", 
+        "UNICODE",
+        "_HAS_CXX23=1"
     )
+    add_rules("@levibuildscript/linkrule")
     set_exceptions("none")
     set_kind("shared")
-    set_languages("cxx23")
+    set_languages("cxx20")
+    set_symbols("debug")
 
     after_build(function (target)
         local mod_packer = import("scripts.after_build")