diff --git a/Game/Dungeon/DungeonHandler.Crafting.cs b/Game/Dungeon/DungeonHandler.Crafting.cs new file mode 100644 index 0000000..d4a9c40 --- /dev/null +++ b/Game/Dungeon/DungeonHandler.Crafting.cs @@ -0,0 +1,205 @@ +using System.Linq; +using System.Threading; +using System.Threading.Tasks; +using Microsoft.EntityFrameworkCore; +using Microsoft.Extensions.DependencyInjection; +using DataServer.Data; +using DataServer.Data.Enums; +using Server.Networking; +using GameServer.Networking.DTOs; +using Server.Networking.Messages; +using DataServer.Data.Entities; + +namespace GameServer.Dungeon; + +public sealed partial class DungeonHandler +{ + #region Crafting + + private async Task HandleCraftingSkillsRequest(IConnection connection, DungeonPlayerSession session, CancellationToken ct) + { + using var scope = _scopeFactory.CreateScope(); + var db = scope.ServiceProvider.GetRequiredService(); + + var skills = await _craftingHandler.GetAllCraftingSkillsAsync(db, session.CharacterId); + + var skillsData = skills.ToDictionary( + kvp => (int)kvp.Key, + kvp => new + { + level = kvp.Value.Level, + xp = kvp.Value.Experience, + xpForNext = kvp.Value.ExperienceForNextLevel, + totalCrafted = kvp.Value.TotalItemsCrafted + } + ); + + await SendAsync(connection, DungeonOpCodes.CRAFTING_SKILLS_STATE, new { skills = skillsData }, ct); + } + + private async Task HandleCraftingRecipesRequest(IConnection connection, DungeonPlayerSession session, CancellationToken ct) + { + using var scope = _scopeFactory.CreateScope(); + var db = scope.ServiceProvider.GetRequiredService(); + + var recipes = await _craftingHandler.GetKnownRecipesAsync(db, session.CharacterId); + + // Get item definitions for names + var itemDefIds = recipes.SelectMany(r => r.Ingredients.Select(i => i.ItemDefinitionId)) + .Concat(recipes.Select(r => r.OutputItemDefinitionId)) + .Concat(recipes.Where(r => r.BonusOutputItemDefinitionId.HasValue).Select(r => r.BonusOutputItemDefinitionId!.Value)) + .Distinct() + .ToList(); + + var itemDefs = await db.DungeonItemDefinitions + .Where(d => itemDefIds.Contains(d.Id)) + .ToDictionaryAsync(d => d.Id, ct); + + var recipesData = recipes.Select(r => new + { + id = r.Id, + name = r.Name, + description = r.Description, + skillType = (int)r.SkillType, + requiredLevel = r.RequiredLevel, + tier = r.Tier, + outputItemDefinitionId = r.OutputItemDefinitionId, + outputName = itemDefs.TryGetValue(r.OutputItemDefinitionId, out var outDef) ? outDef.Name : "Unknown", + outputQuantity = r.OutputQuantity, + hasStatRolls = r.HasStatRolls, + bonusOutputName = r.BonusOutputItemDefinitionId.HasValue && itemDefs.TryGetValue(r.BonusOutputItemDefinitionId.Value, out var bonusDef) + ? bonusDef.Name + : null, + bonusOutputMinLevel = r.BonusOutputMinLevel, + ingredients = r.Ingredients.Select(i => new + { + itemDefinitionId = i.ItemDefinitionId, + itemName = itemDefs.TryGetValue(i.ItemDefinitionId, out var ingDef) ? ingDef.Name : "Unknown", + quantity = i.Quantity + }).ToList() + }); + + await SendAsync(connection, DungeonOpCodes.CRAFTING_RECIPES_STATE, new { recipes = recipesData }, ct); + } + + private async Task HandleCraftingAttempt(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory payload, CancellationToken ct) + { + var request = _ser.Deserialize(payload); + if (request == null) return; + + using var scope = _scopeFactory.CreateScope(); + var db = scope.ServiceProvider.GetRequiredService(); + + // Load character + var character = await db.DungeonCharacters.FindAsync(new object[] { session.CharacterId }, ct); + if (character == null) + { + await SendAsync(connection, DungeonOpCodes.CRAFTING_RESULT, new { success = false, error = "Character not found" }, ct); + return; + } + + if (request.Discover && request.Ingredients != null && request.Ingredients.Count > 0) + { + // Recipe discovery attempt with optional skill type filter + var ingredients = request.Ingredients.Select(i => (i.ItemDefinitionId, i.Quantity)).ToList(); + CraftingSkillType? skillFilter = request.SkillType.HasValue + ? (CraftingSkillType)request.SkillType.Value + : null; + + var (recipe, alreadyKnown, error) = await _craftingHandler.TryDiscoverRecipeAsync( + db, session.CharacterId, ingredients, skillFilter); + + if (recipe == null) + { + // Failed discovery - 65% chance to lose materials + var (materialsLost, lostItems) = await _craftingHandler.TryConsumeMaterialsOnFailedDiscoveryAsync( + db, session.CharacterId, ingredients); + + var errorMsg = error ?? "No recipe found for these ingredients"; + if (materialsLost) + { + errorMsg += $"\nMaterials lost: {string.Join(", ", lostItems)}"; + } + else + { + errorMsg += "\nMaterials saved!"; + } + + await SendAsync(connection, DungeonOpCodes.CRAFTING_RESULT, new + { + success = false, + error = errorMsg, + materialsLost = materialsLost, + lostItems = lostItems + }, ct); + } + else if (alreadyKnown) + { + await SendAsync(connection, DungeonOpCodes.CRAFTING_RESULT, new + { + success = false, + error = "You already know this recipe!", + recipeName = recipe.Name + }, ct); + } + else + { + // New recipe discovered! + await SendAsync(connection, DungeonOpCodes.RECIPE_DISCOVERED, new + { + id = recipe.Id, + name = recipe.Name, + skillType = (int)recipe.SkillType + }, ct); + + await SendAsync(connection, DungeonOpCodes.CRAFTING_RESULT, new + { + success = true, + discovered = true, + recipeName = recipe.Name + }, ct); + } + } + else + { + // Normal crafting from known recipe + var result = await _craftingHandler.CraftItemAsync(db, session.CharacterId, request.RecipeId, character); + + if (result.Success) + { + await SendAsync(connection, DungeonOpCodes.CRAFTING_RESULT, new + { + success = true, + outputName = result.OutputItem?.Name ?? "Unknown", + quantity = result.OutputQuantity, + xpGained = result.XpGained, + newSkillLevel = result.NewSkillLevel, + leveledUp = result.LeveledUp, + gotBonusOutput = result.GotBonusOutput, + slotIndex = result.SlotIndex, + rollResults = result.RollResults.Select(r => new { stat = r.Stat, value = r.Value }), + qualityRating = result.CraftedItem?.QualityRating + }, ct); + + if (result.LeveledUp) + { + await SendAsync(connection, DungeonOpCodes.CRAFTING_SKILL_LEVELUP, new + { + skillType = (int)result.OutputItem?.Type, // We'd need to get the skill type from recipe + newLevel = result.NewSkillLevel + }, ct); + } + } + else + { + await SendAsync(connection, DungeonOpCodes.CRAFTING_RESULT, new + { + success = false, + error = result.ErrorMessage + }, ct); + } + } + } + + #endregion +} diff --git a/Game/Dungeon/DungeonHandler.Dungeons.cs b/Game/Dungeon/DungeonHandler.Dungeons.cs new file mode 100644 index 0000000..3935634 --- /dev/null +++ b/Game/Dungeon/DungeonHandler.Dungeons.cs @@ -0,0 +1,680 @@ +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(); + + 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 +} diff --git a/Game/Dungeon/DungeonHandler.LootChests.cs b/Game/Dungeon/DungeonHandler.LootChests.cs new file mode 100644 index 0000000..f3b8cb4 --- /dev/null +++ b/Game/Dungeon/DungeonHandler.LootChests.cs @@ -0,0 +1,392 @@ +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 Server.Networking; +using GameServer.Networking.DTOs; +using Server.Networking.Messages; + +namespace GameServer.Dungeon; + +public sealed partial class DungeonHandler +{ + #region Loot Chest Handlers + + /// + /// Handle opening a loot chest + /// + private async Task HandleLootChestOpen(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory payload, CancellationToken ct) + { + var json = System.Text.Encoding.UTF8.GetString(payload.Span); + var request = System.Text.Json.JsonSerializer.Deserialize(json); + if (request == null) return; + + if (!session.CurrentDungeonId.HasValue || + !_dungeons.TryGetValue(session.CurrentDungeonId.Value, out var dungeon)) + return; + + if (!dungeon.Simulation.LootChests.TryGetValue(request.ChestId, out var chest)) + { + await SendErrorAsync(connection, "Chest not found", ct); + return; + } + + // Check ownership + if (chest.OwnerCharacterId != session.CharacterId) + { + await SendErrorAsync(connection, "This chest doesn't belong to you", ct); + return; + } + + // Check distance + if (session.PlayerInstance != null) + { + float dist = MathF.Sqrt( + MathF.Pow(session.PlayerInstance.X - chest.X, 2) + + MathF.Pow(session.PlayerInstance.Y - chest.Y, 2)); + + if (dist > 96) // Interaction range + { + await SendErrorAsync(connection, "Too far from chest", ct); + return; + } + } + + chest.IsOpen = true; + + // Load item definitions for display + using var scope = _scopeFactory.CreateScope(); + var db = scope.ServiceProvider.GetRequiredService(); + + var itemDefIds = chest.Items.Select(i => i.ItemDefinitionId).Distinct().ToList(); + var itemDefs = await db.Set() + .Where(d => itemDefIds.Contains(d.Id)) + .ToDictionaryAsync(d => d.Id, ct); + + // Build chest state + var chestItems = new object?[100]; + foreach (var item in chest.Items) + { + if (itemDefs.TryGetValue(item.ItemDefinitionId, out var def)) + { + chestItems[item.SlotIndex] = new + { + slotIndex = item.SlotIndex, + definitionId = def.Id, + name = def.Name, + description = def.Description, + type = def.Type.ToString(), + rarity = def.Rarity.ToString(), + quantity = item.Quantity, + spritePath = def.SpritePath, + tintColor = def.TintColor + }; + } + } + + await SendAsync(connection, DungeonOpCodes.LOOT_CHEST_STATE, new + { + chestId = chest.Id, + gold = chest.Gold, + items = chestItems, + slots = 100 + }, ct); + } + + /// + /// Handle taking a single item from loot chest + /// + private async Task HandleLootChestTakeItem(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory payload, CancellationToken ct) + { + var json = System.Text.Encoding.UTF8.GetString(payload.Span); + var request = System.Text.Json.JsonSerializer.Deserialize(json); + if (request == null) return; + + if (!session.CurrentDungeonId.HasValue || + !_dungeons.TryGetValue(session.CurrentDungeonId.Value, out var dungeon)) + return; + + if (!dungeon.Simulation.LootChests.TryGetValue(request.ChestId, out var chest)) + return; + + if (chest.OwnerCharacterId != session.CharacterId) + return; + + // Find the item in chest + var chestItem = chest.Items.FirstOrDefault(i => i.SlotIndex == request.SlotIndex); + if (chestItem == null) + { + await SendErrorAsync(connection, "Item not found in chest", ct); + return; + } + + using var scope = _scopeFactory.CreateScope(); + var db = scope.ServiceProvider.GetRequiredService(); + + // Get item definition + var itemDef = await db.Set() + .FirstOrDefaultAsync(d => d.Id == chestItem.ItemDefinitionId, ct); + if (itemDef == null) return; + + // Get player's current inventory + var existingItems = await db.Set() + .Where(i => i.CharacterId == session.CharacterId && !i.IsEquipped) + .ToListAsync(ct); + + // Find an available slot + var usedSlots = existingItems.Select(i => i.SlotIndex).ToHashSet(); + int targetSlot = request.TargetSlotIndex; + + if (targetSlot < 0 || targetSlot >= 30 || usedSlots.Contains(targetSlot)) + { + // Find first available slot + targetSlot = -1; + for (int i = 0; i < 30; i++) + { + if (!usedSlots.Contains(i)) + { + targetSlot = i; + break; + } + } + } + + if (targetSlot < 0) + { + await SendErrorAsync(connection, "Inventory full", ct); + return; + } + + // Add to player inventory + var newItem = new DungeonCharacterItem + { + CharacterId = session.CharacterId, + ItemDefinitionId = chestItem.ItemDefinitionId, + Quantity = chestItem.Quantity, + SlotIndex = targetSlot + }; + db.Set().Add(newItem); + + // Update database chest item as taken + var dbChestItem = await db.DeathChestItems + .FirstOrDefaultAsync(i => i.DeathChestId == chest.DatabaseId && + i.SlotIndex == request.SlotIndex && + !i.IsTaken, ct); + if (dbChestItem != null) + { + dbChestItem.IsTaken = true; + dbChestItem.TakenAt = DateTime.UtcNow; + } + + await db.SaveChangesAsync(ct); + + // Remove from runtime chest + chest.Items.Remove(chestItem); + + // Check if chest is now empty + await CheckAndRemoveEmptyChestAsync(db, dungeon, chest, session, ct); + + // Send updated states + await HandleInventoryRequest(connection, session, ct); + + // Only resend chest state if it still exists + if (!chest.IsEmpty) + { + await HandleLootChestOpen(connection, session, payload, ct); + } + } + + /// + /// Handle taking all items from loot chest + /// + private async Task HandleLootChestTakeAll(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory payload, CancellationToken ct) + { + var json = System.Text.Encoding.UTF8.GetString(payload.Span); + var request = System.Text.Json.JsonSerializer.Deserialize(json); + if (request == null) return; + + if (!session.CurrentDungeonId.HasValue || + !_dungeons.TryGetValue(session.CurrentDungeonId.Value, out var dungeon)) + return; + + if (!dungeon.Simulation.LootChests.TryGetValue(request.ChestId, out var chest)) + return; + + if (chest.OwnerCharacterId != session.CharacterId) + return; + + using var scope = _scopeFactory.CreateScope(); + var db = scope.ServiceProvider.GetRequiredService(); + + // Get player's current inventory + var existingItems = await db.Set() + .Where(i => i.CharacterId == session.CharacterId && !i.IsEquipped) + .ToListAsync(ct); + + var usedSlots = existingItems.Select(i => i.SlotIndex).ToHashSet(); + var itemsTaken = new List(); + var takenLoot = new List(); + + // Try to take each item + foreach (var chestItem in chest.Items.ToList()) + { + // Find available slot + int targetSlot = -1; + for (int i = 0; i < 30; i++) + { + if (!usedSlots.Contains(i)) + { + targetSlot = i; + usedSlots.Add(i); + break; + } + } + + if (targetSlot < 0) + break; // Inventory full + + // Get item definition for popup + var itemDef = await db.Set() + .FirstOrDefaultAsync(d => d.Id == chestItem.ItemDefinitionId, ct); + + // Add to player inventory + var newItem = new DungeonCharacterItem + { + CharacterId = session.CharacterId, + ItemDefinitionId = chestItem.ItemDefinitionId, + Quantity = chestItem.Quantity, + SlotIndex = targetSlot + }; + db.Set().Add(newItem); + + // Update database chest item as taken + var dbChestItem = await db.DeathChestItems + .FirstOrDefaultAsync(i => i.DeathChestId == chest.DatabaseId && + i.SlotIndex == chestItem.SlotIndex && + !i.IsTaken, ct); + if (dbChestItem != null) + { + dbChestItem.IsTaken = true; + dbChestItem.TakenAt = DateTime.UtcNow; + } + + itemsTaken.Add(chestItem); + + if (itemDef != null) + { + takenLoot.Add(new LootDrop + { + ItemDefinitionId = chestItem.ItemDefinitionId, + Item = itemDef, + Quantity = chestItem.Quantity + }); + } + } + + // Take gold + if (chest.Gold > 0) + { + var character = await db.DungeonCharacters.FindAsync(new object[] { session.CharacterId }, ct); + if (character != null) + { + character.Gold += chest.Gold; + + // Update database chest + var dbChest = await db.DeathChests.FindAsync(new object[] { chest.DatabaseId }, ct); + if (dbChest != null) + { + dbChest.GoldAmount = 0; + } + + chest.Gold = 0; + } + } + + await db.SaveChangesAsync(ct); + + // Remove taken items from runtime chest + foreach (var item in itemsTaken) + { + chest.Items.Remove(item); + } + + // Send loot popup + if (takenLoot.Count > 0) + { + await SendLootPopupAsync(session, takenLoot); + } + + // Check if chest is now empty + await CheckAndRemoveEmptyChestAsync(db, dungeon, chest, session, ct); + + // Send updated inventory + await HandleInventoryRequest(connection, session, ct); + + // If chest still has items, send updated state + if (!chest.IsEmpty) + { + var openPayload = System.Text.Json.JsonSerializer.SerializeToUtf8Bytes( + new LootChestOpenRequest { ChestId = request.ChestId }); + await HandleLootChestOpen(connection, session, openPayload, ct); + } + } + + /// + /// Handle closing a loot chest + /// + private async Task HandleLootChestClose(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory payload, CancellationToken ct) + { + var json = System.Text.Encoding.UTF8.GetString(payload.Span); + var request = System.Text.Json.JsonSerializer.Deserialize(json); + if (request == null) return; + + if (!session.CurrentDungeonId.HasValue || + !_dungeons.TryGetValue(session.CurrentDungeonId.Value, out var dungeon)) + return; + + if (dungeon.Simulation.LootChests.TryGetValue(request.ChestId, out var chest)) + { + if (chest.OwnerCharacterId == session.CharacterId) + { + chest.IsOpen = false; + } + } + } + + /// + /// Check if a chest is empty and remove it if so + /// + private async Task CheckAndRemoveEmptyChestAsync(GameDbContext db, DungeonInstance dungeon, LootChestInstance chest, DungeonPlayerSession owner, CancellationToken ct) + { + if (chest.IsEmpty) + { + // Update database + var dbChest = await db.DeathChests.FindAsync(new object[] { chest.DatabaseId }, ct); + if (dbChest != null) + { + dbChest.IsEmpty = true; + dbChest.EmptiedAt = DateTime.UtcNow; + await db.SaveChangesAsync(ct); + } + + // Notify owner that chest is removed + await SendAsync(owner.Connection, DungeonOpCodes.LOOT_CHEST_REMOVED, new + { + chestId = chest.Id + }, ct); + + // Remove from runtime + dungeon.Simulation.LootChests.TryRemove(chest.Id, out _); + + _log.LogInformation("Loot chest {ChestId} emptied and removed", chest.Id); + } + } + + #endregion +} diff --git a/Game/Dungeon/DungeonHandler.MobCache.cs b/Game/Dungeon/DungeonHandler.MobCache.cs new file mode 100644 index 0000000..898f485 --- /dev/null +++ b/Game/Dungeon/DungeonHandler.MobCache.cs @@ -0,0 +1,45 @@ +using System.Linq; +using System.Threading.Tasks; +using Microsoft.EntityFrameworkCore; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +using DataServer.Data; +using DataServer.Data.Entities; + +namespace GameServer.Dungeon; + +public sealed partial class DungeonHandler +{ + private async Task LoadMobDefinitionsAsync() + { + await RefreshMobCacheAsync(); + } + + /// + /// Refresh mob definitions cache. Call this after mobs are modified in admin. + /// + public async Task RefreshMobCacheAsync() + { + using var scope = _scopeFactory.CreateScope(); + var db = scope.ServiceProvider.GetRequiredService(); + + var mobs = await db.Set() + .Where(m => m.IsEnabled) + .ToListAsync(); + + if (mobs.Count == 0) + { + _log.LogCritical("Dungeon Mobs Table EMPTY"); + } + + _mobDefinitions = mobs.ToDictionary(m => m.Id); + + // Build sprite configs from animation assignments + var spriteConfigBuilder = new MobSpriteConfigBuilder(db); + _mobSpriteConfigs = await spriteConfigBuilder.BuildSpriteConfigsAsync(mobs.Select(m => m.Id)); + + // Count animation assignments for debugging + var assignmentCount = await db.Set().CountAsync(); + _log.LogInformation("Refreshed mob cache: {MobCount} mobs, {AssignmentCount} animation assignments", mobs.Count, assignmentCount); + } +} diff --git a/Game/Dungeon/DungeonHandler.MobLoot.cs b/Game/Dungeon/DungeonHandler.MobLoot.cs new file mode 100644 index 0000000..bdd706c --- /dev/null +++ b/Game/Dungeon/DungeonHandler.MobLoot.cs @@ -0,0 +1,184 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading; +using System.Threading.Tasks; +using Microsoft.Extensions.Logging; +using Server.Networking; +using GameServer.Networking.DTOs; +using Server.Networking.Messages; + +namespace GameServer.Dungeon; + +public sealed partial class DungeonHandler +{ + #region Mob Loot Handlers + + private async Task HandleMobLootRequest(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory payload, CancellationToken ct) + { + var json = System.Text.Encoding.UTF8.GetString(payload.Span); + var request = System.Text.Json.JsonSerializer.Deserialize(json); + if (request == null) return; + + if (!session.CurrentDungeonId.HasValue || + !_dungeons.TryGetValue(session.CurrentDungeonId.Value, out var dungeon)) + return; + + if (!dungeon.Simulation.Mobs.TryGetValue(request.MobId, out var mob)) + { + await SendErrorAsync(connection, "Mob not found", ct); + return; + } + + // Check if mob is dead + if (mob.IsAlive) + { + await SendErrorAsync(connection, "Mob is still alive", ct); + return; + } + + // Check distance + if (session.PlayerInstance != null) + { + float dist = MathF.Sqrt( + MathF.Pow(session.PlayerInstance.X - mob.X, 2) + + MathF.Pow(session.PlayerInstance.Y - mob.Y, 2)); + + if (dist > 96) // Interaction range + { + await SendErrorAsync(connection, "Too far from mob", ct); + return; + } + } + + // Send mob loot state + var lootItems = new List(); + + if (mob.DeathLoot != null) + { + foreach (var loot in mob.DeathLoot) + { + lootItems.Add(new + { + definitionId = loot.ItemDefinitionId, + name = loot.Item.Name, + description = loot.Item.Description, + type = loot.Item.Type.ToString(), + rarity = loot.Item.Rarity.ToString(), + quantity = loot.Quantity, + spritePath = loot.Item.SpritePath, + tintColor = loot.Item.TintColor + }); + } + } + + await SendAsync(connection, DungeonOpCodes.MOB_LOOT_STATE, new + { + mobId = mob.Id, + mobName = mob.Name, + gold = mob.DeathLootGold, + items = lootItems + }, ct); + } + + private async Task HandleMobLootTakeItem(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory payload, CancellationToken ct) + { + var json = System.Text.Encoding.UTF8.GetString(payload.Span); + var request = System.Text.Json.JsonSerializer.Deserialize(json); + if (request == null) return; + + if (!session.CurrentDungeonId.HasValue || + !_dungeons.TryGetValue(session.CurrentDungeonId.Value, out var dungeon)) + return; + + if (!dungeon.Simulation.Mobs.TryGetValue(request.MobId, out var mob)) + return; + + if (!mob.IsAlive && mob.DeathLoot != null && request.ItemIndex >= 0 && request.ItemIndex < mob.DeathLoot.Count) + { + var lootItem = mob.DeathLoot[request.ItemIndex]; + + // Try to add to inventory + var (addedItems, overflowItems, _) = await AddLootToInventoryWithOverflowAsync( + session, new List { lootItem }, 0); + + if (addedItems.Count > 0) + { + // Remove from mob loot + mob.DeathLoot.RemoveAt(request.ItemIndex); + + // Send updated inventory + await HandleInventoryRequest(connection, session, ct); + + // Send updated mob loot state so client knows what's left + await HandleMobLootRequest(connection, session, System.Text.Encoding.UTF8.GetBytes( + System.Text.Json.JsonSerializer.Serialize(new { mobId = request.MobId })), ct); + + _log.LogDebug("Player {Player} looted {Item} x{Qty} from mob {Mob}", + session.Character.Name, lootItem.Item.Name, lootItem.Quantity, mob.Name); + } + else if (overflowItems.Count > 0) + { + await SendErrorAsync(connection, "Inventory full", ct); + } + } + } + + private async Task HandleMobLootTakeAll(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory payload, CancellationToken ct) + { + var json = System.Text.Encoding.UTF8.GetString(payload.Span); + var request = System.Text.Json.JsonSerializer.Deserialize(json); + if (request == null) return; + + if (!session.CurrentDungeonId.HasValue || + !_dungeons.TryGetValue(session.CurrentDungeonId.Value, out var dungeon)) + return; + + if (!dungeon.Simulation.Mobs.TryGetValue(request.MobId, out var mob)) + return; + + if (!mob.IsAlive && mob.HasDeathLoot) + { + long goldToTake = mob.DeathLootGold; + var itemsToTake = mob.DeathLoot != null ? new List(mob.DeathLoot) : new List(); + + // Try to add all loot to inventory + var (addedItems, overflowItems, overflowGold) = await AddLootToInventoryWithOverflowAsync( + session, itemsToTake, goldToTake); + + // Remove successfully added items from mob loot + if (mob.DeathLoot != null) + { + foreach (var added in addedItems) + { + var toRemove = mob.DeathLoot.FirstOrDefault(l => + l.ItemDefinitionId == added.ItemDefinitionId && + l.Quantity == added.Quantity); + if (toRemove != null) + { + mob.DeathLoot.Remove(toRemove); + } + } + } + + // Remove taken gold + long goldTaken = goldToTake - overflowGold; + mob.DeathLootGold = overflowGold; + + // If there's overflow, spawn a loot chest + if (overflowItems.Count > 0 || overflowGold > 0) + { + await SpawnLootChestAsync(dungeon, session, overflowItems, overflowGold, + mob.X, mob.Y, null, mob.DefinitionId); + } + + // Send updated inventory + await HandleInventoryRequest(connection, session, ct); + + _log.LogDebug("Player {Player} looted all from mob {Mob}: {Items} items, {Gold} gold", + session.Character.Name, mob.Name, addedItems.Count, goldTaken); + } + } + + #endregion +} diff --git a/Game/Dungeon/DungeonHandler.Redis.cs b/Game/Dungeon/DungeonHandler.Redis.cs new file mode 100644 index 0000000..59645e8 --- /dev/null +++ b/Game/Dungeon/DungeonHandler.Redis.cs @@ -0,0 +1,103 @@ +using System; +using System.Text.Json; +using System.Threading; +using System.Threading.Tasks; +using Microsoft.Extensions.Logging; +using Server.Networking.Messages; + +namespace GameServer.Dungeon; + +public sealed partial class DungeonHandler +{ + private async Task SubscribeToBroadcastChannelAsync() + { + try + { + // Subscribe to server:broadcast channel + await _redis.Bus.SubscribeAsync("server:broadcast", (channel, message) => + { + try + { + if (message.IsNullOrEmpty) return; + + var payload = JsonSerializer.Deserialize(message.ToString()); + if (payload == null) return; + + _log.LogInformation("Received broadcast from Redis: [{Type}] {Message}", payload.Type, payload.Message); + + // Send to all local player sessions + foreach (var session in _playerSessions.Values) + { + _ = SendAsync(session.Connection, DungeonOpCodes.SERVER_BROADCAST, new + { + message = payload.Message, + type = payload.Type + }, CancellationToken.None); + } + } + catch (Exception ex) + { + _log.LogError(ex, "Error processing broadcast message"); + } + }); + + // Subscribe to server:command channel for asset refresh, force reconnect, etc. + await _redis.Bus.SubscribeAsync("server:command", (channel, message) => + { + try + { + if (message.IsNullOrEmpty) return; + + var payload = JsonSerializer.Deserialize(message.ToString()); + if (payload == null) return; + + _log.LogInformation("Received command from Redis: {Command}", payload.Command); + + switch (payload.Command) + { + case "refresh_assets": + // Queue asset refresh for all local players + _broadcastService.QueueAssetRefresh(); + break; + case "force_reconnect": + // Could implement force disconnect here + break; + } + } + catch (Exception ex) + { + _log.LogError(ex, "Error processing command message"); + } + }); + + _log.LogInformation("Subscribed to Redis broadcast channels"); + } + catch (Exception ex) + { + _log.LogError(ex, "Failed to subscribe to Redis broadcast channels"); + } + } + + // Payload classes for Redis pub/sub + private class BroadcastPayload + { + [System.Text.Json.Serialization.JsonPropertyName("type")] + public string Type { get; set; } = "system"; + + [System.Text.Json.Serialization.JsonPropertyName("message")] + public string Message { get; set; } = ""; + + [System.Text.Json.Serialization.JsonPropertyName("duration")] + public int Duration { get; set; } = 10; + + [System.Text.Json.Serialization.JsonPropertyName("timestamp")] + public long Timestamp { get; set; } + } + + private class CommandPayload + { + [System.Text.Json.Serialization.JsonPropertyName("command")] + public string Command { get; set; } = ""; + public long Timestamp { get; set; } + } +} diff --git a/Game/Dungeon/DungeonHandler.Stash.cs b/Game/Dungeon/DungeonHandler.Stash.cs new file mode 100644 index 0000000..73f4044 --- /dev/null +++ b/Game/Dungeon/DungeonHandler.Stash.cs @@ -0,0 +1,355 @@ +using System; +using System.Linq; +using System.Threading; +using System.Threading.Tasks; +using Microsoft.EntityFrameworkCore; +using Microsoft.Extensions.DependencyInjection; +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; + +#region Stash System (VIP Feature) + +public sealed partial class DungeonHandler +{ + private const int STASH_SLOTS = 50; // Number of stash slots for VIP + + /// + /// Handle request to view stash contents + /// + private async Task HandleStashRequest(IConnection connection, DungeonPlayerSession session, CancellationToken ct) + { + using var scope = _scopeFactory.CreateScope(); + var db = scope.ServiceProvider.GetRequiredService(); + + // Check VIP status + var account = await db.Accounts.FindAsync(new object[] { session.AccountId }, ct); + if (account == null || account.Role < AccountRole.Vip) + { + await SendAsync(connection, DungeonOpCodes.STASH_RESULT, new + { + success = false, + error = "vip_required", + message = "Stash is a VIP feature. Upgrade your account to access it!" + }, ct); + return; + } + + // Get stash items + var stashItems = await db.DungeonStashItems + .Where(s => s.CharacterId == session.CharacterId) + .Include(s => s.Definition) + .OrderBy(s => s.SlotIndex) + .ToListAsync(ct); + + await SendAsync(connection, DungeonOpCodes.STASH_STATE, new + { + slots = STASH_SLOTS, + items = stashItems.Select(s => new + { + id = s.Id, + slotIndex = s.SlotIndex, + itemDefinitionId = s.ItemDefinitionId, + quantity = s.Quantity, + storedAt = s.StoredAt, + definition = s.Definition == null ? null : new + { + id = s.Definition.Id, + name = s.Definition.Name, + description = s.Definition.Description, + type = s.Definition.Type.ToString(), + rarity = s.Definition.Rarity.ToString(), + spritePath = s.Definition.SpritePath, + stackable = s.Definition.Stackable, + maxStack = s.Definition.MaxStack + } + }) + }, ct); + } + + /// + /// Handle depositing an item from inventory to stash + /// + private async Task HandleStashDeposit(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory payload, CancellationToken ct) + { + using var scope = _scopeFactory.CreateScope(); + var db = scope.ServiceProvider.GetRequiredService(); + + // Check VIP status + var account = await db.Accounts.FindAsync(new object[] { session.AccountId }, ct); + if (account == null || account.Role < AccountRole.Vip) + { + await SendAsync(connection, DungeonOpCodes.STASH_RESULT, new + { + success = false, + error = "vip_required", + message = "Stash is a VIP feature." + }, ct); + return; + } + + // Must be in hub to use stash + if (session.State != PlayerState.InHub) + { + await SendAsync(connection, DungeonOpCodes.STASH_RESULT, new + { + success = false, + error = "not_in_hub", + message = "You must be in the hub to access your stash." + }, ct); + return; + } + + var request = _ser.Deserialize(payload); + var inventorySlot = request.InventorySlot; + var quantity = request.Quantity > 0 ? request.Quantity : 1; + var targetSlot = request.TargetSlot; + + // Find the inventory item + var invItem = await db.DungeonCharacterItems + .Include(i => i.ItemDefinition) + .FirstOrDefaultAsync(i => i.CharacterId == session.CharacterId && i.SlotIndex == inventorySlot && !i.IsEquipped, ct); + + if (invItem == null) + { + await SendAsync(connection, DungeonOpCodes.STASH_RESULT, new + { + success = false, + error = "item_not_found", + message = "Item not found in inventory." + }, ct); + return; + } + + // Find target slot + if (targetSlot < 0) + { + // Auto-find empty slot + var usedSlots = await db.DungeonStashItems + .Where(s => s.CharacterId == session.CharacterId) + .Select(s => s.SlotIndex) + .ToListAsync(ct); + + for (int i = 0; i < STASH_SLOTS; i++) + { + if (!usedSlots.Contains(i)) + { + targetSlot = i; + break; + } + } + + if (targetSlot < 0) + { + await SendAsync(connection, DungeonOpCodes.STASH_RESULT, new + { + success = false, + error = "stash_full", + message = "Your stash is full!" + }, ct); + return; + } + } + + // Validate quantity + quantity = Math.Min(quantity, invItem.Quantity); + + // Check if stacking with existing stash item + DungeonStashItem? existingStash = null; + if (invItem.ItemDefinition?.Stackable == true) + { + existingStash = await db.DungeonStashItems + .Include(s => s.Definition) + .FirstOrDefaultAsync(s => s.CharacterId == session.CharacterId && + s.ItemDefinitionId == invItem.ItemDefinitionId, ct); + } + + if (existingStash != null && invItem.ItemDefinition?.Stackable == true) + { + // Stack with existing + var maxAdd = (invItem.ItemDefinition?.MaxStack ?? 99) - existingStash.Quantity; + var toAdd = Math.Min(quantity, maxAdd); + + if (toAdd > 0) + { + existingStash.Quantity += toAdd; + invItem.Quantity -= toAdd; + + if (invItem.Quantity <= 0) + db.DungeonCharacterItems.Remove(invItem); + } + } + else + { + // Create new stash entry + var stashItem = new DungeonStashItem + { + CharacterId = session.CharacterId, + ItemDefinitionId = invItem.ItemDefinitionId, + Quantity = quantity, + SlotIndex = targetSlot, + StoredAt = DateTime.UtcNow + }; + db.DungeonStashItems.Add(stashItem); + + invItem.Quantity -= quantity; + if (invItem.Quantity <= 0) + db.DungeonCharacterItems.Remove(invItem); + } + + await db.SaveChangesAsync(ct); + + await SendAsync(connection, DungeonOpCodes.STASH_RESULT, new + { + success = true, + message = "Item deposited to stash." + }, ct); + + // Send updated inventory and stash + await HandleInventoryRequest(connection, session, ct); + await HandleStashRequest(connection, session, ct); + } + + /// + /// Handle withdrawing an item from stash to inventory + /// + private async Task HandleStashWithdraw(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory payload, CancellationToken ct) + { + using var scope = _scopeFactory.CreateScope(); + var db = scope.ServiceProvider.GetRequiredService(); + + // Check VIP status + var account = await db.Accounts.FindAsync(new object[] { session.AccountId }, ct); + if (account == null || account.Role < AccountRole.Vip) + { + await SendAsync(connection, DungeonOpCodes.STASH_RESULT, new + { + success = false, + error = "vip_required", + message = "Stash is a VIP feature." + }, ct); + return; + } + + // Must be in hub to use stash + if (session.State != PlayerState.InHub) + { + await SendAsync(connection, DungeonOpCodes.STASH_RESULT, new + { + success = false, + error = "not_in_hub", + message = "You must be in the hub to access your stash." + }, ct); + return; + } + + var request = _ser.Deserialize(payload); + var stashSlot = request.StashSlot; + var quantity = request.Quantity > 0 ? request.Quantity : 1; + + // Find the stash item + var stashItem = await db.DungeonStashItems + .Include(s => s.Definition) + .FirstOrDefaultAsync(s => s.CharacterId == session.CharacterId && s.SlotIndex == stashSlot, ct); + + if (stashItem == null) + { + await SendAsync(connection, DungeonOpCodes.STASH_RESULT, new + { + success = false, + error = "item_not_found", + message = "Item not found in stash." + }, ct); + return; + } + + // Validate quantity + quantity = Math.Min(quantity, stashItem.Quantity); + + // Find empty inventory slot or stackable slot + var invItems = await db.DungeonCharacterItems + .Where(i => i.CharacterId == session.CharacterId && !i.IsEquipped) + .Include(i => i.ItemDefinition) + .ToListAsync(ct); + + // Check for stackable existing + DungeonCharacterItem? targetItem = null; + if (stashItem.Definition?.Stackable == true) + { + targetItem = invItems.FirstOrDefault(i => + i.ItemDefinitionId == stashItem.ItemDefinitionId && + i.Quantity < (i.ItemDefinition?.MaxStack ?? 99)); + } + + if (targetItem != null) + { + // Stack with existing + var maxAdd = (stashItem.Definition?.MaxStack ?? 99) - targetItem.Quantity; + var toAdd = Math.Min(quantity, maxAdd); + + targetItem.Quantity += toAdd; + stashItem.Quantity -= toAdd; + + if (stashItem.Quantity <= 0) + db.DungeonStashItems.Remove(stashItem); + } + else + { + // Find empty slot (starting from slot 0 for inventory) + var usedSlots = invItems.Select(i => i.SlotIndex).ToHashSet(); + int emptySlot = -1; + for (int i = 0; i < 30; i++) + { + if (!usedSlots.Contains(i)) + { + emptySlot = i; + break; + } + } + + if (emptySlot < 0) + { + await SendAsync(connection, DungeonOpCodes.STASH_RESULT, new + { + success = false, + error = "inventory_full", + message = "Your inventory is full!" + }, ct); + return; + } + + // Create new inventory item + var newItem = new DungeonCharacterItem + { + CharacterId = session.CharacterId, + ItemDefinitionId = stashItem.ItemDefinitionId, + Quantity = quantity, + SlotIndex = emptySlot + }; + db.DungeonCharacterItems.Add(newItem); + + stashItem.Quantity -= quantity; + if (stashItem.Quantity <= 0) + db.DungeonStashItems.Remove(stashItem); + } + + await db.SaveChangesAsync(ct); + + await SendAsync(connection, DungeonOpCodes.STASH_RESULT, new + { + success = true, + message = "Item withdrawn from stash." + }, ct); + + // Send updated inventory and stash + await HandleInventoryRequest(connection, session, ct); + await HandleStashRequest(connection, session, ct); + } +} + +#endregion diff --git a/Game/Dungeon/DungeonHandler.cs b/Game/Dungeon/DungeonHandler.cs index f5b6c29..80b1182 100644 --- a/Game/Dungeon/DungeonHandler.cs +++ b/Game/Dungeon/DungeonHandler.cs @@ -146,131 +146,6 @@ public sealed partial class DungeonHandler : IClientMessageHandler _log.LogInformation("DungeonHandler initialized on pod {PodId} with {MobCount} mob definitions", _podId, _mobDefinitions.Count); } - private async Task SubscribeToBroadcastChannelAsync() - { - try - { - // Subscribe to server:broadcast channel - await _redis.Bus.SubscribeAsync("server:broadcast", (channel, message) => - { - try - { - if (message.IsNullOrEmpty) return; - - var payload = JsonSerializer.Deserialize(message.ToString()); - if (payload == null) return; - - _log.LogInformation("Received broadcast from Redis: [{Type}] {Message}", payload.Type, payload.Message); - - // Send to all local player sessions - foreach (var session in _playerSessions.Values) - { - _ = SendAsync(session.Connection, DungeonOpCodes.SERVER_BROADCAST, new - { - message = payload.Message, - type = payload.Type - }, CancellationToken.None); - } - } - catch (Exception ex) - { - _log.LogError(ex, "Error processing broadcast message"); - } - }); - - // Subscribe to server:command channel for asset refresh, force reconnect, etc. - await _redis.Bus.SubscribeAsync("server:command", (channel, message) => - { - try - { - if (message.IsNullOrEmpty) return; - - var payload = JsonSerializer.Deserialize(message.ToString()); - if (payload == null) return; - - _log.LogInformation("Received command from Redis: {Command}", payload.Command); - - switch (payload.Command) - { - case "refresh_assets": - // Queue asset refresh for all local players - _broadcastService.QueueAssetRefresh(); - break; - case "force_reconnect": - // Could implement force disconnect here - break; - } - } - catch (Exception ex) - { - _log.LogError(ex, "Error processing command message"); - } - }); - - _log.LogInformation("Subscribed to Redis broadcast channels"); - } - catch (Exception ex) - { - _log.LogError(ex, "Failed to subscribe to Redis broadcast channels"); - } - } - - // Payload classes for Redis pub/sub - private class BroadcastPayload - { - [System.Text.Json.Serialization.JsonPropertyName("type")] - public string Type { get; set; } = "system"; - - [System.Text.Json.Serialization.JsonPropertyName("message")] - public string Message { get; set; } = ""; - - [System.Text.Json.Serialization.JsonPropertyName("duration")] - public int Duration { get; set; } = 10; - - [System.Text.Json.Serialization.JsonPropertyName("timestamp")] - public long Timestamp { get; set; } - } - - private class CommandPayload - { - [System.Text.Json.Serialization.JsonPropertyName("command")] - public string Command { get; set; } = ""; - public long Timestamp { get; set; } - } - - private async Task LoadMobDefinitionsAsync() - { - await RefreshMobCacheAsync(); - } - - /// - /// Refresh mob definitions cache. Call this after mobs are modified in admin. - /// - public async Task RefreshMobCacheAsync() - { - using var scope = _scopeFactory.CreateScope(); - var db = scope.ServiceProvider.GetRequiredService(); - - var mobs = await db.Set() - .Where(m => m.IsEnabled) - .ToListAsync(); - - if (mobs.Count == 0) - { - _log.LogCritical("Dungeon Mobs Table EMPTY"); - } - - _mobDefinitions = mobs.ToDictionary(m => m.Id); - - // Build sprite configs from animation assignments - var spriteConfigBuilder = new MobSpriteConfigBuilder(db); - _mobSpriteConfigs = await spriteConfigBuilder.BuildSpriteConfigsAsync(mobs.Select(m => m.Id)); - - // Count animation assignments for debugging - var assignmentCount = await db.Set().CountAsync(); - _log.LogInformation("Refreshed mob cache: {MobCount} mobs, {AssignmentCount} animation assignments", mobs.Count, assignmentCount); - } - public async Task HandleAsync(int opCode, IConnection connection, ReadOnlyMemory payload, CancellationToken ct) { // Ensure initialized @@ -2163,380 +2038,7 @@ public sealed partial class DungeonHandler : IClientMessageHandler var (_, _, _) = await AddLootToInventoryWithOverflowAsync(session, loot, 0); } - #region Loot Chest Handlers - - /// - /// Handle opening a loot chest - /// - private async Task HandleLootChestOpen(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory payload, CancellationToken ct) - { - var json = System.Text.Encoding.UTF8.GetString(payload.Span); - var request = System.Text.Json.JsonSerializer.Deserialize(json); - if (request == null) return; - - if (!session.CurrentDungeonId.HasValue || - !_dungeons.TryGetValue(session.CurrentDungeonId.Value, out var dungeon)) - return; - - if (!dungeon.Simulation.LootChests.TryGetValue(request.ChestId, out var chest)) - { - await SendErrorAsync(connection, "Chest not found", ct); - return; - } - - // Check ownership - if (chest.OwnerCharacterId != session.CharacterId) - { - await SendErrorAsync(connection, "This chest doesn't belong to you", ct); - return; - } - - // Check distance - if (session.PlayerInstance != null) - { - float dist = MathF.Sqrt( - MathF.Pow(session.PlayerInstance.X - chest.X, 2) + - MathF.Pow(session.PlayerInstance.Y - chest.Y, 2)); - - if (dist > 96) // Interaction range - { - await SendErrorAsync(connection, "Too far from chest", ct); - return; - } - } - - chest.IsOpen = true; - - // Load item definitions for display - using var scope = _scopeFactory.CreateScope(); - var db = scope.ServiceProvider.GetRequiredService(); - - var itemDefIds = chest.Items.Select(i => i.ItemDefinitionId).Distinct().ToList(); - var itemDefs = await db.Set() - .Where(d => itemDefIds.Contains(d.Id)) - .ToDictionaryAsync(d => d.Id, ct); - - // Build chest state - var chestItems = new object?[100]; - foreach (var item in chest.Items) - { - if (itemDefs.TryGetValue(item.ItemDefinitionId, out var def)) - { - chestItems[item.SlotIndex] = new - { - slotIndex = item.SlotIndex, - definitionId = def.Id, - name = def.Name, - description = def.Description, - type = def.Type.ToString(), - rarity = def.Rarity.ToString(), - quantity = item.Quantity, - spritePath = def.SpritePath, - tintColor = def.TintColor - }; - } - } - - await SendAsync(connection, DungeonOpCodes.LOOT_CHEST_STATE, new - { - chestId = chest.Id, - gold = chest.Gold, - items = chestItems, - slots = 100 - }, ct); - } - - /// - /// Handle taking a single item from loot chest - /// - private async Task HandleLootChestTakeItem(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory payload, CancellationToken ct) - { - var json = System.Text.Encoding.UTF8.GetString(payload.Span); - var request = System.Text.Json.JsonSerializer.Deserialize(json); - if (request == null) return; - - if (!session.CurrentDungeonId.HasValue || - !_dungeons.TryGetValue(session.CurrentDungeonId.Value, out var dungeon)) - return; - - if (!dungeon.Simulation.LootChests.TryGetValue(request.ChestId, out var chest)) - return; - - if (chest.OwnerCharacterId != session.CharacterId) - return; - - // Find the item in chest - var chestItem = chest.Items.FirstOrDefault(i => i.SlotIndex == request.SlotIndex); - if (chestItem == null) - { - await SendErrorAsync(connection, "Item not found in chest", ct); - return; - } - - using var scope = _scopeFactory.CreateScope(); - var db = scope.ServiceProvider.GetRequiredService(); - - // Get item definition - var itemDef = await db.Set() - .FirstOrDefaultAsync(d => d.Id == chestItem.ItemDefinitionId, ct); - if (itemDef == null) return; - - // Get player's current inventory - var existingItems = await db.Set() - .Where(i => i.CharacterId == session.CharacterId && !i.IsEquipped) - .ToListAsync(ct); - - // Find an available slot - var usedSlots = existingItems.Select(i => i.SlotIndex).ToHashSet(); - int targetSlot = request.TargetSlotIndex; - - if (targetSlot < 0 || targetSlot >= 30 || usedSlots.Contains(targetSlot)) - { - // Find first available slot - targetSlot = -1; - for (int i = 0; i < 30; i++) - { - if (!usedSlots.Contains(i)) - { - targetSlot = i; - break; - } - } - } - - if (targetSlot < 0) - { - await SendErrorAsync(connection, "Inventory full", ct); - return; - } - - // Add to player inventory - var newItem = new DungeonCharacterItem - { - CharacterId = session.CharacterId, - ItemDefinitionId = chestItem.ItemDefinitionId, - Quantity = chestItem.Quantity, - SlotIndex = targetSlot - }; - db.Set().Add(newItem); - - // Update database chest item as taken - var dbChestItem = await db.DeathChestItems - .FirstOrDefaultAsync(i => i.DeathChestId == chest.DatabaseId && - i.SlotIndex == request.SlotIndex && - !i.IsTaken, ct); - if (dbChestItem != null) - { - dbChestItem.IsTaken = true; - dbChestItem.TakenAt = DateTime.UtcNow; - } - - await db.SaveChangesAsync(ct); - - // Remove from runtime chest - chest.Items.Remove(chestItem); - - // Check if chest is now empty - await CheckAndRemoveEmptyChestAsync(db, dungeon, chest, session, ct); - - // Send updated states - await HandleInventoryRequest(connection, session, ct); - - // Only resend chest state if it still exists - if (!chest.IsEmpty) - { - await HandleLootChestOpen(connection, session, payload, ct); - } - } - - /// - /// Handle taking all items from loot chest - /// - private async Task HandleLootChestTakeAll(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory payload, CancellationToken ct) - { - var json = System.Text.Encoding.UTF8.GetString(payload.Span); - var request = System.Text.Json.JsonSerializer.Deserialize(json); - if (request == null) return; - - if (!session.CurrentDungeonId.HasValue || - !_dungeons.TryGetValue(session.CurrentDungeonId.Value, out var dungeon)) - return; - - if (!dungeon.Simulation.LootChests.TryGetValue(request.ChestId, out var chest)) - return; - - if (chest.OwnerCharacterId != session.CharacterId) - return; - - using var scope = _scopeFactory.CreateScope(); - var db = scope.ServiceProvider.GetRequiredService(); - - // Get player's current inventory - var existingItems = await db.Set() - .Where(i => i.CharacterId == session.CharacterId && !i.IsEquipped) - .ToListAsync(ct); - - var usedSlots = existingItems.Select(i => i.SlotIndex).ToHashSet(); - var itemsTaken = new List(); - var takenLoot = new List(); - - // Try to take each item - foreach (var chestItem in chest.Items.ToList()) - { - // Find available slot - int targetSlot = -1; - for (int i = 0; i < 30; i++) - { - if (!usedSlots.Contains(i)) - { - targetSlot = i; - usedSlots.Add(i); - break; - } - } - - if (targetSlot < 0) - break; // Inventory full - - // Get item definition for popup - var itemDef = await db.Set() - .FirstOrDefaultAsync(d => d.Id == chestItem.ItemDefinitionId, ct); - - // Add to player inventory - var newItem = new DungeonCharacterItem - { - CharacterId = session.CharacterId, - ItemDefinitionId = chestItem.ItemDefinitionId, - Quantity = chestItem.Quantity, - SlotIndex = targetSlot - }; - db.Set().Add(newItem); - - // Update database chest item as taken - var dbChestItem = await db.DeathChestItems - .FirstOrDefaultAsync(i => i.DeathChestId == chest.DatabaseId && - i.SlotIndex == chestItem.SlotIndex && - !i.IsTaken, ct); - if (dbChestItem != null) - { - dbChestItem.IsTaken = true; - dbChestItem.TakenAt = DateTime.UtcNow; - } - - itemsTaken.Add(chestItem); - - if (itemDef != null) - { - takenLoot.Add(new LootDrop - { - ItemDefinitionId = chestItem.ItemDefinitionId, - Item = itemDef, - Quantity = chestItem.Quantity - }); - } - } - - // Take gold - if (chest.Gold > 0) - { - var character = await db.DungeonCharacters.FindAsync(new object[] { session.CharacterId }, ct); - if (character != null) - { - character.Gold += chest.Gold; - - // Update database chest - var dbChest = await db.DeathChests.FindAsync(new object[] { chest.DatabaseId }, ct); - if (dbChest != null) - { - dbChest.GoldAmount = 0; - } - - chest.Gold = 0; - } - } - - await db.SaveChangesAsync(ct); - - // Remove taken items from runtime chest - foreach (var item in itemsTaken) - { - chest.Items.Remove(item); - } - - // Send loot popup - if (takenLoot.Count > 0) - { - await SendLootPopupAsync(session, takenLoot); - } - - // Check if chest is now empty - await CheckAndRemoveEmptyChestAsync(db, dungeon, chest, session, ct); - - // Send updated inventory - await HandleInventoryRequest(connection, session, ct); - - // If chest still has items, send updated state - if (!chest.IsEmpty) - { - var openPayload = System.Text.Json.JsonSerializer.SerializeToUtf8Bytes( - new LootChestOpenRequest { ChestId = request.ChestId }); - await HandleLootChestOpen(connection, session, openPayload, ct); - } - } - - /// - /// Handle closing a loot chest - /// - private async Task HandleLootChestClose(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory payload, CancellationToken ct) - { - var json = System.Text.Encoding.UTF8.GetString(payload.Span); - var request = System.Text.Json.JsonSerializer.Deserialize(json); - if (request == null) return; - - if (!session.CurrentDungeonId.HasValue || - !_dungeons.TryGetValue(session.CurrentDungeonId.Value, out var dungeon)) - return; - - if (dungeon.Simulation.LootChests.TryGetValue(request.ChestId, out var chest)) - { - if (chest.OwnerCharacterId == session.CharacterId) - { - chest.IsOpen = false; - } - } - } - - /// - /// Check if a chest is empty and remove it if so - /// - private async Task CheckAndRemoveEmptyChestAsync(GameDbContext db, DungeonInstance dungeon, LootChestInstance chest, DungeonPlayerSession owner, CancellationToken ct) - { - if (chest.IsEmpty) - { - // Update database - var dbChest = await db.DeathChests.FindAsync(new object[] { chest.DatabaseId }, ct); - if (dbChest != null) - { - dbChest.IsEmpty = true; - dbChest.EmptiedAt = DateTime.UtcNow; - await db.SaveChangesAsync(ct); - } - - // Notify owner that chest is removed - await SendAsync(owner.Connection, DungeonOpCodes.LOOT_CHEST_REMOVED, new - { - chestId = chest.Id - }, ct); - - // Remove from runtime - dungeon.Simulation.LootChests.TryRemove(chest.Id, out _); - - _log.LogInformation("Loot chest {ChestId} emptied and removed", chest.Id); - } - } - - #endregion - + #if false // moved to DungeonHandler.Dungeons.cs #region Dungeon Browser Handlers /// @@ -3208,6 +2710,7 @@ public sealed partial class DungeonHandler : IClientMessageHandler } #endregion + #endif /// /// Sends loot popup to client showing what they received @@ -4321,6 +3824,7 @@ public sealed partial class DungeonHandler : IClientMessageHandler } } + #if false // moved to DungeonHandler.Crafting.cs #region Crafting private async Task HandleCraftingSkillsRequest(IConnection connection, DungeonPlayerSession session, CancellationToken ct) @@ -4497,11 +4001,13 @@ public sealed partial class DungeonHandler : IClientMessageHandler } #endregion + #endif } // Request/Input DTOs +#if false // moved to DungeonHandler.Stash.cs and DungeonHandler.MobLoot.cs #region Stash System (VIP Feature) public partial class DungeonHandler @@ -5013,3 +4519,4 @@ public partial class DungeonHandler #endregion +#endif