Files
dungeon-divers/scripts/autoload/network.gd
T
2025-12-18 11:33:12 -05:00

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