belt

-- animator

local function init()
    local JointData = {}
    JointData["Right Shoulder"] = CFrame.new(1, 0.5, 0, 0, 0, 1, 0, 1, -0, -1, 0, 0)
    JointData["Left Shoulder"] = CFrame.new(-1, 0.5, 0, 0, 0, -1, 0, 1, 0, 1, 0, 0)
    JointData["Right Hip"] = CFrame.new(1, -1, 0, 0, 0, 1, 0, 1, -0, -1, 0, 0)
    JointData["Left Hip"] = CFrame.new(-1, -1, 0, 0, 0, -1, 0, 1, 0, 1, 0, 0)
    JointData["Neck"] = CFrame.new(0, 1, 0, -1, 0, 0, 0, 0, 1, 0, 1, -0)
    JointData["RootJoint"] = CFrame.new(0, 0, 0, -1, 0, 0, 0, 0, 1, 0, 1, -0)

    local Animator = {}
    local Playing = {}
    local JointC0 = {}

    local GlobalPlaying = _G['GlobalPlaying']
    if not GlobalPlaying then
        _G['GlobalPlaying'] = {}
        GlobalPlaying = _G['GlobalPlaying']
    end

    local global_welds = _G['global_welds']
    if not global_welds then
        _G['global_welds'] = {}
        global_welds = _G['global_welds']
    end

    local TS = game:GetService("TweenService")

    local function Ver(Model)
        if Model and Model.Parent then
            if not GlobalPlaying[Model] then
                GlobalPlaying[Model] = {}
            end
            if not Playing[Model] then
                Playing[Model] = {}
                return true
            end
        end
    end

    function Animator.create_welds(targchar)
        if not global_welds[targchar] then else
            return
        end

        local anim_welds = {}
        local char_welds = {}

        for i,v in ipairs(targchar:GetDescendants()) do
            if v:IsA("Motor6D") or v:IsA("Weld") then
                if game:GetService("CollectionService"):HasTag(v,'fakemotor') then
                    anim_welds[v] = v.Part0
                elseif game:GetService("CollectionService"):HasTag(v,'realmotor') then
                    char_welds[v] = v.Part0
                end
            end
        end

        for i,v in ipairs(targchar:GetDescendants()) do
            if v:IsA("Motor6D") and not char_welds[v] then
                local m = Instance.new("Weld")
                m.Name = v.Name
                m.Part0 = v.Part0
                m.Part1 = v.Part1
                m.C0 = v.C0
                m.C1 = v.C1
                m.Parent = v.Parent

                game:GetService("CollectionService"):AddTag(m,'fakemotor')
                game:GetService("CollectionService"):AddTag(v,'realmotor')

                anim_welds[m] = v.Part0
                char_welds[v] = v.Part0
            end
        end

        global_welds[targchar] = {
            anim_welds = anim_welds,
            char_welds = char_welds,
            taid = 0,
        }
    end

    function Animator.toggle_anim(mode,targchar)
        local welds = global_welds[targchar]

        if welds then else
            return
        end

        welds.taid += 1
        local cid = welds.taid

        local function run()
            if cid == welds.taid then else return end
            if mode then
                for i,v in pairs(welds.anim_welds) do
                    i.Enabled = true
                end
                for i,v in pairs(welds.char_welds) do
                    i.Enabled = false
                end
            else
                for i,v in pairs(welds.char_welds) do
                    i.Enabled = true
                end
                for i,v in pairs(welds.anim_welds) do
                    i.Enabled = false
                end
            end
        end

        if not mode then
            task.delay(0.2,run)
        else
            run()
        end

        return cid
    end

    function Animator.get_aid(targchar)
        local welds = global_welds[targchar]
        return welds.taid
    end

    local function Play(self, FadeIn, Speed, Looped)
        self.TimePosition = 0
        self.StartInternal = os.clock()

        self.FadeIn = FadeIn or 0
        self.Speed = Speed or self.Speed
        self.Looped = Looped or self.Looped
        self.LastPlayed = os.clock()
        self.fired = {}
        self.RecoverFade = {}

        local StopEvent = Instance.new("BindableEvent")
        self.Stopped = StopEvent.Event
        self.StopEvent = StopEvent

        local LoopedEvent = Instance.new("BindableEvent")
        self.OnLooped = LoopedEvent.Event
        self.LoopedEvent = LoopedEvent

        local KeyframeReachedEvent = Instance.new("BindableEvent")
        self.KeyframeReached = KeyframeReachedEvent.Event
        self.KeyframeReachedEvent = KeyframeReachedEvent

        local MarkerReachedEvent = Instance.new("BindableEvent")
        self.MarkerReached = MarkerReachedEvent.Event
        self.MarkerReachedEvent = MarkerReachedEvent

        local I = Playing[self.Model]
        if I then else
            return
        end
        self.Playing = true
        I[self] = true
    end

    local function Stop(self,fire)
        local I = Playing[self.Model]
        if I then
            if fire then
                self.StopEvent:Fire()
            end
        end

        self.LastPlayed = 0
        self.Playing = false
        I[self] = nil

        self.Stopped = nil
        if self.StopEvent then
            self.StopEvent:Destroy()
        end
        self.StopEvent = nil

        self.OnLooped = nil
        if self.StopEvent then
            self.LoopedEvent:Destroy()
        end
        self.LoopedEvent = nil

        self.KeyframeReached = nil
        if self.StopEvent then
            self.KeyframeReachedEvent:Destroy()
        end
        self.KeyframeReachedEvent = nil

        self.MarkerReached = nil
        if self.StopEvent then
            self.MarkerReachedEvent:Destroy()
        end
        self.MarkerReachedEvent = nil

        self.FadeIn = nil
    end

    local function Resume(self)
        if self.PauseInternal then
            self.StartInternal = os.clock() - self.PauseInternal
        end
        local I = Playing[self.Model]
        self.Playing = true
        I[self] = true
    end

    local function Pause(self)
        local TimeSince = os.clock() - self.StartInternal
        self.PauseInternal = TimeSince
        local I = Playing[self.Model]
        self.Playing = false
        I[self] = nil
    end

    local function SetTime(self, Time)
        self.StartInternal = os.clock() - Time
    end

    local function AdjustSpeed(self, NewSpeed)
        self.Speed = NewSpeed
    end

    local function ft(t,c)
        for i,v in pairs(t) do
            --if i == 'Parent' or i == 'Name' or i == 'Marker' or i == 'Time' or i == 'CF' then continue end
            if typeof(v) == 'table' then
                ft(v,true)
                local name = v.Name
                v.Name = nil
                local index_t = {
                    Parent = t,
                    Name = name or i,
                }
                if v.Marker then
                    index_t.Marker = v.Marker
                    v.Marker = nil
                end
                if v.Time then
                    index_t.Time = v.Time
                    v.Time = nil
                end
                if v.CF then
                    index_t.CF = v.CF
                    v.CF = nil
                end
                if tonumber(i) and not v.CF then
                    index_t.Time = tonumber(i)
                end
                v = setmetatable(v,{
                    __index = index_t
                })
            end
        end
        return t
    end

    local function iter(t)
        local new_t = {}
        for i,v in pairs(t) do
            --if i == 'Parent' or i == 'Name' or i == 'Marker' or i == 'Time' or i == 'CF' then continue end
            table.insert(new_t,v)
            if typeof(v) == 'table' then
                for ii,vv in pairs(iter(v)) do
                    table.insert(new_t,vv)
                end
            end
        end
        return new_t
    end

    local ModelAnimations = {}
    local hasloaded = {}
    local TrackKeyframes = {}

    function Animator.Preload(Track)
        if TrackKeyframes[Track] then
            return TrackKeyframes[Track]
        end

        Track.Keyframes = ft(Track.Keyframes)
        local kf = Track.Keyframes
        table.sort(kf, function(a, b) return a.Time < b.Time end)

        local Keyframes = {}
        local jdata = {}
        local largest_time = 0

        do
            for STime, SKeyframe in next, kf do
                STime = tonumber(STime)
                if STime > largest_time then
                    largest_time = STime
                end
                local descendants = iter(SKeyframe)

                local function set_marker(name)
                    if not Keyframes['_null'] then
                        Keyframes['_null'] = {}
                    end
                    Keyframes['_null'][#Keyframes['_null'] + 1] = {Time = STime, Name = name, Marker = 1, ["Info"] = nil}
                end

                if 0 >= #descendants then
                    set_marker(SKeyframe.Name)
                end
                for _,Pose in next, descendants do
                    if typeof(Pose) ~= 'table' then continue end
                    if Pose.Name == 'HumanoidRootPart' then continue end

                    if Pose.Marker then
                        set_marker(Pose.Name)
                    end

                    local P0 = Pose.Parent.Name
                    local P1 = Pose.Name

                    local JT = Keyframes[P0..'KEyjtsep'..P1]
                    if not JT then
                        JT = {}
                        Keyframes[P0..'KEyjtsep'..P1] = JT
                        jdata[P0..'KEyjtsep'..P1] = 1
                    end

                    local Style = Pose.ES or 'Linear'
                    local Direction = Pose.ED or 'In'
                    local Weight = Pose.Weight or 1
                    local PCF = Pose.CF

                    if not PCF then continue end

                    local CF
                    for i,v in pairs(PCF) do
                        PCF[i] = tonumber(v)
                    end

                    if PCF[1] then
                        CF = CFrame.new(PCF[1],PCF[2],PCF[3])
                    else
                        CF = CFrame.new()
                    end
                    if PCF[4] then
                        CF = CF*CFrame.Angles(math.rad(PCF[4]),math.rad(PCF[5]),math.rad(PCF[6]))
                    end

                    local Info = {EasingStyle = Style, EasingDirection = Direction, Weight = Weight, CFrame = CF}

                    JT[#JT+1] = {Time = STime, Name = SKeyframe.Name, ["Info"] = Info}
                end
            end

            for Joint,Poses in pairs(Keyframes) do
                table.sort(Poses, function(a, b) return a.Time < b.Time end)
            end

            TrackKeyframes[Track] = {
                Keyframes,
                jdata,
                largest_time
            }

            return TrackKeyframes[Track]
        end
    end

    function Animator.LoadAnimation(Track, Model)
        assert(Track,'No track.')
        assert(Model,'No model.')
        local notmodel
        if not ModelAnimations[Model] then
            notmodel = true
            ModelAnimations[Model] = {}
            ModelAnimations[Model].Joints = {}
        elseif ModelAnimations[Model][Track] then
            return ModelAnimations[Model][Track]
        end
        local Animation = {}
        ModelAnimations[Model][Track] = Animation

        if not hasloaded[Track] then
            Track.Properties.Priority = Enum.AnimationPriority[Track.Properties.Priority]
        end

        local set_model = Ver(Model)

        local largest_time = 0

        if not GlobalPlaying[Model][Animation] then
            GlobalPlaying[Model][Animation] = {}
        end

        if notmodel then
            local function new_joint(Obj)
                if Obj:IsA("Weld") then
                    local P0 = Obj.Part0
                    local P1 = Obj.Part1
                    if not P0 or not P1 then return end

                    local jd = JointData[Obj.Name]
                    if jd then
                        Obj.C0 = jd
                        JointC0[Obj] = jd
                    else
                        JointC0[Obj] = Obj.C0
                    end

                    local T = ModelAnimations[Model].Joints[P0.Name]
                    if not T then
                        T = {}
                        ModelAnimations[Model].Joints[P0.Name] = T
                    end
                    if not T[P1.Name] then
                        T[P1.Name] = Obj
                    end
                end
            end

            for _,v in ipairs(Model:GetDescendants()) do
                new_joint(v)
            end
            Model.DescendantAdded:Connect(new_joint)
        end

        local track_data = Animator.Preload(Track)
        if track_data then
            local Keyframes,jdata,lt = unpack(track_data)
            Animation.Keyframes = Keyframes
            GlobalPlaying[Model][Animation] = jdata
            largest_time = lt
        else
            error('No track preloaded.')
        end

        Animation.TimePosition = 0
        Animation.TimeLength = largest_time
        Animation.Track = Track
        Animation.Model = Model
        Animation.TimeScale = 1
        Animation.GeneralWeight = 1
        Animation.Play = Play
        Animation.Stop = Stop
        Animation.Resume = Resume
        Animation.Pause = Pause
        Animation.SetTime = SetTime
        Animation.AdjustSpeed = AdjustSpeed
        Animation.Looped = Track.Properties.Looping or false
        Animation.Speed = 1
        Animation.FadeIn = 0
        Animation.LastPlayed = 0
        Animation.i = 0
        Animation.Playing = false
        Animation.fired = {}
        Animation.RecoverFade = {}

        if Track.Properties.Priority == Enum.AnimationPriority.Idle then
            Animation.Priority = 1
        elseif Track.Properties.Priority == Enum.AnimationPriority.Movement then
            Animation.Priority = 2
        elseif Track.Properties.Priority == Enum.AnimationPriority.Action then
            Animation.Priority = 3
        else--if Track.Properties.Priority == Enum.AnimationPriority.Core then
            Animation.Priority = 0
        end

        Animation.StartInternal = 0
        Animation.PauseInternal = 0

        Animation.GetTimeOfKeyframe = function(name)
            for Time,v in ipairs(Animation.Keyframes) do
                if v.Name == name then
                    return Time
                end
            end
        end

        hasloaded[Track] = true

        return Animation
    end

    local CF = CFrame.new()
    local function GetPose(TimeSince, Poses, Joint, Animation)
        for i = 1,#Poses do
            local Keyframe = Poses[i]
            local NextKeyframe = Poses[i+1]
            local Time = Keyframe.Time

            --local JT = Joint.Transform

            if TimeSince >= Time then
                if not Animation.fired[Keyframe.Name .. Time] and Keyframe.Name ~= 'Keyframe' then
                    Animation.fired[Keyframe.Name .. Time] = 1
                    if Keyframe.Marker then -- keymarker
                        Animation.MarkerReachedEvent:Fire(Keyframe.Name)
                    else -- keyframe
                        Animation.KeyframeReachedEvent:Fire(Keyframe.Name)
                    end
                end
            end

            if (TimeSince >= Time) or Poses[1].Time > TimeSince then
                if NextKeyframe then
                    local NextTime = NextKeyframe.Time
                    if TimeSince < NextTime then
                        if Keyframe.Marker then
                            return {nil, nil, Keyframe.Name, Time, Keyframe.Marker}
                        end
                        local Info1 = Keyframe.Info
                        local Info2 = NextKeyframe.Info

                        local Alpha = (TimeSince - Time) / (NextTime - Time)

                        local CFA = CF:Lerp(Info1.CFrame, Info1.Weight)
                        local CFB = CF:Lerp(Info2.CFrame, Info2.Weight)

                        local Pose
                        if Info2.EasingStyle == 'Constant' then
                            Pose = CFA
                        else
                            Pose = CFA:Lerp(CFB, TS:GetValue(Alpha, Enum.EasingStyle[Info2.EasingStyle], Enum.EasingDirection[Info2.EasingDirection]))
                        end

                        return {Joint, Pose, Keyframe.Name, Time}
                    end
                else
                    if Keyframe.Marker then
                        return {nil, nil, Keyframe.Name, Time, Keyframe.Marker}
                    end
                    return {Joint, Keyframe.Info.CFrame, Keyframe.Name, Time}
                end
            end
        end
    end

    local total_playing = 0

    local function UpdatePlaying()
        local tp = 0
        for Model, Animations in next, Playing do
            for Animation,_ in next, Animations do
                if not Animation.Playing then
                    continue
                end
                if not Model or not Model.Parent then
                    Playing[Model] = nil
                    Animation.FadeIn = nil
                    Animation.fired = {}
                    Animation.Playing = false

                    continue
                end

                local TimeSince = Animation.StartInternal
                TimeSince = os.clock() - ((os.clock() - TimeSince) * Animation.Speed)
                TimeSince = os.clock() - TimeSince

                --local TimeSince = os.clock() - Animation.StartInternal
                --TimeSince = TimeSince * Animation.Speed

                if Animation.FadeIn then
                    Animation.OFadeIn = Animation.FadeIn
                end

                local Length = Animation.TimeLength

                if TimeSince > Length then
                    Animation.FadeIn = nil
                    Animation.fired = {}
                    if Animation.Looped then
                        Animation.LoopedEvent:Fire()
                        if 0 >= Length then
                            TimeSince = 0
                        else
                            TimeSince = TimeSince%Length
                        end
                        --Animation.StartInternal += Length-TimeSince
                    else
                        Animation.TimePosition = 0
                        Playing[Model][Animation] = nil
                        Animation.Playing = false
                        Animation.StopEvent:Fire()
                        continue
                    end
                end

                local Keyframes = Animation.Keyframes

                if Keyframes then else continue end
                tp += 1
                local ToAnimate = {}
                local StartFade = nil
                for Joint, Poses in pairs(Keyframes) do
                    local strjoint = Joint
                    local jd = string.split(strjoint,'KEyjtsep')
                    local Joint
                    if jd[1] and jd[2] then
                        Joint = ModelAnimations[Model].Joints[jd[1]]
                        if not Joint then
                            continue
                        end
                        Joint = Joint[jd[2]]
                        if not Joint then
                            continue
                        end
                    end
                    if not Poses[1] or not Poses[1].Marker then
                        local f,fade
                        for i,using in pairs(GlobalPlaying[Model]) do
                            if i ~= Animation then else
                                continue
                            end
                            if i.Playing then else
                                continue
                            end
                            if using[strjoint] then else
                                continue
                            end
                            if i.Priority > Animation.Priority or (i.Priority == Animation.Priority and i.LastPlayed > Animation.LastPlayed) then else
                                continue
                            end
                            f = true
                        end
                        if f then
                            Animation.RecoverFade[Joint.Name] = os.clock()
                            continue
                        end
                    end
                    if Poses[1] and Poses[1].Time > TimeSince then
                        --StartFade = Poses[1].Time * Animation.Speed
                    end

                    ToAnimate[#ToAnimate+1] = GetPose(TimeSince, Poses, Joint, Animation)
                end
                for i = 1,#ToAnimate do
                    local Pose = ToAnimate[i]
                    if not Pose[5] then
                        local TCF = Pose[2]
                        local FadeIn = Animation.FadeIn
                        local RF = Animation.RecoverFade[Pose[1].Name]
                        local TimeSince = TimeSince
                        if RF then
                            TimeSince = os.clock()-RF
                            if TimeSince >= Length then
                                Animation.RecoverFade[Pose[1].Name] = nil
                            else
                                FadeIn = Animation.OFadeIn
                            end
                        end
                        TCF = JointC0[Pose[1]] * TCF
                        if StartFade then
                            TCF = Pose[1].C0:Lerp(TCF, TimeSince / StartFade)
                        elseif FadeIn and TimeSince < FadeIn then
                            TCF = Pose[1].C0:Lerp(TCF, TimeSince / FadeIn)
                        end
                        Pose[1].C0 = TCF
                    end
                end

                Animation.TimePosition = TimeSince
            end
        end
        total_playing = tp
    end

    function Animator.GetPlaying()
        return total_playing
    end

    local con
    if game:GetService("RunService"):IsClient() then
        con = game:GetService("RunService").RenderStepped:Connect(UpdatePlaying)
    else
        con = game:GetService("RunService").Stepped:Connect(UpdatePlaying)
    end

    return Animator,con
end

-- anims

local default_anims = game:GetService("HttpService"):GetAsync('https://pastebin.com/raw/0JSVJpVB')
default_anims = game:GetService("HttpService"):JSONDecode(default_anims)

-- anims

local anims = {}

local function add_anim(li)
    local a = game:GetService("HttpService"):GetAsync(li)
    a = game:GetService("HttpService"):JSONDecode(a)
    if a then
        for i,v in pairs(a) do
            anims[i] = v
        end
    end
end

add_anim('https://pastebin.com/raw/dhCkVwux')

-- starter

local plr = owner
local char = plr.Character
local hum = char:FindFirstChildOfClass("Humanoid")
local root = char:FindFirstChild("HumanoidRootPart")

if hum.RigType == Enum.HumanoidRigType.R6 then else
    warn('Humanoid is not R6')
    return
end

--

local animator,con = init()

animator.create_welds(char)
animator.toggle_anim(false,char)

for i,v in pairs(anims) do
    animator.Preload(v)
end
for i,v in pairs(default_anims) do
    animator.Preload(v)
end

function load(anim,targchar)
    targchar = targchar or char
    return animator.LoadAnimation(anim,targchar)
end

local move_anims = {
    fall = {
        anim = default_anims.fall,
        fade = 0.3,
    },
    climb = {
        anim = default_anims.climb,
        fade = 0.2,
    },
    jump = {
        anim = default_anims.jump,
        fade = 0.2,
    },
    walk = {
        anim = default_anims.walk,
        fade = 0.2,
    },
    idle = {
        anim = default_anims.idle,
        fade = 0.3,
    },
    sit = {
        anim = default_anims.sit,
        fade = 0.5,
    },
}

local jumped = false
local paused_default = false
local current_move = nil

function play_move_anim(cid)
    if not cid then
        for id,data in pairs(move_anims) do
            local anim = load(data.anim)
            if anim.Playing then
                anim:Stop()
            end
        end
        return
    end
    local data = move_anims[cid]
    local anim = load(data.anim)
    if cid == 'walk' then
        --data.anim:AdjustSpeed(hum.WalkSpeed/16)
    end
    if not anim.Playing then
        if current_move then
            local data = move_anims[current_move]
            local anim = load(data.anim)
            anim:Stop()
        end
        current_move = cid
        anim:Play(data.fade, nil, true)
    end
end

--

function sleep(n)
    return task.wait(n or 0)
end

local function wrap(func)
    coroutine.resume(coroutine.create(func))
end

function play_sound(par,id,vol,speed,loop,perm)
    local s = Instance.new("Sound")
    s.SoundId = 'rbxassetid://' .. id
    s.Volume = vol or 0.5
    s.PlaybackSpeed = speed or 1
    s.Looped = loop or false
    s.Parent = par or root
    if not perm then
        s:Play()
    end
    if not loop and not perm then
        s.Ended:Connect(function()
            sleep()
            s:Destroy()
        end)
    end
    return s
end

function hitbox(hb,ignore,func)
    local hit = {}

    local params = OverlapParams.new()
    params.FilterDescendantsInstances = ignore or {char}
    params.FilterType = Enum.RaycastFilterType.Blacklist
    params.MaxParts = 100

    for _,box in ipairs(hb) do
        for i,obj in ipairs(workspace:GetPartsInPart(box,params)) do
            local targchar = obj.Parent
            local targhum
            pcall(function()
                targhum = targchar:FindFirstChildOfClass("Humanoid")
            end)
            local targroot
            pcall(function()
                targroot = targchar:FindFirstChild("HumanoidRootPart") or targchar:FindFirstChild("Torso")
            end)
            if targchar and not hit[targchar] and targhum and targroot then
                hit[targchar] = {targchar,targroot,obj}
                func(targchar,targroot,targhum)
            end
        end
    end
end

--

do
    Tool0 = Instance.new("Tool")
    Part1 = Instance.new("Part")
    Part2 = Instance.new("Part")
    Part3 = Instance.new("Part")
    Part4 = Instance.new("Part")
    Part5 = Instance.new("Part")
    Part6 = Instance.new("Part")
    Part7 = Instance.new("Part")
    Part8 = Instance.new("Part")
    Part9 = Instance.new("Part")
    Part10 = Instance.new("Part")
    Part11 = Instance.new("Part")
    Part12 = Instance.new("Part")
    Part13 = Instance.new("Part")
    Tool0.Parent = nil
    Part1.Name = "main"
    Part1.Parent = Tool0
    Part1.CFrame = CFrame.new(-12.3988037, 1.79999995, 2.77315688, 1, 0, 0, 0, 1, 0, 0, 0, 1)
    Part1.Position = Vector3.new(-12.3988037109375, 1.7999999523162842, 2.7731568813323975)
    Part1.Color = Color3.new(0.411765, 0.25098, 0.156863)
    Part1.Transparency = 1
    Part1.Size = Vector3.new(0.5, 0.30000001192092896, 0.5)
    Part1.BottomSurface = Enum.SurfaceType.Smooth
    Part1.BrickColor = BrickColor.new("Reddish brown")
    Part1.CanCollide = false
    Part1.TopSurface = Enum.SurfaceType.Smooth
    Part1.brickColor = BrickColor.new("Reddish brown")
    Part2.Parent = Part1
    Part2.CFrame = CFrame.new(-12.3988037, 1.89999998, 2.77315688, 1, 0, 0, 0, 1, 0, 0, 0, 1)
    Part2.Position = Vector3.new(-12.3988037109375, 1.899999976158142, 2.7731568813323975)
    Part2.Color = Color3.new(0.411765, 0.25098, 0.156863)
    Part2.Size = Vector3.new(0.5, 0.10000000149011612, 0.5)
    Part2.Anchored = true
    Part2.BottomSurface = Enum.SurfaceType.Smooth
    Part2.BrickColor = BrickColor.new("Reddish brown")
    Part2.CanCollide = false
    Part2.TopSurface = Enum.SurfaceType.Smooth
    Part2.brickColor = BrickColor.new("Reddish brown")
    Part3.Parent = Part1
    Part3.CFrame = CFrame.new(-12.3988037, 1.96129727, 3.23875642, 1, 0, 0, 0, 0.965925813, 0.258819044, 0, -0.258819044, 0.965925813)
    Part3.Orientation = Vector3.new(-15, 0, 0)
    Part3.Position = Vector3.new(-12.3988037109375, 1.9612972736358643, 3.2387564182281494)
    Part3.Rotation = Vector3.new(-15, 0, 0)
    Part3.Color = Color3.new(0.411765, 0.25098, 0.156863)
    Part3.Size = Vector3.new(0.5, 0.10000000149011612, 0.5)
    Part3.Anchored = true
    Part3.BottomSurface = Enum.SurfaceType.Smooth
    Part3.BrickColor = BrickColor.new("Reddish brown")
    Part3.CanCollide = false
    Part3.TopSurface = Enum.SurfaceType.Smooth
    Part3.brickColor = BrickColor.new("Reddish brown")
    Part4.Parent = Part1
    Part4.CFrame = CFrame.new(-12.3988037, 2.14101195, 3.67262602, 1, 0, 0, 0, 0.866025388, 0.5, 0, -0.5, 0.866025388)
    Part4.Orientation = Vector3.new(-30, 0, 0)
    Part4.Position = Vector3.new(-12.3988037109375, 2.141011953353882, 3.67262601852417)
    Part4.Rotation = Vector3.new(-30, 0, 0)
    Part4.Color = Color3.new(0.411765, 0.25098, 0.156863)
    Part4.Size = Vector3.new(0.5, 0.10000000149011612, 0.5)
    Part4.Anchored = true
    Part4.BottomSurface = Enum.SurfaceType.Smooth
    Part4.BrickColor = BrickColor.new("Reddish brown")
    Part4.CanCollide = false
    Part4.TopSurface = Enum.SurfaceType.Smooth
    Part4.brickColor = BrickColor.new("Reddish brown")
    Part5.Parent = Part1
    Part5.CFrame = CFrame.new(-12.3988037, 1.96300101, 2.29461646, 1, 0, 0, 0, 0.965925813, -0.258819044, 0, 0.258819044, 0.965925813)
    Part5.Orientation = Vector3.new(15, 0, 0)
    Part5.Position = Vector3.new(-12.3988037109375, 1.963001012802124, 2.294616460800171)
    Part5.Rotation = Vector3.new(15, 0, 0)
    Part5.Color = Color3.new(0.411765, 0.25098, 0.156863)
    Part5.Size = Vector3.new(0.5, 0.10000000149011612, 0.5)
    Part5.Anchored = true
    Part5.BottomSurface = Enum.SurfaceType.Smooth
    Part5.BrickColor = BrickColor.new("Reddish brown")
    Part5.CanCollide = false
    Part5.TopSurface = Enum.SurfaceType.Smooth
    Part5.brickColor = BrickColor.new("Reddish brown")
    Part6.Parent = Part1
    Part6.CFrame = CFrame.new(-12.3988037, 1.90770078, 1.87456977, 1, 0, 0, 0, 0.866025269, 0.49999994, 0, -0.49999994, 0.866025269)
    Part6.Orientation = Vector3.new(-30, 0, 0)
    Part6.Position = Vector3.new(-12.3988037109375, 1.907700777053833, 1.8745697736740112)
    Part6.Rotation = Vector3.new(-30, 0, 0)
    Part6.Color = Color3.new(0.411765, 0.25098, 0.156863)
    Part6.Size = Vector3.new(0.5, 0.10000000149011612, 0.5)
    Part6.Anchored = true
    Part6.BottomSurface = Enum.SurfaceType.Smooth
    Part6.BrickColor = BrickColor.new("Reddish brown")
    Part6.CanCollide = false
    Part6.TopSurface = Enum.SurfaceType.Smooth
    Part6.brickColor = BrickColor.new("Reddish brown")
    Part7.Parent = Part1
    Part7.CFrame = CFrame.new(-12.3988037, 1.63449574, 1.80136478, 1, 0, 0, 0, -0.499999821, 0.866025031, 0, -0.866025031, -0.499999821)
    Part7.Orientation = Vector3.new(-60, 180, 180)
    Part7.Position = Vector3.new(-12.3988037109375, 1.634495735168457, 1.801364779472351)
    Part7.Rotation = Vector3.new(-120, 0, 0)
    Part7.Color = Color3.new(0.411765, 0.25098, 0.156863)
    Part7.Size = Vector3.new(0.5, 0.10000000149011612, 0.5)
    Part7.Anchored = true
    Part7.BottomSurface = Enum.SurfaceType.Smooth
    Part7.BrickColor = BrickColor.new("Reddish brown")
    Part7.CanCollide = false
    Part7.TopSurface = Enum.SurfaceType.Smooth
    Part7.brickColor = BrickColor.new("Reddish brown")
    Part8.Parent = Part1
    Part8.CFrame = CFrame.new(-12.3988037, 1.56129074, 2.0745697, 1, 0, 0, 0, -0.866024315, -0.499999434, 0, 0.499999434, -0.866024315)
    Part8.Orientation = Vector3.new(30, 180, 180)
    Part8.Position = Vector3.new(-12.3988037109375, 1.5612907409667969, 2.0745697021484375)
    Part8.Rotation = Vector3.new(150, 0, 0)
    Part8.Color = Color3.new(0.411765, 0.25098, 0.156863)
    Part8.Size = Vector3.new(0.5, 0.10000000149011612, 0.5)
    Part8.Anchored = true
    Part8.BottomSurface = Enum.SurfaceType.Smooth
    Part8.BrickColor = BrickColor.new("Reddish brown")
    Part8.CanCollide = false
    Part8.TopSurface = Enum.SurfaceType.Smooth
    Part8.brickColor = BrickColor.new("Reddish brown")
    Part9.Parent = Part1
    Part9.CFrame = CFrame.new(-12.3988037, 1.72376347, 2.52095985, 1, 0, 0, 0, -0.984804153, -0.173647612, 0, 0.173647612, -0.984804153)
    Part9.Orientation = Vector3.new(10, 180, 180)
    Part9.Position = Vector3.new(-12.3988037109375, 1.7237634658813477, 2.5209598541259766)
    Part9.Rotation = Vector3.new(170, 0, 0)
    Part9.Color = Color3.new(0.411765, 0.25098, 0.156863)
    Part9.Size = Vector3.new(0.5, 0.10000000149011612, 0.5)
    Part9.Anchored = true
    Part9.BottomSurface = Enum.SurfaceType.Smooth
    Part9.BrickColor = BrickColor.new("Reddish brown")
    Part9.CanCollide = false
    Part9.TopSurface = Enum.SurfaceType.Smooth
    Part9.brickColor = BrickColor.new("Reddish brown")
    Part10.Parent = Part1
    Part10.CFrame = CFrame.new(-12.3988037, 1.7237637, 2.99599719, 1, 0, 0, 0, -0.984807789, 0.173648089, 0, -0.173648089, -0.984807789)
    Part10.Orientation = Vector3.new(-10, 180, 180)
    Part10.Position = Vector3.new(-12.3988037109375, 1.7237637042999268, 2.995997190475464)
    Part10.Rotation = Vector3.new(-170, 0, 0)
    Part10.Color = Color3.new(0.411765, 0.25098, 0.156863)
    Part10.Size = Vector3.new(0.5, 0.10000000149011612, 0.5)
    Part10.Anchored = true
    Part10.BottomSurface = Enum.SurfaceType.Smooth
    Part10.BrickColor = BrickColor.new("Reddish brown")
    Part10.CanCollide = false
    Part10.TopSurface = Enum.SurfaceType.Smooth
    Part10.brickColor = BrickColor.new("Reddish brown")
    Part11.Parent = Part1
    Part11.CFrame = CFrame.new(-12.3988037, 1.56129074, 3.44238758, 1, 0, 0, 0, -0.866025448, 0.49999994, 0, -0.49999994, -0.866025448)
    Part11.Orientation = Vector3.new(-30, 180, 180)
    Part11.Position = Vector3.new(-12.3988037109375, 1.5612907409667969, 3.442387580871582)
    Part11.Rotation = Vector3.new(-150, 0, 0)
    Part11.Color = Color3.new(0.411765, 0.25098, 0.156863)
    Part11.Size = Vector3.new(0.5, 0.10000000149011612, 0.5)
    Part11.Anchored = true
    Part11.BottomSurface = Enum.SurfaceType.Smooth
    Part11.BrickColor = BrickColor.new("Reddish brown")
    Part11.CanCollide = false
    Part11.TopSurface = Enum.SurfaceType.Smooth
    Part11.brickColor = BrickColor.new("Reddish brown")
    Part12.Parent = Part1
    Part12.CFrame = CFrame.new(-12.3988037, 1.25594175, 3.80628848, 1, 0, 0, 0, -0.642787695, 0.766044378, 0, -0.766044378, -0.642787695)
    Part12.Orientation = Vector3.new(-50, 180, 180)
    Part12.Position = Vector3.new(-12.3988037109375, 1.2559417486190796, 3.806288480758667)
    Part12.Rotation = Vector3.new(-130, 0, 0)
    Part12.Color = Color3.new(0.411765, 0.25098, 0.156863)
    Part12.Size = Vector3.new(0.5, 0.10000000149011612, 0.5)
    Part12.Anchored = true
    Part12.BottomSurface = Enum.SurfaceType.Smooth
    Part12.BrickColor = BrickColor.new("Reddish brown")
    Part12.CanCollide = false
    Part12.TopSurface = Enum.SurfaceType.Smooth
    Part12.brickColor = BrickColor.new("Reddish brown")
    Part13.Name = "hitbox"
    Part13.Parent = Part1
    Part13.CFrame = CFrame.new(-12.3988037, 1.75, 2.87315702, 1, 0, 0, 0, 1, 0, 0, 0, 1)
    Part13.Position = Vector3.new(-12.3988037109375, 1.75, 2.873157024383545)
    Part13.Color = Color3.new(0.411765, 0.25098, 0.156863)
    Part13.Transparency = 1
    Part13.Size = Vector3.new(1, 1.600000023841858, 2.700000047683716)
    Part13.Anchored = true
    Part13.BottomSurface = Enum.SurfaceType.Smooth
    Part13.BrickColor = BrickColor.new("Reddish brown")
    Part13.CanCollide = false
    Part13.TopSurface = Enum.SurfaceType.Smooth
    Part13.brickColor = BrickColor.new("Reddish brown")

    local tool = Tool0

    tool.Name = 'BELT'
    tool.RequiresHandle = false

    tool.main.CanCollide = true

    for i,v in pairs(tool.main:GetChildren()) do
        if v:IsA("BasePart") then
            v.Anchored = false
            if v ~= tool.main then
                local w = Instance.new("Weld")
                w.Part0 = tool.main
                w.Part1 = v
                w.C0 = w.Part0.CFrame:Inverse()
                w.C1 = w.Part1.CFrame:Inverse()
                w.Parent = v
            end
        end
    end

    local w = Instance.new("Weld")
    w.Part0 = nil
    w.Part1 = tool.main
    w.C1 = CFrame.new(0,-0.7,0)*CFrame.new(0,math.rad(90),0)
    w.Parent = tool.main

    tool.Parent = plr:FindFirstChildOfClass("Backpack")

    local using = false

    function swing()
        if using then
            return
        end
        using = true

        local anim = load(anims.swing)
        anim:Play()

        play_sound(tool.main,1306070008,0.5,math.random(95,105)/100)

        local st = os.clock()
        repeat
            hitbox({tool.main.hitbox},nil,function(targchar,targroot,targhum)
                if targhum.Health > 0 then else
                    return
                end
                play_sound(tool.main,4533871268,0.5,math.random(95,105)/100) -- 8556065163
                targchar:BreakJoints()
                targhum.BreakJointsOnDeath = true
                targhum.Health = 0
            end)
            sleep()
        until os.clock()-st >= 0.5

        sleep(0.2)

        using = false
    end

    tool.main.Touched:Connect(function(obj)
        if tool.Parent == workspace and obj and obj.Parent and obj.Parent:FindFirstChildOfClass("Humanoid") then
            tool.Parent = obj.Parent
        end
    end)

    tool.Equipped:Connect(function()
        char = tool.Parent
        hum = char:FindFirstChildOfClass("Humanoid")
        root = char:FindFirstChild("HumanoidRootPart")

        local rarm = char:FindFirstChild("Right Arm")
        if rarm and hum and hum.Health > 0 and hum.RigType == Enum.HumanoidRigType.R6 then else
            sleep()
            tool.Parent = workspace
        end
        w.Part0 = rarm

        animator.create_welds(char)
        animator.toggle_anim(true,char)
    end)
    tool.Unequipped:Connect(function()
        w.Part0 = nil
        animator.toggle_anim(false,char)
        if tool.Parent == workspace then
            tool.main.CFrame = tool.main.CFrame*CFrame.new(0,0,-5)
        end
    end)
    tool.Activated:Connect(function()
        swing()
    end)
end

--

local c
c = game:GetService("RunService").Heartbeat:Connect(function()
    if not char or not char.Parent or 0 >= hum.Health then
        --c:Disconnect()
        return
    end
    local dir = root.Velocity
    local params = RaycastParams.new()
    params.FilterType = Enum.RaycastFilterType.Blacklist
    params.FilterDescendantsInstances = {char}
    params.IgnoreWater = false
    local ground = workspace:Raycast(root.Position,root.CFrame.UpVector*-1*5,params)
    local jumpvel = dir.Y
    local walkvel = (dir*Vector3.new(1,0,1)).Magnitude
    local movevel = dir.Magnitude
    local faceDir = root.CFrame.LookVector.Unit
    local moveDir = dir.Unit
    local dot = faceDir:Dot(moveDir)

    local moving,air_state

    if walkvel > 0.01 then
        moving = true
    else
        moving = false
    end

    local state = hum:GetState()

    if state == Enum.HumanoidStateType.Freefall then
        air_state = 1
    elseif state == Enum.HumanoidStateType.Jumping then
        air_state = 2
    else
        air_state = 0
    end

    if state == Enum.HumanoidStateType.Jumping then
        jumped = true
    else
        jumped = false
    end

    if not paused_default then
        if state == Enum.HumanoidStateType.Climbing then
            play_move_anim('climb')
        elseif hum.Sit then
            play_move_anim('sit')
        elseif air_state == 1 then
            play_move_anim('fall')
        elseif air_state == 2 then
            play_move_anim('jump')
        elseif moving then
            play_move_anim('walk')
        else
            play_move_anim('idle')
        end
    else
        play_move_anim()
    end
end)