新增2接口2事件

- 新增getMaxPlayers和dropPlayerItem接口
- 新增handleRequestTryAction和handleRequestAction事件

lib/EventAPI-JS.d.ts

@@ -191,4 +191,38 @@ declare class Event2 {
             entity: Entity
         ) => void
     ): boolean;
+
+    /** 尝试物品物品请求 */
+    static listen(
+        /** 事件名 */
+        event: "handleRequestTryAction",
+        /** 回调函数 */
+        listener: (
+            /** 请求的玩家对象 */
+            Player: Player,
+            /** 请求的操作 */
+            actionType: number,
+            /** 请求的槽位 */
+            slot: number,
+            /** 容器的ID */
+            containerNetId: number
+        ) => boolean | void
+    ): boolean;
+
+    /** 处理物品请求后(不可拦截) */
+    static listen(
+        /** 事件名 */
+        event: "handleRequestAction",
+        /** 回调函数 */
+        listener: (
+            /** 请求的玩家对象 */
+            Player: Player,
+            /** 请求的操作 */
+            actionType: number,
+            /** 请求的槽位 */
+            slot: number,
+            /** 容器的ID */
+            containerNetId: number
+        ) => void
+    ): boolean;
 }

lib/GMLIB_API-JS.d.ts

@@ -348,7 +348,18 @@ declare class Minecraft {
     ): number;
 
     /** 获取游戏规则列表 */
-    static getGameRules(): { Name: string; Value: boolean | number; }[]
+    static getGameRules(): { Name: string; Value: boolean | number; }[];
+
+    /** 获取附魔名字和等级 */
+    static getEnchantNameAndLevel(
+        /** 附魔ID */
+        id: number,
+        /** 附魔的等级 */
+        level: number
+    ): string;
+
+    /** 获取最大玩家数 */
+    static getMaxPlayers(): number;
 }
 
 /** 合成表类 */
