Download page: forward UDP 24243 too for the Cove; test_net_lands can run against an exported build (EMBERWILD_SERVER_BIN)

README.md

@@ -16,7 +16,7 @@ addon SDK with guard rails.
 ## Status
 See `docs/ROADMAP.md` for milestones and `docs/ARCHITECTURE.md` for the design.
 
-**Emberwild 0.4.0** is released (download page and player guide:
+**Emberwild 0.5.0** is released (download page and player guide:
 https://emberwild-95k.pages.dev, builds on the Gitea releases). Built so far:
 - M0-M1: the island, survival, crafting, building, weather, wildlife, hunting, fishing.
 - M2: self-hosted multiplayer (Host Game, dedicated servers, rules, chat, admin).
@@ -28,10 +28,12 @@ https://emberwild-95k.pages.dev, builds on the Gitea releases). Built so far:
 - M4 so far: packaged builds, the update check, music, ambience, sound effects
   and creature voices (`assets/audio/CREDITS.md`), the trailer and help pages,
   the map (N) and compass.
-- W0-W3, J1 (`docs/WORLDLETS_DESIGN.md`): worldlets as data, the Cove (beach,
+- W0-W3, J1, J3 (`docs/WORLDLETS_DESIGN.md`): worldlets as data, the Cove
-  pier, sea fishing), and the cliff tunnel between them, with a save file per
+  (beach, pier, sea fishing, a stream), and the cliff tunnel between them,
-  worldlet (single-player).
+  with a save file per worldlet; on a server, a server per land (the Valley's
-Next: J3, the journey on a server ("spread out"), then the Highlands.
+  starts the Cove's on the next UDP port), with chat, the player list,
+  admin commands and sleep across lands, and one clock everywhere.
+Next: J2 (each tunnel's own gate and supplies), then the Highlands (by sail).
 Running from the source, `godot --path . -- --dev-worldlets` lets New World
 start in any worldlet, to try one directly.
 

data/fish.json

@@ -44,6 +44,20 @@
           "min_depth": 2.2
         }
       ]
+    },
+    "stream": {
+      "min_depth": 0.3,
+      "bite_wait": [
+        8.0,
+        18.0
+      ],
+      "fish": [
+        {
+          "id": "trout",
+          "weight": 100,
+          "dawn_dusk": 100
+        }
+      ]
     }
   }
 }

data/worldlets/cove.json

@@ -1,5 +1,5 @@
 {
-  "_doc": "The Cove (docs/WORLDLETS_DESIGN.md §5, W3): the second worldlet, reached from the Valley down the cliff tunnel (J1). Low hills run down to a wide sandy bay with a pier (scripts/world/pier.gd) for sea fishing; a small pond inland; mountains behind. Not a start: you get here on the journey.",
+  "_doc": "The Cove (docs/WORLDLETS_DESIGN.md §5, W3): the second worldlet, reached from the Valley down the cliff tunnel (J1). Low hills run down to a wide sandy bay with a pier (scripts/world/pier.gd) for sea fishing; a small pond inland; a stream from a spring under the mountains down to the bay (a 'stream' block: its points, spring first, in world metres); mountains behind. Not a start: you get here on the journey.",
   "id": "cove",
   "name": "Cove",
   "description": "Low hills running down to a sheltered sandy bay, with a pier out over the water for sea fishing.",
@@ -11,6 +11,7 @@
     {"type": "rim", "play_radius": 100.0, "rim_width": 30.0, "mountain_height": 52.0, "rim_warp": 14.0, "wall_frac": 0.45},
     {"type": "beach", "angle_deg": 90.0, "half_width_deg": 55.0, "fade_deg": 22.0, "shore_offset": -16.0, "slope": 0.08, "current_out": 22.0, "wall_out": 36.0},
     {"type": "lake", "center": [-30.0, -40.0], "radius": 11.0, "water_level": -2.6},
+    {"type": "stream", "points": [[46.0, -80.0], [34.0, -48.0], [40.0, -14.0], [30.0, 22.0], [36.0, 52.0], [33.0, 78.0], [33.0, 104.0]], "width": 2.4, "depth": 0.6},
     {"type": "ocean_edge"}
   ],
   "climate": {"snowline": 42.0},

docs/HOSTING.md

@@ -113,15 +113,22 @@ To check it works: `tailscale ping <server name>` from the friend's
 computer.
 
 ### Port forwarding
