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

feat: refactor event API to use unique event names and remove NextEventId

Browse Source
This commit is contained in:
子沐呀
2024-09-20 22:02:24 +08:00
Unverified
parent 3e446d95de
commit b5fbcdd7b8
3 changed files with 159 additions and 288 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/EventAPI-JS.d.ts
Vendored
+8 -8
View File
@@ -13,7 +13,7 @@ declare class Event {
) => boolean | void ) => boolean | void
): boolean; ): boolean;
/** 客户端登录后事件(不可以拦截) */ /** 客户端登录后事件 */
static listen( static listen(
/** 事件名 */ /** 事件名 */
event: "onClientLogin", event: "onClientLogin",
@@ -27,7 +27,7 @@ declare class Event {
serverXuid: string, serverXuid: string,
/** 玩家在客户端的xuid */ /** 玩家在客户端的xuid */
clientXuid: string clientXuid: string
) => void ) => bool
): boolean; ): boolean;
/** 天气改变事件事件 */ /** 天气改变事件事件 */
@@ -55,8 +55,8 @@ declare class Event {
item: Item, item: Item,
/** 尝试生成的坐标对象 */ /** 尝试生成的坐标对象 */
pos: FloatPos, pos: FloatPos,
/** 创建掉落物的实体对象 */ /** 创建掉落物的实体uniqueId */
spawnerEntity: Entity spawnerUniqueId: number
) => boolean | void ) => boolean | void
): boolean; ): boolean;
@@ -72,15 +72,15 @@ declare class Event {
entity: Entity, entity: Entity,
/** 实体生成的坐标 */ /** 实体生成的坐标 */
pos: FloatPos, pos: FloatPos,
/** 创建掉落物的实体对象 */ /** 创建掉落物的实体uniqueId */
spawnerEntity: Entity spawnerUniqueId: number
) => void ) => void
): boolean; ): boolean;
/** 实体切换维度 */ /** 实体切换维度 */
static listen( static listen(
/** 事件名 */ /** 事件名 */
event: "onEntityChangeDim", event: "onEntityTryChangeDim",
/** 回调函数 */ /** 回调函数 */
listener: ( listener: (
/** 切换维度的实体对象 */ /** 切换维度的实体对象 */
@@ -93,7 +93,7 @@ declare class Event {
/** 实体切换维度后(不可拦截) */ /** 实体切换维度后(不可拦截) */
static listen( static listen(
/** 事件名 */ /** 事件名 */
event: "onEntityChangeDimAfter", event: "onEntityChangeDim",
/** 回调函数 */ /** 回调函数 */
listener: ( listener: (
/** 切换维度的实体对象 */ /** 切换维度的实体对象 */
lib/EventAPI-JS.js
+1 -13
View File
@@ -1,18 +1,6 @@
/** 事件创建函数 @type {function(string,string):boolean} */ /** 事件创建函数 @type {function(string,string):boolean} */
const CallEvent = ll.import("GMLIB_API", "callCustomEvent"); const CallEvent = ll.import("GMLIB_API", "callCustomEvent");
/** 事件ID @type {number} */
let NextEventId = 0;
/**
* 获取事件ID标识名
* @returns {string} 事件ID标识名
*/
function getNextEventId() {
NextEventId++;
return "GMLIB_Event_" + NextEventId;
}
/** 事件类 */ /** 事件类 */
class Event { class Event {
constructor() { constructor() {
@@ -26,7 +14,7 @@ class Event {
* @returns {boolean} 是否创建成功 * @returns {boolean} 是否创建成功
*/ */
static listen(event, callback) { static listen(event, callback) {
let eventId = getNextEventId(); let eventId = "GMLIB_Event_" + Math.random().toString(16).slice(2);
ll.export(callback, event, eventId); ll.export(callback, event, eventId);
let result = CallEvent(event, eventId); let result = CallEvent(event, eventId);
if (!result) { if (!result) {
src/EventAPI.cpp
+150 -267
View File
@@ -1,329 +1,212 @@
#include "Global.h" #include "Global.h"
using namespace ll::hash_utils; using namespace ll::hash_utils;
#define REGISTER_EVENT_LISTEN(eventType, callFunction, eventParams, cancelFunction, otherFunction) \
if (eventListeners.contains(eventName + "_" + eventId)) \
eventBus.removeListener(eventListeners.at(eventName + "_" + eventId)); \
eventListeners[eventName + "_" + eventId] = \
eventBus.emplaceListener<eventType>([eventName, eventId, &eventBus](eventType& ev) -> void { \
if (!RemoteCall::hasFunc(eventName, eventId)) { \
eventBus.removeListener(eventListeners.at(eventName + "_" + eventId)); \
eventListeners.erase(eventName + "_" + eventId); \
return; \
} \
bool result = true; \
try { \
otherFunction; \
result = RemoteCall::importAs<bool callFunction>(eventName, eventId) eventParams; \
} catch (std::exception & e) { \
if (std::string(e.what()) != "bad variant access") { \
logger.error("Exception in event listener: {0}", e.what()); \
logger.error("Event: {0}, Id: {1}", eventName, eventId); \
} \
} \
if (!result) cancelFunction; \
}); \
return true;
std::unordered_map<std::string, ll::event::ListenerPtr> eventListeners;
void Export_Event_API() { void Export_Event_API() {
auto eventBus = &ll::event::EventBus::getInstance(); auto& eventBus = ll::event::EventBus::getInstance();
RemoteCall::exportAs( RemoteCall::exportAs(
"GMLIB_API", "GMLIB_API",
"callCustomEvent", "callCustomEvent",
[eventBus](std::string const& eventName, std::string const& eventId) -> bool { [&eventBus](std::string const& eventName, std::string const& eventId) -> bool {
if (!RemoteCall::hasFunc(eventName, eventId)) return false; if (!RemoteCall::hasFunc(eventName, eventId)) return false;
switch (doHash(eventName)) { switch (doHash(eventName)) {
case doHash("onClientLogin"): { case doHash("onClientLogin"): {
auto Call = RemoteCall::importAs<bool( REGISTER_EVENT_LISTEN(
std::string const& realName, Event::PacketEvent::ClientLoginAfterEvent,
std::string const& uuid, (std::string const& realName,
std::string const& serverXuid, std::string const& uuid,
std::string const& clientXuid std::string const& serverXuid,
)>(eventName, eventId); std::string const& clientXuid),
eventBus->emplaceListener<Event::PacketEvent::ClientLoginAfterEvent>( (ev.getRealName(), ev.getUuid().asString(), ev.getServerAuthXuid(), ev.getClientAuthXuid()),
[Call](Event::PacketEvent::ClientLoginAfterEvent& ev) { ev.disConnectClient(),
try {
Call(
ev.getRealName(),
ev.getUuid().asString(),
ev.getServerAuthXuid(),
ev.getClientAuthXuid()
);
} catch (...) {}
}
); );
return true;
} }
case doHash("onWeatherChange"): { case doHash("onWeatherChange"): {
auto Call = REGISTER_EVENT_LISTEN(
RemoteCall::importAs<bool(int lightningLevel, int rainLevel, int lightningLast, int rainLast)>( Event::LevelEvent::WeatherUpdateBeforeEvent,
eventName, (int lightningLevel, int rainLevel, int lightningLast, int rainLast),
eventId (ev.getLightningLevel(), ev.getRainLevel(), ev.getLightningLastTick(), ev.getRainingLastTick()),
); ev.cancel(),
eventBus->emplaceListener<Event::LevelEvent::WeatherUpdateBeforeEvent>(
[Call](Event::LevelEvent::WeatherUpdateBeforeEvent& ev) {
bool result = true;
try {
result = Call(
ev.getLightningLevel(),
ev.getRainLevel(),
ev.getLightningLastTick(),
ev.getRainingLastTick()
);
} catch (...) {}
if (!result) {
ev.cancel();
}
}
); );
return true;
} }
case doHash("onMobPick"): { case doHash("onMobPick"): {
auto Call = RemoteCall::importAs<bool(Actor * mob, Actor * item)>(eventName, eventId); REGISTER_EVENT_LISTEN(
eventBus->emplaceListener<Event::EntityEvent::MobPickupItemBeforeEvent>( Event::EntityEvent::MobPickupItemBeforeEvent,
[Call](Event::EntityEvent::MobPickupItemBeforeEvent& ev) { (Actor * mob, Actor * item),
bool result = true; (&ev.self(), (Actor*)&ev.getItemActor()),
try { ev.cancel(),
result = Call(&ev.self(), (Actor*)&ev.getItemActor());
} catch (...) {}
if (!result) {
ev.cancel();
}
}
); );
return true;
} }
case doHash("onItemTrySpawn"): { case doHash("onItemTrySpawn"): {
auto Call = REGISTER_EVENT_LISTEN(
RemoteCall::importAs<bool(const ItemStack* item, std::pair<Vec3, int> position, Actor* spawner)>( Event::EntityEvent::ItemActorSpawnBeforeEvent,
eventName, (const ItemStack* item, std::pair<Vec3, int> position, int64 spawnerUniqueId),
eventId (&ev.getItem(),
); {ev.getPosition(), ev.getBlockSource().getDimensionId().id},
eventBus->emplaceListener<Event::EntityEvent::ItemActorSpawnBeforeEvent>( ev.getSpawner().has_value() ? ev.getSpawner()->getOrCreateUniqueID().id : -1),
[Call](Event::EntityEvent::ItemActorSpawnBeforeEvent& ev) { ev.cancel(),
auto pos = ev.getPosition();
auto dimid = ev.getBlockSource().getDimensionId().id;
std::pair<Vec3, int> lsePos = {pos, dimid};
bool result = true;
try {
result = Call(&ev.getItem(), lsePos, ev.getSpawner());
} catch (...) {}
if (!result) {
ev.cancel();
}
}
); );
return true;
} }
case doHash("onItemSpawned"): { case doHash("onItemSpawned"): {
auto Call = RemoteCall::importAs< REGISTER_EVENT_LISTEN(
bool(const ItemStack* item, Actor* itemActor, std::pair<Vec3, int> position, Actor* spawner)>( Event::EntityEvent::ItemActorSpawnAfterEvent,
eventName, (const ItemStack* item, Actor* itemActor, std::pair<Vec3, int> position, int64 spawnerUniqueId),
eventId (&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"),
); );
eventBus->emplaceListener<Event::EntityEvent::ItemActorSpawnAfterEvent>(
[Call](Event::EntityEvent::ItemActorSpawnAfterEvent& ev) {
auto pos = ev.getPosition();
auto dimid = ev.getBlockSource().getDimensionId().id;
std::pair<Vec3, int> lsePos = {pos, dimid};
try {
Call(&ev.getItem(), (Actor*)&ev.getItemActor(), lsePos, ev.getSpawner());
} catch (...) {}
}
);
return true;
} }
case doHash("onEntityChangeDim"): { case doHash("onEntityTryChangeDim"): {
auto Call = RemoteCall::importAs<bool(Actor * entity, int toDimId)>(eventName, eventId); REGISTER_EVENT_LISTEN(
eventBus->emplaceListener<Event::EntityEvent::ActorChangeDimensionBeforeEvent>( Event::EntityEvent::ActorChangeDimensionBeforeEvent,
[Call](Event::EntityEvent::ActorChangeDimensionBeforeEvent& ev) { (Actor * entity, int toDimId),
bool result = true; (&ev.self(), ev.getToDimensionId()),
try { ev.cancel(),
result = Call(&ev.self(), ev.getToDimensionId());
} catch (...) {}
if (!result) {
ev.cancel();
}
}
); );
return true;
} }
case doHash("onLeaveBed"): { case doHash("onLeaveBed"): {
auto Call = RemoteCall::importAs<bool(Player * pl)>(eventName, eventId); REGISTER_EVENT_LISTEN(
eventBus->emplaceListener<Event::PlayerEvent::PlayerStopSleepBeforeEvent>( Event::PlayerEvent::PlayerStopSleepBeforeEvent,
[Call](Event::PlayerEvent::PlayerStopSleepBeforeEvent& ev) { (Player * pl),
bool result = true; (&ev.self()),
try { ev.cancel(),
result = Call(&ev.self());
} catch (...) {}
if (!result) {
ev.cancel();
}
}
); );
return true;
} }
case doHash("onDeathMessage"): { case doHash("onDeathMessage"): {
auto Call = REGISTER_EVENT_LISTEN(
RemoteCall::importAs<bool(std::string const& message, std::vector<std::string>, Actor* dead)>( Event::EntityEvent::DeathMessageAfterEvent,
eventName, (std::string const& message, std::vector<std::string>, Actor* dead),
eventId (ev.getDeathMessage().first, ev.getDeathMessage().second, &ev.self()),
); logger.error("Event \"onDeathMessage\" cannot be intercepted"),
eventBus->emplaceListener<Event::EntityEvent::DeathMessageAfterEvent>(
[Call](Event::EntityEvent::DeathMessageAfterEvent& ev) {
auto msg = ev.getDeathMessage();
auto source = ev.getDamageSource();
try {
Call(msg.first, msg.second, &ev.self());
} catch (...) {}
}
); );
return true;
} }
case doHash("onMobHurted"): { case doHash("onMobHurted"): {
auto Call = RemoteCall::importAs<bool(Actor * mob, Actor * source, float damage, int cause)>( REGISTER_EVENT_LISTEN(
eventName, Event::EntityEvent::MobHurtAfterEvent,
eventId (Actor * mob, Actor * source, float damage, int cause),
); (&ev.self(), source, ev.getDamage(), (int)damageSource.getCause()),
eventBus->emplaceListener<Event::EntityEvent::MobHurtAfterEvent>( logger.error("Event \"onMobHurted\" cannot be intercepted"),
[Call](Event::EntityEvent::MobHurtAfterEvent& ev) { auto& damageSource = ev.getSource();
auto& damageSource = ev.getSource(); Actor* source = nullptr;
Actor* source = nullptr; if (damageSource.isEntitySource()) {
if (damageSource.isEntitySource()) { auto uniqueId = damageSource.getDamagingEntityUniqueID();
auto uniqueId = damageSource.getDamagingEntityUniqueID(); source = ll::service::getLevel()->fetchEntity(uniqueId);
source = ll::service::getLevel()->fetchEntity(uniqueId); if (source->getOwner()) source = source->getOwner();
if (source->getOwner()) {
source = source->getOwner();
}
}
try {
Call(&ev.self(), source, ev.getDamage(), (int)damageSource.getCause());
} catch (...) {}
} }
); );
return true;
} }
case doHash("onEndermanTake"): { case doHash("onEndermanTake"): {
auto Call = RemoteCall::importAs<bool(Actor * mob)>(eventName, eventId); REGISTER_EVENT_LISTEN(
eventBus->emplaceListener<Event::EntityEvent::EndermanTakeBlockBeforeEvent>( Event::EntityEvent::EndermanTakeBlockBeforeEvent,
[Call](Event::EntityEvent::EndermanTakeBlockBeforeEvent& ev) { (Actor * mob),
bool result = true; (&ev.self()),
try { ev.cancel(),
result = Call(&ev.self());
} catch (...) {}
if (!result) {
ev.cancel();
}
}
); );
return true;
} }
case doHash("onEntityChangeDimAfter"): { case doHash("onEntityChangeDim"): {
auto Call = RemoteCall::importAs<bool(Actor * mob, int fromDimId)>(eventName, eventId); REGISTER_EVENT_LISTEN(
eventBus->emplaceListener<Event::EntityEvent::ActorChangeDimensionAfterEvent>( Event::EntityEvent::ActorChangeDimensionAfterEvent,
[Call](Event::EntityEvent::ActorChangeDimensionAfterEvent& ev) { (Actor * mob, int fromDimId),
bool result = true; (&ev.self(), ev.getFromDimensionId()),
try { logger.error("Event \"onEntityChangeDim\" cannot be intercepted"),
result = Call(&ev.self(), ev.getFromDimensionId());
} catch (...) {}
}
); );
return true;
} }
case doHash("onDragonRespawn"): { case doHash("onDragonRespawn"): {
auto Call = RemoteCall::importAs<bool(int64 enderDragonUniqueID)>(eventName, eventId); REGISTER_EVENT_LISTEN(
eventBus->emplaceListener<Event::EntityEvent::DragonRespawnBeforeEvent>( Event::EntityEvent::DragonRespawnBeforeEvent,
[Call](Event::EntityEvent::DragonRespawnBeforeEvent& ev) { (int64 enderDragonUniqueID),
bool result = true; (ev.getEnderDragon().id),
try { ev.cancel(),
result = Call(ev.getEnderDragon().id); )
} catch (...) {}
if (!result) {
ev.cancel();
}
}
);
return true;
} }
case doHash("onProjectileTryCreate"): { case doHash("onProjectileTryCreate"): {
auto Call = RemoteCall::importAs<bool(Actor * mob, int64 uniqueId)>(eventName, eventId); REGISTER_EVENT_LISTEN(
eventBus->emplaceListener<Event::EntityEvent::ProjectileCreateBeforeEvent>( Event::EntityEvent::ProjectileCreateBeforeEvent,
[Call](Event::EntityEvent::ProjectileCreateBeforeEvent& ev) { (Actor * mob, int64 uniqueId),
bool result = true; (&ev.self(), ev.getShooter() ? ev.getShooter()->getOrCreateUniqueID().id : -1),
try { ev.cancel(),
auto uid = ev.getShooter() ? ev.getShooter()->getOrCreateUniqueID().id : -1;
result = Call(&ev.self(), uid);
} catch (...) {}
if (!result) {
ev.cancel();
}
}
); );
return true;
} }
case doHash("onProjectileCreate"): { case doHash("onProjectileCreate"): {
auto Call = RemoteCall::importAs<bool(Actor * mob, int64 uniqueId)>(eventName, eventId); REGISTER_EVENT_LISTEN(
eventBus->emplaceListener<Event::EntityEvent::ProjectileCreateAfterEvent>( Event::EntityEvent::ProjectileCreateAfterEvent,
[Call](Event::EntityEvent::ProjectileCreateAfterEvent& ev) { (Actor * mob, int64 uniqueId),
try { (&ev.self(), ev.getShooter() ? ev.getShooter()->getOrCreateUniqueID().id : -1),
auto uid = ev.getShooter() ? ev.getShooter()->getOrCreateUniqueID().id : -1; logger.error("Event \"onProjectileCreate\" cannot be intercepted"),
Call(&ev.self(), uid);
} catch (...) {}
}
); );
return true;
} }
case doHash("onSpawnWanderingTrader"): { case doHash("onSpawnWanderingTrader"): {
auto Call = RemoteCall::importAs<bool(std::pair<BlockPos, int> pos)>(eventName, eventId); REGISTER_EVENT_LISTEN(
eventBus->emplaceListener<Event::EntityEvent::SpawnWanderingTraderBeforeEvent>( Event::EntityEvent::SpawnWanderingTraderBeforeEvent,
[Call](Event::EntityEvent::SpawnWanderingTraderBeforeEvent& ev) { (std::pair<BlockPos, int> pos),
bool result = true; ({ev.getPos(), ev.getRegion().getDimensionId()}),
try { ev.cancel(),
result = Call({ev.getPos(), ev.getRegion().getDimensionId()});
} catch (...) {}
if (!result) {
ev.cancel();
}
}
); );
return true;
} }
case doHash("onHandleRequestAction"): { case doHash("onHandleRequestAction"): {
auto Call = RemoteCall::importAs<bool( REGISTER_EVENT_LISTEN(Event::PlayerEvent::HandleRequestActionBeforeEvent,
Player * player, (Player * player,
std::string const& actionType, std::string const& actionType,
int count, int count,
std::string const& sourceContainerNetId, std::string const& sourceContainerNetId,
int sourceSlot, int sourceSlot,
std::string const& destinationContainerNetId, std::string const& destinationContainerNetId,
int destinationSlot int destinationSlot),
)>(eventName, eventId); ((Player*)&ev.self(),
eventBus->emplaceListener<Event::PlayerEvent::HandleRequestActionBeforeEvent>( magic_enum::enum_name(requestAction->mActionType).data(),
[Call](Event::PlayerEvent::HandleRequestActionBeforeEvent& ev) { (int)requestAction->mAmount,
bool result = true; magic_enum::enum_name(requestAction->mSrc.mOpenContainerNetId).data(),
try { (int)requestAction->mSrc.mSlot,
auto requestAction = (ItemStackRequestActionTransferBase*)&ev.getRequestAction(); magic_enum::enum_name(requestAction->mDst.mOpenContainerNetId).data(),
auto source = requestAction->getSrc(); (int)requestAction->mDst.mSlot),
// TODO: The next version of LeviLamina changes to a member function ev.cancel(),
auto destination = ll::memory::dAccess<ItemStackRequestSlotInfo>(requestAction, 56); auto requestAction = (ItemStackRequestActionTransferBase*)&ev.getRequestAction();
result = Call(
&ev.self(),
magic_enum::enum_name(requestAction->mActionType).data(),
ll::memory::dAccess<uchar>(requestAction, 18),
magic_enum::enum_name(source.mOpenContainerNetId).data(),
source.mSlot,
magic_enum::enum_name(destination.mOpenContainerNetId).data(),
destination.mSlot
);
} catch (...) {}
if (!result) {
ev.cancel();
}
}
); );
return true;
} }
case doHash("onSendContainerClosePacket"): { case doHash("onSendContainerClosePacket"): {
auto Call = RemoteCall::importAs<bool(Player * player, int ContainerNetId)>(eventName, eventId); REGISTER_EVENT_LISTEN(
eventBus->emplaceListener<Event::PacketEvent::ContainerClosePacketSendAfterEvent>( Event::PacketEvent::ContainerClosePacketSendAfterEvent,
[Call](Event::PacketEvent::ContainerClosePacketSendAfterEvent& ev) { (Player * player, int ContainerNetId),
try { (ev.getServerNetworkHandler()
Call( .getServerPlayer(ev.getNetworkIdentifier(), ev.getPacket().mClientSubId),
ev.getServerNetworkHandler() (int)ev.getPacket().mContainerId),
.getServerPlayer(ev.getNetworkIdentifier(), ev.getPacket().mClientSubId), logger.error("Event \"onSendContainerClosePacket\" cannot be intercepted"),
(int)ev.getPacket().mContainerId )
);
} catch (...) {}
}
);
return true;
} }
case doHash("onServerStopping"): { case doHash("onServerStopping"): {
auto Call = RemoteCall::importAs<bool()>(eventName, eventId); REGISTER_EVENT_LISTEN(
eventBus->emplaceListener<ll::event::server::ServerStoppingEvent>( ll::event::server::ServerStoppingEvent,
[Call](ll::event::server::ServerStoppingEvent& ev) { (),
try { (),
Call(); logger.error("Event \"onServerStopping\" cannot be intercepted"),
} catch (...) {}
}
); );
return true;
} }
default: default:
return false; return false;