refactor: rewrite experiments shit

lib/GMLIB_API-JS.js

@@ -16,6 +16,8 @@ const GMLIB_API = {
     setPlayerNbt: ll.import("GMLIB_API", "setPlayerNbt"),
     setPlayerNbtTags: ll.import("GMLIB_API", "setPlayerNbtTags"),
     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"),
@@ -31,9 +33,10 @@ const GMLIB_API = {
     PlayerToEntity: ll.import("GMLib_ServerAPI", "PlayerToEntity"),
     setUnknownBlockCleaner: ll.import("GMLib_ModAPI", "setUnknownBlockCleaner"),
     getAllExperiments: ll.import("GMLIB_API", "getAllExperiments"),
-    getExperimentTranslatedName: ll.import("GMLIB_API", "getExperimentTranslatedName"),
+    getExperimentTranslateKey: ll.import("GMLIB_API", "getExperimentTranslateKey"),
     getExperimentEnabled: ll.import("GMLib_ModAPI", "getExperimentEnabled"),
     setExperimentEnabled: ll.import("GMLib_ModAPI", "setExperimentEnabled"),
+    unregisterRecipe: ll.import("GMLIB_API", "unregisterRecipe"),
     registerExperimentsRequire: ll.import("GMLib_ModAPI", "registerExperimentsRequire"),
     registerStoneCutterRecipe: ll.import("GMLib_ModAPI", "registerStoneCutterRecipe"),
     registerSmithingTrimRecipe: ll.import("GMLib_ModAPI", "registerSmithingTrimRecipe"),
@@ -87,7 +90,13 @@ const GMLIB_API = {
     setWorldSpawn: ll.import("GMLIB_API", "setWorldSpawn"),
     getPlayerSpawnPoint: ll.import("GMLIB_API", "getPlayerSpawnPoint"),
     setPlayerSpawnPoint: ll.import("GMLIB_API", "setPlayerSpawnPoint"),
-    clearPlayerSpawnPoint: ll.import("GMLIB_API", "clearPlayerSpawnPoint")
+    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")
 }
 
 const FloatingTextList = [];
@@ -99,10 +108,6 @@ class StaticFloatingText {
         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) {
@@ -278,22 +283,15 @@ class Minecraft {
     }
 
     static getPlayerNbt(uuid) {
-        let snbt = GMLIB_API.getPlayerNbt(uuid);
-        if (snbt == "null") {
-            return null;
-        }
-        let nbt = NBT.parseSNBT(snbt);
-        return nbt;
+        return GMLIB_API.getPlayerNbt(uuid);
     }
 
     static setPlayerNbt(uuid, nbt, forceCreate = true) {
-        let snbt = nbt.toSNBT();
-        return GMLIB_API.setPlayerNbt(uuid, snbt, forceCreate);
+        return GMLIB_API.setPlayerNbt(uuid, nbt, forceCreate);
     }
 
     static setPlayerNbtTags(uuid, nbt, tags) {
-        let snbt = nbt.toSNBT();
-        return GMLIB_API.setPlayerNbtTags(uuid, snbt, tags);
+        return GMLIB_API.setPlayerNbtTags(uuid, nbt, tags);
     }
 
     static getPlayerPosition(uuid) {
@@ -316,18 +314,6 @@ class Minecraft {
         return GMLIB_API.setWorldSpawn(pos);
     }
 
-    static getPlayerSpawnPoint() {
-        return GMLIB_API.getPlayerSpawnPoint();
-    }
-
-    static setPlayerSpawnPoint(pos) {
-        GMLIB_API.setPlayerSpawnPoint(pos);
-    }
-
-    static clearPlayerSpawnPoint() {
-        GMLIB_API.clearPlayerSpawnPoint();
-    }
-
     static setEducationFeatureEnabled() {
         return GMLIB_API.setEducationFeatureEnabled();
     }
@@ -364,10 +350,6 @@ class Minecraft {
         return GMLIB_API.setUnknownBlockCleaner();
     }
 
-    static playerToEntity(player) {
-        return GMLIB_API.PlayerToEntity(player);
-    }
-
     static spawnEntity(pos, name) {
         return GMLIB_API.spawnEntity(pos, name);
     }
@@ -380,12 +362,20 @@ class Minecraft {
         return GMLIB_API.throwEntity(entity, proj, speed = 2, offset = 3);
     }
 
-    static chooseResourcePackI18nLanguage(language) {
-        return GMLIB_API.chooseResourcePackI18nLanguage(language);
+    static getServerLanguage() {
+        return I18nAPI.getCurrentLanguage();
+    }
+
+    static setServerLanguage(language) {
+        return I18nAPI.chooseLanguage(language);
+    }
+
+    static setCustomPackPath(path) {
+        GMLIB_API.setCustomPackPath(path);
     }
 
     static resourcePackTranslate(key, params = []) {
-        return GMLIB_API.resourcePackTranslate(key, params);
+        return I18nAPI.get(key, params);
     }
 }
 
@@ -394,6 +384,10 @@ class Recipes {
         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);
     }
@@ -438,18 +432,8 @@ class Experiments {
         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 getExperimentTranslateKey(id) {
+        return GMLIB_API.getExperimentTranslateKey(id);
     }
 
     static getExperimentEnabled(id) {
@@ -465,21 +449,62 @@ class Experiments {
     }
 }
 
-class GMLIB {
-    constructor() {
-        throw new Error("Static class cannot be instantiated");
+class Version {
+    constructor(major, minor, patch) {
+        this.mMajor = major;
+        this.mMinor = minor;
+        this.mPatch = patch;
     }
 
-    static isVersionMatched(major, minor, patch) {
-        return GMLIB_API.isVersionMatched(major, minor, patch);
+    toString(prefix = true) {
+        let result = `${this.mMajor}.${this.mMinor}.${this.mPatch}`;
+        if (prefix) {
+            result = "v" + result;
+        }
+        return result;
     }
 
-    static getVersion_LRCA() {
-        return GMLIB_API.getVersion_LRCA();
+    toArray() {
+        return [this.mMajor, this.mMinor, this.mPatch];
     }
 
-    static getVersion_GMLIB() {
-        return GMLIB_API.getVersion_GMLIB();
+    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());
     }
 }
 
@@ -649,12 +674,20 @@ 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);
-            this.mData = Object.assign({}, this.mData, JSON.parse(existDataStr));
+            existDataStr = existDataStr.replace(/\/\/.*|\/\*[^]*?\*\//g, "");
+            try {
+                let result = GMLIB_API.mergePatchJson(JSON.stringify(this.mData), existDataStr);
+                this.mData = JSON.parse(result);
+            } catch {
+                let newPath = this.mPath + "_old";
+                File.rename(this.mPath, newPath);
+            }
         }
         this.save();
     }
@@ -668,9 +701,9 @@ class JsonConfig {
         return this.mData;
     }
 
-    get(key, defultValue = null) {
+    get(key, defultValue = undefined) {
         let result = this.getData()[key];
-        if (!result && defultValue != null) {
+        if (!result && defultValue != undefined) {
             this.set(key, defultValue);
             return defultValue;
         }
@@ -688,13 +721,149 @@ class JsonConfig {
     }
 }
 
+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);
+    }
+};
+
+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);
+}
+
 module.exports = {
     StaticFloatingText,
     DynamicFloatingText,
     Minecraft,
     Recipes,
     Experiments,
-    GMLIB,
     Scoreboard,
-    JsonConfig
+    JsonConfig,
+    JsonLanguage,
+    JsonI18n,
+    Version,
+    I18nAPI
 };

manifest.json

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

src/CompatibilityApi.cpp

@@ -14,6 +14,16 @@ ActorUniqueID parseScriptUniqueID(std::string uniqueId) {
 }
 
 void Export_Compatibility_API() {
+    RemoteCall::exportAs("GMLIB_API", "unregisterRecipe", [](std::string id) -> bool {
+        auto level = GMLIB_Level::getInstance();
+        if (!level) {
+            return false;
+        }
+        return GMLIB::Mod::CustomRecipe::unregisterRecipe(id);
+    });
+    RemoteCall::exportAs("GMLIB_API", "setCustomPackPath", [](std::string path) -> void {
+        GMLIB::Mod::CustomPacks::addCustomPackPath(path);
+    });
     RemoteCall::exportAs("GMLIB_API", "getServerMspt", []() -> float {
         auto level = GMLIB_Level::getInstance();
         if (!level) {
@@ -43,25 +53,19 @@ void Export_Compatibility_API() {
         }
         return result;
     });
-    RemoteCall::exportAs("GMLIB_API", "getPlayerNbt", [](std::string uuid) -> std::string {
+    RemoteCall::exportAs("GMLIB_API", "getPlayerNbt", [](std::string uuid) -> std::unique_ptr<CompoundTag> {
         auto uid = mce::UUID::fromString(uuid);
-        auto nbt = GMLIB_Player::getPlayerNbt(uid);
-        if (nbt) {
-            return nbt->toSnbt();
-        }
-        return "null";
+        return std::move(GMLIB_Player::getPlayerNbt(uid));
     });
-    RemoteCall::exportAs("GMLIB_API", "setPlayerNbt", [](std::string uuid, std::string snbt, bool forceCreate) -> bool {
+    RemoteCall::exportAs("GMLIB_API", "setPlayerNbt", [](std::string uuid, CompoundTag* nbt, bool forceCreate) -> bool {
         auto uid = mce::UUID::fromString(uuid);
-        auto nbt = CompoundTag::fromSnbt(snbt);
         return GMLIB_Player::setPlayerNbt(uid, *nbt, forceCreate);
     });
     RemoteCall::exportAs(
         "GMLIB_API",
         "setPlayerNbtTags",
-        [](std::string uuid, std::string snbt, std::vector<std::string> tags) -> bool {
+        [](std::string uuid, CompoundTag* nbt, std::vector<std::string> tags) -> bool {
             auto uid = mce::UUID::fromString(uuid);
-            auto nbt = CompoundTag::fromSnbt(snbt);
             return GMLIB_Player::setPlayerNbtTags(uid, *nbt, tags);
         }
     );
@@ -73,18 +77,18 @@ void Export_Compatibility_API() {
         }
         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", "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 text, bool papi) -> int {
-            auto ft = new GMLIB::Server::FloatingText(text, pos.first, pos.second, papi);
+            auto ft = new GMLIB::Server::StaticFloatingText(text, pos.first, pos.second, papi);
             return ft->getRuntimeID();
         }
     );
@@ -102,7 +106,7 @@ void Export_Compatibility_API() {
     RemoteCall::exportAs("GMLIB_API", "sendFloatingTextToPlayer", [](int id, Player* pl) -> bool {
         auto ft = GMLIB::Server::FloatingText::getFloatingText(id);
         if (ft) {
-            ft->sendToClient(pl);
+            ft->sendToClient(*pl);
             return true;
         }
         return false;
@@ -118,7 +122,7 @@ void Export_Compatibility_API() {
     RemoteCall::exportAs("GMLIB_API", "removeFloatingTextFromPlayer", [](int id, Player* pl) -> bool {
         auto ft = GMLIB::Server::FloatingText::getFloatingText(id);
         if (ft) {
-            ft->removeFromClient(pl);
+            ft->removeFromClient(*pl);
             return true;
         }
         return false;
@@ -134,7 +138,7 @@ void Export_Compatibility_API() {
     RemoteCall::exportAs("GMLIB_API", "updateClientFloatingTextData", [](int id, Player* pl) -> bool {
         auto ft = GMLIB::Server::FloatingText::getFloatingText(id);
         if (ft) {
-            ft->updateClient(pl);
+            ft->updateClient(*pl);
             return true;
         }
         return false;
@@ -148,20 +152,60 @@ void Export_Compatibility_API() {
         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);
+        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 key, std::vector<std::string> params) -> std::string { return I18nAPI::get(key, params); }
+    );
     RemoteCall::exportAs(
         "GMLIB_API",
         "resourcePackTranslate",
-        [](std::string key, std::vector<std::string> params) -> std::string { return I18n::get(key, params); }
+        [](std::string key, std::vector<std::string> params, std::string code) -> std::string {
+            return I18nAPI::get(key, params, code);
+        }
     );
     RemoteCall::exportAs("GMLIB_API", "chooseResourcePackI18nLanguage", [](std::string code) -> void {
-        I18n::chooseLanguage(code);
+        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 code, std::string lang) -> void {
+        if (GMLIB_Level::getInstance()) {
+            I18nAPI::loadLanguage(code, lang);
+        }
+    });
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "updateOrCreateLanguageFile",
+        [](std::string code, std::string lang, std::string path) -> void {
+            if (GMLIB_Level::getInstance()) {
+                I18nAPI::updateOrCreateLanguageFile(path, code, lang);
+            }
+        }
+    );
+    RemoteCall::exportAs("GMLIB_API", "loadLanguagePath", [](std::string path) -> void {
+        if (GMLIB_Level::getInstance()) {
+            I18nAPI::loadLanguagesFromDirectory(path);
+        }
     });
     RemoteCall::exportAs("GMLIB_API", "getPlayerPosition", [](std::string uuid) -> std::pair<BlockPos, int> {
         auto uid = mce::UUID::fromString(uuid);
@@ -376,7 +420,7 @@ void Export_Compatibility_API() {
         auto                     auids = GMLIB_Scoreboard::getInstance()->getInstance()->getAllEntities();
         std::vector<std::string> result;
         for (auto auid : auids) {
-            result.push_back(std::to_string(auid.get()));
+            result.push_back(std::to_string(auid.id));
         }
         return result;
     });
@@ -415,4 +459,10 @@ void Export_Compatibility_API() {
         auto player = (GMLIB_Player*)pl;
         player->clearSpawnPoint();
     });
+    RemoteCall::exportAs("GMLIB_API", "mergePatchJson", [](std::string oldJson, std::string patchJson) -> std::string {
+        auto oldData = nlohmann::ordered_json::parse(oldJson);
+        auto newData = nlohmann::ordered_json::parse(patchJson);
+        oldData.merge_patch(newData);
+        return oldData.dump();
+    });
 }

src/Entry.cpp

@@ -17,7 +17,11 @@ bool LRCA::load() {
     ExportPAPI();
     Export_Event_API();
     logger.info("GMLIB-LegacyRemoteCallApi Loaded!");
-    logger.info("Version: {}", LIB_VERSION.asString());
+    logger.info(
+        "Loaded Version: {} with {}",
+        fmt::format(fg(fmt::color::pink), "GMLIB-" + 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;

src/EventAPI.cpp

@@ -105,14 +105,13 @@ void Export_Event_API() {
                     );
                     return true;
                 }
-                case doHash("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();
+                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(pkt.mAuthor, pkt.mMessage);
+                                result = Call(&ev.self(), ev.getToDimensionId());
                             } catch (...) {}
                             if (!result) {
                                 ev.cancel();
@@ -152,6 +151,44 @@ void Export_Event_API() {
                     );
                     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;
                 }

src/Global.h

@@ -3,8 +3,9 @@
 
 #include <RemoteCallAPI.h>
 
-#define PLUGIN_NAME "GMLIB-LRCA"
-#define LIB_VERSION SemVersion(0, 9, 4, "", "")
+#define PLUGIN_NAME fmt::format(fg(fmt::color::light_green), "GMLIB-LRCA")
+
+#define LIB_VERSION GMLIB::Version(0, 12, 5)
 
 extern ll::Logger logger;
 

src/LegacyServerApi.cpp

@@ -2,16 +2,18 @@
 
 void Export_Legacy_GMLib_ServerAPI() {
     RemoteCall::exportAs("GMLib_ServerAPI", "setEducationFeatureEnabled", []() -> void {
-        GMLIB_Level::addEducationEditionRequired();
+        GMLIB_Level::tryEnableEducationEdition();
     });
     RemoteCall::exportAs("GMLib_ServerAPI", "registerAbilityCommand", []() -> void {
-        GMLIB_Level::forceEnableAbilityCommand();
+        GMLIB_Level::tryRegisterAbilityCommand();
     });
     RemoteCall::exportAs("GMLib_ServerAPI", "setEnableAchievement", []() -> void {
         GMLIB_Level::setForceAchievementsEnabled();
     });
-    RemoteCall::exportAs("GMLib_ServerAPI", "setForceTrustSkins", []() -> void { GMLIB_Level::setForceTrustSkin(); });
-    RemoteCall::exportAs("GMLib_ServerAPI", "enableCoResourcePack", []() -> void { GMLIB_Level::setCoResourcePack(); });
+    RemoteCall::exportAs("GMLib_ServerAPI", "setForceTrustSkins", []() -> void { GMLIB_Level::trustAllSkins(); });
+    RemoteCall::exportAs("GMLib_ServerAPI", "enableCoResourcePack", []() -> void {
+        GMLIB_Level::requireServerResourcePackAndAllowClientResourcePack();
+    });
     RemoteCall::exportAs("GMLib_ServerAPI", "getLevelName", []() -> std::string {
         auto level = GMLIB_Level::getInstance();
         if (!level) {

src/PlaceholderApi.cpp

@@ -3,6 +3,16 @@
 
 namespace PAPIRemoteCall {
 
+std::string removeBrackets(std::string a1) {
+    a1.erase(a1.find_last_not_of("%") + 1);
+    return a1;
+}
+
+bool isParameters(std::string 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) {
@@ -15,12 +25,24 @@ bool registerPlayerPlaceholder(
     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;
@@ -32,12 +54,22 @@ bool registerServerPlaceholder(
     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;
@@ -50,6 +82,7 @@ bool registerStaticPlaceholder(
     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(
@@ -65,6 +98,7 @@ bool registerStaticPlaceholder(
                     PluginName
                 );
             }
+        }
         return true;
     }
     return false;

tooth.json

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