using System.Collections.Concurrent;
using System.Text.Json;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using DataServer.Data;
using DataServer.Data.Entities;
using DataServer.Data.Enums;
using Server.Networking;
using Server.Networking.Handling;
using Server.Networking.Messages;
using Server.Redis;
using GameServices;
using GameServices.Auth;
using GameServer.Networking.DTOs;
namespace GameServer.Dungeon;
///
/// Handles dungeon crawler game messages via the server's message router
/// Implements IClientMessageHandler for integration with existing infrastructure
///
public sealed partial class DungeonHandler : IClientMessageHandler
{
private readonly ILogger _log;
private readonly ISessionRegistry _sessions;
private readonly IMessageSerializer _ser;
private readonly IServiceScopeFactory _scopeFactory;
private readonly IServerBroadcastService _broadcastService;
private readonly IRedisManager _redis;
// Pod identifier for multi-instance tracking
private readonly string _podId;
// 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 Dictionary _abilityDefinitions = new();
private Dictionary _abilityAnimationMappings = new();
private Dictionary _mobSpriteConfigs = new(); // MobDefinitionId -> SpriteConfig JSON
private Dictionary _npcDefinitions = new();
private bool _initialized = false;
private volatile bool _spatialStateFilterEnabled = true;
private volatile float _spatialStateRadiusPx = 32f * 28f; // 28 tiles
private volatile int _spatialStateIntervalTicks = 1;
// Tick management
private Timer? _tickTimer;
private long _currentTick = 0;
//LootSystem
private LootService _lootService = null!;
// Crafting
private CraftingHandler _craftingHandler = null!;
public DungeonHandler(
ILogger log,
ISessionRegistry sessions,
IMessageSerializer ser,
IServiceScopeFactory scopeFactory,
LootService lootService,
CraftingHandler craftingHandler,
IServerBroadcastService broadcastService,
IRedisManager redis)
{
_log = log;
_sessions = sessions;
_ser = ser;
_scopeFactory = scopeFactory;
_lootService = lootService;
_craftingHandler = craftingHandler;
_broadcastService = broadcastService;
_redis = redis;
LoadSpatialStateTuningFromEnvironment();
// Generate unique pod ID (use hostname in K8s, or random for local dev)
_podId = Environment.GetEnvironmentVariable("HOSTNAME")
?? Environment.GetEnvironmentVariable("POD_NAME")
?? $"local-{Guid.NewGuid().ToString()[..8]}";
}
private void LoadSpatialStateTuningFromEnvironment()
{
var enabledRaw = Environment.GetEnvironmentVariable("DUNGEON_SPATIAL_FILTER_ENABLED");
if (!string.IsNullOrWhiteSpace(enabledRaw))
{
_spatialStateFilterEnabled = enabledRaw == "1" || enabledRaw.Equals("true", StringComparison.OrdinalIgnoreCase);
}
if (float.TryParse(Environment.GetEnvironmentVariable("DUNGEON_UPDATE_RADIUS_PX"), out var radiusPx))
{
_spatialStateRadiusPx = Math.Clamp(radiusPx, 128f, 8192f);
}
if (int.TryParse(Environment.GetEnvironmentVariable("DUNGEON_SPATIAL_INTERVAL_TICKS"), out var interval))
{
_spatialStateIntervalTicks = Math.Clamp(interval, 1, 20);
}
}
private static object? DeserializeSpriteConfigSafe(string? spriteConfigJson)
{
if (string.IsNullOrWhiteSpace(spriteConfigJson))
return null;
try
{
// Keep JSON structure intact for client-side consumers.
return JsonSerializer.Deserialize(spriteConfigJson);
}
catch
{
return null;
}
}
private static void NormalizeMobVisualStateForPayload(DungeonSimulation sim)
{
foreach (var mob in sim.Mobs.Values)
{
if (mob.IsAlive)
{
if (mob.State == MobState.Dead)
{
mob.State = MobState.Idle;
}
if (string.IsNullOrWhiteSpace(mob.CurrentAnimation) ||
mob.CurrentAnimation.StartsWith("death_", StringComparison.OrdinalIgnoreCase) ||
mob.CurrentAnimation.StartsWith("hurt_", StringComparison.OrdinalIgnoreCase))
{
mob.CurrentAnimation = mob.GetDirectionalAnimation("idle");
}
}
else
{
mob.Health = 0;
mob.State = MobState.Dead;
if (string.IsNullOrWhiteSpace(mob.CurrentAnimation) ||
!mob.CurrentAnimation.StartsWith("death_", StringComparison.OrdinalIgnoreCase))
{
mob.CurrentAnimation = mob.GetDirectionalAnimation("death");
}
}
}
}
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.DUNGEON_INPUT_PORTAL,
DungeonOpCodes.DUNGEON_INPUT_FIRE_PROJECTILE,
DungeonOpCodes.DUNGEON_INPUT_NPC_INTERACT,
DungeonOpCodes.DUNGEON_INPUT_NPC_DIALOG_SELECT,
DungeonOpCodes.DUNGEON_INPUT_NPC_SHOP_ACTION,
DungeonOpCodes.INVENTORY_REQUEST,
DungeonOpCodes.EQUIP_ITEM,
DungeonOpCodes.UNEQUIP_ITEM,
DungeonOpCodes.USE_ITEM,
DungeonOpCodes.DROP_ITEM,
DungeonOpCodes.CHAT_SEND,
DungeonOpCodes.HOTBAR_ASSIGN,
// Loot chest operations
DungeonOpCodes.LOOT_CHEST_OPEN,
DungeonOpCodes.LOOT_CHEST_TAKE_ITEM,
DungeonOpCodes.LOOT_CHEST_TAKE_ALL,
DungeonOpCodes.LOOT_CHEST_CLOSE,
//Mob Loot
DungeonOpCodes.MOB_LOOT_REQUEST,
DungeonOpCodes.MOB_LOOT_TAKE_ALL,
DungeonOpCodes.MOB_LOOT_TAKE_ITEM,
// Dungeon browser
DungeonOpCodes.DUNGEON_LIST_REQUEST,
DungeonOpCodes.DUNGEON_CREATE,
DungeonOpCodes.DUNGEON_JOIN,
// Asset management
DungeonOpCodes.ASSET_MANIFEST_REQUEST,
// Crafting
DungeonOpCodes.CRAFTING_SKILLS_REQUEST,
DungeonOpCodes.CRAFTING_RECIPES_REQUEST,
DungeonOpCodes.CRAFTING_ATTEMPT,
// Stash
DungeonOpCodes.STASH_REQUEST,
DungeonOpCodes.STASH_DEPOSIT,
DungeonOpCodes.STASH_WITHDRAW,
//Inventory
DungeonOpCodes.MOVE_ITEM,
DungeonOpCodes.STACK_ITEMS,
DungeonOpCodes.AUTO_STACK_INVENTORY,
OpCodes.PONG
};
public async Task InitializeAsync()
{
if (_initialized) return;
await LoadMobDefinitionsAsync();
await _lootService.InitializeAsync();
// Subscribe to Redis broadcast channel for multi-pod support
await SubscribeToBroadcastChannelAsync();
// Start tick loop (20 ticks per second)
_tickTimer = new Timer(TickAll, null, 0, 50);
_initialized = true;
_log.LogInformation("DungeonHandler initialized on pod {PodId} with {MobCount} mob definitions", _podId, _mobDefinitions.Count);
}
public async Task HandleAsync(int opCode, IConnection connection, ReadOnlyMemory payload, CancellationToken ct)
{
// Ensure initialized
if (!_initialized)
{
await InitializeAsync();
}
if (opCode == DungeonOpCodes.ASSET_MANIFEST_REQUEST)
{
await HandleAssetManifestRequest(connection, ct);
return;
}
// All dungeon operations require authentication
if (!_sessions.TryGet(connection.Id, out var accountId, out _))
{
// Ignore stray input before auth to avoid booting the client during connect
if (opCode is >= DungeonOpCodes.DUNGEON_INPUT_MOVE and <= DungeonOpCodes.DUNGEON_INPUT_NPC_SHOP_ACTION)
return;
await SendErrorAsync(connection, $"auth_required for packet: {opCode}", ct);
return;
}
// Get or create player session (only for authenticated opcodes)
if (opCode == OpCodes.PONG)
{
return;
}
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.DUNGEON_INPUT_PORTAL:
await HandlePortalUse(connection, session, payload, ct);
break;
case DungeonOpCodes.DUNGEON_INPUT_FIRE_PROJECTILE:
await HandleFireProjectile(connection, session, payload, ct);
break;
case DungeonOpCodes.DUNGEON_INPUT_NPC_INTERACT:
await HandleNpcInteract(connection, session, payload, ct);
break;
case DungeonOpCodes.DUNGEON_INPUT_NPC_DIALOG_SELECT:
await HandleNpcDialogSelect(connection, session, payload, ct);
break;
case DungeonOpCodes.DUNGEON_INPUT_NPC_SHOP_ACTION:
await HandleNpcShopAction(connection, session, payload, ct);
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.STACK_ITEMS:
await HandleStackItems(connection, session, payload, ct);
break;
case DungeonOpCodes.MOVE_ITEM:
await HandleMoveItem(connection, session, payload, ct);
break;
case DungeonOpCodes.AUTO_STACK_INVENTORY:
await HandleAutoStackInventory(connection, session, ct);
break;
case DungeonOpCodes.CHAT_SEND:
await HandleChatSend(connection, session, payload, ct);
break;
case DungeonOpCodes.HOTBAR_ASSIGN:
await HandleHotbarAssign(connection, session, payload, ct);
break;
// Loot chest operations
case DungeonOpCodes.LOOT_CHEST_OPEN:
await HandleLootChestOpen(connection, session, payload, ct);
break;
case DungeonOpCodes.LOOT_CHEST_TAKE_ITEM:
await HandleLootChestTakeItem(connection, session, payload, ct);
break;
case DungeonOpCodes.LOOT_CHEST_TAKE_ALL:
await HandleLootChestTakeAll(connection, session, payload, ct);
break;
case DungeonOpCodes.LOOT_CHEST_CLOSE:
await HandleLootChestClose(connection, session, payload, ct);
break;
// Mob loot operations
case DungeonOpCodes.MOB_LOOT_REQUEST:
await HandleMobLootRequest(connection, session, payload, ct);
break;
case DungeonOpCodes.MOB_LOOT_TAKE_ITEM:
await HandleMobLootTakeItem(connection, session, payload, ct);
break;
case DungeonOpCodes.MOB_LOOT_TAKE_ALL:
await HandleMobLootTakeAll(connection, session, payload, ct);
break;
// Dungeon browser
case DungeonOpCodes.DUNGEON_LIST_REQUEST:
await HandleDungeonListRequest(connection, session, ct);
break;
case DungeonOpCodes.DUNGEON_CREATE:
await HandleDungeonCreate(connection, session, payload, ct);
break;
case DungeonOpCodes.DUNGEON_JOIN:
await HandleDungeonJoin(connection, session, payload, ct);
break;
case DungeonOpCodes.ASSET_MANIFEST_REQUEST:
await HandleAssetManifestRequest(connection, ct);
break;
// Crafting
case DungeonOpCodes.CRAFTING_SKILLS_REQUEST:
await HandleCraftingSkillsRequest(connection, session, ct);
break;
case DungeonOpCodes.CRAFTING_RECIPES_REQUEST:
await HandleCraftingRecipesRequest(connection, session, ct);
break;
case DungeonOpCodes.CRAFTING_ATTEMPT:
await HandleCraftingAttempt(connection, session, payload, ct);
break;
// Stash
case DungeonOpCodes.STASH_REQUEST:
await HandleStashRequest(connection, session, ct);
break;
case DungeonOpCodes.STASH_DEPOSIT:
await HandleStashDeposit(connection, session, payload, ct);
break;
case DungeonOpCodes.STASH_WITHDRAW:
await HandleStashWithdraw(connection, session, payload, ct);
break;
case OpCodes.PONG:
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;
// Track in Redis for global player count
await TrackPlayerConnectedAsync(session);
return session;
}
///
/// Track player connection in Redis for global stats
///
private async Task TrackPlayerConnectedAsync(DungeonPlayerSession session)
{
try
{
// Increment global player count
await _redis.Db.StringIncrementAsync("stats:players");
// Store player session info for this pod
await _redis.SetJsonAsync($"player:{session.CharacterId}", new
{
accountId = session.AccountId,
characterId = session.CharacterId,
characterName = session.Character.Name,
podId = _podId,
state = session.State.ToString(),
connectedAt = DateTimeOffset.UtcNow.ToUnixTimeSeconds()
}, TimeSpan.FromHours(24));
_log.LogDebug("Player {CharacterId} connected on pod {PodId}", session.CharacterId, _podId);
}
catch (Exception ex)
{
_log.LogWarning(ex, "Failed to track player connection in Redis");
}
}
///
/// Remove player tracking from Redis
///
private async Task TrackPlayerDisconnectedAsync(DungeonPlayerSession session)
{
try
{
// Decrement global player count (don't go below 0)
var count = await _redis.Db.StringDecrementAsync("stats:players");
if (count < 0)
{
await _redis.Db.StringSetAsync("stats:players", 0);
}
// Remove player session info
await _redis.Db.KeyDeleteAsync($"player:{session.CharacterId}");
_log.LogDebug("Player {CharacterId} disconnected from pod {PodId}", session.CharacterId, _podId);
}
catch (Exception ex)
{
_log.LogWarning(ex, "Failed to track player disconnection in Redis");
}
}
///
/// Track dungeon creation in Redis
///
private async Task TrackDungeonCreatedAsync(DungeonInstance dungeon)
{
try
{
// Increment global dungeon count
await _redis.Db.StringIncrementAsync("stats:dungeons");
// Store dungeon info
await _redis.SetJsonAsync($"dungeon:{dungeon.Id}", new
{
id = dungeon.Id.ToString(),
tier = dungeon.Tier,
podId = _podId,
creatorName = dungeon.CreatorName,
creatorLevel = dungeon.CreatorLevel,
levelBracketMin = dungeon.LevelBracketMin,
levelBracketMax = dungeon.LevelBracketMax,
createdAt = DateTimeOffset.UtcNow.ToUnixTimeSeconds()
}, TimeSpan.FromHours(2)); // Dungeons auto-expire from Redis after 2 hours
_log.LogDebug("Dungeon {DungeonId} created on pod {PodId}", dungeon.Id, _podId);
}
catch (Exception ex)
{
_log.LogWarning(ex, "Failed to track dungeon creation in Redis");
}
}
///
/// Track dungeon destruction in Redis
///
private async Task TrackDungeonDestroyedAsync(Guid dungeonId)
{
try
{
// Decrement global dungeon count (don't go below 0)
var count = await _redis.Db.StringDecrementAsync("stats:dungeons");
if (count < 0)
{
await _redis.Db.StringSetAsync("stats:dungeons", 0);
}
// Remove dungeon info
await _redis.Db.KeyDeleteAsync($"dungeon:{dungeonId}");
_log.LogDebug("Dungeon {DungeonId} destroyed on pod {PodId}", dungeonId, _podId);
}
catch (Exception ex)
{
_log.LogWarning(ex, "Failed to track dungeon destruction in Redis");
}
}
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);
// If player is in dungeon, update their stats in simulation immediately
if (session.State == PlayerState.InDungeon && session.CurrentDungeonId.HasValue)
{
if (_dungeons.TryGetValue(session.CurrentDungeonId.Value, out var dungeon))
{
if (dungeon.Simulation.Players.TryGetValue(session.CharacterId, out var player))
{
// Recalculate combat stats with new base stats
var equippedItems = await db.DungeonCharacterItems
.Include(i => i.ItemDefinition)
.Include(i => i.CraftedItem)
.Where(i => i.CharacterId == character.Id && i.IsEquipped)
.ToListAsync(ct);
var newStats = DungeonCharacterStats.GetCombatStats(character, equippedItems);
// Update player instance stats
player.Strength = newStats.Strength;
player.Intelligence = newStats.Intelligence;
player.Wisdom = newStats.Wisdom;
player.Endurance = newStats.Endurance;
player.Dexterity = newStats.Dexterity;
player.Armor = newStats.Armor;
player.MoveSpeed = newStats.MoveSpeed;
player.AttackSpeed = newStats.AttackSpeed;
// Update max health/mana/stamina and heal the difference
float oldMaxHealth = player.MaxHealth;
float oldMaxMana = player.MaxMana;
float oldMaxStamina = player.MaxStamina;
player.MaxHealth = newStats.MaxHealth;
player.MaxMana = newStats.MaxMana;
player.MaxStamina = newStats.MaxStamina;
// Heal the difference when max increases
if (newStats.MaxHealth > oldMaxHealth)
player.Health = Math.Min(newStats.MaxHealth, player.Health + (newStats.MaxHealth - oldMaxHealth));
if (newStats.MaxMana > oldMaxMana)
player.Mana = Math.Min(newStats.MaxMana, player.Mana + (newStats.MaxMana - oldMaxMana));
if (newStats.MaxStamina > oldMaxStamina)
player.Stamina = Math.Min(newStats.MaxStamina, player.Stamina + (newStats.MaxStamina - oldMaxStamina));
Console.WriteLine($"[StatAllocate] Updated {character.Name}'s stats in dungeon - STR:{player.Strength} INT:{player.Intelligence} WIS:{player.Wisdom} END:{player.Endurance} DEX:{player.Dexterity}");
}
}
}
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);
int playerLevel = session.Character.Level;
var (bracketMin, bracketMax) = DungeonInstance.GetLevelBracket(playerLevel);
const int maxPlayersPerDungeon = 20;
// Try to find an existing dungeon of the same tier AND bracket that isn't full
DungeonInstance? instance = null;
Guid dungeonId = Guid.Empty;
foreach (var (id, dungeon) in _dungeons)
{
if (dungeon.Tier == tier &&
dungeon.LevelBracketMin == bracketMin && // Must match bracket
dungeon.Simulation.Phase == DungeonPhase.Active &&
!dungeon.AllBossesDefeated &&
dungeon.Simulation.Players.Count < maxPlayersPerDungeon &&
dungeon.IsJoinWindowOpen) // Use join window instead of hardcoded time
{
instance = dungeon;
dungeonId = id;
_log.LogInformation("Player {Name} joining existing dungeon {Id} (tier {Tier}, bracket {Min}-{Max}, {Players}/{Max} players)",
session.Character.Name, id, tier, bracketMin, bracketMax, dungeon.Simulation.Players.Count, maxPlayersPerDungeon);
// If dungeon is empty, respawn all mobs
if (dungeon.Simulation.Players.Count == 0)
{
RespawnAllMobs(dungeon);
_log.LogInformation("Respawned all mobs in dungeon {Id} (was empty when player joined via Quick Join)", id);
}
break;
}
}
// Create new dungeon if none found
if (instance == null)
{
dungeonId = Guid.NewGuid();
int seed = Random.Shared.Next();
var (layout, layoutV2) = await GenerateDungeonLayoutWithFallbackAsync(seed, tier, ct);
var simulation = new DungeonSimulation(layout, tier, _mobDefinitions, bracketMin, _abilityDefinitions, _mobSpriteConfigs, _abilityAnimationMappings, _npcDefinitions);
instance = new DungeonInstance
{
Id = dungeonId,
Tier = tier,
Seed = seed,
Simulation = simulation,
CreatedAt = DateTime.UtcNow,
LevelBracketMin = bracketMin,
LevelBracketMax = bracketMax,
CreatorLevel = playerLevel,
CreatorCharacterId = session.CharacterId,
CreatorName = session.Character.Name,
LayoutV2 = layoutV2 // Store V2 layout for visual tile data
};
instance.InitializeBossState(simulation.Mobs.Values.Count(m => m.Type == MobType.Boss));
_dungeons[dungeonId] = instance;
// Track in Redis
_ = TrackDungeonCreatedAsync(instance);
_log.LogInformation("Player {Name} (Level {Level}) created new dungeon {Id} (tier {Tier}, bracket {Min}-{Max})",
session.Character.Name, playerLevel, dungeonId, tier, bracketMin, bracketMax);
}
// Update last activity
instance.LastPlayerActivity = DateTime.UtcNow;
NormalizeMobVisualStateForPayload(instance.Simulation);
var layout2 = instance.Simulation.Layout;
// Add player to dungeon
var spawnPos = layout2.Rooms[0]; // Entrance room
// Load equipped items for stat calculations
List equippedCharacterItems;
DungeonCharacterCombatStats combatStats;
using (var scope = _scopeFactory.CreateScope())
{
var db = scope.ServiceProvider.GetRequiredService();
equippedCharacterItems = await db.Set()
.Include(i => i.ItemDefinition)
.Include(i => i.CraftedItem)
.Where(i => i.CharacterId == session.CharacterId && i.IsEquipped)
.ToListAsync(ct);
// Calculate combat stats with equipment bonuses (including crafted)
combatStats = DungeonCharacterStats.GetCombatStats(session.Character, equippedCharacterItems);
}
var player = new PlayerInstance
{
CharacterId = session.CharacterId,
CharacterName = session.Character.Name,
X = spawnPos.CenterX * 32 + Random.Shared.Next(-20, 20),
Y = spawnPos.CenterY * 32 + Random.Shared.Next(-20, 20),
Health = Math.Min(session.Character.CurrentHealth, combatStats.MaxHealth),
MaxHealth = combatStats.MaxHealth,
Mana = Math.Min(session.Character.CurrentMana, combatStats.MaxMana),
MaxMana = combatStats.MaxMana,
Stamina = combatStats.MaxStamina,
MaxStamina = combatStats.MaxStamina,
MoveSpeed = combatStats.MoveSpeed,
AttackSpeed = combatStats.AttackSpeed,
Strength = combatStats.Strength,
Intelligence = combatStats.Intelligence,
Wisdom = combatStats.Wisdom,
Endurance = combatStats.Endurance,
Dexterity = combatStats.Dexterity,
Armor = combatStats.Armor
};
instance.Simulation.Players[session.CharacterId] = player;
// Update session state
session.State = PlayerState.InDungeon;
session.CurrentDungeonId = dungeonId;
session.PlayerInstance = player;
session.InitialMobCatalogDungeonId = null;
// Build visual tile data if V2 layout available
object? tileSheets = null;
object? visualTiles = null;
object? placedObjects = null;
_log.LogInformation("LayoutV2 is null: {IsNull}, TileDetails count: {Count}",
instance.LayoutV2 == null, instance.LayoutV2?.TileDetails?.Count ?? 0);
if (instance.LayoutV2 != null && instance.LayoutV2.TileDetails.Count > 0)
{
// Materialize to arrays for JSON serialization
tileSheets = instance.LayoutV2.TileMapSheets.Select(s => new
{
id = s.Id,
path = s.CdnPath,
tileW = s.TileWidth,
tileH = s.TileHeight,
sheetW = s.SheetWidth,
sheetH = s.SheetHeight,
cols = s.Columns
}).ToArray();
visualTiles = instance.LayoutV2.TileDetails.Select(t => new
{
x = t.X,
y = t.Y,
tid = t.TileDefinitionId,
sid = t.SheetId,
frame = t.FrameIndex,
l = t.Layer,
r = t.Rotation,
fx = t.FlipX,
fy = t.FlipY
}).ToArray();
// V3: Include placed objects (decorations, containers, traps)
if (instance.LayoutV2.Objects?.Count > 0)
{
placedObjects = instance.LayoutV2.Objects.Select(o => new
{
x = o.X,
y = o.Y,
id = o.ObjectTemplateId,
name = o.Name,
type = o.Type,
sheetId = o.SpriteSheetId,
frame = o.FrameIndex,
blocks = o.BlocksMovement,
interact = o.IsInteractable,
triggeredByWalk = o.TriggeredByWalk,
interactionType = o.InteractionType,
trap = o.IsTrap,
damage = o.TrapDamage,
loot = o.LootTableId,
metadataJson = o.MetadataJson
}).ToArray();
}
_log.LogInformation("Sending {SheetCount} sheets, {TileCount} visual tiles, {ObjectCount} objects to client",
instance.LayoutV2.TileMapSheets.Count, instance.LayoutV2.TileDetails.Count, instance.LayoutV2.Objects?.Count ?? 0);
}
await SendAsync(connection, DungeonOpCodes.DUNGEON_ENTER_RESULT, new
{
ok = true,
dungeonId = dungeonId.ToString(),
tier = instance.Tier,
seed = instance.Seed,
width = layout2.Width,
height = layout2.Height,
tilesRLE = layout2.SerializeTilesRLE(),
spawn = new { x = player.X, y = player.Y },
players = instance.Simulation.Players.Values.Select(p => new
{
id = p.CharacterId,
name = p.CharacterName,
x = p.X,
y = p.Y
}),
mobs = instance.Simulation.Mobs.Values.Select(m => new
{
id = m.Id,
definitionId = m.DefinitionId,
name = m.Name,
x = m.X,
y = m.Y,
rotation = m.Rotation,
health = m.Health,
maxHealth = m.MaxHealth,
hasLoot = m.HasDeathLoot,
state = m.State.ToString().ToLower(),
currentAnimation = m.CurrentAnimation,
isAlive = m.IsAlive,
spriteConfig = DeserializeSpriteConfigSafe(m.SpriteConfigJson),
tintColor = m.TintColor,
scale = m.Scale
}),
mobCatalog = instance.Simulation.Mobs.Values.Select(m => new
{
id = m.Id,
definitionId = m.DefinitionId,
name = m.Name,
spriteConfig = DeserializeSpriteConfigSafe(m.SpriteConfigJson),
tintColor = m.TintColor,
scale = m.Scale
}),
chests = instance.Simulation.Chests.Values.Select(c => new
{
id = c.Id,
x = c.X,
y = c.Y,
type = c.Type.ToString().ToLower(),
opened = c.IsOpened
}),
portals = instance.Simulation.Portals.Values.Where(p => p.IsActive).Select(p => new
{
id = p.Id,
x = p.X,
y = p.Y,
type = p.Type.ToString().ToLower(),
triggerOnCollision = p.TriggerOnCollision,
triggerRadius = p.TriggerRadius,
destinationX = p.DestinationX,
destinationY = p.DestinationY
}),
// V3 visual tile data
tileSheets,
visualTiles,
placedObjects
}, 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 (dx, dy, aimAngle) = ParseMoveInput(payload, session.PlayerInstance.X, session.PlayerInstance.Y);
session.PlayerInstance.InputX = dx;
session.PlayerInstance.InputY = dy;
session.PlayerInstance.Rotation = aimAngle;
}
private static (float Dx, float Dy, float AimAngle) ParseMoveInput(ReadOnlyMemory payload, float currentX, float currentY)
{
if (payload.IsEmpty) return (0f, 0f, 0f);
try
{
using var doc = JsonDocument.Parse(System.Text.Encoding.UTF8.GetString(payload.Span));
var root = doc.RootElement;
if (root.ValueKind != JsonValueKind.Object) return (0f, 0f, 0f);
var source = root;
if (TryGetJsonProperty(root, "input", out var nested) && nested.ValueKind == JsonValueKind.Object)
{
source = nested;
}
var hasDx = TryGetJsonFloat(source, out var dx, "dx", "moveX", "inputX", "horizontal");
var hasDy = TryGetJsonFloat(source, out var dy, "dy", "moveY", "inputY", "vertical");
var hasRawX = TryGetJsonFloat(source, out var rawX, "x");
var hasRawY = TryGetJsonFloat(source, out var rawY, "y");
if (!hasDx && hasRawX && IsDirectionalValue(rawX))
{
dx = rawX;
hasDx = true;
}
if (!hasDy && hasRawY && IsDirectionalValue(rawY))
{
dy = rawY;
hasDy = true;
}
// Compatibility: absolute target coordinates from location-style clients.
if (!hasDx && !hasDy && hasRawX && hasRawY && (!IsDirectionalValue(rawX) || !IsDirectionalValue(rawY)))
{
var tx = rawX - currentX;
var ty = rawY - currentY;
var targetLen = MathF.Sqrt((tx * tx) + (ty * ty));
if (targetLen > 0.001f)
{
dx = tx / targetLen;
dy = ty / targetLen;
hasDx = true;
hasDy = true;
}
}
if (!hasDx) dx = 0f;
if (!hasDy) dy = 0f;
var len = MathF.Sqrt((dx * dx) + (dy * dy));
if (len > 1f)
{
dx /= len;
dy /= len;
}
else
{
dx = Math.Clamp(dx, -1f, 1f);
dy = Math.Clamp(dy, -1f, 1f);
}
TryGetJsonFloat(source, out var aimAngle, "aimAngle", "rotation", "angle");
return (dx, dy, aimAngle);
}
catch
{
return (0f, 0f, 0f);
}
}
private static bool TryGetJsonProperty(JsonElement source, string name, out JsonElement value)
{
foreach (var p in source.EnumerateObject())
{
if (string.Equals(p.Name, name, StringComparison.OrdinalIgnoreCase))
{
value = p.Value;
return true;
}
}
value = default;
return false;
}
private static bool TryGetJsonFloat(JsonElement source, out float value, params string[] names)
{
foreach (var n in names)
{
if (!TryGetJsonProperty(source, n, out var e)) continue;
if (e.ValueKind == JsonValueKind.Number && e.TryGetSingle(out value)) return true;
if (e.ValueKind == JsonValueKind.String && float.TryParse(e.GetString(), out value)) return true;
}
value = 0f;
return false;
}
private static bool IsDirectionalValue(float value)
=> float.IsFinite(value) && value >= -1.05f && value <= 1.05f;
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);
}
}
///
/// Handle projectile firing - validates weapon, consumes ammunition, creates projectile
///
private async Task HandleFireProjectile(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory payload, CancellationToken ct)
{
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;
// Normalize direction vector
float magnitude = MathF.Sqrt(input.DirectionX * input.DirectionX + input.DirectionY * input.DirectionY);
if (magnitude < 0.01f) return; // Invalid direction
float dirX = input.DirectionX / magnitude;
float dirY = input.DirectionY / magnitude;
using var scope = _scopeFactory.CreateScope();
var db = scope.ServiceProvider.GetRequiredService();
// Get equipped weapon using new equipment system
var weaponItem = await db.DungeonCharacterItems
.Include(i => i.ItemDefinition)
.FirstOrDefaultAsync(i => i.CharacterId == session.CharacterId
&& i.IsEquipped
&& i.EquipSlot == DungeonEquipmentSlot.MainHand, ct);
if (weaponItem?.ItemDefinition == null) return;
var weapon = weaponItem.ItemDefinition;
// Handle throwable weapons (consume from inventory)
if (weapon.IsThrowable)
{
await HandleThrowableProjectile(session, dungeon, weapon, dirX, dirY, ct);
return;
}
// Handle ranged weapons (require ammunition)
if (!weapon.RequiresAmmunition || weapon.ProjectileSpeed <= 0) return;
// Get ammunition from quiver
var ammo = await ConsumeAmmunitionFromQuiver(session, weapon.AmmunitionType, db, ct);
if (ammo == null)
{
// No ammo available - could send error message to client
_log.LogDebug("Player {Name} tried to fire {Weapon} but has no {AmmoType} ammunition",
session.Character.Name, weapon.Name, weapon.AmmunitionType);
return;
}
// Calculate damage (STR 30% + DEX 70%)
int weaponDamage = Random.Shared.Next(weapon.MinDamage, weapon.MaxDamage + 1);
int ammoDamage = Random.Shared.Next(ammo.MinDamage, ammo.MaxDamage + 1);
int baseDamage = weaponDamage + ammoDamage;
float statModifier = (session.Character.Strength * 0.3f + session.Character.Dexterity * 0.7f);
float statBonus = baseDamage * (statModifier / 100f);
int totalDamage = (int)(baseDamage + statBonus);
// Debug logging disabled
// Console.WriteLine($"[HandleFireProjectile] Weapon: {weapon.Name} ({weapon.MinDamage}-{weapon.MaxDamage}), Ammo: {ammo.Name} ({ammo.MinDamage}-{ammo.MaxDamage}), Total: {totalDamage}");
// Create projectile
var projectile = new ProjectileInstance
{
Id = dungeon.Simulation.GetNextProjectileId(),
SourceType = ProjectileSource.Player,
SourcePlayerId = session.CharacterId,
X = player.X,
Y = player.Y,
VelocityX = dirX * weapon.ProjectileSpeed,
VelocityY = dirY * weapon.ProjectileSpeed,
Speed = weapon.ProjectileSpeed,
Damage = totalDamage,
DamageTypeKey = weapon.DamageTypeKey,
MaxRange = weapon.ProjectileRange,
DistanceTraveled = 0,
AmmunitionItemDefinitionId = ammo.Id,
RecoveryChance = ammo.ArrowRecoveryChance,
CanHitMobs = true,
CanHitPlayers = false, // TODO: PvP support
SpriteKey = ammo.SpritePath ?? "projectile_arrow",
IsLinear = ammo.IsLinearProjectile,
FrontX = ammo.ProjectileFrontX,
FrontY = ammo.ProjectileFrontY,
BackX = ammo.ProjectileBackX,
BackY = ammo.ProjectileBackY
};
dungeon.Simulation.Projectiles.TryAdd(projectile.Id, projectile);
// Debug logging disabled
// Console.WriteLine($"[HandleFireProjectile] Added projectile {projectile.Id} to simulation. Total projectiles: {dungeon.Simulation.Projectiles.Count}");
// Broadcast projectile spawned
// Console.WriteLine($"[HandleFireProjectile] Broadcasting projectile {projectile.Id} to {dungeon.Simulation.Players.Count} players");
foreach (var dungeonPlayer in dungeon.Simulation.Players.Values)
{
// Console.WriteLine($"[HandleFireProjectile] Checking player CharId={dungeonPlayer.CharacterId}");
var playerSession = _playerSessions.Values.FirstOrDefault(p => p.CharacterId == dungeonPlayer.CharacterId);
if (playerSession != null)
{
// Console.WriteLine($"[HandleFireProjectile] Sending EVENT_PROJECTILE_SPAWNED (504) to player {playerSession.Character.Name} (CharId={playerSession.CharacterId})");
try
{
await SendAsync(playerSession.Connection, DungeonOpCodes.EVENT_PROJECTILE_SPAWNED, new
{
id = projectile.Id,
sourceType = "player",
sourceId = session.CharacterId,
x = projectile.X,
y = projectile.Y,
vx = projectile.VelocityX,
vy = projectile.VelocityY,
sprite = projectile.SpriteKey,
isLinear = projectile.IsLinear,
frontX = projectile.FrontX,
frontY = projectile.FrontY,
backX = projectile.BackX,
backY = projectile.BackY
}, ct);
// Console.WriteLine($"[HandleFireProjectile] Successfully sent EVENT_PROJECTILE_SPAWNED to {playerSession.Character.Name}");
}
catch (Exception ex)
{
Console.WriteLine($"[HandleFireProjectile] ERROR sending EVENT_PROJECTILE_SPAWNED to {playerSession.Character.Name}: {ex.Message}");
}
}
// else
// {
// Console.WriteLine($"[HandleFireProjectile] WARNING: No session found for player CharId={dungeonPlayer.CharacterId}");
// }
}
_log.LogDebug("Player {Name} fired projectile with {Weapon} using {Ammo} for {Damage} damage",
session.Character.Name, weapon.Name, ammo.Name, totalDamage);
}
private async Task HandleThrowableProjectile(DungeonPlayerSession session, DungeonInstance dungeon, DungeonItemDefinition weapon, float dirX, float dirY, CancellationToken ct)
{
// Throwables consume from inventory
using var scope = _scopeFactory.CreateScope();
var db = scope.ServiceProvider.GetRequiredService();
var throwableStack = await db.DungeonCharacterItems
.Include(i => i.CraftedItem)
.FirstOrDefaultAsync(i => i.CharacterId == session.CharacterId &&
i.ItemDefinitionId == weapon.Id &&
i.Quantity > 0, ct);
if (throwableStack == null) return;
// Consume one
throwableStack.Quantity--;
if (throwableStack.Quantity <= 0)
{
db.DungeonCharacterItems.Remove(throwableStack);
}
await db.SaveChangesAsync(ct);
// Calculate damage (include crafted item rolled bonuses)
int totalMinDamage = weapon.MinDamage + (throwableStack.CraftedItem?.RolledBonusMinDamage ?? 0);
int totalMaxDamage = weapon.MaxDamage + (throwableStack.CraftedItem?.RolledBonusMaxDamage ?? 0);
int baseDamage = Random.Shared.Next(totalMinDamage, totalMaxDamage + 1);
float statModifier = (session.Character.Strength * 0.3f + session.Character.Dexterity * 0.7f);
float statBonus = baseDamage * (statModifier / 100f);
int totalDamage = (int)(baseDamage + statBonus);
// Create projectile
var projectile = new ProjectileInstance
{
Id = dungeon.Simulation.GetNextProjectileId(),
SourceType = ProjectileSource.Player,
SourcePlayerId = session.CharacterId,
X = session.PlayerInstance!.X,
Y = session.PlayerInstance.Y,
VelocityX = dirX * weapon.ProjectileSpeed,
VelocityY = dirY * weapon.ProjectileSpeed,
Speed = weapon.ProjectileSpeed,
Damage = totalDamage,
DamageTypeKey = weapon.DamageTypeKey,
MaxRange = weapon.ProjectileRange,
DistanceTraveled = 0,
AmmunitionItemDefinitionId = weapon.Id,
RecoveryChance = weapon.ArrowRecoveryChance,
CanHitMobs = true,
CanHitPlayers = false,
SpriteKey = weapon.SpritePath ?? "projectile_knife",
IsLinear = weapon.IsLinearProjectile,
FrontX = weapon.ProjectileFrontX,
FrontY = weapon.ProjectileFrontY,
BackX = weapon.ProjectileBackX,
BackY = weapon.ProjectileBackY
};
dungeon.Simulation.Projectiles.TryAdd(projectile.Id, projectile);
Console.WriteLine($"[HandleThrowableProjectile] Broadcasting projectile {projectile.Id} to {dungeon.Simulation.Players.Count} players");
foreach (var dungeonPlayer in dungeon.Simulation.Players.Values)
{
var playerSession = _playerSessions.Values.FirstOrDefault(p => p.CharacterId == dungeonPlayer.CharacterId);
if (playerSession != null)
{
Console.WriteLine($"[HandleThrowableProjectile] Sending EVENT_PROJECTILE_SPAWNED (504) to player {playerSession.Character.Name}");
try
{
await SendAsync(playerSession.Connection, DungeonOpCodes.EVENT_PROJECTILE_SPAWNED, new
{
id = projectile.Id,
sourceType = "player",
sourceId = session.CharacterId,
x = projectile.X,
y = projectile.Y,
vx = projectile.VelocityX,
vy = projectile.VelocityY,
sprite = projectile.SpriteKey,
isLinear = projectile.IsLinear,
frontX = projectile.FrontX,
frontY = projectile.FrontY,
backX = projectile.BackX,
backY = projectile.BackY
}, ct);
Console.WriteLine($"[HandleThrowableProjectile] Successfully sent EVENT_PROJECTILE_SPAWNED to {playerSession.Character.Name}");
}
catch (Exception ex)
{
Console.WriteLine($"[HandleThrowableProjectile] ERROR sending EVENT_PROJECTILE_SPAWNED to {playerSession.Character.Name}: {ex.Message}");
}
}
}
}
private async Task ConsumeAmmunitionFromQuiver(DungeonPlayerSession session, string? ammoType, GameDbContext db, CancellationToken ct)
{
if (string.IsNullOrEmpty(ammoType)) return null;
// Get equipped quiver using new equipment system
var quiverItem = await db.DungeonCharacterItems
.Include(i => i.ItemDefinition)
.FirstOrDefaultAsync(i => i.CharacterId == session.CharacterId
&& i.IsEquipped
&& i.EquipSlot == DungeonEquipmentSlot.Quiver, ct);
if (quiverItem?.ItemDefinition == null) return null;
// Check if it's a quiver container
if (quiverItem.ItemDefinition.QuiverCapacity > 0)
{
// Quiver container - find ammunition in slots
var ammoSlot = await db.DungeonQuiverAmmoSlots
.Include(s => s.ItemDefinition)
.Where(s => s.QuiverCharacterItemId == quiverItem.Id && s.Quantity > 0)
.OrderBy(s => s.SlotIndex)
.FirstOrDefaultAsync(ct);
if (ammoSlot?.ItemDefinition == null) return null;
// Consume one
ammoSlot.Quantity--;
await db.SaveChangesAsync(ct);
return ammoSlot.ItemDefinition;
}
else
{
// Direct ammo equip (stack of arrows in quiver slot)
if (quiverItem.Quantity <= 0) return null;
quiverItem.Quantity--;
if (quiverItem.Quantity <= 0)
{
// Unequip when empty using new equipment system
quiverItem.IsEquipped = false;
quiverItem.EquipSlot = null;
db.DungeonCharacterItems.Remove(quiverItem);
}
await db.SaveChangesAsync(ct);
return quiverItem.ItemDefinition;
}
}
///
/// Handle portal use - instant extraction when player clicks/walks into portal
///
private async Task HandlePortalUse(IConnection connection, DungeonPlayerSession session, ReadOnlyMemory payload, CancellationToken ct)
{
if (session.State != PlayerState.InDungeon || !session.CurrentDungeonId.HasValue) return;
if (!_dungeons.TryGetValue(session.CurrentDungeonId.Value, out var dungeon)) return;
var json = System.Text.Encoding.UTF8.GetString(payload.Span);
var request = System.Text.Json.JsonSerializer.Deserialize(json);
if (request == null) return;
// Find the portal
if (!dungeon.Simulation.Portals.TryGetValue(request.PortalId, out var portal))
{
_log.LogWarning("Player {Name} tried to use non-existent portal {Id}", session.Character.Name, request.PortalId);
return;
}
if (!portal.IsActive)
{
_log.LogWarning("Player {Name} tried to use inactive portal {Id}", session.Character.Name, request.PortalId);
return;
}
var player = session.PlayerInstance;
if (player == null) return;
// Check distance to portal (must be within 64 pixels)
float dx = player.X - portal.X;
float dy = player.Y - portal.Y;
float dist = MathF.Sqrt(dx * dx + dy * dy);
if (dist > 64)
{
_log.LogDebug("Player {Name} too far from portal ({Dist})", session.Character.Name, dist);
return;
}
if (portal.DestinationX.HasValue && portal.DestinationY.HasValue)
{
if (!dungeon.Simulation.CanActorMoveTo(portal.DestinationX.Value, portal.DestinationY.Value))
{
_log.LogDebug("Player {Name} tried to use portal {Id} with blocked destination", session.Character.Name, portal.Id);
return;
}
player.X = portal.DestinationX.Value;
player.Y = portal.DestinationY.Value;
player.InputX = 0f;
player.InputY = 0f;
await SendAsync(connection, DungeonOpCodes.PORTAL_USED, new
{
portalId = portal.Id,
type = portal.Type.ToString().ToLower(),
teleported = true,
x = player.X,
y = player.Y
}, ct);
return;
}
_log.LogInformation("Player {Name} using exit portal", session.Character.Name);
// Send portal used confirmation
await SendAsync(connection, DungeonOpCodes.PORTAL_USED, new
{
portalId = portal.Id,
type = portal.Type.ToString().ToLower()
}, ct);
// Extract player (keep loot, save progress)
await RemoveFromDungeonAsync(session, true, ct);
// Return to hub
await SendAsync(connection, DungeonOpCodes.HUB_STATE, GetHubState(session.Character), ct);
}
///
/// 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 valid item (consumable or equipment)
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 and equipment in hotbar
if (itemDef == null || (itemDef.Type != ItemType.Consumable &&
itemDef.Type != ItemType.Weapon &&
itemDef.Type != ItemType.Armor &&
itemDef.Type != ItemType.Accessory))
{
_log.LogDebug("Cannot assign item type {Type} to hotbar", itemDef?.Type);
return;
}
}
// Remove the same inventory slot from any other hotbar slot (prevent duplicates)
var duplicateEntries = await db.Set()
.Where(b => b.CharacterId == session.CharacterId &&
b.InventorySlotIndex == request.InventorySlot &&
b.SlotIndex != request.HotbarSlot)
.ToListAsync(ct);
if (duplicateEntries.Any())
{
db.Set().RemoveRange(duplicateEntries);
}
// 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++;
// Process pending broadcasts
ProcessPendingBroadcasts();
// Update active connection count for admin display
_broadcastService.SetActiveConnectionCount(_playerSessions.Count);
foreach (var (dungeonId, instance) in _dungeons)
{
try
{
var result = instance.Simulation.Tick(_currentTick);
// Process death events for loot generation
if (result.DeathEvents != null)
{
foreach (var death in result.DeathEvents)
{
if (death.EntityType == EntityType.Mob && death.KillerType == EntityType.Player)
{
_ = ProcessMobDeathLootAsync(instance, death);
if (instance.Simulation.Mobs.TryGetValue(death.EntityId, out var killedMob))
{
if (killedMob.Type == MobType.Boss)
{
if (instance.RegisterBossDefeat(death.EntityId))
{
_log.LogInformation(
"Boss defeated in dungeon {Id}: {Defeated}/{Total} bosses cleared.",
dungeonId,
instance.BossesDefeatedCount,
instance.TotalBossCount);
}
}
}
}
else if (death.EntityType == EntityType.Player)
{
_ = ProcessPlayerDeathLootTransferAsync(instance, death);
}
}
}
// Get players in this dungeon
var playersInDungeon = _playerSessions.Values
.Where(s => s.CurrentDungeonId == dungeonId && s.State == PlayerState.InDungeon)
.ToList();
// ==================== TILE UPDATE BROADCASTING ====================
// Check for pending tile updates from admin editing
if (instance.HasPendingTileUpdates && instance.LayoutV2 != null && playersInDungeon.Count > 0)
{
instance.HasPendingTileUpdates = false;
// Get changed tiles if we're tracking them, otherwise send all
object[] tilesToSend;
object[]? walkableUpdates = null;
if (_changedTiles.TryRemove(dungeonId, out var changes) && changes.Count > 0)
{
// Differential update - only send changed tiles
var changedList = changes.ToList();
var tileDetails = instance.LayoutV2.TileDetails;
tilesToSend = changedList
.Select(c => {
var tile = tileDetails.FirstOrDefault(t => t.X == c.x && t.Y == c.y && t.Layer == c.layer);
if (tile != null)
{
return new
{
x = tile.X,
y = tile.Y,
sid = tile.SheetId,
frame = tile.FrameIndex,
l = tile.Layer,
r = tile.Rotation,
fx = tile.FlipX,
fy = tile.FlipY
};
}
// Tile was removed - send with sid=0 to indicate removal
return new
{
x = c.x,
y = c.y,
sid = 0,
frame = 0,
l = c.layer,
r = 0,
fx = false,
fy = false
};
})
.Cast