-On your router, forward **UDP 24242** to the server computer's local
+On your router, forward **UDP 24242 and 24243** to the server computer's
-address (give that computer a fixed local address first). Friends join
+local address (give that computer a fixed local address first). Friends
-with your public IP address. It needs no extra software, but your home IP
+join with your public IP address. It needs no extra software, but your
-and that port are public, so set a `password`.
+home IP and those ports are public, so set a `password`.
+
+Why two: each land of the journey runs as its own server on the next port
+up (24243 is the Cove's, when the server's on 24242). The server players
+join (the Valley's) starts it when someone first goes there and stops it
+when it's been empty a couple of minutes; everyone still joins on 24242.
+Host Game and the server's log both say which ports to forward. With
+Tailscale, or on the same Wi-Fi, there's nothing to do.
 
 ### A cloud server
 Any small Linux server works (it needs little: a couple of GB of memory).
-Install Godot, clone the game, use the systemd file, and open UDP 24242 in
+Install Godot, clone the game, use the systemd file, and open UDP 24242
-the provider's firewall.
+and 24243 in the provider's firewall.
 
 ## Troubleshooting
 - **"Different game version":** the server and the player are on different
@@ -132,6 +139,11 @@ the provider's firewall.
 - **"Port 24242 is already in use":** another server is running on this
   computer (a dedicated one, or a Host Game that didn't stop). Stop it, or
   host on another port.
+- **"Lost the connection to the Cove":** that land's server stopped (it
+  logs to `land-cove.log` beside `server.json`). Join again: the server
+  starts it afresh and sends you back there.
+- **Stuck going on to the Cove from the internet:** UDP 24243 isn't
+  forwarded (see above).
 - **The server says the game's scripts didn't load:** it's a fresh copy
   that hasn't been imported, or Godot is older than 4.7. `run_server.sh`
   handles both; see `docs/SETUP_ON_NEW_MACHINE.md`.

docs/ROADMAP.md

@@ -91,7 +91,9 @@ phases M2.0-M2.7).
   compass along the top (0.4.0, Gitea issue #1).
 - More places: the worldlets and the journey (`docs/WORLDLETS_DESIGN.md`).
   *Done (0.4.0):* W0-W3 and J1, the Cove reached down the cliff tunnel
-  (single-player). Next J3 (multiplayer, "spread out"), then J2/J4.
+  (single-player). *(0.5.0):* J3, the journey on a server: a server per
+  land, players in different lands at once, chat, the player list, admin
+  and sleep across lands. Next J2, then J4 (the Highlands by sail).
 - Audio, music, weather. *Done (0.2.0-0.2.1):* mood music (calm, night,
   storm, danger, boss) that crossfades with what's happening, ambience (CC0
   birdsong, crickets, owls, fire), sound effects for every action (Kenney

docs/WORLDLETS_DESIGN.md

@@ -1,7 +1,72 @@
 # Worldlets design
 
-Status: **W0-W3 and J1 built** (the Cove without its stream yet; the
+Status: **W0-W3, J1 and J3a built**: the Cove (with its stream), the cliff
-tunnel single-player only); the rest is planned.
+tunnel, and the journey on a server (a server per land; chat and the
+player list across lands are J3b). The rest is planned.
+
+*As built in J3a (a server per land):*
+- `scripts/net/lands.gd` (autoload `Lands`): the server players join is the
+  hub. `Lands.ensure(land)` starts a land server (`--server --land cove
+  --port <hub+1..> --hub-port <hub>`, same config and world folder, output
+  to `land-<land>.log` beside server.json) and waits for it to say it's
+  listening. Hub and land servers talk over TCP on 127.0.0.1, port hub +
+  100, one JSON object per line: hello/ready, the player count, the clock
+  (the hub's, every 10 s: one clock everywhere), how far the tunnel's dug,
+  one-time passes, "stop", "host_left". A land server stops after 2 minutes
+  empty, when the hub stops, or if it loses the hub.
+- A land server's saves: `Saves.land` makes it load and save its own
+  worldlet's file (`worldlets/cove.json`) in the hub's world folder.
+  Characters (`players/<id>.json`) are shared, and say which land they're
+  in (`land`) and, mid-crossing, where they'll come out (`arrive`).
+- Crossing (`PlayerNet.cross`): the server saves the character as heading
+  there, makes sure the other server's up, and sends the game
+  `_s2c_travel {land, port, pass}`; the game drops the connection quietly
+  and joins that port with the pass (`Net.join(address, "", pass)`), checked
+  after the identity proof: a land server lets nobody in without one. The
+  world reloads on `Net.arrived`. Joining the hub when your character's in
+  another land sends you on there; a crossing that fails goes back to the
+  title. A hosted game: the host crossing doesn't stop the hub; the host
+  leaving the game from another land stops everything.
+- The tunnel online: built on the server and in every game. The server
+  decides blows on its faces (`"hit"` finds them by uid), props
+  (`"tunnel_prop"`), going in and out (`"tunnel_go"`: a server teleport;
+  the move check allows the tunnel only from inside it) and the crossings
+  (`"cross"`), and tells everyone how it stands (`_s2c_tunnel`; it's in the
+  shared state a joining player gets, and saved with the Valley).
+- `tests/test_net_lands.gd`: Alice digs and props online, lights it,
+  crosses to the Cove (bag and day kept) while Bob stays in the Valley,
+  comes back up, then leaves from the Cove and rejoining sends her there.
+
+*As built in J3b (everyone, everywhere):*
+- Chat and server messages go to every land (`Chat._all` relays through
+  the hub, `Lands.relay_line`).
+- The hub keeps the **roster** (everyone on every land, with their land);
+  every land and every player's game gets it (`Net.roster`,
+  `Net.everyone()`): the pause menu's player list and `/players` show
+  where each player is.
+- Commands typed in another land run **on the hub** (it alone keeps
+  server.json) and answer back there; after one that changes server.json
+  (`/set`, `/ban`, `/admin`, `/friend`...) every land reloads it.
+  `/kick` and `/ban` reach the land the player's in; `/weather`, `/save`
+  and `/backup` reach every land.
+- **Sleep needs everyone in every land:** land servers report their beds,
+  the hub decides, and every land passes the night together. Getting into
+  bed while others are up: "You're in bed: waiting for everyone else to go
+  to bed (1 of 2 asleep)", and every land hears "Bob is in bed (1 of 2
+  asleep)" in chat.
+- `tests/test_net_lands.gd` covers it all, Alice in the Cove and Bob in the
+  Valley.
+
+*As built in J3c:*
+- A land server that stops (crashed, or killed) tells its players "Lost the
+  connection to the Cove. Join the server again to carry on there."; the
+  hub notices it's gone (even mid-join) and joining again starts it afresh
+  and sends them back (their characters were saved by its autosave).
+- The extra ports: `Lands.extra_ports()` / `ports_text()` ("UDP 24242 and
+  24243 (the Cove)"), on the Host page, in the "You're hosting" message, in
+  a hub's start-up log, and in docs/HOSTING.md.
+- Tested in `test_net_lands.gd` (the Cove's server killed, Alice rejoins)
+  and `test_worldlet_pick.gd` (the Host page).
 
 *As built in J1:*
 - `scripts/world/tunnel.gd`: the seam (an outcrop on the clifftop strip,
@@ -52,9 +117,14 @@ its decisions.
 - Tests: `test_cove` (walk onto the pier, catch a mackerel off its end, cod
   only in deep water), and the Cove in `test_terrain_edges` and
   `test_boundary`.
-- Still to do: the stream (it needs water that runs downhill, which the
+- The stream (after 0.4.0): a `stream` block, a line of points from a
-  one flat water surface can't do: its own ribbon of water, planned with
+  spring under the mountains to the bay. Its water surface is the running
-  the Cove's sea cave when the tunnel arrives).
+  minimum of the ground along it (so it only ever runs downhill, down to
+  sea level), the bed is cut 0.6 m under that and the banks rise a little
+  above it; its water is its own ribbon mesh (`terrain._stream_mesh()`),
+  murkier than the lake. `water_at()` answers "stream" (trout bite there,
+  `data/fish.json`), the map shows it, and scenery, the den, the barrow and
+  the stones keep clear of it (`terrain.near_stream()`).
 
 *As built in W2:*
 - `lake` blocks can repeat: every lake and pond is its own body
@@ -358,8 +428,10 @@ tunnel goes **down**, inside the cliff, from the clifftop to the shore.
   meat, clay jars) becomes what you carry between them.
 - **Your bases stay** where you built them: each worldlet keeps its own
   save file, so your Valley hut, chests and jars are waiting.
-- **Time:** a worldlet you're not in stands still (as a server does with
+- **Time:** there's one clock for every land (see the decisions below). A
-  nobody on), so a base you left doesn't starve or get raided.
+  worldlet you're not in doesn't run, but catches up on the time when you
+  come back, as after a night's sleep; nothing roams it meanwhile, so a base
+  you left isn't raided.
 
 ### Building it (phases)
 | Phase | Delivers | Done when |
@@ -390,17 +462,45 @@ A server today runs one island. Options:
   bites can make you sick, and bog, mist and the like. Others in the same
   spirit per biome (to design with each worldlet).
 - **Multiplayer: spread out.** Each player goes where they like; the server
-  runs every worldlet someone is in, and the rest stand still. Built in J3,
+  runs every worldlet someone is in. Built in J3, after single-player travel
-  after single-player travel works. What that means for the code:
+  works.
-  - one server process holds several worldlet scenes, each with its own
+- **A server per land (Paul, Nov 2026)**, rather than one process holding
-    clock, weather, creatures and save file;
+  several worldlets (which would mean making every network module, the
-  - every player belongs to one worldlet at a time, and the server only
+  saves and the actions handle several worlds at once):
-    sends them that worldlet's world, creatures, sounds and chat-free events
+  - the Valley's server is the **hub**: the address everyone joins. It
-    (chat and the player list stay server-wide);
+    starts a server for another land (the next UDP port: 24243 the Cove,
-  - a crossing moves a player from one worldlet to another (save their
+    and so on) when someone first goes there, and stops it a couple of
-    place, load or wake the other worldlet, send them its world);
+    minutes after its last player leaves;
-  - sleep: "everyone in bed" counts the players in that worldlet only;
+  - each land server is today's server, with its own worldlet, save file,
-  - the Old Stag and other bosses scale with the players in their worldlet.
+    weather and creatures; it keeps a private link to the hub on the host
+    machine;
+  - characters live in one shared folder. A crossing saves your character
+    first, marks you as on your way, and hands your game the land's port
+    and a one-time pass; your game reconnects there ("On to the Cove...").
+    Nothing can be lost or copied on the way: crash mid-way and you come
+    back where you were going. Joining the hub when your character's in
+    another land sends you straight on there;
+  - chat, the player list (with where each player is) and admin commands
+    go through the hub to every land;
+  - the tunnel belongs to the Valley's server; the Cove's asks the hub
+    whether it's dug through;
+  - from the internet, friends need those extra ports forwarded too (on a
+    home network, nothing to do). The Host page will list them;
+  - the Old Stag and other bosses scale with the players in their land.
+  - Phases: **J3a** the tunnel online, land servers on demand, the
+    crossing and the shared characters; **J3b** chat, the player list and
+    admin across lands; **J3c** the awkward cases (a land server crashing,
+    rejoining mid-crossing, the Host page's ports).
+- **One clock for every land (Paul, Nov 2026).** The day and hour are the
+  same everywhere, so the lands never drift apart:
+  - sleeping until morning needs **everyone, in every land**, in bed (on a
+    server the hub counts them all, and every land skips to morning
+    together);
+  - a land nobody is in doesn't run, but when someone arrives it catches up
+    on the time since anyone was last there, as after a night's sleep:
+    kilns and smelters work, fires burn down, food goes off, trees and
+    berries grow back. (Built for single-player already: `world.catch_up()`.)
+    No creatures roam it meanwhile, so a base you left isn't raided.
 - **Boats: one each, no passengers.** A boat belongs to whoever built it
   (like a bed): only the owner, and their friends under the server's locks
   rule, can sail it, and nobody else can dismantle it. It stays moored where
@@ -434,7 +534,7 @@ One worldlet, a dedicated server on the M5 Pro, never pausing: about
 creatures, weather and pickups around them. So with *spread out*, the worst
 case of 8 players in all 5 worldlets is about five of today's servers in
 one process: roughly 1.4 GB and a little over half a core before players,
-and worldlets with nobody in them stand still and cost next to nothing.
+and worldlets with nobody in them aren't running and cost nothing (each starts its own server when someone goes there).
 Comfortable on the home Mac; a small cloud server (2 GB) would be tight.
 
 ### (Answered) questions

export_presets.cfg

@@ -29,8 +29,8 @@ application/icon_interpolation=4
 application/bundle_identifier="com.pbailey.emberwild"
 application/signature=""
 application/app_category="Games"
-application/short_version="0.4.0"
+application/short_version="0.5.0"
-application/version="0.4.0"
+application/version="0.5.0"
 application/copyright=""
 display/high_res=true
 codesign/codesign=1
@@ -89,8 +89,8 @@ application/modify_resources=false
 application/icon=""
 application/console_wrapper_icon=""
 application/icon_interpolation=4
-application/file_version="0.4.0"
+application/file_version="0.5.0"
-application/product_version="0.4.0"
+application/product_version="0.5.0"
 application/company_name=""
 application/product_name="Emberwild"
 application/file_description="Emberwild"

project.godot

@@ -19,7 +19,7 @@ config/description="Low-poly survival game — Valheim look, Rust depth, self-ho
 run/main_scene="res://scenes/title.tscn"
 config/features=PackedStringArray("4.7", "Forward Plus")
 config/icon="res://icon.svg"
-config/version="0.4.0"
+config/version="0.5.0"
 
 [autoload]
 
@@ -31,6 +31,7 @@ Hints="*res://scripts/core/hints.gd"
 Updates="*res://scripts/core/updates.gd"
 Saves="*res://scripts/core/saves.gd"
 Net="*res://scripts/net/net.gd"
+Lands="*res://scripts/net/lands.gd"
 WorldNet="*res://scripts/net/world_net.gd"
 PlayerNet="*res://scripts/net/player_net.gd"
 CreatureNet="*res://scripts/net/creature_net.gd"

scripts/core/saves.gd

@@ -102,8 +102,14 @@ func read_meta(id: String) -> Dictionary:
 # saves are unchanged; the others are worldlets/<id>.json. meta.json's
 # "worldlet" is where you are now, so that's the one loaded.
 
+## A land server (J3, `--land cove`) runs one worldlet of a server's world:
+## this is that worldlet ("" = whatever the world's meta says).
+var land := ""
+
 ## The worldlet world `id` is being played in now.
 func worldlet_of(id: String) -> String:
+	if not land.is_empty():
+		return land
 	return String(read_meta(id).get("worldlet", "valley"))
 
 ## The worldlet world `id` began in (its world.json).

scripts/creatures/den.gd

@@ -90,7 +90,7 @@ func _check_site(world: Node3D, p: Vector2) -> Vector3:
 	var hs: Array[float] = []
 	for d in [Vector2(-1, -1), Vector2(1, -1), Vector2(-1, 1), Vector2(1, 1), Vector2.ZERO]:
 		hs.append(terrain.sample_height(p.x + d.x * 4.0, p.y + d.y * 4.0))
-	if hs.max() - hs.min() > 2.2 or hs.min() < terrain.water_level + 1.0:
+	if hs.max() - hs.min() > 2.2 or hs.min() < terrain.water_level + 1.0 or terrain.near_stream(p.x, p.y, 7.0):
 		return Vector3.INF
 	# Trees and boulders in the way are cleared (_clear_area); just avoid
 	# the thickest woods. Counted by position, because their colliders

scripts/net/chat.gd

@@ -57,6 +57,11 @@ func _c2s_say(text: String) -> void:
 	var who: String = Net.players[peer].name
 	if text.begins_with("/"):
 		print("[server] %s: %s" % [who, text])
+		if not Lands.land.is_empty():
+			# (Another land's server: commands run on the hub, which keeps
+			# server.json, and answers back here.)
+			Lands.send_hub({"t": "cmd", "line": text.substr(1), "id": String(Net.players[peer].id), "name": who, "peer": peer})
+			return
 		run(text.substr(1), peer)
 		return
 	# Plain chat only: a line every GAP seconds, so nobody can flood it.
@@ -68,22 +73,44 @@ func _c2s_say(text: String) -> void:
 	print("[chat] %s: %s" % [who, text])
 	_all("%s: %s" % [who, text], "chat")
 
-func _all(text: String, kind: String) -> void:
+## A line for everyone here, and (`relay`) in every other land too (J3b).
+func _all(text: String, kind: String, relay: bool = true) -> void:
 	if kind == "server":
 		print("[server] ", text)
 	for peer in Net.players:
 		_s2c_line.rpc_id(peer, text, kind)
+	if relay:
+		Lands.relay_line(text, kind)
+
+## A command typed by someone in another land (J3b): who they are, and where
+## to send the answer. `run()` sees them as REMOTE.
+const Terrain = preload("res://scripts/world/terrain.gd")
+const REMOTE := -1
+var _caller: Dictionary = {}
+
+func run_remote(line: String, caller: Dictionary) -> void:
+	print("[server] %s (in the %s): /%s" % [caller.name, caller.land, line])
+	_caller = caller
+	run(line, REMOTE)
+	_caller = {}
 
 ## An answer to whoever gave the command (peer 0 = the console).
 func _reply(peer: int, text: String) -> void:
 	if peer == 0:
 		print(text)
+	elif peer == REMOTE:
+		Lands.tell_land(String(_caller.land), {"t": "reply", "peer": int(_caller.peer), "text": text})
 	else:
 		_s2c_line.rpc_id(peer, text, "reply")
 
 func _is_admin(peer: int) -> bool:
+	if peer == REMOTE:
+		return Net.config.is_admin(String(_caller.id))
 	return peer == 0 or (Net.players.has(peer) and Net.config.is_admin(String(Net.players[peer].id)))
 
+## Another land's server should know: this command changed server.json.
+const CHANGES_CONFIG := ["friend", "unfriend", "ban", "unban", "admin", "set", "release-name"]
+
 ## The player id a name belongs to (online or reserved), or "".
 func _id_of(n: String) -> String:
 	var peer := Net.peer_by_name(n)
@@ -102,16 +129,24 @@ func run(line: String, peer: int) -> void:
 	if cmd in ADMIN_ONLY and not _is_admin(peer):
 		_reply(peer, "Only admins can use /%s" % cmd)
 		return
-	var me: String = String(Net.players[peer].id) if Net.players.has(peer) else ""
+	var me: String = String(Net.players[peer].id) if Net.players.has(peer) else String(_caller.get("id", ""))
-	var by: String = String(Net.players[peer].name) if Net.players.has(peer) else "The server"
+	var by: String = String(Net.players[peer].name) if Net.players.has(peer) else String(_caller.get("name", "The server"))
+	_run_cmd(cmd, parts, rest, arg, peer, me, by)
+	if cmd in CHANGES_CONFIG:
+		Lands.tell_lands({"t": "config"})
+
+func _run_cmd(cmd: String, parts: PackedStringArray, rest: String, arg: String, peer: int, me: String, by: String) -> void:
 	match cmd:
 		"help":
 			_reply(peer, "Commands: /players /rules /friend <name> /unfriend <name> /friends" +
 				("  ·  admin: /kick /ban /unban /admin /save /backup /backups /time 08:00 /weather <state|auto> /set <rule> <value> /say /release-name" if _is_admin(peer) else ""))
 		"players":
+			# Everyone, in every land (J3b: the hub's roster), with where they are.
 			var names: Array[String] = []
-			for p in Net.players.values():
+			var many := Lands.roster.any(func(e): return String(e.land) != Lands.here())
-				names.append(String(p.name) + (" (admin)" if Net.config.is_admin(String(p.id)) else ""))
+			for p in (Lands.roster if not Lands.roster.is_empty() else Lands._here_list()):
+				names.append(String(p.name) + (" (admin)" if Net.config.is_admin(String(p.id)) else "")
+					+ (" in the %s" % Terrain.worldlet_name(String(p.land)) if many else ""))
 			_reply(peer, "%d online: %s" % [names.size(), ", ".join(names)])
 		"rules":
 			var c: RefCounted = Net.config
@@ -142,10 +177,14 @@ func run(line: String, peer: int) -> void:
 			_reply(peer, "Your friends: %s" % (", ".join(names) if not names.is_empty() else "nobody yet (/friend <name>)"))
 		"kick":
 			var kp := Net.peer_by_name(arg)
-			if kp == 0:
+			var away := Lands.land_of_name(arg) if kp == 0 else ""
+			if kp == 0 and (away.is_empty() or away == Lands.here()):
 				_reply(peer, "Nobody called '%s' is online" % arg)
 				return
+			if kp != 0:
 				Net.kick(kp, "You were kicked by %s" % by)
+			else:
+				Lands.tell_land(away, {"t": "kick", "name": arg, "reason": "You were kicked by %s" % by})
 			_all("%s was kicked" % arg, "server")
 		"ban":
 			var bid := _id_of(arg)
@@ -156,6 +195,8 @@ func run(line: String, peer: int) -> void:
 			var bp := Net.peer_by_name(arg)
 			if bp != 0:
 				Net.kick(bp, "You were banned by %s" % by)
+			elif not Lands.land_of_name(arg).is_empty():
+				Lands.tell_land(Lands.land_of_name(arg), {"t": "kick", "name": arg, "reason": "You were banned by %s" % by})
 			_all("%s was banned" % arg, "server")
 		"unban":
 			var uid: String = Net.config.name_owner(arg)
@@ -173,9 +214,11 @@ func run(line: String, peer: int) -> void:
 				_reply(ap, "%s made you an admin (/help for the commands)" % by)
 		"save":
 			WorldNet.save()
+			Lands.tell_lands({"t": "save"})
 			_reply(peer, "Saved")
 		"backup":
 			WorldNet.save()
+			Lands.tell_lands({"t": "save"})
 			var b: String = WorldNet.backup("by %s" % by)
 			_reply(peer, "Backed up as %s (%d kept)" % [b, WorldNet.list_backups().size()] if not b.is_empty() else "Nothing to back up yet")
 		"backups":
@@ -198,6 +241,7 @@ func run(line: String, peer: int) -> void:
 				_reply(peer, "Use /weather %s or auto" % "|".join(PackedStringArray(states)))
 				return
 			Net.set_weather("" if arg == "auto" else arg)
+			Lands.tell_lands({"t": "weather", "state": "" if arg == "auto" else arg})
 			_all("%s set the weather to %s" % [by, arg], "server")
 		"set":
 			if parts.size() < 3:

scripts/net/lands.gd

@@ -0,0 +1,534 @@
+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", ""))
+	roster = []
+	if not Net.players_changed.is_connected(rebuild_roster):
+		Net.players_changed.connect(rebuild_roster)
+	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
+	elif not _order().is_empty():
+		print("[lands] other lands start on demand. Players over the internet need %s forwarded" % ports_text(home(), game_port()))
+
+## 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:
+	return journey_from(home())
+
+## The lands a server whose home is `home` and whose port is `base` may run,
+## after home: [[land, port]] (24243 for the Cove when the server's 24242).
+## Friends playing over the internet need these forwarded too.
+static func extra_ports(home_land: String, base: int) -> Array:
+	var out: Array = []
+	var i := 1
+	for l in journey_from(home_land):
+		out.append([l, base + i])
+		i += 1
+	return out
+
+## "UDP 24242 and 24243 (the Cove)": what to forward for a server on `base`.
+static func ports_text(home_land: String, base: int) -> String:
+	var extra := extra_ports(home_land, base)
+	if extra.is_empty():
+		return "UDP %d" % base
+	var T: Script = load("res://scripts/world/terrain.gd")
+	var parts: Array[String] = []
+	for e in extra:
+		parts.append("%d (the %s)" % [int(e[1]), T.worldlet_name(String(e[0]))])
+	return "UDP %d and %s" % [base, ", ".join(parts)]
+
+static func journey_from(home_land: String) -> Array:
+	var out: Array = []
+	var at := home_land
+	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_land \
+					and not load("res://scripts/world/terrain.gd").load_worldlet(String(c.get("to", ""))).is_empty():
+				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 int(servers[l].pid) != 0 and not OS.is_process_running(int(servers[l].pid)):
+		print("[lands] the %s's server has gone: starting it again" % l)
+		servers.erase(l)   # (crashed, and not noticed yet: start afresh)
+	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)
+			rebuild_roster()
+			PlayerNet.beds_changed()
+			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()
+		"roster":
+			servers[l].list = msg.get("list", [])
+			rebuild_roster()
+		"line":
+			# Chat from that land: everyone here, and every other land.
+			Chat._all(String(msg.text), String(msg.kind), false)
+			for other in servers:
+				if other != l:
+					_send_land(other, msg)
+		"cmd":
+			Chat.run_remote(String(msg.line), {"id": String(msg.id), "name": String(msg.name), "land": l, "peer": int(msg.peer)})
+		"beds":
+			servers[l].beds = [int(msg.alive), int(msg.asleep)]
+			# Tell the lands the running total (minus their own), so each can
+			# say "N of M asleep", then see if the night passes.
+			_push_bed_totals()
+			PlayerNet.beds_changed()
+
+## 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 or _roster_dirty:
+			_last_players = n
+			_roster_dirty = false
+			send_hub({"t": "players", "n": n})
+			send_hub({"t": "roster", "list": _here_list()})
+		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)
+		"roster":
+			roster = msg.get("list", [])
+			Net.push_roster()
+		"line":
+			Chat._all(String(msg.text), String(msg.kind), false)
+		"reply":
+			if Net.players.has(int(msg.peer)):
+				Chat._s2c_line.rpc_id(int(msg.peer), String(msg.text), "reply")
+		"kick":
+			var kp: int = Net.peer_by_name(String(msg.name))
+			if kp != 0:
+				Net.kick(kp, String(msg.reason))
+		"config":
+			Net.reload_config()
+			Net.broadcast_rules()
+		"weather":
+			Net.set_weather(String(msg.state))
+		"save":
+			WorldNet.save()
+		"night":
+			PlayerNet.pass_night_here(float(msg.secs))
+		"beds_total":
+			PlayerNet._hub_beds = [int(msg.alive), int(msg.asleep)]
+	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())
+
+# --- everyone, everywhere (J3b) ------------------------------------------------------------
+
+## Everyone on every land: [{"name", "id", "land", "admin"}]. The hub builds
+## it from its own players and what each land reports; every land and every
+## player's game gets a copy (Net.roster), for the player list and /players.
+var roster: Array = []
+var _roster_dirty := false
+
+## The players on this server, as the roster lists them.
+func _here_list() -> Array:
+	var out: Array = []
+	for p in Net.players.values():
+		out.append({"name": String(p.name), "id": String(p.id), "land": here(), "admin": bool(p.get("admin", false))})
+	return out
+
+## Hub: the roster again (its players changed, or a land's did), sent out.
+func rebuild_roster() -> void:
+	if not hub:
+		if not land.is_empty():
+			_roster_dirty = true   # (a land server: tell the hub, next tick)
+		return
+	var out: Array = _here_list()
+	for l in servers:
+		for e in servers[l].get("list", []):
+			var e2: Dictionary = (e as Dictionary).duplicate()
+			e2.land = l
+			out.append(e2)
+	roster = out
+	Net.push_roster()
+	for l in servers:
+		_send_land(l, {"t": "roster", "list": out})
+
+## The land a player called `n` is in ("" = not on anywhere).
+func land_of_name(n: String) -> String:
+	for e in roster:
+		if String(e.name).to_lower() == n.to_lower():
+			return String(e.land)
+	return ""
+
+## Chat or a server message, from here to every other land.
+func relay_line(text: String, kind: String) -> void:
+	if hub:
+		for l in servers:
+			_send_land(l, {"t": "line", "text": text, "kind": kind})
+	elif not land.is_empty():
+		send_hub({"t": "line", "text": text, "kind": kind})
+
+## Hub: sends `msg` to every land.
+func tell_lands(msg: Dictionary) -> void:
+	for l in servers:
+		_send_land(l, msg)
+
+## Hub: sends `msg` to land `l`.
+func tell_land(l: String, msg: Dictionary) -> void:
+	_send_land(l, msg)
+
+## Hub: tells each land the alive/asleep everywhere BUT that land, so a land
+## server can show the right "N of M" and know when all are abed.
+func _push_bed_totals() -> void:
+	var here_alive: int = PlayerNet._alive().size()
+	var here_asleep: int = PlayerNet._alive().filter(func(q): return q.in_bed).size()
+	for l in servers:
+		var a := here_alive
+		var s := here_asleep
+		for other in servers:
+			if other != l:
+				var b: Array = servers[other].get("beds", [0, 0])
+				a += int(b[0])
+				s += int(b[1])
+		_send_land(l, {"t": "beds_total", "alive": a, "asleep": s})
+
+## Hub: how many are alive, and how many asleep, in every other land.
+func beds_elsewhere() -> Array:
+	var alive := 0
+	var asleep := 0
+	for l in servers:
+		var b: Array = servers[l].get("beds", [0, 0])
+		alive += int(b[0])
+		asleep += int(b[1])
+	return [alive, asleep]
+
+## 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

scripts/net/lands.gd.uid

@@ -0,0 +1 @@
+uid://cl2iw0a328ja8

scripts/net/net.gd

@@ -32,7 +32,7 @@ signal clock(day: int, time: float)    ## the server's time of day
 const Identity = preload("res://scripts/net/identity.gd")
 const ServerConfig = preload("res://scripts/net/server_config.gd")
 
-const PROTOCOL := 16  ## 16: worldlets (the Cove), sea fish (mackerel, cod); 3: shared world; 4: the server decides; 5: wildlife; 6: rules and chat (M2.6); 7: the alpha, broken doors; 8: the bear; 9: crows and foxes; 10: the barrow (P3); 11: food spoilage, lightning (P4); 12: the standing stones and the Old Stag (P5); 13: sounds sent to players nearby (sfx.gd); 14: dropping items, any bag row in hand, new items (jar, bedroll, necklace, bear cloak, rug, pemmican); 15: placed lights (candle, torch stand)
+const PROTOCOL := 17  ## 17: lands on a server (crossings, the tunnel online, the roster); 16: worldlets (the Cove), sea fish (mackerel, cod); 3: shared world; 4: the server decides; 5: wildlife; 6: rules and chat (M2.6); 7: the alpha, broken doors; 8: the bear; 9: crows and foxes; 10: the barrow (P3); 11: food spoilage, lightning (P4); 12: the standing stones and the Old Stag (P5); 13: sounds sent to players nearby (sfx.gd); 14: dropping items, any bag row in hand, new items (jar, bedroll, necklace, bear cloak, rug, pemmican); 15: placed lights (candle, torch stand)
 const DEFAULT_PORT := 24242
 const HANDSHAKE_TIMEOUT := 10.0
 const JOIN_TIMEOUT := 20.0             ## includes the server building its terrain on first join
@@ -191,6 +191,10 @@ func start_server(config_path: String, overrides: Dictionary = {}) -> String:
 		if overrides.has(flag):
 			var v: Variant = overrides[flag]
 			config.overrides[map[flag]] = int(v) if map[flag] in ["port", "max_players", "seed"] else String(v)
+	# A land server (J3, lands.gd) runs another land of the hub's world.
+	Saves.land = String(overrides.get("land", ""))
+	if not Saves.land.is_empty():
+		config.overrides["port"] = int(overrides.get("port", config.v("port")))
 	# The shared island (world_net.gd): the same terrain and scenery every
 	# client generates from the seed, plus everything players changed.
 	_world = WorldNet.open_server_world(config)
@@ -211,8 +215,10 @@ func start_server(config_path: String, overrides: Dictionary = {}) -> String:
 	players.clear()
 	_pending.clear()
 	_set_state("server")
-	print("[server] '%s' listening on UDP %d (max %d players%s). Config: %s" % [config.v("server_name"), port,
+	Lands.server_started(overrides)
+	print("[server] '%s' listening on UDP %d (max %d players%s%s). Config: %s" % [config.v("server_name"), port,
 		int(config.v("max_players")), ", password set" if not String(config.v("password")).is_empty() else "",
+		", the %s (a land server)" % Saves.land if not Saves.land.is_empty() else "",
 		ProjectSettings.globalize_path(config.path)])
 	return ""
 
@@ -226,11 +232,14 @@ func stop() -> void:
 	_states.clear()
 	server_info.clear()
 	world_info.clear()
+	roster.clear()
 	_out_q.clear()
 	_in_q.clear()
 	local_peer = 0
 	if _world != null:
 		WorldNet.close_server_world()   # saves it first
+		Lands.server_stopped()          # (and the hub's land servers with it)
+		Saves.land = ""
 	_world = null
 	_terrain = null
 	if state != "offline":
@@ -252,7 +261,8 @@ func _on_peer_disconnected(id: int) -> void:
 		_s2c_player_left.rpc(id)
 		PlayerNet.server_leave(id)   # saves their character
 		WorldNet.peer_left(id)
-		if _hosted_by(String(p.id)):
+		# (The host crossing to another land hasn't left: only leaving the game does.)
+		if _hosted_by(String(p.id)) and PlayerNet.land_of(String(p.id)) in ["", Lands.here()]:
 			_host_left.call_deferred()
 		players_changed.emit()
 
@@ -282,10 +292,12 @@ func _process(delta: float) -> void:
 ## it every few seconds.
 func _tick_clock(delta: float) -> void:
 	_clock_left -= delta
-	if _clock_left <= 0.0 and not players.is_empty():
+	if _clock_left <= 0.0 and (not players.is_empty() or not Lands.servers.is_empty()):
 		_clock_left = CLOCK_INTERVAL
 		for peer in players:
 			_s2c_clock.rpc_id(peer, _world.day_night.day, _world.day_night.time)
+		if Lands.hub:
+			Lands.push_clock(_world.day_night.day, _world.day_night.time)   # (one clock for every land)
 
 # --- hosting from the title screen (M2.7) ------------------------------------------
 # "Host Game" runs a dedicated server as a separate, windowless copy of the
@@ -414,7 +426,9 @@ func _hosted_by(id: String) -> bool:
 
 func _host_left() -> void:
 	print("[server] the host left: saving and stopping")
-	stop()   # (saves the world and everyone's characters)
+	if not Lands.land.is_empty():
+		Lands.send_hub({"t": "host_left"})   # (they left from another land: the hub stops too)
+	stop()   # (saves the world and everyone's characters, and stops the other lands)
 	get_tree().quit()
 
 # --- admin (chat.gd) ---------------------------------------------------------------
@@ -456,11 +470,94 @@ func _s2c_weather(state: String) -> void:
 
 signal weather_changed(state: String)
 
+# --- crossing to another land (J3, lands.gd) ------------------------------------------
+
+signal travelling(land: String)        ## client: on our way to another land's server
+signal arrived(land: String)           ## client: in, at the other land (the world reloads)
+
+var _travel: Dictionary = {}           ## client: {"land", "address", "pass"} while crossing
+var _hub_address := ""                 ## client: the address we joined (the hub's), for the host part
+
+## Server: sends player `peer`'s game on to land `l` (its server's port, and
+## the pass that lets them in), then lets them go.
+func send_travel(peer: int, l: String, pass_: String) -> void:
+	_s2c_travel.rpc_id(peer, {"land": l, "port": Lands.port_for(l), "pass": pass_})
+	# (Their game goes on its own; this only tidies up one that doesn't.)
+	get_tree().create_timer(3.0).timeout.connect(func():
+		if _peer != null and is_server() and (players.has(peer) or _pending.has(peer)):
+			_peer.disconnect_peer(peer))
+
+@rpc("authority", "call_remote", "reliable")
+func _s2c_travel(d: Dictionary) -> void:
+	var host := String(parse_address(_hub_address if not _hub_address.is_empty() else get_identity().last_server)[0])
+	if host.is_empty():
+		host = "127.0.0.1"
+	_travel = {"land": String(d.land), "address": "%s:%d" % [host, int(d.port)], "pass": String(d.pass)}
+	print("[net] on to the %s (%s)" % [d.land, _travel.address])
+	travelling.emit(String(d.land))
+	var pw := _pending_password
+	_quiet_stop()
+	join(String(_travel.address), pw, String(_travel.pass))
+
+## Closes the connection without telling anyone we left (a crossing).
+func _quiet_stop() -> void:
+	if _peer != null:
+		_peer.close()
+	_peer = null
+	multiplayer.multiplayer_peer = null
+	players.clear()
+	_states.clear()
+	_out_q.clear()
+	_in_q.clear()
+	local_peer = 0
+	_set_state("offline")
+
+func is_travelling() -> bool:
+	return not _travel.is_empty()
+
+# --- everyone on every land (J3b, lands.gd) -------------------------------------------
+
+## Client: everyone on the server, whichever land they're in: [{"name",
+## "id", "land", "admin"}] (the hub's roster). Empty on a server with only
+## one land running: then `players` is everyone.
+var roster: Array = []
+
+## Server: everyone here gets the roster.
+func push_roster() -> void:
+	for peer in players:
+		_s2c_roster.rpc_id(peer, Lands.roster)
+
+@rpc("authority", "call_remote", "reliable")
+func _s2c_roster(list: Array) -> void:
+	roster = list
+	players_changed.emit()
+
+## Everyone on the server to show in a list: the roster, or (one land) just
+## those here. [{"name", "admin", "land"}]
+func everyone() -> Array:
+	if not roster.is_empty():
+		return roster
+	var out: Array = []
+	for p in players.values():
+		out.append({"name": String(p.name), "admin": bool(p.get("admin", false)), "land": String(world_info.get("worldlet", ""))})
+	return out
+
+## Server: server.json read again (the hub changed it: a /set, a ban, a
+## new admin, a friend), keeping this run's command-line overrides.
+func reload_config() -> void:
+	if config == null:
+		return
+	var ov: Dictionary = config.overrides
+	config = ServerConfig.open(config.path)
+	config.overrides = ov
+
 ## Everyone gets the clock now (after a night's sleep, an admin's /time).
 func push_clock() -> void:
 	_clock_left = CLOCK_INTERVAL
 	for peer in players:
 		_s2c_clock.rpc_id(peer, _world.day_night.day, _world.day_night.time)
+	if Lands.hub:
+		Lands.push_clock(_world.day_night.day, _world.day_night.time)
 
 ## Where a player is, as far as the server knows.
 func player_pos(peer: int) -> Vector3:
@@ -541,6 +638,12 @@ func move_problem(from: Vector3, to: Vector3, dt: float, teleported: bool) -> St
 		return "too fast (%.0f m in %.2f s)" % [flat, dt]
 	elif to.y - from.y > MAX_RISE * dt + MOVE_SLACK:
 		return "rising too fast"
+	# (Down the cliff tunnel, J1: its own space under the island, where its
+	# rock is the ground. The way in and out is a server teleport.)
+	if _world != null and _world.underground_at(to):
+		return "" if teleported or _world.underground_at(from) else "into the tunnel without going in"
+	if _world != null and _world.underground_at(from):
+		return "out of the tunnel without climbing out"
 	if not _terrain.inside_boundary(to.x, to.z, -3.0):
 		return "outside the island"
 	if to.y < _terrain.sample_height(to.x, to.z) - 1.5:
@@ -594,8 +697,10 @@ func _c2s_hello(d: Dictionary) -> void:
 		_reject(peer, "Different game version: this server runs Emberwild %s (protocol %d), you have protocol %d. %s" % [
 			Updates.version, PROTOCOL, theirs, "Update the game to join." if theirs < PROTOCOL else "The server needs updating."])
 		return
+	# (A crossing to another land comes with a one-time pass instead, checked
+	# once they've proved who they are: _c2s_proof.)
 	var pw := String(config.v("password"))
-	if not pw.is_empty() and String(d.get("password", "")) != pw:
+	if not pw.is_empty() and String(d.get("password", "")) != pw and String(d.get("pass", "")).is_empty():
 		_reject(peer, "Wrong password")
 		return
 	var nonce := Crypto.new().generate_random_bytes(32)
@@ -619,6 +724,23 @@ func _c2s_proof(sig: PackedByteArray) -> void:
 	if not why.is_empty():
 		_reject(peer, why)
 		return
+	# Lands (J3): a land server only lets in someone crossing with a pass the
+	# hub gave them; a pass anywhere must be theirs and fresh. And on the
+	# hub, a character who's in another land is sent straight on there.
+	var pass_ := String(hello.get("pass", ""))
+	if not pass_.is_empty():
+		if not Lands.take_pass(pass_, id):
+			_reject(peer, "That way in has expired: join the server again")
+			return
+	elif not Lands.land.is_empty():
+		_reject(peer, "Join this server's main address (this is one of its other lands)")
+		return
+	elif Lands.hub:
+		var away: String = PlayerNet.land_of(id)
+		if not away.is_empty() and away != Lands.home():
+			_pending.erase(peer)
+			PlayerNet.send_on(peer, id, away)
+			return
 	_pending.erase(peer)
 	config.reserve_name(name, id)
 	if config.data.admins.is_empty():
@@ -641,7 +763,8 @@ func _c2s_proof(sig: PackedByteArray) -> void:
 	# (The world's own seed: an existing world keeps the seed it was made with.)
 	var world := {"seed": int(_terrain.noise_seed), "worldlet": String(_terrain.worldlet_id), "spawn": start, "yaw": yaw,
 		"island_spawn": _spawn, "day": _world.day_night.day, "time": _world.day_night.time, "server_time": server_time,
-		"weather": _world.weather.override}
+		"weather": _world.weather.override,
+		"tunnel_dug": Lands.tunnel_dug if not Lands.land.is_empty() else Lands._tunnel_dug_here()}
 	_s2c_welcome.rpc_id(peer, {"you": peer, "server": config.public_info(), "players": players, "world": world})
 	for other in players:
 		if other != peer:
@@ -683,7 +806,12 @@ static func parse_address(a: String) -> Array:
 	return [a, DEFAULT_PORT]
 
 ## Connects to a server. The outcome arrives as `joined` or `join_failed`.
-func join(address: String, password: String = "") -> void:
+## `pass_` is a one-time pass from a crossing to another land (J3).
+func join(address: String, password: String = "", pass_: String = "") -> void:
+	_pending_pass = pass_
+	if pass_.is_empty():
+		_hub_address = address.strip_edges()
+		_travel = {}
 	if state != "offline":
 		stop()
 	var me := get_identity()
@@ -705,11 +833,13 @@ func join(address: String, password: String = "") -> void:
 	_reject_reason = ""
 	_pending_password = password
 	_join_left = JOIN_TIMEOUT
-	me.last_server = address.strip_edges()
+	if pass_.is_empty():
+		me.last_server = address.strip_edges()   # (always the hub's: rejoining sends you on)
 		me.save_profile()
 	_set_state("connecting")
 
 var _pending_password := ""
+var _pending_pass := ""
 
 func leave() -> void:
 	var was := state
@@ -722,7 +852,7 @@ func leave() -> void:
 func _on_connected() -> void:
 	var me := get_identity()
 	_c2s_hello.rpc_id(1, {"protocol": debug_protocol if debug_protocol != 0 else PROTOCOL, "name": me.name,
-		"appearance": me.appearance, "public_key": me.public_pem, "password": _pending_password})
+		"appearance": me.appearance, "public_key": me.public_pem, "password": _pending_password, "pass": _pending_pass})
 
 @rpc("authority", "call_remote", "reliable")
 func _s2c_challenge(nonce: PackedByteArray) -> void:
