Dynamic Animation Script [Roblox Studio]

--[[
    Script modified by Kript0's Proyect
    Original Script from Air Proyect (Daniel)

    Delete this message if you want to
]]--

local Character = script.Parent
local Humanoid = Character:WaitForChild("Humanoid")
local pose = "Standing"
local UserInputService = game:GetService("UserInputService")

local userNoUpdateOnLoopSuccess, userNoUpdateOnLoopValue = pcall(function() return UserSettings():IsUserFeatureEnabled("UserNoUpdateOnLoop") end)
local userNoUpdateOnLoop = userNoUpdateOnLoopSuccess and userNoUpdateOnLoopValue
local userAnimationSpeedDampeningSuccess, userAnimationSpeedDampeningValue = pcall(function() return UserSettings():IsUserFeatureEnabled("UserAnimationSpeedDampening") end)
local userAnimationSpeedDampening = userAnimationSpeedDampeningSuccess and userAnimationSpeedDampeningValue
local animateScriptEmoteHookFlagExists, animateScriptEmoteHookFlagEnabled = pcall(function()
    return UserSettings():IsUserFeatureEnabled("UserAnimateScriptEmoteHook")
end)
local FFlagAnimateScriptEmoteHook = animateScriptEmoteHookFlagExists and animateScriptEmoteHookFlagEnabled
local AnimationSpeedDampeningObject = script:FindFirstChild("ScaleDampeningPercent")
local HumanoidHipHeight = 2
local EMOTE_TRANSITION_TIME = 0.1
local currentAnim = ""
local currentAnimInstance = nil
local currentAnimTrack = nil
local currentAnimKeyframeHandler = nil
local currentAnimSpeed = 2
Character:WaitForChild("HumanoidRootPart").Running.Volume = 0
local smallButNotZero = 0.0001
local hrp = Character:WaitForChild("HumanoidRootPart")

local runTracks = {
    run = {
        track = nil,
        handler = nil,
        lastWeight = smallButNotZero,
    },
    walk = {
        track = nil,
        handler = nil,
        lastWeight = smallButNotZero,
    },
    back = {
        track = nil,
        handler = nil,
        lastWeight = smallButNotZero,
    },
    left = {
        track = nil,
        handler = nil,
        lastWeight = smallButNotZero,
    },
    right = {
        track = nil,
        handler = nil,
        lastWeight = smallButNotZero,
    },
}
local wasStrafe = false

local function doForAllRunTracks(func)
    for name, track in pairs(runTracks) do
        func(track, name)
    end
end

local animTable = {}
local animNames = {
    idle =  {
        { id = "http://www.roblox.com/asset/?id=14949780617", weight = 1 },
        { id = "http://www.roblox.com/asset/?id=14949780617", weight = 1 },
        { id = "http://www.roblox.com/asset/?id=14949780617", weight = 9 }
            },
    walk =  {
        { id = "http://www.roblox.com/asset/?id=14949724983", weight = 10 }
            },
    run =   {
        { id = "http://www.roblox.com/asset/?id=8304552165", weight = 10 }
            },
    back =  {
        { id = "http://www.roblox.com/asset/?id=8500469730", weight = 10 }
            },
    left =  {
        { id = "http://www.roblox.com/asset/?id=8500427567", weight = 10 }
            },
    right =     {
        { id = "http://www.roblox.com/asset/?id=8500441178", weight = 10 }
            },
    swim =  {
                { id = "http://www.roblox.com/asset/?id=507784897", weight = 10 }
            },
    swimidle =  {
                { id = "http://www.roblox.com/asset/?id=507785072", weight = 10 }
            },
    jump =  {
            { id = "http://www.roblox.com/asset/?id=8301607806", weight = 10 }
            },
    fall =  {
            { id = "http://www.roblox.com/asset/?id=8301541853", weight = 10 }
            },
    climb = {
                { id = "http://www.roblox.com/asset/?id=507765644", weight = 10 }
            },
    sit =   {
                { id = "http://www.roblox.com/asset/?id=2506281703", weight = 10 }
            },
    toolnone = {
                { id = "http://www.roblox.com/asset/?id=507768375", weight = 10 }
            },
    toolslash = {
                { id = "http://www.roblox.com/asset/?id=522635514", weight = 10 }
            },
    toollunge = {
                { id = "http://www.roblox.com/asset/?id=522638767", weight = 10 }
            },
    wave = {
                { id = "http://www.roblox.com/asset/?id=507770239", weight = 10 }
            },
    point = {
                { id = "http://www.roblox.com/asset/?id=507770453", weight = 10 }
            },
    dance = {
                { id = "http://www.roblox.com/asset/?id=507771019", weight = 10 },
                { id = "http://www.roblox.com/asset/?id=507771955", weight = 10 },
                { id = "http://www.roblox.com/asset/?id=507772104", weight = 10 }
            },
    dance2 = {
                { id = "http://www.roblox.com/asset/?id=507776043", weight = 10 },
                { id = "http://www.roblox.com/asset/?id=507776720", weight = 10 },
                { id = "http://www.roblox.com/asset/?id=507776879", weight = 10 }
            },
    dance3 = {
                { id = "http://www.roblox.com/asset/?id=507777268", weight = 10 },
                { id = "http://www.roblox.com/asset/?id=507777451", weight = 10 },
                { id = "http://www.roblox.com/asset/?id=507777623", weight = 10 }
            },
    laugh = {
                { id = "http://www.roblox.com/asset/?id=507770818", weight = 10 }
            },
    cheer = {
                { id = "http://www.roblox.com/asset/?id=507770677", weight = 10 }
            },
}


