feat(traffic): implement autonomous City Traffic Engine and Living Urban Crowd Engine from CBT dump

2026-09-18 14:19:52 +07:00
1 parent f2a36fe188
commit 67bdbae24b
@@ -0,0 +1,377 @@
+using System.Collections.Concurrent;
+using System.Text.Json;
+using Ananta.SDK.Network;
+
+namespace Ananta.Server.Gameplay.Traffic;
+
+public sealed class CityTrafficEngine
+{
+    public static CityTrafficEngine Instance { get; } = new();
+
+    private ITrafficVehicleDriver? _driver;
+    private Func<IEnumerable<TcpSession>>? _sessionProvider;
+
+    private readonly ConcurrentDictionary<ulong, SimulatedVehicle> _simulatedVehicles = new();
+    private RoadNetworkFile? _roadNetwork;
+    private readonly Dictionary<int, RoadLaneData> _laneLookup = new();
+
+    private CancellationTokenSource? _cts;
+    private Task? _simulationLoopTask;
+
+    // Traffic Configuration
+    public bool Enabled { get; set; } = true;
+    public int TargetDensity { get; set; } = 20;
+    public float SpeedScale { get; set; } = 1.0f;
+    public float MinSpawnDistance { get; set; } = 50f;
+    public float MaxSpawnDistance { get; set; } = 160f;
+    public float DespawnDistance { get; set; } = 220f;
+
+    // Pool of verified vehicle configs with full models and multi-seat support
+    private static readonly uint[] TrafficVehiclePool =
+    [
+        81001001, // Sunset Skywing (Sedan)
+        81001002, // Korou RV6 (SUV)
+        81001003, // Kazama Voyage (Sedan)
+        81000007, // Sunset GT-X Specter (Sports Car)
+        81000002, // Korou Transporter M (Truck)
+        81000005, // Erebos Black Box (Van)
+    ];
+
+    private readonly Random _rng = new();
+
+    public sealed class SimulatedVehicle
+    {
+        public ulong EntityId { get; set; }
+        public uint ConfigId { get; set; }
+        public int CurrentLaneId { get; set; }
+        public float DistanceOnLane { get; set; }
+        public float Speed { get; set; }
+        public float X { get; set; }
+        public float Y { get; set; }
+        public float Z { get; set; }
+        public float Yaw { get; set; }
+        public DateTime CreatedAt { get; set; }
+        public bool HijackedByPlayer { get; set; }
+    }
+
+    public void Initialize(string clientDataPath, ITrafficVehicleDriver driver, Func<IEnumerable<TcpSession>> sessionProvider)
+    {
+        _driver = driver;
+        _sessionProvider = sessionProvider;
+
+        var roadPath = Path.Combine(clientDataPath, "World", "RoadNetwork.json");
+        if (!File.Exists(roadPath))
+        {
+            Console.WriteLine($"[TRAFFIC] RoadNetwork.json not found at: {roadPath}");
+            return;
+        }
+
+        try
+        {
+            Console.WriteLine($"[TRAFFIC] Loading road network from: {roadPath}...");
+            var json = File.ReadAllText(roadPath);
+            _roadNetwork = JsonSerializer.Deserialize<RoadNetworkFile>(json);
+            if (_roadNetwork is not null)
+            {
+                foreach (var lane in _roadNetwork.Lanes)
+                {
+                    lane.Precompute();
+                    _laneLookup[lane.Id] = lane;
+                }
+                Console.WriteLine($"[TRAFFIC] Road network loaded: {_roadNetwork.Lanes.Count} lanes precomputed across {_roadNetwork.SpatialGrid.Count} spatial cells.");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine($"[TRAFFIC] Failed to load road network: {ex.Message}");
+        }
+
+        Start();
+    }
+
+    public void Start()
+    {
+        if (_simulationLoopTask is not null && !_simulationLoopTask.IsCompleted)
+            return;
+
+        _cts = new CancellationTokenSource();
+        _simulationLoopTask = Task.Run(() => SimulationLoopAsync(_cts.Token));
+        Console.WriteLine("[TRAFFIC] Autonomous City Traffic Engine started.");
+    }
+
+    public void Stop()
+    {
+        _cts?.Cancel();
+    }
+
+    private async Task SimulationLoopAsync(CancellationToken token)
+    {
+        const int tickIntervalMs = 100; // 10 ticks per second for smooth client replication
+        const float dt = tickIntervalMs / 1000f;
+
+        while (!token.IsCancellationRequested)
+        {
+            try
+            {
+                if (Enabled && _driver is not null && _sessionProvider is not null && _roadNetwork is not null)
+                {
+                    var sessions = _sessionProvider().ToList();
+                    foreach (var session in sessions)
+                    {
+                        await TickSessionTrafficAsync(session, dt);
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                // Engine tick exception guard
+                Console.WriteLine($"[TRAFFIC-ERROR] Loop exception: {ex.Message}");
+            }
+
+            try
+            {
+                await Task.Delay(tickIntervalMs, token);
+            }
+            catch (OperationCanceledException)
+            {
+                break;
+            }
+        }
+    }
+
+    private async Task TickSessionTrafficAsync(TcpSession session, float dt)
+    {
+        if (_driver is null || _roadNetwork is null)
+            return;
+
+        var (hasPlayer, px, py, pz, pyaw, raidId) = _driver.GetPlayerPosition(session);
+        if (!hasPlayer || !float.IsFinite(px) || !float.IsFinite(pz))
+            return;
+
+        // 1. Move and update existing simulated vehicles
+        var vehicleEntries = _simulatedVehicles.Values.ToList();
+        foreach (var v in vehicleEntries)
+        {
+            if (v.HijackedByPlayer)
+                continue;
+
+            // Check if player has boarded or driven this vehicle
+            if (_driver.IsVehiclePlayerControlled(v.EntityId))
+            {
+                v.HijackedByPlayer = true;
+                _simulatedVehicles.TryRemove(v.EntityId, out _);
+                Console.WriteLine($"[TRAFFIC] Player took control of traffic vehicle entity={v.EntityId}!");
+                continue;
+            }
+
+            // Distance to player
+            var dx = v.X - px;
+            var dz = v.Z - pz;
+            var distSq = dx * dx + dz * dz;
+
+            if (distSq > DespawnDistance * DespawnDistance)
+            {
+                // Despawn far away vehicle
+                _simulatedVehicles.TryRemove(v.EntityId, out _);
+                await _driver.DestroyTrafficVehicleAsync(session, v.EntityId);
+                continue;
+            }
+
+            // Advance vehicle along lane
+            if (!_laneLookup.TryGetValue(v.CurrentLaneId, out var currentLane) || currentLane.TotalLength <= 0.1f)
+            {
+                _simulatedVehicles.TryRemove(v.EntityId, out _);
+                await _driver.DestroyTrafficVehicleAsync(session, v.EntityId);
+                continue;
+            }
+
+            v.DistanceOnLane += v.Speed * SpeedScale * dt;
+
+            // Check if vehicle reached the end of the lane
+            if (v.DistanceOnLane >= currentLane.TotalLength)
+            {
+                if (currentLane.Next.Count > 0)
+                {
+                    // Pick next connected lane
+                    var nextLaneId = currentLane.Next[_rng.Next(currentLane.Next.Count)];
+                    if (_laneLookup.TryGetValue(nextLaneId, out var nextLane))
+                    {
+                        v.CurrentLaneId = nextLaneId;
+                        v.DistanceOnLane = 0f;
+                        v.Speed = nextLane.Speed > 0 ? nextLane.Speed : currentLane.Speed;
+                        currentLane = nextLane;
+                    }
+                    else
+                    {
+                        // Unresolved next lane -> despawn
+                        _simulatedVehicles.TryRemove(v.EntityId, out _);
+                        await _driver.DestroyTrafficVehicleAsync(session, v.EntityId);
+                        continue;
+                    }
+                }
+                else
+                {
+                    // Dead end -> despawn
+                    _simulatedVehicles.TryRemove(v.EntityId, out _);
+                    await _driver.DestroyTrafficVehicleAsync(session, v.EntityId);
+                    continue;
+                }
+            }
+
+            // Calculate new spline position & velocity
+            var (nx, ny, nz, nyaw, vx, vz) = currentLane.Evaluate(v.DistanceOnLane, v.Speed * SpeedScale);
+            v.X = nx;
+            v.Y = ny;
+            v.Z = nz;
+            v.Yaw = nyaw;
+
+            // Send smooth SyncVehicleMove to client
+            await _driver.SendVehicleMoveAsync(session, v.EntityId, nx, ny, nz, nyaw, vx, vz);
+        }
+
+        // 2. Spawn new vehicles if below target density
+        var activeCount = _simulatedVehicles.Count;
+        if (activeCount < TargetDensity)
+        {
+            await TrySpawnTrafficVehicleAroundPlayerAsync(session, px, py, pz, pyaw);
+        }
+    }
+
+    private async Task<bool> TrySpawnTrafficVehicleAroundPlayerAsync(
+        TcpSession session, float px, float py, float pz, float pyaw)
+    {
+        if (_driver is null || _roadNetwork is null)
+            return false;
+
+        // Query spatial cells around player
+        var grid = _roadNetwork.SpatialGrid;
+        var gridSize = _roadNetwork.Metadata.GridSize;
+        var centerCx = (int)MathF.Floor(px / gridSize);
+        var centerCz = (int)MathF.Floor(pz / gridSize);
+
+        var candidateLanes = new List<RoadLaneData>();
+        var minSq = MinSpawnDistance * MinSpawnDistance;
+        var maxSq = MaxSpawnDistance * MaxSpawnDistance;
+
+        // Search 3x3 surrounding cells (~300m range)
+        for (var cx = centerCx - 2; cx <= centerCx + 2; cx++)
+        {
+            for (var cz = centerCz - 2; cz <= centerCz + 2; cz++)
+            {
+                var ckey = $"{cx}_{cz}";
+                if (grid.TryGetValue(ckey, out var laneIds))
+                {
+                    foreach (var lId in laneIds)
+                    {
+                        if (_laneLookup.TryGetValue(lId, out var lane) && lane.TotalLength > 10f)
+                        {
+                            var laneStart = lane.Pts[0];
+                            var ldx = laneStart[0] - px;
+                            var ldz = laneStart[2] - pz;
+                            var dSq = ldx * ldx + ldz * ldz;
+                            if (dSq >= minSq && dSq <= maxSq)
+                            {
+                                candidateLanes.Add(lane);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        if (candidateLanes.Count == 0)
+            return false;
+
+        // Pick a random lane from candidates
+        var chosenLane = candidateLanes[_rng.Next(candidateLanes.Count)];
+
+        // Check if there is already a vehicle near the start of this lane
+        foreach (var existing in _simulatedVehicles.Values)
+        {
+            if (existing.CurrentLaneId == chosenLane.Id && existing.DistanceOnLane < 20f)
+                return false; // Lane entry occupied
+        }
+
+        // Evaluate spawn coordinates at start of lane
+        var (sx, sy, sz, syaw, _, _) = chosenLane.Evaluate(0f, 0f);
+
+        // Pick vehicle config
+        var configId = TrafficVehiclePool[_rng.Next(TrafficVehiclePool.Length)];
+
+        var (ok, entityId) = await _driver.SpawnTrafficVehicleAsync(session, configId, sx, sy, sz, syaw);
+        if (!ok || entityId == 0)
+            return false;
+
+        var simVehicle = new SimulatedVehicle
+        {
+            EntityId = entityId,
+            ConfigId = configId,
+            CurrentLaneId = chosenLane.Id,
+            DistanceOnLane = 0f,
+            Speed = chosenLane.Speed > 0f ? chosenLane.Speed : 11.11f,
+            X = sx,
+            Y = sy,
+            Z = sz,
+            Yaw = syaw,
+            CreatedAt = DateTime.UtcNow,
+            HijackedByPlayer = false
+        };
+
+        _simulatedVehicles[entityId] = simVehicle;
+        return true;
+    }
+
+    public async Task<int> SpawnWaveAheadAsync(TcpSession session, int count = 5)
+    {
+        if (_driver is null || _roadNetwork is null)
+            return 0;
+
+        var (hasPlayer, px, py, pz, pyaw, _) = _driver.GetPlayerPosition(session);
+        if (!hasPlayer)
+            return 0;
+
+        var spawned = 0;
+        for (var i = 0; i < count; i++)
+        {
+            if (await TrySpawnTrafficVehicleAroundPlayerAsync(session, px, py, pz, pyaw))
+                spawned++;
+        }
+        return spawned;
+    }
+
+    public async Task ClearAllTrafficAsync(TcpSession session)
+    {
+        if (_driver is null)
+            return;
+
+        var ids = _simulatedVehicles.Keys.ToList();
+        _simulatedVehicles.Clear();
+
+        foreach (var id in ids)
+        {
+            await _driver.DestroyTrafficVehicleAsync(session, id);
+        }
+
+        Console.WriteLine($"[TRAFFIC] Cleared {ids.Count} traffic vehicles.");
+    }
+
+    public TrafficStatus GetStatus() => new()
+    {
+        Enabled = Enabled,
+        TargetDensity = TargetDensity,
+        SpeedScale = SpeedScale,
+        ActiveVehicles = _simulatedVehicles.Count,
+        TotalRoadLanes = _roadNetwork?.Lanes.Count ?? 0,
+        TotalSpatialCells = _roadNetwork?.SpatialGrid.Count ?? 0
+    };
+}
+
+public sealed class TrafficStatus
+{
+    public bool Enabled { get; set; }
+    public int TargetDensity { get; set; }
+    public float SpeedScale { get; set; }
+    public int ActiveVehicles { get; set; }
+    public int TotalRoadLanes { get; set; }
+    public int TotalSpatialCells { get; set; }
+}