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

adapt: adapt LeviLamina v0.12.1

Browse Source
This commit is contained in:
Tsubasa6848
2024-04-29 07:04:48 +08:00
Unverified
parent 63586f62cb
commit 8321181be5
18 changed files with 341 additions and 405 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/Features/Clean.cpp
+13 -13
View File
@@ -26,25 +26,26 @@ bool shouldIgnore(GMLIB_Actor* ac) {
bool ShouldClean(Actor* actor) {
// Players
auto en = (GMLIB_Actor*)actor;
auto& config = Cleaner::Entry::getInstance().getConfig();
auto en = (GMLIB_Actor*)actor;
if (en->isPlayer() || shouldIgnore(en)) {
return false;
}
auto type = en->getTypeName();
for (auto& tag : ConfigFile::mIgnoreTags) {
for (auto& tag : config.IgnoreTags) {
if (en->hasTag(tag)) {
return false;
}
}
// Items
if (en->isItemActor()) {
if (Config->getValue<bool>({"CleanItem", "Enabled"}, false)) {
if (config.CleanItem.Enabled) {
auto itac = (ItemActor*)en;
if (itac->age() <= Config->getValue<int>({"CleanItem", "ExistTicks"}, 0)) {
if (itac->age() <= config.CleanItem.ExistTicks) {
return false;
}
auto itemType = itac->item().getTypeName();
auto whitelist = Config->getValue<std::vector<std::string>>({"CleanItem", "Whitelist"}, {});
auto whitelist = config.CleanItem.Whitelist;
for (auto& key : whitelist) {
if (isMatch(itemType, key)) {
return false;
@@ -56,24 +57,23 @@ bool ShouldClean(Actor* actor) {
}
// Mobs
else if (en->isMob()) {
if (Config->getValue<bool>({"CleanMobs", "Enabled"}, false)) {
auto blacklist = Config->getValue<std::vector<std::string>>({"CleanMobs", "BlackList"}, {});
if (config.CleanMobs.Enabled) {
auto blacklist = config.CleanMobs.BlackList;
for (auto& key : blacklist) {
if (isMatch(type, key)) {
return true;
}
}
auto whitelist = Config->getValue<std::vector<std::string>>({"CleanMobs", "Whitelist"}, {});
auto whitelist = config.CleanMobs.Whitelist;
for (auto& key : whitelist) {
if (isMatch(type, key)) {
return false;
}
}
if (Config->getValue<bool>({"CleanMobs", "CleanMonstors"}, false)
&& en->hasCategory(ActorCategory::Monster)) {
if (config.CleanMobs.CleanMonstors && en->hasCategory(ActorCategory::Monster)) {
return true;
}
if (Config->getValue<bool>({"CleanMobs", "CleanPeacefulMobs"}, false)) {
if (config.CleanMobs.CleanPeacefulMobs) {
return true;
}
}
@@ -81,8 +81,8 @@ bool ShouldClean(Actor* actor) {
}
// Others
else {
if (Config->getValue<bool>({"CleanInanimate", "Enabled"}, false)) {
auto blacklist = Config->getValue<std::vector<std::string>>({"CleanInanimate", "Blacklist"}, {});
if (config.CleanInanimate.Enabled) {
auto blacklist = config.CleanInanimate.Blacklist;
for (auto& key : blacklist) {
if (isMatch(type, key)) {
return true;
src/Features/CleanTask.cpp
+45 -54
View File
@@ -1,60 +1,49 @@
#include "Cleaner.h"
namespace ConfigFile {
bool mConsoleLog = true;
bool mAnnounce = true;
bool mSendToast = true;
std::vector<std::string> mIgnoreTags = {};
} // namespace ConfigFile
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;
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())}));
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);
if (config.Basic.ConsoleLog) {
logger.info(I18nAPI::get("cleaner.output.count1", {S(time_1.count())}));
}
if (ConfigFile::mAnnounce) {
Helper::broadcastMessage(tr("cleaner.output.count1", {S(time_1.count())}));
if (config.Basic.SendBroadcast) {
Helper::broadcastMessage(I18nAPI::get("cleaner.output.count1", {S(time_1.count())}));
}
if (ConfigFile::mSendToast) {
Helper::broadcastToast(tr("cleaner.output.count2", {S(announce_time)}));
if (config.Basic.SendToast) {
Helper::broadcastToast(I18nAPI::get("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)}));
Cleaner::Entry::getInstance().getScheduler().add<DelayTask>(time_2, [announce_time, &config] {
if (config.Basic.ConsoleLog) {
logger.info(I18nAPI::get("cleaner.output.count2", {S(announce_time)}));
}
if (ConfigFile::mAnnounce) {
Helper::broadcastMessage(tr("cleaner.output.count2", {S(announce_time)}));
if (config.Basic.SendBroadcast) {
Helper::broadcastMessage(I18nAPI::get("cleaner.output.count2", {S(announce_time)}));
}
if (ConfigFile::mSendToast) {
Helper::broadcastToast(tr("cleaner.output.count2", {S(announce_time)}));
if (config.Basic.SendToast) {
Helper::broadcastToast(I18nAPI::get("cleaner.output.count2", {S(announce_time)}));
}
});
scheduler.add<DelayTask>(time_1, [] {
Cleaner::Entry::getInstance().getScheduler().add<DelayTask>(time_1, [&config] {
auto count = ExecuteClean();
if (ConfigFile::mConsoleLog) {
logger.info(tr("cleaner.output.finish", {S(count)}));
if (config.Basic.ConsoleLog) {
logger.info(I18nAPI::get("cleaner.output.finish", {S(count)}));
}
if (ConfigFile::mAnnounce) {
Helper::broadcastMessage(tr("cleaner.output.finish", {S(count)}));
if (config.Basic.SendBroadcast) {
Helper::broadcastMessage(I18nAPI::get("cleaner.output.finish", {S(count)}));
}
if (ConfigFile::mSendToast) {
Helper::broadcastToast(tr("cleaner.output.finish", {S(count)}));
if (config.Basic.SendToast) {
Helper::broadcastToast(I18nAPI::get("cleaner.output.finish", {S(count)}));
}
auto_clean_triggerred = false;
});
@@ -62,23 +51,24 @@ void CleanTask() {
void AutoCleanTask(int seconds) {
auto time = std::chrono::seconds::duration(seconds);
mAutoCleanTask = scheduler.add<RepeatTask>(time, [] { CleanTask(); });
mAutoCleanTask = Cleaner::Entry::getInstance().getScheduler().add<RepeatTask>(time, [] { CleanTask(); });
}
void CleanTaskCount(int max_entities) {
mCleanTaskCount = scheduler.add<RepeatTask>(10s, [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 (ConfigFile::mConsoleLog) {
logger.warn(tr("cleaner.output.triggerAutoCleanCount", {S(count)}));
if (config.Basic.ConsoleLog) {
logger.warn(I18nAPI::get("cleaner.output.triggerAutoCleanCount", {S(count)}));
}
if (ConfigFile::mAnnounce) {
Helper::broadcastMessage(tr("cleaner.output.triggerAutoCleanCount", {S(count)}));
if (config.Basic.SendBroadcast) {
Helper::broadcastMessage(I18nAPI::get("cleaner.output.triggerAutoCleanCount", {S(count)}));
}
if (ConfigFile::mSendToast) {
Helper::broadcastToast(tr("cleaner.output.triggerAutoCleanCount", {S(count)}));
if (config.Basic.SendToast) {
Helper::broadcastToast(I18nAPI::get("cleaner.output.triggerAutoCleanCount", {S(count)}));
}
CleanTask();
}
@@ -87,19 +77,20 @@ void CleanTaskCount(int max_entities) {
}
void CleanTaskTPS(float min_tps) {
mCleanTaskTPS = scheduler.add<RepeatTask>(10s, [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 (ConfigFile::mConsoleLog) {
logger.warn(tr("cleaner.output.triggerAutoCleanTps", {mspt}));
if (config.Basic.ConsoleLog) {
logger.warn(I18nAPI::get("cleaner.output.triggerAutoCleanTps", {mspt}));
}
if (ConfigFile::mAnnounce) {
Helper::broadcastMessage(tr("cleaner.output.triggerAutoCleanTps", {mspt}));
if (config.Basic.SendBroadcast) {
Helper::broadcastMessage(I18nAPI::get("cleaner.output.triggerAutoCleanTps", {mspt}));
}
if (ConfigFile::mSendToast) {
Helper::broadcastToast(tr("cleaner.output.triggerAutoCleanTps", {mspt}));
if (config.Basic.SendToast) {
Helper::broadcastToast(I18nAPI::get("cleaner.output.triggerAutoCleanTps", {mspt}));
}
CleanTask();
}
@@ -110,15 +101,15 @@ void CleanTaskTPS(float min_tps) {
void stopAllTasks() {
if (!mCleanTaskCount) {
mCleanTaskTPS->cancel();
scheduler.remove(mCleanTaskTPS);
Cleaner::Entry::getInstance().getScheduler().remove(mCleanTaskTPS);
}
if (mCleanTaskCount) {
mCleanTaskCount->cancel();
scheduler.remove(mCleanTaskCount);
Cleaner::Entry::getInstance().getScheduler().remove(mCleanTaskCount);
}
if (mAutoCleanTask) {
mAutoCleanTask->cancel();
scheduler.remove(mAutoCleanTask);
Cleaner::Entry::getInstance().getScheduler().remove(mAutoCleanTask);
}
}
} // namespace Cleaner
src/Features/Cleaner.cpp
+9 -17
View File
@@ -3,31 +3,23 @@
namespace Cleaner {
void loadCleaner() {
if (Config->getValue<bool>({"ScheduleClean", "Enabled"}, false)) {
Cleaner::AutoCleanTask(Config->getValue<int>({"ScheduleClean", "CleanInterval"}, 3000));
auto& config = Cleaner::Entry::getInstance().getConfig();
if (config.ScheduleClean.Enabled) {
Cleaner::AutoCleanTask(config.ScheduleClean.CleanInterval);
}
if (Config->getValue<bool>({"AutoCleanCount", "Enabled"}, false)) {
Cleaner::CleanTaskCount(Config->getValue<int>({"AutoCleanCount", "TriggerCount"}, 900));
if (config.AutoCleanCount.Enabled) {
Cleaner::CleanTaskCount(config.AutoCleanCount.TriggerCount);
}
if (Config->getValue<bool>({"AutoCleanTPS", "Enabled"}, false)) {
Cleaner::CleanTaskTPS(Config->getValue<float>({"AutoCleanTPS", "TriggerTPS"}, 15.0f));
if (config.AutoCleanTPS.Enabled) {
Cleaner::CleanTaskTPS(config.AutoCleanTPS.TriggerTPS);
}
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);
ConfigFile::mIgnoreTags = Config->getValue<std::vector<std::string>>({"IgnoreTags"}, {});
}
void unloadCleaner() { stopAllTasks(); }
void reloadCleaner() {
unloadCleaner();
Config->reload();
std::string languageCode = Config->getValue<std::string>({"Basic", "Language"}, "en_US");
Language->reloadAllLanguages();
Language->chooseLanguage(languageCode);
loadCleaner();
Cleaner::Entry::getInstance().disable();
Cleaner::Entry::getInstance().enable();
}
} // namespace Cleaner
src/Features/Cleaner.h
-2
View File
@@ -6,8 +6,6 @@ using namespace ll::chrono_literals;
namespace Cleaner {
extern ServerTimeScheduler scheduler;
extern int ExecuteClean();
extern int CountEntities();
src/Features/Events.cpp
+6 -12
View File
@@ -1,21 +1,15 @@
#include "Cleaner.h"
namespace ConfigFile {
int mItemDespawnTicks = 3000;
} // namespace ConfigFile
namespace Cleaner {
void setShouldIgnore(GMLIB_Actor* 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>(
[](GMLIB::Event::EntityEvent::ItemActorSpawnAfterEvent& event) {
[&config](GMLIB::Event::EntityEvent::ItemActorSpawnAfterEvent& event) {
auto& item = event.getItemActor();
if (event.getSpawner().has_value()) {
auto pl = (GMLIB_Player*)event.getSpawner().as_ptr();
@@ -25,16 +19,16 @@ void ListenEvents() {
return;
}
}
if (Config->getValue<bool>({"ItemDespawn", "Enabled"}, true)) {
item.lifeTime() = ConfigFile::mItemDespawnTicks;
auto list = Config->getValue<std::vector<std::string>>({"ItemDespawn", "WhiteList"}, {});
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() = ConfigFile::mItemDespawnTicks;
item.lifeTime() = config.ItemDespawn.DespawnTime;
}
}
);
src/Features/Helper.cpp
+2 -2
View File
@@ -2,8 +2,8 @@
namespace Helper {
void broadcastMessage(std::string_view msg) { GMLIB_Level::broadcast(tr("cleaner.info.prefix") + std::string(msg)); }
void broadcastMessage(std::string_view msg) { GMLIB_Level::broadcast(I18nAPI::get("cleaner.info.prefix") + std::string(msg)); }
void broadcastToast(std::string_view msg) { GMLIB_Level::broadcastToast(tr("cleaner.info.prefix"), msg); }
void broadcastToast(std::string_view msg) { GMLIB_Level::broadcastToast(I18nAPI::get("cleaner.info.prefix"), msg); }
} // namespace Helper
src/Features/VoteClean.cpp
+33 -31
View File
@@ -24,10 +24,10 @@ int getPlayerCount() {
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")
I18nAPI::get("cleaner.vote.title"),
I18nAPI::get("cleaner.vote.subtitle", {pl->getRealName()}),
I18nAPI::get("cleaner.vote.ok"),
I18nAPI::get("cleaner.vote.no")
);
ll::service::getLevel()->forEachPlayer([&](Player& pl) -> bool {
fm.sendTo(pl, [](Player& player, ll::form::ModalFormResult result, ll::form::FormCancelReason reason) {
@@ -35,12 +35,12 @@ void sendVoteForm(Player* pl) {
switch (result.value()) {
case ll::form::ModalFormSelectedButton::Upper: {
voteList[player.getUuid()] = true;
player.sendMessage(tr("cleaner.vote.accept"));
player.sendMessage(I18nAPI::get("cleaner.vote.accept"));
return;
}
case ll::form::ModalFormSelectedButton::Lower: {
voteList[player.getUuid()] = false;
player.sendMessage(tr("cleaner.vote.deny"));
player.sendMessage(I18nAPI::get("cleaner.vote.deny"));
return;
}
default:
@@ -53,7 +53,8 @@ void sendVoteForm(Player* pl) {
}
void checkVote() {
float percentage = Config->getValue<float>({"VoteClean", "Percentage"}, 50.0f) / 100.0f;
auto& config = Cleaner::Entry::getInstance().getConfig();
float percentage = config.VoteClean.Percentage / 100.0f;
int voteCount = 0;
for (auto& key : voteList) {
if (key.second == true) {
@@ -62,19 +63,19 @@ void checkVote() {
}
float result = ((float)voteCount) / ((float)playerCount);
if (result >= percentage) {
if (ConfigFile::mAnnounce) {
Helper::broadcastMessage(tr("cleaner.vote.succeed"));
if (config.Basic.SendBroadcast) {
Helper::broadcastMessage(I18nAPI::get("cleaner.vote.succeed"));
}
if (ConfigFile::mSendToast) {
Helper::broadcastToast(tr("cleaner.vote.succeed"));
if (config.Basic.SendToast) {
Helper::broadcastToast(I18nAPI::get("cleaner.vote.succeed"));
}
Cleaner::CleanTask();
} else {
if (ConfigFile::mAnnounce) {
Helper::broadcastMessage(tr("cleaner.vote.failed"));
if (config.Basic.SendBroadcast) {
Helper::broadcastMessage(I18nAPI::get("cleaner.vote.failed"));
}
if (ConfigFile::mSendToast) {
Helper::broadcastToast(tr("cleaner.vote.failed"));
if (config.Basic.SendToast) {
Helper::broadcastToast(I18nAPI::get("cleaner.vote.failed"));
}
}
hasVote = false;
@@ -82,29 +83,30 @@ void checkVote() {
}
void voteClean(Player* pl) {
auto& config = Cleaner::Entry::getInstance().getConfig();
voteList.clear();
canVote = false;
hasVote = true;
playerCount = getPlayerCount();
if (ConfigFile::mAnnounce) {
Helper::broadcastMessage(tr("cleaner.vote.voteMessage", {pl->getRealName()}));
if (config.Basic.SendBroadcast) {
Helper::broadcastMessage(I18nAPI::get("cleaner.vote.voteMessage", {pl->getRealName()}));
}
if (ConfigFile::mSendToast) {
Helper::broadcastToast(tr("cleaner.vote.voteMessage", {pl->getRealName()}));
if (config.Basic.SendToast) {
Helper::broadcastToast(I18nAPI::get("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(); });
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(); });
}
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")
I18nAPI::get("cleaner.vote.title"),
I18nAPI::get("cleaner.vote.confirmTubtitle"),
I18nAPI::get("cleaner.vote.confirmOk"),
I18nAPI::get("cleaner.vote.confirmNo")
);
fm.sendTo(*pl, [](Player& player, ll::form::ModalFormResult result, ll::form::FormCancelReason reason) {
if (result.has_value()) {
@@ -113,7 +115,7 @@ void confirmForm(Player* pl) {
return voteClean(&player);
}
case ll::form::ModalFormSelectedButton::Lower: {
return player.sendMessage(tr("cleaner.vote.cancel"));
return player.sendMessage(I18nAPI::get("cleaner.vote.cancel"));
}
default:
return;
@@ -127,14 +129,14 @@ void voteCommandExecute(Player* pl) {
if (canVote) {
confirmForm(pl);
} else {
pl->sendMessage(tr("cleaner.vote.cooldown"));
pl->sendMessage(I18nAPI::get("cleaner.vote.cooldown"));
}
} else {
if (voteList.count(pl->getUuid())) {
pl->sendMessage(tr("cleaner.vote.voted"));
pl->sendMessage(I18nAPI::get("cleaner.vote.voted"));
} else {
voteList[pl->getUuid()] = true;
pl->sendMessage(tr("cleaner.vote.accept"));
pl->sendMessage(I18nAPI::get("cleaner.vote.accept"));
}
}
}