refactor: use xmake to fetch sdk

导出i18nFix接口

.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
       
@@ -29,4 +25,10 @@ jobs:
         with:
           name: ${{ github.event.repository.name }}-windows-x64-${{ github.sha }}
           path: |
-            bin/
+            bin/DLL/
+
+      - uses: actions/upload-artifact@v3
+        with:
+          name: PDB
+          path: |
+            bin/PDB/

.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
       
@@ -29,7 +25,13 @@ jobs:
         with:
           name: ${{ github.event.repository.name }}-windows-x64-${{ github.sha }}
           path: |
-            bin/
+            bin/DLL/
+
+      - uses: actions/upload-artifact@v3
+        with:
+          name: PDB
+          path: |
+            bin/PDB/
 
   upload-to-release:
     needs:
@@ -38,24 +40,35 @@ jobs:
       contents: write
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - name: Checkout code
+        uses: actions/checkout@v4
 
-      - uses: actions/download-artifact@v3
+      - name: Download Plugin
+        uses: actions/download-artifact@v3
         with:
           name: ${{ github.event.repository.name }}-windows-x64-${{ github.sha }}
-          path: release/
+          path: release/Plugin/
 
-      - run: |
-          cp LICENSE README.md release/
+      - name: Download PDB
+        uses: actions/download-artifact@v3
+        with:
+          name: PDB
+          path: release/PDB/
+
+      - name: Copy additional files
+        run: |
+          cp LICENSE README.md release/Plugin/
 
       - name: Archive release
         run: |
-          cd release
+          cd release/Plugin
           zip -r ../${{ github.event.repository.name }}-windows-x64.zip *
           cd ..
 
-      - uses: softprops/action-gh-release@v1
+      - name: Create GitHub Release
+        id: create_release
+        uses: softprops/action-gh-release@v1
         with:
-          append_body: true
           files: |
-            ${{ github.event.repository.name }}-windows-x64.zip
+            release/${{ github.event.repository.name }}-windows-x64.zip
+            release/PDB/${{ github.event.repository.name }}.pdb 

.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。
 
-# 注意事项
-- 本模块仅为兼容性保留模块，仅保留过去的接口以保留兼容性。
-- 本模块不会提供 `GMLIB` 在迁移到 `LeviLamina` 后新开发的接口。
+# 开发文档
+- https://groupmountain.github.io/Documentation/

lib/BEPlaceholderAPI-JS.js

