Skip to content
Event

基础类型 / Event

Event Class

事件

MW编辑器支持多种类型的事件。

在实现逻辑时,您可以将函数连接到编辑器触发的内置事件以响应它们。还可以创建触发并响应自定义事件。此外,您可以使用网络事件来允许跨客户端-服务器边界进行事件驱动的通信。

许多对象都具有由其 API 提供的内置事件,这些事件会自动响应与这些对象相关的特定操作或更改。例如: HotWeapon 中装备上武器会触发 onEquip 事件。

Event 类提供了本地、客户端和服务器之间通信的事件。

本地、客户端和服务器之间是如何通信的呢 ?

  • 本地 :指当前主机。

  • 服务器 :MW编辑器多人游戏基于客户端-服务器模式。也就是说,会有一个服务器担当游戏状态的主控者,而连接的客户端将保持近似复本。服务器可以看作傀儡师,客户端则为傀儡师控制的牵线木偶们。

  • 客户端 :连接到服务器的一个或多个“木偶”。

本地、客户端和服务器之间通信时如同打开开关,屋子里的灯就会亮。当我在某地执行事件(打开开关),添加完的事件就会触发(安装好的灯泡就会亮)。

Table of contents

Methods

addClientListener(eventName: string, listener: (player: Player, ...params: unknown[]) => void): EventListener server
服务器监听客户端发来的事件
addGameEventListener(eventName: string, callback: (data: string) => void): EventListener server
注册游戏级的事件
addLocalListener(eventName: string, listener: (...params: unknown[]) => void): EventListener
添加本地事件。
addSceneEventListener(eventName: string, callback: (data: string) => void): EventListener server
注册场景级的事件,在同一个场景中的不同房间,都可以收到该事件广播
addServerListener(eventName: string, listener: (...params: unknown[]) => void): EventListener client
客户端监听服务器事件
dispatchGameEvent(eventName: string, data: string): void server
广播游戏级的事件,在同一个游戏中的不同房间,都可以收到该事件广播
dispatchSceneEvent(eventName: string, data: string): void server
广播场景级的事件,在同一个场景中的不同房间,都可以收到该事件广播
dispatchToAllClient(eventName: string, ...params: unknown[]): DispatchEventResult server
服务器发送事件给所有客户端
dispatchToAllClientUnreliable(eventName: string, ...params: unknown[]): DispatchEventResult server
服务器发送不可靠事件给所有客户端,不可靠事件没有重发机制,当遭遇网络波动或者其他情况时会丢失
dispatchToClient(player: Player, eventName: string, ...params: unknown[]): DispatchEventResult server
服务器发送事件给指定客户端
dispatchToClientUnreliable(player: Player, eventName: string, ...params: unknown[]): DispatchEventResult server
服务器发送不可靠事件给指定客户端,不可靠事件没有重发机制,当遭遇网络波动或者其他情况时会丢失
dispatchToLocal(eventName: string, ...params: unknown[]): DispatchEventResult
执行已添加的本地事件。
dispatchToServer(eventName: string, ...params: unknown[]): DispatchEventResult client
客户端发送事件给服务器
dispatchToServerUnreliable(eventName: string, ...params: unknown[]): DispatchEventResult client
客户端发送不可靠事件给服务器,不可靠事件没有重发机制,当遭遇网络波动或者其他情况时会丢失
removeListener(event: EventListener): void
移除事件监听器

Methods

addClientListener

Static addClientListener(eventName, listener): EventListener server

服务器监听客户端发来的事件

Parameters

eventName string事件名
range: 长度不做限制,但请设置合适的长度和名称。
listener (player: Player, ...params: unknown[]) => void监听回调 Player 发送事件的客户端 target 事件内容

Returns

EventListener返回一个事件监听器

Precautions

应该在服务器端的逻辑里面使用

使用示例:创建一个名为"EventSample"的脚本,放置在对象管理器中,打开脚本,输入以下代码保存,运行游戏,你将在服务端中看到每帧打印ok,代码如下:
ts
 @Component
 export default class EventSample extends Script {
     protected async onStart(): `Promise`<`void`\> {
         this.useUpdate = true;
         // 客户端向服务器发送 eventOne 事件
         // 客户端发送 eventOne 事件可以看作灯的开关
         if(SystemUtil.isClient()){
             Event.dispatchToServer("eventOne");
         }
         // 在服务器执行客户端发来的 eventOne 事件,并在服务器执行传入的函数逻辑
         // 服务器执行 eventOne 事件,传入的函数开始执行可以看作灯泡亮了
         if (SystemUtil.isServer()){
             Event.addClientListener("eventOne" ,()=>{console.log("ok")});
         }
     }
 }
 @Component
 export default class EventSample extends Script {
     protected async onStart(): `Promise`<`void`\> {
         this.useUpdate = true;
         // 客户端向服务器发送 eventOne 事件
         // 客户端发送 eventOne 事件可以看作灯的开关
         if(SystemUtil.isClient()){
             Event.dispatchToServer("eventOne");
         }
         // 在服务器执行客户端发来的 eventOne 事件,并在服务器执行传入的函数逻辑
         // 服务器执行 eventOne 事件,传入的函数开始执行可以看作灯泡亮了
         if (SystemUtil.isServer()){
             Event.addClientListener("eventOne" ,()=>{console.log("ok")});
         }
     }
 }

