Files
systemrevivalserver/Game/Dungeon/MobAI.cs
T

838 lines
27 KiB
C#

using DataServer.Data.Entities;
using DataServer.Data.Enums;
namespace GameServer.Dungeon;
/// <summary>
/// Handles mob AI behavior and decision making
/// </summary>
public static class MobAI
{
private static readonly Random _rng = new();
/// <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;
mob.StateTime = 0;
}
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.Tank:
UpdateTank(mob, sim, deltaTime);
break;
case MobBehavior.Assassin:
UpdateAssassin(mob, sim, deltaTime);
break;
case MobBehavior.Healer:
UpdateHealer(mob, sim, deltaTime);
break;
case MobBehavior.Patrol:
UpdatePatrol(mob, sim, deltaTime);
break;
case MobBehavior.Pack:
UpdatePack(mob, sim, deltaTime);
break;
case MobBehavior.Summoner:
UpdateSummoner(mob, sim, deltaTime);
break;
default:
UpdateAggressive(mob, sim, deltaTime);
break;
}
}
#region Core Behaviors
/// <summary>
/// Aggressive: Charges player on sight, melee attacks. Wanders when idle.
/// </summary>
private static void UpdateAggressive(MobInstance mob, DungeonSimulation sim, float deltaTime)
{
var target = FindNearestPlayer(mob, sim);
if (target == null)
{
// No target - wander or return to spawn area
UpdateIdleWander(mob, sim, 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, sim, deltaTime);
return;
}
mob.TargetId = target.CharacterId;
mob.UpdateFacingDirection(target.X, target.Y);
mob.CombatTime += deltaTime;
// In attack range?
if (distance <= mob.Stats.AttackRange)
{
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, sim);
}
}
/// <summary>
/// Defensive: Only attacks if player comes close to spawn. Wanders near spawn.
/// </summary>
private static void UpdateDefensive(MobInstance mob, DungeonSimulation sim, float deltaTime)
{
var target = FindNearestPlayer(mob, sim);
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, sim, 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;
MoveToward(mob, target.X, target.Y, mob.Stats.MoveSpeed * 0.7f * deltaTime, sim);
}
return;
}
}
// No threat - wander near spawn
mob.TargetId = null;
UpdateIdleWander(mob, sim, deltaTime, wanderRadius: 80f);
}
/// <summary>
/// Ranged: Keeps distance, fires projectiles
/// </summary>
private static void UpdateRanged(MobInstance mob, DungeonSimulation sim, float deltaTime)
{
var target = FindNearestPlayer(mob, sim);
if (target == null)
{
UpdateIdleWander(mob, sim, 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, sim, 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, sim);
}
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, sim);
}
else
{
// Good range, attack
mob.State = MobState.Attacking;
mob.CurrentAnimation = mob.GetDirectionalAnimation("attack");
}
}
/// <summary>
/// Skirmisher: Hit-and-run tactics
/// </summary>
private static void UpdateSkirmisher(MobInstance mob, DungeonSimulation sim, float deltaTime)
{
var target = FindNearestPlayer(mob, sim);
if (target == null)
{
UpdateIdleWander(mob, sim, 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, sim);
return;
}
if (distFromSpawn > mob.Stats.LeashRange)
{
ReturnToSpawn(mob, sim, 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, sim);
}
}
else
{
// Retreat phase
mob.State = MobState.Kiting;
mob.CurrentAnimation = mob.GetDirectionalAnimation("walk");
MoveAwayFrom(mob, target.X, target.Y, mob.Stats.MoveSpeed * deltaTime, sim);
}
}
/// <summary>
/// Tank: Slow but tough, always moves toward target
/// </summary>
private static void UpdateTank(MobInstance mob, DungeonSimulation sim, float deltaTime)
{
var target = FindNearestPlayer(mob, sim);
if (target == null)
{
UpdateIdleWander(mob, sim, 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, sim, 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");
// Tanks move at 60% speed
MoveToward(mob, target.X, target.Y, mob.Stats.MoveSpeed * 0.6f * deltaTime, sim);
}
}
/// <summary>
/// Assassin: Targets lowest HP player, moves fast
/// </summary>
private static void UpdateAssassin(MobInstance mob, DungeonSimulation sim, float deltaTime)
{
// Target lowest HP player
var target = sim.Players.Values
.Where(p => p.IsAlive)
.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, sim, 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, sim, 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, sim);
}
}
/// <summary>
/// Healer: Heals nearby mobs, stays back from combat
/// </summary>
private static void UpdateHealer(MobInstance mob, DungeonSimulation sim, float deltaTime)
{
// Check for injured allies first
var injuredAlly = sim.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, sim);
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, sim);
}
else if (distance <= mob.Stats.AttackRange)
{
mob.State = MobState.Attacking;
}
}
else
{
UpdateIdleWander(mob, sim, deltaTime);
}
}
/// <summary>
/// Patrol: Walks a path, alerts others when seeing players
/// </summary>
private static void UpdatePatrol(MobInstance mob, DungeonSimulation sim, float deltaTime)
{
var target = FindNearestPlayer(mob, sim);
if (target != null)
{
// Alert nearby mobs
if (!mob.HasCalledForHelp)
{
CallForHelp(mob, sim);
}
// Then fight like aggressive
UpdateAggressive(mob, sim, deltaTime);
}
else
{
mob.HasCalledForHelp = false;
// Patrol - wander in a larger area
UpdateIdleWander(mob, sim, deltaTime, wanderRadius: 150f);
}
}
/// <summary>
/// Pack: Calls nearby mobs when engaged
/// </summary>
private static void UpdatePack(MobInstance mob, DungeonSimulation sim, float deltaTime)
{
var target = FindNearestPlayer(mob, sim);
if (target != null)
{
if (!mob.HasCalledForHelp)
{
CallForHelp(mob, sim);
}
UpdateAggressive(mob, sim, deltaTime);
}
else
{
mob.HasCalledForHelp = false;
UpdateIdleWander(mob, sim, deltaTime);
}
}
/// <summary>
/// Summoner: Stays back and summons minions
/// </summary>
private static void UpdateSummoner(MobInstance mob, DungeonSimulation sim, float deltaTime)
{
var target = FindNearestPlayer(mob, sim);
if (target == null)
{
UpdateIdleWander(mob, sim, 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);
// Stay back
if (distance < preferredRange * 0.5f)
{
mob.State = MobState.Kiting;
MoveAwayFrom(mob, target.X, target.Y, mob.Stats.MoveSpeed * deltaTime, sim);
}
else
{
mob.State = MobState.Summoning;
mob.CurrentAnimation = mob.GetDirectionalAnimation("cast");
}
}
#endregion
#region Idle & Wander
/// <summary>
/// Wander around spawn area when no targets
/// </summary>
private static void UpdateIdleWander(MobInstance mob, DungeonSimulation sim, 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, sim, 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));
}
// 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 (sim.CanMoveTo(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, sim);
}
}
}
private static void ReturnToSpawn(MobInstance mob, DungeonSimulation sim, 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, sim);
// Heal while returning
if (mob.Health < mob.MaxHealth)
{
mob.Health = Math.Min(mob.MaxHealth, mob.Health + (int)(mob.MaxHealth * 0.05f * deltaTime));
}
}
}
private static void CallForHelp(MobInstance mob, DungeonSimulation sim)
{
mob.HasCalledForHelp = true;
float helpRadius = mob.Stats.AggroRange * 1.5f;
foreach (var ally in sim.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, DungeonSimulation sim)
{
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 (sim.CanMoveTo(newX, mob.Y))
{
mob.X = newX;
}
else
{
// Try sliding along wall
mob.StuckTime += 0.05f;
}
if (sim.CanMoveTo(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, sim);
mob.StuckTime = 0;
}
}
private static void MoveAwayFrom(MobInstance mob, float targetX, float targetY, float speed, DungeonSimulation sim)
{
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 (sim.CanMoveTo(newX, mob.Y))
{
mob.X = newX;
}
if (sim.CanMoveTo(mob.X, newY))
{
mob.Y = newY;
}
}
private static void TryUnstick(MobInstance mob, DungeonSimulation sim)
{
// Try moving in cardinal directions to get unstuck
float[] offsets = { 16, -16 };
foreach (float ox in offsets)
{
if (sim.CanMoveTo(mob.X + ox, mob.Y))
{
mob.X += ox * 0.5f;
return;
}
}
foreach (float oy in offsets)
{
if (sim.CanMoveTo(mob.X, mob.Y + oy))
{
mob.Y += oy * 0.5f;
return;
}
}
}
#endregion
#region Ability System
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);
}
#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;
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 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
}