@@ -0,0 +1,64 @@
+const PlaceholderAPI = {
+    getValueAPI: ll.import("BEPlaceholderAPI", "GetValue"),
+    getValueByPlayerAPI: ll.import("BEPlaceholderAPI", "GetValueWithPlayer"),
+    registerPlayerPlaceholderAPI: ll.import("BEPlaceholderAPI", "registerPlayerPlaceholder"),
+    registerServerPlaceholderAPI: ll.import("BEPlaceholderAPI", "registerServerPlaceholder"),
+    registerStaticPlaceholderAPI: ll.import("BEPlaceholderAPI", "registerStaticPlaceholder"),
+    translateStringAPI: ll.import("BEPlaceholderAPI", "translateString"),
+    translateStringWithPlayerAPI: ll.import("BEPlaceholderAPI", "translateStringWithPlayer"),
+    unRegisterPlaceholderAPI: ll.import("BEPlaceholderAPI", "unRegisterPlaceholder"),
+    getAllPAPI: ll.import("BEPlaceholderAPI", "getAllPAPI")
+}
+
+Function.prototype.getName = function () {
+    return this.name || this.toString().match(/function\s*([^(]*)\(/)[1]
+}
+
+class PAPI {
+    constructor() {
+        throw new Error("Static class cannot be instantiated");
+    }
+
+    static registerPlayerPlaceholder(func, PluginName, PAPIName) {
+        ll.export(func, PluginName, func.getName());
+        return PlaceholderAPI.registerPlayerPlaceholderAPI(PluginName, func.getName(), PAPIName);
+    }
+
+    static registerServerPlaceholder(func, PluginName, PAPIName) {
+        ll.export(func, PluginName, func.getName());
+        return PlaceholderAPI.registerServerPlaceholderAPI(PluginName, func.getName(), PAPIName);
+    }
+
+    static registerStaticPlaceholder(func, PluginName, PAPIName, UpdateInterval = 50) {
+        ll.export(func, PluginName, func.getName());
+        return PlaceholderAPI.registerStaticPlaceholderAPI(PluginName, func.getName(), PAPIName, UpdateInterval);
+    }
+
+    static getValue(key) {
+        return PlaceholderAPI.getValueAPI(key);
+    }
+
+    static getValueByPlayer(key, pl) {
+        return PlaceholderAPI.getValueByPlayerAPI(key, pl);
+    }
+
+    static translateString(str, pl = null) {
+        if (pl) {
+            return PlaceholderAPI.translateStringWithPlayerAPI(str, pl);
+        }
+        return PlaceholderAPI.translateStringAPI(str);
+    }
+
+    static unRegisterPlaceholder(str) {
+        return PlaceholderAPI.unRegisterPlaceholderAPI(str);
+    }
+
+    static getAllPAPI() {
+        return PlaceholderAPI.getAllPAPI();
+    }
+
+}
+
+module.exports = {
+    PAPI
+};

lib/EventAPI-JS.js

@@ -0,0 +1,29 @@
+const CallEvent = ll.import("GMLIB_API", "callCustomEvent");
+
+let NextEventId = 0;
+
+function getNextEventId() {
+    NextEventId++;
+    return "GMLIB_Event_" + NextEventId;
+}
+
+class Event {
+    constructor() {
+        throw new Error("Static class cannot be instantiated");
+    }
+
+    static listen(event, callback) {
+        let eventId = getNextEventId();
+        ll.export(callback, event, eventId);
+        let result = CallEvent(event, eventId);
+        if (!result) {
+            logger.error(`Cannot listen event "${event}"!`);
+            logger.error(`Event "${event}" No Found!`);
+        }
+        return result;
+    }
+}
+
+module.exports = {
+    Event
+};

lib/GMLIB_API-JS.js

@@ -0,0 +1,979 @@
+const GMLIB_API = {
+    createFloatingText: ll.import("GMLIB_API", "createFloatingText"),
+    deleteFloatingText: ll.import("GMLIB_API", "deleteFloatingText"),
+    setFloatingTextData: ll.import("GMLIB_API", "setFloatingTextData"),
+    sendFloatingTextToPlayer: ll.import("GMLIB_API", "sendFloatingTextToPlayer"),
+    sendFloatingText: ll.import("GMLIB_API", "sendFloatingText"),
+    removeFloatingTextFromPlayer: ll.import("GMLIB_API", "removeFloatingTextFromPlayer"),
+    removeFloatingText: ll.import("GMLIB_API", "removeFloatingText"),
+    updateClientFloatingTextData: ll.import("GMLIB_API", "updateClientFloatingTextData"),
+    updateAllClientsFloatingTextData: ll.import("GMLIB_API", "updateAllClientsFloatingTextData"),
+    getServerMspt: ll.import("GMLIB_API", "getServerMspt"),
+    getServerCurrentTps: ll.import("GMLIB_API", "getServerCurrentTps"),
+    getServerAverageTps: ll.import("GMLIB_API", "getServerAverageTps"),
+    getAllPlayerUuids: ll.import("GMLIB_API", "getAllPlayerUuids"),
+    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"),
+    registerAbilityCommand: ll.import("GMLib_ServerAPI", "registerAbilityCommand"),
+    setEnableAchievement: ll.import("GMLib_ServerAPI", "setEnableAchievement"),
+    setForceTrustSkins: ll.import("GMLib_ServerAPI", "setForceTrustSkins"),
+    enableCoResourcePack: ll.import("GMLib_ServerAPI", "enableCoResourcePack"),
+    getLevelName: ll.import("GMLib_ServerAPI", "getLevelName"),
+    setLevelName: ll.import("GMLib_ServerAPI", "setLevelName"),
+    setFakeSeed: ll.import("GMLib_ServerAPI", "setFakeSeed"),
+    spawnEntity: ll.import("GMLib_ServerAPI", "spawnEntity"),
+    shootProjectile: ll.import("GMLib_ServerAPI", "shootProjectile"),
+    throwEntity: ll.import("GMLib_ServerAPI", "throwEntity"),
+    PlayerToEntity: ll.import("GMLib_ServerAPI", "PlayerToEntity"),
+    setUnknownBlockCleaner: ll.import("GMLib_ModAPI", "setUnknownBlockCleaner"),
+    getAllExperiments: ll.import("GMLIB_API", "getAllExperiments"),
+    getExperimentTranslateKey: ll.import("GMLIB_API", "getExperimentTranslateKey"),
+    getExperimentEnabled: ll.import("GMLib_ModAPI", "getExperimentEnabled"),
+    setExperimentEnabled: ll.import("GMLib_ModAPI", "setExperimentEnabled"),
+    unregisterRecipe: ll.import("GMLIB_API", "unregisterRecipe"),
+    registerExperimentsRequire: ll.import("GMLib_ModAPI", "registerExperimentsRequire"),
+    registerStoneCutterRecipe: ll.import("GMLib_ModAPI", "registerStoneCutterRecipe"),
+    registerSmithingTrimRecipe: ll.import("GMLib_ModAPI", "registerSmithingTrimRecipe"),
+    registerSmithingTransformRecipe: ll.import("GMLib_ModAPI", "registerSmithingTransformRecipe"),
+    registerBrewingContainerRecipe: ll.import("GMLib_ModAPI", "registerBrewingContainerRecipe"),
+    registerBrewingMixRecipe: ll.import("GMLib_ModAPI", "registerBrewingMixRecipe"),
+    registerFurnaceRecipe: ll.import("GMLib_ModAPI", "registerFurnaceRecipe"),
+    registerShapedRecipe: ll.import("GMLib_ModAPI", "registerShapedRecipe"),
+    registerShapelessRecipe: ll.import("GMLib_ModAPI", "registerShapelessRecipe"),
+    isVersionMatched: ll.import("GMLIB_API", "isVersionMatched"),
+    getVersion_LRCA: ll.import("GMLIB_API", "getVersion_LRCA"),
+    getVersion_GMLIB: ll.import("GMLIB_API", "getVersion_GMLIB"),
+    getPlayerPosition: ll.import("GMLIB_API", "getPlayerPosition"),
+    setPlayerPosition: ll.import("GMLIB_API", "setPlayerPosition"),
+    playerHasScore: ll.import("GMLIB_API", "playerHasScore"),
+    getPlayerScore: ll.import("GMLIB_API", "getPlayerScore"),
+    addPlayerScore: ll.import("GMLIB_API", "addPlayerScore"),
+    reducePlayerScore: ll.import("GMLIB_API", "reducePlayerScore"),
+    setPlayerScore: ll.import("GMLIB_API", "setPlayerScore"),
+    resetPlayerScore: ll.import("GMLIB_API", "resetPlayerScore"),
+    resetPlayerScores: ll.import("GMLIB_API", "resetPlayerScores"),
+    entityHasScore: ll.import("GMLIB_API", "entityHasScore"),
+    getEntityScore: ll.import("GMLIB_API", "getEntityScore"),
+    addEntityScore: ll.import("GMLIB_API", "addEntityScore"),
+    reduceEntityScore: ll.import("GMLIB_API", "reduceEntityScore"),
+    setEntityScore: ll.import("GMLIB_API", "setEntityScore"),
+    resetEntityScore: ll.import("GMLIB_API", "resetEntityScore"),
+    resetEntityScores: ll.import("GMLIB_API", "resetEntityScores"),
+    fakePlayerHasScore: ll.import("GMLIB_API", "fakePlayerHasScore"),
+    getFakePlayerScore: ll.import("GMLIB_API", "getFakePlayerScore"),
+    addFakePlayerScore: ll.import("GMLIB_API", "addFakePlayerScore"),
+    reduceFakePlayerScore: ll.import("GMLIB_API", "reduceFakePlayerScore"),
+    setFakePlayerScore: ll.import("GMLIB_API", "setFakePlayerScore"),
+    resetFakePlayerScore: ll.import("GMLIB_API", "resetFakePlayerScore"),
+    resetFakePlayerScores: ll.import("GMLIB_API", "resetFakePlayerScores"),
+    addObjective: ll.import("GMLIB_API", "addObjective"),
+    addObjectiveWithDisplayName: ll.import("GMLIB_API", "addObjectiveWithDisplayName"),
+    getDisplayName: ll.import("GMLIB_API", "getDisplayName"),
+    setDisplayName: ll.import("GMLIB_API", "setDisplayName"),
+    removeObjective: ll.import("GMLIB_API", "removeObjective"),
+    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"),
+    getPlayerFromUuid: ll.import("GMLIB_API", "getPlayerFromUuid"),
+    getPlayerFromUniqueId: ll.import("GMLIB_API", "getPlayerFromUniqueId"),
+    getEntityFromUniqueId: ll.import("GMLIB_API", "getEntityFromUniqueId"),
+    getWorldSpawn: ll.import("GMLIB_API", "getWorldSpawn"),
+    setWorldSpawn: ll.import("GMLIB_API", "setWorldSpawn"),
+    getPlayerSpawnPoint: ll.import("GMLIB_API", "getPlayerSpawnPoint"),
+    setPlayerSpawnPoint: ll.import("GMLIB_API", "setPlayerSpawnPoint"),
+    clearPlayerSpawnPoint: ll.import("GMLIB_API", "clearPlayerSpawnPoint"),
+    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")
+}
+
+const FloatingTextList = [];
+
+class StaticFloatingText {
+    constructor(pos, text, papi = true) {
+        this.mPosition = pos;
+        this.mText = text;
+        this.mPlaceholderAPI = papi;
+        this.mRuntimeId = GMLIB_API.createFloatingText(this.mPosition, this.mText, this.mPlaceholderAPI);
+        FloatingTextList.push(this);
+    }
+
+    sendToClient(player) {
+        return GMLIB_API.sendFloatingTextToPlayer(this.mRuntimeId, player);
+    }
+
+    sendToClients() {
+        return GMLIB_API.sendFloatingText(this.mRuntimeId);
+    }
+
+    removeFromClient(player) {
+        return GMLIB_API.removeFloatingTextFromPlayer(this.mRuntimeId, player);
+    }
+
+    removeFromClients() {
+        return GMLIB_API.removeFloatingText(this.mRuntimeId);
+    }
+
+    updateClient(player) {
+        return GMLIB_API.updateClientFloatingTextData(this.mRuntimeId, player);
+    }
+
+    updateClients() {
+        return GMLIB_API.updateAllClientsFloatingTextData(this.mRuntimeId);
+    }
+
+    getRuntimeId() {
+        return this.mRuntimeId;
+    }
+
+    getText() {
+        return this.mText;
+    }
+
+    setText(newText) {
+        this.mText = newText;
+    }
+
+    update() {
+        GMLIB_API.setFloatingTextData(this.mRuntimeId, this.mText);
+        return this.updateClients();
+    }
+
+    updateText(newText) {
+        this.setText(newText);
+        return this.update();
+    }
+
+    getPos() {
+        return this.mPosition;
+    }
+
+    destroy() {
+        let size_t = FloatingTextList.indexOf(this);
+        FloatingTextList.splice(size_t, 1);
+        return GMLIB_API.deleteFloatingText(this.mRuntimeId);
+    }
+
+    isDynamic() {
+        return false;
+    }
+
+    static getFloatingText(runtimeId) {
+        for (const ft of FloatingTextList) {
+            if (ft.getRuntimeId() == runtimeId) {
+                if (!ft.isDynamic()) {
+                    return ft;
+                }
+            }
+        }
+        return null;
+    }
+
+    static getAllFloatingTexts() {
+        let result = [];
+        FloatingTextList.forEach((ft) => {
+            if (!ft.isDynamic()) {
+                result.push(ft);
+            }
+        });
+        return result;
+    }
+}
+
+class DynamicFloatingText extends StaticFloatingText {
+    constructor(pos, text, updateRate = 1, papi = true) {
+        super(pos, text, papi);
+        this.mUpdateRate = updateRate;
+        this.mTaskId = null;
+        this.startUpdate();
+    }
+
+    getUpdateRate() {
+        return this.mUpdateRate;
+    }
+
+    setUpdateRate(updateRate = 1) {
+        this.stopUpdate();
+        this.mUpdateRate = updateRate;
+        this.startUpdate();
+    }
+
+    startUpdate() {
+        if (this.mTaskId == null) {
+            this.mTaskId = setInterval(() => {
+                this.update();
+            }, this.mUpdateRate * 1000);
+            return true;
+        }
+        return false;
+    }
+
+    stopUpdate() {
+        if (this.mTaskId != null) {
+            clearInterval(this.mTaskId);
+            this.mTaskId = null;
+            return true;
+        }
+        return false;
+    }
+
+    destroy() {
+        let size_t = FloatingTextList.indexOf(this);
+        FloatingTextList.splice(size_t, 1);
+        return GMLIB_API.deleteFloatingText(this.mRuntimeId);
+    }
+
+    isDynamic() {
+        return true;
+    }
+
+    static getFloatingText(runtimeId) {
+        for (const ft of FloatingTextList) {
+            if (ft.getRuntimeId() == runtimeId) {
+                if (ft.isDynamic()) {
+                    return ft;
+                }
+            }
+        }
+        return null;
+    }
+
+    static getAllFloatingTexts() {
+        let result = [];
+        FloatingTextList.forEach((ft) => {
+            if (ft.isDynamic()) {
+                result.push(ft);
+            }
+        });
+        return result;
+    }
+}
+
+class Minecraft {
+    constructor() {
+        throw new Error("Static class cannot be instantiated");
+    }
+
+    static getServerAverageTps() {
+        return GMLIB_API.getServerAverageTps();
+    }
+
+    static getServerCurrentTps() {
+        return GMLIB_API.getServerCurrentTps();
+    }
+
+    static getServerMspt() {
+        return GMLIB_API.getServerMspt();
+    }
+
+    static getAllPlayerUuids() {
+        return GMLIB_API.getAllPlayerUuids();
+    }
+
+    static getPlayerNbt(uuid) {
+        return GMLIB_API.getPlayerNbt(uuid);
+    }
+
+    static setPlayerNbt(uuid, nbt, forceCreate = true) {
+        return GMLIB_API.setPlayerNbt(uuid, nbt, forceCreate);
+    }
+
+    static setPlayerNbtTags(uuid, nbt, tags) {
+        return GMLIB_API.setPlayerNbtTags(uuid, nbt, tags);
+    }
+
+    static deletePlayerNbt(uuid) {
+        return GMLIB_API.deletePlayerNbt(uuid);
+    }
+
+    static getPlayerPosition(uuid) {
+        let pos = GMLIB_API.getPlayerPosition(uuid);
+        if (pos.dimid == -1) {
+            return null;
+        }
+        return pos;
+    }
+
+    static setPlayerPosition(uuid, pos) {
+        return GMLIB_API.setPlayerPosition(uuid, pos);
+    }
+
+    static getWorldSpawn() {
+        return GMLIB_API.getWorldSpawn();
+    }
+
+    static setWorldSpawn(pos) {
+        return GMLIB_API.setWorldSpawn(pos);
+    }
+
+    static setEducationFeatureEnabled() {
+        return GMLIB_API.setEducationFeatureEnabled();
+    }
+
+    static registerAbilityCommand() {
+        return GMLIB_API.registerAbilityCommand();
+    }
+
+    static setEnableAchievement() {
+        return GMLIB_API.setEnableAchievement();
+    }
+
+    static setForceTrustSkins() {
+        return GMLIB_API.setForceTrustSkins();
+    }
+
+    static enableCoResourcePack() {
+        return GMLIB_API.enableCoResourcePack();
+    }
+
+    static getWorldName() {
+        return GMLIB_API.getLevelName();
+    }
+
+    static setWorldName(name) {
+        return GMLIB_API.setLevelName(name);
+    }
+
+    static setFakeSeed(seed = 114514) {
+        return GMLIB_API.setFakeSeed(seed);
+    }
+
+    static setUnknownBlockCleaner() {
+        return GMLIB_API.setUnknownBlockCleaner();
+    }
+
+    static spawnEntity(pos, name) {
+        return GMLIB_API.spawnEntity(pos, name);
+    }
+
+    static shootProjectile(entity, proj, speed = 2, offset = 3) {
+        return GMLIB_API.shootProjectile(entity, proj, speed, offset);
+    }
+
+    static throwEntity(entity, proj, speed = 2, offset = 3) {
+        return GMLIB_API.throwEntity(entity, proj, speed = 2, offset = 3);
+    }
+
+    static getServerLanguage() {
+        return I18nAPI.getCurrentLanguage();
+    }
+
+    static setServerLanguage(language) {
+        return I18nAPI.chooseLanguage(language);
+    }
+
+    static setCustomPackPath(path) {
+        GMLIB_API.setCustomPackPath(path);
+    }
+
+    static 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(xuid, name);
+    }
+
+    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);
+    }
+}
+
+class Recipes {
+    constructor() {
+        throw new Error("Static class cannot be instantiated");
+    }
+
+    static unregisterRecipe(recipeId) {
+        return GMLIB_API.unregisterRecipe(recipeId);
+    }
+
+    static registerStoneCutterRecipe(recipeId, inputName, inputAux, outputName, outputAux, outputCount) {
+        return GMLIB_API.registerStoneCutterRecipe(recipeId, inputName, inputAux, outputName, outputAux, outputCount);
+    }
+
+    static registerSmithingTrimRecipe(recipeId, template, base, addition) {
+        return GMLIB_API.registerSmithingTrimRecipe(recipeId, template, base, addition);
+    }
+
+    static registerSmithingTransformRecipe(recipeId, template, base, addition, result) {
+        return GMLIB_API.registerSmithingTransformRecipe(recipeId, template, base, addition, result);
+    }
+
+    static registerBrewingContainerRecipe(recipeId, input, output, reagent) {
+        return GMLIB_API.registerBrewingContainerRecipe(recipeId, input, output, reagent);
+    }
+
+    static registerBrewingMixRecipe(recipeId, input, output, reagent) {
+        return GMLIB_API.registerBrewingMixRecipe(recipeId, input, output, reagent);
+    }
+
+    // tags ["furnace", "blast_furnace", "smoker", "campfire", "soul_campfire"]
+    static registerFurnaceRecipe(recipeId, input, output, tags = ["furnace"]) {
+        return GMLIB_API.registerFurnaceRecipe(recipeId, input, output, tags);
+    }
+
+    // unlock : "AlwaysUnlocked", "PlayerHasManyItems", "PlayerInWater", "None", Item ID
+    static registerShapedRecipe(recipeId, shape, ingredients, result, count = 1, unlock = "AlwaysUnlocked") {
+        return GMLIB_API.registerShapedRecipe(recipeId, shape, ingredients, result, count, unlock);
+    }
+
+    static registerShapelessRecipe(recipeId, ingredients, result, count = 1, unlock = "AlwaysUnlocked") {
+        return GMLIB_API.registerShapelessRecipe(recipeId, ingredients, result, count, unlock);
+    }
+}
+
+class Experiments {
+    constructor() {
+        throw new Error("Static class cannot be instantiated");
+    }
+
+    static getAllExperimentIds() {
+        return GMLIB_API.getAllExperiments();
+    }
+
+    static getExperimentTranslateKey(id) {
+        return GMLIB_API.getExperimentTranslateKey(id);
+    }
+
+    static getExperimentEnabled(id) {
+        return GMLIB_API.getExperimentEnabled(id);
+    }
+
+    static setExperimentEnabled(id, value = true) {
+        return GMLIB_API.setExperimentEnabled(id, value);
+    }
+
+    static registerExperimentsRequire(id) {
+        return GMLIB_API.registerExperimentsRequire(id);
+    }
+}
+
+class Version {
+    constructor(major, minor, patch) {
+        this.mMajor = major;
+        this.mMinor = minor;
+        this.mPatch = patch;
+    }
+
+    toString(prefix = true) {
+        let result = `${this.mMajor}.${this.mMinor}.${this.mPatch}`;
+        if (prefix) {
+            result = "v" + result;
+        }
+        return result;
+    }
+
+    toArray() {
+        return [this.mMajor, this.mMinor, this.mPatch];
+    }
+
+    valueOf() {
+        return 100000000 * this.mMajor + 10000 * this.mMinor + this.mPatch;
+    }
+
+    static fromString(string) {
+        if (typeof string === 'string' || string instanceof String) {
+            let pattern = /^v?\d+\.\d+\.\d+$/;
+            if (pattern.test(string)) {
+                let regex = /\d+/g;
+                let numbers = string.match(regex);
+                let array = numbers.slice(0, 3).map(Number);
+                return new Version(array[0], array[1], array[2]);
+            }
+        }
+        return null;
+    }
+
+    static fromArray(array) {
+        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 null;
+    }
+
+    static isPluginVersionMatched(version) {
+        return GMLIB_API.isVersionMatched(version.mMajor, version.mMinor, version.mPatch);
+    }
+
+    static getLrcaVersion() {
+        return Version.fromString(GMLIB_API.getVersion_LRCA());
+    }
+
+    static getGmlibVersion() {
+        return Version.fromString(GMLIB_API.getVersion_GMLIB());
+    }
+}
+
+class Scoreboard {
+    constructor() {
+        throw new Error("Static class cannot be instantiated");
+    }
+
+    // Targets
+    static getAllTrackedEntities() {
+        return GMLIB_API.getAllScoreboardEntities();
+    }
+
+    static getAllTrackedPlayers() {
+        return GMLIB_API.getAllScoreboardPlayers();
+    }
+
+    static getAllTrackedFakePlayers() {
+        return GMLIB_API.getAllScoreboardFakePlayers();
+    }
+
+    static getAllTrackedTargets() {
+        return GMLIB_API.getAllTrackedTargets();
+    }
+
+    // Objectives
+    static addObjective(name, displayName = "") {
+        if (displayName == "") {
+            return GMLIB_API.addObjective(name);
+        }
+        return GMLIB_API.addObjectiveWithDisplayName(name, displayName);
+    }
+
+    static removeObjective(name) {
+        return GMLIB_API.removeObjective(name);
+    }
+
+    static getAllObjectives() {
+        return GMLIB_API.getAllObjectives();
+    }
+
+    static getDisplayName(objective) {
+        return GMLIB_API.getDisplayName(objective);
+    }
+
+    static setDisplayName(objective, displayName) {
+        return GMLIB_API.setDisplayName(objective, displayName);
+    }
+
+    static setDisplay(objective, slot, order = 0) {
+        GMLIB_API.setDisplayObjective(objective, slot, order);
+    }
+
+    static clearDisplay(slot) {
+        GMLIB_API.clearDisplayObjective(slot);
+    }
+
+    // Player Score
+    static getPlayerScore(uuid, objective) {
+        if (GMLIB_API.playerHasScore(uuid, objective)) {
+            return GMLIB_API.getPlayerScore(uuid, objective);
+        }
+        return null;
+    }
+
+    static addPlayerScore(uuid, objective, value) {
+        return GMLIB_API.addPlayerScore(uuid, objective, value);
+    }
+
+    static reducePlayerScore(uuid, objective, value) {
+        return GMLIB_API.reducePlayerScore(uuid, objective, value);
+    }
+
+    static setPlayerScore(uuid, objective, value) {
+        return GMLIB_API.setPlayerScore(uuid, objective, value);
+    }
+
+    static resetPlayerScore(uuid, objective) {
+        return GMLIB_API.resetPlayerScore(uuid, objective);
+    }
+
+    static resetPlayerScores(uuid) {
+        return GMLIB_API.resetPlayerScores(uuid);
+    }
+
+    // FakePlayer Score
+    static getFakePlayerScore(name, objective) {
+        if (GMLIB_API.fakePlayerHasScore(name, objective)) {
+            return GMLIB_API.getFakePlayerScore(name, objective);
+        }
+        return null;
+    }
+
+    static addFakePlayerScore(name, objective, value) {
+        return GMLIB_API.addFakePlayerScore(name, objective, value);
+    }
+
+    static reduceFakePlayerScore(name, objective, value) {
+        return GMLIB_API.reduceFakePlayerScore(name, objective, value);
+    }
+
+    static setFakePlayerScore(name, objective, value) {
+        return GMLIB_API.setFakePlayerScore(name, objective, value);
+    }
+
+    static resetFakePlayerScore(name, objective) {
+        return GMLIB_API.resetFakePlayerScore(name, objective);
+    }
+
+    static resetFakePlayerScores(name) {
+        return GMLIB_API.resetFakePlayerScores(name);
+    }
+
+    // Entity Score
+    static getEntityScore(uniqueId, objective) {
+        if (GMLIB_API.entityHasScore(uniqueId, objective)) {
+            return GMLIB_API.getEntityScore(uniqueId, objective);
+        }
+        return null;
+    }
+
+    static addEntityScore(uniqueId, objective, value) {
+        return GMLIB_API.addEntityScore(uniqueId, objective, value);
+    }
+
+    static reduceEntityScore(uniqueId, objective, value) {
+        return GMLIB_API.reduceEntityScore(uniqueId, objective, value);
+    }
+
+    static setEntityScore(uniqueId, objective, value) {
+        return GMLIB_API.setEntityScore(uniqueId, objective, value);
+    }
+
+    static resetEntityScore(uniqueId, objective) {
+        return GMLIB_API.resetEntityScore(uniqueId, objective);
+    }
+
+    static resetEntityScores(uniqueId) {
+        return GMLIB_API.resetEntityScores(uniqueId);
+    }
+
+}
+
+class JsonConfig {
+    constructor(path, defultValue = {}) {
+        this.mData = defultValue;
+        this.mPath = path;
+        this.init();
+    }
+
+    init() {
+        if (File.exists(this.mPath)) {
+            let existDataStr = File.readFrom(this.mPath);
+            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();
+    }
+
+    save(format = 4) {
+        let dataStr = JSON.stringify(this.mData, null, format);
+        File.writeTo(this.mPath, dataStr);
+    }
+
+    getData() {
+        return this.mData;
+    }
+
+    get(key, defultValue = undefined) {
+        let result = this.getData()[key];
+        if (!result && defultValue != undefined) {
+            this.set(key, defultValue);
+            return defultValue;
+        }
+        return result;
+    }
+
+    set(key, value) {
+        this.getData()[key] = value;
+        this.save();
+    }
+
+    delete(key) {
+        delete this.getData()[key];
+        this.save();
+    }
+}
+
+class JsonLanguage extends JsonConfig {
+    constructor(path, defultValue = {}) {
+        super(path, defultValue);
+    }
+
+    translate(key, data = []) {
+        let result = this.get(key);
+        if (result == null) {
+            return key;
+        }
+        data.forEach((val, index) => {
+            let old = `{${index + 1}}`;
+            result = result.split(old).join(val);
+        });
+        return result;
+    }
+}
+
+class JsonI18n {
+    constructor(path, localLangCode = "en_US") {
+        if (!path.endsWith("/") && !path.endsWith("\\")) {
+            path = path + "/";
+        }
+        this.mPath = path;
+        this.mLangCode = localLangCode;
+        this.mAllLanguages = {};
+        this.mDefaultLangCode = "en_US";
+        this.loadAllLanguages();
+    }
+
+    loadAllLanguages() {
+        let exist_list = File.getFilesList(this.mPath);
+        exist_list.forEach((name) => {
+            let code = name.replace(".json", "");
+            let path = this.mPath + name;
+            let language = new JsonLanguage(path);
+            this.mAllLanguages[code] = language;
+        });
+    }
+
+    loadLanguage(langCode, defaultData = {}) {
+        let langPath = this.mPath;
+        langPath = langPath + langCode + ".json";
+        let language = new JsonLanguage(langPath, defaultData);
+        this.mAllLanguages[langCode] = language;
+    }
+
+    chooseLanguage(langCode) {
+        this.mLangCode = langCode;
+    }
+
+    setDefaultLanguage(langCode) {
+        this.mDefaultLangCode = langCode;
+    }
+
+    translate(key, data = [], langCode = this.mLangCode) {
+        let language = this.mAllLanguages[langCode];
+        let result = language.translate(key, data);
+        if (result == key) {
+            let language = this.mAllLanguages[this.mDefaultLangCode];
+            if (language) {
+                result = language.translate(key, data);
+            }
+        }
+        return result;
+    }
+};
+
+class I18nAPI {
+    constructor() {
+        throw new Error("Static class cannot be instantiated");
+    }
+
+    static get(key, params = [], langCode = undefined) {
+        if (langCode) {
+            return GMLIB_API.resourcePackTranslate(key, params, langCode);
+        }
+        return GMLIB_API.resourcePackDefaultTranslate(key, params);
+    }
+
+    static translate(key, params = []) {
+        return I18nAPI.get(key, params);
+    }
+
+    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);
+}
+
+LLSE_Player.prototype.getSpawnPoint = function () {
+    return GMLIB_API.getPlayerSpawnPoint(this);
+}
+
+LLSE_Player.prototype.setSpawnPoint = function (pos) {
+    return GMLIB_API.setPlayerSpawnPoint(this, pos);
+}
+
+LLSE_Player.prototype.clearSpawnPoint = function () {
+    return GMLIB_API.clearPlayerSpawnPoint(this);
+}
+
+LLSE_Entity.prototype.shootProjectile = function (proj, speed = 2, offset = 3) {
+    return GMLIB_API.shootProjectile(this, proj, speed, offset);
+}
+
+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);
+}
+
+module.exports = {
+    StaticFloatingText,
+    DynamicFloatingText,
+    Minecraft,
+    Recipes,
+    Experiments,
+    Scoreboard,
+    JsonConfig,
+    JsonLanguage,
+    JsonI18n,
+    Version,
+    I18nAPI,
+    UserCache
+};

