J3a: the journey on a server. A server per land (Lands: the hub starts land servers on demand over a private link), the cliff tunnel online, crossings with one-time passes, shared characters that remember their land, one clock from the hub; test_net_lands
This commit is contained in:
Paul Bailey
375
scripts/net/lands.gd
Normal file
375
scripts/net/lands.gd
Normal file
@@ -0,0 +1,375 @@
|
||||
extends Node
|
||||
## Autoload "Lands" (J3, docs/WORLDLETS_DESIGN.md: a server per land).
|
||||
##
|
||||
## A server's world can span several lands (worldlets). The server players
|
||||
## join, on the usual port, runs the world's home land (the Valley) and is the
|
||||
## **hub**. When someone first heads for another land, the hub starts a
|
||||
## **land server** for it: the same game, headless, on the next port (24243
|
||||
## for the Cove, and so on), with `--land cove`. It shares the hub's config
|
||||
## and world folder (worlds/<world>/: that land's state is
|
||||
## worldlets/<land>.json, and characters are in players/, shared by all), so
|
||||
## a character saved by one is loaded by the next. A land server stops a
|
||||
## couple of minutes after its last player leaves, and whenever the hub
|
||||
## stops.
|
||||
##
|
||||
## Hub and land servers talk over a private TCP link on 127.0.0.1 (one JSON
|
||||
## object per line), never seen from outside. J3a carries: the land's
|
||||
## "ready" (listening), its player count, the hub's clock, one-time passes
|
||||
## for players crossing over, and asks about the tunnel.
|
||||
##
|
||||
## A crossing (PlayerNet, server side): the player's character is saved with
|
||||
## where they're heading; the hub (or the land server, back the other way)
|
||||
## makes a one-time pass, makes sure the other server is up, and sends the
|
||||
## player's game `{port, pass, land}`. The game reconnects there with the
|
||||
## pass (Net.join(..., pass)), and that server lets them straight in.
|
||||
|
||||
signal land_ready(land: String) ## hub: a land server is listening
|
||||
signal hub_message(msg: Dictionary) ## land server: something from the hub
|
||||
|
||||
const LINK_PORT_OFFSET := 100 ## the hub's private link: its game port + 100 (24342)
|
||||
const IDLE_STOP_SECONDS := 120.0 ## a land server with nobody on stops after this
|
||||
const PASS_SECONDS := 60.0 ## a pass not used by then is no good
|
||||
|
||||
var hub := false ## this server is the hub
|
||||
var land := "" ## this server is a land server, running this land
|
||||
var hub_port := 0 ## (land server) the hub's game port
|
||||
|
||||
## Hub: the land servers it's running. land -> {"pid", "port", "io", "conn", "players", "ready", "idle"}
|
||||
var servers: Dictionary = {}
|
||||
var _link: TCPServer
|
||||
var _unclaimed: Array = [] ## links not yet saying which land they are
|
||||
## One-time passes, wherever a player is arriving: pass -> {"id", "t", "land"}
|
||||
var passes: Dictionary = {}
|
||||
|
||||
## Land server: the link to the hub.
|
||||
var _hub: StreamPeerTCP
|
||||
var _hub_link: Dictionary = {} ## {"conn": _hub, "buf": the partial line}
|
||||
|
||||
# --- setup (called by Net.start_server) ------------------------------------------------
|
||||
|
||||
## Called once a server is listening. `args` are the command-line flags.
|
||||
func server_started(args: Dictionary) -> void:
|
||||
land = String(args.get("land", ""))
|
||||
if not land.is_empty():
|
||||
hub_port = int(args.get("hub-port", Net.DEFAULT_PORT))
|
||||
_hub = StreamPeerTCP.new()
|
||||
_hub.connect_to_host("127.0.0.1", hub_port + LINK_PORT_OFFSET)
|
||||
_hub_link = {"conn": _hub, "buf": ""}
|
||||
return
|
||||
hub = true
|
||||
_link = TCPServer.new()
|
||||
var err := _link.listen(game_port() + LINK_PORT_OFFSET, "127.0.0.1")
|
||||
if err != OK:
|
||||
push_warning("[lands] couldn't open the private link on %d (error %d): no other lands this run" % [game_port() + LINK_PORT_OFFSET, err])
|
||||
_link = null
|
||||
|
||||
## Called as a server stops: stops every land server it started.
|
||||
func server_stopped() -> void:
|
||||
for l in servers:
|
||||
_send_land(l, {"t": "stop"})
|
||||
var pids: Array = servers.values().map(func(s): return int(s.pid))
|
||||
if not pids.is_empty():
|
||||
get_tree().create_timer(6.0).timeout.connect(func():
|
||||
for pid in pids:
|
||||
if pid != 0 and OS.is_process_running(pid):
|
||||
OS.kill(pid))
|
||||
servers.clear()
|
||||
_unclaimed.clear()
|
||||
if _link != null:
|
||||
_link.stop()
|
||||
_link = null
|
||||
if _hub != null:
|
||||
_hub.disconnect_from_host()
|
||||
_hub = null
|
||||
hub = false
|
||||
land = ""
|
||||
passes.clear()
|
||||
|
||||
func game_port() -> int:
|
||||
return int(Net.config.v("port")) if Net.config != null else Net.DEFAULT_PORT
|
||||
|
||||
## The worldlet this server runs.
|
||||
func here() -> String:
|
||||
return land if not land.is_empty() else String(Net.config.v("worldlet")) if Net.config != null else "valley"
|
||||
|
||||
## The port land `l` runs on: the hub's, then one up for each land after it
|
||||
## in the journey's order (data/worldlets: next).
|
||||
func port_for(l: String) -> int:
|
||||
if l == home():
|
||||
return hub_port if not land.is_empty() else game_port()
|
||||
var base := hub_port if not land.is_empty() else game_port()
|
||||
return base + 1 + maxi(_order().find(l), 0)
|
||||
|
||||
## The world's home land (the hub's).
|
||||
func home() -> String:
|
||||
return String(Net.config.v("worldlet")) if Net.config != null else "valley"
|
||||
|
||||
## Every land after home, in the order the journey reaches them.
|
||||
func _order() -> Array:
|
||||
var out: Array = []
|
||||
var at := home()
|
||||
for _i in range(16):
|
||||
var d: Dictionary = load("res://scripts/world/terrain.gd").load_worldlet(at)
|
||||
var nxt := ""
|
||||
for c in d.get("next", []):
|
||||
if c is Dictionary and not String(c.get("to", "")) in out and String(c.get("to", "")) != home():
|
||||
nxt = String(c.to)
|
||||
break
|
||||
if nxt.is_empty():
|
||||
break
|
||||
out.append(nxt)
|
||||
at = nxt
|
||||
return out
|
||||
|
||||
# --- passes -------------------------------------------------------------------------
|
||||
|
||||
## A one-time pass for player `id` to come into land `l`.
|
||||
func make_pass(id: String, l: String) -> String:
|
||||
var p := Crypto.new().generate_random_bytes(16).hex_encode()
|
||||
passes[p] = {"id": id, "t": 0.0, "land": l}
|
||||
return p
|
||||
|
||||
## Whether `p` lets player `id` in here (it's used up either way).
|
||||
func take_pass(p: String, id: String) -> bool:
|
||||
if not passes.has(p):
|
||||
return false
|
||||
var e: Dictionary = passes[p]
|
||||
passes.erase(p)
|
||||
return String(e.id) == id and float(e.t) < PASS_SECONDS
|
||||
|
||||
# --- the hub ------------------------------------------------------------------------
|
||||
|
||||
## Makes sure land `l` has a server (starting one if not). Calls `then`
|
||||
## (with "" or what went wrong) once it's listening.
|
||||
func ensure(l: String, then: Callable) -> void:
|
||||
if not hub:
|
||||
then.call("this isn't the hub")
|
||||
return
|
||||
if servers.has(l) and bool(servers[l].ready):
|
||||
servers[l].idle = 0.0
|
||||
then.call("")
|
||||
return
|
||||
if not servers.has(l):
|
||||
var why := _start(l)
|
||||
if not why.is_empty():
|
||||
then.call(why)
|
||||
return
|
||||
var waiting: Callable
|
||||
waiting = func(which: String):
|
||||
if which == l:
|
||||
land_ready.disconnect(waiting)
|
||||
then.call("")
|
||||
land_ready.connect(waiting)
|
||||
|
||||
func _start(l: String) -> String:
|
||||
var args := PackedStringArray(["--headless"])
|
||||
if not OS.has_feature("template"):
|
||||
args.append_array(["--path", ProjectSettings.globalize_path("res://")])
|
||||
args.append_array(["--", "--server", "--land", l, "--port", str(port_for(l)), "--hub-port", str(game_port()),
|
||||
"--config", ProjectSettings.globalize_path(Net.config.path), "--exit-with", str(OS.get_process_id())])
|
||||
for k in ["no-creatures", "debug-cheats"]:
|
||||
if Net._args.has(k):
|
||||
args.append("--" + k)
|
||||
if Net._args.has("host-id"):
|
||||
args.append_array(["--host-id", String(Net._args["host-id"])]) # (a hosted game: the host leaving stops it all)
|
||||
var p: Dictionary = OS.execute_with_pipe(OS.get_executable_path(), args, false)
|
||||
if p.is_empty():
|
||||
return "couldn't start the %s's server" % l
|
||||
var log := FileAccess.open(Net.config.path.get_base_dir().path_join("land-%s.log" % l), FileAccess.WRITE)
|
||||
servers[l] = {"pid": int(p.pid), "port": port_for(l), "io": p.stdio, "log": log, "conn": null,
|
||||
"players": 0, "ready": false, "idle": 0.0}
|
||||
print("[lands] starting the %s's server on UDP %d" % [l, port_for(l)])
|
||||
return ""
|
||||
|
||||
func _process(delta: float) -> void:
|
||||
for p in passes.keys():
|
||||
passes[p].t += delta
|
||||
if float(passes[p].t) > PASS_SECONDS:
|
||||
passes.erase(p)
|
||||
if hub:
|
||||
_hub_tick(delta)
|
||||
elif not land.is_empty():
|
||||
_land_tick()
|
||||
|
||||
func _hub_tick(delta: float) -> void:
|
||||
if _link != null:
|
||||
while _link.is_connection_available():
|
||||
var c := _link.take_connection()
|
||||
_unclaimed.append({"conn": c, "buf": ""})
|
||||
for u in _unclaimed.duplicate():
|
||||
var claimed := ""
|
||||
for msg in _read(u):
|
||||
if claimed.is_empty():
|
||||
if String(msg.get("t", "")) == "hello" and servers.has(String(msg.land)):
|
||||
claimed = String(msg.land)
|
||||
servers[claimed].conn = u.conn
|
||||
_unclaimed.erase(u)
|
||||
else:
|
||||
_from_land(claimed, msg) # (what came in the same read: "ready", most likely)
|
||||
if not claimed.is_empty():
|
||||
servers[claimed].buf = u.buf
|
||||
for l in servers.keys():
|
||||
var s: Dictionary = servers[l]
|
||||
_drain_output(s)
|
||||
if int(s.pid) != 0 and not OS.is_process_running(int(s.pid)):
|
||||
print("[lands] the %s's server stopped" % l)
|
||||
_drain_output(s)
|
||||
servers.erase(l)
|
||||
continue
|
||||
if s.conn != null:
|
||||
for msg in _read(s):
|
||||
_from_land(l, msg)
|
||||
s.idle = float(s.idle) + delta if int(s.players) == 0 and bool(s.ready) else 0.0
|
||||
if float(s.idle) > IDLE_STOP_SECONDS:
|
||||
print("[lands] nobody in the %s for %d s: stopping its server" % [l, int(IDLE_STOP_SECONDS)])
|
||||
_send_land(l, {"t": "stop"})
|
||||
s.idle = -INF # (asked once)
|
||||
|
||||
## A land server's output goes to land-<land>.log beside server.json.
|
||||
func _drain_output(s: Dictionary) -> void:
|
||||
if s.io == null:
|
||||
return
|
||||
for _i in range(16):
|
||||
var chunk: PackedByteArray = s.io.get_buffer(8192)
|
||||
if chunk.is_empty():
|
||||
break
|
||||
if s.log != null:
|
||||
s.log.store_string(chunk.get_string_from_utf8())
|
||||
s.log.flush()
|
||||
|
||||
func _from_land(l: String, msg: Dictionary) -> void:
|
||||
match String(msg.get("t", "")):
|
||||
"ready":
|
||||
servers[l].ready = true
|
||||
_send_land(l, {"t": "clock", "day": Net._world.day_night.day, "time": Net._world.day_night.time})
|
||||
_send_land(l, {"t": "tunnel", "dug": _tunnel_dug_here()})
|
||||
land_ready.emit(l)
|
||||
"players":
|
||||
servers[l].players = int(msg.n)
|
||||
"pass":
|
||||
# A player there is coming back here: let them in with this pass.
|
||||
passes[String(msg.pass)] = {"id": String(msg.id), "t": 0.0, "land": home()}
|
||||
"tunnel?":
|
||||
_send_land(l, {"t": "tunnel", "dug": _tunnel_dug_here()})
|
||||
"host_left":
|
||||
Net._host_left.call_deferred()
|
||||
|
||||
## Sends `msg` to land `l`'s server.
|
||||
func _send_land(l: String, msg: Dictionary) -> void:
|
||||
if not servers.has(l) or servers[l].conn == null:
|
||||
return
|
||||
var c: StreamPeerTCP = servers[l].conn
|
||||
c.poll()
|
||||
if c.get_status() == StreamPeerTCP.STATUS_CONNECTED:
|
||||
c.put_data((JSON.stringify(msg) + "\n").to_utf8_buffer())
|
||||
|
||||
## Hub: tells every land how far the cliff tunnel's dug (the Cove's sea
|
||||
## cave leads up it once it's through).
|
||||
func push_tunnel(dug: int) -> void:
|
||||
for l in servers:
|
||||
_send_land(l, {"t": "tunnel", "dug": dug})
|
||||
|
||||
func _tunnel_dug_here() -> int:
|
||||
var t: Node3D = Net._world.tunnel if Net._world != null else null
|
||||
return int(t.dug) if t != null else 0
|
||||
|
||||
## Hub: tells every land the clock (so there's one clock everywhere).
|
||||
func push_clock(day: int, time: float) -> void:
|
||||
for l in servers:
|
||||
_send_land(l, {"t": "clock", "day": day, "time": time})
|
||||
|
||||
## Hub: a pass for player `id` to go to land `l` (the land server learns it).
|
||||
func pass_to(l: String, id: String) -> String:
|
||||
var p := make_pass(id, l)
|
||||
_send_land(l, {"t": "pass", "pass": p, "id": id})
|
||||
passes.erase(p) # (it's the land server's to take, not ours)
|
||||
return p
|
||||
|
||||
# --- a land server --------------------------------------------------------------------
|
||||
|
||||
var _said_hello := false
|
||||
var _last_players := -1
|
||||
var tunnel_dug := -1 ## (land server) how far the hub's tunnel is dug, last asked
|
||||
|
||||
func _land_tick() -> void:
|
||||
if _hub == null:
|
||||
return
|
||||
_hub.poll()
|
||||
var st := _hub.get_status()
|
||||
if st == StreamPeerTCP.STATUS_CONNECTED:
|
||||
if not _said_hello:
|
||||
_said_hello = true
|
||||
send_hub({"t": "hello", "land": land})
|
||||
send_hub({"t": "ready"})
|
||||
var n := Net.players.size()
|
||||
if n != _last_players:
|
||||
_last_players = n
|
||||
send_hub({"t": "players", "n": n})
|
||||
for msg in _read(_hub_link):
|
||||
_from_hub(msg)
|
||||
elif st == StreamPeerTCP.STATUS_ERROR or (st == StreamPeerTCP.STATUS_NONE and _said_hello):
|
||||
print("[lands] lost the hub: saving and stopping")
|
||||
_hub = null
|
||||
Net.stop()
|
||||
get_tree().quit()
|
||||
|
||||
func _from_hub(msg: Dictionary) -> void:
|
||||
match String(msg.get("t", "")):
|
||||
"stop":
|
||||
print("[lands] the hub asked us to stop: saving")
|
||||
_hub = null
|
||||
Net.stop()
|
||||
get_tree().quit()
|
||||
"pass":
|
||||
passes[String(msg.pass)] = {"id": String(msg.id), "t": 0.0, "land": land}
|
||||
"clock":
|
||||
if Net._world != null:
|
||||
var dn: Node = Net._world.day_night
|
||||
var was_day: int = dn.day
|
||||
var was_t: float = dn.time
|
||||
var secs: float = ((int(msg.day) - was_day) + (float(msg.time) - was_t)) * dn.day_length
|
||||
if secs > 1.0:
|
||||
Net._world.skip_time(secs) # (catching up: a slept night, or time nobody was here)
|
||||
dn.day = int(msg.day)
|
||||
dn.time = float(msg.time)
|
||||
dn.apply(true)
|
||||
Net.push_clock()
|
||||
"tunnel":
|
||||
tunnel_dug = int(msg.dug)
|
||||
hub_message.emit(msg)
|
||||
|
||||
func send_hub(msg: Dictionary) -> void:
|
||||
if _hub != null and _hub.get_status() == StreamPeerTCP.STATUS_CONNECTED:
|
||||
_hub.put_data((JSON.stringify(msg) + "\n").to_utf8_buffer())
|
||||
|
||||
## Land server: a pass for player `id` to go back to the hub.
|
||||
func pass_home(id: String) -> String:
|
||||
var p := Crypto.new().generate_random_bytes(16).hex_encode()
|
||||
send_hub({"t": "pass", "pass": p, "id": id})
|
||||
return p
|
||||
|
||||
# --- the line protocol ------------------------------------------------------------------
|
||||
|
||||
## Whole JSON lines waiting on `link` ({"conn", "buf"}); keeps the rest.
|
||||
func _read(link: Dictionary) -> Array:
|
||||
var c: StreamPeerTCP = link.conn
|
||||
if c == null:
|
||||
return []
|
||||
c.poll()
|
||||
if c.get_status() != StreamPeerTCP.STATUS_CONNECTED:
|
||||
return []
|
||||
var n := c.get_available_bytes()
|
||||
if n > 0:
|
||||
var got: Array = c.get_data(n)
|
||||
if int(got[0]) == OK:
|
||||
link.buf = String(link.get("buf", "")) + (got[1] as PackedByteArray).get_string_from_utf8()
|
||||
var out: Array = []
|
||||
var buf := String(link.get("buf", ""))
|
||||
while buf.contains("\n"):
|
||||
var line := buf.get_slice("\n", 0)
|
||||
buf = buf.substr(line.length() + 1)
|
||||
var m: Variant = JSON.parse_string(line)
|
||||
if m is Dictionary:
|
||||
out.append(m)
|
||||
link.buf = buf
|
||||
return out
|
||||
Reference in New Issue
Block a user