feat: scene ghosting, as the client streams a zone's scenes

The client keeps the scene under the player loaded, the scenes the zone
file's transitions connect to it, and the global scene
(Zone::StreamScenesAroundPosition 0x0108a3f0, TerrainManager::GetSceneAtPos
0x01069010, the connected scenes at 0x01066500; transitions naming a
missing scene dropped as Zone::FixupInvalidTransitions 0x010842e0 does).

- ZoneScenes (dCommon): the terrain's scene map lookup and the scene graph,
  shared by the world server and the dashboard.
- Objects remember the scene they were placed in (spawners pass theirs on).
- ghosting_scenes=1 (world config, off by default): players get the objects
  of their loaded scenes instead of the ones within the ghosting distances;
  objects from no scene go by the scene under them. Zones without a scene
  map keep distance ghosting.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

dCommon/ZoneScenes.cpp

@@ -0,0 +1,85 @@
+#include "ZoneScenes.h"
+
+#include <algorithm>
+#include <cmath>
+
+namespace ZoneScenes {
+	namespace {
+		// The client's margin on chunk edges (FLOAT_01479f24)
+		constexpr float EDGE = 0.001f;
+	}
+
+	SceneMap::SceneMap(const Raw::Raw& raw) {
+		bool first = true;
+		for (const auto& chunk : raw.chunks) {
+			if (!chunk.IsValidForSceneLookup() || chunk.sceneMap.size() < static_cast<size_t>(chunk.colorMapResolution) * chunk.colorMapResolution) continue;
+			Chunk out;
+			out.minX = chunk.offsetX;
+			out.minZ = chunk.offsetZ;
+			out.maxX = chunk.offsetX + static_cast<float>(chunk.width - 1) * chunk.scaleFactor;
+			out.maxZ = chunk.offsetZ + static_cast<float>(chunk.height - 1) * chunk.scaleFactor;
+			out.resolution = chunk.colorMapResolution;
+			out.cellsPerUnitX = static_cast<float>(chunk.colorMapResolution) / (static_cast<float>(chunk.width - 1) * chunk.scaleFactor);
+			out.cellsPerUnitZ = static_cast<float>(chunk.colorMapResolution) / (static_cast<float>(chunk.height - 1) * chunk.scaleFactor);
+			out.scenes = chunk.sceneMap;
+			m_MinX = first ? out.minX : std::min(m_MinX, out.minX);
+			m_MinZ = first ? out.minZ : std::min(m_MinZ, out.minZ);
+			m_MaxX = first ? out.maxX : std::max(m_MaxX, out.maxX);
+			m_MaxZ = first ? out.maxZ : std::max(m_MaxZ, out.maxZ);
+			first = false;
+			m_Chunks.push_back(std::move(out));
+		}
+	}
+
+	uint32_t SceneMap::SceneAt(float x, float z) const {
+		if (m_Chunks.empty() || !std::isfinite(x) || !std::isfinite(z)) return GLOBAL_SCENE;
+		// As TerrainManager's chunk lookup (0x01065c00): clamped to the terrain, then to one cell inside its far edge
+		x = std::clamp(x, m_MinX, m_MaxX);
+		z = std::clamp(z, m_MinZ, m_MaxZ);
+		for (const auto& chunk : m_Chunks) {
+			const auto px = std::min(x, m_MaxX - 1.0f / chunk.cellsPerUnitX);
+			const auto pz = std::min(z, m_MaxZ - 1.0f / chunk.cellsPerUnitZ);
+			if (px < chunk.minX - EDGE || px >= chunk.maxX - EDGE || pz < chunk.minZ - EDGE || pz >= chunk.maxZ - EDGE) continue;
+			const auto last = static_cast<int64_t>(chunk.resolution) - 1;
+			const auto cellX = std::clamp(static_cast<int64_t>(std::floor(chunk.cellsPerUnitX * (px - chunk.minX) + 0.5f)), int64_t{ 0 }, last);
+			const auto cellZ = std::clamp(static_cast<int64_t>(std::floor(chunk.cellsPerUnitZ * (pz - chunk.minZ) + 0.5f)), int64_t{ 0 }, last);
+			const auto scene = chunk.scenes[static_cast<size_t>(cellX * chunk.resolution + cellZ)];
+			return scene == NO_SCENE ? GLOBAL_SCENE : scene;
+		}
+		return GLOBAL_SCENE;
+	}
+
+	SceneGraph::SceneGraph(const std::vector<ZoneScene>& scenes, const std::vector<SceneTransition>& transitions) {
+		for (const auto& scene : scenes) m_Scenes.insert(scene.id);
+		const auto link = [this](uint32_t from, uint32_t to) {
+			auto it = std::find_if(m_Neighbours.begin(), m_Neighbours.end(), [from](const auto& entry) { return entry.first == from; });
+			if (it == m_Neighbours.end()) it = m_Neighbours.insert(m_Neighbours.end(), { from, {} });
+			it->second.insert(to);
+		};
+		for (const auto& transition : transitions) {
+			if (transition.points.size() < 2) continue;
+			// The low half of a point's LWOSCENEID is the scene, the high half its layer
+			const auto a = static_cast<uint32_t>(transition.points[0].sceneID & 0xFFFFFFFF);
+			const auto b = static_cast<uint32_t>(transition.points[1].sceneID & 0xFFFFFFFF);
+			if (a == b || !m_Scenes.contains(a) || !m_Scenes.contains(b)) continue;
+			link(a, b);
+			link(b, a);
+		}
+	}
+
+	const std::set<uint32_t>& SceneGraph::Neighbours(uint32_t scene) const {
+		static const std::set<uint32_t> NONE;
+		if (scene == GLOBAL_SCENE) return NONE;
+		const auto it = std::find_if(m_Neighbours.begin(), m_Neighbours.end(), [scene](const auto& entry) { return entry.first == scene; });
+		return it == m_Neighbours.end() ? NONE : it->second;
+	}
+
+	std::set<uint32_t> SceneGraph::Loaded(uint32_t scene) const {
+		std::set<uint32_t> loaded{ GLOBAL_SCENE };
+		if (scene == GLOBAL_SCENE) return loaded;
+		loaded.insert(scene);
+		const auto& neighbours = Neighbours(scene);
+		loaded.insert(neighbours.begin(), neighbours.end());
+		return loaded;
+	}
+}