refactor: Rewrites the event API

lib/EventAPI-JS.js

@@ -1,28 +1,169 @@
-/** 事件创建函数 @type {function(string,string):boolean} */
+/**
-const CallEvent = ll.import("GMLIB_Event_API", "callCustomEvent");
+ * @returns {string}
-/** 获取事件ID函数 @type {function():string} */
+ */
-const getNextEventId = ll.import("GMLIB_Event_API", "getNextScriptEventId");
+const getPluginName = () => {
-
+    try {
-/** 事件类 */
+        throw new Error("getPluginName");
-class Event {
+    } catch (error) {
-    constructor() { throw new Error("Static class cannot be instantiated"); }
+        return error.stack.trim().match(/plugins\\(.*)\\.*\.js:[0-9]+\)$/i)?.[1] || "Unknown";
-
-    /**
-     * 监听事件
-     * @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(`GMLIB Script Event "${event}" does not exist !`);
-        }
-        return result;
     }
 }
 
-module.exports = { Event };
+module.exports = {
+    Event: {
+        /**
+         * 事件订阅记录   
+         * 例如: {事件名: [事件ID, ...], ...}
+         * @type {Object.<string, number[]>}
+         */
+        mEventData: {},
+        /**
+         * 事件异常处理回调
+         * @param {Error} error
+         * @param {string} eventName
+         * @param {number} eventID
+         * @param {string} pluginName
+         * @returns {void}
+         */
+        mErrorHanlerCallback: (error, eventName, eventID, pluginName) => {
+            logger.error(`Info: ${pluginName}-${eventName}-${eventID}   Exception: ${error.message}\n${error.stack}`);
+        },
+
+        /**
+         * 监听事件(兼容旧版)
+         * @param {string} eventName
+         * @param {function} callback
+         * @param {boolean}
+         */
+        listen: function (eventName, callback) {
+            try {
+                const eventReflection = {
+                    onServerStopping: "ll::ServerStoppingEvent",
+                    onClientLogin: "gmlib::ClientLoginAfterEvent",
+                    onWeatherChange: "gmlib::WeatherUpdateBeforeEvent",
+                    onMobPick: "gmlib::MobPickupItemBeforeEvent",
+                    onItemTrySpawn: "gmlib::ItemActorSpawnBeforeEvent",
+                    onItemSpawned: "gmlib::ItemActorSpawnAfterEvent",
+                    onEntityTryChangeDim: "gmlib::ActorChangeDimensionBeforeEvent",
+                    onLeaveBed: "gmlib::PlayerStopSleepBeforeEvent",
+                    onDeathMessage: "gmlib::DeathMessageAfterEvent",
+                    onMobHurted: "gmlib::MobHurtAfterEvent",
+                    onEndermanTake: "gmlib::EndermanTakeBlockBeforeEvent",
+                    onEntityChangeDim: "gmlib::ActorChangeDimensionAfterEvent",
+                    onDragonRespawn: "gmlib::DragonRespawnBeforeEvent",
+                    onProjectileTryCreate: "gmlib::ProjectileCreateBeforeEvent",
+                    onProjectileCreate: "gmlib::ProjectileCreateAfterEvent",
+                    onSpawnWanderingTrader: "gmlib::SpawnWanderingTraderBeforeEvent",
+                    onHandleRequestAction: "gmlib::HandleRequestActionBeforeEvent",
+                    onSendContainerClosePacket: "gmlib::ContainerClosePacketSendAfterEvent"
+                };
+                this.emplaceListener(eventReflection[eventName] ?? eventName, event => {
+                    const result = callback(...event.params);
+                    if (typeof (result) === "boolean" && !result) event.cancel();
+                });
+                return true;
+            } catch { }
+            return false;
+        },
+
+        /**
+         * 订阅事件
+         * @param {string} eventName
+         * @param {function} callback
+         * @param {number?} priority
+         * @param {string?} pluginName
+         * @returns {number}
+         */
+        emplaceListener: function (eventName, callback, priority = this.EventPriority.Normal, pluginName = getPluginName()) {
+            const /** @type {number} */ eventId = ll.imports("GMLIB_Event_API", "emplaceListener")(pluginName, eventName, priority);
+            if (eventId === -1) throw new Error(`Event ${eventName} creation failed!`);
+            ll.exports((...data) => {
+                let /** @type {boolean} */ result = typeof (data.slice(-1)[0]) === "boolean" ? data.pop() : false;
+                try {
+                    callback({
+                        params: data,
+                        cancel: () => result = true,
+                        setCancelled: (/** @type {boolean} */value) => result = value,
+                        isCancelled: () => result,
+                        getId: () => eventId,
+                        getEventType: () => eventName
+                    });
+                } catch (error) {
+                    try {
+                        this.mErrorHanlerCallback(error, eventName, eventId, pluginName);
+                    } catch { }
+                }
+                return result;
+            }, pluginName, eventName + "_" + eventId);
+            if (this.mEventData[eventName] === undefined) this.mEventData[eventName] = [];
+            this.mEventData[eventName].push(eventId);
+            return eventId;
+        },
+
+        /**
+         * 取消事件订阅
+         * @param {number} eventId
+         * @param {boolean}
+         */
+        removeListener: function (eventId) {
+            const result = ll.imports("GMLIB_Event_API", "removeListener")(eventId);
+            if (result) {
+                for (let [eventName, eventIds] of Object.entries(this.mEventData)) {
+                    this.mEventData[eventName] = eventIds.filter(id => id !== eventId);
+                    if (this.mEventData[eventName].length === 0) delete this.mEventData[eventName];
+                }
+            }
+            return result;
+        },
+
+        /**
+         * 判断事件订阅是否存在
+         * @param {number} eventId
+         * @returns {boolean}
+         */
+        hasListener: function (eventId) {
+            return ll.imports("GMLIB_Event_API", "hasListener")(eventId);
+        },
+
+        /**
+         * 获取订阅事件优先级
+         * @param {number} eventId
+         * @returns {number?}
+         */
+        getListenerPriority: function (eventId) {
+            const priority = ll.imports("GMLIB_Event_API", "getListenerPriority")(eventId);
+            return priority === -1 ? undefined : priority;
+        },
+
+        /**
+         * 获取订阅事件列表
+         * @param {string | undefined} eventName
+         * @returns {number[] | Object.<string, number[]>}
+         */
+        getListener: function(eventName) {
+            return eventName === undefined ? this.mEventData : this.mEventData[eventName] ?? [];
+        },
+
+        /**
+         * 设置异常处理回调
+         * @param {function(Error, string, number, string): void} callback
+         * @returns {boolean}
+         */
+        setErrorHanlerCallback: function (callback) {
+            if (callback === undefined || typeof callback !== "function") return false;
+            this.mErrorHanlerCallback = callback;
+            return true;
+        },
+
+        /**
+         * 事件优先级
+         */
+        EventPriority: {
+            Highest: 0,
+            High: 100,
+            Normal: 200,
+            Low: 300,
+            Lowest: 400
+        }
+    }
+};

