using System.Collections.Concurrent; using System.Text.Json; using DataServer.Data; using DataServer.Data.Entities; using GameServices; using GameServices.Auth; using Microsoft.EntityFrameworkCore; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Logging; using Server.Networking; using Server.Networking.Handling; using Server.Networking.Messages; namespace GameServer.World; public sealed class WorldHandler : IClientMessageHandler { private const int TileSize = 32; private static readonly TimeSpan NeutralInputGrace = TimeSpan.FromMilliseconds(180); private static readonly TimeSpan DirectionalPriorityGrace = TimeSpan.FromMilliseconds(450); private readonly ILogger _log; private readonly ISessionRegistry _sessions; private readonly IServiceScopeFactory _scopeFactory; private readonly WorldChunkCache _cache; private readonly WorldMovementService _movement; private readonly WorldBroadcastService _broadcast; private readonly WorldEditDeltaHub _deltaHub; private readonly ConcurrentDictionary _players = new(); private readonly ConcurrentDictionary _portalCooldownByCharacter = new(); private readonly bool _debugInput; private Task? _tickTask; private CancellationTokenSource? _tickCts; private long _tick; private volatile bool _initialized; public WorldHandler( ILogger log, ISessionRegistry sessions, IServiceScopeFactory scopeFactory, WorldChunkCache cache, WorldMovementService movement, WorldBroadcastService broadcast, WorldEditDeltaHub deltaHub) { _log = log; _sessions = sessions; _scopeFactory = scopeFactory; _cache = cache; _movement = movement; _broadcast = broadcast; _deltaHub = deltaHub; var debugInputEnv = Environment.GetEnvironmentVariable("WORLD_INPUT_DEBUG"); _debugInput = !string.IsNullOrWhiteSpace(debugInputEnv) && (debugInputEnv == "1" || string.Equals(debugInputEnv, "true", StringComparison.OrdinalIgnoreCase)); } public IReadOnlyCollection SupportedOpCodes => new[] { OpCodes.WORLD_SPAWN_REQUEST, OpCodes.WORLD_INPUT, OpCodes.PONG }; public Task InitializeAsync() { if (_initialized) return Task.CompletedTask; _tickCts = new CancellationTokenSource(); _tickTask = Task.Run(() => TickLoopAsync(_tickCts.Token), _tickCts.Token); _deltaHub.OnDeltaPublished += OnWorldEditDelta; _initialized = true; _log.LogInformation("WorldHandler initialized (cached movement pipeline + live delta forwarding)"); return Task.CompletedTask; } public async Task HandleAsync(int opCode, IConnection connection, ReadOnlyMemory payload, CancellationToken ct) { if (!_initialized) await InitializeAsync(); if (opCode == OpCodes.PONG) return; if (!_sessions.TryGet(connection.Id, out var accountId, out _)) { if (opCode == OpCodes.WORLD_INPUT) return; await _broadcast.SendErrorAsync(connection, "auth_required", ct); return; } if (opCode == OpCodes.WORLD_SPAWN_REQUEST) { await HandleSpawnAsync(connection, accountId, payload, ct); return; } if (opCode == OpCodes.WORLD_INPUT) { HandleInput(connection, accountId, payload); } } public void OnDisconnect(Guid connectionId) { if (_players.TryRemove(connectionId, out var s)) { _ = PersistPlayerLocationAsync(s); _ = _broadcast.BroadcastToRegionAsync( OpCodes.WORLD_DESPAWN, new { playerId = s.CharacterId, reason = "disconnect" }, s.RegionId, _players, s.ConnectionId); } } // ---- Spawn (DB access only here, once per connect) ---- private async Task HandleSpawnAsync(IConnection conn, ulong accountId, ReadOnlyMemory payload, CancellationToken ct) { var req = WorldInputParser.Parse(payload) ?? new WorldInputParser.SpawnReq(); using var scope = _scopeFactory.CreateScope(); var db = scope.ServiceProvider.GetRequiredService(); var account = await db.Accounts.AsNoTracking().FirstOrDefaultAsync(a => a.Id == accountId, ct); if (account == null) { await _broadcast.SendErrorAsync(conn, "account_not_found", ct); return; } var character = await db.DungeonCharacters.FirstOrDefaultAsync(c => c.AccountId == accountId && !c.IsDeleted, ct); if (character == null) { character = new DungeonCharacter { AccountId = accountId, Name = $"Hero_{accountId}", CreatedAt = DateTime.UtcNow, LastPlayedAt = DateTime.UtcNow }; db.DungeonCharacters.Add(character); await db.SaveChangesAsync(ct); } var region = await _cache.ResolveRegionAsync(req.RegionId ?? character.WorldRegionId, ct); if (region == null) { await _broadcast.SendErrorAsync(conn, "region_not_found", ct); return; } await _cache.EnsureZonesAsync(region.Id, ct); var requestedExplicitChunk = req.ZoneX.HasValue || req.ZoneY.HasValue || req.ChunkX.HasValue || req.ChunkY.HasValue; var zx = Math.Clamp(req.ZoneX ?? character.WorldZoneX ?? 0, 0, Math.Max(0, region.ZonesPerRegionX - 1)); var zy = Math.Clamp(req.ZoneY ?? character.WorldZoneY ?? 0, 0, Math.Max(0, region.ZonesPerRegionY - 1)); var cx = Math.Clamp(req.ChunkX ?? character.WorldChunkX ?? 0, 0, Math.Max(0, region.ChunksPerZoneX - 1)); var cy = Math.Clamp(req.ChunkY ?? character.WorldChunkY ?? 0, 0, Math.Max(0, region.ChunksPerZoneY - 1)); var tx = Math.Max(0, Math.Min(region.ChunkWidthTiles - 1, region.ChunkWidthTiles / 2)); var ty = Math.Max(0, Math.Min(region.ChunkHeightTiles - 1, region.ChunkHeightTiles / 2)); var x = requestedExplicitChunk ? WorldMovementService.WorldPxX(region, zx, cx, tx) : (character.WorldX ?? WorldMovementService.WorldPxX(region, zx, cx, tx)); var y = requestedExplicitChunk ? WorldMovementService.WorldPxY(region, zy, cy, ty) : (character.WorldY ?? WorldMovementService.WorldPxY(region, zy, cy, ty)); if (!float.IsFinite(x) || x < (TileSize / 2f)) x = WorldMovementService.WorldPxX(region, zx, cx, tx); if (!float.IsFinite(y) || y < (TileSize / 2f)) y = WorldMovementService.WorldPxY(region, zy, cy, ty); var (pzX, pzY, pcX, pcY) = WorldMovementService.ToChunkPos(region, x, y); var s = new WorldSessionState { ConnectionId = conn.Id, Connection = conn, AccountId = accountId, CharacterId = character.Id, Name = character.Name, IsVip = account.Role >= AccountRole.Vip, RegionId = region.Id, ZoneX = pzX, ZoneY = pzY, ChunkX = pcX, ChunkY = pcY, X = x, Y = y }; _players[conn.Id] = s; character.WorldRegionId = s.RegionId; character.WorldZoneX = s.ZoneX; character.WorldZoneY = s.ZoneY; character.WorldChunkX = s.ChunkX; character.WorldChunkY = s.ChunkY; character.WorldX = s.X; character.WorldY = s.Y; character.LastPlayedAt = DateTime.UtcNow; await db.SaveChangesAsync(ct); var initial = await _broadcast.GetChunkUpdatesAsync(region, s, ct); var tileSheets = await db.TileMapSheets .AsNoTracking() .Where(ts => ts.IsEnabled) .OrderBy(ts => ts.Id) .Select(ts => new { id = ts.Id, name = ts.Name, path = ts.CdnPath, tileW = ts.TileWidth, tileH = ts.TileHeight, cols = ts.Columns, sheetW = ts.SheetWidth, sheetH = ts.SheetHeight }) .ToArrayAsync(ct); await _broadcast.SendAsync(conn, OpCodes.WORLD_SPAWN, new { success = true, player = new { id = s.CharacterId, name = s.Name, x = s.X, y = s.Y, regionId = s.RegionId, zoneX = s.ZoneX, zoneY = s.ZoneY, chunkX = s.ChunkX, chunkY = s.ChunkY, isVip = s.IsVip }, region = new { id = region.Id, name = region.Name, zonesX = region.ZonesPerRegionX, zonesY = region.ZonesPerRegionY, chunksPerZoneX = region.ChunksPerZoneX, chunksPerZoneY = region.ChunksPerZoneY, chunkWidthTiles = region.ChunkWidthTiles, chunkHeightTiles = region.ChunkHeightTiles }, tileSheets, initialChunks = initial.Where(u => u.type == "chunk_full").Select(u => u.payload), nearbyPlayers = VisiblePlayers(s).Select(p => new { id = p.CharacterId, name = p.Name, x = p.X, y = p.Y, facing = p.Facing, speed = p.Speed, isMoving = p.IsMoving }) }, ct); await _broadcast.BroadcastToRegionAsync(OpCodes.WORLD_SPAWN, new { success = true, isRemote = true, player = new { id = s.CharacterId, name = s.Name, x = s.X, y = s.Y, facing = s.Facing, speed = s.Speed, isMoving = s.IsMoving, regionId = s.RegionId, zoneX = s.ZoneX, zoneY = s.ZoneY, chunkX = s.ChunkX, chunkY = s.ChunkY } }, s.RegionId, _players, s.ConnectionId); } // ---- Input (pure in-memory, no DB) ---- private void HandleInput(IConnection conn, ulong accountId, ReadOnlyMemory payload) { if (!_players.TryGetValue(conn.Id, out var s)) return; if (s.AccountId != accountId) return; var req = WorldInputParser.ParseWorldInput(payload, s.X, s.Y); if (req == null) return; var dx = MathF.Max(-1f, MathF.Min(1f, req.MoveX)); var dy = MathF.Max(-1f, MathF.Min(1f, req.MoveY)); var len = MathF.Sqrt((dx * dx) + (dy * dy)); if (len > 1f) { dx /= len; dy /= len; } var hasMovement = MathF.Abs(dx) > 0.001f || MathF.Abs(dy) > 0.001f; var now = DateTime.UtcNow; if (req.NativeDirectional && hasMovement) { s.PreferDirectionalUntil = now + DirectionalPriorityGrace; s.HasPendingTarget = false; } if (req.UseTargetPosition && now >= s.PreferDirectionalUntil) { s.HasPendingTarget = true; s.PendingTargetX = req.TargetX; s.PendingTargetY = req.TargetY; s.LastNonNeutralInputAt = now; } else if (hasMovement) { s.HasPendingTarget = false; } if (hasMovement) { s.PendingMoveX = dx; s.PendingMoveY = dy; s.PendingIsRunning = req.IsRunning; s.LastNonNeutralInputAt = now; } else { var explicitDirectionalStop = req.NativeDirectional && !req.UseTargetPosition; var shouldStopNow = explicitDirectionalStop || (req.IsMovingProvided && !req.IsMoving) || (now - s.LastNonNeutralInputAt) > NeutralInputGrace; if (shouldStopNow) { s.PendingMoveX = 0f; s.PendingMoveY = 0f; s.PendingIsRunning = req.IsRunning; s.HasPendingTarget = false; } } if (!string.IsNullOrWhiteSpace(req.Facing)) s.PendingFacing = req.Facing; s.PendingSeq = req.Seq; if (_debugInput) { _log.LogInformation( "WORLD_INPUT conn={Conn} seq={Seq} nativeDir={NativeDir} useTarget={UseTarget} hasTarget={HasTarget} move=({MoveX:F3},{MoveY:F3}) target=({TargetX:F2},{TargetY:F2}) pendingTarget={PendingTarget} pendingMove=({PendingX:F3},{PendingY:F3}) pos=({PosX:F2},{PosY:F2})", conn.Id, req.Seq, req.NativeDirectional, req.UseTargetPosition, req.HasTargetPosition, req.MoveX, req.MoveY, req.TargetX, req.TargetY, s.HasPendingTarget, s.PendingMoveX, s.PendingMoveY, s.X, s.Y); } } // ---- Tick loop (zero DB queries in hot path) ---- private async Task TickLoopAsync(CancellationToken ct) { var timer = new PeriodicTimer(TimeSpan.FromMilliseconds(100)); try { while (!ct.IsCancellationRequested && await timer.WaitForNextTickAsync(ct)) { Interlocked.Increment(ref _tick); await SendStatesAsync(ct); } } catch (OperationCanceledException) { } finally { timer.Dispose(); } } private async Task SendStatesAsync(CancellationToken ct) { if (_players.IsEmpty) return; var tick = Interlocked.Read(ref _tick); // Process all players in parallel instead of sequentially var tasks = _players.Values.Select(s => ProcessPlayerTickAsync(s, tick, ct)); await Task.WhenAll(tasks); } private async Task ProcessPlayerTickAsync(WorldSessionState s, long tick, CancellationToken ct) { try { var region = await _cache.GetRegionAsync(s.RegionId, ct); if (region == null) { s.Errors.Add("region_not_found"); return; } // Movement + collision + portal detection (synchronous, pure in-memory) _movement.ApplyMovement(region, s, tick, _portalCooldownByCharacter, _debugInput); // Resolve cross-region portal teleports (async cache lookup, rare) await _movement.ResolvePortalTeleportAsync(s, tick, _portalCooldownByCharacter, ct); // Chunk updates (from cache, possibly one async load for first-time chunks) var updates = await _broadcast.GetChunkUpdatesAsync(region, s, ct); var errs = s.Errors.Count == 0 ? null : s.Errors.Distinct().ToArray(); s.Errors.Clear(); await _broadcast.SendAsync(s.Connection, OpCodes.WORLD_STATE, new { tick, ackSeq = s.Seq, self = new { x = s.X, y = s.Y, velocityX = s.VelX, velocityY = s.VelY, regionId = s.RegionId, zoneX = s.ZoneX, zoneY = s.ZoneY, chunkX = s.ChunkX, chunkY = s.ChunkY }, players = VisiblePlayers(s).Select(p => new { id = p.CharacterId, name = p.Name, x = p.X, y = p.Y, facing = p.Facing, speed = p.Speed, isMoving = p.IsMoving, regionId = p.RegionId, zoneX = p.ZoneX, zoneY = p.ZoneY, chunkX = p.ChunkX, chunkY = p.ChunkY }), chunkUpdates = updates.Select(u => u.payload), portalEvent = s.PendingPortalEvent, errors = errs }, ct); s.PendingPortalEvent = null; } catch (Exception ex) { _log.LogWarning(ex, "Error processing tick for player {CharacterId}", s.CharacterId); } } private IEnumerable VisiblePlayers(WorldSessionState self) => _players.Values.Where(p => p.ConnectionId != self.ConnectionId && p.RegionId == self.RegionId && Math.Abs(p.ZoneX - self.ZoneX) <= 1 && Math.Abs(p.ZoneY - self.ZoneY) <= 1 && Math.Abs(p.X - self.X) <= (TileSize * 48) && Math.Abs(p.Y - self.Y) <= (TileSize * 48)); // ---- Live delta forwarding (admin world edits -> game clients) ---- private void OnWorldEditDelta(string chunkKey, string deltaJson) { // Fire-and-forget: forward delta to clients and invalidate cache _ = ProcessDeltaAsync(chunkKey, deltaJson); } private async Task ProcessDeltaAsync(string chunkKey, string deltaJson) { try { // Parse the delta to extract version and operation details using var doc = JsonDocument.Parse(deltaJson); var root = doc.RootElement; var toVersion = root.TryGetProperty("toVersion", out var tv) && tv.ValueKind == JsonValueKind.Number ? tv.GetInt64() : 0L; // Parse chunk coordinates from the key for cache invalidation var parts = chunkKey.Split(':'); if (parts.Length == 5 && int.TryParse(parts[0], out var regionId) && int.TryParse(parts[1], out var zoneX) && int.TryParse(parts[2], out var zoneY) && int.TryParse(parts[3], out var chunkX) && int.TryParse(parts[4], out var chunkY)) { // Invalidate cache so next access reloads fresh data from DB _cache.InvalidateChunk(regionId, zoneX, zoneY, chunkX, chunkY); // Deserialize the delta to a dynamic object for forwarding to clients. // The raw JSON from the hub already has all the fields the client needs. var deltaPayload = JsonSerializer.Deserialize(deltaJson); if (deltaPayload != null) { await _broadcast.BroadcastChunkDeltaAsync(chunkKey, deltaPayload, toVersion, _players); } } } catch (Exception ex) { _log.LogWarning(ex, "Error processing world edit delta for chunk {ChunkKey}", chunkKey); } } // ---- Persistence (only on disconnect) ---- private async Task PersistPlayerLocationAsync(WorldSessionState s) { try { using var scope = _scopeFactory.CreateScope(); var db = scope.ServiceProvider.GetRequiredService(); var character = await db.DungeonCharacters.FirstOrDefaultAsync(c => c.Id == s.CharacterId); if (character == null) return; character.WorldRegionId = s.RegionId; character.WorldZoneX = s.ZoneX; character.WorldZoneY = s.ZoneY; character.WorldChunkX = s.ChunkX; character.WorldChunkY = s.ChunkY; character.WorldX = s.X; character.WorldY = s.Y; character.LastPlayedAt = DateTime.UtcNow; await db.SaveChangesAsync(); } catch (Exception ex) { _log.LogWarning(ex, "Failed to persist world location for character {CharacterId}", s.CharacterId); } } }