@@ -745,6 +875,10 @@ func _s2c_welcome(d: Dictionary) -> void:
 	_set_state("connected")
 	joined.emit()
 	players_changed.emit()
+	if not _travel.is_empty():
+		var l := String(_travel.land)
+		_travel = {}
+		arrived.emit(l)
 
 @rpc("authority", "call_remote", "reliable")
 func _s2c_rejected(reason: String) -> void:
@@ -807,10 +941,17 @@ func _run_queue(q: Array) -> void:
 		f.call()
 
 func _fail(reason: String) -> void:
+	var crossing := not _travel.is_empty()
+	_travel = {}
+	if not crossing:
 		stop_hosting()   # (hosting and couldn't get in: don't leave the server running)
 	stop()
 	last_reason = reason
 	join_failed.emit(reason)
+	if crossing:
+		# (The world we were in is still on screen: it goes back to the title.)
+		last_reason = "Couldn't get through to the next land (%s). Join again to carry on." % reason
+		left.emit(last_reason)
 
 func _on_connection_failed() -> void:
 	_fail("Couldn't reach the server")
@@ -818,6 +959,11 @@ func _on_connection_failed() -> void:
 func _on_server_disconnected() -> void:
 	var was := state
 	var reason := _reject_reason
+	if not _travel.is_empty():
+		if was == "connecting":
+			_fail(reason if not reason.is_empty() else "the server hung up")   # (the next land wouldn't have us)
+		return   # (the land we're leaving letting us go)
+	var land_name := on_land()
 	stop_hosting()
 	stop()
 	if was == "connecting":
@@ -825,8 +971,19 @@ func _on_server_disconnected() -> void:
 		join_failed.emit(last_reason)
 	else:
 		last_reason = reason if not reason.is_empty() else "The server closed the connection"
+		if reason.is_empty() and not land_name.is_empty():
+			# (Another land's server went: the rest of the server's still up,
+			# and joining again starts that land's server afresh.)
+			last_reason = "Lost the connection to the %s. Join the server again to carry on there." % \
+				preload("res://scripts/world/terrain.gd").worldlet_name(land_name)
 		left.emit(last_reason)
 
+## Client: the land we're in when it's not the server's home land (we're on
+## one of its other lands' servers), else "".
+func on_land() -> String:
+	var here := String(world_info.get("worldlet", ""))
+	return here if not here.is_empty() and here != String(server_info.get("worldlet", here)) else ""
+
 func _notification(what: int) -> void:
 	if what == NOTIFICATION_WM_CLOSE_REQUEST or what == NOTIFICATION_PREDELETE:
 		if _peer != null:

scripts/net/player_net.gd

@@ -79,11 +79,20 @@ func server_join(peer: int, id: String, display: String) -> Vector3:
 		p.load_data(d)
 		var t: Node3D = WorldNet.world.terrain
 		var pos := Vector3(d.pos[0], d.pos[1], d.pos[2]) if d.has("pos") else Vector3.INF
-		if pos.is_finite() and t.inside_boundary(pos.x, pos.z, 1.0) and pos.y > t.sample_height(pos.x, pos.z) - 1.0:
+		var here_ := String(d.get("land", Lands.here())) == Lands.here()
+		if here_ and d.has("arrive"):
+			# Just crossed over: where the way in comes out (J3).
+			pos = WorldNet.world.arrival_point(String(d.arrive))
+		elif not here_:
+			pos = Vector3.INF   # (saved somewhere else: start at this land's start)
+		var ok_spot: bool = pos.is_finite() and (WorldNet.world.underground_at(pos) \
+			or (t.inside_boundary(pos.x, pos.z, 1.0) and pos.y > t.sample_height(pos.x, pos.z) - 1.0))
+		if ok_spot:
 			at = pos
 		print("[server] %s's character loaded" % display)
 	if at != Vector3.INF:
 		p.global_position = at
+	beds_changed.call_deferred()   # (one more awake: everyone's count changes)
 	return at
 
 func place_at(peer: int, pos: Vector3) -> void:
@@ -127,10 +136,54 @@ func _save(p: Node3D) -> void:
 	if f == null:
 		printerr("[server] can't save %s's character" % p.display)
 		return
-	f.store_string(JSON.stringify(p.to_data(), "\t"))
+	var d: Dictionary = p.to_data()
+	# Which land the character's in (J3: characters are shared by every land
+	# of the world); heading somewhere, it's there they'll turn up next.
+	d["land"] = String(p.get_meta("heading", Lands.here()))
+	if p.has_meta("arrive"):
+		d["arrive"] = String(p.get_meta("arrive"))
+	f.store_string(JSON.stringify(d, "\t"))
 	f.close()
 	DirAccess.rename_absolute(tmp, path)
 
+## Which land player `id`'s character is in ("" = not saved yet, or here).
+func land_of(id: String) -> String:
+	return String(_read(_file(id)).get("land", ""))
+
+## The hub: player `id` (at `peer`, not let in yet) left their character in
+## land `l`: start its server if need be and send them on there.
+func send_on(peer: int, id: String, l: String) -> void:
+	print("[server] %s's character is in the %s: sending them on" % [id.substr(0, 8), l])
+	Lands.ensure(l, func(why: String):
+		if not why.is_empty():
+			Net._reject(peer, "The %s isn't open right now (%s)" % [l, why])
+			return
+		Net.send_travel(peer, l, Lands.pass_to(l, id)))
+
+## A crossing, on the server (the tunnel's sea cave, the cave back up): the
+## character is saved as heading for `to`, arriving at `arrive`, and their
+## game is sent on (to a land server, or back to the hub).
+func cross(peer: int, to: String, arrive: String) -> void:
+	var p: Node3D = proxies.get(peer)
+	if p == null or p.has_meta("heading"):
+		return
+	p.set_meta("heading", to)
+	p.set_meta("arrive", arrive)
+	_save(p)
+	var id: String = p.player_id
+	print("[server] %s crosses to the %s" % [p.display, to])
+	if to == Lands.home() and not Lands.land.is_empty():
+		Net.send_travel(peer, to, Lands.pass_home(id))
+		return
+	Lands.ensure(to, func(why: String):
+		if not why.is_empty():
+			p.remove_meta("heading")
+			p.remove_meta("arrive")
+			_save(p)
+			tell(peer, "The way's blocked for now (%s)" % why)
+			return
+		Net.send_travel(peer, to, Lands.pass_to(to, id)))
+
 static func _read(path: String) -> Dictionary:
 	if not FileAccess.file_exists(path):
 		return {}
