bunny hop script

--- made by forsaken c:

workspace.Gravity = 100


local Config = {

    --[[General]]
    VISUALIZE_FEET_HB = false, -- Visualize Feet Hitbox
    VISUALIZE_COLLIDE_AND_SLIDE = false,
    STEP_OFFSET = 1.2,
    MASS = 16,
    AIR_FRICTION = 0.4,
    FRICTION = 6,
    GRAVITY = 10,
    JUMP_VELOCITY = 30,

    --[[Accel/Deccel]]
    GROUND_ACCEL = 14,
    GROUND_DECCEL = 10,
    AIR_ACCEL = 52,

    --[[General Speed]]
    AIR_SPEED = 42,
    RUN_SPEED = 32,
    WALK_SPEED = 10,
    CROUCH_SPEED = 10,

    --[[Advanced Speed]]
    AIR_MAX_SPEED = 36.5,        -- The speed at which AIR_MAX_SPEED_FRIC is applied.
    AIR_MAX_SPEED_FRIC = 3,      -- The initial friction applied at max speed
    AIR_MAX_SPEED_FRIC_DEC = .5, -- Amount multiplied to current max speed friction per 1/60sec
    MIN_SLOPE_ANGLE = 40,
    MAX_SLOPE_ANGLE = 75,

    --[[Misc (Don't worry about these)]]
    LEG_HEIGHT = 1.9+.3,
    TORSO_TO_FEET = 3.1+1.9,
    FEET_HB_SIZE = Vector3.new(1,0.1,1),
    TORSO_HB_SIZE = Vector3.new(3,1,3),
    FOOT_OFFSET_AMOUNT = 1.2
}

local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")

local ids = {
    "rbxassetid://7338942417",
    "rbxassetid://7338942345",
    "rbxassetid://7338942259",
    "rbxassetid://7338942180",
    "rbxassetid://7338942417",
}
local sounds = {}

for _, i in ipairs(ids) do
    local sound = Instance.new("Sound")
    sound.SoundId = i
    sound.Volume = 2
    sound.Parent = game.Workspace  -- Or another appropriate parent
    table.insert(sounds, sound)
end






export type Movement = {
    Keys: {W: number, A: number, S: number, D: number, Space: number},

    player: Player,
    character: Model,
    collider: Part,
    vispart: Part?,
    vis_coll_parts: {Part},
    config: MovementConfig,
    mover: LinearVelocity,
    up_mover: LinearVelocity,
    dt: number,
    states: MovementStates,
}

export type MovementConfig = {
    VISUALIZE_FEET_HB: boolean,
    VISUALIZE_COLLIDE_AND_SLIDE: boolean,
    LEG_HEIGHT: number,
    FEET_HB_SIZE: Vector3,
    TORSO_HB_SIZE: Vector3,

    MASS: number,
    GRAVITY: number,
    FRICTION: number,
    AIR_FRICTION: number,

    GROUND_ACCEL: number,
    GROUND_DECCEL: number,
    AIR_ACCEL: number,

    RUN_SPEED: number,
    WALK_SPEED: number,
    CROUCH_SPEED: number,
    AIR_SPEED: number,

    AIR_MAX_SPEED: number,
    AIR_MAX_SPEED_FRIC: number,
    AIR_MAX_SPEED_FRIC_DEC: number,

    JUMP_VELOCITY: number,

    STEP_OFFSET: number,
    TORSO_TO_FEET: number,

    MIN_SLOPE_ANGLE: number,
    MAX_SLOPE_ANGLE: number,
}

export type MovementStates = {
    grounded: boolean,
    air_friction: number,
    input_vec: number,
    surfing: boolean,
    jumping: boolean,
}

export type Vec3Mod = {x: number, y: number, z: number, ToVector3: (Vec3Mod) -> Vector3}
local Vec3Mod = {}
Vec3Mod.__index = Vec3Mod

function Vec3Mod.new(input: Vector3?) : Vec3Mod
    input = input or Vector3.zero
    return setmetatable({x = input.X, y = input.Y, z = input.Z}, Vec3Mod) :: Vec3Mod
end

function Vec3Mod:ToVector3()
    return Vector3.new(self.x, self.y, self.z)
end

local Movement: Movement = {}
local Physics = {} :: Movement
local Shared  : Movement= {}
local Trace : Movement= {}
local Collisions = {} :: Movement

local function visualizeRayResult(result: RaycastResult, origin: Vector3, direction: Vector3)
    local position = result and result.Position or (origin + direction)
    local distance = (origin - position).Magnitude
    local p = Instance.new("Part")
    p.Anchored = true
    p.CanCollide = false
    p.Size = Vector3.new(0.1, 0.1, distance)
    p.CFrame = CFrame.lookAt(origin, position)*CFrame.new(0, 0, -distance/2)
    p.Parent = workspace.Temp
    return p
end

local function flattenVectorAgainstWall(moveVector: Vector3, normal: Vector3)
    -- if magnitudes are 0 then just nevermind
    if moveVector.Magnitude == 0 and normal.Magnitude == 0 then
        return Vector3.zero
    end

    -- unit the normal (i its already normalized idk)
    normal = normal.Unit

    -- reflect the vector
    local reflected = moveVector - 2 * moveVector:Dot(normal) * normal
    -- add the reflection to the move vector = vector parallel to wall
    local parallel = moveVector + reflected

    -- if magnitude 0 NEVERMIND!!!
    if parallel.Magnitude == 0 then
        return Vector3.zero
    end

    -- reduce the parallel vector to make sense idk HorseNuggetsXD did all this thank u
    local cropped = parallel.Unit:Dot(moveVector.Unit) * parallel.Unit * moveVector.Magnitude
    return cropped
end

function Collisions:CollideAndSlide(wishedSpeed: Vector3)
    local mod = 1

    if wishedSpeed.Magnitude == 0 then
        return wishedSpeed
    end

    -- get input vector
    local inputVec = self.states.input_vec
    local newSpeed = wishedSpeed
    local hrp = self.player.Character.HumanoidRootPart

    -- raycast var
    local params = Shared.GetMovementParams(self)

    -- wished speed modifier
    wishedSpeed *= 2

    -- direction amount var
    local dirAmnt = 1.375 * (mod or 1)
    local mainDirAmnt = 1.55 * (mod or 1)

    -- stick var
    local isSticking = false
    local normals = {}
    local stickingDirections = {}
    local ldd = {dir = false, dist = false} -- lowest distance direction
    local partsAlreadyHit = {}

    -- destroy sticking visualizations
    if Config.VISUALIZE_COLLIDE_AND_SLIDE then
        for _, v in pairs(self.vis_coll_parts) do
            v:Destroy()
        end
    end

    local lookVecs = {
        Vector3.new(0, (-Config.TORSO_TO_FEET) + Config.STEP_OFFSET, 0),
        Vector3.new(0, 0, 0),
        Vector3.new(0, 2, 0)
    }

    for _, v in pairs(lookVecs) do
        local values = {}
        local hval = {}
        local currForDir
        local currSideDir
        local rayPos

        if typeof(v) == "Vector3" then
            rayPos = hrp.Position + v
        else
            rayPos = Vector3.new(hrp.Position.X, hrp.Parent[v].CFrame.Position, hrp.Position.Z)
        end

        -- right, front, back
        if inputVec.X > 0 then
            currForDir = hrp.CFrame.RightVector
            table.insert(values, currForDir)
            table.insert(hval, hrp.CFrame.LookVector * dirAmnt)
            table.insert(hval, -hrp.CFrame.LookVector * dirAmnt)
            -- left, front, back
        elseif inputVec.X < 0 then
            currForDir = -hrp.CFrame.RightVector
            table.insert(values, currForDir)
            table.insert(hval, hrp.CFrame.LookVector * dirAmnt)
            table.insert(hval, -hrp.CFrame.LookVector * dirAmnt)
        end

        -- back, left, right
        if inputVec.Z > 0 then
            currSideDir = -hrp.CFrame.LookVector
            table.insert(values, currSideDir)
            table.insert(hval, hrp.CFrame.RightVector * dirAmnt)
            table.insert(hval, -hrp.CFrame.RightVector * dirAmnt)
            -- front, left, right
        elseif inputVec.Z < 0 then
            currSideDir = hrp.CFrame.LookVector
            table.insert(values, currSideDir)
            table.insert(hval, hrp.CFrame.RightVector * dirAmnt)
            table.insert(hval, -hrp.CFrame.RightVector * dirAmnt)
        end


        if inputVec.Z == 0 and inputVec.X == 0 then
            values[1] = wishedSpeed.Unit
            table.insert(hval, CFrame.new(wishedSpeed.Unit).RightVector * dirAmnt)
            table.insert(hval, -CFrame.new(wishedSpeed.Unit).RightVector * dirAmnt)
        else
            table.insert(values, wishedSpeed.Unit * dirAmnt)
        end

        -- middle directions
        if currForDir and currSideDir then
            for a, b in pairs(values) do
                values[a] = b * mainDirAmnt
            end
            table.insert(values, (currForDir+currSideDir) * mainDirAmnt)
        else
            values[1] *= mainDirAmnt
            table.insert(values, (values[1] + hval[1]).Unit * mainDirAmnt)
            table.insert(values, (values[1] + hval[2]).Unit * mainDirAmnt)
            table.insert(values, hval[1])
            table.insert(values, hval[2])
        end

        for _, b in pairs(values) do
            if not b then continue end

            -- visualize ray using pos and direction
            if Config.VISUALIZE_COLLIDE_AND_SLIDE then
                table.insert(self.vis_coll_parts, visualizeRayResult(false, rayPos, b))
            end

            local result = workspace:Raycast(rayPos, b, params)
            if not result then continue end

            if (not ldd.dir or not ldd.dist) or (ldd.dist and ldd.dist < result.Distance) then
                ldd.dir = b
                ldd.dist = result.Distance
            end

            -- don't collide with the same part twice
            if table.find(partsAlreadyHit, result.Instance) then continue end
            table.insert(partsAlreadyHit, result.Instance)

            -- get the movement direction compared to the wall
            local _v =  newSpeed.Unit * result.Normal

            -- find active coordinate of comparison
            for _, c in pairs({_v.X, _v.Y, _v.Z}) do
                if math.abs(c) > 0 then
                    _v = c
                    break
                end
            end

            -- if we are moving AWAY from the normal, (positive)
            -- then do not flatten the vector.

            -- it's not necessary.
            -- you will stick.
            -- stick.

            if type(_v) == "number" and _v > 0 then
                continue
            end

            if not isSticking then isSticking = true end
            newSpeed = flattenVectorAgainstWall(newSpeed, result.Normal)
            newSpeed -= result.Instance.Velocity

            self.mover.PlaneVelocity = Vector2.new(newSpeed.X, newSpeed.Z)
            --self.collider.Velocity = Vector3.new(newSpeed.X, (self.collider.Velocity.Y), newSpeed.Z) -- anti sticking has to be applied on collider velocity as well (resolves head & in air collision)
        end
    end

    return newSpeed, isSticking and normals, isSticking and stickingDirections, isSticking and ldd.dir
end


export type Trace = {
    startPos: Vector3,
    endPos: Vector3,


    fraction: number,
    startSolid: boolean,
    hitPart: Instance,
    hitPoint: Vector3,
    planeNormal: Vector3,
    distance: number
}

local function HandleVisualization(self, cf, size)
    if not Config.VISUALIZE_FEET_HB then
        return
    end
    if not self.vispart then
        self.vispart = Instance.new("Part", self.character)
        self.vispart.CanCollide = false
        self.vispart.Anchored = true
    end

    self.vispart.CFrame = cf
    self.vispart.Size = size
end

function Shared.GetAngle(normal)
    return math.deg(math.acos(normal:Dot(Vector3.yAxis)))
end

function Shared:IsGrounded(dir): (boolean, boolean?, RaycastResult?, number?)
    local params = Shared.GetMovementParams(self)
    local cf = CFrame.new(self.collider.Position) - Vector3.new(0, self.collider.Size.Y/2, 0)
    local size = Config.FEET_HB_SIZE
    dir = dir or Vector3.new(0,-1 * self.collider.Size.Y-Config.FOOT_OFFSET_AMOUNT,0)

    local result = workspace:Blockcast(cf, size, dir, params)

    HandleVisualization(self, cf, size)

    if not result then
        return false
    end

    local steepness = Shared.GetAngle(result.Normal)
    local isSurfing = steepness >= Config.MIN_SLOPE_ANGLE and steepness <= Config.MAX_SLOPE_ANGLE
    if isSurfing then
        return false, true, result, steepness
    end

    return true, false, result
end

function Shared:RotateCharacter()
    local collider = self.collider
    local camera = workspace.CurrentCamera
    local rotationLook = collider.Position + camera.CoordinateFrame.lookVector
    collider.CFrame = CFrame.new(collider.Position, Vector3.new(rotationLook.x, collider.Position.y, rotationLook.z))
    collider.RotVelocity = Vector3.new()
end

function Shared:GetMovementDirection(groundNormal)
    local forward = self.Keys.W + -self.Keys.S
    local side = self.Keys.A + -self.Keys.D
    groundNormal = groundNormal or Vector3.new(0,1,0)

    if forward == 0 and side == 0 then
        self.states.input_vec = Vector3.zero
        return Vector3.zero
    else
        self.states.input_vec = Vector3.new(-side, 0, -forward).Unit
        local forwardMove = groundNormal:Cross(self.collider.CFrame.RightVector)
        local sideMove = groundNormal:Cross(forwardMove)
        return (forwardMove * forward + sideMove * side).Unit
    end
end

function Shared:GetMovementParams()
    local params = RaycastParams.new()
    params.FilterDescendantsInstances = {self.character, workspace.CurrentCamera}
    params.FilterType = Enum.RaycastFilterType.Exclude
    params.RespectCanCollide = false
    params.CollisionGroup = "PlayerMovement"
    return params
end

function Shared:VectorMa(start: Vector3, scale: number, direction: Vector3)
    return Vector3.new(
        start.X + direction.X * scale,
        start.Y + direction.Y * scale,
        start.Z + direction.Z * scale
    )
end


local Trace: Movement = {}

local numBumps = 1
local maxClipPlanes = 5
local _planes = {}

local numToCoord = {"X", "Y", "Z"}

local function ClipVelocity(self, input, normal, output, overbounce)
    local newVelMod = Vec3Mod.new(output)
    Trace.ClipVelocity(self, input, normal, newVelMod, overbounce)
    return newVelMod:ToVector3()
end

function Trace:TraceBox(start: Vector3, destination: Vector3)
    local contactOffset = 0.1 -- idk what this is

    local longSide = math.sqrt(contactOffset * contactOffset + contactOffset * contactOffset)
    local direction = (destination - start).Unit
    local maxDistance = (start - destination).Magnitude + longSide

    local result: Trace = {
        startPos = start,
        endPos = destination
    }

    local _, _, hit = Shared.IsGrounded(self, direction*maxDistance)
    if hit then
        result.fraction = hit.Distance / maxDistance
        result.hitPart = hit.Instance
        result.hitPoint = hit.Position
        result.planeNormal = hit.Normal
        result.distance = hit.Distance
    else
        result.fraction = 1
    end

    return result
end

function Trace:ClipVelocity(input: Vector3, normal: Vector3, output: Types.Vec3Mod, overbounce: number)
    local angle = normal.Y
    local blocked = 0x00     -- // Assume unblocked.

    if angle > 0 then -- // If the plane that is blocking us has a positive z component, then assume it's a floor.
        blocked = blocked or 0x01
    end

    if angle == 0 then -- // If the plane has no Z, it is vertical (wall/step)
        blocked = blocked or 0x02
    end

    -- // Determine how far along plane to slide based on incoming direction.
    local backoff = input:Dot(normal) * overbounce

    --// iterate once to make sure we aren't still moving through the plane
    for i = 1, 3, 1 do
        local ci = numToCoord[i]
        local change = normal[ci] * backoff
        output[ci] = input[ci] - change
    end

    local adjust = output:ToVector3():Dot(normal)
    if adjust < 0 then
        output = output:ToVector3()-(normal * adjust)
    end

    -- Return blocking flags.
    return blocked
end

function Trace:Reflect(velocity: Vector3, origin: Vector3)

    self = self :: Movement

    local d
    local newVelocity = Vector3.zero
    local blocked = 0
    local numplanes = 1
    local originalVelocity = velocity
    local primalVelocity = velocity

    local allFraction = 0
    local timeLeft = self.dt

    for bumpcount = 1, numBumps, 1 do

        if velocity.Magnitude == 0 then
            break
        end

        -- Assume we can move all the way from the current origin to the
        --  end point.
        local endp = Shared.VectorMa(self, origin, timeLeft, velocity)
        local trace = Trace.TraceBox(self, origin, endp)
        allFraction += trace.fraction

        if trace.fraction > 0 then
            -- actually covered some distance
            originalVelocity = velocity
            numplanes = 0
        end

        -- If we covered the entire distance, we are done
        --  and can return.
        if trace.fraction == 1 then
            break
        end -- moved the entire distance

        -- If the plane we hit has a high z component in the normal, then
        --  it's probably a floor
        if trace.planeNormal.Y > Config.MAX_SLOPE_ANGLE then
            blocked = blocked or 1
        end

        -- If the plane has a zero z component in the normal, then it's a
        --  step or wall
        if trace.planeNormal.Y == 0 then
            blocked = blocked or 2 -- step/wall
        end

        -- Reduce amount of m_flFrameTime left by total time left * fraction
        --  that we covered.
        timeLeft -= timeLeft * trace.fraction


        -- Did we run out of planes to clip against?
        if numplanes >= maxClipPlanes then
            -- this shouldn't really happen
            --  Stop our movement if so.
            velocity = Vector3.zero
            break
        end

        -- Set up next clipping plane
        _planes[numplanes] = trace.planeNormal
        numplanes+=1

        -- modify original_velocity so it parallels all of the clip planes
        --

        -- reflect player velocity
        -- Only give this a try for first impact plane because you can get yourself stuck in an acute corner by jumping in place
        --  and pressing forward and nobody was really using this bounce/reflection feature anyway...
        if numplanes == 2 then
            if _planes[1].Y > Config.MAX_SLOPE_ANGLE then
                return blocked
            else
                newVelocity = ClipVelocity(self, originalVelocity, _planes[1], newVelocity, 1)
            end
            velocity = newVelocity
            originalVelocity = newVelocity
        else
            local _i = 0
            for i = 1, numplanes-1, 1 do
                _i = i

                newVelocity = ClipVelocity(self, originalVelocity, _planes[i], newVelocity, 1)

                local _j = 0
                for j = 1, numplanes-1, 1 do
                    _j = j
                    if j ~= i and velocity:Dot(_planes[j]) < 0 then
                        break
                    end
                end

                if _j == numplanes then
                    break
                end
            end

            if _i ~= numplanes then

            else
                if numplanes ~= 3 then
                    velocity = Vector3.zero
                    break
                end

                local dir = _planes[1]:Cross(_planes[2]).Unit
                d = dir:Dot(velocity)
                velocity = dir * d
            end
        end

        d = velocity:Dot(primalVelocity)
        if d <= 0 then
            velocity = Vector3.zero
            break
        end

    end

    if allFraction == 0 then
        velocity = Vector3.zero
    end

    return velocity, blocked
end


local function ApplyMoverVelocity(self: Movement, velocity: Vector3): Vector2
    local vel = Vector2.new(velocity.X, velocity.Z)
    self.mover.PlaneVelocity = vel
    return vel
end

function Physics:ApplyGroundVelocity(groundNormal: Vector3)
    local wishDir = Shared.GetMovementDirection(self, groundNormal)
    local wishSpeed = wishDir.Magnitude * Config.RUN_SPEED

    -- normal friction
    if self.states.air_friction <= 0 then
        Physics.ApplyFriction(self)
    else

        -- friction that is applied due to the player reaching max speed while bhopping
        local sub = Config.AIR_MAX_SPEED_FRIC_DEC * self.dt * 60
        local curr = self.states.air_friction
        local fric = curr - sub
        if fric < 0 then
            fric = curr + fric
        end

        Physics.ApplyFriction(self, math.max(1, fric/Config.FRICTION))
        self.states.air_friction = math.max(0, curr - sub)
    end

    Physics.ApplyGroundAcceleration(self, wishDir, wishSpeed)
    Collisions.CollideAndSlide(self, Vector3.new(self.mover.PlaneVelocity.X, 0, self.mover.PlaneVelocity.Y))

    -- calculate & apply slope movement
    if Shared.GetAngle(groundNormal) < 5 then
        return
    end

    local curVel: Vector3 = Vector3.new(self.mover.PlaneVelocity.X, self.collider.Velocity.Y, self.mover.PlaneVelocity.Y)
    local forVel: Vector3 = groundNormal:Cross(CFrame.Angles(0,math.rad(90),0).LookVector * curVel)
    local yVel: number = 0

    if forVel.Magnitude > 0 then
        yVel = forVel.Unit.Y * curVel.Magnitude
    end

    self.collider.Velocity = Vector3.new(curVel.X, yVel, curVel.Z)
end

function Physics:ApplyGroundAcceleration(wishDir: Vector3, wishSpeed: number)
    local addSpeed
    local accelerationSpeed
    local currentSpeed
    local currentVelocity = Vector3.new(self.mover.PlaneVelocity.X, 0, self.mover.PlaneVelocity.Y)
    local newVelocity = currentVelocity

    -- get current/add speed
    currentSpeed = currentVelocity:Dot(wishDir)
    addSpeed = wishSpeed - currentSpeed

    -- if we're not adding speed, dont do anything
    if addSpeed <= 0 then return end

    -- get accelSpeed, cap at addSpeed
    accelerationSpeed = math.min(Config.GROUND_ACCEL * self.dt * wishSpeed, addSpeed)

    -- you can't change the properties of a Vector3, so we do x, y, z
    newVelocity += (accelerationSpeed * wishDir)
    newVelocity = Vector3.new(newVelocity.X,  0, newVelocity.Z)

    -- clamp magnitude (max speed)
    if newVelocity.Magnitude > (Config.RUN_SPEED) then
        newVelocity = newVelocity.Unit * math.min(newVelocity.Magnitude, (Config.RUN_SPEED))
    end

    -- apply acceleration
    ApplyMoverVelocity(self, newVelocity)
end

function Physics:ApplyAirVelocity(normal)
    normal = Vector3.new(0,1,0)
    local vel = Vector3.new(self.mover.PlaneVelocity.X, 0, self.mover.PlaneVelocity.Y)
    local wishDir = Shared.GetMovementDirection(self, normal)
    local wishSpeed = wishDir.Magnitude * Config.AIR_SPEED
    local currSpeed = vel.Magnitude

    -- initiate extra friction for max speed
    if currSpeed > Config.AIR_MAX_SPEED then
        self.states.air_friction = Config.AIR_MAX_SPEED_FRIC
    end

    -- apply extra friction if necessary
    if self.states.air_friction > 0 and not self.states.surfing then
        Physics.ApplyFriction(self, 0.01 * self.states.air_friction, false)
    end

    Physics.ApplyAirAcceleration(self, wishDir, wishSpeed)

    local refVel = Vector3.new(self.mover.PlaneVelocity.X, self.collider.Velocity.Y, self.mover.PlaneVelocity.Y)
    ApplyMoverVelocity(self, Trace.Reflect(self, refVel, self.collider.Position))
end

function Physics:ApplyAirAcceleration(wishDir: Vector3, wishSpeed: number)
    local currentSpeed
    local addSpeed
    local accelerationSpeed
    local currentVelocity = Vector3.new(self.mover.PlaneVelocity.X, 0, self.mover.PlaneVelocity.Y)

    -- get current/add speed
    currentSpeed = currentVelocity:Dot(wishDir)
    addSpeed = wishSpeed - currentSpeed

    -- if we're not adding speed, dont do anything
    if addSpeed <= 0 then return end

    -- get accelSpeed, cap at addSpeed
    accelerationSpeed = math.min(Config.AIR_ACCEL * self.dt * wishSpeed, addSpeed)

    -- get new velocity
    local newVelocity = currentVelocity + accelerationSpeed * wishDir

    -- apply acceleration
    ApplyMoverVelocity(self, newVelocity)
end

function Physics:ApplyFriction(modifier: number?, inAir: boolean?)
    local vel
    if inAir then
        vel = self.collider.Velocity
    else
        vel = Vector3.new(self.mover.PlaneVelocity.X, 0, self.mover.PlaneVelocity.Y)
    end

    local speed = vel.Magnitude
    modifier = modifier or 1

    local drop = 0
    local fric = inAir and Config.AIR_FRICTION or Config.FRICTION
    local decel = Config.GROUND_DECCEL
    local newSpeed
    local control

    -- if we're not moving, don't apply friction
    if speed <= 0 then
        return vel
    end

    -- ???
    control = speed < decel and decel or speed
    drop = control * fric * self.dt * modifier
    if type(drop) ~= "number" then drop = drop.Magnitude end

    -- ????????????
    newSpeed = math.max(speed - drop, 0)
    if speed > 0 and newSpeed > 0 then
        newSpeed /= speed
    end

    vel *= newSpeed
    ApplyMoverVelocity(self, vel)

    if inAir then
        local nv = self.mover.VectorVelocity
        --self.collider.Velocity = Vector3.new(nv.X, self.collider.Velocity.Y * newSpeed, nv.Z)
    end
end

local function Init()
    Movement.Keys = {W = 0, S = 0, D = 0, A = 0, Space = 0}
    Movement.player = game.Players.LocalPlayer
    Movement.character = Movement.player.Character or Movement.player.CharacterAdded:Wait()
    Movement.collider = Movement.character:WaitForChild("HumanoidRootPart")
    Movement.vispart = false
    Movement.vis_coll_parts = {}
    Movement.config = Config

    local mover = Instance.new("LinearVelocity", Movement.collider)
    local a0 = Instance.new("Attachment", Movement.collider)
    a0.Name = "MovementAttachment"
    mover.Attachment0 = a0
    mover.MaxForce = 10000000
    mover.VelocityConstraintMode = Enum.VelocityConstraintMode.Plane
    mover.PrimaryTangentAxis = Vector3.new(1,0,0)
    mover.SecondaryTangentAxis = Vector3.new(0,0,1)
    Movement.mover = mover

    -- Will figure this out soon.
    --[[local upMover = Instance.new("LinearVelocity", Movement.collider)
    upMover.Attachment0 = Movement.collider:WaitForChild("MovementAttachment")
    upMover.ForceLimitMode = Enum.ForceLimitMode.PerAxis
    upMover.ForceLimitsEnabled = true
    upMover.MaxAxesForce = Vector3.new(0, 100000, 0)
    upMover.VelocityConstraintMode = Enum.VelocityConstraintMode.Vector
    Movement.up_mover = upMover]]

    Movement.states = {grounded = false, air_friction = 0, input_vec = Vector3.zero, surfing = false}
end

--

local function Gravity()
    local mod = Movement.config.GRAVITY * Movement.dt
    Movement.collider.AssemblyLinearVelocity = Vector3.new(
        Movement.collider.AssemblyLinearVelocity.X,
        Movement.collider.AssemblyLinearVelocity.Y - mod,
        Movement.collider.AssemblyLinearVelocity.Z
    )
end

local function Air()
    Physics.ApplyAirVelocity(Movement)
    local vel = Vector3.new(Movement.mover.PlaneVelocity.X, Movement.collider.AssemblyLinearVelocity.Y, Movement.mover.PlaneVelocity.Y)
    vel = Trace.Reflect(Movement, vel, Movement.collider.CFrame.Position)
    Movement.mover.PlaneVelocity = Vector2.new(vel.X, vel.Z)
    Movement.collider.AssemblyLinearVelocity = vel
end

local function Ground(groundNormal: Vector3)
    Physics.ApplyGroundVelocity(Movement, groundNormal)
end

local function Jump()
    sounds[math.random(1, #sounds)]:Play()
    Movement.temp_jump_last = tick()
    Movement.states.jumping = true
    Movement.collider.AssemblyLinearVelocity = Vector3.new(
        Movement.collider.AssemblyLinearVelocity.X,
        Movement.config.JUMP_VELOCITY,
        Movement.collider.AssemblyLinearVelocity.Z
    )
end

local function ProcessMovement()
    local isGrounded, isSurfing, result = Shared.IsGrounded(Movement)
    Movement.states.grounded = isGrounded or false
    Movement.states.surfing = isSurfing or false

    if Movement.collider.AssemblyLinearVelocity.Y < 0 then
        Movement.states.jumping = false

    end

    Shared.RotateCharacter(Movement)

    if Movement.states.jumping or not Movement.states.grounded then
        local groundNormal = false
        if isSurfing then
            groundNormal = result.Normal
            if Movement.collider.Velocity.Y > 0 then
                --Physics.ApplyFriction(Movement, false, true)
            end
        end

        Air(groundNormal)
        Gravity()
    elseif Movement.Keys.Space > 0 then
        Jump()
        Air()
    else
        Ground(result.Normal)
    end
end

--

local function InputBegan(input: InputObject, gp: boolean)
    if input.KeyCode and Movement.Keys[input.KeyCode.Name] then
        Movement.Keys[input.KeyCode.Name] = 1
    end
end

local function InputEnded(input: InputObject, gp: boolean)
    if input.KeyCode and Movement.Keys[input.KeyCode.Name] then
        Movement.Keys[input.KeyCode.Name] = 0
    end
end

local function Update(dt)
    Movement.dt = dt
    ProcessMovement()
end

Init()
UserInputService.InputBegan:Connect(InputBegan)
UserInputService.InputEnded:Connect(InputEnded)
RunService.RenderStepped:Connect(Update)