using System; using System.Collections.Generic; using System.Linq; using System.Threading; using System.Threading.Tasks; using Microsoft.EntityFrameworkCore; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Logging; using DataServer.Data; using DataServer.Data.Entities; using DataServer.Data.Enums; using Server.Networking; using GameServer.Networking.DTOs; using Server.Networking.Messages; namespace GameServer.Dungeon; public sealed partial class DungeonHandler { #region Dungeon Browser Handlers /// /// Handle request for asset manifest (list of all CDN files for hot-update) /// private async Task HandleAssetManifestRequest(IConnection connection, CancellationToken ct) { using var scope = _scopeFactory.CreateScope(); var db = scope.ServiceProvider.GetRequiredService(); var assets = await db.ClientAssets .Where(a => a.IsEnabled) .Select(a => new { filePath = a.FilePath, assetType = (int)a.AssetType, fileHash = a.FileHash, fileSize = a.FileSize, version = a.Version, isRequired = a.IsRequired, minClientVersion = a.MinClientVersion, cdnPath = a.CdnPath ?? a.FilePath }) .ToListAsync(ct); await SendAsync(connection, DungeonOpCodes.ASSET_MANIFEST_RESPONSE, new { cdnBaseUrl = "https://assets.aeternalisgames.com/downloads/", assets = assets }, ct); _log.LogInformation("Sent asset manifest with {Count} files", assets.Count); } /// /// Handle request for list of available dungeons /// private async Task HandleDungeonListRequest(IConnection connection, DungeonPlayerSession session, CancellationToken ct) { var playerLevel = session.Character.Level; var (bracketMin, bracketMax) = DungeonInstance.GetLevelBracket(playerLevel); // Get active dungeons in player's bracket var availableDungeons = _dungeons.Values .Where(d => d.Simulation.Phase == DungeonPhase.Active && !d.AllBossesDefeated) .Select(d => new { id = d.Id.ToString(), tier = d.Tier, levelBracket = $"{d.LevelBracketMin}-{d.LevelBracketMax}", bracketMin = d.LevelBracketMin, bracketMax = d.LevelBracketMax, creatorName = d.CreatorName, creatorLevel = d.CreatorLevel, playerCount = d.Simulation.Players.Count, maxPlayers = 20, isJoinWindowOpen = d.IsJoinWindowOpen, totalBosses = d.TotalBossCount, defeatedBosses = d.BossesDefeatedCount, createdAt = d.CreatedAt, secondsRemaining = d.IsJoinWindowOpen ? (int)(d.JoinWindowEnd - DateTime.UtcNow).TotalSeconds : 0 }) .OrderByDescending(d => d.isJoinWindowOpen) .ThenByDescending(d => d.createdAt) .ToList(); // Also load persisted dungeons from database (all of them, not filtered by bracket) using var scope = _scopeFactory.CreateScope(); var db = scope.ServiceProvider.GetRequiredService(); var persistedDungeons = await db.Set() .Where(d => !d.IsCleared) .Select(d => new { id = d.Id.ToString(), tier = d.Tier, levelBracket = $"{d.LevelBracketMin}-{d.LevelBracketMax}", bracketMin = d.LevelBracketMin, bracketMax = d.LevelBracketMax, creatorName = d.CreatorName, creatorLevel = d.CreatorLevel, playerCount = 0, maxPlayers = 20, isJoinWindowOpen = false, isPersisted = true, createdAt = d.CreatedAt }) .ToListAsync(ct); await SendAsync(connection, DungeonOpCodes.DUNGEON_LIST_RESPONSE, new { playerLevel = playerLevel, bracket = new { min = bracketMin, max = bracketMax }, activeDungeons = availableDungeons, persistedDungeons = persistedDungeons }, ct); } /// /// Handle creating a new dungeon /// private async Task HandleDungeonCreate(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory payload, CancellationToken ct) { if (session.State == PlayerState.InDungeon) { await SendAsync(connection, DungeonOpCodes.DUNGEON_ENTER_RESULT, new { ok = false, error = "already_in_dungeon" }, ct); return; } var request = _ser.Deserialize(payload); int tier = Math.Clamp(request.Tier, 1, 10); int playerLevel = session.Character.Level; // Get player's natural bracket, but allow them to select different ones within +/-50 levels var (naturalBracketMin, naturalBracketMax) = DungeonInstance.GetLevelBracket(playerLevel); int bracketMin, bracketMax; if (request.BracketMin > 0) { // Player specified a bracket - validate it's within +/-50 levels of player bracketMin = request.BracketMin; (bracketMin, bracketMax) = DungeonInstance.GetLevelBracket(bracketMin); // Normalize to valid bracket // Check if bracket start is within +/-50 of player level if (Math.Abs(bracketMin - playerLevel) > 50) { await SendAsync(connection, DungeonOpCodes.DUNGEON_ENTER_RESULT, new { ok = false, error = "bracket_out_of_range", message = $"You can only create dungeons for brackets within 50 levels of your level ({playerLevel})" }, ct); return; } } else { // Use player's natural bracket bracketMin = naturalBracketMin; bracketMax = naturalBracketMax; } var dungeonId = Guid.NewGuid(); int seed = Random.Shared.Next(); var (layout, layoutV2) = await GenerateDungeonLayoutWithFallbackAsync(seed, tier, ct); var simulation = new DungeonSimulation(layout, tier, _mobDefinitions, bracketMin, _abilityDefinitions, _mobSpriteConfigs, _abilityAnimationMappings, _npcDefinitions); var instance = new DungeonInstance { Id = dungeonId, Tier = tier, Seed = seed, Simulation = simulation, CreatedAt = DateTime.UtcNow, LevelBracketMin = bracketMin, LevelBracketMax = bracketMax, CreatorLevel = playerLevel, CreatorCharacterId = session.CharacterId, CreatorName = session.Character.Name, LayoutV2 = layoutV2 // Store V2 layout for visual tile data }; instance.InitializeBossState(simulation.Mobs.Values.Count(m => m.Type == MobType.Boss)); _dungeons[dungeonId] = instance; _log.LogInformation("Player {Name} (Level {Level}) created dungeon {Id} (tier {Tier}, bracket {Min}-{Max})", session.Character.Name, playerLevel, dungeonId, tier, bracketMin, bracketMax); // Add player to dungeon await AddPlayerToDungeonAsync(connection, session, instance, ct); } /// /// Handle joining an existing dungeon /// private async Task HandleDungeonJoin(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory payload, CancellationToken ct) { if (session.State == PlayerState.InDungeon) { await SendAsync(connection, DungeonOpCodes.DUNGEON_ENTER_RESULT, new { ok = false, error = "already_in_dungeon" }, ct); return; } var request = _ser.Deserialize(payload); if (!Guid.TryParse(request.DungeonId, out var dungeonId)) { await SendAsync(connection, DungeonOpCodes.DUNGEON_ENTER_RESULT, new { ok = false, error = "invalid_dungeon_id" }, ct); return; } int playerLevel = session.Character.Level; // Check if dungeon is in memory if (_dungeons.TryGetValue(dungeonId, out var instance)) { // Validate level bracket if (!instance.IsLevelInBracket(playerLevel)) { // Players can join any bracket - just log a warning _log.LogInformation("Player {Name} (Level {Level}) joining dungeon outside their bracket ({Min}-{Max})", session.Character.Name, playerLevel, instance.LevelBracketMin, instance.LevelBracketMax); } // Check if full if (instance.Simulation.Players.Count >= 20) { await SendAsync(connection, DungeonOpCodes.DUNGEON_ENTER_RESULT, new { ok = false, error = "dungeon_full" }, ct); return; } // Check if boss killed if (instance.AllBossesDefeated) { await SendAsync(connection, DungeonOpCodes.DUNGEON_ENTER_RESULT, new { ok = false, error = "dungeon_cleared" }, ct); return; } // If dungeon is currently empty (no players), respawn all mobs if (instance.Simulation.Players.Count == 0) { RespawnAllMobs(instance); _log.LogInformation("Respawned all mobs in dungeon {Id} (was empty when player joined)", dungeonId); } await AddPlayerToDungeonAsync(connection, session, instance, ct); return; } // Try to restore from persistence using var scope = _scopeFactory.CreateScope(); var db = scope.ServiceProvider.GetRequiredService(); var persisted = await db.Set().FindAsync(new object[] { dungeonId }, ct); if (persisted == null) { await SendAsync(connection, DungeonOpCodes.DUNGEON_ENTER_RESULT, new { ok = false, error = "dungeon_not_found" }, ct); return; } if (persisted.IsCleared) { await SendAsync(connection, DungeonOpCodes.DUNGEON_ENTER_RESULT, new { ok = false, error = "dungeon_cleared" }, ct); return; } // Players can join any bracket - just log if outside their level if (playerLevel < persisted.LevelBracketMin || playerLevel > persisted.LevelBracketMax) { _log.LogInformation("Player {Name} (Level {Level}) joining persisted dungeon outside their bracket ({Min}-{Max})", session.Character.Name, playerLevel, persisted.LevelBracketMin, persisted.LevelBracketMax); } // Restore dungeon from persistence instance = await RestoreDungeonFromPersistenceAsync(persisted, ct); if (instance == null) { await SendAsync(connection, DungeonOpCodes.DUNGEON_ENTER_RESULT, new { ok = false, error = "restore_failed" }, ct); return; } _dungeons[dungeonId] = instance; // Remove from persistence table (it's active now) db.Set().Remove(persisted); await db.SaveChangesAsync(ct); await AddPlayerToDungeonAsync(connection, session, instance, ct); } /// /// Add a player to a dungeon and send the result /// private async Task AddPlayerToDungeonAsync(IConnection connection, DungeonPlayerSession session, DungeonInstance instance, CancellationToken ct) { using var scope = _scopeFactory.CreateScope(); var db = scope.ServiceProvider.GetRequiredService(); var layout = instance.Simulation.Layout; var spawnPos = layout.Rooms[0]; // Entrance room // Load equipped items for stat calculations var equippedCharacterItems = await db.Set() .Include(i => i.ItemDefinition) .Include(i => i.CraftedItem) .Where(i => i.CharacterId == session.CharacterId && i.IsEquipped) .ToListAsync(ct); // Calculate combat stats with equipment bonuses (including crafted) var combatStats = DungeonCharacterStats.GetCombatStats(session.Character, equippedCharacterItems); var player = new PlayerInstance { CharacterId = session.CharacterId, CharacterName = session.Character.Name, X = spawnPos.CenterX * 32 + Random.Shared.Next(-20, 20), Y = spawnPos.CenterY * 32 + Random.Shared.Next(-20, 20), Health = Math.Min(session.Character.CurrentHealth, combatStats.MaxHealth), MaxHealth = combatStats.MaxHealth, Mana = Math.Min(session.Character.CurrentMana, combatStats.MaxMana), MaxMana = combatStats.MaxMana, Stamina = combatStats.MaxStamina, MaxStamina = combatStats.MaxStamina, MoveSpeed = combatStats.MoveSpeed, AttackSpeed = combatStats.AttackSpeed, Strength = combatStats.Strength, Intelligence = combatStats.Intelligence, Wisdom = combatStats.Wisdom, Endurance = combatStats.Endurance, Dexterity = combatStats.Dexterity, Armor = combatStats.Armor }; instance.Simulation.Players[session.CharacterId] = player; instance.LastPlayerActivity = DateTime.UtcNow; NormalizeMobVisualStateForPayload(instance.Simulation); session.State = PlayerState.InDungeon; session.CurrentDungeonId = instance.Id; session.PlayerInstance = player; session.InitialMobCatalogDungeonId = null; // Build visual tile data if V2 layout available object? tileSheets = null; object? visualTiles = null; object? placedObjects = null; if (instance.LayoutV2 != null && instance.LayoutV2.TileDetails.Count > 0) { tileSheets = instance.LayoutV2.TileMapSheets.Select(s => new { id = s.Id, path = s.CdnPath, tileW = s.TileWidth, tileH = s.TileHeight, sheetW = s.SheetWidth, sheetH = s.SheetHeight, cols = s.Columns }).ToArray(); visualTiles = instance.LayoutV2.TileDetails.Select(t => new { x = t.X, y = t.Y, tid = t.TileDefinitionId, sid = t.SheetId, frame = t.FrameIndex, l = t.Layer, r = t.Rotation, fx = t.FlipX, fy = t.FlipY }).ToArray(); // V3: Include placed objects (decorations, containers, traps) if (instance.LayoutV2.Objects?.Count > 0) { placedObjects = instance.LayoutV2.Objects.Select(o => new { x = o.X, y = o.Y, id = o.ObjectTemplateId, name = o.Name, type = o.Type, sheetId = o.SpriteSheetId, frame = o.FrameIndex, blocks = o.BlocksMovement, interact = o.IsInteractable, triggeredByWalk = o.TriggeredByWalk, interactionType = o.InteractionType, trap = o.IsTrap, damage = o.TrapDamage, loot = o.LootTableId, metadataJson = o.MetadataJson }).ToArray(); } _log.LogInformation("Sending {SheetCount} sheets, {TileCount} visual tiles, {ObjectCount} objects to client", instance.LayoutV2.TileMapSheets.Count, instance.LayoutV2.TileDetails.Count, instance.LayoutV2.Objects?.Count ?? 0); } await SendAsync(connection, DungeonOpCodes.DUNGEON_ENTER_RESULT, new { ok = true, dungeonId = instance.Id.ToString(), tier = instance.Tier, seed = instance.Seed, levelBracket = new { min = instance.LevelBracketMin, max = instance.LevelBracketMax }, width = layout.Width, height = layout.Height, tilesRLE = layout.SerializeTilesRLE(), spawn = new { x = player.X, y = player.Y }, players = instance.Simulation.Players.Values.Select(p => new { id = p.CharacterId, name = p.CharacterName, x = p.X, y = p.Y }), mobs = instance.Simulation.Mobs.Values.Select(m => new { id = m.Id, definitionId = m.DefinitionId, name = m.Name, x = m.X, y = m.Y, rotation = m.Rotation, health = m.Health, maxHealth = m.MaxHealth, hasLoot = m.HasDeathLoot, isAlive = m.IsAlive, state = m.State.ToString().ToLower(), currentAnimation = m.CurrentAnimation, spriteConfig = DeserializeSpriteConfigSafe(m.SpriteConfigJson), tintColor = m.TintColor, scale = m.Scale }), mobCatalog = instance.Simulation.Mobs.Values.Select(m => new { id = m.Id, definitionId = m.DefinitionId, name = m.Name, spriteConfig = DeserializeSpriteConfigSafe(m.SpriteConfigJson), tintColor = m.TintColor, scale = m.Scale }), chests = instance.Simulation.Chests.Values.Select(c => new { id = c.Id, x = c.X, y = c.Y, type = c.Type.ToString().ToLower(), opened = c.IsOpened }), portals = instance.Simulation.Portals.Values.Where(p => p.IsActive).Select(p => new { id = p.Id, x = p.X, y = p.Y, type = p.Type.ToString().ToLower(), triggerOnCollision = p.TriggerOnCollision, triggerRadius = p.TriggerRadius, destinationX = p.DestinationX, destinationY = p.DestinationY }), // V3 visual tile data tileSheets, visualTiles, placedObjects }, ct); _log.LogInformation("Player {Name} (Level {Level}) joined dungeon {Id}", session.Character.Name, session.Character.Level, instance.Id); } /// /// Restore a dungeon from persistence /// private async Task RestoreDungeonFromPersistenceAsync(DungeonPersistence persisted, CancellationToken ct) { try { using var scope = _scopeFactory.CreateScope(); var db = scope.ServiceProvider.GetRequiredService(); var vnext = new DungeonGeneratorVNext(db, persisted.Seed, persisted.Tier); var layout = await vnext.GenerateAsync(); var simulation = new DungeonSimulation(layout, persisted.Tier, _mobDefinitions, persisted.LevelBracketMin, _abilityDefinitions, _mobSpriteConfigs, _abilityAnimationMappings, _npcDefinitions); var mobStatePayload = DeserializePersistedMobPayload(persisted.MobStateJson); var persistedMobStates = mobStatePayload?.Mobs; // Rehydrate runtime/admin-spawned alive mobs that are not in static layout spawns. if (persistedMobStates != null) { foreach (var mobState in persistedMobStates.Where(m => m.IsAlive)) { if (simulation.Mobs.ContainsKey(mobState.Id)) continue; simulation.TrySpawnMobFromPersistedState(mobState); } } _log.LogInformation("Dungeon {Id} restored from persistence with {MobCount} saved mob states", persisted.Id, persistedMobStates?.Count ?? 0); // Restore chest state if available (chests stay opened) if (!string.IsNullOrEmpty(persisted.ChestStateJson)) { var chestStates = System.Text.Json.JsonSerializer.Deserialize>(persisted.ChestStateJson); if (chestStates != null) { foreach (var chestState in chestStates) { if (simulation.Chests.TryGetValue(chestState.Id, out var chest)) { chest.IsOpened = chestState.IsOpened; } } } } var instance = new DungeonInstance { Id = persisted.Id, Tier = persisted.Tier, Seed = persisted.Seed, Simulation = simulation, CreatedAt = persisted.CreatedAt, LevelBracketMin = persisted.LevelBracketMin, LevelBracketMax = persisted.LevelBracketMax, CreatorLevel = persisted.CreatorLevel, CreatorCharacterId = persisted.CreatorCharacterId, CreatorName = persisted.CreatorName, BossKilled = persisted.BossKilled, IsPersisted = false, LastPlayerActivity = DateTime.UtcNow }; instance.BossesRespawnOnReload = mobStatePayload?.BossesRespawnOnReload ?? false; instance.InitializeBossState(simulation.Mobs.Values.Count(m => m.Type == MobType.Boss), false); // Restore defeated-boss progress from persisted mob state. if (persistedMobStates != null && !instance.BossesRespawnOnReload) { foreach (var mobState in persistedMobStates.Where(m => !m.IsAlive)) { bool isBoss = false; if (simulation.Mobs.TryGetValue(mobState.Id, out var simMob)) { isBoss = simMob.Type == MobType.Boss; } else if (_mobDefinitions.TryGetValue(mobState.DefinitionId, out var mobDef)) { isBoss = mobDef.Type == MobType.Boss; } if (!isBoss) continue; // If this boss existed in current simulation, keep it dead. if (simulation.Mobs.TryGetValue(mobState.Id, out var killedBoss)) { killedBoss.IsAlive = false; killedBoss.Health = 0; killedBoss.State = MobState.Dead; killedBoss.CurrentAnimation = killedBoss.GetDirectionalAnimation("death"); } else { // Preserve boss progress for runtime/admin-spawned bosses that are not in static layout. instance.RegisterBossSpawn(mobState.Id); } instance.RegisterBossDefeat(mobState.Id); } } // Backward compatibility: if persisted record only marks fully cleared, mirror that state. if (persisted.BossKilled && !instance.AllBossesDefeated) { var allBossIds = simulation.Mobs.Values .Where(m => m.Type == MobType.Boss) .Select(m => m.Id) .ToList(); instance.SetDefeatedBossMobIds(allBossIds); foreach (var bossId in allBossIds) { if (simulation.Mobs.TryGetValue(bossId, out var boss)) { boss.IsAlive = false; boss.Health = 0; boss.State = MobState.Dead; boss.CurrentAnimation = boss.GetDirectionalAnimation("death"); } } } _log.LogInformation("Restored dungeon {Id} from persistence with fresh mobs", persisted.Id); return instance; } catch (Exception ex) { _log.LogError(ex, "Failed to restore dungeon {Id} from persistence", persisted.Id); return null; } } /// /// Respawn all mobs in a dungeon (called when dungeon was empty and player rejoins) /// Preserves mobs that are carrying player loot from kills /// private void RespawnAllMobs(DungeonInstance instance) { var defeatedBossMobIds = !instance.BossesRespawnOnReload ? instance.GetDefeatedBossMobIdsSnapshot() : new HashSet(); if (instance.BossesRespawnOnReload) { instance.ResetBossProgress(); } // Check if any existing mobs have carried player loot - don't respawn those var mobsWithLoot = instance.Simulation.Mobs.Values .Where(m => m.HasCarriedLoot) .ToDictionary(m => m.Id, m => m); if (mobsWithLoot.Count > 0) { _log.LogInformation("Preserving {Count} mobs with carried player loot during respawn", mobsWithLoot.Count); } // IMPORTANT: Reuse the existing layout to preserve mob spawn positions. var layout = instance.Simulation.Layout; var freshSimulation = new DungeonSimulation(layout, instance.Tier, _mobDefinitions, instance.LevelBracketMin, _abilityDefinitions, _mobSpriteConfigs, _abilityAnimationMappings, _npcDefinitions); // Clear and rebuild mobs, keeping those with loot instance.Simulation.Mobs.Clear(); foreach (var mob in freshSimulation.Mobs) { // If we have a preserved mob with this ID (same spawn point), use the preserved one if (mobsWithLoot.TryGetValue(mob.Key, out var preservedMob)) { // Restore the preserved mob (keeps carried loot) instance.Simulation.Mobs.TryAdd(mob.Key, preservedMob); } else { // Use the fresh mob if (!instance.BossesRespawnOnReload && mob.Value.Type == MobType.Boss && defeatedBossMobIds.Contains(mob.Key)) { mob.Value.IsAlive = false; mob.Value.Health = 0; mob.Value.State = MobState.Dead; mob.Value.CurrentAnimation = mob.Value.GetDirectionalAnimation("death"); } instance.Simulation.Mobs.TryAdd(mob.Key, mob.Value); } } // Reset runtime combat/animation state for all living mobs after a dungeon reset. foreach (var mob in instance.Simulation.Mobs.Values.Where(m => m.IsAlive)) { mob.State = MobState.Idle; mob.StateTime = 0f; mob.StuckTime = 0f; mob.TargetId = null; mob.CastingAbility = null; mob.CastTimeRemaining = 0f; mob.CurrentAnimation = mob.GetDirectionalAnimation("idle"); } // Reset chest states (they respawn closed) - but NOT loot chests foreach (var chest in instance.Simulation.Chests.Values) { chest.IsOpened = false; } // DON'T clear loot chests - these contain player death drops! // instance.Simulation.LootChests.Clear(); // DON'T clear dropped items - these might be important! // instance.Simulation.DroppedItems.Clear(); // Reset portals to default active state. foreach (var portal in instance.Simulation.Portals.Values) { portal.IsActive = true; } _log.LogDebug("Respawned {MobCount} mobs in dungeon {Id} (preserved {PreservedCount} with loot, bossesRespawn={BossesRespawn})", instance.Simulation.Mobs.Count, instance.Id, mobsWithLoot.Count, instance.BossesRespawnOnReload); } /// /// Persist a dungeon to SQL (called when empty for 10 minutes) /// private async Task PersistDungeonAsync(DungeonInstance instance, CancellationToken ct) { if (instance.IsPersisted || instance.AllBossesDefeated) return; try { using var scope = _scopeFactory.CreateScope(); var db = scope.ServiceProvider.GetRequiredService(); // Serialize mob state var mobStates = instance.Simulation.Mobs.Values.Select(m => new PersistedMobState { Id = m.Id, DefinitionId = m.DefinitionId, X = m.X, Y = m.Y, Health = m.Health, IsAlive = m.IsAlive }).ToList(); var mobStatePayload = new PersistedDungeonMobPayload { BossesRespawnOnReload = instance.BossesRespawnOnReload, Mobs = mobStates }; // Serialize chest state var chestStates = instance.Simulation.Chests.Values.Select(c => new PersistedChestState { Id = c.Id, IsOpened = c.IsOpened }).ToList(); // Check if record already exists (can happen if restore failed to delete the record) var existing = await db.Set().FindAsync(new object[] { instance.Id }, ct); if (existing != null) { // Update existing record existing.LastActivity = instance.LastPlayerActivity; existing.PersistedAt = DateTime.UtcNow; existing.BossKilled = instance.AllBossesDefeated; existing.MobStateJson = System.Text.Json.JsonSerializer.Serialize(mobStatePayload); existing.ChestStateJson = System.Text.Json.JsonSerializer.Serialize(chestStates); } else { var persisted = new DungeonPersistence { Id = instance.Id, Tier = instance.Tier, Seed = instance.Seed, LevelBracketMin = instance.LevelBracketMin, LevelBracketMax = instance.LevelBracketMax, CreatorCharacterId = instance.CreatorCharacterId, CreatorName = instance.CreatorName, CreatorLevel = instance.CreatorLevel, CreatedAt = instance.CreatedAt, LastActivity = instance.LastPlayerActivity, PersistedAt = DateTime.UtcNow, BossKilled = instance.AllBossesDefeated, MobStateJson = System.Text.Json.JsonSerializer.Serialize(mobStatePayload), ChestStateJson = System.Text.Json.JsonSerializer.Serialize(chestStates) }; db.Set().Add(persisted); } await db.SaveChangesAsync(ct); instance.IsPersisted = true; _log.LogInformation("Persisted dungeon {Id} to database", instance.Id); } catch (Exception ex) { _log.LogError(ex, "Failed to persist dungeon {Id}", instance.Id); } } private PersistedDungeonMobPayload? DeserializePersistedMobPayload(string? mobStateJson) { if (string.IsNullOrWhiteSpace(mobStateJson)) return null; try { var payload = System.Text.Json.JsonSerializer.Deserialize(mobStateJson); if (payload != null) { payload.Mobs ??= new List(); return payload; } } catch { } try { var legacyMobs = System.Text.Json.JsonSerializer.Deserialize>(mobStateJson); if (legacyMobs != null) { return new PersistedDungeonMobPayload { BossesRespawnOnReload = false, Mobs = legacyMobs }; } } catch { } return null; } #endregion }