191 lines
5.8 KiB
GDScript
191 lines
5.8 KiB
GDScript
extends Node
|
|
|
|
signal connected
|
|
signal disconnected
|
|
signal message_received(opcode: int, data: Dictionary)
|
|
signal connection_error(error: String)
|
|
|
|
const SERVER_URL = "wss://srs.aeternalisgames.com/ws"
|
|
|
|
var socket: WebSocketPeer = WebSocketPeer.new()
|
|
var _receive_buffer: PackedByteArray = PackedByteArray()
|
|
var _is_connected: bool = false
|
|
|
|
func _ready():
|
|
set_process(false)
|
|
|
|
func _process(_delta):
|
|
socket.poll()
|
|
|
|
var state = socket.get_ready_state()
|
|
|
|
match state:
|
|
WebSocketPeer.STATE_OPEN:
|
|
if not _is_connected:
|
|
_is_connected = true
|
|
print("[Network] WebSocket connected successfully")
|
|
connected.emit()
|
|
|
|
# Receive data
|
|
while socket.get_available_packet_count() > 0:
|
|
var packet = socket.get_packet()
|
|
print("[Network] Received packet, size: ", packet.size())
|
|
_handle_received_data(packet)
|
|
|
|
WebSocketPeer.STATE_CLOSING:
|
|
print("[Network] WebSocket closing...")
|
|
|
|
WebSocketPeer.STATE_CLOSED:
|
|
var code = socket.get_close_code()
|
|
var reason = socket.get_close_reason()
|
|
print("[Network] WebSocket closed - code: %d, reason: %s" % [code, reason])
|
|
if _is_connected:
|
|
_is_connected = false
|
|
disconnected.emit()
|
|
set_process(false)
|
|
|
|
func connect_to_server() -> Error:
|
|
_receive_buffer.clear()
|
|
|
|
# Reset socket for fresh connection
|
|
socket = WebSocketPeer.new()
|
|
|
|
# Increase buffer sizes for large dungeon data
|
|
socket.inbound_buffer_size = 8 * 1024 * 1024 # 8MB
|
|
socket.outbound_buffer_size = 1024 * 1024 # 1MB
|
|
socket.max_queued_packets = 4096
|
|
|
|
print("[Network] Attempting connection to: ", SERVER_URL)
|
|
var err = socket.connect_to_url(SERVER_URL)
|
|
|
|
if err == OK:
|
|
set_process(true)
|
|
print("[Network] Connection initiated, waiting for handshake...")
|
|
else:
|
|
print("[Network] Connection failed with error: ", err)
|
|
connection_error.emit("Failed to initiate connection: " + str(err))
|
|
|
|
return err
|
|
|
|
func disconnect_from_server():
|
|
if _is_connected:
|
|
socket.close()
|
|
|
|
func send_message(opcode: int, payload: Dictionary = {}):
|
|
if socket.get_ready_state() != WebSocketPeer.STATE_OPEN:
|
|
push_warning("[Network] Cannot send - socket not open (state: %d)" % socket.get_ready_state())
|
|
return
|
|
|
|
# Encode payload to JSON bytes
|
|
var payload_json = JSON.stringify(payload)
|
|
var payload_bytes = payload_json.to_utf8_buffer()
|
|
|
|
# Create message envelope - matching JS client exactly
|
|
var message = {
|
|
"OpCode": opcode,
|
|
"Payload": Array(payload_bytes) # Array of ints, same as JS Array.from()
|
|
}
|
|
var message_json = JSON.stringify(message)
|
|
var message_bytes = message_json.to_utf8_buffer()
|
|
|
|
# Create framed message with 4-byte big-endian length prefix
|
|
var length = message_bytes.size()
|
|
var framed = PackedByteArray()
|
|
framed.resize(4 + length)
|
|
|
|
# Big-endian length prefix
|
|
framed[0] = (length >> 24) & 0xFF
|
|
framed[1] = (length >> 16) & 0xFF
|
|
framed[2] = (length >> 8) & 0xFF
|
|
framed[3] = length & 0xFF
|
|
|
|
# Copy message bytes
|
|
for i in range(length):
|
|
framed[4 + i] = message_bytes[i]
|
|
|
|
print("[Network] Sending opcode %d, payload: %s" % [opcode, payload_json])
|
|
print("[Network] Framed message size: %d bytes" % framed.size())
|
|
|
|
# Send as binary (default)
|
|
var send_err = socket.send(framed)
|
|
if send_err != OK:
|
|
print("[Network] Send error: ", send_err)
|
|
else:
|
|
print("[Network] Message sent successfully")
|
|
|
|
func _handle_received_data(data: PackedByteArray):
|
|
# Append to buffer
|
|
_receive_buffer.append_array(data)
|
|
print("[Network] Buffer size after append: ", _receive_buffer.size())
|
|
|
|
# Process complete messages
|
|
while _receive_buffer.size() >= 4:
|
|
# Read length (big-endian)
|
|
var length = (_receive_buffer[0] << 24) | \
|
|
(_receive_buffer[1] << 16) | \
|
|
(_receive_buffer[2] << 8) | \
|
|
_receive_buffer[3]
|
|
|
|
print("[Network] Message length header: ", length)
|
|
|
|
if length <= 0 or length > 4194304:
|
|
push_error("[Network] Invalid message length: %d" % length)
|
|
_receive_buffer.clear()
|
|
return
|
|
|
|
if _receive_buffer.size() < 4 + length:
|
|
print("[Network] Waiting for more data, have %d, need %d" % [_receive_buffer.size(), 4 + length])
|
|
return # Wait for more data
|
|
|
|
# Extract message
|
|
var message_bytes = _receive_buffer.slice(4, 4 + length)
|
|
_receive_buffer = _receive_buffer.slice(4 + length)
|
|
|
|
# Parse JSON
|
|
var message_text = message_bytes.get_string_from_utf8()
|
|
print("[Network] Raw message: ", message_text.substr(0, 200)) # First 200 chars
|
|
|
|
var json = JSON.new()
|
|
var parse_result = json.parse(message_text)
|
|
|
|
if parse_result != OK:
|
|
push_error("[Network] Failed to parse message JSON: " + json.get_error_message())
|
|
continue
|
|
|
|
var msg = json.data
|
|
var opcode: int = msg.get("opCode", msg.get("OpCode", 0))
|
|
print("[Network] Parsed opcode: ", opcode)
|
|
|
|
# Decode payload
|
|
var payload_data = msg.get("payload", msg.get("Payload", null))
|
|
var decoded_data = {}
|
|
|
|
if payload_data != null:
|
|
var payload_string: String
|
|
if payload_data is String:
|
|
# Base64 encoded
|
|
print("[Network] Payload is base64 string")
|
|
payload_string = Marshalls.base64_to_utf8(payload_data)
|
|
elif payload_data is Array:
|
|
# Array of bytes
|
|
print("[Network] Payload is byte array, size: ", payload_data.size())
|
|
var byte_array = PackedByteArray(payload_data)
|
|
payload_string = byte_array.get_string_from_utf8()
|
|
else:
|
|
print("[Network] Payload is other type: ", typeof(payload_data))
|
|
payload_string = JSON.stringify(payload_data)
|
|
|
|
print("[Network] Decoded payload string: ", payload_string.substr(0, 200))
|
|
|
|
var payload_json = JSON.new()
|
|
if payload_json.parse(payload_string) == OK:
|
|
decoded_data = payload_json.data
|
|
else:
|
|
decoded_data = {"raw": payload_string}
|
|
|
|
print("[Network] Emitting message_received with opcode: ", opcode)
|
|
message_received.emit(opcode, decoded_data)
|
|
|
|
func is_socket_connected() -> bool:
|
|
return _is_connected and socket.get_ready_state() == WebSocketPeer.STATE_OPEN
|