wed150/Cleaner
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: refactoring skeleton

Browse Source
This commit is contained in:
Tsubasa6848
2024-02-16 11:58:41 +08:00
Unverified
parent 971cdee837
commit a458ec8aea
12 changed files with 391 additions and 294 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/Cleaner.cpp
-254
View File
@@ -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
+22 -21
View File
@@ -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": [
"minecraft:guardian",
"minecraft:zombie_pigman"
],
"Enabled": true,
"CleanMonstors": true,
"CleanPeacefulMobs": false,
"EnableAutoExclude": true,
"Enabled": true,
"IgnoreTags": [
"ignore",
"不清理"
"BlackList": [
"minecraft:guardian",
"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,
"VoteCleanCommand": "voteclean"
"CleanInterval": 3600
},
"VoteClean": {
"Enabled": true,
"VoteCleanCommand": "voteclean",
"Cooldown": 120,
"CheckDelay": 30,
"Percentage": 50
}
})";
src/Features/Clean.cpp
+124
View File
@@ -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
+108
View File
@@ -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
+36
View File
@@ -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
+14
View File
@@ -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
+44
View File
@@ -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
+14
View File
@@ -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
View File
src/Global.h
+18 -10
View File
@@ -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 GMLIB::Files::JsonConfig* Config;
extern ll::Logger logger;
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 {
static std::shared_ptr<ll::schedule::task::Task<ll::chrono::ServerClock>> mAutoCleanTask;
static std::shared_ptr<ll::schedule::task::Task<ll::chrono::ServerClock>> mCheckCleanTask;
extern void CleanTask();
extern void reloadCleaner();
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
-1
View File
@@ -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
+11 -8
View File
@@ -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)) {
TextPacket::createRawMessage(tr("cleaner.info.prefix") + tr("cleaner.output.opClean")).sendToClients();
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"));
}
@@ -61,19 +64,19 @@ void RegCleanerCommand() {
.required("despawntime")
.required("ticks")
.execute<[&](CommandOrigin const& origin, CommandOutput& output, CleanerParam const& param) {
item_despawn_time = param.ticks;
Config->setValue({"ItemDespawn", "DespawnTime"}, item_despawn_time);
return output.success(tr("cleaner.command.despawntime", {S(item_despawn_time)}));
ConfigFile::mItemDespawnTicks = param.ticks;
Config->setValue({"ItemDespawn", "DespawnTime"}, ConfigFile::mItemDespawnTicks);
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,