refactor: Rewrites the event API
This commit is contained in:
子沐呀
Vendored
+855
-209
File diff suppressed because it is too large
Load Diff
+165
-24
@@ -1,28 +1,169 @@
|
||||
/** 事件创建函数 @type {function(string,string):boolean} */
|
||||
const CallEvent = ll.import("GMLIB_Event_API", "callCustomEvent");
|
||||
/** 获取事件ID函数 @type {function():string} */
|
||||
const getNextEventId = ll.import("GMLIB_Event_API", "getNextScriptEventId");
|
||||
|
||||
/** 事件类 */
|
||||
class Event {
|
||||
constructor() { throw new Error("Static class cannot be instantiated"); }
|
||||
|
||||
/**
|
||||
* 监听事件
|
||||
* @param {string} event 事件名称
|
||||
* @param {function} callback 回调
|
||||
* @returns {boolean} 是否创建成功
|
||||
/**
|
||||
* @returns {string}
|
||||
*/
|
||||
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;
|
||||
const getPluginName = () => {
|
||||
try {
|
||||
throw new Error("getPluginName");
|
||||
} catch (error) {
|
||||
return error.stack.trim().match(/plugins\\(.*)\\.*\.js:[0-9]+\)$/i)?.[1] || "Unknown";
|
||||
}
|
||||
}
|
||||
|
||||
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
|
||||
}
|
||||
}
|
||||
};
|
||||
+227
-151
@@ -1,205 +1,288 @@
|
||||
#include "Global.h"
|
||||
using namespace ll::hash_utils;
|
||||
|
||||
class LegacyScriptEventManager {
|
||||
private:
|
||||
int64 mNextEventId = 0;
|
||||
std::unordered_map<uint64, ll::event::ListenerPtr> mEventListeners;
|
||||
|
||||
public:
|
||||
std::string getNextEventId() {
|
||||
mNextEventId++;
|
||||
return "GMLIB_EVENT_" + std::to_string(mNextEventId);
|
||||
}
|
||||
|
||||
void emplaceListener(std::string const& scriptEventId, ll::event::ListenerPtr listenerPtr) {
|
||||
mEventListeners[doHash(scriptEventId)] = std::move(listenerPtr);
|
||||
}
|
||||
|
||||
void removeListener(std::string const& scriptEventId) {
|
||||
ll::event::EventBus::getInstance().removeListener(mEventListeners[doHash(scriptEventId)]);
|
||||
mEventListeners.erase(doHash(scriptEventId));
|
||||
}
|
||||
|
||||
public:
|
||||
static LegacyScriptEventManager& getInstance() {
|
||||
static std::unique_ptr<LegacyScriptEventManager> instance;
|
||||
if (!instance) {
|
||||
instance = std::make_unique<LegacyScriptEventManager>();
|
||||
}
|
||||
return *instance;
|
||||
}
|
||||
};
|
||||
|
||||
#define REGISTER_EVENT_LISTEN(eventType, callFunction, eventParams, cancelFunction, otherFunction) \
|
||||
eventManager.emplaceListener( \
|
||||
eventId, \
|
||||
eventBus.emplaceListener<eventType>([eventName, eventId, &eventBus, &eventManager](eventType& ev) -> void { \
|
||||
if (!RemoteCall::hasFunc(eventName, eventId)) { \
|
||||
eventManager.removeListener(eventId); \
|
||||
#define REGISTER_EVENT_LISTEN(eventType, paramType, params, cancelFun, ...) \
|
||||
ll::event::ListenerPtr eventPtr = eventBus.emplaceListener<eventType>( \
|
||||
[&eventBus, pluginName, eventName, eventId = (llong)mEventIds.size()](eventType& event) -> void { \
|
||||
if (!RemoteCall::hasFunc(pluginName, eventName + "_" + std::to_string(mEventIds.at(eventId)))) { \
|
||||
eventBus.removeListener(mEventIds.at(eventId)); \
|
||||
return; \
|
||||
} \
|
||||
bool result = true; \
|
||||
try { \
|
||||
otherFunction; \
|
||||
result = RemoteCall::importAs<bool callFunction>(eventName, eventId) eventParams; \
|
||||
__VA_ARGS__ \
|
||||
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 {
|
||||
return LegacyScriptEventManager::getInstance().getNextEventId();
|
||||
});
|
||||
static std::unordered_map<llong, ullong> mEventIds = {};
|
||||
|
||||
auto& eventBus = ll::event::EventBus::getInstance();
|
||||
auto& eventManager = LegacyScriptEventManager::getInstance();
|
||||
|
||||
RemoteCall::exportAs("GMLIB_Event_API", "removeListener", [&eventBus](ll::event::ListenerId eventId) -> bool {
|
||||
return eventBus.removeListener(eventId);
|
||||
});
|
||||
|
||||
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",
|
||||
[&eventBus, &eventManager](std::string const& eventName, std::string const& eventId) -> bool {
|
||||
if (!RemoteCall::hasFunc(eventName, eventId)) return false;
|
||||
"emplaceListener",
|
||||
[&eventBus](std::string const& pluginName, std::string const& eventName, int priority) -> llong {
|
||||
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()),
|
||||
logger.error("Event \"onClientLogin\" cannot be intercepted"),
|
||||
)
|
||||
(event.getRealName(),
|
||||
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),
|
||||
(ev.getLightningLevel(), ev.getRainLevel(), ev.getLightningLastTick(), ev.getRainingLastTick()),
|
||||
ev.cancel(),
|
||||
)
|
||||
(float rainLevel, int rainTime, float lightningLevel, int lightningTime, bool isCancelled),
|
||||
(event.getRainLevel(),
|
||||
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),
|
||||
(&ev.self(), (Actor*)&ev.getItemActor()),
|
||||
ev.cancel(),
|
||||
)
|
||||
(Actor * mob, Actor * item, bool isCancelled),
|
||||
(&event.self(), (Actor*)&event.getItemActor(), event.isCancelled()),
|
||||
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),
|
||||
(&ev.getItem(),
|
||||
{ev.getPosition(), ev.getBlockSource().getDimensionId().id},
|
||||
ev.getSpawner().has_value() ? ev.getSpawner()->getOrCreateUniqueID().id : -1),
|
||||
ev.cancel(),
|
||||
)
|
||||
(ItemStack * item, std::pair<Vec3, int> position, int64 spawnerUniqueId, bool isCancelled),
|
||||
(&event.getItem(),
|
||||
{event.getPosition(), event.getBlockSource().getDimensionId().id},
|
||||
event.getSpawner().has_value() ? event.getSpawner()->getOrCreateUniqueID().id : -1,
|
||||
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),
|
||||
(&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"),
|
||||
)
|
||||
(ItemStack * item, std::pair<Vec3, int> position, int64 spawnerUniqueId),
|
||||
(&event.getItem(),
|
||||
{event.getPosition(), event.getBlockSource().getDimensionId().id},
|
||||
event.getSpawner().has_value() ? event.getSpawner()->getOrCreateUniqueID().id : -1),
|
||||
,
|
||||
);
|
||||
}
|
||||
case doHash("onEntityTryChangeDim"): {
|
||||
case doHash("gmlib::ActorChangeDimensionBeforeEvent"): {
|
||||
REGISTER_EVENT_LISTEN(
|
||||
GMLIB::Event::EntityEvent::ActorChangeDimensionBeforeEvent,
|
||||
(Actor * entity, int toDimId),
|
||||
(&ev.self(), ev.getToDimensionId()),
|
||||
ev.cancel(),
|
||||
)
|
||||
(Actor * entity, int toDimId, bool isCancelled),
|
||||
(&event.self(), event.getToDimensionId(), event.isCancelled()),
|
||||
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),
|
||||
(&ev.self()),
|
||||
ev.cancel(),
|
||||
)
|
||||
(Player * entity, bool forcefulWakeUp, bool updateLevelList, bool isCancelled),
|
||||
(&event.self(), event.isForcefulWakeUp(), event.isUpdateLevelList(), event.isCancelled()),
|
||||
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()),
|
||||
logger.error("Event \"onDeathMessage\" cannot be intercepted"),
|
||||
)
|
||||
(event.getDeathMessage().first, event.getDeathMessage().second, &event.self()),
|
||||
,
|
||||
);
|
||||
}
|
||||
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()),
|
||||
logger.error("Event \"onMobHurted\" cannot be intercepted"),
|
||||
auto& damageSource = ev.getSource();
|
||||
(&event.self(), source, -event.getDamage(), (int)damageSource.getCause()),
|
||||
,
|
||||
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),
|
||||
(&ev.self()),
|
||||
ev.cancel(),
|
||||
)
|
||||
(Actor * mob, bool isCancelled),
|
||||
(&event.self(), event.isCancelled()),
|
||||
event.setCancelled(result)
|
||||
);
|
||||
}
|
||||
case doHash("onEntityChangeDim"): {
|
||||
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"): {
|
||||
case doHash("gmlib::DragonRespawnBeforeEvent"): {
|
||||
REGISTER_EVENT_LISTEN(
|
||||
GMLIB::Event::EntityEvent::DragonRespawnBeforeEvent,
|
||||
(int64 enderDragonUniqueID),
|
||||
(ev.getEnderDragon().id),
|
||||
ev.cancel(),
|
||||
)
|
||||
(int64 uniqueId, bool isCancelled),
|
||||
(event.getEnderDragon().id, event.isCancelled()),
|
||||
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),
|
||||
(&ev.self(), ev.getShooter() ? ev.getShooter()->getOrCreateUniqueID().id : -1),
|
||||
ev.cancel(),
|
||||
)
|
||||
(Actor * mob, int64 uniqueId, bool isCancelled),
|
||||
(&event.self(),
|
||||
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),
|
||||
logger.error("Event \"onProjectileCreate\" cannot be intercepted"),
|
||||
)
|
||||
(&event.self(), event.getShooter() ? event.getShooter()->getOrCreateUniqueID().id : -1),
|
||||
);
|
||||
}
|
||||
case doHash("onSpawnWanderingTrader"): {
|
||||
case doHash("gmlib::SpawnWanderingTraderBeforeEvent"): {
|
||||
REGISTER_EVENT_LISTEN(
|
||||
GMLIB::Event::EntityEvent::SpawnWanderingTraderBeforeEvent,
|
||||
(std::pair<BlockPos, int> pos),
|
||||
({ev.getPos(), ev.getRegion().getDimensionId()}),
|
||||
ev.cancel(),
|
||||
)
|
||||
(std::pair<BlockPos, int> pos, bool isCancelled),
|
||||
({event.getPos(), event.getRegion().getDimensionId()}, event.isCancelled()),
|
||||
event.setCancelled(result)
|
||||
);
|
||||
}
|
||||
case doHash("onHandleRequestAction"): {
|
||||
case doHash("gmlib::SpawnWanderingTraderAfterEvent"): {
|
||||
REGISTER_EVENT_LISTEN(
|
||||
GMLIB::Event::EntityEvent::SpawnWanderingTraderAfterEvent,
|
||||
(std::pair<BlockPos, int> pos),
|
||||
({event.getPos(), event.getRegion().getDimensionId()}),
|
||||
);
|
||||
}
|
||||
case doHash("gmlib::HandleRequestActionBeforeEvent"): {
|
||||
// clang-format off
|
||||
REGISTER_EVENT_LISTEN(
|
||||
GMLIB::Event::PlayerEvent::HandleRequestActionBeforeEvent,
|
||||
(
|
||||
Player * player,
|
||||
std::string const& actionType,
|
||||
int count,
|
||||
std::string const& sourceContainerNetId,
|
||||
int sourceSlot,
|
||||
std::string const& destinationContainerNetId,
|
||||
int destinationSlot,
|
||||
bool isCancelled
|
||||
),
|
||||
(
|
||||
(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("gmlib::HandleRequestActionAfterEvent"): {
|
||||
// clang-format off
|
||||
REGISTER_EVENT_LISTEN(
|
||||
GMLIB::Event::PlayerEvent::HandleRequestActionAfterEvent,
|
||||
(
|
||||
Player * player,
|
||||
std::string const& actionType,
|
||||
@@ -210,7 +293,7 @@ void Export_Event_API() {
|
||||
int destinationSlot
|
||||
),
|
||||
(
|
||||
(Player*)&ev.self(),
|
||||
(Player*)&event.self(),
|
||||
magic_enum::enum_name(requestAction.mActionType).data(),
|
||||
(int)requestAction.mAmount,
|
||||
magic_enum::enum_name(requestAction.mSrc.mOpenContainerNetId).data(),
|
||||
@@ -218,32 +301,25 @@ void Export_Event_API() {
|
||||
magic_enum::enum_name(requestAction.mDst.mOpenContainerNetId).data(),
|
||||
(int)requestAction.mDst.mSlot
|
||||
),
|
||||
ev.cancel(),
|
||||
auto& requestAction = (ItemStackRequestActionTransferBase&)ev.getRequestAction();
|
||||
)
|
||||
,
|
||||
auto& requestAction = (ItemStackRequestActionTransferBase&)event.getRequestAction();
|
||||
);
|
||||
// clang-format on
|
||||
}
|
||||
case doHash("onSendContainerClosePacket"): {
|
||||
case doHash("gmlib::ContainerClosePacketSendAfterEvent"): {
|
||||
REGISTER_EVENT_LISTEN(
|
||||
GMLIB::Event::PacketEvent::ContainerClosePacketSendAfterEvent,
|
||||
(Player * player, int ContainerNetId),
|
||||
(ev.getServerNetworkHandler()
|
||||
.getServerPlayer(ev.getNetworkIdentifier(), ev.getPacket().mClientSubId),
|
||||
(int)ev.getPacket().mContainerId),
|
||||
logger.error("Event \"onSendContainerClosePacket\" cannot be intercepted"),
|
||||
)
|
||||
(Player * player, int containerId, bool serverInitiatedClose, bool),
|
||||
(event.getServerNetworkHandler()
|
||||
.getServerPlayer(event.getNetworkIdentifier(), event.getPacket().mClientSubId),
|
||||
(int)event.getPacket().mContainerId,
|
||||
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;
|
||||
}
|
||||
);
|
||||
}
|
||||
Reference in New Issue
Block a user