API
Return to top
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监听器