feat: add some features

src/Cleaner.cpp

@@ -1,14 +1,71 @@
 #include "Global.h"
 
+using namespace ll::schedule;
+using namespace ll::chrono_literals;
+
+GameTimeScheduler scheduler;
+
 namespace Cleaner {
 
+bool isDeathDrop(ItemActor* itac) {
+    // Todo
+    return false;
+}
+
+bool shouldIgnoreMob(Mob* mob) {
+    // Todo
+    return false;
+}
+
 bool ShouldClean(Actor* en) {
+    // Players
     if (en->isType(ActorType::Player)) {
         return false;
     }
-    // 过滤
-    // Todo
-    return true;
+    // Tag
+    if (en->hasTag("testtag")) {
+        // Todo
+    }
+    auto type = en->getTypeName();
+    // Items
+    if (en->hasCategory(ActorCategory::Item)) {
+        if (true) { // Todo Config Toggle
+            auto itac = (ItemActor*)en;
+            if (isDeathDrop(itac)) {
+                return false;
+            }
+            auto itemType = itac->item().getTypeName();
+            if (true) { // Todo Config WhiteList
+                return true;
+                return false;
+            }
+            return true;
+        }
+        return false;
+    }
+    // Mobs
+    else if (en->hasCategory(ActorCategory::Mob)) {
+        if (true) { // Todo Config Toggle
+            auto mob = (Mob*)en;
+            if (shouldIgnoreMob(mob)) {
+                return false;
+            }
+            if (true) { // Todo WhiteList
+                return true;
+                return false;
+            }
+        }
+        return false;
+    }
+    // Others
+    else {
+        if (true) {     // Todo Config Toggle
+            if (true) { // BlackList
+                return true;
+            }
+        }
+        return false;
+    }
 }
 
 int ExecuteClean() {
@@ -34,10 +91,21 @@ int CountEntities() {
     return clean_count;
 }
 
-void CleanSchedule() {
+using namespace ll::schedule;
+
+using namespace ll::chrono_literals;
+
+void CleanTask() {
     // Todo Schedule
-    auto count = ExecuteClean();
-    // Todo Notice & Console Log
+    logger.info("clean will in {}", 20s);
+    scheduler.add<DelayTask>(20s, [] {
+        auto count = ExecuteClean();
+        logger.info("Successfully cleaned {} entities", count);
+    });
+}
+
+void CountEntitiesTask() {
+    //
 }
 
 } // namespace Cleaner

src/Global.h

@@ -1,19 +1,11 @@
 #pragma once
 #include "Plugin.h"
-#include <ll/api/command/DynamicCommand.h>
-#include <ll/api/event/EventBus.h>
-#include <ll/api/event/ListenerBase.h>
-#include <ll/api/event/command/SetupCommandEvent.h>
-#include <ll/api/plugin/NativePlugin.h>
-#include <ll/api/memory/Hook.h>
-#include <ll/api/service/Bedrock.h>
-#include <ll/api/schedule/Scheduler.h>
-#include <ll/api/schedule/Task.h>
-#include "include_mcapi.h"
+#include "include_all.h"
 
 extern ll::Logger logger;
-extern void RegisterCommand(CommandRegistry &registry);
+extern void RegisterCommands();
+extern void UnregisterCommands();
 
 namespace Cleaner {
-    extern void CleanSchedule(int seconds, int notice_time);
+    extern void CleanTask();
 }

src/Mspt.cpp

@@ -0,0 +1 @@
+#include "Global.h"

src/Plugin.cpp

@@ -6,14 +6,10 @@ namespace plugin {
 
 Plugin::Plugin(ll::plugin::NativePlugin& self) : mSelf(self) {
     // Code for loading the plugin goes here.
-    auto& eventBus             = ll::event::EventBus::getInstance();
-    mSetupCommandEventListener = eventBus.emplaceListener<ll::event::command::SetupCommandEvent>([](ll::event::command::SetupCommandEvent& event) {
-        RegisterCommand(event.registry());
-    });  
 }
 
 bool Plugin::enable() {
-    auto& logger = mSelf.getLogger();
+    RegisterCommands();
     logger.info("Cleaner Loaded!");
     logger.info("Author: Tsubasa6848");
     logger.info("Repository: https://github.com/GroupMountain/Cleaner");
@@ -21,10 +17,9 @@ bool Plugin::enable() {
 }
 
 bool Plugin::disable() {
-    auto& logger = mSelf.getLogger();
     logger.info("Disabling Cleaner...");
     // Code for disabling the plugin goes here.
-    
+    UnregisterCommands();
     logger.info("Cleaner Disabled!");
     return true;
 }

src/Plugin.h

@@ -1,13 +1,12 @@
 #pragma once
 
 #include <ll/api/plugin/NativePlugin.h>
-#include <ll/api/event/ListenerBase.h>
 
 namespace plugin {
 
 class Plugin {
 public:
-    Plugin(ll::plugin::NativePlugin& self);
+    explicit Plugin(ll::plugin::NativePlugin& self);
 
     Plugin(Plugin&&)                 = delete;
     Plugin(const Plugin&)            = delete;
@@ -24,7 +23,6 @@ public:
 
 private:
     ll::plugin::NativePlugin& mSelf;
-    ll::event::ListenerPtr mSetupCommandEventListener;
 };
 
 } // namespace plugin

src/RegCommand.cpp

@@ -21,25 +21,25 @@ void RegCleanCommand(CommandRegistry& registry) {
                             CommandOrigin const&                                     origin,
                             CommandOutput&                                           output,
                             std::unordered_map<std::string, DynamicCommand::Result>& result) {
-        Cleaner::CleanSchedule(20, 5);
+        Cleaner::CleanTask();
     });
     DynamicCommand::setup(registry, std::move(command));
 }
 
-void RegReloadCommand(CommandRegistry& registry) {
-    auto command = DynamicCommand::createCommand(registry, "cleane", "Clean entities", CommandPermissionLevel::Any);
+void RegConfigCommand(CommandRegistry& registry) {
+    auto command = DynamicCommand::createCommand(registry, "cleaner", "Cleaner plugin settings", CommandPermissionLevel::Any);
     command->addOverload();
     command->setCallback([](DynamicCommand const&                                    cmd,
                             CommandOrigin const&                                     origin,
                             CommandOutput&                                           output,
                             std::unordered_map<std::string, DynamicCommand::Result>& result) {
-        // reload command
+        // reload & config
     });
     DynamicCommand::setup(registry, std::move(command));
 }
 
 void RegDespawnCommand(CommandRegistry& registry) {
-    auto command = DynamicCommand::createCommand(registry, "cleanee", "Clean entities", CommandPermissionLevel::Any);
+    auto command = DynamicCommand::createCommand(registry, "despawn", "despawn entities", CommandPermissionLevel::Any);
     command->mandatory("target", ParamType::Actor);
     command->addOverload({"target"});
     command->addOverload();
@@ -51,11 +51,18 @@ void RegDespawnCommand(CommandRegistry& registry) {
         for (auto en : ens) {
             en->despawn();
         }
-        // despawn command
     });
     DynamicCommand::setup(registry, std::move(command));
 }
 
-void RegisterCommand(CommandRegistry &registry) {
+void RegisterCommands() {
+    auto registry = ll::service::bedrock::getCommandRegistry();
     RegCleanCommand(registry);
+    RegDespawnCommand(registry);
+}
+
+void UnregisterCommands() {
+    auto registry = ll::service::bedrock::getCommandRegistry();
+    registry->unregisterCommand("clean");
+    registry->unregisterCommand("despawn");
 }