1492 lines
54 KiB
C#
1492 lines
54 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;
|
|
|
|
//LootSystem
|
|
private LootService _lootService = null!;
|
|
|
|
public DungeonHandler(
|
|
ILogger<DungeonHandler> log,
|
|
ISessionRegistry sessions,
|
|
IMessageSerializer ser,
|
|
IServiceScopeFactory scopeFactory, LootService lootService)
|
|
{
|
|
_log = log;
|
|
_sessions = sessions;
|
|
_ser = ser;
|
|
_scopeFactory = scopeFactory;
|
|
_lootService = lootService;
|
|
}
|
|
|
|
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,
|
|
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<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;
|
|
|
|
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<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 "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<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 = 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<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;
|
|
}
|
|
/// <summary>
|
|
/// Handle hotbar slot assignment - links a hotbar slot to an inventory slot
|
|
/// </summary>
|
|
private async Task HandleHotbarAssign(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory<byte> payload, CancellationToken ct)
|
|
{
|
|
var json = System.Text.Encoding.UTF8.GetString(payload.Span);
|
|
var request = System.Text.Json.JsonSerializer.Deserialize<HotbarAssignRequest>(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<GameDbContext>();
|
|
|
|
// Check if the inventory slot has a consumable item
|
|
var invItem = await db.Set<DungeonCharacterItem>()
|
|
.FirstOrDefaultAsync(i => i.CharacterId == session.CharacterId &&
|
|
i.SlotIndex == request.InventorySlot &&
|
|
!i.IsEquipped, ct);
|
|
|
|
if (invItem != null)
|
|
{
|
|
var itemDef = await db.Set<DungeonItemDefinition>()
|
|
.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<DungeonBeltItem>()
|
|
.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<DungeonBeltItem>().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 >= 400)
|
|
{
|
|
_ = 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);
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Process loot when a mob dies
|
|
/// </summary>
|
|
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");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Adds loot directly to player's inventory in the database
|
|
/// </summary>
|
|
private async Task AddLootToInventoryAsync(DungeonPlayerSession session, List<LootDrop> loot)
|
|
{
|
|
using var scope = _scopeFactory.CreateScope();
|
|
var db = scope.ServiceProvider.GetRequiredService<GameDbContext>();
|
|
|
|
// Get existing inventory items
|
|
var existingItems = await db.Set<DungeonCharacterItem>()
|
|
.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<DungeonCharacterItem>().Add(newItem);
|
|
existingItems.Add(newItem);
|
|
}
|
|
}
|
|
|
|
await db.SaveChangesAsync();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sends loot popup to client showing what they received
|
|
/// </summary>
|
|
private async Task SendLootPopupAsync(DungeonPlayerSession session, List<LootDrop> 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);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handle inventory request - sends current inventory and equipment
|
|
/// </summary>
|
|
private async Task HandleInventoryRequest(IConnection connection, DungeonPlayerSession session, CancellationToken ct)
|
|
{
|
|
using var scope = _scopeFactory.CreateScope();
|
|
var db = scope.ServiceProvider.GetRequiredService<GameDbContext>();
|
|
|
|
// Get all inventory items
|
|
var inventoryItems = await db.Set<DungeonCharacterItem>()
|
|
.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<DungeonItemDefinition>()
|
|
.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<DungeonBeltItem>()
|
|
.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<string, object?>();
|
|
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);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handle equip item request
|
|
/// </summary>
|
|
private async Task HandleEquipItem(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory<byte> payload, CancellationToken ct)
|
|
{
|
|
var json = System.Text.Encoding.UTF8.GetString(payload.Span);
|
|
var request = System.Text.Json.JsonSerializer.Deserialize<EquipItemRequest>(json);
|
|
if (request == null) return;
|
|
|
|
using var scope = _scopeFactory.CreateScope();
|
|
var db = scope.ServiceProvider.GetRequiredService<GameDbContext>();
|
|
|
|
// Get the item to equip
|
|
var item = await db.Set<DungeonCharacterItem>()
|
|
.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<DungeonCharacterItem>()
|
|
.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<DungeonCharacterItem>()
|
|
.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);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handle unequip item request
|
|
/// </summary>
|
|
private async Task HandleUnequipItem(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory<byte> payload, CancellationToken ct)
|
|
{
|
|
var json = System.Text.Encoding.UTF8.GetString(payload.Span);
|
|
var request = System.Text.Json.JsonSerializer.Deserialize<UnequipItemRequest>(json);
|
|
if (request == null) return;
|
|
|
|
using var scope = _scopeFactory.CreateScope();
|
|
var db = scope.ServiceProvider.GetRequiredService<GameDbContext>();
|
|
|
|
// 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<DungeonCharacterItem>()
|
|
.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<DungeonCharacterItem>()
|
|
.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);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handle use item request (consumables)
|
|
/// </summary>
|
|
private async Task HandleUseItem(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory<byte> payload, CancellationToken ct)
|
|
{
|
|
var json = System.Text.Encoding.UTF8.GetString(payload.Span);
|
|
var request = System.Text.Json.JsonSerializer.Deserialize<UseItemRequest>(json);
|
|
if (request == null) return;
|
|
|
|
using var scope = _scopeFactory.CreateScope();
|
|
var db = scope.ServiceProvider.GetRequiredService<GameDbContext>();
|
|
|
|
var item = await db.Set<DungeonCharacterItem>()
|
|
.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<DungeonCharacterItem>().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);
|
|
}
|
|
/// <summary>
|
|
/// Handle dungeon cleared - return player to hub with all loot
|
|
/// </summary>
|
|
private async Task HandleDungeonClearedAsync(DungeonPlayerSession session)
|
|
{
|
|
_log.LogInformation("Dungeon cleared! Returning player {Name} to hub", session.Character.Name);
|
|
|
|
// Send dungeon cleared notification
|
|
await SendAsync(session.Connection, DungeonOpCodes.DUNGEON_STATE, new
|
|
{
|
|
phase = "cleared",
|
|
message = "Dungeon cleared! All enemies defeated."
|
|
}, CancellationToken.None);
|
|
|
|
// Small delay to let client see the message
|
|
await Task.Delay(2000);
|
|
|
|
// Remove from dungeon (extracted = true, so they keep XP and loot)
|
|
await RemoveFromDungeonAsync(session, true, CancellationToken.None);
|
|
|
|
// Send hub state
|
|
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);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Handle chat message from player
|
|
/// </summary>
|
|
private async Task HandleChatSend(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory<byte> payload, CancellationToken ct)
|
|
{
|
|
var json = System.Text.Encoding.UTF8.GetString(payload.Span);
|
|
var request = System.Text.Json.JsonSerializer.Deserialize<ChatSendRequest>(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);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Broadcast a system message to all players in a dungeon
|
|
/// </summary>
|
|
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);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Broadcast a system message to all connected players
|
|
/// </summary>
|
|
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; } = "";
|
|
}
|