Files
systemrevivalserver/Game/World/WorldHandler.cs
T
2026-02-18 06:48:34 -05:00

820 lines
34 KiB
C#

using System.Collections.Concurrent;
using System.Text.Json;
using DataServer.Data;
using DataServer.Data.Entities;
using GameServer.Dungeon;
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 partial class WorldHandler : IClientMessageHandler
{
private const int TileSize = 32;
private const float TickDeltaSeconds = 0.1f; // 10Hz
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;
// Zone simulations (keyed by "{regionId}:{zoneX}:{zoneY}:{zoneZ}")
private readonly ConcurrentDictionary<string, WorldZoneSimulation> _activeZones = new();
// Mob/NPC definition caches (loaded once at init)
private Dictionary<int, DungeonMobDefinition> _mobDefinitions = new();
private Dictionary<int, DungeonNpcDefinition> _npcDefinitions = new();
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,
// World combat
OpCodes.WORLD_ATTACK,
OpCodes.WORLD_MOB_LOOT_REQUEST,
// World NPC
OpCodes.WORLD_NPC_INTERACT,
OpCodes.WORLD_NPC_DIALOG_SELECT,
OpCodes.WORLD_NPC_SHOP_ACTION,
// World objects
OpCodes.WORLD_OBJECT_INTERACT
};
public async Task InitializeAsync()
{
if (_initialized) return;
// Load mob and NPC definitions for zone simulations
await LoadWorldDefinitionsAsync();
_tickCts = new CancellationTokenSource();
_tickTask = Task.Run(() => TickLoopAsync(_tickCts.Token), _tickCts.Token);
_deltaHub.OnDeltaPublished += OnWorldEditDelta;
_initialized = true;
_log.LogInformation(
"WorldHandler initialized with {MobCount} mob defs, {NpcCount} NPC defs",
_mobDefinitions.Count, _npcDefinitions.Count);
}
private async Task LoadWorldDefinitionsAsync()
{
using var scope = _scopeFactory.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<GameDbContext>();
var mobs = await db.Set<DungeonMobDefinition>()
.AsNoTracking()
.Where(m => m.IsEnabled)
.Include(m => m.AbilityAssignments)
.ThenInclude(a => a.AbilityDefinition)
.ToListAsync();
_mobDefinitions = mobs.ToDictionary(m => m.Id);
var npcs = await db.Set<DungeonNpcDefinition>()
.AsNoTracking()
.Where(n => n.IsEnabled)
.ToListAsync();
_npcDefinitions = npcs.ToDictionary(n => n.Id);
// Log mob stats for debugging
foreach (var mob in mobs.Take(5))
{
var stats = mob.GetStatsForBracket(1);
_log.LogInformation(
"MobDef {Id} '{Name}': MoveSpeed={MoveSpeed}, AggroRange={AggroRange}, LeashRange={LeashRange}, Behavior={Behavior}, Abilities={AbilityCount}",
mob.Id, mob.Name, stats.MoveSpeed, stats.AggroRange, stats.LeashRange, mob.Behavior,
mob.AbilityAssignments?.Count(a => a.IsEnabled) ?? 0);
}
}
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);
return;
}
// All remaining opcodes require the player to be spawned
if (!_players.TryGetValue(connection.Id, out var session)) return;
switch (opCode)
{
// Combat
case OpCodes.WORLD_ATTACK:
await HandleWorldAttackAsync(connection, session, payload, ct);
break;
case OpCodes.WORLD_MOB_LOOT_REQUEST:
await HandleWorldMobLootAsync(connection, session, payload, ct);
break;
// NPC
case OpCodes.WORLD_NPC_INTERACT:
await HandleWorldNpcInteract(connection, session, payload, ct);
break;
case OpCodes.WORLD_NPC_DIALOG_SELECT:
await HandleWorldNpcDialogSelect(connection, session, payload, ct);
break;
case OpCodes.WORLD_NPC_SHOP_ACTION:
await HandleWorldNpcShopAction(connection, session, payload, ct);
break;
// Objects
case OpCodes.WORLD_OBJECT_INTERACT:
await HandleWorldObjectInteract(connection, session, payload, ct);
break;
}
}
public void OnDisconnect(Guid connectionId)
{
if (_players.TryRemove(connectionId, out var s))
{
// Remove from zone simulation
var zoneKey = WorldChunkCache.ZoneKey(s.RegionId, s.ZoneX, s.ZoneY, s.ZoneZ);
if (_activeZones.TryGetValue(zoneKey, out var zoneSim))
{
zoneSim.RemovePlayer(s.CharacterId);
}
_ = 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 zz = character.WorldZoneZ ?? 0;
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,
ZoneZ = zz,
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.WorldZoneZ = s.ZoneZ;
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 && _activeZones.IsEmpty) return;
var tick = Interlocked.Read(ref _tick);
// 1. Ensure players are registered in zone simulations
await EnsurePlayersInZoneSimsAsync(tick, ct);
// 2. Tick all active zone simulations (mob AI, combat, projectiles, etc.)
TickActiveZones(tick);
// 3. Broadcast combat events from zone simulations
await BroadcastCombatEventsAsync(ct);
// 4. Process all players (movement, chunk updates, state broadcast)
var tasks = _players.Values.Select(s => ProcessPlayerTickAsync(s, tick, ct));
await Task.WhenAll(tasks);
// 5. Clean up deactivated zones
CleanupInactiveZones();
}
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();
// Get mob/NPC data from zone simulation if active
var zoneKey = WorldChunkCache.ZoneKey(s.RegionId, s.ZoneX, s.ZoneY, s.ZoneZ);
object[]? nearbyMobs = null;
object[]? nearbyNpcs = null;
if (_activeZones.TryGetValue(zoneKey, out var zoneSim))
{
float visRange = TileSize * 48;
nearbyMobs = zoneSim.Mobs.Values
.Where(m => Math.Abs(m.X - s.X) <= visRange && Math.Abs(m.Y - s.Y) <= visRange)
.Select(m => zoneSim.SerializeMob(m))
.ToArray();
nearbyNpcs = zoneSim.Npcs.Values
.Where(n => Math.Abs(n.X - s.X) <= visRange && Math.Abs(n.Y - s.Y) <= visRange)
.Select(n => zoneSim.SerializeNpc(n))
.ToArray();
}
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 }),
mobs = nearbyMobs,
npcs = nearbyNpcs,
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 &&
p.ZoneZ == self.ZoneZ &&
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 == 6 &&
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 zoneZ) &&
int.TryParse(parts[4], out var chunkX) &&
int.TryParse(parts[5], out var chunkY))
{
// Invalidate cache so next access reloads fresh data from DB
_cache.InvalidateChunk(regionId, zoneX, zoneY, zoneZ, 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);
}
}
// ---- Zone Simulation Lifecycle ----
/// <summary>
/// Ensure all players are registered in their zone's simulation.
/// Activates new zone simulations as needed.
/// </summary>
private async Task EnsurePlayersInZoneSimsAsync(long tick, CancellationToken ct)
{
foreach (var s in _players.Values)
{
var zoneKey = WorldChunkCache.ZoneKey(s.RegionId, s.ZoneX, s.ZoneY, s.ZoneZ);
if (!_activeZones.TryGetValue(zoneKey, out var zoneSim))
{
// Activate zone simulation
zoneSim = await ActivateZoneSimulationAsync(zoneKey, s.RegionId, s.ZoneX, s.ZoneY, s.ZoneZ, ct);
if (zoneSim == null) continue;
}
// Ensure player is in the simulation
if (!zoneSim.Players.ContainsKey(s.CharacterId))
{
var combatState = new WorldPlayerCombatState(s);
// Initialize with basic stats (character stats would come from DB/gear)
// For now use defaults — Phase 4 will flesh out stat loading from gear
combatState.InitializeFromCharacter(
strength: 10, intelligence: 10, endurance: 10, dexterity: 10,
armor: 0, maxHealth: 100, weaponDamageTypeKey: "physical",
resistances: new Dictionary<string, float>());
zoneSim.AddPlayer(combatState);
}
}
}
/// <summary>
/// Activate a new zone simulation by loading mob/NPC spawn data from cached chunks.
/// </summary>
private async Task<WorldZoneSimulation?> ActivateZoneSimulationAsync(
string zoneKey, int regionId, int zoneX, int zoneY, int zoneZ, CancellationToken ct)
{
try
{
var region = await _cache.GetRegionAsync(regionId, ct);
if (region == null) return null;
var zoneSim = new WorldZoneSimulation(zoneKey, regionId, zoneX, zoneY, zoneZ, _cache);
zoneSim.SetRegion(region);
// Collect mob and NPC spawns from all chunks in this zone
var mobSpawns = new List<(WorldChunkMobSpawnData, int, int)>();
var npcSpawns = new List<(NpcInstance, int, int)>();
int nextNpcId = 1;
for (int cx = 0; cx < region.ChunksPerZoneX; cx++)
for (int cy = 0; cy < region.ChunksPerZoneY; cy++)
{
var chunk = await _cache.GetChunkAsync(regionId, zoneX, zoneY, zoneZ, cx, cy, ct);
if (chunk == null) continue;
// Calculate world pixel offset for this chunk
int chunkWorldOffsetX = (zoneX * region.ChunksPerZoneX + cx) * region.ChunkWidthTiles * TileSize;
int chunkWorldOffsetY = (zoneY * region.ChunksPerZoneY + cy) * region.ChunkHeightTiles * TileSize;
// Extract mob spawns from MobDtos (anonymous objects)
ExtractMobSpawnsFromChunk(chunk, chunkWorldOffsetX, chunkWorldOffsetY, mobSpawns);
// Extract NPC spawns from NpcDtos
ExtractNpcSpawnsFromChunk(chunk, chunkWorldOffsetX, chunkWorldOffsetY, npcSpawns, ref nextNpcId);
}
zoneSim.Initialize(_mobDefinitions, mobSpawns, npcSpawns);
if (_activeZones.TryAdd(zoneKey, zoneSim))
{
_log.LogInformation(
"Activated zone simulation {ZoneKey}: {MobCount} mobs, {NpcCount} NPCs, {SpawnPoints} spawn points",
zoneKey, zoneSim.Mobs.Count, zoneSim.Npcs.Count,
zoneSim.MobSpawnTracker?.SpawnPointCount ?? 0);
// Log mob details for debugging
foreach (var mob in zoneSim.Mobs.Values.Take(3))
{
_log.LogInformation(
" Mob {Id} '{Name}' at ({X:F0},{Y:F0}): MoveSpeed={MoveSpeed}, Behavior={Behavior}, State={State}, Abilities={AbilityCount}",
mob.Id, mob.Name, mob.X, mob.Y, mob.Stats.MoveSpeed, mob.Behavior, mob.State, mob.Abilities.Count);
}
return zoneSim;
}
// Another thread beat us, use their version
return _activeZones.TryGetValue(zoneKey, out var existing) ? existing : null;
}
catch (Exception ex)
{
_log.LogWarning(ex, "Failed to activate zone simulation {ZoneKey}", zoneKey);
return null;
}
}
/// <summary>
/// Extract mob spawn data from a cached chunk's MobDtos.
/// The MobDtos are anonymous objects serialized from WorldChunkMobSpawn entities.
/// </summary>
private static void ExtractMobSpawnsFromChunk(
WorldChunkCache.CachedChunk chunk,
int chunkWorldOffsetX, int chunkWorldOffsetY,
List<(WorldChunkMobSpawnData, int, int)> mobSpawns)
{
foreach (var mobDto in chunk.MobDtos)
{
// MobDtos are anonymous objects with: id, x, y, mobDefinitionId, mobName, rotation, spawnCount, respawnSeconds, metadataJson
// Use JSON round-trip to extract values
var json = JsonSerializer.Serialize(mobDto);
using var doc = JsonDocument.Parse(json);
var root = doc.RootElement;
var spawnData = new WorldChunkMobSpawnData
{
Id = root.TryGetProperty("id", out var idProp) ? idProp.GetInt64() : 0,
MobDefinitionId = root.TryGetProperty("mobDefinitionId", out var mobDefProp) ? mobDefProp.GetInt32() : 0,
TileX = root.TryGetProperty("x", out var xProp) ? xProp.GetInt32() : 0,
TileY = root.TryGetProperty("y", out var yProp) ? yProp.GetInt32() : 0,
SpawnCount = root.TryGetProperty("spawnCount", out var scProp) ? scProp.GetInt32() : 1,
RespawnSeconds = root.TryGetProperty("respawnSeconds", out var rsProp) ? rsProp.GetSingle() : 30f
};
if (spawnData.MobDefinitionId > 0)
{
mobSpawns.Add((spawnData, chunkWorldOffsetX, chunkWorldOffsetY));
}
}
}
/// <summary>
/// Extract NPC instances from a cached chunk's NpcDtos.
/// </summary>
private void ExtractNpcSpawnsFromChunk(
WorldChunkCache.CachedChunk chunk,
int chunkWorldOffsetX, int chunkWorldOffsetY,
List<(NpcInstance, int, int)> npcSpawns,
ref int nextNpcId)
{
foreach (var npcDto in chunk.NpcDtos)
{
var json = JsonSerializer.Serialize(npcDto);
using var doc = JsonDocument.Parse(json);
var root = doc.RootElement;
int npcDefId = root.TryGetProperty("npcDefinitionId", out var defProp) ? defProp.GetInt32() : 0;
if (npcDefId <= 0 || !_npcDefinitions.TryGetValue(npcDefId, out var npcDef)) continue;
int tileX = root.TryGetProperty("x", out var xProp) ? xProp.GetInt32() : 0;
int tileY = root.TryGetProperty("y", out var yProp) ? yProp.GetInt32() : 0;
float worldX = chunkWorldOffsetX + (tileX * TileSize) + (TileSize / 2f);
float worldY = chunkWorldOffsetY + (tileY * TileSize) + (TileSize / 2f);
var npc = NpcInstance.FromDefinition(npcDef, nextNpcId++, worldX, worldY);
npcSpawns.Add((npc, chunkWorldOffsetX, chunkWorldOffsetY));
}
}
/// <summary>
/// Tick all active zone simulations.
/// </summary>
private void TickActiveZones(long tick)
{
foreach (var (zoneKey, zoneSim) in _activeZones)
{
try
{
zoneSim.Tick(tick, TickDeltaSeconds);
// Periodic debug log every ~10 seconds (100 ticks)
if (tick % 100 == 0 && zoneSim.Mobs.Count > 0)
{
var sample = zoneSim.Mobs.Values.FirstOrDefault();
if (sample != null)
{
_log.LogDebug(
"Zone {ZoneKey} tick {Tick}: {MobCount} mobs, {PlayerCount} players. Sample mob {Id} '{Name}' state={State} pos=({X:F0},{Y:F0}) speed={Speed}",
zoneKey, tick, zoneSim.Mobs.Count, zoneSim.Players.Count,
sample.Id, sample.Name, sample.State, sample.X, sample.Y, sample.Stats.MoveSpeed);
}
}
}
catch (Exception ex)
{
_log.LogWarning(ex, "Error ticking zone simulation {ZoneKey}", zoneKey);
}
}
}
/// <summary>
/// Broadcast pending combat events from all zone simulations.
/// </summary>
private async Task BroadcastCombatEventsAsync(CancellationToken ct)
{
foreach (var (_, zoneSim) in _activeZones)
{
var events = new List<object>();
while (zoneSim.PendingEvents.TryDequeue(out var evt))
{
events.Add(new
{
type = evt.Type.ToString(),
sourceMobId = evt.SourceMobId,
sourcePlayerId = evt.SourcePlayerId,
targetMobId = evt.TargetMobId,
targetPlayerId = evt.TargetPlayerId,
damage = evt.Damage,
damageTypeKey = evt.DamageTypeKey,
x = evt.X,
y = evt.Y,
mobData = evt.MobData
});
}
if (events.Count == 0) continue;
// Send combat state to all players in this zone
foreach (var player in zoneSim.Players.Values)
{
await _broadcast.SendAsync(
player.Session.Connection,
OpCodes.WORLD_COMBAT_STATE,
new { events },
ct);
}
}
}
/// <summary>
/// Remove deactivated zone simulations.
/// </summary>
private void CleanupInactiveZones()
{
foreach (var (zoneKey, zoneSim) in _activeZones)
{
if (!zoneSim.IsActive)
{
if (_activeZones.TryRemove(zoneKey, out var removed))
{
removed.Deactivate();
_log.LogInformation("Deactivated zone simulation {ZoneKey}", zoneKey);
}
}
}
}
// ---- Persistence (only on disconnect) ----
private async Task PersistPlayerLocationAsync(WorldSessionState s)
{
try
{
_log.LogInformation(
"Persisting location for character {CharacterId}: Region={RegionId} Zone=({ZoneX},{ZoneY},{ZoneZ}) Chunk=({ChunkX},{ChunkY}) Pos=({X:F1},{Y:F1})",
s.CharacterId, s.RegionId, s.ZoneX, s.ZoneY, s.ZoneZ, s.ChunkX, s.ChunkY, s.X, s.Y);
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)
{
_log.LogWarning("Character {CharacterId} not found for position persist", s.CharacterId);
return;
}
character.WorldRegionId = s.RegionId;
character.WorldZoneX = s.ZoneX;
character.WorldZoneY = s.ZoneY;
character.WorldZoneZ = s.ZoneZ;
character.WorldChunkX = s.ChunkX;
character.WorldChunkY = s.ChunkY;
character.WorldX = s.X;
character.WorldY = s.Y;
character.LastPlayedAt = DateTime.UtcNow;
await db.SaveChangesAsync();
_log.LogInformation("Successfully persisted location for character {CharacterId}", s.CharacterId);
}
catch (Exception ex)
{
_log.LogError(ex, "Failed to persist world location for character {CharacterId}", s.CharacterId);
}
}
}