780 lines
30 KiB
C#
780 lines
30 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.AllBossesDefeated)
|
|
.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,
|
|
totalBosses = d.TotalBossCount,
|
|
defeatedBosses = d.BossesDefeatedCount,
|
|
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();
|
|
|
|
var (layout, layoutV2) = await GenerateDungeonLayoutWithFallbackAsync(seed, tier, ct);
|
|
|
|
var simulation = new DungeonSimulation(layout, tier, _mobDefinitions, bracketMin, _abilityDefinitions, _mobSpriteConfigs, _abilityAnimationMappings);
|
|
|
|
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
|
|
};
|
|
instance.InitializeBossState(simulation.Mobs.Values.Count(m => m.Type == MobType.Boss));
|
|
|
|
_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.AllBossesDefeated)
|
|
{
|
|
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, _abilityAnimationMappings);
|
|
var mobStatePayload = DeserializePersistedMobPayload(persisted.MobStateJson);
|
|
var persistedMobStates = mobStatePayload?.Mobs;
|
|
|
|
// Rehydrate runtime/admin-spawned alive mobs that are not in static layout spawns.
|
|
if (persistedMobStates != null)
|
|
{
|
|
foreach (var mobState in persistedMobStates.Where(m => m.IsAlive))
|
|
{
|
|
if (simulation.Mobs.ContainsKey(mobState.Id)) continue;
|
|
simulation.TrySpawnMobFromPersistedState(mobState);
|
|
}
|
|
}
|
|
|
|
_log.LogInformation("Dungeon {Id} restored from persistence with {MobCount} saved mob states",
|
|
persisted.Id,
|
|
persistedMobStates?.Count ?? 0);
|
|
|
|
// 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
|
|
};
|
|
instance.BossesRespawnOnReload = mobStatePayload?.BossesRespawnOnReload ?? false;
|
|
instance.InitializeBossState(simulation.Mobs.Values.Count(m => m.Type == MobType.Boss), false);
|
|
|
|
// Restore defeated-boss progress from persisted mob state.
|
|
if (persistedMobStates != null && !instance.BossesRespawnOnReload)
|
|
{
|
|
foreach (var mobState in persistedMobStates.Where(m => !m.IsAlive))
|
|
{
|
|
bool isBoss = false;
|
|
|
|
if (simulation.Mobs.TryGetValue(mobState.Id, out var simMob))
|
|
{
|
|
isBoss = simMob.Type == MobType.Boss;
|
|
}
|
|
else if (_mobDefinitions.TryGetValue(mobState.DefinitionId, out var mobDef))
|
|
{
|
|
isBoss = mobDef.Type == MobType.Boss;
|
|
}
|
|
|
|
if (!isBoss) continue;
|
|
|
|
// If this boss existed in current simulation, keep it dead.
|
|
if (simulation.Mobs.TryGetValue(mobState.Id, out var killedBoss))
|
|
{
|
|
killedBoss.IsAlive = false;
|
|
killedBoss.Health = 0;
|
|
killedBoss.State = MobState.Dead;
|
|
}
|
|
else
|
|
{
|
|
// Preserve boss progress for runtime/admin-spawned bosses that are not in static layout.
|
|
instance.RegisterBossSpawn(mobState.Id);
|
|
}
|
|
|
|
instance.RegisterBossDefeat(mobState.Id);
|
|
}
|
|
}
|
|
|
|
// Backward compatibility: if persisted record only marks fully cleared, mirror that state.
|
|
if (persisted.BossKilled && !instance.AllBossesDefeated)
|
|
{
|
|
var allBossIds = simulation.Mobs.Values
|
|
.Where(m => m.Type == MobType.Boss)
|
|
.Select(m => m.Id)
|
|
.ToList();
|
|
instance.SetDefeatedBossMobIds(allBossIds);
|
|
|
|
foreach (var bossId in allBossIds)
|
|
{
|
|
if (simulation.Mobs.TryGetValue(bossId, out var boss))
|
|
{
|
|
boss.IsAlive = false;
|
|
boss.Health = 0;
|
|
boss.State = MobState.Dead;
|
|
}
|
|
}
|
|
}
|
|
|
|
_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)
|
|
{
|
|
var defeatedBossMobIds = !instance.BossesRespawnOnReload
|
|
? instance.GetDefeatedBossMobIdsSnapshot()
|
|
: new HashSet<int>();
|
|
|
|
if (instance.BossesRespawnOnReload)
|
|
{
|
|
instance.ResetBossProgress();
|
|
}
|
|
|
|
// 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, _abilityAnimationMappings);
|
|
|
|
// 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
|
|
if (!instance.BossesRespawnOnReload &&
|
|
mob.Value.Type == MobType.Boss &&
|
|
defeatedBossMobIds.Contains(mob.Key))
|
|
{
|
|
mob.Value.IsAlive = false;
|
|
mob.Value.Health = 0;
|
|
mob.Value.State = MobState.Dead;
|
|
}
|
|
|
|
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, bossesRespawn={BossesRespawn})",
|
|
instance.Simulation.Mobs.Count, instance.Id, mobsWithLoot.Count, instance.BossesRespawnOnReload);
|
|
}
|
|
|
|
/// <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.AllBossesDefeated) 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();
|
|
var mobStatePayload = new PersistedDungeonMobPayload
|
|
{
|
|
BossesRespawnOnReload = instance.BossesRespawnOnReload,
|
|
Mobs = mobStates
|
|
};
|
|
|
|
// 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.AllBossesDefeated;
|
|
existing.MobStateJson = System.Text.Json.JsonSerializer.Serialize(mobStatePayload);
|
|
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.AllBossesDefeated,
|
|
MobStateJson = System.Text.Json.JsonSerializer.Serialize(mobStatePayload),
|
|
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);
|
|
}
|
|
}
|
|
|
|
private PersistedDungeonMobPayload? DeserializePersistedMobPayload(string? mobStateJson)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(mobStateJson))
|
|
return null;
|
|
|
|
try
|
|
{
|
|
var payload = System.Text.Json.JsonSerializer.Deserialize<PersistedDungeonMobPayload>(mobStateJson);
|
|
if (payload != null)
|
|
{
|
|
payload.Mobs ??= new List<PersistedMobState>();
|
|
return payload;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
|
|
try
|
|
{
|
|
var legacyMobs = System.Text.Json.JsonSerializer.Deserialize<List<PersistedMobState>>(mobStateJson);
|
|
if (legacyMobs != null)
|
|
{
|
|
return new PersistedDungeonMobPayload
|
|
{
|
|
BossesRespawnOnReload = false,
|
|
Mobs = legacyMobs
|
|
};
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
#endregion
|
|
}
|