Merge pull request #40 from GroupMountain/zimuya4153

adapt: adapt to GMLIB v0.13.7

.github/workflows/build.yml

@@ -9,12 +9,10 @@ jobs:
     steps:
       - name: Checkout repository
         uses: actions/checkout@v2
-        with:
-          submodules: recursive
-
-      - uses: actions/checkout@v4
 
       - uses: xmake-io/github-action-setup-xmake@v1
+        with:
+          xmake-version: "2.9.3"
       
       - run: |
           xmake repo -u

.github/workflows/release.yml

@@ -9,12 +9,10 @@ jobs:
     steps:
       - name: Checkout repository
         uses: actions/checkout@v2
-        with:
-          submodules: recursive
-
-      - uses: actions/checkout@v4
 
       - uses: xmake-io/github-action-setup-xmake@v1
+        with:
+          xmake-version: "2.9.3"
       
       - run: |
           xmake repo -u

.gitignore

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

.gitmodules

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

README.md

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

lib/BEPlaceholderAPI-JS.d.ts

@@ -0,0 +1,72 @@
+declare class PAPI {
+    /** 注册一个玩家PAPI变量 */
+    static registerPlayerPlaceholder(
+        /** PAPI调用函数 */
+        func: (
+            /** 玩家对象 */
+            player: Player,
+            /** 变量参数 */
+            param: null | object.<string, string>
+        ) => string,
+        /** 插件名字 */
+        pluginsName: string,
+        /** PAPI变量 */
+        PAPIName: string
+    ): boolean;
+
+    /** 注册一个服务器PAPI变量 */
+    static registerServerPlaceholder(
+        /** PAPI调用函数 */
+        func: (
+            /** 变量参数 */
+            param: null | object.<string, string>
+        ) => string,
+        /** 插件名字 */
+        pluginsName: string,
+        /** PAPI变量 */
+        PAPIName: string
+    ): boolean;
+
+    /** 注册一个静态PAPI变量 */
+    static registerStaticPlaceholder(
+        /** PAPI调用函数 */
+        func: () => string,
+        /** 插件名字 */
+        pluginsName: string,
+        /** PAPI变量 */
+        PAPIName: string,
+        /** 更新时间 */
+        UpdateInterval: number
+    ): boolean;
+
+    /** 获取一个服务器变量的值 */
+    static getValue(
+        /** PAPI名 */
+        key: string
+    ): string;
+
+    /** 获取一个玩家变量的值 */
+    static getValueByPlayer(
+        /** PAPI名 */
+        key: string,
+        /** 玩家对象 */
+        pl: Player
+    ): string;
+
+    /** 翻译带PAPI变量的字符串 */
+    static translateString(
+        /** 要翻译的字符串 */
+        str: string,
+        /** 玩家对象 */
+        pl: Player | undefined
+    ): string;
+
+    /** 注销一个PAPI变量 */
+    static unRegisterPlaceholder(
+        /** PAPI名 */
+        str: string
+    ): boolean;
+
+    /** 获取所有已注册的PAPI变量 */
+    static getAllPAPI(): string[];
+}

lib/BEPlaceholderAPI-JS.js

@@ -1,47 +1,117 @@
 const PlaceholderAPI = {
+    /** 获取一个服务器变量的值 @type {function(string):string} */
     getValueAPI: ll.import("BEPlaceholderAPI", "GetValue"),
+    /** 获取一个玩家变量的值 @type {function(string,Player):string} */
     getValueByPlayerAPI: ll.import("BEPlaceholderAPI", "GetValueWithPlayer"),
+    /** 注册一个玩家变量 @type {function(string,string,string):boolean} */
     registerPlayerPlaceholderAPI: ll.import("BEPlaceholderAPI", "registerPlayerPlaceholder"),
+    /** 注册一个服务器变量 @type {function(string,string,string):boolean} */
     registerServerPlaceholderAPI: ll.import("BEPlaceholderAPI", "registerServerPlaceholder"),
+    /** 注册一个静态变量 @type {function(string,string,string,number):boolean} */
     registerStaticPlaceholderAPI: ll.import("BEPlaceholderAPI", "registerStaticPlaceholder"),
+    /** 翻译包含PAPI服务器变量的字符串 @type {function(string):string} */
     translateStringAPI: ll.import("BEPlaceholderAPI", "translateString"),
+    /** 翻译包含PAPI玩家变量的字符串 @type {function(string,Player):string} */
     translateStringWithPlayerAPI: ll.import("BEPlaceholderAPI", "translateStringWithPlayer"),
+    /** 注销PAPI变量 @type {function(string):boolean} */
     unRegisterPlaceholderAPI: ll.import("BEPlaceholderAPI", "unRegisterPlaceholder"),
+    /** 获取所有已注册的PAPI变量 @type {function():Array.<string>} */
     getAllPAPI: ll.import("BEPlaceholderAPI", "getAllPAPI")
 }
 
