Extremely Buggy rigidbody collisions [URGENT, DEADLINE 3 DAYS AGO!!!!!!! C#] Please answer. I can't figure it out! (As of 1 Answer)

Are you sure physics is definitely the way to go?

As good as physics is.. a custom movement behaviour/system may be better, it may be bit more work but you'd get exactly what you want.

I suggest this because your requirements seem simple and everything is to move perfectly aligned to a grid, IMO, I don't think a physics engine will give good results or at least it's very hard for those without deep understanding to get a physics engine to simulate a non-real environment to such restrictions as it will want to behave organically(?)

Off the top of my head I'd ... id suggest a master/manager class that has a 2d array of Tiles(This could be an enum or an object). This 2d array (aka map) describes the environment, so you'd have terrain definitions and moveable objects on the same map.

Let's say everything is set on the grid and gravity is currently downwards. In the downwards mode the manager would have to scan each column from the bottom going up (if gravity was upwards then it would scan from top to bottom). Whilst it scans it first tries to detect a moveable object. If it finds one it then searches in the line of gravity (downwards) to find the last available empty space. Once it has that it then swaps those tiles and tells that object in the scene to move to that position. The manager will then carry on from where it last detected a moveable object and process anymore moveable objects.

This would only need to be done when the gravity direction is changed. This won't support a diagonal direction of gravity mind.

With this you can then have an animation curve to show a cartoon bounce that will look cool and simulate the physics bounciness with complete control and stuff.

Example video of gameplay: https://youtu.be/xgY1A49NwhU

GridSampler.cs

     using System.Collections;
     using System.Collections.Generic;
     using UnityEngine;
     using UnityEngine.Tilemaps;

     public class GridSampler : MonoBehaviour
     {
       public BoundsInt myBounds;
       public Tilemap myTileMap;
       public bool[,] Map { get; private set; }
  
       public void LoadMap()
       {
         myTileMap = GetComponent<Tilemap>();

         if (myTileMap != null)
         {
           Map = new bool[myBounds.size.x, myBounds.size.y];
           int xIndex = 0;
           int yIndex = 0;
           for (int x = myBounds.xMin; x < myBounds.xMax; x++)
           {
             yIndex = 0;
             for (int y = myBounds.yMin; y < myBounds.yMax; y++)
             {
               var tile = myTileMap.GetTile(new Vector3Int(x, y, 0));

               if (tile != null)
               {
                 Map[xIndex, yIndex] = true;
               }
               yIndex++;
             }
             xIndex++;
           }
         }
       }
     }

GridManager.cs and other stuff

     using System;
     using System.Collections;
     using System.Collections.Generic;
     using UnityEngine;

     public enum TileType
     {
       Empty,
       World,
       Moveable
     }

     public class TileObject
     {
       public TileType tileType = TileType.Empty;
       public FallableObject obj;

       public TileObject(bool isWorld)
       {
         if (isWorld)
         {
           tileType = TileType.World;
         }
         else
         {
           tileType = TileType.Empty;
         }
       }
  
       internal void MoveTowards(Vector3 vector3)
       {
         if (tileType != TileType.Moveable)
         {
           Debug.LogError("None moveable tile type was told to move!!!");
         }

         if (obj != null)
         {
           obj.MoveTo(vector3);
         }
       }
     }

     public class GridManager : MonoBehaviour
     {
       public static GridManager grid { get; private set; }
       public GridSampler gridSampler;

       private TileObject[,] objectMap;

       private void Awake()
       {
         grid = this;

         if (gridSampler != null)
         {
           gridSampler.LoadMap();

           objectMap = new TileObject[gridSampler.Map.GetLength(0), gridSampler.Map.GetLength(1)];

           for (int x = 0; x < objectMap.GetLength(0); x++)
           {
             for (int y = 0; y < objectMap.GetLength(1); y++)
             {
               objectMap[x, y] = new TileObject(gridSampler.Map[x, y]);
             }
           }
         }
       }

       public Vector3? WorldObjectSpawned(FallableObject newObj, Vector3 initialPosition)
       {
         Vector3Int intPos = new Vector3Int(
           Mathf.FloorToInt(initialPosition.x),
           Mathf.FloorToInt(initialPosition.y),
           0);

         if (gridSampler.myBounds.Contains(intPos))
         {
           // need to convert world int space to local absolute space for array
           Vector3Int mapPos = intPos + gridSampler.myBounds.position + gridSampler.myBounds.size;
           Debug.Log(intPos);
           Debug.Log(mapPos);
           if (objectMap[mapPos.x, mapPos.y].tileType == TileType.Empty)
           {
             objectMap[mapPos.x, mapPos.y].tileType = TileType.Moveable;
             objectMap[mapPos.x, mapPos.y].obj = newObj;
             // Vector3 anchorOffset = gridSampler.myTileMap.tileAnchor;
             return intPos + gridSampler.myTileMap.tileAnchor;
           }
         }
         return null;
       }

       public Vector3 LocalToWorld(int x, int y)
       {
         Vector3 temp = Vector3.zero;
         temp += gridSampler.myBounds.position;
         temp += new Vector3(x, y);
         temp += gridSampler.myTileMap.tileAnchor;
         return temp;
       }
 
         // Update is called once per frame
         void Update ()
       {
         Vector2Int? direction = null;

         if (Input.GetKeyDown(KeyCode.LeftArrow))
         {
           direction = Vector2Int.left;
         }

         if (Input.GetKeyDown(KeyCode.RightArrow))
         {
           direction = Vector2Int.right;
         }

         if (Input.GetKeyDown(KeyCode.UpArrow))
         {
           direction = Vector2Int.up;
         }

         if (Input.GetKeyDown(KeyCode.DownArrow))
         {
           direction = Vector2Int.down;
         }

         if (direction.HasValue)
         {
           ApplyGravity(direction.Value);
         }
       }

       private void ApplyGravity(Vector2Int dir)
       {
         if (dir.y != 0) // Up or Down
         {
           ProcessColumns(dir.y > 0);
         }
         else
         {
           ProcessRows(dir.x > 0);
         }
       }

       private void ProcessColumns(bool up)
       {
         int start = up ? objectMap.GetLength(1) - 1 : 0;
         int target = up ? 0 : objectMap.GetLength(1) - 1;

         for (int x = 0; x < objectMap.GetLength(0); x++)
         {
           for (int y = start; up ? (y > target) : (y < target); y = (int)Mathf.MoveTowards(y, target, 1))
           {
             TileObject selectedObj = objectMap[x, y];

             if (selectedObj.tileType == TileType.Moveable)
             {
               bool spotFound = false;
               bool waitingForEnd = true;

               int _target = !up ? -1 : objectMap.GetLength(1);
               for (
                 int _y = (int)Mathf.MoveTowards(y, _target, 1); 
                 up ? (_y < _target) : (_y > _target); 
                 _y = (int)Mathf.MoveTowards(_y, _target, 1)
                 )
               {
                 TileObject scanningObj = objectMap[x, _y];

                 if (scanningObj.tileType == TileType.Empty)
                 {
                   if (!spotFound)
                   {
                     spotFound = true;
                   }
                 }

                 if (spotFound && (scanningObj.tileType == TileType.World || scanningObj.tileType == TileType.Moveable))
                 {
                   waitingForEnd = false;
                 }

                 if (!waitingForEnd)
                 {
                   _y = (int)Mathf.MoveTowards(_y, _target, -1);
                   selectedObj.MoveTowards(LocalToWorld(x, _y));
                   objectMap[x, _y] = selectedObj;
                   objectMap[x, y] = new TileObject(false);
                   break;
                 }
                 if (!spotFound)
                 {
                   break;
                 }
               }
             }
           }
         }
       }

       private void ProcessRows(bool right)
       {
         int start = right ? objectMap.GetLength(0) - 1 : 0;
         int target = right ? 0 : objectMap.GetLength(0) - 1;

         for (int x = start; right ? (x > target) : (x < target); x = (int)Mathf.MoveTowards(x, target, 1))
         {
           for (int y = 0; y < objectMap.GetLength(1); y++)
           {
             TileObject selectedObj = objectMap[x, y];
     
             if (selectedObj.tileType == TileType.Moveable)
             {
     
               bool spotFound = false;
               bool waitingForEnd = true;

               int _target = !right ? -1 : objectMap.GetLength(0);

               for (
                 int _x = (int)Mathf.MoveTowards(x, _target, 1);
                 right ? (_x < _target) : (_x > _target);
                 _x = (int)Mathf.MoveTowards(_x, _target, 1)
                 )
               {
                 TileObject scanningObj = objectMap[_x, y];

                 if (scanningObj.tileType == TileType.Empty)
                 {
                   if (!spotFound)
                   {
                     spotFound = true;
                   }
                 }

                 if (spotFound && (scanningObj.tileType == TileType.World || scanningObj.tileType == TileType.Moveable))
                 {
                   waitingForEnd = false;
                 }

                 if (!waitingForEnd)
                 {
                   _x = (int)Mathf.MoveTowards(_x, _target, -1);
                   selectedObj.MoveTowards(LocalToWorld(_x, y));
                   objectMap[_x, y] = selectedObj;
                   objectMap[x, y] = new TileObject(false);
                   break;
                 }

                 if (!spotFound)
                 {
                   break;
                 }
               }
             }
           }
         }
       }

       private void OnDrawGizmosSelected()
       {
         if (objectMap != null)
         {
           for (int x = 0; x < objectMap.GetLength(0); x++)
           {
             for (int y = 0; y < objectMap.GetLength(1); y++)
             {
               var tile = objectMap[x, y];

               if (tile.tileType == TileType.Moveable)
               {
                 Gizmos.DrawWireSphere(LocalToWorld(x,y), 0.4f);
               }
               else if(tile.tileType == TileType.World)
               {
                 var oldColor = Gizmos.color;
                 Gizmos.color = Color.red;
                 Gizmos.DrawWireSphere(LocalToWorld(x, y), 0.4f);
                 Gizmos.color = oldColor;

               }

               if (tile.obj != null)
               {
                 var oldColor = Gizmos.color;
                 Gizmos.color = Color.magenta;
                 Gizmos.DrawWireSphere(LocalToWorld(x, y), 0.4f);
                 Gizmos.color = oldColor;
               }
             }
           }
         }
       }
     }

FallableObject.cs

     using System;
     using System.Collections;
     using System.Collections.Generic;
     using UnityEngine;

     public class FallableObject : MonoBehaviour
     {
       Transform tran;
       public float acceleration;
       private float currentVelocity;
       Vector3? target;
       private void Awake()
       {
         tran = transform;
       }
       private void Start()
       {
         Vector3? newPosition = GridManager.grid.WorldObjectSpawned(this, transform.position);

         if (newPosition.HasValue)
         {
           transform.position = newPosition.Value;
         }
         else
         {
           gameObject.SetActive(false);
         }
       }
  
       internal void MoveTo(Vector3 vector3)
       {
         target = vector3;
         currentVelocity = 0;
       }

       private void Update()
       {
         if (target.HasValue)
         {
           currentVelocity += acceleration * Time.smoothDeltaTime;
           tran.position = Vector3.MoveTowards(tran.position, target.Value, currentVelocity * Time.smoothDeltaTime);

           if (tran.position == target.Value)
           {
             target = null;
           }
         }
       }
     }

Demo project Link: https://we.tl/pbN04iJpoE

You're using Vector3 and 3D physics and you have a 2D game you need to consider using Vector2 and 2D physics to fix the issue or check the coordinates but I believe the best way to go is Vector2 and materials to change the behaviour of your character