InfiniteAmmoInc · October 1, 2025 21:24 · Aug 6, 2018 · Aug 6, 2018 · Aug 6, 2018 · Aug 6, 2018
diff --git a/BoxMover.cs b/BoxMover.cs
@@ -91,7 +91,7 @@ private bool TrySlide(Vector3 direction, float distance, ref Vector3 newDirectio
         return false;
     }
 
-    bool BoxCastHit(Vector3 pos, Vector3 direction, float distance, out float castDistance)
+    private bool BoxCastHit(Vector3 pos, Vector3 direction, float distance, out float castDistance)
     {
         RaycastHit raycastHit;
         if (Physics.BoxCast(pos + boxOffset, boxScale * .5f, direction, out raycastHit, Quaternion.identity, distance,

diff --git a/BoxMover.cs b/BoxMover.cs
@@ -4,10 +4,10 @@
 
 public class BoxMover : MonoBehaviour
 {
-    public enum SlideType
+    public enum Slide
     {
         None,
-        Vertical,
+        Perpendicular,
     }
 
     public Vector3 boxScale, boxOffset;
@@ -20,25 +20,25 @@ void Awake()
         layerMask = LayerMask.GetMask("Default");
     }
 
-    public bool Move(Vector3 move, SlideType slideType = SlideType.None)
+    public bool Move(Vector3 move, Slide slide = Slide.None)
     {
         var distance = move.magnitude;
         var direction = move / distance;
         var pos = transform.position;
-        RaycastHit raycastHit;
-        if (Physics.BoxCast(pos + boxOffset, boxScale * .5f, direction, out raycastHit, Quaternion.identity, distance,
-            layerMask))
+        float castDistance;
+        if (BoxCastHit(pos, direction, distance, out castDistance))
         {
-            if (slideType == SlideType.None)
+            var bailPos = pos + (castDistance - shim) * direction;
+            if (slide == Slide.None)
             {
-                transform.position = pos + (raycastHit.distance - shim) * direction;
+                transform.position = bailPos;
                 return false;
             }
 
             var newDirection = Vector3.zero;
             if (!TrySlide(direction, distance, ref newDirection))
             {
-                transform.position = pos + (raycastHit.distance - shim) * direction;
+                transform.position = bailPos;
                 return false;
             }
 
@@ -51,14 +51,14 @@ public bool Move(Vector3 move, SlideType slideType = SlideType.None)
         return true;
     }
 
-    public bool MoveX(float xAmount, SlideType slideType = SlideType.None)
+    public bool MoveX(float xAmount, Slide slide = Slide.None)
     {
-        return Move(Vector3.right * xAmount, slideType);
+        return Move(Vector3.right * xAmount, slide);
     }
 
-    public bool MoveY(float yAmount)
+    public bool MoveY(float yAmount, Slide slide = Slide.None)
     {
-        return Move(Vector3.up * yAmount);
+        return Move(Vector3.up * yAmount, slide);
     }
 
     private bool TrySlide(Vector3 direction, float distance, ref Vector3 newDirection)
@@ -68,28 +68,44 @@ private bool TrySlide(Vector3 direction, float distance, ref Vector3 newDirectio
             maxAdjust = .5f;
         const float adjustStep = .1f;
         var pos = transform.position;
+        float castDistance;
         for (var adjust = adjustStep; adjust < maxAdjust; adjust += adjustStep)
         {
             if (direction == Vector3.right || direction == Vector3.left)
             {
                 newDirection = (direction + Vector3.up * adjust).normalized;
-                if (!Physics.BoxCast(pos + boxOffset, boxScale * .5f, newDirection, Quaternion.identity, distance, layerMask))
+                if (!BoxCastHit(pos, newDirection, distance, out castDistance))
                     return true;
             }
             else if (direction == Vector3.down)
             {
                 newDirection = (direction + Vector3.right * adjust).normalized;
-                if (!Physics.BoxCast(pos + boxOffset, boxScale * .5f, newDirection, Quaternion.identity, distance, layerMask))
+                if (!BoxCastHit(pos, newDirection, distance, out castDistance))
                     return true;
 
                 newDirection = (direction + Vector3.left * adjust).normalized;
-                if (!Physics.BoxCast(pos + boxOffset, boxScale * .5f, newDirection, Quaternion.identity, distance, layerMask))
+                if (!BoxCastHit(pos, newDirection, distance, out castDistance))
                     return true;
             }
         }
         return false;
     }
-
+
+    bool BoxCastHit(Vector3 pos, Vector3 direction, float distance, out float castDistance)
+    {
+        RaycastHit raycastHit;
+        if (Physics.BoxCast(pos + boxOffset, boxScale * .5f, direction, out raycastHit, Quaternion.identity, distance,
+            layerMask))
+        {
+            castDistance = raycastHit.distance;
+            return true;
+        }
+
+        castDistance = distance;
+        return false;
+    }
+
+
     void OnDrawGizmosSelected()
     {
         Gizmos.matrix = transform.localToWorldMatrix;

diff --git a/Entity.cs → BoxMover.cs b/Entity.cs → BoxMover.cs
@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using UnityEngine;
 
-public class Entity : MonoBehaviour
+public class BoxMover : MonoBehaviour
 {
     public enum SlideType
     {
@@ -13,14 +13,21 @@ public enum SlideType
     public Vector3 boxScale, boxOffset;
     private const float shim = .01f;
     private bool overlapping;
+    private int layerMask;
+
+    void Awake()
+    {
+        layerMask = LayerMask.GetMask("Default");
+    }
 
     public bool Move(Vector3 move, SlideType slideType = SlideType.None)
     {
         var distance = move.magnitude;
         var direction = move / distance;
         var pos = transform.position;
-        if (Physics.BoxCast(pos + boxOffset, boxScale * .5f, direction, out var raycastHit, Quaternion.identity, distance,
-            LayerMask.GetMask("Default")))
+        RaycastHit raycastHit;
+        if (Physics.BoxCast(pos + boxOffset, boxScale * .5f, direction, out raycastHit, Quaternion.identity, distance,
+            layerMask))
         {
             if (slideType == SlideType.None)
             {
@@ -29,7 +36,7 @@ public bool Move(Vector3 move, SlideType slideType = SlideType.None)
             }
 
             var newDirection = Vector3.zero;
-            if (!TrySlide(direction, distance, LayerMask.GetMask("Default"), ref newDirection))
+            if (!TrySlide(direction, distance, ref newDirection))
             {
                 transform.position = pos + (raycastHit.distance - shim) * direction;
                 return false;
@@ -54,42 +61,38 @@ public bool MoveY(float yAmount)
         return Move(Vector3.up * yAmount);
     }
 
-    private bool TrySlide(Vector3 direction, float distance, int layerMask, ref Vector3 newDirection)
+    private bool TrySlide(Vector3 direction, float distance, ref Vector3 newDirection)
     {
         var maxAdjust = 1.5f;
         if (direction == Vector3.down)
             maxAdjust = .5f;
         const float adjustStep = .1f;
-        RaycastHit raycastHit;
         var pos = transform.position;
         for (var adjust = adjustStep; adjust < maxAdjust; adjust += adjustStep)
         {
             if (direction == Vector3.right || direction == Vector3.left)
             {
                 newDirection = (direction + Vector3.up * adjust).normalized;
-                if (!Physics.BoxCast(pos + boxOffset, boxScale * .5f, newDirection, out raycastHit, Quaternion.identity, distance, layerMask))
+                if (!Physics.BoxCast(pos + boxOffset, boxScale * .5f, newDirection, Quaternion.identity, distance, layerMask))
                     return true;
             }
             else if (direction == Vector3.down)
             {
-
                 newDirection = (direction + Vector3.right * adjust).normalized;
-                if (!Physics.BoxCast(pos + boxOffset, boxScale * .5f, newDirection, out raycastHit, Quaternion.identity, distance, layerMask))
+                if (!Physics.BoxCast(pos + boxOffset, boxScale * .5f, newDirection, Quaternion.identity, distance, layerMask))
                     return true;
 
                 newDirection = (direction + Vector3.left * adjust).normalized;
-                if (!Physics.BoxCast(pos + boxOffset, boxScale * .5f, newDirection, out raycastHit, Quaternion.identity, distance, layerMask))
+                if (!Physics.BoxCast(pos + boxOffset, boxScale * .5f, newDirection, Quaternion.identity, distance, layerMask))
                     return true;
             }
         }
         return false;
     }
 
-
     void OnDrawGizmosSelected()
     {
         Gizmos.matrix = transform.localToWorldMatrix;
         Gizmos.DrawWireCube(boxOffset, boxScale);
     }
-
 }
diff --git a/Entity.cs b/Entity.cs
@@ -61,24 +61,24 @@ private bool TrySlide(Vector3 direction, float distance, int layerMask, ref Vect
             maxAdjust = .5f;
         const float adjustStep = .1f;
         RaycastHit raycastHit;
+        var pos = transform.position;
         for (var adjust = adjustStep; adjust < maxAdjust; adjust += adjustStep)
         {
             if (direction == Vector3.right || direction == Vector3.left)
             {
                 newDirection = (direction + Vector3.up * adjust).normalized;
-                if (!Physics.BoxCast(transform.TransformPoint(boxOffset), boxScale * .5f, newDirection, out raycastHit, transform.rotation, distance, layerMask))
+                if (!Physics.BoxCast(pos + boxOffset, boxScale * .5f, newDirection, out raycastHit, Quaternion.identity, distance, layerMask))
                     return true;
             }
             else if (direction == Vector3.down)
             {
 
                 newDirection = (direction + Vector3.right * adjust).normalized;
-                if (!Physics.BoxCast(transform.TransformPoint(boxOffset), boxScale * .5f, newDirection, out raycastHit, transform.rotation, distance, layerMask))
+                if (!Physics.BoxCast(pos + boxOffset, boxScale * .5f, newDirection, out raycastHit, Quaternion.identity, distance, layerMask))
                     return true;
 
                 newDirection = (direction + Vector3.left * adjust).normalized;
-                newDirection = newDirection.normalized;
-                if (!Physics.BoxCast(transform.TransformPoint(boxOffset), boxScale * .5f, newDirection, out raycastHit, transform.rotation, distance, layerMask))
+                if (!Physics.BoxCast(pos + boxOffset, boxScale * .5f, newDirection, out raycastHit, Quaternion.identity, distance, layerMask))
                     return true;
             }
         }

diff --git a/Entity.cs b/Entity.cs
@@ -0,0 +1,95 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class Entity : MonoBehaviour
+{
+    public enum SlideType
+    {
+        None,
+        Vertical,
+    }
+
+    public Vector3 boxScale, boxOffset;
+    private const float shim = .01f;
+    private bool overlapping;
+
+    public bool Move(Vector3 move, SlideType slideType = SlideType.None)
+    {
+        var distance = move.magnitude;
+        var direction = move / distance;
+        var pos = transform.position;
+        if (Physics.BoxCast(pos + boxOffset, boxScale * .5f, direction, out var raycastHit, Quaternion.identity, distance,
+            LayerMask.GetMask("Default")))
+        {
+            if (slideType == SlideType.None)
+            {
+                transform.position = pos + (raycastHit.distance - shim) * direction;
+                return false;
+            }
+
+            var newDirection = Vector3.zero;
+            if (!TrySlide(direction, distance, LayerMask.GetMask("Default"), ref newDirection))
+            {
+                transform.position = pos + (raycastHit.distance - shim) * direction;
+                return false;
+            }
+
+            transform.position = pos + newDirection * distance;
+            return true;
+        }
+
+        pos += move;
+        transform.position = pos;
+        return true;
+    }
+
+    public bool MoveX(float xAmount, SlideType slideType = SlideType.None)
+    {
+        return Move(Vector3.right * xAmount, slideType);
+    }
+
+    public bool MoveY(float yAmount)
+    {
+        return Move(Vector3.up * yAmount);
+    }
+
+    private bool TrySlide(Vector3 direction, float distance, int layerMask, ref Vector3 newDirection)
+    {
+        var maxAdjust = 1.5f;
+        if (direction == Vector3.down)
+            maxAdjust = .5f;
+        const float adjustStep = .1f;
+        RaycastHit raycastHit;
+        for (var adjust = adjustStep; adjust < maxAdjust; adjust += adjustStep)
+        {
+            if (direction == Vector3.right || direction == Vector3.left)
+            {
+                newDirection = (direction + Vector3.up * adjust).normalized;
+                if (!Physics.BoxCast(transform.TransformPoint(boxOffset), boxScale * .5f, newDirection, out raycastHit, transform.rotation, distance, layerMask))
+                    return true;
+            }
+            else if (direction == Vector3.down)
+            {
+
+                newDirection = (direction + Vector3.right * adjust).normalized;
+                if (!Physics.BoxCast(transform.TransformPoint(boxOffset), boxScale * .5f, newDirection, out raycastHit, transform.rotation, distance, layerMask))
+                    return true;
+
+                newDirection = (direction + Vector3.left * adjust).normalized;
+                newDirection = newDirection.normalized;
+                if (!Physics.BoxCast(transform.TransformPoint(boxOffset), boxScale * .5f, newDirection, out raycastHit, transform.rotation, distance, layerMask))
+                    return true;
+            }
+        }
+        return false;
+    }
+
+
+    void OnDrawGizmosSelected()
+    {
+        Gizmos.matrix = transform.localToWorldMatrix;
+        Gizmos.DrawWireCube(boxOffset, boxScale);
+    }
+
+}