manifest.json

@@ -1,6 +1,8 @@
 {
     "name": "${pluginName}",
     "entry": "${pluginFile}",
+    "version": "0.12.7",
+    "author": "GroupMountain",
     "type": "native",
     "dependencies": [
         {

scripts/after_build.lua

@@ -88,10 +88,12 @@ function pack_plugin(target,plugin_define)
     local manifest_path = find_file("manifest.json", os.projectdir())
     if manifest_path then
         local manifest = io.readfile(manifest_path)
-        local bindir = path.join(os.projectdir(), "bin")
+        local bindir = path.join(os.projectdir(), "bin/DLL")
+        local pdbdir = path.join(os.projectdir(), "bin/PDB")
         local outputdir = path.join(bindir, plugin_define.pluginName)
         local targetfile = path.join(outputdir, plugin_define.pluginFile)
-        local pdbfile = path.join(outputdir, path.basename(plugin_define.pluginFile) .. ".pdb")
+        local pdbfile = path.join(pdbdir, path.basename(plugin_define.pluginFile) .. ".pdb")
+        local libfile = path.join(os.projectdir(), "lib")
         local manifestfile = path.join(outputdir, "manifest.json")
         local oritargetfile = target:targetfile()
         local oripdbfile = path.join(path.directory(oritargetfile), path.basename(oritargetfile) .. ".pdb")
@@ -101,6 +103,7 @@ function pack_plugin(target,plugin_define)
         if os.isfile(oripdbfile) then
             os.cp(oripdbfile, pdbfile)
         end
+        os.cp(libfile, outputdir)
 
         formattedmanifest = string_formatter(manifest, plugin_define)
         io.writefile(manifestfile,formattedmanifest)

src/CompatibilityApi.cpp

@@ -1,38 +1,633 @@
 #include "Global.h"
+#include <regex>
+
+bool isInteger(const std::string& str) {
+    std::regex pattern("^[+-]?\\d+$");
+    return std::regex_match(str, pattern);
+}
+
+ActorUniqueID parseScriptUniqueID(std::string const& uniqueId) {
+    if (!isInteger(uniqueId)) {
+        return ActorUniqueID::INVALID_ID;
+    }
+    return ActorUniqueID(std::stoll(uniqueId));
+}
 
 void Export_Compatibility_API() {
+    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);
+    });
+    RemoteCall::exportAs("GMLIB_API", "setCustomPackPath", [](std::string const& path) -> void {
+        GMLIB::Mod::CustomPacks::addCustomPackPath(path);
+    });
     RemoteCall::exportAs("GMLIB_API", "getServerMspt", []() -> float {
-        auto level = GMLIB_Level::getLevel();
+        auto level = GMLIB_Level::getInstance();
         if (!level) {
             return 0.0f;
         }
         return level->getServerMspt();
     });
     RemoteCall::exportAs("GMLIB_API", "getServerCurrentTps", []() -> float {
-        auto level = GMLIB_Level::getLevel();
+        auto level = GMLIB_Level::getInstance();
         if (!level) {
             return 0.0f;
         }
         return level->getServerCurrentTps();
     });
     RemoteCall::exportAs("GMLIB_API", "getServerAverageTps", []() -> float {
-        auto level = GMLIB_Level::getLevel();
+        auto level = GMLIB_Level::getInstance();
         if (!level) {
             return 0.0f;
         }
         return level->getServerAverageTps();
     });
     RemoteCall::exportAs("GMLIB_API", "getAllPlayerUuids", []() -> std::vector<std::string> {
-        return GMLIB_Player::getAllUuids();
+        std::vector<std::string> result;
+        std::vector<mce::UUID>   uuids = GMLIB_Player::getAllUuids();
+        for (auto& uuid : uuids) {
+            result.push_back(uuid.asString());
+        }
+        return result;
+    });
+    RemoteCall::exportAs("GMLIB_API", "getPlayerNbt", [](std::string const& uuid) -> std::unique_ptr<CompoundTag> {
+        auto uid = mce::UUID::fromString(uuid);
+        return std::move(GMLIB_Player::getPlayerNbt(uid));
+    });
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "setPlayerNbt",
+        [](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);
+            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> {
-        return {6, 7, 8, 9, 10, 13, 16, 17, 18};
+        auto             list = GMLIB_Level::getAllExperiments();
+        std::vector<int> result;
+        for (auto& key : list) {
+            result.push_back((int)key);
+        }
+        return result;
     });
