chore: update version

feat: add playerWillDestroy,attack,pullInEntity

.github/workflows/build.yml

@@ -9,10 +9,6 @@ jobs:
     steps:
       - name: Checkout repository
         uses: actions/checkout@v2
-        with:
-          submodules: recursive
-
-      - uses: actions/checkout@v4
 
       - uses: xmake-io/github-action-setup-xmake@v1
       

.github/workflows/release.yml

@@ -9,10 +9,6 @@ jobs:
     steps:
       - name: Checkout repository
         uses: actions/checkout@v2
-        with:
-          submodules: recursive
-
-      - uses: actions/checkout@v4
 
       - uses: xmake-io/github-action-setup-xmake@v1
       

.gitignore

@@ -15,3 +15,4 @@ build/
 /.xmake
 /CMakeLists.txt
 /bin
+.cache/clangd/index

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "SDK-GMLIB"]
-	path = SDK-GMLIB
-	url = https://github.com/GroupMountain/SDK-GMLIB.git

README.md

@@ -5,6 +5,5 @@ Legacy RemoteCall API for GMLIB. Only for legacy LSE plugin compatibility.
 - 本模块是 `GMLIB` 的 `Legacy RemoteCall API` 模块，是为LL2的LLSE插件的兼容性保留。
 - 通过本模块，可以使LSE插件调用 `GMLIB` 内部的API。
 
-# 注意事项
+# 开发文档
-- 本模块仅为兼容性保留模块，仅保留过去的接口以保留兼容性。
+- https://groupmountain.github.io/Documentation/
-- 本模块不会提供 `GMLIB` 在迁移到 `LeviLamina` 后新开发的接口。

lib/GMLIB_API-JS.js