src/EventAPI.cpp

@@ -1,249 +1,325 @@
 #include "Global.h"
 using namespace ll::hash_utils;
 
-class LegacyScriptEventManager {
+#define REGISTER_EVENT_LISTEN(eventType, paramType, params, cancelFun, ...)                                            \
-private:
+    ll::event::ListenerPtr eventPtr = eventBus.emplaceListener<eventType>(                                             \
-    int64                                              mNextEventId = 0;
+        [&eventBus, pluginName, eventName, eventId = (llong)mEventIds.size()](eventType& event) -> void {              \
-    std::unordered_map<uint64, ll::event::ListenerPtr> mEventListeners;
+            if (!RemoteCall::hasFunc(pluginName, eventName + "_" + std::to_string(mEventIds.at(eventId)))) {           \
-
+                eventBus.removeListener(mEventIds.at(eventId));                                                        \
-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;                                                                                         \
+                __VA_ARGS__                                                                                            \
-                result = RemoteCall::importAs<bool callFunction>(eventName, eventId) eventParams;                      \
+                auto result = RemoteCall::importAs<bool paramType>(                                                    \
+                    pluginName,                                                                                        \
+                    eventName + "_" + std::to_string(mEventIds.at(eventId))                                            \
+                ) params;                                                                                              \
+                cancelFun;                                                                                             \
             } catch (...) {}                                                                                           \
-            if (!result) cancelFunction;                                                                               \
+        },                                                                                                             \
-        })                                                                                                             \
+        ll::event::EventPriority(priority)                                                                             \
     );                                                                                                                 \
