Files
systemrevivalserver/Game/Dungeon/MobAI.cs
T
2025-12-27 11:09:09 -05:00

463 lines
15 KiB
C#

using DataServer.Data.Entities;
using DataServer.Data.Enums;
namespace Server.Game.Dungeon;
/// <summary>
/// Handles mob AI behavior and decision making
/// </summary>
public static class MobAI
{
/// <summary>
/// Main AI update - called each tick for each mob
/// </summary>
public static void UpdateMob(MobInstance mob, DungeonSimulation sim, float deltaTime)
{
if (!mob.IsAlive || mob.IsStunned) return;
// Update cooldowns
UpdateCooldowns(mob, deltaTime);
// Update status effects
UpdateStatusEffects(mob, sim, 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, sim);
mob.CastingAbility = null;
mob.State = MobState.Idle;
}
return;
}
// Main behavior switch
switch (mob.Behavior)
{
case MobBehavior.Aggressive:
UpdateAggressive(mob, sim, deltaTime);
break;
case MobBehavior.Defensive:
UpdateDefensive(mob, sim, deltaTime);
break;
case MobBehavior.Ranged:
UpdateRanged(mob, sim, deltaTime);
break;
case MobBehavior.Skirmisher:
UpdateSkirmisher(mob, sim, deltaTime);
break;
case MobBehavior.Summoner:
case MobBehavior.Tank:
case MobBehavior.Assassin:
case MobBehavior.Healer:
case MobBehavior.Patrol:
case MobBehavior.Pack:
// For now, fall back to aggressive behavior
// TODO: Implement specialized behaviors
UpdateAggressive(mob, sim, deltaTime);
break;
}
}
#region Core Behaviors
private static void UpdateAggressive(MobInstance mob, DungeonSimulation sim, float deltaTime)
{
var target = FindNearestPlayer(mob, sim);
if (target == null)
{
ReturnToSpawn(mob, sim, deltaTime);
return;
}
float distance = GetDistance(mob.X, mob.Y, target.X, target.Y);
mob.TargetId = target.CharacterId;
mob.UpdateFacingDirection(target.X, target.Y);
mob.CombatTime += deltaTime;
// Try to use abilities
var ability = SelectAbility(mob, distance);
if (ability != null && TryUseAbility(mob, ability, target, sim))
{
return;
}
// Chase and melee
if (distance <= mob.Stats.AttackRange)
{
mob.State = MobState.Attacking;
mob.CurrentAnimation = mob.GetDirectionalAnimation("attack");
}
else if (distance <= mob.Stats.LeashRange)
{
mob.State = MobState.Chasing;
mob.CurrentAnimation = mob.GetDirectionalAnimation("walk");
MoveToward(mob, target.X, target.Y, mob.Stats.MoveSpeed * mob.GetSpeedModifier() * deltaTime);
}
else
{
ReturnToSpawn(mob, sim, deltaTime);
}
}
private static void UpdateDefensive(MobInstance mob, DungeonSimulation sim, float deltaTime)
{
float distFromSpawn = GetDistance(mob.X, mob.Y, mob.SpawnX, mob.SpawnY);
var target = FindNearestPlayer(mob, sim);
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);
if (targetDistFromSpawn <= mob.Stats.AggroRange)
{
mob.TargetId = target.CharacterId;
mob.UpdateFacingDirection(target.X, target.Y);
if (distFromSpawn > mob.Stats.LeashRange * 0.5f)
{
ReturnToSpawn(mob, sim, deltaTime);
return;
}
var ability = SelectAbility(mob, distance);
if (ability != null && TryUseAbility(mob, ability, target, sim))
{
return;
}
if (distance <= mob.Stats.AttackRange)
{
mob.State = MobState.Attacking;
}
else
{
mob.State = MobState.Chasing;
MoveToward(mob, target.X, target.Y, mob.Stats.MoveSpeed * 0.7f * deltaTime);
}
}
else
{
mob.TargetId = null;
ReturnToSpawn(mob, sim, deltaTime);
}
}
else
{
ReturnToSpawn(mob, sim, deltaTime);
}
}
private static void UpdateRanged(MobInstance mob, DungeonSimulation sim, float deltaTime)
{
var target = FindNearestPlayer(mob, sim);
if (target == null)
{
ReturnToSpawn(mob, sim, deltaTime);
return;
}
float distance = GetDistance(mob.X, mob.Y, target.X, target.Y);
mob.TargetId = target.CharacterId;
mob.UpdateFacingDirection(target.X, target.Y);
mob.CombatTime += deltaTime;
var ability = SelectAbility(mob, distance, preferRanged: true);
if (ability != null && TryUseAbility(mob, ability, target, sim))
{
return;
}
// Maintain preferred range
if (distance < mob.PreferredRange * 0.6f)
{
mob.State = MobState.Kiting;
MoveAwayFrom(mob, target.X, target.Y, mob.Stats.MoveSpeed * deltaTime);
}
else if (distance > mob.PreferredRange * 1.2f && distance <= mob.Stats.LeashRange)
{
mob.State = MobState.Chasing;
MoveToward(mob, target.X, target.Y, mob.Stats.MoveSpeed * deltaTime);
}
else if (distance > mob.Stats.LeashRange)
{
ReturnToSpawn(mob, sim, deltaTime);
}
else
{
mob.State = MobState.Attacking;
}
}
private static void UpdateSkirmisher(MobInstance mob, DungeonSimulation sim, float deltaTime)
{
var target = FindNearestPlayer(mob, sim);
if (target == null)
{
ReturnToSpawn(mob, sim, deltaTime);
return;
}
float distance = GetDistance(mob.X, mob.Y, target.X, target.Y);
mob.TargetId = target.CharacterId;
mob.UpdateFacingDirection(target.X, target.Y);
if (mob.HpPercent <= mob.FleeThreshold && mob.FleeThreshold > 0)
{
mob.State = MobState.Fleeing;
MoveAwayFrom(mob, target.X, target.Y, mob.Stats.MoveSpeed * 1.2f * deltaTime);
return;
}
// Attack then retreat pattern
if (mob.State == MobState.Attacking && mob.StateTime < 2.0f)
{
var ability = SelectAbility(mob, distance);
if (ability != null && TryUseAbility(mob, ability, target, sim))
{
return;
}
if (distance <= mob.Stats.AttackRange)
{
mob.CurrentAnimation = mob.GetDirectionalAnimation("attack");
}
else
{
MoveToward(mob, target.X, target.Y, mob.Stats.MoveSpeed * deltaTime);
}
}
else if (mob.StateTime < 4.0f)
{
mob.State = MobState.Kiting;
MoveAwayFrom(mob, target.X, target.Y, mob.Stats.MoveSpeed * deltaTime);
}
else
{
mob.StateTime = 0;
mob.State = MobState.Attacking;
}
}
#endregion
#region Ability System
private static MobAbilityState? SelectAbility(MobInstance mob, float distance, bool preferRanged = false)
{
var available = mob.Abilities
.Where(a => a.IsAvailable(mob.HpPercent))
.Where(a => a.Phase == 0 || a.Phase == mob.CurrentPhase)
.Where(a => a.Definition.Range >= distance || a.Definition.Range == 0)
.ToList();
if (preferRanged)
{
available = available
.Where(a => a.Definition.AbilityType == MobAbilityType.ProjectileSingle ||
a.Definition.AbilityType == MobAbilityType.ProjectileAoe)
.ToList();
}
if (available.Count == 0) return null;
// Weight by priority
var weighted = available.OrderByDescending(a => a.Priority).ToList();
// Add some randomness
if (weighted.Count > 1 && Random.Shared.NextDouble() < 0.3)
{
return weighted[Random.Shared.Next(weighted.Count)];
}
return weighted.FirstOrDefault();
}
private static bool TryUseAbility(MobInstance mob, MobAbilityState ability, PlayerInstance target, DungeonSimulation sim)
{
if (!ability.IsAvailable(mob.HpPercent)) return false;
if (mob.IsSilenced && ability.Definition.CastTime > 0) return false;
float distance = GetDistance(mob.X, mob.Y, target.X, target.Y);
if (ability.Definition.Range > 0 && distance > ability.Definition.Range) return false;
// Check mana cost
if (ability.Definition.ManaCost > mob.Mana) return false;
// Start casting
if (ability.Definition.CastTime > 0)
{
mob.CastingAbility = ability;
mob.CastTimeRemaining = ability.Definition.CastTime;
mob.State = MobState.Casting;
mob.CurrentAnimation = mob.GetDirectionalAnimation(ability.Definition.AnimationKey);
return true;
}
// Instant ability
ExecuteAbility(mob, ability, sim);
return true;
}
private static void ExecuteAbility(MobInstance mob, MobAbilityState ability, DungeonSimulation sim)
{
ability.CooldownRemaining = ability.Definition.Cooldown;
mob.Mana -= ability.Definition.ManaCost;
mob.CurrentAnimation = mob.GetDirectionalAnimation(ability.Definition.AnimationKey);
// TODO: Queue the ability effect for the simulation to process
// For now, abilities are tracked but effects need to be wired up in DungeonSimulation
// The simulation will need to check mob.CastingAbility and process effects there
}
#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, DungeonSimulation sim, float deltaTime)
{
var expired = new List<MobStatusEffect>();
foreach (var effect in mob.StatusEffects)
{
effect.Duration -= deltaTime;
// Handle DOT
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;
}
}
}
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 PlayerInstance? FindNearestPlayer(MobInstance mob, DungeonSimulation sim)
{
return sim.Players.Values
.Where(p => p.IsAlive)
.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 void ReturnToSpawn(MobInstance mob, DungeonSimulation sim, float deltaTime)
{
float dist = GetDistance(mob.X, mob.Y, mob.SpawnX, mob.SpawnY);
if (dist < 10f)
{
mob.State = MobState.Idle;
mob.TargetId = null;
mob.CombatTime = 0;
mob.CurrentAnimation = mob.GetDirectionalAnimation("idle");
// Heal when returning
if (mob.Health < mob.MaxHealth)
{
mob.Health = Math.Min(mob.MaxHealth, mob.Health + (int)(mob.MaxHealth * 0.1f * deltaTime));
}
}
else
{
mob.State = MobState.Returning;
mob.UpdateFacingDirection(mob.SpawnX, mob.SpawnY);
mob.CurrentAnimation = mob.GetDirectionalAnimation("walk");
MoveToward(mob, mob.SpawnX, mob.SpawnY, mob.Stats.MoveSpeed * deltaTime);
}
}
private static void MoveToward(MobInstance mob, float targetX, float targetY, float speed)
{
if (mob.IsRooted) return;
float dx = targetX - mob.X;
float dy = targetY - mob.Y;
float dist = MathF.Sqrt(dx * dx + dy * dy);
if (dist > 0)
{
mob.X += (dx / dist) * speed;
mob.Y += (dy / dist) * speed;
}
}
private static void MoveAwayFrom(MobInstance mob, float targetX, float targetY, float speed)
{
if (mob.IsRooted) return;
float dx = mob.X - targetX;
float dy = mob.Y - targetY;
float dist = MathF.Sqrt(dx * dx + dy * dy);
if (dist > 0)
{
mob.X += (dx / dist) * speed;
mob.Y += (dy / dist) * speed;
}
}
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);
}
#endregion
}