using System.Collections.Concurrent; using System.Text.Json; using Microsoft.EntityFrameworkCore; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Logging; using Server.Data; using Server.Data.Entities; using Server.Data.Enums; using Server.Networking; using Server.Networking.Handling; using Server.Networking.Messages; using Server.Services.Auth; namespace Server.Game.Dungeon; /// /// Handles dungeon crawler game messages via the server's message router /// Implements IClientMessageHandler for integration with existing infrastructure /// public sealed class DungeonHandler : IClientMessageHandler { private readonly ILogger _log; private readonly ISessionRegistry _sessions; private readonly IMessageSerializer _ser; private readonly IServiceScopeFactory _scopeFactory; // Player state tracking (keyed by connection ID) private readonly ConcurrentDictionary _playerSessions = new(); // Active dungeon instances private readonly ConcurrentDictionary _dungeons = new(); // Mob definitions cache private Dictionary _mobDefinitions = new(); private bool _initialized = false; // Tick management private Timer? _tickTimer; private long _currentTick = 0; //LootSystem private LootService _lootService = null!; public DungeonHandler( ILogger log, ISessionRegistry sessions, IMessageSerializer ser, IServiceScopeFactory scopeFactory, LootService lootService) { _log = log; _sessions = sessions; _ser = ser; _scopeFactory = scopeFactory; _lootService = lootService; } public IReadOnlyCollection SupportedOpCodes => new[] { DungeonOpCodes.HUB_STATE, DungeonOpCodes.STAT_ALLOCATE, DungeonOpCodes.DUNGEON_ENTER, DungeonOpCodes.DUNGEON_LEAVE, DungeonOpCodes.DUNGEON_INPUT_MOVE, DungeonOpCodes.DUNGEON_INPUT_ATTACK, DungeonOpCodes.DUNGEON_INPUT_PICKUP, DungeonOpCodes.DUNGEON_INPUT_CHEST, DungeonOpCodes.ESCAPE_START, DungeonOpCodes.ESCAPE_CANCEL, DungeonOpCodes.INVENTORY_REQUEST, DungeonOpCodes.EQUIP_ITEM, DungeonOpCodes.UNEQUIP_ITEM, DungeonOpCodes.USE_ITEM, DungeonOpCodes.DROP_ITEM, DungeonOpCodes.CHAT_SEND, DungeonOpCodes.HOTBAR_ASSIGN }; public async Task InitializeAsync() { if (_initialized) return; await LoadMobDefinitionsAsync(); await _lootService.InitializeAsync(); // Start tick loop (20 ticks per second) _tickTimer = new Timer(TickAll, null, 0, 50); _initialized = true; _log.LogInformation("DungeonHandler initialized with {MobCount} mob definitions", _mobDefinitions.Count); } private async Task LoadMobDefinitionsAsync() { using var scope = _scopeFactory.CreateScope(); var db = scope.ServiceProvider.GetRequiredService(); var mobs = await db.Set() .Where(m => m.IsEnabled) .ToListAsync(); if (mobs.Count == 0) { // Seed default mobs var defaults = DefaultDungeonMobs.GetDefaultMobs(); db.Set().AddRange(defaults); await db.SaveChangesAsync(); mobs = defaults; _log.LogInformation("Seeded {Count} default mob definitions", defaults.Count); } _mobDefinitions = mobs.ToDictionary(m => m.Id); } public async Task HandleAsync(int opCode, IConnection connection, ReadOnlyMemory payload, CancellationToken ct) { // Ensure initialized if (!_initialized) { await InitializeAsync(); } // All dungeon operations require authentication if (!_sessions.TryGet(connection.Id, out var accountId, out _)) { await SendErrorAsync(connection, "auth_required", ct); return; } // Get or create player session var session = await GetOrCreateSessionAsync(connection, accountId, ct); if (session == null) { await SendErrorAsync(connection, "no_character", ct); return; } try { switch (opCode) { case DungeonOpCodes.HUB_STATE: await HandleHubStateRequest(connection, session, ct); break; case DungeonOpCodes.STAT_ALLOCATE: await HandleStatAllocate(connection, session, payload, ct); break; case DungeonOpCodes.DUNGEON_ENTER: await HandleDungeonEnter(connection, session, payload, ct); break; case DungeonOpCodes.DUNGEON_LEAVE: await HandleDungeonLeave(connection, session, ct); break; case DungeonOpCodes.DUNGEON_INPUT_MOVE: HandleInputMove(session, payload); break; case DungeonOpCodes.DUNGEON_INPUT_ATTACK: HandleInputAttack(session, payload); break; case DungeonOpCodes.DUNGEON_INPUT_PICKUP: HandleInputPickup(session, payload); break; case DungeonOpCodes.DUNGEON_INPUT_CHEST: HandleInputChest(session, payload); break; case DungeonOpCodes.ESCAPE_START: HandleEscapeStart(session); break; case DungeonOpCodes.ESCAPE_CANCEL: HandleEscapeCancel(session); break; case DungeonOpCodes.INVENTORY_REQUEST: await HandleInventoryRequest(connection, session, ct); break; case DungeonOpCodes.EQUIP_ITEM: await HandleEquipItem(connection, session, payload, ct); break; case DungeonOpCodes.UNEQUIP_ITEM: await HandleUnequipItem(connection, session, payload, ct); break; case DungeonOpCodes.USE_ITEM: await HandleUseItem(connection, session, payload, ct); break; case DungeonOpCodes.CHAT_SEND: await HandleChatSend(connection, session, payload, ct); break; case DungeonOpCodes.HOTBAR_ASSIGN: await HandleHotbarAssign(connection, session, payload, ct); break; } } catch (Exception ex) { _log.LogError(ex, "Error handling dungeon opcode {OpCode} for account {AccountId}", opCode, accountId); await SendErrorAsync(connection, "internal_error", ct); } } private async Task GetOrCreateSessionAsync(IConnection connection, ulong accountId, CancellationToken ct) { if (_playerSessions.TryGetValue(connection.Id, out var existing)) { return existing; } // Load character from database using var scope = _scopeFactory.CreateScope(); var db = scope.ServiceProvider.GetRequiredService(); var character = await db.Set() .FirstOrDefaultAsync(c => c.AccountId == accountId && !c.IsDeleted, ct); if (character == null) { // Auto-create a character for this account character = new DungeonCharacter { AccountId = accountId, Name = $"Hero_{accountId}", Level = 1, UnspentStatPoints = 5, Strength = 1, Intelligence = 1, Wisdom = 1, Endurance = 1, Dexterity = 1 }; db.Set().Add(character); await db.SaveChangesAsync(ct); _log.LogInformation("Created new dungeon character for account {AccountId}", accountId); } var session = new DungeonPlayerSession { ConnectionId = connection.Id, Connection = connection, AccountId = accountId, CharacterId = character.Id, Character = character, State = PlayerState.InHub }; _playerSessions[connection.Id] = session; return session; } private async Task HandleHubStateRequest(IConnection connection, DungeonPlayerSession session, CancellationToken ct) { var hubState = GetHubState(session.Character); await SendAsync(connection, DungeonOpCodes.HUB_STATE, hubState, ct); } private async Task HandleStatAllocate(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory payload, CancellationToken ct) { var request = _ser.Deserialize(payload); if (string.IsNullOrEmpty(request.Stat)) return; var character = session.Character; if (character.UnspentStatPoints <= 0) return; switch (request.Stat.ToLower()) { case "strength": character.Strength++; break; case "str": character.Strength++; break; case "intelligence": character.Intelligence++; break; case "int": character.Intelligence++; break; case "wisdom": character.Wisdom++; break; case "wis": character.Wisdom++; break; case "endurance": character.Endurance++; break; case "end": character.Endurance++; break; case "dexterity": character.Dexterity++; break; case "dex": character.Dexterity++; break; default: return; } character.UnspentStatPoints--; // Save to database using var scope = _scopeFactory.CreateScope(); var db = scope.ServiceProvider.GetRequiredService(); db.Attach(character); db.Entry(character).Property(c => c.Strength).IsModified = true; db.Entry(character).Property(c => c.Intelligence).IsModified = true; db.Entry(character).Property(c => c.Wisdom).IsModified = true; db.Entry(character).Property(c => c.Endurance).IsModified = true; db.Entry(character).Property(c => c.Dexterity).IsModified = true; db.Entry(character).Property(c => c.UnspentStatPoints).IsModified = true; await db.SaveChangesAsync(ct); await SendAsync(connection, DungeonOpCodes.HUB_STATE, GetHubState(character), ct); } private async Task HandleDungeonEnter(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); const int maxPlayersPerDungeon = 20; // Try to find an existing dungeon of the same tier that isn't full DungeonInstance? instance = null; Guid dungeonId = Guid.Empty; foreach (var (id, dungeon) in _dungeons) { if (dungeon.Tier == tier && dungeon.Simulation.Phase == DungeonPhase.Active && dungeon.Simulation.Players.Count < maxPlayersPerDungeon && (DateTime.UtcNow - dungeon.CreatedAt).TotalSeconds < 300) // Only join dungeons < 60s old { instance = dungeon; dungeonId = id; _log.LogInformation("Player {Name} joining existing dungeon {Id} (tier {Tier}, {Players}/{Max} players)", session.Character.Name, id, tier, dungeon.Simulation.Players.Count, maxPlayersPerDungeon); break; } } // Create new dungeon if none found if (instance == null) { dungeonId = Guid.NewGuid(); int seed = Random.Shared.Next(); var layout = DungeonGenerator.Generate(seed, tier); var simulation = new DungeonSimulation(layout, tier, _mobDefinitions); instance = new DungeonInstance { Id = dungeonId, Tier = tier, Seed = seed, Simulation = simulation, CreatedAt = DateTime.UtcNow }; _dungeons[dungeonId] = instance; _log.LogInformation("Player {Name} created new dungeon {Id} (tier {Tier})", session.Character.Name, dungeonId, tier); } var layout2 = instance.Simulation.Layout; // Add player to dungeon var spawnPos = layout2.Rooms[0]; // Entrance room var player = new PlayerInstance { CharacterId = session.CharacterId, CharacterName = session.Character.Name, X = spawnPos.CenterX * 32 + Random.Shared.Next(-20, 20), // Slight offset to avoid stacking Y = spawnPos.CenterY * 32 + Random.Shared.Next(-20, 20), Health = session.Character.CurrentHealth, MaxHealth = DungeonCharacterStats.GetMaxHealth(session.Character), Mana = session.Character.CurrentMana, MaxMana = DungeonCharacterStats.GetMaxMana(session.Character), Stamina = DungeonCharacterStats.GetMaxStamina(session.Character), MaxStamina = DungeonCharacterStats.GetMaxStamina(session.Character), MoveSpeed = DungeonCharacterStats.GetMoveSpeed(session.Character), AttackSpeed = DungeonCharacterStats.GetAttackSpeed(session.Character), Strength = session.Character.Strength, Intelligence = session.Character.Intelligence }; instance.Simulation.Players[session.CharacterId] = player; // Update session state session.State = PlayerState.InDungeon; session.CurrentDungeonId = dungeonId; session.PlayerInstance = player; await SendAsync(connection, DungeonOpCodes.DUNGEON_ENTER_RESULT, new { ok = true, dungeonId = dungeonId.ToString(), tier = instance.Tier, seed = instance.Seed, width = layout2.Width, height = layout2.Height, tiles = layout2.SerializeTiles(), spawn = new { x = player.X, y = player.Y }, players = instance.Simulation.Players.Values.Select(p => new { id = p.CharacterId, name = p.CharacterName, x = p.X, y = p.Y }), mobs = instance.Simulation.Mobs.Values.Select(m => new { id = m.Id, name = m.Name, x = m.X, y = m.Y, health = m.Health, maxHealth = m.MaxHealth }), 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 }) }, ct); } private async Task HandleDungeonLeave(IConnection connection, DungeonPlayerSession session, CancellationToken ct) { if (session.State != PlayerState.InDungeon || !session.CurrentDungeonId.HasValue) { return; } await RemoveFromDungeonAsync(session, false, ct); await SendAsync(connection, DungeonOpCodes.HUB_STATE, GetHubState(session.Character), ct); } private void HandleInputMove(DungeonPlayerSession session, ReadOnlyMemory payload) { if (session.PlayerInstance == null) return; var input = _ser.Deserialize(payload); session.PlayerInstance.InputX = input.Dx; session.PlayerInstance.InputY = input.Dy; session.PlayerInstance.Rotation = input.AimAngle; } private void HandleInputAttack(DungeonPlayerSession session, ReadOnlyMemory payload) { if (session.PlayerInstance == null) return; if (session.State != PlayerState.InDungeon || !session.CurrentDungeonId.HasValue) return; if (!_dungeons.TryGetValue(session.CurrentDungeonId.Value, out var dungeon)) return; var input = _ser.Deserialize(payload); var player = session.PlayerInstance; // Find nearest mob in attack direction (within attack range and angle tolerance) const float attackRange = 60f; const float angleToleranceRad = 0.8f; // ~45 degrees MobInstance? bestTarget = null; float bestDist = float.MaxValue; foreach (var mob in dungeon.Simulation.Mobs.Values.Where(m => m.IsAlive)) { float dx = mob.X - player.X; float dy = mob.Y - player.Y; float dist = MathF.Sqrt(dx * dx + dy * dy); if (dist > attackRange) continue; float angleToMob = MathF.Atan2(dy, dx); float angleDiff = MathF.Abs(NormalizeAngle(angleToMob - input.AimAngle)); if (angleDiff <= angleToleranceRad && dist < bestDist) { bestDist = dist; bestTarget = mob; } } if (bestTarget != null) { player.AttackTargetId = (ulong)bestTarget.Id; player.WantsToAttack = true; } } private static float NormalizeAngle(float angle) { while (angle > MathF.PI) angle -= 2 * MathF.PI; while (angle < -MathF.PI) angle += 2 * MathF.PI; return angle; } private void HandleInputPickup(DungeonPlayerSession session, ReadOnlyMemory payload) { if (session.State != PlayerState.InDungeon || !session.CurrentDungeonId.HasValue) return; if (!_dungeons.TryGetValue(session.CurrentDungeonId.Value, out var dungeon)) return; var input = _ser.Deserialize(payload); if (dungeon.Simulation.DroppedItems.TryRemove((int)input.ItemId, out var item)) { // TODO: Add to player inventory _log.LogDebug("Player {Name} picked up item {ItemId}", session.Character.Name, item.ItemDefinitionId); } } private void HandleInputChest(DungeonPlayerSession session, ReadOnlyMemory payload) { if (session.State != PlayerState.InDungeon || !session.CurrentDungeonId.HasValue) return; if (!_dungeons.TryGetValue(session.CurrentDungeonId.Value, out var dungeon)) return; var input = _ser.Deserialize(payload); if (dungeon.Simulation.Chests.TryGetValue((int)input.ChestId, out var chest) && !chest.IsOpened) { chest.IsOpened = true; // TODO: Generate loot _log.LogDebug("Player {Name} opened chest {ChestId}", session.Character.Name, chest.Id); } } private void HandleEscapeStart(DungeonPlayerSession session) { if (session.State != PlayerState.InDungeon || !session.CurrentDungeonId.HasValue) return; if (!_dungeons.TryGetValue(session.CurrentDungeonId.Value, out var dungeon)) return; // Check if at exit var layout = dungeon.Simulation.Layout; if (layout.ExitPosition == null) return; var player = session.PlayerInstance; if (player == null) return; float exitX = layout.ExitPosition.Value.X * 32 + 16; float exitY = layout.ExitPosition.Value.Y * 32 + 16; float dist = MathF.Sqrt((player.X - exitX) * (player.X - exitX) + (player.Y - exitY) * (player.Y - exitY)); if (dist < 48) // Within range { session.IsEscaping = true; session.EscapeStartTick = _currentTick; } } private void HandleEscapeCancel(DungeonPlayerSession session) { session.IsEscaping = false; } /// /// Handle hotbar slot assignment - links a hotbar slot to an inventory slot /// private async Task HandleHotbarAssign(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; // Validate slots if (request.HotbarSlot < 0 || request.HotbarSlot >= 8) return; if (request.InventorySlot < 0 || request.InventorySlot >= 30) return; using var scope = _scopeFactory.CreateScope(); var db = scope.ServiceProvider.GetRequiredService(); // Check if the inventory slot has a consumable item var invItem = await db.Set() .FirstOrDefaultAsync(i => i.CharacterId == session.CharacterId && i.SlotIndex == request.InventorySlot && !i.IsEquipped, ct); if (invItem != null) { var itemDef = await db.Set() .FirstOrDefaultAsync(d => d.Id == invItem.ItemDefinitionId, ct); // Only allow consumables in hotbar if (itemDef == null || itemDef.Type != ItemType.Consumable) { _log.LogDebug("Cannot assign non-consumable item to hotbar"); return; } } // Find existing hotbar entry for this slot var existingEntry = await db.Set() .FirstOrDefaultAsync(b => b.CharacterId == session.CharacterId && b.SlotIndex == request.HotbarSlot, ct); if (existingEntry != null) { // Update existing existingEntry.InventorySlotIndex = request.InventorySlot; } else { // Create new var newEntry = new DungeonBeltItem { CharacterId = session.CharacterId, SlotIndex = request.HotbarSlot, InventorySlotIndex = request.InventorySlot }; db.Set().Add(newEntry); } await db.SaveChangesAsync(ct); // Send updated inventory state (includes hotbar) await HandleInventoryRequest(connection, session, ct); _log.LogDebug("Player {Name} assigned inventory slot {InvSlot} to hotbar slot {HotbarSlot}", session.Character.Name, request.InventorySlot, request.HotbarSlot); } private void TickAll(object? state) { _currentTick++; foreach (var (dungeonId, instance) in _dungeons) { try { var result = instance.Simulation.Tick(_currentTick); // Process mob death events for loot generation if (result.DeathEvents != null) { foreach (var death in result.DeathEvents) { if (death.EntityType == EntityType.Mob && death.KillerType == EntityType.Player) { // Fire and forget loot generation (async in sync context) _ = ProcessMobDeathLootAsync(instance, death); } } } // Send state to all players in this dungeon var playersInDungeon = _playerSessions.Values .Where(s => s.CurrentDungeonId == dungeonId && s.State == PlayerState.InDungeon) .ToList(); foreach (var session in playersInDungeon) { // Check escape completion (5 seconds = 100 ticks) if (session.IsEscaping && _currentTick - session.EscapeStartTick >= 100) { _ = CompleteEscapeAsync(session); continue; } // Check if player died if (session.PlayerInstance != null && !session.PlayerInstance.IsAlive) { _ = HandlePlayerDeathAsync(session); continue; } _ = SendDungeonStateAsync(session, result); } // Cleanup empty dungeons if (playersInDungeon.Count == 0 && (DateTime.UtcNow - instance.CreatedAt).TotalMinutes > 5) { _dungeons.TryRemove(dungeonId, out _); } } catch (Exception ex) { _log.LogError(ex, "Error ticking dungeon {DungeonId}", dungeonId); } } } /// /// Process loot when a mob dies /// private async Task ProcessMobDeathLootAsync(DungeonInstance dungeon, DeathEvent death) { try { // Find the mob that died (it's still in the dictionary but marked dead) if (!dungeon.Simulation.Mobs.TryGetValue(death.EntityId, out var mob)) return; // Find the player who killed it var killerSession = _playerSessions.Values .FirstOrDefault(s => s.CharacterId == (ulong)death.KillerId); if (killerSession == null) return; // Generate loot from the mob's loot tables var loot = _lootService.GenerateMobLoot( mob.DefinitionId, dungeon.Tier, 1.0f // Can multiply by mob's DropChanceMultiplier if stored ); if (loot.Count == 0) return; // Add loot to player's inventory await AddLootToInventoryAsync(killerSession, loot); // Send loot popup to the player await SendLootPopupAsync(killerSession, loot); _log.LogDebug("Player {Player} received {Count} items from {Mob}", killerSession.Character.Name, loot.Count, mob.Name); } catch (Exception ex) { _log.LogError(ex, "Error processing loot for mob death"); } } /// /// Adds loot directly to player's inventory in the database /// private async Task AddLootToInventoryAsync(DungeonPlayerSession session, List loot) { using var scope = _scopeFactory.CreateScope(); var db = scope.ServiceProvider.GetRequiredService(); // Get existing inventory items var existingItems = await db.Set() .Where(i => i.CharacterId == session.CharacterId) .ToListAsync(); int nextSlot = existingItems.Count > 0 ? existingItems.Max(i => i.SlotIndex) + 1 : 0; foreach (var drop in loot) { // Check if item is stackable and already exists in inventory var existingStack = existingItems.FirstOrDefault(i => i.ItemDefinitionId == drop.ItemDefinitionId && drop.Item.Stackable); if (existingStack != null && drop.Item.Stackable) { // Add to existing stack existingStack.Quantity = Math.Min( existingStack.Quantity + drop.Quantity, drop.Item.MaxStack ); } else { // Check if inventory is full (30 slots) if (nextSlot >= 30) { // TODO: Drop item on ground instead _log.LogWarning("Player {Name} inventory full, item {Item} not added", session.Character.Name, drop.Item.Name); continue; } // Create new inventory entry var newItem = new DungeonCharacterItem { CharacterId = session.CharacterId, ItemDefinitionId = drop.ItemDefinitionId, Quantity = drop.Quantity, SlotIndex = nextSlot++ }; db.Set().Add(newItem); existingItems.Add(newItem); } } await db.SaveChangesAsync(); } /// /// Sends loot popup to client showing what they received /// private async Task SendLootPopupAsync(DungeonPlayerSession session, List loot) { var lootData = loot.Select(l => new { id = l.ItemDefinitionId, name = l.Item.Name, description = l.Item.Description, type = l.Item.Type.ToString(), rarity = l.Item.Rarity.ToString(), quantity = l.Quantity, spriteId = l.Item.SpriteId, // Include stats for display armor = l.Item.Armor, minDamage = l.Item.MinDamage, maxDamage = l.Item.MaxDamage, bonusHealth = l.Item.BonusHealth, bonusMana = l.Item.BonusMana, healAmount = l.Item.HealAmount, manaRestore = l.Item.ManaRestore }); await SendAsync(session.Connection, DungeonOpCodes.LOOT_RECEIVED, new { items = lootData }, CancellationToken.None); } /// /// Handle inventory request - sends current inventory and equipment /// private async Task HandleInventoryRequest(IConnection connection, DungeonPlayerSession session, CancellationToken ct) { using var scope = _scopeFactory.CreateScope(); var db = scope.ServiceProvider.GetRequiredService(); // Get all inventory items var inventoryItems = await db.Set() .Where(i => i.CharacterId == session.CharacterId) .ToListAsync(ct); // Get item definitions for all items var itemDefIds = inventoryItems.Select(i => i.ItemDefinitionId).Distinct().ToList(); var itemDefs = await db.Set() .Where(d => itemDefIds.Contains(d.Id)) .ToDictionaryAsync(d => d.Id, ct); // Build inventory array (30 slots, null for empty) var items = new object?[30]; foreach (var invItem in inventoryItems.Where(i => !i.IsEquipped)) { if (invItem.SlotIndex >= 0 && invItem.SlotIndex < 30 && itemDefs.TryGetValue(invItem.ItemDefinitionId, out var def)) { items[invItem.SlotIndex] = new { id = invItem.Id, definitionId = def.Id, name = def.Name, description = def.Description, type = def.Type.ToString(), rarity = def.Rarity.ToString(), quantity = invItem.Quantity, minDamage = def.MinDamage, maxDamage = def.MaxDamage, armor = def.Armor, bonusHealth = def.BonusHealth, bonusMana = def.BonusMana, healAmount = def.HealAmount, manaRestore = def.ManaRestore, spriteId = def.SpriteId }; } } // Load hotbar assignments var hotbarItems = await db.Set() .Where(b => b.CharacterId == session.CharacterId) .OrderBy(b => b.SlotIndex) .ToListAsync(ct); var hotbar = new object?[8]; foreach (var belt in hotbarItems) { if (belt.SlotIndex >= 0 && belt.SlotIndex < 8) { hotbar[belt.SlotIndex] = new { inventory_slot = belt.InventorySlotIndex }; } } // Build equipment map - using your actual enum names var equipment = new Dictionary(); foreach (var equippedItem in inventoryItems.Where(i => i.IsEquipped)) { if (itemDefs.TryGetValue(equippedItem.ItemDefinitionId, out var def)) { // Map enum to client slot names var slotName = equippedItem.EquipSlot switch { DungeonEquipmentSlot.MainHand => "weapon", DungeonEquipmentSlot.OffHand => "offhand", DungeonEquipmentSlot.Head => "helm", DungeonEquipmentSlot.Chest => "chest", DungeonEquipmentSlot.Legs => "legs", DungeonEquipmentSlot.Boots => "boots", DungeonEquipmentSlot.Gloves => "gloves", DungeonEquipmentSlot.Accessory1 => "ring1", DungeonEquipmentSlot.Accessory2 => "ring2", _ => "unknown" }; equipment[slotName] = new { id = equippedItem.Id, definitionId = def.Id, name = def.Name, description = def.Description, type = def.Type.ToString(), rarity = def.Rarity.ToString(), minDamage = def.MinDamage, maxDamage = def.MaxDamage, armor = def.Armor, bonusHealth = def.BonusHealth, bonusMana = def.BonusMana }; } } await SendAsync(connection, DungeonOpCodes.INVENTORY_STATE, new { items, equipment, hotbar, }, ct); } /// /// Handle equip item request /// private async Task HandleEquipItem(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; using var scope = _scopeFactory.CreateScope(); var db = scope.ServiceProvider.GetRequiredService(); // Get the item to equip var item = await db.Set() .Include(i => i.ItemDefinition) .FirstOrDefaultAsync(i => i.CharacterId == session.CharacterId && i.SlotIndex == request.SlotIndex && !i.IsEquipped, ct); if (item?.ItemDefinition == null) return; // Determine equipment slot based on item type var equipSlot = GetEquipSlotForItem(item.ItemDefinition); if (equipSlot == null) { _log.LogWarning("Cannot equip item {ItemName} - no valid equip slot", item.ItemDefinition.Name); return; } // Unequip any existing item in that slot var existingEquipped = await db.Set() .FirstOrDefaultAsync(i => i.CharacterId == session.CharacterId && i.IsEquipped && i.EquipSlot == equipSlot, ct); if (existingEquipped != null) { existingEquipped.IsEquipped = false; existingEquipped.EquipSlot = null; // Find first empty inventory slot var usedSlots = await db.Set() .Where(i => i.CharacterId == session.CharacterId && !i.IsEquipped) .Select(i => i.SlotIndex) .ToListAsync(ct); existingEquipped.SlotIndex = Enumerable.Range(0, 30).FirstOrDefault(s => !usedSlots.Contains(s)); } // Equip the new item item.IsEquipped = true; item.EquipSlot = equipSlot; item.SlotIndex = -1; // Not in regular inventory await db.SaveChangesAsync(ct); // Send updated inventory await HandleInventoryRequest(connection, session, ct); } /// /// Handle unequip item request /// private async Task HandleUnequipItem(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; using var scope = _scopeFactory.CreateScope(); var db = scope.ServiceProvider.GetRequiredService(); // Map client slot name to enum var equipSlot = request.Slot?.ToLower() switch { "weapon" => DungeonEquipmentSlot.MainHand, "offhand" => DungeonEquipmentSlot.OffHand, "helm" => DungeonEquipmentSlot.Head, "chest" => DungeonEquipmentSlot.Chest, "legs" => DungeonEquipmentSlot.Legs, "boots" => DungeonEquipmentSlot.Boots, "gloves" => DungeonEquipmentSlot.Gloves, "ring1" => DungeonEquipmentSlot.Accessory1, "ring2" => DungeonEquipmentSlot.Accessory2, _ => (DungeonEquipmentSlot?)null }; if (equipSlot == null) return; var equippedItem = await db.Set() .FirstOrDefaultAsync(i => i.CharacterId == session.CharacterId && i.IsEquipped && i.EquipSlot == equipSlot, ct); if (equippedItem == null) return; // Find first empty inventory slot var usedSlots = await db.Set() .Where(i => i.CharacterId == session.CharacterId && !i.IsEquipped) .Select(i => i.SlotIndex) .ToListAsync(ct); if (usedSlots.Count >= 30) { _log.LogWarning("Cannot unequip - inventory full"); return; } var emptySlot = Enumerable.Range(0, 30).FirstOrDefault(s => !usedSlots.Contains(s)); equippedItem.IsEquipped = false; equippedItem.EquipSlot = null; equippedItem.SlotIndex = emptySlot; await db.SaveChangesAsync(ct); // Send updated inventory await HandleInventoryRequest(connection, session, ct); } /// /// Handle use item request (consumables) /// private async Task HandleUseItem(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; using var scope = _scopeFactory.CreateScope(); var db = scope.ServiceProvider.GetRequiredService(); var item = await db.Set() .Include(i => i.ItemDefinition) .FirstOrDefaultAsync(i => i.CharacterId == session.CharacterId && i.SlotIndex == request.SlotIndex && !i.IsEquipped, ct); if (item?.ItemDefinition == null) return; // Only consumables can be used if (item.ItemDefinition.Type != ItemType.Consumable) return; // Apply effects if (session.PlayerInstance != null) { if (item.ItemDefinition.HealAmount > 0) { session.PlayerInstance.Health = Math.Min( session.PlayerInstance.Health + item.ItemDefinition.HealAmount, session.PlayerInstance.MaxHealth ); } if (item.ItemDefinition.ManaRestore > 0) { session.PlayerInstance.Mana = Math.Min( session.PlayerInstance.Mana + item.ItemDefinition.ManaRestore, session.PlayerInstance.MaxMana ); } } // Decrease quantity or remove item.Quantity--; if (item.Quantity <= 0) { db.Set().Remove(item); } await db.SaveChangesAsync(ct); // Send updated inventory await HandleInventoryRequest(connection, session, ct); } private DungeonEquipmentSlot? GetEquipSlotForItem(DungeonItemDefinition item) { return item.Type switch { ItemType.Weapon => item.EquipSlot ?? DungeonEquipmentSlot.MainHand, ItemType.Armor => item.EquipSlot ?? DungeonEquipmentSlot.Chest, ItemType.Accessory => DungeonEquipmentSlot.Accessory1, _ => null }; } // Request DTOs private class EquipItemRequest { public int SlotIndex { get; set; } } private class UnequipItemRequest { public string Slot { get; set; } = ""; } private class UseItemRequest { public int SlotIndex { get; set; } } private async Task SendDungeonStateAsync(DungeonPlayerSession session, TickResult? tickResult) { var dungeon = _dungeons.GetValueOrDefault(session.CurrentDungeonId!.Value); if (dungeon == null) return; var sim = dungeon.Simulation; var state = new { tick = _currentTick, phase = sim.Phase.ToString().ToLower(), // NOTE: tiles are NOT sent every tick - they're static and sent once on DUNGEON_ENTER_RESULT players = sim.Players.Values.Select(p => new { id = p.CharacterId, name = p.CharacterName, x = p.X, y = p.Y, rotation = p.Rotation, health = (int)p.Health, maxHealth = (int)p.MaxHealth, mana = (int)p.Mana, maxMana = (int)p.MaxMana, stamina = (int)p.Stamina, maxStamina = (int)p.MaxStamina, isAlive = p.IsAlive, isInCombat = p.IsInCombat }), mobs = sim.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(), spriteSheet = m.SpriteSheet, spriteWidth = m.SpriteWidth, spriteHeight = m.SpriteHeight, tintColor = m.TintColor }), chests = sim.Chests.Values.Select(c => new { id = c.Id, x = c.X, y = c.Y, opened = c.IsOpened }), droppedItems = sim.DroppedItems.Values.Select(i => new { id = i.Id, itemId = i.ItemDefinitionId, quantity = i.Quantity, x = i.X, y = i.Y }), events = tickResult == null ? null : new { damage = tickResult.DamageEvents.Select(e => new { sourceType = e.SourceType.ToString().ToLower(), sourceId = e.SourceId, targetType = e.TargetType.ToString().ToLower(), targetId = e.TargetId, damage = e.Damage }), deaths = tickResult.DeathEvents.Select(e => new { entityType = e.EntityType.ToString().ToLower(), entityId = e.EntityId, entityName = e.EntityName, killerType = e.KillerType.ToString().ToLower(), killerId = e.KillerId, killerName = e.KillerName, xp = e.XpReward }) }, exitPosition = sim.Layout.ExitPosition != null ? new { x = sim.Layout.ExitPosition.Value.X * 32 + 16, y = sim.Layout.ExitPosition.Value.Y * 32 + 16 } : null }; await SendAsync(session.Connection, DungeonOpCodes.DUNGEON_STATE, state, CancellationToken.None); } private async Task CompleteEscapeAsync(DungeonPlayerSession session) { session.IsEscaping = false; await SendAsync(session.Connection, DungeonOpCodes.ESCAPE_SUCCESS, new { }, CancellationToken.None); await RemoveFromDungeonAsync(session, true, CancellationToken.None); await SendAsync(session.Connection, DungeonOpCodes.HUB_STATE, GetHubState(session.Character), CancellationToken.None); } private async Task HandlePlayerDeathAsync(DungeonPlayerSession session) { await RemoveFromDungeonAsync(session, false, CancellationToken.None); // Reset health on death session.Character.CurrentHealth = DungeonCharacterStats.GetMaxHealth(session.Character); session.Character.CurrentMana = DungeonCharacterStats.GetMaxMana(session.Character); session.Character.TotalDeaths++; using var scope = _scopeFactory.CreateScope(); var db = scope.ServiceProvider.GetRequiredService(); db.Attach(session.Character); db.Entry(session.Character).State = EntityState.Modified; await db.SaveChangesAsync(); await SendAsync(session.Connection, DungeonOpCodes.HUB_STATE, GetHubState(session.Character), CancellationToken.None); } private async Task RemoveFromDungeonAsync(DungeonPlayerSession session, bool extracted, CancellationToken ct) { if (!session.CurrentDungeonId.HasValue) return; if (_dungeons.TryGetValue(session.CurrentDungeonId.Value, out var dungeon)) { dungeon.Simulation.Players.TryRemove(session.CharacterId, out var player); if (player != null) { await SaveCharacterStateAsync(session.Character, player, extracted, ct); } } session.State = PlayerState.InHub; session.CurrentDungeonId = null; session.PlayerInstance = null; session.IsEscaping = false; } private async Task SaveCharacterStateAsync(DungeonCharacter character, PlayerInstance player, bool extracted, CancellationToken ct) { using var scope = _scopeFactory.CreateScope(); var db = scope.ServiceProvider.GetRequiredService(); // Add XP earned character.Experience += player.XpGained; character.TotalKills += player.MobsKilled; character.PlayersKilled += player.PlayersKilled; if (extracted) { character.DungeonsCompleted++; character.CurrentHealth = (int)player.Health; character.CurrentMana = (int)player.Mana; } else { character.TotalDeaths++; character.CurrentHealth = DungeonCharacterStats.GetMaxHealth(character); character.CurrentMana = DungeonCharacterStats.GetMaxMana(character); } // Check for level up while (character.Experience >= LevelSystem.GetTotalXpForLevel(character.Level + 1)) { character.Level++; character.UnspentStatPoints += 5; } character.LastPlayedAt = DateTime.UtcNow; db.Attach(character); db.Entry(character).State = EntityState.Modified; await db.SaveChangesAsync(ct); _log.LogInformation("Saved character {Name}: Level {Level}, XP {Xp}, Extracted={Extracted}", character.Name, character.Level, character.Experience, extracted); } private object GetHubState(DungeonCharacter character) { return new { character = new { id = character.Id, name = character.Name, level = character.Level, xp = character.Experience, xpNext = LevelSystem.GetXpForLevel(character.Level + 1), unspentPoints = character.UnspentStatPoints, strength = character.Strength, intelligence = character.Intelligence, wisdom = character.Wisdom, endurance = character.Endurance, dexterity = character.Dexterity, maxHealth = DungeonCharacterStats.GetMaxHealth(character), maxMana = DungeonCharacterStats.GetMaxMana(character), maxStamina = DungeonCharacterStats.GetMaxStamina(character) } }; } private async Task SendAsync(IConnection connection, int opCode, object payload, CancellationToken ct) { try { var payloadBytes = _ser.Serialize(payload); var msg = new ServerMessage(opCode, payloadBytes); var wire = _ser.Serialize(msg); await connection.SendAsync(wire, ct); } catch (Exception ex) { _log.LogWarning(ex, "Failed to send message to connection {Id}", connection.Id); } } private async Task SendErrorAsync(IConnection connection, string error, CancellationToken ct) { await SendAsync(connection, OpCodes.ERROR, new { error }, ct); } /// /// Called when a connection is closed - cleanup session /// public void OnDisconnect(Guid connectionId) { if (_playerSessions.TryRemove(connectionId, out var session)) { if (session.CurrentDungeonId.HasValue) { _ = RemoveFromDungeonAsync(session, false, CancellationToken.None); } _log.LogInformation("Dungeon session cleaned up for connection {Id}", connectionId); } } /// /// Handle chat message from player /// private async Task HandleChatSend(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 || string.IsNullOrWhiteSpace(request.Message)) return; // Sanitize message (basic - remove excessive whitespace, limit length) var message = request.Message.Trim(); if (message.Length > 200) message = message.Substring(0, 200); var senderName = session.Character?.Name ?? "Unknown"; // Determine chat scope based on player state if (session.CurrentDungeonId.HasValue && _dungeons.TryGetValue(session.CurrentDungeonId.Value, out var dungeon)) { // In dungeon - broadcast to all players in same dungeon foreach (var player in dungeon.Simulation.Players.Values) { await SendAsync(_playerSessions.Values.Where(p => p.CharacterId == player.CharacterId).FirstOrDefault().Connection, DungeonOpCodes.CHAT_MESSAGE, new { sender = senderName, message = message, type = "normal" }, ct); } } else { // In hub - broadcast to all connected players in hub foreach (var playerSession in _playerSessions.Values.Where(p => !p.CurrentDungeonId.HasValue)) { await SendAsync(playerSession.Connection, DungeonOpCodes.CHAT_MESSAGE, new { sender = senderName, message = message, type = "normal" }, ct); } } _log.LogDebug("Chat from {Player}: {Message}", senderName, message); } /// /// Broadcast a system message to all players in a dungeon /// private async Task BroadcastSystemMessage(DungeonInstance dungeon, string message, CancellationToken ct) { foreach (var player in dungeon.Simulation.Players.Values) { await SendAsync(_playerSessions.Values.Where(p => p.CharacterId == player.CharacterId).FirstOrDefault().Connection, DungeonOpCodes.CHAT_MESSAGE, new { sender = "System", message = message, type = "system" }, ct); } } /// /// Broadcast a system message to all connected players /// private async Task BroadcastGlobalSystemMessage(string message, CancellationToken ct) { foreach (var session in _playerSessions.Values) { await SendAsync(session.Connection, DungeonOpCodes.CHAT_MESSAGE, new { sender = "System", message = message, type = "system" }, ct); } } } // Request/Input DTOs public class StatAllocateRequest { public string Stat { get; set; } = ""; } public class DungeonEnterRequest { public int Tier { get; set; } = 1; } public class MoveInput { public float Dx { get; set; } public float Dy { get; set; } public float AimAngle { get; set; } } public class AttackInput { public float AimAngle { get; set; } } public class PickupInput { public ulong ItemId { get; set; } } public class ChestInput { public ulong ChestId { get; set; } } public class EquipItemRequest { public int SlotIndex { get; set; } } public class UnequipItemRequest { public string Slot { get; set; } = ""; } public class UseItemRequest { public int SlotIndex { get; set; } } public class ChatSendRequest { public string Message { get; set; } = ""; }