xyz Well, there you go again... mystery solved.
ClientNode
# client_node.gd
class_name ClientNode
extends Node
var udp := PacketPeerUDP.new()
var timer = Timer.new()
var client_is_running = false
var thread :Thread
func _ready():
add_child(timer)
timer.wait_time=1
timer.timeout.connect(_on_timeout)
pass
func _process(_delta):
pass
func _on_timeout():
#var ut = Time.get_unix_time_from_system()
var ms = str(Time.get_ticks_msec()) #str(int(ut * 1000))
udp.put_packet(ms.to_utf8_buffer())
func start_ping(ip:String, port:int):
var error = udp.connect_to_host(ip,port)
if error != OK:
print("ClientNode didnt connect")
else:
print("ClientNode connected")
timer.start()
print("Timer started!")
client_is_running = true
thread = Thread.new()
thread.start(thread_get_packet, Thread.PRIORITY_HIGH)
pass
func stop_ping():
client_is_running = false
timer.stop()
udp.close()
thread.wait_to_finish()
print("ClientNode disconnected")
pass
func thread_get_packet():
while(client_is_running):
if udp.get_available_packet_count() > 0:
#var ut = Time.get_unix_time_from_system()
var ms = Time.get_ticks_msec()
var packet_ms = udp.get_packet().get_string_from_utf8().to_int()
var latency = ms - packet_ms
print("latency: %s ms" % latency)
ServerNode
# server_node.gd
class_name ServerNode
extends Node
var server := UDPServer.new()
var peers = []
var server_port = 4242
var server_is_running = false
var thread :Thread
func _ready():
pass
func _process(_delta):
pass
func start_server(port):
var usable_port = server_port
if port:
usable_port = port
var error = server.listen(usable_port)
if error != OK:
print("ServerNode didnt listten")
else:
print("ServerNode listenning")
server_is_running = true
thread = Thread.new()
thread.start(thread_poll, Thread.PRIORITY_HIGH)
pass
func stop_server():
server_is_running= false
server.stop()
thread.wait_to_finish()
print("ServerNode stopped")
pass
func thread_poll():
while(server_is_running):
server.poll() # Important!
if server.is_connection_available():
var peer: PacketPeerUDP = server.take_connection()
var packet = peer.get_packet()
peer.put_packet(packet)
peers.append(peer)
for i in range(0, peers.size()):
if peers[i].get_available_packet_count() > 0:
var packet = peers[i].get_packet()
peers[i].put_packet(packet)
pass # Do something with the connected peers.
MainScene
extends Control
@onready var udp_ping_server: ServerNode = $UdpPingServer
@onready var udp_ping_client: ClientNode = $UdpPingClient
@onready var line_edit_ip: LineEdit = $PanelContainer/MarginContainer/VBoxContainer/MarginContainer/HBoxContainer/LineEditIP
@onready var line_edit_port_client: LineEdit = $PanelContainer/MarginContainer/VBoxContainer/MarginContainer2/HBoxContainer/LineEditPortClient
@onready var button_start_client: Button = $PanelContainer/MarginContainer/VBoxContainer/ButtonStartClient
@onready var button_stop_client: Button = $PanelContainer/MarginContainer/VBoxContainer/ButtonStopClient
@onready var line_edit_port_server: LineEdit = $PanelContainer/MarginContainer/VBoxContainer/MarginContainer3/HBoxContainer/LineEditPortServer
@onready var button_start_server: Button = $PanelContainer/MarginContainer/VBoxContainer/ButtonStartServer
@onready var button_stop_server: Button = $PanelContainer/MarginContainer/VBoxContainer/ButtonStopServer
# Called when the node enters the scene tree for the first time.
func _ready() -> void:
pass # Replace with function body.
# Called every frame. 'delta' is the elapsed time since the previous frame.
func _process(_delta: float) -> void:
pass
func _on_button_start_client_button_down() -> void:
udp_ping_client.start_ping(line_edit_ip.text,line_edit_port_client.text.to_int())
pass # Replace with function body.
func _on_button_stop_client_button_down() -> void:
udp_ping_client.stop_ping()
pass # Replace with function body.
func _on_button_start_server_button_down() -> void:
udp_ping_server.start_server(line_edit_port_server.text.to_int())
pass # Replace with function body.
func _on_button_stop_server_button_down() -> void:
udp_ping_server.stop_server()
pass # Replace with function body.
So i merged everything in one app, and with main scene i orchestrate what happens. Manually start/stop client/server.
Distributed this app across few local computers and now im getting better pings.
Did a test with swapped machines, same result, just didnt record the results.
So can we call it - problem solved? 😃 not sure how else to debug but to maybe host this over internet and try pinging machine somewhere in the world?
EDIT: Fixed the thread thing, and updated the codes above
..
That looks more like the actual latency. Although if you did it properly and run it in a single instance, your "latency" printout should be near 0.
