From 08f46ddaf77a8800924dc31b3cd9fc5a56fc3072 Mon Sep 17 00:00:00 2001 From: dingo Date: Sun, 7 Dec 2025 08:58:29 -0500 Subject: [PATCH] Handler --- Game/Dungeon/DungeonHandler.cs | 361 ++++++++++++++++++++------------- 1 file changed, 217 insertions(+), 144 deletions(-) diff --git a/Game/Dungeon/DungeonHandler.cs b/Game/Dungeon/DungeonHandler.cs index 206e087..43a9be7 100644 --- a/Game/Dungeon/DungeonHandler.cs +++ b/Game/Dungeon/DungeonHandler.cs @@ -23,21 +23,21 @@ public sealed class DungeonHandler : IClientMessageHandler 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; - + public DungeonHandler( ILogger log, ISessionRegistry sessions, @@ -49,7 +49,7 @@ public sealed class DungeonHandler : IClientMessageHandler _ser = ser; _scopeFactory = scopeFactory; } - + public IReadOnlyCollection SupportedOpCodes => new[] { DungeonOpCodes.HUB_STATE, @@ -63,29 +63,29 @@ public sealed class DungeonHandler : IClientMessageHandler DungeonOpCodes.ESCAPE_START, DungeonOpCodes.ESCAPE_CANCEL }; - + public async Task InitializeAsync() { if (_initialized) return; - + await LoadMobDefinitionsAsync(); - + // 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 @@ -95,10 +95,10 @@ public sealed class DungeonHandler : IClientMessageHandler 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 @@ -106,14 +106,14 @@ public sealed class DungeonHandler : IClientMessageHandler { 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) @@ -121,7 +121,7 @@ public sealed class DungeonHandler : IClientMessageHandler await SendErrorAsync(connection, "no_character", ct); return; } - + try { switch (opCode) @@ -129,39 +129,39 @@ public sealed class DungeonHandler : IClientMessageHandler 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; @@ -173,21 +173,21 @@ public sealed class DungeonHandler : IClientMessageHandler 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 @@ -203,12 +203,12 @@ public sealed class DungeonHandler : IClientMessageHandler 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, @@ -218,25 +218,25 @@ public sealed class DungeonHandler : IClientMessageHandler 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; @@ -246,9 +246,9 @@ public sealed class DungeonHandler : IClientMessageHandler case "dexterity": character.Dexterity++; break; default: return; } - + character.UnspentStatPoints--; - + // Save to database using var scope = _scopeFactory.CreateScope(); var db = scope.ServiceProvider.GetRequiredService(); @@ -260,10 +260,10 @@ public sealed class DungeonHandler : IClientMessageHandler 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) @@ -271,36 +271,63 @@ public sealed class DungeonHandler : IClientMessageHandler 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); - - // Create new dungeon instance - var dungeonId = Guid.NewGuid(); - int seed = Random.Shared.Next(); - - var layout = DungeonGenerator.Generate(seed, tier); - var simulation = new DungeonSimulation(layout, tier, _mobDefinitions); - - var instance = new DungeonInstance + + const int maxPlayersPerDungeon = 4; + + // 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) { - Id = dungeonId, - Tier = tier, - Seed = seed, - Simulation = simulation, - CreatedAt = DateTime.UtcNow - }; - - _dungeons[dungeonId] = instance; - + if (dungeon.Tier == tier && + dungeon.Simulation.Phase == DungeonPhase.Active && + dungeon.Simulation.Players.Count < maxPlayersPerDungeon && + (DateTime.UtcNow - dungeon.CreatedAt).TotalSeconds < 60) // 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 = layout.Rooms[0]; // Entrance room + var spawnPos = layout2.Rooms[0]; // Entrance room var player = new PlayerInstance { CharacterId = session.CharacterId, CharacterName = session.Character.Name, - X = spawnPos.CenterX * 32, - Y = spawnPos.CenterY * 32, + 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, @@ -312,27 +339,32 @@ public sealed class DungeonHandler : IClientMessageHandler Strength = session.Character.Strength, Intelligence = session.Character.Intelligence }; - - simulation.Players[session.CharacterId] = player; - + + instance.Simulation.Players[session.CharacterId] = player; + // Update session state session.State = PlayerState.InDungeon; session.CurrentDungeonId = dungeonId; session.PlayerInstance = player; - - _log.LogInformation("Player {Name} entered dungeon tier {Tier}", session.Character.Name, tier); - + await SendAsync(connection, DungeonOpCodes.DUNGEON_ENTER_RESULT, new { ok = true, dungeonId = dungeonId.ToString(), - tier, - seed, - width = layout.Width, - height = layout.Height, - tiles = layout.SerializeTiles(), + tier = instance.Tier, + seed = instance.Seed, + width = layout2.Width, + height = layout2.Height, + tiles = layout2.SerializeTiles(), spawn = new { x = player.X, y = player.Y }, - mobs = simulation.Mobs.Values.Select(m => new + 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, @@ -341,7 +373,7 @@ public sealed class DungeonHandler : IClientMessageHandler health = m.Health, maxHealth = m.MaxHealth }), - chests = simulation.Chests.Values.Select(c => new + chests = instance.Simulation.Chests.Values.Select(c => new { id = c.Id, x = c.X, @@ -351,58 +383,98 @@ public sealed class DungeonHandler : IClientMessageHandler }) }, 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.X; - session.PlayerInstance.InputY = input.Y; + 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); - session.PlayerInstance.AttackTargetId = input.TargetId; - session.PlayerInstance.WantsToAttack = true; + 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; @@ -410,50 +482,50 @@ public sealed class DungeonHandler : IClientMessageHandler _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; } - + private void TickAll(object? state) { _currentTick++; - + foreach (var (dungeonId, instance) in _dungeons) { try { var result = instance.Simulation.Tick(_currentTick); - + // 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) @@ -462,17 +534,17 @@ public sealed class DungeonHandler : IClientMessageHandler _ = 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) { @@ -485,21 +557,21 @@ public sealed class DungeonHandler : IClientMessageHandler } } } - + 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(), - - //tiles = sim.Layout.Tiles, - + + // 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, @@ -516,7 +588,7 @@ public sealed class DungeonHandler : IClientMessageHandler isAlive = p.IsAlive, isInCombat = p.IsInCombat }), - + mobs = sim.Mobs.Values.Where(m => m.IsAlive).Select(m => new { id = m.Id, @@ -532,7 +604,7 @@ public sealed class DungeonHandler : IClientMessageHandler spriteHeight = m.SpriteHeight, tintColor = m.TintColor }), - + chests = sim.Chests.Values.Select(c => new { id = c.Id, @@ -540,7 +612,7 @@ public sealed class DungeonHandler : IClientMessageHandler y = c.Y, opened = c.IsOpened }), - + droppedItems = sim.DroppedItems.Values.Select(i => new { id = i.Id, @@ -549,7 +621,7 @@ public sealed class DungeonHandler : IClientMessageHandler x = i.X, y = i.Y }), - + events = tickResult == null ? null : new { damage = tickResult.DamageEvents.Select(e => new @@ -571,74 +643,74 @@ public sealed class DungeonHandler : IClientMessageHandler 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++; @@ -651,24 +723,24 @@ public sealed class DungeonHandler : IClientMessageHandler 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}", + + _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 @@ -692,7 +764,7 @@ public sealed class DungeonHandler : IClientMessageHandler } }; } - + private async Task SendAsync(IConnection connection, int opCode, object payload, CancellationToken ct) { try @@ -707,12 +779,12 @@ public sealed class DungeonHandler : IClientMessageHandler _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 /// @@ -743,13 +815,14 @@ public class DungeonEnterRequest public class MoveInput { - public float X { get; set; } - public float Y { get; set; } + public float Dx { get; set; } + public float Dy { get; set; } + public float AimAngle { get; set; } } public class AttackInput { - public ulong TargetId { get; set; } + public float AimAngle { get; set; } } public class PickupInput