@@ -1002,6 +1013,14 @@ interface Player {
 
     /** (GMLIB)清除玩家重生点 */
     clearSpawnPoint(): void;
+
+    /** 丢出玩家物品 */
+    dropItem(
+        /** 物品对象 */
+        item: Item,
+        /** 随机丢出位置 */
+        randomly: boolean | undefined
+    ): boolean;
 }
 
 interface Entity {
@@ -1072,7 +1091,7 @@ interface Block {
     /** (GMLIB)方块是否不需要工具采集 */
     isAlwaysDestroyable(): boolean;
 
-    /** (GMLIB) */
+    /** (GMLIB)检测方块是否能被玩家挖掘(比如插件拦截) */
     playerWillDestroy(
         /** 挖掘的玩家对象 */
         player: Player

lib/GMLIB_API-JS.js

@@ -275,7 +275,11 @@ const GMLIB_API = {
     /** 获取附魔等级 @type {function(Item,number):number} */
     getEnchantLevel: ll.import("GMLIB_API", "getEnchantLevel"),
     /** 获取附魔名字 @type {function(number,number):number} */
-    getEnchantNameAndLevel: ll.import("GMLIB_API", "getEnchantNameAndLevel")
+    getEnchantNameAndLevel: ll.import("GMLIB_API", "getEnchantNameAndLevel"),
+    /** 获取最大玩家数 @type {function():number} */
+    getMaxPlayers:ll.import("GMLIB_ServerAPI","getMaxPlayers"),
+    /** 丢出玩家背包内物品 @type {function(Player,Item,boolean):boolean} */
+    dropPlayerItem:ll.import("GMLIB_API","dropPlayerItem")
 }
 
 /** 静态悬浮字类列表 @type {Map<number,StaticFloatingText>} */
@@ -938,6 +942,14 @@ class Minecraft {
     static getEnchantNameAndLevel(id, level) {
         return GMLIB_API.getEnchantNameAndLevel(id, level);
     }
+
+    /**
+     * 获取最大玩家数量
+     * @returns {number} 最大玩家数量
+     */
+    static getMaxPlayers(){
+        return GMLIB_API.getMaxPlayers();
+    }
 }
 
 /** 合成表类 */
@@ -2068,7 +2080,7 @@ LLSE_Block.prototype.isAlwaysDestroyable =
 
 LLSE_Block.prototype.playerWillDestroy =
     /**
-     * 
+     * 检测方块是否能被玩家挖掘(比如插件拦截)
      * @param {Player} player 玩家对象
      * @returns {boolean}
      */
@@ -2145,6 +2157,17 @@ LLSE_Item.prototype.getEnchantLevel =
         return GMLIB_API.getEnchantLevel(this, id);
     }
 
+LLSE_Player.prototype.dropItem =
+    /**
+     * 使玩家丢出物品
+     * @param {Item} item 物品对象
+     * @param {boolean} [randomly=false] 随机丢出位置
+     * @returns {boolean} 是否丢出成功
+     */
+    function (item, randomly = false) {
+        return GMLIB_API.dropPlayerItem(this, item, randomly);
+    }
+
 module.exports = {
     StaticFloatingText,
     DynamicFloatingText,

src/CompatibilityApi.cpp

@@ -743,4 +743,9 @@ void Export_Compatibility_API() {
     RemoteCall::exportAs("GMLIB_API", "getEnchantNameAndLevel", [](int id, int level) -> std::string {
         return EnchantUtils::getEnchantNameAndLevel((Enchant::Type)id, level);
     });
+    RemoteCall::exportAs(
+        "GMLIB_API",
+        "dropPlayerItem",
+        [](Player* player, ItemStack const* item, bool randomly) -> bool { return player->drop(*item, randomly); }
+    );
 }

src/Event/HandleRequestAction/HandleRequestAction.cpp

@@ -0,0 +1,41 @@
+#include "HandleRequestAction.h"
+#include "Global.h"
+
+
+HandleRequestActionBeforeEvent::HandleRequestActionBeforeEvent(
+    Player*                             player,
+    ItemStackRequestAction& requestAction
+)
+: mPlayer(player),
+  mRequestAction(requestAction) {}
+
+Player* HandleRequestActionBeforeEvent::self() const { return mPlayer; }
+
+ItemStackRequestAction& HandleRequestActionBeforeEvent::getRequestAction() const { return mRequestAction; }
+
+HandleRequestActionAfterEvent::HandleRequestActionAfterEvent(
+    Player*                             player,
+    ItemStackRequestAction& requestAction
+)
+: mPlayer(player),
+  mRequestAction(requestAction) {}
+
+Player* HandleRequestActionAfterEvent::self() const { return mPlayer; }
+
+ItemStackRequestAction& HandleRequestActionAfterEvent::getRequestAction() const { return mRequestAction; }
+
+
+LL_AUTO_TYPE_INSTANCE_HOOK(
+    HandleRequestActionHook,
+    HookPriority::Normal,
+    ItemStackRequestActionHandler,
+    "?handleRequestAction@ItemStackRequestActionHandler@@QEAA?AW4ItemStackNetResult@@AEBVItemStackRequestAction@@@Z",
+    void,
+    ItemStackRequestAction& requestAction
+) {
+    auto beforeEvent = HandleRequestActionBeforeEvent(((Player*)(*(__int64*)this)), requestAction);
+    ll::event::EventBus::getInstance().publish(beforeEvent);
+    if (beforeEvent.isCancelled()) return;
+    ll::event::EventBus::getInstance().publish(HandleRequestActionAfterEvent(((Player*)(*(__int64*)this)), requestAction));
+    return origin(requestAction);
+}

src/Event/HandleRequestAction/HandleRequestAction.h

@@ -0,0 +1,28 @@
+#include "Global.h"
+#include "ll/api/event/Cancellable.h"
+
+class HandleRequestActionBeforeEvent final : public ll::event::Cancellable<ll::event::Event> {
+private:
+    Player*                             mPlayer{};
+    ItemStackRequestAction& mRequestAction;
+
+public:
+    HandleRequestActionBeforeEvent(Player* player, ItemStackRequestAction& requestAction);
+
+    Player* self() const;
+
+    ItemStackRequestAction& getRequestAction() const;
+};
+
+class HandleRequestActionAfterEvent final : public ll::event::Event {
+private:
+    Player*                    mPlayer;
+    ItemStackRequestAction& mRequestAction;
+
+public:
+    HandleRequestActionAfterEvent(Player* player, ItemStackRequestAction& requestAction);
+
+    Player* self() const;
+
+    ItemStackRequestAction& getRequestAction() const;
+};

src/EventAPI.cpp

@@ -1,4 +1,5 @@
 #include "Global.h"
+#include "Event/HandleRequestAction/HandleRequestAction.h"
 using namespace ll::hash_utils;
 
 void Export_Event_API() {
@@ -247,6 +248,46 @@ void Export_Event_API() {
                 );
                 return true;
             }
+            case doHash("handleRequestTryAction"): {
+                auto Call =
+                    RemoteCall::importAs<bool(Player * player, int requestAction, int slot, int containerNetId)>(
+                        eventName,
+                        eventId
+                    );
+                eventBus->emplaceListener<HandleRequestActionBeforeEvent>([Call](HandleRequestActionBeforeEvent& ev) {
+                    bool result = true;
+                    try {
+                        result = Call(
+                            ev.self(),
+                            (int)ev.getRequestAction().getActionType(),
+                            (int)ev.getRequestAction().getSrc().mSlot,
+                            (int)ev.getRequestAction().getSrc().mOpenContainerNetId
+                        );
+                    } catch (...) {}
+                    if (!result) {
+                        ev.cancel();
+                    }
+                });
+                return true;
+            }
+            case doHash("handleRequestAction"): {
+                auto Call =
+                    RemoteCall::importAs<bool(Player * player, int requestAction, int slot, int containerNetId)>(
+                        eventName,
+                        eventId
+                    );
+                eventBus->emplaceListener<HandleRequestActionAfterEvent>([Call](HandleRequestActionAfterEvent& ev) {
+                    try {
+                        Call(
+                            ev.self(),
+                            (int)ev.getRequestAction().getActionType(),
+                            (int)ev.getRequestAction().getSrc().mSlot,
+                            (int)ev.getRequestAction().getSrc().mOpenContainerNetId
+                        );
+                    } catch (...) {}
+                });
+                return true;
+            }
             default:
                 return false;
             }

src/LegacyServerApi.cpp

@@ -1,6 +1,8 @@
 #include "GMLIB/Server/FakeListAPI.h"
+#include "GMLIB/Server/LevelAPI.h"
 #include "Global.h"
 #include "mc/world/ActorUniqueID.h"
+#include <variant>
 
 void Export_Legacy_GMLib_ServerAPI() {
     RemoteCall::exportAs("GMLib_ServerAPI", "setEducationFeatureEnabled", []() -> void {
@@ -73,4 +75,7 @@ void Export_Legacy_GMLib_ServerAPI() {
     RemoteCall::exportAs("GMLib_ServerAPI", "removeAllFakeList", []() -> void {
         return FakeList::removeAllFakeLists();
     });
+    RemoteCall::exportAs("GMLib_ServerAPI", "getMaxPlayers", []() -> int {
+        return ll::memory::dAccess<int>(ll::service::getServerNetworkHandler().as_ptr(), 200);
+    });
 }