enhancement: smoother NPC and Critter random movement

Arufonsu · Arufonsu · commit 127d7f92da90 · 2025-12-29T20:22:45.000-03:00
This update refactors how both, NPCs and Critters randomly move around, replacing the boring single-tile shuffling-around with a more natural, range-based pathing system.
diff --git a/Intersect.Client.Core/Entities/Critter.cs b/Intersect.Client.Core/Entities/Critter.cs
@@ -15,7 +15,10 @@ namespace Intersect.Client.Entities;
 public partial class Critter : Entity
 {
     private readonly MapCritterAttribute mAttribute;
-    private long mLastMove = -1;
+    
+    // Critter's Movement
+    private long _lastMove = -1;
+    private byte _randomMoveRange;
 
     public Critter(MapInstance map, byte x, byte y, MapCritterAttribute att) : base(Guid.NewGuid(), null, EntityType.GlobalEntity)
     {
@@ -50,65 +53,65 @@ public Critter(MapInstance map, byte x, byte y, MapCritterAttribute att) : base(
 
     public override bool Update()
     {
-        if (base.Update())
+        if (!base.Update())
         {
-            if (mLastMove < Timing.Global.MillisecondsUtc)
-            {
-                switch (mAttribute.Movement)
-                {
-                    case 0: //Move Randomly
-                        MoveRandomly();
-                        break;
-                    case 1: //Turn?
-                        DirectionFacing = Randomization.NextDirection();
-                        break;
-
-                }
-
-                mLastMove = Timing.Global.MillisecondsUtc + mAttribute.Frequency + Globals.Random.Next((int)(mAttribute.Frequency * .5f));
-            }
+            return false;
+        }
 
+        // Only skip if we are NOT in the middle of a range-walk AND the frequency timer is active
+        if (_randomMoveRange <= 0 && _lastMove >= Timing.Global.MillisecondsUtc)
+        {
             return true;
         }
 
-        return false;
+        switch (mAttribute.Movement)
+        {
+            case 0: // Move Randomly
+                MoveRandomly();
+                break;
+            case 1: // Turn Randomly
+                DirectionFacing = Randomization.NextDirection();
+                // Set pause after turning
+                _lastMove = Timing.Global.MillisecondsUtc + mAttribute.Frequency + Globals.Random.Next((int)(mAttribute.Frequency * .5f));
+                break;
+        }
+
+        return true;
     }
 
     private void MoveRandomly()
     {
-        DirectionMoving = Randomization.NextDirection();
-        var tmpX = (sbyte)X;
-        var tmpY = (sbyte)Y;
-        IEntity? blockedBy = null;
-
+        // Don't start a new step if currently moving between tiles
         if (IsMoving || MoveTimer >= Timing.Global.MillisecondsUtc)
         {
             return;
         }
 
+        // No range left: pick a new direction and range
+        if (_randomMoveRange <= 0)
+        {
+            DirectionFacing = Randomization.NextDirection();
+            _randomMoveRange = (byte)Randomization.Next(1, 5);
+        }
+
         var deltaX = 0;
         var deltaY = 0;
-
-        switch (DirectionMoving)
+        switch (DirectionFacing)
         {
             case Direction.Up:
-                deltaX = 0;
                 deltaY = -1;
                 break;
 
             case Direction.Down:
-                deltaX = 0;
                 deltaY = 1;
                 break;
 
             case Direction.Left:
                 deltaX = -1;
-                deltaY = 0;
                 break;
 
             case Direction.Right:
                 deltaX = 1;
-                deltaY = 0;
                 break;
 
             case Direction.UpLeft:
@@ -132,59 +135,37 @@ private void MoveRandomly()
                 break;
         }
 
-        if (deltaX != 0 || deltaY != 0)
-        {
-            var newX = tmpX + deltaX;
-            var newY = tmpY + deltaY;
-            var isBlocked = -1 ==
-                            IsTileBlocked(
-                                new Point(newX, newY),
-                                Z,
-                                MapId,
-                                ref blockedBy,
-                                true,
-                                true,
-                                mAttribute.IgnoreNpcAvoids
-                            );
-            var playerOnTile = PlayerOnTile(MapId, newX, newY);
-
-            if (isBlocked && newX >= 0 && newX < Options.Instance.Map.MapWidth && newY >= 0 && newY < Options.Instance.Map.MapHeight &&
-                (!mAttribute.BlockPlayers || !playerOnTile))
-            {
-                tmpX += (sbyte)deltaX;
-                tmpY += (sbyte)deltaY;
-                IsMoving = true;
-                DirectionFacing = DirectionMoving;
+        var newX = (sbyte)X + deltaX;
+        var newY = (sbyte)Y + deltaY;
+        IEntity? blockedBy = null;
 
-                if (deltaX == 0)
-                {
-                    OffsetX = 0;
-                }
-                else
-                {
-                    OffsetX = deltaX > 0 ? -Options.Instance.Map.TileWidth : Options.Instance.Map.TileWidth;
-                }
+        // Boundary checks
+        var isBlocked = -1 == IsTileBlocked(new Point(newX, newY), Z, MapId, ref blockedBy, true, true, mAttribute.IgnoreNpcAvoids);
+        var playerOnTile = PlayerOnTile(MapId, newX, newY);
 
-                if (deltaY == 0)
-                {
-                    OffsetY = 0;
-                }
-                else
-                {
-                    OffsetY = deltaY > 0 ? -Options.Instance.Map.TileHeight : Options.Instance.Map.TileHeight;
-                }
-            }
-        }
-
-        if (IsMoving)
+        if (isBlocked && !playerOnTile && 
+            newX >= 0 && newX < Options.Instance.Map.MapWidth &&
+            newY >= 0 && newY < Options.Instance.Map.MapHeight)
         {
-            X = (byte)tmpX;
-            Y = (byte)tmpY;
+            X = (byte)newX;
+            Y = (byte)newY;
+            IsMoving = true;
+            OffsetX = deltaX == 0 ? 0 : (deltaX > 0 ? -Options.Instance.Map.TileWidth : Options.Instance.Map.TileWidth);
+            OffsetY = deltaY == 0 ? 0 : (deltaY > 0 ? -Options.Instance.Map.TileHeight : Options.Instance.Map.TileHeight);
             MoveTimer = Timing.Global.MillisecondsUtc + (long)GetMovementTime();
+            _randomMoveRange--;
+
+            // Critter's last step: set an idle pause timer
+            if (_randomMoveRange <= 0)
+            {
+                _lastMove = Timing.Global.MillisecondsUtc + mAttribute.Frequency + Globals.Random.Next((int)(mAttribute.Frequency * .5f));
+            }
         }
-        else if (DirectionMoving != DirectionFacing)
+        else
         {
-            DirectionFacing = DirectionMoving;
+            // Blocked by something: end range early and trigger pause
+            _randomMoveRange = 0;
+            _lastMove = Timing.Global.MillisecondsUtc + mAttribute.Frequency;
         }
     }
 
diff --git a/Intersect.Server.Core/Entities/Npc.cs b/Intersect.Server.Core/Entities/Npc.cs
@@ -159,6 +159,8 @@ public Npc(NPCDescriptor npcDescriptor, bool despawnable = false) : base()
     private bool IsStunnedOrSleeping => CachedStatuses.Any(PredicateStunnedOrSleeping);
 
     private bool IsUnableToCastSpells => CachedStatuses.Any(PredicateUnableToCastSpells);
+    
+    private bool IsUnableToMove => CachedStatuses.Any(PredicateUnableToMove);
 
     public override EntityType GetEntityType()
     {
@@ -538,6 +540,31 @@ private static bool PredicateUnableToCastSpells(Status status)
         }
     }
 
+    private static bool PredicateUnableToMove(Status status)
+    {
+        switch (status?.Type)
+        {
+            case SpellEffect.Stun:
+            case SpellEffect.Sleep:
+            case SpellEffect.Snare:
+                return true;
+            case SpellEffect.Silence:
+            case SpellEffect.None:
+            case SpellEffect.Blind:
+            case SpellEffect.Stealth:
+            case SpellEffect.Transform:
+            case SpellEffect.Cleanse:
+            case SpellEffect.Invulnerable:
+            case SpellEffect.Shield:
+            case SpellEffect.OnHit:
+            case SpellEffect.Taunt:
+            case null:
+                return false;
+            default:
+                throw new ArgumentOutOfRangeException();
+        }
+    }
+
     protected override bool IgnoresNpcAvoid => false;
 
     /// <inheritdoc />
@@ -1159,7 +1186,7 @@ public override void Update(long timeMs)
 
                     CheckForResetLocation();
 
-                    if (targetMap != Guid.Empty || LastRandomMove >= Timing.Global.Milliseconds || IsCasting)
+                    if (IsUnableToMove || targetMap != Guid.Empty || LastRandomMove >= Timing.Global.Milliseconds || IsCasting)
                     {
                         return;
                     }
@@ -1216,35 +1243,53 @@ public override void Update(long timeMs)
 
     private void MoveRandomly()
     {
+        // Pick new direction and range
         if (_randomMoveRange <= 0)
         {
             Dir = Randomization.NextDirection();
-            LastRandomMove = Timing.Global.Milliseconds + Randomization.Next(1000, 2000);
-            _randomMoveRange = (byte)Randomization.Next(0, Descriptor.SightRange + Randomization.Next(0, 3));
+            _randomMoveRange = (byte)Randomization.Next(0, Descriptor.SightRange + 1);
         }
-        else if (CanMoveInDirection(Dir))
+
+        // Mid-Path Deviation: 35% chance to change behavior while walking
+        if (_randomMoveRange > 1 && Randomization.Next(0, 100) < 35)
         {
-            foreach (var status in CachedStatuses)
+            if (Randomization.Next(0, 2) == 0)
             {
-                if (status.Type is SpellEffect.Stun or SpellEffect.Snare or SpellEffect.Sleep)
-                {
-                    return;
-                }
+                // 5% chance to "pivot": change direction but continue the current range
+                ChangeDir(Randomization.NextDirection());
+            }
+            else
+            {
+                // 5% chance to "stop and think": abandon path and trigger an idle pause
+                ChangeDir(Randomization.NextDirection());
+                _randomMoveRange = 0;
+                LastRandomMove = Timing.Global.Milliseconds + Randomization.Next(840, 1000);
+                return;
             }
+        }
 
+        // Check if the tile is clear before moving and if the NPC is able to move
+        if (CanMoveInDirection(Dir) && !IsUnableToMove)
+        {
             Move(Dir, null);
-            LastRandomMove = Timing.Global.Milliseconds + (long)GetMovementTime();
+            _randomMoveRange--;
 
-            if (_randomMoveRange <= Randomization.Next(0, 3))
+            // Pacing: Use walking speed for steps and idle pause for the end of a path
+            if (_randomMoveRange > 0)
             {
-                Dir = Randomization.NextDirection();
+                LastRandomMove = Timing.Global.Milliseconds + (long)GetMovementTime();
+            }
+            else
+            {
+                ChangeDir(Randomization.NextDirection());
+                LastRandomMove = Timing.Global.Milliseconds + Randomization.Next(420, 840);
             }
-
-            _randomMoveRange--;
         }
         else
         {
-            Dir = Randomization.NextDirection();
+            // Blocked by something: Clear range and pause briefly to re-evaluate
+            _randomMoveRange = 0;
+            LastRandomMove = Timing.Global.Milliseconds + 420;
         }
     }
 
