435 lines
18 KiB
C#
435 lines
18 KiB
C#
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<WorldHandler> _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<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,
|
|
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<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);
|
|
_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<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));
|
|
|
|
// ---- 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<object>(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<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);
|
|
}
|
|
}
|
|
}
|