wed150/GMLIB-LegacyRemoteCallApi
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #39 from GroupMountain/develop

Browse Source 
merge prs
This commit is contained in:
Zhongzi8972
2024-10-24 22:31:39 +08:00
committed by GitHub
Unverified
parent efacbeb89b b666ae361e
commit 92f9db9986
13 changed files with 1477 additions and 630 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/FormAPI-JS.js
+56 -3
View File
@@ -1,6 +1,10 @@
const getNextCallbackId = ll.import("GMLIB_FormAPI", "getNextFormCallbackId");
// 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")();
}
@@ -123,7 +127,56 @@ class ServerSettingForm {
static removeElement(id) {
return ll.import("GMLIB_ServerSettingForm", "removeElement")(id);
}
}
module.exports = { ServerSettingForm };
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
};
lib/GMLIB_API-JS.d.ts
Vendored
+284 -1
View File
@@ -1054,6 +1054,289 @@ declare class UserCache {
static getAllPlayerInfo(): { Xuid: String; Uuid: string; Name: string; }[]
}
type PacketDataItem = (
{
id: number,
type: 0x0 | 0x1 | 0x2 | 0x3 | 0x7,
value: number
}
| {
id: number,
type: 0x4,
value: string
}
| {
id: number,
type: 0x5,
value: NbtCompound
}
| {
id: number,
type: 0x6 | 0x8,
value: IntPos | FloatPos
}
);
type PacketData = (
| { type: "", value: PacketData | PacketData[] }
| { type: "Item", value: Item }
| { type: "CompoundTag", value: NbtCompound }
| {
type: "DataItem",
value: PacketDataItem[],
}
| {
type: "ActorLink",
value: {
mA: number,
mB: number,
mType: number,
mImmediate: boolean,
mPassengerInitiated: boolean,
},
}
| { type: "Vec3" | "BlockPos", value: FloatPos | IntPos }
| { type: "Vec2", value: DirectionAngle }
| { type: "String" | "Uuid", value: string }
| { type: "Bool", value: boolean }
| {
type:
"PacketHeader"
| "Byte"
| "Double"
| "Float"
| "SignedBigEndianInt"
| "SignedInt"
| "SignedInt64"
| "SignedShort"
| "UnsignedChar"
| "UnsignedInt"
| "UnsignedInt64"
| "UnsignedShort"
| "UnsignedVarInt"
| "UnsignedVarInt64"
| "VarInt"
| "VarInt64",
value: number,
}
);
/** 二进制流数据包类 */
declare class GMLIB_BinaryStream {
/** 数据包ID */
#id: number;
/** 数据包是否被销毁 */
#destroy: boolean;
constructor(
/** 数据包数据 */
data: PacketData[]?
);
/** 发送数据包 */
sendTo(
/** 要发送数据包的玩家对象 */
player: Player,
/** 数据包发送后是否销毁 */
free: boolean = true
): GMLIB_BinaryStream;
/** 发送数据包到玩家数组 */
sendToPlayers(
/** 要发送数据包的玩家对象数组 */
players: Player[],
/** 数据包发送后是否销毁 */
free: boolean = true
): GMLIB_BinaryStream;
/** 发送数据包到所有玩家 */
sendToAll(
/** 数据包发送后是否销毁 */
free: boolean = true
): GMLIB_BinaryStream;
/** 发送数据包到维度 */
sendToDimension(
/** 维度ID */
dimid: number,
/** 数据包发送后是否销毁 */
free: boolean = true
): GMLIB_BinaryStream;
/** 销毁数据包 */
destroy(): GMLIB_BinaryStream;
/** 数据包是否已被销毁 */
isDestroy(): boolean;
/** 重置数据包 */
reset(): GMLIB_BinaryStream;
/** 转换成字符串 */
toString(): string;
/** 写入数据 */
write(
/** 数据 */
data: PacketData | PacketData[]?
): GMLIB_BinaryStream;
/** 写入数据包头部 */
writePacketHeader(
/** 数据包ID */
id: number
): GMLIB_BinaryStream;
/** 写入UUID */
writeUuid(
/** UUID */
value: string
): GMLIB_BinaryStream;
/** 写入物品 */
writeItem(
/** 物品对象 */
value: Item
): GMLIB_BinaryStream;
/** 写入NBT */
writeCompoundTag(
/** NBT */
value: NbtCompound
): GMLIB_BinaryStream;
/** */
writeDataItem(
/** 数据项 */
value: PacketDataItem[]
): GMLIB_BinaryStream;
writeActorLink(
/** 数据项 */
value: { "mA": number, "mB": number, "mType": number, "mImmediate": boolean, "mPassengerInitiated": boolean }
): GMLIB_BinaryStream;
/** 写入浮点数坐标对象 */
writeVec3(
/** 浮点数坐标对象 */
value: FloatPos
): GMLIB_BinaryStream;
/** 写入整数坐标对象 */
writeBlockPos(
/** 整数坐标对象 */
value: IntPos
): GMLIB_BinaryStream;
/** */
writeVec2(
/** 数据 */
value: { "x": number, "z": number }
): GMLIB_BinaryStream;
/** 写入字符串 */
writeString(
/** 字符串 */
value: string
): GMLIB_BinaryStream;
/** 写入布尔值 */
writeBool(
/** 布尔值 */
value: boolean
): GMLIB_BinaryStream;
/** 写入字节 */
writeByte(
/** 字节 */
value: number
): GMLIB_BinaryStream;
/** 写入(双精度)浮点数 */
writeDouble(
/** 浮点数 */
value: number
): GMLIB_BinaryStream;
/** 写入(单精度)浮点数 */
writeFloat(
/** 浮点数 */
value: number
): GMLIB_BinaryStream;
/** */
writeSignedBigEndianInt(
/** 数值 */
value: number
): GMLIB_BinaryStream;
/** */
writeSignedInt(
/** 数值 */
value: number
): GMLIB_BinaryStream;
/** 写入 */
writeSignedInt64(
/** 数值 */
value: number
): GMLIB_BinaryStream;
/** */
writeSignedShort(
/** 数值 */
value: number
): GMLIB_BinaryStream;
/** */
writeUnsignedChar(
/** 数值 */
value: number
): GMLIB_BinaryStream;
/** */
writeUnsignedInt(
/** 数值 */
value: number
): GMLIB_BinaryStream;
/** */
writeUnsignedInt64(
/** 数值 */
value: number
): GMLIB_BinaryStream;
/** */
writeUnsignedShort(
/** 数值 */
value: number
): GMLIB_BinaryStream;
/** */
writeUnsignedVarInt(
/** 数值 */
value: number
): GMLIB_BinaryStream;
/** */
writeUnsignedVarInt64(
/** 数值 */
value: number
): GMLIB_BinaryStream;
/** */
writeVarInt(
/** 数值 */
value: number
): GMLIB_BinaryStream;
/** */
writeVarInt64(
/** 数值 */
value: number
): GMLIB_BinaryStream;
}
interface Player {
/** (GMLIB)转换成实体对象 */
toEntity(): Entity;
@@ -1081,7 +1364,7 @@ interface Player {
/** (GMLIB)获取玩家的rumtimeId */
getRuntimeId(): number;
/** (GMLIB)获取玩家饱食度 */
/** (GMLIB)获取玩家饥饿值 */
getHungry(): number;
/** (GMLIB)获取玩家盔甲覆盖百分比 */
lib/GMLIB_API-JS.js
+473 -4
View File
@@ -316,7 +316,7 @@ const GMLIB_API = {
getItemCanPlaceOn: ll.import("GMLIB_API", "getItemCanPlaceOn"),
/** 设置物品冒险模式下能放置在什么方块上 @type {function(Item,Array.<string>):void} */
setItemCanPlaceOn: ll.import("GMLIB_API", "setItemCanPlaceOn"),
/** 获取玩家饱食度 @type {function(Player):number} */
/** 获取玩家饥饿值 @type {function(Player):number} */
getPlayerHungry: ll.import("GMLIB_API", "getPlayerHungry"),
/** 获取玩家盔甲覆盖百分比 @type {function(Player):number} */
getPlayerArmorCoverPercentage: ll.import("GMLIB_API", "getPlayerArmorCoverPercentage"),
@@ -374,7 +374,61 @@ const GMLIB_API = {
getDefaultGameMode: ll.import("GMLIB_API", "getDefaultGameMode"),
/** 设置默认游戏模式 @type {function(mode):void} */
setDefaultGameMode: ll.import("GMLIB_API", "setDefaultGameMode"),
}
};
/** LRCA的二进制流数据包导出接口 */
const GMLIB_BinaryStream_API = {
/** 创建二进制流数据包 @type {function():number} */
create: ll.import("GMLIB_BinaryStream_API", "create"),
/** 发送二进制流数据包 @type {function(number,player):void} */
sendTo: ll.import("GMLIB_BinaryStream_API", "sendTo"),
/** 销毁二进制流数据包 @type {function(number):void} */
destroy: ll.import("GMLIB_BinaryStream_API", "destroy"),
/** 重置二进制流数据包 @type {function(number):void} */
reset: ll.import("GMLIB_BinaryStream_API", "reset"),
/** 写入二进制流数据包头部 @type {function(number, number):void} */
writePacketHeader: ll.import("GMLIB_BinaryStream_API", "writePacketHeader"),
/** 写入UUID @type {function(number, string):void} */
writeUuid: ll.import("GMLIB_BinaryStream_API", "writeUuid"),
/** 写入物品 @type {function(number, Item):void} */
writeItem: ll.import("GMLIB_BinaryStream_API", "writeItem"),
/** 写入NBT @type {function(NbtCompound, Item):void} */
writeCompoundTag: ll.import("GMLIB_BinaryStream_API", "writeCompoundTag"),
/** 写入字符串 @type {function(number, string):void} */
writeString: ll.import("GMLIB_BinaryStream_API", "writeString"),
/** 写入布尔值 @type {function(number, boolean):void} */
writeBool: ll.import("GMLIB_BinaryStream_API", "writeBool"),
/** 写入字节 @type {function(number, number):void} */
writeByte: ll.import("GMLIB_BinaryStream_API", "writeByte"),
/** 写入双精度浮点数 @type {function(number, number):void} */
writeDouble: ll.import("GMLIB_BinaryStream_API", "writeDouble"),
/** 写入浮点数 @type {function(number, number):void} */
writeFloat: ll.import("GMLIB_BinaryStream_API", "writeFloat"),
/** @type {function(number, number):void} */
writeSignedBigEndianInt: ll.import("GMLIB_BinaryStream_API", "writeSignedBigEndianInt"),
/** @type {function(number, number):void} */
writeSignedInt: ll.import("GMLIB_BinaryStream_API", "writeSignedInt"),
/** @type {function(number, number):void} */
writeSignedInt64: ll.import("GMLIB_BinaryStream_API", "writeSignedInt64"),
/** @type {function(number, number):void} */
writeSignedShort: ll.import("GMLIB_BinaryStream_API", "writeSignedShort"),
/** @type {function(number, number):void} */
writeUnsignedChar: ll.import("GMLIB_BinaryStream_API", "writeUnsignedChar"),
/** @type {function(number, number):void} */
writeUnsignedInt: ll.import("GMLIB_BinaryStream_API", "writeUnsignedInt"),
/** @type {function(number, number):void} */
writeUnsignedInt64: ll.import("GMLIB_BinaryStream_API", "writeUnsignedInt64"),
/** @type {function(number, number):void} */
writeUnsignedShort: ll.import("GMLIB_BinaryStream_API", "writeUnsignedShort"),
/** @type {function(number, number):void} */
writeUnsignedVarInt: ll.import("GMLIB_BinaryStream_API", "writeUnsignedVarInt"),
/** @type {function(number, number):void} */
writeUnsignedVarInt64: ll.import("GMLIB_BinaryStream_API", "writeUnsignedVarInt64"),
/** @type {function(number, number):void} */
writeVarInt: ll.import("GMLIB_BinaryStream_API", "writeVarInt"),
/** @type {function(number, number):void} */
writeVarInt64: ll.import("GMLIB_BinaryStream_API", "writeVarInt64"),
};
/** 静态悬浮字类列表 @type {Map<number,StaticFloatingText>} */
const mStaticFloatingTextMap = new Map();
@@ -2052,6 +2106,420 @@ class UserCache {
}
};
/** 二进制数据包API类 */
class GMLIB_BinaryStream {
/** 数据包ID @type {number} */
#id = null;
/** 数据包是否被销毁 @type {boolean} */
#destroy = false;
/**
* 创建二进制流数据包
* @param {{"type":string,"value":any}[]?} value 写入数据
* @returns {GMLIB_BinaryStream}
*/
constructor(value) {
this.#id = GMLIB_BinaryStream_API.create();
if (Array.isArray(value)) this.write(value);
}
/**
* 发送数据包
* @param {Player} player 玩家
* @param {boolean} [free=true] 发送后销毁数据包
* @returns {GMLIB_BinaryStream}
*/
sendTo(player, free = true) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
GMLIB_BinaryStream_API.sendTo(this.#id, player);
if (free) this.destroy();
return this;
}
/**
* 发送数据包到玩家
* @param {Player[]} players 玩家对象数组
* @param {boolean} free 发送后销毁数据包
* @returns {GMLIB_BinaryStream}
*/
sendToPlayers(players, free = true) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
players.forEach(player => this.sendTo(player, false));
if (free) this.destroy();
return this;
}
/**
* 发送数据包到所有玩家
* @param {boolean} [free=true] 发送后销毁数据包
* @returns {GMLIB_BinaryStream}
*/
sendToAll(free = true) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
mc.getOnlinePlayers().forEach(player => this.sendTo(player, false));
if (free) this.destroy();
return this;
}
/**
* 发送数据包到维度
* @param {number} dimid 维度ID
* @param {boolean} [free=true] 发送后销毁数据包
* @returns {GMLIB_BinaryStream}
*/
sendToDimension(dimid, free = true) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
mc.getOnlinePlayers().filter(player => player.pos.dimid === dimid).forEach(player => this.sendTo(player, false));
if (free) this.destroy();
return this;
}
/**
* 销毁数据包
* @returns {GMLIB_BinaryStream}
*/
destroy() {
GMLIB_BinaryStream_API.destroy(this.#id);
this.#destroy = true;
return this;
}
/**
* 数据包是否已被销毁
* @returns {boolean}
*/
isDestroy() {
return this.#destroy;
}
/**
* 重置数据包
* @returns {GMLIB_BinaryStream}
*/
reset() {
GMLIB_BinaryStream_API.reset(this.#id);
this.#destroy = false;
return this;
}
/**
* 转换成字符串
* @returns {string} 字符串
*/
toString(){
return `<GMLIB_BinaryStream#${this.#id}>`
}
/**
* 写入数据
* @param {{"type":string,"value":any}[]|{"type":string,"value":any}} value 数据
* @returns {GMLIB_BinaryStream}
*/
write(value) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
if (Array.isArray(value)) value.forEach(v => this.write(v));
if (value?.type != null && value?.value != null) this[`write${value.type}`]?.(value.value);
return this;
}
/**
* 写入数据包头部
* @param {number} id 数据包ID
* @returns {GMLIB_BinaryStream}
*/
writePacketHeader(id) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
GMLIB_BinaryStream_API.writePacketHeader(this.#id, id);
return this;
}
/**
* 写入UUID
* @param {string} value UUID
* @returns {GMLIB_BinaryStream}
*/
writeUuid(value) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
GMLIB_BinaryStream_API.writeUuid(this.#id, value);
return this;
}
/**
* 写入物品
* @param {Item} value 物品
* @returns {GMLIB_BinaryStream}
*/
writeItem(value) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
GMLIB_BinaryStream_API.writeItem(this.#id, value);
return this;
}
/**
* 写入NBT
* @param {NbtCompound} value NBT
* @returns {GMLIB_BinaryStream}
*/
writeCompoundTag(value) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
GMLIB_BinaryStream_API.writeCompoundTag(this.#id, value);
return this;
}
/**
* @param {{"id":number,"type":number,"value":string|IntPos|FloatPos|number|NbtCompound}[]} value 数据
* @returns {GMLIB_BinaryStream}
*/
writeDataItem(value) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
this.writeUnsignedVarInt(value.length);
for (const data of value) {
this.writeUnsignedVarInt(data.id);
this.writeUnsignedVarInt(data.type);
switch (data.type) {
case 0: this.writeByte(data.value); break;
case 1: this.writeSignedShort(data.value); break;
case 2: this.writeSignedInt(data.value); break;
case 3: this.writeFloat(data.value); break;
case 4: this.writeString(data.value); break;
case 5: this.writeCompoundTag(data.value); break;
case 6: this.writeBlockPos(data.value); break;
case 7: this.writeSignedInt64(data.value); break;
case 8: this.writeVec3(data.value); break;
default: throw new Error("Unknown data type");
}
}
return this;
}
/**
* @param {{"mA":number,"mB":number,"mType":number,"mImmediate":boolean,"mPassengerInitiated":boolean}} value 数据
* @returns {GMLIB_BinaryStream}
*/
writeActorLink(value) {
this.writeVarInt64(value.mA);
this.writeVarInt64(value.mB);
this.writeUnsignedChar(value.mType);
this.writeBool(value.mImmediate);
this.writeBool(value.mPassengerInitiated);
return this;
}
/**
* 写入字符串
* @param {string} value 字符串
* @returns {GMLIB_BinaryStream}
*/
writeString(value) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
GMLIB_BinaryStream_API.writeString(this.#id, value);
return this;
}
/**
* 写入布尔值
* @param {boolean} value 布尔值
* @returns {GMLIB_BinaryStream}
*/
writeBool(value) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
GMLIB_BinaryStream_API.writeBool(this.#id, value);
return this;
}
/**
* 写入字节
* @param {number} value 字节
* @returns {GMLIB_BinaryStream}
*/
writeByte(value) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
GMLIB_BinaryStream_API.writeByte(this.#id, value);
return this;
}
/**
* 写入(双精度)浮点数
* @param {number} value 浮点数
* @returns {GMLIB_BinaryStream}
*/
writeDouble(value) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
GMLIB_BinaryStream_API.writeDouble(this.#id, value);
return this;
}
/**
* 写入(单精度)浮点数
* @param {number} value 浮点数
* @returns {GMLIB_BinaryStream}
*/
writeFloat(value) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
GMLIB_BinaryStream_API.writeFloat(this.#id, value);
return this;
}
/**
* 写入浮点数坐标对象
* @param {FloatPos} value 浮点数坐标对象
* @returns {GMLIB_BinaryStream}
*/
writeVec3({ x, y, z }) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
this.writeFloat(x);
this.writeFloat(y);
this.writeFloat(z);
return this;
}
/**
* 写入整数坐标对象
* @param {IntPos} value 整数坐标对象
* @returns {GMLIB_BinaryStream}
*/
writeBlockPos({ x, y, z }) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
this.writeVarInt(x);
this.writeUnsignedVarInt(y);
this.writeVarInt(z);
return this;
}
/**
*
* @param {{"x":number,"z":number}} value 数值
* @returns {GMLIB_BinaryStream}
*/
writeVec2({ x, z }) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
this.writeFloat(x);
this.writeFloat(z);
return this;
}
/**
* @param {number} value 数值
* @returns {GMLIB_BinaryStream}
*/
writeSignedBigEndianInt(value) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
GMLIB_BinaryStream_API.writeSignedBigEndianInt(this.#id, value);
return this;
}
/**
* @param {number} value 数值
* @returns {GMLIB_BinaryStream}
*/
writeSignedInt(value) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
GMLIB_BinaryStream_API.writeSignedInt(this.#id, value);
return this;
}
/**
* @param {number} value 数值
* @returns {GMLIB_BinaryStream}
*/
writeSignedInt64(value) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
GMLIB_BinaryStream_API.writeSignedInt64(this.#id, value);
return this;
}
/**
* @param {number} value 数值
* @returns {GMLIB_BinaryStream}
*/
writeSignedShort(value) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
GMLIB_BinaryStream_API.writeSignedShort(this.#id, value);
return this;
}
/**
* @param {number} value 数值
* @returns {GMLIB_BinaryStream}
*/
writeUnsignedChar(value) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
GMLIB_BinaryStream_API.writeUnsignedChar(this.#id, value);
return this;
}
/**
* @param {number} value 数值
* @returns {GMLIB_BinaryStream}
*/
writeUnsignedInt(value) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
GMLIB_BinaryStream_API.writeUnsignedInt(this.#id, value);
return this;
}
/**
* @param {number} value 数值
* @returns {GMLIB_BinaryStream}
*/
writeUnsignedInt64(value) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
GMLIB_BinaryStream_API.writeUnsignedInt64(this.#id, value);
return this;
}
/**
* @param {number} value 数值
* @returns {GMLIB_BinaryStream}
*/
writeUnsignedShort(value) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
GMLIB_BinaryStream_API.writeUnsignedShort(this.#id, value);
return this;
}
/**
* @param {number} value 数值
* @returns {GMLIB_BinaryStream}
*/
writeUnsignedVarInt(value) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
GMLIB_BinaryStream_API.writeUnsignedVarInt(this.#id, value);
return this;
}
/**
* @param {number} value 数值
* @returns {GMLIB_BinaryStream}
*/
writeUnsignedVarInt64(value) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
GMLIB_BinaryStream_API.writeUnsignedVarInt64(this.#id, value);
return this;
}
/**
* @param {number} value 数值
* @returns {GMLIB_BinaryStream}
*/
writeVarInt(value) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
GMLIB_BinaryStream_API.writeVarInt(this.#id, value);
return this;
}
/**
* @param {number} value 数值
* @returns {GMLIB_BinaryStream}
*/
writeVarInt64(value) {
if (this.#destroy) throw new Error("The BinaryStream has been destroyed");
GMLIB_BinaryStream_API.writeVarInt64(this.#id, value);
return this;
}
}
LLSE_Player.prototype.toEntity =
/**
* 获取实体对象
@@ -2470,7 +2938,7 @@ LLSE_Item.prototype.setCanPlaceOn =
LLSE_Player.prototype.getHungry =
/**
* 获取玩家饱食度
* 获取玩家饥饿值
* @returns {number}
*/
function () {
@@ -2661,5 +3129,6 @@ module.exports = {
JsonI18n,
Version,
I18nAPI,
UserCache
UserCache,
GMLIB_BinaryStream
};
src/BinaryStreamApi.cpp
+80
View File
@@ -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::network::BinaryStream>> mBinaryStream;
public:
uint getNextId() { return mNextBinaryStreamId++; }
void cretateBinaryStream(uint id) { mBinaryStream[id] = std::make_shared<gmlib::network::BinaryStream>(); }
void removeBinaryStream(uint64 id) { mBinaryStream.erase(id); }
std::shared_ptr<gmlib::network::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::network::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/CompatibilityApi.cpp
+241 -352
View File
File diff suppressed because it is too large Load Diff
src/Entry.cpp
+5 -4
View File
@@ -3,7 +3,7 @@
ll::Logger logger(PLUGIN_NAME);
namespace GMLIB {
namespace gmlib {
std::unique_ptr<LegacyRemoteCallApi>& LegacyRemoteCallApi::getInstance() {
static std::unique_ptr<LegacyRemoteCallApi> instance;
@@ -16,11 +16,12 @@ bool LegacyRemoteCallApi::load() {
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-" + Version::getLibVersionString()),
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");
@@ -32,6 +33,6 @@ bool LegacyRemoteCallApi::enable() { return true; }
bool LegacyRemoteCallApi::disable() { return true; }
} // namespace GMLIB
} // namespace gmlib
LL_REGISTER_MOD(LegacyRemoteCallApi, LegacyRemoteCallApi::getInstance());
LL_REGISTER_MOD(gmlib::LegacyRemoteCallApi, gmlib::LegacyRemoteCallApi::getInstance());
src/Entry.h
+2 -2
View File
@@ -2,7 +2,7 @@
#include <ll/api/mod/NativeMod.h>
#include <ll/api/mod/RegisterHelper.h>
namespace GMLIB {
namespace gmlib {
class LegacyRemoteCallApi {
@@ -30,4 +30,4 @@ private:
ll::mod::NativeMod& mSelf;
};
} // namespace GMLIB
} // namespace gmlib
src/EventAPI.cpp
+51 -44
View File
@@ -13,7 +13,7 @@ public:
}
void emplaceListener(std::string const& scriptEventId, ll::event::ListenerPtr listenerPtr) {
mEventListeners[doHash(scriptEventId)] = listenerPtr;
mEventListeners[doHash(scriptEventId)] = std::move(listenerPtr);
}
void removeListener(std::string const& scriptEventId) {
@@ -63,79 +63,79 @@ void Export_Event_API() {
switch (doHash(eventName)) {
case doHash("onClientLogin"): {
REGISTER_EVENT_LISTEN(
Event::PacketEvent::ClientLoginAfterEvent,
gmlib::event::packet::ClientLoginAfterEvent,
(std::string const& realName,
std::string const& uuid,
std::string const& serverXuid,
std::string const& clientXuid),
(ev.getRealName(), ev.getUuid().asString(), ev.getServerAuthXuid(), ev.getClientAuthXuid()),
logger.error("Event \"onClientLogin\" cannot be intercepted"),
);
)
}
case doHash("onWeatherChange"): {
REGISTER_EVENT_LISTEN(
Event::LevelEvent::WeatherUpdateBeforeEvent,
gmlib::event::level::WeatherUpdateBeforeEvent,
(int lightningLevel, int rainLevel, int lightningLast, int rainLast),
(ev.getLightningLevel(), ev.getRainLevel(), ev.getLightningLastTick(), ev.getRainingLastTick()),
ev.cancel(),
);
)
}
case doHash("onMobPick"): {
REGISTER_EVENT_LISTEN(
Event::EntityEvent::MobPickupItemBeforeEvent,
gmlib::event::entity::MobPickupItemBeforeEvent,
(Actor * mob, Actor * item),
(&ev.self(), (Actor*)&ev.getItemActor()),
ev.cancel(),
);
)
}
case doHash("onItemTrySpawn"): {
REGISTER_EVENT_LISTEN(
Event::EntityEvent::ItemActorSpawnBeforeEvent,
gmlib::event::entity::ItemActorSpawnBeforeEvent,
(const ItemStack* item, std::pair<Vec3, int> position, int64 spawnerUniqueId),
(&ev.getItem(),
{ev.getPosition(), ev.getBlockSource().getDimensionId().id},
ev.getSpawner().has_value() ? ev.getSpawner()->getOrCreateUniqueID().id : -1),
ev.cancel(),
);
)
}
case doHash("onItemSpawned"): {
REGISTER_EVENT_LISTEN(
Event::EntityEvent::ItemActorSpawnAfterEvent,
gmlib::event::entity::ItemActorSpawnAfterEvent,
(const ItemStack* item, Actor* itemActor, std::pair<Vec3, int> position, int64 spawnerUniqueId),
(&ev.getItem(),
(Actor*)&ev.getItemActor(),
{ev.getPosition(), ev.getBlockSource().getDimensionId().id},
ev.getSpawner().has_value() ? ev.getSpawner()->getOrCreateUniqueID().id : -1),
logger.error("Event \"onItemSpawned\" cannot be intercepted"),
);
)
}
case doHash("onEntityTryChangeDim"): {
REGISTER_EVENT_LISTEN(
Event::EntityEvent::ActorChangeDimensionBeforeEvent,
gmlib::event::entity::ActorChangeDimensionBeforeEvent,
(Actor * entity, int toDimId),
(&ev.self(), ev.getToDimensionId()),
ev.cancel(),
);
)
}
case doHash("onLeaveBed"): {
REGISTER_EVENT_LISTEN(
Event::PlayerEvent::PlayerStopSleepBeforeEvent,
gmlib::event::player::PlayerStopSleepBeforeEvent,
(Player * pl),
(&ev.self()),
ev.cancel(),
);
)
}
case doHash("onDeathMessage"): {
REGISTER_EVENT_LISTEN(
Event::EntityEvent::DeathMessageAfterEvent,
gmlib::event::entity::DeathMessageAfterEvent,
(std::string const& message, std::vector<std::string>, Actor* dead),
(ev.getDeathMessage().first, ev.getDeathMessage().second, &ev.self()),
logger.error("Event \"onDeathMessage\" cannot be intercepted"),
);
)
}
case doHash("onMobHurted"): {
REGISTER_EVENT_LISTEN(
Event::EntityEvent::MobHurtAfterEvent,
gmlib::event::entity::MobHurtAfterEvent,
(Actor * mob, Actor * source, float damage, int cause),
(&ev.self(), source, ev.getDamage(), (int)damageSource.getCause()),
logger.error("Event \"onMobHurted\" cannot be intercepted"),
@@ -146,27 +146,27 @@ void Export_Event_API() {
source = ll::service::getLevel()->fetchEntity(uniqueId);
if (source->getOwner()) source = source->getOwner();
}
);
)
}
case doHash("onEndermanTake"): {
REGISTER_EVENT_LISTEN(
Event::EntityEvent::EndermanTakeBlockBeforeEvent,
gmlib::event::entity::EndermanTakeBlockBeforeEvent,
(Actor * mob),
(&ev.self()),
ev.cancel(),
);
)
}
case doHash("onEntityChangeDim"): {
REGISTER_EVENT_LISTEN(
Event::EntityEvent::ActorChangeDimensionAfterEvent,
gmlib::event::entity::ActorChangeDimensionAfterEvent,
(Actor * mob, int fromDimId),
(&ev.self(), ev.getFromDimensionId()),
logger.error("Event \"onEntityChangeDim\" cannot be intercepted"),
);
)
}
case doHash("onDragonRespawn"): {
REGISTER_EVENT_LISTEN(
Event::EntityEvent::DragonRespawnBeforeEvent,
gmlib::event::entity::DragonRespawnBeforeEvent,
(int64 enderDragonUniqueID),
(ev.getEnderDragon().id),
ev.cancel(),
@@ -174,51 +174,58 @@ void Export_Event_API() {
}
case doHash("onProjectileTryCreate"): {
REGISTER_EVENT_LISTEN(
Event::EntityEvent::ProjectileCreateBeforeEvent,
gmlib::event::entity::ProjectileCreateBeforeEvent,
(Actor * mob, int64 uniqueId),
(&ev.self(), ev.getShooter() ? ev.getShooter()->getOrCreateUniqueID().id : -1),
ev.cancel(),
);
)
}
case doHash("onProjectileCreate"): {
REGISTER_EVENT_LISTEN(
Event::EntityEvent::ProjectileCreateAfterEvent,
gmlib::event::entity::ProjectileCreateAfterEvent,
(Actor * mob, int64 uniqueId),
(&ev.self(), ev.getShooter() ? ev.getShooter()->getOrCreateUniqueID().id : -1),
logger.error("Event \"onProjectileCreate\" cannot be intercepted"),
);
)
}
case doHash("onSpawnWanderingTrader"): {
REGISTER_EVENT_LISTEN(
Event::EntityEvent::SpawnWanderingTraderBeforeEvent,
gmlib::event::entity::SpawnWanderingTraderBeforeEvent,
(std::pair<BlockPos, int> pos),
({ev.getPos(), ev.getRegion().getDimensionId()}),
ev.cancel(),
);
)
}
case doHash("onHandleRequestAction"): {
REGISTER_EVENT_LISTEN(Event::PlayerEvent::HandleRequestActionBeforeEvent,
(Player * player,
// clang-format off
REGISTER_EVENT_LISTEN(
gmlib::event::player::HandleRequestActionBeforeEvent,
(
Player * player,
std::string const& actionType,
int count,
std::string const& sourceContainerNetId,
int sourceSlot,
std::string const& destinationContainerNetId,
int destinationSlot),
((Player*)&ev.self(),
magic_enum::enum_name(requestAction->mActionType).data(),
(int)requestAction->mAmount,
magic_enum::enum_name(requestAction->mSrc.mOpenContainerNetId).data(),
(int)requestAction->mSrc.mSlot,
magic_enum::enum_name(requestAction->mDst.mOpenContainerNetId).data(),
(int)requestAction->mDst.mSlot),
int destinationSlot
),
(
(Player*)&ev.self(),
magic_enum::enum_name(requestAction.mActionType).data(),
(int)requestAction.mAmount,
magic_enum::enum_name(requestAction.mSrc.mOpenContainerNetId).data(),
(int)requestAction.mSrc.mSlot,
magic_enum::enum_name(requestAction.mDst.mOpenContainerNetId).data(),
(int)requestAction.mDst.mSlot
),
ev.cancel(),
auto requestAction = (ItemStackRequestActionTransferBase*)&ev.getRequestAction();
);
auto& requestAction = (ItemStackRequestActionTransferBase&)ev.getRequestAction();
)
// clang-format on
}
case doHash("onSendContainerClosePacket"): {
REGISTER_EVENT_LISTEN(
Event::PacketEvent::ContainerClosePacketSendAfterEvent,
gmlib::event::packet::ContainerClosePacketSendAfterEvent,
(Player * player, int ContainerNetId),
(ev.getServerNetworkHandler()
.getServerPlayer(ev.getNetworkIdentifier(), ev.getPacket().mClientSubId),
@@ -232,7 +239,7 @@ void Export_Event_API() {
(),
(),
logger.error("Event \"onServerStopping\" cannot be intercepted"),
);
)
}
default:
return false;
src/FormAPI.cpp
+139 -83
View File
@@ -1,19 +1,70 @@
#include "Global.h"
using namespace GMLIB::Server::Form;
using namespace ll::hash_utils;
class LegacyScriptFormManager {
private:
int64 mNextFormCallbackId = 0;
// std::unordered_map<int64, ll::event::ListenerPtr> mEventListeners;
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() {
mNextFormCallbackId++;
return "GMLIB_EVENT_" + std::to_string(mNextFormCallbackId);
// 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;
@@ -25,113 +76,83 @@ public:
};
#define PLAYER_DETECROR \
[detectorId, result](Player& pl) -> bool { \
[detectorId, result](::Player& pl) -> bool { \
try { \
if (RemoteCall::hasFunc("GMLIB_FORM_CALLBACK", detectorId)) { \
auto const& detector = RemoteCall::importAs<bool(Player*)>("GMLIB_FORM_CALLBACK", detectorId); \
auto const& detector = RemoteCall::importAs<bool(::Player*)>("GMLIB_FORM_CALLBACK", detectorId); \
return detector(&pl); \
} else { \
ServerSettingForm::removeElement(result); \
gmlib::form::ServerSettingForm::removeElement(result); \
} \
} catch (...) {} \
return false; \
}
#define CALLBACK_TYPE_STRING \
[callbackId, result](Player& pl, std::string const& data) { \
#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*, std::string const&)>("GMLIB_FORM_CALLBACK", callbackId); \
auto const& callback = RemoteCall::importAs<void(Player*, type)>("GMLIB_FORM_CALLBACK", callbackId); \
callback(&pl, data); \
} else { \
ServerSettingForm::removeElement(result); \
gmlib::form::ServerSettingForm::removeElement(result); \
} \
} catch (...) {} \
}
#define CALLBACK_TYPE_BOOL \
[callbackId, result](Player& pl, bool data) { \
#define CALLBACK_TYPE_NORMAL \
[callbackId](::Player& pl) { \
try { \
if (RemoteCall::hasFunc("GMLIB_FORM_CALLBACK", callbackId)) { \
auto const& callback = RemoteCall::importAs<void(Player*, bool)>("GMLIB_FORM_CALLBACK", callbackId); \
callback(&pl, data); \
} else { \
ServerSettingForm::removeElement(result); \
} \
} catch (...) {} \
}
#define CALLBACK_TYPE_DOUBLE \
[callbackId, result](Player& pl, double data) { \
try { \
if (RemoteCall::hasFunc("GMLIB_FORM_CALLBACK", callbackId)) { \
auto const& callback = RemoteCall::importAs<void(Player*, double)>("GMLIB_FORM_CALLBACK", callbackId); \
callback(&pl, data); \
} else { \
ServerSettingForm::removeElement(result); \
} \
} catch (...) {} \
}
#define CALLBACK_TYPE_LONG \
[callbackId, result](Player& pl, int64 data) { \
try { \
if (RemoteCall::hasFunc("GMLIB_FORM_CALLBACK", callbackId)) { \
auto const& callback = RemoteCall::importAs<void(Player*, int64)>("GMLIB_FORM_CALLBACK", callbackId); \
callback(&pl, data); \
} else { \
ServerSettingForm::removeElement(result); \
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 ServerSettingForm::getDefaultPriority();
return gmlib::form::ServerSettingForm::getDefaultPriority();
});
RemoteCall::exportAs("GMLIB_FormAPI", "getNextFormCallbackId", []() -> std::string {
return LegacyScriptFormManager::getInstance().getNextFormCallbackId();
});
RemoteCall::exportAs("GMLIB_ServerSettingForm", "hasTitle", []() -> bool { return ServerSettingForm::hasTitle(); });
RemoteCall::exportAs("GMLIB_ServerSettingForm", "hasTitle", []() -> bool { return gmlib::form::ServerSettingForm::hasTitle(); });
RemoteCall::exportAs("GMLIB_ServerSettingForm", "getTitle", []() -> std::string {
return ServerSettingForm::getTitle();
return gmlib::form::ServerSettingForm::getTitle();
});
RemoteCall::exportAs("GMLIB_ServerSettingForm", "setTitle", [](std::string const& title, bool forceModify) -> bool {
return ServerSettingForm::setTitle(title, forceModify);
RemoteCall::exportAs("GMLIB_gmlib::form::ServerSettingForm", "setTitle", [](std::string const& title, bool forceModify) -> bool {
return gmlib::form::ServerSettingForm::setTitle(title, forceModify);
});
RemoteCall::exportAs("GMLIB_ServerSettingForm", "hasIcon", []() -> bool { return ServerSettingForm::hasIcon(); });
RemoteCall::exportAs("GMLIB_ServerSettingForm", "getIconData", []() -> std::string {
if (auto data = ServerSettingForm::getIconData()) {
return data.value();
}
return "";
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_ServerSettingForm", "getIconType", []() -> int {
if (auto type = ServerSettingForm::getIconType()) {
return (int)type.value();
}
return -1;
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_ServerSettingForm",
"GMLIB_gmlib::form::ServerSettingForm",
"setIcon",
[](std::string const& title, uchar type, bool forceModify) -> bool {
return ServerSettingForm::setIcon(title, IconType(type), forceModify);
return gmlib::form::ServerSettingForm::setIcon(title, gmlib::form::IconType(type), forceModify);
}
);
RemoteCall::exportAs(
"GMLIB_ServerSettingForm",
"GMLIB_gmlib::form::ServerSettingForm",
"addLabel",
[](std::string const& text, std::string const& detectorId, int priority) -> uint {
uint result = ServerSettingForm::addLabel(text, PLAYER_DETECROR, priority);
uint result = gmlib::form::ServerSettingForm::addLabel(text, PLAYER_DETECROR, priority);
return result;
}
);
RemoteCall::exportAs(
"GMLIB_ServerSettingForm",
"GMLIB_gmlib::form::ServerSettingForm",
"addInput",
[](std::string const& text,
std::string const& placeholder,
@@ -139,11 +160,11 @@ void Export_Form_API() {
std::string const& callbackId,
std::string const& detectorId,
int priority) -> uint {
uint result = ServerSettingForm::addInput(
uint result = gmlib::form::ServerSettingForm::addInput(
text,
placeholder,
defaultVal,
CALLBACK_TYPE_STRING,
CALLBACK_TYPE(std::string const&),
PLAYER_DETECROR,
priority
);
@@ -151,19 +172,19 @@ void Export_Form_API() {
}
);
RemoteCall::exportAs(
"GMLIB_ServerSettingForm",
"GMLIB_gmlib::form::ServerSettingForm",
"addToggle",
[](std::string const& text,
bool defaultVal,
std::string const& callbackId,
std::string const& detectorId,
int priority) -> uint {
uint result = ServerSettingForm::addToggle(text, defaultVal, CALLBACK_TYPE_BOOL, PLAYER_DETECROR, priority);
uint result = gmlib::form::ServerSettingForm::addToggle(text, defaultVal, CALLBACK_TYPE(bool), PLAYER_DETECROR, priority);
return result;
}
);
RemoteCall::exportAs(
"GMLIB_ServerSettingForm",
"GMLIB_gmlib::form::ServerSettingForm",
"addDropdown",
[](std::string const& text,
std::vector<std::string> options,
@@ -171,11 +192,11 @@ void Export_Form_API() {
std::string const& callbackId,
std::string const& detectorId,
int priority) -> uint {
uint result = ServerSettingForm::addDropdown(
uint result = gmlib::form::ServerSettingForm::addDropdown(
text,
options,
defaultVal,
CALLBACK_TYPE_LONG,
CALLBACK_TYPE(int64),
PLAYER_DETECROR,
priority
);
@@ -183,7 +204,7 @@ void Export_Form_API() {
}
);
RemoteCall::exportAs(
"GMLIB_ServerSettingForm",
"GMLIB_gmlib::form::ServerSettingForm",
"addSlider",
[](std::string const& text,
double min,
@@ -193,13 +214,13 @@ void Export_Form_API() {
std::string const& callbackId,
std::string const& detectorId,
int priority) -> uint {
uint result = ServerSettingForm::addSlider(
uint result = gmlib::form::ServerSettingForm::addSlider(
text,
min,
max,
step,
defaultVal,
CALLBACK_TYPE_DOUBLE,
CALLBACK_TYPE(double),
PLAYER_DETECROR,
priority
);
@@ -207,7 +228,7 @@ void Export_Form_API() {
}
);
RemoteCall::exportAs(
"GMLIB_ServerSettingForm",
"GMLIB_gmlib::form::ServerSettingForm",
"addStepSlider",
[](std::string const& text,
std::vector<std::string> steps,
@@ -215,18 +236,53 @@ void Export_Form_API() {
std::string const& callbackId,
std::string const& detectorId,
int priority) -> uint {
uint result = ServerSettingForm::addStepSlider(
uint result = gmlib::form::ServerSettingForm::addStepSlider(
text,
steps,
defaultVal,
CALLBACK_TYPE_LONG,
CALLBACK_TYPE(int64),
PLAYER_DETECROR,
priority
);
return result;
}
);
RemoteCall::exportAs("GMLIB_ServerSettingForm", "removeElement", [](uint id) -> bool {
return ServerSettingForm::removeElement(id);
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
+3 -6
View File
@@ -1,19 +1,15 @@
#pragma once
#include <include_all.h>
#include <headers/include_all.h>
#include <RemoteCallAPI.h>
using namespace GMLIB;
using namespace Server;
using namespace Mod;
#define PLUGIN_NAME fmt::format(fg(fmt::color::light_green), "GMLIB-LRCA")
#define LIB_VERSION_MAJOR 0
#define LIB_VERSION_MINOR 13
#define LIB_VERSION_PATCH 3
#define LIB_VERSION Version(LIB_VERSION_MAJOR, LIB_VERSION_MINOR, LIB_VERSION_PATCH)
#define LIB_VERSION gmlib::Version(LIB_VERSION_MAJOR, LIB_VERSION_MINOR, LIB_VERSION_PATCH)
extern ll::Logger logger;
@@ -22,4 +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
+74 -76
View File
@@ -3,13 +3,8 @@
std::unordered_set<std::string> HardCodedKeys = {"AlwaysUnlocked", "PlayerHasManyItems", "PlayerInWater", "None"};
std::variant<std::string, std::vector<RecipeIngredient>> makeRecipeUnlockingKey(std::string const& key) {
if (HardCodedKeys.count(key)) {
return key;
}
std::vector<RecipeIngredient> result;
auto item = RecipeIngredient(key, 0, 1);
result.emplace_back(item);
return result;
if (HardCodedKeys.count(key)) return key;
return std::vector<RecipeIngredient>({RecipeIngredient(key, 0, 1)});
}
void Export_Legacy_GMLib_ModAPI() {
@@ -22,18 +17,17 @@ void Export_Legacy_GMLib_ModAPI() {
std::string const& result,
int count,
std::string const& unlock) -> void {
auto level = GMLIB_Level::getInstance();
if (!level) {
return;
}
if (!gmlib::world::Level::getInstance().has_value()) return;
std::vector<RecipeIngredient> types;
for (auto ing : ingredients) {
auto key = RecipeIngredient(ing, 0, 1);
types.push_back(key);
types.emplace_back(ing, 0, 1);
}
auto res = RecipeIngredient(result, 0, count);
auto unl = makeRecipeUnlockingKey(unlock);
JsonRecipe::registerShapelessCraftingTableRecipe(recipe_id, types, res, unl);
gmlib::mod::recipe::JsonRecipeRegistry::registerShapelessCraftingTableRecipe(
recipe_id,
types,
RecipeIngredient(result, 0, count),
makeRecipeUnlockingKey(unlock)
);
}
);
RemoteCall::exportAs(
@@ -45,18 +39,18 @@ void Export_Legacy_GMLib_ModAPI() {
std::string const& result,
int count,
std::string const& unlock) -> void {
auto level = GMLIB_Level::getInstance();
if (!level) {
return;
}
if (!gmlib::world::Level::getInstance().has_value()) return;
std::vector<RecipeIngredient> types;
for (auto ing : ingredients) {
auto key = RecipeIngredient(ing, 0, 1);
types.push_back(key);
types.push_back(RecipeIngredient(ing, 0, 1));
}
auto res = RecipeIngredient(result, 0, count);
auto unl = makeRecipeUnlockingKey(unlock);
JsonRecipe::registerShapedCraftingTableRecipe(recipe_id, shape, types, res, unl);
gmlib::mod::recipe::JsonRecipeRegistry::registerShapedCraftingTableRecipe(
recipe_id,
shape,
types,
RecipeIngredient(result, 0, count),
makeRecipeUnlockingKey(unlock)
);
}
);
RemoteCall::exportAs(
@@ -66,13 +60,13 @@ void Export_Legacy_GMLib_ModAPI() {
std::string const& input,
std::string const& output,
std::vector<std::string> tags) -> void {
auto level = GMLIB_Level::getInstance();
if (!level) {
return;
}
auto inp = RecipeIngredient(input, 0, 1);
auto outp = RecipeIngredient(output, 0, 1);
JsonRecipe::registerFurnaceRecipe(recipe_id, inp, outp, tags);
if (!gmlib::world::Level::getInstance().has_value()) return;
gmlib::mod::recipe::JsonRecipeRegistry::registerFurnaceRecipe(
recipe_id,
RecipeIngredient(input, 0, 1),
RecipeIngredient(output, 0, 1),
tags
);
}
);
RemoteCall::exportAs(
@@ -80,12 +74,13 @@ void Export_Legacy_GMLib_ModAPI() {
"registerBrewingMixRecipe",
[](std::string const& recipe_id, std::string const& input, std::string const& output, std::string const& reagent
) -> void {
auto level = GMLIB_Level::getInstance();
if (!level) {
return;
}
auto rea = RecipeIngredient(reagent, 0, 1);
JsonRecipe::registerBrewingMixRecipe(recipe_id, input, output, rea);
if (!gmlib::world::Level::getInstance().has_value()) return;
gmlib::mod::recipe::JsonRecipeRegistry::registerBrewingMixRecipe(
recipe_id,
input,
output,
RecipeIngredient(reagent, 0, 1)
);
}
);
RemoteCall::exportAs(
@@ -93,14 +88,13 @@ void Export_Legacy_GMLib_ModAPI() {
"registerBrewingContainerRecipe",
[](std::string const& recipe_id, std::string const& input, std::string const& output, std::string const& reagent
) -> void {
auto level = GMLIB_Level::getInstance();
if (!level) {
return;
}
auto inp = RecipeIngredient(input, 0, 1);
auto outp = RecipeIngredient(output, 0, 1);
auto rea = RecipeIngredient(reagent, 0, 1);
JsonRecipe::registerBrewingContainerRecipe(recipe_id, inp, outp, rea);
if (!gmlib::world::Level::getInstance().has_value()) return;
gmlib::mod::recipe::JsonRecipeRegistry::registerBrewingContainerRecipe(
recipe_id,
RecipeIngredient(input, 0, 1),
RecipeIngredient(output, 0, 1),
RecipeIngredient(reagent, 0, 1)
);
}
);
RemoteCall::exportAs(
@@ -111,11 +105,14 @@ void Export_Legacy_GMLib_ModAPI() {
std::string const& base,
std::string const& addition,
std::string const& result) -> void {
auto level = GMLIB_Level::getInstance();
if (!level) {
return;
}
JsonRecipe::registerSmithingTransformRecipe(recipe_id, smithing_template, base, addition, result);
if (!gmlib::world::Level::getInstance().has_value()) return;
gmlib::mod::recipe::JsonRecipeRegistry::registerSmithingTransformRecipe(
recipe_id,
smithing_template,
base,
addition,
result
);
}
);
RemoteCall::exportAs(
@@ -125,11 +122,13 @@ void Export_Legacy_GMLib_ModAPI() {
std::string const& smithing_template,
std::string const& base,
std::string const& addition) -> void {
auto level = GMLIB_Level::getInstance();
if (!level) {
return;
}
JsonRecipe::registerSmithingTrimRecipe(recipe_id, smithing_template, base, addition);
if (!gmlib::world::Level::getInstance().has_value()) return;
gmlib::mod::recipe::JsonRecipeRegistry::registerSmithingTrimRecipe(
recipe_id,
smithing_template,
base,
addition
);
}
);
RemoteCall::exportAs(
@@ -141,50 +140,49 @@ void Export_Legacy_GMLib_ModAPI() {
std::string const& output,
int output_data,
int output_count) -> void {
auto level = GMLIB_Level::getInstance();
if (!level) {
return;
}
auto inp = RecipeIngredient(input, 0, 1);
auto outp = RecipeIngredient(output, 0, 1);
JsonRecipe::registerStoneCutterRecipe(recipe_id, inp, outp);
if (!gmlib::world::Level::getInstance().has_value()) return;
gmlib::mod::recipe::JsonRecipeRegistry::registerStoneCutterRecipe(
recipe_id,
RecipeIngredient(input, 0, 1),
RecipeIngredient(output, 0, 1)
);
}
);
// 错误方块清理
RemoteCall::exportAs("GMLib_ModAPI", "setUnknownBlockCleaner", []() -> void {
VanillaFix::setAutoCleanUnknownBlockEnabled();
gmlib::tools::VanillaFix::setAutoCleanUnknownBlockEnabled();
});
// 实验性
RemoteCall::exportAs("GMLib_ModAPI", "registerExperimentsRequire", [](int experiment_id) -> void {
auto list = GMLIB_Level::getAllExperiments();
auto list = gmlib::world::Level::getAllExperiments();
std::unordered_set<AllExperiments> set(list.begin(), list.end());
if (set.contains((AllExperiments)experiment_id)) {
GMLIB_Level::addExperimentsRequire((AllExperiments)experiment_id);
gmlib::world::Level::addExperimentsRequire((AllExperiments)experiment_id);
} else {
ll::Logger("Server").error("Experiment ID '{}' does not exist!", experiment_id);
}
});
RemoteCall::exportAs("GMLib_ModAPI", "setExperimentEnabled", [](int experiment_id, bool value) -> void {
if (GMLIB_Level::getInstance()) {
auto list = GMLIB_Level::getAllExperiments();
if (gmlib::world::Level::getInstance()) {
auto list = gmlib::world::Level::getAllExperiments();
std::unordered_set<AllExperiments> set(list.begin(), list.end());
if (set.contains((AllExperiments)experiment_id)) {
GMLIB_Level::getInstance()->setExperimentEnabled(((AllExperiments)experiment_id), value);
gmlib::world::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 {
if (GMLIB_Level::getInstance()) {
auto list = GMLIB_Level::getAllExperiments();
if (gmlib::world::Level::getInstance()) {
auto list = gmlib::world::Level::getAllExperiments();
std::unordered_set<AllExperiments> set(list.begin(), list.end());
if (set.contains((AllExperiments)experiment_id)) {
return GMLIB_Level::getInstance()->getExperimentEnabled(((AllExperiments)experiment_id));
} else {
ll::Logger("Server").error("Experiment ID '{}' does not exist!", experiment_id);
return false;
return gmlib::world::Level::getInstance()->getExperimentEnabled(((AllExperiments)experiment_id));
}
ll::Logger("Server").error("Experiment ID '{}' does not exist!", experiment_id);
}
return false;
});
RemoteCall::exportAs("GMLib_ModAPI", "setFixI18nEnabled", []() -> void { VanillaFix::setFixI18nEnabled(); });
RemoteCall::exportAs("GMLib_ModAPI", "setFixI18nEnabled", []() -> void {
gmlib::tools::VanillaFix::setFixI18nEnabled();
});
}
src/LegacyServerApi.cpp
+24 -25
View File
@@ -2,50 +2,50 @@
void Export_Legacy_GMLib_ServerAPI() {
RemoteCall::exportAs("GMLib_ServerAPI", "setEducationFeatureEnabled", []() -> void {
GMLIB_Level::tryEnableEducationEdition();
gmlib::world::Level::tryEnableEducationEdition();
});
RemoteCall::exportAs("GMLib_ServerAPI", "registerAbilityCommand", []() -> void {
GMLIB_Level::tryRegisterAbilityCommand();
gmlib::world::Level::tryRegisterAbilityCommand();
});
RemoteCall::exportAs("GMLib_ServerAPI", "setEnableAchievement", []() -> void {
GMLIB_Level::setForceAchievementsEnabled();
gmlib::world::Level::setForceAchievementsEnabled();
});
RemoteCall::exportAs("GMLib_ServerAPI", "setForceTrustSkins", []() -> void {
gmlib::world::Level::trustAllSkins();
});
RemoteCall::exportAs("GMLib_ServerAPI", "setForceTrustSkins", []() -> void { GMLIB_Level::trustAllSkins(); });
RemoteCall::exportAs("GMLib_ServerAPI", "enableCoResourcePack", []() -> void {
GMLIB_Level::requireServerResourcePackAndAllowClientResourcePack();
gmlib::world::Level::requireServerResourcePackAndAllowClientResourcePack();
});
RemoteCall::exportAs("GMLib_ServerAPI", "getLevelName", []() -> std::string {
if (auto level = GMLIB_Level::getInstance()) {
return level->getLevelName();
}
return {};
return gmlib::world::Level::getInstance()
.transform([](gmlib::world::Level& level) -> std::string { return level.getLevelName(); })
.value_or("");
});
RemoteCall::exportAs("GMLib_ServerAPI", "setLevelName", [](std::string const& name) -> void {
if (auto level = GMLIB_Level::getInstance()) {
if (auto level = gmlib::world::Level::getInstance()) {
level->setLevelName(name);
}
});
RemoteCall::exportAs("GMLib_ServerAPI", "getLevelSeed", []() -> std::string {
if (auto level = GMLIB_Level::getInstance()) {
return std::to_string(level->getSeed());
}
return {};
return gmlib::world::Level::getInstance()
.transform([](gmlib::world::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);
return gmlib::world::Level::setFakeSeed(seed);
});
RemoteCall::exportAs(
"GMLib_ServerAPI",
"spawnEntity",
[](std::pair<Vec3, int> pos, std::string const& name) -> Actor* {
return GMLIB_Spawner::spawnEntity(pos.first, pos.second, name).as_ptr();
return gmlib::world::Spawner::spawnEntity(pos.first, pos.second, name).as_ptr();
}
);
RemoteCall::exportAs(
"GMLib_ServerAPI",
"shootProjectile",
[](Actor* owner, std::string const& name, float speed, float offset) -> Actor* {
auto ac = (GMLIB_Actor*)owner;
auto ac = (gmlib::world::Actor*)owner;
return ac->shootProjectile(name, speed, offset).as_ptr();
}
);
@@ -53,7 +53,7 @@ void Export_Legacy_GMLib_ServerAPI() {
"GMLib_ServerAPI",
"throwEntity",
[](Actor* owner, Actor* actor, float speed, float offset) -> bool {
auto ac = (GMLIB_Actor*)owner;
auto ac = (gmlib::world::Actor*)owner;
return ac->throwEntity(*actor, speed, offset);
}
);
@@ -62,19 +62,18 @@ void Export_Legacy_GMLib_ServerAPI() {
"GMLib_ServerAPI",
"addFakeList",
[](const std::string& name, const std::string& xuid) -> bool {
return FakeList::addFakeList(name, xuid, ActorUniqueID(-1));
return gmlib::tools::FakeList::addFakeList(name, xuid, ActorUniqueID(-1));
}
);
RemoteCall::exportAs("GMLib_ServerAPI", "removeFakeList", [](const std::string& nameOrXuid) -> bool {
return FakeList::removeFakeList(nameOrXuid);
return gmlib::tools::FakeList::removeFakeList(nameOrXuid);
});
RemoteCall::exportAs("GMLib_ServerAPI", "removeAllFakeList", []() -> void {
return FakeList::removeAllFakeLists();
return gmlib::tools::FakeList::removeAllFakeLists();
});
RemoteCall::exportAs("GMLib_ServerAPI", "getMaxPlayers", []() -> int {
if (auto level = GMLIB_Level::getInstance()) {
return level->getMaxPlayerCount();
}
return {};
return gmlib::world::Level::getInstance()
.transform([](gmlib::world::Level& level) -> int { return level.getMaxPlayerCount(); })
.value_or(0);
});
}
src/PlaceholderApi.cpp
+30 -15
View File
@@ -13,9 +13,11 @@ bool isParameters(std::string const& str) {
return std::regex_search(removeBrackets(str), reg);
}
std::string GetValue(std::string const& from) { return PlaceholderAPI::getValue(from); }
std::string GetValue(std::string const& from) { return gmlib::tools::PlaceholderAPI::getValue(from); }
std::string GetValueWithPlayer(std::string const& key, Player* player) { return PlaceholderAPI::getValue(key, player); }
std::string GetValueWithPlayer(std::string const& key, Player* player) {
return gmlib::tools::PlaceholderAPI::getValue(key, player);
}
bool registerPlayerPlaceholder(
std::string const& PluginName,
@@ -23,20 +25,24 @@ bool registerPlayerPlaceholder(
std::string const& PAPIName
) {
if (RemoteCall::hasFunc(PluginName, FuncName)) {
PlaceholderAPI::unregisterPlaceholder(PAPIName);
gmlib::tools::PlaceholderAPI::unregisterPlaceholder(PAPIName);
if (isParameters(PAPIName)) {
auto Call = RemoteCall::importAs<std::string(Player * pl, std::unordered_map<std::string, std::string>)>(
PluginName,
FuncName
);
PlaceholderAPI::registerPlayerPlaceholder(
gmlib::tools::PlaceholderAPI::registerPlayerPlaceholder(
PAPIName,
[Call](Player* sp, std::unordered_map<std::string, std::string> map) { return Call(sp, map); },
PluginName
);
} else {
auto Call = RemoteCall::importAs<std::string(Player * pl)>(PluginName, FuncName);
PlaceholderAPI::registerPlayerPlaceholder(PAPIName, [Call](Player* sp) { return Call(sp); }, PluginName);
gmlib::tools::PlaceholderAPI::registerPlayerPlaceholder(
PAPIName,
[Call](Player* sp) { return Call(sp); },
PluginName
);
}
return true;
}
@@ -49,18 +55,18 @@ bool registerServerPlaceholder(
std::string const& PAPIName
) {
if (RemoteCall::hasFunc(PluginName, FuncName)) {
PlaceholderAPI::unregisterPlaceholder(PAPIName);
gmlib::tools::PlaceholderAPI::unregisterPlaceholder(PAPIName);
if (isParameters(PAPIName)) {
auto Call =
RemoteCall::importAs<std::string(std::unordered_map<std::string, std::string>)>(PluginName, FuncName);
PlaceholderAPI::registerServerPlaceholder(
gmlib::tools::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);
PlaceholderAPI::registerServerPlaceholder(PAPIName, [Call]() { return Call(); }, PluginName);
gmlib::tools::PlaceholderAPI::registerServerPlaceholder(PAPIName, [Call]() { return Call(); }, PluginName);
}
return true;
}
@@ -74,13 +80,22 @@ bool registerStaticPlaceholder(
int num
) {
if (RemoteCall::hasFunc(PluginName, FuncName)) {
PlaceholderAPI::unregisterPlaceholder(PAPIName);
gmlib::tools::PlaceholderAPI::unregisterPlaceholder(PAPIName);
if (isParameters(PAPIName)) {
auto Call = RemoteCall::importAs<std::string()>(PluginName, FuncName);
if (num == -1) {
PlaceholderAPI::registerStaticPlaceholder(PAPIName, [Call] { return Call(); }, PluginName);
gmlib::tools::PlaceholderAPI::registerStaticPlaceholder(
PAPIName,
[Call] { return Call(); },
PluginName
);
} else {
PlaceholderAPI::registerStaticPlaceholder(PAPIName, num, [Call] { return Call(); }, PluginName);
gmlib::tools::PlaceholderAPI::registerStaticPlaceholder(
PAPIName,
num,
[Call] { return Call(); },
PluginName
);
}
}
return true;
@@ -89,14 +104,14 @@ bool registerStaticPlaceholder(
}
std::string translateStringWithPlayer(std::string const& str, Player* pl) {
return PlaceholderAPI::translateString(str, pl);
return gmlib::tools::PlaceholderAPI::translateString(str, pl);
}
std::string translateString(std::string const& str) { return PlaceholderAPI::translateString(str); }
std::string translateString(std::string const& str) { return gmlib::tools::PlaceholderAPI::translateString(str); }
bool unRegisterPlaceholder(std::string const& str) { return PlaceholderAPI::unregisterPlaceholder(str); }
bool unRegisterPlaceholder(std::string const& str) { return gmlib::tools::PlaceholderAPI::unregisterPlaceholder(str); }
std::vector<std::string> getAllPAPI() { return PlaceholderAPI::getAllPAPI(); }
std::vector<std::string> getAllPAPI() { return gmlib::tools::PlaceholderAPI::getAllPAPI(); }
} // namespace PAPIRemoteCall