addGameEventListener

Static addGameEventListener(eventName, callback): EventListener server

注册游戏级的事件

Parameters

eventName string事件名称
range: 长度不做限制,但建议设置合适的长度和名称。
callback (data: string) => void收到注册的事件时会触发的回调

Returns

EventListener

addLocalListener

Static addLocalListener(eventName, listener): EventListener

添加本地事件。

Parameters

eventName string事件名
range: 长度不做限制,但请设置合适的长度和名称。
listener (...params: unknown[]) => void监听回调

Returns

EventListener返回一个事件监听器

addSceneEventListener

Static addSceneEventListener(eventName, callback): EventListener server

注册场景级的事件,在同一个场景中的不同房间,都可以收到该事件广播

Parameters

eventName string事件名称
range: 长度不做限制,但建议设置合适的长度和名称。
callback (data: string) => void收到注册的事件时会触发的回调

Returns

EventListener

addServerListener

Static addServerListener(eventName, listener): EventListener client

客户端监听服务器事件

Parameters

eventName string事件名
range: 长度不做限制,但建议设置合适的长度和名称。
listener (...params: unknown[]) => void监听回调 params 事件内容

Returns

EventListener返回一个事件监听器

Precautions

应在客户端逻辑里调用

使用示例:创建一个名为"EventSample"的脚本,放置在对象管理器中,打开脚本,输入以下代码保存,运行游戏,你将在客户端中看到每帧打印ok,代码如下:
ts
@Component
 export default class EventSample extends Script {
     protected async onStart(): `Promise`<`void`\> {
         this.useUpdate = true;
         // 在客户端执行服务器发来的 eventOne 事件,并在客户端执行传入的函数逻辑
         // 客户端执行 eventOne 事件,传入的函数开始执行可以看作灯泡亮了
         if(SystemUtil.isClient()){
             Event.addServerListener("eventOne",()=>{console.log("ok")});
         }
     }
     protected onUpdate(dt: number): void {
         // 服务器每帧对所有客户端发送 eventOne 事件
         // 服务端发送 eventOne 事件可以看作灯的开关,每帧打开一次灯泡的开关
         if (SystemUtil.isServer()){
             Event.dispatchToAllClient("eventOne");
         }
     }
 }
@Component
 export default class EventSample extends Script {
     protected async onStart(): `Promise`<`void`\> {
         this.useUpdate = true;
         // 在客户端执行服务器发来的 eventOne 事件,并在客户端执行传入的函数逻辑
         // 客户端执行 eventOne 事件,传入的函数开始执行可以看作灯泡亮了
         if(SystemUtil.isClient()){
             Event.addServerListener("eventOne",()=>{console.log("ok")});
         }
     }
     protected onUpdate(dt: number): void {
         // 服务器每帧对所有客户端发送 eventOne 事件
         // 服务端发送 eventOne 事件可以看作灯的开关,每帧打开一次灯泡的开关
         if (SystemUtil.isServer()){
             Event.dispatchToAllClient("eventOne");
         }
     }
 }

dispatchGameEvent

Static dispatchGameEvent(eventName, data): void server

广播游戏级的事件,在同一个游戏中的不同房间,都可以收到该事件广播

Parameters

eventName string事件名称
range: 长度不做限制,但建议设置合适的长度和名称。
data string携带的数据
range: 长度不做限制。

dispatchSceneEvent

Static dispatchSceneEvent(eventName, data): void server

广播场景级的事件,在同一个场景中的不同房间,都可以收到该事件广播

Parameters

eventName string事件名称
range: 长度不做限制,但建议设置合适的长度和名称。
data string携带的数据
range: 长度不做限制。

dispatchToAllClient

Static dispatchToAllClient(eventName, ...params): DispatchEventResult server

服务器发送事件给所有客户端

Parameters

eventName string事件名
range: 长度不做限制,但建议设置合适的长度和名称。
...params unknown[]可变长参数

Returns

DispatchEventResult返回事件发送结果

