using System.Collections.Concurrent; using System.Text; using System.Text.Json; using DataServer.Data; using DataServer.Data.Entities; 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 const float MoveWalk = 120f; private const float MoveRun = 180f; private const float TickStepSec = 0.10f; private static readonly TimeSpan NeutralInputGrace = TimeSpan.FromMilliseconds(180); private static readonly TimeSpan DirectionalPriorityGrace = TimeSpan.FromMilliseconds(450); private const long PortalCooldownTicks = 8; // 0.8s at 10hz private readonly ILogger _log; private readonly ISessionRegistry _sessions; private readonly IMessageSerializer _ser; private readonly IServiceScopeFactory _scopeFactory; private readonly ConcurrentDictionary _players = new(); private readonly ConcurrentDictionary _portalCooldownByCharacter = new(); private readonly JsonSerializerOptions _json = new() { PropertyNameCaseInsensitive = true }; private readonly bool _debugInput; private Task? _tickTask; private CancellationTokenSource? _tickCts; private long _tick; private volatile bool _initialized; public WorldHandler( ILogger log, ISessionRegistry sessions, IMessageSerializer ser, IServiceScopeFactory scopeFactory) { _log = log; _sessions = sessions; _ser = ser; _scopeFactory = scopeFactory; 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); _initialized = true; _log.LogInformation("WorldHandler initialized"); 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 SendErrorAsync(connection, "auth_required", ct); return; } if (opCode == OpCodes.WORLD_SPAWN_REQUEST) { await HandleSpawnAsync(connection, accountId, payload, ct); return; } if (opCode == OpCodes.WORLD_INPUT) { await HandleInputAsync(connection, accountId, payload, ct); } } public void OnDisconnect(Guid connectionId) { if (_players.TryRemove(connectionId, out var s)) { _ = PersistPlayerLocationAsync(s); _ = BroadcastAsync(OpCodes.WORLD_DESPAWN, new { playerId = s.CharacterId, reason = "disconnect" }, s.RegionId, s.ConnectionId); } } private async Task HandleSpawnAsync(IConnection conn, ulong accountId, ReadOnlyMemory payload, CancellationToken ct) { var req = Parse(payload) ?? new 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 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 ResolveRegionAsync(db, req.RegionId ?? character.WorldRegionId, ct); if (region == null) { await SendErrorAsync(conn, "region_not_found", ct); return; } await EnsureZonesAsync(db, region, 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 ? WorldPxX(region, zx, cx, tx) : (character.WorldX ?? WorldPxX(region, zx, cx, tx)); var y = requestedExplicitChunk ? WorldPxY(region, zy, cy, ty) : (character.WorldY ?? WorldPxY(region, zy, cy, ty)); // Stored world coords should be tile-center aligned; treat 0/invalid as legacy-bad and recover. if (!float.IsFinite(x) || x < (TileSize / 2f)) x = WorldPxX(region, zx, cx, tx); if (!float.IsFinite(y) || y < (TileSize / 2f)) y = WorldPxY(region, zy, cy, ty); var (pzX, pzY, pcX, pcY) = ToChunkPos(region, x, y); var s = new SessionState { 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 ChunkUpdatesAsync(db, 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 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 BroadcastAsync(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, s.ConnectionId); } private Task HandleInputAsync(IConnection conn, ulong accountId, ReadOnlyMemory payload, CancellationToken ct) { if (!_players.TryGetValue(conn.Id, out var s)) { return Task.CompletedTask; } if (s.AccountId != accountId) { return Task.CompletedTask; } var req = ParseWorldInput(payload, s.X, s.Y); if (req == null) { return Task.CompletedTask; } 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) { // Directional input takes precedence over any previously latched target. s.HasPendingTarget = false; } // Store latest input; movement/collision is applied once per world tick to avoid input backlog. // Keep the last non-neutral direction briefly to avoid neutral packet jitter canceling held input. if (hasMovement) { s.PendingMoveX = dx; s.PendingMoveY = dy; s.PendingIsRunning = req.IsRunning; s.LastNonNeutralInputAt = now; } else { // Match dungeon semantics: an explicit neutral directional packet should // clear movement immediately instead of waiting for neutral-input grace. 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); } return Task.CompletedTask; } 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; using var scope = _scopeFactory.CreateScope(); var db = scope.ServiceProvider.GetRequiredService(); var tick = Interlocked.Read(ref _tick); foreach (var s in _players.Values) { var region = await db.WorldRegions.AsNoTracking().FirstOrDefaultAsync(r => r.Id == s.RegionId && r.IsEnabled, ct); if (region == null) { s.Errors.Add("region_not_found"); continue; } await ApplyPendingInputAsync(db, region, s, ct); var updates = await ChunkUpdatesAsync(db, region, s, ct); var errs = s.Errors.Count == 0 ? null : s.Errors.Distinct().ToArray(); s.Errors.Clear(); await 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; } } private async Task ApplyPendingInputAsync(GameDbContext db, WorldRegion region, SessionState s, CancellationToken ct) { var beforeX = s.X; var beforeY = s.Y; float dx; float dy; var targetMode = s.HasPendingTarget; var targetX = s.PendingTargetX; var targetY = s.PendingTargetY; var stepScale = 1f; if (s.HasPendingTarget) { var tx = targetX - s.X; var ty = targetY - s.Y; var targetDist = MathF.Sqrt((tx * tx) + (ty * ty)); if (targetDist <= 1f) { s.HasPendingTarget = false; targetMode = false; dx = s.PendingMoveX; dy = s.PendingMoveY; } else { dx = tx / targetDist; dy = ty / targetDist; var speedForScale = s.PendingIsRunning ? MoveRun : MoveWalk; var maxTickStep = speedForScale * TickStepSec; if (maxTickStep > 0.001f) { stepScale = MathF.Min(1f, targetDist / maxTickStep); } } } else { dx = s.PendingMoveX; dy = s.PendingMoveY; } dx = MathF.Max(-1f, MathF.Min(1f, dx)); dy = MathF.Max(-1f, MathF.Min(1f, dy)); var len = MathF.Sqrt((dx * dx) + (dy * dy)); if (len > 1f) { dx /= len; dy /= len; } var speed = s.PendingIsRunning ? MoveRun : MoveWalk; var effectiveSpeed = speed * stepScale; var nextX = s.X + (dx * effectiveSpeed * TickStepSec); var nextY = s.Y + (dy * effectiveSpeed * TickStepSec); var moving = MathF.Abs(dx) > 0.001f || MathF.Abs(dy) > 0.001f; if (moving) { if (await WalkableAsync(db, region, nextX, s.Y, s.IsVip, ct)) s.X = nextX; else s.Errors.Add("blocked_non_walkable"); if (await WalkableAsync(db, region, s.X, nextY, s.IsVip, ct)) s.Y = nextY; else s.Errors.Add("blocked_non_walkable"); } if (targetMode && s.HasPendingTarget) { var rx = targetX - s.X; var ry = targetY - s.Y; var remaining = MathF.Sqrt((rx * rx) + (ry * ry)); if (remaining <= 1f) { s.HasPendingTarget = false; } } var (zx, zy, cx, cy) = ToChunkPos(region, s.X, s.Y); s.ZoneX = zx; s.ZoneY = zy; s.ChunkX = cx; s.ChunkY = cy; s.VelX = moving ? dx * effectiveSpeed : 0f; s.VelY = moving ? dy * effectiveSpeed : 0f; s.Speed = moving ? effectiveSpeed : 0f; s.IsMoving = moving; s.Facing = Facing(s.PendingFacing, dx, dy, s.Facing); s.Seq = s.PendingSeq; await TryTriggerPortalAsync(db, region, s, ct); if (_debugInput) { _log.LogInformation( "WORLD_TICK seq={Seq} targetMode={TargetMode} hasPendingTarget={HasPendingTarget} input=({InputX:F3},{InputY:F3}) effSpeed={Speed:F1} vel=({VelX:F1},{VelY:F1}) pos=({BeforeX:F2},{BeforeY:F2})->({AfterX:F2},{AfterY:F2})", s.Seq, targetMode, s.HasPendingTarget, dx, dy, s.Speed, s.VelX, s.VelY, beforeX, beforeY, s.X, s.Y); } } private IEnumerable VisiblePlayers(SessionState 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)); private async Task> ChunkUpdatesAsync(GameDbContext db, WorldRegion region, SessionState s, CancellationToken ct) { var required = new HashSet(StringComparer.Ordinal); var list = new List<(string, object)>(); var chunksPerRegionX = region.ZonesPerRegionX * region.ChunksPerZoneX; var chunksPerRegionY = region.ZonesPerRegionY * region.ChunksPerZoneY; if (chunksPerRegionX <= 0 || chunksPerRegionY <= 0) { return list; } var centerAbsChunkX = (s.ZoneX * region.ChunksPerZoneX) + s.ChunkX; var centerAbsChunkY = (s.ZoneY * region.ChunksPerZoneY) + s.ChunkY; for (var ay = Math.Max(0, centerAbsChunkY - 1); ay <= Math.Min(chunksPerRegionY - 1, centerAbsChunkY + 1); ay++) for (var ax = Math.Max(0, centerAbsChunkX - 1); ax <= Math.Min(chunksPerRegionX - 1, centerAbsChunkX + 1); ax++) { var zx = ax / region.ChunksPerZoneX; var zy = ay / region.ChunksPerZoneY; var cx = ax % region.ChunksPerZoneX; var cy = ay % region.ChunksPerZoneY; var key = $"{region.Id}:{zx}:{zy}:{cx}:{cy}"; required.Add(key); // Load chunk payload only when it enters the visible set. // Runtime chunk edits should be pushed by dedicated world-edit services/events. if (!s.ChunkVersions.ContainsKey(key)) { var data = await LoadChunkAsync(db, region, zx, zy, cx, cy, ct); s.ChunkVersions[key] = data.version; list.Add(("chunk_full", new { type = "chunk_full", chunk = data.chunk, tiles = data.tiles, objects = data.objects, npcs = data.npcs, mobs = data.mobs })); } } foreach (var stale in s.ChunkVersions.Keys.Where(k => !required.Contains(k)).ToList()) { s.ChunkVersions.Remove(stale); var p = stale.Split(':'); list.Add(("chunk_unload", new { type = "chunk_unload", regionId = int.Parse(p[0]), zoneX = int.Parse(p[1]), zoneY = int.Parse(p[2]), chunkX = int.Parse(p[3]), chunkY = int.Parse(p[4]) })); } return list; } private async Task<(long version, object chunk, object[] tiles, object[] objects, object[] npcs, object[] mobs)> LoadChunkAsync(GameDbContext db, WorldRegion region, int zoneX, int zoneY, int chunkX, int chunkY, CancellationToken ct) { var zone = await db.WorldZones.AsNoTracking().FirstOrDefaultAsync(z => z.RegionId == region.Id && z.ZoneX == zoneX && z.ZoneY == zoneY && z.IsEnabled, ct); if (zone == null) return (0, new { regionId = region.Id, zoneX, zoneY, chunkX, chunkY, version = 0, width = region.ChunkWidthTiles, height = region.ChunkHeightTiles }, Array.Empty(), Array.Empty(), Array.Empty(), Array.Empty()); var chunk = await db.WorldChunks.AsNoTracking().FirstOrDefaultAsync(c => c.WorldZoneId == zone.Id && c.ChunkX == chunkX && c.ChunkY == chunkY, ct); if (chunk == null) return (0, new { regionId = region.Id, zoneX, zoneY, chunkX, chunkY, version = 0, width = region.ChunkWidthTiles, height = region.ChunkHeightTiles }, Array.Empty(), Array.Empty(), Array.Empty(), Array.Empty()); var tiles = await db.WorldChunkTiles.AsNoTracking().Where(t => t.WorldChunkId == chunk.Id).OrderBy(t => t.TileY).ThenBy(t => t.TileX).Select(t => new { id = t.Id, x = t.TileX, y = t.TileY, sheetId = t.SheetId, frameIndex = t.FrameIndex, isWalkable = t.IsWalkable, isInvisiblePaywall = t.IsInvisiblePaywall }).ToArrayAsync(ct); var objects = await db.WorldChunkObjects.AsNoTracking().Include(o => o.ObjectDefinition).Where(o => o.WorldChunkId == chunk.Id).OrderBy(o => o.TileY).ThenBy(o => o.TileX).Select(o => new { id = o.Id, x = o.TileX, y = o.TileY, objectDefinitionId = o.ObjectDefinitionId, objectName = o.ObjectDefinition != null ? o.ObjectDefinition.Name : $"Object {o.ObjectDefinitionId}", interactionType = o.ObjectDefinition != null ? o.ObjectDefinition.InteractionType.ToString() : null, rotation = o.Rotation, metadataJson = o.MetadataJson }).ToArrayAsync(ct); var npcs = await db.WorldChunkNpcSpawns.AsNoTracking().Include(n => n.NpcDefinition).Where(n => n.WorldChunkId == chunk.Id).OrderBy(n => n.TileY).ThenBy(n => n.TileX).Select(n => new { id = n.Id, x = n.TileX, y = n.TileY, npcDefinitionId = n.NpcDefinitionId, npcName = n.NpcDefinition != null ? n.NpcDefinition.Name : $"NPC {n.NpcDefinitionId}", rotation = n.Rotation, metadataJson = n.MetadataJson }).ToArrayAsync(ct); var mobs = await db.WorldChunkMobSpawns.AsNoTracking().Include(m => m.MobDefinition).Where(m => m.WorldChunkId == chunk.Id).OrderBy(m => m.TileY).ThenBy(m => m.TileX).Select(m => new { id = m.Id, x = m.TileX, y = m.TileY, mobDefinitionId = m.MobDefinitionId, mobName = m.MobDefinition != null ? m.MobDefinition.Name : $"Mob {m.MobDefinitionId}", rotation = m.Rotation, spawnCount = m.SpawnCount, respawnSeconds = m.RespawnSeconds, metadataJson = m.MetadataJson }).ToArrayAsync(ct); return (chunk.Version, new { id = chunk.Id, regionId = region.Id, zoneX, zoneY, chunkX, chunkY, version = chunk.Version, width = region.ChunkWidthTiles, height = region.ChunkHeightTiles }, tiles.Cast().ToArray(), objects.Cast().ToArray(), npcs.Cast().ToArray(), mobs.Cast().ToArray()); } private async Task WalkableAsync(GameDbContext db, WorldRegion region, float wx, float wy, bool isVip, CancellationToken ct) { var checks = new[] { (0f, 0f), (8f, 0f), (-8f, 0f), (0f, 8f), (0f, -8f) }; foreach (var (ox, oy) in checks) { var tile = await ResolveTileAsync(db, region, wx + ox, wy + oy, ct); if (tile == null) continue; if (!tile.IsWalkable) return false; if (tile.IsInvisiblePaywall && !isVip) return false; } return true; } private async Task TryTriggerPortalAsync(GameDbContext db, WorldRegion region, SessionState s, CancellationToken ct) { var nowTick = Interlocked.Read(ref _tick); if (_portalCooldownByCharacter.TryGetValue(s.CharacterId, out var untilTick) && untilTick > nowTick) { return; } var portalObject = await ResolvePortalObjectAtPositionAsync(db, region, s.X, s.Y, ct); if (portalObject == null || string.IsNullOrWhiteSpace(portalObject.MetadataJson)) { return; } if (!TryParsePortalMetadata(portalObject.MetadataJson, out var portalMeta)) { return; } _portalCooldownByCharacter[s.CharacterId] = nowTick + PortalCooldownTicks; if (portalMeta.PortalType.Equals("world", StringComparison.OrdinalIgnoreCase)) { if (TryResolveWorldPortalTarget(portalMeta, out var targetRegionId, out var targetZoneX, out var targetZoneY, out var targetChunkX, out var targetChunkY, out var targetTileX, out var targetTileY)) { var targetRegion = await db.WorldRegions.AsNoTracking().FirstOrDefaultAsync(r => r.Id == targetRegionId && r.IsEnabled, ct); if (targetRegion != null) { var nx = WorldPxX(targetRegion, targetZoneX, targetChunkX, targetTileX); var ny = WorldPxY(targetRegion, targetZoneY, targetChunkY, targetTileY); s.RegionId = targetRegion.Id; s.X = nx; s.Y = ny; var (zx, zy, cx, cy) = ToChunkPos(targetRegion, s.X, s.Y); s.ZoneX = zx; s.ZoneY = zy; s.ChunkX = cx; s.ChunkY = cy; s.PendingPortalEvent = new { type = "world_teleport", sourceObjectId = portalObject.Id, regionId = s.RegionId, zoneX = s.ZoneX, zoneY = s.ZoneY, chunkX = s.ChunkX, chunkY = s.ChunkY, x = s.X, y = s.Y }; return; } } s.Errors.Add("portal_world_target_invalid"); return; } s.PendingPortalEvent = new { type = "dungeon_request", sourceObjectId = portalObject.Id, portalType = portalMeta.PortalType, dungeonTemplateId = portalMeta.DungeonTemplateId, randomTier = portalMeta.RandomTier, levelBracketMin = portalMeta.LevelBracketMin, levelBracketMax = portalMeta.LevelBracketMax }; } private async Task ResolvePortalObjectAtPositionAsync(GameDbContext db, WorldRegion region, float wx, float wy, CancellationToken ct) { var gx = (int)MathF.Floor(wx / TileSize); var gy = (int)MathF.Floor(wy / TileSize); if (gx < 0 || gy < 0) return null; var zoneW = region.ChunksPerZoneX * region.ChunkWidthTiles; var zoneH = region.ChunksPerZoneY * region.ChunkHeightTiles; if (zoneW <= 0 || zoneH <= 0) return null; var zx = gx / zoneW; var zy = gy / zoneH; if (zx < 0 || zy < 0 || zx >= region.ZonesPerRegionX || zy >= region.ZonesPerRegionY) return null; var lzx = gx - (zx * zoneW); var lzy = gy - (zy * zoneH); var cx = lzx / region.ChunkWidthTiles; var cy = lzy / region.ChunkHeightTiles; var tx = lzx % region.ChunkWidthTiles; var ty = lzy % region.ChunkHeightTiles; var zone = await db.WorldZones.AsNoTracking().FirstOrDefaultAsync(z => z.RegionId == region.Id && z.ZoneX == zx && z.ZoneY == zy && z.IsEnabled, ct); if (zone == null) return null; var chunk = await db.WorldChunks.AsNoTracking().FirstOrDefaultAsync(c => c.WorldZoneId == zone.Id && c.ChunkX == cx && c.ChunkY == cy, ct); if (chunk == null) return null; var objects = await db.WorldChunkObjects .AsNoTracking() .Include(o => o.ObjectDefinition) .Where(o => o.WorldChunkId == chunk.Id) .ToListAsync(ct); return objects.FirstOrDefault(o => { var w = Math.Max(1, o.ObjectDefinition?.Width ?? 1); var h = Math.Max(1, o.ObjectDefinition?.Height ?? 1); var isTeleport = o.ObjectDefinition?.InteractionType == ObjectInteractionType.Teleport || (o.MetadataJson?.Contains("portalType", StringComparison.OrdinalIgnoreCase) ?? false); if (!isTeleport) return false; return tx >= o.TileX && ty >= o.TileY && tx < (o.TileX + w) && ty < (o.TileY + h); }); } private static bool TryParsePortalMetadata(string metadataJson, out WorldPortalMetadata metadata) { metadata = new WorldPortalMetadata(); try { var parsed = JsonSerializer.Deserialize(metadataJson, new JsonSerializerOptions { PropertyNameCaseInsensitive = true }); if (parsed == null || string.IsNullOrWhiteSpace(parsed.PortalType)) { return false; } metadata = parsed; return true; } catch { return false; } } private static bool TryResolveWorldPortalTarget( WorldPortalMetadata m, out int targetRegionId, out int targetZoneX, out int targetZoneY, out int targetChunkX, out int targetChunkY, out int targetTileX, out int targetTileY) { targetRegionId = m.TargetRegionId ?? 0; targetZoneX = m.TargetZoneX ?? 0; targetZoneY = m.TargetZoneY ?? 0; targetChunkX = m.TargetChunkX ?? 0; targetChunkY = m.TargetChunkY ?? 0; targetTileX = m.TargetTileX ?? 0; targetTileY = m.TargetTileY ?? 0; return targetRegionId > 0; } private async Task ResolveTileAsync(GameDbContext db, WorldRegion region, float wx, float wy, CancellationToken ct) { var gx = (int)MathF.Floor(wx / TileSize); var gy = (int)MathF.Floor(wy / TileSize); if (gx < 0 || gy < 0) return null; var zoneW = region.ChunksPerZoneX * region.ChunkWidthTiles; var zoneH = region.ChunksPerZoneY * region.ChunkHeightTiles; if (zoneW <= 0 || zoneH <= 0) return null; var zx = gx / zoneW; var zy = gy / zoneH; if (zx < 0 || zy < 0 || zx >= region.ZonesPerRegionX || zy >= region.ZonesPerRegionY) return null; var lzx = gx - (zx * zoneW); var lzy = gy - (zy * zoneH); var cx = lzx / region.ChunkWidthTiles; var cy = lzy / region.ChunkHeightTiles; var tx = lzx % region.ChunkWidthTiles; var ty = lzy % region.ChunkHeightTiles; var zone = await db.WorldZones.AsNoTracking().FirstOrDefaultAsync(z => z.RegionId == region.Id && z.ZoneX == zx && z.ZoneY == zy && z.IsEnabled, ct); if (zone == null) return null; var chunk = await db.WorldChunks.AsNoTracking().FirstOrDefaultAsync(c => c.WorldZoneId == zone.Id && c.ChunkX == cx && c.ChunkY == cy, ct); if (chunk == null) return null; return await db.WorldChunkTiles.AsNoTracking().FirstOrDefaultAsync(t => t.WorldChunkId == chunk.Id && t.TileX == tx && t.TileY == ty, ct); } private async Task ResolveRegionAsync(GameDbContext db, int? requestedId, CancellationToken ct) { if (requestedId.HasValue && requestedId.Value > 0) { var match = await db.WorldRegions.AsNoTracking().FirstOrDefaultAsync(r => r.Id == requestedId.Value && r.IsEnabled, ct); if (match != null) return match; } return await db.WorldRegions.AsNoTracking().Where(r => r.IsEnabled).OrderBy(r => r.Id).FirstOrDefaultAsync(ct); } private async Task EnsureZonesAsync(GameDbContext db, WorldRegion region, CancellationToken ct) { var existing = await db.WorldZones.Where(z => z.RegionId == region.Id).Select(z => new { z.ZoneX, z.ZoneY }).ToListAsync(ct); var set = existing.Select(z => $"{z.ZoneX}:{z.ZoneY}").ToHashSet(StringComparer.Ordinal); var now = DateTime.UtcNow; var changed = false; for (var y = 0; y < region.ZonesPerRegionY; y++) for (var x = 0; x < region.ZonesPerRegionX; x++) { if (set.Contains($"{x}:{y}")) continue; db.WorldZones.Add(new WorldZone { RegionId = region.Id, ZoneX = x, ZoneY = y, Name = $"Zone {x},{y}", IsEnabled = true, CreatedAt = now, UpdatedAt = now }); changed = true; } if (changed) await db.SaveChangesAsync(ct); } private static float WorldPxX(WorldRegion r, int zoneX, int chunkX, int tileX) => (((zoneX * (r.ChunksPerZoneX * r.ChunkWidthTiles)) + (chunkX * r.ChunkWidthTiles) + tileX) * TileSize) + (TileSize / 2f); private static float WorldPxY(WorldRegion r, int zoneY, int chunkY, int tileY) => (((zoneY * (r.ChunksPerZoneY * r.ChunkHeightTiles)) + (chunkY * r.ChunkHeightTiles) + tileY) * TileSize) + (TileSize / 2f); private static (int zx, int zy, int cx, int cy) ToChunkPos(WorldRegion r, float wx, float wy) { var gx = Math.Max(0, (int)MathF.Floor(wx / TileSize)); var gy = Math.Max(0, (int)MathF.Floor(wy / TileSize)); var zoneW = r.ChunksPerZoneX * r.ChunkWidthTiles; var zoneH = r.ChunksPerZoneY * r.ChunkHeightTiles; var zx = Math.Clamp(zoneW > 0 ? gx / zoneW : 0, 0, Math.Max(0, r.ZonesPerRegionX - 1)); var zy = Math.Clamp(zoneH > 0 ? gy / zoneH : 0, 0, Math.Max(0, r.ZonesPerRegionY - 1)); var lzx = gx - (zx * zoneW); var lzy = gy - (zy * zoneH); var cx = Math.Clamp(r.ChunkWidthTiles > 0 ? lzx / r.ChunkWidthTiles : 0, 0, Math.Max(0, r.ChunksPerZoneX - 1)); var cy = Math.Clamp(r.ChunkHeightTiles > 0 ? lzy / r.ChunkHeightTiles : 0, 0, Math.Max(0, r.ChunksPerZoneY - 1)); return (zx, zy, cx, cy); } private static string Facing(string? facing, float dx, float dy, string fallback) { if (!string.IsNullOrWhiteSpace(facing)) { var f = facing.Trim().ToLowerInvariant(); if (f is "up" or "down" or "left" or "right") return f; } if (MathF.Abs(dx) > MathF.Abs(dy)) return dx >= 0 ? "right" : "left"; if (MathF.Abs(dy) > 0.001f) return dy >= 0 ? "down" : "up"; return fallback; } private T? Parse(ReadOnlyMemory payload) { try { if (payload.IsEmpty) return default; var s = Encoding.UTF8.GetString(payload.Span); if (string.IsNullOrWhiteSpace(s)) return default; return JsonSerializer.Deserialize(s, _json); } catch { return default; } } private InputReq? ParseWorldInput(ReadOnlyMemory payload, float currentX, float currentY) { if (payload.IsEmpty) return null; try { using var doc = JsonDocument.Parse(Encoding.UTF8.GetString(payload.Span)); var root = doc.RootElement; if (root.ValueKind != JsonValueKind.Object) return null; // Some clients wrap movement inside an "input" object. var source = root; if (TryGetProperty(root, "input", out var nested) && nested.ValueKind == JsonValueKind.Object) { source = nested; } float moveX = 0f; float moveY = 0f; var hasMoveX = TryGetFloat(source, out moveX, "moveX", "dx", "inputX", "horizontal"); var hasMoveY = TryGetFloat(source, out moveY, "moveY", "dy", "inputY", "vertical"); var hasRawX = TryGetFloat(source, out var rawX, "x"); var hasRawY = TryGetFloat(source, out var rawY, "y"); // Support directional top-level/nested x/y values in [-1,1]. if (!hasMoveX && hasRawX && IsDirectionalValue(rawX)) { moveX = rawX; hasMoveX = true; } if (!hasMoveY && hasRawY && IsDirectionalValue(rawY)) { moveY = rawY; hasMoveY = true; } // Compatibility: allow absolute target movement only when target fields are explicit. // Plain x/y frequently carry client render position and must not drive world movement. var hasAbsTarget = false; var useAbsTarget = false; var absTargetX = 0f; var absTargetY = 0f; var hadNativeDirectional = hasMoveX || hasMoveY; var hasTargetX = TryGetFloat(source, out var parsedTargetX, "targetX", "worldTargetX"); var hasTargetY = TryGetFloat(source, out var parsedTargetY, "targetY", "worldTargetY"); if (hasTargetX && hasTargetY) { hasAbsTarget = true; absTargetX = parsedTargetX; absTargetY = parsedTargetY; var dx = absTargetX - currentX; var dy = absTargetY - currentY; var len = MathF.Sqrt((dx * dx) + (dy * dy)); var directionalIsNeutral = (!hasMoveX && !hasMoveY) || (MathF.Abs(moveX) <= 0.01f && MathF.Abs(moveY) <= 0.01f); if (directionalIsNeutral && len > 0.5f) { useAbsTarget = true; moveX = dx / len; moveY = dy / len; hasMoveX = true; hasMoveY = true; } } if (!hasMoveX && !hasMoveY) { return null; } TryGetUInt(source, out var seq, "seq", "clientSeq", "inputSeq"); TryGetBool(source, out var isRunning, "isRunning", "running", "sprint"); var hasIsMoving = TryGetBool(source, out var isMoving, "isMoving", "moving"); TryGetString(source, out var facing, "facing", "dir", "direction"); return new InputReq { Seq = seq, MoveX = moveX, MoveY = moveY, IsRunning = isRunning, Facing = facing, IsMovingProvided = hasIsMoving, IsMoving = isMoving, HasTargetPosition = hasAbsTarget, UseTargetPosition = useAbsTarget, NativeDirectional = hadNativeDirectional, TargetX = absTargetX, TargetY = absTargetY }; } catch { return null; } } private static bool TryGetProperty(JsonElement source, string name, out JsonElement value) { foreach (var p in source.EnumerateObject()) { if (string.Equals(p.Name, name, StringComparison.OrdinalIgnoreCase)) { value = p.Value; return true; } } value = default; return false; } private static bool TryGetFloat(JsonElement source, out float value, params string[] names) { foreach (var n in names) { if (!TryGetProperty(source, n, out var e)) continue; if (e.ValueKind == JsonValueKind.Number && e.TryGetSingle(out value)) return true; if (e.ValueKind == JsonValueKind.String && float.TryParse(e.GetString(), out value)) return true; } value = 0f; return false; } private static bool TryGetUInt(JsonElement source, out uint value, params string[] names) { foreach (var n in names) { if (!TryGetProperty(source, n, out var e)) continue; if (e.ValueKind == JsonValueKind.Number && e.TryGetUInt32(out value)) return true; if (e.ValueKind == JsonValueKind.String && uint.TryParse(e.GetString(), out value)) return true; } value = 0; return false; } private static bool TryGetBool(JsonElement source, out bool value, params string[] names) { foreach (var n in names) { if (!TryGetProperty(source, n, out var e)) continue; if (e.ValueKind == JsonValueKind.True || e.ValueKind == JsonValueKind.False) { value = e.GetBoolean(); return true; } if (e.ValueKind == JsonValueKind.Number && e.TryGetInt32(out var num)) { value = num != 0; return true; } if (e.ValueKind == JsonValueKind.String && bool.TryParse(e.GetString(), out value)) { return true; } } value = false; return false; } private static bool TryGetString(JsonElement source, out string? value, params string[] names) { foreach (var n in names) { if (!TryGetProperty(source, n, out var e)) continue; if (e.ValueKind == JsonValueKind.String) { value = e.GetString(); return true; } } value = null; return false; } private static bool IsDirectionalValue(float value) => float.IsFinite(value) && value >= -1.05f && value <= 1.05f; private async Task BroadcastAsync(int opCode, object payload, int regionId, Guid? exceptConnectionId = null) { var tasks = _players.Values .Where(p => p.RegionId == regionId && (exceptConnectionId == null || p.ConnectionId != exceptConnectionId.Value)) .Select(p => SendAsync(p.Connection, opCode, payload, CancellationToken.None)); await Task.WhenAll(tasks); } private async Task PersistPlayerLocationAsync(SessionState 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); } } private async Task SendAsync(IConnection connection, int opCode, object payload, CancellationToken ct) { try { var bytes = _ser.Serialize(payload); var msg = new ServerMessage(opCode, bytes); await connection.SendAsync(_ser.Serialize(msg), ct); } catch (Exception ex) { _log.LogWarning(ex, "Failed sending opcode {Op} to {ConnectionId}", opCode, connection.Id); } } private Task SendErrorAsync(IConnection connection, string error, CancellationToken ct) => SendAsync(connection, OpCodes.ERROR, new { error }, ct); private sealed class SessionState { public Guid ConnectionId { get; set; } public IConnection Connection { get; set; } = null!; public ulong AccountId { get; set; } public ulong CharacterId { get; set; } public string Name { get; set; } = ""; public bool IsVip { get; set; } public int RegionId { get; set; } public int ZoneX { get; set; } public int ZoneY { get; set; } public int ChunkX { get; set; } public int ChunkY { get; set; } public float X { get; set; } public float Y { get; set; } public float VelX { get; set; } public float VelY { get; set; } public string Facing { get; set; } = "down"; public float Speed { get; set; } public bool IsMoving { get; set; } public uint Seq { get; set; } public float PendingMoveX { get; set; } public float PendingMoveY { get; set; } public bool PendingIsRunning { get; set; } public string? PendingFacing { get; set; } public uint PendingSeq { get; set; } public DateTime LastNonNeutralInputAt { get; set; } = DateTime.UtcNow; public DateTime PreferDirectionalUntil { get; set; } = DateTime.MinValue; public bool HasPendingTarget { get; set; } public float PendingTargetX { get; set; } public float PendingTargetY { get; set; } public Dictionary ChunkVersions { get; } = new(StringComparer.Ordinal); public List Errors { get; } = new(); public object? PendingPortalEvent { get; set; } } private sealed class SpawnReq { public int? RegionId { get; set; } public int? ZoneX { get; set; } public int? ZoneY { get; set; } public int? ChunkX { get; set; } public int? ChunkY { get; set; } } private sealed class InputReq { public uint Seq { get; set; } public float MoveX { get; set; } public float MoveY { get; set; } public bool IsRunning { get; set; } public string? Facing { get; set; } public bool IsMovingProvided { get; set; } public bool IsMoving { get; set; } public bool HasTargetPosition { get; set; } public bool UseTargetPosition { get; set; } public bool NativeDirectional { get; set; } public float TargetX { get; set; } public float TargetY { get; set; } } private sealed class LegacyInputReq { public uint ClientSeq { get; set; } public float Dx { get; set; } public float Dy { get; set; } public bool IsRunning { get; set; } public string? Facing { get; set; } } private sealed class WorldPortalMetadata { public string PortalType { get; set; } = ""; public int? TargetRegionId { get; set; } public int? TargetZoneX { get; set; } public int? TargetZoneY { get; set; } public int? TargetChunkX { get; set; } public int? TargetChunkY { get; set; } public int? TargetTileX { get; set; } public int? TargetTileY { get; set; } public int? DungeonTemplateId { get; set; } public int? RandomTier { get; set; } public int? LevelBracketMin { get; set; } public int? LevelBracketMax { get; set; } } }