Files
systemrevivalserver/Game/Dungeon/DungeonGameHandler.cs
T
2025-12-06 11:20:32 -05:00

730 lines
25 KiB
C#

using System.Collections.Concurrent;
using System.Net.WebSockets;
using System.Text;
using System.Text.Json;
using DungeonCrawler.Data.Entities;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Server.Data;
namespace DungeonCrawler.Game.Dungeon;
/// <summary>
/// Manages WebSocket connections, dungeon instances, and game state
/// </summary>
public class DungeonGameHandler
{
private readonly IServiceScopeFactory _scopeFactory;
private readonly ILogger<DungeonGameHandler> _log;
private readonly JsonSerializerOptions _jsonOptions;
// Active connections
private readonly ConcurrentDictionary<ulong, PlayerConnection> _connections = new();
// Active dungeon instances
private readonly ConcurrentDictionary<Guid, DungeonInstance> _dungeons = new();
// Mob definitions cache
private Dictionary<int, MobDefinition> _mobDefinitions = new();
// Tick timer
private Timer? _tickTimer;
public DungeonGameHandler(IServiceScopeFactory scopeFactory, ILogger<DungeonGameHandler> log)
{
_scopeFactory = scopeFactory;
_log = log;
_jsonOptions = new JsonSerializerOptions
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
WriteIndented = false
};
}
public async Task StartAsync()
{
// Load mob definitions
await LoadMobDefinitionsAsync();
// Start tick loop (20 ticks per second)
_tickTimer = new Timer(TickAll, null, 0, 50);
_log.LogInformation("DungeonGameHandler started with {MobCount} mob definitions", _mobDefinitions.Count);
}
private async Task LoadMobDefinitionsAsync()
{
using var scope = _scopeFactory.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<GameDbContext>();
var mobs = await db.Set<MobDefinition>()
.Where(m => m.IsEnabled)
.ToListAsync();
if (mobs.Count == 0)
{
// Seed default mobs
var defaults = DefaultMobs.GetDefaultMobs();
db.Set<MobDefinition>().AddRange(defaults);
await db.SaveChangesAsync();
mobs = defaults;
_log.LogInformation("Seeded {Count} default mob definitions", defaults.Count);
}
_mobDefinitions = mobs.ToDictionary(m => m.Id);
}
public async Task HandleConnectionAsync(WebSocket ws, ulong accountId, Character character)
{
var connection = new PlayerConnection
{
AccountId = accountId,
CharacterId = character.Id,
CharacterName = character.Name,
WebSocket = ws,
Character = character
};
_connections[character.Id] = connection;
_log.LogInformation("Player {Name} connected (CharId: {CharId})", character.Name, character.Id);
// Send initial state (hub)
await SendAsync(connection, OpCodes.HUB_STATE, GetHubState(character));
try
{
var buffer = new byte[4096];
while (ws.State == WebSocketState.Open)
{
var result = await ws.ReceiveAsync(buffer, CancellationToken.None);
if (result.MessageType == WebSocketMessageType.Close)
break;
if (result.MessageType == WebSocketMessageType.Binary ||
result.MessageType == WebSocketMessageType.Text)
{
await HandleMessageAsync(connection, buffer, result.Count);
}
}
}
catch (WebSocketException ex)
{
_log.LogWarning("WebSocket error for {Name}: {Error}", character.Name, ex.Message);
}
finally
{
await HandleDisconnectAsync(connection);
}
}
private async Task HandleDisconnectAsync(PlayerConnection connection)
{
_connections.TryRemove(connection.CharacterId, out _);
// Remove from dungeon if in one
if (connection.CurrentDungeonId.HasValue)
{
if (_dungeons.TryGetValue(connection.CurrentDungeonId.Value, out var dungeon))
{
dungeon.Simulation.Players.TryRemove(connection.CharacterId, out var player);
// Save character state
if (player != null)
{
await SaveCharacterStateAsync(connection.Character, player, false);
}
}
}
_log.LogInformation("Player {Name} disconnected", connection.CharacterName);
}
private async Task HandleMessageAsync(PlayerConnection connection, byte[] buffer, int length)
{
try
{
// Parse message (expecting JSON with OpCode and Payload)
var json = Encoding.UTF8.GetString(buffer, 0, length);
var msg = JsonSerializer.Deserialize<ClientMessage>(json, _jsonOptions);
if (msg == null) return;
switch (msg.OpCode)
{
case OpCodes.STAT_ALLOCATE:
await HandleStatAllocate(connection, msg.Payload);
break;
case OpCodes.DUNGEON_ENTER:
await HandleDungeonEnter(connection, msg.Payload);
break;
case OpCodes.DUNGEON_LEAVE:
await HandleDungeonLeave(connection);
break;
case OpCodes.INPUT_MOVE:
HandleInputMove(connection, msg.Payload);
break;
case OpCodes.INPUT_ATTACK:
HandleInputAttack(connection, msg.Payload);
break;
case OpCodes.INPUT_PICKUP:
HandleInputPickup(connection, msg.Payload);
break;
case OpCodes.INPUT_CHEST:
HandleInputChest(connection, msg.Payload);
break;
case OpCodes.ESCAPE_START:
HandleEscapeStart(connection);
break;
case OpCodes.ESCAPE_CANCEL:
HandleEscapeCancel(connection);
break;
}
}
catch (Exception ex)
{
_log.LogError(ex, "Error handling message from {Name}", connection.CharacterName);
}
}
private async Task HandleStatAllocate(PlayerConnection connection, JsonElement payload)
{
var stat = payload.GetProperty("stat").GetString();
if (string.IsNullOrEmpty(stat)) return;
var character = connection.Character;
if (character.UnspentStatPoints <= 0) return;
switch (stat.ToLower())
{
case "strength": character.Strength++; break;
case "intelligence": character.Intelligence++; break;
case "wisdom": character.Wisdom++; break;
case "endurance": character.Endurance++; break;
case "dexterity": character.Dexterity++; break;
default: return;
}
character.UnspentStatPoints--;
// Save to database
using var scope = _scopeFactory.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<GameDbContext>();
db.Attach(character);
db.Entry(character).Property(c => c.Strength).IsModified = true;
db.Entry(character).Property(c => c.Intelligence).IsModified = true;
db.Entry(character).Property(c => c.Wisdom).IsModified = true;
db.Entry(character).Property(c => c.Endurance).IsModified = true;
db.Entry(character).Property(c => c.Dexterity).IsModified = true;
db.Entry(character).Property(c => c.UnspentStatPoints).IsModified = true;
await db.SaveChangesAsync();
await SendAsync(connection, OpCodes.HUB_STATE, GetHubState(character));
}
private async Task HandleDungeonEnter(PlayerConnection connection, JsonElement payload)
{
int tier = payload.TryGetProperty("tier", out var t) ? t.GetInt32() : 1;
tier = Math.Clamp(tier, 1, 10);
// Find or create dungeon
DungeonInstance? dungeon = null;
// Look for existing incomplete dungeon at this tier
foreach (var d in _dungeons.Values)
{
if (d.Tier == tier && d.Simulation.Phase == DungeonPhase.Active)
{
dungeon = d;
break;
}
}
if (dungeon == null)
{
// Create new dungeon
var id = Guid.NewGuid();
var seed = Random.Shared.Next();
var simulation = new DungeonSimulation(id, tier, seed, _mobDefinitions);
dungeon = new DungeonInstance
{
Id = id,
Tier = tier,
Seed = seed,
Simulation = simulation
};
_dungeons[id] = dungeon;
_log.LogInformation("Created new Tier {Tier} dungeon: {Id}", tier, id);
}
// Add player to dungeon
var character = connection.Character;
var stats = CharacterStats.GetCombatStats(character);
// Spawn at entrance
var spawnX = dungeon.Simulation.Layout.SpawnPoint.X * 32 + 16;
var spawnY = dungeon.Simulation.Layout.SpawnPoint.Y * 32 + 16;
var player = dungeon.Simulation.AddPlayer(
character.Id,
character.Name,
stats,
spawnX,
spawnY
);
connection.CurrentDungeonId = dungeon.Id;
connection.State = PlayerState.InDungeon;
// Send dungeon layout and initial state
await SendAsync(connection, OpCodes.DUNGEON_ENTER_RESULT, new
{
ok = true,
dungeonId = dungeon.Id,
tier = tier,
layout = new
{
width = dungeon.Simulation.Layout.Width,
height = dungeon.Simulation.Layout.Height,
tiles = dungeon.Simulation.Layout.SerializeTiles(),
spawn = new { x = spawnX, y = spawnY }
}
});
// Send initial game state
await SendDungeonStateAsync(connection, dungeon);
}
private async Task HandleDungeonLeave(PlayerConnection connection)
{
if (!connection.CurrentDungeonId.HasValue) return;
if (_dungeons.TryGetValue(connection.CurrentDungeonId.Value, out var dungeon))
{
if (dungeon.Simulation.Players.TryRemove(connection.CharacterId, out var player))
{
// Save character with XP and any surviving inventory
await SaveCharacterStateAsync(connection.Character, player, true);
}
}
connection.CurrentDungeonId = null;
connection.State = PlayerState.InHub;
await SendAsync(connection, OpCodes.HUB_STATE, GetHubState(connection.Character));
}
private void HandleInputMove(PlayerConnection connection, JsonElement payload)
{
if (!connection.CurrentDungeonId.HasValue) return;
if (!_dungeons.TryGetValue(connection.CurrentDungeonId.Value, out var dungeon)) return;
if (!dungeon.Simulation.Players.TryGetValue(connection.CharacterId, out var player)) return;
if (!player.IsAlive) return;
float dx = payload.TryGetProperty("dx", out var dxProp) ? dxProp.GetSingle() : 0;
float dy = payload.TryGetProperty("dy", out var dyProp) ? dyProp.GetSingle() : 0;
float aimAngle = payload.TryGetProperty("aimAngle", out var aProp) ? aProp.GetSingle() : 0;
player.InputDx = Math.Clamp(dx, -1f, 1f);
player.InputDy = Math.Clamp(dy, -1f, 1f);
player.AimAngle = aimAngle;
}
private void HandleInputAttack(PlayerConnection connection, JsonElement payload)
{
if (!connection.CurrentDungeonId.HasValue) return;
if (!_dungeons.TryGetValue(connection.CurrentDungeonId.Value, out var dungeon)) return;
float aimAngle = payload.TryGetProperty("aimAngle", out var aProp) ? aProp.GetSingle() : 0;
dungeon.Simulation.PlayerAttack(connection.CharacterId, aimAngle);
}
private void HandleInputPickup(PlayerConnection connection, JsonElement payload)
{
if (!connection.CurrentDungeonId.HasValue) return;
if (!_dungeons.TryGetValue(connection.CurrentDungeonId.Value, out var dungeon)) return;
int itemId = payload.TryGetProperty("itemId", out var idProp) ? idProp.GetInt32() : 0;
dungeon.Simulation.TryPickupItem(connection.CharacterId, itemId);
}
private void HandleInputChest(PlayerConnection connection, JsonElement payload)
{
if (!connection.CurrentDungeonId.HasValue) return;
if (!_dungeons.TryGetValue(connection.CurrentDungeonId.Value, out var dungeon)) return;
int chestId = payload.TryGetProperty("chestId", out var idProp) ? idProp.GetInt32() : 0;
dungeon.Simulation.TryOpenChest(connection.CharacterId, chestId);
}
private void HandleEscapeStart(PlayerConnection connection)
{
if (!connection.CurrentDungeonId.HasValue) return;
if (!_dungeons.TryGetValue(connection.CurrentDungeonId.Value, out var dungeon)) return;
if (!dungeon.Simulation.Players.TryGetValue(connection.CharacterId, out var player)) return;
// Can only escape if out of combat
if (!player.IsInCombat)
{
connection.IsEscaping = true;
connection.EscapeStartTick = dungeon.Simulation.CurrentTick;
}
}
private void HandleEscapeCancel(PlayerConnection connection)
{
connection.IsEscaping = false;
connection.EscapeStartTick = 0;
}
// Tick loop
private void TickAll(object? state)
{
foreach (var dungeon in _dungeons.Values)
{
try
{
TickDungeon(dungeon);
}
catch (Exception ex)
{
_log.LogError(ex, "Error ticking dungeon {Id}", dungeon.Id);
}
}
// Cleanup empty dungeons
var emptyDungeons = _dungeons.Values
.Where(d => d.Simulation.Players.IsEmpty &&
(DateTime.UtcNow - d.CreatedAt).TotalMinutes > 5)
.Select(d => d.Id)
.ToList();
foreach (var id in emptyDungeons)
{
_dungeons.TryRemove(id, out _);
_log.LogInformation("Removed empty dungeon {Id}", id);
}
}
private void TickDungeon(DungeonInstance dungeon)
{
var sim = dungeon.Simulation;
// Process player movement
foreach (var player in sim.Players.Values.Where(p => p.IsAlive))
{
if (player.InputDx != 0 || player.InputDy != 0)
{
float speed = player.Stats.MoveSpeed * DungeonSimulation.TickDelta;
// Normalize input
float len = MathF.Sqrt(player.InputDx * player.InputDx + player.InputDy * player.InputDy);
if (len > 0)
{
float dx = (player.InputDx / len) * speed;
float dy = (player.InputDy / len) * speed;
if (sim.CanMoveTo(player.X + dx, player.Y)) player.X += dx;
if (sim.CanMoveTo(player.X, player.Y + dy)) player.Y += dy;
}
}
player.Rotation = player.AimAngle;
}
// Run simulation tick
var tickResult = sim.Tick();
// Check escape teleports
foreach (var conn in _connections.Values.Where(c => c.CurrentDungeonId == dungeon.Id && c.IsEscaping))
{
if (sim.Players.TryGetValue(conn.CharacterId, out var player))
{
if (player.IsInCombat)
{
conn.IsEscaping = false;
conn.EscapeStartTick = 0;
_ = SendAsync(conn, OpCodes.ESCAPE_INTERRUPTED, new { reason = "combat" });
}
else
{
// Check if escape complete (2 minutes = 2400 ticks at 20 TPS)
long escapeTicks = sim.CurrentTick - conn.EscapeStartTick;
if (escapeTicks >= 2400)
{
// Successful escape!
conn.IsEscaping = false;
_ = HandleDungeonLeave(conn);
}
}
}
}
// Broadcast state to all players in dungeon
foreach (var conn in _connections.Values.Where(c => c.CurrentDungeonId == dungeon.Id))
{
_ = SendDungeonStateAsync(conn, dungeon, tickResult);
}
}
private async Task SendDungeonStateAsync(PlayerConnection connection, DungeonInstance dungeon, TickResult? tickResult = null)
{
var sim = dungeon.Simulation;
var state = new
{
tick = sim.CurrentTick,
phase = sim.Phase.ToString().ToLower(),
players = sim.Players.Values.Select(p => new
{
id = p.CharacterId,
name = p.Name,
x = p.X,
y = p.Y,
rotation = p.Rotation,
health = (int)p.Health,
maxHealth = (int)p.MaxHealth,
mana = (int)p.Mana,
maxMana = (int)p.MaxMana,
stamina = (int)p.Stamina,
maxStamina = (int)p.MaxStamina,
isAlive = p.IsAlive,
isInCombat = p.IsInCombat
}),
mobs = sim.Mobs.Values.Where(m => m.IsAlive).Select(m => new
{
id = m.Id,
name = m.Name,
x = m.X,
y = m.Y,
rotation = m.Rotation,
health = m.Health,
maxHealth = m.MaxHealth,
state = m.State.ToString().ToLower(),
spriteSheet = m.SpriteSheet,
spriteWidth = m.SpriteWidth,
spriteHeight = m.SpriteHeight,
tintColor = m.TintColor
}),
chests = sim.Chests.Values.Select(c => new
{
id = c.Id,
x = c.X,
y = c.Y,
opened = c.IsOpened
}),
droppedItems = sim.DroppedItems.Values.Select(i => new
{
id = i.Id,
itemId = i.ItemDefinitionId,
quantity = i.Quantity,
x = i.X,
y = i.Y
}),
events = tickResult == null ? null : new
{
damage = tickResult.DamageEvents.Select(e => new
{
sourceType = e.SourceType.ToString().ToLower(),
sourceId = e.SourceId,
targetType = e.TargetType.ToString().ToLower(),
targetId = e.TargetId,
damage = e.Damage
}),
deaths = tickResult.DeathEvents.Select(e => new
{
entityType = e.EntityType.ToString().ToLower(),
entityId = e.EntityId,
entityName = e.EntityName,
killerType = e.KillerType.ToString().ToLower(),
killerId = e.KillerId,
killerName = e.KillerName,
xp = e.XpReward
})
},
exitPosition = sim.Layout.ExitPosition != null ? new
{
x = sim.Layout.ExitPosition.Value.X * 32 + 16,
y = sim.Layout.ExitPosition.Value.Y * 32 + 16
} : null
};
await SendAsync(connection, OpCodes.DUNGEON_STATE, state);
}
private object GetHubState(Character character)
{
return new
{
character = new
{
id = character.Id,
name = character.Name,
level = character.Level,
xp = character.Experience,
xpNext = LevelSystem.GetXpForLevel(character.Level + 1),
unspentPoints = character.UnspentStatPoints,
strength = character.Strength,
intelligence = character.Intelligence,
wisdom = character.Wisdom,
endurance = character.Endurance,
dexterity = character.Dexterity,
maxHealth = CharacterStats.GetMaxHealth(character),
maxMana = CharacterStats.GetMaxMana(character),
maxStamina = CharacterStats.GetMaxStamina(character)
}
};
}
private async Task SaveCharacterStateAsync(Character character, PlayerInstance player, bool extracted)
{
using var scope = _scopeFactory.CreateScope();
var db = scope.ServiceProvider.GetRequiredService<GameDbContext>();
// Add XP earned
character.Experience += player.XpGained;
character.TotalKills += player.MobsKilled;
character.PlayersKilled += player.PlayersKilled;
if (extracted)
{
character.DungeonsCompleted++;
// Save current health/mana (they extracted alive)
character.CurrentHealth = (int)player.Health;
character.CurrentMana = (int)player.Mana;
}
else
{
character.TotalDeaths++;
// Reset to full on death
character.CurrentHealth = CharacterStats.GetMaxHealth(character);
character.CurrentMana = CharacterStats.GetMaxMana(character);
}
// Check for level up
while (character.Experience >= LevelSystem.GetTotalXpForLevel(character.Level + 1))
{
character.Level++;
character.UnspentStatPoints += 5;
}
character.LastPlayedAt = DateTime.UtcNow;
db.Attach(character);
db.Entry(character).State = EntityState.Modified;
await db.SaveChangesAsync();
_log.LogInformation("Saved character {Name}: Level {Level}, XP {Xp}",
character.Name, character.Level, character.Experience);
}
private async Task SendAsync(PlayerConnection connection, int opCode, object payload)
{
if (connection.WebSocket.State != WebSocketState.Open) return;
try
{
var msg = new { opCode, payload };
var json = JsonSerializer.Serialize(msg, _jsonOptions);
var bytes = Encoding.UTF8.GetBytes(json);
await connection.WebSocket.SendAsync(bytes, WebSocketMessageType.Text, true, CancellationToken.None);
}
catch (Exception ex)
{
_log.LogWarning("Failed to send to {Name}: {Error}", connection.CharacterName, ex.Message);
}
}
}
// Connection tracking
public class PlayerConnection
{
public ulong AccountId { get; set; }
public ulong CharacterId { get; set; }
public string CharacterName { get; set; } = "";
public WebSocket WebSocket { get; set; } = null!;
public Character Character { get; set; } = null!;
public PlayerState State { get; set; } = PlayerState.InHub;
public Guid? CurrentDungeonId { get; set; }
public bool IsEscaping { get; set; }
public long EscapeStartTick { get; set; }
}
public enum PlayerState
{
InHub,
InDungeon
}
public class DungeonInstance
{
public Guid Id { get; set; }
public int Tier { get; set; }
public int Seed { get; set; }
public DungeonSimulation Simulation { get; set; } = null!;
public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
}
// Messages
public class ClientMessage
{
public int OpCode { get; set; }
public JsonElement Payload { get; set; }
}
// OpCodes
public static class OpCodes
{
// Hub
public const int HUB_STATE = 200;
public const int STAT_ALLOCATE = 201;
// Dungeon
public const int DUNGEON_ENTER = 300;
public const int DUNGEON_ENTER_RESULT = 301;
public const int DUNGEON_STATE = 302;
public const int DUNGEON_LEAVE = 303;
// Input
public const int INPUT_MOVE = 400;
public const int INPUT_ATTACK = 401;
public const int INPUT_PICKUP = 402;
public const int INPUT_CHEST = 403;
// Escape
public const int ESCAPE_START = 450;
public const int ESCAPE_CANCEL = 451;
public const int ESCAPE_INTERRUPTED = 452;
public const int ESCAPE_SUCCESS = 453;
// Events
public const int EVENT_DAMAGE = 500;
public const int EVENT_DEATH = 501;
public const int EVENT_LEVELUP = 502;
public const int EVENT_LOOT = 503;
}