-    return true;
+    mEventIds[mEventIds.size()] = eventPtr->getId();                                                                   \
+    return (llong)eventPtr->getId()
 
 void Export_Event_API() {
-    RemoteCall::exportAs("GMLIB_Event_API", "getNextScriptEventId", []() -> std::string {
+    static std::unordered_map<llong, ullong> mEventIds = {};
-        return LegacyScriptEventManager::getInstance().getNextEventId();
+
+    auto& eventBus = ll::event::EventBus::getInstance();
+
+    RemoteCall::exportAs("GMLIB_Event_API", "removeListener", [&eventBus](ll::event::ListenerId eventId) -> bool {
+        return eventBus.removeListener(eventId);
     });
-    auto& eventBus     = ll::event::EventBus::getInstance();
+
-    auto& eventManager = LegacyScriptEventManager::getInstance();
+    RemoteCall::exportAs("GMLIB_Event_API", "hasListener", [&eventBus](ll::event::ListenerId eventId) -> bool {
+        return eventBus.hasListener(eventId);
+    });
+
+    RemoteCall::exportAs("GMLIB_Event_API", "getListenerPriority", [&eventBus](ll::event::ListenerId eventId) -> int {
+        if (auto event = eventBus.getListener(eventId); event != nullptr) {
+            return (int)event->getPriority();
+        }
+        return -1;
+    });
+
     RemoteCall::exportAs(
         "GMLIB_Event_API",
-        "callCustomEvent",
+        "emplaceListener",
-        [&eventBus, &eventManager](std::string const& eventName, std::string const& eventId) -> bool {
+        [&eventBus](std::string const& pluginName, std::string const& eventName, int priority) -> llong {
-            if (!RemoteCall::hasFunc(eventName, eventId)) return false;
             switch (doHash(eventName)) {
-            case doHash("onClientLogin"): {
+            case doHash("ll::ServerStoppingEvent"): {
+                REGISTER_EVENT_LISTEN(ll::event::ServerStoppingEvent, (), (), , );
+            }
+            case doHash("gmlib::ClientLoginAfterEvent"): {
                 REGISTER_EVENT_LISTEN(
                     GMLIB::Event::PacketEvent::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()),
+                    (event.getRealName(),
-                    logger.error("Event \"onClientLogin\" cannot be intercepted"),
+                     event.getUuid().asString(),
-                )
+                     event.getServerAuthXuid(),
+                     event.getClientAuthXuid()),
+                    if (result) event.disConnectClient()
+                );
             }
-            case doHash("onWeatherChange"): {
+            case doHash("gmlib::WeatherUpdateBeforeEvent"): {
                 REGISTER_EVENT_LISTEN(
                     GMLIB::Event::LevelEvent::WeatherUpdateBeforeEvent,
-                    (int lightningLevel, int rainLevel, int lightningLast, int rainLast),
+                    (float rainLevel, int rainTime, float lightningLevel, int lightningTime, bool isCancelled),
-                    (ev.getLightningLevel(), ev.getRainLevel(), ev.getLightningLastTick(), ev.getRainingLastTick()),
+                    (event.getRainLevel(),
-                    ev.cancel(),
+                     event.getRainingLastTick(),
-                )
+                     event.getLightningLevel(),
+                     event.getLightningLastTick(),
+                     event.isCancelled()),
+                    event.setCancelled(result)
+                );
             }
-            case doHash("onMobPick"): {
+            case doHash("gmlib::WeatherUpdateAfterEvent"): {
+                REGISTER_EVENT_LISTEN(
+                    GMLIB::Event::LevelEvent::WeatherUpdateAfterEvent,
+                    (float rainLevel, int rainTime, float lightningLevel, int lightningTime),
+                    (event.getRainLevel(),
+                     event.getRainingLastTick(),
+                     event.getLightningLevel(),
+                     event.getLightningLastTick()),
+                    ,
+                );
+            }
+            case doHash("gmlib::MobPickupItemBeforeEvent"): {
                 REGISTER_EVENT_LISTEN(
                     GMLIB::Event::EntityEvent::MobPickupItemBeforeEvent,
-                    (Actor * mob, Actor * item),
+                    (Actor * mob, Actor * item, bool isCancelled),
-                    (&ev.self(), (Actor*)&ev.getItemActor()),
+                    (&event.self(), (Actor*)&event.getItemActor(), event.isCancelled()),
-                    ev.cancel(),
+                    event.setCancelled(result)
-                )
+                );
             }
-            case doHash("onItemTrySpawn"): {
+            case doHash("gmlib::MobPickupItemAfterEvent"): {
+                REGISTER_EVENT_LISTEN(
+                    GMLIB::Event::EntityEvent::MobPickupItemAfterEvent,
+                    (Actor * mob, Actor * item),
+                    (&event.self(), (Actor*)&event.getItemActor()),
+                    ,
+                );
+            }
+            case doHash("gmlib::ItemActorSpawnBeforeEvent"): {
                 REGISTER_EVENT_LISTEN(
                     GMLIB::Event::EntityEvent::ItemActorSpawnBeforeEvent,
-                    (const ItemStack* item, std::pair<Vec3, int> position, int64 spawnerUniqueId),
+                    (ItemStack * item, std::pair<Vec3, int> position, int64 spawnerUniqueId, bool isCancelled),
-                    (&ev.getItem(),
+                    (&event.getItem(),
-                     {ev.getPosition(), ev.getBlockSource().getDimensionId().id},
+                     {event.getPosition(), event.getBlockSource().getDimensionId().id},
-                     ev.getSpawner().has_value() ? ev.getSpawner()->getOrCreateUniqueID().id : -1),
+                     event.getSpawner().has_value() ? event.getSpawner()->getOrCreateUniqueID().id : -1,
-                    ev.cancel(),
+                     event.isCancelled()),
-                )
+                    event.setCancelled(result)
+                );
             }
-            case doHash("onItemSpawned"): {
+            case doHash("gmlib::ItemActorSpawnAfterEvent"): {
                 REGISTER_EVENT_LISTEN(
                     GMLIB::Event::EntityEvent::ItemActorSpawnAfterEvent,
-                    (const ItemStack* item, Actor* itemActor, std::pair<Vec3, int> position, int64 spawnerUniqueId),
+                    (ItemStack * item, std::pair<Vec3, int> position, int64 spawnerUniqueId),
-                    (&ev.getItem(),
+                    (&event.getItem(),
-                     (Actor*)&ev.getItemActor(),
+                     {event.getPosition(), event.getBlockSource().getDimensionId().id},
-                     {ev.getPosition(), ev.getBlockSource().getDimensionId().id},
+                     event.getSpawner().has_value() ? event.getSpawner()->getOrCreateUniqueID().id : -1),
-                     ev.getSpawner().has_value() ? ev.getSpawner()->getOrCreateUniqueID().id : -1),
+                    ,
-                    logger.error("Event \"onItemSpawned\" cannot be intercepted"),
+                );
-                )
             }
-            case doHash("onEntityTryChangeDim"): {
+            case doHash("gmlib::ActorChangeDimensionBeforeEvent"): {
                 REGISTER_EVENT_LISTEN(
                     GMLIB::Event::EntityEvent::ActorChangeDimensionBeforeEvent,
-                    (Actor * entity, int toDimId),
+                    (Actor * entity, int toDimId, bool isCancelled),
-                    (&ev.self(), ev.getToDimensionId()),
+                    (&event.self(), event.getToDimensionId(), event.isCancelled()),
-                    ev.cancel(),
+                    event.setCancelled(result)
-                )
+                );
             }
-            case doHash("onLeaveBed"): {
+            case doHash("gmlib::ActorChangeDimensionAfterEvent"): {
+                REGISTER_EVENT_LISTEN(
+                    GMLIB::Event::EntityEvent::ActorChangeDimensionAfterEvent,
+                    (Actor * entity, int fromDimId, int toDimId),
+                    (&event.self(), event.getFromDimensionId(), event.getToDimensionId()),
+                    ,
+                );
+            }
+            case doHash("gmlib::PlayerStartSleepBeforeEvent"): {
+                REGISTER_EVENT_LISTEN(
+                    GMLIB::Event::PlayerEvent::PlayerStartSleepBeforeEvent,
+                    (Player * entity, BlockPos pos, bool isCancelled),
+                    (&event.self(), event.getPosition(), event.isCancelled()),
+                    event.setCancelled(result)
+                );
+            }
+            case doHash("gmlib::PlayerStartSleepAfterEvent"): {
+                REGISTER_EVENT_LISTEN(
+                    GMLIB::Event::PlayerEvent::PlayerStartSleepAfterEvent,
+                    (Player * entity, BlockPos pos, int result),
+                    (&event.self(), event.getPosition(), (int)event.getResult()),
+                    ,
+                );
+            }
+            case doHash("gmlib::PlayerStopSleepBeforeEvent"): {
                 REGISTER_EVENT_LISTEN(
                     GMLIB::Event::PlayerEvent::PlayerStopSleepBeforeEvent,
-                    (Player * pl),
+                    (Player * entity, bool forcefulWakeUp, bool updateLevelList, bool isCancelled),
-                    (&ev.self()),
+                    (&event.self(), event.isForcefulWakeUp(), event.isUpdateLevelList(), event.isCancelled()),
-                    ev.cancel(),
+                    event.setCancelled(result)
-                )
+                );
             }
-            case doHash("onDeathMessage"): {
+            case doHash("gmlib::PlayerStopSleepAfterEvent"): {
+                REGISTER_EVENT_LISTEN(
+                    GMLIB::Event::PlayerEvent::PlayerStopSleepAfterEvent,
+                    (Player * entity, bool forcefulWakeUp, bool updateLevelList, bool),
+                    (&event.self(), event.isForcefulWakeUp(), event.isUpdateLevelList(), false),
+                    ,
+                );
+            }
+            case doHash("gmlib::DeathMessageAfterEvent"): {
                 REGISTER_EVENT_LISTEN(
                     GMLIB::Event::EntityEvent::DeathMessageAfterEvent,
                     (std::string const& message, std::vector<std::string>, Actor* dead),
-                    (ev.getDeathMessage().first, ev.getDeathMessage().second, &ev.self()),
+                    (event.getDeathMessage().first, event.getDeathMessage().second, &event.self()),
-                    logger.error("Event \"onDeathMessage\" cannot be intercepted"),
+                    ,
-                )
+                );
             }
-            case doHash("onMobHurted"): {
+            case doHash("gmlib::MobHurtAfterEvent"): {
                 REGISTER_EVENT_LISTEN(
                     GMLIB::Event::EntityEvent::MobHurtAfterEvent,
                     (Actor * mob, Actor * source, float damage, int cause),
-                    (&ev.self(), source, ev.getDamage(), (int)damageSource.getCause()),
+                    (&event.self(), source, -event.getDamage(), (int)damageSource.getCause()),
-                    logger.error("Event \"onMobHurted\" cannot be intercepted"),
+                    ,
-                    auto& damageSource = ev.getSource();
+                    auto& damageSource = event.getSource();
                     Actor* source      = nullptr;
                     if (damageSource.isEntitySource()) {
                         auto uniqueId = damageSource.getDamagingEntityUniqueID();
                         source        = ll::service::getLevel()->fetchEntity(uniqueId);
                         if (source->getOwner()) source = source->getOwner();
                     }
-                )
+                );
             }
-            case doHash("onEndermanTake"): {
+            case doHash("gmlib::EndermanTakeBlockBeforeEvent"): {
                 REGISTER_EVENT_LISTEN(
                     GMLIB::Event::EntityEvent::EndermanTakeBlockBeforeEvent,
-                    (Actor * mob),
+                    (Actor * mob, bool isCancelled),
-                    (&ev.self()),
+                    (&event.self(), event.isCancelled()),
-                    ev.cancel(),
+                    event.setCancelled(result)
-                )
+                );
             }
-            case doHash("onEntityChangeDim"): {
+            case doHash("gmlib::DragonRespawnBeforeEvent"): {
-                REGISTER_EVENT_LISTEN(
-                    GMLIB::Event::EntityEvent::ActorChangeDimensionAfterEvent,
-                    (Actor * mob, int fromDimId),
-                    (&ev.self(), ev.getFromDimensionId()),
-                    logger.error("Event \"onEntityChangeDim\" cannot be intercepted"),
-                )
-            }
-            case doHash("onDragonRespawn"): {
                 REGISTER_EVENT_LISTEN(
                     GMLIB::Event::EntityEvent::DragonRespawnBeforeEvent,
-                    (int64 enderDragonUniqueID),
+                    (int64 uniqueId, bool isCancelled),
-                    (ev.getEnderDragon().id),
+                    (event.getEnderDragon().id, event.isCancelled()),
-                    ev.cancel(),
+                    event.setCancelled(result)
-                )
+                );
             }
-            case doHash("onProjectileTryCreate"): {
+            case doHash("gmlib::DragonRespawnAfterEvent"): {
+                REGISTER_EVENT_LISTEN(
+                    GMLIB::Event::EntityEvent::DragonRespawnAfterEvent,
+                    (Actor * mob),
+                    (event.getEnderDragon()),
+                );
+            }
+            case doHash("gmlib::ProjectileCreateBeforeEvent"): {
                 REGISTER_EVENT_LISTEN(
                     GMLIB::Event::EntityEvent::ProjectileCreateBeforeEvent,
-                    (Actor * mob, int64 uniqueId),
+                    (Actor * mob, int64 uniqueId, bool isCancelled),
-                    (&ev.self(), ev.getShooter() ? ev.getShooter()->getOrCreateUniqueID().id : -1),
+                    (&event.self(),
-                    ev.cancel(),
+                     event.getShooter() ? event.getShooter()->getOrCreateUniqueID().id : -1,
-                )
+                     event.isCancelled()),
+                    event.setCancelled(result)
+                );
             }
-            case doHash("onProjectileCreate"): {
+            case doHash("gmlib::ProjectileCreateAfterEvent"): {
                 REGISTER_EVENT_LISTEN(
                     GMLIB::Event::EntityEvent::ProjectileCreateAfterEvent,
                     (Actor * mob, int64 uniqueId),
-                    (&ev.self(), ev.getShooter() ? ev.getShooter()->getOrCreateUniqueID().id : -1),
+                    (&event.self(), event.getShooter() ? event.getShooter()->getOrCreateUniqueID().id : -1),
-                    logger.error("Event \"onProjectileCreate\" cannot be intercepted"),
+                );
-                )
             }
-            case doHash("onSpawnWanderingTrader"): {
+            case doHash("gmlib::SpawnWanderingTraderBeforeEvent"): {
                 REGISTER_EVENT_LISTEN(
                     GMLIB::Event::EntityEvent::SpawnWanderingTraderBeforeEvent,
-                    (std::pair<BlockPos, int> pos),
+                    (std::pair<BlockPos, int> pos, bool isCancelled),
-                    ({ev.getPos(), ev.getRegion().getDimensionId()}),
+                    ({event.getPos(), event.getRegion().getDimensionId()}, event.isCancelled()),
-                    ev.cancel(),
+                    event.setCancelled(result)
-                )
+                );
             }
-            case doHash("onHandleRequestAction"): {
+            case doHash("gmlib::SpawnWanderingTraderAfterEvent"): {
-                // clang-format off
                 REGISTER_EVENT_LISTEN(
-                    GMLIB::Event::PlayerEvent::HandleRequestActionBeforeEvent,
+                    GMLIB::Event::EntityEvent::SpawnWanderingTraderAfterEvent,
-                    (
+                    (std::pair<BlockPos, int> pos),
-                        Player * player,
+                    ({event.getPos(), event.getRegion().getDimensionId()}),
-                        std::string const& actionType,
+                );
-                        int                count,
+            }
-                        std::string const& sourceContainerNetId,
+            case doHash("gmlib::HandleRequestActionBeforeEvent"): {
-                        int                sourceSlot,
+                // clang-format off
-                        std::string const& destinationContainerNetId,
+                    REGISTER_EVENT_LISTEN(
-                        int                destinationSlot
+                        GMLIB::Event::PlayerEvent::HandleRequestActionBeforeEvent,
-                    ),
+                        (
-                    (
+                            Player *           player,
-                        (Player*)&ev.self(),
+                            std::string const& actionType,
-                        magic_enum::enum_name(requestAction.mActionType).data(),
+                            int                count,
-                        (int)requestAction.mAmount,
+                            std::string const& sourceContainerNetId,
-                        magic_enum::enum_name(requestAction.mSrc.mOpenContainerNetId).data(),
+                            int                sourceSlot,
-                        (int)requestAction.mSrc.mSlot,
+                            std::string const& destinationContainerNetId,
-                        magic_enum::enum_name(requestAction.mDst.mOpenContainerNetId).data(),
+                            int                destinationSlot,
-                        (int)requestAction.mDst.mSlot
+                            bool               isCancelled
-                    ),
+                        ),
-                    ev.cancel(),
+                        (
-                    auto& requestAction = (ItemStackRequestActionTransferBase&)ev.getRequestAction();
+                            (Player*)&event.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,
+                            event.isCancelled()
+                        ),
+                        event.setCancelled(result),
+                        auto& requestAction = (ItemStackRequestActionTransferBase&)event.getRequestAction();
+                    );
                 // clang-format on
             }
-            case doHash("onSendContainerClosePacket"): {
+            case doHash("gmlib::HandleRequestActionAfterEvent"): {
+                // clang-format off
+                    REGISTER_EVENT_LISTEN(
+                        GMLIB::Event::PlayerEvent::HandleRequestActionAfterEvent,
+                        (
+                            Player *           player,
+                            std::string const& actionType,
+                            int                count,
+                            std::string const& sourceContainerNetId,
+                            int                sourceSlot,
+                            std::string const& destinationContainerNetId,
+                            int                destinationSlot
+                        ),
+                        (
+                            (Player*)&event.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
+                        ),
+                        ,
+                        auto& requestAction = (ItemStackRequestActionTransferBase&)event.getRequestAction();
+                    );
+                // clang-format on
+            }
+            case doHash("gmlib::ContainerClosePacketSendAfterEvent"): {
                 REGISTER_EVENT_LISTEN(
                     GMLIB::Event::PacketEvent::ContainerClosePacketSendAfterEvent,
-                    (Player * player, int ContainerNetId),
+                    (Player * player, int containerId, bool serverInitiatedClose, bool),
-                    (ev.getServerNetworkHandler()
+                    (event.getServerNetworkHandler()
-                         .getServerPlayer(ev.getNetworkIdentifier(), ev.getPacket().mClientSubId),
+                         .getServerPlayer(event.getNetworkIdentifier(), event.getPacket().mClientSubId),
-                     (int)ev.getPacket().mContainerId),
+                     (int)event.getPacket().mContainerId,
-                    logger.error("Event \"onSendContainerClosePacket\" cannot be intercepted"),
+                     event.getPacket().mServerInitiatedClose,
-                )
+                     false),
+                    ,
+                );
             }
-            case doHash("onServerStopping"): {
-                REGISTER_EVENT_LISTEN(
-                    ll::event::server::ServerStoppingEvent,
-                    (),
-                    (),
-                    logger.error("Event \"onServerStopping\" cannot be intercepted"),
-                )
-            }
-            default:
-                return false;
             }
+            return -1;
         }
     );
 }