@@ -160,6 +213,7 @@ func server_moved(peer: int, from: Vector3, to: Vector3, yaw: float, anim: int,
 	if p.in_bed and to.distance_to(p.bed_at) > 1.5:
 		p.in_bed = false
 		tell(p.peer, "You got out of bed")
+		beds_changed()
 
 func _process(delta: float) -> void:
 	if not Net.is_server() or proxies.is_empty():
@@ -300,8 +354,42 @@ func _run(p: Node3D, what: String, a: Array) -> void:
 		"hit":
 			var n: Node3D = w.props.resource_nodes.get(_s(a, 0))
 			var at: Vector3 = _v(a, 1)
-			if n != null and is_instance_valid(n) and at.is_finite() and Actions.harvest_hit(p, n, at):
+			if n == null and w.tunnel != null:
+				var f: Node3D = w.tunnel.face_by_uid(_s(a, 0))   # (the cliff tunnel's seam or face)
+				if f != null and at.is_finite():
+					Actions.harvest_hit(p, f, at)   # (the tunnel tells everyone: tunnel.gd)
+			elif n != null and is_instance_valid(n) and at.is_finite() and Actions.harvest_hit(p, n, at):
 				WorldNet.node_hit(n, at, p.global_position)
+		"tunnel_prop":
+			if w.tunnel != null:
+				w.tunnel.set_prop(p, _i(a, 0))
+		"tunnel_go":
+			# Down into the cliff tunnel, or back out at the top: a teleport
+			# the server makes (the tunnel's under the island), from nearby.
+			var t: Node3D = w.tunnel
+			if t == null or not t.opened:
+				return
+			var go_in := _s(a, 0) == "in"
+			var from: Vector3 = t.seam_out if go_in else t.top
+			if p.global_position.distance_to(from) > 4.5:
+				return
+			if go_in:
+				t.go_in(p)
+			else:
+				t.go_out(p)
+			Net.teleport(p.peer, p.global_position)
+			_s2c_respawn.rpc_id(p.peer, p.global_position, p.rotation.y, "")
+		"cross":
+			# The sea cave's mouth (the Valley), or the sea cave (the Cove).
+			var where := _s(a, 0)
+			if where == "tunnel" and w.tunnel != null and w.tunnel.dug >= w.tunnel.STRETCHES \
+					and p.global_position.distance_to(w.tunnel.cave_mouth) < 4.0:
+				cross(p.peer, w.tunnel.to, "sea_cave")
+			elif where == "sea_cave" and w.sea_cave != null and w.sea_cave.open() \
+					and p.global_position.distance_to(w.sea_cave.front) < 6.0:
+				cross(p.peer, w.sea_cave.to, "tunnel_bottom")
+			elif where == "sea_cave" and w.sea_cave != null:
+				tell(p.peer, w.sea_cave.interact_prompt(p))
 		"pickup":
 			var key := _s(a, 0)
 			var pk: Node3D = WorldNet.find_pickup(key)
@@ -456,6 +544,12 @@ func _run(p: Node3D, what: String, a: Array) -> void:
 				w.day_night.apply(true)
 				w.weather.snap()
 				Net.push_clock()
+		"debug_tunnel":
+			# (tests) dig the cliff tunnel to `n` stretches, all propped.
+			if cheats and w.tunnel != null:
+				var n := clampi(_i(a, 0), 0, w.tunnel.STRETCHES)
+				w.tunnel.load_data({"opened": true, "dug": n, "props": range(1, n + 1)})
+				w.tunnel._tell_everyone()
 		"debug_tp":
 			var to := _v(a, 0)
 			if cheats and to.is_finite():
@@ -515,28 +609,66 @@ func go_to_bed(p: Node3D) -> void:
 	p.in_bed = true
 	p.bed_at = p.global_position
 	if not _maybe_pass_night():
-		var n: int = _alive().size()
+		# (Counting everyone, in every land: on another land's server, the
-		var asleep: int = _alive().filter(func(q): return q.in_bed).size()
+		# hub's last count, with this bed in it.)
-		tell(p.peer, "You're in bed (%d of %d asleep). The night passes when %s." % [asleep, n,
+		var counts := sleep_counts()
-			"everyone's in bed" if _beds_needed(n) >= n else "%d are" % _beds_needed(n)])
+		if not Lands.land.is_empty():
-		for q in _alive():
+			counts = [_alive().size() + _hub_beds[0], _alive().filter(func(q): return q.in_bed).size() + _hub_beds[1]]
-			if q != p:
+		var n: int = counts[0]
-				tell(q.peer, "%s is in bed (%d of %d asleep)" % [p.display, asleep, n])
+		var asleep: int = counts[1]
+		var need: int = _beds_needed(n)
+		tell(p.peer, waiting_text(asleep, n, need))
+		# Everyone else, in every land, hears it in chat (so whoever's still
+		# up knows they're being waited for).
+		Chat._all("%s is in bed (%d of %d asleep%s)" % [p.display, asleep, n,
+			"" if need >= n else ", %d needed" % need], "server")
+
+## What a player who's just got into bed is told while the others are up.
+static func waiting_text(asleep: int, n: int, need: int) -> String:
+	var left := need - asleep
+	var who := "everyone else" if need >= n else ("%d more" % left)
+	return "You're in bed: waiting for %s to go to bed (%d of %d asleep)" % [who, asleep, n]
 
 func _alive() -> Array:
 	return proxies.values().filter(func(q): return not q.survival.dead)
 
 ## Everyone in bed (by the rule)? Then until 06:00 for all: the clock, fires,
 ## regrowth and weather move on; sleepers wake rested.
+## One clock for every land (J3b): the night passes when enough of everyone,
+## in every land, is in bed. Another land's server reports its beds to the
+## hub, which decides, and tells every land to pass the night too.
 func _maybe_pass_night() -> bool:
 	var w: Node3D = WorldNet.world
-	var live := _alive()
+	if w == null:
-	if w == null or live.is_empty():
 		return false
-	var asleep := live.filter(func(q): return q.in_bed)
+	if not Lands.land.is_empty():
-	if asleep.size() < _beds_needed(live.size()):
+		_report_beds()
+		return false
+	Lands._push_bed_totals()
+	var counts := sleep_counts()
+	if counts[0] == 0 or counts[1] < _beds_needed(counts[0]):
 		return false
 	var secs: float = fposmod(6.0 - w.day_night.hours(), 24.0) / 24.0 * w.day_night.day_length
+	Lands.tell_lands({"t": "night", "secs": secs})
+	pass_night_here(secs)
+	return true
+
+## [alive, asleep] on this server and (the hub) every other land.
+func sleep_counts() -> Array:
+	var live := _alive()
+	var counts := [live.size(), live.filter(func(q): return q.in_bed).size()]
+	if Lands.hub:
+		var e: Array = Lands.beds_elsewhere()
+		counts = [counts[0] + int(e[0]), counts[1] + int(e[1])]
+	return counts
+
+## The night passes here: until 06:00 for everyone on this server.
+func pass_night_here(secs: float) -> void:
+	var w: Node3D = WorldNet.world
+	if w == null:
+		return
+	var live := _alive()
+	var asleep := live.filter(func(q): return q.in_bed)
 	w.skip_time(secs)
 	for q in live:
 		if q.in_bed:
@@ -545,7 +677,20 @@ func _maybe_pass_night() -> bool:
 		_s2c_slept.rpc_id(q.peer, asleep.has(q))
 	Net.push_clock()
 	WorldNet.save()
-	return true
+	if not Lands.land.is_empty():
+		_report_beds()
+
+## Someone got into or out of bed, or came or went: (a land server) the hub
+## hears the new count; (the hub) the night may pass.
+func beds_changed() -> void:
+	if not Lands.land.is_empty():
+		_report_beds()
+	elif Net.is_server():
+		_maybe_pass_night()
+
+func _report_beds() -> void:
+	var live := _alive()
+	Lands.send_hub({"t": "beds", "alive": live.size(), "asleep": live.filter(func(q): return q.in_bed).size()})
 
 ## The chest or grave `nid`, if this player may use it right now.
 func _container(p: Node3D, nid: int) -> Node3D:
@@ -556,6 +701,10 @@ func _container(p: Node3D, nid: int) -> Node3D:
 
 const Rules = preload("res://scripts/net/rules.gd")
 
+## (Land server) the hub's latest [alive, asleep] in every OTHER land, for
+## the "N of M asleep" message and the all-abed check here.
+var _hub_beds := [0, 0]
+
 ## Tells the player why not, if there's a reason.
 func _allowed(why: String) -> bool:
 	if why.is_empty():

scripts/net/world_net.gd

@@ -369,6 +369,20 @@ func _s2c_node(uid: String, hp: float, point: Vector3, from: Vector3) -> void:
 func stones_state(d: Dictionary) -> void:
 	_all("_s2c_stones", [d])
 
+## The cliff tunnel changed (a blow on its face, a stretch dug, a prop set):
+## everyone here sees it, and the other lands hear how far it's dug.
+func tunnel_state(d: Dictionary) -> void:
+	_all("_s2c_tunnel", [d])
+	mark_changed()
+	if Lands.hub:
+		Lands.push_tunnel(int(d.get("dug", 0)))
+
+@rpc("authority", "call_remote", "reliable")
+func _s2c_tunnel(d: Dictionary) -> void:
+	if not is_client() or world.tunnel == null:
+		return
+	world.tunnel.load_data(d)
+
 @rpc("authority", "call_remote", "reliable")
 func _s2c_stones(d: Dictionary) -> void:
 	if not is_client() or world.stones == null:

scripts/ui/map_screen.gd

@@ -31,6 +31,7 @@ var _tex: TextureRect
 var _marks: Control
 var _title: Label
 var _facing: Label
+var _others_key: Label
 
 func setup(w: Node3D, p: Node3D) -> void:
 	world = w
@@ -75,6 +76,9 @@ func setup(w: Node3D, p: Node3D) -> void:
 	var you := UITheme.label("●  You", 14)
 	you.add_theme_color_override("font_color", Color(1, 1, 1))
 	legend.add_child(you)
+	_others_key = UITheme.label("●  Other players (co-op)", 14)
+	_others_key.add_theme_color_override("font_color", Color(0.6, 1.0, 0.65))
+	legend.add_child(_others_key)
 	for k in MARKS:
 		var l := UITheme.label("■  %s" % MARKS[k][1], 14)
 		l.add_theme_color_override("font_color", MARKS[k][0])
@@ -92,6 +96,7 @@ func is_open() -> bool:
 func open() -> void:
 	_tex.texture = ImageTexture.create_from_image(render(world))
 	_title.text = "The %s" % preload("res://scripts/world/terrain.gd").worldlet_name(world.worldlet_id())
+	_others_key.visible = world.is_online() and not bool(Net.server_info.get("pvp", true))
 	visible = true
 	player.ui_open = true
 	Input.mouse_mode = Input.MOUSE_MODE_VISIBLE
@@ -132,6 +137,13 @@ func _draw_marks() -> void:
 		_marks.draw_rect(Rect2(at - Vector2(r, r), Vector2(r, r) * 2.0), Color(0, 0, 0, 0.7), false, 1.0)
 		if m.kind in ["den", "barrow", "stones", "seam", "pier", "cave"]:
 			_marks.draw_string(font, at + Vector2(9, 5), String(m.label), HORIZONTAL_ALIGNMENT_LEFT, -1, 13, col)
+	# Other players in this land: only on a co-op server (with PvP on, the
+	# map never gives anyone away). Green dots with their names.
+	for o in others(world):
+		var at2 := _to_map(o.pos)
+		_marks.draw_circle(at2, 5.5, Color(0, 0, 0, 0.8))
+		_marks.draw_circle(at2, 4.0, Color(0.45, 0.95, 0.5))
+		_marks.draw_string(font, at2 + Vector2(8, 5), String(o.name), HORIZONTAL_ALIGNMENT_LEFT, -1, 13, Color(0.6, 1.0, 0.65))
 	# You: a dot (the way you're facing is on the compass).
 	var p := player.global_position
 	if world.underground_at(p) and world.tunnel != null:
@@ -143,6 +155,19 @@ func _draw_marks() -> void:
 	_marks.draw_string(font, Vector2(SIDE - 26, 24), "N", HORIZONTAL_ALIGNMENT_LEFT, -1, 18, Color(1.0, 0.55, 0.35))
 	_marks.draw_line(Vector2(SIDE - 20, 30), Vector2(SIDE - 20, 48), Color(1.0, 0.55, 0.35), 2.0)
 
+## The other players to show: [{name, pos}], everyone in this land on a
+## server with PvP off; nobody single-player or with PvP on (rivals and
+## adversarial), so the map can't be used to hunt anyone down.
+static func others(w: Node3D) -> Array:
+	var out: Array = []
+	if not w.is_online() or bool(Net.server_info.get("pvp", true)) or w.net_sync == null:
+		return out
+	for peer in w.net_sync.avatars:
+		var a: Node3D = w.net_sync.avatars[peer]
+		if is_instance_valid(a) and a.visible:
+			out.append({"name": String(a.info.get("name", "?")), "pos": a.global_position})
+	return out
+
 ## The map image: the terrain, coloured and shaded, blank where unexplored.
 static func render(w: Node3D) -> Image:
 	var t: Node3D = w.terrain
@@ -163,6 +188,8 @@ static func render(w: Node3D) -> Image:
 
 static func ground_colour(t: Node3D, x: float, z: float) -> Color:
 	var h: float = t.sample_height(x, z)
+	if t.near_stream(x, z, 0.3):
+		return Color(0.32, 0.56, 0.66)   # (the stream, a little wider than it is so it shows)
 	var surface: float = t.water_level if t.inside_boundary(x, z, -2.0) else t.sea_level
 	if h < surface:
 		var deep := clampf((surface - h) / 6.0, 0.0, 1.0)

scripts/ui/pause_menu.gd

@@ -194,9 +194,18 @@ func open() -> void:
 	get_tree().paused = not _online   # a shared world can't be paused by one player
 	Input.mouse_mode = Input.MOUSE_MODE_VISIBLE
 	if _online:
+		# Everyone on the server, in whichever land (J3b), with where they are
+		# once anyone's somewhere else.
+		var all: Array = Net.everyone()
+		var lands := {}
+		for p in all:
+			lands[String(p.get("land", ""))] = true
 		var names: Array[String] = []
-		for p in Net.players.values():
+		for p in all:
-			names.append(String(p.name) + (" (admin)" if p.get("admin", false) else ""))
+			var where := ""
+			if lands.size() > 1 and not String(p.get("land", "")).is_empty():
+				where = " · %s" % preload("res://scripts/world/terrain.gd").worldlet_name(String(p.land))
+			names.append(String(p.name) + (" (admin)" if p.get("admin", false) else "") + where)
 		names.sort()
 		_players_label.text = "%s  ·  %d online\n%s" % [Net.server_info.get("server_name", "Server"), names.size(), ", ".join(names)]
 

scripts/ui/title_screen.gd

@@ -426,7 +426,9 @@ func _fill_host() -> void:
 	_host_seed_label.text = "Seed" if not existing else "Seed (kept)"
 	_host_seed.text = "" if not existing else str(int(c.data.seed))
 	_show_host_worldlet(existing, meta_path)
-	_host_msg.text = "Your hosted island carries on where you left it." if existing else "A new island will be made."
+	_host_msg.text = ("Your hosted island carries on where you left it." if existing else "A new island will be made.") + \
+		"\nFriends on your network join at your address. Over the internet, forward %s on your router." % \
+		Lands.ports_text(picked_worldlet(_host_worldlet), int(c.data.port))
 	_host_msg.add_theme_color_override("font_color", UITheme.TEXT_DIM)
 	_host_btn.disabled = false
 

scripts/world/barrow.gd

@@ -102,7 +102,7 @@ func _search(max_spread: float, from_spawn: float, from_den: float) -> Vector3:
 				hs.append(terrain.sample_height(c.x + cos(b) * rad, c.y + sin(b) * rad))
 		var h0: float = terrain.sample_height(c.x, c.y)
 		hs.append(h0)
-		if hs.min() < terrain.water_level + 1.0:
+		if hs.min() < terrain.water_level + 1.0 or terrain.near_stream(c.x, c.y, MOUND_R + 4.0):
 			continue
 		var spread: float = hs.max() - hs.min()
 		if spread > max_spread:

scripts/world/props.gd

@@ -423,6 +423,8 @@ func _scatter_trees() -> void:
 func _on_clifftop(x: float, z: float) -> bool:
 	if pier != null and pier.covers(x, z, 2.0):
 		return true
+	if terrain.near_stream(x, z, 1.2):
+		return true   # (the stream's bed and banks)
 	for c in keep_clear:
 		if Vector2(x - c[0].x, z - c[0].z).length() < float(c[1]):
 			return true
@@ -615,7 +617,7 @@ func _place_logs() -> void:
 			continue
 		var h: float = terrain.sample_height(x, z)
 		var n: Vector3 = terrain.sample_normal(x, z)
-		if h < terrain.water_level + 0.6 or n.y < 0.97 or Vector2(x - _spawn.x, z - _spawn.z).length() < 8.0:
+		if h < terrain.water_level + 0.6 or n.y < 0.97 or Vector2(x - _spawn.x, z - _spawn.z).length() < 8.0 or terrain.near_stream(x, z, 1.5):
 			continue
 		var mi := MeshInstance3D.new()
 		var shape: Shape3D
@@ -680,7 +682,7 @@ func _scatter_pickups() -> void:
 				continue
 			var h: float = terrain.sample_height(x, z)
 			var n: Vector3 = terrain.sample_normal(x, z)
-			if h < terrain.water_level + 0.3 or n.y < 0.8 or (pier != null and pier.covers(x, z, 1.0)):
+			if h < terrain.water_level + 0.3 or n.y < 0.8 or (pier != null and pier.covers(x, z, 1.0)) or terrain.near_stream(x, z, 0.3):
 				continue
 			var chance := 1.0
 			match id:
@@ -742,7 +744,7 @@ func _scatter_berry_bushes(root: Node3D) -> void:
 			continue
 		var h: float = terrain.sample_height(x, z)
 		var n: Vector3 = terrain.sample_normal(x, z)
-		if h < terrain.water_level + 0.6 or n.y < 0.85:
+		if h < terrain.water_level + 0.6 or n.y < 0.85 or terrain.near_stream(x, z, 1.0):
 			continue
 		var f := _forest(x, z)
 		var chance := 0.12 + (1.0 - absf(f - 0.45) * 2.0) * 0.5
@@ -824,7 +826,7 @@ func _make_grass_tile(k: Vector2i) -> Node3D:
 			if not terrain.in_bounds(x, z):
 				continue
 			var h: float = terrain.sample_height(x, z)
-			if h < terrain.water_level + 0.25 or h > terrain.snow_height - 6.0:
+			if h < terrain.water_level + 0.25 or h > terrain.snow_height - 6.0 or terrain.near_stream(x, z, -0.2):
 				continue
 			var n: Vector3 = terrain.sample_normal(x, z)
 			if n.y < 0.72:

scripts/world/rock_pile.gd

@@ -0,0 +1,39 @@
+extends RefCounted
+## Boulders for hand-placed rockwork (the cliff tunnel's seam and its faces,
+## the Cove's sea cave): the same low-poly rocks as the scenery and the wolf
+## den (ProcMesh.rock, rock.gdshader: moss on top, snow up high), each with a
+## convex collider that matches it.
+
+const ProcMesh = preload("res://scripts/world/proc_mesh.gd")
+
+## The scenery's rock material, for a world's terrain.
+static func material(terrain: Node3D) -> ShaderMaterial:
+	var m := ShaderMaterial.new()
+	m.shader = preload("res://shaders/rock.gdshader")
+	m.set_shader_parameter("noise_tex", terrain.noise_tex)
+	m.set_shader_parameter("snow_height", terrain.snow_height)
+	return m
+
+## One boulder under `parent` at local `at`, `radii` across (a rock mesh is
+## about 1 m round before scaling), turned `turn` radians. Its collider goes
+## on `body` (which must share `parent`'s transform), unless `body` is null.
+static func add(parent: Node3D, body: CollisionObject3D, seed: int, at: Vector3, radii: Vector3, turn: float,
+		mat: Material, tall: bool = false) -> MeshInstance3D:
+	var mesh := ProcMesh.rock(seed, tall)
+	var b := Basis(Vector3.UP, turn).scaled(radii)
+	var mi := MeshInstance3D.new()
+	mi.mesh = mesh
+	mi.material_override = mat
+	mi.transform = Transform3D(b, at)
+	parent.add_child(mi)
+	if body != null:
+		var hull := mesh.create_convex_shape(true, true) as ConvexPolygonShape3D
+		var pts := PackedVector3Array()
+		for p: Vector3 in hull.points:
+			pts.append(b * p)
+		hull.points = pts
+		var cs := CollisionShape3D.new()
+		cs.shape = hull
+		cs.position = at
+		body.add_child(cs)
+	return mi

scripts/world/rock_pile.gd.uid

@@ -0,0 +1 @@
+uid://ijajgdb0unan

scripts/world/sea_cave.gd

@@ -8,6 +8,8 @@ extends Node3D
 ## Placed from the terrain alone, like the pier, so it's the same for
 ## everyone; nothing about it is saved here (the tunnel is the Valley's).
 
+const RockPile = preload("res://scripts/world/rock_pile.gd")
+
 var world: Node3D
 var to := "valley"
 var front := Vector3.ZERO   ## where you stand in front of it (arriving from the tunnel)
@@ -49,6 +51,11 @@ func place(w: Node3D) -> bool:
 
 ## Whether the Valley's tunnel has been dug right down to here.
 func open() -> bool:
+	var full: int = preload("res://scripts/world/tunnel.gd").STRETCHES
+	if not Lands.land.is_empty():
+		return Lands.tunnel_dug >= full   # (a land server: the hub says how far it's dug)
+	if world.is_online():
+		return int(Net.world_info.get("tunnel_dug", 0)) >= full   # (as the server said when we came in)
 	if not Saves.has_world():
 		return false
 	var s: Dictionary = Saves.load_state(Saves.current_id, to)
@@ -66,44 +73,36 @@ func interact(_player: Node) -> void:
 		Actions.notify.emit(interact_prompt(null))
 
 func _build(w: Node3D) -> void:
-	var rock := StandardMaterial3D.new()
+	var rock: ShaderMaterial = RockPile.material(w.terrain)
-	rock.albedo_color = Color(0.42, 0.40, 0.38)
-	rock.roughness = 1.0
-	if w.terrain.noise_tex != null:
-		rock.albedo_texture = w.terrain.noise_tex
-		rock.uv1_triplanar = true
-		rock.uv1_scale = Vector3(0.18, 0.18, 0.18)
 	var body := StaticBody3D.new()
 	add_child(body)
-	# (local -Z faces the beach; the rocks are behind, +Z)
+	# A heap of big boulders at the foot of the headland, with a dark mouth
-	for part in [[Vector3(-2.0, 1.6, 1.0), Vector3(1.8, 3.6, 3.0)], [Vector3(2.0, 1.4, 1.0), Vector3(1.8, 3.2, 3.0)],
+	# between them (local -Z faces the beach; the heap is behind, +Z), and
-			[Vector3(0, 3.5, 1.0), Vector3(5.8, 1.4, 3.2)], [Vector3(0, 1.4, 2.4), Vector3(2.4, 3.0, 0.6)],
+	# seaweed-dark stones scattered on the sand in front.
-			[Vector3(-3.4, 1.0, 2.0), Vector3(2.0, 2.4, 3.0)], [Vector3(3.2, 0.8, 2.2), Vector3(1.8, 2.0, 2.6)]]:
+	var s: int = w.terrain.noise_seed + 5100
-		var mi := MeshInstance3D.new()
+	for part in [[Vector3(-2.4, 1.3, 1.0), Vector3(1.3, 2.1, 1.7), 0.5, true],
-		var bm := BoxMesh.new()
+			[Vector3(2.4, 1.15, 1.0), Vector3(1.25, 1.9, 1.6), 2.0, true],
-		bm.size = part[1]
+			[Vector3(0.0, 3.75, 1.2), Vector3(2.9, 1.0, 1.9), 0.3, false],
-		mi.mesh = bm
+			[Vector3(0.0, 1.8, 3.2), Vector3(2.4, 2.4, 1.4), 1.1, false],
-		mi.material_override = rock
+			[Vector3(-4.3, 0.8, 2.0), Vector3(1.8, 1.5, 1.8), 2.6, false],
-		mi.position = part[0]
+			[Vector3(4.1, 0.6, 2.2), Vector3(1.6, 1.3, 1.7), 0.7, false],
-		mi.rotation.y = part[0].x * 0.06
+			[Vector3(-2.0, 4.4, 2.8), Vector3(1.8, 1.2, 1.6), 1.7, false],
-		add_child(mi)
+			[Vector3(2.3, 4.1, 3.0), Vector3(1.6, 1.1, 1.5), 2.9, false]]:
-		var cs := CollisionShape3D.new()
+		RockPile.add(self, body, s, part[0], part[1], part[2], rock, part[3])
-		var box := BoxShape3D.new()
+		s += 1
-		box.size = part[1]
+	for stone in [[Vector3(-1.4, 0.08, -1.6), 0.4], [Vector3(1.6, 0.06, -2.2), 0.3],
-		cs.shape = box
+			[Vector3(-3.2, 0.06, -1.0), 0.35], [Vector3(0.4, 0.05, -2.9), 0.22], [Vector3(3.4, 0.05, -1.2), 0.28]]:
-		cs.position = part[0]
+		RockPile.add(self, null, s, stone[0], Vector3.ONE * float(stone[1]), float(s), rock)
-		cs.rotation.y = part[0].x * 0.06
+		s += 1
-		body.add_child(cs)
 	var dark := MeshInstance3D.new()
-	var q := QuadMesh.new()
+	var bm := BoxMesh.new()
-	q.size = Vector2(2.2, 2.8)
+	bm.size = Vector3(2.0, 2.6, 0.1)
-	dark.mesh = q
+	dark.mesh = bm
 	var m := StandardMaterial3D.new()
-	m.albedo_color = Color(0.02, 0.02, 0.025)
+	m.albedo_color = Color(0.015, 0.014, 0.018)
 	m.shading_mode = BaseMaterial3D.SHADING_MODE_UNSHADED
 	dark.material_override = m
-	dark.position = Vector3(0, 1.4, 2.08)
+	dark.position = Vector3(0, 1.3, 1.6)
-	dark.rotation.y = PI
 	add_child(dark)
 	# What you press E on: the opening (interactables layer: you walk into it).
 	var spot := StaticBody3D.new()

scripts/world/standing_stones.gd

@@ -97,7 +97,7 @@ func _find_site() -> Vector3:
 					hs.append(terrain.sample_height(c.x + cos(b) * RING_R, c.y + sin(b) * RING_R))
 				var h0: float = terrain.sample_height(c.x, c.y)
 				hs.append(h0)
-				if hs.max() - hs.min() > float(pass_[0]) or hs.min() < terrain.water_level + 1.0:
+				if hs.max() - hs.min() > float(pass_[0]) or hs.min() < terrain.water_level + 1.0 or terrain.near_stream(c.x, c.y, RING_R + 3.0):
 					continue
 				return Vector3(c.x, h0, c.y)
 	return Vector3.INF

scripts/world/terrain.gd

@@ -88,7 +88,7 @@ func _ready() -> void:
 	elif saves != null and saves.has_world():
 		noise_seed = saves.world_seed()
 		# (worlds from before worldlets have none: they're the Valley)
-		worldlet_id = String(saves.read_meta(saves.current_id).get("worldlet", "valley"))
+		worldlet_id = String(saves.worldlet_of(saves.current_id))   # (a land server's own land, or the world's)
 	var why := use_worldlet(worldlet_id)
 	if not why.is_empty():
 		push_error("[terrain] %s: using the Valley" % why)
@@ -174,11 +174,18 @@ func _wall_threshold(x: float, z: float) -> float:
 # (data/worldlets/<id>.json "terrain"). Each block takes the ground so far and
 # returns it changed; "hills" starts it. A worldlet can only combine these.
 
-const BLOCKS := ["hills", "rim", "sea_cliff", "beach", "lake", "ocean_edge"]
+const BLOCKS := ["hills", "rim", "sea_cliff", "beach", "lake", "stream", "ocean_edge"]
 var worldlet_id := "valley"
 var worldlet: Dictionary = {}           ## the definition, as loaded
 var _blocks: Array = []                 ## its terrain blocks, in order
 var lakes: Array = []                   ## every "lake" block's {center: Vector2, radius} (W2: several)
+var stream_path := PackedVector2Array()  ## a "stream" block's points, spring first (W3: the Cove's)
+var stream_width := 2.4
+var stream_depth := 0.6
+var _stream_profile := PackedFloat32Array()   ## its water surface, every STREAM_STEP m along it
+var _stream_len := 0.0                  ## its length
+var _stream_end := 0.0                  ## where it meets the sea (its water ends there)
+const STREAM_STEP := 1.0
 var _has_sea := true                    ## a sea cliff (the Valley's)
 var _has_beach := false                 ## a beach (W2)
 var _valley := 0.0                      ## the hills before anything else (the sea cliff eases from it)
@@ -231,6 +238,8 @@ func use_worldlet(id: String) -> String:
 	resolution = int(d.get("resolution", resolution))
 	_blocks = d.get("terrain", [])
 	lakes = []
+	stream_path = PackedVector2Array()
+	_stream_profile = PackedFloat32Array()
 	_has_sea = _has_block("sea_cliff")
 	_has_beach = _has_block("beach")
 	for b in _blocks:
@@ -252,6 +261,12 @@ func use_worldlet(id: String) -> String:
 				cliff_top = float(b.get("cliff_top", cliff_top))
 				cliff_offset = float(b.get("cliff_offset", cliff_offset))
 				cliff_drop_width = float(b.get("drop_width", cliff_drop_width))
+			"stream":
+				stream_path = PackedVector2Array()
+				for q in b.get("points", []):
+					stream_path.append(Vector2(float(q[0]), float(q[1])))
+				stream_width = float(b.get("width", stream_width))
+				stream_depth = float(b.get("depth", stream_depth))
 			"beach":
 				beach_angle_deg = float(b.get("angle_deg", beach_angle_deg))
 				beach_half_width_deg = float(b.get("half_width_deg", beach_half_width_deg))
@@ -285,10 +300,14 @@ func _has_block(t: String) -> bool:
 			return true
 	return false
 
-func _height_fn(x: float, z: float) -> float:
+## The ground at (x, z). `stop_at_stream`: as it is before the stream cuts
+## its bed (what the stream's water level is worked out from).
+func _height_fn(x: float, z: float, stop_at_stream: bool = false) -> float:
 	_ensure_noise()
 	if _blocks.is_empty():
 		use_worldlet(worldlet_id)
+	if not stop_at_stream and stream_path.size() >= 2 and _stream_profile.is_empty():
+		_make_stream_profile()
 	var land := 0.0
 	for b in _blocks:
 		match String(b.type):
@@ -302,6 +321,10 @@ func _height_fn(x: float, z: float) -> float:
 				land = _blk_beach(x, z, land)
 			"lake":
 				land = _blk_lake(x, z, land, b._c, b._r)
+			"stream":
+				if stop_at_stream:
+					return land
+				land = _blk_stream(x, z, land)
 			"ocean_edge":
 				land = _blk_ocean_edge(x, z, land)
 	return land
@@ -354,6 +377,101 @@ func _blk_lake(x: float, z: float, land: float, at: Vector2, r: float) -> float:
 	ld += _detail.get_noise_2d(x * 0.5, z * 0.5) * 5.0
 	return lerpf(land, water_level - 3.2, smoothstep(r, r * 0.35, ld))
 
+## A stream (W3): runs along its points from a spring to the sea. Its water
+## surface comes down step by step from the ground at the spring, never
+## rising (the running minimum of the land along it), so it always runs
+## downhill. The bed is cut stream_depth below the surface, the banks rise a
+## little above it (so the water never hangs over lower ground) and blend
+## into the land, and where the land is high it cuts a little valley.
+func _make_stream_profile() -> void:
+	_stream_profile = PackedFloat32Array()
+	_stream_len = 0.0
+	for i in range(1, stream_path.size()):
+		_stream_len += stream_path[i - 1].distance_to(stream_path[i])
+	_stream_end = _stream_len
+	var surf := INF
+	var n := int(_stream_len / STREAM_STEP) + 1
+	for i in range(n + 1):
+		var p := _stream_point(i * STREAM_STEP)
+		var g := _height_fn(p.x, p.y, true)
+		surf = minf(surf - 0.01, g - 0.25) if surf < INF else g - 0.25
+		surf = maxf(surf, water_level)
+		_stream_profile.append(surf)
+		if g < water_level - 0.2 and _stream_end >= _stream_len:
+			_stream_end = i * STREAM_STEP   # (into the sea: the stream's done)
+
+## The point `along` metres down the stream.
+func _stream_point(along: float) -> Vector2:
+	var left := along
+	for i in range(1, stream_path.size()):
+		var seg := stream_path[i - 1].distance_to(stream_path[i])
+		if left <= seg or i == stream_path.size() - 1:
+			return stream_path[i - 1].lerp(stream_path[i], clampf(left / maxf(seg, 0.001), 0.0, 1.0))
+		left -= seg
+	return stream_path[stream_path.size() - 1]
+
+## How far (x, z) is from the stream's line, and how far along it that is.
+func _stream_near(x: float, z: float) -> Vector2:
+	var p := Vector2(x, z)
+	var best := INF
+	var best_along := 0.0
+	var run := 0.0
+	for i in range(1, stream_path.size()):
+		var a := stream_path[i - 1]
+		var b := stream_path[i]
+		var ab := b - a
+		var t := clampf((p - a).dot(ab) / maxf(ab.length_squared(), 0.001), 0.0, 1.0)
+		var d := p.distance_to(a + ab * t)
+		if d < best:
+			best = d
+			best_along = run + t * ab.length()
+		run += ab.length()
+	return Vector2(best, best_along)
+
+func _stream_surface_at(along: float) -> float:
+	var f := clampf(along / STREAM_STEP, 0.0, _stream_profile.size() - 1.001)
+	var i := int(f)
+	return lerpf(_stream_profile[i], _stream_profile[i + 1], f - i)
+
+func _blk_stream(x: float, z: float, land: float) -> float:
+	if _stream_profile.size() < 2:
+		return land
+	var near := _stream_near(x, z)
+	var hw := stream_width * 0.5
+	var k := near.x / hw
+	if k > 6.0:
+		return land
+	var along := near.y
+	var surf := _stream_surface_at(along)
+	var target: float
+	if k < 1.0:
+		target = surf - stream_depth * (1.0 - k * k)
+	else:
+		target = surf + 0.12 + (k - 1.0) * 0.3
+	# Down to the bed, up to the banks; where the land's high, a gentle
+	# valley rather than a slot.
+	var w := smoothstep(6.0, 1.6, k) if land > target else smoothstep(2.6, 1.6, k)
+	w *= smoothstep(0.0, 5.0, along)                                # (the spring)
+	w *= 1.0 - smoothstep(_stream_end - 8.0, _stream_end, along)   # (into the sea)
+	return lerpf(land, target, w)
+
+## The stream's water surface at (x, z), or -INF where there's no stream.
+func stream_surface(x: float, z: float) -> float:
+	if _stream_profile.size() < 2:
+		return -INF
+	var near := _stream_near(x, z)
+	if near.x > stream_width * 0.5 or near.y > _stream_end - 1.0 or near.y < 0.5:
+		return -INF
+	return _stream_surface_at(near.y)
+
+## Whether (x, z) is in or by the stream (within `margin` m of its banks):
+## scenery and landmarks keep clear.
+func near_stream(x: float, z: float, margin: float = 1.0) -> bool:
+	if _stream_profile.size() < 2:
+		return false
+	var near := _stream_near(x, z)
+	return near.x < stream_width * 0.5 + margin and near.y < _stream_end
+
 ## A beach (W2): on its side of the rim the land eases down to a sandy
 ## waterline, then shelves gently into the sea (beach_slope deeper per
 ## metre), so you can wade, then swim, until the current turns you back.
@@ -572,6 +690,11 @@ func _build_water() -> void:
 	if absf(sea_level - water_level) > 0.05:   # (by a beach the sea is the same surface: no second sheet)
 		_add_water("Water", disc, water_level, {})
 
+	if _stream_profile.size() >= 2:
+		# (Murkier than the lake, so half a metre of water reads as water, not a path.)
+		_add_water("Stream", _stream_mesh(), 0.0, {"clarity": 0.45,
+			"shallow_col": Color(0.20, 0.42, 0.46), "deep_col": Color(0.05, 0.16, 0.22)})
+
 	var ocean := PlaneMesh.new()
 	ocean.size = Vector2(8000.0, 8000.0)
 	_add_water("Ocean", ocean, sea_level, {
@@ -580,6 +703,40 @@ func _build_water() -> void:
 		"clarity": 6.0,
 	})
 
+## The stream's water: a ribbon down its bed, just under the tops of the
+## banks, each point at the surface there. It stops where it meets the sea
+## (whose own water carries on from there).
+func _stream_mesh() -> ArrayMesh:
+	var st := SurfaceTool.new()
+	st.begin(Mesh.PRIMITIVE_TRIANGLES)
+	var hw := stream_width * 0.5 * 1.05
+	var prev_l := Vector3.ZERO
+	var prev_r := Vector3.ZERO
+	var have := false
+	var along := 0.6
+	var stop := _stream_end - 1.0
+	while along < stop:
+		var p := _stream_point(along)
+		var q := _stream_point(minf(along + 0.5, _stream_len))
+		var dir := (q - p).normalized() if q.distance_to(p) > 0.001 else Vector2(0, 1)
+		var side := Vector2(-dir.y, dir.x) * hw
+		var y := _stream_surface_at(along) + 0.02
+		if y <= water_level + 0.06:
+			break   # (level with the sea: its water takes over)
+		var l := Vector3(p.x + side.x, y, p.y + side.y)
+		var r := Vector3(p.x - side.x, y, p.y - side.y)
+		if have:
+			for v in [prev_l, l, prev_r, prev_r, l, r]:
+				st.set_normal(Vector3.UP)
+				st.set_tangent(Plane(1, 0, 0, 1))
+				st.set_uv(Vector2(v.x, v.z) / size + Vector2(0.5, 0.5))
+				st.add_vertex(v)
+		prev_l = l
+		prev_r = r
+		have = true
+		along += 0.75
+	return st.commit()
+
 func _add_water(label: String, mesh: Mesh, y: float, params: Dictionary) -> void:
 	var mat := ShaderMaterial.new()
 	mat.shader = preload("res://shaders/water.gdshader")

scripts/world/tunnel.gd

@@ -21,6 +21,7 @@ extends Node3D
 ## for now: on a server it isn't built (J3 brings travel online).
 
 const TunnelFace = preload("res://scripts/world/tunnel_face.gd")
+const RockPile = preload("res://scripts/world/rock_pile.gd")
 
 const ORIGIN := Vector3(0.0, -260.0, 0.0)   ## where the tunnel space sits (well under the island)
 const STRETCHES := 6
@@ -54,8 +55,9 @@ var bottom := Vector3.ZERO      ## inside, at the bottom by the cave
 var cave_mouth := Vector3.ZERO  ## the far end of the sea cave
 var aabb := AABB()
 
-var _rock_mat: StandardMaterial3D
+var _rock_mat: StandardMaterial3D        ## the tunnel's walls
-var _face_mat: StandardMaterial3D
+var _boulder_mat: ShaderMaterial         ## the seam's outcrop (rock_pile.gd)
+var _face_mat: ShaderMaterial            ## the faces you dig
 var _wood_mat: StandardMaterial3D
 var _rock: CSGCombiner3D
 var _cuts: Node3D
@@ -141,8 +143,20 @@ func dig_refusal(stage: int) -> String:
 				return "It's loose: prop the last stretch first ([E] at its mouth, %d wood)" % PROP_WOOD
 	return ""
 
+## The face called `uid` (what a player's game asks the server to hit).
+func face_by_uid(uid: String) -> Node3D:
+	return _face if _face != null and is_instance_valid(_face) and String(_face.uid) == uid and not _face.depleted else null
+
+## On a server, everyone playing (and the other lands) hears how the tunnel
+## stands after each change.
+func _tell_everyone() -> void:
+	if Net.is_server():
+		WorldNet.tunnel_state(to_data())
+
 func face_hit(f: Node) -> void:
 	face_hp = f.hp
+	if not f.depleted:
+		_tell_everyone()
 
 func face_broken(f: Node) -> void:
 	face_hp = FACE_HP
@@ -156,9 +170,14 @@ func face_broken(f: Node) -> void:
 		else:
 			Actions.notify.emit("The rock gives. Prop this stretch before you dig on")
 	_rebuild.call_deferred()
+	_tell_everyone()
 
-## [E] at the mouth of stretch `k`: sets a timber prop there.
+## [E] at the mouth of stretch `k`: sets a timber prop there. (Online, your
+## game asks the server, which sets it and tells everyone.)
 func set_prop(player: Node, k: int) -> bool:
+	if world.is_online():
+		PlayerNet.ask("tunnel_prop", [k])
+		return true
 	if k < 1 or k > dug or props[k]:
 		return false
 	if player.inventory.count("wood") < PROP_WOOD:
@@ -168,14 +187,22 @@ func set_prop(player: Node, k: int) -> bool:
 	props[k] = true
 	Actions.notify.emit("Propped. The next face is safe to dig")
 	_rebuild.call_deferred()
+	_tell_everyone()
 	return true
 
 # --- going in and out ----------------------------------------------------------
 
+## (Online, your game asks the server, which moves you: player_net.gd.)
 func go_in(player: Node3D) -> void:
+	if world.is_online() and player == world.player:
+		PlayerNet.ask("tunnel_go", ["in"])
+		return
 	_move(player, top + Vector3(0, 0.1, 0), Vector3(1, 0, 0))
 
 func go_out(player: Node3D) -> void:
+	if world.is_online() and player == world.player:
+		PlayerNet.ask("tunnel_go", ["out"])
+		return
 	_move(player, seam_out + Vector3(0, 0.2, 0), -Vector3(seam_at.x, 0.0, seam_at.z).normalized())
 
 func _move(player: Node3D, at: Vector3, facing: Vector3) -> void:
@@ -193,6 +220,7 @@ func to_data() -> Dictionary:
 	return {"opened": opened, "dug": dug, "face_hp": face_hp, "props": p}
 
 func load_data(d: Dictionary) -> void:
+	var was := [opened, dug, props.duplicate()]
 	opened = bool(d.get("opened", false))
 	dug = clampi(int(d.get("dug", 0)), 0, STRETCHES)
 	face_hp = float(d.get("face_hp", FACE_HP))
@@ -200,6 +228,11 @@ func load_data(d: Dictionary) -> void:
 	for k in d.get("props", []):
 		if int(k) >= 1 and int(k) <= STRETCHES:
 			props[int(k)] = true
+	# (Online, a blow on the face only changes how much is left of it: no
+	# need to rebuild the rock for that.)
+	if was == [opened, dug, props] and _face != null and is_instance_valid(_face):
+		_face.hp = clampf(face_hp, 0.5, _face.max_hp)
+		return
 	_rebuild()
 
 # --- building it ---------------------------------------------------------------
@@ -212,8 +245,8 @@ func _make_materials() -> void:
 		_rock_mat.albedo_texture = terrain.noise_tex
 		_rock_mat.uv1_triplanar = true
 		_rock_mat.uv1_scale = Vector3(0.18, 0.18, 0.18)
-	_face_mat = _rock_mat.duplicate()
+	_boulder_mat = RockPile.material(terrain)
-	_face_mat.albedo_color = Color(0.30, 0.27, 0.25)
+	_face_mat = RockPile.material(terrain)   # (the same rock: the seam's cleft and pick marks set it apart)
 	_wood_mat = StandardMaterial3D.new()
 	_wood_mat.albedo_color = Color(0.42, 0.29, 0.17)
 	_wood_mat.roughness = 0.9
@@ -322,13 +355,37 @@ func _make_face(stage: int, center: Vector3, size: Vector3) -> StaticBody3D:
 	box.size = size
 	cs.shape = box
 	f.add_child(cs)
-	var mi := MeshInstance3D.new()
-	var bm := BoxMesh.new()
-	bm.size = size
-	mi.mesh = bm
-	mi.material_override = _face_mat
-	f.add_child(mi)
 	add_child(f)
+	var s: int = terrain.noise_seed + 4200 + stage * 7
+	if stage == 0:
+		# The seam: two slabs of rock with a dark cleft between them, and
+		# old pick marks (pale chips) on either side.
+		var gap := MeshInstance3D.new()
+		var gm := BoxMesh.new()
+		gm.size = Vector3(0.28, size.y * 0.85, 0.3)
+		gap.mesh = gm
+		var dm := StandardMaterial3D.new()
+		dm.albedo_color = Color(0.02, 0.018, 0.015)
+		dm.shading_mode = BaseMaterial3D.SHADING_MODE_UNSHADED
+		gap.material_override = dm
+		gap.position = Vector3(0.05, -0.05, 0.05)
+		f.add_child(gap)
+		RockPile.add(f, null, s, Vector3(-0.52, 0.0, 0.1), Vector3(0.55, size.y * 0.5, 0.42), 0.3, _face_mat, true)
+		RockPile.add(f, null, s + 1, Vector3(0.58, -0.05, 0.12), Vector3(0.52, size.y * 0.47, 0.4), 2.1, _face_mat, true)
+		var chip := StandardMaterial3D.new()
+		chip.albedo_color = Color(0.62, 0.58, 0.52)
+		for c in [Vector3(-0.32, 0.35, -0.3), Vector3(0.36, -0.2, -0.3), Vector3(-0.25, -0.45, -0.28)]:
+			var m := MeshInstance3D.new()
+			var cm := BoxMesh.new()
+			cm.size = Vector3(0.12, 0.05, 0.03)
+			m.mesh = cm
+			m.material_override = chip
+			m.position = c
+			m.rotation.z = c.x * 2.0
+			f.add_child(m)
+	else:
+		# A face down the tunnel: rough rock filling the passage.
+		RockPile.add(f, null, s, Vector3(-0.05, 0.0, 0.0), Vector3(0.45, size.y * 0.55, size.z * 0.55), 0.1, _face_mat)
 	f.global_position = center
 	return f
 
@@ -344,35 +401,39 @@ func _build_seam() -> void:
 	# (local -Z faces inland, towards the valley; the outcrop is behind, +Z)
 	var body := StaticBody3D.new()
 	_seam.add_child(body)
-	for part in [[Vector3(-1.5, 1.2, 0.4), Vector3(1.0, 2.6, 2.0)], [Vector3(1.5, 1.1, 0.4), Vector3(1.0, 2.4, 2.0)],
+	# An outcrop of boulders round a cleft: two tall ones either side, one
-			[Vector3(0, 2.6, 0.4), Vector3(4.0, 0.9, 2.2)], [Vector3(0, 1.1, 1.1), Vector3(2.2, 2.4, 0.6)]]:
+	# across the top, a big one behind and two lower ones at the shoulders,
-		var mi := MeshInstance3D.new()
+	# with loose stones fallen at its foot. (Each sits a little into the
-		var bm := BoxMesh.new()
+	# ground, which isn't quite flat.)
-		bm.size = part[1]
+	var s: int = terrain.noise_seed + 4100
-		mi.mesh = bm
+	for part in [[Vector3(-2.05, 0.95, 0.5), Vector3(1.0, 1.55, 1.3), 0.4, true],
-		mi.material_override = _rock_mat
+			[Vector3(2.05, 0.85, 0.55), Vector3(0.95, 1.45, 1.25), 1.9, true],
-		mi.position = part[0]
+			[Vector3(0.0, 2.95, 0.65), Vector3(2.3, 0.7, 1.4), 0.2, false],
-		_seam.add_child(mi)
+			[Vector3(0.0, 1.4, 1.9), Vector3(2.3, 2.3, 1.3), 3.0, false],
-		var cs := CollisionShape3D.new()
+			[Vector3(-1.2, 2.6, 2.4), Vector3(1.7, 1.5, 1.3), 1.3, false],
-		var box := BoxShape3D.new()
+			[Vector3(1.3, 2.5, 2.3), Vector3(1.6, 1.4, 1.3), 2.5, false],
-		box.size = part[1]
+			[Vector3(-3.3, 0.35, 1.2), Vector3(1.2, 0.9, 1.2), 2.2, false],
-		cs.shape = box
+			[Vector3(3.2, 0.3, 1.0), Vector3(1.0, 0.8, 1.1), 0.9, false]]:
-		cs.position = part[0]
+		RockPile.add(_seam, body, s, part[0], part[1], part[2], _boulder_mat, part[3])
-		body.add_child(cs)
+		s += 1
+	for stone in [[Vector3(-0.8, 0.06, -1.0), 0.28], [Vector3(1.1, 0.05, -1.3), 0.22],
+			[Vector3(0.35, 0.04, -1.7), 0.18], [Vector3(-1.6, 0.04, -1.6), 0.2]]:
+		RockPile.add(_seam, null, s, stone[0], Vector3.ONE * float(stone[1]), float(s), _boulder_mat)
+		s += 1
 	if not opened:
-		_face = _make_face(0, _seam.global_transform * Vector3(0, 1.1, -0.35), Vector3(2.0, 2.2, 0.5))
+		_face = _make_face(0, _seam.global_transform * Vector3(0, 1.1, -0.2), Vector3(2.0, 2.2, 0.6))
 		_face.global_basis = _seam.global_basis
 	else:
+		# The cleft dug open: black inside, set back between the boulders.
 		var dark := MeshInstance3D.new()
-		var q := QuadMesh.new()
+		var bm := BoxMesh.new()
-		q.size = Vector2(2.0, 2.1)
+		bm.size = Vector3(1.6, 2.0, 0.1)
-		dark.mesh = q
+		dark.mesh = bm
 		var m := StandardMaterial3D.new()
-		m.albedo_color = Color(0.02, 0.02, 0.02)
+		m.albedo_color = Color(0.015, 0.012, 0.01)
 		m.shading_mode = BaseMaterial3D.SHADING_MODE_UNSHADED
 		dark.material_override = m
-		dark.position = Vector3(0, 1.05, 0.78)
+		dark.position = Vector3(0, 1.0, 0.45)
-		dark.rotation.y = PI   # (a quad faces +Z: turn it to face inland)
 		_seam.add_child(dark)
 		var spot := _spot_body(Vector3(2.0, 2.1, 0.4), "in", 0)
 		_seam.add_child(spot)

scripts/world/world.gd

@@ -366,8 +366,9 @@ func _on_terrain_ready() -> void:
 	else:
 		pr.free()
 	# The journey's ways on (J1): the Valley's cliff tunnel and the Cove's sea
-	# cave. Single-player for now (J3 brings travel online).
+	# cave. On a server too (J3): the server decides the digging and the
-	if not server_mode and not menu_mode and not is_online():
+	# crossings, and every player's game has the same rock to see and walk.
+	if not menu_mode:
 		var tn := preload("res://scripts/world/tunnel.gd").new()
 		tn.name = "Tunnel"
 		add_child(tn)
@@ -446,6 +447,7 @@ func _on_terrain_ready() -> void:
 		if not state.is_empty():
 			apply_save(state)
 			print("[world] loaded '%s'" % Saves.current_id)
+			catch_up(state.get("catch_up_to", {}))
 		_arrive(Saves.take_arrival(Saves.current_id))
 	player.set_physics_process(true)
 	set_physics_process(true)
@@ -697,6 +699,7 @@ func _shared_state(harvested: Dictionary, regrow: Dictionary, taken: Array, drop
 		"bear": bears.save_data() if bears != null else _saved_bear,
 		"barrow": barrow.save_data() if barrow != null else {},
 		"stones": stones.save_data() if stones != null else {},
+		"tunnel": tunnel.to_data() if tunnel != null else {},
 	}
 
 ## The live pieces (placed and not being removed).
@@ -985,7 +988,15 @@ func underground_at(p: Vector3) -> bool:
 ## at `arrive` ("sea_cave", "tunnel_bottom"). Each worldlet keeps its own
 ## state file (Saves.state_path), so what you built here waits for you.
 func travel(to: String, arrive: String) -> void:
-	if traveling or not Saves.has_world() or is_online() or server_mode:
+	if server_mode:
+		return   # (on a server, the crossing is the player's game asking: player_net.gd "cross")
+	if is_online():
+		# The server checks, saves your character and sends you on (J3).
+		if not traveling and Time.get_ticks_msec() > _cross_asked + 3000:
+			_cross_asked = Time.get_ticks_msec()
+			PlayerNet.ask("cross", ["tunnel" if arrive == "sea_cave" else "sea_cave"])
+		return
+	if traveling or not Saves.has_world():
 		return
 	traveling = true
 	var id := Saves.current_id
@@ -995,6 +1006,10 @@ func travel(to: String, arrive: String) -> void:
 	var there: Dictionary = Saves.load_state(id, to)
 	if there.is_empty():
 		there = {"time": here.time}   # (a new place: the same day and hour)
+	else:
+		# One clock for every land: the one you're going to catches up on the
+		# time you were away when it loads (catch_up()).
+		there["catch_up_to"] = here.time
 	there["player"] = here.player
 	Saves.save_state(id, there, 0.0, to)
 	Saves.set_worldlet(id, to, arrive)
@@ -1006,21 +1021,66 @@ func travel(to: String, arrive: String) -> void:
 		get_tree().change_scene_to_file.call_deferred(scene_file_path if not scene_file_path.is_empty() else "res://scenes/world.tscn")
 
 signal travelled(to: String)   ## saved and on the way to another worldlet
+var _cross_asked := -100000    ## (online: when we last asked the server to cross)
+
+## Online (J3): the server's sending us on to another land's server.
+func _on_net_travelling(to: String) -> void:
+	traveling = true
+	player.set_physics_process(false)
+	if net_sync != null:
+		net_sync.set_process(false)          # (nothing more to tell the land we're leaving,
+		net_sync.set_physics_process(false)  # nor the next one about this one)
+	if hud != null:
+		hud.toast("On to the %s..." % Terrain.worldlet_name(to))
+		hud.fade(func(): pass)
+
+## Online: in at the other land: the world reloads as that land (its terrain
+## comes from what that server says, Net.world_info).
+func _on_net_arrived(_to: String) -> void:
+	travelled.emit(_to)
+	if get_tree().current_scene == self:
+		get_tree().change_scene_to_file.call_deferred(scene_file_path if not scene_file_path.is_empty() else "res://scenes/world.tscn")
+
+## Back in a land you've been to before: its clock comes forward to `to`
+## ({day, time}, the clock where you've come from), and everything in it
+## catches up on the time between, as after a night's sleep (kilns and
+## smelters work, fires burn, food goes off, trees and berries grow back).
+## Returns the seconds caught up.
+func catch_up(to: Dictionary) -> float:
+	if to.is_empty():
+		return 0.0
+	var secs: float = ((int(to.get("day", day_night.day)) - day_night.day) \
+		+ (float(to.get("time", day_night.time)) - day_night.time)) * day_night.day_length
+	if secs <= 0.0:
+		return 0.0
+	skip_time(secs)
+	print("[world] %s caught up on %.0f s while you were away" % [worldlet_id(), secs])
+	return secs
 
 ## Just arrived from another worldlet: put you where you came in.
+## Where the way in called `at` puts you ("sea_cave", "tunnel_bottom"), or
+## INF if this land has no such way in. (A server places crossing players
+## here too: player_net.gd.)
+func arrival_point(at: String) -> Vector3:
+	match at:
+		"sea_cave":
+			if sea_cave != null:
+				return sea_cave.front
+		"tunnel_bottom":
+			if tunnel != null and tunnel.dug >= tunnel.STRETCHES:
+				return tunnel.bottom + Vector3(0.8, 0.0, 0.0)
+	return Vector3.INF
+
 func _arrive(at: String) -> void:
 	if at.is_empty():
 		return
-	var pos := Vector3.INF
+	var pos := arrival_point(at)
 	var facing := Vector3.FORWARD
 	match at:
 		"sea_cave":
 			if sea_cave != null:
-				pos = sea_cave.front
 				facing = (sea_cave.front - sea_cave.global_position).normalized()
 		"tunnel_bottom":
-			if tunnel != null and tunnel.dug >= tunnel.STRETCHES:
-				pos = tunnel.bottom + Vector3(0.8, 0.0, 0.0)
 			facing = Vector3(1, 0, 0)
 	if pos == Vector3.INF:
 		push_warning("[world] nowhere to arrive at '%s': the start instead" % at)
@@ -1122,6 +1182,9 @@ func _update_grass_cuts() -> void:
 ## fishing (and later swimming, boats) work on any world that answers it.
 func water_at(x: float, z: float) -> Dictionary:
 	var ground: float = terrain.sample_height(x, z)
+	var ss: float = terrain.stream_surface(x, z)
+	if ground < ss:
+		return {"type": "stream", "surface": ss, "depth": ss - ground}
 	var beach: bool = terrain.beach_weight(x, z) > 0.5
 	if terrain.inside_boundary(x, z, -2.0) and ground < terrain.water_level:
 		if beach and not _in_lake(x, z):
@@ -1161,6 +1224,11 @@ func water_bodies() -> Array:
 			"beach":
 				out.append({"type": "sea", "surface": terrain.sea_level,
 					"center": terrain.shore_point(12.0), "radius": 0.0})
+			"stream":
+				if terrain.stream_path.size() >= 2:
+					var mid: Vector2 = terrain._stream_point(terrain._stream_end * 0.5)
+					out.append({"type": "stream", "surface": terrain._stream_surface_at(terrain._stream_end * 0.5),
+						"center": mid, "radius": terrain.stream_width * 0.5, "path": terrain.stream_path})
 	return out
 
 ## Whether (x, z) is in one of the lakes or ponds (not the sea off a beach).
@@ -1199,6 +1267,8 @@ func _go_online() -> void:
 	load_online_map()   # (your map of this server, from your own computer)
 	Net.left.connect(func(_why = ""): save_online_map(), CONNECT_ONE_SHOT)
 	Net.left.connect(_on_net_left)
+	Net.travelling.connect(_on_net_travelling)
+	Net.arrived.connect(_on_net_arrived)
 	get_tree().auto_accept_quit = false   # leave the server cleanly on window close
 	# The island's changes come from the server from now on.
 	props.regrow_enabled = false
@@ -1213,6 +1283,9 @@ func _go_online() -> void:
 	if Net.hosting:
 		var at := Net.my_addresses()
 		Actions.notify.emit("You're hosting. Friends join at %s" % (", ".join(PackedStringArray(at)) if not at.is_empty() else "this computer's address"))
+		var home_land := String(Net.server_info.get("worldlet", "valley"))
+		if not Lands.extra_ports(home_land, Net._host_port).is_empty():
+			Actions.notify.emit("Over the internet, forward %s" % Lands.ports_text(home_land, Net._host_port))
 
 func _on_net_left(_reason: String) -> void:
 	WorldNet.leave_world()

tests/run_all.sh

@@ -9,7 +9,7 @@ if [ ! -f .godot/global_script_class_cache.cfg ]; then
 	echo "Importing the project first (fresh copy)..."
 	godot --headless --path . --import >/dev/null 2>&1
 fi
-for t in test_survival_core test_survival_stats test_save_load test_weather_building test_creatures_combat test_wolves test_alpha test_bear test_thieves test_barrow test_boss test_den_sites test_fishing_diet test_food test_hazards test_iron test_stone test_net_lobby test_net_world test_net_shared test_net_life test_net_boss test_net_rules test_host test_tutorial test_tutorial_full test_hints test_updates test_audio test_items_more test_worldlets test_worldlet_pick test_water_bodies test_cove test_tunnel test_map test_terrain_edges test_boundary; do
+for t in test_survival_core test_survival_stats test_save_load test_weather_building test_creatures_combat test_wolves test_alpha test_bear test_thieves test_barrow test_boss test_den_sites test_fishing_diet test_food test_hazards test_iron test_stone test_net_lobby test_net_world test_net_shared test_net_life test_net_boss test_net_rules test_net_lands test_host test_tutorial test_tutorial_full test_hints test_updates test_audio test_items_more test_worldlets test_worldlet_pick test_water_bodies test_cove test_tunnel test_map test_terrain_edges test_boundary; do
 	extra=""
 	[ "$t" = "test_boundary" ] && extra="--fixed-fps 30"
 	# A suite that waits on a world that failed to load would hang forever,

tests/test_cove.gd

@@ -62,6 +62,30 @@ func _body() -> void:
 	check(world.den != null and world.barrow != null and world.stones != null, "the den, the barrow and the stones found places")
 	check(t.get_node_or_null("Water") == null, "one water surface (the bay is the sea)")
 
+	print("the stream")
+	check(t.stream_path.size() >= 2 and t.get_node_or_null("Stream") != null, "a stream, with water in it")
+	var downhill := true
+	for i in range(1, t._stream_profile.size()):
+		downhill = downhill and t._stream_profile[i] <= t._stream_profile[i - 1] + 0.0001
+	check(downhill and t._stream_profile[0] > t.water_level + 1.5, "running downhill all the way from its spring (%.1f m) to the sea" % t._stream_profile[0])
+	var mid: Vector2 = t._stream_point(t._stream_end * 0.3)
+	var sw: Dictionary = world.water_at(mid.x, mid.y)
+	check(sw.get("type", "") == "stream" and float(sw.depth) > 0.3 and float(sw.depth) < 1.0,
+		"stream water, wading deep (%.1f m)" % float(sw.get("depth", 0.0)))
+	var side: Vector2 = mid + Vector2(t.stream_width * 1.2, 0.0)
+	check(world.water_at(side.x, side.y).is_empty() and t.sample_height(side.x, side.y) > float(sw.surface),
+		"its banks are dry, and above the water")
+	check(DB.water_fishing("stream").get("fish", []).any(func(f): return f.id == "trout"), "trout in the stream")
+	var away := true
+	for p in [world.den.global_position, world.barrow.global_position, world.stones.global_position, world._spawn]:
+		away = away and not t.near_stream(p.x, p.z, 3.0)
+	check(away, "the den, the barrow, the stones and the start are all clear of it")
+	var in_bed := 0
+	for n in world.props.resource_nodes.values():
+		if is_instance_valid(n) and t.near_stream(n.global_position.x, n.global_position.z, 0.0):
+			in_bed += 1
+	check(in_bed == 0, "no trees or boulders standing in it")
+
 	print("the pier")
 	var pier: Node3D = world.pier
 	check(pier != null and pier.is_in_group("pier"), "a pier")

tests/test_net_lands.gd

@@ -0,0 +1,408 @@
+extends SceneTree
+## J3a (docs/WORLDLETS_DESIGN.md: a server per land): the journey on a server.
+##
+## A real headless server (the hub, the Valley, with --debug-cheats), Alice
+## (this test) and Bob (tests/net_world_bot.gd), who stays in the Valley.
+## Alice digs the cliff tunnel's seam and first stretch online (the server
+## decides, and her game sees the rock change), props it, goes down, lights
+## it. With the tunnel dug through, she walks out of the sea cave's mouth:
+## the hub starts the Cove's server, she's sent on there with a pass, and
+## arrives on the Cove's shore with her bag, on the same day and hour, while
+## Bob carries on in the Valley. Back up the sea cave to the hub; then out
+## to the Cove again, leave the game, and join the hub again: she's sent
+## straight on to the Cove, where she left off.
+## Run: godot --headless --path . --script res://tests/test_net_lands.gd
+
+const PORT := 24371
+const DIR := "user://test_net"
+const SRV := DIR + "/server_lands"
+const BOBS := DIR + "/bob_lands"
+const SEED := 1337
+
+var _fails := 0
+var _finished := false
+var _pids: Array[int] = []
+var Net: Node
+var WN: Node
+var PN: Node
+var A: Node
+var L: Node
+var world: Node3D
+var player: CharacterBody3D
+var _bob_dir := ""
+var _cmd := 0
+var _toasts: Array[String] = []
+var _arrived := ""
+
+func check(cond: bool, what: String) -> void:
+	print(("  ok   " if cond else "  FAIL ") + what)
+	if not cond:
+		_fails += 1
+
+func _initialize() -> void:
+	_run.call_deferred()
+
+func _run() -> void:
+	Engine.max_fps = 60
+	Net = root.get_node("Net")
+	WN = root.get_node("WorldNet")
+	PN = root.get_node("PlayerNet")
+	A = root.get_node("Actions")
+	L = root.get_node("Lands")
+	A.notify.connect(func(t): _toasts.append(t))
+	Net.arrived.connect(func(l): _arrived = l)
+	for d in [SRV, BOBS]:
+		_rm_tree(d)
+	# (EMBERWILD_SERVER_BIN=<an exported game>: the hub, and the land servers
+	# it starts, are that build: checks a release does it too.)
+	_spawn(["--server", "--port", str(PORT), "--config", ProjectSettings.globalize_path(SRV + "/server.json"),
+		"--server-name", "Lands Test", "--seed", str(SEED), "--debug-cheats", "--no-creatures"], "",
+		OS.get_environment("EMBERWILD_SERVER_BIN"))
+	await _sleep(4.0)
+	await _body()
+	if world != null and is_instance_valid(world):
+		world.queue_free()
+		await process_frame
+	Net.leave()
+	await _sleep(0.5)
+	for pid in _pids:
+		if OS.is_process_running(pid):
+			OS.kill(pid)
+	check(_finished, "test ran to the end (no script errors)")
+	await _sleep(1.0)
+	if _fails == 0 or OS.get_environment("KEEP_SRV").is_empty():
+		_rm_tree(SRV)
+	_rm_tree(BOBS)
+	print("RESULT: %s (%d failures)" % ["PASS" if _fails == 0 else "FAIL", _fails])
+	quit(1 if _fails > 0 else 0)
+
+func _body() -> void:
+	var me = load("res://scripts/net/identity.gd").open(DIR + "/a_lands")
+	me.name = "Alice"
+	Net.identity = me
+	var r := await _join()
+	check(r == "", "Alice joins the hub (%s)" % r)
+	if r != "":
+		return
+	await _load_world()
+	check(world.worldlet_id() == "valley" and world.tunnel != null, "the Valley, with its cliff tunnel, online")
+	var b0 := await _new_bob()
+	check(bool(b0.get("ok", false)), "Bob joins too (%s)" % b0.get("why", "ok"))
+	PN.ask("debug_give", ["antler_pickaxe", 1])
+	PN.ask("debug_give", ["wood", 10])
+	PN.ask("debug_give", ["torch_stand", 2])
+	await _sleep(0.6)
+	_hold("antler_pickaxe")
+	await _sleep(0.3)
+
+	print("digging the seam, online")
+	var t: Node3D = world.tunnel
+	await _tp(t.seam_out + Vector3(0, 0.2, 0))
+	var seam: Node3D = t._face
+	check(seam != null and seam.stage == 0, "the seam, as the server sees it")
+	await _dig_face(30)
+	check(t.opened, "dug open: the server says so, and Alice's game has the opening")
+	t.go_in(player)   # (asks the server, which moves her)
+	await _until(func(): return world.underground_at(player.global_position), 3.0)
+	check(world.underground_at(player.global_position), "down into the tunnel (the server takes her)")
+	await _dig_face(40)
+	check(t.dug == 1, "dug the first stretch (%d)" % t.dug)
+	t.set_prop(player, 1)
+	await _until(func(): return bool(t.props[1]), 3.0)
+	check(t.props[1], "propped it, online")
+	PN.ask("debug_tunnel", [t.STRETCHES])
+	await _until(func(): return t.dug == t.STRETCHES, 3.0)
+	check(t.dug == t.STRETCHES and t.props.count(true) >= t.STRETCHES - 1, "(the rest dug by the test's cheat: down to the sea cave)")
+	var slot := _slot("torch_stand")
+	var floor_at: Vector3 = t._mouth(2) + Vector3(0.9, 0, 0.5)   # (on the landing, beside the way down)
+	await _tp(floor_at + Vector3(1.0, 0.1, 0))
+	A.place(player, slot, Transform3D(Basis(), floor_at), world)
+	await _until(func(): return world.all_pieces().any(func(p): return p.item_id == "torch_stand"), 3.0)
+	check(world.all_pieces().any(func(p): return p.item_id == "torch_stand" and world.underground_at(p.global_position)),
+		"a torch stand set down there, for everyone")
+
+	# (A hut with beds in the Valley, for Bob, later.)
+	var vsite: Vector3 = world.build.debug_find_site(world._spawn + Vector3(0, 0, 14), 3.0)
+	PN.ask("debug_hut", [vsite])
+	await _until(func(): return _beds().size() >= 1, 8.0)
+	var bob_bed: int = WN.nid(_beds()[0]) if not _beds().is_empty() else 0
+	var bob_bed_at: Vector3 = _beds()[0].global_position if not _beds().is_empty() else Vector3.ZERO
+
+	print("out to the Cove")
+	var day0: int = world.day_night.day
+	var stone0: int = player.inventory.count("stone")
+	await _tp(t.cave_mouth + Vector3(0.8, 0.2, 0))
+	_arrived = ""
+	world.travel("cove", "sea_cave")   # (what walking into the mouth does)
+	await _until(func(): return not _arrived.is_empty(), 45.0)
+	check(_arrived == "cove", "the hub starts the Cove's server and sends her on (%s)" % (_arrived if not _arrived.is_empty() else "never arrived: %s" % [_toasts.slice(-3)]))
+	if _arrived != "cove":
+		return
+	check(FileAccess.file_exists(SRV + "/land-cove.log"), "(the Cove's server logs beside server.json)")
+	await _load_world()
+	check(world.worldlet_id() == "cove", "Alice is in the Cove")
+	check(world.sea_cave != null and player.global_position.distance_to(world.sea_cave.front) < 2.0,
+		"on its shore, by the sea cave (%.1f m off)" % player.global_position.distance_to(world.sea_cave.front))
+	check(player.inventory.count("antler_pickaxe") == 1 and player.inventory.count("stone") == stone0, "with her bag as it was")
+	check(world.day_night.day == day0, "the same day: one clock for every land")
+	check(world.sea_cave.open(), "the sea cave leads back up (the hub says the tunnel's through)")
+	var bob := await _bob({"do": "report"})
+	check(not bob.has("error") and not bob.is_empty(), "Bob carries on in the Valley, on the hub (%s)" % bob.get("error", "ok"))
+	await _across_lands(bob_bed, bob_bed_at)
+
+	print("back up to the Valley")
+	_arrived = ""
+	await _tp(world.sea_cave.front)
+	world.sea_cave.interact(player)
+	await _until(func(): return not _arrived.is_empty(), 30.0)
+	check(_arrived == "valley", "into the sea cave: back to the hub (%s)" % _arrived)
+	if _arrived != "valley":
+		return
+	await _load_world()
+	check(world.worldlet_id() == "valley" and world.underground_at(player.global_position)
+		and player.global_position.distance_to(world.tunnel.bottom) < 2.5, "arriving at the bottom of the tunnel")
+
+	print("leave from the Cove, and come back")
+	await _tp(world.tunnel.cave_mouth + Vector3(0.8, 0.2, 0))
+	_arrived = ""
+	world.travel("cove", "sea_cave")
+	await _until(func(): return not _arrived.is_empty(), 30.0)
+	await _load_world()
+	var spot: Vector3 = world.sea_cave.front + Vector3(4.0, 0.0, 2.0)
+	spot.y = world.terrain.sample_height(spot.x, spot.z) + 0.1
+	await _tp(spot)
+	world.queue_free()
+	await process_frame
+	world = null
+	Net.leave()
+	await _sleep(1.5)
+	_arrived = ""
+	r = await _join()
+	await _until(func(): return not _arrived.is_empty(), 30.0)
+	check(_arrived == "cove", "joining the hub again sends her straight on to the Cove (%s)" % _arrived)
+	if _arrived == "cove":
+		await _load_world()
+		check(world.worldlet_id() == "cove" and player.global_position.distance_to(spot) < 1.5,
+			"where she left off (%.1f m off)" % player.global_position.distance_to(spot))
+		print("the Cove's server crashes")
+		var why := {"text": ""}
+		var on_left := func(t): why.text = t
+		Net.left.connect(on_left)
+		var out: Array = []
+		OS.execute("lsof", ["-nP", "-t", "-iUDP:%d" % (PORT + 1)], out)
+		var pid := String(out[0] if not out.is_empty() else "").strip_edges().get_slice("\n", 0)
+		check(pid.is_valid_int(), "(found the Cove's server: pid %s)" % pid)
+		if pid.is_valid_int():
+			OS.kill(int(pid))
+		await _until(func(): return not String(why.text).is_empty(), 15.0)
+		Net.left.disconnect(on_left)
+		check(String(why.text).begins_with("Lost the connection to the Cove"), "Alice is told what happened (%s)" % why.text)
+		world.queue_free()
+		await process_frame
+		world = null
+		_arrived = ""
+		r = await _join()
+		await _until(func(): return not _arrived.is_empty(), 30.0)
+		check(_arrived == "cove", "joining again: the hub starts the Cove's server afresh and sends her back (%s)" % _arrived)
+		if _arrived == "cove":
+			await _load_world()
+			check(world.worldlet_id() == "cove" and player.inventory.count("antler_pickaxe") == 1, "in the Cove, with her things")
+		print("an admin in the Cove kicks someone in the Valley")
+		await _until(func(): return Net.roster.any(func(e): return String(e.name) == "Bob"), 4.0)
+		root.get_node("Chat").say("/kick Bob")
+		await _until(func(): return not Net.roster.any(func(e): return String(e.name) == "Bob"), 6.0)
+		check(not Net.roster.any(func(e): return String(e.name) == "Bob"), "Bob's gone from the server (%s)" % [Net.roster.map(func(e): return e.name)])
+	_finished = true
+
+# --- J3b: chat, the player list, commands and sleep across lands --------------------------
+
+func _across_lands(bob_bed: int, bob_bed_at: Vector3) -> void:
+	var C: Node = root.get_node("Chat")
+	print("chat across lands")
+	await _bob({"do": "say", "text": "hello from the Valley"})
+	await _until(func(): return C.heard.has("Bob: hello from the Valley"), 4.0)
+	check(C.heard.has("Bob: hello from the Valley"), "Bob in the Valley says hello; Alice hears it in the Cove")
+	await _sleep(1.2)   # (chat's flood gap)
+	C.say("hi from the Cove")
+	var heard := false
+	for _i in range(15):
+		var h := await _bob({"do": "heard"})
+		if (h.get("heard", []) as Array).has("Alice: hi from the Cove"):
+			heard = true
+			break
+		await _sleep(0.2)
+	check(heard, "and Bob hears her back")
+
+	print("the player list")
+	await _until(func(): return Net.roster.size() >= 2, 4.0)
+	var where := {}
+	for e in Net.roster:
+		where[String(e.name)] = String(e.land)
+	check(where.get("Alice", "") == "cove" and where.get("Bob", "") == "valley", "everyone, and where they are (%s)" % [where])
+	C.say("/players")
+	await _until(func(): return C.heard.any(func(l): return String(l).begins_with("2 online")), 4.0)
+	var line: String = ""
+	for l in C.heard:
+		if String(l).begins_with("2 online"):
+			line = String(l)
+	check(line.contains("Bob in the Valley") and line.contains("Alice (admin) in the Cove"), "/players from the Cove: %s" % line)
+	C.say("/set wolf_grace_days 5")
+	await _until(func(): return int(Net.server_info.get("wolf_grace_days", 0)) == 5, 4.0)
+	check(int(Net.server_info.get("wolf_grace_days", 0)) == 5, "an admin's /set from the Cove: the hub keeps server.json, and the Cove's rules follow")
+
+	print("sleep needs everyone, in every land")
+	await _bob({"do": "ask", "what": "debug_time", "args": [world.day_night.day, 21.0]})
+	await _until(func(): return world.day_night.hours() > 20.5, 15.0)
+	check(world.day_night.hours() > 20.5, "night in the Valley is night in the Cove (%s)" % world.day_night.clock_text())
+	var day_n: int = world.day_night.day
+	var site: Vector3 = world.build.debug_find_site(player.global_position + Vector3(0, 0, 14), 3.0)
+	PN.ask("debug_hut", [site])
+	await _until(func(): return _beds().size() >= 1, 8.0)
+	check(not _beds().is_empty() and bob_bed != 0, "beds in the Cove and the Valley")
+	if _beds().is_empty() or bob_bed == 0:
+		return
+	await _bob({"do": "tp", "to": [bob_bed_at.x, bob_bed_at.y + 0.1, bob_bed_at.z + 0.9]})
+	await _bob({"do": "bed", "nid": bob_bed})
+	await _bob({"do": "bed", "nid": bob_bed})
+	await _until(func(): return C.heard.any(func(l): return String(l).begins_with("Bob is in bed")), 4.0)
+	check(C.heard.has("Bob is in bed (1 of 2 asleep)"), "Bob gets into bed in the Valley; Alice hears it in the Cove (%s)" % [C.heard.slice(-2)])
+	await _sleep(1.0)
+	check(world.day_night.hours() > 20.5, "and the night goes on: Alice is still up, in another land")
+	var mine: Node3D = _beds()[0]
+	await _tp(mine.global_position + Vector3(0, 0.1, 0.9))
+	_toasts.clear()
+	A.use_bed(player, mine)
+	await _sleep(0.5)
+	A.use_bed(player, mine)
+	await _until(func(): return world.day_night.hours() < 7.0, 5.0)
+	check(world.day_night.hours() >= 5.9 and world.day_night.hours() < 7.0 and world.day_night.day == day_n + 1,
+		"Alice gets into bed in the Cove, and the night passes for both (%s, day %d)" % [world.day_night.clock_text(), world.day_night.day])
+	var life := await _bob({"do": "life"})
+	check(float(life.get("hours", 0)) >= 5.9 and float(life.get("hours", 0)) < 7.0, "Bob wakes to morning in the Valley too (%.1f h)" % float(life.get("hours", 0)))
+
+func _beds() -> Array:
+	return WN.pieces.values().filter(func(p): return is_instance_valid(p) and p.item_id == "bed")
+
+# --- helpers -------------------------------------------------------------------------
+
+## (Re)loads the world for whichever server we're on now.
+func _load_world() -> void:
+	if world != null and is_instance_valid(world):
+		world.queue_free()
+		for _i in range(3):
+			await process_frame
+	var r0: int = WN.received
+	world = load("res://scenes/world.tscn").instantiate()
+	root.add_child(world)
+	for _i in range(8):
+		await physics_frame
+	player = world.player
+	player.set_physics_process(false)
+	await _until(func(): return WN.received > r0, 10.0)
+	await _sleep(0.3)
+
+func _tp(at: Vector3) -> void:
+	PN.ask("debug_tp", [at])
+	await _until(func(): return player.global_position.distance_to(at) < 0.5, 3.0)
+	await _sleep(0.2)
+
+## Swings at the tunnel's face (whichever it is now) until it gives.
+func _dig_face(limit: int) -> void:
+	var t: Node3D = world.tunnel
+	var stage0: int = t.dug if t.opened else -1
+	for _i in range(limit):
+		var f: Node3D = t._face
+		if f == null or not is_instance_valid(f) or (t.dug if t.opened else -1) != stage0:
+			break
+		PN.ask("debug_stats", [{"stamina": 100.0}])
+		A.harvest_hit(player, f, f.global_position)
+		await _sleep(0.12)
+	await _until(func(): return (t.dug if t.opened else -1) != stage0, 3.0)
+	await _sleep(0.3)
+
+func _slot(id: String) -> int:
+	for i in range(player.inventory.size()):
+		var s = player.inventory.get_slot(i)
+		if s != null and s.id == id:
+			return i
+	return -1
+
+func _hold(id: String) -> void:
+	var i := _slot(id)
+	if i >= 0:
+		player.select(i)
+		PN.ask("select", [i])
+
+func _join() -> String:
+	var state := {"done": false, "reason": ""}
+	var ok := func(): state.done = true
+	var bad := func(why): state.done = true; state.reason = why
+	Net.joined.connect(ok)
+	Net.join_failed.connect(bad)
+	Net.join("127.0.0.1:%d" % PORT)
+	var t := 0.0
+	while not state.done and t < 25.0:
+		await _sleep(0.05)
+		t += 0.05
+	Net.joined.disconnect(ok)
+	Net.join_failed.disconnect(bad)
+	return state.reason if state.done else "test timed out"
+
+func _new_bob() -> Dictionary:
+	_bob_dir = "%s/b1" % BOBS
+	DirAccess.make_dir_recursive_absolute(_bob_dir)
+	_cmd = 0
+	_spawn(["--identity", DIR + "/bob_lands_id", "--name", "Bob", "--address", "127.0.0.1:%d" % PORT, "--dir", _bob_dir],
+		"res://tests/net_world_bot.gd")
+	return await _bob_result(0, 30.0)
+
+func _bob(cmd: Dictionary) -> Dictionary:
+	_cmd += 1
+	var f := FileAccess.open("%s/cmd_%d.json" % [_bob_dir, _cmd], FileAccess.WRITE)
+	f.store_string(JSON.stringify(cmd))
+	f.close()
+	return await _bob_result(_cmd, 20.0)
+
+func _bob_result(n: int, limit: float) -> Dictionary:
+	var path := "%s/res_%d.json" % [_bob_dir, n]
+	var t := 0.0
+	while not FileAccess.file_exists(path) and t < limit:
+		await _sleep(0.05)
+		t += 0.05
+	await _sleep(0.05)
+	var d: Variant = JSON.parse_string(FileAccess.get_file_as_string(path)) if FileAccess.file_exists(path) else null
+	return d if d is Dictionary else {"error": "Bob gave no answer to command %d" % n}
+
+func _spawn(user_args: Array, script: String = "", bin: String = "") -> int:
+	var args := PackedStringArray(["--headless"])
+	if bin.is_empty():
+		args.append_array(["--path", ProjectSettings.globalize_path("res://")])
+	if not script.is_empty():
+		args.append_array(["--script", script])
+	args.append("--")
+	for x in user_args:
+		args.append(str(x))
+	args.append_array(["--exit-with", str(OS.get_process_id())])
+	var pid := OS.create_process(OS.get_executable_path() if bin.is_empty() else bin, args)
+	_pids.append(pid)
+	return pid
+
+func _until(cond: Callable, limit: float) -> bool:
+	var t := 0.0
+	while not cond.call() and t < limit:
+		await _sleep(0.05)
+		t += 0.05
+	return cond.call()
+
+func _sleep(s: float) -> void:
+	await create_timer(s).timeout
+
+static func _rm_tree(d: String) -> void:
+	var da := DirAccess.open(d)
+	if da == null:
+		return
+	for sub in da.get_directories():
+		_rm_tree(d.path_join(sub))
+	for f in da.get_files():
+		da.remove(f)
+	DirAccess.remove_absolute(d)

tests/test_net_lands.gd.uid

@@ -0,0 +1 @@
+uid://dh6t6lxjmhj8m

tests/test_net_life.gd

@@ -269,7 +269,8 @@ func _sleeping() -> void:
 	await _sleep(0.5)
 	A.use_bed(player, beds[0])
 	await _sleep(1.0)
-	check(_toasts.any(func(t): return t.begins_with("You're in bed (1 of 2")), "Alice gets into bed: 1 of 2 asleep (%s)" % [_toasts])
+	check(_toasts.any(func(t): return t == "You're in bed: waiting for everyone else to go to bed (1 of 2 asleep)"),
+		"Alice gets into bed: waiting for the others, 1 of 2 asleep (%s)" % [_toasts])
 	check(world.day_night.hours() > 20.5, "and the night goes on, because Bob's still up")
 	await _bob({"do": "bed", "nid": WN.nid(beds[1])})
 	await _bob({"do": "bed", "nid": WN.nid(beds[1])})

tests/test_net_rules.gd

@@ -194,9 +194,14 @@ func _pvp() -> void:
 	await _bob({"do": "ask", "what": "hit_player", "args": [Net.local_peer]})
 	await _sleep(0.6)
 	check(PN.hurts == hurts0 and player.survival.health >= h0 - 0.5, "with PvP off, Bob's club does nothing to Alice")
+	# The map (issue #1): with PvP off, Bob is on Alice's map...
+	var MS: Script = load("res://scripts/ui/map_screen.gd")
+	await _until(func(): return not MS.others(world).is_empty(), 3.0)
+	check(MS.others(world).any(func(o): return o.name == "Bob"), "co-op: Bob shows on Alice's map (%s)" % [MS.others(world).map(func(o): return o.name)])
 	C.say("/set pvp true")
 	await _until(func(): return bool(Net.server_info.get("pvp", false)), 2.0)
 	check(bool(Net.server_info.get("pvp", false)), "Alice turns PvP on, and every game hears the new rules")
+	check(MS.others(world).is_empty(), "...and with PvP on, nobody's on the map but you")
 	await _bob({"do": "ask", "what": "hit_player", "args": [Net.local_peer]})
 	await _until(func(): return PN.hurts > hurts0, 2.0)
 	await _sleep(0.3)

tests/test_tunnel.gd

@@ -235,9 +235,25 @@ func _body() -> void:
 	check(player.inventory.count("stone") == stone0 and player.inventory.count("antler_pickaxe") == 1, "with your bag as it was")
 	check(w.day_night.day == day0, "on the same day")
 	check(w.tunnel == null, "(the Cove has no tunnel of its own: it's the Valley's)")
+	# Save and quit in the Cove, then load the world again from the menu.
+	print("save and quit in the Cove")
+	var spot: Vector3 = w.sea_cave.front + Vector3(5.0, 0.0, 3.0)
+	spot.y = w.terrain.sample_height(spot.x, spot.z) + 0.1
+	player.global_position = spot
+	w.save_now()
+	await _drop_world(w)
+	check(S.list_worlds().any(func(m): return String(m.get("worldlet", "")) == "cove"), "the Load list has the world in the Cove")
+	w = await _load_world()
+	player = w.player
+	check(w.worldlet_id() == "cove", "loading it again: still in the Cove")
+	check(player.global_position.distance_to(spot) < 1.0, "right where you saved (%.1f m off)" % player.global_position.distance_to(spot))
 
 	print("back up home")
 	check(w.sea_cave.open(), "the sea cave leads back up (the tunnel's dug)")
+	# A day and a half in the Cove before going home.
+	w.day_night.advance(w.day_night.day_length * 1.5)
+	var cove_day: int = w.day_night.day
+	var cove_time: float = w.day_night.time
 	_went = ""
 	w.sea_cave.interact(player)
 	check(_went == "valley", "into the cave: back to the Valley")
@@ -247,6 +263,8 @@ func _body() -> void:
 	player = w.player
 	check(w.worldlet_id() == "valley" and w.underground_at(player.global_position) and player.global_position.distance_to(t.bottom) < 2.0,
 		"arriving at the bottom of the tunnel")
+	check(w.day_night.day == cove_day and absf(w.day_night.time - cove_time) < 0.01,
+		"one clock for every land: home is on the Cove's day and hour (day %d), not the one you left it" % w.day_night.day)
 	t.go_out(player)
 	await physics_frame
 	check(not w.underground_at(player.global_position) and player.global_position.distance_to(t.seam_out) < 1.0, "climb out at the top, on the clifftop")

tests/test_worldlet_pick.gd

@@ -84,6 +84,10 @@ func _body(S: Node, Net: Node) -> void:
 	await process_frame
 	check(hp.disabled and TS.picked_worldlet(hp) == "valley", "an island already made: shows its worldlet, locked")
 	check(title._host_seed_label.text == "Seed (kept)", "(like its seed)")
+	check(title._host_msg.text.contains("forward UDP 24242 and 24243 (the Cove)"),
+		"the Host page says which ports to forward, the Cove's too (%s)" % title._host_msg.text.get_slice("\n", 1))
+	var L: Node = root.get_node("Lands")
+	check(L.extra_ports("valley", 24242) == [["cove", 24243]], "(the Valley's lands: the Cove on 24243)")
 	# A worldlet that isn't a start (an island made elsewhere) is still shown.
 	var extra := OptionButton.new()
 	extra.add_item("Valley")

tools/site/guide_sections.md

@@ -43,7 +43,7 @@ The tutorial island is calm: no wolf pack (just one demonstration wolf), no bear
 - `1` to `8` or the mouse wheel pick a hotbar slot.
 - `K` and `M` move the hotbar up and down your bag's rows, so `1` to `8` pick from the row above or below. The hotbar shows which row you're on.
 - `Q` drops what you're holding at your feet; `Shift` and `Q` drops just one.
-- `N` opens the map. It starts blank and fills in as you explore, marking the places you've found, your camp and your bed. You're the white dot.
+- `N` opens the map. It starts blank and fills in as you explore, marking the places you've found, your camp and your bed. You're the white dot. On a co-op server, the other players in your land show as green dots with their names; with PvP on (friendly rivals or adversarial), the map shows nobody but you.
 - The compass across the top of the screen shows which way you're facing.
 - `Tab` or `I` opens your inventory and crafting.
 - In the inventory: `Left click` picks up or puts down a stack, `Right click` splits a stack or puts down one, `Shift` + click moves a stack to or from a chest, `Shift` + click on **Craft** makes up to five.
@@ -332,7 +332,7 @@ It doesn't run and ignores fire. If dawn comes, or everyone leaves or dies, it f
 
 ## The journey {#journey}
 
-The Valley is only the start. Beyond it lie other lands, each reached a different way, and each with its own ground, weather and creatures. The first is the **Cove**, down at the foot of the sea cliffs. For now the journey is single-player; on a server everyone stays in the Valley.
+The Valley is only the start. Beyond it lie other lands, each reached a different way, and each with its own ground, weather and creatures. The first is the **Cove**, down at the foot of the sea cliffs. On a server, players can be in different lands at once: the tunnel and its lights are shared, and walking out to the Cove takes you on to the Cove's own server (started for you, on the server's next UDP port: 24243 if the server's on 24242). Friends playing over the internet need that port forwarded too. Leave from the Cove and you'll be back there next time you join.
 
 ### The cliff tunnel
 
@@ -345,12 +345,12 @@ The Valley is only the start. Beyond it lie other lands, each reached a differen
 
 ### The Cove
 
-Low hills run down to a sheltered sandy bay, with mountains behind and a small pond inland. Wade out from the beach and it gets deeper slowly; swim too far and a strong current carries you back to the shore.
+Low hills run down to a sheltered sandy bay, with mountains behind, a small pond inland, and a stream that runs from a spring under the mountains down to the sea. You can wade the stream anywhere, and trout bite in it. Wade out from the beach and it gets deeper slowly; swim too far and a strong current carries you back to the shore.
 
 - **The pier** runs out over the bay. Fish off its end for **mackerel**, the usual catch. **Cod** are bigger but only bite where the water's at least 2.2 m deep, so cast well out. Both bite best at dawn and dusk, and grill at a campfire, salt or smoke like lake fish.
 - **The sea cave** at the end of the beach is the way back: `E` goes into it and up the same tunnel, arriving at the bottom.
 
-Each land keeps its own state. What you build in the Valley waits for you while you're away, and time stands still in a land you're not in.
+Each land keeps its own state, and there's one clock for them all. What you build in the Valley waits for you while you're away, and when you come back the time you were gone catches up, as after a night's sleep: kilns and smelters will have done their work, fires burned down and food gone off. Nothing roams a land while you're away, so your base won't have been raided.
 
 ## Multiplayer {#multiplayer}
 
@@ -360,7 +360,7 @@ Set a name (3 to 16 letters, digits, spaces, `_` or `-`), tunic colour, hair col
 
 ### Hosting
 
-**Host Game** starts a server on your computer and puts you in. Pick a server name, a rules preset, an optional password, the port (24242 by default) and, the first time, a seed. As its first player you're its admin. A message tells you the addresses friends can join at. Leaving saves the island and stops the server; next time it carries on. On a Mac, allow incoming connections if asked.
+**Host Game** starts a server on your computer and puts you in. Pick a server name, a rules preset, an optional password, the port (24242 by default) and, the first time, a seed. As its first player you're its admin. A message tells you the addresses friends can join at, and the page says which UDP ports to forward for friends over the internet (24242, and 24243 for the Cove's server). Leaving saves the island and stops the server; next time it carries on. On a Mac, allow incoming connections if asked.
 
 ### Dedicated servers
 