-    RemoteCall::exportAs("GMLIB_API", "getExperimentTranslatedName", [](int id) -> std::string {
-        auto map = GMLIB_Level::getAllExperimentsTranslateKeys();
-        if (map.count(id)) {
-            return map[id];
+    RemoteCall::exportAs("GMLIB_API", "getExperimentTranslateKey", [](int id) -> std::string {
+        std::string result;
+        try {
+            result = Experiments::getExperimentTextID(AllExperiments(id));
+        } catch (...) {}
+        return result;
+    });
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "createFloatingText",
+        [](std::pair<Vec3, int> pos, std::string const& text, bool papi) -> int {
+            auto ft = std::make_shared<GMLIB::Server::StaticFloatingText>(text, pos.first, pos.second, papi);
+            GMLIB::Server::FloatingTextManager::getInstance().add(ft);
+            return ft->getRuntimeID();
+        }
+    );
+    RemoteCall::exportAs("GMLIB_API", "setFloatingTextData", [](int id, std::string const& text) -> bool {
+        if (auto ft = GMLIB::Server::FloatingTextManager::getInstance().getFloatingText(id)) {
+            ft->setText(text);
+            return true;
+        }
+        return false;
+    });
+    RemoteCall::exportAs("GMLIB_API", "deleteFloatingText", [](int id) -> bool {
+        return GMLIB::Server::FloatingTextManager::getInstance().remove(id);
+    });
+    RemoteCall::exportAs("GMLIB_API", "sendFloatingTextToPlayer", [](int id, Player* pl) -> bool {
+        if (auto ft = GMLIB::Server::FloatingTextManager::getInstance().getFloatingText(id)) {
+            ft->sendTo(*pl);
+            return true;
+        }
+        return false;
+    });
+    RemoteCall::exportAs("GMLIB_API", "sendFloatingText", [](int id) -> bool {
+        if (auto ft = GMLIB::Server::FloatingTextManager::getInstance().getFloatingText(id)) {
+            ft->sendToClients();
+            return true;
+        }
+        return false;
+    });
+    RemoteCall::exportAs("GMLIB_API", "removeFloatingTextFromPlayer", [](int id, Player* pl) -> bool {
+        if (auto ft = GMLIB::Server::FloatingTextManager::getInstance().getFloatingText(id)) {
+            ft->removeFrom(*pl);
+            return true;
+        }
+        return false;
+    });
+    RemoteCall::exportAs("GMLIB_API", "removeFloatingText", [](int id) -> bool {
+        if (auto ft = GMLIB::Server::FloatingTextManager::getInstance().getFloatingText(id)) {
+            ft->removeFromClients();
+            return true;
+        }
+        return false;
+    });
+    RemoteCall::exportAs("GMLIB_API", "updateClientFloatingTextData", [](int id, Player* pl) -> bool {
+        if (auto ft = GMLIB::Server::FloatingTextManager::getInstance().getFloatingText(id)) {
+            ft->update(*pl);
+            return true;
+        }
+        return false;
+    });
+    RemoteCall::exportAs("GMLIB_API", "updateAllClientsFloatingTextData", [](int id) -> bool {
+        if (auto ft = GMLIB::Server::FloatingTextManager::getInstance().getFloatingText(id)) {
+            ft->updateClients();
+            return true;
+        }
+        return false;
+    });
+    RemoteCall::exportAs("GMLIB_API", "isVersionMatched", [](int a, int b, int c) -> bool {
+        auto version = GMLIB::Version(a, b, c, "", "");
+        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();
+    });
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "resourcePackDefaultTranslate",
+        [](std::string const& key, std::vector<std::string> params) -> std::string { return I18nAPI::get(key, params); }
+    );
+    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()) {
+            I18nAPI::chooseLanguage(code);
+        }
+    });
+    RemoteCall::exportAs("GMLIB_API", "getResourcePackI18nLanguage", []() -> std::string {
+        if (GMLIB_Level::getInstance()) {
+            return I18nAPI::getCurrentLanguageCode();
+        }
+        return "unknown";
+    });
+    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()) {
+            return pos.value();
+        }
+        return {
+            {0, 0, 0},
+            -1
+        };
+    });
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "setPlayerPosition",
+        [](std::string const& uuid, std::pair<BlockPos, int> pos) -> 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 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 const& uuid, std::string const& obj, int value) -> bool {
+            auto uid = mce::UUID::fromString(uuid);
+            if (auto res = GMLIB_Player::setPlayerScore(uid, obj, value, PlayerScoreSetFunction::Add)) {
+                return true;
+            }
+            return false;
+        }
+    );
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "reducePlayerScore",
+        [](std::string const& uuid, std::string const& obj, int value) -> bool {
+            auto uid = mce::UUID::fromString(uuid);
+            if (auto res = GMLIB_Player::setPlayerScore(uid, obj, value, PlayerScoreSetFunction::Subtract)) {
+                return true;
+            }
+            return false;
+        }
+    );
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "setPlayerScore",
+        [](std::string const& uuid, std::string const& obj, int value) -> bool {
+            auto uid = mce::UUID::fromString(uuid);
+            if (auto res = GMLIB_Player::setPlayerScore(uid, obj, value)) {
+                return true;
+            }
+            return false;
+        }
+    );
+    RemoteCall::exportAs("GMLIB_API", "resetPlayerScore", [](std::string const& uuid, std::string const& obj) -> bool {
+        auto uid = mce::UUID::fromString(uuid);
+        return GMLIB_Player::resetPlayerScore(uid, obj);
+    });
+    RemoteCall::exportAs("GMLIB_API", "resetPlayerScores", [](std::string const& uuid) -> bool {
+        auto uid = mce::UUID::fromString(uuid);
+        return GMLIB_Player::resetPlayerScore(uid);
+    });
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "entityHasScore",
+        [](std::string const& uniqueId, std::string const& obj) -> bool {
+            auto auid = parseScriptUniqueID(uniqueId);
+            if (auto result = GMLIB_Scoreboard::getInstance()->getScore(obj, auid)) {
+                return true;
+            }
+            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 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)) {
+                return true;
+            }
+            return false;
+        }
+    );
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "setEntityScore",
+        [](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;
+        }
+    );
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "resetEntityScore",
+        [](std::string const& uniqueId, std::string const& obj) -> bool {
+            auto auid = parseScriptUniqueID(uniqueId);
+            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 const& name, std::string const& obj) -> bool {
+            if (auto result = GMLIB_Scoreboard::getInstance()->getScore(obj, name)) {
+                return true;
+            }
+            return false;
+        }
+    );
+    RemoteCall::exportAs("GMLIB_API", "getFakePlayerScore", [](std::string const& name, std::string const& obj) -> int {
+        if (auto result = GMLIB_Scoreboard::getInstance()->getScore(obj, name)) {
+            return result.value();
+        }
+        return 0;
+    });
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "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;
+        }
+    );
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "reduceFakePlayerScore",
+        [](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;
+            }
+            return false;
+        }
+    );
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "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;
+        }
+    );
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "resetFakePlayerScore",
+        [](std::string const& name, std::string const& obj) -> 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 const& obj) -> bool {
+        if (auto res = GMLIB_Scoreboard::getInstance()->addObjective(obj)) {
+            return true;
+        }
+        return false;
+    });
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "addObjectiveWithDisplayName",
+        [](std::string const& obj, std::string const& displayName) -> bool {
+            if (auto res = GMLIB_Scoreboard::getInstance()->addObjective(obj, displayName)) {
+                return true;
+            }
+            return false;
+        }
+    );
+    RemoteCall::exportAs("GMLIB_API", "getDisplayName", [](std::string const& obj) -> std::string {
+        if (auto result = GMLIB_Scoreboard::getInstance()->getObjectiveDisplayName(obj)) {
+            return result.value();
         }
         return "";
     });