local emoteNames = { wave = false, point = false, dance = true, dance2 = true, dance3 = true, laugh = false, cheer = false}

local PreloadAnimsUserFlag = false
local PreloadedAnims = {}
local successPreloadAnim, msgPreloadAnim = pcall(function()
    PreloadAnimsUserFlag = UserSettings():IsUserFeatureEnabled("UserPreloadAnimations")
end)
if not successPreloadAnim then
    PreloadAnimsUserFlag = false
end

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 = {}
    local allowCustomAnimations = true
    local success, msg = pcall(function() allowCustomAnimations = game:GetService("StarterPlayer").AllowCustomAnimations end)
    if not success then
        allowCustomAnimations = true
    end
    -- check for config values
    local config = script:FindFirstChild(name)
    if (allowCustomAnimations and 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))
            end
        end
    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
    if PreloadAnimsUserFlag then
        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
end
------------------------------------------------------------------------------------------------------------
function configureAnimationSetOld(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 = {}

    local allowCustomAnimations = true

    local success, msg = pcall(function() allowCustomAnimations = game:GetService("StarterPlayer").AllowCustomAnimations end)
    if not success then
        allowCustomAnimations = true
    end

    -- check for config values
    local config = script:FindFirstChild(name)
    if (allowCustomAnimations and 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 = 1
        for _, childPart in pairs(config:GetChildren()) do
            if (childPart:IsA("Animation")) then
                table.insert(animTable[name].connections, childPart.Changed:connect(function(property) configureAnimationSet(name, fileList) end))
                animTable[name][idx] = {}
                animTable[name][idx].anim = childPart
                local weightObject = childPart:FindFirstChild("Weight")
                if (weightObject == nil) then
                    animTable[name][idx].weight = 1
                else
                    animTable[name][idx].weight = weightObject.Value
                end
                animTable[name].count = animTable[name].count + 1
                animTable[name].totalWeight = animTable[name].totalWeight + animTable[name][idx].weight
                idx = idx + 1
            end
        end
    end

    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

    if PreloadAnimsUserFlag then
        for i, animType in pairs(animTable) do
            for idx = 1, animType.count, 1 do
                Humanoid:LoadAnimation(animType[idx].anim)
            end
        end
    end
end

-- Setup animation objects
function scriptChildModified(child)
    local fileList = animNames[child.Name]
    if (fileList ~= nil) then
        configureAnimationSet(child.Name, fileList)
    end
end

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

for name, fileList in pairs(animNames) do
    configureAnimationSet(name, fileList)
end

-- declarations
local jumpAnimTime = 0
local jumpAnimDuration = 0.2
local toolTransitionTime = 0.1
local fallTransitionTime = 0.2
local currentlyPlayingEmote = false

-- functions
function stopAllAnimations()
    local oldAnim = currentAnim

    if (emoteNames[oldAnim] ~= nil and emoteNames[oldAnim] == false) then
        oldAnim = "idle"
    end

    if FFlagAnimateScriptEmoteHook and 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

    doForAllRunTracks(function(trackRec, name)
        if trackRec.handler ~= nil then
            trackRec.handler:disconnect()
        end
    end)

    doForAllRunTracks(function(trackRec, name)
        if (trackRec.track ~= nil) then
            trackRec.track:Stop()
            trackRec.track:Destroy()
            trackRec.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 userAnimationSpeedDampening then
            if AnimationSpeedDampeningObject == nil then
                AnimationSpeedDampeningObject = script:FindFirstChild("ScaleDampeningPercent")
            end
            if AnimationSpeedDampeningObject ~= nil then
                scale = 1 + (Humanoid.HipHeight - HumanoidHipHeight) * AnimationSpeedDampeningObject.Value / HumanoidHipHeight
            end
        end
        return scale
    end
    return 1
end

-------------------- TODO
local upVec = Vector3.new(0, 1, 0)
local blendTime = 0.2

function setRunSpeed()
    if UserInputService.MouseBehavior == Enum.MouseBehavior.LockCenter then
        local currWeight = {
            run = smallButNotZero,
            walk = smallButNotZero,
            back = smallButNotZero,
            left = smallButNotZero,
            right = smallButNotZero,
        }
        local camLookVec = workspace.Camera.CFrame.LookVector
        local camLookVecFlat = Vector3.new(camLookVec.x, 0, camLookVec.z).Unit
        local hrpVel = hrp.Velocity
        local hrpVelFlat = Vector3.new(hrpVel.x, 0, hrpVel.z)
        local hrpDir = hrpVelFlat.Unit
        local forwardDot = hrpDir:Dot(camLookVecFlat)
        local rightVec = camLookVecFlat:Cross(upVec)
        local rightDot = hrpDir:Dot(rightVec)

        if Humanoid.WalkSpeed > 7 then
            if forwardDot > 0.1 then
                currWeight.walk = forwardDot
            elseif forwardDot < -0.1 then
                currWeight.back = - forwardDot
            end
            if rightDot > 0.1 then
                currWeight.right = rightDot
            elseif rightDot < -0.1 then
                currWeight.left = - rightDot
            end
        end
        doForAllRunTracks(function(trackRec, name)
            if currWeight[name] ~= trackRec.lastWeight then
                trackRec.track:AdjustWeight(currWeight[name], blendTime)
                trackRec.lastWeight = currWeight[name]
            end
        end)

        local lastSpeed = 1
        doForAllRunTracks(function(trackRec, name)
            trackRec.track:AdjustSpeed(lastSpeed, blendTime)
        end)
    end
end

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

function keyFrameReachedFunc(frameName)
    if (frameName == "End") then
        if currentAnim == "walk" then
            if userNoUpdateOnLoop == true then
                doForAllRunTracks(function(trackRec)
                    if trackRec.track.Looped ~= true then
                        trackRec.track.TimePosition = 0.0
                    end
                end)
                if currentAnimTrack.Looped ~= true then
                    currentAnimTrack.TimePosition = 0.0
                end
            else
                doForAllRunTracks(function(trackRec)
                    if trackRec.track.Looped ~= true then
                        trackRec.track.TimePosition = 0.0
                    end
                end)
                currentAnimTrack.TimePosition = 0.0
            end
        else
            local repeatAnim = currentAnim
            -- return to idle if finishing an emote
            if (emoteNames[repeatAnim] ~= nil and emoteNames[repeatAnim] == false) then
                repeatAnim = "idle"
            end

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

                repeatAnim = "idle"
                currentlyPlayingEmote = false
            end

            local animSpeed = 1
            playAnimation(repeatAnim, 0.2, Humanoid)
            setAnimationSpeed(animSpeed)
        end
    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 function switchToAnim(anim, animName, transitionTime, humanoid)
    -- switch animation
    if (anim ~= currentAnimInstance) then

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

        doForAllRunTracks(function(trackRec)
            if (trackRec.track ~= nil) then
                trackRec.track:Stop(transitionTime)
                trackRec.track:Destroy()
                if userNoUpdateOnLoop == true then
                    trackRec.track = nil
                end
            end
        end)
        currentAnimSpeed = 1.0

        -- load it to the humanoid; get AnimationTrack
        currentAnimTrack = humanoid:LoadAnimation(anim)
        currentAnimTrack.Priority = Enum.AnimationPriority.Core

        -- play the animation
        currentAnimTrack:Play(transitionTime)
        currentAnim = animName
        currentAnimInstance = anim

        -- set up keyframe name triggers
        if (currentAnimKeyframeHandler ~= nil) then
            currentAnimKeyframeHandler:disconnect()
        end
        currentAnimKeyframeHandler = currentAnimTrack.KeyframeReached:connect(keyFrameReachedFunc)

        -- check to see if we need to blend a walk/run animation
        if animName == "walk" then
            doForAllRunTracks(function(trackRec, runAnimName)
                local runIdx = rollAnimation(runAnimName)

                trackRec.track = humanoid:LoadAnimation(animTable[runAnimName][runIdx].anim)
                trackRec.track.Priority = Enum.AnimationPriority.Core
                trackRec.track:Play(transitionTime)
                trackRec.track:AdjustWeight(smallButNotZero, 0)
                trackRec.lastWeight = smallButNotZero

                if (trackRec.handler ~= nil) then
                    trackRec.handler:disconnect()
                end
                trackRec.handler = trackRec.track.KeyframeReached:connect(keyFrameReachedFunc)
            end)
        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 onRunning(speed)
    if speed > 0 then
        playAnimation("walk", 0.3, Humanoid)
        setAnimationSpeed(1)
        pose = "Running"
    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.2, 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 > 1.00 then
        local scale = 10.0
        playAnimation("swim", 0.4, Humanoid)
        setAnimationSpeed(speed / scale)
        pose = "Swimming"
    else
        playAnimation("swimidle", 0.4, Humanoid)
        pose = "Standing"
    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.9, Humanoid)
        if UserInputService.MouseBehavior == Enum.MouseBehavior.LockCenter then
            if not wasStrafe then
                doForAllRunTracks(function(trackRec, name)
                    trackRec.track:AdjustWeight(smallButNotZero, blendTime)
                    trackRec.lastWeight = smallButNotZero
                end)
            end
            setRunSpeed()
            wasStrafe = true
        else
            if wasStrafe then
                doForAllRunTracks(function(trackRec, name)
                    trackRec.track:AdjustWeight(smallButNotZero, blendTime)
                    trackRec.lastWeight = smallButNotZero
                end)
                setRunSpeed()
                wasStrafe = false
            end
        end
    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
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)

-- initialize to idle
playAnimation("idle", 0.1, Humanoid)
pose = "Standing"

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