Files
systemrevivalserver/Game/Dungeon/DungeonHandler.cs
T
2025-12-07 08:58:29 -05:00

837 lines
29 KiB
C#

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;
/// <summary>
/// Handles dungeon crawler game messages via the server's message router
/// Implements IClientMessageHandler for integration with existing infrastructure
/// </summary>
public sealed class DungeonHandler : IClientMessageHandler
{
private readonly ILogger<DungeonHandler> _log;
private readonly ISessionRegistry _sessions;
private readonly IMessageSerializer _ser;
private readonly IServiceScopeFactory _scopeFactory;
// Player state tracking (keyed by connection ID)
private readonly ConcurrentDictionary<Guid, DungeonPlayerSession> _playerSessions = new();
// Active dungeon instances
private readonly ConcurrentDictionary<Guid, DungeonInstance> _dungeons = new();
// Mob definitions cache
private Dictionary<int, DungeonMobDefinition> _mobDefinitions = new();
private bool _initialized = false;
// Tick management
private Timer? _tickTimer;
private long _currentTick = 0;
public DungeonHandler(
ILogger<DungeonHandler> log,
ISessionRegistry sessions,
IMessageSerializer ser,
IServiceScopeFactory scopeFactory)
{
_log = log;
_sessions = sessions;
_ser = ser;
_scopeFactory = scopeFactory;
}
public IReadOnlyCollection<int> 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
};
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<GameDbContext>();
var mobs = await db.Set<DungeonMobDefinition>()
.Where(m => m.IsEnabled)
.ToListAsync();
if (mobs.Count == 0)
{
// Seed default mobs
var defaults = DefaultDungeonMobs.GetDefaultMobs();
db.Set<DungeonMobDefinition>().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<byte> 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;
}
}
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<DungeonPlayerSession?> 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<GameDbContext>();
var character = await db.Set<DungeonCharacter>()
.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<DungeonCharacter>().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<byte> payload, CancellationToken ct)
{
var request = _ser.Deserialize<StatAllocateRequest>(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 "intelligence": character.Intelligence++; break;
case "wisdom": character.Wisdom++; break;
case "endurance": character.Endurance++; break;
case "dexterity": character.Dexterity++; break;
default: return;
}
character.UnspentStatPoints--;
// Save to database
using var scope = _scopeFactory.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<GameDbContext>();
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<byte> 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<DungeonEnterRequest>(payload);
int tier = Math.Clamp(request.Tier, 1, 10);
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)
{
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 = 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<byte> payload)
{
if (session.PlayerInstance == null) return;
var input = _ser.Deserialize<MoveInput>(payload);
session.PlayerInstance.InputX = input.Dx;
session.PlayerInstance.InputY = input.Dy;
session.PlayerInstance.Rotation = input.AimAngle;
}
private void HandleInputAttack(DungeonPlayerSession session, ReadOnlyMemory<byte> 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<AttackInput>(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<byte> payload)
{
if (session.State != PlayerState.InDungeon || !session.CurrentDungeonId.HasValue) return;
if (!_dungeons.TryGetValue(session.CurrentDungeonId.Value, out var dungeon)) return;
var input = _ser.Deserialize<PickupInput>(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<byte> payload)
{
if (session.State != PlayerState.InDungeon || !session.CurrentDungeonId.HasValue) return;
if (!_dungeons.TryGetValue(session.CurrentDungeonId.Value, out var dungeon)) return;
var input = _ser.Deserialize<ChestInput>(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;
}
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)
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);
}
}
}
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<GameDbContext>();
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<GameDbContext>();
// 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);
}
/// <summary>
/// Called when a connection is closed - cleanup session
/// </summary>
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);
}
}
}
// 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; }
}