+    RemoteCall::exportAs(
+        "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",
+        "setDisplayObjective",
+        [](std::string const& obj, std::string const& slot, int order) -> void {
+            return GMLIB_Scoreboard::getInstance()->setObjectiveDisplay(obj, slot, (ObjectiveSortOrder)order);
+        }
+    );
+    RemoteCall::exportAs("GMLIB_API", "clearDisplayObjective", [](std::string const& slot) -> void {
+        return GMLIB_Scoreboard::getInstance()->clearObjectiveDisplay(slot);
+    });
+    RemoteCall::exportAs("GMLIB_API", "getAllObjectives", []() -> std::vector<std::string> {
+        auto                     objs = GMLIB_Scoreboard::getInstance()->getObjectives();
+        std::vector<std::string> result;
+        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()->getAllPlayerUuids();
+        std::vector<std::string> result;
+        for (auto& uuid : uuids) {
+            result.push_back(uuid.asString());
+        }
+        return result;
+    });
+    RemoteCall::exportAs("GMLIB_API", "getAllScoreboardFakePlayers", []() -> std::vector<std::string> {
+        auto                     names = GMLIB_Scoreboard::getInstance()->getAllFakePlayers();
+        std::vector<std::string> result;
+        for (auto& name : names) {
+            result.push_back(name);
+        }
+        return result;
+    });
+    RemoteCall::exportAs("GMLIB_API", "getAllScoreboardEntities", []() -> std::vector<std::string> {
+        auto                     uniqueIds = GMLIB_Scoreboard::getInstance()->getAllEntities();
+        std::vector<std::string> result;
+        for (auto& uniqueId : uniqueIds) {
+            result.push_back(std::to_string(uniqueId.id));
+        }
+        return result;
+    });
+    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 const& uniqueId) -> Actor* {
+        auto auid = parseScriptUniqueID(uniqueId);
+        return ll::service::getLevel()->getPlayer(auid);
+    });
+    RemoteCall::exportAs("GMLIB_API", "getEntityFromUniqueId", [](std::string const& uniqueId) -> Actor* {
+        auto auid = parseScriptUniqueID(uniqueId);
+        return ll::service::getLevel()->fetchEntity(auid);
+    });
+    RemoteCall::exportAs("GMLIB_API", "getWorldSpawn", []() -> std::pair<BlockPos, int> {
+        return {GMLIB_Level::getInstance()->getWorldSpawn(), 0};
+    });
+    RemoteCall::exportAs("GMLIB_API", "setWorldSpawn", [](std::pair<BlockPos, int> pos) -> bool {
+        if (pos.second != 0) {
+            return false;
+        }
+        GMLIB_Level::getInstance()->setWorldSpawn(pos.first);
+        return true;
+    });
+    RemoteCall::exportAs("GMLIB_API", "getPlayerSpawnPoint", [](Player* pl) -> std::pair<BlockPos, int> {
+        auto player = (GMLIB_Player*)pl;
+        auto res    = player->getSpawnPoint();
+        return {res.first, res.second};
+    });
+    RemoteCall::exportAs("GMLIB_API", "setPlayerSpawnPoint", [](Player* pl, std::pair<BlockPos, int> pos) -> void {
+        auto player = (GMLIB_Player*)pl;
+        player->setSpawnPoint(pos.first, pos.second);
+    });
+    RemoteCall::exportAs("GMLIB_API", "clearPlayerSpawnPoint", [](Player* pl) -> void {
+        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 = GMLIB::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 = GMLIB::UserCache::getNameByUuid(uid);
+        return result ? result.value() : "";
+    });
+    RemoteCall::exportAs("GMLIB_API", "getUuidByXuid", [](std::string const& xuid) -> std::string {
+        auto result = GMLIB::UserCache::getUuidByXuid(xuid);
+        return result ? result.value().asString() : "";
+    });
+    RemoteCall::exportAs("GMLIB_API", "getNameByXuid", [](std::string const& xuid) -> std::string {
+        auto result = GMLIB::UserCache::getNameByXuid(xuid);
+        return result ? result.value() : "";
+    });
+    RemoteCall::exportAs("GMLIB_API", "getXuidByName", [](std::string const& name) -> std::string {
+        auto result = GMLIB::UserCache::getXuidByName(name);
+        return result ? result.value() : "";
+    });
+    RemoteCall::exportAs("GMLIB_API", "getUuidByName", [](std::string const& name) -> std::string {
+        auto result = GMLIB::UserCache::getUuidByName(name);
+        return result ? result.value().asString() : "";
+    });
+    RemoteCall::exportAs("GMLIB_API", "getUuidByName", [](std::string const& name) -> std::string {
+        auto result = GMLIB::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;
+            GMLIB::UserCache::forEach([&result](const GMLIB::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);
+        }
+    );
 }

