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.BossKilled) .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, 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(); // Try V3 generator with DungeonBuilder templates first DungeonLayout layout; DungeonLayoutV2? layoutV2 = null; try { using var scope = _scopeFactory.CreateScope(); var db = scope.ServiceProvider.GetRequiredService(); var generator = new DungeonGeneratorV3(db, seed, tier); layoutV2 = await generator.GenerateAsync(); // Check if V3 actually produced tiles if (layoutV2.TileDetails.Count == 0) { _log.LogWarning("V3 generator produced no tiles, falling back to V2"); var generatorV2 = new DungeonGeneratorV2(db, seed, tier); layoutV2 = await generatorV2.GenerateAsync(); } layout = layoutV2; _log.LogInformation("Generated dungeon - {RoomCount} rooms, {TileCount} visual tiles", layoutV2.Rooms.Count, layoutV2.TileDetails?.Count ?? 0); } catch (Exception ex) { _log.LogWarning(ex, "Dungeon generator failed, falling back to V2"); try { using var scope = _scopeFactory.CreateScope(); var db = scope.ServiceProvider.GetRequiredService(); var generatorV2 = new DungeonGeneratorV2(db, seed, tier); layoutV2 = await generatorV2.GenerateAsync(); layout = layoutV2; } catch (Exception ex2) { _log.LogWarning(ex2, "V2 generator also failed, using V1"); layout = DungeonGenerator.Generate(seed, tier); } } var simulation = new DungeonSimulation(layout, tier, _mobDefinitions, bracketMin, null, _mobSpriteConfigs); 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 }; _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.BossKilled) { 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; session.State = PlayerState.InDungeon; session.CurrentDungeonId = instance.Id; session.PlayerInstance = player; // 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, trap = o.IsTrap, damage = o.TrapDamage, loot = o.LootTableId }).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.Where(m => m.IsAlive).Select(m => new { id = m.Id, name = m.Name, x = m.X, y = m.Y, rotation = m.Rotation, health = m.Health, maxHealth = m.MaxHealth, state = m.State.ToString().ToLower(), spriteConfig = string.IsNullOrEmpty(m.SpriteConfigJson) ? null : System.Text.Json.JsonSerializer.Deserialize(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() }), // 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 { var layout = DungeonGenerator.Generate(persisted.Seed, persisted.Tier); var simulation = new DungeonSimulation(layout, persisted.Tier, _mobDefinitions, persisted.LevelBracketMin, null, _mobSpriteConfigs); // NOTE: We intentionally do NOT restore mob state here. // When a dungeon is restored (all players left), ALL mobs respawn fresh. // This gives the dungeon a "reset" behavior when empty. // The mob state is preserved in persistence for potential future use, // but on restore we use the freshly generated mobs from DungeonSimulation. _log.LogInformation("Dungeon {Id} restored with all mobs respawned (was persisted with {MobCount} mob states)", persisted.Id, string.IsNullOrEmpty(persisted.MobStateJson) ? 0 : "saved"); // 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 }; _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) { // 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! // Using DungeonGenerator.Generate() would create a V1 layout which has different // room geometry than V2/V3, causing mobs to spawn in wrong positions. var layout = instance.Simulation.Layout; var freshSimulation = new DungeonSimulation(layout, instance.Tier, _mobDefinitions, instance.LevelBracketMin, null, _mobSpriteConfigs); // 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 instance.Simulation.Mobs.TryAdd(mob.Key, mob.Value); } } // 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 (exit portal should be inactive until boss killed) foreach (var portal in instance.Simulation.Portals.Values) { if (portal.Type == PortalType.Exit) { portal.IsActive = false; } } _log.LogDebug("Respawned {MobCount} mobs in dungeon {Id} (preserved {PreservedCount} with loot)", instance.Simulation.Mobs.Count, instance.Id, mobsWithLoot.Count); } /// /// Persist a dungeon to SQL (called when empty for 10 minutes) /// private async Task PersistDungeonAsync(DungeonInstance instance, CancellationToken ct) { if (instance.IsPersisted || instance.BossKilled) 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(); // 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.BossKilled; existing.MobStateJson = System.Text.Json.JsonSerializer.Serialize(mobStates); 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.BossKilled, MobStateJson = System.Text.Json.JsonSerializer.Serialize(mobStates), 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); } } #endregion }