838 lines
27 KiB
C#
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
|
|
}
|