src/DllMain.cpp

@@ -1,32 +0,0 @@
-#include <memory>
-
-#include <ll/api/plugin/NativePlugin.h>
-
-#include "Plugin.h"
-
-namespace plugin {
-
-// The global plugin instance.
-std::unique_ptr<Plugin> plugin = nullptr;
-
-extern "C" {
-_declspec(dllexport) bool ll_plugin_load(ll::plugin::NativePlugin& self) {
-    plugin = std::make_unique<plugin::Plugin>(self);
-
-    return true;
-}
-
-/// @warning Unloading the plugin may cause a crash if the plugin has not released all of its
-/// resources. If you are unsure, keep this function commented out.
-// _declspec(dllexport) bool ll_plugin_unload(ll::plugin::Plugin&) {
-//     plugin.reset();
-//
-//     return true;
-// }
-
-_declspec(dllexport) bool ll_plugin_enable(ll::plugin::NativePlugin&) { return plugin->enable(); }
-
-_declspec(dllexport) bool ll_plugin_disable(ll::plugin::NativePlugin&) { return plugin->disable(); }
-}
-
-} // namespace plugin

src/Entry.cpp

@@ -0,0 +1,36 @@
+#include "Entry.h"
+#include "Global.h"
+
+ll::Logger logger(PLUGIN_NAME);
+
+namespace GMLIB {
+
+std::unique_ptr<LegacyRemoteCallApi>& LegacyRemoteCallApi::getInstance() {
+    static std::unique_ptr<LegacyRemoteCallApi> instance;
+    return instance;
+}
+
+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(
+        "Loaded Version: {} with {}",
+        fmt::format(fg(fmt::color::pink), "GMLIB-" + GMLIB::Version::getLibVersionString()),
+        fmt::format(fg(fmt::color::light_green), "GMLIB-LegacyRemoteCallApi-" + LIB_VERSION.asString())
+    );
+    logger.info("Author: GroupMountain");
+    logger.info("Repository: https://github.com/GroupMountain/GMLIB-LegacyRemoteCallApi");
+    return true;
+}
+
+bool LegacyRemoteCallApi::enable() { return true; }
+
+bool LegacyRemoteCallApi::disable() { return true; }
+
+} // namespace GMLIB
+
+LL_REGISTER_PLUGIN(GMLIB::LegacyRemoteCallApi, GMLIB::LegacyRemoteCallApi::getInstance());

src/Entry.h

@@ -0,0 +1,33 @@
+#pragma once
+#include <ll/api/plugin/NativePlugin.h>
+#include <ll/api/plugin/RegisterHelper.h>
+
+namespace GMLIB {
+
+class LegacyRemoteCallApi {
+
+public:
+    static std::unique_ptr<LegacyRemoteCallApi>& getInstance();
+
+    LegacyRemoteCallApi(ll::plugin::NativePlugin& self) : mSelf(self) {}
+
+    [[nodiscard]] ll::plugin::NativePlugin& getSelf() const { return mSelf; }
+
+    /// @return True if the plugin is loaded successfully.
+    bool load();
+
+    /// @return True if the plugin is enabled successfully.
+    bool enable();
+
+    /// @return True if the plugin is disabled successfully.
+    bool disable();
+
+    // TODO: Implement this method if you need to unload the plugin.
+    // /// @return True if the plugin is unloaded successfully.
+    // bool unload();
+
+private:
+    ll::plugin::NativePlugin& mSelf;
+};
+
+} // namespace GMLIB

src/EventAPI.cpp

@@ -0,0 +1,201 @@
+#include "Global.h"
+using namespace ll::hash_utils;
+
+void Export_Event_API() {
+    auto eventBus = &ll::event::EventBus::getInstance();
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "callCustomEvent",
+        [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<bool(
+                        std::string const& realName,
+                        std::string const& uuid,
+                        std::string const& serverXuid,
+                        std::string const& clientXuid
+                    )>(eventName, eventId);
+                    eventBus->emplaceListener<GMLIB::Event::PacketEvent::ClientLoginAfterEvent>(
+                        [Call](GMLIB::Event::PacketEvent::ClientLoginAfterEvent& ev) {
+                            try {
+                                Call(
+                                    ev.getRealName(),
+                                    ev.getUuid().asString(),
+                                    ev.getServerAuthXuid(),
+                                    ev.getClientAuthXuid()
+                                );
+                            } catch (...) {}
+                        }
+                    );
+                    return true;
+                }
+                case doHash("onWeatherChange"): {
+                    auto Call =
+                        RemoteCall::importAs<bool(int lightningLevel, int rainLevel, int lightningLast, int rainLast)>(
+                            eventName,
+                            eventId
+                        );
+                    eventBus->emplaceListener<GMLIB::Event::LevelEvent::WeatherUpdateBeforeEvent>(
+                        [Call](GMLIB::Event::LevelEvent::WeatherUpdateBeforeEvent& ev) {
+                            bool result = true;
+                            try {
+                                result = Call(
+                                    ev.getLightningLevel(),
+                                    ev.getRainLevel(),
+                                    ev.getLightningLastTick(),
+                                    ev.getRainingLastTick()
+                                );
+                            } catch (...) {}
+                            if (!result) {
+                                ev.cancel();
+                            }
+                        }
+                    );
+                    return true;
+                }
+                case doHash("onMobPick"): {
+                    auto Call = RemoteCall::importAs<bool(Actor * mob, Actor * item)>(eventName, eventId);
+                    eventBus->emplaceListener<GMLIB::Event::EntityEvent::MobPickupItemBeforeEvent>(
+                        [Call](GMLIB::Event::EntityEvent::MobPickupItemBeforeEvent& ev) {
+                            bool result = true;
+                            try {
+                                result = Call(&ev.self(), (Actor*)&ev.getItemActor());
+                            } catch (...) {}
+                            if (!result) {
+                                ev.cancel();
+                            }
+                        }
+                    );
+                    return true;
+                }
+                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>(
+                        [Call](GMLIB::Event::EntityEvent::ItemActorSpawnBeforeEvent& ev) {
+                            auto                 pos    = ev.getPosition();
+                            auto                 dimid  = ev.getBlockSource().getDimensionId().id;
+                            std::pair<Vec3, int> lsePos = {pos, dimid};
+                            bool                 result = true;
+                            try {
+                                result = Call(&ev.getItem(), lsePos, ev.getSpawner());
+                            } catch (...) {}
+                            if (!result) {
+                                ev.cancel();
+                            }
+                        }
+                    );
+                    return true;
+                }
+                case doHash("onItemSpawned"): {
+                    auto Call = RemoteCall::importAs<
+                        bool(const ItemStack* item, Actor* itemActor, std::pair<Vec3, int> position, Actor* spawner)>(
+                        eventName,
+                        eventId
+                    );
+                    eventBus->emplaceListener<GMLIB::Event::EntityEvent::ItemActorSpawnAfterEvent>(
+                        [Call](GMLIB::Event::EntityEvent::ItemActorSpawnAfterEvent& ev) {
+                            auto                 pos    = ev.getPosition();
+                            auto                 dimid  = ev.getBlockSource().getDimensionId().id;
+                            std::pair<Vec3, int> lsePos = {pos, dimid};
+                            try {
+                                Call(&ev.getItem(), (Actor*)&ev.getItemActor(), lsePos, ev.getSpawner());
+                            } catch (...) {}
+                        }
+                    );
+                    return true;
+                }
+                case doHash("onEntityChangeDim"): {
+                    auto Call = RemoteCall::importAs<bool(Actor * entity, int toDimId)>(eventName, eventId);
+                    eventBus->emplaceListener<GMLIB::Event::EntityEvent::ActorChangeDimensionBeforeEvent>(
+                        [Call](GMLIB::Event::EntityEvent::ActorChangeDimensionBeforeEvent& ev) {
+                            bool result = true;
+                            try {
+                                result = Call(&ev.self(), ev.getToDimensionId());
+                            } catch (...) {}
+                            if (!result) {
+                                ev.cancel();
+                            }
+                        }
+                    );
+                    return true;
+                }
+                case doHash("onLeaveBed"): {
+                    auto Call = RemoteCall::importAs<bool(Player * pl)>(eventName, eventId);
+                    eventBus->emplaceListener<GMLIB::Event::PlayerEvent::PlayerStopSleepBeforeEvent>(
+                        [Call](GMLIB::Event::PlayerEvent::PlayerStopSleepBeforeEvent& ev) {
+                            bool result = true;
+                            try {
+                                result = Call(&ev.self());
+                            } catch (...) {}
+                            if (!result) {
+                                ev.cancel();
+                            }
+                        }
+                    );
+                    return true;
+                }
+                case doHash("onDeathMessage"): {
+                    auto Call =
+                        RemoteCall::importAs<bool(std::string const& message, std::vector<std::string>, Actor* dead)>(
+                            eventName,
+                            eventId
+                        );
+                    eventBus->emplaceListener<GMLIB::Event::EntityEvent::DeathMessageAfterEvent>(
+                        [Call](GMLIB::Event::EntityEvent::DeathMessageAfterEvent& ev) {
+                            auto msg    = ev.getDeathMessage();
+                            auto source = ev.getDamageSource();
+                            try {
+                                Call(msg.first, msg.second, &ev.self());
+                            } catch (...) {}
+                        }
+                    );
+                    return true;
+                }
+                case doHash("onMobHurted"): {
+                    auto Call = RemoteCall::importAs<bool(Actor * mob, Actor * source, float damage, int cause)>(
+                        eventName,
+                        eventId
+                    );
+                    eventBus->emplaceListener<GMLIB::Event::EntityEvent::MobHurtAfterEvent>(
+                        [Call](GMLIB::Event::EntityEvent::MobHurtAfterEvent& ev) {
+                            auto&  damageSource = ev.getSource();
+                            Actor* source       = nullptr;
+                            if (damageSource.isEntitySource()) {
+                                auto uniqueId = damageSource.getDamagingEntityUniqueID();
+                                source        = ll::service::getLevel()->fetchEntity(uniqueId);
+                                if (source->getOwner()) {
+                                    source = source->getOwner();
+                                }
+                            }
+                            try {
+                                Call(&ev.self(), source, ev.getDamage(), (int)damageSource.getCause());
+                            } catch (...) {}
+                        }
+                    );
+                    return true;
+                }
+                case doHash("onEndermanTake"): {
+                    auto Call = RemoteCall::importAs<bool(Actor * mob)>(eventName, eventId);
+                    eventBus->emplaceListener<GMLIB::Event::EntityEvent::EndermanTakeBlockBeforeEvent>(
+                        [Call](GMLIB::Event::EntityEvent::EndermanTakeBlockBeforeEvent& ev) {
+                            bool result = true;
+                            try {
+                                result = Call(&ev.self());
+                            } catch (...) {}
+                            if (!result) {
+                                ev.cancel();
+                            }
+                        }
+                    );
+                    return true;
+                }
+                default:
+                    return false;
+                }
+            }
+            return false;
+        }
+    );
+}

