正如所指出的，你的图像并不十分准确^^
无论如何，可能会有更有效和可扩展的方法，但这里是我将做的第一次迭代-平原直接前进：

• 有一个网格组件，它包含一个3x 3网格并处理所有的移位操作

此外，我还将通过此Grid组件来路由所有移动，以便轻松地将磁贴移动到一起（整行或整列）并保持整洁
我希望评论足够清楚

public class Grid : MonoBehaviour
 {
     // To make things simple for the demo I simply have 9 "GridElement" objects and place them later based on their index
     [SerializeField]
     private GridElement[] elements = new GridElement[9];

     // stores the current grid state
     private readonly GridElement[,] _grid = new GridElement[3, 3];

     private void Awake()
     {
         // go through the grid and assign initial elements to their positions and initialize them
         for (var column = 0; column < 3; column++)
         {
             for (var row = 0; row < 3; row++)
             {
                 _grid[column, row] = elements[row * 3 + column];

                 _grid[column, row].Initialize(this);
             }
         }

         RefreshIndices();
     }

     // Shifts the given column one step up with wrap around
     // => top element becomes new bottom
     public void ShiftColumnUp(int column)
     {
         var temp = _grid[column, 2];
         _grid[column, 2] = _grid[column, 1];
         _grid[column, 1] = _grid[column, 0];
         _grid[column, 0] = temp;

         RefreshIndices();
     }

     // Shifts the given column one step down with wrap around
     // => bottom element becomes new top
     public void ShiftColumnDown(int column)
     {
         var temp = _grid[column, 0];
         _grid[column, 0] = _grid[column, 1];
         _grid[column, 1] = _grid[column, 2];
         _grid[column, 2] = temp;

         RefreshIndices();
     }

     // Shifts the given row one step right with wrap around
     // => right element becomes new left
     public void ShiftRowRight(int row)
     {
         var temp = _grid[2, row];
         _grid[2, row] = _grid[1, row];
         _grid[1, row] = _grid[0, row];
         _grid[0, row] = temp;

         RefreshIndices();
     }

     // Shifts the given row one step left with wrap around
     // => left element becomes new right
     public void ShiftRowLeft(int row)
     {
         var temp = _grid[0, row];
         _grid[0, row] = _grid[1, row];
         _grid[1, row] = _grid[2, row];
         _grid[2, row] = temp;

         RefreshIndices();
     }

     // Iterates through all grid elements and updates their current row and column indices
     // and applies according positions
     public void RefreshIndices()
     {
         for (var column = 0; column < 3; column++)
         {
             for (var row = 0; row < 3; row++)
             {
                 _grid[column, row].UpdateIndices(row, column);
                 _grid[column, row].transform.position = new Vector3(column - 1, 0, row - 1);
             }
         }
     }

     // Called while dragging an element
     // Moves the entire row according to given delta (+/- 1)
     public void MoveRow(int targetRow, float delta)
     {
         for (var column = 0; column < 3; column++)
         {
             for (var row = 0; row < 3; row++)
             {
                 _grid[column, row].transform.position = new Vector3(column - 1 + (row == targetRow ? delta : 0), 0, row - 1);
             }
         }
     }

     // Called while dragging an element
     // Moves the entire column according to given delta (+/- 1)
     public void MoveColumn(int targetColumn, float delta)
     {
         for (var column = 0; column < 3; column++)
         {
             for (var row = 0; row < 3; row++)
             {
                 _grid[column, row].transform.position = new Vector3(column - 1, 0, row - 1 + (column == targetColumn ? delta : 0));
             }
         }
     }
 }

• 然后相应地在每个网格元素上有一个GridElement组件来处理拖动并通过Grid路由移动

public class GridElement : MonoBehaviour, IBeginDragHandler, IEndDragHandler, IDragHandler
 {
     // on indices within the grid so we can forward thm to method calls later
     private int _currentRow;
     private int _currentColumn;

     // a mathematical XZ plane we will use for the dragging input
     // you could as well just use physics raycasts 
     // but for now just wanted to keep it simple
     private static Plane _dragPlane = new Plane(Vector3.up, 1f);

     // reference to the grid to forward invoke methods
     private Grid _grid;

     // the world position where the current draggin was started
     private Vector3 _startDragPoint;

     // camera used to convert screenspace mouse position to ray
     [SerializeField]
     private Camera _camera;

     public void Initialize(Grid grid)
     {
         // assign the camera 
         if(!_camera)_camera = Camera.main;

         // store the grid reference to later forward the input calls
         _grid = grid;
     }

     // plain set the indices to the new values
     public void UpdateIndices(int currentRow, int currentColumn)
     {
         _currentRow = currentRow;
         _currentColumn = currentColumn;
     }

     // called by the EventSystem when starting to drag this object
     public void OnBeginDrag(PointerEventData eventData)
     {
         // get a ray for the current mouse position
         var ray = _camera.ScreenPointToRay(eventData.position);

         // shoot a raycast against the mathemtical XZ plane
         // You could as well use Physics.Raycast and get the exact hit point on the collider etc 
         // but this should be close enough especially in top-down views
         if (_dragPlane.Raycast(ray, out var distance))
         {
             // store the world space position of the cursor hit point
             _startDragPoint = ray.GetPoint(distance);
         }
     }

     // Called by the EventSystem while dragging this object
     public void OnDrag(PointerEventData eventData)
     {
         var ray = _camera.ScreenPointToRay(eventData.position);

         if (_dragPlane.Raycast(ray, out var distance))
         {
             // get the dragged delta against the start position
             var currentDragPoint = ray.GetPoint(distance);
             var delta = currentDragPoint - _startDragPoint;

             // we either only drag vertically or horizontally
             if (Mathf.Abs(delta.x) > Mathf.Abs(delta.z))
             {
                 // clamp the delta between -1 and 1
                 delta.x = Mathf.Clamp(delta.x, -1f, 1f);

                 // and tell the grid to move this entire row
                 _grid.MoveRow(_currentRow, delta.x);
             }
             else
             {
                 delta.z = Mathf.Clamp(delta.z, -1f, 1f);

                 // accordingly tell the grid to move this entire column
                 _grid.MoveColumn(_currentColumn,delta.z);
             }
         }
     }

     // Called by the EventSystem when stop dragging this object
     public void OnEndDrag(PointerEventData eventData)
     {
         var ray = _camera.ScreenPointToRay(eventData.position);

         if (_dragPlane.Raycast(ray, out var distance))
         {
             // as before get the final delta
             var currentDragPoint = ray.GetPoint(distance);
             var delta = currentDragPoint - _startDragPoint;

             // Check against a threashold - if simply went with more then the half of one step
             // and shift the grid into the according direction
             if (delta.x > 0.5f)
             {
                 _grid.ShiftRowRight(_currentRow);
             }else if (delta.x < -0.5f)
             {
                 _grid.ShiftRowLeft(_currentRow);
             }
             else if (delta.z > 0.5f)
             {
                 _grid.ShiftColumnUp(_currentColumn);
             }
             else if(delta.z < -0.5f)
             {
                 _grid.ShiftColumnDown(_currentColumn);
             }
             else
             {
                 // if no direction matched at all just make sure to reset the positions
                 _grid.RefreshIndices();
             }
         }
     }
 }

• 最后，为了使此设置正常工作，您需要
• 场景中任意位置的EventSystem组件
• Camera上的PhysicsRaycaster组件

小演示