@@ -372,7 +372,7 @@ A spare computer can run an always-on server with no window, set up in its `serv
 
 ### Playing together
 
-The server decides everything, so the pause menu doesn't pause; it lists who's online and has **Disconnect**. Each player has their own bed. Only you can open your grave. Looking at someone's piece shows whose it is. More players means more animals about, and the wolf pack splits between the players it hunts, preferring those away from a fire. The night passes once enough players are in bed.
+The server decides everything, so the pause menu doesn't pause; it lists who's online, and which land each of them is in, and has **Disconnect**. Chat reaches everyone, whatever land they're in. Each player has their own bed. Only you can open your grave. Looking at someone's piece shows whose it is. More players means more animals about, and the wolf pack splits between the players it hunts, preferring those away from a fire. The night passes once enough players are in bed, counting everyone in every land: get into bed while others are up and you'll see "waiting for everyone else to go to bed", and everyone hears in chat that you're in bed.
 
 ### Rules and presets
 

tools/site/index.html

@@ -91,6 +91,7 @@
       <li>Weather that matters: storms, blizzards and hard winters.</li>
       <li>A bear, a barrow, and the Old Stag at the standing stones.</li>
       <li>Dig down through the sea cliffs to the Cove, and fish off its pier.</li>
+      <li>On a server, friends can be in different lands at once.</li>
       <li>A map that fills in as you explore, and a compass.</li>
       <li>Play alone, or host a server for friends on your own machine.</li>
       <li>A guided tutorial with Old Tam the hermit.</li>
@@ -100,9 +101,13 @@
   <section aria-labelledby="host-title">
     <h2 id="host-title">Playing with friends</h2>
     <p>Choose <b>Host Game</b> on the title screen, and friends choose <b>Join Game</b>
-      with your address (UDP port 24242). Everyone needs the same version. A spare
+      with your address (UDP port 24242). Everyone needs the same version. On the same
-      computer can run a dedicated server from the same download:
+      network, or over Tailscale, that's all. For friends over the internet, forward
-      <code>Emberwild --headless -- --server</code>.</p>
+      <b>UDP 24242 and 24243</b> on your router: the Cove runs as its own server on the
+      next port, started when someone first goes there. A spare computer can run a
+      dedicated server from the same download:
+      <code>Emberwild --headless -- --server</code>.
+      <a href="guide.html#multiplayer">More in the guide</a>.</p>
   </section>
 </main>
 

tools/site/make_site.sh

@@ -52,3 +52,12 @@ DATA=build/site_data.json
 	|| { echo "couldn't dump the game data for the guide"; exit 1; }
 python3 tools/site/make_guide.py "$DATA" build/site || exit 1
 rm -f "$DATA"
+
+# Cloudflare Pages refuses any file over 25 MiB: catch it here, not at deploy.
+LIMIT=26214400
+for f in build/site/*; do
+	s=$(stat -f %z "$f" 2>/dev/null || stat -c %s "$f")
+	if [ "$s" -ge "$LIMIT" ]; then
+		echo "$f is $s bytes: over Cloudflare Pages' 25 MiB limit (re-encode the trailer smaller)"; exit 1
+	fi
+done

tools/trailer/make_trailer.sh

@@ -32,7 +32,7 @@ ffmpeg -v error -y -i "$RAW" -f lavfi -i "aevalsrc='$PAD|$PAD_R':s=48000:d=$D" \
 	-filter_complex "[1:a]lowpass=f=1800,aecho=0.8:0.7:180|340:0.35|0.25,afade=t=in:d=2.5,afade=t=out:st=$OUT_AT:d=2.5[m];[0:a]volume=0.8[g];[g][m]amix=inputs=2:duration=first:normalize=0[a]" \
 	-map 0:v -map "[a]" -vf "scale=in_range=pc:out_range=tv,format=yuv420p" -color_range tv \
 	-colorspace bt709 -color_primaries bt709 -color_trc bt709 \
-	-c:v libx264 -profile:v high -level 4.0 -preset slow -crf 20 -tag:v avc1 \
+	-c:v libx264 -profile:v high -level 4.0 -preset slow -crf 23 -maxrate 3500k -bufsize 7000k -tag:v avc1 \
 	-c:a aac -b:a 160k -movflags +faststart "$OUT" || exit 1
 # The title, for the download page's poster.
 ffmpeg -v error -y -ss 4.5 -i "$OUT" -frames:v 1 -q:v 3 build/trailer/poster.jpg

tools/trailer/trailer.gd

@@ -322,6 +322,7 @@ func _shot_cove() -> void:
 	if pier == null:
 		return
 	var side: Vector3 = pier.dir.cross(Vector3.UP)
+	# (From out over the bay, with the stream's mouth along the shore.)
 	var from: Vector3 = pier.end + pier.dir * 18.0 + side * 14.0 + Vector3(0, 2.5, 0)
 	var to: Vector3 = pier.end + pier.dir * 6.0 + side * 7.0 + Vector3(0, 1.6, 0)
 	await _shot(6.0, func(_t: float, k: float):