Precautions

应在服务器逻辑里调用

使用示例:创建一个名为"EventSample"的脚本,放置在对象管理器中,打开脚本,输入以下代码保存,运行游戏,你将在客户端中看到每帧打印ok,代码如下:
ts
@Component
 export default class EventSample extends Script {
     protected async onStart(): `Promise`<`void`\> {
         this.useUpdate = true;
         // 在客户端执行服务器发来的 eventOne 事件,并在客户端执行传入的函数逻辑
         // 客户端执行 eventOne 事件,传入的函数开始执行可以看作灯泡亮了
         if(SystemUtil.isClient()){
             Event.addServerListener("eventOne",()=>{console.log("ok")});
         }
     }
     protected onUpdate(dt: number): void {
         // 服务器每帧对所有客户端发送 eventOne 事件
         // 服务端发送 eventOne 事件可以看作灯的开关,每帧打开一次灯泡的开关
         if (SystemUtil.isServer()){
             Event.dispatchToAllClient("eventOne");
         }
     }
 }
@Component
 export default class EventSample extends Script {
     protected async onStart(): `Promise`<`void`\> {
         this.useUpdate = true;
         // 在客户端执行服务器发来的 eventOne 事件,并在客户端执行传入的函数逻辑
         // 客户端执行 eventOne 事件,传入的函数开始执行可以看作灯泡亮了
         if(SystemUtil.isClient()){
             Event.addServerListener("eventOne",()=>{console.log("ok")});
         }
     }
     protected onUpdate(dt: number): void {
         // 服务器每帧对所有客户端发送 eventOne 事件
         // 服务端发送 eventOne 事件可以看作灯的开关,每帧打开一次灯泡的开关
         if (SystemUtil.isServer()){
             Event.dispatchToAllClient("eventOne");
         }
     }
 }

dispatchToAllClientUnreliable

Static dispatchToAllClientUnreliable(eventName, ...params): DispatchEventResult server

服务器发送不可靠事件给所有客户端,不可靠事件没有重发机制,当遭遇网络波动或者其他情况时会丢失

Parameters

eventName string事件名
range: 长度不做限制,但建议设置合适的长度和名称。
...params unknown[]可变长参数

Returns

DispatchEventResult返回事件发送结果

Precautions

应在服务器逻辑里调用

使用示例:创建一个名为"EventSample"的脚本,放置在对象管理器中,打开脚本,输入以下代码保存,运行游戏,你将在客户端中看到每帧打印ok,代码如下:
ts
@Component
 export default class EventSample extends Script {
     protected async onStart(): `Promise`<`void`\> {
         this.useUpdate = true;
         // 在客户端执行服务器发来的 eventOne 事件,并在客户端执行传入的函数逻辑
         // 客户端执行 eventOne 事件,传入的函数开始执行可以看作灯泡亮了
         if(SystemUtil.isClient()){
             Event.addServerListener("eventOne",()=>{console.log("ok")});
         }
     }
     protected onUpdate(dt: number): void {
         // 服务器每帧对所有客户端发送 eventOne 事件
         // 服务端发送 eventOne 事件可以看作灯的开关,每帧打开一次灯泡的开关
         if (SystemUtil.isServer()){
             Event.dispatchToAllClientUnreliable("eventOne");
         }
     }
 }
@Component
 export default class EventSample extends Script {
     protected async onStart(): `Promise`<`void`\> {
         this.useUpdate = true;
         // 在客户端执行服务器发来的 eventOne 事件,并在客户端执行传入的函数逻辑
         // 客户端执行 eventOne 事件,传入的函数开始执行可以看作灯泡亮了
         if(SystemUtil.isClient()){
             Event.addServerListener("eventOne",()=>{console.log("ok")});
         }
     }
     protected onUpdate(dt: number): void {
         // 服务器每帧对所有客户端发送 eventOne 事件
         // 服务端发送 eventOne 事件可以看作灯的开关,每帧打开一次灯泡的开关
         if (SystemUtil.isServer()){
             Event.dispatchToAllClientUnreliable("eventOne");
         }
     }
 }

dispatchToClient

Static dispatchToClient(player, eventName, ...params): DispatchEventResult server

服务器发送事件给指定客户端

Parameters

player Player客户端
eventName string事件名
range: 长度不做限制,但建议设置合适的长度和名称。
...params unknown[]可变长参数

Returns

DispatchEventResult返回事件发送结果

Precautions

应在服务器逻辑里调用


dispatchToClientUnreliable

Static dispatchToClientUnreliable(player, eventName, ...params): DispatchEventResult server

服务器发送不可靠事件给指定客户端,不可靠事件没有重发机制,当遭遇网络波动或者其他情况时会丢失