@@ -1,6 +1,3 @@
-// LiteLoader-AIDS automatic generated
-/// <reference path="D:\LiteLoader\VSCode/dts/HelperLib-master/src/index.d.ts"/> 
-
 const GMLIB_API = {
     createFloatingText: ll.import("GMLIB_API", "createFloatingText"),
     deleteFloatingText: ll.import("GMLIB_API", "deleteFloatingText"),
@@ -18,7 +15,9 @@ const GMLIB_API = {
     getPlayerNbt: ll.import("GMLIB_API", "getPlayerNbt"),
     setPlayerNbt: ll.import("GMLIB_API", "setPlayerNbt"),
     setPlayerNbtTags: ll.import("GMLIB_API", "setPlayerNbtTags"),
+    deletePlayerNbt: ll.import("GMLIB_API", "deletePlayerNbt"),
     resourcePackTranslate: ll.import("GMLIB_API", "resourcePackTranslate"),
+    resourcePackDefaultTranslate: ll.import("GMLIB_API", "resourcePackDefaultTranslate"),
     getResourcePackI18nLanguage: ll.import("GMLIB_API", "getResourcePackI18nLanguage"),
     chooseResourcePackI18nLanguage: ll.import("GMLIB_API", "chooseResourcePackI18nLanguage"),
     setEducationFeatureEnabled: ll.import("GMLib_ServerAPI", "setEducationFeatureEnabled"),
@@ -35,7 +34,7 @@ const GMLIB_API = {
     PlayerToEntity: ll.import("GMLib_ServerAPI", "PlayerToEntity"),
     setUnknownBlockCleaner: ll.import("GMLib_ModAPI", "setUnknownBlockCleaner"),
     getAllExperiments: ll.import("GMLIB_API", "getAllExperiments"),
-    getExperimentTranslatedName: ll.import("GMLIB_API", "getExperimentTranslatedName"),
+    getExperimentTranslateKey: ll.import("GMLIB_API", "getExperimentTranslateKey"),
     getExperimentEnabled: ll.import("GMLib_ModAPI", "getExperimentEnabled"),
     setExperimentEnabled: ll.import("GMLib_ModAPI", "setExperimentEnabled"),
     unregisterRecipe: ll.import("GMLIB_API", "unregisterRecipe"),
@@ -82,6 +81,7 @@ const GMLIB_API = {
     setDisplayObjective: ll.import("GMLIB_API", "setDisplayObjective"),
     clearDisplayObjective: ll.import("GMLIB_API", "clearDisplayObjective"),
     getAllObjectives: ll.import("GMLIB_API", "getAllObjectives"),
+    getAllTrackedTargets: ll.import("GMLIB_API", "getAllTrackedTargets"),
     getAllScoreboardPlayers: ll.import("GMLIB_API", "getAllScoreboardPlayers"),
     getAllScoreboardFakePlayers: ll.import("GMLIB_API", "getAllScoreboardFakePlayers"),
     getAllScoreboardEntities: ll.import("GMLIB_API", "getAllScoreboardEntities"),
@@ -93,10 +93,45 @@ const GMLIB_API = {
     getPlayerSpawnPoint: ll.import("GMLIB_API", "getPlayerSpawnPoint"),
     setPlayerSpawnPoint: ll.import("GMLIB_API", "setPlayerSpawnPoint"),
     clearPlayerSpawnPoint: ll.import("GMLIB_API", "clearPlayerSpawnPoint"),
-    setCustomPackPath: ll.import("GMLIB_API", "setCustomPackPath")
+    setCustomPackPath: ll.import("GMLIB_API", "setCustomPackPath"),
+    getSupportedLanguages: ll.import("GMLIB_API", "getSupportedLanguages"),
+    loadLanguage: ll.import("GMLIB_API", "loadLanguage"),
+    updateOrCreateLanguageFile: ll.import("GMLIB_API", "updateOrCreateLanguageFile"),
+    loadLanguagePath: ll.import("GMLIB_API", "loadLanguagePath"),
+    mergePatchJson: ll.import("GMLIB_API", "mergePatchJson"),
+    getXuidByUuid: ll.import("GMLIB_API", "getXuidByUuid"),
+    getNameByUuid: ll.import("GMLIB_API", "getNameByUuid"),
+    getUuidByXuid: ll.import("GMLIB_API", "getUuidByXuid"),
+    getNameByXuid: ll.import("GMLIB_API", "getNameByXuid"),
+    getXuidByName: ll.import("GMLIB_API", "getXuidByName"),
+    getUuidByName: ll.import("GMLIB_API", "getUuidByName"),
+    getAllPlayerInfo: ll.import("GMLIB_API", "getAllPlayerInfo"),
+    getBlockRuntimeId: ll.import("GMLIB_API", "getBlockRuntimeId"),
+    addFakeList: ll.import("GMLIB_API", "addFakeList"),
+    removeFakeList: ll.import("GMLIB_API", "removeFakeList"),
+    removeAllFakeLists: ll.import("GMLIB_API", "removeAllFakeList"),
+    setFixI18nEnabled: ll.import("GMLib_ModAPI", "setFixI18nEnabled"),
+    getBlockTranslateKey: ll.import("GMLIB_API", "getBlockTranslateKey"),
+    getItemTranslateKey: ll.import("GMLIB_API", "getItemTranslateKey"),
+    getEntityTranslateKey: ll.import("GMLIB_API", "getEntityTranslateKey"),
+    readNbtFromFile: ll.import("GMLIB_API", "readNbtFromFile"),
+    saveNbtToFile: ll.import("GMLIB_API", "saveNbtToFile"),
+    getBlockDestroySpeed: ll.import("GMLIB_API", "getBlockDestroySpeed"),
+    getDestroyBlockSpeed: ll.import("GMLIB_API", "getDestroyBlockSpeed"),
+    playerDestroyBlock: ll.import("GMLIB_API", "playerDestroyBlock"),
+    itemCanDestroyBlock: ll.import("GMLIB_API", "itemCanDestroyBlock"),
+    itemCanDestroyInCreative: ll.import("GMLIB_API", "itemCanDestroyInCreative"),
+    itemCanDestroySpecial: ll.import("GMLIB_API", "itemCanDestroySpecial"),
+    blockCanDropWithAnyTool: ll.import("GMLIB_API", "blockCanDropWithAnyTool"),
+    blockIsAlwaysDestroyable: ll.import("GMLIB_API", "blockIsAlwaysDestroyable"),
+    blockPlayerWillDestroy: ll.import("GMLIB_API", "blockPlayerWillDestroy"),
+    playerAttack: ll.import("GMLIB_API", "playerAttack"),
+    playerPullInEntity: ll.import("GMLIB_API", "playerPullInEntity"),
+    getBlockTranslateKeyFromName: ll.import("GMLIB_API", "getBlockTranslateKeyFromName")
 }
 
-const FloatingTextList = [];
+const mStaticFloatingTextMap = new Map();
+const mDynamicFloatingTextMap = new Map();
 
 class StaticFloatingText {
     constructor(pos, text, papi = true) {
@@ -104,11 +139,7 @@ class StaticFloatingText {
         this.mText = text;
         this.mPlaceholderAPI = papi;
         this.mRuntimeId = GMLIB_API.createFloatingText(this.mPosition, this.mText, this.mPlaceholderAPI);
-        FloatingTextList.push(this);
+        mStaticFloatingTextMap.set(this.mRuntimeId, this);
-        this.sendToClients();
-        mc.listen("onJoin", (pl) => {
-            this.sendToClient(pl);
-        });
     }
 
     sendToClient(player) {
@@ -162,32 +193,21 @@ class StaticFloatingText {
     }
 
     destroy() {
-        let size_t = FloatingTextList.indexOf(this);
+        mStaticFloatingTextMap.delete(this.mRuntimeId);
-        FloatingTextList.splice(size_t, 1);
         return GMLIB_API.deleteFloatingText(this.mRuntimeId);
     }
 
-    isDynamic() {
-        return false;
-    }
-
     static getFloatingText(runtimeId) {
-        for (const ft of FloatingTextList) {
+        if (mStaticFloatingTextMap.has(runtimeId)) {
-            if (ft.getRuntimeId() == runtimeId) {
+            return mStaticFloatingTextMap.get(runtimeId);
-                if (!ft.isDynamic()) {
-                    return ft;
-                }
-            }
         }
         return null;
     }
 
     static getAllFloatingTexts() {
         let result = [];
-        FloatingTextList.forEach((ft) => {
+        mStaticFloatingTextMap.forEach((ft) => {
-            if (!ft.isDynamic()) {
+            result.push(ft);
-                result.push(ft);
-            }
         });
         return result;
     }
@@ -195,9 +215,13 @@ class StaticFloatingText {
 
 class DynamicFloatingText extends StaticFloatingText {
     constructor(pos, text, updateRate = 1, papi = true) {
-        super(pos, text, papi);
+        this.mPosition = pos;
+        this.mText = text;
+        this.mPlaceholderAPI = papi;
+        this.mRuntimeId = GMLIB_API.createFloatingText(this.mPosition, this.mText, this.mPlaceholderAPI);
         this.mUpdateRate = updateRate;
         this.mTaskId = null;
+        mDynamicFloatingTextMap.set(this.mRuntimeId, this);
         this.startUpdate();
     }
 
@@ -222,7 +246,7 @@ class DynamicFloatingText extends StaticFloatingText {
     }
 
     stopUpdate() {
-        if (this.mTaskId != null) {
+        if (this.mTaskId) {
             clearInterval(this.mTaskId);
             this.mTaskId = null;
             return true;
@@ -231,32 +255,21 @@ class DynamicFloatingText extends StaticFloatingText {
     }
 
     destroy() {
-        let size_t = FloatingTextList.indexOf(this);
+        mDynamicFloatingTextMap.delete(this.mRuntimeId);
-        FloatingTextList.splice(size_t, 1);
         return GMLIB_API.deleteFloatingText(this.mRuntimeId);
     }
 
-    isDynamic() {
-        return true;
-    }
-
     static getFloatingText(runtimeId) {
-        for (const ft of FloatingTextList) {
+        if (mDynamicFloatingTextMap.has(runtimeId)) {
-            if (ft.getRuntimeId() == runtimeId) {
+            return mDynamicFloatingTextMap.get(runtimeId);
-                if (ft.isDynamic()) {
-                    return ft;
-                }
-            }
         }
         return null;
     }
 
     static getAllFloatingTexts() {
         let result = [];
-        FloatingTextList.forEach((ft) => {
+        mDynamicFloatingTextMap.forEach((ft) => {
-            if (ft.isDynamic()) {
+            result.push(ft);
-                result.push(ft);
-            }
         });
         return result;
     }
@@ -284,22 +297,19 @@ class Minecraft {
     }
 
     static getPlayerNbt(uuid) {
-        let snbt = GMLIB_API.getPlayerNbt(uuid);
+        return GMLIB_API.getPlayerNbt(uuid);
-        if (snbt == "null") {
-            return null;
-        }
-        let nbt = NBT.parseSNBT(snbt);
-        return nbt;
     }
 
     static setPlayerNbt(uuid, nbt, forceCreate = true) {
-        let snbt = nbt.toSNBT();
+        return GMLIB_API.setPlayerNbt(uuid, nbt, forceCreate);
-        return GMLIB_API.setPlayerNbt(uuid, snbt, forceCreate);
     }
 
     static setPlayerNbtTags(uuid, nbt, tags) {
-        let snbt = nbt.toSNBT();
+        return GMLIB_API.setPlayerNbtTags(uuid, nbt, tags);
-        return GMLIB_API.setPlayerNbtTags(uuid, snbt, tags);
+    }
+
+    static deletePlayerNbt(uuid) {
+        return GMLIB_API.deletePlayerNbt(uuid);
     }
 
     static getPlayerPosition(uuid) {
@@ -371,11 +381,11 @@ class Minecraft {
     }
 
     static getServerLanguage() {
-        return GMLIB_API.getResourcePackI18nLanguage(language);
+        return I18nAPI.getCurrentLanguage();
     }
 
     static setServerLanguage(language) {
-        return GMLIB_API.chooseResourcePackI18nLanguage(language);
+        return I18nAPI.chooseLanguage(language);
     }
 
     static setCustomPackPath(path) {
@@ -383,7 +393,51 @@ class Minecraft {
     }
 
     static resourcePackTranslate(key, params = []) {
-        return GMLIB_API.resourcePackTranslate(key, params);
+        return I18nAPI.get(key, params);
+    }
+
+    static getPlayerFromUuid(uuid) {
+        return GMLIB_API.getPlayerFromUuid(uuid);
+    }
+
+    static getPlayerFromUniqueId(uniqueId) {
+        return GMLIB_API.getPlayerFromUniqueId(uniqueId);
+    }
+
+    static getEntityFromUniqueId(uniqueId) {
+        return GMLIB_API.getFromUniqueId(uniqueId);
+    }
+
+    static getBlockRuntimeId(block) {
+        return GMLIB_API.getBlockRuntimeId(block);
+    }
+
+    static addFakeList(name, xuid) {
+        return GMLIB_API.addFakeList(name, xuid);
+    }
+
+    static removeFakeList(nameOrXuid) {
+        return GMLIB_API.removeFakeList(nameOrXuid);
+    }
+
+    static removeAllFakeLists() {
+        return GMLIB_API.removeAllFakeLists();
+    }
+
+    static setFixI18nEnabled() {
+        GMLIB_API.setFixI18nEnabled();
+    }
+
+    static saveNbtToFile(path, nbt, isBinary = true) {
+        return GMLIB_API.saveNbtToFile(path, nbt, isBinary);
+    }
+
+    static readNbtFromFile(path, isBinary = true) {
+        return GMLIB_API.readNbtFromFile(path, isBinary);
+    }
+
+    static getBlockTranslateKeyFromName(name) {
+        return GMLIB_API.getBlockTranslateKeyFromName(name);
     }
 }
 
@@ -440,18 +494,8 @@ class Experiments {
         return GMLIB_API.getAllExperiments();
     }
 
-    static getExperimentTranslatedName(id) {
+    static getExperimentTranslateKey(id) {
-        return GMLIB_API.getExperimentTranslatedName(id);
+        return GMLIB_API.getExperimentTranslateKey(id);
-    }
-
-    static getExperimentsMap() {
-        let ids = this.getAllExperimentIds();
-        let result = {};
-        for (let id in ids) {
-            let name = this.getExperimentTranslatedName(id);
-            result[id] = name;
-        }
-        return result;
     }
 
     static getExperimentEnabled(id) {
@@ -507,28 +551,22 @@ class Version {
         if (Array.isArray(array) && array.length == 3) {
             let isNumber = array.every(element => typeof element == "number");
             if (isNumber) {
-                return new Version(array[0], array[1], array[2])
+                return new Version(array[0], array[1], array[2]);
             }
         }
         return null;
     }
-}
 
-class GMLIB {
+    static isPluginVersionMatched(version) {
-    constructor() {
+        return GMLIB_API.isVersionMatched(version.mMajor, version.mMinor, version.mPatch);
-        throw new Error("Static class cannot be instantiated");
     }
 
-    static isVersionMatched(major, minor, patch) {
+    static getLrcaVersion() {
-        return GMLIB_API.isVersionMatched(major, minor, patch);
+        return Version.fromString(GMLIB_API.getVersion_LRCA());
     }
 
-    static getVersion_LRCA() {
+    static getGmlibVersion() {
-        return GMLIB_API.getVersion_LRCA();
+        return Version.fromString(GMLIB_API.getVersion_GMLIB());
-    }
-
-    static getVersion_GMLIB() {
-        return GMLIB_API.getVersion_GMLIB();
     }
 }
 
@@ -551,29 +589,7 @@ class Scoreboard {
     }
 
     static getAllTrackedTargets() {
-        let result = [];
+        return GMLIB_API.getAllTrackedTargets();
-        GMLIB_API.getAllScoreboardPlayers().forEach((uuid) => {
-            let key = {
-                "Type": "Player",
-                "Uuid": uuid
-            };
-            result.push(key);
-        });
-        GMLIB_API.getAllScoreboardEntities().forEach((uniqueId) => {
-            let key = {
-                "Type": "Entity",
-                "UniqueId": uniqueId
-            };
-            result.push(key);
-        });
-        GMLIB_API.getAllScoreboardFakePlayers().forEach((name) => {
-            let key = {
-                "Type": "FakePlayer",
-                "Name": name
-            };
-            result.push(key);
-        });
-        return result;
     }
 
     // Objectives
@@ -704,7 +720,14 @@ class JsonConfig {
     init() {
         if (File.exists(this.mPath)) {
             let existDataStr = File.readFrom(this.mPath);
-            this.mData = Object.assign({}, this.mData, JSON.parse(existDataStr));
+            existDataStr = existDataStr.replace(/\/\/.*|\/\*[^]*?\*\//g, "");
+            try {
+                let result = GMLIB_API.mergePatchJson(JSON.stringify(this.mData), existDataStr);
+                this.mData = JSON.parse(result);
+            } catch {
+                let newPath = this.mPath + "_old";
+                File.rename(this.mPath, newPath);
+            }
         }
         this.save();
     }
@@ -718,9 +741,9 @@ class JsonConfig {
         return this.mData;
     }
 
-    get(key, defultValue = null) {
+    get(key, defultValue = undefined) {
         let result = this.getData()[key];
-        if (!result && defultValue != null) {
+        if (!result && defultValue != undefined) {
             this.set(key, defultValue);
             return defultValue;
         }
@@ -806,6 +829,95 @@ class JsonI18n {
     }
 };
 
+class I18nAPI {
+    constructor() {
+        throw new Error("Static class cannot be instantiated");
+    }
+
+    static get(key, params = [], langCode = undefined) {
+        let data = [];
+        params.forEach((param) => {
+            data.push(param);
+        });
+        if (langCode) {
+            return GMLIB_API.resourcePackTranslate(key, data, langCode);
+        }
+        return GMLIB_API.resourcePackDefaultTranslate(key, data);
+    }
+
+    static translate(key, params = [], langCode = undefined) {
+        return I18nAPI.get(key, params, langCode);
+    }
+
+    static getSupportedLanguages() {
+        return GMLIB_API.getSupportedLanguages();
+    }
+
+    static getCurrentLanguage() {
+        return GMLIB_API.getResourcePackI18nLanguage(language);
+    }
+
+    static chooseLanguage(language) {
+        GMLIB_API.chooseResourcePackI18nLanguage(language);
+    }
+
+    static loadLanguage(code, language) {
+        GMLIB_API.loadLanguage(code, language);
+    }
+
+    static updateOrCreateLanguageFile(code, lang, path) {
+        GMLIB_API.updateOrCreateLanguageFile(code, lang, path);
+    }
+
+    static loadLanguageDirectory(path) {
+        GMLIB_API.loadLanguagePath(path);
+    }
+};
+
+class UserCache {
+    constructor() {
+        throw new Error("Static class cannot be instantiated");
+    }
+
+    static getXuidByUuid(uuid) {
+        let result = GMLIB_API.getXuidByUuid(uuid);
+        return result == "" ? null : result;
+    }
+
+    static getUuidByXuid(xuid) {
+        let result = GMLIB_API.getUuidByXuid(xuid);
+        return result == "" ? null : result;
+    }
+
+    static getNameByUuid(uuid) {
+        let result = GMLIB_API.getNameByUuid(uuid);
+        return result == "" ? null : result;
+    }
+
+    static getNameByXuid(xuid) {
+        let result = GMLIB_API.getNameByXuid(xuid);
+        return result == "" ? null : result;
+    }
+
+    static getXuidByName(name) {
+        let result = GMLIB_API.getXuidByName(name);
+        return result == "" ? null : result;
+    }
+
+    static getUuidByName(name) {
+        let result = GMLIB_API.getUuidByName(name);
+        return result == "" ? null : result;
+    }
+
+    static getPlayerInfo(playerIdentifier) {
+        return GMLIB_API.getAllPlayerInfo().find(Info => Object.keys(Info).some(InfoKey => Info[InfoKey] === playerIdentifier));
+    }
+
+    static getAllPlayerInfo() {
+        return GMLIB_API.getAllPlayerInfo();
+    }
+};
+
 LLSE_Player.prototype.toEntity = function () {
     return GMLIB_API.PlayerToEntity(this);
 }
@@ -830,6 +942,73 @@ LLSE_Entity.prototype.throwEntity = function (proj, speed = 2, offset = 3) {
     return GMLIB_API.throwEntity(this, proj, speed, offset);
 }
 
+LLSE_Entity.prototype.getTranslateKey = function () {
+    return GMLIB_API.getEntityTranslateKey(this);
+}
+
+LLSE_Entity.prototype.getTranslateName = function (language) {
+    return I18nAPI.get(this.getTranslateKey(), [], language);
+}
+
+LLSE_Block.prototype.getTranslateKey = function () {
+    return GMLIB_API.getBlockTranslateKey(this);
+}
+
+LLSE_Block.prototype.getTranslateName = function (language) {
+    return I18nAPI.get(this.getTranslateKey(), [], language);
+}
+
+LLSE_Item.prototype.getTranslateKey = function () {
+    return GMLIB_API.getItemTranslateKey(this);
+}
+
+LLSE_Item.prototype.getTranslateName = function (language) {
+    return I18nAPI.get(this.getTranslateKey(), [], language);
+}
+
+LLSE_Block.prototype.getBlockDestroySpeed = function () {
+    return GMLIB_API.getBlockDestroySpeed(this);
+}
+
+LLSE_Item.prototype.getDestroyBlockSpeed = function (block) {
+    return GMLIB_API.getDestroyBlockSpeed(this, block);
+}
+
+LLSE_Block.prototype.playerDestroy = function (player) {
+    GMLIB_API.playerDestroyBlock(this, this.pos, player);
+}
+
+LLSE_Item.prototype.canDestroy = function (block) {
+    return GMLIB_API.itemCanDestroyBlock(this, block);
+}
+
+LLSE_Item.prototype.canDestroyInCreative = function () {
+    return GMLIB_API.itemCanDestroyInCreative(this);
+}
+
+LLSE_Item.prototype.canDestroySpecial = function (block) {
+    return GMLIB_API.itemCanDestroySpecial(this, block);
+}
+
+LLSE_Block.prototype.canDropWithAnyTool = function () {
+    return GMLIB_API.blockCanDropWithAnyTool(this);
+}
+
+LLSE_Block.prototype.isAlwaysDestroyable = function () {
+    return GMLIB_API.blockIsAlwaysDestroyable(this);
+}
+
+LLSE_Block.prototype.playerWillDestroy = function (player) {
+    return GMLIB_API.blockPlayerWillDestroy(this, player, this.pos);
+}
+
+LLSE_Player.prototype.attack = function (entity) {
+    return GMLIB_API.playerAttack(this, entity);
+}
+
+LLSE_Player.prototype.pullInEntity = function (entity) {
+    return GMLIB_API.playerPullInEntity(this, entity);
+}
 
 module.exports = {
     StaticFloatingText,
@@ -837,16 +1016,11 @@ module.exports = {
     Minecraft,
     Recipes,
     Experiments,
-    GMLIB,
     Scoreboard,
     JsonConfig,
     JsonLanguage,
     JsonI18n,
-    Version
+    Version,
+    I18nAPI,
+    UserCache
 };
-
-
-
-
-
-

manifest.json

@@ -1,7 +1,7 @@
 {
     "name": "${pluginName}",
     "entry": "${pluginFile}",
-    "version": "0.10.1",
+    "version": "0.12.8",
     "author": "GroupMountain",
     "type": "native",
     "dependencies": [

src/CompatibilityApi.cpp

@@ -6,7 +6,7 @@ bool isInteger(const std::string& str) {
     return std::regex_match(str, pattern);
 }
 
-ActorUniqueID parseScriptUniqueID(std::string uniqueId) {
+ActorUniqueID parseScriptUniqueID(std::string const& uniqueId) {
     if (!isInteger(uniqueId)) {
         return ActorUniqueID::INVALID_ID;
     }
@@ -14,15 +14,15 @@ ActorUniqueID parseScriptUniqueID(std::string uniqueId) {
 }
 
 void Export_Compatibility_API() {
-    RemoteCall::exportAs("GMLIB_API", "unregisterRecipe", [](std::string id) -> bool {
+    RemoteCall::exportAs("GMLIB_API", "unregisterRecipe", [](std::string const& id) -> bool {
         auto level = GMLIB_Level::getInstance();
         if (!level) {
             return false;
         }
-        return GMLIB::Mod::CustomRecipe::unregisterRecipe(id);
+        return CustomRecipe::unregisterRecipe(id);
     });
-    RemoteCall::exportAs("GMLIB_API", "setCustomPackPath", [](std::string path) -> void {
+    RemoteCall::exportAs("GMLIB_API", "setCustomPackPath", [](std::string const& path) -> void {
-        GMLIB::Mod::CustomPacks::addCustomPackPath(path);
+        CustomPacks::addCustomPackPath(path);
     });
     RemoteCall::exportAs("GMLIB_API", "getServerMspt", []() -> float {
         auto level = GMLIB_Level::getInstance();
@@ -53,135 +53,165 @@ void Export_Compatibility_API() {
         }
         return result;
     });
-    RemoteCall::exportAs("GMLIB_API", "getPlayerNbt", [](std::string uuid) -> std::string {
+    RemoteCall::exportAs("GMLIB_API", "getPlayerNbt", [](std::string const& uuid) -> std::unique_ptr<CompoundTag> {
         auto uid = mce::UUID::fromString(uuid);
-        auto nbt = GMLIB_Player::getPlayerNbt(uid);
+        return std::move(GMLIB_Player::getPlayerNbt(uid));
-        if (nbt) {
-            return nbt->toSnbt();
-        }
-        return "null";
-    });
-    RemoteCall::exportAs("GMLIB_API", "setPlayerNbt", [](std::string uuid, std::string snbt, bool forceCreate) -> bool {
-        auto uid = mce::UUID::fromString(uuid);
-        auto nbt = CompoundTag::fromSnbt(snbt);
-        return GMLIB_Player::setPlayerNbt(uid, *nbt, forceCreate);
     });
     RemoteCall::exportAs(
         "GMLIB_API",
-        "setPlayerNbtTags",
+        "setPlayerNbt",
-        [](std::string uuid, std::string snbt, std::vector<std::string> tags) -> bool {
+        [](std::string const& uuid, CompoundTag* nbt, bool forceCreate) -> bool {
+            auto uid = mce::UUID::fromString(uuid);
+            return GMLIB_Player::setPlayerNbt(uid, *nbt, forceCreate);
+        }
+    );
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "setPlayerNbtTags",
+        [](std::string const& uuid, CompoundTag* nbt, std::vector<std::string> tags) -> bool {
             auto uid = mce::UUID::fromString(uuid);
-            auto nbt = CompoundTag::fromSnbt(snbt);
             return GMLIB_Player::setPlayerNbtTags(uid, *nbt, tags);
         }
     );
+    RemoteCall::exportAs("GMLIB_API", "deletePlayerNbt", [](std::string const& uuid) -> bool {
+        auto uid = mce::UUID::fromString(uuid);
+        return GMLIB_Player::deletePlayerNbt(uid);
+    });
     RemoteCall::exportAs("GMLIB_API", "getAllExperiments", []() -> std::vector<int> {
-        auto             map = GMLIB_Level::getAllExperiments();
+        auto             list = GMLIB_Level::getAllExperiments();
         std::vector<int> result;
-        for (auto& key : map) {
+        for (auto& key : list) {
-            result.push_back(key.first);
+            result.push_back((int)key);
         }
         return result;
     });
-    RemoteCall::exportAs("GMLIB_API", "getExperimentTranslatedName", [](int id) -> std::string {
+    RemoteCall::exportAs("GMLIB_API", "getExperimentTranslateKey", [](int id) -> std::string {
-        auto map = GMLIB_Level::getAllExperimentsTranslateKeys();
+        std::string result;
-        if (map.count(id)) {
+        try {
-            return std::string(map[id]);
+            result = Experiments::getExperimentTextID(AllExperiments(id));
-        }
+        } catch (...) {}
-        return "";
+        return result;
     });
     RemoteCall::exportAs(
         "GMLIB_API",
         "createFloatingText",
-        [](std::pair<Vec3, int> pos, std::string text, bool papi) -> int {
+        [](std::pair<Vec3, int> pos, std::string const& text, bool papi) -> int {
-            auto ft = new GMLIB::Server::FloatingText(text, pos.first, pos.second, papi);
+            auto& manager = FloatingTextManager::getInstance();
+            auto  ft      = manager.createStatic(text, pos.first, pos.second, papi);
+            manager.add(ft);
             return ft->getRuntimeID();
         }
     );
-    RemoteCall::exportAs("GMLIB_API", "setFloatingTextData", [](int id, std::string text) -> bool {
+    RemoteCall::exportAs("GMLIB_API", "setFloatingTextData", [](int id, std::string const& text) -> bool {
-        auto ft = GMLIB::Server::FloatingText::getFloatingText(id);
+        if (auto ft = FloatingTextManager::getInstance().getFloatingText(id)) {
-        if (ft) {
             ft->setText(text);
             return true;
         }
         return false;
     });
     RemoteCall::exportAs("GMLIB_API", "deleteFloatingText", [](int id) -> bool {
-        return GMLIB::Server::FloatingText::deleteFloatingText(id);
+        return FloatingTextManager::getInstance().remove(id);
     });
     RemoteCall::exportAs("GMLIB_API", "sendFloatingTextToPlayer", [](int id, Player* pl) -> bool {
-        auto ft = GMLIB::Server::FloatingText::getFloatingText(id);
+        if (auto ft = FloatingTextManager::getInstance().getFloatingText(id)) {
-        if (ft) {
+            ft->sendTo(*pl);
-            ft->sendToClient(pl);
             return true;
         }
         return false;
     });
     RemoteCall::exportAs("GMLIB_API", "sendFloatingText", [](int id) -> bool {
-        auto ft = GMLIB::Server::FloatingText::getFloatingText(id);
+        if (auto ft = FloatingTextManager::getInstance().getFloatingText(id)) {
-        if (ft) {
+            ft->sendToClients();
-            ft->sendToAllClients();
             return true;
         }
         return false;
     });
     RemoteCall::exportAs("GMLIB_API", "removeFloatingTextFromPlayer", [](int id, Player* pl) -> bool {
-        auto ft = GMLIB::Server::FloatingText::getFloatingText(id);
+        if (auto ft = FloatingTextManager::getInstance().getFloatingText(id)) {
-        if (ft) {
+            ft->removeFrom(*pl);
-            ft->removeFromClient(pl);
             return true;
         }
         return false;
     });
     RemoteCall::exportAs("GMLIB_API", "removeFloatingText", [](int id) -> bool {
-        auto ft = GMLIB::Server::FloatingText::getFloatingText(id);
+        if (auto ft = FloatingTextManager::getInstance().getFloatingText(id)) {
-        if (ft) {
+            ft->removeFromClients();
-            ft->removeFromAllClients();
             return true;
         }
         return false;
     });
     RemoteCall::exportAs("GMLIB_API", "updateClientFloatingTextData", [](int id, Player* pl) -> bool {
-        auto ft = GMLIB::Server::FloatingText::getFloatingText(id);
+        if (auto ft = FloatingTextManager::getInstance().getFloatingText(id)) {
-        if (ft) {
+            ft->update(*pl);
-            ft->updateClient(pl);
             return true;
         }
         return false;
     });
     RemoteCall::exportAs("GMLIB_API", "updateAllClientsFloatingTextData", [](int id) -> bool {
-        auto ft = GMLIB::Server::FloatingText::getFloatingText(id);
+        if (auto ft = FloatingTextManager::getInstance().getFloatingText(id)) {
-        if (ft) {
+            ft->updateClients();
-            ft->updateAllClients();
             return true;
         }
         return false;
     });
     RemoteCall::exportAs("GMLIB_API", "isVersionMatched", [](int a, int b, int c) -> bool {
-        auto version = GMLIB::Version(a, b, c, "", "");
+        auto version = Version(a, b, c, "", "");
-        return version >= LIB_VERSION;
+        return LIB_VERSION >= version;
     });
     RemoteCall::exportAs("GMLIB_API", "getVersion_LRCA", []() -> std::string { return LIB_VERSION.asString(); });
     RemoteCall::exportAs("GMLIB_API", "getVersion_GMLIB", []() -> std::string {
-        return GMLIB::Version::getLibVersionString();
+        return Version::getLibVersionString();
     });
     RemoteCall::exportAs(
         "GMLIB_API",
-        "resourcePackTranslate",
+        "resourcePackDefaultTranslate",
-        [](std::string key, std::vector<std::string> params) -> std::string { return I18n::get(key, params); }
+        [](std::string const& key, std::vector<std::string> params) -> std::string { return I18nAPI::get(key, params); }
     );
-    RemoteCall::exportAs("GMLIB_API", "chooseResourcePackI18nLanguage", [](std::string code) -> void {
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "resourcePackTranslate",
+        [](std::string const& key, std::vector<std::string> params, std::string const& code) -> std::string {
+            return I18nAPI::get(key, params, code);
+        }
+    );
+    RemoteCall::exportAs("GMLIB_API", "chooseResourcePackI18nLanguage", [](std::string const& code) -> void {
         if (GMLIB_Level::getInstance()) {
-            I18n::chooseLanguage(code);
+            I18nAPI::chooseLanguage(code);
         }
     });
     RemoteCall::exportAs("GMLIB_API", "getResourcePackI18nLanguage", []() -> std::string {
         if (GMLIB_Level::getInstance()) {
-            return I18n::getCurrentLanguage()->getFullLanguageCode();
+            return I18nAPI::getCurrentLanguageCode();
         }
         return "unknown";
     });
-    RemoteCall::exportAs("GMLIB_API", "getPlayerPosition", [](std::string uuid) -> std::pair<BlockPos, int> {
+    RemoteCall::exportAs("GMLIB_API", "getSupportedLanguages", []() -> std::vector<std::string> {
+        if (GMLIB_Level::getInstance()) {
+            return I18nAPI::getSupportedLanguageCodes();
+        }
+        return {};
+    });
+    RemoteCall::exportAs("GMLIB_API", "loadLanguage", [](std::string const& code, std::string const& lang) -> void {
+        if (GMLIB_Level::getInstance()) {
+            I18nAPI::loadLanguage(code, lang);
+        }
+    });
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "updateOrCreateLanguageFile",
+        [](std::string const& code, std::unordered_map<std::string, std::string> lang, std::string const& path
+        ) -> void {
+            if (GMLIB_Level::getInstance()) {
+                I18nAPI::updateOrCreateLanguageFile(path, code, lang);
+            }
+        }
+    );
+    RemoteCall::exportAs("GMLIB_API", "loadLanguagePath", [](std::string const& path) -> void {
+        if (GMLIB_Level::getInstance()) {
+            I18nAPI::loadLanguagesFromDirectory(path);
+        }
+    });
+    RemoteCall::exportAs("GMLIB_API", "getPlayerPosition", [](std::string const& uuid) -> std::pair<BlockPos, int> {
         auto uid = mce::UUID::fromString(uuid);
         auto pos = GMLIB_Player::getPlayerPosition(uid);
         if (pos.has_value()) {
@@ -192,78 +222,102 @@ void Export_Compatibility_API() {
             -1
         };
     });
-    RemoteCall::exportAs("GMLIB_API", "setPlayerPosition", [](std::string uuid, std::pair<BlockPos, int> pos) -> bool {
+    RemoteCall::exportAs(
-        auto uid = mce::UUID::fromString(uuid);
+        "GMLIB_API",
-        return GMLIB_Player::setPlayerPosition(uid, pos.first, pos.second);
+        "setPlayerPosition",
-    });
+        [](std::string const& uuid, std::pair<BlockPos, int> pos) -> bool {
-    RemoteCall::exportAs("GMLIB_API", "playerHasScore", [](std::string uuid, std::string obj) -> bool {
+            auto uid = mce::UUID::fromString(uuid);
+            return GMLIB_Player::setPlayerPosition(uid, pos.first, pos.second);
+        }
+    );
+    RemoteCall::exportAs("GMLIB_API", "playerHasScore", [](std::string const& uuid, std::string const& obj) -> bool {
         auto uid = mce::UUID::fromString(uuid);
         if (auto result = GMLIB_Player::getPlayerScore(uid, obj)) {
             return true;
         }
         return false;
     });
-    RemoteCall::exportAs("GMLIB_API", "getPlayerScore", [](std::string uuid, std::string obj) -> int {
+    RemoteCall::exportAs("GMLIB_API", "getPlayerScore", [](std::string const& uuid, std::string const& obj) -> int {
         auto uid = mce::UUID::fromString(uuid);
         if (auto result = GMLIB_Player::getPlayerScore(uid, obj)) {
             return result.value();
         }
         return 0;
     });
-    RemoteCall::exportAs("GMLIB_API", "addPlayerScore", [](std::string uuid, std::string obj, int value) -> bool {
+    RemoteCall::exportAs(
-        auto uid = mce::UUID::fromString(uuid);
+        "GMLIB_API",
-        if (auto res = GMLIB_Player::setPlayerScore(uid, obj, value, PlayerScoreSetFunction::Add)) {
+        "addPlayerScore",
-            return true;
+        [](std::string const& uuid, std::string const& obj, int value) -> bool {
-        }
+            auto uid = mce::UUID::fromString(uuid);
-        return false;
+            if (auto res = GMLIB_Player::setPlayerScore(uid, obj, value, PlayerScoreSetFunction::Add)) {
-    });
+                return true;
-    RemoteCall::exportAs("GMLIB_API", "reducePlayerScore", [](std::string uuid, std::string obj, int value) -> bool {
+            }
-        auto uid = mce::UUID::fromString(uuid);
+            return false;
-        if (auto res = GMLIB_Player::setPlayerScore(uid, obj, value, PlayerScoreSetFunction::Subtract)) {
+        }
-            return true;
+    );
-        }
+    RemoteCall::exportAs(
-        return false;
+        "GMLIB_API",
-    });
+        "reducePlayerScore",
-    RemoteCall::exportAs("GMLIB_API", "setPlayerScore", [](std::string uuid, std::string obj, int value) -> bool {
+        [](std::string const& uuid, std::string const& obj, int value) -> bool {
-        auto uid = mce::UUID::fromString(uuid);
+            auto uid = mce::UUID::fromString(uuid);
-        if (auto res = GMLIB_Player::setPlayerScore(uid, obj, value)) {
+            if (auto res = GMLIB_Player::setPlayerScore(uid, obj, value, PlayerScoreSetFunction::Subtract)) {
-            return true;
+                return true;
-        }
+            }
-        return false;
+            return false;
-    });
+        }
-    RemoteCall::exportAs("GMLIB_API", "resetPlayerScore", [](std::string uuid, std::string obj) -> bool {
+    );
-        auto uid = mce::UUID::fromString(uuid);
+    RemoteCall::exportAs(
-        return GMLIB_Player::resetPlayerScore(uid, obj);
+        "GMLIB_API",
-    });
+        "setPlayerScore",
-    RemoteCall::exportAs("GMLIB_API", "resetPlayerScores", [](std::string uuid) -> bool {
+        [](std::string const& uuid, std::string const& obj, int value) -> bool {
-        auto uid = mce::UUID::fromString(uuid);
+            auto uid = mce::UUID::fromString(uuid);
-        return GMLIB_Player::resetPlayerScore(uid);
+            if (auto res = GMLIB_Player::setPlayerScore(uid, obj, value)) {
-    });
+                return true;
-    RemoteCall::exportAs("GMLIB_API", "entityHasScore", [](std::string uniqueId, std::string obj) -> bool {
+            }
-        auto auid = parseScriptUniqueID(uniqueId);
+            return false;
-        if (auto result = GMLIB_Scoreboard::getInstance()->getScore(obj, auid)) {
+        }
-            return true;
+    );
-        }
+    RemoteCall::exportAs("GMLIB_API", "resetPlayerScore", [](std::string const& uuid, std::string const& obj) -> bool {
-        return false;
+        auto uid = mce::UUID::fromString(uuid);
-    });
+        return GMLIB_Player::resetPlayerScore(uid, obj);
-    RemoteCall::exportAs("GMLIB_API", "getEntityScore", [](std::string uniqueId, std::string obj) -> int {
+    });
-        auto auid = parseScriptUniqueID(uniqueId);
+    RemoteCall::exportAs("GMLIB_API", "resetPlayerScores", [](std::string const& uuid) -> bool {
-        if (auto result = GMLIB_Scoreboard::getInstance()->getScore(obj, auid)) {
+        auto uid = mce::UUID::fromString(uuid);
-            return result.value();
+        return GMLIB_Player::resetPlayerScore(uid);
-        }
+    });
-        return 0;
+    RemoteCall::exportAs(
-    });
+        "GMLIB_API",
-    RemoteCall::exportAs("GMLIB_API", "addEntityScore", [](std::string uniqueId, std::string obj, int value) -> bool {
+        "entityHasScore",
-        auto auid = parseScriptUniqueID(uniqueId);
+        [](std::string const& uniqueId, std::string const& obj) -> bool {
-        if (auto res = GMLIB_Scoreboard::getInstance()->setScore(obj, auid, value, PlayerScoreSetFunction::Add)) {
+            auto auid = parseScriptUniqueID(uniqueId);
-            return true;
+            if (auto result = GMLIB_Scoreboard::getInstance()->getScore(obj, auid)) {
-        }
+                return true;
-        return false;
+            }
-    });
+            return false;
+        }
+    );
+    RemoteCall::exportAs("GMLIB_API", "getEntityScore", [](std::string const& uniqueId, std::string const& obj) -> int {
+        auto auid = parseScriptUniqueID(uniqueId);
+        if (auto result = GMLIB_Scoreboard::getInstance()->getScore(obj, auid)) {
+            return result.value();
+        }
+        return 0;
+    });
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "addEntityScore",
+        [](std::string const& uniqueId, std::string const& obj, int value) -> bool {
+            auto auid = parseScriptUniqueID(uniqueId);
+            if (auto res = GMLIB_Scoreboard::getInstance()->setScore(obj, auid, value, PlayerScoreSetFunction::Add)) {
+                return true;
+            }
+            return false;
+        }
+    );
     RemoteCall::exportAs(
         "GMLIB_API",
         "reduceEntityScore",
-        [](std::string uniqueId, std::string obj, int value) -> bool {
+        [](std::string const& uniqueId, std::string const& obj, int value) -> bool {
             auto auid = parseScriptUniqueID(uniqueId);
             if (auto res =
                     GMLIB_Scoreboard::getInstance()->setScore(obj, auid, value, PlayerScoreSetFunction::Subtract)) {
@@ -272,43 +326,59 @@ void Export_Compatibility_API() {
             return false;
         }
     );
-    RemoteCall::exportAs("GMLIB_API", "setEntityScore", [](std::string uniqueId, std::string obj, int value) -> bool {
+    RemoteCall::exportAs(
-        auto auid = parseScriptUniqueID(uniqueId);
+        "GMLIB_API",
-        if (auto res = GMLIB_Scoreboard::getInstance()->setScore(obj, auid, value)) {
+        "setEntityScore",
-            return true;
+        [](std::string const& uniqueId, std::string const& obj, int value) -> bool {
+            auto auid = parseScriptUniqueID(uniqueId);
+            if (auto res = GMLIB_Scoreboard::getInstance()->setScore(obj, auid, value)) {
+                return true;
+            }
+            return false;
         }
-        return false;
+    );
-    });
+    RemoteCall::exportAs(
-    RemoteCall::exportAs("GMLIB_API", "resetEntityScore", [](std::string uniqueId, std::string obj) -> bool {
+        "GMLIB_API",
-        auto auid = parseScriptUniqueID(uniqueId);
+        "resetEntityScore",
-        return GMLIB_Scoreboard::getInstance()->resetScore(obj, auid);
+        [](std::string const& uniqueId, std::string const& obj) -> bool {
-    });
+            auto auid = parseScriptUniqueID(uniqueId);
-    RemoteCall::exportAs("GMLIB_API", "resetEntityScores", [](std::string uniqueId) -> bool {
+            return GMLIB_Scoreboard::getInstance()->resetScore(obj, auid);
+        }
+    );
+    RemoteCall::exportAs("GMLIB_API", "resetEntityScores", [](std::string const& uniqueId) -> bool {
         auto auid = parseScriptUniqueID(uniqueId);
         return GMLIB_Scoreboard::getInstance()->resetScore(auid);
     });
-    RemoteCall::exportAs("GMLIB_API", "fakePlayerHasScore", [](std::string name, std::string obj) -> bool {
+    RemoteCall::exportAs(
-        if (auto result = GMLIB_Scoreboard::getInstance()->getScore(obj, name)) {
+        "GMLIB_API",
-            return true;
+        "fakePlayerHasScore",
+        [](std::string const& name, std::string const& obj) -> bool {
+            if (auto result = GMLIB_Scoreboard::getInstance()->getScore(obj, name)) {
+                return true;
+            }
+            return false;
         }
-        return false;
+    );
-    });
+    RemoteCall::exportAs("GMLIB_API", "getFakePlayerScore", [](std::string const& name, std::string const& obj) -> int {
-    RemoteCall::exportAs("GMLIB_API", "getFakePlayerScore", [](std::string name, std::string obj) -> int {
         if (auto result = GMLIB_Scoreboard::getInstance()->getScore(obj, name)) {
             return result.value();
         }
         return 0;
     });
-    RemoteCall::exportAs("GMLIB_API", "addFakePlayerScore", [](std::string name, std::string obj, int value) -> bool {
+    RemoteCall::exportAs(
-        if (auto res = GMLIB_Scoreboard::getInstance()->setScore(obj, name, value, PlayerScoreSetFunction::Add)) {
+        "GMLIB_API",
-            return true;
+        "addFakePlayerScore",
+        [](std::string const& name, std::string const& obj, int value) -> bool {
+            if (auto res = GMLIB_Scoreboard::getInstance()->setScore(obj, name, value, PlayerScoreSetFunction::Add)) {
+                return true;
+            }
+            return false;
         }
-        return false;
+    );
-    });
     RemoteCall::exportAs(
         "GMLIB_API",
         "reduceFakePlayerScore",
-        [](std::string name, std::string obj, int value) -> bool {
+        [](std::string const& name, std::string const& obj, int value) -> bool {
             if (auto res =
                     GMLIB_Scoreboard::getInstance()->setScore(obj, name, value, PlayerScoreSetFunction::Subtract)) {
                 return true;
@@ -316,20 +386,28 @@ void Export_Compatibility_API() {
             return false;
         }
     );
-    RemoteCall::exportAs("GMLIB_API", "setFakePlayerScore", [](std::string name, std::string obj, int value) -> bool {
+    RemoteCall::exportAs(
-        if (auto res = GMLIB_Scoreboard::getInstance()->setScore(obj, name, value)) {
+        "GMLIB_API",
-            return true;
+        "setFakePlayerScore",
+        [](std::string const& name, std::string const& obj, int value) -> bool {
+            if (auto res = GMLIB_Scoreboard::getInstance()->setScore(obj, name, value)) {
+                return true;
+            }
+            return false;
         }
-        return false;
+    );
-    });
+    RemoteCall::exportAs(
-    RemoteCall::exportAs("GMLIB_API", "resetFakePlayerScore", [](std::string name, std::string obj) -> bool {
+        "GMLIB_API",
-        return GMLIB_Scoreboard::getInstance()->resetScore(obj, name);
+        "resetFakePlayerScore",
-    });
+        [](std::string const& name, std::string const& obj) -> bool {
-    RemoteCall::exportAs("GMLIB_API", "resetFakePlayerScores", [](std::string name) -> bool {
+            return GMLIB_Scoreboard::getInstance()->resetScore(obj, name);
+        }
+    );
+    RemoteCall::exportAs("GMLIB_API", "resetFakePlayerScores", [](std::string const& name) -> bool {
         return GMLIB_Scoreboard::getInstance()->resetScore(name);
     });
-    RemoteCall::exportAs("GMLIB_API", "addObjective", [](std::string obj) -> bool {
+    RemoteCall::exportAs("GMLIB_API", "addObjective", [](std::string const& obj) -> bool {
-        if (auto res = GMLIB_Scoreboard::getInstance()->getInstance()->addObjective(obj)) {
+        if (auto res = GMLIB_Scoreboard::getInstance()->addObjective(obj)) {
             return true;
         }
         return false;
@@ -337,45 +415,49 @@ void Export_Compatibility_API() {
     RemoteCall::exportAs(
         "GMLIB_API",
         "addObjectiveWithDisplayName",
-        [](std::string obj, std::string displayName) -> bool {
+        [](std::string const& obj, std::string const& displayName) -> bool {
-            if (auto res = GMLIB_Scoreboard::getInstance()->getInstance()->addObjective(obj, displayName)) {
+            if (auto res = GMLIB_Scoreboard::getInstance()->addObjective(obj, displayName)) {
                 return true;
             }
             return false;
         }
     );
-    RemoteCall::exportAs("GMLIB_API", "getDisplayName", [](std::string obj) -> std::string {
+    RemoteCall::exportAs("GMLIB_API", "getDisplayName", [](std::string const& obj) -> std::string {
-        if (auto result = GMLIB_Scoreboard::getInstance()->getInstance()->getObjectiveDisplayName(obj)) {
+        if (auto result = GMLIB_Scoreboard::getInstance()->getObjectiveDisplayName(obj)) {
             return result.value();
         }
         return "";
     });
-    RemoteCall::exportAs("GMLIB_API", "setDisplayName", [](std::string obj, std::string displayName) -> bool {
+    RemoteCall::exportAs(
-        return GMLIB_Scoreboard::getInstance()->getInstance()->setObjectiveDisplayName(obj, displayName);
+        "GMLIB_API",
+        "setDisplayName",
+        [](std::string const& obj, std::string const& displayName) -> bool {
+            return GMLIB_Scoreboard::getInstance()->setObjectiveDisplayName(obj, displayName);
+        }
+    );
+    RemoteCall::exportAs("GMLIB_API", "removeObjective", [](std::string const& obj) -> bool {
+        return GMLIB_Scoreboard::getInstance()->removeObjective(obj);
     });
-    RemoteCall::exportAs("GMLIB_API", "removeObjective", [](std::string obj) -> bool {
+    RemoteCall::exportAs(
-        return GMLIB_Scoreboard::getInstance()->getInstance()->removeObjective(obj);
+        "GMLIB_API",
-    });
+        "setDisplayObjective",
-    RemoteCall::exportAs("GMLIB_API", "setDisplayObjective", [](std::string obj, std::string slot, int order) -> void {
+        [](std::string const& obj, std::string const& slot, int order) -> void {
-        return GMLIB_Scoreboard::getInstance()->getInstance()->setObjectiveDisplay(
+            return GMLIB_Scoreboard::getInstance()->setObjectiveDisplay(obj, slot, (ObjectiveSortOrder)order);
-            obj,
+        }
-            slot,
+    );
-            (ObjectiveSortOrder)order
+    RemoteCall::exportAs("GMLIB_API", "clearDisplayObjective", [](std::string const& slot) -> void {
-        );
+        return GMLIB_Scoreboard::getInstance()->clearObjectiveDisplay(slot);
-    });
-    RemoteCall::exportAs("GMLIB_API", "clearDisplayObjective", [](std::string slot) -> void {
-        return GMLIB_Scoreboard::getInstance()->getInstance()->clearObjectiveDisplay(slot);
     });
     RemoteCall::exportAs("GMLIB_API", "getAllObjectives", []() -> std::vector<std::string> {
-        auto                     objs = GMLIB_Scoreboard::getInstance()->getInstance()->getObjectives();
+        auto                     objs = GMLIB_Scoreboard::getInstance()->getObjectives();
         std::vector<std::string> result;
-        for (auto obj : objs) {
+        for (auto& obj : objs) {
             result.push_back(obj->getName());
         }
         return result;
     });
     RemoteCall::exportAs("GMLIB_API", "getAllScoreboardPlayers", []() -> std::vector<std::string> {
-        auto                     uuids = GMLIB_Scoreboard::getInstance()->getInstance()->getAllPlayerUuids();
+        auto                     uuids = GMLIB_Scoreboard::getInstance()->getAllPlayerUuids();
         std::vector<std::string> result;
         for (auto& uuid : uuids) {
             result.push_back(uuid.asString());
@@ -383,30 +465,59 @@ void Export_Compatibility_API() {
         return result;
     });
     RemoteCall::exportAs("GMLIB_API", "getAllScoreboardFakePlayers", []() -> std::vector<std::string> {
-        auto                     names = GMLIB_Scoreboard::getInstance()->getInstance()->getAllFakePlayers();
+        auto                     names = GMLIB_Scoreboard::getInstance()->getAllFakePlayers();
         std::vector<std::string> result;
-        for (auto name : names) {
+        for (auto& name : names) {
             result.push_back(name);
         }
         return result;
     });
     RemoteCall::exportAs("GMLIB_API", "getAllScoreboardEntities", []() -> std::vector<std::string> {
-        auto                     auids = GMLIB_Scoreboard::getInstance()->getInstance()->getAllEntities();
+        auto                     uniqueIds = GMLIB_Scoreboard::getInstance()->getAllEntities();
         std::vector<std::string> result;
-        for (auto auid : auids) {
+        for (auto& uniqueId : uniqueIds) {
-            result.push_back(std::to_string(auid.get()));
+            result.push_back(std::to_string(uniqueId.id));
         }
         return result;
     });
-    RemoteCall::exportAs("GMLIB_API", "getPlayerFromUuid", [](std::string uuid) -> Player* {
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "getAllTrackedTargets",
+        []() -> std::vector<std::unordered_map<std::string, std::string>> {
+            std::vector<std::unordered_map<std::string, std::string>> result;
+            auto uuids = GMLIB_Scoreboard::getInstance()->getAllPlayerUuids();
+            for (auto& uuid : uuids) {
+                std::unordered_map<std::string, std::string> data;
+                data["Type"] = "Player";
+                data["Uuid"] = uuid.asString();
+                result.push_back(data);
+            }
+            auto names = GMLIB_Scoreboard::getInstance()->getAllFakePlayers();
+            for (auto& name : names) {
+                std::unordered_map<std::string, std::string> data;
+                data["Type"] = "FakePlayer";
+                data["Name"] = name;
+                result.push_back(data);
+            }
+            auto uniqueIds = GMLIB_Scoreboard::getInstance()->getAllEntities();
+            for (auto& uniqueId : uniqueIds) {
+                std::unordered_map<std::string, std::string> data;
+                data["Type"]     = "Entity";
+                data["UniqueId"] = std::to_string(uniqueId.id);
+                result.push_back(data);
+            }
+            return result;
+        }
+    );
+    RemoteCall::exportAs("GMLIB_API", "getPlayerFromUuid", [](std::string const& uuid) -> Player* {
         auto uid = mce::UUID::fromString(uuid);
         return ll::service::getLevel()->getPlayer(uuid);
     });
-    RemoteCall::exportAs("GMLIB_API", "getPlayerFromUniqueId", [](std::string uniqueId) -> Actor* {
+    RemoteCall::exportAs("GMLIB_API", "getPlayerFromUniqueId", [](std::string const& uniqueId) -> Actor* {
         auto auid = parseScriptUniqueID(uniqueId);
         return ll::service::getLevel()->getPlayer(auid);
     });
-    RemoteCall::exportAs("GMLIB_API", "getEntityFromUniqueId", [](std::string uniqueId) -> Actor* {
+    RemoteCall::exportAs("GMLIB_API", "getEntityFromUniqueId", [](std::string const& uniqueId) -> Actor* {
         auto auid = parseScriptUniqueID(uniqueId);
         return ll::service::getLevel()->fetchEntity(auid);
     });
@@ -433,4 +544,138 @@ void Export_Compatibility_API() {
         auto player = (GMLIB_Player*)pl;
         player->clearSpawnPoint();
     });
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "mergePatchJson",
+        [](std::string const& oldJson, std::string const& patchJson) -> std::string {
+            auto oldData = nlohmann::ordered_json::parse(oldJson);
+            auto newData = nlohmann::ordered_json::parse(patchJson);
+            oldData.merge_patch(newData);
+            return oldData.dump();
+        }
+    );
+    RemoteCall::exportAs("GMLIB_API", "getXuidByUuid", [](std::string const& uuid) -> std::string {
+        auto uid    = mce::UUID::fromString(uuid);
+        auto result = UserCache::getXuidByUuid(uid);
+        return result ? result.value() : "";
+    });
+    RemoteCall::exportAs("GMLIB_API", "getNameByUuid", [](std::string const& uuid) -> std::string {
+        auto uid    = mce::UUID::fromString(uuid);
+        auto result = UserCache::getNameByUuid(uid);
+        return result ? result.value() : "";
+    });
+    RemoteCall::exportAs("GMLIB_API", "getUuidByXuid", [](std::string const& xuid) -> std::string {
+        auto result = UserCache::getUuidByXuid(xuid);
+        return result ? result.value().asString() : "";
+    });
+    RemoteCall::exportAs("GMLIB_API", "getNameByXuid", [](std::string const& xuid) -> std::string {
+        auto result = UserCache::getNameByXuid(xuid);
+        return result ? result.value() : "";
+    });
+    RemoteCall::exportAs("GMLIB_API", "getXuidByName", [](std::string const& name) -> std::string {
+        auto result = UserCache::getXuidByName(name);
+        return result ? result.value() : "";
+    });
+    RemoteCall::exportAs("GMLIB_API", "getUuidByName", [](std::string const& name) -> std::string {
+        auto result = UserCache::getUuidByName(name);
+        return result ? result.value().asString() : "";
+    });
+    RemoteCall::exportAs("GMLIB_API", "getUuidByName", [](std::string const& name) -> std::string {
+        auto result = UserCache::getUuidByName(name);
+        return result ? result.value().asString() : "";
+    });
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "getAllPlayerInfo",
+        []() -> std::vector<std::unordered_map<std::string, std::string>> {
+            std::vector<std::unordered_map<std::string, std::string>> result;
+            UserCache::forEach([&result](const UserCache::UserCacheEntry& entry) {
+                std::unordered_map<std::string, std::string> info;
+                info["Name"] = entry.mName;
+                info["Xuid"] = entry.mXuid;
+                info["Uuid"] = entry.mUuid.asString();
+                result.push_back(info);
+            });
+            return result;
+        }
+    );
+    RemoteCall::exportAs("GMLIB_API", "getBlockRuntimeId", [](std::string const& blockName) -> uint {
+        if (auto block = Block::tryGetFromRegistry(blockName)) {
+            return block->getRuntimeId();
+        }
+        return 0;
+    });
+    RemoteCall::exportAs("GMLIB_API", "getBlockTranslateKey", [](Block const* block) -> std::string {
+        return block->buildDescriptionId();
+    });
+    RemoteCall::exportAs("GMLIB_API", "getItemTranslateKey", [](ItemStack* item) -> std::string {
+        return item->getDescriptionId();
+    });
+    RemoteCall::exportAs("GMLIB_API", "getEntityTranslateKey", [](Actor* entity) -> std::string {
+        return entity->getEntityLocNameString();
+    });
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "readNbtFromFile",
+        [](std::string const& path, bool isBinary) -> std::unique_ptr<CompoundTag> {
+            if (auto nbt = GMLIB_CompoundTag::readFromFile(path, isBinary)) {
+                return std::make_unique<CompoundTag>(nbt.value());
+            }
+            return nullptr;
+        }
+    );
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "saveNbtToFile",
+        [](std::string const& path, CompoundTag* nbt, bool isBinary) -> bool {
+            return GMLIB_CompoundTag::saveToFile(path, *nbt, isBinary);
+        }
+    );
+    RemoteCall::exportAs("GMLIB_API", "getBlockDestroySpeed", [](Block const* block) -> float {
+        return block->getDestroySpeed();
+    });
+    RemoteCall::exportAs("GMLIB_API", "getDestroyBlockSpeed", [](ItemStack const* item, Block const* block) -> float {
+        return item->getDestroySpeed(*block);
+    });
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "playerDestroyBlock",
+        [](Block const* block, std::pair<BlockPos, int> pos, Player* player) -> void {
+            return block->playerDestroy(*player, pos.first);
+        }
+    );
+    RemoteCall::exportAs("GMLIB_API", "itemCanDestroyBlock", [](ItemStack const* item, Block const* block) -> bool {
+        return item->canDestroy(block);
+    });
+    RemoteCall::exportAs("GMLIB_API", "itemCanDestroyInCreative", [](ItemStack const* item) -> bool {
+        return item->getItem()->canDestroyInCreative();
+    });
+    RemoteCall::exportAs("GMLIB_API", "itemCanDestroySpecial", [](ItemStack const* item, Block const* block) -> bool {
+        return item->canDestroySpecial(*block);
+    });
+    RemoteCall::exportAs("GMLIB_API", "blockCanDropWithAnyTool", [](Block const* block) -> bool {
+        return block->canDropWithAnyTool();
+    });
+    RemoteCall::exportAs("GMLIB_API", "blockIsAlwaysDestroyable", [](Block const* block) -> bool {
+        return block->getMaterial().isAlwaysDestroyable();
+    });
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "blockPlayerWillDestroy",
+        [](Block const* block, Player* player, std::pair<BlockPos, int> pos) -> bool {
+            return block->playerWillDestroy(*player, pos.first);
+        }
+    );
+    RemoteCall::exportAs("GMLIB_API", "playerAttack", [](Player* player, Actor* entity) -> bool {
+        return player->attack(*entity, ActorDamageCause::EntityAttack);
+    });
+    RemoteCall::exportAs("GMLIB_API", "playerPullInEntity", [](Player* player, Actor* entity) -> bool {
+        return player->pullInEntity(*entity);
+    });
+    RemoteCall::exportAs("GMLIB_API", "getBlockTranslateKeyFromName", [](std::string const& blockName) -> std::string {
+        if (auto block = Block::tryGetFromRegistry(blockName)) {
+            return block->buildDescriptionId();
+        }
+        return "tile.unknown.name";
+    });
 }

src/Entry.cpp

@@ -3,30 +3,34 @@
 
 ll::Logger logger(PLUGIN_NAME);
 
-namespace GMLIB_LegacyRemoteCallApi {
+namespace GMLIB {
 
-std::unique_ptr<LRCA>& LRCA::getInstance() {
+std::unique_ptr<LegacyRemoteCallApi>& LegacyRemoteCallApi::getInstance() {
-    static std::unique_ptr<LRCA> instance;
+    static std::unique_ptr<LegacyRemoteCallApi> instance;
     return instance;
 }
 
-bool LRCA::load() {
+bool LegacyRemoteCallApi::load() {
     Export_Legacy_GMLib_ModAPI();
     Export_Legacy_GMLib_ServerAPI();
     Export_Compatibility_API();
     ExportPAPI();
     Export_Event_API();
     logger.info("GMLIB-LegacyRemoteCallApi Loaded!");
-    logger.info("Version: {}", LIB_VERSION.asString());
+    logger.info(
+        "Loaded Version: {} with {}",
+        fmt::format(fg(fmt::color::pink), "GMLIB-" + Version::getLibVersionString()),
+        fmt::format(fg(fmt::color::light_green), "GMLIB-LegacyRemoteCallApi-" + LIB_VERSION.asString())
+    );
     logger.info("Author: GroupMountain");
     logger.info("Repository: https://github.com/GroupMountain/GMLIB-LegacyRemoteCallApi");
     return true;
 }
 
-bool LRCA::enable() { return true; }
+bool LegacyRemoteCallApi::enable() { return true; }
 
-bool LRCA::disable() { return true; }
+bool LegacyRemoteCallApi::disable() { return true; }
 
-} // namespace GMLIB_LegacyRemoteCallApi
+} // namespace GMLIB
 
-LL_REGISTER_PLUGIN(GMLIB_LegacyRemoteCallApi::LRCA, GMLIB_LegacyRemoteCallApi::LRCA::getInstance());
+LL_REGISTER_PLUGIN(LegacyRemoteCallApi, LegacyRemoteCallApi::getInstance());

src/Entry.h

@@ -2,14 +2,14 @@
 #include <ll/api/plugin/NativePlugin.h>
 #include <ll/api/plugin/RegisterHelper.h>
 
-namespace GMLIB_LegacyRemoteCallApi {
+namespace GMLIB {
 
-class LRCA {
+class LegacyRemoteCallApi {
 
 public:
-    static std::unique_ptr<LRCA>& getInstance();
+    static std::unique_ptr<LegacyRemoteCallApi>& getInstance();
 
-    LRCA(ll::plugin::NativePlugin& self) : mSelf(self) {}
+    LegacyRemoteCallApi(ll::plugin::NativePlugin& self) : mSelf(self) {}
 
     [[nodiscard]] ll::plugin::NativePlugin& getSelf() const { return mSelf; }
 
@@ -30,4 +30,4 @@ private:
     ll::plugin::NativePlugin& mSelf;
 };
 
-} // namespace GMLIB_LegacyRemoteCallApi
+} // namespace GMLIB

src/EventAPI.cpp

@@ -6,17 +6,18 @@ void Export_Event_API() {
     RemoteCall::exportAs(
         "GMLIB_API",
         "callCustomEvent",
-        [eventBus](std::string eventName, std::string eventId) -> bool {
+        [eventBus](std::string const& eventName, std::string const& eventId) -> bool {
             if (RemoteCall::hasFunc(eventName, eventId)) {
                 switch (doHash(eventName)) {
                 case doHash("onClientLogin"): {
-                    auto Call = RemoteCall::importAs<
+                    auto Call = RemoteCall::importAs<bool(
-                        bool(std::string realName, std::string uuid, std::string serverXuid, std::string clientXuid)>(
+                        std::string const& realName,
-                        eventName,
+                        std::string const& uuid,
-                        eventId
+                        std::string const& serverXuid,
-                    );
+                        std::string const& clientXuid
-                    eventBus->emplaceListener<GMLIB::Event::PacketEvent::ClientLoginAfterEvent>(
+                    )>(eventName, eventId);
-                        [Call](GMLIB::Event::PacketEvent::ClientLoginAfterEvent& ev) {
+                    eventBus->emplaceListener<Event::PacketEvent::ClientLoginAfterEvent>(
+                        [Call](Event::PacketEvent::ClientLoginAfterEvent& ev) {
                             try {
                                 Call(
                                     ev.getRealName(),
@@ -35,8 +36,8 @@ void Export_Event_API() {
                             eventName,
                             eventId
                         );
-                    eventBus->emplaceListener<GMLIB::Event::LevelEvent::WeatherUpdateBeforeEvent>(
+                    eventBus->emplaceListener<Event::LevelEvent::WeatherUpdateBeforeEvent>(
-                        [Call](GMLIB::Event::LevelEvent::WeatherUpdateBeforeEvent& ev) {
+                        [Call](Event::LevelEvent::WeatherUpdateBeforeEvent& ev) {
                             bool result = true;
                             try {
                                 result = Call(
@@ -55,8 +56,8 @@ void Export_Event_API() {
                 }
                 case doHash("onMobPick"): {
                     auto Call = RemoteCall::importAs<bool(Actor * mob, Actor * item)>(eventName, eventId);
-                    eventBus->emplaceListener<GMLIB::Event::EntityEvent::MobPickupItemBeforeEvent>(
+                    eventBus->emplaceListener<Event::EntityEvent::MobPickupItemBeforeEvent>(
-                        [Call](GMLIB::Event::EntityEvent::MobPickupItemBeforeEvent& ev) {
+                        [Call](Event::EntityEvent::MobPickupItemBeforeEvent& ev) {
                             bool result = true;
                             try {
                                 result = Call(&ev.self(), (Actor*)&ev.getItemActor());
@@ -71,8 +72,8 @@ void Export_Event_API() {
                 case doHash("onItemTrySpawn"): {
                     auto Call = RemoteCall::importAs<
                         bool(const ItemStack* item, std::pair<Vec3, int> position, Actor* spawner)>(eventName, eventId);
-                    eventBus->emplaceListener<GMLIB::Event::EntityEvent::ItemActorSpawnBeforeEvent>(
+                    eventBus->emplaceListener<Event::EntityEvent::ItemActorSpawnBeforeEvent>(
-                        [Call](GMLIB::Event::EntityEvent::ItemActorSpawnBeforeEvent& ev) {
+                        [Call](Event::EntityEvent::ItemActorSpawnBeforeEvent& ev) {
                             auto                 pos    = ev.getPosition();
                             auto                 dimid  = ev.getBlockSource().getDimensionId().id;
                             std::pair<Vec3, int> lsePos = {pos, dimid};
@@ -93,8 +94,8 @@ void Export_Event_API() {
                         eventName,
                         eventId
                     );
-                    eventBus->emplaceListener<GMLIB::Event::EntityEvent::ItemActorSpawnAfterEvent>(
+                    eventBus->emplaceListener<Event::EntityEvent::ItemActorSpawnAfterEvent>(
-                        [Call](GMLIB::Event::EntityEvent::ItemActorSpawnAfterEvent& ev) {
+                        [Call](Event::EntityEvent::ItemActorSpawnAfterEvent& ev) {
                             auto                 pos    = ev.getPosition();
                             auto                 dimid  = ev.getBlockSource().getDimensionId().id;
                             std::pair<Vec3, int> lsePos = {pos, dimid};
@@ -107,8 +108,8 @@ void Export_Event_API() {
                 }
                 case doHash("onEntityChangeDim"): {
                     auto Call = RemoteCall::importAs<bool(Actor * entity, int toDimId)>(eventName, eventId);
-                    eventBus->emplaceListener<GMLIB::Event::EntityEvent::ActorChangeDimensionBeforeEvent>(
+                    eventBus->emplaceListener<Event::EntityEvent::ActorChangeDimensionBeforeEvent>(
-                        [Call](GMLIB::Event::EntityEvent::ActorChangeDimensionBeforeEvent& ev) {
+                        [Call](Event::EntityEvent::ActorChangeDimensionBeforeEvent& ev) {
                             bool result = true;
                             try {
                                 result = Call(&ev.self(), ev.getToDimensionId());
@@ -122,8 +123,8 @@ void Export_Event_API() {
                 }
                 case doHash("onLeaveBed"): {
                     auto Call = RemoteCall::importAs<bool(Player * pl)>(eventName, eventId);
-                    eventBus->emplaceListener<GMLIB::Event::PlayerEvent::PlayerStopSleepBeforeEvent>(
+                    eventBus->emplaceListener<Event::PlayerEvent::PlayerStopSleepBeforeEvent>(
-                        [Call](GMLIB::Event::PlayerEvent::PlayerStopSleepBeforeEvent& ev) {
+                        [Call](Event::PlayerEvent::PlayerStopSleepBeforeEvent& ev) {
                             bool result = true;
                             try {
                                 result = Call(&ev.self());
@@ -136,12 +137,13 @@ void Export_Event_API() {
                     return true;
                 }
                 case doHash("onDeathMessage"): {
-                    auto Call = RemoteCall::importAs<bool(std::string message, std::vector<std::string>, Actor * dead)>(
+                    auto Call =
-                        eventName,
+                        RemoteCall::importAs<bool(std::string const& message, std::vector<std::string>, Actor* dead)>(
-                        eventId
+                            eventName,
-                    );
+                            eventId
-                    eventBus->emplaceListener<GMLIB::Event::EntityEvent::DeathMessageAfterEvent>(
+                        );
-                        [Call](GMLIB::Event::EntityEvent::DeathMessageAfterEvent& ev) {
+                    eventBus->emplaceListener<Event::EntityEvent::DeathMessageAfterEvent>(
+                        [Call](Event::EntityEvent::DeathMessageAfterEvent& ev) {
                             auto msg    = ev.getDeathMessage();
                             auto source = ev.getDamageSource();
                             try {
@@ -156,8 +158,8 @@ void Export_Event_API() {
                         eventName,
                         eventId
                     );
-                    eventBus->emplaceListener<GMLIB::Event::EntityEvent::MobHurtAfterEvent>(
+                    eventBus->emplaceListener<Event::EntityEvent::MobHurtAfterEvent>(
-                        [Call](GMLIB::Event::EntityEvent::MobHurtAfterEvent& ev) {
+                        [Call](Event::EntityEvent::MobHurtAfterEvent& ev) {
                             auto&  damageSource = ev.getSource();
                             Actor* source       = nullptr;
                             if (damageSource.isEntitySource()) {
@@ -174,6 +176,21 @@ void Export_Event_API() {
                     );
                     return true;
                 }
+                case doHash("onEndermanTake"): {
+                    auto Call = RemoteCall::importAs<bool(Actor * mob)>(eventName, eventId);
+                    eventBus->emplaceListener<Event::EntityEvent::EndermanTakeBlockBeforeEvent>(
+                        [Call](Event::EntityEvent::EndermanTakeBlockBeforeEvent& ev) {
+                            bool result = true;
+                            try {
+                                result = Call(&ev.self());
+                            } catch (...) {}
+                            if (!result) {
+                                ev.cancel();
+                            }
+                        }
+                    );
+                    return true;
+                }
                 default:
                     return false;
                 }

src/Global.h

@@ -3,8 +3,17 @@
 
 #include <RemoteCallAPI.h>
 
-#define PLUGIN_NAME "GMLIB-LRCA"
+using namespace GMLIB;
-#define LIB_VERSION GMLIB::Version(0, 10, 1)
+using namespace Server;
+using namespace Mod;
+
+#define PLUGIN_NAME fmt::format(fg(fmt::color::light_green), "GMLIB-LRCA")
+
+#define LIB_VERSION_MAJOR 0
+#define LIB_VERSION_MINOR 12
+#define LIB_VERSION_PATCH 8
+
+#define LIB_VERSION Version(LIB_VERSION_MAJOR, LIB_VERSION_MINOR, LIB_VERSION_PATCH)
 
 extern ll::Logger logger;
 

src/LegacyModApi.cpp

@@ -2,7 +2,7 @@
 
 std::unordered_set<std::string> HardCodedKeys = {"AlwaysUnlocked", "PlayerHasManyItems", "PlayerInWater", "None"};
 
-std::variant<std::string, std::vector<RecipeIngredient>> makeRecipeUnlockingKey(std::string& key) {
+std::variant<std::string, std::vector<RecipeIngredient>> makeRecipeUnlockingKey(std::string const& key) {
     if (HardCodedKeys.count(key)) {
         return key;
     }
@@ -17,11 +17,11 @@ void Export_Legacy_GMLib_ModAPI() {
     RemoteCall::exportAs(
         "GMLib_ModAPI",
         "registerShapelessRecipe",
-        [](std::string              recipe_id,
+        [](std::string const&       recipe_id,
            std::vector<std::string> ingredients,
-           std::string              result,
+           std::string const&       result,
            int                      count,
-           std::string              unlock) -> void {
+           std::string const&       unlock) -> void {
             auto level = GMLIB_Level::getInstance();
             if (!level) {
                 return;
@@ -33,18 +33,18 @@ void Export_Legacy_GMLib_ModAPI() {
             }
             auto res = RecipeIngredient(result, 0, count);
             auto unl = makeRecipeUnlockingKey(unlock);
-            GMLIB::Mod::JsonRecipe::registerShapelessCraftingTableRecipe(recipe_id, types, res, unl);
+            JsonRecipe::registerShapelessCraftingTableRecipe(recipe_id, types, res, unl);
         }
     );
     RemoteCall::exportAs(
         "GMLib_ModAPI",
         "registerShapedRecipe",
-        [](std::string              recipe_id,
+        [](std::string const&       recipe_id,
            std::vector<std::string> shape,
            std::vector<std::string> ingredients,
-           std::string              result,
+           std::string const&       result,
            int                      count,
-           std::string              unlock) -> void {
+           std::string const&       unlock) -> void {
             auto level = GMLIB_Level::getInstance();
             if (!level) {
                 return;
@@ -56,38 +56,43 @@ void Export_Legacy_GMLib_ModAPI() {
             }
             auto res = RecipeIngredient(result, 0, count);
             auto unl = makeRecipeUnlockingKey(unlock);
-            GMLIB::Mod::JsonRecipe::registerShapedCraftingTableRecipe(recipe_id, shape, types, res, unl);
+            JsonRecipe::registerShapedCraftingTableRecipe(recipe_id, shape, types, res, unl);
         }
     );
     RemoteCall::exportAs(
         "GMLib_ModAPI",
         "registerFurnaceRecipe",
-        [](std::string recipe_id, std::string input, std::string output, std::vector<std::string> tags) -> void {
+        [](std::string const&       recipe_id,
+           std::string const&       input,
+           std::string const&       output,
+           std::vector<std::string> tags) -> void {
             auto level = GMLIB_Level::getInstance();
             if (!level) {
                 return;
             }
             auto inp  = RecipeIngredient(input, 0, 1);
             auto outp = RecipeIngredient(output, 0, 1);
-            GMLIB::Mod::JsonRecipe::registerFurnaceRecipe(recipe_id, inp, outp, tags);
+            JsonRecipe::registerFurnaceRecipe(recipe_id, inp, outp, tags);
         }
     );
     RemoteCall::exportAs(
         "GMLib_ModAPI",
         "registerBrewingMixRecipe",
-        [](std::string recipe_id, std::string input, std::string output, std::string reagent) -> void {
+        [](std::string const& recipe_id, std::string const& input, std::string const& output, std::string const& reagent
+        ) -> void {
             auto level = GMLIB_Level::getInstance();
             if (!level) {
                 return;
             }
             auto rea = RecipeIngredient(reagent, 0, 1);
-            GMLIB::Mod::JsonRecipe::registerBrewingMixRecipe(recipe_id, input, output, rea);
+            JsonRecipe::registerBrewingMixRecipe(recipe_id, input, output, rea);
         }
     );
     RemoteCall::exportAs(
         "GMLib_ModAPI",
         "registerBrewingContainerRecipe",
-        [](std::string recipe_id, std::string input, std::string output, std::string reagent) -> void {
+        [](std::string const& recipe_id, std::string const& input, std::string const& output, std::string const& reagent
+        ) -> void {
             auto level = GMLIB_Level::getInstance();
             if (!level) {
                 return;
@@ -95,22 +100,22 @@ void Export_Legacy_GMLib_ModAPI() {
             auto inp  = RecipeIngredient(input, 0, 1);
             auto outp = RecipeIngredient(output, 0, 1);
             auto rea  = RecipeIngredient(reagent, 0, 1);
-            GMLIB::Mod::JsonRecipe::registerBrewingContainerRecipe(recipe_id, inp, outp, rea);
+            JsonRecipe::registerBrewingContainerRecipe(recipe_id, inp, outp, rea);
         }
     );
     RemoteCall::exportAs(
         "GMLib_ModAPI",
         "registerSmithingTransformRecipe",
-        [](std::string recipe_id,
+        [](std::string const& recipe_id,
-           std::string smithing_template,
+           std::string const& smithing_template,
-           std::string base,
+           std::string const& base,
-           std::string addition,
+           std::string const& addition,
-           std::string result) -> void {
+           std::string const& result) -> void {
             auto level = GMLIB_Level::getInstance();
             if (!level) {
                 return;
             }
-            GMLIB::Mod::JsonRecipe::registerSmithingTransformRecipe(
+            JsonRecipe::registerSmithingTransformRecipe(
                 recipe_id,
                 smithing_template,
                 base,
@@ -122,66 +127,72 @@ void Export_Legacy_GMLib_ModAPI() {
     RemoteCall::exportAs(
         "GMLib_ModAPI",
         "registerSmithingTrimRecipe",
-        [](std::string recipe_id, std::string smithing_template, std::string base, std::string addition) -> void {
+        [](std::string const& recipe_id,
+           std::string const& smithing_template,
+           std::string const& base,
+           std::string const& addition) -> void {
             auto level = GMLIB_Level::getInstance();
             if (!level) {
                 return;
             }
-            GMLIB::Mod::JsonRecipe::registerSmithingTrimRecipe(recipe_id, smithing_template, base, addition);
+            JsonRecipe::registerSmithingTrimRecipe(recipe_id, smithing_template, base, addition);
         }
     );
     RemoteCall::exportAs(
         "GMLib_ModAPI",
         "registerStoneCutterRecipe",
-        [](std::string recipe_id,
+        [](std::string const& recipe_id,
-           std::string input,
+           std::string const& input,
-           int         input_data,
+           int                input_data,
-           std::string output,
+           std::string const& output,
-           int         output_data,
+           int                output_data,
-           int         output_count) -> void {
+           int                output_count) -> void {
             auto level = GMLIB_Level::getInstance();
             if (!level) {
                 return;
             }
             auto inp  = RecipeIngredient(input, 0, 1);
             auto outp = RecipeIngredient(output, 0, 1);
-            GMLIB::Mod::JsonRecipe::registerStoneCutterRecipe(recipe_id, inp, outp);
+            JsonRecipe::registerStoneCutterRecipe(recipe_id, inp, outp);
         }
     );
     // 错误方块清理
     RemoteCall::exportAs("GMLib_ModAPI", "setUnknownBlockCleaner", []() -> void {
-        GMLIB::Mod::VanillaFix::setAutoCleanUnknownBlockEnabled();
+        VanillaFix::setAutoCleanUnknownBlockEnabled();
     });
     // 实验性
     RemoteCall::exportAs("GMLib_ModAPI", "registerExperimentsRequire", [](int experiment_id) -> void {
-        auto map = GMLIB_Level::getAllExperiments();
+        auto                               list = GMLIB_Level::getAllExperiments();
-        if (map.count(experiment_id)) {
+        std::unordered_set<AllExperiments> set(list.begin(), list.end());
+        if (set.contains((AllExperiments)experiment_id)) {
             GMLIB_Level::addExperimentsRequire((AllExperiments)experiment_id);
         } else {
             ll::Logger("Server").error("Experiment ID '{}' does not exist!", experiment_id);
         }
     });
     RemoteCall::exportAs("GMLib_ModAPI", "setExperimentEnabled", [](int experiment_id, bool value) -> void {
-        auto level = GMLIB_Level::getInstance();
+        if (GMLIB_Level::getInstance()) {
-        if (!level) {
+            auto                               list = GMLIB_Level::getAllExperiments();
-            return;
+            std::unordered_set<AllExperiments> set(list.begin(), list.end());
+            if (set.contains((AllExperiments)experiment_id)) {
+                GMLIB_Level::getInstance()->setExperimentEnabled(((AllExperiments)experiment_id), value);
+            } else ll::Logger("Server").error("Experiment ID '{}' does not exist!", experiment_id);
         }
-        auto map = GMLIB_Level::getAllExperiments();
-        if (map.count(experiment_id)) {
-            GMLIB_Level::getInstance()->setExperimentEnabled(((AllExperiments)experiment_id), value);
-        } else ll::Logger("Server").error("Experiment ID '{}' does not exist!", experiment_id);
     });
     RemoteCall::exportAs("GMLib_ModAPI", "getExperimentEnabled", [](int experiment_id) -> bool {
-        auto level = GMLIB_Level::getInstance();
+        if (GMLIB_Level::getInstance()) {
-        if (!level) {
+            auto                               list = GMLIB_Level::getAllExperiments();
-            return false;
+            std::unordered_set<AllExperiments> set(list.begin(), list.end());
-        }
+            if (set.contains((AllExperiments)experiment_id)) {
-        auto map = GMLIB_Level::getAllExperiments();
+                return GMLIB_Level::getInstance()->getExperimentEnabled(((AllExperiments)experiment_id));
-        if (map.count(experiment_id)) {
+            } else {
-            return GMLIB_Level::getInstance()->getExperimentEnabled(((AllExperiments)experiment_id));
+                ll::Logger("Server").error("Experiment ID '{}' does not exist!", experiment_id);
-        } else {
+                return false;
-            ll::Logger("Server").error("Experiment ID '{}' does not exist!", experiment_id);
+            }
-            return false;
         }
+        return false;
+    });
+    RemoteCall::exportAs("GMLib_ModAPI", "setFixI18nEnabled", []() -> void {
+        VanillaFix::setFixI18nEnabled();
     });
 }

src/LegacyServerApi.cpp

@@ -1,41 +1,52 @@
+#include "GMLIB/Server/FakeListAPI.h"
 #include "Global.h"
+#include "mc/world/ActorUniqueID.h"
 
 void Export_Legacy_GMLib_ServerAPI() {
     RemoteCall::exportAs("GMLib_ServerAPI", "setEducationFeatureEnabled", []() -> void {
-        GMLIB_Level::addEducationEditionRequired();
+        GMLIB_Level::tryEnableEducationEdition();
     });
     RemoteCall::exportAs("GMLib_ServerAPI", "registerAbilityCommand", []() -> void {
-        GMLIB_Level::forceEnableAbilityCommand();
+        GMLIB_Level::tryRegisterAbilityCommand();
     });
     RemoteCall::exportAs("GMLib_ServerAPI", "setEnableAchievement", []() -> void {
         GMLIB_Level::setForceAchievementsEnabled();
     });
-    RemoteCall::exportAs("GMLib_ServerAPI", "setForceTrustSkins", []() -> void { GMLIB_Level::setForceTrustSkin(); });
+    RemoteCall::exportAs("GMLib_ServerAPI", "setForceTrustSkins", []() -> void { GMLIB_Level::trustAllSkins(); });
-    RemoteCall::exportAs("GMLib_ServerAPI", "enableCoResourcePack", []() -> void { GMLIB_Level::setCoResourcePack(); });
+    RemoteCall::exportAs("GMLib_ServerAPI", "enableCoResourcePack", []() -> void {
-    RemoteCall::exportAs("GMLib_ServerAPI", "getLevelName", []() -> std::string {
+        GMLIB_Level::requireServerResourcePackAndAllowClientResourcePack();
-        auto level = GMLIB_Level::getInstance();
-        if (!level) {
-            return "";
-        }
-        return level->getLevelName();
     });
-    RemoteCall::exportAs("GMLib_ServerAPI", "setLevelName", [](std::string name) -> void {
+    RemoteCall::exportAs("GMLib_ServerAPI", "getLevelName", []() -> std::string {
-        auto level = GMLIB_Level::getInstance();
+        if (auto level = GMLIB_Level::getInstance()) {
-        if (!level) {
+            return level->getLevelName();
-            return;
         }
-        return level->setLevelName(name);
+        return {};
+    });
+    RemoteCall::exportAs("GMLib_ServerAPI", "setLevelName", [](std::string const& name) -> void {
+        if (auto level = GMLIB_Level::getInstance()) {
+            level->setLevelName(name);
+        }
+    });
+    RemoteCall::exportAs("GMLib_ServerAPI", "getLevelSeed", []() -> std::string {
+        if (auto level = GMLIB_Level::getInstance()) {
+            return std::to_string(level->getSeed());
+        }
+        return {};
     });
     RemoteCall::exportAs("GMLib_ServerAPI", "setFakeSeed", [](int64_t seed) -> void {
         return GMLIB_Level::setFakeSeed(seed);
     });
-    RemoteCall::exportAs("GMLib_ServerAPI", "spawnEntity", [](std::pair<Vec3, int> pos, std::string name) -> Actor* {
+    RemoteCall::exportAs(
-        return GMLIB_Spawner::spawnEntity(pos.first, pos.second, name);
+        "GMLib_ServerAPI",
-    });
+        "spawnEntity",
+        [](std::pair<Vec3, int> pos, std::string const& name) -> Actor* {
+            return GMLIB_Spawner::spawnEntity(pos.first, pos.second, name);
+        }
+    );
     RemoteCall::exportAs(
         "GMLib_ServerAPI",
         "shootProjectile",
-        [](Actor* owner, std::string name, float speed, float offset) -> Actor* {
+        [](Actor* owner, std::string const& name, float speed, float offset) -> Actor* {
             auto ac = (GMLIB_Actor*)owner;
             return ac->shootProjectile(name, speed, offset);
         }
@@ -45,8 +56,21 @@ void Export_Legacy_GMLib_ServerAPI() {
         "throwEntity",
         [](Actor* owner, Actor* actor, float speed, float offset) -> bool {
             auto ac = (GMLIB_Actor*)owner;
-            return ac->throwEntity(actor, speed, offset);
+            return ac->throwEntity(*actor, speed, offset);
         }
     );
     RemoteCall::exportAs("GMLib_ServerAPI", "PlayerToEntity", [](Player* player) -> Actor* { return (Actor*)player; });
+    RemoteCall::exportAs(
+        "GMLib_ServerAPI",
+        "addFakeList",
+        [](const std::string& name, const std::string& xuid) -> bool {
+            return FakeList::addFakeList(name, xuid, ActorUniqueID(-1));
+        }
+    );
+    RemoteCall::exportAs("GMLib_ServerAPI", "removeFakeList", [](const std::string& nameOrXuid) -> bool {
+        return FakeList::removeFakeList(nameOrXuid);
+    });
+    RemoteCall::exportAs("GMLib_ServerAPI", "removeAllFakeList", []() -> void {
+        return FakeList::removeAllFakeLists();
+    });
 }

src/PlaceholderApi.cpp

@@ -3,10 +3,20 @@
 
 namespace PAPIRemoteCall {
 
-std::string GetValue(std::string const& from) { return GMLIB::Server::PlaceholderAPI::getValue(from); }
+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 PlaceholderAPI::getValue(from); }
 
 std::string GetValueWithPlayer(std::string const& a1, std::string const& a2) {
-    return GMLIB::Server::PlaceholderAPI::getValue(a1, ll::service::bedrock::getLevel()->getPlayer(a2));
+    return PlaceholderAPI::getValue(a1, ll::service::bedrock::getLevel()->getPlayer(a2));
 }
 
 bool registerPlayerPlaceholder(
@@ -15,12 +25,24 @@ bool registerPlayerPlaceholder(
     std::string const& PAPIName
 ) {
     if (RemoteCall::hasFunc(PluginName, FuncName)) {
-        auto Call = RemoteCall::importAs<std::string(Player * pl)>(PluginName, FuncName);
+        if (isParameters(PAPIName)) {
-        GMLIB::Server::PlaceholderAPI::registerPlayerPlaceholder(
+            auto Call = RemoteCall::importAs<std::string(Player * pl, std::unordered_map<std::string, std::string>)>(
-            PAPIName,
+                PluginName,
-            [Call](Player* sp) { return Call(sp); },
+                FuncName
-            PluginName
+            );
-        );
+            PlaceholderAPI::registerPlayerPlaceholder(
+                PAPIName,
+                [Call](Player* sp, std::unordered_map<std::string, std::string> map) { return Call(sp, map); },
+                PluginName
+            );
+        } else {
+            auto Call = RemoteCall::importAs<std::string(Player * pl)>(PluginName, FuncName);
+            PlaceholderAPI::registerPlayerPlaceholder(
+                PAPIName,
+                [Call](Player* sp) { return Call(sp); },
+                PluginName
+            );
+        }
         return true;
     }
     return false;
@@ -32,12 +54,18 @@ bool registerServerPlaceholder(
     std::string const& PAPIName
 ) {
     if (RemoteCall::hasFunc(PluginName, FuncName)) {
-        auto Call = RemoteCall::importAs<std::string()>(PluginName, FuncName);
+        if (isParameters(PAPIName)) {
-        GMLIB::Server::PlaceholderAPI::registerServerPlaceholder(
+            auto Call =
-            PAPIName,
+                RemoteCall::importAs<std::string(std::unordered_map<std::string, std::string>)>(PluginName, FuncName);
-            [Call]() { return Call(); },
+            PlaceholderAPI::registerServerPlaceholder(
-            PluginName
+                PAPIName,
-        );
+                [Call](std::unordered_map<std::string, std::string> map) { return Call(map); },
+                PluginName
+            );
+        } else {
+            auto Call = RemoteCall::importAs<std::string()>(PluginName, FuncName);
+            PlaceholderAPI::registerServerPlaceholder(PAPIName, [Call]() { return Call(); }, PluginName);
+        }
         return true;
     }
     return false;
@@ -50,20 +78,22 @@ bool registerStaticPlaceholder(
     int                num
 ) {
     if (RemoteCall::hasFunc(PluginName, FuncName)) {
-        auto Call = RemoteCall::importAs<std::string()>(PluginName, FuncName);
+        if (isParameters(PAPIName)) {
-        if (num == -1) {
+            auto Call = RemoteCall::importAs<std::string()>(PluginName, FuncName);
-            GMLIB::Server::PlaceholderAPI::registerStaticPlaceholder(
+            if (num == -1) {
-                PAPIName,
+                PlaceholderAPI::registerStaticPlaceholder(
-                [Call] { return Call(); },
+                    PAPIName,
-                PluginName
+                    [Call] { return Call(); },
-            );
+                    PluginName
-        } else {
+                );
-            GMLIB::Server::PlaceholderAPI::registerStaticPlaceholder(
+            } else {
-                PAPIName,
+                PlaceholderAPI::registerStaticPlaceholder(
-                num,
+                    PAPIName,
-                [Call] { return Call(); },
+                    num,
-                PluginName
+                    [Call] { return Call(); },
-            );
+                    PluginName
+                );
+            }
         }
         return true;
     }
@@ -71,14 +101,14 @@ bool registerStaticPlaceholder(
 }
 
 std::string translateStringWithPlayer(std::string const& str, Player* pl) {
-    return GMLIB::Server::PlaceholderAPI::translateString(str, pl);
+    return PlaceholderAPI::translateString(str, pl);
 }
 
-std::string translateString(std::string const& str) { return GMLIB::Server::PlaceholderAPI::translateString(str); }
+std::string translateString(std::string const& str) { return PlaceholderAPI::translateString(str); }
 
-bool unRegisterPlaceholder(std::string const& str) { return GMLIB::Server::PlaceholderAPI::unRegisterPlaceholder(str); }
+bool unRegisterPlaceholder(std::string const& str) { return PlaceholderAPI::unregisterPlaceholder(str); }
 
-std::vector<std::string> getAllPAPI() { return GMLIB::Server::PlaceholderAPI::getAllPAPI(); }
+std::vector<std::string> getAllPAPI() { return PlaceholderAPI::getAllPAPI(); }
 
 } // namespace PAPIRemoteCall
 

tooth.json

@@ -1,7 +1,7 @@
 {
     "format_version": 2,
     "tooth": "github.com/GroupMountain/GMLIB-LegacyRemoteCallApi",
-    "version": "0.10.1",
+    "version": "0.12.8",
     "info": {
         "name": "GMLIB-LegacyRemoteCallApi",
         "description": "Legacy RemoteCall API for GMLIB",
@@ -14,9 +14,9 @@
             "library"
         ]
     },
-    "asset_url": "https://github.com/GroupMountain/GMLIB-LegacyRemoteCallApi/releases/download/v0.10.1/GMLIB-LegacyRemoteCallApi-windows-x64.zip",
+    "asset_url": "https://github.com/GroupMountain/GMLIB-LegacyRemoteCallApi/releases/download/v0.12.8/GMLIB-LegacyRemoteCallApi-windows-x64.zip",
     "dependencies": {
-        "github.com/GroupMountain/GMLIB": ">=0.10.0"
+        "github.com/GroupMountain/GMLIB": ">=0.12.8"
     },
     "files": {
         "place": [

xmake.lua

@@ -1,6 +1,7 @@
 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")
 
 if not has_config("vs_runtime") then
     set_runtimes("MD")
@@ -9,6 +10,7 @@ end
 -- Option 1: Use the latest version of LeviLamina released on GitHub.
 add_requires("levilamina")
 add_requires("legacyremotecall")
+add_requires("gmlib")
 
 -- Option 2: Use a specific version of LeviLamina released on GitHub.
 -- add_requires("levilamina x.x.x")
@@ -53,16 +55,13 @@ target("GMLIB-LegacyRemoteCallApi") -- Change this to your plugin name.
     add_files(
         "src/**.cpp"
     )
-    add_links(
-        "SDK-GMLIB/Lib/GMLIB"
-    )
     add_includedirs(
-        "SDK-GMLIB",
         "src"
     )
     add_packages(
         "levilamina",
-        "legacyremotecall"
+        "legacyremotecall",
+        "gmlib"
     )
     add_shflags(
         "/DELAYLOAD:bedrock_server.dll" -- Magic to import symbols from BDS