feat: adapt to levilamina 1.7.x

.github/workflows/build.yml

@@ -18,7 +18,7 @@ jobs:
           xmake repo -u
 
       - run: |
-          xmake f -a x64 -m release -p windows -v -y
+          xmake f -a x64 -m release -p windows -y
 
       - run: |
           xmake -w -y

.github/workflows/release.yml

@@ -18,7 +18,7 @@ jobs:
           xmake repo -u
 
       - run: |
-          xmake f -a x64 -m release -p windows -v -y
+          xmake f -a x64 -m release -p windows -y
 
       - run: |
           xmake -w -y

lib/EventAPI-JS.js

@@ -1,51 +1,54 @@
-/**
- * @returns {string}
- */
 const getPluginName = () => {
-    // quickjs
-    try {
-        throw new Error("getPluginName");
-    } catch (error) {
-        const /** @type {string} */ line = error.stack.trim().split("\n").pop().trim();
-        if (line.includes("<anonymous>")) {
-            return line.slice(
-                line.indexOf("(") + 1,
-                line.indexOf("\\")
-            );
-        }
-        if (line.includes("<eval>")) {
-            return line.slice(
-                line.indexOf("/", line.indexOf("/") + 1) + 1,
-                line.indexOf("\\")
-            );
-        }
-    }
+    if (getPluginName.PluginNameCache) return getPluginName.PluginNameCache;
 
-    // nodejs
-    try {
-        const path = require('path');
-        const selfFileName = path.basename(__filename);
-        const pluginDirectory = Object.entries(
-            require('module')._pathCache
-        ).find(
-            ([key, _]) =>
-                key.includes(selfFileName)
-        )[0].split("\u0000")[1];
-        const directories = pluginDirectory.split("\\");
-        const pluginName = directories[directories.findIndex(value => value === "plugins") + 1].trim();
-        if (pluginName) return pluginName;
-    } catch { }
-    try {
-        throw new Error("getPluginName");
-    } catch (error) {
-        const /** @type {string} */ line = error.stack.trim().split("\n").pop().trim();
-        if (line.includes(".js") && /:\d+:\d+$/.test(line)) {
-            const directories = line.split("\\");
-            const pluginName = directories[directories.findIndex(value => value === "plugins") + 1].trim();
-            if (pluginName) return pluginName;
+    return getPluginName.PluginNameCache = (() => {
+        if (ll.getCurrentPluginInfo) return ll.getCurrentPluginInfo().name;
+
+        const error = new Error("getPluginName");
+        switch (ll.scriptEngineVersion) {
+            case "QuickJS": {
+                if (!error.stack) break;
+                const /** @type {string} */ line = error.stack.trim().split("\n").pop().trim();
+                if (line.includes("<anonymous>")) {
+                    return line.slice(
+                        line.indexOf("(") + 1,
+                        line.indexOf("\\")
+                    );
+                }
+                if (line.includes("<eval>")) {
+                    return line.slice(
+                        line.indexOf("/", line.indexOf("/") + 1) + 1,
+                        line.indexOf("\\")
+                    );
+                }
+                break;
+            }
+            case "V8 12.4.254.21-node.21": {
+                try {
+                    const selfFileName = require('path').basename(__filename);
+                    const pluginDirectory = Object.entries(
+                        require('module')._pathCache
+                    ).find(
+                        ([key, _]) => key.includes(selfFileName)
+                    )[0].split("\u0000")[1];
+                    const directories = pluginDirectory.split("\\");
+                    const pluginName = directories[directories.findIndex(value => value === "plugins") + 1].trim();
+                    if (pluginName) return pluginName;
+                } catch { }
+
+                if (!error.stack) break;
+                const /** @type {string} */ line = error.stack.trim().split("\n").pop().trim();
+                if (line.includes(".js") && /:\d+:\d+$/.test(line)) {
+                    const directories = line.split("\\");
+                    const pluginName = directories[directories.findIndex(value => value === "plugins") + 1].trim();
+                    if (pluginName) return pluginName;
+                }
+                break;
+            }
+            default: break;
         }
-    }
-    return "Unknown";
+        return "Unknown";
+    })();
 };
 
 module.exports = {

lib/GMLIB_API-JS.js

@@ -326,7 +326,7 @@ const GMLIB_API = {
     getItemCategoryName: ll.imports("GMLIB_API", "getItemCategoryName"),
     /** 获取物品的命名 @type {function(Item):string} */
     getItemCustomName: ll.imports("GMLIB_API", "getItemCustomName"),
-    /** 获取物品BUFF效果名称 @type {function(Item):string} */
+    /** 获取物品BUFF效果名称 @type {function(Item,boolean):string} */
     getItemEffecName: ll.imports("GMLIB_API", "getItemEffecName"),
     /** 物品是否为食物 @type {function(Item):boolean} */
     itemIsFood: ll.imports("GMLIB_API", "itemIsFood"),
@@ -3001,10 +3001,11 @@ LLSE_Item.prototype.getCustomName =
 LLSE_Item.prototype.getEffecName =
     /**
      * 获取物品的BUFF效果名称
+     * @param {boolean} playerIsCreative 玩家是否为创造模式
      * @returns {string}
      */
-    function () {
-        return GMLIB_API.getItemEffecName(this);
+    function (playerIsCreative = false) {
+        return GMLIB_API.getItemEffecName(this, playerIsCreative);
     };
 
 LLSE_Item.prototype.isFood =

lib/PlaceholderAPI.js

@@ -1,50 +1,56 @@
 /// <reference path='d:/dts/dts/helperlib/src/index.d.ts'/> 
 
 const getPluginName = () => {
-    // quickjs
-    try {
-        throw new Error("getPluginName");
-    } catch (error) {
-        const /** @type {string} */ line = error.stack.trim().split("\n").pop().trim();
-        if (line.includes("<anonymous>")) {
-            return line.slice(
-                line.indexOf("(") + 1,
-                line.indexOf("\\")
-            );
-        }
-        if (line.includes("<eval>")) {
-            return line.slice(
-                line.indexOf("/", line.indexOf("/") + 1) + 1,
-                line.indexOf("\\")
-            );
-        }
-    }
+    if (getPluginName.PluginNameCache) return getPluginName.PluginNameCache;
 
-    // nodejs
-    try {
-        const path = require('path');
-        const selfFileName = path.basename(__filename);
-        const pluginDirectory = Object.entries(
-            require('module')._pathCache
-        ).find(
-            ([key, _]) =>
-                key.includes(selfFileName)
-        )[0].split("\u0000")[1];
-        const directories = pluginDirectory.split("\\");
-        const pluginName = directories[directories.findIndex(value => value === "plugins") + 1].trim();
-        if (pluginName) return pluginName;
-    } catch { }
-    try {
-        throw new Error("getPluginName");
-    } catch (error) {
-        const /** @type {string} */ line = error.stack.trim().split("\n").pop().trim();
-        if (line.includes(".js") && /:\d+:\d+$/.test(line)) {
-            const directories = line.split("\\");
-            const pluginName = directories[directories.findIndex(value => value === "plugins") + 1].trim();
-            if (pluginName) return pluginName;
+    return getPluginName.PluginNameCache = (() => {
+        if (ll.getCurrentPluginInfo) return ll.getCurrentPluginInfo().name;
+
+        const error = new Error("getPluginName");
+        switch (ll.scriptEngineVersion) {
+            case "QuickJS": {
+                if (!error.stack) break;
+                const /** @type {string} */ line = error.stack.trim().split("\n").pop().trim();
+                if (line.includes("<anonymous>")) {
+                    return line.slice(
+                        line.indexOf("(") + 1,
+                        line.indexOf("\\")
+                    );
+                }
+                if (line.includes("<eval>")) {
+                    return line.slice(
+                        line.indexOf("/", line.indexOf("/") + 1) + 1,
+                        line.indexOf("\\")
+                    );
+                }
+                break;
+            }
+            case "V8 12.4.254.21-node.21": {
+                try {
+                    const selfFileName = require('path').basename(__filename);
+                    const pluginDirectory = Object.entries(
+                        require('module')._pathCache
+                    ).find(
+                        ([key, _]) => key.includes(selfFileName)
+                    )[0].split("\u0000")[1];
+                    const directories = pluginDirectory.split("\\");
+                    const pluginName = directories[directories.findIndex(value => value === "plugins") + 1].trim();
+                    if (pluginName) return pluginName;
+                } catch { }
+
+                if (!error.stack) break;
+                const /** @type {string} */ line = error.stack.trim().split("\n").pop().trim();
+                if (line.includes(".js") && /:\d+:\d+$/.test(line)) {
+                    const directories = line.split("\\");
+                    const pluginName = directories[directories.findIndex(value => value === "plugins") + 1].trim();
+                    if (pluginName) return pluginName;
+                }
+                break;
+            }
+            default: break;
         }
-    }
-    return "Unknown";
+        return "Unknown";
+    })();
 };
 
 module.exports = {

manifest.json

@@ -14,6 +14,9 @@
         },
         {
             "name": "iListenAttentively"
+        },
+        {
+            "name": "ModAPI"
         }
     ]
 }

src/CompatibilityApi.cpp

@@ -11,7 +11,7 @@ void Export_Compatibility_API() {
         return CustomRecipeRegistry::getInstance().unregisterRecipe(id, true);
     });
     RemoteCall::exportAs("GMLIB_API", "setCustomPackPath", [](std::string const& path) -> void {
-        AddonsLoader::addCustomPackPath(path);
+        AddonsLoader::getInstance().addCustomPackPath(path);
     });
     RemoteCall::exportAs("GMLIB_API", "getServerMspt", []() -> double {
         return GMLevel::getInstance().transform(
@@ -19,14 +19,10 @@ void Export_Compatibility_API() {
         ).value_or(0.0);
     });
     RemoteCall::exportAs("GMLIB_API", "getServerCurrentTps", []() -> float {
-        return GMLevel::getInstance().transform(
-                                         [](GMLevel& level) -> float { return level.getServerCurrentTps(); }
-        ).value_or(0.0);
+        return TpsStatus::getInstance().getLevelCurrentTps();
     });
     RemoteCall::exportAs("GMLIB_API", "getServerAverageTps", []() -> double {
-        return GMLevel::getInstance().transform(
-                                         [](GMLevel& level) -> double { return level.getServerAverageTps(); }
-        ).value_or(0.0);
+        return TpsStatus::getInstance().getLevelAverageTps();
     });
     RemoteCall::exportAs("GMLIB_API", "getAllPlayerUuids", []() -> std::vector<std::string> {
         std::vector<std::string> result;
@@ -445,7 +441,30 @@ void Export_Compatibility_API() {
         return ll::service::getLevel()->fetchEntity(parseScriptUniqueID(uniqueId), false);
     });
     RemoteCall::exportAs("GMLIB_API", "getWorldSpawn", []() -> std::pair<BlockPos, int> {
-        return {GMLevel::getInstance()->getLevelData().getSpawnPos(), 0};
+        constexpr static HashedString SPAWN_POS{"spawnPos"};
+        using mUnkfc867e = std::variant<
+            int,
+            bool,
+            float,
+            std::string,
+            GeneratorType,
+            GameType,
+            BlockPos,
+            LevelSeed64,
+            LevelDataValue::Tag,
+            DaylightCycle>;
+        auto& levelData = GMLevel::getInstance()->getLevelData();
+        if (auto it = levelData.mValues->find(SPAWN_POS); it != levelData.mValues->end()) {
+            if (auto value = std::get_if<BlockPos>(&it->second.mUnkfc867e.as<mUnkfc867e>()); value) {
+                return {*value, 0};
+            }
+        }
+        if (auto it = levelData.mOverrides->find(SPAWN_POS); it != levelData.mOverrides->end()) {
+            if (auto value = std::get_if<BlockPos>(&it->second.mUnkfc867e.as<mUnkfc867e>()); value) {
+                return {*value, 0};
+            }
+        }
+        return {BlockPos::ZERO(), 1};
     });
     RemoteCall::exportAs("GMLIB_API", "setWorldSpawn", [](std::pair<BlockPos, int> pos) -> bool {
         if (pos.second != 0) return false;
@@ -534,7 +553,7 @@ void Export_Compatibility_API() {
             .value_or(0);
     });
     RemoteCall::exportAs("GMLIB_API", "getBlockTranslateKey", [](Block const* block) -> std::string {
-        return block->getLegacyBlock().mDescriptionId.get() + ".name";
+        return block->mBlockType->mDescriptionId.get() + ".name";
     });
     RemoteCall::exportAs("GMLIB_API", "getItemTranslateKey", [](ItemStack* item) -> std::string {
         return item->getDescriptionId();
@@ -573,7 +592,7 @@ void Export_Compatibility_API() {
         }
     );
     RemoteCall::exportAs("GMLIB_API", "itemCanDestroyBlock", [](ItemStack const* item, Block const* block) -> bool {
-        return std::ranges::any_of(item->mCanDestroy, [block](BlockLegacy const* blockLegacy) {
+        return std::ranges::any_of(item->mCanDestroy, [block](BlockType const* blockLegacy) {
             return blockLegacy && block->getTypeName() == blockLegacy->getTypeName();
         });
     });
@@ -590,13 +609,13 @@ void Export_Compatibility_API() {
         return false;
     });
     RemoteCall::exportAs("GMLIB_API", "blockCanDropWithAnyTool", [](Block const* block) -> bool {
-        return !block->getLegacyBlock().mRequiresCorrectToolForDrops;
+        return !block->mBlockType->mRequiresCorrectToolForDrops;
     });
     RemoteCall::exportAs(
         "GMLIB_API",
         "blockPlayerWillDestroy",
         [](Block const* block, Player* player, std::pair<BlockPos, int> pos) -> bool {
-            return block->getLegacyBlock().playerWillDestroy(*player, pos.first, *block);
+            return block->mBlockType->playerWillDestroy(*player, pos.first, *block);
         }
     );
     RemoteCall::exportAs("GMLIB_API", "playerAttack", [](Player* player, Actor* entity) -> bool {
@@ -630,23 +649,23 @@ void Export_Compatibility_API() {
                 switch (gameRule.mType) {
                 case GameRule::Type::Bool:
                     result.push_back({
-                        {"Name",  gameRule.mName                          },
-                        {"Type",  "Bool"                                  },
-                        {"Value", std::to_string(gameRule.mValue->boolVal)}
+                        {"Name",  gameRule.mName                                 },
+                        {"Type",  "Bool"                                         },
+                        {"Value", std::to_string(std::get<bool>(*gameRule.mValue))}
                     });
                     break;
                 case GameRule::Type::Float:
                     result.push_back({
-                        {"Name",  gameRule.mName                           },
-                        {"Type",  "Float"                                  },
-                        {"Value", std::to_string(gameRule.mValue->floatVal)}
+                        {"Name",  gameRule.mName                                  },
+                        {"Type",  "Float"                                         },
+                        {"Value", std::to_string(std::get<float>(*gameRule.mValue))}
                     });
                     break;
                 case GameRule::Type::Int:
                     result.push_back({
-                        {"Name",  gameRule.mName                         },
-                        {"Type",  "Int"                                  },
-                        {"Value", std::to_string(gameRule.mValue->intVal)}
+                        {"Name",  gameRule.mName                                },
+                        {"Type",  "Int"                                         },
+                        {"Value", std::to_string(std::get<int>(*gameRule.mValue))}
                     });
                     break;
                 case GameRule::Type::Invalid:
@@ -674,7 +693,7 @@ void Export_Compatibility_API() {
             );
         }
     );
-    RemoteCall::exportAs("GMLIB_API", "removeEnchants", [](ItemStack* item) -> void { item->removeEnchants(); });
+    RemoteCall::exportAs("GMLIB_API", "removeEnchants", [](ItemStack* item) -> void { (void)item->removeEnchants(); });
     RemoteCall::exportAs("GMLIB_API", "hasEnchant", [](ItemStack* item, std::string const& typeName) -> bool {
         return EnchantUtils::hasEnchant(Enchant::mEnchantNameToType()[HashedString(typeName)], *item);
     });
@@ -745,9 +764,9 @@ void Export_Compatibility_API() {
         "GMLIB_API",
         "setItemCanDestroy",
         [](ItemStack const* item, std::vector<std::string> blocks) -> void {
-            std::vector<const BlockLegacy*> data;
+            std::vector<const BlockType*> data;
             for (auto& name : blocks) {
-                if (auto block = BlockLegacy::tryGetFromRegistry(name)) {
+                if (auto block = BlockType::tryGetFromRegistry(name)) {
                     data.push_back(block.as_ptr());
                 }
             }
@@ -765,9 +784,9 @@ void Export_Compatibility_API() {
         "GMLIB_API",
         "setItemCanPlaceOn",
         [](ItemStack const* item, std::vector<std::string> blocks) -> void {
-            std::vector<const BlockLegacy*> data;
+            std::vector<const BlockType*> data;
             for (auto& name : blocks) {
-                if (auto block = BlockLegacy::tryGetFromRegistry(name)) {
+                if (auto block = BlockType::tryGetFromRegistry(name)) {
                     data.push_back(block.as_ptr());
                 }
             }
@@ -795,9 +814,9 @@ void Export_Compatibility_API() {
     RemoteCall::exportAs("GMLIB_API", "getItemCustomName", [](ItemStack const* item) -> std::string {
         return item->getCustomName();
     });
-    RemoteCall::exportAs("GMLIB_API", "getItemEffecName", [](ItemStack const* item) -> std::string {
+    RemoteCall::exportAs("GMLIB_API", "getItemEffecName", [](ItemStack const* item, bool playerIsCreative) -> std::string {
         if (auto item2 = item->mItem) {
-            return item2->buildEffectDescriptionName(*item);
+            return item2->buildEffectDescriptionName(*item, playerIsCreative);
         }
         return "";
     });
@@ -972,7 +991,10 @@ void Export_Compatibility_API() {
         return entity->isType((ActorType)type);
     });
     RemoteCall::exportAs("GMLIB_API", "entityHasType", [](Actor* entity, int type) -> bool {
-        return entity->hasType((ActorType)type);
+        if (auto component = entity->mEntityContext->tryGetComponent<ActorTypeComponent>(); component) {
+            return (type & std::to_underlying(component->mType)) == type;
+        }
+        return false;
     });
     RemoteCall::exportAs("GMLIB_API", "getEntityTypeId", [](Actor* entity) -> int {
         return (int)entity->getEntityTypeId();

src/EventAPI.cpp

@@ -216,10 +216,11 @@ void Export_Event_API() {
                 );
             }
             case doHash("gmlib::EndermanTakeBlockBeforeEvent"): {
-                REGISTER_EVENT_LISTEN(ila::mc::EndermanTakeBlockBeforeEvent,
+                REGISTER_EVENT_LISTEN(ila::mc::MobTakeBlockBeforeEvent,
                                       (Actor * mob, bool isCancelled),
                                       (&event.self(), event.isCancelled()),
-                                      event.setCancelled(result););
+                                      event.setCancelled(result);
+                                      , if (!event.self().isType(ActorType::EnderMan)) return;);
             }
             case doHash("gmlib::DragonRespawnBeforeEvent"): {
                 REGISTER_EVENT_LISTEN(ila::mc::DragonRespawnBeforeEvent,

src/Global.h

@@ -2,19 +2,30 @@
 // clang-format off
 #pragma warning(push)
 #pragma warning(disable : 4996)
-#define GMLIB_GLOBAL_USING
-#include <gmlib/GlobalUsing.h>
-#include <gmlib/include_all.h>
+#pragma include_alias("mc/world/item/HumanoidArmorItem.h", "modapi/item/types/mc/HumanoidArmorItem.h")
+#pragma include_alias("mc/world/level/block/states/BuiltInBlockStateVariant.h", "mc/BuiltInBlockStateVariant.h")
+#pragma include_alias("mc/world/events/EventCoordinatorPimpl.h", "mc/EventCoordinatorPimpl.h")
+#pragma include_alias("mc/world/events/PlayerNotificationEvent.h", "mc/PlayerNotificationEvent.h")
+#include <gmlib/include_ll.h>
+#include <gmlib/include_lib.h>
+#include <gmlib/include_mc.h>
 #include <ila/include_all.h>
+#include <modapi/addons/AddonsLoader.h>
+#include <modapi/recipe/CustomRecipeRegistry.h>
+#include <modapi/item/CustomItemRegistry.h>
 #include <RemoteCallAPI.h>
-using namespace gmlib::mod;
+using namespace gmlib;
+using namespace gmlib::ui;
+using namespace gmlib::i18n;
+using namespace gmlib::memory;
+using namespace modapi;
 #pragma warning(pop)
 // clang-format on
 
 #define PLUGIN_NAME fmt::format(fg(fmt::color::light_green), "GMLIB-LRCA")
 
 #define LIB_VERSION_MAJOR    1
-#define LIB_VERSION_MINOR    0
+#define LIB_VERSION_MINOR    6
 #define LIB_VERSION_PATCH    0
 #define LIB_VERSION_PRERELEASE std::nullopt
 

src/PlaceholderApi.cpp

@@ -2,10 +2,12 @@
 #include <regex>
 
 namespace PAPIRemoteCall {
-std::string GetValue(std::string const& from) { return PlaceholderAPI::getValue(from, std::nullopt).value_or(""); }
+std::string GetValue(std::string const& from) {
+    return PlaceholderAPI::getInstance().getValue(from, std::nullopt).value_or("");
+}
 
 std::string GetValueWithPlayer(std::string const& key, Player* player) {
-    return PlaceholderAPI::getValue(key, (GMActor*)player).value_or("");
+    return PlaceholderAPI::getInstance().getValue(key, (GMActor*)player).value_or("");
 }
 
 void registerPlayerPlaceholder(
@@ -15,15 +17,15 @@ void registerPlayerPlaceholder(
 ) {
     if (!RemoteCall::hasFunc(PluginName, FuncName)) return;
     auto func = [=]() -> void {
-        PlaceholderAPI::unregisterPlaceholder(PAPIName);
+        PlaceholderAPI::getInstance().unregisterPlaceholder(PAPIName);
         std::weak_ptr mod = ll::mod::ModManagerRegistry::getInstance().getMod(PluginName);
         if (mod.expired()) return;
-        PlaceholderAPI::registerPlaceholder(
+        PlaceholderAPI::getInstance().registerPlaceholder(
             PAPIName,
             [Call = RemoteCall::importAs<std::string(Player * pl, std::unordered_map<std::string, std::string>)>(
                  PluginName,
                  FuncName
-             )](optional_ref<Actor> actor, ll::StringMap<std::string> const& params, auto&&...
+             )](optional_ref<Actor> actor, ll::SmallStringMap<std::string> const& params, auto&&...
             ) -> std::optional<std::string> {
                 if (actor.has_value() && ((Actor*)actor.as_ptr())->isPlayer()) {
                     std::unordered_map<std::string, std::string> paramMap;
@@ -34,6 +36,7 @@ void registerPlayerPlaceholder(
                 }
                 return std::nullopt;
             },
+            false,
             mod
         );
     };
@@ -51,21 +54,22 @@ void registerServerPlaceholder(
 ) {
     if (!RemoteCall::hasFunc(PluginName, FuncName)) return;
     auto func = [=]() -> void {
-        PlaceholderAPI::unregisterPlaceholder(PAPIName);
+        PlaceholderAPI::getInstance().unregisterPlaceholder(PAPIName);
         std::weak_ptr mod = ll::mod::ModManagerRegistry::getInstance().getMod(PluginName);
         if (mod.expired()) return;
-        PlaceholderAPI::registerPlaceholder(
+        PlaceholderAPI::getInstance().registerPlaceholder(
             PAPIName,
             [Call = RemoteCall::importAs<std::string(std::unordered_map<std::string, std::string>)>(
                  PluginName,
                  FuncName
-             )](auto, ll::StringMap<std::string> const& params, auto&&...) -> std::optional<std::string> {
+             )](auto, ll::SmallStringMap<std::string> const& params, auto&&...) -> std::optional<std::string> {
                 std::unordered_map<std::string, std::string> paramMap;
                 for (auto& [key, val] : params) {
                     paramMap[key] = val;
                 }
                 return Call(paramMap);
             },
+            false,
             mod
         );
     };
@@ -84,13 +88,14 @@ void registerStaticPlaceholder(
 ) {
     if (!RemoteCall::hasFunc(PluginName, FuncName)) return;
     auto func = [=]() -> void {
-        PlaceholderAPI::unregisterPlaceholder(PAPIName);
+        PlaceholderAPI::getInstance().unregisterPlaceholder(PAPIName);
         std::weak_ptr mod = ll::mod::ModManagerRegistry::getInstance().getMod(PluginName);
         if (mod.expired()) return;
-        PlaceholderAPI::registerPlaceholder(
+        PlaceholderAPI::getInstance().registerPlaceholder(
             PAPIName,
-            [Call = RemoteCall::importAs<std::string()>(PluginName, FuncName)](auto&&...)
-                -> std::optional<std::string> { return Call(); },
+            [Call = RemoteCall::importAs<std::string()>(PluginName, FuncName)](auto&&...
+            ) -> std::optional<std::string> { return Call(); },
+            false,
             mod
         );
     };
@@ -102,16 +107,18 @@ void registerStaticPlaceholder(
 }
 
 std::string translateStringWithPlayer(std::string const& str, Player* pl) {
-    return PlaceholderAPI::translate(str, (GMActor*)pl);
+    return PlaceholderAPI::getInstance().translate(str, (GMActor*)pl);
 }
 
-std::string translateString(std::string const& str) { return PlaceholderAPI::translate(str, std::nullopt); }
+std::string translateString(std::string const& str) {
+    return PlaceholderAPI::getInstance().translate(str, std::nullopt);
+}
 
-bool unRegisterPlaceholder(std::string const& str) { return PlaceholderAPI::unregisterPlaceholder(str); }
+bool unRegisterPlaceholder(std::string const& str) { return PlaceholderAPI::getInstance().unregisterPlaceholder(str); }
 
 std::vector<std::string> getAllPAPI() {
     std::vector<std::string> result;
-    for (auto& papi : PlaceholderAPI::getAllPlaceholderData()) {
+    for (auto& papi : PlaceholderAPI::getInstance().getAllPlaceholderData()) {
         result.push_back(papi.first);
     }
     return result;
@@ -121,23 +128,23 @@ std::vector<std::string> getAllPAPI() {
 
 namespace NewPapiRemoteCall {
 std::string translate(std::string const& value, std::string const& language) {
-    return PlaceholderAPI::translate(value, std::nullopt, language);
+    return PlaceholderAPI::getInstance().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);
+    return PlaceholderAPI::getInstance().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(
+            PlaceholderAPI::getInstance().unregisterPlaceholder(placeholder);
+            PlaceholderAPI::getInstance().registerPlaceholder(
                 placeholder,
                 [Call = RemoteCall::importAs<
                      std::string(Actor*, std::unordered_map<std::string, std::string>, std::string)>(
                      pluginName,
                      funcName
-                 )](optional_ref<Actor> actor, ll::StringMap<std::string> const& params, std::string const& language
+                 )](optional_ref<Actor> actor, ll::SmallStringMap<std::string> const& params, std::string const& language
                 ) -> std::optional<std::string> {
                     std::unordered_map<std::string, std::string> paramMap;
                     for (auto& [key, val] : params) {
@@ -146,6 +153,7 @@ void registerPlaceholder(std::string const& placeholder, std::string const& func
                     auto result = Call((Actor*)actor.as_ptr(), paramMap, language);
                     return result == "<std::nullopt>" ? std::nullopt : std::optional(result);
                 },
+                false,
                 mod
             );
         }
@@ -157,23 +165,25 @@ void registerPlaceholder(std::string const& placeholder, std::string const& func
     }
 }
 bool unregisterPlaceholder(std::string const& placeholder) {
-    return PlaceholderAPI::unregisterPlaceholder(placeholder);
+    return PlaceholderAPI::getInstance().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);
+    return PlaceholderAPI::getInstance().unregisterPlaceholder(plugin);
 }
 std::string getValue(
     std::string const&                           placeholder,
     std::unordered_map<std::string, std::string> params,
     std::string const&                           language
 ) {
-    ll::StringMap<std::string> paramMap;
+    ll::SmallStringMap<std::string> paramMap;
     for (auto& [key, val] : params) {
         paramMap[key] = val;
     }
-    return PlaceholderAPI::getValue(placeholder, std::nullopt, paramMap, language).value_or("<std::nullopt>");
+    return PlaceholderAPI::getInstance()
+        .getValue(placeholder, std::nullopt, paramMap, language)
+        .value_or("<std::nullopt>");
 }
 std::string getValueFromActor(
     std::string const&                           placeholder,
@@ -181,11 +191,13 @@ std::string getValueFromActor(
     std::unordered_map<std::string, std::string> params,
     std::string const&                           language
 ) {
-    ll::StringMap<std::string> paramMap;
+    ll::SmallStringMap<std::string> paramMap;
     for (auto& [key, val] : params) {
         paramMap[key] = val;
     }
-    return PlaceholderAPI::getValue(placeholder, (GMActor*)actor, paramMap, language).value_or("<std::nullopt>");
+    return PlaceholderAPI::getInstance()
+        .getValue(placeholder, (GMActor*)actor, paramMap, language)
+        .value_or("<std::nullopt>");
 }
 } // namespace NewPapiRemoteCall
 

src/mc/BuiltInBlockStateVariant.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "mc/_HeaderOutputPredefine.h"
+#include "mc/world/level/block/states/BlockStateVariant.h"
+
+template <typename T0>
+class BuiltInBlockStateVariant : public ::BlockStateVariant<T0> {
+public:
+    // virtual functions
+    // NOLINTBEGIN
+    // vIndex: 0
+    virtual ~BuiltInBlockStateVariant() /*override*/ = default;
+    // NOLINTEND
+};

src/mc/EventCoordinatorPimpl.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "mc/_HeaderOutputPredefine.h"
+#include "mc/deps/core/utility/EnableNonOwnerReferences.h"
+#include "mc/world/events/EventResult.h"
+
+template <class T0>
+class EventCoordinatorPimpl : Bedrock::EnableNonOwnerReferences {
+public:
+    using EventFuncPtr = std::function<EventResult(T0&)>;
+
+    std::vector<T0*>          mListeners;
+    std::vector<EventFuncPtr> mEventsToProcess;
+    std::vector<T0*>          mPendingRegistrations;
+    bool                      mHasPendingRegistrations;
+    std::thread::id           mThreadId;
+    bool                      mThreadIdInitialized;
+    uint                      mThreadCheckIndex;
+
+    // // ServerInstanceEventListener
+    // virtual ~EventCoordinatorPimpl();
+
+    // // ServerInstanceEventListener
+    // MCAPI bool registerListener(gsl::not_null<T0*>);
+
+    // // ScriptingEventListener
+    // MCAPI void processEvent(EventFuncPtr);
+
+    // // ActorEventListener
+    // MCAPI void unregisterListener(gsl::not_null<T0*>);
+};

src/mc/PlayerNotificationEvent.h

@@ -0,0 +1,139 @@
+#pragma once
+
+#include "mc/_HeaderOutputPredefine.h"
+#include "mc/world/events/PlayerAddEvent.h"
+#include "mc/world/events/PlayerAddExpEvent.h"
+#include "mc/world/events/PlayerAddLevelEvent.h"
+#include "mc/world/events/PlayerArmorExchangeEvent.h"
+#include "mc/world/events/PlayerDamageEvent.h"
+#include "mc/world/events/PlayerDestroyBlockEvent.h"
+#include "mc/world/events/PlayerDimensionChangeAfterEvent.h"
+#include "mc/world/events/PlayerDimensionChangeBeforeEvent.h"
+#include "mc/world/events/PlayerDisconnectEvent.h"
+#include "mc/world/events/PlayerDropItemEvent.h"
+#include "mc/world/events/PlayerEatFoodEvent.h"
+#include "mc/world/events/PlayerEmoteEvent.h"
+#include "mc/world/events/PlayerFormCloseEvent.h"
+#include "mc/world/events/PlayerFormResponseEvent.h"
+#include "mc/world/events/PlayerGameModeChangeEvent.h"
+#include "mc/world/events/PlayerGetExperienceOrbEvent.h"
+#include "mc/world/events/PlayerInitialSpawnEvent.h"
+#include "mc/world/events/PlayerInputModeChangeEvent.h"
+#include "mc/world/events/PlayerInputPermissionCategoryChangeEvent.h"
+#include "mc/world/events/PlayerInteractEvent.h"
+#include "mc/world/events/PlayerInteractWithBlockAfterEvent.h"
+#include "mc/world/events/PlayerInteractWithBlockBeforeEvent.h"
+#include "mc/world/events/PlayerInteractWithEntityAfterEvent.h"
+#include "mc/world/events/PlayerInteractWithEntityBeforeEvent.h"
+#include "mc/world/events/PlayerOpenContainerEvent.h"
+#include "mc/world/events/PlayerRespawnEvent.h"
+#include "mc/world/events/PlayerSayCommandEvent.h"
+#include "mc/world/events/PlayerScriptInputEvent.h"
+#include "mc/world/events/PlayerSelectedItemChangedEvent.h"
+#include "mc/world/events/PlayerShootArrowEvent.h"
+#include "mc/world/events/PlayerSkinLoadedClientEvent.h"
+#include "mc/world/events/PlayerSleepStateChangeEvent.h"
+#include "mc/world/events/PlayerStopLoadingEvent.h"
+#include "mc/world/events/PlayerSwingStartEvent.h"
+#include "mc/world/events/PlayerUpdateInteractionEvent.h"
+#include "mc/world/events/PlayerUseNameTagEvent.h"
+
+
+// auto generated inclusion list
+#include "mc/world/events/EventVariantImpl.h"
+
+// auto generated forward declare list
+// clang-format off
+struct PlayerAddEvent;
+struct PlayerAddExpEvent;
+struct PlayerAddLevelEvent;
+struct PlayerArmorExchangeEvent;
+struct PlayerCloseContainerEvent;
+struct PlayerDamageEvent;
+struct PlayerDestroyBlockEvent;
+struct PlayerDimensionChangeAfterEvent;
+struct PlayerDimensionChangeBeforeEvent;
+struct PlayerDisconnectEvent;
+struct PlayerDropItemEvent;
+struct PlayerEatFoodEvent;
+struct PlayerEmoteEvent;
+struct PlayerFormCloseEvent;
+struct PlayerFormResponseEvent;
+struct PlayerGameModeChangeEvent;
+struct PlayerGetExperienceOrbEvent;
+struct PlayerHotbarSelectedSlotChangeEvent;
+struct PlayerInitialSpawnEvent;
+struct PlayerInputModeChangeEvent;
+struct PlayerInputPermissionCategoryChangeEvent;
+struct PlayerInteractEvent;
+struct PlayerInteractWithBlockAfterEvent;
+struct PlayerInteractWithBlockBeforeEvent;
+struct PlayerInteractWithEntityAfterEvent;
+struct PlayerInteractWithEntityBeforeEvent;
+struct PlayerInventoryItemChangeEvent;
+struct PlayerOpenContainerEvent;
+struct PlayerRespawnEvent;
+struct PlayerSayCommandEvent;
+struct PlayerScriptInputEvent;
+struct PlayerSelectedItemChangedEvent;
+struct PlayerShootArrowEvent;
+struct PlayerSkinLoadedClientEvent;
+struct PlayerSleepStateChangeEvent;
+struct PlayerStopLoadingEvent;
+struct PlayerSwingStartEvent;
+struct PlayerUpdateInteractionEvent;
+struct PlayerUseNameTagEvent;
+// clang-format on
+
+struct PlayerNotificationEvent : public ::EventVariantImpl<
+                                     ::PlayerSkinLoadedClientEvent const,
+                                     ::PlayerAddEvent const,
+                                     ::PlayerAddExpEvent const,
+                                     ::PlayerAddLevelEvent const,
+                                     ::PlayerArmorExchangeEvent const,
+                                     ::PlayerDestroyBlockEvent const,
+                                     ::PlayerUseNameTagEvent const,
+                                     ::PlayerDropItemEvent const,
+                                     ::PlayerEatFoodEvent const,
+                                     ::PlayerDamageEvent const,
+                                     ::PlayerDisconnectEvent const,
+                                     ::PlayerFormCloseEvent const,
+                                     ::PlayerFormResponseEvent const,
+                                     ::PlayerInputModeChangeEvent const,
+                                     ::PlayerInitialSpawnEvent const,
+                                     ::PlayerOpenContainerEvent const,
+                                     ::PlayerCloseContainerEvent const,
+                                     ::PlayerShootArrowEvent const,
+                                     ::PlayerSwingStartEvent const,
+                                     ::PlayerRespawnEvent const,
+                                     ::PlayerSleepStateChangeEvent const,
+                                     ::PlayerStopLoadingEvent const,
+                                     ::PlayerUpdateInteractionEvent const,
+                                     ::PlayerSelectedItemChangedEvent const,
+                                     ::PlayerDimensionChangeBeforeEvent const,
+                                     ::PlayerDimensionChangeAfterEvent const,
+                                     ::PlayerInteractWithEntityAfterEvent const,
+                                     ::PlayerInteractWithBlockAfterEvent const,
+                                     ::PlayerEmoteEvent const,
+                                     ::PlayerScriptInputEvent const,
+                                     ::PlayerInventoryItemChangeEvent const,
+                                     ::PlayerHotbarSelectedSlotChangeEvent const,
+                                     ::PlayerInputPermissionCategoryChangeEvent const,
+                                     ::PlayerSayCommandEvent const,
+                                     ::PlayerGetExperienceOrbEvent const,
+                                     ::PlayerInteractEvent const,
+                                     ::PlayerInteractWithEntityBeforeEvent const,
+                                     ::PlayerInteractWithBlockBeforeEvent const,
+                                     ::PlayerGameModeChangeEvent const> {
+public:
+    // member functions
+    // NOLINTBEGIN
+    MCAPI ~PlayerNotificationEvent();
+    // NOLINTEND
+
+public:
+    // destructor thunk
+    // NOLINTBEGIN
+    MCAPI void $dtor();
+    // NOLINTEND
+};

tooth.json

@@ -2,7 +2,7 @@
     "format_version": 3,
     "format_uuid": "289f771f-2c9a-4d73-9f3f-8492495a924d",
     "tooth": "github.com/GroupMountain/GMLIB-LegacyRemoteCallApi",
-    "version": "1.4.1",
+    "version": "1.7.0",
     "info": {
         "name": "GMLIB-LegacyRemoteCallApi",
         "description": "Legacy RemoteCall API for GMLIB",
@@ -19,9 +19,10 @@
         {
             "platform": "win-x64",
             "dependencies": {
-                "github.com/LiteLDev/LeviLamina": ">=1.3.0",
-                "github.com/GroupMountain/GMLIB-Release": ">=1.3.0-rc.1",
-                "github.com/MiracleForest/iListenAttentively-Release": ">=0.6.0"
+                "github.com/LiteLDev/LeviLamina": ">=1.7.0",
+                "github.com/GroupMountain/GMLIB-Release": ">=1.7.0",
+                "github.com/GroupMountain/ModAPI-Release": ">=0.3.0",
+                "github.com/MiracleForest/iListenAttentively-Release": ">=0.10.0"
             },
             "assets": [
                 {

xmake.lua

@@ -8,11 +8,12 @@ if not has_config("vs_runtime") then
     set_runtimes("MD")
 end
 
-add_requires("levilamina 1.4.1", {configs = {target_type = "server"}})
+add_requires("levilamina 1.7.1", {configs = {target_type = "server"}})
 add_requires("legacyremotecall")
-add_requires("levibuildscript")
-add_requires("ilistenattentively 0.7.0")
-add_requires("gmlib 1.4.3")
+add_requires("levibuildscript 0.5.2")
+add_requires("ilistenattentively 0.10.0")
+add_requires("gmlib 1.7.00")
+add_requires("modapi 0.3.0")
 
 target("GMLIB-LegacyRemoteCallApi")
     add_cxflags(
@@ -35,7 +36,8 @@ target("GMLIB-LegacyRemoteCallApi")
         "levilamina",
         "legacyremotecall",
         "ilistenattentively",
-        "gmlib"
+        "gmlib",
+        "modapi"
     )
     add_rules("@levibuildscript/linkrule")
     add_rules("@levibuildscript/modpacker")