Parameters

player Player客户端
eventName string事件名
range: 长度不做限制,但建议设置合适的长度和名称。
...params unknown[]可变长参数

Returns

DispatchEventResult返回事件发送结果

Precautions

应在服务器逻辑里调用


dispatchToLocal

Static dispatchToLocal(eventName, ...params): DispatchEventResult

执行已添加的本地事件。

Parameters

eventName string事件名
range: 长度不做限制,与添加事件名配对。
...params unknown[]事件内容

Returns

DispatchEventResult返回发送本地事件的结果

dispatchToServer

Static dispatchToServer(eventName, ...params): DispatchEventResult client

客户端发送事件给服务器

Parameters

eventName string事件名
range: 长度不做限制,但建议设置合适的长度和名称。
...params unknown[]可变长参数

Returns

DispatchEventResult返回事件发送结果

Precautions

应在客户端逻辑里面调用

使用示例:创建一个名为"EventSample"的脚本,放置在对象管理器中,打开脚本,输入以下代码保存,运行游戏,你将在服务端中看到每帧打印ok,代码如下:
ts
 @Component
 export default class EventSample extends Script {
     protected async onStart(): `Promise`<`void`\> {
         this.useUpdate = true;
         // 客户端向服务器发送 eventOne 事件
         // 客户端发送 eventOne 事件可以看作灯的开关
         if(SystemUtil.isClient()){
             Event.dispatchToServer("eventOne");
         }
         // 在服务器执行客户端发来的 eventOne 事件,并在服务器执行传入的函数逻辑
         // 服务器执行 eventOne 事件,传入的函数开始执行可以看作灯泡亮了
         if (SystemUtil.isServer()){
             Event.addClientListener("eventOne" ,()=>{console.log("ok")});
         }
     }
 }
 @Component
 export default class EventSample extends Script {
     protected async onStart(): `Promise`<`void`\> {
         this.useUpdate = true;
         // 客户端向服务器发送 eventOne 事件
         // 客户端发送 eventOne 事件可以看作灯的开关
         if(SystemUtil.isClient()){
             Event.dispatchToServer("eventOne");
         }
         // 在服务器执行客户端发来的 eventOne 事件,并在服务器执行传入的函数逻辑
         // 服务器执行 eventOne 事件,传入的函数开始执行可以看作灯泡亮了
         if (SystemUtil.isServer()){
             Event.addClientListener("eventOne" ,()=>{console.log("ok")});
         }
     }
 }

dispatchToServerUnreliable

Static dispatchToServerUnreliable(eventName, ...params): DispatchEventResult client

客户端发送不可靠事件给服务器,不可靠事件没有重发机制,当遭遇网络波动或者其他情况时会丢失

Parameters

eventName string事件名
range: 长度不做限制,但建议设置合适的长度和名称。
...params unknown[]可变长参数

Returns

DispatchEventResult返回事件发送结果

Precautions

应在客户端逻辑里面调用

使用示例:创建一个名为"EventSample"的脚本,放置在对象管理器中,打开脚本,输入以下代码保存,运行游戏,你将在服务端中看到每帧打印ok,代码如下:
ts
 @Component
 export default class EventSample extends Script {
     protected async onStart(): `Promise`<`void`\> {
         this.useUpdate = true;
         // 客户端向服务器发送 eventOne 事件
         // 客户端发送 eventOne 事件可以看作灯的开关
         if(SystemUtil.isClient()){
             Event.dispatchToServerUnreliable("eventOne");
         }
         // 在服务器执行客户端发来的 eventOne 事件,并在服务器执行传入的函数逻辑
         // 服务器执行 eventOne 事件,传入的函数开始执行可以看作灯泡亮了
         if (SystemUtil.isServer()){
             Event.addClientListener("eventOne" ,()=>{console.log("ok")});
         }
     }
 }
 @Component
 export default class EventSample extends Script {
     protected async onStart(): `Promise`<`void`\> {
         this.useUpdate = true;
         // 客户端向服务器发送 eventOne 事件
         // 客户端发送 eventOne 事件可以看作灯的开关
         if(SystemUtil.isClient()){
             Event.dispatchToServerUnreliable("eventOne");
         }
         // 在服务器执行客户端发来的 eventOne 事件,并在服务器执行传入的函数逻辑
         // 服务器执行 eventOne 事件,传入的函数开始执行可以看作灯泡亮了
         if (SystemUtil.isServer()){
             Event.addClientListener("eventOne" ,()=>{console.log("ok")});
         }
     }
 }

removeListener

Static removeListener(event): void

移除事件监听器

Parameters

event EventListener监听器