1038 lines
46 KiB
C#
1038 lines
46 KiB
C#
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<WorldHandler> _log;
|
|
private readonly ISessionRegistry _sessions;
|
|
private readonly IMessageSerializer _ser;
|
|
private readonly IServiceScopeFactory _scopeFactory;
|
|
private readonly ConcurrentDictionary<Guid, SessionState> _players = new();
|
|
private readonly ConcurrentDictionary<ulong, long> _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<WorldHandler> 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<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");
|
|
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 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<byte> payload, CancellationToken ct)
|
|
{
|
|
var req = Parse<SpawnReq>(payload) ?? new 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 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<byte> 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<GameDbContext>();
|
|
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<SessionState> 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<List<(string type, object payload)>> ChunkUpdatesAsync(GameDbContext db, WorldRegion region, SessionState s, CancellationToken ct)
|
|
{
|
|
var required = new HashSet<string>(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<object>(), Array.Empty<object>(), Array.Empty<object>(), Array.Empty<object>());
|
|
|
|
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<object>(), Array.Empty<object>(), Array.Empty<object>(), Array.Empty<object>());
|
|
|
|
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<object>().ToArray(), objects.Cast<object>().ToArray(), npcs.Cast<object>().ToArray(), mobs.Cast<object>().ToArray());
|
|
}
|
|
|
|
private async Task<bool> 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<WorldChunkObject?> 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<WorldPortalMetadata>(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<WorldChunkTile?> 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<WorldRegion?> 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<T>(ReadOnlyMemory<byte> payload)
|
|
{
|
|
try
|
|
{
|
|
if (payload.IsEmpty) return default;
|
|
var s = Encoding.UTF8.GetString(payload.Span);
|
|
if (string.IsNullOrWhiteSpace(s)) return default;
|
|
return JsonSerializer.Deserialize<T>(s, _json);
|
|
}
|
|
catch { return default; }
|
|
}
|
|
|
|
private InputReq? ParseWorldInput(ReadOnlyMemory<byte> 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<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);
|
|
}
|
|
}
|
|
|
|
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<string, long> ChunkVersions { get; } = new(StringComparer.Ordinal);
|
|
public List<string> 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; }
|
|
}
|
|
}
|