WebSocket

HTML5 与 WebSocket

WebSocket协议在2011年被标准化, 最初的目标是让浏览器与服务器建立稳定的双向连接. 在此之前, 浏览器曾只支持HTTPRequests, 并不适合双向通信.

The protocol is message based and a very powerful tool to send push notifications to browsers, and has been used to implement chats, turn-based games, etc. It still uses a TCP connection, which is good for reliability but not for latency, so not good for real-time applications like VoIP and fast-paced games (see WebRTC for those use cases).

由于它的简单性, 广泛的兼容性以及比原始TCP连接更容易使用,WebSocket很快就开始在浏览器以外的地方应用, 在本地应用程序中作为与网络服务器通信的一种手段.

Godot在本机和HTML5导出中都支持WebSocket.

在 Godot 中使用 WebSocket

WebSocket is implemented in Godot via WebSocketPeer. The WebSocket implementation is compatible with the High Level Multiplayer. See section on high-level multiplayer for more details.

警告

导出到 Android 时，在导出项目或使用一键部署之前，确保在 Android 导出预设中启用 INTERNET 权限。否则，Android 系统会阻止该程序任何形式的网络通信。

最小客户端示例

本示例将向你展示如何创建与远程服务器的 WebSocket 连接, 以及如何发送和接收数据.

  1. extends Node
  3. # The URL we will connect to.
  4. @export var websocket_url = "wss://echo.websocket.org"
  6. # Our WebSocketClient instance.
  7. var socket = WebSocketPeer.new()
  9. func _ready():
  10.     # Initiate connection to the given URL.
  11.     var err = socket.connect_to_url(websocket_url)
  12.     if err != OK:
  13.         print("Unable to connect")
  14.         set_process(false)
  15.     else:
  16.         # Wait for the socket to connect.
  17.         await get_tree().create_timer(2).timeout
  19.         # Send data.
  20.         socket.send_text("Test packet")
  22. func _process(_delta):
  23.     # Call this in _process or _physics_process. Data transfer and state updates
  24.     # will only happen when calling this function.
  25.     socket.poll()
  27.     # get_ready_state() tells you what state the socket is in.
  28.     var state = socket.get_ready_state()
  30.     # WebSocketPeer.STATE_OPEN means the socket is connected and ready
  31.     # to send and receive data.
  32.     if state == WebSocketPeer.STATE_OPEN:
  33.         while socket.get_available_packet_count():
  34.             print("Got data from server: ", socket.get_packet().get_string_from_utf8())
  36.     # WebSocketPeer.STATE_CLOSING means the socket is closing.
  37.     # It is important to keep polling for a clean close.
  38.     elif state == WebSocketPeer.STATE_CLOSING:
  39.         pass
  41.     # WebSocketPeer.STATE_CLOSED means the connection has fully closed.
  42.     # It is now safe to stop polling.
  43.     elif state == WebSocketPeer.STATE_CLOSED:
  44.         # The code will be -1 if the disconnection was not properly notified by the remote peer.
  45.         var code = socket.get_close_code()
  46.         print("WebSocket closed with code: %d. Clean: %s" % [code, code != -1])
  47.         set_process(false) # Stop processing.

This will print something similar to:

  1. Got data from server: Request served by 7811941c69e658
  2. Got data from server: Test packet

最小服务器示例

这个例子将告诉你如何创建一个监听远程连接的WebSocket服务器，以及如何发送和接收数据。

  1. extends Node
  3. # The port we will listen to
  4. const PORT = 9080
  5. # Our WebSocketServer instance
  6. var _server = WebSocketServer.new()
  8. func _ready():
  9.     # Connect base signals to get notified of new client connections,
  10.     # disconnections, and disconnect requests.
  11.     _server.client_connected.connect(_connected)
  12.     _server.client_disconnected.connect(_disconnected)
  13.     _server.client_close_request.connect(_close_request)
  14.     # This signal is emitted when not using the Multiplayer API every time a
  15.     # full packet is received.
  16.     # Alternatively, you could check get_peer(PEER_ID).get_available_packets()
  17.     # in a loop for each connected peer.
  18.     _server.data_received.connect(_on_data)
  19.     # Start listening on the given port.
  20.     var err = _server.listen(PORT)
  21.     if err != OK:
  22.         print("Unable to start server")
  23.         set_process(false)
  25. func _connected(id, proto):
  26.     # This is called when a new peer connects, "id" will be the assigned peer id,
  27.     # "proto" will be the selected WebSocket sub-protocol (which is optional)
  28.     print("Client %d connected with protocol: %s" % [id, proto])
  30. func _close_request(id, code, reason):
  31.     # This is called when a client notifies that it wishes to close the connection,
  32.     # providing a reason string and close code.
  33.     print("Client %d disconnecting with code: %d, reason: %s" % [id, code, reason])
  35. func _disconnected(id, was_clean = false):
  36.     # This is called when a client disconnects, "id" will be the one of the
  37.     # disconnecting client, "was_clean" will tell you if the disconnection
  38.     # was correctly notified by the remote peer before closing the socket.
  39.     print("Client %d disconnected, clean: %s" % [id, str(was_clean)])
  41. func _on_data(id):
  42.     # Print the received packet, you MUST always use get_peer(id).get_packet to receive data,
  43.     # and not get_packet directly when not using the MultiplayerAPI.
  44.     var pkt = _server.get_peer(id).get_packet()
  45.     print("Got data from client %d: %s ... echoing" % [id, pkt.get_string_from_utf8()])
  46.     _server.get_peer(id).put_packet(pkt)
  48. func _process(delta):
  49.     # Call this in _process or _physics_process.
  50.     # Data transfer, and signals emission will only happen when calling this function.
  51.     _server.poll()

这将打印(当客户端连接时)与此类似的东西:

  1. Client 1348090059 connected with protocol: selected-protocol
  2. Got data from client 1348090059: Test packet ... echoing

高级聊天演示

在 godot demo projects 下 networking/websocket_chat 和 networking/websocket_multiplayer 有一个更高级的聊天演示demo, 可以选择使用多人中级抽象和高级多人演示demo.