Files
systemrevivalserver/Game/World/WorldHandler.cs
T
2026-02-16 08:56:15 -05:00

384 lines
16 KiB
C#

using System.Collections.Concurrent;
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 static readonly TimeSpan NeutralInputGrace = TimeSpan.FromMilliseconds(180);
private static readonly TimeSpan DirectionalPriorityGrace = TimeSpan.FromMilliseconds(450);
private readonly ILogger<WorldHandler> _log;
private readonly ISessionRegistry _sessions;
private readonly IServiceScopeFactory _scopeFactory;
private readonly WorldChunkCache _cache;
private readonly WorldMovementService _movement;
private readonly WorldBroadcastService _broadcast;
private readonly ConcurrentDictionary<Guid, WorldSessionState> _players = new();
private readonly ConcurrentDictionary<ulong, long> _portalCooldownByCharacter = new();
private readonly bool _debugInput;
private Task? _tickTask;
private CancellationTokenSource? _tickCts;
private long _tick;
private volatile bool _initialized;
public WorldHandler(
ILogger<WorldHandler> log,
ISessionRegistry sessions,
IServiceScopeFactory scopeFactory,
WorldChunkCache cache,
WorldMovementService movement,
WorldBroadcastService broadcast)
{
_log = log;
_sessions = sessions;
_scopeFactory = scopeFactory;
_cache = cache;
_movement = movement;
_broadcast = broadcast;
var debugInputEnv = Environment.GetEnvironmentVariable("WORLD_INPUT_DEBUG");
_debugInput = !string.IsNullOrWhiteSpace(debugInputEnv) &&
(debugInputEnv == "1" || string.Equals(debugInputEnv, "true", StringComparison.OrdinalIgnoreCase));
}
public IReadOnlyCollection<int> 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 (cached movement pipeline)");
return Task.CompletedTask;
}
public async Task HandleAsync(int opCode, IConnection connection, ReadOnlyMemory<byte> 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<byte> payload, CancellationToken ct)
{
var req = WorldInputParser.Parse<WorldInputParser.SpawnReq>(payload) ?? new WorldInputParser.SpawnReq();
using var scope = _scopeFactory.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<GameDbContext>();
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<byte> 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<WorldSessionState> 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));
// ---- Persistence (only on disconnect) ----
private async Task PersistPlayerLocationAsync(WorldSessionState s)
{
try
{
using var scope = _scopeFactory.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<GameDbContext>();
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);
}
}
}