-Function.prototype.getName = function () {
+Function.prototype.getName =
-    return this.name || this.toString().match(/function\s*([^(]*)\(/)[1]
+    /**
+     * 获取函数名字
+     * @returns {string}
+     */
+    function () {
+        return this.name || this.toString().match(/function\s*([^(]*)\(/)?.[1] || getStringHashCode(this.toString()).toString(16);
+    }
+
+/**
+ * 获取字符串哈希值
+ * @param {string} str 字符串
+ * @returns {number}
+ */
+function getStringHashCode(str) {
+    let hash = 0, chr;
+    if (str.length === 0) return hash;
+    for (let i = 0; i < str.length; i++) {
+        chr = str.charCodeAt(i);
+        hash = ((hash << 5) - hash) + chr;
+        hash |= 0;
+    }
+    return hash;
 }
 
+/** PAPI变量类 */
 class PAPI {
     constructor() {
         throw new Error("Static class cannot be instantiated");
     }
 
+    /**
+     * 注册一个玩家PAPI变量
+     * @param {function} func 变量调用的函数
+     * @param {string} PluginName 插件名字
+     * @param {string} PAPIName PAPI变量名
+     * @returns {boolean} 是否注册成功
+     */
     static registerPlayerPlaceholder(func, PluginName, PAPIName) {
         ll.export(func, PluginName, func.getName());
         return PlaceholderAPI.registerPlayerPlaceholderAPI(PluginName, func.getName(), PAPIName);
     }
 
+    /**
+     * 注册一个服务器PAPI变量
+     * @param {function} func 变量调用的函数
+     * @param {string} PluginName 插件名字
+     * @param {string} PAPIName PAPI变量名
+     * @returns {boolean} 是否注册成功
+     */
     static registerServerPlaceholder(func, PluginName, PAPIName) {
         ll.export(func, PluginName, func.getName());
         return PlaceholderAPI.registerServerPlaceholderAPI(PluginName, func.getName(), PAPIName);
     }
 
+    /**
+     * 注册一个静态PAPI变量
+     * @param {function} func 变量调用的函数
+     * @param {string} PluginName 插件名字
+     * @param {string} PAPIName PAPI变量名
+     * @param {number} [UpdateInterval=50] 更新间隔
+     * @returns {boolean} 是否注册成功
+     */
     static registerStaticPlaceholder(func, PluginName, PAPIName, UpdateInterval = 50) {
         ll.export(func, PluginName, func.getName());
         return PlaceholderAPI.registerStaticPlaceholderAPI(PluginName, func.getName(), PAPIName, UpdateInterval);
     }
 
+    /**
+     * 获取一个服务器变量的值
+     * @param {string} key PAPI变量名
+     * @returns {string} 值
+     */
     static getValue(key) {
         return PlaceholderAPI.getValueAPI(key);
     }
 
+    /**
+     * 获取一个玩家变量的值
+     * @param {string} key PAPI变量名
+     * @param {Player} pl 玩家对象
+     * @returns {string} 值
+     */
     static getValueByPlayer(key, pl) {
         return PlaceholderAPI.getValueByPlayerAPI(key, pl);
     }
 
+    /**
+     * 翻译带PAPI变量的字符串
+     * @param {string} str 字符串
+     * @param {Player} pl 玩家对象
+     * @returns {string} 翻译结果
+     */
     static translateString(str, pl = null) {
         if (pl) {
             return PlaceholderAPI.translateStringWithPlayerAPI(str, pl);
@@ -49,10 +119,19 @@ class PAPI {
         return PlaceholderAPI.translateStringAPI(str);
     }
 
+    /**
+     * 注销一个PAPI变量
+     * @param {string} str PAPI变量名
+     * @returns {boolean} 是否注销成功
+     */
     static unRegisterPlaceholder(str) {
         return PlaceholderAPI.unRegisterPlaceholderAPI(str);
     }
 
+    /**
+     * 获取所有已注册的PAPI变量
+     * @returns {Array.<string>} 已注册的PAPI变量数组
+     */
     static getAllPAPI() {
         return PlaceholderAPI.getAllPAPI();
     }

lib/EventAPI-JS.d.ts

@@ -0,0 +1,251 @@
+/** 事件监听接口 */
+declare class Event {
+    /** 生物捡起物品 */
+    static listen(
+        /** 事件名 */
+        event: "onMobDie",
+        /** 监听函数 */
+        listener: (
+            /** 尝试捡起物品的实体对象 */
+            entity: Entity,
+            /** 掉落物实体对象 */
+            itemEntity: Entity
+        ) => boolean | void
+    ): boolean;
+
+    /** 客户端登录后事件(不可以拦截) */
+    static listen(
+        /** 事件名 */
+        event: "onClientLogin",
+        /** 监听函数 */
+        listener: (
+            /** 玩家的游戏名字 */
+            realName: string,
+            /** 玩家的uuid */
+            uuid: string,
+            /** 玩家在服务端的xuid */
+            serverXuid: string,
+            /** 玩家在客户端的xuid */
+            clientXuid: string
+        ) => void
+    ): boolean;
+
+    /** 天气改变事件事件 */
+    static listen(
+        /** 事件名 */
+        event: "onWeatherChange",
+        /** 监听函数 */
+        listener: (
+            /** 雷暴天气等级 */
+            lightningLevel: number,
+            /** 雨天天气等级 */
+            rainLevel: number,
+            /** 雷暴持续时间（刻） */
+            lightningLastTick: number,
+            /** 雨天持续时间(刻) */
+            rainingLastTick: number
+        ) => boolean | void
+    ): boolean;
+
+    /** 掉落物尝试生成 */
+    static listen(
+        event: "onItemTrySpawn",
+        listener: (
+            /** 物品对象 */
+            item: Item,
+            /** 尝试生成的坐标对象 */
+            pos: FloatPos,
+            /** 创建掉落物的实体uniqueId */
+            spawnerUniqueId: number
+        ) => boolean | void
+    ): boolean;
+
+    /** 掉落物生成完毕(不可以拦截) */
+    static listen(
+        /** 事件名 */
+        event: "onItemSpawned",
+        /** 回调函数 */
+        listener: (
+            /** 物品对象 */
+            item: Item,
+            /** 掉落物实体对象 */
+            entity: Entity,
+            /** 实体生成的坐标 */
+            pos: FloatPos,
+            /** 创建掉落物的实体uniqueId */
+            spawnerUniqueId: number
+        ) => void
+    ): boolean;
+
+    /** 实体切换维度 */
+    static listen(
+        /** 事件名 */
+        event: "onEntityTryChangeDim",
+        /** 回调函数 */
+        listener: (
+            /** 切换维度的实体对象 */
+            entity: Entity,
+            /** 前往到的维度ID */
+            dimid: number
+        ) => boolean | void
+    ): boolean;
+
+    /** 实体切换维度后(不可拦截) */
+    static listen(
+        /** 事件名 */
+        event: "onEntityChangeDim",
+        /** 回调函数 */
+        listener: (
+            /** 切换维度的实体对象 */
+            entity: Entity,
+            /** 前往到的维度ID */
+            fromDimid: number
+        ) => void
+    ): boolean;
+
+    /** 玩家下床 */
+    static listen(
+        /** 事件名 */
+        event: "onLeaveBed",
+        /** 回调函数 */
+        listener: (
+            /** 下床的玩家对象 */
+            player: Player
+        ) => boolean | void
+    ): boolean;
+
+    /** 触发死亡信息(不可以拦截) */
+    static listen(
+        /** 事件名 */
+        event: "onDeathMessage",
+        /** 回调函数 */
+        listener: (
+            /** 死亡信息键名 */
+            deathMsgKey: string,
+            /** 死亡信息翻译参数 */
+            deathMsgParams: string[],
+            /** 死亡实体的实体对象 */
+            entity: Entity
+        ) => void
+    ): boolean;
+
+    /** 实体受伤后事件 */
+    static listen(
+        /** 事件名 */
+        event: "onMobHurted",
+        /** 回调函数 */
+        listener: (
+            /** 受伤的实体对象 */
+            entity: Entity,
+            /** 造成伤害的实体对象 */
+            source: Entity,
+            /** 伤害值 */
+            damage: number,
+            /** 伤害类型 */
+            cause: number
+        ) => void
+    ): boolean;
+
+    /** 末影人搬起方块 */
+    static listen(
+        /** 事件名 */
+        event: "onEndermanTake",
+        /** 回调函数 */
+        listener: (
+            /** 末影人实体对象 */
+            entity: Entity
+        ) => boolean | void
+    ): boolean;
+
+    /** 末影龙重生事件 */
+    static listen(
+        /** 事件名 */
+        event: "onDragonRespawn",
+        /** 回调函数 */
+        listener: (
+            /** 末影龙重生后的UniqueID */
+            uniqueID: number
+        ) => boolean | void
+    ): boolean;
+
+    /** 弹射物实体尝试创建 */
+    static listen(
+        /** 事件名 */
+        event: "onProjectileTryCreate",
+        /** 回调函数 */
+        listener: (
+            /** 弹射物实体对象 */
+            entity: Entity,
+            /** 创建弹射的实体的uniqueID */
+            uniqueId: number
+        ) => boolean | void
+    ): boolean;
+
+    /** 弹射物实体成功后(不可拦截) */
+    static listen(
+        /** 事件名 */
+        event: "onProjectileCreate",
+        /** 回调函数 */
+        listener: (
+            /** 弹射物实体对象 */
+            entity: Entity,
+            /** 创建弹射的实体的uniqueID */
+            uniqueId: number
+        ) => void
+    ): boolean;
+
+    /** 生成流浪商人 */
+    static listen(
+        /** 事件名 */
+        event: "onSpawnWanderingTrader",
+        /** 回调函数 */
+        listener: (
+            /** 生成的坐标 */
+            pos: IntPos
+        ) => boolean | void
+    ): boolean;
+
+    /** 处理物品请求 */
+    static listen(
+        /** 事件名 */
+        event: "onHandleRequestAction",
+        /** 回调函数 */
+        listener: (
+            /** 请求玩家 */
+            player: Player,
+            /** 请求类型 */
+            actionType: string,
+            /** 请求数量 */
+            count: number,
+            /** 第一个格子的容器类型 */
+            sourceContainerNetId: string,
+            /** 第一个格子的槽位 */
+            sourceSlot: number,
+            /** 第二个格子的容器类型 */
+            destinationContainerNetId: string,
+            /** 第二个格子的槽位 */
+            destinationSlot: number
+        ) => boolean | void
+    ): boolean;
+
+    /** 发送容器关闭数据包后(不可拦截) */
+    static listen(
+        /** 事件名 */
+        event: "onSendContainerClosePacket",
+        /** 回调函数 */
+        listener: (
+            /** 要被关闭的玩家 */
+            player: Player,
+            /** 容器ID */
+            containerId: number
+        ) => void
+    ): boolean;
+
+    /** 关闭服务器(不可拦截) */
+    static listen(
+        /** 事件名 */
+        event: "onServerStopping",
+        /** 回调函数 */
+        listener: () => void
+    ): boolean;
+}

lib/EventAPI-JS.js

@@ -1,29 +1,28 @@
-const CallEvent = ll.import("GMLIB_API", "callCustomEvent");
+/** 事件创建函数 @type {function(string,string):boolean} */
-
+const CallEvent = ll.import("GMLIB_Event_API", "callCustomEvent");
-let NextEventId = 0;
+/** 获取事件ID函数 @type {function():string} */
-
+const getNextEventId = ll.import("GMLIB_Event_API", "getNextScriptEventId");
-function getNextEventId() {
-    NextEventId++;
-    return "GMLIB_Event_" + NextEventId;
-}
 
+/** 事件类 */
 class Event {
-    constructor() {
+    constructor() { throw new Error("Static class cannot be instantiated"); }
-        throw new Error("Static class cannot be instantiated");
-    }
 
+    /**
+     * 监听事件
+     * @param {string} event 事件名称
+     * @param {function} callback 回调
+     * @returns {boolean} 是否创建成功
+     */
     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(`Cannot listen event "${event}" !`);
-            logger.error(`Event "${event}" No Found!`);
+            logger.error(`GMLIB Script Event "${event}" does not exist !`);
         }
         return result;
     }
 }
 
-module.exports = {
+module.exports = { Event };
-    Event
-};

lib/FormAPI-JS.js

@@ -0,0 +1,182 @@
+// // const getNextCallbackId = ll.import("GMLIB_FormAPI", "getNextFormCallbackId");
+
+// class ServerSettingForm {
+//     constructor() {
+//         throw new Error("Static class cannot be instantiated");
+//     }
+
+//     static getDefaultPriority() {
+//         return ll.import("GMLIB_ServerSettingForm", "getDefaultPriority")();
+//     }
+
+//     static hasTitle() {
+//         return ll.import("GMLIB_ServerSettingForm", "hasTitle")();
+//     }
+
+//     static getTitle() {
+//         return ll.import("GMLIB_ServerSettingForm", "getTitle")();
+//     }
+
+//     static setTitle(title, forceModify = false) {
+//         return ll.import("GMLIB_ServerSettingForm", "setTitle")(title, forceModify);
+//     }
+
+//     static hasIcon() {
+//         return ll.import("GMLIB_ServerSettingForm", "hasIcon")();
+//     }
+
+//     static getIconData() {
+//         return hasIcon() ? ll.import("GMLIB_ServerSettingForm", "getIconData")() : null;
+//     }
+
+//     static getIconType() {
+//         return ll.import("GMLIB_ServerSettingForm", "getIconType")();
+//     }
+
+//     static setIcon(data, type = 0, forceModify = false) {
+//         return ll.import("GMLIB_ServerSettingForm", "setIcon")(data, type, forceModify);
+//     }
+
+//     static addLabel(
+//         text,
+//         playerDetector = (pl) => { return true; },
+//         priority = this.getDefaultPriority()
+//     ) {
+//         let detectorId = getNextCallbackId();
+//         ll.export(playerDetector, "GMLIB_FORM_CALLBACK", detectorId);
+//         return ll.import("GMLIB_ServerSettingForm", "addLabel")(text, detectorId, priority);
+//     }
+
+
+//     static addInput(
+//         text,
+//         placeholder,
+//         defaultVal,
+//         callback = (pl, input) => { },
+//         playerDetector = (pl) => { return true; },
+//         priority = this.getDefaultPriority()
+//     ) {
+//         let callbackId = getNextCallbackId();
+//         ll.export(callback, "GMLIB_FORM_CALLBACK", callbackId);
+//         let detectorId = getNextCallbackId();
+//         ll.export(playerDetector, "GMLIB_FORM_CALLBACK", detectorId);
+//         return ll.import("GMLIB_ServerSettingForm", "addInput")(text, placeholder, defaultVal, callbackId, detectorId, priority);
+//     }
+
+//     static addToggle(
+//         text,
+//         defaultVal = false,
+//         callback = (pl, input) => { },
+//         playerDetector = (pl) => { return true; },
+//         priority = this.getDefaultPriority()
+//     ) {
+//         let callbackId = getNextCallbackId();
+//         ll.export(callback, "GMLIB_FORM_CALLBACK", callbackId);
+//         let detectorId = getNextCallbackId();
+//         ll.export(playerDetector, "GMLIB_FORM_CALLBACK", detectorId);
+//         return ll.import("GMLIB_ServerSettingForm", "addToggle")(text, defaultVal, callbackId, detectorId, priority);
+//     }
+
+//     static addDropdown(
+//         text,
+//         options,
+//         defaultVal = 0,
+//         callback = (pl, input) => { },
+//         playerDetector = (pl) => { return true; },
+//         priority = this.getDefaultPriority()
+//     ) {
+//         let callbackId = getNextCallbackId();
+//         ll.export(callback, "GMLIB_FORM_CALLBACK", callbackId);
+//         let detectorId = getNextCallbackId();
+//         ll.export(playerDetector, "GMLIB_FORM_CALLBACK", detectorId);
+//         return ll.import("GMLIB_ServerSettingForm", "addDropdown")(text, options, defaultVal, callbackId, detectorId, priority);
+//     }
+
+//     static addSlider(
+//         text,
+//         min,
+//         max,
+//         step = 0.0,
+//         defaultVal = 0.0,
+//         callback = (pl, input) => { },
+//         playerDetector = (pl) => { return true; },
+//         priority = this.getDefaultPriority()
+//     ) {
+//         let callbackId = getNextCallbackId();
+//         ll.export(callback, "GMLIB_FORM_CALLBACK", callbackId);
+//         let detectorId = getNextCallbackId();
+//         ll.export(playerDetector, "GMLIB_FORM_CALLBACK", detectorId);
+//         return ll.import("GMLIB_ServerSettingForm", "addSlider")(text, min, max, step, defaultVal, callbackId, detectorId, priority);
+//     }
+
+//     static addStepSlider(
+//         text,
+//         steps,
+//         defaultVal = 0,
+//         callback = (pl, input) => { },
+//         playerDetector = (pl) => { return true; },
+//         priority = this.getDefaultPriority()
+//     ) {
+//         let callbackId = getNextCallbackId();
+//         ll.export(callback, "GMLIB_FORM_CALLBACK", callbackId);
+//         let detectorId = getNextCallbackId();
+//         ll.export(playerDetector, "GMLIB_FORM_CALLBACK", detectorId);
+//         return ll.import("GMLIB_ServerSettingForm", "addStepSlider")(text, steps, defaultVal, callbackId, detectorId, priority);
+//     }
+
+//     static removeElement(id) {
+//         return ll.import("GMLIB_ServerSettingForm", "removeElement")(id);
+//     }
+// }
+
+// class NpcDialogueForm {
+//     constructor(npcName, sceneName, dialogue) {
+//         this.mFormId = ll.import("GMLIB_NpcDialogueForm", "createForm")(npcName, sceneName, dialogue);
+//     }
+
+//     addButton(button) {
+//         return ll.import("GMLIB_NpcDialogueForm", "addButton")(this.mFormId, button);
+//     }
+
+//     sendTo(pl, callback = (pl, index, type) => { }, free = true) {
+//         let callbackId = getNextCallbackId();
+//         ll.export(callback, "GMLIB_FORM_CALLBACK", callbackId);
+//         ll.import("GMLIB_NpcDialogueForm", "sendTo")(this.mFormId, pl, callbackId);
+//         if (free) {
+//             this.destroy();
+//         }
+//     }
+
+//     destroy() {
+//         ll.import("GMLIB_NpcDialogueForm", "destroyForm")(this.mFormId);
+//     }
+// }
+
+// class ChestForm {
+//     constructor(npcName, sceneName, dialogue) {
+//         this.mFormId = ll.import("GMLIB_NpcDialogueForm", "createForm")(npcName, sceneName, dialogue);
+//     }
+
+//     addButton(button) {
+//         return ll.import("GMLIB_NpcDialogueForm", "addButton")(this.mFormId, button);
+//     }
+
+//     sendTo(pl, free = true) {
+//         //let callbackId = getNextCallbackId();
+//         //ll.export(callback, "GMLIB_FORM_CALLBACK", callbackId);
+//         //ll.import("GMLIB_NpcDialogueForm", "sendTo")(this.mFormId, pl, callbackId);
+//         //if (free) {
+//         //    this.destroy();
+//         //}
+//     }
+
+//     destroy() {
+//         //ll.import("GMLIB_NpcDialogueForm", "destroyForm")(this.mFormId);
+//     }
+// }
+
+// module.exports = {
+//     ServerSettingForm,
+//     NpcDialogueForm,
+//     ChestForm
+// };

manifest.json

@@ -1,9 +1,10 @@
 {
     "name": "${pluginName}",
     "entry": "${pluginFile}",
-    "version": "0.12.5",
+    "version": "0.13.4",
     "author": "GroupMountain",
     "type": "native",
+    "passive": true,
     "dependencies": [
         {
             "name": "GMLIB"

src/BinaryStreamApi.cpp

@@ -0,0 +1,80 @@
+#include "Global.h"
+using namespace ll::hash_utils;
+
+class LegacyScriptBinaryStreamManager {
+private:
+    int64                                                           mNextBinaryStreamId = 0;
+    std::unordered_map<uint64, std::shared_ptr<GMLIB_BinaryStream>> mBinaryStream;
+
+public:
+    uint getNextId() { return mNextBinaryStreamId++; }
+
+    void cretateBinaryStream(uint id) { mBinaryStream[id] = std::make_shared<GMLIB_BinaryStream>(); }
+
+    void removeBinaryStream(uint64 id) { mBinaryStream.erase(id); }
+
+    std::shared_ptr<GMLIB_BinaryStream> getBinaryStream(uint64 id) {
+        return mBinaryStream.contains(id) ? mBinaryStream.at(id) : nullptr;
+    }
+
+public:
+    static LegacyScriptBinaryStreamManager& getInstance() {
+        static std::unique_ptr<LegacyScriptBinaryStreamManager> instance;
+        if (!instance) instance = std::make_unique<LegacyScriptBinaryStreamManager>();
+        return *instance;
+    }
+};
+
+#define BinaryStreamManager LegacyScriptBinaryStreamManager::getInstance()
+#define EXPORTAPI(funcName, type, fuc)                                                                                 \
+    RemoteCall::exportAs("GMLIB_BinaryStream_API", funcName, [](uint64 id, type value) -> void {                       \
+        auto bs = BinaryStreamManager.getBinaryStream(id);                                                             \
+        if (bs != nullptr) fuc;                                                                                        \
+    })
+
+template <typename T>
+struct Info;
+template <typename T, typename R, typename A, typename... AS>
+struct Info<R (T::*)(A, AS...)> {
+    using ArgT = A;
+};
+#define EXPORTAPI2(T) EXPORTAPI(#T, Info<decltype(&GMLIB_BinaryStream::T)>::ArgT, bs->T(value))
+
+void Export_BinaryStream_API() {
+    RemoteCall::exportAs("GMLIB_BinaryStream_API", "create", []() -> uint64 {
+        auto id = BinaryStreamManager.getNextId();
+        BinaryStreamManager.cretateBinaryStream(id);
+        return id;
+    });
+    RemoteCall::exportAs("GMLIB_BinaryStream_API", "reset", [](uint64 id) -> void {
+        if (BinaryStreamManager.getBinaryStream(id) == nullptr) BinaryStreamManager.cretateBinaryStream(id);
+        else BinaryStreamManager.getBinaryStream(id)->reset();
+    });
+    RemoteCall::exportAs("GMLIB_BinaryStream_API", "sendTo", [](uint64 id, Player* player) -> void {
+        if (auto bs = BinaryStreamManager.getBinaryStream(id); bs != nullptr) bs->sendTo(*player);
+    });
+    RemoteCall::exportAs("GMLIB_BinaryStream_API", "destroy", [](uint64 id) -> void {
+        BinaryStreamManager.removeBinaryStream(id);
+    });
+    EXPORTAPI("writePacketHeader", int, bs->writePacketHeader((MinecraftPacketIds)value));
+    EXPORTAPI("writeUuid", std::string const&, bs->writeUuid(mce::UUID::fromString(value)));
+    EXPORTAPI("writeItem", ItemStack*, bs->writeType(NetworkItemStackDescriptor(*value)));
+    EXPORTAPI("writeString", std::string const&, bs->writeString(value));
+    EXPORTAPI("writeCompoundTag", CompoundTag*, bs->writeCompoundTag(*value));
+    EXPORTAPI2(writeBool);
+    EXPORTAPI2(writeByte);
+    EXPORTAPI2(writeDouble);
+    EXPORTAPI2(writeFloat);
+    EXPORTAPI2(writeSignedBigEndianInt);
+    EXPORTAPI2(writeSignedInt);
+    EXPORTAPI2(writeSignedInt64);
+    EXPORTAPI2(writeSignedShort);
+    EXPORTAPI2(writeUnsignedChar);
+    EXPORTAPI2(writeUnsignedInt);
+    EXPORTAPI2(writeUnsignedInt64);
+    EXPORTAPI2(writeUnsignedShort);
+    EXPORTAPI2(writeUnsignedVarInt);
+    EXPORTAPI2(writeUnsignedVarInt64);
+    EXPORTAPI2(writeVarInt);
+    EXPORTAPI2(writeVarInt64);
+}

src/Entry.cpp

@@ -3,34 +3,36 @@
 
 ll::Logger logger(PLUGIN_NAME);
 
-namespace GMLIB_LegacyRemoteCallApi {
+namespace gmlib {
 
-std::unique_ptr<LRCA>& LRCA::getInstance() {
+std::unique_ptr<LegacyRemoteCallApi>& LegacyRemoteCallApi::getInstance() {
-    static std::unique_ptr<LRCA> instance;
+    static std::unique_ptr<LegacyRemoteCallApi> instance;
     return instance;
 }
 
-bool LRCA::load() {
+bool LegacyRemoteCallApi::load() {
     Export_Legacy_GMLib_ModAPI();
     Export_Legacy_GMLib_ServerAPI();
     Export_Compatibility_API();
     ExportPAPI();
     Export_Event_API();
+    Export_BinaryStream_API();
+    // Export_Form_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())
+        fmt::format(fg(fmt::color::light_green), "GMLIB-LegacyRemoteCallApi-" + LIB_VERSION.asString())
     );
     logger.info("Author: GroupMountain");
     logger.info("Repository: https://github.com/GroupMountain/GMLIB-LegacyRemoteCallApi");
     return true;
 }
 
-bool LRCA::enable() { return true; }
+bool LegacyRemoteCallApi::enable() { return true; }
 
-bool LRCA::disable() { return true; }
+bool LegacyRemoteCallApi::disable() { return true; }
 
-} // namespace GMLIB_LegacyRemoteCallApi
+} // namespace gmlib
 
-LL_REGISTER_PLUGIN(GMLIB_LegacyRemoteCallApi::LRCA, GMLIB_LegacyRemoteCallApi::LRCA::getInstance());
+LL_REGISTER_MOD(gmlib::LegacyRemoteCallApi, gmlib::LegacyRemoteCallApi::getInstance());

src/Entry.h

@@ -1,17 +1,17 @@
 #pragma once
-#include <ll/api/plugin/NativePlugin.h>
+#include <ll/api/mod/NativeMod.h>
-#include <ll/api/plugin/RegisterHelper.h>
+#include <ll/api/mod/RegisterHelper.h>
 
-namespace GMLIB_LegacyRemoteCallApi {
+namespace gmlib {
 
-class LRCA {
+class LegacyRemoteCallApi {
 
 public:
-    static std::unique_ptr<LRCA>& getInstance();
+    static std::unique_ptr<LegacyRemoteCallApi>& getInstance();
 
-    LRCA(ll::plugin::NativePlugin& self) : mSelf(self) {}
+    LegacyRemoteCallApi(ll::mod::NativeMod& self) : mSelf(self) {}
 
-    [[nodiscard]] ll::plugin::NativePlugin& getSelf() const { return mSelf; }
+    [[nodiscard]] ll::mod::NativeMod& getSelf() const { return mSelf; }
 
     /// @return True if the plugin is loaded successfully.
     bool load();
@@ -27,7 +27,7 @@ public:
     // bool unload();
 
 private:
-    ll::plugin::NativePlugin& mSelf;
+    ll::mod::NativeMod& mSelf;
 };
 
-} // namespace GMLIB_LegacyRemoteCallApi
+} // namespace gmlib

src/EventAPI.cpp

@@ -1,199 +1,249 @@
 #include "Global.h"
 using namespace ll::hash_utils;
 
+class LegacyScriptEventManager {
+private:
+    int64                                              mNextEventId = 0;
+    std::unordered_map<uint64, ll::event::ListenerPtr> mEventListeners;
+
+public:
+    std::string getNextEventId() {
+        mNextEventId++;
+        return "GMLIB_EVENT_" + std::to_string(mNextEventId);
+    }
+
+    void emplaceListener(std::string const& scriptEventId, ll::event::ListenerPtr listenerPtr) {
+        mEventListeners[doHash(scriptEventId)] = std::move(listenerPtr);
+    }
+
+    void removeListener(std::string const& scriptEventId) {
+        ll::event::EventBus::getInstance().removeListener(mEventListeners[doHash(scriptEventId)]);
+        mEventListeners.erase(doHash(scriptEventId));
+    }
+
+public:
+    static LegacyScriptEventManager& getInstance() {
+        static std::unique_ptr<LegacyScriptEventManager> instance;
+        if (!instance) {
+            instance = std::make_unique<LegacyScriptEventManager>();
+        }
+        return *instance;
+    }
+};
+
+#define REGISTER_EVENT_LISTEN(eventType, callFunction, eventParams, cancelFunction, otherFunction)                     \
+    eventManager.emplaceListener(                                                                                      \
+        eventId,                                                                                                       \
+        eventBus.emplaceListener<eventType>([eventName, eventId, &eventBus, &eventManager](eventType& ev) -> void {    \
+            if (!RemoteCall::hasFunc(eventName, eventId)) {                                                            \
+                eventManager.removeListener(eventId);                                                                  \
+                return;                                                                                                \
+            }                                                                                                          \
+            bool result = true;                                                                                        \
+            try {                                                                                                      \
+                otherFunction;                                                                                         \
+                result = RemoteCall::importAs<bool callFunction>(eventName, eventId) eventParams;                      \
+            } catch (...) {}                                                                                           \
+            if (!result) cancelFunction;                                                                               \
+        })                                                                                                             \
+    );                                                                                                                 \
+    return true;
+
 void Export_Event_API() {
-    auto eventBus = &ll::event::EventBus::getInstance();
+    RemoteCall::exportAs("GMLIB_Event_API", "getNextScriptEventId", []() -> std::string {
+        return LegacyScriptEventManager::getInstance().getNextEventId();
+    });
+    auto& eventBus     = ll::event::EventBus::getInstance();
+    auto& eventManager = LegacyScriptEventManager::getInstance();
     RemoteCall::exportAs(
-        "GMLIB_API",
+        "GMLIB_Event_API",
         "callCustomEvent",
-        [eventBus](std::string eventName, std::string eventId) -> bool {
+        [&eventBus, &eventManager](std::string const& eventName, std::string const& eventId) -> bool {
-            if (RemoteCall::hasFunc(eventName, eventId)) {
+            if (!RemoteCall::hasFunc(eventName, eventId)) return false;
-                switch (doHash(eventName)) {
+            switch (doHash(eventName)) {
-                case doHash("onClientLogin"): {
+            case doHash("onClientLogin"): {
-                    auto Call = RemoteCall::importAs<
+                REGISTER_EVENT_LISTEN(
-                        bool(std::string realName, std::string uuid, std::string serverXuid, std::string clientXuid)>(
+                    GMLIB::Event::PacketEvent::ClientLoginAfterEvent,
-                        eventName,
+                    (std::string const& realName,
-                        eventId
+                     std::string const& uuid,
-                    );
+                     std::string const& serverXuid,
-                    eventBus->emplaceListener<GMLIB::Event::PacketEvent::ClientLoginAfterEvent>(
+                     std::string const& clientXuid),
-                        [Call](GMLIB::Event::PacketEvent::ClientLoginAfterEvent& ev) {
+                    (ev.getRealName(), ev.getUuid().asString(), ev.getServerAuthXuid(), ev.getClientAuthXuid()),
-                            try {
+                    logger.error("Event \"onClientLogin\" cannot be intercepted"),
-                                Call(
+                )
-                                    ev.getRealName(),
+            }
-                                    ev.getUuid().asString(),
+            case doHash("onWeatherChange"): {
-                                    ev.getServerAuthXuid(),
+                REGISTER_EVENT_LISTEN(
-                                    ev.getClientAuthXuid()
+                    GMLIB::Event::LevelEvent::WeatherUpdateBeforeEvent,
-                                );
+                    (int lightningLevel, int rainLevel, int lightningLast, int rainLast),
-                            } catch (...) {}
+                    (ev.getLightningLevel(), ev.getRainLevel(), ev.getLightningLastTick(), ev.getRainingLastTick()),
-                        }
+                    ev.cancel(),
-                    );
+                )
-                    return true;
+            }
-                }
+            case doHash("onMobPick"): {
-                case doHash("onWeatherChange"): {
+                REGISTER_EVENT_LISTEN(
-                    auto Call =
+                    GMLIB::Event::EntityEvent::MobPickupItemBeforeEvent,
-                        RemoteCall::importAs<bool(int lightningLevel, int rainLevel, int lightningLast, int rainLast)>(
+                    (Actor * mob, Actor * item),
-                            eventName,
+                    (&ev.self(), (Actor*)&ev.getItemActor()),
-                            eventId
+                    ev.cancel(),
-                        );
+                )
-                    eventBus->emplaceListener<GMLIB::Event::LevelEvent::WeatherUpdateBeforeEvent>(
+            }
-                        [Call](GMLIB::Event::LevelEvent::WeatherUpdateBeforeEvent& ev) {
+            case doHash("onItemTrySpawn"): {
-                            bool result = true;
+                REGISTER_EVENT_LISTEN(
-                            try {
+                    GMLIB::Event::EntityEvent::ItemActorSpawnBeforeEvent,
-                                result = Call(
+                    (const ItemStack* item, std::pair<Vec3, int> position, int64 spawnerUniqueId),
-                                    ev.getLightningLevel(),
+                    (&ev.getItem(),
-                                    ev.getRainLevel(),
+                     {ev.getPosition(), ev.getBlockSource().getDimensionId().id},
-                                    ev.getLightningLastTick(),
+                     ev.getSpawner().has_value() ? ev.getSpawner()->getOrCreateUniqueID().id : -1),
-                                    ev.getRainingLastTick()
+                    ev.cancel(),
-                                );
+                )
-                            } catch (...) {}
+            }
-                            if (!result) {
+            case doHash("onItemSpawned"): {
-                                ev.cancel();
+                REGISTER_EVENT_LISTEN(
-                            }
+                    GMLIB::Event::EntityEvent::ItemActorSpawnAfterEvent,
-                        }
+                    (const ItemStack* item, Actor* itemActor, std::pair<Vec3, int> position, int64 spawnerUniqueId),
-                    );
+                    (&ev.getItem(),
-                    return true;
+                     (Actor*)&ev.getItemActor(),
-                }
+                     {ev.getPosition(), ev.getBlockSource().getDimensionId().id},
-                case doHash("onMobPick"): {
+                     ev.getSpawner().has_value() ? ev.getSpawner()->getOrCreateUniqueID().id : -1),
-                    auto Call = RemoteCall::importAs<bool(Actor * mob, Actor * item)>(eventName, eventId);
+                    logger.error("Event \"onItemSpawned\" cannot be intercepted"),
-                    eventBus->emplaceListener<GMLIB::Event::EntityEvent::MobPickupItemBeforeEvent>(
+                )
-                        [Call](GMLIB::Event::EntityEvent::MobPickupItemBeforeEvent& ev) {
+            }
-                            bool result = true;
+            case doHash("onEntityTryChangeDim"): {
-                            try {
+                REGISTER_EVENT_LISTEN(
-                                result = Call(&ev.self(), (Actor*)&ev.getItemActor());
+                    GMLIB::Event::EntityEvent::ActorChangeDimensionBeforeEvent,
-                            } catch (...) {}
+                    (Actor * entity, int toDimId),
-                            if (!result) {
+                    (&ev.self(), ev.getToDimensionId()),
-                                ev.cancel();
+                    ev.cancel(),
-                            }
+                )
-                        }
+            }
-                    );
+            case doHash("onLeaveBed"): {
-                    return true;
+                REGISTER_EVENT_LISTEN(
-                }
+                    GMLIB::Event::PlayerEvent::PlayerStopSleepBeforeEvent,
-                case doHash("onItemTrySpawn"): {
+                    (Player * pl),
-                    auto Call = RemoteCall::importAs<
+                    (&ev.self()),
-                        bool(const ItemStack* item, std::pair<Vec3, int> position, Actor* spawner)>(eventName, eventId);
+                    ev.cancel(),
-                    eventBus->emplaceListener<GMLIB::Event::EntityEvent::ItemActorSpawnBeforeEvent>(
+                )
-                        [Call](GMLIB::Event::EntityEvent::ItemActorSpawnBeforeEvent& ev) {
+            }
-                            auto                 pos    = ev.getPosition();
+            case doHash("onDeathMessage"): {
-                            auto                 dimid  = ev.getBlockSource().getDimensionId().id;
+                REGISTER_EVENT_LISTEN(
-                            std::pair<Vec3, int> lsePos = {pos, dimid};
+                    GMLIB::Event::EntityEvent::DeathMessageAfterEvent,
-                            bool                 result = true;
+                    (std::string const& message, std::vector<std::string>, Actor* dead),
-                            try {
+                    (ev.getDeathMessage().first, ev.getDeathMessage().second, &ev.self()),
-                                result = Call(&ev.getItem(), lsePos, ev.getSpawner());
+                    logger.error("Event \"onDeathMessage\" cannot be intercepted"),
-                            } catch (...) {}
+                )
-                            if (!result) {
+            }
-                                ev.cancel();
+            case doHash("onMobHurted"): {
-                            }
+                REGISTER_EVENT_LISTEN(
-                        }
+                    GMLIB::Event::EntityEvent::MobHurtAfterEvent,
-                    );
+                    (Actor * mob, Actor * source, float damage, int cause),
-                    return true;
+                    (&ev.self(), source, ev.getDamage(), (int)damageSource.getCause()),
-                }
+                    logger.error("Event \"onMobHurted\" cannot be intercepted"),
-                case doHash("onItemSpawned"): {
+                    auto& damageSource = ev.getSource();
-                    auto Call = RemoteCall::importAs<
+                    Actor* source      = nullptr;
-                        bool(const ItemStack* item, Actor* itemActor, std::pair<Vec3, int> position, Actor* spawner)>(
+                    if (damageSource.isEntitySource()) {
-                        eventName,
+                        auto uniqueId = damageSource.getDamagingEntityUniqueID();
-                        eventId
+                        source        = ll::service::getLevel()->fetchEntity(uniqueId);
-                    );
+                        if (source->getOwner()) source = source->getOwner();
-                    eventBus->emplaceListener<GMLIB::Event::EntityEvent::ItemActorSpawnAfterEvent>(
+                    }
-                        [Call](GMLIB::Event::EntityEvent::ItemActorSpawnAfterEvent& ev) {
+                )
-                            auto                 pos    = ev.getPosition();
+            }
-                            auto                 dimid  = ev.getBlockSource().getDimensionId().id;
+            case doHash("onEndermanTake"): {
-                            std::pair<Vec3, int> lsePos = {pos, dimid};
+                REGISTER_EVENT_LISTEN(
-                            try {
+                    GMLIB::Event::EntityEvent::EndermanTakeBlockBeforeEvent,
-                                Call(&ev.getItem(), (Actor*)&ev.getItemActor(), lsePos, ev.getSpawner());
+                    (Actor * mob),
-                            } catch (...) {}
+                    (&ev.self()),
-                        }
+                    ev.cancel(),
-                    );
+                )
-                    return true;
+            }
-                }
+            case doHash("onEntityChangeDim"): {
-                case doHash("onEntityChangeDim"): {
+                REGISTER_EVENT_LISTEN(
-                    auto Call = RemoteCall::importAs<bool(Actor * entity, int toDimId)>(eventName, eventId);
+                    GMLIB::Event::EntityEvent::ActorChangeDimensionAfterEvent,
-                    eventBus->emplaceListener<GMLIB::Event::EntityEvent::ActorChangeDimensionBeforeEvent>(
+                    (Actor * mob, int fromDimId),
-                        [Call](GMLIB::Event::EntityEvent::ActorChangeDimensionBeforeEvent& ev) {
+                    (&ev.self(), ev.getFromDimensionId()),
-                            bool result = true;
+                    logger.error("Event \"onEntityChangeDim\" cannot be intercepted"),
-                            try {
+                )
-                                result = Call(&ev.self(), ev.getToDimensionId());
+            }
-                            } catch (...) {}
+            case doHash("onDragonRespawn"): {
-                            if (!result) {
+                REGISTER_EVENT_LISTEN(
-                                ev.cancel();
+                    GMLIB::Event::EntityEvent::DragonRespawnBeforeEvent,
-                            }
+                    (int64 enderDragonUniqueID),
-                        }
+                    (ev.getEnderDragon().id),
-                    );
+                    ev.cancel(),
-                    return true;
+                )
-                }
+            }
-                case doHash("onLeaveBed"): {
+            case doHash("onProjectileTryCreate"): {
-                    auto Call = RemoteCall::importAs<bool(Player * pl)>(eventName, eventId);
+                REGISTER_EVENT_LISTEN(
-                    eventBus->emplaceListener<GMLIB::Event::PlayerEvent::PlayerStopSleepBeforeEvent>(
+                    GMLIB::Event::EntityEvent::ProjectileCreateBeforeEvent,
-                        [Call](GMLIB::Event::PlayerEvent::PlayerStopSleepBeforeEvent& ev) {
+                    (Actor * mob, int64 uniqueId),
-                            bool result = true;
+                    (&ev.self(), ev.getShooter() ? ev.getShooter()->getOrCreateUniqueID().id : -1),
-                            try {
+                    ev.cancel(),
-                                result = Call(&ev.self());
+                )
-                            } catch (...) {}
+            }
-                            if (!result) {
+            case doHash("onProjectileCreate"): {
-                                ev.cancel();
+                REGISTER_EVENT_LISTEN(
-                            }
+                    GMLIB::Event::EntityEvent::ProjectileCreateAfterEvent,
-                        }
+                    (Actor * mob, int64 uniqueId),
-                    );
+                    (&ev.self(), ev.getShooter() ? ev.getShooter()->getOrCreateUniqueID().id : -1),
-                    return true;
+                    logger.error("Event \"onProjectileCreate\" cannot be intercepted"),
-                }
+                )
-                case doHash("onDeathMessage"): {
+            }
-                    auto Call = RemoteCall::importAs<bool(std::string message, std::vector<std::string>, Actor * dead)>(
+            case doHash("onSpawnWanderingTrader"): {
-                        eventName,
+                REGISTER_EVENT_LISTEN(
-                        eventId
+                    GMLIB::Event::EntityEvent::SpawnWanderingTraderBeforeEvent,
-                    );
+                    (std::pair<BlockPos, int> pos),
-                    eventBus->emplaceListener<GMLIB::Event::EntityEvent::DeathMessageAfterEvent>(
+                    ({ev.getPos(), ev.getRegion().getDimensionId()}),
-                        [Call](GMLIB::Event::EntityEvent::DeathMessageAfterEvent& ev) {
+                    ev.cancel(),
-                            auto msg    = ev.getDeathMessage();
+                )
-                            auto source = ev.getDamageSource();
+            }
-                            try {
+            case doHash("onHandleRequestAction"): {
-                                Call(msg.first, msg.second, &ev.self());
+                // clang-format off
-                            } catch (...) {}
+                REGISTER_EVENT_LISTEN(
-                        }
+                    GMLIB::Event::PlayerEvent::HandleRequestActionBeforeEvent,
-                    );
+                    (
-                    return true;
+                        Player * player,
-                }
+                        std::string const& actionType,
-                case doHash("onMobHurted"): {
+                        int                count,
-                    auto Call = RemoteCall::importAs<bool(Actor * mob, Actor * source, float damage, int cause)>(
+                        std::string const& sourceContainerNetId,
-                        eventName,
+                        int                sourceSlot,
-                        eventId
+                        std::string const& destinationContainerNetId,
-                    );
+                        int                destinationSlot
-                    eventBus->emplaceListener<GMLIB::Event::EntityEvent::MobHurtAfterEvent>(
+                    ),
-                        [Call](GMLIB::Event::EntityEvent::MobHurtAfterEvent& ev) {
+                    (
-                            auto&  damageSource = ev.getSource();
+                        (Player*)&ev.self(),
-                            Actor* source       = nullptr;
+                        magic_enum::enum_name(requestAction.mActionType).data(),
-                            if (damageSource.isEntitySource()) {
+                        (int)requestAction.mAmount,
-                                auto uniqueId = damageSource.getDamagingEntityUniqueID();
+                        magic_enum::enum_name(requestAction.mSrc.mOpenContainerNetId).data(),
-                                source        = ll::service::getLevel()->fetchEntity(uniqueId);
+                        (int)requestAction.mSrc.mSlot,
-                                if (source->getOwner()) {
+                        magic_enum::enum_name(requestAction.mDst.mOpenContainerNetId).data(),
-                                    source = source->getOwner();
+                        (int)requestAction.mDst.mSlot
-                                }
+                    ),
-                            }
+                    ev.cancel(),
-                            try {
+                    auto& requestAction = (ItemStackRequestActionTransferBase&)ev.getRequestAction();
-                                Call(&ev.self(), source, ev.getDamage(), (int)damageSource.getCause());
+                )
-                            } catch (...) {}
+                // clang-format on
-                        }
+            }
-                    );
+            case doHash("onSendContainerClosePacket"): {
-                    return true;
+                REGISTER_EVENT_LISTEN(
-                }
+                    GMLIB::Event::PacketEvent::ContainerClosePacketSendAfterEvent,
-                case doHash("onEndermanTake"): {
+                    (Player * player, int ContainerNetId),
-                    auto Call = RemoteCall::importAs<bool(Actor * mob)>(eventName, eventId);
+                    (ev.getServerNetworkHandler()
-                    eventBus->emplaceListener<GMLIB::Event::EntityEvent::EndermanTakeBlockBeforeEvent>(
+                         .getServerPlayer(ev.getNetworkIdentifier(), ev.getPacket().mClientSubId),
-                        [Call](GMLIB::Event::EntityEvent::EndermanTakeBlockBeforeEvent& ev) {
+                     (int)ev.getPacket().mContainerId),
-                            bool result = true;
+                    logger.error("Event \"onSendContainerClosePacket\" cannot be intercepted"),
-                            try {
+                )
-                                result = Call(&ev.self());
+            }
-                            } catch (...) {}
+            case doHash("onServerStopping"): {
-                            if (!result) {
+                REGISTER_EVENT_LISTEN(
-                                ev.cancel();
+                    ll::event::server::ServerStoppingEvent,
-                            }
+                    (),
-                        }
+                    (),
-                    );
+                    logger.error("Event \"onServerStopping\" cannot be intercepted"),
-                    return true;
+                )
-                }
+            }
-                default:
+            default:
-                    return false;
+                return false;
-                }
             }
-            return false;
         }
     );
 }

src/FormAPI.cpp

@@ -0,0 +1,288 @@
+// #include "Global.h"
+
+// using namespace ll::hash_utils;
+
+// class LegacyScriptFormManager {
+// private:
+//     int64                                                       mNextFormCallbackId = 0;
+//     int64                                                       mNextFormId         = 0;
+//     std::unordered_map<int64, std::unique_ptr<gmlib::form::NpcDialogueForm>> mNpcDialogueForms;
+//     // std::unordered_map<int64, std::unique_ptr<ChestForm>>       mChestForms;
+
+// public:
+//     //     std::string getNextFormCallbackId() {
+//     //         return "GMLIB_FormApi_" + std::to_string(mNextFormCallbackId++);
+//     //     }
+
+//     int64 getNextFormId() {
+//         mNextFormId++;
+//         return mNextFormId;
+//     }
+
+//     int64 createNpcDialogueForm(std::string const& npcName, std::string const& sceneName, std::string const& dialogue) {
+//         auto formId               = LegacyScriptFormManager::getInstance().getNextFormId();
+//         auto formPtr              = std::make_unique<gmlib::form::NpcDialogueForm>(npcName, sceneName, dialogue);
+//         mNpcDialogueForms[formId] = std::move(formPtr);
+//         return formId;
+//     }
+
+//     bool destroyNpcDialogueForm(int64 formId) {
+//         if (mNpcDialogueForms.contains(formId)) {
+//             mNpcDialogueForms.erase(formId);
+//             return true;
+//         }
+//         return false;
+//     }
+
+//     optional_ref<gmlib::form::NpcDialogueForm> getNpcDialogueForm(int64 formId) {
+//         if (mNpcDialogueForms.contains(formId)) {
+//             return mNpcDialogueForms[formId].get();
+//         }
+//         return {};
+//     }
+
+//     /*
+//     int64 createChestForm(std::string const& npcName, std::string const& sceneName, std::string const& dialogue) {
+//         auto formId         = LegacyScriptFormManager::getInstance().getNextFormId();
+//         auto formPtr        = std::make_unique<ChestForm>(npcName, sceneName, dialogue);
+//         mChestForms[formId] = std::move(formPtr);
+//         return formId;
+//     }
+
+//     bool destroyChestForm(int64 formId) {
+//         if (mChestForms.contains(formId)) {
+//             mChestForms.erase(formId);
+//             return true;
+//         }
+//         return false;
+//     }
+
+//     optional_ref<ChestForm> getChestForm(int64 formId) {
+//         if (mChestForms.contains(formId)) {
+//             return mChestForms[formId].get();
+//         }
+//         return {};
+//     }
+
+//     */
+// public:
+//     static LegacyScriptFormManager& getInstance() {
+//         static std::unique_ptr<LegacyScriptFormManager> instance;
+//         if (!instance) {
+//             instance = std::make_unique<LegacyScriptFormManager>();
+//         }
+//         return *instance;
+//     }
+// };
+
+// #define PLAYER_DETECROR                                                                                                \
+//     [detectorId, result](::Player& pl) -> bool {                                                                       \
+//         try {                                                                                                          \
+//             if (RemoteCall::hasFunc("GMLIB_FORM_CALLBACK", detectorId)) {                                              \
+//                 auto const& detector = RemoteCall::importAs<bool(::Player*)>("GMLIB_FORM_CALLBACK", detectorId);       \
+//                 return detector(&pl);                                                                                  \
+//             } else {                                                                                                   \
+//                 gmlib::form::ServerSettingForm::removeElement(result);                                                 \
+//             }                                                                                                          \
+//         } catch (...) {}                                                                                               \
+//         return false;                                                                                                  \
+//     }
+
+// #define CALLBACK_TYPE(type)                                                                                            \
+//     [callbackId, result](Player& pl, type data) {                                                                      \
+//         try {                                                                                                          \
+//             if (RemoteCall::hasFunc("GMLIB_FORM_CALLBACK", callbackId)) {                                              \
+//                 auto const& callback = RemoteCall::importAs<void(Player*, type)>("GMLIB_FORM_CALLBACK", callbackId);   \
+//                 callback(&pl, data);                                                                                   \
+//             } else {                                                                                                   \
+//                 gmlib::form::ServerSettingForm::removeElement(result);                                                 \
+//             }                                                                                                          \
+//         } catch (...) {}                                                                                               \
+//     }
+
+// #define CALLBACK_TYPE_NORMAL                                                                                           \
+//     [callbackId](::Player& pl) {                                                                                       \
+//         try {                                                                                                          \
+//             if (RemoteCall::hasFunc("GMLIB_FORM_CALLBACK", callbackId)) {                                              \
+//                 auto const& callback = RemoteCall::importAs<void(::Player*)>("GMLIB_FORM_CALLBACK", callbackId);       \
+//                 callback(&pl);                                                                                         \
+//             }                                                                                                          \
+//         } catch (...) {}                                                                                               \
+//     }
+
+
+// void Export_Form_API() {
+//     ////////////////////////////////   Form Manager   /////////////////////////////////
+//     // RemoteCall::exportAs("GMLIB_FormAPI", "getNextFormCallbackId", []() -> std::string {
+//     //     return LegacyScriptFormManager::getInstance().getNextFormCallbackId();
+//     // });
+//     //////////////////////////////   ServerSettingForm   //////////////////////////////
+//     RemoteCall::exportAs("GMLIB_ServerSettingForm", "getDefaultPriority", []() -> int {
+//         return gmlib::form::ServerSettingForm::getDefaultPriority();
+//     });
+//     RemoteCall::exportAs("GMLIB_ServerSettingForm", "hasTitle", []() -> bool { return gmlib::form::ServerSettingForm::hasTitle(); });
+//     RemoteCall::exportAs("GMLIB_ServerSettingForm", "getTitle", []() -> std::string {
+//         return gmlib::form::ServerSettingForm::getTitle();
+//     });
+//     RemoteCall::exportAs("GMLIB_gmlib::form::ServerSettingForm", "setTitle", [](std::string const& title, bool forceModify) -> bool {
+//         return gmlib::form::ServerSettingForm::setTitle(title, forceModify);
+//     });
+//     RemoteCall::exportAs("GMLIB_gmlib::form::ServerSettingForm", "hasIcon", []() -> bool { return gmlib::form::ServerSettingForm::hasIcon(); });
+//     RemoteCall::exportAs("GMLIB_gmlib::form::ServerSettingForm", "getIconData", []() -> std::string {
+//         return gmlib::form::ServerSettingForm::getIconData().value_or("");
+//     });
+//     RemoteCall::exportAs("GMLIB_gmlib::form::ServerSettingForm", "getIconType", []() -> int {
+//         return gmlib::form::ServerSettingForm::getIconType()
+//             .transform([](gmlib::form::IconType&& type) -> int { return (int)type; })
+//             .value_or(-1);
+//     });
+//     RemoteCall::exportAs(
+//         "GMLIB_gmlib::form::ServerSettingForm",
+//         "setIcon",
+//         [](std::string const& title, uchar type, bool forceModify) -> bool {
+//             return gmlib::form::ServerSettingForm::setIcon(title, gmlib::form::IconType(type), forceModify);
+//         }
+//     );
+//     RemoteCall::exportAs(
+//         "GMLIB_gmlib::form::ServerSettingForm",
+//         "addLabel",
+//         [](std::string const& text, std::string const& detectorId, int priority) -> uint {
+//             uint result = gmlib::form::ServerSettingForm::addLabel(text, PLAYER_DETECROR, priority);
+//             return result;
+//         }
+//     );
+//     RemoteCall::exportAs(
+//         "GMLIB_gmlib::form::ServerSettingForm",
+//         "addInput",
+//         [](std::string const& text,
+//            std::string const& placeholder,
+//            std::string const& defaultVal,
+//            std::string const& callbackId,
+//            std::string const& detectorId,
+//            int                priority) -> uint {
+//             uint result = gmlib::form::ServerSettingForm::addInput(
+//                 text,
+//                 placeholder,
+//                 defaultVal,
+//                 CALLBACK_TYPE(std::string const&),
+//                 PLAYER_DETECROR,
+//                 priority
+//             );
+//             return result;
+//         }
+//     );
+//     RemoteCall::exportAs(
+//         "GMLIB_gmlib::form::ServerSettingForm",
+//         "addToggle",
+//         [](std::string const& text,
+//            bool               defaultVal,
+//            std::string const& callbackId,
+//            std::string const& detectorId,
+//            int                priority) -> uint {
+//             uint result = gmlib::form::ServerSettingForm::addToggle(text, defaultVal, CALLBACK_TYPE(bool), PLAYER_DETECROR, priority);
+//             return result;
+//         }
+//     );
+//     RemoteCall::exportAs(
+//         "GMLIB_gmlib::form::ServerSettingForm",
+//         "addDropdown",
+//         [](std::string const&       text,
+//            std::vector<std::string> options,
+//            int64                    defaultVal,
+//            std::string const&       callbackId,
+//            std::string const&       detectorId,
+//            int                      priority) -> uint {
+//             uint result = gmlib::form::ServerSettingForm::addDropdown(
+//                 text,
+//                 options,
+//                 defaultVal,
+//                 CALLBACK_TYPE(int64),
+//                 PLAYER_DETECROR,
+//                 priority
+//             );
+//             return result;
+//         }
+//     );
+//     RemoteCall::exportAs(
+//         "GMLIB_gmlib::form::ServerSettingForm",
+//         "addSlider",
+//         [](std::string const& text,
+//            double             min,
+//            double             max,
+//            double             step,
+//            double             defaultVal,
+//            std::string const& callbackId,
+//            std::string const& detectorId,
+//            int                priority) -> uint {
+//             uint result = gmlib::form::ServerSettingForm::addSlider(
+//                 text,
+//                 min,
+//                 max,
+//                 step,
+//                 defaultVal,
+//                 CALLBACK_TYPE(double),
+//                 PLAYER_DETECROR,
+//                 priority
+//             );
+//             return result;
+//         }
+//     );
+//     RemoteCall::exportAs(
+//         "GMLIB_gmlib::form::ServerSettingForm",
+//         "addStepSlider",
+//         [](std::string const&       text,
+//            std::vector<std::string> steps,
+//            int64                    defaultVal,
+//            std::string const&       callbackId,
+//            std::string const&       detectorId,
+//            int                      priority) -> uint {
+//             uint result = gmlib::form::ServerSettingForm::addStepSlider(
+//                 text,
+//                 steps,
+//                 defaultVal,
+//                 CALLBACK_TYPE(int64),
+//                 PLAYER_DETECROR,
+//                 priority
+//             );
+//             return result;
+//         }
+//     );
+//     RemoteCall::exportAs("GMLIB_gmlib::form::ServerSettingForm", "removeElement", [](uint id) -> bool {
+//         return gmlib::form::ServerSettingForm::removeElement(id);
+//     });
+//     //////////////////////////////   NpcDialogueForm   //////////////////////////////
+//     RemoteCall::exportAs(
+//         "GMLIB_NpcDialogueForm",
+//         "createForm",
+//         [](std::string const& npcName, std::string const& sceneName, std::string const& dialogue) -> int64 {
+//             return LegacyScriptFormManager::getInstance().createNpcDialogueForm(npcName, sceneName, dialogue);
+//         }
+//     );
+//     RemoteCall::exportAs("GMLIB_NpcDialogueForm", "destroyForm", [](int64 formId) -> bool {
+//         return LegacyScriptFormManager::getInstance().destroyNpcDialogueForm(formId);
+//     });
+//     RemoteCall::exportAs(
+//         "GMLIB_NpcDialogueForm",
+//         "addButton",
+//         [](int64 formId, std::string const& button, std::string const& callbackId) -> void {
+//             if (auto formPtr = LegacyScriptFormManager::getInstance().getNpcDialogueForm(formId)) {
+//                 formPtr->addButton(button, CALLBACK_TYPE_NORMAL);
+//             }
+//         }
+//     );
+//     RemoteCall::exportAs(
+//         "GMLIB_NpcDialogueForm",
+//         "onPlayerClose",
+//         [](int64 formId, std::string const& callbackId) -> void {
+//             if (auto formPtr = LegacyScriptFormManager::getInstance().getNpcDialogueForm(formId)) {
+//                 formPtr->onPlayerClose(CALLBACK_TYPE_NORMAL);
+//             }
+//         }
+//     );
+//     RemoteCall::exportAs("GMLIB_NpcDialogueForm", "sendTo", [](int64 formId, ::Player* pl) -> void {
+//         if (auto formPtr = LegacyScriptFormManager::getInstance().getNpcDialogueForm(formId)) {
+//             formPtr->sendTo(*pl);
+//         }
+//     });
+//     //////////////////////////////   ChestForm   //////////////////////////////
+// }

src/Global.h

@@ -5,7 +5,11 @@
 
 #define PLUGIN_NAME fmt::format(fg(fmt::color::light_green), "GMLIB-LRCA")
 
-#define LIB_VERSION GMLIB::Version(0, 12, 5)
+#define LIB_VERSION_MAJOR 0
+#define LIB_VERSION_MINOR 13
+#define LIB_VERSION_PATCH 4
+
+#define LIB_VERSION GMLIB::Version(LIB_VERSION_MAJOR, LIB_VERSION_MINOR, LIB_VERSION_PATCH)
 
 extern ll::Logger logger;
 
@@ -14,3 +18,5 @@ extern void Export_Legacy_GMLib_ServerAPI();
 extern void Export_Compatibility_API();
 extern void ExportPAPI();
 extern void Export_Event_API();
+extern void Export_BinaryStream_API();
+// extern void Export_Form_API();

src/LegacyModApi.cpp

@@ -2,14 +2,9 @@
 
 std::unordered_set<std::string> HardCodedKeys = {"AlwaysUnlocked", "PlayerHasManyItems", "PlayerInWater", "None"};
 
-std::variant<std::string, std::vector<RecipeIngredient>> makeRecipeUnlockingKey(std::string& key) {
+std::variant<std::string, std::vector<RecipeIngredient>> makeRecipeUnlockingKey(std::string const& key) {
-    if (HardCodedKeys.count(key)) {
+    if (HardCodedKeys.count(key)) return key;
-        return key;
+    return std::vector<RecipeIngredient>({RecipeIngredient(key, 0, 1)});
-    }
-    std::vector<RecipeIngredient> result;
-    auto                          item = RecipeIngredient(key, 0, 1);
-    result.emplace_back(item);
-    return result;
 }
 
 void Export_Legacy_GMLib_ModAPI() {
@@ -17,99 +12,95 @@ void Export_Legacy_GMLib_ModAPI() {
     RemoteCall::exportAs(
         "GMLib_ModAPI",
         "registerShapelessRecipe",
-        [](std::string              recipe_id,
+        [](std::string const&       recipe_id,
            std::vector<std::string> ingredients,
-           std::string              result,
+           std::string const&       result,
            int                      count,
-           std::string              unlock) -> void {
+           std::string const&       unlock) -> void {
-            auto level = GMLIB_Level::getInstance();
+            if (!GMLIB_Level::getInstance().has_value()) return;
-            if (!level) {
-                return;
-            }
             std::vector<RecipeIngredient> types;
             for (auto ing : ingredients) {
-                auto key = RecipeIngredient(ing, 0, 1);
+                types.emplace_back(ing, 0, 1);
-                types.push_back(key);
             }
-            auto res = RecipeIngredient(result, 0, count);
+            GMLIB::Mod::JsonRecipe::registerShapelessCraftingTableRecipe(
-            auto unl = makeRecipeUnlockingKey(unlock);
+                recipe_id,
-            GMLIB::Mod::JsonRecipe::registerShapelessCraftingTableRecipe(recipe_id, types, res, unl);
+                types,
+                RecipeIngredient(result, 0, count),
+                makeRecipeUnlockingKey(unlock)
+            );
         }
     );
     RemoteCall::exportAs(
         "GMLib_ModAPI",
         "registerShapedRecipe",
-        [](std::string              recipe_id,
+        [](std::string const&       recipe_id,
            std::vector<std::string> shape,
            std::vector<std::string> ingredients,
-           std::string              result,
+           std::string const&       result,
            int                      count,
-           std::string              unlock) -> void {
+           std::string const&       unlock) -> void {
-            auto level = GMLIB_Level::getInstance();
+            if (!GMLIB_Level::getInstance().has_value()) return;
-            if (!level) {
-                return;
-            }
             std::vector<RecipeIngredient> types;
             for (auto ing : ingredients) {
-                auto key = RecipeIngredient(ing, 0, 1);
+                types.push_back(RecipeIngredient(ing, 0, 1));
-                types.push_back(key);
             }
-            auto res = RecipeIngredient(result, 0, count);
+            GMLIB::Mod::JsonRecipe::registerShapedCraftingTableRecipe(
-            auto unl = makeRecipeUnlockingKey(unlock);
+                recipe_id,
-            GMLIB::Mod::JsonRecipe::registerShapedCraftingTableRecipe(recipe_id, shape, types, res, unl);
+                shape,
+                types,
+                RecipeIngredient(result, 0, count),
+                makeRecipeUnlockingKey(unlock)
+            );
         }
     );
     RemoteCall::exportAs(
         "GMLib_ModAPI",
         "registerFurnaceRecipe",
-        [](std::string recipe_id, std::string input, std::string output, std::vector<std::string> tags) -> void {
+        [](std::string const&       recipe_id,
-            auto level = GMLIB_Level::getInstance();
+           std::string const&       input,
-            if (!level) {
+           std::string const&       output,
-                return;
+           std::vector<std::string> tags) -> void {
-            }
+            if (!GMLIB_Level::getInstance().has_value()) return;
-            auto inp  = RecipeIngredient(input, 0, 1);
+            GMLIB::Mod::JsonRecipe::registerFurnaceRecipe(
-            auto outp = RecipeIngredient(output, 0, 1);
+                recipe_id,
-            GMLIB::Mod::JsonRecipe::registerFurnaceRecipe(recipe_id, inp, outp, tags);
+                RecipeIngredient(input, 0, 1),
+                RecipeIngredient(output, 0, 1),
+                tags
+            );
         }
     );
     RemoteCall::exportAs(
         "GMLib_ModAPI",
         "registerBrewingMixRecipe",
-        [](std::string recipe_id, std::string input, std::string output, std::string reagent) -> void {
+        [](std::string const& recipe_id, std::string const& input, std::string const& output, std::string const& reagent
-            auto level = GMLIB_Level::getInstance();
+        ) -> void {
-            if (!level) {
+            if (!GMLIB_Level::getInstance().has_value()) return;
-                return;
+            GMLIB::Mod::JsonRecipe::registerBrewingMixRecipe(recipe_id, input, output, RecipeIngredient(reagent, 0, 1));
-            }
-            auto rea = RecipeIngredient(reagent, 0, 1);
-            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 {
+        [](std::string const& recipe_id, std::string const& input, std::string const& output, std::string const& reagent
-            auto level = GMLIB_Level::getInstance();
+        ) -> void {
-            if (!level) {
+            if (!GMLIB_Level::getInstance().has_value()) return;
-                return;
+            GMLIB::Mod::JsonRecipe::registerBrewingContainerRecipe(
-            }
+                recipe_id,
-            auto inp  = RecipeIngredient(input, 0, 1);
+                RecipeIngredient(input, 0, 1),
-            auto outp = RecipeIngredient(output, 0, 1);
+                RecipeIngredient(output, 0, 1),
-            auto rea  = RecipeIngredient(reagent, 0, 1);
+                RecipeIngredient(reagent, 0, 1)
-            GMLIB::Mod::JsonRecipe::registerBrewingContainerRecipe(recipe_id, inp, outp, rea);
+            );
         }
     );
     RemoteCall::exportAs(
         "GMLib_ModAPI",
         "registerSmithingTransformRecipe",
-        [](std::string recipe_id,
+        [](std::string const& recipe_id,
-           std::string smithing_template,
+           std::string const& smithing_template,
-           std::string base,
+           std::string const& base,
-           std::string addition,
+           std::string const& addition,
-           std::string result) -> void {
+           std::string const& result) -> void {
-            auto level = GMLIB_Level::getInstance();
+            if (!GMLIB_Level::getInstance().has_value()) return;
-            if (!level) {
-                return;
-            }
             GMLIB::Mod::JsonRecipe::registerSmithingTransformRecipe(
                 recipe_id,
                 smithing_template,
@@ -122,30 +113,29 @@ void Export_Legacy_GMLib_ModAPI() {
     RemoteCall::exportAs(
         "GMLib_ModAPI",
         "registerSmithingTrimRecipe",
-        [](std::string recipe_id, std::string smithing_template, std::string base, std::string addition) -> void {
+        [](std::string const& recipe_id,
-            auto level = GMLIB_Level::getInstance();
+           std::string const& smithing_template,
-            if (!level) {
+           std::string const& base,
-                return;
+           std::string const& addition) -> void {
-            }
+            if (!GMLIB_Level::getInstance().has_value()) return;
             GMLIB::Mod::JsonRecipe::registerSmithingTrimRecipe(recipe_id, smithing_template, base, addition);
         }
     );
     RemoteCall::exportAs(
         "GMLib_ModAPI",
         "registerStoneCutterRecipe",
-        [](std::string recipe_id,
+        [](std::string const& recipe_id,
-           std::string input,
+           std::string const& input,
-           int         input_data,
+           int                input_data,
-           std::string output,
+           std::string const& output,
-           int         output_data,
+           int                output_data,
-           int         output_count) -> void {
+           int                output_count) -> void {
-            auto level = GMLIB_Level::getInstance();
+            if (!GMLIB_Level::getInstance().has_value()) return;
-            if (!level) {
+            GMLIB::Mod::JsonRecipe::registerStoneCutterRecipe(
-                return;
+                recipe_id,
-            }
+                RecipeIngredient(input, 0, 1),
-            auto inp  = RecipeIngredient(input, 0, 1);
+                RecipeIngredient(output, 0, 1)
-            auto outp = RecipeIngredient(output, 0, 1);
+            );
-            GMLIB::Mod::JsonRecipe::registerStoneCutterRecipe(recipe_id, inp, outp);
         }
     );
     // 错误方块清理
@@ -154,34 +144,35 @@ void Export_Legacy_GMLib_ModAPI() {
     });
     // 实验性
     RemoteCall::exportAs("GMLib_ModAPI", "registerExperimentsRequire", [](int experiment_id) -> void {
-        auto map = GMLIB_Level::getAllExperiments();
+        auto                               list = GMLIB_Level::getAllExperiments();
-        if (map.count(experiment_id)) {
+        std::unordered_set<AllExperiments> set(list.begin(), list.end());
+        if (set.contains((AllExperiments)experiment_id)) {
             GMLIB_Level::addExperimentsRequire((AllExperiments)experiment_id);
         } else {
             ll::Logger("Server").error("Experiment ID '{}' does not exist!", experiment_id);
         }
     });
     RemoteCall::exportAs("GMLib_ModAPI", "setExperimentEnabled", [](int experiment_id, bool value) -> void {
-        auto level = GMLIB_Level::getInstance();
+        if (GMLIB_Level::getInstance()) {
-        if (!level) {
+            auto                               list = GMLIB_Level::getAllExperiments();
-            return;
+            std::unordered_set<AllExperiments> set(list.begin(), list.end());
+            if (set.contains((AllExperiments)experiment_id)) {
+                GMLIB_Level::getInstance()->setExperimentEnabled(((AllExperiments)experiment_id), value);
+            } else ll::Logger("Server").error("Experiment ID '{}' does not exist!", experiment_id);
         }
-        auto map = GMLIB_Level::getAllExperiments();
-        if (map.count(experiment_id)) {
-            GMLIB_Level::getInstance()->setExperimentEnabled(((AllExperiments)experiment_id), value);
-        } else ll::Logger("Server").error("Experiment ID '{}' does not exist!", experiment_id);
     });
     RemoteCall::exportAs("GMLib_ModAPI", "getExperimentEnabled", [](int experiment_id) -> bool {
-        auto level = GMLIB_Level::getInstance();
+        if (GMLIB_Level::getInstance()) {
-        if (!level) {
+            auto                               list = GMLIB_Level::getAllExperiments();
-            return false;
+            std::unordered_set<AllExperiments> set(list.begin(), list.end());
-        }
+            if (set.contains((AllExperiments)experiment_id)) {
-        auto map = GMLIB_Level::getAllExperiments();
+                return GMLIB_Level::getInstance()->getExperimentEnabled(((AllExperiments)experiment_id));
-        if (map.count(experiment_id)) {
+            }
-            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

@@ -15,31 +15,36 @@ void Export_Legacy_GMLib_ServerAPI() {
         GMLIB_Level::requireServerResourcePackAndAllowClientResourcePack();
     });
     RemoteCall::exportAs("GMLib_ServerAPI", "getLevelName", []() -> std::string {
-        auto level = GMLIB_Level::getInstance();
+        return GMLIB_Level::getInstance()
-        if (!level) {
+            .transform([](GMLIB_Level& level) -> std::string { return level.getLevelName(); })
-            return "";
+            .value_or("");
-        }
-        return level->getLevelName();
     });
-    RemoteCall::exportAs("GMLib_ServerAPI", "setLevelName", [](std::string name) -> void {
+    RemoteCall::exportAs("GMLib_ServerAPI", "setLevelName", [](std::string const& name) -> void {
-        auto level = GMLIB_Level::getInstance();
+        if (auto level = GMLIB_Level::getInstance()) {
-        if (!level) {
+            level->setLevelName(name);
-            return;
         }
-        return level->setLevelName(name);
+    });
+    RemoteCall::exportAs("GMLib_ServerAPI", "getLevelSeed", []() -> std::string {
+        return GMLIB_Level::getInstance()
+            .transform([](GMLIB_Level& level) -> std::string { return std::to_string(level.getSeed()); })
+            .value_or("");
     });
     RemoteCall::exportAs("GMLib_ServerAPI", "setFakeSeed", [](int64_t seed) -> void {
         return GMLIB_Level::setFakeSeed(seed);
     });
-    RemoteCall::exportAs("GMLib_ServerAPI", "spawnEntity", [](std::pair<Vec3, int> pos, std::string name) -> Actor* {
+    RemoteCall::exportAs(
-        return GMLIB_Spawner::spawnEntity(pos.first, pos.second, name);
+        "GMLib_ServerAPI",
-    });
+        "spawnEntity",
+        [](std::pair<Vec3, int> pos, std::string const& name) -> Actor* {
+            return GMLIB_Spawner::spawnEntity(pos.first, pos.second, name).as_ptr();
+        }
+    );
     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);
+            return ac->shootProjectile(name, speed, offset).as_ptr();
         }
     );
     RemoteCall::exportAs(
@@ -47,8 +52,26 @@ 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();
+    });
+    RemoteCall::exportAs("GMLib_ServerAPI", "getMaxPlayers", []() -> int {
+        return GMLIB_Level::getInstance().transform(
+                                             [](GMLIB_Level& level) -> int { return level.getMaxPlayerCount(); }
+        ).value_or(0);
+    });
 }

src/PlaceholderApi.cpp

@@ -8,15 +8,15 @@ std::string removeBrackets(std::string a1) {
     return a1;
 }
 
-bool isParameters(std::string str) {
+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) {
+std::string GetValueWithPlayer(std::string const& key, Player* player) {
-    return GMLIB::Server::PlaceholderAPI::getValue(a1, ll::service::bedrock::getLevel()->getPlayer(a2));
+    return GMLIB::Server::PlaceholderAPI::getValue(key, player);
 }
 
 bool registerPlayerPlaceholder(
@@ -25,6 +25,7 @@ bool registerPlayerPlaceholder(
     std::string const& PAPIName
 ) {
     if (RemoteCall::hasFunc(PluginName, FuncName)) {
+        GMLIB::Server::PlaceholderAPI::unregisterPlaceholder(PAPIName);
         if (isParameters(PAPIName)) {
             auto Call = RemoteCall::importAs<std::string(Player * pl, std::unordered_map<std::string, std::string>)>(
                 PluginName,
@@ -54,6 +55,7 @@ bool registerServerPlaceholder(
     std::string const& PAPIName
 ) {
     if (RemoteCall::hasFunc(PluginName, FuncName)) {
+        GMLIB::Server::PlaceholderAPI::unregisterPlaceholder(PAPIName);
         if (isParameters(PAPIName)) {
             auto Call =
                 RemoteCall::importAs<std::string(std::unordered_map<std::string, std::string>)>(PluginName, FuncName);
@@ -64,11 +66,7 @@ bool registerServerPlaceholder(
             );
         } else {
             auto Call = RemoteCall::importAs<std::string()>(PluginName, FuncName);
-            GMLIB::Server::PlaceholderAPI::registerServerPlaceholder(
+            GMLIB::Server::PlaceholderAPI::registerServerPlaceholder(PAPIName, [Call]() { return Call(); }, PluginName);
-                PAPIName,
-                [Call]() { return Call(); },
-                PluginName
-            );
         }
         return true;
     }
@@ -82,6 +80,7 @@ bool registerStaticPlaceholder(
     int                num
 ) {
     if (RemoteCall::hasFunc(PluginName, FuncName)) {
+        GMLIB::Server::PlaceholderAPI::unregisterPlaceholder(PAPIName);
         if (isParameters(PAPIName)) {
             auto Call = RemoteCall::importAs<std::string()>(PluginName, FuncName);
             if (num == -1) {
@@ -110,7 +109,7 @@ std::string translateStringWithPlayer(std::string const& str, Player* 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); }
+bool unRegisterPlaceholder(std::string const& str) { return GMLIB::Server::PlaceholderAPI::unregisterPlaceholder(str); }
 
 std::vector<std::string> getAllPAPI() { return GMLIB::Server::PlaceholderAPI::getAllPAPI(); }
 

tooth.json

@@ -1,7 +1,7 @@
 {
     "format_version": 2,
     "tooth": "github.com/GroupMountain/GMLIB-LegacyRemoteCallApi",
-    "version": "0.12.5",
+    "version": "0.13.4",
     "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.12.5/GMLIB-LegacyRemoteCallApi-windows-x64.zip",
+    "asset_url": "https://github.com/GroupMountain/GMLIB-LegacyRemoteCallApi/releases/download/v0.13.4/GMLIB-LegacyRemoteCallApi-windows-x64.zip",
     "dependencies": {
-        "github.com/GroupMountain/GMLIB": ">=0.12.4"
+        "github.com/GroupMountain/GMLIB": ">=0.13.0"
     },
     "files": {
         "place": [

xmake.lua

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