Files
systemrevivalserver/Game/Dungeon/DungeonHandler.Dungeons.cs
T
2026-02-01 10:00:38 -05:00

694 lines
27 KiB
C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
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 GameServer.Networking.DTOs;
using Server.Networking.Messages;
namespace GameServer.Dungeon;
public sealed partial class DungeonHandler
{
#region Dungeon Browser Handlers
/// <summary>
/// Handle request for asset manifest (list of all CDN files for hot-update)
/// </summary>
private async Task HandleAssetManifestRequest(IConnection connection, CancellationToken ct)
{
using var scope = _scopeFactory.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<GameDbContext>();
var assets = await db.ClientAssets
.Where(a => a.IsEnabled)
.Select(a => new
{
filePath = a.FilePath,
assetType = (int)a.AssetType,
fileHash = a.FileHash,
fileSize = a.FileSize,
version = a.Version,
isRequired = a.IsRequired,
minClientVersion = a.MinClientVersion,
cdnPath = a.CdnPath ?? a.FilePath
})
.ToListAsync(ct);
await SendAsync(connection, DungeonOpCodes.ASSET_MANIFEST_RESPONSE, new
{
cdnBaseUrl = "https://assets.aeternalisgames.com/downloads/",
assets = assets
}, ct);
_log.LogInformation("Sent asset manifest with {Count} files", assets.Count);
}
/// <summary>
/// Handle request for list of available dungeons
/// </summary>
private async Task HandleDungeonListRequest(IConnection connection, DungeonPlayerSession session, CancellationToken ct)
{
var playerLevel = session.Character.Level;
var (bracketMin, bracketMax) = DungeonInstance.GetLevelBracket(playerLevel);
// Get active dungeons in player's bracket
var availableDungeons = _dungeons.Values
.Where(d => d.Simulation.Phase == DungeonPhase.Active &&
!d.BossKilled)
.Select(d => new
{
id = d.Id.ToString(),
tier = d.Tier,
levelBracket = $"{d.LevelBracketMin}-{d.LevelBracketMax}",
bracketMin = d.LevelBracketMin,
bracketMax = d.LevelBracketMax,
creatorName = d.CreatorName,
creatorLevel = d.CreatorLevel,
playerCount = d.Simulation.Players.Count,
maxPlayers = 20,
isJoinWindowOpen = d.IsJoinWindowOpen,
createdAt = d.CreatedAt,
secondsRemaining = d.IsJoinWindowOpen ? (int)(d.JoinWindowEnd - DateTime.UtcNow).TotalSeconds : 0
})
.OrderByDescending(d => d.isJoinWindowOpen)
.ThenByDescending(d => d.createdAt)
.ToList();
// Also load persisted dungeons from database (all of them, not filtered by bracket)
using var scope = _scopeFactory.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<GameDbContext>();
var persistedDungeons = await db.Set<DungeonPersistence>()
.Where(d => !d.IsCleared)
.Select(d => new
{
id = d.Id.ToString(),
tier = d.Tier,
levelBracket = $"{d.LevelBracketMin}-{d.LevelBracketMax}",
bracketMin = d.LevelBracketMin,
bracketMax = d.LevelBracketMax,
creatorName = d.CreatorName,
creatorLevel = d.CreatorLevel,
playerCount = 0,
maxPlayers = 20,
isJoinWindowOpen = false,
isPersisted = true,
createdAt = d.CreatedAt
})
.ToListAsync(ct);
await SendAsync(connection, DungeonOpCodes.DUNGEON_LIST_RESPONSE, new
{
playerLevel = playerLevel,
bracket = new { min = bracketMin, max = bracketMax },
activeDungeons = availableDungeons,
persistedDungeons = persistedDungeons
}, ct);
}
/// <summary>
/// Handle creating a new dungeon
/// </summary>
private async Task HandleDungeonCreate(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<DungeonCreateRequest>(payload);
int tier = Math.Clamp(request.Tier, 1, 10);
int playerLevel = session.Character.Level;
// Get player's natural bracket, but allow them to select different ones within +/-50 levels
var (naturalBracketMin, naturalBracketMax) = DungeonInstance.GetLevelBracket(playerLevel);
int bracketMin, bracketMax;
if (request.BracketMin > 0)
{
// Player specified a bracket - validate it's within +/-50 levels of player
bracketMin = request.BracketMin;
(bracketMin, bracketMax) = DungeonInstance.GetLevelBracket(bracketMin); // Normalize to valid bracket
// Check if bracket start is within +/-50 of player level
if (Math.Abs(bracketMin - playerLevel) > 50)
{
await SendAsync(connection, DungeonOpCodes.DUNGEON_ENTER_RESULT, new
{
ok = false,
error = "bracket_out_of_range",
message = $"You can only create dungeons for brackets within 50 levels of your level ({playerLevel})"
}, ct);
return;
}
}
else
{
// Use player's natural bracket
bracketMin = naturalBracketMin;
bracketMax = naturalBracketMax;
}
var dungeonId = Guid.NewGuid();
int seed = Random.Shared.Next();
// Try V3 generator with DungeonBuilder templates first
DungeonLayout layout;
DungeonLayoutV2? layoutV2 = null;
try
{
using var scope = _scopeFactory.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<GameDbContext>();
var generator = new DungeonGeneratorV3(db, seed, tier);
layoutV2 = await generator.GenerateAsync();
// Check if V3 actually produced tiles
if (layoutV2.TileDetails.Count == 0)
{
_log.LogWarning("V3 generator produced no tiles, falling back to V2");
var generatorV2 = new DungeonGeneratorV2(db, seed, tier);
layoutV2 = await generatorV2.GenerateAsync();
}
layout = layoutV2;
_log.LogInformation("Generated dungeon - {RoomCount} rooms, {TileCount} visual tiles",
layoutV2.Rooms.Count, layoutV2.TileDetails?.Count ?? 0);
}
catch (Exception ex)
{
_log.LogWarning(ex, "Dungeon generator failed, falling back to V2");
try
{
using var scope = _scopeFactory.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<GameDbContext>();
var generatorV2 = new DungeonGeneratorV2(db, seed, tier);
layoutV2 = await generatorV2.GenerateAsync();
layout = layoutV2;
}
catch (Exception ex2)
{
_log.LogWarning(ex2, "V2 generator also failed, using V1");
layout = DungeonGenerator.Generate(seed, tier);
}
}
var simulation = new DungeonSimulation(layout, tier, _mobDefinitions, bracketMin, _abilityDefinitions, _mobSpriteConfigs);
var 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
};
_dungeons[dungeonId] = instance;
_log.LogInformation("Player {Name} (Level {Level}) created dungeon {Id} (tier {Tier}, bracket {Min}-{Max})",
session.Character.Name, playerLevel, dungeonId, tier, bracketMin, bracketMax);
// Add player to dungeon
await AddPlayerToDungeonAsync(connection, session, instance, ct);
}
/// <summary>
/// Handle joining an existing dungeon
/// </summary>
private async Task HandleDungeonJoin(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<DungeonJoinRequest>(payload);
if (!Guid.TryParse(request.DungeonId, out var dungeonId))
{
await SendAsync(connection, DungeonOpCodes.DUNGEON_ENTER_RESULT, new { ok = false, error = "invalid_dungeon_id" }, ct);
return;
}
int playerLevel = session.Character.Level;
// Check if dungeon is in memory
if (_dungeons.TryGetValue(dungeonId, out var instance))
{
// Validate level bracket
if (!instance.IsLevelInBracket(playerLevel))
{
// Players can join any bracket - just log a warning
_log.LogInformation("Player {Name} (Level {Level}) joining dungeon outside their bracket ({Min}-{Max})",
session.Character.Name, playerLevel, instance.LevelBracketMin, instance.LevelBracketMax);
}
// Check if full
if (instance.Simulation.Players.Count >= 20)
{
await SendAsync(connection, DungeonOpCodes.DUNGEON_ENTER_RESULT, new { ok = false, error = "dungeon_full" }, ct);
return;
}
// Check if boss killed
if (instance.BossKilled)
{
await SendAsync(connection, DungeonOpCodes.DUNGEON_ENTER_RESULT, new { ok = false, error = "dungeon_cleared" }, ct);
return;
}
// If dungeon is currently empty (no players), respawn all mobs
if (instance.Simulation.Players.Count == 0)
{
RespawnAllMobs(instance);
_log.LogInformation("Respawned all mobs in dungeon {Id} (was empty when player joined)", dungeonId);
}
await AddPlayerToDungeonAsync(connection, session, instance, ct);
return;
}
// Try to restore from persistence
using var scope = _scopeFactory.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<GameDbContext>();
var persisted = await db.Set<DungeonPersistence>().FindAsync(new object[] { dungeonId }, ct);
if (persisted == null)
{
await SendAsync(connection, DungeonOpCodes.DUNGEON_ENTER_RESULT, new { ok = false, error = "dungeon_not_found" }, ct);
return;
}
if (persisted.IsCleared)
{
await SendAsync(connection, DungeonOpCodes.DUNGEON_ENTER_RESULT, new { ok = false, error = "dungeon_cleared" }, ct);
return;
}
// Players can join any bracket - just log if outside their level
if (playerLevel < persisted.LevelBracketMin || playerLevel > persisted.LevelBracketMax)
{
_log.LogInformation("Player {Name} (Level {Level}) joining persisted dungeon outside their bracket ({Min}-{Max})",
session.Character.Name, playerLevel, persisted.LevelBracketMin, persisted.LevelBracketMax);
}
// Restore dungeon from persistence
instance = await RestoreDungeonFromPersistenceAsync(persisted, ct);
if (instance == null)
{
await SendAsync(connection, DungeonOpCodes.DUNGEON_ENTER_RESULT, new { ok = false, error = "restore_failed" }, ct);
return;
}
_dungeons[dungeonId] = instance;
// Remove from persistence table (it's active now)
db.Set<DungeonPersistence>().Remove(persisted);
await db.SaveChangesAsync(ct);
await AddPlayerToDungeonAsync(connection, session, instance, ct);
}
/// <summary>
/// Add a player to a dungeon and send the result
/// </summary>
private async Task AddPlayerToDungeonAsync(IConnection connection, DungeonPlayerSession session, DungeonInstance instance, CancellationToken ct)
{
using var scope = _scopeFactory.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<GameDbContext>();
var layout = instance.Simulation.Layout;
var spawnPos = layout.Rooms[0]; // Entrance room
// Load equipped items for stat calculations
var equippedCharacterItems = await db.Set<DungeonCharacterItem>()
.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)
var 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;
instance.LastPlayerActivity = DateTime.UtcNow;
session.State = PlayerState.InDungeon;
session.CurrentDungeonId = instance.Id;
session.PlayerInstance = player;
// Build visual tile data if V2 layout available
object? tileSheets = null;
object? visualTiles = null;
object? placedObjects = null;
if (instance.LayoutV2 != null && instance.LayoutV2.TileDetails.Count > 0)
{
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,
trap = o.IsTrap,
damage = o.TrapDamage,
loot = o.LootTableId
}).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 = instance.Id.ToString(),
tier = instance.Tier,
seed = instance.Seed,
levelBracket = new { min = instance.LevelBracketMin, max = instance.LevelBracketMax },
width = layout.Width,
height = layout.Height,
tilesRLE = layout.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.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(),
spriteConfig = string.IsNullOrEmpty(m.SpriteConfigJson) ? null :
System.Text.Json.JsonSerializer.Deserialize<object>(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()
}),
// V3 visual tile data
tileSheets,
visualTiles,
placedObjects
}, ct);
_log.LogInformation("Player {Name} (Level {Level}) joined dungeon {Id}",
session.Character.Name, session.Character.Level, instance.Id);
}
/// <summary>
/// Restore a dungeon from persistence
/// </summary>
private async Task<DungeonInstance?> RestoreDungeonFromPersistenceAsync(DungeonPersistence persisted, CancellationToken ct)
{
try
{
var layout = DungeonGenerator.Generate(persisted.Seed, persisted.Tier);
var simulation = new DungeonSimulation(layout, persisted.Tier, _mobDefinitions, persisted.LevelBracketMin, _abilityDefinitions, _mobSpriteConfigs);
// NOTE: We intentionally do NOT restore mob state here.
// When a dungeon is restored (all players left), ALL mobs respawn fresh.
// This gives the dungeon a "reset" behavior when empty.
// The mob state is preserved in persistence for potential future use,
// but on restore we use the freshly generated mobs from DungeonSimulation.
_log.LogInformation("Dungeon {Id} restored with all mobs respawned (was persisted with {MobCount} mob states)",
persisted.Id,
string.IsNullOrEmpty(persisted.MobStateJson) ? 0 : "saved");
// Restore chest state if available (chests stay opened)
if (!string.IsNullOrEmpty(persisted.ChestStateJson))
{
var chestStates = System.Text.Json.JsonSerializer.Deserialize<List<PersistedChestState>>(persisted.ChestStateJson);
if (chestStates != null)
{
foreach (var chestState in chestStates)
{
if (simulation.Chests.TryGetValue(chestState.Id, out var chest))
{
chest.IsOpened = chestState.IsOpened;
}
}
}
}
var instance = new DungeonInstance
{
Id = persisted.Id,
Tier = persisted.Tier,
Seed = persisted.Seed,
Simulation = simulation,
CreatedAt = persisted.CreatedAt,
LevelBracketMin = persisted.LevelBracketMin,
LevelBracketMax = persisted.LevelBracketMax,
CreatorLevel = persisted.CreatorLevel,
CreatorCharacterId = persisted.CreatorCharacterId,
CreatorName = persisted.CreatorName,
BossKilled = persisted.BossKilled,
IsPersisted = false,
LastPlayerActivity = DateTime.UtcNow
};
_log.LogInformation("Restored dungeon {Id} from persistence with fresh mobs", persisted.Id);
return instance;
}
catch (Exception ex)
{
_log.LogError(ex, "Failed to restore dungeon {Id} from persistence", persisted.Id);
return null;
}
}
/// <summary>
/// Respawn all mobs in a dungeon (called when dungeon was empty and player rejoins)
/// Preserves mobs that are carrying player loot from kills
/// </summary>
private void RespawnAllMobs(DungeonInstance instance)
{
// Check if any existing mobs have carried player loot - don't respawn those
var mobsWithLoot = instance.Simulation.Mobs.Values
.Where(m => m.HasCarriedLoot)
.ToDictionary(m => m.Id, m => m);
if (mobsWithLoot.Count > 0)
{
_log.LogInformation("Preserving {Count} mobs with carried player loot during respawn", mobsWithLoot.Count);
}
// IMPORTANT: Reuse the existing layout to preserve mob spawn positions!
// Using DungeonGenerator.Generate() would create a V1 layout which has different
// room geometry than V2/V3, causing mobs to spawn in wrong positions.
var layout = instance.Simulation.Layout;
var freshSimulation = new DungeonSimulation(layout, instance.Tier, _mobDefinitions, instance.LevelBracketMin, _abilityDefinitions, _mobSpriteConfigs);
// Clear and rebuild mobs, keeping those with loot
instance.Simulation.Mobs.Clear();
foreach (var mob in freshSimulation.Mobs)
{
// If we have a preserved mob with this ID (same spawn point), use the preserved one
if (mobsWithLoot.TryGetValue(mob.Key, out var preservedMob))
{
// Restore the preserved mob (keeps carried loot)
instance.Simulation.Mobs.TryAdd(mob.Key, preservedMob);
}
else
{
// Use the fresh mob
instance.Simulation.Mobs.TryAdd(mob.Key, mob.Value);
}
}
// Reset chest states (they respawn closed) - but NOT loot chests
foreach (var chest in instance.Simulation.Chests.Values)
{
chest.IsOpened = false;
}
// DON'T clear loot chests - these contain player death drops!
// instance.Simulation.LootChests.Clear();
// DON'T clear dropped items - these might be important!
// instance.Simulation.DroppedItems.Clear();
// Reset portals (exit portal should be inactive until boss killed)
foreach (var portal in instance.Simulation.Portals.Values)
{
if (portal.Type == PortalType.Exit)
{
portal.IsActive = false;
}
}
_log.LogDebug("Respawned {MobCount} mobs in dungeon {Id} (preserved {PreservedCount} with loot)",
instance.Simulation.Mobs.Count, instance.Id, mobsWithLoot.Count);
}
/// <summary>
/// Persist a dungeon to SQL (called when empty for 10 minutes)
/// </summary>
private async Task PersistDungeonAsync(DungeonInstance instance, CancellationToken ct)
{
if (instance.IsPersisted || instance.BossKilled) return;
try
{
using var scope = _scopeFactory.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<GameDbContext>();
// Serialize mob state
var mobStates = instance.Simulation.Mobs.Values.Select(m => new PersistedMobState
{
Id = m.Id,
DefinitionId = m.DefinitionId,
X = m.X,
Y = m.Y,
Health = m.Health,
IsAlive = m.IsAlive
}).ToList();
// Serialize chest state
var chestStates = instance.Simulation.Chests.Values.Select(c => new PersistedChestState
{
Id = c.Id,
IsOpened = c.IsOpened
}).ToList();
// Check if record already exists (can happen if restore failed to delete the record)
var existing = await db.Set<DungeonPersistence>().FindAsync(new object[] { instance.Id }, ct);
if (existing != null)
{
// Update existing record
existing.LastActivity = instance.LastPlayerActivity;
existing.PersistedAt = DateTime.UtcNow;
existing.BossKilled = instance.BossKilled;
existing.MobStateJson = System.Text.Json.JsonSerializer.Serialize(mobStates);
existing.ChestStateJson = System.Text.Json.JsonSerializer.Serialize(chestStates);
}
else
{
var persisted = new DungeonPersistence
{
Id = instance.Id,
Tier = instance.Tier,
Seed = instance.Seed,
LevelBracketMin = instance.LevelBracketMin,
LevelBracketMax = instance.LevelBracketMax,
CreatorCharacterId = instance.CreatorCharacterId,
CreatorName = instance.CreatorName,
CreatorLevel = instance.CreatorLevel,
CreatedAt = instance.CreatedAt,
LastActivity = instance.LastPlayerActivity,
PersistedAt = DateTime.UtcNow,
BossKilled = instance.BossKilled,
MobStateJson = System.Text.Json.JsonSerializer.Serialize(mobStates),
ChestStateJson = System.Text.Json.JsonSerializer.Serialize(chestStates)
};
db.Set<DungeonPersistence>().Add(persisted);
}
await db.SaveChangesAsync(ct);
instance.IsPersisted = true;
_log.LogInformation("Persisted dungeon {Id} to database", instance.Id);
}
catch (Exception ex)
{
_log.LogError(ex, "Failed to persist dungeon {Id}", instance.Id);
}
}
#endregion
}