Flutter游戏网络通信插件game_socket的使用

该库是在早期访问阶段发布的，并且尚未稳定。由于它与其他解决方案并行开发，因此在某些方面可能还不成熟。英语不是我的母语，所以没有注释。目前，该库适用于那些希望理解源代码并以此为起点来构建自己的解决方案或帮助我的人。

特性

• 一个库同时包含服务器端和客户端部分。
• API通信库类似于Socket.io，但不兼容此解决方案。
• 包含内置二进制协议，因此无需在字节级别工作。
• 传输层使用TCP。计划实现与UDP并行工作以发送游戏消息。
• 实现了多路复用的概念 - 通过单个通道与多个空间进行交互。

当前不计划支持WebSocket（但社区的支持可能会改变这一点）。

示例

创建客户端

此客户端连接到服务器上的主要/命名空间，然后连接到/home命名空间。接着它发送请求进入lobby房间，之后它会分发一个包含消息文本hello all的hello事件。

import 'package:game_socket/client.dart';

void main() {
  var client = GameClientExample();
  client.connect('localhost', 3103);
}

class GameClientExample extends GameSocketClient {
  GameClientExample() {
    on(Event.handshake, (packet) => _onHandshake(packet));
    on(Event.roomPacket, (packet) => _onRoomPacket(packet));
  }

  void _onHandshake(Packet packet) {
    if (packet.namespace == '/') {
      sendMessage(ConnectRequest('/home'));
    } else if (packet.namespace == '/home') {
      sendMessage(JoinRoomRequest('lobby', namespace: '/home'));
    }
  }

  void _onRoomPacket(RoomPacket packet) {
    var roomName = packet.roomName;
    if (packet.joinRoom && roomName == 'lobby') {
      var msg = RoomEvent(roomName!, namespace: '/home', event: 'hello', message: 'hello all');
      sendMessage(msg);
    }
  }
}

客户端日志

open InternetAddress('127.0.0.1', IPv4) ReadyState.open
handshake Packet{[0.0 /], bit:516, bool:16, int:[0, 0, 60, 0, 0, 0], string:{3: 15466abe2006464e99b6c8b36f7f4ed8}}
>> Message{[/home] boolMask:4, int:[0, 0, 0, 0, 0, 0], string:{} null}
handshake Packet{[0.0 /home], bit:516, bool:16, int:[0, 0, 60, 0, 0, 0], string:{3: 15466abe2006464e99b6c8b36f7f4ed8}}
>> Message{[/home] boolMask:16, int:[0, 0, 0], string:{0: lobby} null}
>> Message{[/home] boolMask:512, int:[0, 0, 0], string:{0: lobby, 5: hello, 1: hello all} null}

创建服务器

import 'package:game_socket/server.dart';

void main() {
  var service = SocketServiceExample();
  service.listen();
}

class SocketServiceExample {
  late GameSocketServer server;
  late Namespace home;

  SocketServiceExample() {
    server = GameSocketServer(options: ServerOptions.byDefault()..supportRawData = true);
    home = server.of('/home');
    home.on(ServerEvent.connect, (data) => _onHomeConnect(data));
    home.on('hello', (packet) => _onHomeData(packet));
    //
    server.on(ServerEvent.connection, (socket) {
      print('/: connection $socket');
      socket.on(ServerEvent.connect, (data) => _onConnect(data[0], data[1]));
      socket.on(Event.disconnecting, (data) => _onDisconnecting(data));
      socket.on(Event.disconnect, (data) => _onDisconnect(data[0], data[1]));
      socket.on(Event.error, (data) => _onError(data));
      socket.on(Event.data, (data) => _onData(data));
      socket.on(Event.close, (data) => {_onClose(data)});
    });
    server.on(ServerEvent.error, (data) => {print('/: eventError $data')});
    server.on(ServerEvent.close, (data) => {print('/: serverClose $data')});
    server.on(ServerEvent.raw, (data) => {print('/: raw $data')});
    server.on(ServerEvent.createRoom, (data) => {print('/: createRoom $data')});
    server.on(ServerEvent.joinRoom, (data) => {print('/: joinRoom $data')});
    server.on(ServerEvent.leaveRoom, (data) => {print('/: leaveRoom $data')});
    server.on(ServerEvent.deleteRoom, (data) => {print('/: deleteRoom $data')});
  }

