So for the Movement in unity or MIU im going to go script by script function by function and you can see which script im talking about by the tittle that comes up.
like here it is "Player.cs"

Veriables Everything under miscellaneous doesnt really matter that much they just reference the other scripts that make up the player character.
I am usuing the Input Actions or IA that unity has for this project. They are very simular to unreals input actions.

Start just Initializes a bunch of these codes or makes new once so im gonna skip it.

Update how ever does do a few things so lets look at that.
First we store the players input this frame and the delta time.
Then we use the input make a new CameraInput with its look vector being equal to the input.look value.
After that we call a custom function in the camera to update its rotation using the cameraInput.
Here we make a new characterInput struct and fill in with information based of if an input.veriable was pressed this frame or not.
Their are some expections to this, like rotation is just grabed from the camera or JumpSustain is just shaking if was pressed or not.
The one line I want to look closer at is the Run/Crouch inputs, see they are both togglable so they need some extra lines.
This statement is just trying to get what value the crouch should be. We use the "?" operator multiple times to get the answer we want.
the "?" operatror is an if statement for a variable basicly; (statement) ? true : false; if statement is true return the left most value other wise return the right most.
The first ? operator checks if we have crouch toggled or not. The secound ? operator just turns the crouch on or off.
We call the player character to update its inputs and then its body, a function we will see later.
After that we do the weapon inputs but also have a debug key that allows us to Teleport to where a ray hits in the scene.
This is very usefull becouse of how our terrain looks in the game.

LateUpdate is what comes next. in here we just call a bunch of function inside other scripts that make up the player. Here is where we update the camera, we do this here so that we know that all the movement callculation have been done this frame and now can just move the camera smoothly.

The actual meat of the character movement happens in this script. Think of player.cs as a manger calling all the other scripts as needed.
Let's being with UpdateInput, now this function updates a bunch of veriabels so I wont show all of it but I wanna show a part of it that I really find cool
This looks odd but this is a simple swtich statement but when I was making this I had no idea you could use a switch like this.
Depending on what CrouchInput is it will return true or false but this also allows us to make toggle crouch by just fliping the _requestedCrouch.
the _ => _requestedCrouch looks really werid but is just the defualt case.

UpdateBody from earlier show up here again and it looks like this This updates the player hight and its camera postion but over time using a lerp.
This create a smooth up and down while crouching.


Now lets look at the BeforeCharacterUpdates function, this on is called before we update the players movement. So this happens before we apply anything like position and rotation.
This is just setting up some states that can be called from heldown buttons, so both runing and crouching comes into play here.
AfterCharacterUpdate does basicly the same so im not going to show it.

So now for the big part * UpdateVelocity * First we do some set up, we clear Acceleration and set it to 0, we get the grounded movements direaction by calling the function GetDirectionTangentToSurface.
This function Crosses the direction with the characters up and then takes the resulting vector and crosses that with surfaceNormal. Returning this vecotr normalized for us to use.
Here we save a bunch of veriabels for later. Almost all of these have something to do with the _state or _lastState veriables which just a saved copy of the enum that saves the players stance, ie crouching, running, wallruning.
Here we have the start to Slide . First we just do a check to see if we can slide or not.
If we can slide then we set the stance to slide.
Then we check if we are in were in the air. If we were then we get the ground normal by using the KinematicCharacterMotor.
We project our current velocity onto this groundNormal. We do this to get a perallel vector to the plane we sliding on.
if the tangent is great enough we set the currentVelocity to be equal to tangent.normalized * currentVelocity.magnitude. This directs our movementom along the normal of the serfuce we are standing on.

After that we make a float called effectiveSlideStartSpeed. This float will effect the currentVelocity later but we make this temperary verstion so we can change it as needed.
So we run a check to see if our _lastState wasnt grounded and _requestedCrouchInAir is false then we set the effectiveSlideStartSpeed to be 0 and flip the _requestedCrouchInAir to be false. This effectevly tells the later code not to use the effectiveSlideStartSpeed.

After that check we now set up another veriable slideSpeed, is initiale value being equal to either effectiveSlideStartSpeed or currentVelocity.magnitude depending on which is higher in value.
We use the GetDirectionTangentToSurface from before here again. Multiplying ther resulting vector with slideSpeed.
Then we are done with slide.