Rotating a gameobject using integers

Hello @HyperGamer87 the reason you're experiencing this, is due to the fact that your cube is rotating around it's local axis, that plus the fact that you're rotating your local axis, will give you some weird rotations. this can be solved by using the Quaternion.AngleAxis()

I have already created a class from scratch and changed a bunch of things. It's already testet, and should work. Keep in mind that the z+ is forward now.

 public class CubeRotation : MonoBehaviour
 {
     #region Fields
     [Header("Camera")]
     public Camera cameraScript;
 
     [Header("Movement Properties")]
     public float movementSpeed = 0.12f; // Movement speed
     public float movementAmount = 0.4f;
     public Text movesText;
     public Vector3 pos; // changed to a vector3 to determain the move direction
     public static int moves;
     public static bool canMove;
     public static bool playerMoved;
     private Vector3 currentPos; // our current position
 
     [Header("Rotation Properties")]
     public float rotationSpeed = 0.12f; // Rotation speed
     public float angle = 90; // this is how much it should be rotated
 
     // we  we'll be using it for rotating
     private Vector3 worldAxis = Vector3.zero; 
     private Quaternion currentRotation; // our current rotation
     private float startTime; // start time for lerping movement and rotation
 
     private bool isRotating;
     private bool isMoving;
     #endregion
 
     #region Start & Update
     void Start()
     {
         moves = 0;
         canMove = true;
         playerMoved = false;
     }
 
     void Update()
     {
         if (movesText != null)
         {
             movesText.text = moves.ToString();
         }
         // These are for lerping, and is the correct way to lerp
         // timeSinceStarted is equal to Time.time - our start time, which is set in the buttons functions
         float timeSinceStarted = Time.time - startTime;
         // percentageComplete is devided by our rotationSpeed, and gives us a number between 0 and 1
         // 0 = just started, 1 = finished rotating
         float percentageComplete = timeSinceStarted / rotationSpeed;
 
         // This is what fixed the weird rotation
         // Here we use Quaternion.AngleAxis to rotatate angle amount around axis. 
         // We then multiply it by our currentRotation to rotate around the world axis
         // Multiplying with Quaternions are very important as they wont have the same end result.
         // currentRotation * Quaternion.AngleAxis() = local axis
         // Quaternion.AngleAxis() * currentRotation = world axis 
 
         // angle just tells us to rotate 90 degrees each time
         // you could change it in the inspector
         Quaternion newRotation = Quaternion.AngleAxis(this.angle, worldAxis) * currentRotation;
 
         // if our new rotation is not = Vector3.zero and currentRotation is not = Vector3.zero
         // then we could rotate
         // lerping will throw an error as it can't calculate Quaternions that are zeroed out.
         // and will therefore throw an error
         if (newRotation.eulerAngles != Vector3.zero  || currentRotation.eulerAngles != Vector3.zero)
         {
             // here we're asigning our lerped rotation to our local Quaternion variable
             Quaternion lerping = Quaternion.Lerp(this.currentRotation, newRotation, percentageComplete);
             // and here we just assign it to our transform.rotation
             transform.rotation = lerping;
             // if isRotating is true and the tranform.rotation has finished rotating
             // then set isRotating back to false, so that we can rotate again
             if (isRotating && transform.rotation == newRotation)
                 isRotating = false;
         }
     }
     #endregion
 
     #region Buttons
     public void ButtonUp()
     {
         if (GameMaster.endTheLevel == false  && !isRotating && !isMoving && canMove)
         {
             // here we set the start time
             startTime = Time.time;
 
             // for asigning movement, forward when moving
             // Use the inspector to change the movement amount
             // which is how much you want the cube to move, in your case it was 0.4
             AssignMovement(Vector3.forward, movementAmount);
 
             // right when rotating, because we rotate around our x axis when going forward
             // this asigns the direction we want to rotate Vector3.right = (1,0,0)
             worldAxis = Vector3.right;
             // We set our current rotation variable to that of the object
             currentRotation = this.transform.rotation;
             // here we set isRotating to true, to make sure that the cube can't be rotated while rotating.
             isRotating = true;
         }
     }
     public void ButtonDown()
     {
         if (GameMaster.endTheLevel == false && !isRotating && !isMoving && canMove)
         {
             startTime = Time.time;
 
             AssignMovement(Vector3.back, -movementAmount);
 
             worldAxis = Vector3.left;
             currentRotation = this.transform.rotation;
             isRotating = true;
         }
     }
     public void ButtonLeft()
     {
         if (GameMaster.endTheLevel == false && !isRotating && !isMoving && canMove)
         {
             startTime = Time.time;
 
             AssignMovement(Vector3.left, -movementAmount);
 
             worldAxis = Vector3.forward;
             currentRotation = this.transform.rotation;
             isRotating = true;
         }
     }
     public void ButtonRight()
     {
         if (GameMaster.endTheLevel == false && !isRotating && !isMoving && canMove)
         {
             startTime = Time.time;
 
             AssignMovement(Vector3.right, movementAmount);
 
             worldAxis = Vector3.back;
             currentRotation = this.transform.rotation;
             isRotating = true;
         } 
     }
     #endregion
 
     #region Movement
     // here we determain our move direction and new move position
     private void AssignMovement(Vector3 moveDir, float moveAmount)
     {
         // set the currentPos variable to our current position
         currentPos = transform.position;
 
         // setting is moving to true
         isMoving = true;
 
         // here we determain our move direction
         // moveDir.x > 0 = right, moveDir.x < 0 = left
         if (moveDir.x > 0 || moveDir.x < 0)
         {
             // set our pos.x to our moveAmount
             pos.x = moveAmount;
         }
         // same as above, but here we check if we're moving forward or backwards
         // moveDir.z > 0 = forward, moveDir.z < 0 = backwards
         if (moveDir.z > 0 || moveDir.z < 0)
         {
             // set our pos.z to our moveAmount
             pos.z = moveAmount;
         }
 
         // Here we invoke our Coroutine, and pass a Vecor3
         // which is our new target position
         // pos could be (0,0,0.4f) + currentPos = new position
         StartCoroutine(Move(pos + currentPos));
         
     }
     // Here we move our cube
     private IEnumerator Move(Vector3 newPos)
     {
         Camera.enableArrows = false;
         cameraScript.greenArrow.interactable = false;
         cameraScript.blueArrow.interactable = false;
         cameraScript.yellowArrow.interactable = false;
         cameraScript.redArrow.interactable = false;
 
         // while our current position is no equal to our new position
         while (this.transform.position != newPos)
         {
             // These are for lerping, and is the correct way to lerp
             // timeSineStarted is equal to Time.time - our start time, which is set in the buttons functions
             float timeSinceStarted = Time.time - startTime;
 
             // percentageComplete is devided by our movementSpeed, and gives us a number between 0 and 1
             // 0 = just started, 1 = finished moving
             float percentageComplete = timeSinceStarted / movementSpeed;
 
             // Here we lerp the position, to give a smother movement
             // it's important that the currentPos and newPos stays the same throughout the lerping
             this.transform.position = Vector3.Lerp(currentPos, newPos, percentageComplete);
             yield return null;
         }
         // zero out pos, for the next movement
         pos = Vector3.zero;
 
         moves = moves + 1;
         playerMoved = true;
         // isMoving is set to false
         isMoving = false;
 
         Camera.enableArrows = true;
         cameraScript.greenArrow.interactable = true;
         cameraScript.blueArrow.interactable = true;
         cameraScript.yellowArrow.interactable = true;
         cameraScript.redArrow.interactable = true;
     }
     #endregion
 
 
 }

i have commented most of the things. naming conventions might not be the best :)