--[[ i skidded it from someone idk ]]--
local plr = game:GetService("Players").LocalPlayer

function RunCustomAnimation(Char)
    if Char:WaitForChild("Animate") ~= nil then
        Char.Animate.Disabled = true
    end

    Char:WaitForChild("Humanoid")

    for i,v in next, Char.Humanoid:GetPlayingAnimationTracks() do
        v:Stop()
    end

    --fake script
    local script = Char.Animate

    local Character = Char
    local Humanoid = Character:WaitForChild("Humanoid")
    local pose = "Standing"

    local UserGameSettings = UserSettings():GetService("UserGameSettings")

    local userNoUpdateOnLoopSuccess, userNoUpdateOnLoopValue = pcall(function() return UserSettings():IsUserFeatureEnabled("UserNoUpdateOnLoop") end)
    local userNoUpdateOnLoop = userNoUpdateOnLoopSuccess and userNoUpdateOnLoopValue

    local AnimationSpeedDampeningObject = script:FindFirstChild("ScaleDampeningPercent")
    local HumanoidHipHeight = 2

    local humanoidSpeed = 0 -- speed most recently sent to us from onRunning()
    local cachedRunningSpeed = 0 -- The most recent speed used to compute blends.  Tiny variations from cachedRunningSpeed will not cause animation updates.
    local cachedLocalDirection = {x=0.0, y=0.0} -- unit 2D object space direction of motion
    local smallButNotZero = 0.0001 -- We want weights to be small but not so small the animation stops
    local runBlendtime = 0.2
    local lastLookVector = Vector3.new(0.0, 0.0, 0.0) -- used to track whether rootPart orientation is changing.
    local lastBlendTime = 0 -- The last time we blended velocities
    local WALK_SPEED = 6.4
    local RUN_SPEED = 12.8

    local EMOTE_TRANSITION_TIME = 0.1

    local currentAnim = ""
    local currentAnimInstance = nil
    local currentAnimTrack = nil
    local currentAnimKeyframeHandler = nil
    local currentAnimSpeed = 1.0

    local PreloadedAnims = {}

    local animTable = {}
    local animNames = {
        idle =  {
            { id = "http://www.roblox.com/asset/?id=12521158637", weight = 9 },
            { id = "http://www.roblox.com/asset/?id=12521162526", weight = 1 },
        },
        walk =  {
            { id = "http://www.roblox.com/asset/?id=12518152696", weight = 10 }
        },
        run =   {
            { id = "http://www.roblox.com/asset/?id=12518152696", weight = 10 }
        },
        jump =  {
            { id = "http://www.roblox.com/asset/?id=12520880485", weight = 10 }
        },
        fall =  {
            { id = "http://www.roblox.com/asset/?id=12520972571", weight = 10 }
        },
        climb = {
            { id = "http://www.roblox.com/asset/?id=12520982150", weight = 10 }
        },
        sit =   {
            { id = "http://www.roblox.com/asset/?id=12520993168", weight = 10 }
        },
        toolnone = {
            { id = "http://www.roblox.com/asset/?id=12520996634", weight = 10 }
        },
        toolslash = {
            { id = "http://www.roblox.com/asset/?id=12520999032", weight = 10 }
        },
        toollunge = {
            { id = "http://www.roblox.com/asset/?id=12521002003", weight = 10 }
        },
        wave = {
            { id = "http://www.roblox.com/asset/?id=12521004586", weight = 10 }
        },
        point = {
            { id = "http://www.roblox.com/asset/?id=12521007694", weight = 10 }
        },
        dance = {
            { id = "http://www.roblox.com/asset/?id=12521009666", weight = 10 },
            { id = "http://www.roblox.com/asset/?id=12521151637", weight = 10 },
            { id = "http://www.roblox.com/asset/?id=12521015053", weight = 10 }
        },
        dance2 = {
            { id = "http://www.roblox.com/asset/?id=12521169800", weight = 10 },
            { id = "http://www.roblox.com/asset/?id=12521173533", weight = 10 },
            { id = "http://www.roblox.com/asset/?id=12521027874", weight = 10 }
        },
        dance3 = {
            { id = "http://www.roblox.com/asset/?id=12521178362", weight = 10 },
            { id = "http://www.roblox.com/asset/?id=12521181508", weight = 10 },
            { id = "http://www.roblox.com/asset/?id=12521184133", weight = 10 }
        },
        laugh = {
            { id = "http://www.roblox.com/asset/?id=12521018724", weight = 10 }
        },
        cheer = {
            { id = "http://www.roblox.com/asset/?id=12521021991", weight = 10 }
        },
    }


    local strafingLocomotionMap = {}
    local fallbackLocomotionMap = {}
    local locomotionMap = strafingLocomotionMap
    -- Existance in this list signifies that it is an emote, the value indicates if it is a looping emote
    local emoteNames = { wave = false, point = false, dance = true, dance2 = true, dance3 = true, laugh = false, cheer = false}

    math.randomseed(tick())

    function findExistingAnimationInSet(set, anim)
        if set == nil or anim == nil then
            return 0
        end

        for idx = 1, set.count, 1 do
            if set[idx].anim.AnimationId == anim.AnimationId then
                return idx
            end
        end

        return 0
    end

    function configureAnimationSet(name, fileList)
        if (animTable[name] ~= nil) then
            for _, connection in pairs(animTable[name].connections) do
                connection:disconnect()
            end
        end
        animTable[name] = {}
        animTable[name].count = 0
        animTable[name].totalWeight = 0
        animTable[name].connections = {}

        -- uncomment this section to allow players to load with their
        -- own (non-classic) animations
        --[[
        local config = script:FindFirstChild(name)
        if (config ~= nil) then
            table.insert(animTable[name].connections, config.ChildAdded:connect(function(child) configureAnimationSet(name, fileList) end))
            table.insert(animTable[name].connections, config.ChildRemoved:connect(function(child) configureAnimationSet(name, fileList) end))

            local idx = 0

            for _, childPart in pairs(config:GetChildren()) do
                if (childPart:IsA("Animation")) then
                    local newWeight = 1
                    local weightObject = childPart:FindFirstChild("Weight")
                    if (weightObject ~= nil) then
                        newWeight = weightObject.Value
                    end
                    animTable[name].count = animTable[name].count + 1
                    idx = animTable[name].count
                    animTable[name][idx] = {}
                    animTable[name][idx].anim = childPart
                    animTable[name][idx].weight = newWeight
                    animTable[name].totalWeight = animTable[name].totalWeight + animTable[name][idx].weight
                    table.insert(animTable[name].connections, childPart.Changed:connect(function(property) configureAnimationSet(name, fileList) end))
                    table.insert(animTable[name].connections, childPart.ChildAdded:connect(function(property) configureAnimationSet(name, fileList) end))
                    table.insert(animTable[name].connections, childPart.ChildRemoved:connect(function(property) configureAnimationSet(name, fileList) end))
                    local lv = childPart:GetAttribute("LinearVelocity")
                    if lv then
                        strafingLocomotionMap[name] = {lv=lv, speed = lv.Magnitude}
                    end
                    if name == "run" or name == "walk" then

                        if lv then
                            fallbackLocomotionMap[name] = strafingLocomotionMap[name]
                        else
                            local speed = name == "run" and RUN_SPEED or WALK_SPEED
                            fallbackLocomotionMap[name] = {lv=Vector2.new(0.0, speed), speed = speed}
                            locomotionMap = fallbackLocomotionMap
                            -- If you don't have a linear velocity with your run or walk, you can't blend/strafe
                            --warn("Strafe blending disabled. No linear velocity information for "..'"'.."walk"..'"'.." and "..'"'.."run"..'"'..".")
                        end

                    end
                end
            end
        end
        ]]

        -- if you uncomment the above section, comment out this "if"-block
        if name == "run" or name == "walk" then
            local speed = name == "run" and RUN_SPEED or WALK_SPEED
            fallbackLocomotionMap[name] = {lv=Vector2.new(0.0, speed), speed = speed}
            locomotionMap = fallbackLocomotionMap
            -- If you don't have a linear velocity with your run or walk, you can't blend/strafe
            --warn("Strafe blending disabled. No linear velocity information for "..'"'.."walk"..'"'.." and "..'"'.."run"..'"'..".")
        end


        -- fallback to defaults
        if (animTable[name].count <= 0) then
            for idx, anim in pairs(fileList) do
                animTable[name][idx] = {}
                animTable[name][idx].anim = Instance.new("Animation")
                animTable[name][idx].anim.Name = name
                animTable[name][idx].anim.AnimationId = anim.id
                animTable[name][idx].weight = anim.weight
                animTable[name].count = animTable[name].count + 1
                animTable[name].totalWeight = animTable[name].totalWeight + anim.weight
            end
        end

        -- preload anims
        for i, animType in pairs(animTable) do
            for idx = 1, animType.count, 1 do
                if PreloadedAnims[animType[idx].anim.AnimationId] == nil then
                    Humanoid:LoadAnimation(animType[idx].anim)
                    PreloadedAnims[animType[idx].anim.AnimationId] = true
                end
            end
        end
    end

    -- Setup animation objects
    function scriptChildModified(child)
        local fileList = animNames[child.Name]
        if (fileList ~= nil) then
            configureAnimationSet(child.Name, fileList)
        else
            if child:isA("StringValue") then
                animNames[child.Name] = {}
                configureAnimationSet(child.Name, animNames[child.Name])
            end
        end
    end

    script.ChildAdded:connect(scriptChildModified)
    script.ChildRemoved:connect(scriptChildModified)

    -- Clear any existing animation tracks
    -- Fixes issue with characters that are moved in and out of the Workspace accumulating tracks
    local animator = if Humanoid then Humanoid:FindFirstChildOfClass("Animator") else nil
    if animator then
        local animTracks = animator:GetPlayingAnimationTracks()
        for i,track in ipairs(animTracks) do
            track:Stop(0)
            track:Destroy()
        end
    end

    for name, fileList in pairs(animNames) do
        configureAnimationSet(name, fileList)
    end
    for _,child in script:GetChildren() do
        if child:isA("StringValue") and not animNames[child.name] then
            animNames[child.Name] = {}
            configureAnimationSet(child.Name, animNames[child.Name])
        end
    end

    -- ANIMATION

    -- declarations
    local toolAnim = "None"
    local toolAnimTime = 0

    local jumpAnimTime = 0
    local jumpAnimDuration = 0.31

    local toolTransitionTime = 0.1
    local fallTransitionTime = 0.2

    local currentlyPlayingEmote = false

    -- functions

    function stopAllAnimations()
        local oldAnim = currentAnim

        -- return to idle if finishing an emote
        if (emoteNames[oldAnim] ~= nil and emoteNames[oldAnim] == false) then
            oldAnim = "idle"
        end

        if currentlyPlayingEmote then
            oldAnim = "idle"
            currentlyPlayingEmote = false
        end

        currentAnim = ""
        currentAnimInstance = nil
        if (currentAnimKeyframeHandler ~= nil) then
            currentAnimKeyframeHandler:disconnect()
        end

        if (currentAnimTrack ~= nil) then
            currentAnimTrack:Stop()
            currentAnimTrack:Destroy()
            currentAnimTrack = nil
        end

        for _,v in pairs(locomotionMap) do
            if v.track then
                v.track:Stop()
                v.track:Destroy()
                v.track = nil
            end
        end

        return oldAnim
    end

    function getHeightScale()
        if Humanoid then
            if not Humanoid.AutomaticScalingEnabled then
                return 1
            end

            local scale = Humanoid.HipHeight / HumanoidHipHeight
            if AnimationSpeedDampeningObject == nil then
                AnimationSpeedDampeningObject = script:FindFirstChild("ScaleDampeningPercent")
            end
            if AnimationSpeedDampeningObject ~= nil then
                scale = 1 + (Humanoid.HipHeight - HumanoidHipHeight) * AnimationSpeedDampeningObject.Value / HumanoidHipHeight
            end
            return scale
        end
        return 1
    end


    local function signedAngle(a, b)
        return -math.atan2(a.x * b.y - a.y * b.x, a.x * b.x + a.y * b.y)
    end

    local angleWeight = 2.0
    local function get2DWeight(px, p1, p2, sx, s1, s2)
        local avgLength = 0.5 * (s1 + s2)

        local p_1 = {x = (sx - s1)/avgLength, y = (angleWeight * signedAngle(p1, px))}
        local p12 = {x = (s2 - s1)/avgLength, y = (angleWeight * signedAngle(p1, p2))}
        local denom = smallButNotZero + (p12.x*p12.x + p12.y*p12.y)
        local numer = p_1.x * p12.x + p_1.y * p12.y
        local r = math.clamp(1.0 - numer/denom, 0.0, 1.0)
        return r
    end

    local function blend2D(targetVelo, targetSpeed)
        local h = {}
        local sum = 0.0
        for n,v1 in pairs(locomotionMap) do
            if targetVelo.x * v1.lv.x < 0.0 or targetVelo.y * v1.lv.y < 0 then
                -- Require same quadrant as target
                h[n] = 0.0
                continue
            end
            h[n] = math.huge
            for j,v2 in pairs(locomotionMap) do
                if targetVelo.x * v2.lv.x < 0.0 or targetVelo.y * v2.lv.y < 0 then
                    -- Require same quadrant as target
                    continue
                end
                h[n] = math.min(h[n], get2DWeight(targetVelo, v1.lv, v2.lv, targetSpeed, v1.speed, v2.speed))
            end
            sum += h[n]
        end

        --truncates below 10% contribution
        local sum2 = 0.0
        local weightedVeloX = 0
        local weightedVeloY = 0
        for n,v in pairs(locomotionMap) do

            if (h[n] / sum > 0.1) then
                sum2 += h[n]
                weightedVeloX += h[n] * v.lv.x
                weightedVeloY += h[n] * v.lv.y
            else
                h[n] = 0.0
            end
        end
        local animSpeed
        local weightedSpeedSquared = weightedVeloX * weightedVeloX + weightedVeloY * weightedVeloY
        if weightedSpeedSquared > smallButNotZero then
            animSpeed = math.sqrt(targetSpeed * targetSpeed / weightedSpeedSquared)
        else
            animSpeed = 0
        end

        animSpeed = animSpeed / getHeightScale()
        local groupTimePosition = 0
        for n,v in pairs(locomotionMap) do
            if v.track.IsPlaying then
                groupTimePosition = v.track.TimePosition
                break
            end
        end
        for n,v in pairs(locomotionMap) do
            -- if not loco
            if h[n] > 0.0 then
                if not v.track.IsPlaying then
                    v.track:Play(runBlendtime)
                    v.track.TimePosition = groupTimePosition
                end

                local weight = math.max(smallButNotZero, h[n] / sum2)
                v.track:AdjustWeight(weight, runBlendtime)
                v.track:AdjustSpeed(animSpeed)
            else
                v.track:Stop(runBlendtime)
            end
        end

    end

    local function getWalkDirection()
        local walkToPoint = Humanoid.WalkToPoint
        local walkToPart = Humanoid.WalkToPart
        if Humanoid.MoveDirection ~= Vector3.zero then
            return Humanoid.MoveDirection
        elseif walkToPart or walkToPoint ~= Vector3.zero then
            local destination
            if walkToPart then
                destination = walkToPart.CFrame:PointToWorldSpace(walkToPoint)
            else
                destination = walkToPoint
            end
            local moveVector = Vector3.zero
            if Humanoid.RootPart then
                moveVector = destination - Humanoid.RootPart.CFrame.Position
                moveVector = Vector3.new(moveVector.x, 0.0, moveVector.z)
                local mag = moveVector.Magnitude
                if mag > 0.01 then
                    moveVector /= mag
                end
            end
            return moveVector
        else
            return Humanoid.MoveDirection
        end
    end

    local function updateVelocity(currentTime)

        local tempDir

        if locomotionMap == strafingLocomotionMap then

            local moveDirection = getWalkDirection()

            if not Humanoid.RootPart then
                return
            end

            local cframe = Humanoid.RootPart.CFrame
            if math.abs(cframe.UpVector.Y) < smallButNotZero or pose ~= "Running" or humanoidSpeed < 0.001 then
                -- We are horizontal!  Do something  (turn off locomotion)
                for n,v in pairs(locomotionMap) do
                    if v.track then
                        v.track:AdjustWeight(smallButNotZero, runBlendtime)
                    end
                end
                return
            end
            local lookat = cframe.LookVector
            local direction = Vector3.new(lookat.X, 0.0, lookat.Z)
            direction = direction / direction.Magnitude --sensible upVector means this is non-zero.
            local ly = moveDirection:Dot(direction)
            if ly <= 0.0 and ly > -0.05 then
                ly = smallButNotZero -- break quadrant ties in favor of forward-friendly strafes
            end
            local lx = direction.X*moveDirection.Z - direction.Z*moveDirection.X
            local tempDir = Vector2.new(lx, ly) -- root space moveDirection
            local delta = Vector2.new(tempDir.x-cachedLocalDirection.x, tempDir.y-cachedLocalDirection.y)
            -- Time check serves the purpose of the old keyframeReached sync check, as it syncs anim timePosition
            if delta:Dot(delta) > 0.001 or math.abs(humanoidSpeed - cachedRunningSpeed) > 0.01 or currentTime - lastBlendTime > 1 then
                cachedLocalDirection = tempDir
                cachedRunningSpeed = humanoidSpeed
                lastBlendTime = currentTime
                blend2D(cachedLocalDirection, cachedRunningSpeed)
            end
        else
            if math.abs(humanoidSpeed - cachedRunningSpeed) > 0.01 or currentTime - lastBlendTime > 1 then
                cachedRunningSpeed = humanoidSpeed
                lastBlendTime = currentTime
                blend2D(Vector2.yAxis, cachedRunningSpeed)
            end
        end
    end

    function setAnimationSpeed(speed)
        if currentAnim ~= "walk" then
            if speed ~= currentAnimSpeed then
                currentAnimSpeed = speed
                currentAnimTrack:AdjustSpeed(currentAnimSpeed)
            end
        end
    end

    function keyFrameReachedFunc(frameName)
        if (frameName == "End") then
            local repeatAnim = currentAnim
            -- return to idle if finishing an emote
            if (emoteNames[repeatAnim] ~= nil and emoteNames[repeatAnim] == false) then
                repeatAnim = "idle"
            end

            if currentlyPlayingEmote then
                if currentAnimTrack.Looped then
                    -- Allow the emote to loop
                    return
                end

                repeatAnim = "idle"
                currentlyPlayingEmote = false
            end

            local animSpeed = currentAnimSpeed
            playAnimation(repeatAnim, 0.15, Humanoid)
            setAnimationSpeed(animSpeed)
        end
    end

    function rollAnimation(animName)
        local roll = math.random(1, animTable[animName].totalWeight)
        local origRoll = roll
        local idx = 1
        while (roll > animTable[animName][idx].weight) do
            roll = roll - animTable[animName][idx].weight
            idx = idx + 1
        end
        return idx
    end

    local maxVeloX, minVeloX, maxVeloY, minVeloY

    local function destroyRunAnimations()
        for _,v in pairs(strafingLocomotionMap) do
            if v.track then
                v.track:Stop()
                v.track:Destroy()
                v.track = nil
            end
        end
        for _,v in pairs(fallbackLocomotionMap) do
            if v.track then
                v.track:Stop()
                v.track:Destroy()
                v.track = nil
            end
        end
        cachedRunningSpeed = 0
    end

    local function resetVelocityBounds(velo)
        minVeloX = 0
        maxVeloX = 0
        minVeloY = 0
        maxVeloY = 0
    end

    local function updateVelocityBounds(velo)
        if velo then
            if velo.x > maxVeloX then maxVeloX = velo.x end
            if velo.y > maxVeloY then maxVeloY = velo.y end
            if velo.x < minVeloX then minVeloX = velo.x end
            if velo.y < minVeloY then minVeloY = velo.y end
        end
    end

    local function checkVelocityBounds(velo)
        if maxVeloX == 0 or minVeloX == 0 or maxVeloY == 0 or minVeloY == 0 then
            if locomotionMap == strafingLocomotionMap then
                warn("Strafe blending disabled.  Not all quadrants of motion represented.")
            end
            locomotionMap = fallbackLocomotionMap
        else
            locomotionMap = strafingLocomotionMap
        end
    end

    local function setupWalkAnimation(anim, animName, transitionTime, humanoid)
        resetVelocityBounds()
        -- check to see if we need to blend a walk/run animation
        for n,v in pairs(locomotionMap) do
            v.track = humanoid:LoadAnimation(animTable[n][1].anim)
            v.track.Priority = Enum.AnimationPriority.Core
            updateVelocityBounds(v.lv)
        end
        checkVelocityBounds()
    end

    local function switchToAnim(anim, animName, transitionTime, humanoid)
        -- switch animation
        if (anim ~= currentAnimInstance) then

            if (currentAnimTrack ~= nil) then
                currentAnimTrack:Stop(transitionTime)
                currentAnimTrack:Destroy()
            end
            if (currentAnimKeyframeHandler ~= nil) then
                currentAnimKeyframeHandler:disconnect()
            end


            currentAnimSpeed = 1.0

            currentAnim = animName
            currentAnimInstance = anim  -- nil in the case of locomotion

            if animName == "walk" then
                setupWalkAnimation(anim, animName, transitionTime, humanoid)
            else
                destroyRunAnimations()
                -- load it to the humanoid; get AnimationTrack
                currentAnimTrack = humanoid:LoadAnimation(anim)
                currentAnimTrack.Priority = Enum.AnimationPriority.Core

                currentAnimTrack:Play(transitionTime)

                -- set up keyframe name triggers
                currentAnimKeyframeHandler = currentAnimTrack.KeyframeReached:connect(keyFrameReachedFunc)
            end
        end
    end

    function playAnimation(animName, transitionTime, humanoid)
        local idx = rollAnimation(animName)
        local anim = animTable[animName][idx].anim

        switchToAnim(anim, animName, transitionTime, humanoid)
        currentlyPlayingEmote = false
    end

    function playEmote(emoteAnim, transitionTime, humanoid)
        switchToAnim(emoteAnim, emoteAnim.Name, transitionTime, humanoid)
        currentlyPlayingEmote = true
    end

    -------------------------------------------------------------------------------------------
    -------------------------------------------------------------------------------------------

    local toolAnimName = ""
    local toolAnimTrack = nil
    local toolAnimInstance = nil
    local currentToolAnimKeyframeHandler = nil

    function toolKeyFrameReachedFunc(frameName)
        if (frameName == "End") then
            playToolAnimation(toolAnimName, 0.0, Humanoid)
        end
    end


    function playToolAnimation(animName, transitionTime, humanoid, priority)
        local idx = rollAnimation(animName)
        local anim = animTable[animName][idx].anim

        if (toolAnimInstance ~= anim) then

            if (toolAnimTrack ~= nil) then
                toolAnimTrack:Stop()
                toolAnimTrack:Destroy()
                transitionTime = 0
            end

            -- load it to the humanoid; get AnimationTrack
            toolAnimTrack = humanoid:LoadAnimation(anim)
            if priority then
                toolAnimTrack.Priority = priority
            end

            -- play the animation
            toolAnimTrack:Play(transitionTime)
            toolAnimName = animName
            toolAnimInstance = anim

            currentToolAnimKeyframeHandler = toolAnimTrack.KeyframeReached:connect(toolKeyFrameReachedFunc)
        end
    end

    function stopToolAnimations()
        local oldAnim = toolAnimName

        if (currentToolAnimKeyframeHandler ~= nil) then
            currentToolAnimKeyframeHandler:disconnect()
        end

        toolAnimName = ""
        toolAnimInstance = nil
        if (toolAnimTrack ~= nil) then
            toolAnimTrack:Stop()
            toolAnimTrack:Destroy()
            toolAnimTrack = nil
        end

        return oldAnim
    end

    -------------------------------------------------------------------------------------------
    -------------------------------------------------------------------------------------------
    -- STATE CHANGE HANDLERS

    function onRunning(speed)
        local movedDuringEmote = currentlyPlayingEmote and Humanoid.MoveDirection == Vector3.new(0, 0, 0)
        local speedThreshold = movedDuringEmote and Humanoid.WalkSpeed or 0.75
        humanoidSpeed = speed
        if speed > speedThreshold then
            playAnimation("walk", 0.2, Humanoid)
            if pose ~= "Running" then
                pose = "Running"
                updateVelocity(0) -- Force velocity update in response to state change
            end
        else
            if emoteNames[currentAnim] == nil and not currentlyPlayingEmote then
                playAnimation("idle", 0.2, Humanoid)
                pose = "Standing"
            end
        end



    end

    function onDied()
        pose = "Dead"
    end

    function onJumping()
        playAnimation("jump", 0.1, Humanoid)
        jumpAnimTime = jumpAnimDuration
        pose = "Jumping"
    end

    function onClimbing(speed)
        local scale = 5.0
        playAnimation("climb", 0.1, Humanoid)
        setAnimationSpeed(speed / scale)
        pose = "Climbing"
    end

    function onGettingUp()
        pose = "GettingUp"
    end

    function onFreeFall()
        if (jumpAnimTime <= 0) then
            playAnimation("fall", fallTransitionTime, Humanoid)
        end
        pose = "FreeFall"
    end

    function onFallingDown()
        pose = "FallingDown"
    end

    function onSeated()
        pose = "Seated"
    end

    function onPlatformStanding()
        pose = "PlatformStanding"
    end

    -------------------------------------------------------------------------------------------
    -------------------------------------------------------------------------------------------

    function onSwimming(speed)
        if speed > 0 then
            pose = "Running"
        else
            pose = "Standing"
        end
    end

    function animateTool()
        if (toolAnim == "None") then
            playToolAnimation("toolnone", toolTransitionTime, Humanoid, Enum.AnimationPriority.Idle)
            return
        end

        if (toolAnim == "Slash") then
            playToolAnimation("toolslash", 0, Humanoid, Enum.AnimationPriority.Action)
            return
        end

        if (toolAnim == "Lunge") then
            playToolAnimation("toollunge", 0, Humanoid, Enum.AnimationPriority.Action)
            return
        end
    end

    function getToolAnim(tool)
        for _, c in ipairs(tool:GetChildren()) do
            if c.Name == "toolanim" and c.className == "StringValue" then
                return c
            end
        end
        return nil
    end

    local lastTick = 0

    function stepAnimate(currentTime)
        local amplitude = 1
        local frequency = 1
        local deltaTime = currentTime - lastTick
        lastTick = currentTime

        local climbFudge = 0
        local setAngles = false

        if (jumpAnimTime > 0) then
            jumpAnimTime = jumpAnimTime - deltaTime
        end

        if (pose == "FreeFall" and jumpAnimTime <= 0) then
            playAnimation("fall", fallTransitionTime, Humanoid)
        elseif (pose == "Seated") then
            playAnimation("sit", 0.5, Humanoid)
            return
        elseif (pose == "Running") then
            playAnimation("walk", 0.2, Humanoid)
            updateVelocity(currentTime)
        elseif (pose == "Dead" or pose == "GettingUp" or pose == "FallingDown" or pose == "Seated" or pose == "PlatformStanding") then
            stopAllAnimations()
            amplitude = 0.1
            frequency = 1
            setAngles = true
        end

        -- Tool Animation handling
        local tool = Character:FindFirstChildOfClass("Tool")
        if tool and tool:FindFirstChild("Handle") then
            local animStringValueObject = getToolAnim(tool)

            if animStringValueObject then
                toolAnim = animStringValueObject.Value
                -- message recieved, delete StringValue
                animStringValueObject.Parent = nil
                toolAnimTime = currentTime + .3
            end

            if currentTime > toolAnimTime then
                toolAnimTime = 0
                toolAnim = "None"
            end

            animateTool()
        else
            stopToolAnimations()
            toolAnim = "None"
            toolAnimInstance = nil
            toolAnimTime = 0
        end
    end


    -- connect events
    Humanoid.Died:connect(onDied)
    Humanoid.Running:connect(onRunning)
    Humanoid.Jumping:connect(onJumping)
    Humanoid.Climbing:connect(onClimbing)
    Humanoid.GettingUp:connect(onGettingUp)
    Humanoid.FreeFalling:connect(onFreeFall)
    Humanoid.FallingDown:connect(onFallingDown)
    Humanoid.Seated:connect(onSeated)
    Humanoid.PlatformStanding:connect(onPlatformStanding)
    Humanoid.Swimming:connect(onSwimming)

    -- setup emote chat hook
    game:GetService("Players").LocalPlayer.Chatted:connect(function(msg)
        local emote = ""
        if (string.sub(msg, 1, 3) == "/e ") then
            emote = string.sub(msg, 4)
        elseif (string.sub(msg, 1, 7) == "/emote ") then
            emote = string.sub(msg, 8)
        end

        if (pose == "Standing" and emoteNames[emote] ~= nil) then
            playAnimation(emote, EMOTE_TRANSITION_TIME, Humanoid)
        end
    end)

    -- emote bindable hook
    script:WaitForChild("PlayEmote").OnInvoke = function(emote)
        -- Only play emotes when idling
        if pose ~= "Standing" then
            return
        end

        if emoteNames[emote] ~= nil then
            -- Default emotes
            playAnimation(emote, EMOTE_TRANSITION_TIME, Humanoid)

            return true, currentAnimTrack
        elseif typeof(emote) == "Instance" and emote:IsA("Animation") then
            -- Non-default emotes
            playEmote(emote, EMOTE_TRANSITION_TIME, Humanoid)

            return true, currentAnimTrack
        end

        -- Return false to indicate that the emote could not be played
        return false
    end

    if Character.Parent ~= nil then
        -- initialize to idle
        playAnimation("idle", 0.1, Humanoid)
        pose = "Standing"
    end

    -- loop to handle timed state transitions and tool animations
    task.spawn(function()
        while Character.Parent ~= nil do
            local _, currentGameTime = wait(0.1)
            stepAnimate(currentGameTime)
        end
    end)
end

RunCustomAnimation(plr.Character)

plr.CharacterAdded:Connect(function(Char)
    RunCustomAnimation(Char)
end)