Files
systemrevivalserver/Game/World/WorldZoneSimulation.cs
T
2026-02-17 11:18:55 -05:00

772 lines
24 KiB
C#

using System.Collections.Concurrent;
using DataServer.Data.Entities;
using DataServer.Data.Enums;
using GameServer.Dungeon;
using GameServer.Shared;
namespace GameServer.World;
/// <summary>
/// Per-zone runtime simulation implementing ICombatEnvironment.
/// Manages mobs, NPCs, projectiles, hazard zones, and interactive objects for a single world zone.
/// Activated when a player enters, deactivated after all players leave (with grace period).
/// </summary>
public sealed class WorldZoneSimulation : ICombatEnvironment
{
private const float DeactivateGraceSeconds = 60f;
public string ZoneKey { get; }
public int RegionId { get; }
public int ZoneX { get; }
public int ZoneY { get; }
public int ZoneZ { get; }
public bool IsPvpEnabled { get; set; }
// ICombatEnvironment
public ConcurrentDictionary<int, MobInstance> Mobs { get; } = new();
public ConcurrentDictionary<int, ProjectileInstance> Projectiles { get; } = new();
public ConcurrentDictionary<int, HazardZone> HazardZones { get; } = new();
public ConcurrentDictionary<int, NpcInstance> Npcs { get; } = new();
// Player tracking (keyed by CharacterId)
public ConcurrentDictionary<ulong, WorldPlayerCombatState> Players { get; } = new();
// Events queue for broadcasting to clients
public ConcurrentQueue<WorldCombatEvent> PendingEvents { get; } = new();
// Spawn management
public WorldMobSpawnTracker? MobSpawnTracker { get; private set; }
// Tick state
public long CurrentTick { get; private set; }
public int Tier => 1; // World mobs use base tier
private float _tickDelta = 0.1f; // 10Hz = 100ms
// Lifecycle
public bool IsActive { get; private set; }
public int PlayerCount => Players.Count;
private float _emptyTimer;
private bool _initialized;
// ID allocators
private int _nextProjectileId = 1;
private int _nextHazardId = 1;
private readonly List<(int MobDefinitionId, float X, float Y, int Tier)> _pendingSummons = new();
// Reference to walkability checker
private readonly WorldChunkCache _cache;
private WorldChunkCache.CachedRegion? _cachedRegion;
public WorldZoneSimulation(string zoneKey, int regionId, int zoneX, int zoneY, int zoneZ, WorldChunkCache cache)
{
ZoneKey = zoneKey;
RegionId = regionId;
ZoneX = zoneX;
ZoneY = zoneY;
ZoneZ = zoneZ;
_cache = cache;
}
/// <summary>
/// Set the cached region reference for walkability checks.
/// Must be called before ticking.
/// </summary>
public void SetRegion(WorldChunkCache.CachedRegion region)
{
_cachedRegion = region;
}
/// <summary>
/// Initialize the zone simulation with mob/NPC spawn data.
/// Called once when the zone first activates.
/// </summary>
public void Initialize(
Dictionary<int, DungeonMobDefinition> mobDefinitions,
List<(WorldChunkMobSpawnData spawnData, int chunkWorldOffsetX, int chunkWorldOffsetY)> mobSpawns,
List<(NpcInstance npc, int chunkWorldOffsetX, int chunkWorldOffsetY)> npcSpawns)
{
if (_initialized) return;
// Initialize mob spawns
MobSpawnTracker = new WorldMobSpawnTracker(mobDefinitions);
foreach (var (spawnData, offsetX, offsetY) in mobSpawns)
{
var mobs = MobSpawnTracker.RegisterSpawnPoint(spawnData, offsetX, offsetY);
foreach (var mob in mobs)
{
Mobs[mob.Id] = mob;
}
}
// Initialize NPCs
foreach (var (npc, _, _) in npcSpawns)
{
Npcs[npc.Id] = npc;
}
_initialized = true;
IsActive = true;
_emptyTimer = 0;
}
/// <summary>
/// Add a player to this zone simulation.
/// </summary>
public void AddPlayer(WorldPlayerCombatState player)
{
Players[player.CharacterId] = player;
_emptyTimer = 0; // Reset deactivation timer
}
/// <summary>
/// Remove a player from this zone simulation.
/// </summary>
public void RemovePlayer(ulong characterId)
{
Players.TryRemove(characterId, out _);
}
/// <summary>
/// Main tick - called each frame by WorldHandler (10Hz).
/// Returns true if zone should remain active, false if ready to deactivate.
/// </summary>
public bool Tick(long tick, float deltaTime)
{
if (!IsActive || !_initialized) return false;
CurrentTick = tick;
_tickDelta = deltaTime;
// Check if zone should deactivate
if (Players.IsEmpty)
{
_emptyTimer += deltaTime;
if (_emptyTimer >= DeactivateGraceSeconds)
{
IsActive = false;
return false;
}
}
else
{
_emptyTimer = 0;
}
// Update player combat states
foreach (var player in Players.Values)
{
player.Update(deltaTime, tick);
}
// Update mob AI
foreach (var mob in Mobs.Values)
{
if (!mob.IsAlive) continue;
MobAI.UpdateMob(mob, this, deltaTime);
}
// Process mob attacks (mobs in Attacking state)
ProcessMobAttacks(deltaTime);
// Update projectiles
UpdateProjectiles(deltaTime);
// Update hazard zones
UpdateHazardZones(deltaTime);
// Update NPC wander
UpdateNpcs(deltaTime);
// Process respawns
if (MobSpawnTracker != null)
{
var newMobs = MobSpawnTracker.Update(deltaTime);
foreach (var mob in newMobs)
{
Mobs[mob.Id] = mob;
PendingEvents.Enqueue(new WorldCombatEvent
{
Type = WorldCombatEventType.MobSpawn,
TargetMobId = mob.Id,
X = mob.X,
Y = mob.Y,
MobData = SerializeMob(mob)
});
}
}
// Process pending summons
ProcessPendingSummons();
return true;
}
#region Mob Attacks
private void ProcessMobAttacks(float deltaTime)
{
foreach (var mob in Mobs.Values)
{
if (!mob.IsAlive || mob.State != MobState.Attacking) continue;
if (!mob.TargetId.HasValue) continue;
// Find available ability
float hpPercent = mob.HpPercent;
var ability = mob.Abilities
.Where(a => a.IsAvailable(hpPercent) && mob.Mana >= a.Definition.ManaCost)
.FirstOrDefault();
if (ability == null) continue;
// Check range
var target = GetPlayer(mob.TargetId.Value);
if (target == null) { mob.TargetId = null; continue; }
float distance = GetDistance(mob.X, mob.Y, target.X, target.Y);
float abilityRange = ability.Definition.Range > 0 ? ability.Definition.Range : mob.Stats.AttackRange;
if (distance > abilityRange) continue;
// Execute ability
ability.CooldownRemaining = ability.Definition.Cooldown;
mob.Mana -= ability.Definition.ManaCost;
switch (ability.Definition.AbilityType)
{
case MobAbilityType.MeleeAttack:
case MobAbilityType.Cleave:
case MobAbilityType.ConeAttack:
ProcessMobDamageAbility(mob, target, ability);
break;
case MobAbilityType.ProjectileSingle:
case MobAbilityType.ProjectileAoe:
SpawnMobProjectile(mob, target, ability);
break;
case MobAbilityType.GroundAoe:
ProcessMobAoeAbility(mob, target, ability);
break;
case MobAbilityType.SummonSingle:
case MobAbilityType.SummonBulk:
// Handled by MobAI casting system
break;
default:
// Fallback to basic damage
ProcessMobDamageAbility(mob, target, ability);
break;
}
}
}
private void ProcessMobDamageAbility(MobInstance mob, IPlayerTarget target, MobAbilityState ability)
{
if (target.IsInvulnerable || !target.IsAlive) return;
int baseDamage = ability.Definition.BaseDamage;
string damageType = !string.IsNullOrEmpty(ability.Definition.DamageTypeKey)
? ability.Definition.DamageTypeKey
: mob.Stats.DamageTypeKey;
var result = CombatCalculator.CalculateMobToPlayerDamage(
mob, target, damageType, baseDamage,
target.Resistances);
target.Health -= result.FinalDamage;
target.IsInCombat = true;
target.LastCombatTick = CurrentTick;
PendingEvents.Enqueue(new WorldCombatEvent
{
Type = WorldCombatEventType.Damage,
SourceMobId = mob.Id,
TargetPlayerId = target.CharacterId,
Damage = result.FinalDamage,
DamageTypeKey = damageType,
X = target.X,
Y = target.Y
});
if (target.Health <= 0)
{
target.Health = 0;
target.IsAlive = false;
PendingEvents.Enqueue(new WorldCombatEvent
{
Type = WorldCombatEventType.PlayerDeath,
TargetPlayerId = target.CharacterId,
X = target.X,
Y = target.Y
});
}
}
private void SpawnMobProjectile(MobInstance mob, IPlayerTarget target, MobAbilityState ability)
{
float dx = target.X - mob.X;
float dy = target.Y - mob.Y;
float dist = MathF.Sqrt(dx * dx + dy * dy);
if (dist < 1f) return;
float speed = ability.Definition.ProjectileSpeed > 0 ? ability.Definition.ProjectileSpeed : 300f;
int id = Interlocked.Increment(ref _nextProjectileId);
var proj = new ProjectileInstance
{
Id = id,
SpawnTick = CurrentTick,
SourceType = ProjectileSource.Mob,
SourceMobId = mob.Id,
X = mob.X,
Y = mob.Y,
VelocityX = (dx / dist) * speed,
VelocityY = (dy / dist) * speed,
Speed = speed,
TargetX = target.X,
TargetY = target.Y,
Damage = ability.Definition.BaseDamage,
DamageTypeKey = !string.IsNullOrEmpty(ability.Definition.DamageTypeKey)
? ability.Definition.DamageTypeKey : mob.Stats.DamageTypeKey,
AoeRadius = ability.Definition.AoeRadius,
MaxRange = ability.Definition.Range > 0 ? ability.Definition.Range * 1.5f : 500f,
SpriteKey = !string.IsNullOrEmpty(ability.Definition.ProjectileSprite)
? ability.Definition.ProjectileSprite : "projectile_default",
CanHitPlayers = true,
CanHitMobs = false
};
Projectiles[proj.Id] = proj;
}
private void ProcessMobAoeAbility(MobInstance mob, IPlayerTarget target, MobAbilityState ability)
{
float radius = ability.Definition.AoeRadius > 0 ? ability.Definition.AoeRadius : 64f;
float centerX = target.X;
float centerY = target.Y;
foreach (var player in Players.Values)
{
if (!player.IsAlive || player.IsInvulnerable) continue;
float dist = GetDistance(centerX, centerY, player.X, player.Y);
if (dist > radius) continue;
int baseDamage = ability.Definition.BaseDamage;
string damageType = !string.IsNullOrEmpty(ability.Definition.DamageTypeKey)
? ability.Definition.DamageTypeKey : mob.Stats.DamageTypeKey;
var result = CombatCalculator.CalculateMobToPlayerDamage(
mob, player, damageType, baseDamage,
player.Resistances);
player.Health -= result.FinalDamage;
player.IsInCombat = true;
player.LastCombatTick = CurrentTick;
PendingEvents.Enqueue(new WorldCombatEvent
{
Type = WorldCombatEventType.Damage,
SourceMobId = mob.Id,
TargetPlayerId = player.CharacterId,
Damage = result.FinalDamage,
DamageTypeKey = damageType,
X = player.X,
Y = player.Y
});
if (player.Health <= 0)
{
player.Health = 0;
player.IsAlive = false;
PendingEvents.Enqueue(new WorldCombatEvent
{
Type = WorldCombatEventType.PlayerDeath,
TargetPlayerId = player.CharacterId,
X = player.X,
Y = player.Y
});
}
}
}
#endregion
#region Projectiles
private void UpdateProjectiles(float deltaTime)
{
var expired = new List<int>();
foreach (var proj in Projectiles.Values)
{
proj.X += proj.VelocityX * deltaTime;
proj.Y += proj.VelocityY * deltaTime;
proj.DistanceTraveled += proj.Speed * deltaTime;
// Check max range
if (proj.DistanceTraveled >= proj.MaxRange)
{
expired.Add(proj.Id);
continue;
}
// Check wall collision
if (!CanActorMoveTo(proj.X, proj.Y))
{
expired.Add(proj.Id);
continue;
}
// Check hit on players (mob projectiles)
if (proj.CanHitPlayers && proj.SourceType == ProjectileSource.Mob)
{
foreach (var player in Players.Values)
{
if (!player.IsAlive || player.IsInvulnerable) continue;
float dist = GetDistance(proj.X, proj.Y, player.X, player.Y);
if (dist <= 20f) // Hit radius
{
ApplyProjectileDamageToPlayer(proj, player);
expired.Add(proj.Id);
break;
}
}
}
// Check hit on mobs (player projectiles)
if (proj.CanHitMobs && proj.SourceType == ProjectileSource.Player)
{
foreach (var mob in Mobs.Values)
{
if (!mob.IsAlive) continue;
float dist = GetDistance(proj.X, proj.Y, mob.X, mob.Y);
if (dist <= 20f)
{
ApplyProjectileDamageToMob(proj, mob);
expired.Add(proj.Id);
break;
}
}
}
}
foreach (var id in expired)
Projectiles.TryRemove(id, out _);
}
private void ApplyProjectileDamageToPlayer(ProjectileInstance proj, WorldPlayerCombatState player)
{
var result = CombatCalculator.CalculateMobToPlayerDamage(
Mobs.TryGetValue(proj.SourceMobId, out var srcMob) ? srcMob : null!,
player, proj.DamageTypeKey, proj.Damage, player.Resistances);
player.Health -= result.FinalDamage;
player.IsInCombat = true;
player.LastCombatTick = CurrentTick;
PendingEvents.Enqueue(new WorldCombatEvent
{
Type = WorldCombatEventType.Damage,
SourceMobId = proj.SourceMobId,
TargetPlayerId = player.CharacterId,
Damage = result.FinalDamage,
DamageTypeKey = proj.DamageTypeKey,
X = player.X,
Y = player.Y
});
if (player.Health <= 0)
{
player.Health = 0;
player.IsAlive = false;
PendingEvents.Enqueue(new WorldCombatEvent
{
Type = WorldCombatEventType.PlayerDeath,
TargetPlayerId = player.CharacterId,
X = player.X,
Y = player.Y
});
}
}
private void ApplyProjectileDamageToMob(ProjectileInstance proj, MobInstance mob)
{
var player = GetPlayer(proj.SourcePlayerId);
if (player == null) return;
var result = CombatCalculator.CalculatePlayerToMobDamage(
player, mob, proj.DamageTypeKey, proj.Damage);
mob.Health -= result.FinalDamage;
PendingEvents.Enqueue(new WorldCombatEvent
{
Type = WorldCombatEventType.Damage,
SourcePlayerId = proj.SourcePlayerId,
TargetMobId = mob.Id,
Damage = result.FinalDamage,
DamageTypeKey = proj.DamageTypeKey,
X = mob.X,
Y = mob.Y
});
if (mob.Health <= 0)
{
mob.Health = 0;
mob.IsAlive = false;
mob.State = MobState.Dead;
mob.CurrentAnimation = mob.GetDirectionalAnimation("death");
MobSpawnTracker?.OnMobDied(mob.Id);
PendingEvents.Enqueue(new WorldCombatEvent
{
Type = WorldCombatEventType.MobDeath,
TargetMobId = mob.Id,
SourcePlayerId = proj.SourcePlayerId,
X = mob.X,
Y = mob.Y
});
}
}
#endregion
#region Hazard Zones
private void UpdateHazardZones(float deltaTime)
{
var expired = new List<int>();
foreach (var hz in HazardZones.Values)
{
hz.Duration -= deltaTime;
if (hz.Duration <= 0)
{
expired.Add(hz.Id);
continue;
}
hz.NextTickIn -= deltaTime;
if (hz.NextTickIn <= 0)
{
hz.NextTickIn = hz.TickInterval;
// Damage players in radius
foreach (var player in Players.Values)
{
if (!player.IsAlive || player.IsInvulnerable) continue;
float dist = GetDistance(hz.X, hz.Y, player.X, player.Y);
if (dist > hz.Radius) continue;
var mob = Mobs.TryGetValue(hz.SourceMobId, out var m) ? m : null;
var result = CombatCalculator.CalculateMobToPlayerDamage(
mob!, player, hz.DamageTypeKey, hz.DamagePerTick, player.Resistances);
player.Health -= result.FinalDamage;
player.IsInCombat = true;
player.LastCombatTick = CurrentTick;
PendingEvents.Enqueue(new WorldCombatEvent
{
Type = WorldCombatEventType.Damage,
SourceMobId = hz.SourceMobId,
TargetPlayerId = player.CharacterId,
Damage = result.FinalDamage,
DamageTypeKey = hz.DamageTypeKey,
X = player.X,
Y = player.Y
});
if (player.Health <= 0)
{
player.Health = 0;
player.IsAlive = false;
PendingEvents.Enqueue(new WorldCombatEvent
{
Type = WorldCombatEventType.PlayerDeath,
TargetPlayerId = player.CharacterId,
X = player.X,
Y = player.Y
});
}
}
}
}
foreach (var id in expired)
HazardZones.TryRemove(id, out _);
}
#endregion
#region NPCs
private void UpdateNpcs(float deltaTime)
{
foreach (var npc in Npcs.Values)
{
if (!npc.IsAlive || !npc.CanWander) continue;
npc.NextWanderIn -= deltaTime;
if (npc.NextWanderIn <= 0)
{
npc.NextWanderIn = npc.WanderIntervalSeconds;
// Pick random point within wander radius
var rng = new Random();
float angle = (float)(rng.NextDouble() * Math.PI * 2);
float dist = (float)(rng.NextDouble() * npc.WanderRadiusPx);
float targetX = npc.SpawnX + MathF.Cos(angle) * dist;
float targetY = npc.SpawnY + MathF.Sin(angle) * dist;
if (CanActorMoveTo(targetX, targetY))
{
// Simple linear move (NPCs don't need full pathfinding)
float moveSpeed = 30f * deltaTime;
float dx = targetX - npc.X;
float dy = targetY - npc.Y;
float moveDist = MathF.Sqrt(dx * dx + dy * dy);
if (moveDist > 1f)
{
npc.X += (dx / moveDist) * Math.Min(moveSpeed, moveDist);
npc.Y += (dy / moveDist) * Math.Min(moveSpeed, moveDist);
}
}
}
}
}
#endregion
#region ICombatEnvironment Implementation
public bool CanActorMoveTo(float x, float y)
{
if (_cachedRegion == null) return true; // Fallback if region not set
return _cache.IsPositionWalkable(_cachedRegion, ZoneZ, x, y, false);
}
public IEnumerable<IPlayerTarget> GetAlivePlayers()
=> Players.Values.Where(p => p.IsAlive);
public IPlayerTarget? GetPlayer(ulong characterId)
=> Players.TryGetValue(characterId, out var p) ? p : null;
public void RequestMobSummon(int mobDefinitionId, float x, float y, int tier)
{
_pendingSummons.Add((mobDefinitionId, x, y, tier));
}
#endregion
#region Helpers
private void ProcessPendingSummons()
{
// World zone doesn't support dynamic mob summoning yet (would need mob definitions)
// Clear to prevent memory leak
_pendingSummons.Clear();
}
public object SerializeMob(MobInstance mob)
{
return new
{
id = mob.Id,
definitionId = mob.DefinitionId,
name = mob.Name,
x = mob.X,
y = mob.Y,
health = mob.Health,
maxHealth = mob.MaxHealth,
isAlive = mob.IsAlive,
state = mob.State.ToString(),
animation = mob.CurrentAnimation,
facing = mob.FacingDirection,
spriteConfig = mob.SpriteConfigJson,
tintColor = mob.TintColor,
scale = mob.Scale
};
}
public object SerializeNpc(NpcInstance npc)
{
return new
{
id = npc.Id,
definitionId = npc.DefinitionId,
name = npc.Name,
x = npc.X,
y = npc.Y,
health = npc.Health,
maxHealth = npc.MaxHealth,
isAlive = npc.IsAlive,
canShop = npc.CanShop,
hasDialog = npc.HasDialog,
animation = npc.CurrentAnimation,
spriteConfig = npc.SpriteConfigJson,
tintColor = npc.TintColor,
scale = npc.Scale
};
}
private static float GetDistance(float x1, float y1, float x2, float y2)
{
float dx = x2 - x1;
float dy = y2 - y1;
return MathF.Sqrt(dx * dx + dy * dy);
}
/// <summary>
/// Clean up zone state when deactivating
/// </summary>
public void Deactivate()
{
IsActive = false;
Mobs.Clear();
Npcs.Clear();
Projectiles.Clear();
HazardZones.Clear();
Players.Clear();
while (PendingEvents.TryDequeue(out _)) { }
_initialized = false;
}
#endregion
}
#region Combat Events
public enum WorldCombatEventType
{
Damage,
MobDeath,
PlayerDeath,
MobSpawn,
ProjectileSpawn,
AbilityUsed,
PlayerAttack,
PvpDamage
}
public sealed class WorldCombatEvent
{
public WorldCombatEventType Type { get; set; }
// Source
public int SourceMobId { get; set; }
public ulong SourcePlayerId { get; set; }
// Target
public int TargetMobId { get; set; }
public ulong TargetPlayerId { get; set; }
// Data
public int Damage { get; set; }
public string DamageTypeKey { get; set; } = "physical";
public float X { get; set; }
public float Y { get; set; }
// For mob spawn events
public object? MobData { get; set; }
}
#endregion