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
}