Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- 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)
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement