Merge branch 'develop' of https://github.com/GroupMountain/GMLIB-LegacyRemoteCallApi

.github/workflows/release.yml

@@ -7,6 +7,11 @@ jobs:
   build:
     runs-on: windows-latest
     steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+        with:
+          submodules: recursive
+          
       - uses: actions/checkout@v4
 
       - uses: xmake-io/github-action-setup-xmake@v1

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,409 @@
+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"),
+    resourcePackTranslate: ll.import("GMLIB_API", "resourcePackTranslate"),
+    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"),
+    getExperimentTranslatedName: ll.import("GMLIB_API", "getExperimentTranslatedName"),
+    getExperimentEnabled: ll.import("GMLib_ModAPI", "getExperimentEnabled"),
+    setExperimentEnabled: ll.import("GMLib_ModAPI", "setExperimentEnabled"),
+    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")
+}
+
+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);
+        this.sendToClients();
+        mc.listen("onJoin", (pl) => {
+            this.sendToClient(pl);
+        });
+    }
+
+    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) {
+        let snbt = GMLIB_API.getPlayerNbt(uuid);
+        let nbt = NBT.parseSNBT(snbt);
+        return nbt;
+    }
+
+    static setPlayerNbt(uuid, nbt) {
+        let snbt = nbt.toSNBT();
+        return GMLIB_API.setPlayerNbt(uuid, snbt);
+    }
+
+    static setPlayerNbtTags(uuid, nbt, tags) {
+        let snbt = nbt.toSNBT();
+        return GMLIB_API.setPlayerNbtTags(uuid, snbt, tags);
+    }
+
+    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 playerToEntity(player) {
+        return GMLIB_API.PlayerToEntity(player);
+    }
+
+    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 chooseResourcePackI18nLanguage(language) {
+        return GMLIB_API.chooseResourcePackI18nLanguage(language);
+    }
+
+    static resourcePackTranslate(key, params = []) {
+        return GMLIB_API.resourcePackTranslate(key, params);
+    }
+}
+
+class Recipes {
+    constructor() {
+        throw new Error("Static class cannot be instantiated");
+    }
+
+    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 getExperimentTranslatedName(id) {
+        return GMLIB_API.getExperimentTranslatedName(id);
+    }
+
+    static getExperimentsMap() {
+        let ids = this.getAllExperimentIds();
+        let result = {};
+        for (let id in ids) {
+            let name = this.getExperimentTranslatedName(id);
+            result[id] = name;
+        }
+        return result;
+    }
+
+    static getExperimentEnabled(id) {
+        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 GMLIB {
+    constructor() {
+        throw new Error("Static class cannot be instantiated");
+    }
+
+    static isVersionMatched(major, minor, patch) {
+        return GMLIB_API.isVersionMatched(major, minor, patch);
+    }
+
+    static getVersion_LRCA() {
+        return GMLIB_API.getVersion_LRCA();
+    }
+
+    static getVersion_GMLIB() {
+        return GMLIB_API.getVersion_GMLIB();
+    }
+}
+
+module.exports = { StaticFloatingText, DynamicFloatingText, Minecraft, Recipes, Experiments, GMLIB };

scripts/after_build.lua

@@ -92,6 +92,7 @@ function pack_plugin(target,plugin_define)
         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 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 +102,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

@@ -2,15 +2,143 @@
 
 void Export_Compatibility_API() {
     RemoteCall::exportAs("GMLIB_API", "getServerMspt", []() -> float {
-        return GMLIB_Level::getLevel()->getServerMspt();
+        auto level = GMLIB_Level::getLevel();
+        if (!level) {
+            return 0.0f;
+        }
+        return level->getServerMspt();
     });
     RemoteCall::exportAs("GMLIB_API", "getServerCurrentTps", []() -> float {
-        return GMLIB_Level::getLevel()->getServerCurrentTps();
+        auto level = GMLIB_Level::getLevel();
+        if (!level) {
+            return 0.0f;
+        }
+        return level->getServerCurrentTps();
     });
     RemoteCall::exportAs("GMLIB_API", "getServerAverageTps", []() -> float {
-        return GMLIB_Level::getLevel()->getServerAverageTps();
+        auto level = GMLIB_Level::getLevel();
+        if (!level) {
+            return 0.0f;
+        }
+        return level->getServerAverageTps();
     });
     RemoteCall::exportAs("GMLIB_API", "getAllPlayerUuids", []() -> std::vector<std::string> {
         return GMLIB_Player::getAllUuids();
     });
+    RemoteCall::exportAs("GMLIB_API", "getPlayerNbt", [](std::string uuid) -> std::string {
+        auto uid = mce::UUID::fromString(uuid);
+        return GMLIB_Player::getPlayerNbt(uid)->toSnbt();
+    });
+    RemoteCall::exportAs("GMLIB_API", "setPlayerNbt", [](std::string uuid, std::string snbt) -> bool {
+        auto uid = mce::UUID::fromString(uuid);
+        auto nbt = CompoundTag::fromSnbt(snbt);
+        return GMLIB_Player::setPlayerNbt(uid, *nbt);
+    });
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "setPlayerNbtTags",
+        [](std::string uuid, std::string snbt, std::vector<std::string> tags) -> bool {
+            auto uid = mce::UUID::fromString(uuid);
+            auto nbt = CompoundTag::fromSnbt(snbt);
+            return GMLIB_Player::setPlayerNbtTags(uid, *nbt, tags);
+        }
+    );
+    RemoteCall::exportAs("GMLIB_API", "getAllExperiments", []() -> std::vector<int> {
+        auto             map = GMLIB_Level::getAllExperiments();
+        std::vector<int> result;
+        for (auto& key : map) {
+            result.push_back(key.first);
+        }
+        return result;
+    });
+    RemoteCall::exportAs("GMLIB_API", "getExperimentTranslatedName", [](int id) -> std::string {
+        auto map = GMLIB_Level::getAllExperimentsTranslateKeys();
+        if (map.count(id)) {
+            return std::string(map[id]);
+        }
+        return "";
+    });
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "createFloatingText",
+        [](std::pair<Vec3, int> pos, std::string text, bool papi) -> int {
+            auto ft = new GMLIB::Server::FloatingText(text, pos.first, pos.second, papi);
+            return ft->getRuntimeID();
+        }
+    );
+    RemoteCall::exportAs("GMLIB_API", "setFloatingTextData", [](int id, std::string text) -> bool {
+        auto ft = GMLIB::Server::FloatingText::getFloatingText(id);
+        if (ft) {
+            ft->setText(text);
+            return true;
+        }
+        return false;
+    });
+    RemoteCall::exportAs("GMLIB_API", "deleteFloatingText", [](int id) -> bool {
+        return GMLIB::Server::FloatingText::deleteFloatingText(id);
+    });
+    RemoteCall::exportAs("GMLIB_API", "sendFloatingTextToPlayer", [](int id, Player* pl) -> bool {
+        auto ft = GMLIB::Server::FloatingText::getFloatingText(id);
+        if (ft) {
+            ft->sendToClient(pl);
+            return true;
+        }
+        return false;
+    });
+    RemoteCall::exportAs("GMLIB_API", "sendFloatingText", [](int id) -> bool {
+        auto ft = GMLIB::Server::FloatingText::getFloatingText(id);
+        if (ft) {
+            ft->sendToAllClients();
+            return true;
+        }
+        return false;
+    });
+    RemoteCall::exportAs("GMLIB_API", "removeFloatingTextFromPlayer", [](int id, Player* pl) -> bool {
+        auto ft = GMLIB::Server::FloatingText::getFloatingText(id);
+        if (ft) {
+            ft->removeFromClient(pl);
+            return true;
+        }
+        return false;
+    });
+    RemoteCall::exportAs("GMLIB_API", "removeFloatingText", [](int id) -> bool {
+        auto ft = GMLIB::Server::FloatingText::getFloatingText(id);
+        if (ft) {
+            ft->removeFromAllClients();
+            return true;
+        }
+        return false;
+    });
+    RemoteCall::exportAs("GMLIB_API", "updateClientFloatingTextData", [](int id, Player* pl) -> bool {
+        auto ft = GMLIB::Server::FloatingText::getFloatingText(id);
+        if (ft) {
+            ft->updateClient(pl);
+            return true;
+        }
+        return false;
+    });
+    RemoteCall::exportAs("GMLIB_API", "updateAllClientsFloatingTextData", [](int id) -> bool {
+        auto ft = GMLIB::Server::FloatingText::getFloatingText(id);
+        if (ft) {
+            ft->updateAllClients();
+            return true;
+        }
+        return false;
+    });
+    RemoteCall::exportAs("GMLIB_API", "isVersionMatched", [](int a, int b, int c) -> bool {
+        auto version = SemVersion(a, b, c, "", "");
+        return LIB_VERSION.satisfies(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",
+        "resourcePackTranslate",
+        [](std::string key, std::vector<std::string> params) -> std::string { return I18n::get(key, params); }
+    );
+    RemoteCall::exportAs("GMLIB_API", "chooseResourcePackI18nLanguage", [](std::string code) -> void {
+        I18n::chooseLanguage(code);
+    });
 }

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,58 @@
+#include "Entry.h"
+#include "Global.h"
+
+ll::Logger logger(PLUGIN_NAME);
+
+namespace GMLIB_LegacyRemoteCallApi {
+
+namespace {
+
+std::unique_ptr<std::reference_wrapper<ll::plugin::NativePlugin>>
+    selfPluginInstance; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+
+auto disable(ll::plugin::NativePlugin& /*self*/) -> bool { return false; }
+
+auto enable(ll::plugin::NativePlugin& /*self*/) -> bool { return true; }
+
+auto load(ll::plugin::NativePlugin& self) -> bool {
+    selfPluginInstance = std::make_unique<std::reference_wrapper<ll::plugin::NativePlugin>>(self);
+    Export_Legacy_GMLib_ModAPI();
+    Export_Legacy_GMLib_ServerAPI();
+    Export_Compatibility_API();
+    ExportPAPI();
+    Export_Event_API();
+    logger.info("GMLIB-LegacyRemoteCallApi Loaded!");
+    logger.info("Version: {}", LIB_VERSION.asString());
+    logger.info("Author: GroupMountain");
+    logger.info("Repository: https://github.com/GroupMountain/GMLIB-LegacyRemoteCallApi");
+    return true;
+}
+
+auto unload(ll::plugin::NativePlugin& self) -> bool { return false; }
+
+} // namespace
+
+auto getSelfPluginInstance() -> ll::plugin::NativePlugin& {
+    if (!selfPluginInstance) {
+        throw std::runtime_error("selfPluginInstance is null");
+    }
+
+    return *selfPluginInstance;
+}
+
+} // namespace GMLIB_LegacyRemoteCallApi
+
+extern "C" {
+_declspec(dllexport) auto ll_plugin_disable(ll::plugin::NativePlugin& self) -> bool {
+    return GMLIB_LegacyRemoteCallApi::disable(self);
+}
+_declspec(dllexport) auto ll_plugin_enable(ll::plugin::NativePlugin& self) -> bool {
+    return GMLIB_LegacyRemoteCallApi::enable(self);
+}
+_declspec(dllexport) auto ll_plugin_load(ll::plugin::NativePlugin& self) -> bool {
+    return GMLIB_LegacyRemoteCallApi::load(self);
+}
+_declspec(dllexport) auto ll_plugin_unload(ll::plugin::NativePlugin& self) -> bool {
+    return GMLIB_LegacyRemoteCallApi::unload(self);
+}
+}

src/Entry.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <ll/api/plugin/NativePlugin.h>
+
+namespace GMLIB_LegacyRemoteCallApi {
+
+[[nodiscard]] auto getSelfPluginInstance() -> ll::plugin::NativePlugin&;
+
+} // namespace GMLIB_LegacyRemoteCallApi

src/EventAPI.cpp

@@ -0,0 +1,162 @@
+#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 eventName, std::string eventId) -> bool {
+            if (RemoteCall::hasFunc(eventName, eventId)) {
+                switch (do_hash(eventName)) {
+                case do_hash("onClientLogin"): {
+                    auto Call = RemoteCall::importAs<
+                        bool(std::string realName, std::string uuid, std::string serverXuid, std::string 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 do_hash("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 do_hash("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 do_hash("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 do_hash("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 do_hash("onTextSend"): {
+                    auto Call = RemoteCall::importAs<bool(std::string author, std::string message)>(eventName, eventId);
+                    eventBus->emplaceListener<GMLIB::Event::PacketEvent::TextPacketSendBeforeEvent>(
+                        [Call](GMLIB::Event::PacketEvent::TextPacketSendBeforeEvent& ev) {
+                            auto pkt    = ev.getPacket();
+                            bool result = true;
+                            try {
+                                result = Call(pkt.mAuthor, pkt.mMessage);
+                            } catch (...) {}
+                            if (!result) {
+                                ev.cancel();
+                            }
+                        }
+                    );
+                    return true;
+                }
+                case do_hash("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 do_hash("onDeathMessage"): {
+                    auto Call = RemoteCall::importAs<bool(std::string 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;
+                }
+                default:
+                    return false;
+                }
+            }
+            return false;
+        }
+    );
+}

src/Global.h

@@ -1,11 +1,15 @@
 #pragma once
 #include <include_all.h>
+
 #include <RemoteCallAPI.h>
 
 #define PLUGIN_NAME "GMLIB-LRCA"
+#define LIB_VERSION SemVersion(0, 9, 1, "", "")
 
 extern ll::Logger logger;
 
 extern void Export_Legacy_GMLib_ModAPI();
 extern void Export_Legacy_GMLib_ServerAPI();
-extern void Export_Compatibility_API();
+extern void Export_Compatibility_API();
+extern void ExportPAPI();
+extern void Export_Event_API();

src/LegacyModApi.cpp

@@ -1,7 +1,6 @@
 #include "Global.h"
 
-std::unordered_set<std::string> HardCodedKeys   = {"AlwaysUnlocked", "PlayerHasManyItems", "PlayerInWater", "None"};
+std::unordered_set<std::string> HardCodedKeys = {"AlwaysUnlocked", "PlayerHasManyItems", "PlayerInWater", "None"};
-std::unordered_set<int>         ExperimentsList = {6, 7, 8, 9, 10, 12, 15, 16};
 
 std::variant<std::string, std::vector<RecipeIngredient>> makeRecipeUnlockingKey(std::string& key) {
     if (HardCodedKeys.count(key)) {
@@ -23,6 +22,10 @@ void Export_Legacy_GMLib_ModAPI() {
            std::string              result,
            int                      count,
            std::string              unlock) -> void {
+            auto level = GMLIB_Level::getLevel();
+            if (!level) {
+                return;
+            }
             std::vector<RecipeIngredient> types;
             for (auto ing : ingredients) {
                 auto key = RecipeIngredient(ing, 0, 1);
@@ -42,6 +45,10 @@ void Export_Legacy_GMLib_ModAPI() {
            std::string              result,
            int                      count,
            std::string              unlock) -> void {
+            auto level = GMLIB_Level::getLevel();
+            if (!level) {
+                return;
+            }
             std::vector<RecipeIngredient> types;
             for (auto ing : ingredients) {
                 auto key = RecipeIngredient(ing, 0, 1);
@@ -56,6 +63,10 @@ void Export_Legacy_GMLib_ModAPI() {
         "GMLib_ModAPI",
         "registerFurnaceRecipe",
         [](std::string recipe_id, std::string input, std::string output, std::vector<std::string> tags) -> void {
+            auto level = GMLIB_Level::getLevel();
+            if (!level) {
+                return;
+            }
             auto inp  = RecipeIngredient(input, 0, 1);
             auto outp = RecipeIngredient(output, 0, 1);
             GMLIB::Mod::CustomRecipe::registerFurnaceRecipe(recipe_id, inp, outp, tags);
@@ -65,6 +76,10 @@ void Export_Legacy_GMLib_ModAPI() {
         "GMLib_ModAPI",
         "registerBrewingMixRecipe",
         [](std::string recipe_id, std::string input, std::string output, std::string reagent) -> void {
+            auto level = GMLIB_Level::getLevel();
+            if (!level) {
+                return;
+            }
             auto rea = RecipeIngredient(reagent, 0, 1);
             GMLIB::Mod::CustomRecipe::registerBrewingMixRecipe(recipe_id, input, output, rea);
         }
@@ -73,6 +88,10 @@ void Export_Legacy_GMLib_ModAPI() {
         "GMLib_ModAPI",
         "registerBrewingContainerRecipe",
         [](std::string recipe_id, std::string input, std::string output, std::string reagent) -> void {
+            auto level = GMLIB_Level::getLevel();
+            if (!level) {
+                return;
+            }
             auto inp  = RecipeIngredient(input, 0, 1);
             auto outp = RecipeIngredient(output, 0, 1);
             auto rea  = RecipeIngredient(reagent, 0, 1);
@@ -87,6 +106,10 @@ void Export_Legacy_GMLib_ModAPI() {
            std::string base,
            std::string addition,
            std::string result) -> void {
+            auto level = GMLIB_Level::getLevel();
+            if (!level) {
+                return;
+            }
             GMLIB::Mod::CustomRecipe::registerSmithingTransformRecipe(
                 recipe_id,
                 smithing_template,
@@ -100,6 +123,10 @@ void Export_Legacy_GMLib_ModAPI() {
         "GMLib_ModAPI",
         "registerSmithingTrimRecipe",
         [](std::string recipe_id, std::string smithing_template, std::string base, std::string addition) -> void {
+            auto level = GMLIB_Level::getLevel();
+            if (!level) {
+                return;
+            }
             GMLIB::Mod::CustomRecipe::registerSmithingTrimRecipe(recipe_id, smithing_template, base, addition);
         }
     );
@@ -112,6 +139,10 @@ void Export_Legacy_GMLib_ModAPI() {
            std::string output,
            int         output_data,
            int         output_count) -> void {
+            auto level = GMLIB_Level::getLevel();
+            if (!level) {
+                return;
+            }
             auto inp  = RecipeIngredient(input, 0, 1);
             auto outp = RecipeIngredient(output, 0, 1);
             GMLIB::Mod::CustomRecipe::registerStoneCutterRecipe(recipe_id, inp, outp);
@@ -123,19 +154,30 @@ void Export_Legacy_GMLib_ModAPI() {
     });
     // 实验性
     RemoteCall::exportAs("GMLib_ModAPI", "registerExperimentsRequire", [](int experiment_id) -> void {
-        if (ExperimentsList.count(experiment_id)) {
+        auto map = GMLIB_Level::getAllExperiments();
+        if (map.count(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 {
-        if (ExperimentsList.count(experiment_id)) {
+        auto level = GMLIB_Level::getLevel();
+        if (!level) {
+            return;
+        }
+        auto map = GMLIB_Level::getAllExperiments();
+        if (map.count(experiment_id)) {
             GMLIB_Level::getLevel()->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 {
-        if (ExperimentsList.count(experiment_id)) {
+        auto level = GMLIB_Level::getLevel();
+        if (!level) {
+            return false;
+        }
+        auto map = GMLIB_Level::getAllExperiments();
+        if (map.count(experiment_id)) {
             return GMLIB_Level::getLevel()->getExperimentEnabled(((AllExperiments)experiment_id));
         } else {
             ll::Logger("Server").error("Experiment ID '{}' does not exist!", experiment_id);

src/LegacyServerApi.cpp

@@ -1,49 +1,52 @@
 #include "Global.h"
 
 void Export_Legacy_GMLib_ServerAPI() {
-    RemoteCall::exportAs("GMLib_ServerAPI", "setEducationFeatureEnabled", []() -> void { 
+    RemoteCall::exportAs("GMLib_ServerAPI", "setEducationFeatureEnabled", []() -> void {
         GMLIB_Level::addEducationEditionRequired();
     });
-    RemoteCall::exportAs("GMLib_ServerAPI", "registerAbilityCommand", []() -> void { 
+    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 {
+    RemoteCall::exportAs("GMLib_ServerAPI", "setEnableAchievement", []() -> void {
-        auto ft = new FloatingText(text, pos.first, pos.second);
-        return ft->mRuntimeId;
-    });
-    RemoteCall::exportAs("GMLib_ServerAPI", "deleteFloatingTextPacket", [](int id) -> void { 
-        FloatingText::deleteFloatingText(id);
-    });
-    RemoteCall::exportAs("GMLib_ServerAPI", "setEnableAchievement", []() -> void { 
         GMLIB_Level::setForceAchievementsEnabled();
     });
-    RemoteCall::exportAs("GMLib_ServerAPI", "setForceTrustSkins", []() -> void { 
+    RemoteCall::exportAs("GMLib_ServerAPI", "setForceTrustSkins", []() -> void { GMLIB_Level::setForceTrustSkin(); });
-        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", "enableCoResourcePack", []() -> void { 
+    RemoteCall::exportAs("GMLib_ServerAPI", "setLevelName", [](std::string name) -> void {
-        GMLIB_Level::setCoResourcePack();
+        auto level = GMLIB_Level::getLevel();
+        if (!level) {
+            return;
+        }
+        return level->setLevelName(name);
     });
-    RemoteCall::exportAs("GMLib_ServerAPI", "getLevelName", []() -> std::string { 
+    RemoteCall::exportAs("GMLib_ServerAPI", "setFakeSeed", [](int64_t seed) -> void {
-        return GMLIB_Level::getLevel()->getLevelName();
+        return GMLIB_Level::setFakeSeed(seed);
     });
-    RemoteCall::exportAs("GMLib_ServerAPI", "setLevelName", [](std::string name) -> void { 
+    RemoteCall::exportAs("GMLib_ServerAPI", "spawnEntity", [](std::pair<Vec3, int> pos, std::string name) -> Actor* {
-        GMLIB_Level::getLevel()->setLevelName(name);
-    });
-    RemoteCall::exportAs("GMLib_ServerAPI", "setFakeSeed", [](int64_t seed) -> void { 
-        GMLIB_Level::getLevel()->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);
     });
-    RemoteCall::exportAs("GMLib_ServerAPI", "shootProjectile", [](Actor* owner, std::string name, float speed, float offset) -> Actor* { 
+    RemoteCall::exportAs(
-        auto ac = (GMLIB_Actor*)owner;
+        "GMLib_ServerAPI",
-        return ac->shootProjectile(name, speed, offset);
+        "shootProjectile",
-    });
+        [](Actor* owner, std::string name, float speed, float offset) -> Actor* {
-    RemoteCall::exportAs("GMLib_ServerAPI", "throwEntity", [](Actor* owner, Actor* actor, float speed, float offset) -> bool {
+            auto ac = (GMLIB_Actor*)owner;
-        auto ac = (GMLIB_Actor*)owner;
+            return ac->shootProjectile(name, speed, offset);
-        return ac->throwEntity(actor, speed, offset);
+        }
-    });
+    );
-    RemoteCall::exportAs("GMLib_ServerAPI", "PlayerToEntity", [](Player* player) -> Actor* { 
+    RemoteCall::exportAs(
-        return (Actor*)player;
+        "GMLib_ServerAPI",
-    });
+        "throwEntity",
+        [](Actor* owner, Actor* actor, float speed, float offset) -> bool {
+            auto ac = (GMLIB_Actor*)owner;
+            return ac->throwEntity(actor, speed, offset);
+        }
+    );
+    RemoteCall::exportAs("GMLib_ServerAPI", "PlayerToEntity", [](Player* player) -> Actor* { return (Actor*)player; });
 }

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,98 @@
+#include "Global.h"
+#include <regex>
+
+namespace PAPIRemoteCall {
+
+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)) {
+        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)) {
+        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)) {
+        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

@@ -0,0 +1,29 @@
+{
+    "format_version": 2,
+    "tooth": "github.com/GroupMountain/GMLIB-LegacyRemoteCallApi",
+    "version": "0.9.1",
+    "info": {
+        "name": "GMLIB-LegacyRemoteCallApi",
+        "description": "Legacy RemoteCall API for GMLIB",
+        "source": "github.com/GroupMountain/GMLIB-LegacyRemoteCallApi",
+        "author": "GroupMountain",
+        "tags": [
+            "levilamina",
+            "gmlib",
+            "lse",
+            "library"
+        ]
+    },
+    "asset_url": "https://github.com/GroupMountain/GMLIB-LegacyRemoteCallApi/releases/download/v0.9.1/GMLIB-LegacyRemoteCallApi-windows-x64.zip",
+    "dependencies": {
+        "github.com/GroupMountain/GMLIB": ">=0.9.2"
+    },
+    "files": {
+        "place": [
+            {
+                "src": "GMLIB-LegacyRemoteCallApi/*",
+                "dest": "plugins/GMLIB-LegacyRemoteCallApi"
+            }
+        ]
+    }
+}