  void listen() {
    server.listen();
  }

  void _onHomeConnect(dynamic data) {
    print('/home: connect $data');
  }

  void _onHomeData(dynamic data) {
    print('/home: $data');
    if (data is RoomPacket && data.roomName != null) {
      home.broadcast(data, rooms: {data.roomName!});
    }
  }

  void _onConnect(String namespace, String socketId) {
    print('/: connect $socketId');
  }

  void _onDisconnecting(dynamic data) {
    print('/: disconnecting $data');
  }

  void _onDisconnect(String namespace, String reason) {
    print('$namespace: disconnect reason:$reason');
  }

  void _onError(dynamic data) {
    print('/: error $data');
  }

  void _onData(dynamic data) {
    print('/: $data');
  }

  void _onClose(dynamic data) {
    print('/: close $data');
  }
}

服务器日志

listen null Options{ port:3103 raw:true closeOnError:false }
/: connection GameClient{ 15466abe2006464e99b6c8b36f7f4ed8 ReadyState.open [137545126]}
/: createRoom 15466abe2006464e99b6c8b36f7f4ed8
/: joinRoom [15466abe2006464e99b6c8b36f7f4ed8, 15466abe2006464e99b6c8b36f7f4ed8]
/home: connect [/home, 15466abe2006464e99b6c8b36f7f4ed8]

协议

该协议基于模式化。这种方法允许减少传输的数据量，因为消息中不传递数据类型，且数字长度不会被序列化。

数据类型

操作时的消息数据类型

计划

• 初始化发送 UDP 图表。
• 自动连接和重新连接。
• 扩展房间工作的可能性。
• 进行压力测试。

初学者提示

• 如果你正在开发浏览器游戏，那么你需要一个 WebSocket 解决方案。
• 在设计实时通信的游戏时，应优先考虑 UDP，因为 TCP 会在数据包丢失时导致延迟。

创建架构

当你创建一个架构时，你要做两件事：取名为单元格数组的编号，并确定数组长度为五种架构数据类型之一。

import 'package:game_socket/protocol.dart';
typedef PS = PlayerStateSchema;
class PlayerStateSchema extends SimpleSchema {
  @override
  int get code => 10; // 独特的架构代码 10..255 
  @override
  int get version => 1; // 版本 0..255 以支持具有不同版本的游戏客户端

  // bool
  static const int reserved = 0; // 保留
  @override
  int get boolCount => 1;

  // int8
  static const int speed = 0; // 0.000..1.000
  static const int health = 1; // 最大值 (100)
  @override
  int get int8Count => 2;
  // int16
  static const int uid = 2; // 最大值 (65535)
  static const int angle = 3; // 弧度
  static const int score = 4; // 最大值 (65535)
  @override
  int get int16Count => 3;
  // int32
  static const int elapsedTime = 5; // 用于内部同步的时间
  static const int x = 6; // x坐标
  static const int y = 7; // y坐标
  @override
  int get int32Count => 3;

  // strings
  static const int name = 0; // 玩家名称
  @override
  int get stringsCount => 1;
}

消息

创建消息类

class PlayerStateMessage extends Message {
  PlayerStateMessage(Player player, {required double elapsedTime}) : super(PS()) {
    putUInt(PS.uid, player.uid);
    putInt(PS.x, (player.positionBody.x * 1000).toInt()); // ~ -2000000.0000..+2000000.0000
    putInt(PS.y, (player.positionBody.y * 1000).toInt());
    putInt(PS.score, player.score);
    putSingle(PS.speed, player.speed);
    putRadians(PS.angle, player.rotationBody);
    putUInt(PS.elapsedTime, (elapsedTime * 1000).toInt()); // double ms
  }
}