463 lines
15 KiB
C#
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
|
|
}
|