From accf1d066460d45e9676aff7b995cb144903e4ed Mon Sep 17 00:00:00 2001 From: zimuya4153 Date: Sat, 22 Mar 2025 00:10:55 +0800 Subject: [PATCH 1/2] adapt: adapt gmlib 1.0.0-rc.2 and levilamina 1.1.0 --- lib/BEPlaceholderAPI-JS.d.ts | 6 +- lib/BEPlaceholderAPI-JS.js | 6 +- lib/EventAPI-JS.js | 4 +- lib/PlaceholderAPI.d.ts | 42 +++ lib/PlaceholderAPI.js | 65 +++++ src/BinaryStreamApi.cpp | 23 +- src/CompatibilityApi.cpp | 527 +++++++++++++++++++---------------- src/Entry.cpp | 11 +- src/Entry.h | 8 +- src/EventAPI.cpp | 343 +++++++++++------------ src/Global.h | 13 +- src/LegacyModApi.cpp | 161 +++++------ src/LegacyServerApi.cpp | 59 ++-- src/PlaceholderApi.cpp | 222 +++++++++------ xmake.lua | 14 +- 15 files changed, 883 insertions(+), 621 deletions(-) create mode 100644 lib/PlaceholderAPI.d.ts create mode 100644 lib/PlaceholderAPI.js diff --git a/lib/BEPlaceholderAPI-JS.d.ts b/lib/BEPlaceholderAPI-JS.d.ts index 8e5d94b..bc69944 100644 --- a/lib/BEPlaceholderAPI-JS.d.ts +++ b/lib/BEPlaceholderAPI-JS.d.ts @@ -12,7 +12,7 @@ export class PAPI { pluginsName: string, /** PAPI变量 */ PAPIName: string - ): boolean; + ): void; /** 注册一个服务器PAPI变量 */ static registerServerPlaceholder( @@ -25,7 +25,7 @@ export class PAPI { pluginsName: string, /** PAPI变量 */ PAPIName: string - ): boolean; + ): void; /** 注册一个静态PAPI变量 */ static registerStaticPlaceholder( @@ -37,7 +37,7 @@ export class PAPI { PAPIName: string, /** 更新时间 */ UpdateInterval: number - ): boolean; + ): void; /** 获取一个服务器变量的值 */ static getValue( diff --git a/lib/BEPlaceholderAPI-JS.js b/lib/BEPlaceholderAPI-JS.js index 64274ec..8c385fc 100644 --- a/lib/BEPlaceholderAPI-JS.js +++ b/lib/BEPlaceholderAPI-JS.js @@ -59,7 +59,7 @@ class PAPI { */ static registerPlayerPlaceholder(func, PluginName, PAPIName) { ll.export(func, PluginName, func.getName()); - return PlaceholderAPI.registerPlayerPlaceholderAPI(PluginName, func.getName(), PAPIName); + PlaceholderAPI.registerPlayerPlaceholderAPI(PluginName, func.getName(), PAPIName); } /** @@ -71,7 +71,7 @@ class PAPI { */ static registerServerPlaceholder(func, PluginName, PAPIName) { ll.export(func, PluginName, func.getName()); - return PlaceholderAPI.registerServerPlaceholderAPI(PluginName, func.getName(), PAPIName); + PlaceholderAPI.registerServerPlaceholderAPI(PluginName, func.getName(), PAPIName); } /** @@ -84,7 +84,7 @@ class PAPI { */ static registerStaticPlaceholder(func, PluginName, PAPIName, UpdateInterval = 50) { ll.export(func, PluginName, func.getName()); - return PlaceholderAPI.registerStaticPlaceholderAPI(PluginName, func.getName(), PAPIName, UpdateInterval); + PlaceholderAPI.registerStaticPlaceholderAPI(PluginName, func.getName(), PAPIName, UpdateInterval); } /** diff --git a/lib/EventAPI-JS.js b/lib/EventAPI-JS.js index f45fd02..408e12c 100644 --- a/lib/EventAPI-JS.js +++ b/lib/EventAPI-JS.js @@ -5,7 +5,9 @@ const getPluginName = () => { try { throw new Error("getPluginName"); } catch (error) { - return error.stack.trim().match(/plugins\\(.*)\\.*\.js:[0-9]+\)$/i)?.[1] || "Unknown"; + return error.stack.trim().match(/plugins\\(.*)\\.*\.js:[0-9]+\)$/i)?.[1] + || error.stack.trim().match(/at \(([^\\|/]+)(.*?):\d+:\d+\)$/i)?.[1] + || "Unknown"; } }; diff --git a/lib/PlaceholderAPI.d.ts b/lib/PlaceholderAPI.d.ts new file mode 100644 index 0000000..9d4e42c --- /dev/null +++ b/lib/PlaceholderAPI.d.ts @@ -0,0 +1,42 @@ +/** 翻译带PAPI变量文本 */ +export function translate( + /** 要翻译的文本 */ + value: String, + /** 实体对象 */ + actor?: Entity, + /** 目标翻译语言 */ + language?: String +): String; + +/** 注册PAPI变量 */ +export function registerPlaceholder( + /** papi变量 */ + placeholder: String, + /** 回调 */ + callback: ( + /** 实体对象 */ actor: Entity, + /** 参数 */ params: String[], + /** 目标翻译语言 */language: String + ) => String | undefined +): void; + +/** 注销PAPI变量 */ +export function unregisterPlaceholder( + /** papi变量 */ + placeholder: String +): Boolean; + +/** 根据模组名注销PAPI变量 */ +export function unregisterPlaceholderFromModName( + /** 模组名 */ + modName: String +): Boolean; + +/** 获取一个papi变量的值 */ +export function getValue( + /** papi变量名 */ + placeholder: String, + actor?: Entity, + params?: Record, + language?: string +): Boolean; \ No newline at end of file diff --git a/lib/PlaceholderAPI.js b/lib/PlaceholderAPI.js new file mode 100644 index 0000000..350cce4 --- /dev/null +++ b/lib/PlaceholderAPI.js @@ -0,0 +1,65 @@ +/// + +const getPluginName = () => { + try { + throw new Error("getPluginName"); + } catch (error) { + return error.stack.trim().match(/plugins\\(.*)\\.*\.js:[0-9]+\)$/i)?.[1] + || error.stack.trim().match(/at \(([^\\|/]+)(.*?):\d+:\d+\)$/i)?.[1] + || "Unknown"; + } +}; + +Function.prototype.getName = + /** + * 获取函数名字 + * @returns {string} + */ + function () { + return this.name || this.toString().match(/function\s*([^(]*)\(/)?.[1] || getStringHashCode(this.toString()).toString(16); + }; + +/** + * 获取字符串哈希值 + * @param {string} str 字符串 + * @returns {number} + */ +function getStringHashCode(str) { + let hash = 0, chr; + if (str.length === 0) return hash; + for (let i = 0; i < str.length; i++) { + chr = str.charCodeAt(i); + hash = ((hash << 5) - hash) + chr; + hash |= 0; + } + return hash; +} + +module.exports = { + translate(value, actor = undefined, language = "") { + return actor instanceof LLSE_Entity + ? ll.imports("PlaceholderAPI", "translateFromActor")(value, actor, language) + : ll.imports("PlaceholderAPI", "translate")(value, language); + }, + registerPlaceholder(placeholder, callback) { + const pluginName = getPluginName(); + ll.exports((...args) => { + if(!args[0].uniqueId) args[0] = undefined; + return callback(...args) ?? ""; + }, pluginName, callback.getName()); + ll.imports("PlaceholderAPI", "registerPlaceholder")(placeholder, callback.getName(), pluginName); + }, + unregisterPlaceholder(placeholder) { + return ll.imports("PlaceholderAPI", "unregisterPlaceholder")(placeholder); + }, + unregisterPlaceholderFromModName(placeholder) { + return ll.imports("PlaceholderAPI", "unregisterPlaceholderFromModName")(placeholder); + }, + getValue(placeholder, actor = undefined, params = {}, language = "") { + if (actor instanceof LLSE_Player) actor = ll.import("GMLib_ServerAPI", "PlayerToEntity")(actor); + const result = actor instanceof LLSE_Entity + ? ll.imports("PlaceholderAPI", "getValueFromActor")(placeholder, actor, params, language) + : ll.imports("PlaceholderAPI", "getValue")(placeholder, params, language); + return result !== "" ? result : undefined; + } +}; \ No newline at end of file diff --git a/src/BinaryStreamApi.cpp b/src/BinaryStreamApi.cpp index be6c5ec..31f43d9 100644 --- a/src/BinaryStreamApi.cpp +++ b/src/BinaryStreamApi.cpp @@ -1,15 +1,16 @@ #include "Global.h" -using namespace ll::hash_utils; +#include +#include class LegacyScriptBinaryStreamManager { private: int64 mNextBinaryStreamId = 0; - std::unordered_map> mBinaryStream; + std::unordered_map> mBinaryStream; public: uint getNextId() { return mNextBinaryStreamId++; } - void cretateBinaryStream(uint id) { mBinaryStream[id] = std::make_shared(); } + void cretateBinaryStream(uint id) { mBinaryStream[id] = std::make_shared(); } uint64 copyBinaryStream(uint id) { auto nextId = getNextId(); @@ -22,7 +23,7 @@ public: void removeBinaryStream(uint64 id) { mBinaryStream.erase(id); } - std::shared_ptr getBinaryStream(uint64 id) { + std::shared_ptr getBinaryStream(uint64 id) { return mBinaryStream.contains(id) ? mBinaryStream.at(id) : nullptr; } @@ -47,7 +48,7 @@ template struct Info { using ArgT = A; }; -#define EXPORTAPI2(T) EXPORTAPI(#T, Info::ArgT, bs->T(value)) +#define EXPORTAPI2(T) EXPORTAPI(#T, Info::ArgT, bs->T(value)) void Export_BinaryStream_API() { RemoteCall::exportAs("GMLIB_BinaryStream_API", "create", []() -> uint64 { @@ -60,17 +61,23 @@ void Export_BinaryStream_API() { }); RemoteCall::exportAs("GMLIB_BinaryStream_API", "reset", [](uint64 id) -> void { if (BinaryStreamManager.getBinaryStream(id) == nullptr) BinaryStreamManager.cretateBinaryStream(id); - else BinaryStreamManager.getBinaryStream(id)->reset(); + else { + auto bs = BinaryStreamManager.getBinaryStream(id); + bs->mBuffer.clear(); + bs->mReadPointer = 0; + bs->mHasOverflowed = false; + } }); RemoteCall::exportAs("GMLIB_BinaryStream_API", "sendTo", [](uint64 id, Player* player) -> void { - if (auto bs = BinaryStreamManager.getBinaryStream(id); bs != nullptr) bs->sendTo(*player); + if (auto bs = BinaryStreamManager.getBinaryStream(id); bs != nullptr) + bs->sendTo(static_cast(*player)); }); RemoteCall::exportAs("GMLIB_BinaryStream_API", "destroy", [](uint64 id) -> void { BinaryStreamManager.removeBinaryStream(id); }); EXPORTAPI("writePacketHeader", int, bs->writePacketHeader((MinecraftPacketIds)value)); EXPORTAPI("writeUuid", std::string const&, bs->writeUuid(mce::UUID::fromString(value))); - EXPORTAPI("writeItem", ItemStack*, bs->writeType(NetworkItemStackDescriptor(*value))); + EXPORTAPI("writeItem", ItemStack*, bs->writeNetworkItemStackDescriptor(NetworkItemStackDescriptor(*value))); EXPORTAPI("writeString", std::string const&, bs->writeString(value)); EXPORTAPI("writeCompoundTag", CompoundTag*, bs->writeCompoundTag(*value)); EXPORTAPI2(writeBool); diff --git a/src/CompatibilityApi.cpp b/src/CompatibilityApi.cpp index 66b067a..f1b38ea 100644 --- a/src/CompatibilityApi.cpp +++ b/src/CompatibilityApi.cpp @@ -1,160 +1,155 @@ -#include "GMLIB/Mod/CustomRecipe/CustomRecipe.h" #include "Global.h" #include -bool isInteger(const std::string& str) { - std::regex pattern("^[+-]?\\d+$"); - return std::regex_match(str, pattern); -} - ActorUniqueID parseScriptUniqueID(std::string const& uniqueId) { - return isInteger(uniqueId) ? ActorUniqueID(std::stoll(uniqueId)) : ActorUniqueID::INVALID_ID(); + return StringUtils::isInteger(uniqueId) ? ActorUniqueID(std::stoll(uniqueId)) : ActorUniqueID::INVALID_ID(); } void Export_Compatibility_API() { RemoteCall::exportAs("GMLIB_API", "unregisterRecipe", [](std::string const& id) -> bool { - return GMLIB_Level::getInstance().has_value() ? GMLIB::Mod::CustomRecipe::unregisterRecipe(id) : false; + // return GMLevel::getInstance().has_value() ? GMLIB::Mod::CustomRecipe::unregisterRecipe(id) : false; + throw std::runtime_error("GMLIB_API::unregisterRecipe is not implemented"); }); RemoteCall::exportAs("GMLIB_API", "setCustomPackPath", [](std::string const& path) -> void { - GMLIB::Mod::CustomPacks::addCustomPackPath(path); + AddonsLoaderUtils::addCustomPackPath(path); }); RemoteCall::exportAs("GMLIB_API", "getServerMspt", []() -> double { - return GMLIB_Level::getInstance().transform( - [](GMLIB_Level& level) -> double { return level.getServerMspt(); } + return GMLevel::getInstance().transform( + [](GMLevel& level) -> double { return level.getServerMspt(); } ).value_or(0.0); }); RemoteCall::exportAs("GMLIB_API", "getServerCurrentTps", []() -> float { - return GMLIB_Level::getInstance() - .transform([](GMLIB_Level& level) -> float { return level.getServerCurrentTps(); }) + return GMLevel::getInstance() + .transform([](GMLevel& level) -> float { return level.getServerCurrentTps(); }) .value_or(0.0); }); RemoteCall::exportAs("GMLIB_API", "getServerAverageTps", []() -> double { - return GMLIB_Level::getInstance() - .transform([](GMLIB_Level& level) -> double { return level.getServerAverageTps(); }) + return GMLevel::getInstance() + .transform([](GMLevel& level) -> double { return level.getServerAverageTps(); }) .value_or(0.0); }); RemoteCall::exportAs("GMLIB_API", "getAllPlayerUuids", []() -> std::vector { std::vector result; - for (auto& uuid : GMLIB_Player::getAllUuids()) { - result.push_back(uuid.asString()); + for (auto& player : OfflinePlayer::getAllOfflinePlayers()) { + result.push_back(player.getUUID().asString()); } return result; }); RemoteCall::exportAs("GMLIB_API", "getPlayerNbt", [](std::string const& uuid) -> std::unique_ptr { - return std::move(GMLIB_Player::getPlayerNbt(mce::UUID::fromString(uuid))); + if (auto player = OfflinePlayer::getOfflinePlayer(mce::UUID::fromString(uuid))) { + return std::make_unique(*player->getNbt()); + } + return nullptr; }); RemoteCall::exportAs( "GMLIB_API", "setPlayerNbt", [](std::string const& uuid, CompoundTag* nbt, bool forceCreate) -> bool { - return GMLIB_Player::setPlayerNbt(mce::UUID::fromString(uuid), (GMLIB_CompoundTag&)*nbt, forceCreate); + if (auto player = OfflinePlayer::getOfflinePlayer(mce::UUID::fromString(uuid))) return player->setNbt(*nbt); + return forceCreate ? OfflinePlayer::createNewPlayerNbt(mce::UUID::fromString(uuid), *nbt).has_value() + : false; } ); RemoteCall::exportAs( "GMLIB_API", "setPlayerNbtTags", [](std::string const& uuid, CompoundTag* nbt, std::vector tags) -> bool { - return GMLIB_Player::setPlayerNbtTags(mce::UUID::fromString(uuid), (GMLIB_CompoundTag&)*nbt, tags); + if (auto player = OfflinePlayer::getOfflinePlayer(mce::UUID::fromString(uuid))) { + auto nbt2 = *player->getNbt(); + GMCompoundTag::writeNbtTags(nbt2, *nbt, tags); + return player->setNbt(nbt2); + } + return false; } ); RemoteCall::exportAs("GMLIB_API", "deletePlayerNbt", [](std::string const& uuid) -> bool { - return GMLIB_Player::deletePlayerNbt(mce::UUID::fromString(uuid)); + return OfflinePlayer::deletePlayerNbt(mce::UUID::fromString(uuid)); }); RemoteCall::exportAs("GMLIB_API", "getAllExperiments", []() -> std::vector { - std::vector result; - for (auto& key : GMLIB_Level::getAllExperiments()) { - result.push_back((int)key); - } - return result; + // std::vector result; + // for (auto& key : GMLevel::getAllExperiments()) { + // result.push_back((int)key); + // } + // return result; + throw std::runtime_error("GMLIB_API::getAllExperiments is not implemented"); }); RemoteCall::exportAs("GMLIB_API", "getExperimentTranslateKey", [](int id) -> std::string { - std::string result; - try { - result = Experiments::getExperimentTextID(AllExperiments(id)); - } catch (...) {} - return result; + // std::string result; + // try { + // result = Experiments::getExperimentTextID(AllExperiments(id)); + // } catch (...) {} + // return result; + throw std::runtime_error("GMLIB_API::getExperimentTranslateKey is not implemented"); }); RemoteCall::exportAs( "GMLIB_API", "createFloatingText", - [](std::pair pos, std::string const& text, bool papi) -> int { - auto ft = GMLIB::Server::FloatingTextManager::createStatic(text, pos.first, pos.second, papi); - GMLIB::Server::FloatingTextManager::getInstance().add(ft); - return ft->getRuntimeID(); + [](std::pair pos, std::string const& text, bool papi) -> uint64 { + return FloatingTextManager::getInstance() + .addStatic(text, pos.first, pos.second, papi) + .lock() + ->getRuntimeID(); } ); - RemoteCall::exportAs("GMLIB_API", "setFloatingTextData", [](int id, std::string const& text) -> bool { - return GMLIB::Server::FloatingTextManager::getInstance() - .getFloatingText(id) - .transform([&text](GMLIB::Server::FloatingTextBase& ft) -> bool { - ft.setText(text); - return true; - }) - .has_value(); + RemoteCall::exportAs("GMLIB_API", "setFloatingTextData", [](uint64 id, std::string const& text) -> bool { + if (auto ft = FloatingTextManager::getInstance().get(id); !ft.expired()) { + ft.lock()->setText(text); + return true; + } + return false; }); - RemoteCall::exportAs("GMLIB_API", "deleteFloatingText", [](int id) -> bool { - return GMLIB::Server::FloatingTextManager::getInstance().remove(id); + RemoteCall::exportAs("GMLIB_API", "deleteFloatingText", [](uint64 id) -> bool { + return FloatingTextManager::getInstance().remove(id); }); - RemoteCall::exportAs("GMLIB_API", "sendFloatingTextToPlayer", [](int id, Player* pl) -> bool { - return GMLIB::Server::FloatingTextManager::getInstance() - .getFloatingText(id) - .transform([&pl](GMLIB::Server::FloatingTextBase& ft) -> bool { - ft.sendTo(*pl); - return true; - }) - .has_value(); + RemoteCall::exportAs("GMLIB_API", "sendFloatingTextToPlayer", [](uint64 id, Player* pl) -> bool { + if (auto ft = FloatingTextManager::getInstance().get(id); !ft.expired()) { + ft.lock()->sendTo((GMPlayer&)*pl); + return true; + } + return false; }); - RemoteCall::exportAs("GMLIB_API", "sendFloatingText", [](int id) -> bool { - return GMLIB::Server::FloatingTextManager::getInstance() - .getFloatingText(id) - .transform([](GMLIB::Server::FloatingTextBase& ft) -> bool { - ft.sendToClients(); - return true; - }) - .has_value(); + RemoteCall::exportAs("GMLIB_API", "sendFloatingText", [](uint64 id) -> bool { + if (auto ft = FloatingTextManager::getInstance().get(id); !ft.expired()) { + ft.lock()->sendToClients(); + return true; + } + return false; }); - RemoteCall::exportAs("GMLIB_API", "removeFloatingTextFromPlayer", [](int id, Player* pl) -> bool { - return GMLIB::Server::FloatingTextManager::getInstance() - .getFloatingText(id) - .transform([&pl](GMLIB::Server::FloatingTextBase& ft) -> bool { - ft.removeFrom(*pl); - return true; - }) - .has_value(); + RemoteCall::exportAs("GMLIB_API", "removeFloatingTextFromPlayer", [](uint64 id, Player* pl) -> bool { + if (auto ft = FloatingTextManager::getInstance().get(id); !ft.expired()){ + ft.lock()->removeFrom((GMPlayer&)*pl); + return true; + } + return false; }); - RemoteCall::exportAs("GMLIB_API", "removeFloatingText", [](int id) -> bool { - return GMLIB::Server::FloatingTextManager::getInstance() - .getFloatingText(id) - .transform([](GMLIB::Server::FloatingTextBase& ft) -> bool { - ft.removeFromClients(); - return true; - }) - .has_value(); + RemoteCall::exportAs("GMLIB_API", "removeFloatingText", [](uint64 id) -> bool { + if (auto ft = FloatingTextManager::getInstance().get(id); !ft.expired()) { + ft.lock()->removeFromClients(); + return true; + } + return false; }); - RemoteCall::exportAs("GMLIB_API", "updateClientFloatingTextData", [](int id, Player* pl) -> bool { - return GMLIB::Server::FloatingTextManager::getInstance() - .getFloatingText(id) - .transform([&pl](GMLIB::Server::FloatingTextBase& ft) -> bool { - ft.update(*pl); - return true; - }) - .has_value(); + RemoteCall::exportAs("GMLIB_API", "updateClientFloatingTextData", [](uint64 id, Player* pl) -> bool { + if (auto ft = FloatingTextManager::getInstance().get(id); !ft.expired()) { + ft.lock()->update((GMPlayer&)*pl); + return true; + } + return false; }); - RemoteCall::exportAs("GMLIB_API", "updateAllClientsFloatingTextData", [](int id) -> bool { - return GMLIB::Server::FloatingTextManager::getInstance() - .getFloatingText(id) - .transform([](GMLIB::Server::FloatingTextBase& ft) -> bool { - ft.updateClients(); - return true; - }) - .has_value(); + RemoteCall::exportAs("GMLIB_API", "updateAllClientsFloatingTextData", [](uint64 id) -> bool { + if (auto ft = FloatingTextManager::getInstance().get(id); !ft.expired()) { + ft.lock()->updateClients(); + return true; + } + return false; }); - RemoteCall::exportAs("GMLIB_API", "isVersionMatched", [](int a, int b, int c) -> bool { - return LIB_VERSION >= GMLIB::Version(a, b, c, "", ""); + RemoteCall::exportAs("GMLIB_API", "isVersionMatched", [](std::uint16_t a, std::uint16_t b, std::uint16_t c) -> bool { + return LIB_VERSION >= ll::data::Version(a, b, c, "", ""); }); - RemoteCall::exportAs("GMLIB_API", "getVersion_LRCA", []() -> std::string { return LIB_VERSION.asString(); }); + RemoteCall::exportAs("GMLIB_API", "getVersion_LRCA", []() -> std::string { return LIB_VERSION.to_string(); }); RemoteCall::exportAs("GMLIB_API", "getVersion_GMLIB", []() -> std::string { - return GMLIB::Version::getLibVersionString(); + return GMLIB_VERSION_TO_STRING(GMLIB_VERSION_MAJOR) "." GMLIB_VERSION_TO_STRING(GMLIB_VERSION_MINOR + ) "." GMLIB_VERSION_TO_STRING(GMLIB_VERSION_PATCH); }); RemoteCall::exportAs( "GMLIB_API", @@ -169,18 +164,18 @@ void Export_Compatibility_API() { } ); RemoteCall::exportAs("GMLIB_API", "chooseResourcePackI18nLanguage", [](std::string const& code) -> void { - if (GMLIB_Level::getInstance()) { + if (GMLevel::getInstance()) { I18nAPI::chooseLanguage(code); } }); RemoteCall::exportAs("GMLIB_API", "getResourcePackI18nLanguage", []() -> std::string { - return GMLIB_Level::getInstance().has_value() ? I18nAPI::getCurrentLanguageCode() : "unknown"; + return GMLevel::getInstance().has_value() ? I18nAPI::getCurrentLanguageCode() : "unknown"; }); RemoteCall::exportAs("GMLIB_API", "getSupportedLanguages", []() -> std::vector { - return GMLIB_Level::getInstance() ? I18nAPI::getSupportedLanguageCodes() : std::vector(); + return GMLevel::getInstance() ? I18nAPI::getSupportedLanguageCodes() : std::vector(); }); RemoteCall::exportAs("GMLIB_API", "loadLanguage", [](std::string const& code, std::string const& lang) -> void { - if (GMLIB_Level::getInstance()) { + if (GMLevel::getInstance()) { I18nAPI::loadLanguage(code, lang); } }); @@ -189,38 +184,47 @@ void Export_Compatibility_API() { "updateOrCreateLanguageFile", [](std::string const& code, std::unordered_map lang, std::string const& path ) -> void { - if (GMLIB_Level::getInstance()) { + if (GMLevel::getInstance()) { I18nAPI::updateOrCreateLanguageFile(path, code, lang); } } ); RemoteCall::exportAs("GMLIB_API", "loadLanguagePath", [](std::string const& path) -> void { - if (GMLIB_Level::getInstance()) { + if (GMLevel::getInstance()) { I18nAPI::loadLanguagesFromDirectory(path); } }); RemoteCall::exportAs("GMLIB_API", "getPlayerPosition", [](std::string const& uuid) -> std::pair { - return GMLIB_Player::getPlayerPosition(mce::UUID::fromString(uuid)) - .value_or(std::pair({0, 0, 0}, -1)); + if (auto player = OfflinePlayer::getOfflinePlayer(mce::UUID::fromString(uuid))) { + if (auto pos = player->getPlayerPosition()) { + return *pos; + } + } + return { + {0, 0, 0}, + 0 + }; }); RemoteCall::exportAs( "GMLIB_API", "setPlayerPosition", [](std::string const& uuid, std::pair pos) -> bool { - return GMLIB_Player::setPlayerPosition(mce::UUID::fromString(uuid), pos.first, pos.second); + // return GMPlayer::setPlayerPosition(mce::UUID::fromString(uuid), pos.first, pos.second); + throw std::runtime_error("GMLIB_API::setPlayerPosition is not implemented"); } ); RemoteCall::exportAs("GMLIB_API", "playerHasScore", [](std::string const& uuid, std::string const& obj) -> bool { - return GMLIB_Player::getPlayerScore(mce::UUID::fromString(uuid), obj).has_value(); + return GMScoreboard::getInstance()->getPlayerScore(obj, mce::UUID::fromString(uuid)).has_value(); }); RemoteCall::exportAs("GMLIB_API", "getPlayerScore", [](std::string const& uuid, std::string const& obj) -> int { - return GMLIB_Player::getPlayerScore(mce::UUID::fromString(uuid), obj).value_or(0); + return GMScoreboard::getInstance()->getPlayerScore(obj, mce::UUID::fromString(uuid)).value_or(0); }); RemoteCall::exportAs( "GMLIB_API", "addPlayerScore", [](std::string const& uuid, std::string const& obj, int value) -> bool { - return GMLIB_Player::setPlayerScore(mce::UUID::fromString(uuid), obj, value, PlayerScoreSetFunction::Add) + return GMScoreboard::getInstance() + ->setPlayerScore(obj, mce::UUID::fromString(uuid), value, PlayerScoreSetFunction::Add) .has_value(); } ); @@ -228,12 +232,8 @@ void Export_Compatibility_API() { "GMLIB_API", "reducePlayerScore", [](std::string const& uuid, std::string const& obj, int value) -> bool { - return GMLIB_Player::setPlayerScore( - mce::UUID::fromString(uuid), - obj, - value, - PlayerScoreSetFunction::Subtract - ) + return GMScoreboard::getInstance() + ->setPlayerScore(obj, mce::UUID::fromString(uuid), value, PlayerScoreSetFunction::Subtract) .has_value(); } ); @@ -241,30 +241,30 @@ void Export_Compatibility_API() { "GMLIB_API", "setPlayerScore", [](std::string const& uuid, std::string const& obj, int value) -> bool { - return GMLIB_Player::setPlayerScore(mce::UUID::fromString(uuid), obj, value).has_value(); + return GMScoreboard::getInstance()->setPlayerScore(obj, mce::UUID::fromString(uuid), value).has_value(); } ); RemoteCall::exportAs("GMLIB_API", "resetPlayerScore", [](std::string const& uuid, std::string const& obj) -> bool { - return GMLIB_Player::resetPlayerScore(mce::UUID::fromString(uuid), obj); + return GMScoreboard::getInstance()->resetPlayerScore(obj, mce::UUID::fromString(uuid)); }); RemoteCall::exportAs("GMLIB_API", "resetPlayerScores", [](std::string const& uuid) -> bool { - return GMLIB_Player::resetPlayerScore(mce::UUID::fromString(uuid)); + return GMScoreboard::getInstance()->resetPlayerScore(mce::UUID::fromString(uuid)); }); RemoteCall::exportAs( "GMLIB_API", "entityHasScore", [](std::string const& uniqueId, std::string const& obj) -> bool { - return GMLIB_Scoreboard::getInstance()->getScore(obj, parseScriptUniqueID(uniqueId)).has_value(); + return GMScoreboard::getInstance()->getScore(obj, parseScriptUniqueID(uniqueId)).has_value(); } ); RemoteCall::exportAs("GMLIB_API", "getEntityScore", [](std::string const& uniqueId, std::string const& obj) -> int { - return GMLIB_Scoreboard::getInstance()->getScore(obj, parseScriptUniqueID(uniqueId)).value_or(0); + return GMScoreboard::getInstance()->getScore(obj, parseScriptUniqueID(uniqueId)).value_or(0); }); RemoteCall::exportAs( "GMLIB_API", "addEntityScore", [](std::string const& uniqueId, std::string const& obj, int value) -> bool { - return GMLIB_Scoreboard::getInstance() + return GMScoreboard::getInstance() ->setScore(obj, parseScriptUniqueID(uniqueId), value, PlayerScoreSetFunction::Add) .has_value(); } @@ -273,7 +273,7 @@ void Export_Compatibility_API() { "GMLIB_API", "reduceEntityScore", [](std::string const& uniqueId, std::string const& obj, int value) -> bool { - return GMLIB_Scoreboard::getInstance() + return GMScoreboard::getInstance() ->setScore(obj, parseScriptUniqueID(uniqueId), value, PlayerScoreSetFunction::Subtract) .has_value(); } @@ -282,41 +282,41 @@ void Export_Compatibility_API() { "GMLIB_API", "setEntityScore", [](std::string const& uniqueId, std::string const& obj, int value) -> bool { - return GMLIB_Scoreboard::getInstance()->setScore(obj, parseScriptUniqueID(uniqueId), value).has_value(); + return GMScoreboard::getInstance()->setScore(obj, parseScriptUniqueID(uniqueId), value).has_value(); } ); RemoteCall::exportAs( "GMLIB_API", "resetEntityScore", [](std::string const& uniqueId, std::string const& obj) -> bool { - return GMLIB_Scoreboard::getInstance()->resetScore(obj, parseScriptUniqueID(uniqueId)); + return GMScoreboard::getInstance()->resetScore(obj, parseScriptUniqueID(uniqueId)); } ); RemoteCall::exportAs("GMLIB_API", "resetEntityScores", [](std::string const& uniqueId) -> bool { - return GMLIB_Scoreboard::getInstance()->resetScore(parseScriptUniqueID(uniqueId)); + return GMScoreboard::getInstance()->resetScore(parseScriptUniqueID(uniqueId)); }); RemoteCall::exportAs( "GMLIB_API", "fakePlayerHasScore", [](std::string const& name, std::string const& obj) -> bool { - return GMLIB_Scoreboard::getInstance()->getScore(obj, name).has_value(); + return GMScoreboard::getInstance()->getScore(obj, name).has_value(); } ); RemoteCall::exportAs("GMLIB_API", "getFakePlayerScore", [](std::string const& name, std::string const& obj) -> int { - return GMLIB_Scoreboard::getInstance()->getScore(obj, name).value_or(0); + return GMScoreboard::getInstance()->getScore(obj, name).value_or(0); }); RemoteCall::exportAs( "GMLIB_API", "addFakePlayerScore", [](std::string const& name, std::string const& obj, int value) -> bool { - return GMLIB_Scoreboard::getInstance()->setScore(obj, name, value, PlayerScoreSetFunction::Add).has_value(); + return GMScoreboard::getInstance()->setScore(obj, name, value, PlayerScoreSetFunction::Add).has_value(); } ); RemoteCall::exportAs( "GMLIB_API", "reduceFakePlayerScore", [](std::string const& name, std::string const& obj, int value) -> bool { - return GMLIB_Scoreboard::getInstance() + return GMScoreboard::getInstance() ->setScore(obj, name, value, PlayerScoreSetFunction::Subtract) .has_value(); } @@ -325,76 +325,76 @@ void Export_Compatibility_API() { "GMLIB_API", "setFakePlayerScore", [](std::string const& name, std::string const& obj, int value) -> bool { - return GMLIB_Scoreboard::getInstance()->setScore(obj, name, value).has_value(); + return GMScoreboard::getInstance()->setScore(obj, name, value).has_value(); } ); RemoteCall::exportAs( "GMLIB_API", "resetFakePlayerScore", [](std::string const& name, std::string const& obj) -> bool { - return GMLIB_Scoreboard::getInstance()->resetScore(obj, name); + return GMScoreboard::getInstance()->resetScore(obj, name); } ); RemoteCall::exportAs("GMLIB_API", "resetFakePlayerScores", [](std::string const& name) -> bool { - return GMLIB_Scoreboard::getInstance()->resetScore(name); + return GMScoreboard::getInstance()->resetScore(name); }); RemoteCall::exportAs("GMLIB_API", "addObjective", [](std::string const& obj) -> bool { - return GMLIB_Scoreboard::getInstance()->addObjective(obj).has_value(); + return GMScoreboard::getInstance()->addObjective(obj).has_value(); }); RemoteCall::exportAs( "GMLIB_API", "addObjectiveWithDisplayName", [](std::string const& obj, std::string const& displayName) -> bool { - return GMLIB_Scoreboard::getInstance()->addObjective(obj, displayName).has_value(); + return GMScoreboard::getInstance()->addObjective(obj, displayName).has_value(); } ); RemoteCall::exportAs("GMLIB_API", "getDisplayName", [](std::string const& obj) -> std::string { - return GMLIB_Scoreboard::getInstance()->getObjectiveDisplayName(obj).value_or(""); + return GMScoreboard::getInstance()->getObjectiveDisplayName(obj).value_or(""); }); RemoteCall::exportAs( "GMLIB_API", "setDisplayName", [](std::string const& obj, std::string const& displayName) -> bool { - return GMLIB_Scoreboard::getInstance()->setObjectiveDisplayName(obj, displayName); + return GMScoreboard::getInstance()->setObjectiveDisplayName(obj, displayName); } ); RemoteCall::exportAs("GMLIB_API", "removeObjective", [](std::string const& obj) -> bool { - return GMLIB_Scoreboard::getInstance()->removeObjective(obj); + return GMScoreboard::getInstance()->removeObjective(obj); }); RemoteCall::exportAs( "GMLIB_API", "setDisplayObjective", [](std::string const& obj, std::string const& slot, int order) -> void { - return GMLIB_Scoreboard::getInstance()->setObjectiveDisplay(obj, slot, (ObjectiveSortOrder)order); + return GMScoreboard::getInstance()->setObjectiveDisplay(obj, slot, (ObjectiveSortOrder)order); } ); RemoteCall::exportAs("GMLIB_API", "clearDisplayObjective", [](std::string const& slot) -> void { - return GMLIB_Scoreboard::getInstance()->clearObjectiveDisplay(slot); + return GMScoreboard::getInstance()->clearObjectiveDisplay(slot); }); RemoteCall::exportAs("GMLIB_API", "getAllObjectives", []() -> std::vector { std::vector result; - for (auto& obj : GMLIB_Scoreboard::getInstance()->getObjectives()) { - result.push_back(obj->getName()); + for (auto& obj : GMScoreboard::getInstance()->getObjectives()) { + result.push_back(obj->mName); } return result; }); RemoteCall::exportAs("GMLIB_API", "getAllScoreboardPlayers", []() -> std::vector { std::vector result; - for (auto& uuid : GMLIB_Scoreboard::getInstance()->getAllPlayerUuids()) { - result.push_back(uuid.asString()); + for (auto& player : GMScoreboard::getInstance()->getAllPlayers()) { + result.push_back(player.getUUID().asString()); } return result; }); RemoteCall::exportAs("GMLIB_API", "getAllScoreboardFakePlayers", []() -> std::vector { std::vector result; - for (auto& name : GMLIB_Scoreboard::getInstance()->getAllFakePlayers()) { + for (auto& name : GMScoreboard::getInstance()->getAllFakePlayers()) { result.push_back(name); } return result; }); RemoteCall::exportAs("GMLIB_API", "getAllScoreboardEntities", []() -> std::vector { std::vector result; - for (auto& uniqueId : GMLIB_Scoreboard::getInstance()->getAllEntities()) { + for (auto& uniqueId : GMScoreboard::getInstance()->getAllEntities()) { result.push_back(std::to_string(uniqueId.rawID)); } return result; @@ -404,19 +404,19 @@ void Export_Compatibility_API() { "getAllTrackedTargets", []() -> std::vector> { std::vector> result; - for (auto& uuid : GMLIB_Scoreboard::getInstance()->getAllPlayerUuids()) { + for (auto& player : GMScoreboard::getInstance()->getAllPlayers()) { result.push_back({ {"Type", "Player" }, - {"Uuid", uuid.asString()} + {"Uuid", player.getUUID().asString()} }); } - for (auto& name : GMLIB_Scoreboard::getInstance()->getAllFakePlayers()) { + for (auto& name : GMScoreboard::getInstance()->getAllFakePlayers()) { result.push_back({ {"Type", "FakePlayer"}, {"Name", name } }); } - for (auto& uniqueId : GMLIB_Scoreboard::getInstance()->getAllEntities()) { + for (auto& uniqueId : GMScoreboard::getInstance()->getAllEntities()) { result.push_back({ {"Type", "Entity" }, {"UniqueId", std::to_string(uniqueId.rawID)} @@ -435,22 +435,30 @@ void Export_Compatibility_API() { return ll::service::getLevel()->fetchEntity(parseScriptUniqueID(uniqueId), false); }); RemoteCall::exportAs("GMLIB_API", "getWorldSpawn", []() -> std::pair { - return {GMLIB_Level::getInstance()->getWorldSpawn(), 0}; + return {GMLevel::getInstance()->getLevelData().getSpawnPos(), 0}; }); RemoteCall::exportAs("GMLIB_API", "setWorldSpawn", [](std::pair pos) -> bool { if (pos.second != 0) return false; - GMLIB_Level::getInstance()->setWorldSpawn(pos.first); + GMLevel::getInstance()->getLevelData().setSpawnPos(pos.first); + auto pkt = SetSpawnPositionPacket(); + pkt.mSpawnBlockPos = NetworkBlockPosition(pos.first); + pkt.mDimensionType = 0; + pkt.mSpawnPosType = SpawnPositionType::WorldSpawn; + pkt.sendToClients(); return true; }); RemoteCall::exportAs("GMLIB_API", "getPlayerSpawnPoint", [](Player* pl) -> std::pair { - auto res = ((GMLIB_Player*)pl)->getSpawnPoint(); - return {res.first, res.second}; + // auto res = ((GMPlayer*)pl)->getSpawnPoint(); + // return {res.first, res.second}; + throw std::runtime_error("GMLIB_API::getPlayerSpawnPoint is not implemented"); }); RemoteCall::exportAs("GMLIB_API", "setPlayerSpawnPoint", [](Player* pl, std::pair pos) -> void { - ((GMLIB_Player*)pl)->setSpawnPoint(pos.first, pos.second); + // ((GMPlayer*)pl)->setSpawnPoint(pos.first, pos.second); + throw std::runtime_error("GMLIB_API::setPlayerSpawnPoint is not implemented"); }); RemoteCall::exportAs("GMLIB_API", "clearPlayerSpawnPoint", [](Player* pl) -> void { - ((GMLIB_Player*)pl)->clearSpawnPoint(); + // ((GMPlayer*)pl)->clearSpawnPoint(); + throw std::runtime_error("GMLIB_API::clearPlayerSpawnPoint is not implemented"); }); RemoteCall::exportAs( "GMLIB_API", @@ -463,24 +471,24 @@ void Export_Compatibility_API() { } ); RemoteCall::exportAs("GMLIB_API", "getXuidByUuid", [](std::string const& uuid) -> std::string { - return GMLIB::UserCache::getXuidByUuid(mce::UUID::fromString(uuid)).value_or(""); + return UserCache::getXuidByUuid(mce::UUID::fromString(uuid)).value_or(""); }); RemoteCall::exportAs("GMLIB_API", "getXuidByName", [](std::string const& name) -> std::string { - return GMLIB::UserCache::getXuidByName(name).value_or(""); + return UserCache::getXuidByName(name).value_or(""); }); RemoteCall::exportAs("GMLIB_API", "getNameByUuid", [](std::string const& uuid) -> std::string { - return GMLIB::UserCache::getNameByUuid(mce::UUID::fromString(uuid)).value_or(""); + return UserCache::getNameByUuid(mce::UUID::fromString(uuid)).value_or(""); }); RemoteCall::exportAs("GMLIB_API", "getNameByXuid", [](std::string const& xuid) -> std::string { - return GMLIB::UserCache::getNameByXuid(xuid).value_or(""); + return UserCache::getNameByXuid(xuid).value_or(""); }); RemoteCall::exportAs("GMLIB_API", "getUuidByXuid", [](std::string const& xuid) -> std::string { - return GMLIB::UserCache::getUuidByXuid(xuid) + return UserCache::getUuidByXuid(xuid) .transform([](mce::UUID&& uuid) -> std::string { return uuid.asString(); }) .value_or(""); }); RemoteCall::exportAs("GMLIB_API", "getUuidByName", [](std::string const& name) -> std::string { - return GMLIB::UserCache::getUuidByName(name) + return UserCache::getUuidByName(name) .transform([](mce::UUID&& uuid) -> std::string { return uuid.asString(); }) .value_or(""); }); @@ -489,23 +497,23 @@ void Export_Compatibility_API() { "getAllPlayerInfo", []() -> std::vector> { std::vector> result; - GMLIB::UserCache::forEach([&result](const GMLIB::UserCache::UserCacheEntry& entry) -> void { + for (auto entry : UserCache::entries()){ result.push_back({ {"Name", entry.mName }, {"Xuid", entry.mXuid }, {"Uuid", entry.mUuid.asString()} }); - }); + } return result; } ); RemoteCall::exportAs("GMLIB_API", "getBlockRuntimeId", [](std::string const& blockName, short legacyData) -> uint { return Block::tryGetFromRegistry(blockName, legacyData) - .transform([](const Block& block) -> uint { return block.getRuntimeId(); }) + .transform([](const Block& block) -> uint { return block.mNetworkId; }) .value_or(0); }); RemoteCall::exportAs("GMLIB_API", "getBlockTranslateKey", [](Block const* block) -> std::string { - return block->buildDescriptionId(); + return block->getLegacyBlock().mDescriptionId; }); RemoteCall::exportAs("GMLIB_API", "getItemTranslateKey", [](ItemStack* item) -> std::string { return item->getDescriptionId(); @@ -517,7 +525,7 @@ void Export_Compatibility_API() { "GMLIB_API", "readNbtFromFile", [](std::string const& path, bool isBinary) -> std::unique_ptr { - if (auto nbt = GMLIB_CompoundTag::readFromFile(path, isBinary)) { + if (auto nbt = GMCompoundTag::readFromFile(path, isBinary)) { return std::make_unique(nbt.value()); } return nullptr; @@ -527,14 +535,15 @@ void Export_Compatibility_API() { "GMLIB_API", "saveNbtToFile", [](std::string const& path, CompoundTag* nbt, bool isBinary) -> bool { - return GMLIB_CompoundTag::saveToFile(path, *nbt, isBinary); + return GMCompoundTag::saveToFile(path, *nbt, isBinary); } ); RemoteCall::exportAs("GMLIB_API", "getBlockDestroySpeed", [](Block const* block) -> float { - return block->getDestroySpeed(); + return block->mDirectData->mUnkc08fbd.as(); }); RemoteCall::exportAs("GMLIB_API", "getDestroyBlockSpeed", [](ItemStack const* item, Block const* block) -> float { - return item->getDestroySpeed(*block); + // return item->getDestroySpeed(*block); + throw std::runtime_error("GMLIB_API::getDestroyBlockSpeed is not implemented"); }); RemoteCall::exportAs( "GMLIB_API", @@ -544,7 +553,9 @@ void Export_Compatibility_API() { } ); RemoteCall::exportAs("GMLIB_API", "itemCanDestroyBlock", [](ItemStack const* item, Block const* block) -> bool { - return item->canDestroy(block); + return std::ranges::any_of(item->mCanDestroy, [block](BlockLegacy const* blockLegacy) { + return block->getTypeName() == blockLegacy->getTypeName(); + }); }); RemoteCall::exportAs("GMLIB_API", "itemCanDestroyInCreative", [](ItemStack const* item) -> bool { if (auto itemDef = item->getItem()) { @@ -553,27 +564,29 @@ void Export_Compatibility_API() { return false; }); RemoteCall::exportAs("GMLIB_API", "itemCanDestroySpecial", [](ItemStack const* item, Block const* block) -> bool { - return item->canDestroySpecial(*block); + // return item->canDestroySpecial(*block); + throw std::runtime_error("GMLIB_API::itemCanDestroySpecial is not implemented"); }); RemoteCall::exportAs("GMLIB_API", "blockCanDropWithAnyTool", [](Block const* block) -> bool { - return !block->requiresCorrectToolForDrops(); + return !block->getLegacyBlock().mRequiresCorrectToolForDrops; }); RemoteCall::exportAs( "GMLIB_API", "blockPlayerWillDestroy", [](Block const* block, Player* player, std::pair pos) -> bool { - return block->playerWillDestroy(*player, pos.first); + return block->getLegacyBlock().playerWillDestroy(*player, pos.first, *block); } ); RemoteCall::exportAs("GMLIB_API", "playerAttack", [](Player* player, Actor* entity) -> bool { - return player->attack(*entity, ActorDamageCause::EntityAttack); + return player->attack(*entity, SharedTypes::Legacy::ActorDamageCause::EntityAttack); }); RemoteCall::exportAs("GMLIB_API", "playerPullInEntity", [](Player* player, Actor* entity) -> bool { - return player->pullInEntity(*entity); + // return player->pullInEntity(*entity); + throw std::runtime_error("GMLIB_API::playerPullInEntity is not implemented"); }); RemoteCall::exportAs("GMLIB_API", "getBlockTranslateKeyFromName", [](std::string const& blockName) -> std::string { return Block::tryGetFromRegistry(blockName) - .transform([](const Block& block) -> std::string { return block.buildDescriptionId(); }) + .transform([](const Block& block) -> std::string { return block.buildDescriptionName(); }) .value_or("tile.unknown.name"); }); RemoteCall::exportAs( @@ -581,7 +594,7 @@ void Export_Compatibility_API() { "getBlockLightEmission", [](std::string const& blockName, short legacyData) -> char { return Block::tryGetFromRegistry(blockName) - .transform([](const Block& block) -> char { return (char)block.getLightEmission().mValue; }) + .transform([](const Block& block) -> char { return block.mDirectData->mUnkda4e0e.as(); }) .value_or(-1); } ); @@ -590,27 +603,27 @@ void Export_Compatibility_API() { "getGameRules", []() -> std::vector> { std::vector> result; - for (auto& gameRule : ll::service::getLevel()->getGameRules().getRules()) { - switch (gameRule.getType()) { + for (auto& gameRule : ll::service::getLevel()->getGameRules().mGameRules.get()) { + switch (gameRule.mType) { case GameRule::Type::Bool: result.push_back({ - {"Name", gameRule.getName() }, + {"Name", gameRule.mName }, {"Type", "Bool" }, - {"Value", std::to_string(gameRule.getBool())} + {"Value", std::to_string(gameRule.mValue->mUnk29fff1.as())} }); break; case GameRule::Type::Float: result.push_back({ - {"Name", gameRule.getName() }, + {"Name", gameRule.mName }, {"Type", "Float" }, - {"Value", std::to_string(gameRule.getFloat())} + {"Value", std::to_string(gameRule.mValue->mUnk768db5.as())} }); break; case GameRule::Type::Int: result.push_back({ - {"Name", gameRule.getName() }, + {"Name", gameRule.mName }, {"Type", "Int" }, - {"Value", std::to_string(gameRule.getInt())} + {"Value", std::to_string(gameRule.mValue->mUnk2ab4f3.as())} }); break; case GameRule::Type::Invalid: @@ -620,9 +633,9 @@ void Export_Compatibility_API() { return result; } ); - RemoteCall::exportAs("GMLIB_API", "getEnchantTypeNameFromId", [](int id) -> std::string { - if (auto enchant = Enchant::getEnchant((Enchant::Type)id)) { - return std::string(enchant->getStringId()); + RemoteCall::exportAs("GMLIB_API", "getEnchantTypeNameFromId", [](size_t id) -> std::string { + if (id < Enchant::mEnchants().size()){ + return Enchant::mEnchants()[id]->mStringId->getString(); } return ""; }); @@ -632,26 +645,26 @@ void Export_Compatibility_API() { [](ItemStack* item, std::string const& typeName, int level, bool allowNonVanilla) -> bool { return EnchantUtils::applyEnchant( *item, - Enchant::getEnchantTypeFromName(HashedString(typeName)), + Enchant::mEnchantNameToType()[HashedString(typeName)], level, allowNonVanilla ); } ); RemoteCall::exportAs("GMLIB_API", "removeEnchants", [](ItemStack* item) -> void { - EnchantUtils::removeEnchants(*item); + item->removeEnchants(); }); RemoteCall::exportAs("GMLIB_API", "hasEnchant", [](ItemStack* item, std::string const& typeName) -> bool { - return EnchantUtils::hasEnchant(Enchant::getEnchantTypeFromName(HashedString(typeName)), *item); + return EnchantUtils::hasEnchant(Enchant::mEnchantNameToType()[HashedString(typeName)], *item); }); RemoteCall::exportAs("GMLIB_API", "getEnchantLevel", [](ItemStack* item, std::string const& typeName) -> int { - return EnchantUtils::getEnchantLevel(Enchant::getEnchantTypeFromName(HashedString(typeName)), *item); + return EnchantUtils::getEnchantLevel(Enchant::mEnchantNameToType()[HashedString(typeName)], *item); }); RemoteCall::exportAs( "GMLIB_API", "getEnchantNameAndLevel", [](std::string const& typeName, int level) -> std::string { - return EnchantUtils::getEnchantNameAndLevel(Enchant::getEnchantTypeFromName(HashedString(typeName)), level); + return EnchantUtils::getEnchantNameAndLevel(Enchant::mEnchantNameToType()[HashedString(typeName)], level); } ); RemoteCall::exportAs( @@ -669,22 +682,30 @@ void Export_Compatibility_API() { return entity->getNameTag(); }); RemoteCall::exportAs("GMLIB_API", "ItemisUnbreakable", [](ItemStack const* item) -> bool { - return ((GMLIB_ItemStack*)item)->isUnbreakable(); + return ((GMItemStack*)item)->isUnbreakable(); }); RemoteCall::exportAs("GMLIB_API", "setItemUnbreakable", [](ItemStack const* item, bool value) -> void { - ((GMLIB_ItemStack*)item)->setUnbreakable(value); + ((GMItemStack*)item)->setUnbreakable(value); }); RemoteCall::exportAs("GMLIB_API", "getItemShouldKeepOnDeath", [](ItemStack const* item) -> bool { - return ((GMLIB_ItemStack*)item)->getShouldKeepOnDeath(); + return ((GMItemStack*)item)->getShouldKeepOnDeath(); }); RemoteCall::exportAs("GMLIB_API", "setItemShouldKeepOnDeath", [](ItemStack const* item, bool value) -> void { - ((GMLIB_ItemStack*)item)->setShouldKeepOnDeath(value); + auto nbt = ((GMItemStack*)item)->getNbt(); + if (value) { + (*nbt)["tags"]["minecraft:keep_on_death"] = true; + }else{ + if (nbt->contains("tags") && (*nbt)["tags"].contains("minecraft:keep_on_death")){ + (*nbt)["tags"].get().erase("minecraft:keep_on_death"); + } + } + ((GMItemStack*)item)->setNbt(*nbt); }); RemoteCall::exportAs("GMLIB_API", "getItemLockMode", [](ItemStack const* item) -> int { - return (int)((GMLIB_ItemStack*)item)->getItemLockMode(); + return (int)((GMItemStack*)item)->getItemLockMode(); }); RemoteCall::exportAs("GMLIB_API", "setItemLockMode", [](ItemStack const* item, int value) -> void { - ((GMLIB_ItemStack*)item)->setItemLockMode((ItemLockMode)value); + ((GMItemStack*)item)->setItemLockMode((ItemLockMode)value); }); RemoteCall::exportAs("GMLIB_API", "getItemRepairCost", [](ItemStack const* item) -> int { return item->getBaseRepairCost(); @@ -694,7 +715,7 @@ void Export_Compatibility_API() { }); RemoteCall::exportAs("GMLIB_API", "getItemCanDestroy", [](ItemStack const* item) -> std::vector { std::vector result = {}; - for (auto& block : ((GMLIB_ItemStack*)item)->getCanDestroy()) { + for (auto& block : ((GMItemStack*)item)->mCanDestroy) { result.push_back(block->getTypeName()); } return result; @@ -703,12 +724,18 @@ void Export_Compatibility_API() { "GMLIB_API", "setItemCanDestroy", [](ItemStack const* item, std::vector blocks) -> void { - ((GMLIB_ItemStack*)item)->setCanDestroy(blocks); + std::vector data; + for (auto& name : blocks) { + if (auto block = BlockLegacy::tryGetFromRegistry(name)) { + data.push_back(block.as_ptr()); + } + } + ((GMItemStack*)item)->mCanDestroy = data; } ); RemoteCall::exportAs("GMLIB_API", "getItemCanPlaceOn", [](ItemStack const* item) -> std::vector { std::vector result = {}; - for (auto& block : ((GMLIB_ItemStack*)item)->getCanPlaceOn()) { + for (auto& block : ((GMItemStack*)item)->mCanPlaceOn) { result.push_back(block->getTypeName()); } return result; @@ -717,11 +744,17 @@ void Export_Compatibility_API() { "GMLIB_API", "setItemCanPlaceOn", [](ItemStack const* item, std::vector blocks) -> void { - ((GMLIB_ItemStack*)item)->setCanPlaceOn(blocks); + std::vector data; + for (auto& name : blocks) { + if (auto block = BlockLegacy::tryGetFromRegistry(name)) { + data.push_back(block.as_ptr()); + } + } + ((GMItemStack*)item)->mCanPlaceOn = data; } ); RemoteCall::exportAs("GMLIB_API", "getPlayerHungry", [](Player* player) -> float { - return player->getMutableAttribute(Player::HUNGER())->getCurrentValue(); + return player->getMutableAttribute(Player::HUNGER()).mInstance->mCurrentValue; }); RemoteCall::exportAs("GMLIB_API", "getPlayerArmorCoverPercentage", [](Player* player) -> float { return player->getArmorCoverPercentage(); @@ -733,13 +766,19 @@ void Export_Compatibility_API() { return entity->getOwnerId().rawID; }); RemoteCall::exportAs("GMLIB_API", "getItemCategoryName", [](ItemStack const* item) -> std::string { - return item->getCategoryName(); + if (auto item2 = item->mItem){ + return item2->buildCategoryDescriptionName(); + } + return ""; }); RemoteCall::exportAs("GMLIB_API", "getItemCustomName", [](ItemStack const* item) -> std::string { return item->getCustomName(); }); RemoteCall::exportAs("GMLIB_API", "getItemEffecName", [](ItemStack const* item) -> std::string { - return item->getEffectName(); + if (auto item2 = item->mItem){ + return item2->buildEffectDescriptionName(*item); + } + return ""; }); RemoteCall::exportAs("GMLIB_API", "itemIsFood", [](ItemStack const* item) -> bool { if (auto itemDef = item->getItem()) { @@ -750,8 +789,8 @@ void Export_Compatibility_API() { RemoteCall::exportAs("GMLIB_API", "setPlayerUIItem", [](Player* player, int slot, ItemStack const* item) -> void { player->setPlayerUIItem((PlayerUISlot)slot, *item, false); }); - RemoteCall::exportAs("GMLIB_API", "getPlayerUIItem", [](Player* player, int slot) -> ItemStack* { - return const_cast(&player->getPlayerUIItem((PlayerUISlot)slot)); + RemoteCall::exportAs("GMLIB_API", "getPlayerUIItem", [](Player* player, int slot) -> ItemStack const* { + return &player->mPlayerUIContainer->getItem(slot); }); RemoteCall::exportAs( "GMLIB_API", @@ -761,10 +800,10 @@ void Export_Compatibility_API() { } ); RemoteCall::exportAs("GMLIB_API", "getContainerType", [](Container* container) -> std::string { - return magic_enum::enum_name(container->getContainerType()).data(); + return magic_enum::enum_name(container->mContainerType).data(); }); RemoteCall::exportAs("GMLIB_API", "hasPlayerNbt", [](std::string const& uuid) -> bool { - return GMLIB_Player::getPlayerNbt(mce::UUID::fromString(uuid)) != nullptr; + return OfflinePlayer::getOfflinePlayer(mce::UUID::fromString(uuid)).transform([&](auto&& player) -> bool { return player.hasNbt(); }).value_or(false); }); RemoteCall::exportAs("GMLIB_API", "getItemMaxCount", [](ItemStack const* item) -> int { return item->getMaxStackSize(); @@ -776,49 +815,58 @@ void Export_Compatibility_API() { return player->getDestroyProgress(*block); }); RemoteCall::exportAs("GMLIB_API", "getEntityEffectVisible", [](Actor* entity, int effectId) -> bool { - if (auto effect = entity->getEffect(effectId)) { + if (effectId < 0 || !MobEffect::mMobEffects()[effectId]) return false; + if (auto effect = entity->getEffect(*MobEffect::mMobEffects()[effectId])) { return effect->mEffectVisible; } return 0; }); RemoteCall::exportAs("GMLIB_API", "getEntityEffectDuration", [](Actor* entity, int effectId) -> int { - if (auto effect = entity->getEffect(effectId)) { + if (effectId < 0 || !MobEffect::mMobEffects()[effectId]) return false; + if (auto effect = entity->getEffect(*MobEffect::mMobEffects()[effectId])) { return effect->mDuration->mValue; } return 0; }); RemoteCall::exportAs("GMLIB_API", "getEntityEffectDurationEasy", [](Actor* entity, int effectId) -> int { - if (auto effect = entity->getEffect(effectId)) { + if (effectId < 0 || !MobEffect::mMobEffects()[effectId]) return false; + if (auto effect = entity->getEffect(*MobEffect::mMobEffects()[effectId])) { return effect->mDurationEasy->transform([](auto&& duration) -> int { return duration.mValue; }).value_or(0); } return 0; }); RemoteCall::exportAs("GMLIB_API", "getEntityEffectDurationHard", [](Actor* entity, int effectId) -> int { - if (auto effect = entity->getEffect(effectId)) { + if (effectId < 0 || !MobEffect::mMobEffects()[effectId]) return false; + if (auto effect = entity->getEffect(*MobEffect::mMobEffects()[effectId])) { return effect->mDurationHard->transform([](auto&& duration) -> int { return duration.mValue; }).value_or(0); } return 0; }); RemoteCall::exportAs("GMLIB_API", "getEntityEffectDurationNormal", [](Actor* entity, int effectId) -> int { - if (auto effect = entity->getEffect(effectId)) { - return effect->mDurationNormal->transform([](auto&& duration) -> int { return duration.mValue; }).value_or(0); + if (effectId < 0 || !MobEffect::mMobEffects()[effectId]) return false; + if (auto effect = entity->getEffect(*MobEffect::mMobEffects()[effectId])) { + return effect->mDurationNormal->transform( + [](auto&& duration) -> int { return duration.mValue; } + ).value_or(0); } return 0; }); RemoteCall::exportAs("GMLIB_API", "getEntityEffectAmplifier", [](Actor* entity, int effectId) -> int { - if (auto effect = entity->getEffect(effectId)) { + if (effectId < 0 || !MobEffect::mMobEffects()[effectId]) return false; + if (auto effect = entity->getEffect(*MobEffect::mMobEffects()[effectId])) { return effect->mAmplifier; } return 0; }); RemoteCall::exportAs("GMLIB_API", "getEntityEffectAmbient", [](Actor* entity, int effectId) -> bool { - if (auto effect = entity->getEffect(effectId)) { + if (effectId < 0 || !MobEffect::mMobEffects()[effectId]) return false; + if (auto effect = entity->getEffect(*MobEffect::mMobEffects()[effectId])) { return effect->mAmbient; } return 0; }); - RemoteCall::exportAs("GMLIB_API", "entityHasEffect", [](Actor* entity, int effectId) -> int { - return entity->hasEffect(*MobEffect::getById(effectId)); + RemoteCall::exportAs("GMLIB_API", "entityHasEffect", [](Actor* entity, int effectId) -> bool { + return effectId > 0x24 ? false : entity->hasEffect(*MobEffect::mMobEffects()[effectId]); }); RemoteCall::exportAs("GMLIB_API", "getGameDifficulty", []() -> int { return ll::service::getLevel().transform( @@ -827,7 +875,7 @@ void Export_Compatibility_API() { }); RemoteCall::exportAs("GMLIB_API", "setGameDifficulty", [](int difficulty) -> void { if (auto level = ll::service::getLevel()) { - level->setDifficulty((Difficulty)difficulty); + level->setDifficulty((SharedTypes::Legacy::Difficulty)difficulty); } }); RemoteCall::exportAs("GMLIB_API", "getDefaultGameMode", []() -> int { @@ -844,19 +892,20 @@ void Export_Compatibility_API() { "GMLIB_API", "registerCustomShapelessRecipe", [](std::string const& recipe_id, std::vector ingredients, ItemStack* result) -> void { - if (!GMLIB_Level::getInstance().has_value()) return; - std::vector types; - char rt = 'A'; - for (auto& ing : ingredients) { - auto ingredient = RecipeIngredient{ing, 0,1}; - types.push_back(Recipes::Type{ - (Item*)ingredient.getItem(), - ingredient.getBlock(), - ingredient, - rt++ - }); - } - GMLIB::Mod::CustomRecipe::registerShapelessCraftingTableRecipe(recipe_id, types, *result); + // if (!GMLevel::getInstance().has_value()) return; + // std::vector types; + // char rt = 'A'; + // for (auto& ing : ingredients) { + // auto ingredient = RecipeIngredient{ing, 0,1}; + // types.push_back(Recipes::Type{ + // (Item*)ingredient.getItem(), + // ingredient.getBlock(), + // ingredient, + // rt++ + // }); + // } + // GMLIB::Mod::CustomRecipe::registerShapelessCraftingTableRecipe(recipe_id, types, *result); + throw std::runtime_error("GMLIB_API::registerCustomShapelessRecipe is not implemented"); } ); RemoteCall::exportAs( @@ -866,7 +915,7 @@ void Export_Compatibility_API() { std::vector shape, std::vector ingredients, ItemStack* result) -> void { - if (!GMLIB_Level::getInstance().has_value()) return; + if (!GMLevel::getInstance().has_value()) return; std::vector types; char rt = 'A'; for (auto& ing : ingredients) { @@ -884,7 +933,13 @@ void Export_Compatibility_API() { 50, nullptr, tmp, - SemVersion(1, 20, 80, "", ""), + SemVersion( + 1, + 20, + 80, + {"", Bedrock::StaticOptimizedString::StorageType::Static}, + {"", Bedrock::StaticOptimizedString::StorageType::Static} + ), true ); } diff --git a/src/Entry.cpp b/src/Entry.cpp index 18fcd80..69929a6 100644 --- a/src/Entry.cpp +++ b/src/Entry.cpp @@ -13,15 +13,15 @@ bool LegacyRemoteCallApi::load() { Export_Legacy_GMLib_ServerAPI(); Export_Compatibility_API(); ExportPAPI(); - Export_Event_API(); + // Export_Event_API(); Export_BinaryStream_API(); // Export_Form_API(); auto logger = ll::io::LoggerRegistry::getInstance().getOrCreate(PLUGIN_NAME); logger->info("GMLIB-LegacyRemoteCallApi Loaded!"); logger->info( "Loaded Version: {} with {}", - fmt::format(fg(fmt::color::pink), "GMLIB-" + GMLIB::Version::getLibVersionString()), - fmt::format(fg(fmt::color::light_green), "GMLIB-LegacyRemoteCallApi-" + LIB_VERSION.asString()) + fmt::format(fg(fmt::color::pink), "GMLIB-" GMLIB_FILE_VERSION_STRING), + fmt::format(fg(fmt::color::light_green), "GMLIB-LegacyRemoteCallApi-" + LIB_VERSION.to_string()) ); logger->info("Author: GroupMountain"); logger->info("Repository: https://github.com/GroupMountain/GMLIB-LegacyRemoteCallApi"); @@ -35,3 +35,8 @@ bool LegacyRemoteCallApi::disable() { return true; } } // namespace gmlib LL_REGISTER_MOD(gmlib::LegacyRemoteCallApi, gmlib::LegacyRemoteCallApi::getInstance()); + + +ll::thread::ThreadPoolExecutor const& getThreadPoolExecutor() { + return gmlib::LegacyRemoteCallApi::getInstance().getThreadPoolExecutor(); +} \ No newline at end of file diff --git a/src/Entry.h b/src/Entry.h index b24b034..6fe19c3 100644 --- a/src/Entry.h +++ b/src/Entry.h @@ -1,6 +1,7 @@ #pragma once #include #include +#include namespace gmlib { @@ -9,7 +10,7 @@ class LegacyRemoteCallApi { public: static LegacyRemoteCallApi& getInstance(); - LegacyRemoteCallApi() : mSelf(*ll::mod::NativeMod::current()) {} + LegacyRemoteCallApi() : mSelf(*ll::mod::NativeMod::current()), mThreadPoolExecutor(getSelf().getName()) {} [[nodiscard]] ll::mod::NativeMod& getSelf() const { return mSelf; } @@ -26,8 +27,11 @@ public: // /// @return True if the plugin is unloaded successfully. // bool unload(); + ll::thread::ThreadPoolExecutor& getThreadPoolExecutor() { return mThreadPoolExecutor; } + private: - ll::mod::NativeMod& mSelf; + ll::mod::NativeMod& mSelf; + ll::thread::ThreadPoolExecutor mThreadPoolExecutor; }; } // namespace gmlib diff --git a/src/EventAPI.cpp b/src/EventAPI.cpp index c3772ef..54c24d6 100644 --- a/src/EventAPI.cpp +++ b/src/EventAPI.cpp @@ -83,152 +83,149 @@ void Export_Event_API() { } case doHash("gmlib::ClientLoginAfterEvent"): { REGISTER_EVENT_LISTEN( - GMLIB::Event::PacketEvent::ClientLoginAfterEvent, + ila::mc::ClientLoginAfterEvent, (std::string const& realName, std::string const& uuid, std::string const& serverXuid, std::string const& clientXuid), - (event.getRealName(), - event.getUuid().asString(), - event.getServerAuthXuid(), - event.getClientAuthXuid()), + (event.realName(), + event.uuid().asString(), + event.serverAuthXuid(), + event.clientAuthXuid()), if (result) event.disConnectClient(); ); } case doHash("gmlib::WeatherUpdateBeforeEvent"): { REGISTER_EVENT_LISTEN( - GMLIB::Event::LevelEvent::WeatherUpdateBeforeEvent, + ila::mc::WeatherUpdateBeforeEvent, (float rainLevel, int rainTime, float lightningLevel, int lightningTime, bool isCancelled), - (event.getRainLevel(), - event.getRainingLastTick(), - event.getLightningLevel(), - event.getLightningLastTick(), + (event.rainLevel(), + event.rainTime(), + event.lightningLevel(), + event.lightningTime(), event.isCancelled()), event.setCancelled(result); ); } case doHash("gmlib::WeatherUpdateAfterEvent"): { REGISTER_EVENT_LISTEN( - GMLIB::Event::LevelEvent::WeatherUpdateAfterEvent, + ila::mc::WeatherUpdateAfterEvent, (float rainLevel, int rainTime, float lightningLevel, int lightningTime), - (event.getRainLevel(), - event.getRainingLastTick(), - event.getLightningLevel(), - event.getLightningLastTick()), + (event.rainLevel(), event.rainTime(), event.lightningLevel(), event.lightningTime()), , ); } case doHash("gmlib::MobPickupItemBeforeEvent"): { REGISTER_EVENT_LISTEN( - GMLIB::Event::EntityEvent::MobPickupItemBeforeEvent, + ila::mc::ActorPickupItemBeforeEvent, (Actor * mob, Actor * item, bool isCancelled), - (&event.self(), (Actor*)&event.getItemActor(), event.isCancelled()), + (&event.self(), (Actor*)&event.itemActor(), event.isCancelled()), event.setCancelled(result); ); } case doHash("gmlib::MobPickupItemAfterEvent"): { REGISTER_EVENT_LISTEN( - GMLIB::Event::EntityEvent::MobPickupItemAfterEvent, + ila::mc::ActorPickupItemAfterEvent, (Actor * mob, Actor * item), - (&event.self(), (Actor*)&event.getItemActor()), + (&event.self(), (Actor*)&event.itemActor()), , ); } case doHash("gmlib::ItemActorSpawnBeforeEvent"): { REGISTER_EVENT_LISTEN( - GMLIB::Event::EntityEvent::ItemActorSpawnBeforeEvent, + ila::mc::SpawnItemActorBeforeEvent, (ItemStack * item, std::pair position, int64 spawnerUniqueId, bool isCancelled), - (&event.getItem(), - {event.getPosition(), event.getBlockSource().getDimensionId().id}, - event.getSpawner().has_value() ? event.getSpawner()->getOrCreateUniqueID().rawID : -1, + (&event.item(), + {event.pos(), event.blockSource().getDimensionId().id}, + event.spawner() ? event.spawner()->getOrCreateUniqueID().rawID : -1, event.isCancelled()), event.setCancelled(result); ); } case doHash("gmlib::ItemActorSpawnAfterEvent"): { REGISTER_EVENT_LISTEN( - GMLIB::Event::EntityEvent::ItemActorSpawnAfterEvent, + ila::mc::SpawnItemActorAfterEvent, (Actor * item, std::pair position, int64 spawnerUniqueId), - (&event.self(), - {event.getPosition(), event.getBlockSource().getDimensionId().id}, - event.getSpawner().has_value() ? event.getSpawner()->getOrCreateUniqueID().rawID : -1), + (event.itemActor(), + {event.pos(), event.blockSource().getDimensionId().id}, + event.spawner() ? event.spawner()->getOrCreateUniqueID().rawID : -1), , ); } case doHash("gmlib::ActorChangeDimensionBeforeEvent"): { REGISTER_EVENT_LISTEN( - GMLIB::Event::EntityEvent::ActorChangeDimensionBeforeEvent, + ila::mc::ActorChangeDimensionBeforeEvent, (Actor * entity, int toDimId, bool isCancelled), - (&event.self(), event.getToDimensionId(), event.isCancelled()), + (&event.self(), event.toDimensionId(), event.isCancelled()), event.setCancelled(result); ); } case doHash("gmlib::ActorChangeDimensionAfterEvent"): { REGISTER_EVENT_LISTEN( - GMLIB::Event::EntityEvent::ActorChangeDimensionAfterEvent, + ila::mc::ActorChangeDimensionAfterEvent, (Actor * entity, int fromDimId, int toDimId), - (&event.self(), event.getFromDimensionId(), event.getToDimensionId()), - , - ); - } - case doHash("gmlib::PlayerStartSleepBeforeEvent"): { - REGISTER_EVENT_LISTEN( - GMLIB::Event::PlayerEvent::PlayerStartSleepBeforeEvent, - (Player * entity, BlockPos pos, bool isCancelled), - (&event.self(), event.getPosition(), event.isCancelled()), - event.setCancelled(result); - ); - } - case doHash("gmlib::PlayerStartSleepAfterEvent"): { - REGISTER_EVENT_LISTEN( - GMLIB::Event::PlayerEvent::PlayerStartSleepAfterEvent, - (Player * entity, BlockPos pos, int result), - (&event.self(), event.getPosition(), (int)event.getResult()), - , - ); - } - case doHash("gmlib::PlayerStopSleepBeforeEvent"): { - REGISTER_EVENT_LISTEN( - GMLIB::Event::PlayerEvent::PlayerStopSleepBeforeEvent, - (Player * entity, bool forcefulWakeUp, bool updateLevelList, bool isCancelled), - (&event.self(), event.isForcefulWakeUp(), event.isUpdateLevelList(), event.isCancelled()), - event.setCancelled(result); - ); - } - case doHash("gmlib::PlayerStopSleepAfterEvent"): { - REGISTER_EVENT_LISTEN( - GMLIB::Event::PlayerEvent::PlayerStopSleepAfterEvent, - (Player * entity, bool forcefulWakeUp, bool updateLevelList, bool), - (&event.self(), event.isForcefulWakeUp(), event.isUpdateLevelList(), false), + (&event.self(), event.fromDimensionId(), event.toDimensionId()), , ); } + // case doHash("gmlib::PlayerStartSleepBeforeEvent"): { + // REGISTER_EVENT_LISTEN( + // GMLIB::Event::PlayerEvent::PlayerStartSleepBeforeEvent, + // (Player * entity, BlockPos pos, bool isCancelled), + // (&event.self(), event.getPosition(), event.isCancelled()), + // event.setCancelled(result); + // ); + // } + // case doHash("gmlib::PlayerStartSleepAfterEvent"): { + // REGISTER_EVENT_LISTEN( + // GMLIB::Event::PlayerEvent::PlayerStartSleepAfterEvent, + // (Player * entity, BlockPos pos, int result), + // (&event.self(), event.getPosition(), (int)event.getResult()), + // , + // ); + // } + // case doHash("gmlib::PlayerStopSleepBeforeEvent"): { + // REGISTER_EVENT_LISTEN( + // GMLIB::Event::PlayerEvent::PlayerStopSleepBeforeEvent, + // (Player * entity, bool forcefulWakeUp, bool updateLevelList, bool isCancelled), + // (&event.self(), event.isForcefulWakeUp(), event.isUpdateLevelList(), event.isCancelled()), + // event.setCancelled(result); + // ); + // } + // case doHash("gmlib::PlayerStopSleepAfterEvent"): { + // REGISTER_EVENT_LISTEN( + // GMLIB::Event::PlayerEvent::PlayerStopSleepAfterEvent, + // (Player * entity, bool forcefulWakeUp, bool updateLevelList, bool), + // (&event.self(), event.isForcefulWakeUp(), event.isUpdateLevelList(), false), + // , + // ); + // } case doHash("gmlib::DeathMessageAfterEvent"): { REGISTER_EVENT_LISTEN( - GMLIB::Event::EntityEvent::DeathMessageAfterEvent, + ila::mc::DeathMessageAfterEvent, (std::string const& message, std::vector, Actor* dead), - (event.getDeathMessage().first, event.getDeathMessage().second, &event.self()), + (event.result().first, event.result().second, &event.self()), , ); } - case doHash("gmlib::MobHurtAfterEvent"): { - REGISTER_EVENT_LISTEN( - GMLIB::Event::EntityEvent::MobHurtAfterEvent, - (Actor * mob, Actor * source, float damage, int cause), - (&event.self(), source, -event.getDamage(), (int)damageSource.getCause()), - , - auto& damageSource = event.getSource(); - Actor* source = nullptr; - if (damageSource.isEntitySource()) { - auto uniqueId = damageSource.getDamagingEntityUniqueID(); - source = ll::service::getLevel()->fetchEntity(uniqueId, false); - if (source->getOwner()) source = source->getOwner(); - } - ); - } + // case doHash("gmlib::MobHurtAfterEvent"): { + // REGISTER_EVENT_LISTEN( + // GMLIB::Event::EntityEvent::MobHurtAfterEvent, + // (Actor * mob, Actor * source, float damage, int cause), + // (&event.self(), source, -event.getDamage(), (int)damageSource.getCause()), + // , + // auto& damageSource = event.getSource(); + // Actor* source = nullptr; + // if (damageSource.isEntitySource()) { + // auto uniqueId = damageSource.getDamagingEntityUniqueID(); + // source = ll::service::getLevel()->fetchEntity(uniqueId, false); + // if (source->getOwner()) source = source->getOwner(); + // } + // ); + // } case doHash("gmlib::EndermanTakeBlockBeforeEvent"): { REGISTER_EVENT_LISTEN( - GMLIB::Event::EntityEvent::EndermanTakeBlockBeforeEvent, + ila::mc::EndermanTakeBlockBeforeEvent, (Actor * mob, bool isCancelled), (&event.self(), event.isCancelled()), event.setCancelled(result); @@ -236,7 +233,7 @@ void Export_Event_API() { } case doHash("gmlib::DragonRespawnBeforeEvent"): { REGISTER_EVENT_LISTEN( - GMLIB::Event::EntityEvent::DragonRespawnBeforeEvent, + ila::mc::DragonRespawnBeforeEvent, (bool isCancelled), (event.isCancelled()), event.setCancelled(result); @@ -244,111 +241,111 @@ void Export_Event_API() { } case doHash("gmlib::DragonRespawnAfterEvent"): { REGISTER_EVENT_LISTEN( - GMLIB::Event::EntityEvent::DragonRespawnAfterEvent, + ila::mc::DragonRespawnAfterEvent, (Actor * mob), - (event.getEnderDragon()), - ); - } - case doHash("gmlib::ProjectileCreateBeforeEvent"): { - REGISTER_EVENT_LISTEN( - GMLIB::Event::EntityEvent::ProjectileCreateBeforeEvent, - (Actor * mob, int64 uniqueId, bool isCancelled), - (&event.self(), - event.getShooter() ? event.getShooter()->getOrCreateUniqueID().rawID : -1, - event.isCancelled()), - event.setCancelled(result); - ); - } - case doHash("gmlib::ProjectileCreateAfterEvent"): { - REGISTER_EVENT_LISTEN( - GMLIB::Event::EntityEvent::ProjectileCreateAfterEvent, - (Actor * mob, int64 uniqueId), - (&event.self(), event.getShooter() ? event.getShooter()->getOrCreateUniqueID().rawID : -1), + (&event.self()), ); } + // case doHash("gmlib::ProjectileCreateBeforeEvent"): { + // REGISTER_EVENT_LISTEN( + // ila::mc::ProjectileCreateBeforeEvent, + // (Actor * mob, int64 uniqueId, bool isCancelled), + // (&event.self(), + // event.getShooter() ? event.getShooter()->getOrCreateUniqueID().rawID : -1, + // event.isCancelled()), + // event.setCancelled(result); + // ); + // } + // case doHash("gmlib::ProjectileCreateAfterEvent"): { + // REGISTER_EVENT_LISTEN( + // GMLIB::Event::EntityEvent::ProjectileCreateAfterEvent, + // (Actor * mob, int64 uniqueId), + // (&event.self(), event.getShooter() ? event.getShooter()->getOrCreateUniqueID().rawID : -1), + // ); + // } case doHash("gmlib::SpawnWanderingTraderBeforeEvent"): { REGISTER_EVENT_LISTEN( - GMLIB::Event::EntityEvent::SpawnWanderingTraderBeforeEvent, + ila::mc::SpawnWanderingTraderBeforeEvent, (std::pair pos, bool isCancelled), - ({event.getPos(), event.getRegion().getDimensionId()}, event.isCancelled()), + ({event.pos(), event.blockSource().getDimensionId()}, event.isCancelled()), event.setCancelled(result); ); } case doHash("gmlib::SpawnWanderingTraderAfterEvent"): { REGISTER_EVENT_LISTEN( - GMLIB::Event::EntityEvent::SpawnWanderingTraderAfterEvent, + ila::mc::SpawnWanderingTraderAfterEvent, (std::pair pos), - ({event.getPos(), event.getRegion().getDimensionId()}), - ); - } - case doHash("gmlib::HandleRequestActionBeforeEvent"): { - // clang-format off - REGISTER_EVENT_LISTEN( - GMLIB::Event::PlayerEvent::HandleRequestActionBeforeEvent, - ( - Player * player, - std::string const& actionType, - int count, - std::string const& sourceContainerNetId, - int sourceSlot, - std::string const& destinationContainerNetId, - int destinationSlot, - bool isCancelled - ), - ( - (Player*)&event.self(), - magic_enum::enum_name(requestAction.mActionType).data(), - (int)requestAction.mAmount, - magic_enum::enum_name(requestAction.mSrc->mFullContainerName.mName).data(), - (int)requestAction.mSrc->mSlot, - magic_enum::enum_name(requestAction.mDst->mFullContainerName.mName).data(), - (int)requestAction.mDst->mSlot, - event.isCancelled() - ), - event.setCancelled(result);, - auto& requestAction = (ItemStackRequestActionTransferBase&)event.getRequestAction(); - ); - // clang-format on - } - case doHash("gmlib::HandleRequestActionAfterEvent"): { - // clang-format off - REGISTER_EVENT_LISTEN( - GMLIB::Event::PlayerEvent::HandleRequestActionAfterEvent, - ( - Player * player, - std::string const& actionType, - int count, - std::string const& sourceContainerNetId, - int sourceSlot, - std::string const& destinationContainerNetId, - int destinationSlot - ), - ( - (Player*)&event.self(), - magic_enum::enum_name(requestAction.mActionType).data(), - (int)requestAction.mAmount, - magic_enum::enum_name(requestAction.mSrc->mFullContainerName.mName).data(), - (int)requestAction.mSrc->mSlot, - magic_enum::enum_name(requestAction.mDst->mFullContainerName.mName).data(), - (int)requestAction.mDst->mSlot - ), - , - auto& requestAction = (ItemStackRequestActionTransferBase&)event.getRequestAction(); - ); - // clang-format on - } - case doHash("gmlib::ContainerClosePacketSendAfterEvent"): { - REGISTER_EVENT_LISTEN( - GMLIB::Event::PacketEvent::ContainerClosePacketSendAfterEvent, - (Player * player, int containerId, bool serverInitiatedClose, bool), - (event.getServerNetworkHandler() - ._getServerPlayer(event.getNetworkIdentifier(), event.getPacket().mClientSubId), - (int)event.getPacket().mContainerId, - event.getPacket().mServerInitiatedClose, - false), - , + ({event.pos(), event.blockSource().getDimensionId()}), ); } + // case doHash("gmlib::HandleRequestActionBeforeEvent"): { + // // clang-format off + // REGISTER_EVENT_LISTEN( + // GMLIB::Event::PlayerEvent::HandleRequestActionBeforeEvent, + // ( + // Player * player, + // std::string const& actionType, + // int count, + // std::string const& sourceContainerNetId, + // int sourceSlot, + // std::string const& destinationContainerNetId, + // int destinationSlot, + // bool isCancelled + // ), + // ( + // (Player*)&event.self(), + // magic_enum::enum_name(requestAction.mActionType).data(), + // (int)requestAction.mAmount, + // magic_enum::enum_name(requestAction.mSrc->mFullContainerName.mName).data(), + // (int)requestAction.mSrc->mSlot, + // magic_enum::enum_name(requestAction.mDst->mFullContainerName.mName).data(), + // (int)requestAction.mDst->mSlot, + // event.isCancelled() + // ), + // event.setCancelled(result);, + // auto& requestAction = (ItemStackRequestActionTransferBase&)event.getRequestAction(); + // ); + // // clang-format on + // } + // case doHash("gmlib::HandleRequestActionAfterEvent"): { + // // clang-format off + // REGISTER_EVENT_LISTEN( + // GMLIB::Event::PlayerEvent::HandleRequestActionAfterEvent, + // ( + // Player * player, + // std::string const& actionType, + // int count, + // std::string const& sourceContainerNetId, + // int sourceSlot, + // std::string const& destinationContainerNetId, + // int destinationSlot + // ), + // ( + // (Player*)&event.self(), + // magic_enum::enum_name(requestAction.mActionType).data(), + // (int)requestAction.mAmount, + // magic_enum::enum_name(requestAction.mSrc->mFullContainerName.mName).data(), + // (int)requestAction.mSrc->mSlot, + // magic_enum::enum_name(requestAction.mDst->mFullContainerName.mName).data(), + // (int)requestAction.mDst->mSlot + // ), + // , + // auto& requestAction = (ItemStackRequestActionTransferBase&)event.getRequestAction(); + // ); + // // clang-format on + // } + // case doHash("gmlib::ContainerClosePacketSendAfterEvent"): { + // REGISTER_EVENT_LISTEN( + // GMLIB::Event::PacketEvent::ContainerClosePacketSendAfterEvent, + // (Player * player, int containerId, bool serverInitiatedClose, bool), + // (event.getServerNetworkHandler() + // ._getServerPlayer(event.getNetworkIdentifier(), event.getPacket().mClientSubId), + // (int)event.getPacket().mContainerId, + // event.getPacket().mServerInitiatedClose, + // false), + // , + // ); + // } } return -1; } diff --git a/src/Global.h b/src/Global.h index 2d6e80c..ca74632 100644 --- a/src/Global.h +++ b/src/Global.h @@ -1,7 +1,11 @@ #pragma once -#include - +// clang-format off +#define GMLIB_Gloabl_Using +#include +#include +#include #include +// clang-format on #define PLUGIN_NAME fmt::format(fg(fmt::color::light_green), "GMLIB-LRCA") @@ -9,7 +13,7 @@ #define LIB_VERSION_MINOR 13 #define LIB_VERSION_PATCH 6 -#define LIB_VERSION GMLIB::Version(LIB_VERSION_MAJOR, LIB_VERSION_MINOR, LIB_VERSION_PATCH) +#define LIB_VERSION ll::data::Version(LIB_VERSION_MAJOR, LIB_VERSION_MINOR, LIB_VERSION_PATCH) extern void Export_Legacy_GMLib_ModAPI(); extern void Export_Legacy_GMLib_ServerAPI(); @@ -17,4 +21,5 @@ extern void Export_Compatibility_API(); extern void ExportPAPI(); extern void Export_Event_API(); extern void Export_BinaryStream_API(); -// extern void Export_Form_API(); +extern ll::thread::ThreadPoolExecutor const& getThreadPoolExecutor(); +// extern void Export_Form_API(); \ No newline at end of file diff --git a/src/LegacyModApi.cpp b/src/LegacyModApi.cpp index 44a200f..6da72c0 100644 --- a/src/LegacyModApi.cpp +++ b/src/LegacyModApi.cpp @@ -1,4 +1,6 @@ #include "Global.h" +#include +#include std::unordered_set HardCodedKeys = {"AlwaysUnlocked", "PlayerHasManyItems", "PlayerInWater", "None"}; @@ -17,17 +19,18 @@ void Export_Legacy_GMLib_ModAPI() { std::string const& result, int count, std::string const& unlock) -> void { - if (!GMLIB_Level::getInstance().has_value()) return; - std::vector types; - for (auto ing : ingredients) { - types.emplace_back(ing, 0, 1); - } - GMLIB::Mod::JsonRecipe::registerShapelessCraftingTableRecipe( - recipe_id, - types, - RecipeIngredient(result, 0, count), - makeRecipeUnlockingKey(unlock) - ); + // if (!GMLIB_Level::getInstance().has_value()) return; + // std::vector types; + // for (auto ing : ingredients) { + // types.emplace_back(ing, 0, 1); + // } + // GMLIB::Mod::JsonRecipe::registerShapelessCraftingTableRecipe( + // recipe_id, + // types, + // RecipeIngredient(result, 0, count), + // makeRecipeUnlockingKey(unlock) + // ); + throw std::runtime_error("GMLib_ModAPI::registerShapelessRecipe is not implemented"); } ); RemoteCall::exportAs( @@ -39,18 +42,19 @@ void Export_Legacy_GMLib_ModAPI() { std::string const& result, int count, std::string const& unlock) -> void { - if (!GMLIB_Level::getInstance().has_value()) return; - std::vector types; - for (auto ing : ingredients) { - types.push_back(RecipeIngredient(ing, 0, 1)); - } - GMLIB::Mod::JsonRecipe::registerShapedCraftingTableRecipe( - recipe_id, - shape, - types, - RecipeIngredient(result, 0, count), - makeRecipeUnlockingKey(unlock) - ); + // if (!GMLIB_Level::getInstance().has_value()) return; + // std::vector types; + // for (auto ing : ingredients) { + // types.push_back(RecipeIngredient(ing, 0, 1)); + // } + // GMLIB::Mod::JsonRecipe::registerShapedCraftingTableRecipe( + // recipe_id, + // shape, + // types, + // RecipeIngredient(result, 0, count), + // makeRecipeUnlockingKey(unlock) + // ); + throw std::runtime_error("GMLib_ModAPI::registerShapedRecipe is not implemented"); } ); RemoteCall::exportAs( @@ -60,13 +64,14 @@ void Export_Legacy_GMLib_ModAPI() { std::string const& input, std::string const& output, std::vector tags) -> void { - if (!GMLIB_Level::getInstance().has_value()) return; - GMLIB::Mod::JsonRecipe::registerFurnaceRecipe( - recipe_id, - RecipeIngredient(input, 0, 1), - RecipeIngredient(output, 0, 1), - tags - ); + // if (!GMLIB_Level::getInstance().has_value()) return; + // GMLIB::Mod::JsonRecipe::registerFurnaceRecipe( + // recipe_id, + // RecipeIngredient(input, 0, 1), + // RecipeIngredient(output, 0, 1), + // tags + // ); + throw std::runtime_error("GMLib_ModAPI::registerFurnaceRecipe is not implemented"); } ); RemoteCall::exportAs( @@ -74,8 +79,10 @@ void Export_Legacy_GMLib_ModAPI() { "registerBrewingMixRecipe", [](std::string const& recipe_id, std::string const& input, std::string const& output, std::string const& reagent ) -> void { - if (!GMLIB_Level::getInstance().has_value()) return; - GMLIB::Mod::JsonRecipe::registerBrewingMixRecipe(recipe_id, input, output, RecipeIngredient(reagent, 0, 1)); + // if (!GMLIB_Level::getInstance().has_value()) return; + // GMLIB::Mod::JsonRecipe::registerBrewingMixRecipe(recipe_id, input, output, RecipeIngredient(reagent, 0, + // 1)); + throw std::runtime_error("GMLib_ModAPI::registerBrewingMixRecipe is not implemented"); } ); RemoteCall::exportAs( @@ -83,13 +90,14 @@ void Export_Legacy_GMLib_ModAPI() { "registerBrewingContainerRecipe", [](std::string const& recipe_id, std::string const& input, std::string const& output, std::string const& reagent ) -> void { - if (!GMLIB_Level::getInstance().has_value()) return; - GMLIB::Mod::JsonRecipe::registerBrewingContainerRecipe( - recipe_id, - RecipeIngredient(input, 0, 1), - RecipeIngredient(output, 0, 1), - RecipeIngredient(reagent, 0, 1) - ); + // if (!GMLIB_Level::getInstance().has_value()) return; + // GMLIB::Mod::JsonRecipe::registerBrewingContainerRecipe( + // recipe_id, + // RecipeIngredient(input, 0, 1), + // RecipeIngredient(output, 0, 1), + // RecipeIngredient(reagent, 0, 1) + // ); + throw std::runtime_error("GMLib_ModAPI::registerBrewingContainerRecipe is not implemented"); } ); RemoteCall::exportAs( @@ -100,14 +108,15 @@ void Export_Legacy_GMLib_ModAPI() { std::string const& base, std::string const& addition, std::string const& result) -> void { - if (!GMLIB_Level::getInstance().has_value()) return; - GMLIB::Mod::JsonRecipe::registerSmithingTransformRecipe( - recipe_id, - smithing_template, - base, - addition, - result - ); + // if (!GMLIB_Level::getInstance().has_value()) return; + // GMLIB::Mod::JsonRecipe::registerSmithingTransformRecipe( + // recipe_id, + // smithing_template, + // base, + // addition, + // result + // ); + throw std::runtime_error("GMLib_ModAPI::registerSmithingTransformRecipe is not implemented"); } ); RemoteCall::exportAs( @@ -117,8 +126,9 @@ void Export_Legacy_GMLib_ModAPI() { std::string const& smithing_template, std::string const& base, std::string const& addition) -> void { - if (!GMLIB_Level::getInstance().has_value()) return; - GMLIB::Mod::JsonRecipe::registerSmithingTrimRecipe(recipe_id, smithing_template, base, addition); + // if (!GMLIB_Level::getInstance().has_value()) return; + // GMLIB::Mod::JsonRecipe::registerSmithingTrimRecipe(recipe_id, smithing_template, base, addition); + throw std::runtime_error("GMLib_ModAPI::registerSmithingTrimRecipe is not implemented"); } ); RemoteCall::exportAs( @@ -130,49 +140,40 @@ void Export_Legacy_GMLib_ModAPI() { std::string const& output, int output_data, int output_count) -> void { - if (!GMLIB_Level::getInstance().has_value()) return; - GMLIB::Mod::JsonRecipe::registerStoneCutterRecipe( - recipe_id, - RecipeIngredient(input, 0, 1), - RecipeIngredient(output, 0, 1) - ); + // if (!GMLIB_Level::getInstance().has_value()) return; + // GMLIB::Mod::JsonRecipe::registerStoneCutterRecipe( + // recipe_id, + // RecipeIngredient(input, 0, 1), + // RecipeIngredient(output, 0, 1) + // ); + throw std::runtime_error("GMLib_ModAPI::registerStoneCutterRecipe is not implemented"); } ); // 错误方块清理 RemoteCall::exportAs("GMLib_ModAPI", "setUnknownBlockCleaner", []() -> void { - GMLIB::Mod::VanillaFix::setAutoCleanUnknownBlockEnabled(); + // GMLIB::Mod::VanillaFix::setAutoCleanUnknownBlockEnabled(); + throw std::runtime_error("GMLib_ModAPI::setUnknownBlockCleaner is not implemented"); }); // 实验性 RemoteCall::exportAs("GMLib_ModAPI", "registerExperimentsRequire", [](int experiment_id) -> void { - auto list = GMLIB_Level::getAllExperiments(); - std::unordered_set set(list.begin(), list.end()); - if (set.contains((AllExperiments)experiment_id)) { - GMLIB_Level::addExperimentsRequire((AllExperiments)experiment_id); - } else { - ll::io::LoggerRegistry::getInstance().getOrCreate("Server")->error("Experiment ID '{}' does not exist!", experiment_id); - } + GMLevel::getInstance().and_then([&](GMLevel& level) { + level.setExperimentEnabled((AllExperiments)experiment_id); + return true; + }); }); RemoteCall::exportAs("GMLib_ModAPI", "setExperimentEnabled", [](int experiment_id, bool value) -> void { - if (GMLIB_Level::getInstance()) { - auto list = GMLIB_Level::getAllExperiments(); - std::unordered_set set(list.begin(), list.end()); - if (set.contains((AllExperiments)experiment_id)) { - GMLIB_Level::getInstance()->setExperimentEnabled(((AllExperiments)experiment_id), value); - } else ll::io::LoggerRegistry::getInstance().getOrCreate("Server")->error("Experiment ID '{}' does not exist!", experiment_id); - } + GMLevel::getInstance().and_then([&](GMLevel& level) { + level.setExperimentEnabled((AllExperiments)experiment_id, value); + return true; + }); }); RemoteCall::exportAs("GMLib_ModAPI", "getExperimentEnabled", [](int experiment_id) -> bool { - if (GMLIB_Level::getInstance()) { - auto list = GMLIB_Level::getAllExperiments(); - std::unordered_set set(list.begin(), list.end()); - if (set.contains((AllExperiments)experiment_id)) { - return GMLIB_Level::getInstance()->getExperimentEnabled(((AllExperiments)experiment_id)); - } - ll::io::LoggerRegistry::getInstance().getOrCreate("Server")->error("Experiment ID '{}' does not exist!", experiment_id); - } - return false; + return GMLevel::getInstance() + .transform([&](GMLevel& level) { return level.getExperimentEnabled((AllExperiments)experiment_id); }) + .value_or(false); }); RemoteCall::exportAs("GMLib_ModAPI", "setFixI18nEnabled", []() -> void { - GMLIB::Mod::VanillaFix::setFixI18nEnabled(); + // GMLIB::Mod::VanillaFix::setFixI18nEnabled(); + throw std::runtime_error("GMLib_ModAPI::setFixI18nEnabled is not implemented"); }); } \ No newline at end of file diff --git a/src/LegacyServerApi.cpp b/src/LegacyServerApi.cpp index 465c052..b756b16 100644 --- a/src/LegacyServerApi.cpp +++ b/src/LegacyServerApi.cpp @@ -2,57 +2,68 @@ void Export_Legacy_GMLib_ServerAPI() { RemoteCall::exportAs("GMLib_ServerAPI", "setEducationFeatureEnabled", []() -> void { - GMLIB_Level::tryEnableEducationEdition(); + // GMLIB_Level::tryEnableEducationEdition(); + throw std::runtime_error("GMLib_ServerAPI::setEducationFeatureEnabled is not implemented"); }); RemoteCall::exportAs("GMLib_ServerAPI", "registerAbilityCommand", []() -> void { - GMLIB_Level::tryRegisterAbilityCommand(); + // GMLIB_Level::tryRegisterAbilityCommand(); + throw std::runtime_error("GMLib_ServerAPI::registerAbilityCommand is not implemented"); }); RemoteCall::exportAs("GMLib_ServerAPI", "setEnableAchievement", []() -> void { - GMLIB_Level::setForceAchievementsEnabled(); + // GMLIB_Level::setForceAchievementsEnabled(); + throw std::runtime_error("GMLib_ServerAPI::setEnableAchievement is not implemented"); + }); + RemoteCall::exportAs("GMLib_ServerAPI", "setForceTrustSkins", []() -> void { + // GMLIB_Level::trustAllSkins(); + throw std::runtime_error("GMLib_ServerAPI::setForceTrustSkins is not implemented"); }); - RemoteCall::exportAs("GMLib_ServerAPI", "setForceTrustSkins", []() -> void { GMLIB_Level::trustAllSkins(); }); RemoteCall::exportAs("GMLib_ServerAPI", "enableCoResourcePack", []() -> void { - GMLIB_Level::requireServerResourcePackAndAllowClientResourcePack(); + // GMLIB_Level::requireServerResourcePackAndAllowClientResourcePack(); + throw std::runtime_error("GMLib_ServerAPI::enableCoResourcePack is not implemented"); }); RemoteCall::exportAs("GMLib_ServerAPI", "getLevelName", []() -> std::string { - return GMLIB_Level::getInstance() - .transform([](GMLIB_Level& level) -> std::string { return level.getLevelName(); }) - .value_or(""); + return GMLevel::getInstance().transform( + [](GMLevel& level) -> std::string { return level.getLevelName(); } + ).value_or(""); }); RemoteCall::exportAs("GMLib_ServerAPI", "setLevelName", [](std::string const& name) -> void { - if (auto level = GMLIB_Level::getInstance()) { + if (auto level = GMLevel::getInstance()) { level->setLevelName(name); } }); RemoteCall::exportAs("GMLib_ServerAPI", "getLevelSeed", []() -> std::string { - return GMLIB_Level::getInstance() - .transform([](GMLIB_Level& level) -> std::string { return std::to_string(level.getSeed()); }) + return GMLevel::getInstance() + .transform([](GMLevel& level) -> std::string { return std::to_string(level.getSeed()); }) .value_or(""); }); RemoteCall::exportAs("GMLib_ServerAPI", "setFakeSeed", [](int64_t seed) -> void { - return GMLIB_Level::setFakeSeed(seed); + // return GMLIB_Level::setFakeSeed(seed); + throw std::runtime_error("GMLib_ServerAPI::setFakeSeed is not implemented"); }); RemoteCall::exportAs( "GMLib_ServerAPI", "spawnEntity", [](std::pair pos, std::string const& name) -> Actor* { - return GMLIB_Spawner::spawnEntity(pos.first, pos.second, name).as_ptr(); + return GMSpawner::spawnEntity(pos.first, pos.second, name).as_ptr(); } ); RemoteCall::exportAs( "GMLib_ServerAPI", "shootProjectile", [](Actor* owner, std::string const& name, float speed, float offset) -> Actor* { - auto ac = (GMLIB_Actor*)owner; - return ac->shootProjectile(name, speed, offset).as_ptr(); + auto actor = GMSpawner::spawnEntity(owner->getPosition(), owner->getDimensionId(), name); + if (!actor) return nullptr; + ((GMActor*)owner)->setProjectile((GMActor&)*actor, speed, offset); + return actor.as_ptr(); } ); RemoteCall::exportAs( "GMLib_ServerAPI", "throwEntity", [](Actor* owner, Actor* actor, float speed, float offset) -> bool { - auto ac = (GMLIB_Actor*)owner; - return ac->throwEntity(*actor, speed, offset); + auto ac = (GMActor*)owner; + ac->setProjectile((GMActor&)*actor, speed, offset); + return true; } ); RemoteCall::exportAs("GMLib_ServerAPI", "PlayerToEntity", [](Player* player) -> Actor* { return (Actor*)player; }); @@ -60,18 +71,18 @@ void Export_Legacy_GMLib_ServerAPI() { "GMLib_ServerAPI", "addFakeList", [](const std::string& name, const std::string& xuid) -> bool { - return GMLIB::Server::FakeList::addFakeList(name, xuid, ActorUniqueID(-1)); + PlayerListAPI::push_back(name, xuid); + return true; } ); RemoteCall::exportAs("GMLib_ServerAPI", "removeFakeList", [](const std::string& nameOrXuid) -> bool { - return GMLIB::Server::FakeList::removeFakeList(nameOrXuid); - }); - RemoteCall::exportAs("GMLib_ServerAPI", "removeAllFakeList", []() -> void { - return GMLIB::Server::FakeList::removeAllFakeLists(); + PlayerListAPI::resetListName(nameOrXuid); + return true; }); + RemoteCall::exportAs("GMLib_ServerAPI", "removeAllFakeList", []() -> void { PlayerListAPI::clear(); }); RemoteCall::exportAs("GMLib_ServerAPI", "getMaxPlayers", []() -> int { - return GMLIB_Level::getInstance().transform( - [](GMLIB_Level& level) -> int { return level.getMaxPlayerCount(); } + return GMLevel::getInstance().transform( + [](GMLevel& level) -> int { return level.getMaxPlayerCount(); } ).value_or(0); }); } diff --git a/src/PlaceholderApi.cpp b/src/PlaceholderApi.cpp index 1c358af..26f38d4 100644 --- a/src/PlaceholderApi.cpp +++ b/src/PlaceholderApi.cpp @@ -2,122 +2,178 @@ #include namespace PAPIRemoteCall { - -std::string removeBrackets(std::string a1) { - a1.erase(a1.find_last_not_of("%") + 1); - return a1; -} - -bool isParameters(std::string const& str) { - std::regex reg("[<]([^<>]+)[>]"); - return std::regex_search(removeBrackets(str), reg); -} - -std::string GetValue(std::string const& from) { return GMLIB::Server::PlaceholderAPI::getValue(from); } +std::string GetValue(std::string const& from) { return PlaceholderAPI::getValue(from, std::nullopt).value_or(""); } std::string GetValueWithPlayer(std::string const& key, Player* player) { - return GMLIB::Server::PlaceholderAPI::getValue(key, player); + return PlaceholderAPI::getValue(key, (GMActor*)player).value_or(""); } -bool registerPlayerPlaceholder( +void registerPlayerPlaceholder( std::string const& PluginName, std::string const& FuncName, std::string const& PAPIName ) { - if (RemoteCall::hasFunc(PluginName, FuncName)) { - GMLIB::Server::PlaceholderAPI::unregisterPlaceholder(PAPIName); - if (isParameters(PAPIName)) { - auto Call = RemoteCall::importAs)>( - PluginName, - FuncName - ); - GMLIB::Server::PlaceholderAPI::registerPlayerPlaceholder( - PAPIName, - [Call](Player* sp, std::unordered_map map) { return Call(sp, map); }, - PluginName - ); - } else { - auto Call = RemoteCall::importAs(PluginName, FuncName); - GMLIB::Server::PlaceholderAPI::registerPlayerPlaceholder( - PAPIName, - [Call](Player* sp) { return Call(sp); }, - PluginName - ); - } - return true; + if (!RemoteCall::hasFunc(PluginName, FuncName)) return; + auto func = [=]() -> void { + PlaceholderAPI::unregisterPlaceholder(PAPIName); + std::weak_ptr mod = ll::mod::ModManagerRegistry::getInstance().getMod(PluginName); + if (mod.expired()) return; + PlaceholderAPI::registerPlaceholder( + PAPIName, + [Call = RemoteCall::importAs)>( + PluginName, + FuncName + )](optional_ref actor, std::unordered_map const& params, auto&&... + ) -> std::optional { + if (actor.has_value() && ((Actor*)actor.as_ptr())->isPlayer()) { + return Call((Player*)actor.as_ptr(), params); + } + return std::nullopt; + }, + mod + ); + }; + if (ll::mod::ModManagerRegistry::getInstance().hasMod(PluginName)) { + func(); + } else { + getThreadPoolExecutor().execute(func); } - return false; } -bool registerServerPlaceholder( +void registerServerPlaceholder( std::string const& PluginName, std::string const& FuncName, std::string const& PAPIName ) { - if (RemoteCall::hasFunc(PluginName, FuncName)) { - GMLIB::Server::PlaceholderAPI::unregisterPlaceholder(PAPIName); - if (isParameters(PAPIName)) { - auto Call = - RemoteCall::importAs)>(PluginName, FuncName); - GMLIB::Server::PlaceholderAPI::registerServerPlaceholder( - PAPIName, - [Call](std::unordered_map map) { return Call(map); }, - PluginName - ); - } else { - auto Call = RemoteCall::importAs(PluginName, FuncName); - GMLIB::Server::PlaceholderAPI::registerServerPlaceholder(PAPIName, [Call]() { return Call(); }, PluginName); - } - return true; + if (!RemoteCall::hasFunc(PluginName, FuncName)) return; + auto func = [=]() -> void { + PlaceholderAPI::unregisterPlaceholder(PAPIName); + std::weak_ptr mod = ll::mod::ModManagerRegistry::getInstance().getMod(PluginName); + if (mod.expired()) return; + PlaceholderAPI::registerPlaceholder( + PAPIName, + [Call = RemoteCall::importAs)>( + PluginName, + FuncName + )](auto, std::unordered_map const& params, auto&&... + ) -> std::optional { return Call(params); }, + mod + ); + }; + if (ll::mod::ModManagerRegistry::getInstance().hasMod(PluginName)) { + func(); + } else { + getThreadPoolExecutor().execute(func); } - return false; } -bool registerStaticPlaceholder( +void registerStaticPlaceholder( std::string const& PluginName, std::string const& FuncName, std::string const& PAPIName, int num ) { - if (RemoteCall::hasFunc(PluginName, FuncName)) { - GMLIB::Server::PlaceholderAPI::unregisterPlaceholder(PAPIName); - if (isParameters(PAPIName)) { - auto Call = RemoteCall::importAs(PluginName, FuncName); - if (num == -1) { - GMLIB::Server::PlaceholderAPI::registerStaticPlaceholder( - PAPIName, - [Call] { return Call(); }, - PluginName - ); - } else { - GMLIB::Server::PlaceholderAPI::registerStaticPlaceholder( - PAPIName, - num, - [Call] { return Call(); }, - PluginName - ); - } - } - return true; + if (!RemoteCall::hasFunc(PluginName, FuncName)) return; + auto func = [=]() -> void { + PlaceholderAPI::unregisterPlaceholder(PAPIName); + std::weak_ptr mod = ll::mod::ModManagerRegistry::getInstance().getMod(PluginName); + if (mod.expired()) return; + PlaceholderAPI::registerPlaceholder( + PAPIName, + [Call = RemoteCall::importAs(PluginName, FuncName)](auto&&... + ) -> std::optional { return Call(); }, + mod + ); + }; + if (ll::mod::ModManagerRegistry::getInstance().hasMod(PluginName)) { + func(); + } else { + getThreadPoolExecutor().execute(func); } - return false; } std::string translateStringWithPlayer(std::string const& str, Player* pl) { - return GMLIB::Server::PlaceholderAPI::translateString(str, pl); + return PlaceholderAPI::translate(str, (GMActor*)pl); } -std::string translateString(std::string const& str) { return GMLIB::Server::PlaceholderAPI::translateString(str); } +std::string translateString(std::string const& str) { return PlaceholderAPI::translate(str, std::nullopt); } -bool unRegisterPlaceholder(std::string const& str) { return GMLIB::Server::PlaceholderAPI::unregisterPlaceholder(str); } +bool unRegisterPlaceholder(std::string const& str) { return PlaceholderAPI::unregisterPlaceholder(str); } -std::vector getAllPAPI() { return GMLIB::Server::PlaceholderAPI::getAllPAPI(); } +std::vector getAllPAPI() { + std::vector result; + for (auto& papi : PlaceholderAPI::getAllPlaceholderData()) { + result.push_back(papi.first); + } + return result; +} } // namespace PAPIRemoteCall +namespace NewPapiRemoteCall { +std::string translate(std::string const& value, std::string const& language) { + return PlaceholderAPI::translate(value, std::nullopt, language); +} +std::string translateFromActor(std::string const& value, Actor* actor, std::string const& language) { + return PlaceholderAPI::translate(value, (GMActor*)actor, language); +} +void registerPlaceholder(std::string const& placeholder, std::string const& funcName, std::string const& pluginName) { + if (!RemoteCall::hasFunc(pluginName, funcName)) return; + auto func = [=]() -> void { + if (std::weak_ptr mod = ll::mod::ModManagerRegistry::getInstance().getMod(pluginName); !mod.expired()) { + PlaceholderAPI::unregisterPlaceholder(placeholder); + PlaceholderAPI::registerPlaceholder( + placeholder, + [Call = RemoteCall::importAs< + std::string(Actor*, std::unordered_map, std::string)>( + pluginName, + funcName + )](optional_ref actor, + std::unordered_map const& params, + std::string const& language) -> std::optional { + auto result = Call((Actor*)actor.as_ptr(), params, language); + return result == "" ? std::nullopt : std::optional(result); + }, + mod + ); + } + }; + if (ll::mod::ModManagerRegistry::getInstance().hasMod(pluginName)) { + func(); + } else { + getThreadPoolExecutor().execute(func); + } +} +bool unregisterPlaceholder(std::string const& placeholder) { + return PlaceholderAPI::unregisterPlaceholder(placeholder); +} +bool unregisterPlaceholderFromModName(std::string const& pluginName) { + std::weak_ptr plugin = ll::mod::ModManagerRegistry::getInstance().getMod(pluginName); + if (plugin.expired()) return false; + return PlaceholderAPI::unregisterPlaceholder(plugin); +} +std::string getValue( + std::string const& placeholder, + std::unordered_map params, + std::string const& language +) { + return PlaceholderAPI::getValue(placeholder, std::nullopt, params, language).value_or(""); +} +std::string getValueFromActor( + std::string const& placeholder, + Actor* actor, + std::unordered_map params, + std::string const& language +) { + return PlaceholderAPI::getValue(placeholder, (GMActor*)actor, params, language).value_or(""); +} +} // namespace NewPapiRemoteCall + #define EXPORTAPI(T) \ RemoteCall::exportAs("BEPlaceholderAPI", ll::utils::string_utils::replaceAll(#T, "PAPIRemoteCall::", ""), T); +#define EXPORTAPI2(T) RemoteCall::exportAs("PlaceholderAPI", #T, NewPapiRemoteCall::T); + void ExportPAPI() { EXPORTAPI(PAPIRemoteCall::registerPlayerPlaceholder); EXPORTAPI(PAPIRemoteCall::registerServerPlaceholder); @@ -128,4 +184,12 @@ void ExportPAPI() { EXPORTAPI(PAPIRemoteCall::translateStringWithPlayer); EXPORTAPI(PAPIRemoteCall::unRegisterPlaceholder); EXPORTAPI(PAPIRemoteCall::getAllPAPI); + + EXPORTAPI2(translate); + EXPORTAPI2(translateFromActor); + EXPORTAPI2(registerPlaceholder); + EXPORTAPI2(unregisterPlaceholder); + EXPORTAPI2(unregisterPlaceholderFromModName); + EXPORTAPI2(getValue); + EXPORTAPI2(getValueFromActor); } \ No newline at end of file diff --git a/xmake.lua b/xmake.lua index e567784..2b6043d 100644 --- a/xmake.lua +++ b/xmake.lua @@ -2,16 +2,18 @@ add_rules("mode.debug", "mode.release") 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-repo https://github.com/MiracleForest/xmake-repo.git") if not has_config("vs_runtime") then set_runtimes("MD") end -add_requires("levilamina", {configs = {target_type = "server"}}) +add_requires("levilamina 1.1.0", {configs = {target_type = "server"}}) add_requires("legacyremotecall") add_requires("gmlib") add_requires("levibuildscript") - +add_requires("ilistenattentively") + target("GMLIB-LegacyRemoteCallApi") add_cxflags( "/EHa", @@ -19,7 +21,8 @@ target("GMLIB-LegacyRemoteCallApi") ) add_defines( "NOMINMAX", - "UNICODE" + "UNICODE", + "_HAS_CXX23=1" ) add_files( "src/**.cpp" @@ -30,12 +33,13 @@ target("GMLIB-LegacyRemoteCallApi") add_packages( "levilamina", "legacyremotecall", - "gmlib" + "gmlib", + "ilistenattentively" ) add_rules("@levibuildscript/linkrule") set_exceptions("none") set_kind("shared") - set_languages("c++23") + set_languages("cxx20") set_symbols("debug") after_build(function (target) From 1064cc8002791550f4fb41940805c514bcecccfa Mon Sep 17 00:00:00 2001 From: zimuya4153 Date: Sat, 22 Mar 2025 01:15:24 +0800 Subject: [PATCH 2/2] build: remove version lock for LeviLamina --- xmake.lua | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/xmake.lua b/xmake.lua index 2b6043d..7f27974 100644 --- a/xmake.lua +++ b/xmake.lua @@ -8,7 +8,7 @@ if not has_config("vs_runtime") then set_runtimes("MD") end -add_requires("levilamina 1.1.0", {configs = {target_type = "server"}}) +add_requires("levilamina", {configs = {target_type = "server"}}) add_requires("legacyremotecall") add_requires("gmlib") add_requires("levibuildscript")