外观
事件系统
事件就是"当某事发生时,执行你的代码"。例如玩家进入游戏、破坏方块、移动时,都会触发对应事件,你可以在处理器里插入逻辑。
如何使用事件
- 让插件实现对应的事件接口;
- 在
Initialize()中注册事件(XxxEventManager.AddObject(this)); - 在事件方法中写你的逻辑。
玩家进入/离开事件
csharp
using Game.Server;
using Game.Server.PlayerEvent;
public class WelcomePlugin : ServerPlugin, IPlayerEnterGameEventHandle
{
public override string Name => "Welcome";
public override int Version => 1;
public byte FirstLevel => 0;
public override void Initialize()
{
PlayerEnterGameEventManager.AddObject(this);
}
void IPlayerEnterGameEventHandle.PlayerEnter(PlayerData player)
{
Console.WriteLine($"玩家 {player.Name} 进来了");
}
void IPlayerEnterGameEventHandle.PlayerLeave(PlayerData player)
{
Console.WriteLine($"{player.Name} 离开了");
}
public override void Load() { }
public override void Save() { }
}方块破坏/放置事件
可以用来做区域保护:
csharp
using Engine;
using Game.Server;
using Game.Server.PlayerEvent;
public class ProtectPlugin : ServerPlugin, IPlayerBreakAndPlaceHandle
{
public override string Name => "Protect";
public override int Version => 1;
public byte FirstLevel => 0;
public override void Initialize()
{
PlayerBreakAndPlaceBlockEventManager.AddObject(this);
}
// 玩家破坏方块时调用
// 返回 true = 允许破坏,false = 阻止破坏
bool IPlayerBreakAndPlaceHandle.PlayerBreakEvent(
ComponentPlayer player,
Point3 point, // 方块坐标
int blockValue, // 方块ID
int toolLevel) // 工具等级
{
if (IsProtected(point))
{
SendMessage(player, "这里是保护区,不能破坏");
return false;
}
return true;
}
// 玩家放置方块时调用
bool IPlayerBreakAndPlaceHandle.PlayerPlaceEvent(
ComponentPlayer player,
Point3 point,
int blockValue)
{
if (IsProtected(point))
{
SendMessage(player, "这里是保护区,不能放置");
return false;
}
return true;
}
bool IsProtected(Point3 pos)
{
return Math.Abs(pos.X) < 100 && Math.Abs(pos.Z) < 100;
}
void SendMessage(ComponentPlayer player, string msg)
{
var pkg = new Game.NetWork.Packages.MessagePackage(null, msg, 0, null);
pkg.To = player.PlayerData.Client;
Game.NetWork.CommonLib.Net.QueuePackage(pkg);
}
public override void Load() { }
public override void Save() { }
}玩家移动事件
csharp
using Engine;
using Game.Server;
using Game.Server.PlayerEvent;
public class MovePlugin : ServerPlugin, IPlayerMoveHandle
{
public override string Name => "MovePlugin";
public override int Version => 1;
public byte FirstLevel => 0;
public override void Initialize()
{
PlayerMoveEventManager.AddObject(this);
}
// 返回 true = 允许移动,false = 阻止移动
bool IPlayerMoveHandle.PlayerMoveEvent(ComponentPlayer player, Vector3 newPos)
{
if (newPos.X > 1000)
{
SendMessage(player, "前方是禁区");
return false;
}
return true;
}
}所有事件接口一览
| 接口 | 注册管理器 | 说明 |
|---|---|---|
IPlayerEnterGameEventHandle | PlayerEnterGameEventManager | 玩家进入/离开 |
IPlayerBreakAndPlaceHandle | PlayerBreakAndPlaceBlockEventManager | 方块破坏/放置 |
IPlayerMoveHandle | PlayerMoveEventManager | 玩家移动 |
IPlayerInteractEventHandle | PlayerInteractEventManager | 玩家交互 |
更完整的事件清单与签名(含聊天、封禁、生物、地形、终端等)见 接口参考 与 事件与命令路线图。
事件返回值
很多事件方法返回 bool:
true= 允许操作继续;false= 取消/阻止操作。
csharp
bool IPlayerBreakAndPlaceHandle.PlayerBreakEvent(...)
{
if (某种条件)
return false; // 阻止破坏
return true; // 允许破坏
}多个插件同时处理时,只要任意处理器返回
false,最终结果通常就是false。默认允许时显式返回true;阻止时记录原因、玩家和位置;确认插件卸载后不会留下永久锁定数据。不要用异常代替权限拒绝。
同时监听多个事件
一个插件可以实现多个接口:
csharp
public class MyPlugin : ServerPlugin,
IPlayerEnterGameEventHandle,
IPlayerBreakAndPlaceHandle
{
public override void Initialize()
{
PlayerEnterGameEventManager.AddObject(this);
PlayerBreakAndPlaceBlockEventManager.AddObject(this);
}
void IPlayerEnterGameEventHandle.PlayerEnter(PlayerData player) { }
void IPlayerEnterGameEventHandle.PlayerLeave(PlayerData player) { }
bool IPlayerBreakAndPlaceHandle.PlayerBreakEvent(...) => true;
bool IPlayerBreakAndPlaceHandle.PlayerPlaceEvent(...) => true;
}小贴士
- 记得注册:在
Initialize()中调用EventManager.AddObject(this)。 - 返回值很重要:返回
false可以阻止操作。 - 不要做太重的操作:事件触发很频繁,代码要高效。
- 发送消息提醒玩家:阻止操作时告诉玩家原因。
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
