feat: block diagonal movement through double-blocks (AscensionGameDev#2111)

Author: pandinocoder

Intersect (Core)/Config/MapOptions.cs

@@ -20,6 +20,11 @@ public partial class MapOptions
         /// </summary>
         public bool DisablePlayerDropsInArenaMaps { get; set; } = false;
 
+        /// <summary>
+        /// Controls whether two block attributes placed diagonally block or not.
+        /// </summary>
+        public bool EnableCrossingDiagonalBlocks { get; set; }
+
         /// <summary>
         /// Indicates whether or not diagonal movement is enabled for entities within the map.
         /// </summary>

Intersect (Core)/Logging/Output/FileOutput.cs

@@ -111,14 +111,15 @@ private void InternalWrite(
             params object[] args
         )
         {
+            string? line = default;
             try
             {
                 if (LogLevel < logLevel)
                 {
                     return;
                 }
 
-                var line = configuration.Formatter.Format(
+                line = configuration.Formatter.Format(
                     configuration,
                     logLevel,
                     DateTime.UtcNow,
@@ -133,7 +134,11 @@ params object[] args
             }
             catch (Exception exceptionWhileWriting)
             {
-                Console.WriteLine(exceptionWhileWriting);
+                Console.WriteLine(
+                    "Exception occurred while writing to file:\n\t{0}\n\t{1}",
+                    line,
+                    exceptionWhileWriting
+                );
             }
         }
 

Intersect.Client/Entities/Player.cs

@@ -2223,6 +2223,8 @@ private void ProcessDirectionalInput()
             var dir = Dir;
             var moveDir = MoveDir;
 
+            var enableCrossingDiagonalBlocks = Options.Instance.MapOpts.EnableCrossingDiagonalBlocks;
+
             if (moveDir != Direction.None)
             {
                 List<Direction> possibleDirections = new(4) { moveDir };
@@ -2246,6 +2248,16 @@ private void ProcessDirectionalInput()
                         continue;
                     }
 
+                    if (!enableCrossingDiagonalBlocks && possibleDirection.IsDiagonal())
+                    {
+                        if (possibleDirection.GetComponentDirections()
+                            .Select(componentDirection => componentDirection.GetDeltaPoint() + position)
+                            .All(componentTarget => IsTileBlocked(componentTarget, Z, MapId, ref blockedBy) != -1))
+                        {
+                            continue;
+                        }
+                    }
+
                     position.X += delta.X;
                     position.Y += delta.Y;
                     IsMoving = true;

Intersect.Server.Core/Entities/Entity.cs

@@ -456,14 +456,41 @@ out EntityType entityType
                 return false;
             }
 
-            var mapController = MapController.Get(tileHelper.GetMapId());
+            if (!MapController.TryGet(tileHelper.GetMapId(), out var mapController))
+            {
+                blockerType = MovementBlockerType.OutOfBounds;
+                return false;
+            }
+
             int tileX = tileHelper.GetX();
             int tileY = tileHelper.GetY();
+
             if (IsBlockedByMapAttribute(direction, mapController.Attributes[tileX, tileY], out blockerType))
             {
                 return false;
             }
 
+            var enableCrossingDiagonalBlocks = Options.Instance.MapOpts.EnableCrossingDiagonalBlocks;
+            if (!enableCrossingDiagonalBlocks && direction.IsDiagonal())
+            {
+                MovementBlockerType componentBlockerType = default;
+                EntityType componentBlockingEntityType = default;
+
+                if (direction.GetComponentDirections()
+                    .All(
+                        componentDirection => !CanMoveInDirection(
+                            componentDirection,
+                            out componentBlockerType,
+                            out componentBlockingEntityType
+                        )
+                    ))
+                {
+                    blockerType = componentBlockerType;
+                    entityType = componentBlockingEntityType;
+                    return false;
+                }
+            }
+
             if (Passable)
             {
                 return !TryGetBlockerOnTile(