Character somewhat works when going up stairs

Hello

Recently I started making the character controller (completely from scratch) for my character. Basically all that the Player script does is sends a velocity to the Controller script every frame.

Controller code:

 using UnityEngine;
 using System.Collections;
 
 [RequireComponent (typeof (BoxCollider2D))]
 public class PlayerController : MonoBehaviour {
     
     private BoxCollider2D colliderRef;
     private RaycastOrigins raycastOrigins;
     public float skinWidth;
     public int rayCountX = 4, rayCountY = 4;
     private float spacingX, spacingY;
     public LayerMask layerMask;
     
     struct RaycastOrigins {
         public Vector2 bottomLeft, bottomRight;
         public Vector2 topLeft, topRight;
     }
     
     void Start () {
         colliderRef = GetComponent <BoxCollider2D> ();
         CalculateRaySpacing ();
     }
     
     void UpdateRaycastBounds () {
         Bounds bounds = colliderRef.bounds;
         raycastOrigins.bottomLeft = new Vector2 (bounds.min.x + skinWidth, bounds.min.y + skinWidth);
         raycastOrigins.bottomRight = new Vector2 (bounds.max.x - skinWidth, bounds.min.y + skinWidth);
         raycastOrigins.topLeft = new Vector2 (bounds.min.x + skinWidth, bounds.max.y - skinWidth);
         raycastOrigins.topRight = new Vector2 (bounds.max.x - skinWidth, bounds.max.y - skinWidth);
     }
     
     void CalculateRaySpacing () {
         Bounds bounds = colliderRef.bounds;
         rayCountX = Mathf.Clamp (rayCountX, 2, 8);
         rayCountY = Mathf.Clamp (rayCountY, 2, 16);
         spacingX = (bounds.size.x - skinWidth) / (rayCountY - 1);
         spacingY = (bounds.size.y - skinWidth) / (rayCountX - 1);
     }
     
     public void Move (Vector3 velocity) {
         UpdateRaycastBounds ();
         CollideVertically (ref velocity);
         CollideHorizontally (ref velocity);
         transform.Translate (velocity);
     }
     
     void CollideVertically (ref Vector3 velocity) {
         float directionY = Mathf.Sign (velocity.y);
         float rayLength = Mathf.Abs (velocity.y) + skinWidth;
         for (int r = 0; r < rayCountY; r ++)
         {
             Vector2 rayOrigin = Vector2.zero;
             if (directionY == -1)
             {
                 rayOrigin = raycastOrigins.bottomLeft;
             }    
             else if (directionY == 1)
             {
                 rayOrigin = raycastOrigins.topLeft;
             }
             rayOrigin += Vector2.right * (spacingX * r + velocity.x);
             RaycastHit2D hit = Physics2D.Raycast (rayOrigin, Vector2.up * directionY, rayLength, layerMask);
             if (hit == true)
             {
                 velocity.y = (hit.distance - skinWidth) * directionY;
                 rayLength = hit.distance;
             }
         }
         for (int r = 0; r < rayCountY; r ++)
         {
             Vector2 rayOrigin = raycastOrigins.bottomLeft;
             rayOrigin += Vector2.right * (spacingX * r + velocity.x);
             RaycastHit2D groundCheck = Physics2D.Raycast (rayOrigin, Vector2.down, skinWidth, layerMask);
             Debug.DrawRay (rayOrigin, Vector2.down * skinWidth, Color.blue, layerMask);
             if (groundCheck == true)
             {
                 WalkUpBlocks ();
             }
         }
     }
     
     void CollideHorizontally (ref Vector3 velocity) {
         float directionX = Mathf.Sign (velocity.x);
         float rayLength = Mathf.Abs (velocity.x) + skinWidth;
         for (int r = 0; r < rayCountX; r ++)
         {
             Vector2 rayOrigin = Vector2.zero;
             if (directionX == -1)
             {
                 rayOrigin = raycastOrigins.bottomLeft;
             }    
             else if (directionX == 1)
             {
                 rayOrigin = raycastOrigins.bottomRight;
             }
             rayOrigin += Vector2.up * (spacingY * r);
             RaycastHit2D hit = Physics2D.Raycast (rayOrigin, Vector2.right * directionX, rayLength, layerMask);
             if (hit == true)
             {
                 velocity.x = (hit.distance - skinWidth) * directionX;
                 rayLength = hit.distance;
             }
         }        
     }
     
     void WalkUpBlocks () {
         Bounds bounds = colliderRef.bounds;
         RaycastHit2D hitLeft = Physics2D.Raycast (new Vector2 (bounds.min.x - 0.125f, bounds.min.y + 0.875f), Vector2.down, 0.75f, layerMask);
         Debug.DrawRay (new Vector2 (bounds.min.x - 0.125f, bounds.min.y + 0.875f), Vector2.down * 0.75f, Color.red, layerMask);
         if (hitLeft == true)
         {
             if (hitLeft.distance == 0.75f)
             {
                 if (Input.GetKey (KeyCode.A))
                 {    
                     transform.position += Vector3.up / 4;
                     transform.position += Vector3.left / 4;    
                 }
             }
         }
         RaycastHit2D hitRight = Physics2D.Raycast (new Vector2 (bounds.max.x + 0.125f, bounds.min.y + 0.875f), Vector2.down, 0.75f, layerMask);
         Debug.DrawRay (new Vector2 (bounds.max.x + 0.125f, bounds.min.y + 0.875f), Vector2.down * 0.75f, Color.red, layerMask);
         if (hitRight == true)
         {
             if (hitRight.distance == 0.75f)
             {
                 if (Input.GetKey (KeyCode.D))
                 {    
                     transform.position += Vector3.up / 4;
                     transform.position += Vector3.right / 4;    
                 }
             }
         }
     }
 }

The blocks are scaled at 0.25 of a unit, and the player is 0.5x1 units.

The player only walks up blocks when going to the right, but it is sort of jittery, and the player also doesn't go up on left blocks.

I hope this can be sorted out. Cheers!