using DataServer.Data.Entities; using DataServer.Data.Enums; using GameServer.Shared; namespace GameServer.Dungeon; /// /// Handles mob AI behavior and decision making /// public static class MobAI { private static readonly Random _rng = new(); /// /// Main AI update - called each tick for each mob /// public static void UpdateMob(MobInstance mob, ICombatEnvironment env, float deltaTime) { if (!mob.IsAlive || mob.IsStunned) return; // Update cooldowns UpdateCooldowns(mob, deltaTime); // Update status effects UpdateStatusEffects(mob, env, deltaTime); // Check for phase transitions (for bosses) CheckPhaseTransition(mob); // Update state time mob.StateTime += deltaTime; // Handle casting if (mob.CastingAbility != null) { mob.CastTimeRemaining -= deltaTime; if (mob.CastTimeRemaining <= 0) { ExecuteAbility(mob, mob.CastingAbility, env); mob.CastingAbility = null; mob.State = MobState.Idle; mob.StateTime = 0; } return; } // Main behavior switch switch (mob.Behavior) { case MobBehavior.Aggressive: UpdateAggressive(mob, env, deltaTime); break; case MobBehavior.Defensive: UpdateDefensive(mob, env, deltaTime); break; case MobBehavior.Ranged: UpdateRanged(mob, env, deltaTime); break; case MobBehavior.Skirmisher: UpdateSkirmisher(mob, env, deltaTime); break; case MobBehavior.Tank: UpdateTank(mob, env, deltaTime); break; case MobBehavior.Assassin: UpdateAssassin(mob, env, deltaTime); break; case MobBehavior.Healer: UpdateHealer(mob, env, deltaTime); break; case MobBehavior.Patrol: UpdatePatrol(mob, env, deltaTime); break; case MobBehavior.Pack: UpdatePack(mob, env, deltaTime); break; case MobBehavior.Summoner: UpdateSummoner(mob, env, deltaTime); break; default: UpdateAggressive(mob, env, deltaTime); break; } } #region Core Behaviors /// /// Aggressive: Charges player on sight, melee attacks. Wanders when idle. /// private static void UpdateAggressive(MobInstance mob, ICombatEnvironment env, float deltaTime) { var target = FindNearestPlayer(mob, env); if (target == null) { // No target - wander or return to spawn area UpdateIdleWander(mob, env, deltaTime); return; } float distance = GetDistance(mob.X, mob.Y, target.X, target.Y); float distFromSpawn = GetDistance(mob.X, mob.Y, mob.SpawnX, mob.SpawnY); // Check leash range if (distFromSpawn > mob.Stats.LeashRange) { ReturnToSpawn(mob, env, deltaTime); return; } mob.TargetId = target.CharacterId; mob.UpdateFacingDirection(target.X, target.Y); mob.CombatTime += deltaTime; float engageRange = GetEngagementRange(mob); // In ability/attack range? if (distance <= engageRange) { mob.State = MobState.Attacking; mob.CurrentAnimation = mob.GetDirectionalAnimation("attack"); } else { // Chase mob.State = MobState.Chasing; mob.CurrentAnimation = mob.GetDirectionalAnimation("walk"); MoveToward(mob, target.X, target.Y, mob.Stats.MoveSpeed * deltaTime, env); } } /// /// Defensive: Only attacks if player comes close to spawn. Wanders near spawn. /// private static void UpdateDefensive(MobInstance mob, ICombatEnvironment env, float deltaTime) { var target = FindNearestPlayer(mob, env); float distFromSpawn = GetDistance(mob.X, mob.Y, mob.SpawnX, mob.SpawnY); if (target != null) { float targetDistFromSpawn = GetDistance(target.X, target.Y, mob.SpawnX, mob.SpawnY); float distance = GetDistance(mob.X, mob.Y, target.X, target.Y); // Only fight if target is close to our spawn area if (targetDistFromSpawn <= mob.Stats.AggroRange * 0.75f) { // Don't stray too far from spawn if (distFromSpawn > mob.Stats.LeashRange * 0.5f) { ReturnToSpawn(mob, env, deltaTime); return; } mob.TargetId = target.CharacterId; mob.UpdateFacingDirection(target.X, target.Y); float engageRange = GetEngagementRange(mob); if (distance <= engageRange) { mob.State = MobState.Attacking; mob.CurrentAnimation = mob.GetDirectionalAnimation("attack"); } else { mob.State = MobState.Chasing; MoveToward(mob, target.X, target.Y, mob.Stats.MoveSpeed * 0.7f * deltaTime, env); } return; } } // No threat - wander near spawn mob.TargetId = null; UpdateIdleWander(mob, env, deltaTime, wanderRadius: 80f); } /// /// Ranged: Keeps distance, fires projectiles /// private static void UpdateRanged(MobInstance mob, ICombatEnvironment env, float deltaTime) { var target = FindNearestPlayer(mob, env); if (target == null) { UpdateIdleWander(mob, env, deltaTime); return; } float distance = GetDistance(mob.X, mob.Y, target.X, target.Y); float distFromSpawn = GetDistance(mob.X, mob.Y, mob.SpawnX, mob.SpawnY); if (distFromSpawn > mob.Stats.LeashRange) { ReturnToSpawn(mob, env, deltaTime); return; } mob.TargetId = target.CharacterId; mob.UpdateFacingDirection(target.X, target.Y); mob.CombatTime += deltaTime; // Maintain preferred range float preferredRange = mob.PreferredRange > 0 ? mob.PreferredRange : 120f; if (distance < preferredRange * 0.5f) { // Too close, back up mob.State = MobState.Kiting; mob.CurrentAnimation = mob.GetDirectionalAnimation("walk"); MoveAwayFrom(mob, target.X, target.Y, mob.Stats.MoveSpeed * deltaTime, env); } else if (distance > preferredRange * 1.3f && distance <= mob.Stats.LeashRange) { // Too far, move closer mob.State = MobState.Chasing; mob.CurrentAnimation = mob.GetDirectionalAnimation("walk"); MoveToward(mob, target.X, target.Y, mob.Stats.MoveSpeed * deltaTime, env); } else { // Good range, attack mob.State = MobState.Attacking; mob.CurrentAnimation = mob.GetDirectionalAnimation("attack"); } } /// /// Skirmisher: Hit-and-run tactics /// private static void UpdateSkirmisher(MobInstance mob, ICombatEnvironment env, float deltaTime) { var target = FindNearestPlayer(mob, env); if (target == null) { UpdateIdleWander(mob, env, deltaTime); return; } float distance = GetDistance(mob.X, mob.Y, target.X, target.Y); float distFromSpawn = GetDistance(mob.X, mob.Y, mob.SpawnX, mob.SpawnY); // Check flee threshold if (mob.FleeThreshold > 0 && mob.HpPercent <= mob.FleeThreshold) { mob.State = MobState.Fleeing; mob.CurrentAnimation = mob.GetDirectionalAnimation("walk"); MoveAwayFrom(mob, target.X, target.Y, mob.Stats.MoveSpeed * 1.3f * deltaTime, env); return; } if (distFromSpawn > mob.Stats.LeashRange) { ReturnToSpawn(mob, env, deltaTime); return; } mob.TargetId = target.CharacterId; mob.UpdateFacingDirection(target.X, target.Y); // Cycle between attack (2s) and retreat (2s) float cycleTime = mob.StateTime % 4f; if (cycleTime < 2f) { // Attack phase if (distance <= mob.Stats.AttackRange) { mob.State = MobState.Attacking; mob.CurrentAnimation = mob.GetDirectionalAnimation("attack"); } else { mob.State = MobState.Chasing; MoveToward(mob, target.X, target.Y, mob.Stats.MoveSpeed * 1.2f * deltaTime, env); } } else { // Retreat phase mob.State = MobState.Kiting; mob.CurrentAnimation = mob.GetDirectionalAnimation("walk"); MoveAwayFrom(mob, target.X, target.Y, mob.Stats.MoveSpeed * deltaTime, env); } } /// /// Tank: Slow but tough, always moves toward target /// private static void UpdateTank(MobInstance mob, ICombatEnvironment env, float deltaTime) { var target = FindNearestPlayer(mob, env); if (target == null) { UpdateIdleWander(mob, env, deltaTime, wanderRadius: 50f); return; } float distance = GetDistance(mob.X, mob.Y, target.X, target.Y); float distFromSpawn = GetDistance(mob.X, mob.Y, mob.SpawnX, mob.SpawnY); if (distFromSpawn > mob.Stats.LeashRange) { ReturnToSpawn(mob, env, deltaTime); return; } mob.TargetId = target.CharacterId; mob.UpdateFacingDirection(target.X, target.Y); float engageRange = GetEngagementRange(mob); if (distance <= engageRange) { mob.State = MobState.Attacking; mob.CurrentAnimation = mob.GetDirectionalAnimation("attack"); } else { mob.State = MobState.Chasing; mob.CurrentAnimation = mob.GetDirectionalAnimation("walk"); // Tanks move at 60% speed MoveToward(mob, target.X, target.Y, mob.Stats.MoveSpeed * 0.6f * deltaTime, env); } } /// /// Assassin: Targets lowest HP player, moves fast /// private static void UpdateAssassin(MobInstance mob, ICombatEnvironment env, float deltaTime) { // Target lowest HP player var target = env.GetAlivePlayers() .Where(p => GetDistance(mob.X, mob.Y, p.X, p.Y) <= mob.Stats.AggroRange) .OrderBy(p => p.Health / p.MaxHealth) .FirstOrDefault(); if (target == null) { UpdateIdleWander(mob, env, deltaTime); return; } float distance = GetDistance(mob.X, mob.Y, target.X, target.Y); float distFromSpawn = GetDistance(mob.X, mob.Y, mob.SpawnX, mob.SpawnY); if (distFromSpawn > mob.Stats.LeashRange) { ReturnToSpawn(mob, env, deltaTime); return; } mob.TargetId = target.CharacterId; mob.UpdateFacingDirection(target.X, target.Y); if (distance <= mob.Stats.AttackRange) { mob.State = MobState.Attacking; mob.CurrentAnimation = mob.GetDirectionalAnimation("attack"); } else { mob.State = MobState.Chasing; mob.CurrentAnimation = mob.GetDirectionalAnimation("walk"); // Assassins move at 130% speed MoveToward(mob, target.X, target.Y, mob.Stats.MoveSpeed * 1.3f * deltaTime, env); } } /// /// Healer: Heals nearby mobs, stays back from combat /// private static void UpdateHealer(MobInstance mob, ICombatEnvironment env, float deltaTime) { // Check for injured allies first var injuredAlly = env.Mobs.Values .Where(m => m.IsAlive && m.Id != mob.Id) .Where(m => GetDistance(mob.X, mob.Y, m.X, m.Y) <= 150f) .Where(m => m.HpPercent < 0.7f) .OrderBy(m => m.HpPercent) .FirstOrDefault(); if (injuredAlly != null) { // Try to heal var healAbility = mob.Abilities .Where(a => a.Definition.AbilityType == MobAbilityType.HealAlly || a.Definition.AbilityType == MobAbilityType.HealAoe) .Where(a => a.IsAvailable(mob.HpPercent)) .FirstOrDefault(); if (healAbility != null) { mob.State = MobState.Healing; mob.UpdateFacingDirection(injuredAlly.X, injuredAlly.Y); mob.CurrentAnimation = mob.GetDirectionalAnimation("cast"); return; } } // Otherwise, stay back from combat var target = FindNearestPlayer(mob, env); if (target != null) { float distance = GetDistance(mob.X, mob.Y, target.X, target.Y); float preferredRange = mob.PreferredRange > 0 ? mob.PreferredRange : 150f; if (distance < preferredRange) { mob.State = MobState.Kiting; MoveAwayFrom(mob, target.X, target.Y, mob.Stats.MoveSpeed * deltaTime, env); } else if (distance <= mob.Stats.AttackRange) { mob.State = MobState.Attacking; } } else { UpdateIdleWander(mob, env, deltaTime); } } /// /// Patrol: Walks a path, alerts others when seeing players /// private static void UpdatePatrol(MobInstance mob, ICombatEnvironment env, float deltaTime) { var target = FindNearestPlayer(mob, env); if (target != null) { // Alert nearby mobs if (!mob.HasCalledForHelp) { CallForHelp(mob, env); } // Then fight like aggressive UpdateAggressive(mob, env, deltaTime); } else { mob.HasCalledForHelp = false; // Patrol - wander in a larger area UpdateIdleWander(mob, env, deltaTime, wanderRadius: 150f); } } /// /// Pack: Calls nearby mobs when engaged /// private static void UpdatePack(MobInstance mob, ICombatEnvironment env, float deltaTime) { var target = FindNearestPlayer(mob, env); if (target != null) { if (!mob.HasCalledForHelp) { CallForHelp(mob, env); } UpdateAggressive(mob, env, deltaTime); } else { mob.HasCalledForHelp = false; UpdateIdleWander(mob, env, deltaTime); } } /// /// Summoner: Stays back and summons minions /// private static void UpdateSummoner(MobInstance mob, ICombatEnvironment env, float deltaTime) { var target = FindNearestPlayer(mob, env); if (target == null) { UpdateIdleWander(mob, env, deltaTime); return; } float distance = GetDistance(mob.X, mob.Y, target.X, target.Y); float preferredRange = mob.PreferredRange > 0 ? mob.PreferredRange : 200f; mob.TargetId = target.CharacterId; mob.UpdateFacingDirection(target.X, target.Y); // Try to use summon ability float hpPercent = (float)mob.Health / mob.MaxHealth; var summonAbility = mob.Abilities .Where(a => a.Definition.AbilityType == MobAbilityType.SummonBulk || a.Definition.AbilityType == MobAbilityType.SummonSingle) .FirstOrDefault(a => a.IsAvailable(hpPercent) && mob.Mana >= a.Definition.ManaCost); if (summonAbility != null) { // Start casting mob.CastingAbility = summonAbility; mob.CastTimeRemaining = summonAbility.Definition.CastTime; mob.State = MobState.Summoning; mob.CurrentAnimation = mob.GetDirectionalAnimation("cast"); return; } // Stay back if (distance < preferredRange * 0.5f) { mob.State = MobState.Kiting; MoveAwayFrom(mob, target.X, target.Y, mob.Stats.MoveSpeed * deltaTime, env); } else { mob.State = MobState.Idle; mob.CurrentAnimation = mob.GetDirectionalAnimation("idle"); } } #endregion #region Idle & Wander /// /// Wander around spawn area when no targets /// private static void UpdateIdleWander(MobInstance mob, ICombatEnvironment env, float deltaTime, float wanderRadius = 0f) { // Use leash range if no wander radius specified if (wanderRadius <= 0) wanderRadius = Math.Max(mob.Stats.LeashRange * 0.6f, 100f); float distFromSpawn = GetDistance(mob.X, mob.Y, mob.SpawnX, mob.SpawnY); // Too far from spawn? Return first if (distFromSpawn > wanderRadius) { ReturnToSpawn(mob, env, deltaTime); return; } // Heal when idle/wandering if (mob.Health < mob.MaxHealth) { mob.Health = Math.Min(mob.MaxHealth, mob.Health + (int)(mob.MaxHealth * 0.02f * deltaTime)); } if (mob.Mana < mob.MaxMana) { mob.Mana = Math.Min(mob.MaxMana, mob.Mana + (int)(mob.MaxMana * 0.02f * deltaTime)); } // State machine for wandering // States: Idle (standing still) -> Moving to wander target -> Idle again if (mob.State == MobState.Idle || mob.State == MobState.Returning) { // Currently idling - wait a bit then pick a new target if (mob.StateTime >= 1.5f + (_rng.NextDouble() * 2f)) // 1.5-3.5 seconds of idling { // Time to pick a new wander target bool foundTarget = false; for (int attempts = 0; attempts < 8; attempts++) { float angle = (float)(_rng.NextDouble() * Math.PI * 2); float dist = 40f + (float)(_rng.NextDouble() * wanderRadius * 0.5f); float targetX = mob.SpawnX + MathF.Cos(angle) * dist; float targetY = mob.SpawnY + MathF.Sin(angle) * dist; // Check if target is walkable if (env.CanActorMoveTo(targetX, targetY)) { mob.WanderTargetX = targetX; mob.WanderTargetY = targetY; foundTarget = true; break; } } if (foundTarget) { // Start moving mob.State = MobState.Chasing; // Reuse chasing state for wander movement mob.StateTime = 0; mob.UpdateFacingDirection(mob.WanderTargetX, mob.WanderTargetY); mob.CurrentAnimation = mob.GetDirectionalAnimation("walk"); } // else stay idle and try again next cycle } // else keep idling, animation already set } else { // Currently moving toward wander target float distToTarget = GetDistance(mob.X, mob.Y, mob.WanderTargetX, mob.WanderTargetY); if (distToTarget < 20f || mob.StateTime > 10f) // Reached target or timeout { // Stop and idle mob.State = MobState.Idle; mob.StateTime = 0; mob.CurrentAnimation = mob.GetDirectionalAnimation("idle"); } else { // Keep moving toward target (30% speed for casual wandering) mob.UpdateFacingDirection(mob.WanderTargetX, mob.WanderTargetY); mob.CurrentAnimation = mob.GetDirectionalAnimation("walk"); MoveToward(mob, mob.WanderTargetX, mob.WanderTargetY, mob.Stats.MoveSpeed * 0.3f * deltaTime, env); } } } private static void ReturnToSpawn(MobInstance mob, ICombatEnvironment env, float deltaTime) { float dist = GetDistance(mob.X, mob.Y, mob.SpawnX, mob.SpawnY); if (dist < 20f) { // Arrived at spawn - reset to idle so wandering can start fresh mob.State = MobState.Idle; mob.TargetId = null; mob.CombatTime = 0; mob.StateTime = 0; mob.WanderTargetX = 0; // Clear so new target will be picked mob.WanderTargetY = 0; mob.CurrentAnimation = mob.GetDirectionalAnimation("idle"); } else { mob.State = MobState.Returning; mob.TargetId = null; mob.UpdateFacingDirection(mob.SpawnX, mob.SpawnY); mob.CurrentAnimation = mob.GetDirectionalAnimation("walk"); MoveToward(mob, mob.SpawnX, mob.SpawnY, mob.Stats.MoveSpeed * deltaTime, env); // Heal while returning if (mob.Health < mob.MaxHealth) { mob.Health = Math.Min(mob.MaxHealth, mob.Health + (int)(mob.MaxHealth * 0.05f * deltaTime)); } if (mob.Mana < mob.MaxMana) { mob.Mana = Math.Min(mob.MaxMana, mob.Mana + (int)(mob.MaxMana * 0.05f * deltaTime)); } } } private static void CallForHelp(MobInstance mob, ICombatEnvironment env) { mob.HasCalledForHelp = true; float helpRadius = mob.Stats.AggroRange * 1.5f; foreach (var ally in env.Mobs.Values.Where(m => m.IsAlive && m.Id != mob.Id)) { if (GetDistance(mob.X, mob.Y, ally.X, ally.Y) <= helpRadius) { // Alert ally to our target if (mob.TargetId.HasValue && ally.TargetId == null) { ally.TargetId = mob.TargetId; ally.State = MobState.Chasing; } } } } #endregion #region Movement with Collision private static void MoveToward(MobInstance mob, float targetX, float targetY, float speed, ICombatEnvironment env) { if (mob.IsRooted) return; float dx = targetX - mob.X; float dy = targetY - mob.Y; float dist = MathF.Sqrt(dx * dx + dy * dy); if (dist < 1f) return; // Update rotation to face movement direction mob.Rotation = MathF.Atan2(dy, dx); float moveX = (dx / dist) * speed; float moveY = (dy / dist) * speed; float newX = mob.X + moveX; float newY = mob.Y + moveY; // Check collision for each axis separately if (env.CanActorMoveTo(newX, mob.Y)) { mob.X = newX; } else { // Try sliding along wall mob.StuckTime += 0.05f; } if (env.CanActorMoveTo(mob.X, newY)) { mob.Y = newY; } else { mob.StuckTime += 0.05f; } // If stuck for too long, try to unstick if (mob.StuckTime > 1f) { TryUnstick(mob, env); mob.StuckTime = 0; } } private static void MoveAwayFrom(MobInstance mob, float targetX, float targetY, float speed, ICombatEnvironment env) { if (mob.IsRooted) return; float dx = mob.X - targetX; float dy = mob.Y - targetY; float dist = MathF.Sqrt(dx * dx + dy * dy); if (dist < 1f) return; float moveX = (dx / dist) * speed; float moveY = (dy / dist) * speed; float newX = mob.X + moveX; float newY = mob.Y + moveY; if (env.CanActorMoveTo(newX, mob.Y)) { mob.X = newX; } if (env.CanActorMoveTo(mob.X, newY)) { mob.Y = newY; } } private static void TryUnstick(MobInstance mob, ICombatEnvironment env) { // Try moving in cardinal directions to get unstuck float[] offsets = { 16, -16 }; foreach (float ox in offsets) { if (env.CanActorMoveTo(mob.X + ox, mob.Y)) { mob.X += ox * 0.5f; return; } } foreach (float oy in offsets) { if (env.CanActorMoveTo(mob.X, mob.Y + oy)) { mob.Y += oy * 0.5f; return; } } } #endregion #region Ability System private static void ExecuteAbility(MobInstance mob, MobAbilityState ability, ICombatEnvironment env) { ability.CooldownRemaining = ability.Definition.Cooldown; mob.Mana -= ability.Definition.ManaCost; mob.CurrentAnimation = mob.GetDirectionalAnimation(ability.Definition.AnimationKey); // Execute ability based on type switch (ability.Definition.AbilityType) { case MobAbilityType.SummonSingle: case MobAbilityType.SummonBulk: ExecuteSummon(mob, ability, env); break; // TODO: Implement other ability types default: Console.WriteLine($"[MobAI] Ability type {ability.Definition.AbilityType} not yet implemented for {mob.Name}"); break; } } private static void ExecuteSummon(MobInstance mob, MobAbilityState ability, ICombatEnvironment env) { if (!ability.Definition.SummonMobId.HasValue) { Console.WriteLine($"[MobAI] Summon ability {ability.Definition.Name} has no SummonMobId"); return; } int summonCount = ability.Definition.SummonCount > 0 ? ability.Definition.SummonCount : 1; int summonMobId = ability.Definition.SummonMobId.Value; float summonDistance = ability.Definition.DisplacementDistance > 0 ? ability.Definition.DisplacementDistance : 50f; Console.WriteLine($"[MobAI] {mob.Name} summoning {summonCount}x mob {summonMobId} at distance {summonDistance}"); // Spawn mobs around the summoner for (int i = 0; i < summonCount; i++) { // Calculate spawn position in a circle around summoner float angle = (float)(Math.PI * 2 * i / summonCount); float spawnX = mob.X + (float)Math.Cos(angle) * summonDistance; float spawnY = mob.Y + (float)Math.Sin(angle) * summonDistance; // Make sure spawn position is walkable if (!env.CanActorMoveTo(spawnX, spawnY)) { // Try closer spawnX = mob.X + (float)Math.Cos(angle) * (summonDistance * 0.5f); spawnY = mob.Y + (float)Math.Sin(angle) * (summonDistance * 0.5f); } // Request mob spawn (this will be handled by DungeonSimulation) env.RequestMobSummon(summonMobId, spawnX, spawnY, env.Tier); } } #endregion #region Helpers private static void UpdateCooldowns(MobInstance mob, float deltaTime) { foreach (var ability in mob.Abilities) { if (ability.CooldownRemaining > 0) ability.CooldownRemaining -= deltaTime; } } private static void UpdateStatusEffects(MobInstance mob, ICombatEnvironment env, float deltaTime) { var expired = new List(); foreach (var effect in mob.StatusEffects) { effect.Duration -= deltaTime; if (effect.DamagePerTick > 0) { effect.NextTickIn -= deltaTime; if (effect.NextTickIn <= 0) { mob.Health -= effect.DamagePerTick; effect.NextTickIn = effect.TickInterval; if (mob.Health <= 0) { mob.Health = 0; mob.IsAlive = false; mob.State = MobState.Dead; mob.TargetId = null; mob.CastingAbility = null; mob.CastTimeRemaining = 0; mob.CurrentAnimation = mob.GetDirectionalAnimation("death"); } } } if (effect.Duration <= 0) expired.Add(effect); } foreach (var e in expired) mob.StatusEffects.Remove(e); } private static void CheckPhaseTransition(MobInstance mob) { if (mob.Phases == null || mob.Phases.Count == 0) return; for (int i = mob.Phases.Count - 1; i >= 0; i--) { var phase = mob.Phases[i]; if (mob.HpPercent <= phase.HpThreshold && mob.CurrentPhase < i + 1) { mob.CurrentPhase = i + 1; mob.Behavior = phase.Behavior; mob.StateTime = 0; break; } } } private static IPlayerTarget? FindNearestPlayer(MobInstance mob, ICombatEnvironment env) { return env.GetAlivePlayers() .Where(p => GetDistance(mob.X, mob.Y, p.X, p.Y) <= mob.Stats.AggroRange) .OrderBy(p => GetDistance(mob.X, mob.Y, p.X, p.Y)) .FirstOrDefault(); } 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); } private static float GetEngagementRange(MobInstance mob) { float range = Math.Max(0f, mob.Stats.AttackRange); if (mob.Abilities.Count == 0) return range; foreach (var ability in mob.Abilities) { var def = ability.Definition; if (def == null || def.Range <= 0) continue; // Keep self/allied support skills from inflating engage distance. if (def.AbilityType is MobAbilityType.HealSelf or MobAbilityType.HealAlly or MobAbilityType.HealAoe or MobAbilityType.BuffSelf or MobAbilityType.BuffAllies or MobAbilityType.Shield or MobAbilityType.Enrage or MobAbilityType.PhaseChange or MobAbilityType.SummonSingle or MobAbilityType.SummonBulk) { continue; } range = Math.Max(range, def.Range); } return range; } #endregion }