feat: add more info for UserCache

.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/GMLIB_API-JS.d.ts

@@ -1078,12 +1078,12 @@ export class UserCache {
 
     /** 获取玩家信息 */
     static getPlayerInfo(
-        /** 玩家名 或 xuid 或 uuid */
+        /** 玩家名 或 xuid 或 uuid 或 serverId 或 uniqueId */
         playerIdentifier: string
-    ): { Xuid: String, Uuid: string, Name: string } | null;
+    ): { Xuid: string, Uuid: string, Name: string, ServerId: string, ActorUniqueID: string } | null;
 
     /** 获取所有玩家信息 */
-    static getAllPlayerInfo(): { Xuid: String; Uuid: string; Name: string; }[]
+    static getAllPlayerInfo(): { Xuid: string, Uuid: string, Name: string, ServerId: string, ActorUniqueID: string }[]
 }
 
 type PacketDataItem = (

lib/GMLIB_API-JS.js

@@ -216,7 +216,9 @@ const GMLIB_API = {
     getXuidByName: ll.imports("GMLIB_API", "getXuidByName"),
     /** 根据名字获取uuid @type {function(string):string} */
     getUuidByName: ll.imports("GMLIB_API", "getUuidByName"),
-    /** 获取所有已记录的玩家信息 @type {function():Array.<{"Uuid":string,"Xuid":string,"Name":string}>} */
+    /** 根据信息获取玩家信息 @type {function():{"Uuid":string,"Xuid":string,"Name":string,"ServerId":string,"ActorUniqueID":string}} */
+    getPlayerInfo: ll.imports("GMLIB_API", "getPlayerInfo"),
+    /** 获取所有已记录的玩家信息 @type {function():Array.<{"Uuid":string,"Xuid":string,"Name":string,"ServerId":string,"ActorUniqueID":string}>} */
     getAllPlayerInfo: ll.imports("GMLIB_API", "getAllPlayerInfo"),
     /** 获取方块RuntimeId @type {function(string,number):number} */
     getBlockRuntimeId: ll.imports("GMLIB_API", "getBlockRuntimeId"),
@@ -326,7 +328,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"),
@@ -2107,16 +2109,17 @@ class UserCache {
 
     /**
      * 获取玩家信息
-     * @param {string} playerIdentifier 玩家的 xuid 或 uuid 或 名称
-     * @returns {{Xuid: String, Uuid: string, Name: string}?} 玩家信息
+     * @param {string} playerIdentifier 玩家的 xuid 或 uuid 或 realName 或 serverId 或 uniqueId
+     * @returns {{Xuid: string, Uuid: string, Name: string, ServerId: string, ActorUniqueID: string}?} 玩家信息
      */
     static getPlayerInfo(playerIdentifier) {
-        return GMLIB_API.getAllPlayerInfo().find(Info => Object.keys(Info).some(InfoKey => Info[InfoKey] === playerIdentifier));
+        const result = GMLIB_API.getPlayerInfo(playerIdentifier)
+        return Object.keys(result).length === 0 ? null : result;
     }
 
     /**
      * 获取所有玩家信息
-     * @returns {Array.<{Xuid: String, Uuid: string, Name: string}>} 包含所有玩家信息的数组
+     * @returns {Array.<{Xuid: string, Uuid: string, Name: string, ServerId: string, ActorUniqueID: string}>} 包含所有玩家信息的数组
      */
     static getAllPlayerInfo() {
         return GMLIB_API.getAllPlayerInfo();
@@ -3001,10 +3004,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 =

src/CompatibilityApi.cpp

@@ -441,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;
@@ -509,17 +532,46 @@ void Export_Compatibility_API() {
         }
         return "";
     });
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "getPlayerInfo",
+        [](std::string const& info) -> std::unordered_map<std::string, std::string> {
+            // TODO: 下个GMLIB更新直接改成from(info, UserCache::QueryType::All)
+            std::unordered_map<std::string, std::string> result;
+            if (auto uce = UserCache::getInstance()->from(mce::UUID::fromString(info))) {
+                ll::reflection::forEachMember(*uce, [&](std::string_view name, auto&& member) {
+                    result[std::string{name.substr(1)}] = fmt::to_string(member);
+                });
+                return result;
+            }
+            if (auto uniqeuId = ll::string_utils::svtoll(info); uniqeuId) {
+                if (auto uce = UserCache::getInstance()->from(ActorUniqueID{*uniqeuId})) {
+                    ll::reflection::forEachMember(*uce, [&](std::string_view name, auto&& member) {
+                        result[std::string{name.substr(1)}] = fmt::to_string(member);
+                    });
+                    return result;
+                }
+            }
+            if (auto uce = UserCache::getInstance()->from(info, UserCache::QueryType::Default)) {
+                ll::reflection::forEachMember(*uce, [&](std::string_view name, auto&& member) {
+                    result[std::string{name.substr(1)}] = fmt::to_string(member);
+                });
+                return result;
+            }
+            return result;
+        }
+    );
     RemoteCall::exportAs(
         "GMLIB_API",
         "getAllPlayerInfo",
         []() -> std::vector<std::unordered_map<std::string, std::string>> {
             std::vector<std::unordered_map<std::string, std::string>> result;
-            for (auto entry : UserCache::getInstance()->entries()) {
-                result.push_back({
-                    {"Name", entry.mName           },
-                    {"Xuid", entry.mXuid           },
-                    {"Uuid", entry.mUuid.asString()}
+            for (auto& entry : UserCache::getInstance()->entries()) {
+                std::unordered_map<std::string, std::string> item;
+                ll::reflection::forEachMember(entry, [&](std::string_view name, auto&& member) {
+                    item[std::string{name.substr(1)}] = fmt::to_string(member);
                 });
+                result.emplace_back(std::move(item));
             }
             return result;
         }
@@ -628,21 +680,21 @@ void Export_Compatibility_API() {
                     result.push_back({
                         {"Name",  gameRule.mName                                 },
                         {"Type",  "Bool"                                         },
-                        {"Value", std::to_string(gameRule.mValue->boolVal)}
+                        {"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)}
+                        {"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)}
+                        {"Value", std::to_string(std::get<int>(*gameRule.mValue))}
                     });
                     break;
                 case GameRule::Type::Invalid:
@@ -670,7 +722,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);
     });
@@ -791,9 +843,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 "";
     });
@@ -968,7 +1020,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/Global.h

@@ -22,8 +22,8 @@ using namespace modapi;
 #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_PATCH    0
+#define LIB_VERSION_MINOR    7
+#define LIB_VERSION_PATCH    1
 #define LIB_VERSION_PRERELEASE std::nullopt
 
 #ifdef LIB_VERSION_PRERELEASE
@@ -41,3 +41,19 @@ extern void                                  Export_BinaryStream_API();
 extern ll::thread::ThreadPoolExecutor const& getThreadPoolExecutor();
 extern ll::io::Logger&                       getLogger();
 // extern void Export_Form_API();
+
+
+template <>
+struct fmt::formatter<ActorUniqueID> : fmt::formatter<int64> {
+    template <class FormatContext>
+    auto format(ActorUniqueID const& t, FormatContext& ctx) const {
+        return formatter<int64>::format(t.rawID, ctx);
+    }
+};
+template <>
+struct fmt::formatter<mce::UUID> : fmt::formatter<std::string> {
+    template <class FormatContext>
+    auto format(mce::UUID const& t, FormatContext& ctx) const {
+        return formatter<std::string>::format(t.asString(), ctx);
+    }
+};

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
 

tooth.json

@@ -2,7 +2,7 @@
     "format_version": 3,
     "format_uuid": "289f771f-2c9a-4d73-9f3f-8492495a924d",
     "tooth": "github.com/GroupMountain/GMLIB-LegacyRemoteCallApi",
-    "version": "1.5.0",
+    "version": "1.7.1",
     "info": {
         "name": "GMLIB-LegacyRemoteCallApi",
         "description": "Legacy RemoteCall API for GMLIB",
@@ -19,10 +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/GroupMountain/ModAPI-Release": ">=0.1.0",
-                "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,12 +8,12 @@ if not has_config("vs_runtime") then
     set_runtimes("MD")
 end
 
-add_requires("levilamina 1.5.2", {configs = {target_type = "server"}})
+add_requires("levilamina 1.7.3", {configs = {target_type = "server"}})
 add_requires("legacyremotecall")
 add_requires("levibuildscript 0.5.2")
-add_requires("ilistenattentively 0.8.0")
-add_requires("gmlib 1.5.1")
-add_requires("modapi 0.1.1")
+add_requires("ilistenattentively 0.10.0")
+add_requires("gmlib 1.7.0")
+add_requires("modapi 0.3.0")
 
 target("GMLIB-LegacyRemoteCallApi")
     add_cxflags(