src/Global.h

@@ -1,11 +1,20 @@
 #pragma once
 #include <include_all.h>
+
 #include <RemoteCallAPI.h>
 
-#define PLUGIN_NAME "GMLIB-LRCA"
+#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 7
+
+#define LIB_VERSION GMLIB::Version(LIB_VERSION_MAJOR, LIB_VERSION_MINOR, LIB_VERSION_PATCH)
 
 extern ll::Logger logger;
 
 extern void Export_Legacy_GMLib_ModAPI();
 extern void Export_Legacy_GMLib_ServerAPI();
 extern void Export_Compatibility_API();
+extern void ExportPAPI();
+extern void Export_Event_API();

src/LegacyModApi.cpp

@@ -1,9 +1,8 @@
 #include "Global.h"
 
 std::unordered_set<std::string> HardCodedKeys = {"AlwaysUnlocked", "PlayerHasManyItems", "PlayerInWater", "None"};
-std::unordered_set<int>         ExperimentsList = {6, 7, 8, 9, 10, 13, 16, 17, 18};
 
-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;
     }
@@ -18,12 +17,12 @@ 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 {
-            auto level = GMLIB_Level::getLevel();
+           std::string const&       unlock) -> void {
+            auto level = GMLIB_Level::getInstance();
             if (!level) {
                 return;
             }
@@ -34,19 +33,19 @@ void Export_Legacy_GMLib_ModAPI() {
             }
             auto res = RecipeIngredient(result, 0, count);
             auto unl = makeRecipeUnlockingKey(unlock);
-            GMLIB::Mod::CustomRecipe::registerShapelessCraftingTableRecipe(recipe_id, types, res, unl);
+            GMLIB::Mod::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 {
-            auto level = GMLIB_Level::getLevel();
+           std::string const&       unlock) -> void {
+            auto level = GMLIB_Level::getInstance();
             if (!level) {
                 return;
             }
@@ -57,61 +56,66 @@ void Export_Legacy_GMLib_ModAPI() {
             }
             auto res = RecipeIngredient(result, 0, count);
             auto unl = makeRecipeUnlockingKey(unlock);
-            GMLIB::Mod::CustomRecipe::registerShapedCraftingTableRecipe(recipe_id, shape, types, res, unl);
+            GMLIB::Mod::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 {
-            auto level = GMLIB_Level::getLevel();
+        [](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::CustomRecipe::registerFurnaceRecipe(recipe_id, inp, outp, tags);
+            GMLIB::Mod::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 {
-            auto level = GMLIB_Level::getLevel();
+        [](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::CustomRecipe::registerBrewingMixRecipe(recipe_id, input, output, rea);
+            GMLIB::Mod::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 {
-            auto level = GMLIB_Level::getLevel();
+        [](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 inp  = RecipeIngredient(input, 0, 1);
             auto outp = RecipeIngredient(output, 0, 1);
             auto rea  = RecipeIngredient(reagent, 0, 1);
-            GMLIB::Mod::CustomRecipe::registerBrewingContainerRecipe(recipe_id, inp, outp, rea);
+            GMLIB::Mod::JsonRecipe::registerBrewingContainerRecipe(recipe_id, inp, outp, rea);
         }
     );
     RemoteCall::exportAs(
         "GMLib_ModAPI",
         "registerSmithingTransformRecipe",
-        [](std::string recipe_id,
-           std::string smithing_template,
-           std::string base,
-           std::string addition,
-           std::string result) -> void {
-            auto level = GMLIB_Level::getLevel();
+        [](std::string const& recipe_id,
+           std::string const& smithing_template,
+           std::string const& base,
+           std::string const& addition,
+           std::string const& result) -> void {
+            auto level = GMLIB_Level::getInstance();
             if (!level) {
                 return;
             }
-            GMLIB::Mod::CustomRecipe::registerSmithingTransformRecipe(
+            GMLIB::Mod::JsonRecipe::registerSmithingTransformRecipe(
                 recipe_id,
                 smithing_template,
                 base,
@@ -123,30 +127,33 @@ 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 {
-            auto level = GMLIB_Level::getLevel();
+        [](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::CustomRecipe::registerSmithingTrimRecipe(recipe_id, smithing_template, base, addition);
+            GMLIB::Mod::JsonRecipe::registerSmithingTrimRecipe(recipe_id, smithing_template, base, addition);
         }
     );
     RemoteCall::exportAs(
         "GMLib_ModAPI",
         "registerStoneCutterRecipe",
-        [](std::string recipe_id,
-           std::string input,
+        [](std::string const& recipe_id,
+           std::string const& input,
            int                input_data,
-           std::string output,
+           std::string const& output,
            int                output_data,
            int                output_count) -> void {
-            auto level = GMLIB_Level::getLevel();
+            auto level = GMLIB_Level::getInstance();
             if (!level) {
                 return;
             }
             auto inp  = RecipeIngredient(input, 0, 1);
             auto outp = RecipeIngredient(output, 0, 1);
-            GMLIB::Mod::CustomRecipe::registerStoneCutterRecipe(recipe_id, inp, outp);
+            GMLIB::Mod::JsonRecipe::registerStoneCutterRecipe(recipe_id, inp, outp);
         }
     );
     // 错误方块清理
@@ -155,31 +162,37 @@ void Export_Legacy_GMLib_ModAPI() {
     });
     // 实验性
     RemoteCall::exportAs("GMLib_ModAPI", "registerExperimentsRequire", [](int experiment_id) -> void {
-        if (ExperimentsList.count(experiment_id)) {
+        auto                               list = GMLIB_Level::getAllExperiments();
+        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::getLevel();
-        if (!level) {
-            return;
-        }
-        if (ExperimentsList.count(experiment_id)) {
-            GMLIB_Level::getLevel()->setExperimentEnabled(((AllExperiments)experiment_id), value);
+        if (GMLIB_Level::getInstance()) {
+            auto                               list = GMLIB_Level::getAllExperiments();
+            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);
+        }
     });
     RemoteCall::exportAs("GMLib_ModAPI", "getExperimentEnabled", [](int experiment_id) -> bool {
-        auto level = GMLIB_Level::getLevel();
-        if (!level) {
-            return false;
-        }
-        if (ExperimentsList.count(experiment_id)) {
-            return GMLIB_Level::getLevel()->getExperimentEnabled(((AllExperiments)experiment_id));
+        if (GMLIB_Level::getInstance()) {
+            auto                               list = GMLIB_Level::getAllExperiments();
+            std::unordered_set<AllExperiments> set(list.begin(), list.end());
+            if (set.contains((AllExperiments)experiment_id)) {
+                return GMLIB_Level::getInstance()->getExperimentEnabled(((AllExperiments)experiment_id));
             } else {
                 ll::Logger("Server").error("Experiment ID '{}' does not exist!", experiment_id);
                 return false;
             }
+        }
+        return false;
+    });
+    RemoteCall::exportAs("GMLib_ModAPI", "setFixI18nEnabled", []() -> void {
+        GMLIB::Mod::VanillaFix::setFixI18nEnabled();
     });
 }

src/LegacyServerApi.cpp

@@ -1,56 +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();
-    });
-    RemoteCall::exportAs(
-        "GMLib_ServerAPI",
-        "addFloatingTextPacket",
-        [](std::string text, std::pair<Vec3, int> pos, int dimid) -> int {
-            auto ft = new GMLIB::Server::FloatingText(text, pos.first, pos.second);
-            return ft->getRuntimeID();
-        }
-    );
-    RemoteCall::exportAs("GMLib_ServerAPI", "deleteFloatingTextPacket", [](int id) -> void {
-        GMLIB::Server::FloatingText::deleteFloatingText(id);
+        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", "enableCoResourcePack", []() -> void { GMLIB_Level::setCoResourcePack(); });
-    RemoteCall::exportAs("GMLib_ServerAPI", "getLevelName", []() -> std::string {
-        auto level = GMLIB_Level::getLevel();
-        if (!level) {
-            return "";
-        }
-        return level->getLevelName();
+    RemoteCall::exportAs("GMLib_ServerAPI", "setForceTrustSkins", []() -> void { GMLIB_Level::trustAllSkins(); });
+    RemoteCall::exportAs("GMLib_ServerAPI", "enableCoResourcePack", []() -> void {
+        GMLIB_Level::requireServerResourcePackAndAllowClientResourcePack();
     });
-    RemoteCall::exportAs("GMLib_ServerAPI", "setLevelName", [](std::string name) -> void {
-        auto level = GMLIB_Level::getLevel();
-        if (!level) {
-            return;
+    RemoteCall::exportAs("GMLib_ServerAPI", "getLevelName", []() -> std::string {
+        if (auto level = GMLIB_Level::getInstance()) {
+            return level->getLevelName();
         }
-        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 {
-        auto level = GMLIB_Level::getLevel();
-        if (!level) {
-            return;
-        }
-        return level->setFakeSeed(seed);
-    });
-    RemoteCall::exportAs("GMLib_ServerAPI", "spawnEntity", [](std::pair<Vec3, int> pos, std::string name) -> Actor* {
-        return GMLIB_Spawner::spawnEntity(pos.first, pos.second, name);
+        return GMLIB_Level::setFakeSeed(seed);
     });
+    RemoteCall::exportAs(
+        "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);
         }
@@ -60,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 GMLIB::Server::FakeList::addFakeList(name, xuid, ActorUniqueID(-1));
+        }
+    );
+    RemoteCall::exportAs("GMLib_ServerAPI", "removeFakeList", [](const std::string& nameOrXuid) -> bool {
+        return GMLIB::Server::FakeList::removeFakeList(nameOrXuid);
+    });
+    RemoteCall::exportAs("GMLib_ServerAPI", "removeAllFakeList", []() -> void {
+        return GMLIB::Server::FakeList::removeAllFakeLists();
+    });
 }

src/MemoryOperators.cpp

@@ -0,0 +1,7 @@
+// This file will make your plugin use LeviLamina's memory operators by default.
+// This improves the memory management of your plugin and is recommended to use.
+// You should not modify anything in this file.
+
+#define LL_MEMORY_OPERATORS
+
+#include <ll/api/memory/MemoryOperators.h>

src/PlaceholderApi.cpp

@@ -0,0 +1,128 @@
+#include "Global.h"
+#include <regex>
+
+namespace PAPIRemoteCall {
+
+std::string removeBrackets(std::string a1) {
+    a1.erase(a1.find_last_not_of("%") + 1);
+    return a1;
+}
+
+bool isParameters(std::string const& str) {
+    std::regex reg("[<]([^<>]+)[>]");
+    return std::regex_search(removeBrackets(str), reg);
+}
+
+std::string GetValue(std::string const& from) { return GMLIB::Server::PlaceholderAPI::getValue(from); }
+
+std::string GetValueWithPlayer(std::string const& a1, std::string const& a2) {
+    return GMLIB::Server::PlaceholderAPI::getValue(a1, ll::service::bedrock::getLevel()->getPlayer(a2));
+}
+
+bool registerPlayerPlaceholder(
+    std::string const& PluginName,
+    std::string const& FuncName,
+    std::string const& PAPIName
+) {
+    if (RemoteCall::hasFunc(PluginName, FuncName)) {
+        if (isParameters(PAPIName)) {
+            auto Call = RemoteCall::importAs<std::string(Player * pl, std::unordered_map<std::string, std::string>)>(
+                PluginName,
+                FuncName
+            );
+            GMLIB::Server::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);
+            GMLIB::Server::PlaceholderAPI::registerPlayerPlaceholder(
+                PAPIName,
+                [Call](Player* sp) { return Call(sp); },
+                PluginName
+            );
+        }
+        return true;
+    }
+    return false;
+}
+
+bool registerServerPlaceholder(
+    std::string const& PluginName,
+    std::string const& FuncName,
+    std::string const& PAPIName
+) {
+    if (RemoteCall::hasFunc(PluginName, FuncName)) {
+        if (isParameters(PAPIName)) {
+            auto Call =
+                RemoteCall::importAs<std::string(std::unordered_map<std::string, std::string>)>(PluginName, FuncName);
+            GMLIB::Server::PlaceholderAPI::registerServerPlaceholder(
+                PAPIName,
+                [Call](std::unordered_map<std::string, std::string> map) { return Call(map); },
+                PluginName
+            );
+        } else {
+            auto Call = RemoteCall::importAs<std::string()>(PluginName, FuncName);
+            GMLIB::Server::PlaceholderAPI::registerServerPlaceholder(PAPIName, [Call]() { return Call(); }, PluginName);
+        }
+        return true;
+    }
+    return false;
+}
+
+bool registerStaticPlaceholder(
+    std::string const& PluginName,
+    std::string const& FuncName,
+    std::string const& PAPIName,
+    int                num
+) {
+    if (RemoteCall::hasFunc(PluginName, FuncName)) {
+        if (isParameters(PAPIName)) {
+            auto Call = RemoteCall::importAs<std::string()>(PluginName, FuncName);
+            if (num == -1) {
+                GMLIB::Server::PlaceholderAPI::registerStaticPlaceholder(
+                    PAPIName,
+                    [Call] { return Call(); },
+                    PluginName
+                );
+            } else {
+                GMLIB::Server::PlaceholderAPI::registerStaticPlaceholder(
+                    PAPIName,
+                    num,
+                    [Call] { return Call(); },
+                    PluginName
+                );
+            }
+        }
+        return true;
+    }
+    return false;
+}
+
+std::string translateStringWithPlayer(std::string const& str, Player* pl) {
+    return GMLIB::Server::PlaceholderAPI::translateString(str, pl);
+}
+
+std::string translateString(std::string const& str) { return GMLIB::Server::PlaceholderAPI::translateString(str); }
+
+bool unRegisterPlaceholder(std::string const& str) { return GMLIB::Server::PlaceholderAPI::unregisterPlaceholder(str); }
+
+std::vector<std::string> getAllPAPI() { return GMLIB::Server::PlaceholderAPI::getAllPAPI(); }
+
+} // namespace PAPIRemoteCall
+
+#define EXPORTAPI(T)                                                                                                   \
+    RemoteCall::exportAs("BEPlaceholderAPI", ll::utils::string_utils::replaceAll(#T, "PAPIRemoteCall::", ""), T);
+
+void ExportPAPI() {
+    EXPORTAPI(PAPIRemoteCall::registerPlayerPlaceholder);
+    EXPORTAPI(PAPIRemoteCall::registerServerPlaceholder);
+    EXPORTAPI(PAPIRemoteCall::registerStaticPlaceholder);
+    EXPORTAPI(PAPIRemoteCall::GetValue);
+    EXPORTAPI(PAPIRemoteCall::GetValueWithPlayer);
+    EXPORTAPI(PAPIRemoteCall::translateString);
+    EXPORTAPI(PAPIRemoteCall::translateStringWithPlayer);
+    EXPORTAPI(PAPIRemoteCall::unRegisterPlaceholder);
+    EXPORTAPI(PAPIRemoteCall::getAllPAPI);
+}

src/Plugin.cpp

@@ -1,28 +0,0 @@
-#include "Plugin.h"
-#include "Global.h"
-
-ll::Logger logger(PLUGIN_NAME);
-
-namespace plugin {
-
-Plugin::Plugin(ll::plugin::NativePlugin& self) : mSelf(self) {
-    // Code for loading the plugin goes here.
-    Export_Legacy_GMLib_ModAPI();
-    Export_Legacy_GMLib_ServerAPI();
-    Export_Compatibility_API();
-    logger.info("GMLIB-LegacyRemoteCallApi Loaded!");
-    logger.info("Author: GroupMountain");
-    logger.info("Repository: https://github.com/GroupMountain/GMLIB-LegacyRemoteCallApi");
-}
-
-bool Plugin::enable() {
-    // Code for enabling the plugin goes here.
-    return true;
-}
-
-bool Plugin::disable() {
-    // Code for disabling the plugin goes here.
-    return true;
-}
-
-} // namespace plugin

src/Plugin.h

@@ -1,27 +0,0 @@
-#pragma once
-#include <ll/api/plugin/NativePlugin.h>
-
-namespace plugin {
-
-class Plugin {
-public:
-    explicit Plugin(ll::plugin::NativePlugin& self);
-
-    Plugin(Plugin&&)                 = delete;
-    Plugin(const Plugin&)            = delete;
-    Plugin& operator=(Plugin&&)      = delete;
-    Plugin& operator=(const Plugin&) = delete;
-
-    ~Plugin() = default;
-
-    /// @return True if the plugin is enabled successfully.
-    bool enable();
-
-    /// @return True if the plugin is disabled successfully.
-    bool disable();
-
-private:
-    ll::plugin::NativePlugin& mSelf;
-};
-
-} // namespace plugin

tooth.json

@@ -1,21 +1,22 @@
 {
     "format_version": 2,
     "tooth": "github.com/GroupMountain/GMLIB-LegacyRemoteCallApi",
-    "version": "0.8.1",
+    "version": "0.12.7",
     "info": {
         "name": "GMLIB-LegacyRemoteCallApi",
         "description": "Legacy RemoteCall API for GMLIB",
+        "source": "github.com/GroupMountain/GMLIB-LegacyRemoteCallApi",
         "author": "GroupMountain",
         "tags": [
-            "LeviLamina",
-            "GMLIB",
-            "GMLIB-LegacyRemoteCallApi",
-            "Library"
+            "levilamina",
+            "gmlib",
+            "lse",
+            "library"
         ]
     },
-    "asset_url": "https://github.com/GroupMountain/GMLIB-LegacyRemoteCallApi/releases/download/v0.8.1/GMLIB-LegacyRemoteCallApi-windows-x64.zip",
+    "asset_url": "https://github.com/GroupMountain/GMLIB-LegacyRemoteCallApi/releases/download/v0.12.7/GMLIB-LegacyRemoteCallApi-windows-x64.zip",
     "dependencies": {
-        "github.com/GroupMountain/GMLIB": ">=0.8.1"
+        "github.com/GroupMountain/GMLIB": ">=0.12.7"
     },
     "files": {
         "place": [

xmake.lua

@@ -1,6 +1,7 @@
-add_rules("mode.debug", "mode.release", "mode.releasedbg")
+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")
@@ -47,28 +49,27 @@ target("GMLIB-LegacyRemoteCallApi") -- Change this to your plugin name.
         "/utf-8"
     )
     add_defines(
-        "_HAS_CXX23=1" -- To enable C++23 features
+        "NOMINMAX",
+        "UNICODE"
     )
     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
     )
     set_exceptions("none") -- To avoid conflicts with /EHa
     set_kind("shared")
-    set_languages("cxx23")
+    set_languages("c++23")
+    set_symbols("debug")
 
     after_build(function (target)
         local plugin_packer = import("scripts.after_build")