local leftHand = false --If you're left handed and are using VR, put this to true (or if you want the sword to be held on your left hand).

local autoEquip = false --(VR only setting) If this is true, instead of holding down the grip button to hold the sword, you just have to press it to equip and unequip it.

 

 

 

 

local character1 = game.Players.LocalPlayer.Character

local sword = nil

local rArm1 = character1["Right Arm"]

local lArm1 = character1["Left Arm"]

local rGrip1 = rArm1.RightGripAttachment

local lGrip1 = lArm1.LeftGripAttachment

local hrp  = character1.HumanoidRootPart

 

local userInputService = game:GetService("UserInputService")

 

hrp.Transparency = 0.5

 

local hrpReplacement = hrp:Clone()

hrpReplacement.Parent = character1

hrpReplacement.Name = "hrpReplacement"

hrpReplacement.Size = hrp.Size

hrpReplacement.Transparency = 1

hrpReplacement.Anchored = true

hrpReplacement.Position = hrp.Position

 

if character1:FindFirstChild("Dark Matter Sword") then

    sword = character1["Dark Matter Sword"].Handle

 

if character1:FindFirstChild("MeshPartAccessory") then

    sword = character1.MeshPartAccessory.Handle

 

if character1:FindFirstChild("Russo's Sword") then

    sword = character1["Russo's Sword"].Handle

 

if leftHand == false and character1:FindFirstChild("Russo's Sword") then

    sword.BodyBackAttachment.Orientation = Vector3.new(-0, 180, 215.002)

 

if leftHand == true and not character1:FindFirstChild("Russo's Sword") then

    sword.BodyBackAttachment.Orientation = Vector3.new(0, 0, -90)

 

local function Hats()

    --From CLOVR (Modified)------------------------------------------------

    for _, Accessory in next, character1:GetChildren() do

        if Accessory:IsA("Accessory") and Accessory:FindFirstChild("Handle") then

            local Attachment1 = Accessory.Handle:FindFirstChildWhichIsA("Attachment")

            local Attachment0 = character1:FindFirstChild(tostring(Attachment1), true)

            local Orientation = Instance.new("AlignOrientation")

            local Position = Instance.new("AlignPosition")

            if character1.Head:FindFirstChild("AlignOrientation") and character1.Head:FindFirstChild("AlignPosition") then

                character1.Head.AlignOrientation:Destroy()

                character1.Head.AlignPosition:Destroy()

            end

            Orientation.Attachment0 = Attachment1

            Orientation.Attachment1 = Attachment0

            Orientation.RigidityEnabled = false

            Orientation.ReactionTorqueEnabled = true

            Orientation.MaxTorque = 20000

            Orientation.Responsiveness = 40

            Orientation.Parent = character1.Head

            Position.Attachment0 = Attachment1

            Position.Attachment1 = Attachment0

            Position.RigidityEnabled = false

            Position.ReactionForceEnabled = true

            Position.MaxForce = 40000

            Position.Responsiveness = 40

            Position.Parent = character1.Head

        end

    end

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

 

 

local flinging = false

 

local vrService = game:GetService("VRService")

 

userInputService.InputBegan:Connect(function(key)

    --No VR-------------------------------------------------------------------------------

    if key.KeyCode == Enum.KeyCode.F and not vrService.VREnabled then

        if flinging == false then

            --Start Flinging

            local hatGrip = sword.BodyBackAttachment

           

            --Orientation

            if leftHand == true then

                hatGrip.Name = lGrip1.Name

                hatGrip = sword.LeftGripAttachment

                if character1:FindFirstChild("Dark Matter Sword") or character1:FindFirstChild("MeshPartAccessory") then

                    hatGrip.Orientation = Vector3.new(-100, -90, 0)

                end

                if character1:FindFirstChild("Russo's Sword") then

                    hatGrip.Orientation = Vector3.new(45, -90, -180)

                end

            else

                hatGrip.Name = rGrip1.Name

                hatGrip = sword.RightGripAttachment

                if character1:FindFirstChild("Dark Matter Sword") or character1:FindFirstChild("MeshPartAccessory") then

                    hatGrip.Orientation = Vector3.new(-100, -90, 0)

                end

                if character1:FindFirstChild("Russo's Sword") then

                    hatGrip.Orientation = Vector3.new(45, -90, -180)

                end

            end

           

            --Position

            if leftHand == true then

                if character1:FindFirstChild("Dark Matter Sword") then

                    hatGrip.Position = lGrip1.Position + Vector3.new(1.2, 2.4, 0)

                end

                if character1:FindFirstChild("MeshPartAccessory") then

                    hatGrip.Position = lGrip1.Position + Vector3.new(1.7, 2.6, 0)

                end

                if character1:FindFirstChild("Russo's Sword") then

                    hatGrip.Position = lGrip1.Position + Vector3.new(-0.1, -0.7, 0)

                end

            else

                if character1:FindFirstChild("Dark Matter Sword") then

                    hatGrip.Position = rGrip1.Position + Vector3.new(1.2, 2.4, 0)

                end

                if character1:FindFirstChild("MeshPartAccessory") then

                    hatGrip.Position = lGrip1.Position + Vector3.new(1.7, 2.6, 0)

                end

                if character1:FindFirstChild("Russo's Sword") then

                    hatGrip.Position = rGrip1.Position + Vector3.new(-0.1, -0.7, 0)

                end

            end

           

            --Function

            Hats()

           

            --Fling Stuff

            if hrp:FindFirstChild("BodyAngularVelocity") then

                hrp.BodyAngularVelocity:Destroy()

            end

           

            local flinger = Instance.new("BodyAngularVelocity", hrp)

            flinger.MaxTorque = Vector3.new(math.huge, math.huge, math.huge)

            flinger.P = 1000000000000000000000000000

            flinger.AngularVelocity = Vector3.new(10000, 10000, 10000)

           

            flinging = true

        else

            --Stop Flinging

            if leftHand == true then

                sword.LeftGripAttachment.Name = "BodyBackAttachment"

            else

                sword.RightGripAttachment.Name = "BodyBackAttachment"

            end

           

            local hatGrip = sword.BodyBackAttachment

           

            --Orientation

            if leftHand == true then

                if character1:FindFirstChild("Dark Matter Sword") or character1:FindFirstChild("MeshPartAccessory") then

                    hatGrip.Orientation = Vector3.new(0, 0, -90)

                end

                if character1:FindFirstChild("Russo's Sword") then

                    hatGrip.Orientation = Vector3.new(-0, 180, 125.002)

                end

            else

                if character1:FindFirstChild("Dark Matter Sword") or character1:FindFirstChild("MeshPartAccessory") then

                    hatGrip.Orientation = Vector3.new(0, 0, 0)

                end

                if character1:FindFirstChild("Russo's Sword") then

                    hatGrip.Orientation = Vector3.new(-0, 180, 215.002)

                end

            end

           

            --Position

            if character1:FindFirstChild("Dark Matter Sword") or character1:FindFirstChild("MeshPartAccessory") then

                hatGrip.Position = Vector3.new(0, 0, -0.25)

            end

            if character1:FindFirstChild("Russo's Sword") then

                hatGrip.Position = Vector3.new(0, 0, 0.25)

            end

           

            Hats()

           

            if hrp:FindFirstChild("BodyAngularVelocity") then

                hrp.BodyAngularVelocity:Destroy()

            end

           

            local flinger = Instance.new("BodyAngularVelocity", hrp)

            flinger.MaxTorque = Vector3.new(math.huge, math.huge, math.huge)

            flinger.P = 1000000000000000000000000000

            flinger.AngularVelocity = Vector3.new(0, 0, 0)

           

            flinging = false

        end

    end

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

   

    --VR----------------------------------------------------------------------------------

    --Right Hand

    if key.KeyCode == Enum.KeyCode.ButtonR1 then

        if flinging == false and autoEquip == false and leftHand == false then

            --Start Flinging

            sword.BodyBackAttachment.Name = rGrip1.Name

           

            local hatGrip = sword.RightGripAttachment

           

            --Orientation

            if character1:FindFirstChild("Dark Matter Sword") or character1:FindFirstChild("MeshPartAccessory") then

                hatGrip.Orientation = Vector3.new(-100, -90, 0)

            end

            if character1:FindFirstChild("Russo's Sword") then

                hatGrip.Orientation = Vector3.new(45, -90, -180)

            end            

           

            --Position

            if character1:FindFirstChild("Dark Matter Sword") then

                hatGrip.Position = rGrip1.Position + Vector3.new(1.2, 2.4, 0)

            end

            if character1:FindFirstChild("MeshPartAccessory") then

                hatGrip.Position = lGrip1.Position + Vector3.new(1.7, 2.6, 0)

            end

            if character1:FindFirstChild("Russo's Sword") then

                hatGrip.Position = rGrip1.Position + Vector3.new(-0.1, -0.7, 0)

            end

           

            --Function

            Hats()

           

            --Fling Stuff

            if hrp:FindFirstChild("BodyAngularVelocity") then

                hrp.BodyAngularVelocity:Destroy()

            end

           

            local flinger = Instance.new("BodyAngularVelocity", hrp)

            flinger.MaxTorque = Vector3.new(math.huge, math.huge, math.huge)

            flinger.P = 1000000000000000000000000000

            flinger.AngularVelocity = Vector3.new(10000, 10000, 10000)

           

            flinging = true

        else

            if flinging == false and autoEquip == true and leftHand == false then

            --Start Flinging

            sword.BodyBackAttachment.Name = rGrip1.Name

           

            local hatGrip = sword.RightGripAttachment

           

            --Orientation

            if character1:FindFirstChild("Dark Matter Sword") or character1:FindFirstChild("MeshPartAccessory") then

                hatGrip.Orientation = Vector3.new(-100, -90, 0)

            end

            if character1:FindFirstChild("Russo's Sword") then

                hatGrip.Orientation = Vector3.new(45, -90, -180)

            end            

           

            --Position

            if character1:FindFirstChild("Dark Matter Sword") then

                hatGrip.Position = rGrip1.Position + Vector3.new(1.2, 2.4, 0)

            end

            if character1:FindFirstChild("MeshPartAccessory") then

                hatGrip.Position = lGrip1.Position + Vector3.new(1.7, 2.6, 0)

            end

            if character1:FindFirstChild("Russo's Sword") then

                hatGrip.Position = rGrip1.Position + Vector3.new(-0.1, -0.7, 0)

            end

           

            --Function

            Hats()

           

            --Fling Stuff

            if hrp:FindFirstChild("BodyAngularVelocity") then

                hrp.BodyAngularVelocity:Destroy()

            end

           

            local flinger = Instance.new("BodyAngularVelocity", hrp)

            flinger.MaxTorque = Vector3.new(math.huge, math.huge, math.huge)

            flinger.P = 1000000000000000000000000000

            flinger.AngularVelocity = Vector3.new(10000, 10000, 10000)

           

            flinging = true

            else

                if flinging == true and autoEquip == true and leftHand == false then

                    --Stop Flinging

                    sword.RightGripAttachment.Name = "BodyBackAttachment"

                   

                    local hatGrip = sword.BodyBackAttachment

                   

                    --Orientation

                    if character1:FindFirstChild("Dark Matter Sword") or character1:FindFirstChild("MeshPartAccessory") then

                        hatGrip.Orientation = Vector3.new(0, 0, 0)

                    end

                    if character1:FindFirstChild("Russo's Sword") then

                        hatGrip.Orientation = Vector3.new(-0, 180, 215.002)

                    end

                   

                    --Position

                    if character1:FindFirstChild("Dark Matter Sword") or character1:FindFirstChild("MeshPartAccessory") then

                        hatGrip.Position = Vector3.new(0, 0, -0.25)

                    end

                    if character1:FindFirstChild("Russo's Sword") then

                        hatGrip.Position = Vector3.new(0, 0, 0.25)

                    end

                   

                    --Function

                    Hats()

                   

                    --Fling Stuff

                    if hrp:FindFirstChild("BodyAngularVelocity") then

                        hrp.BodyAngularVelocity:Destroy()

                    end

                   

                    local flinger = Instance.new("BodyAngularVelocity", hrp)

                    flinger.MaxTorque = Vector3.new(math.huge, math.huge, math.huge)

                    flinger.P = 1000000000000000000000000000

                    flinger.AngularVelocity = Vector3.new(0, 0, 0)

                   

                    flinging = false

                end

            end

        end

    end

   

    --Left Hand

    if key.KeyCode == Enum.KeyCode.ButtonL1 then

        if flinging == false and autoEquip == false and leftHand == true then

            --Start Flinging

            sword.BodyBackAttachment.Name = lGrip1.Name

           

            local hatGrip = sword.LeftGripAttachment

           

            --Orientation

            if character1:FindFirstChild("Dark Matter Sword") or character1:FindFirstChild("MeshPartAccessory") then

                hatGrip.Orientation = Vector3.new(-100, -90, 0)

            end

            if character1:FindFirstChild("Russo's Sword") then

                hatGrip.Orientation = Vector3.new(45, -90, -180)

            end

           

            --Position

            if character1:FindFirstChild("Dark Matter Sword") then

                hatGrip.Position = lGrip1.Position + Vector3.new(1.2, 2.4, 0)

            end

            if character1:FindFirstChild("MeshPartAccessory") then

                hatGrip.Position = lGrip1.Position + Vector3.new(1.7, 2.6, 0)

            end

            if character1:FindFirstChild("Russo's Sword") then

                hatGrip.Position = lGrip1.Position + Vector3.new(-0.1, -0.7, 0)

            end

           

            --Function

            Hats()

           

            --FLing Stuff

            if hrp:FindFirstChild("BodyAngularVelocity") then

                hrp.BodyAngularVelocity:Destroy()

            end

           

            local flinger = Instance.new("BodyAngularVelocity", hrp)

            flinger.MaxTorque = Vector3.new(math.huge, math.huge, math.huge)

            flinger.P = 1000000000000000000000000000

            flinger.AngularVelocity = Vector3.new(10000, 10000, 10000)

           

            flinging = true

        else

            if flinging == false and autoEquip == true and leftHand == true then

            --Start Flinging

            sword.BodyBackAttachment.Name = lGrip1.Name

           

            local hatGrip = sword.LeftGripAttachment

           

            --Orientation

            if character1:FindFirstChild("Dark Matter Sword") or character1:FindFirstChild("MeshPartAccessory") then

                hatGrip.Orientation = Vector3.new(-100, -90, 0)

            end

            if character1:FindFirstChild("Russo's Sword") then

                hatGrip.Orientation = Vector3.new(45, -90, -180)

            end

           

            --Position

            if character1:FindFirstChild("Dark Matter Sword") then

                hatGrip.Position = lGrip1.Position + Vector3.new(1.2, 2.4, 0)

            end

            if character1:FindFirstChild("MeshPartAccessory") then

                hatGrip.Position = lGrip1.Position + Vector3.new(1.7, 2.6, 0)

            end

            if character1:FindFirstChild("Russo's Sword") then

                hatGrip.Position = lGrip1.Position + Vector3.new(-0.1, -0.7, 0)

            end

           

            --Function

            Hats()

           

            --FLing Stuff

            if hrp:FindFirstChild("BodyAngularVelocity") then

                hrp.BodyAngularVelocity:Destroy()

            end

           

            local flinger = Instance.new("BodyAngularVelocity", hrp)

            flinger.MaxTorque = Vector3.new(math.huge, math.huge, math.huge)

            flinger.P = 1000000000000000000000000000

            flinger.AngularVelocity = Vector3.new(10000, 10000, 10000)

           

            flinging = true

            else

                if flinging == true and autoEquip == true and leftHand == true then

                    --Stop Flinging

                    sword.LeftGripAttachment.Name = "BodyBackAttachment"

                   

                    local hatGrip = sword.BodyBackAttachment

                   

                    --Orientation

                    if character1:FindFirstChild("Dark Matter Sword") or character1:FindFirstChild("MeshPartAccessory") then

                        hatGrip.Orientation = Vector3.new(0, 0, -90)

                    end

                    if character1:FindFirstChild("Russo's Sword") then

                        hatGrip.Orientation = Vector3.new(-0, 180, 125.002)

                    end

                   

                    --Position

                    if character1:FindFirstChild("Dark Matter Sword") or character1:FindFirstChild("MeshPartAccessory") then

                        hatGrip.Position = Vector3.new(0, 0, -0.25)

                    end

                    if character1:FindFirstChild("Russo's Sword") then

                        hatGrip.Position = Vector3.new(0, 0, 0.25)

                    end

                   

                    --Function

                    Hats()

                   

                    --Fling Stuff

                    if hrp:FindFirstChild("BodyAngularVelocity") then

                        hrp.BodyAngularVelocity:Destroy()

                    end

                   

                    local flinger = Instance.new("BodyAngularVelocity", hrp)

                    flinger.MaxTorque = Vector3.new(math.huge, math.huge, math.huge)

                    flinger.P = 1000000000000000000000000000

                    flinger.AngularVelocity = Vector3.new(0, 0, 0)

                   

                    flinging = false

                end

            end

        end

    end

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

 

userInputService.InputEnded:Connect(function(key)

    --VR----------------------------------------------------------------------------------

    --Right Hand

    if key.KeyCode == Enum.KeyCode.ButtonR1 then

        if flinging == true and autoEquip == false and leftHand == false then

            --Stop Flinging

            sword.RightGripAttachment.Name = "BodyBackAttachment"

           

            local hatGrip = sword.BodyBackAttachment

           

            --Orientation

            if character1:FindFirstChild("Dark Matter Sword") or character1:FindFirstChild("MeshPartAccessory") then

                hatGrip.Orientation = Vector3.new(0, 0, 0)

            end

            if character1:FindFirstChild("Russo's Sword") then

                hatGrip.Orientation = Vector3.new(-0, 180, 215.002)

            end

           

            --Position

            if character1:FindFirstChild("Dark Matter Sword") or character1:FindFirstChild("MeshPartAccessory") then

                hatGrip.Position = Vector3.new(0, 0, -0.25)

            end

            if character1:FindFirstChild("Russo's Sword") then

                hatGrip.Position = Vector3.new(0, 0, 0.25)

            end

           

            --Function

            Hats()

           

            --Fling Stuff

            if hrp:FindFirstChild("BodyAngularVelocity") then

                hrp.BodyAngularVelocity:Destroy()

            end

           

            local flinger = Instance.new("BodyAngularVelocity", hrp)

            flinger.MaxTorque = Vector3.new(math.huge, math.huge, math.huge)

            flinger.P = 1000000000000000000000000000

            flinger.AngularVelocity = Vector3.new(0, 0, 0)

           

            flinging = false

        end

    end

   

    --Left Hand

    if key.KeyCode == Enum.KeyCode.ButtonL1 then

        if flinging == true and autoEquip == false and leftHand == true then

            --Stop Flinging

            sword.LeftGripAttachment.Name = "BodyBackAttachment"

           

            local hatGrip = sword.BodyBackAttachment

           

            --Orientation

            if character1:FindFirstChild("Dark Matter Sword") or character1:FindFirstChild("MeshPartAccessory") then

                hatGrip.Orientation = Vector3.new(0, 0, -90)

            end

            if character1:FindFirstChild("Russo's Sword") then

                hatGrip.Orientation = Vector3.new(-0, 180, 125.002)

            end

           

            --Position

            if character1:FindFirstChild("Dark Matter Sword") or character1:FindFirstChild("MeshPartAccessory") then

                hatGrip.Position = Vector3.new(0, 0, -0.25)

            end

            if character1:FindFirstChild("Russo's Sword") then

                hatGrip.Position = Vector3.new(0, 0, 0.25)

            end

           

            --Function

            Hats()

           

            --Fling Stuff

            if hrp:FindFirstChild("BodyAngularVelocity") then

                hrp.BodyAngularVelocity:Destroy()

            end

           

            local flinger = Instance.new("BodyAngularVelocity", hrp)

            flinger.MaxTorque = Vector3.new(math.huge, math.huge, math.huge)

            flinger.P = 1000000000000000000000000000

            flinger.AngularVelocity = Vector3.new(0, 0, 0)

           

            flinging = false

        end

    end

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

 

spawn(function()

    while true do

        game:GetService("RunService").Heartbeat:Wait();

        settings().Physics.AllowSleep = false;

        game:GetService("Players").LocalPlayer.MaximumSimulationRadius = math.huge;

        setsimulationradius(math.huge);

    end

 

 

 

 

 

local StudsOffset = 0 -- Character height (negative if you're too high)

local Smoothness = .5 -- Character interpolation (0.1 - 1 = smooth - rigid)

local AnchorCharacter = true -- Prevent physics from causing inconsistencies

local HideCharacter = false -- Hide character on a platform

local NoCollision = true -- Disable player collision

local ChatEnabled = true -- See chat on your left hand in-game

local ChatLocalRange = 75 -- Local chat range

local ViewportEnabled = true -- View nearby players in a frame

local ViewportRange = 30 -- Maximum distance players are updated

local RagdollEnabled = true -- Use your character instead of hats (NetworkOwner vulnerability)

local RagdollHeadMovement = true -- Move your head separately from your body (+9 second wait)

local AutoRun = false -- Run script on respawn

local AutoRespawn = true -- Kill your real body when your virtual body dies

local WearAllAccessories = true -- Use all leftover hats for the head

local AccurateHandPosition = true -- Move your Roblox hands according to your real hands

local AccessorySettings = {

    LeftArm = "",

    RightArm = "",

    LeftLeg = "",

    RightLeg = "",

    Torso = "",

    Head = true,

    BlockArms = true,

    BlockLegs = true,

    BlockTorso = true,

    LimbOffset = CFrame.Angles(math.rad(90), 0, 0)

local FootPlacementSettings = {

    RightOffset = Vector3.new(.5, 0, 0),

    LeftOffset = Vector3.new(-.5, 0, 0)

local Script = nil

Script = function()

    --[[

    local Players = game:GetService("Players")

    local Client = Players.LocalPlayer

    local Character = Client.Character or Client.CharacterAdded:Wait()

    local WeldBase = Character:WaitForChild("hrpReplacement")

    local ArmBase = Character:FindFirstChild("RightHand") or Character:FindFirstChild("Right Arm") or WeldBase

    local Backpack = Client:WaitForChild("Backpack")

    local Mouse = Client:GetMouse()

    local Camera = workspace.CurrentCamera

    local VRService = game:GetService("VRService")

    local VRReady = VRService.VREnabled

    local UserInputService = game:GetService("UserInputService")

    local RunService = game:GetService("RunService")

    local HttpService = game:GetService("HttpService")

    local StarterGui = game:GetService("StarterGui")

    local HeadAccessories = {}

    local UsedAccessories = {}

    local Pointer = false

    local Point1 = false

    local Point2 = false

    local VirtualRig = game:GetObjects("rbxassetid://4468539481")[1]

    local VirtualBody = game:GetObjects("rbxassetid://4464983829")[1]

    local Anchor = Instance.new("Part")

    Anchor.Anchored = true

    Anchor.Transparency = 1

    Anchor.CanCollide = false

    Anchor.Parent = workspace

    if RagdollEnabled then

        print("RagdollEnabled, thank you for using CLOVR!")

        local NetworkAccess =

            coroutine.create(

            function()

                settings().Physics.AllowSleep = false

                while true do

                    game:GetService("RunService").RenderStepped:Wait()

                    for _, Players in next, game:GetService("Players"):GetChildren() do

                        if Players ~= game:GetService("Players").LocalPlayer then

                            Players.MaximumSimulationRadius = 0.1

                            Players.SimulationRadius = 0

                        end

                    end

                    game:GetService("Players").LocalPlayer.MaximumSimulationRadius = math.pow(math.huge, math.huge)

                    game:GetService("Players").LocalPlayer.SimulationRadius = math.huge * math.huge

                end

            end

        )

        coroutine.resume(NetworkAccess)

    end

    StarterGui:SetCore("VRLaserPointerMode", 3)

    --[[

    local CharacterCFrame = WeldBase.CFrame

    if not RagdollEnabled then

        Character.Humanoid.AnimationPlayed:Connect(

            function(Animation)

                Animation:Stop()

            end

        )

        for _, Track in next, Character.Humanoid:GetPlayingAnimationTracks() do

            Track:Stop()

        end

        if HideCharacter then

            local Platform = Instance.new("Part")

            Platform.Anchored = true

            Platform.Size = Vector3.new(100, 5, 100)

            Platform.CFrame = CFrame.new(0, 10000, 0)

            Platform.Transparency = 1

            Platform.Parent = workspace

            Character:MoveTo(Platform.Position + Vector3.new(0, 5, 0))

            wait(.5)

        end

        if AnchorCharacter then

            for _, Part in pairs(Character:GetChildren()) do

                if Part:IsA("BasePart") then

                    Part.Anchored = true

                end

            end

        end

    end

    --[[

    function Tween(Object, Style, Direction, Time, Goal)

        local tweenInfo = TweenInfo.new(Time, Enum.EasingStyle[Style], Enum.EasingDirection[Direction])

        local tween = game:GetService("TweenService"):Create(Object, tweenInfo, Goal)

        tween.Completed:Connect(

            function()

                tween:Destroy()

            end

        )

        tween:Play()

        return tween

    end

    local function GetMotorForLimb(Limb)

        for _, Motor in next, Character:GetDescendants() do

            if Motor:IsA("Motor6D") and Motor.Part1 == Limb then

                return Motor

            end

        end

    end

    local function CreateAlignment(Limb, Part0)

        local Attachment0 = Instance.new("Attachment", Part0 or Anchor)

        local Attachment1 = Instance.new("Attachment", Limb)

        local Orientation = Instance.new("AlignOrientation")

        local Position = Instance.new("AlignPosition")

        Orientation.Attachment0 = Attachment1

        Orientation.Attachment1 = Attachment0

        Orientation.RigidityEnabled = false

        Orientation.MaxTorque = 20000

        Orientation.Responsiveness = 40

        Orientation.Parent = Character.hrpReplacement

        Position.Attachment0 = Attachment1

        Position.Attachment1 = Attachment0

        Position.RigidityEnabled = false

        Position.MaxForce = 40000

        Position.Responsiveness = 40

        Position.Parent = Character.hrpReplacement

        Limb.Massless = false

        local Motor = GetMotorForLimb(Limb)

        if Motor then

            Motor:Destroy()

        end

        return function(CF, Local)

            if Local then

                Attachment0.CFrame = CF

            else

                Attachment0.WorldCFrame = CF

            end

        end

    end

    local function GetExtraTool()

        for _, Tool in next, Character:GetChildren() do

            if Tool:IsA("Tool") and not Tool.Name:match("LIMB_TOOL") then

                return Tool

            end

        end

    end

    local function GetGripForHandle(Handle)

        for _, Weld in next, Character:GetDescendants() do

            if Weld:IsA("Weld") and (Weld.Part0 == Handle or Weld.Part1 == Handle) then

                return Weld

            end

        end

        wait(.2)

        for _, Weld in next, Character:GetDescendants() do

            if Weld:IsA("Weld") and (Weld.Part0 == Handle or Weld.Part1 == Handle) then

                return Weld

            end

        end

    end

    local function CreateRightGrip(Handle)

        local RightGrip = Instance.new("Weld")

        RightGrip.Name = "RightGrip"

        RightGrip.Part1 = Handle

        RightGrip.Part0 = WeldBase

        RightGrip.Parent = WeldBase

        return RightGrip

    end

    local function CreateAccessory(Accessory, DeleteMeshes)

        if not Accessory then

            return

        end

        local HatAttachment = Accessory.Handle:FindFirstChildWhichIsA("Attachment")

        local HeadAttachment = VirtualRig:FindFirstChild(HatAttachment.Name, true)

        local BasePart = HeadAttachment.Parent

        local HatAtt = HatAttachment.CFrame

        local HeadAtt = HeadAttachment.CFrame

        if DeleteMeshes then

            if Accessory.Handle:FindFirstChild("Mesh") then

                Accessory.Handle.Mesh:Destroy()

            end

        end

        wait()

        local Handle = Accessory:WaitForChild("Handle")

        if Handle:FindFirstChildWhichIsA("Weld", true) then

            Handle:FindFirstChildWhichIsA("Weld", true):Destroy()

            Handle:BreakJoints()

        else

            Handle:BreakJoints()

        end

        Handle.Massless = true

        Handle.Transparency = 0.5

        UsedAccessories[Accessory] = true

        local RightGrip = CreateRightGrip(Handle)

        wait()

        for _, Object in pairs(Handle:GetDescendants()) do

            if not Object:IsA("BasePart") then

                pcall(

                    function()

                        Object.Transparency = 1

                    end

                )

                pcall(

                    function()

                        Object.Enabled = false

                    end

                )

            end

        end

        return Handle, RightGrip, HatAtt, HeadAtt, BasePart

    end

    local function GetHeadAccessories()

        for _, Accessory in next, Character:GetChildren() do

            if Accessory:IsA("Accessory") and not UsedAccessories[Accessory] then

                local Handle, RightGrip, HatAtt, HeadAtt, BasePart = CreateAccessory(Accessory)

                table.insert(HeadAccessories, {Handle, RightGrip, HatAtt, HeadAtt, BasePart})

                do

                    Handle.Transparency = 0

                end

                if not WearAllAccessories then

                    break

                end

            end

        end

    end

    --[[

    if not RagdollEnabled then

        LeftHandle, LeftHandGrip =

            CreateAccessory(Character:FindFirstChild(AccessorySettings.LeftArm), AccessorySettings.BlockArms)

        RightHandle, RightHandGrip =

            CreateAccessory(Character:FindFirstChild(AccessorySettings.RightArm), AccessorySettings.BlockArms)

        LeftHipHandle, LeftLegGrip =

            CreateAccessory(Character:FindFirstChild(AccessorySettings.LeftLeg), AccessorySettings.BlockLegs)

        RightHipHandle, RightLegGrip =

            CreateAccessory(Character:FindFirstChild(AccessorySettings.RightLeg), AccessorySettings.BlockLegs)

        TorsoHandle, TorsoGrip =

            CreateAccessory(Character:FindFirstChild(AccessorySettings.Torso), AccessorySettings.BlockTorso)

        GetHeadAccessories()

    elseif RagdollEnabled then

        if RagdollHeadMovement then

            Permadeath()

            MoveHead = CreateAlignment(Character["Head"])

        end

        MoveRightArm = CreateAlignment(Character["Right Arm"])

        MoveLeftArm = CreateAlignment(Character["Left Arm"])

        MoveRightLeg = CreateAlignment(Character["Right Leg"])

        MoveLeftLeg = CreateAlignment(Character["Left Leg"])

        MoveTorso = CreateAlignment(Character["Torso"])

        MoveRoot = CreateAlignment(Character.hrpReplacement)

        if RagdollHeadMovement then

            for _, Accessory in next, Character:GetChildren() do

                if Accessory:IsA("Accessory") and Accessory:FindFirstChild("Handle") then

                    local Attachment1 = Accessory.Handle:FindFirstChildWhichIsA("Attachment")

                    local Attachment0 = Character:FindFirstChild(tostring(Attachment1), true)

                    local Orientation = Instance.new("AlignOrientation")

                    local Position = Instance.new("AlignPosition")

                    print(Attachment1, Attachment0, Accessory)

                    Orientation.Attachment0 = Attachment1

                    Orientation.Attachment1 = Attachment0

                    Orientation.RigidityEnabled = false

                    Orientation.ReactionTorqueEnabled = true

                    Orientation.MaxTorque = 20000

                    Orientation.Responsiveness = 40

                    Orientation.Parent = Character.Head

                    Position.Attachment0 = Attachment1

                    Position.Attachment1 = Attachment0

                    Position.RigidityEnabled = false

                    Position.ReactionForceEnabled = true

                    Position.MaxForce = 40000

                    Position.Responsiveness = 40

                    Position.Parent = Character.Head

                end

            end

        end

    end

    --[[

    VirtualRig.Name = "VirtualRig"

    VirtualRig.RightFoot.BodyPosition.Position = CharacterCFrame.p

    VirtualRig.LeftFoot.BodyPosition.Position = CharacterCFrame.p

    VirtualRig.Parent = workspace

    VirtualRig:SetPrimaryPartCFrame(CharacterCFrame)

    VirtualRig.Humanoid.Health = 0

    VirtualRig:BreakJoints()

    --

    VirtualBody.Parent = workspace

    VirtualBody.Name = "VirtualBody"

    VirtualBody.Humanoid.WalkSpeed = 8

    VirtualBody.Humanoid.CameraOffset = Vector3.new(0, StudsOffset, 0)

    VirtualBody:SetPrimaryPartCFrame(CharacterCFrame)

    VirtualBody.Humanoid.Died:Connect(

        function()

            print("Virtual death")

            if AutoRespawn then

                Character:BreakJoints()

                if RagdollHeadMovement and RagdollEnabled then

                    Network:Unclaim()

                    Respawn()

                end

            end

        end

    )

    --

    Camera.CameraSubject = VirtualBody.Humanoid

    Character.Humanoid.WalkSpeed = 0

    Character.Humanoid.JumpPower = 1

    for _, Part in next, VirtualBody:GetChildren() do

        if Part:IsA("BasePart") then

            Part.Transparency = 1

        end

    end

    for _, Part in next, VirtualRig:GetChildren() do

        if Part:IsA("BasePart") then

            Part.Transparency = 1

        end

    end

    if not VRReady then

        VirtualRig.RightUpperArm.ShoulderConstraint.RigidityEnabled = true

        VirtualRig.LeftUpperArm.ShoulderConstraint.RigidityEnabled = true

    end

    local OnMoving =

        RunService.Stepped:Connect(

        function()

            local Direction = Character.Humanoid.MoveDirection

            local Start = VirtualBody.HumanoidRootPart.Position

            local Point = Start + Direction * 6

            VirtualBody.Humanoid:MoveTo(Point)

        end

    )

    Character.Humanoid.Jumping:Connect(

        function()

            VirtualBody.Humanoid.Jump = true

        end

    )

    UserInputService.JumpRequest:Connect(

        function()

            VirtualBody.Humanoid.Jump = true

        end

    )

    --[[

    if RagdollEnabled then

        for _, Part in pairs(Character:GetDescendants()) do

            if Part:IsA("BasePart") and Part.Name == "Handle" and Part.Parent:IsA("Accessory") then

                Part.LocalTransparencyModifier = 0

            elseif Part:IsA("BasePart") and Part.Transparency < 0 xss=removed xss=removed xss=removed xss=removed xss=removed xss=removed xss=removed xss=removed xss=removed xss=removed xss=removed xss=removed xss=removed> 0 then

            MaxDist = .5

        else

            MaxDist = 1

        end

        local PastThreshold = (Foot.Position - Target.Position).Magnitude > MaxDist

        local PastTick = tick() - FootUpdateDebounce >= 2

        if PastThreshold or PastTick then

            FootUpdateDebounce = tick()

        end

        return PastThreshold or PastTick

    end

    local function FootYield()

        local RightFooting = VirtualRig.RightFoot.BodyPosition

        local LeftFooting = VirtualRig.LeftFoot.BodyPosition

        local LowerTorso = VirtualRig.LowerTorso

        local Yield = tick()

        repeat

            RunService.Stepped:Wait()

            if

                (LowerTorso.Position - RightFooting.Position).Y > 4 or

                    (LowerTorso.Position - LeftFooting.Position).Y > 4 or

                    ((LowerTorso.Position - RightFooting.Position) * Vector3.new(1, 0, 1)).Magnitude > 4 or

                    ((LowerTorso.Position - LeftFooting.Position) * Vector3.new(1, 0, 1)).Magnitude > 4

             then

                break

            end

        until tick() - Yield >= .17

    end

    local function UpdateFooting()

        if not VirtualRig:FindFirstChild("LowerTorso") then

            wait()

            return

        end

        local Floor, FloorPosition, FloorNormal, Dist = FloorRay(VirtualRig.LowerTorso, 3)

        Dist = math.clamp(Dist, 0, 5)

        local FootTarget =

            VirtualRig.LowerTorso.CFrame * CFrame.new(FootPlacementSettings.RightOffset) - Vector3.new(0, Dist, 0) +

            Character.Humanoid.MoveDirection * (VirtualBody.Humanoid.WalkSpeed / 8) * 2

        if FootReady(VirtualRig.RightFoot, FootTarget) then

            VirtualRig.RightFoot.BodyPosition.Position = FootTarget.p

            VirtualRig.RightFoot.BodyGyro.CFrame = Flatten(VirtualRig.LowerTorso.CFrame)

        end

        FootYield()

        local FootTarget =

            VirtualRig.LowerTorso.CFrame * CFrame.new(FootPlacementSettings.LeftOffset) - Vector3.new(0, Dist, 0) +

            Character.Humanoid.MoveDirection * (VirtualBody.Humanoid.WalkSpeed / 8) * 2

        if FootReady(VirtualRig.LeftFoot, FootTarget) then

            VirtualRig.LeftFoot.BodyPosition.Position = FootTarget.p

            VirtualRig.LeftFoot.BodyGyro.CFrame = Flatten(VirtualRig.LowerTorso.CFrame)

        end

    end

    local function UpdateTorsoPosition()

        if not RagdollEnabled then

            if TorsoHandle then

                local Positioning = VirtualRig.UpperTorso.CFrame

                if not TorsoGrip or not TorsoGrip.Parent then

                    TorsoGrip = CreateRightGrip(TorsoHandle)

                end

                local Parent = TorsoGrip.Parent

                TorsoGrip.C1 = CFrame.new()

                TorsoGrip.C0 =

                    TorsoGrip.C0:Lerp(

                    WeldBase.CFrame:ToObjectSpace(Positioning * CFrame.new(0, -0.25, 0) * AccessorySettings.LimbOffset),

                    Smoothness

                )

                TorsoGrip.Parent = nil

                TorsoGrip.Parent = Parent

            end

        else

            local Positioning = VirtualRig.UpperTorso.CFrame

            MoveTorso(Positioning * CFrame.new(0, -0.25, 0))

            MoveRoot(Positioning * CFrame.new(0, -0.25, 0))

        end

    end

    local function UpdateLegPosition()

        if not RagdollEnabled then

            if RightHipHandle then

                local Positioning =

                    VirtualRig.RightLowerLeg.CFrame:Lerp(VirtualRig.RightFoot.CFrame, 0.5) + Vector3.new(0, 0.5, 0)

                if not RightHipHandle or not RightHipHandle.Parent then

                    RightLegGrip = CreateRightGrip(RightHipHandle)

                end

                local Parent = RightLegGrip.Parent

                RightLegGrip.C1 = CFrame.new()

                RightLegGrip.C0 =

                    RightLegGrip.C0:Lerp(

                    WeldBase.CFrame:ToObjectSpace(Positioning * AccessorySettings.LimbOffset),

                    Smoothness

                )

                RightLegGrip.Parent = nil

                RightLegGrip.Parent = Parent

            end

            if LeftHipHandle then

                local Positioning =

                    VirtualRig.LeftLowerLeg.CFrame:Lerp(VirtualRig.LeftFoot.CFrame, 0.5) + Vector3.new(0, 0.5, 0)

                if not LeftLegGrip or not LeftLegGrip.Parent then

                    LeftLegGrip = CreateRightGrip(LeftHipHandle)

                end

                local Parent = LeftLegGrip.Parent

                LeftLegGrip.C1 = CFrame.new()

                LeftLegGrip.C0 =

                    LeftLegGrip.C0:Lerp(

                    WeldBase.CFrame:ToObjectSpace(Positioning * AccessorySettings.LimbOffset),

                    Smoothness

                )

                LeftLegGrip.Parent = nil

                LeftLegGrip.Parent = Parent

            end

        else

            do

                local Positioning =

                    VirtualRig.RightLowerLeg.CFrame:Lerp(VirtualRig.RightFoot.CFrame, 0.5) *

                    CFrame.Angles(0, math.rad(180), 0) +

                    Vector3.new(0, 0.5, 0)

                MoveRightLeg(Positioning)

            end

            do

                local Positioning =

                    VirtualRig.LeftLowerLeg.CFrame:Lerp(VirtualRig.LeftFoot.CFrame, 0.5) *

                    CFrame.Angles(0, math.rad(180), 0) +

                    Vector3.new(0, 0.5, 0)

                MoveLeftLeg(Positioning)

            end

        end

    end

    warn("VRReady is", VRReady)

    local function OnUserCFrameChanged(UserCFrame, Positioning, IgnoreTorso)

        local Positioning = Camera.CFrame * Positioning

        if not IgnoreTorso then

            UpdateTorsoPosition()

            UpdateLegPosition()

        end

        if not RagdollEnabled then

            if UserCFrame == Enum.UserCFrame.Head and AccessorySettings.Head then

                for _, Table in next, HeadAccessories do

                    local Handle, RightGrip, HatAtt, HeadAtt, BasePart = unpack(Table)

                    local LocalPositioning = Positioning

                    if not RightGrip or not RightGrip.Parent then

                        RightGrip = CreateRightGrip(Handle)

                        Table[2] = RightGrip

                    end

                    local Parent = RightGrip.Parent

                    if BasePart then

                        LocalPositioning = BasePart.CFrame * HeadAtt

                    end

                    RightGrip.C1 = HatAtt

                    RightGrip.C0 = RightGrip.C0:Lerp(WeldBase.CFrame:ToObjectSpace(LocalPositioning), Smoothness)

                    RightGrip.Parent = nil

                    RightGrip.Parent = Parent

                end

            elseif RightHandle and UserCFrame == Enum.UserCFrame.RightHand and AccessorySettings.RightArm then

                local HandPosition = Positioning

                local LocalPositioning = Positioning

                if not RightHandGrip or not RightHandGrip.Parent then

                    RightHandGrip = CreateRightGrip(RightHandle)

                end

                if AccurateHandPosition then

                    HandPosition = HandPosition * CFrame.new(0, 0, 1)

                end

                if not VRReady then

                    local HeadRotation = Camera.CFrame - Camera.CFrame.p

                    HandPosition =

                        VirtualRig.RightUpperArm.CFrame:Lerp(VirtualRig.RightLowerArm.CFrame, 0.5) *

                        AccessorySettings.LimbOffset

                    --LocalPositioning = (HeadRotation + (HandPosition * CFrame.new(0, 0, 1)).p) * CFrame.Angles(math.rad(-45), 0, 0)

                    LocalPositioning = HandPosition * CFrame.new(0, 0, 1) * CFrame.Angles(math.rad(-180), 0, 0)

                    if Point2 then

                        VirtualRig.RightUpperArm.Aim.MaxTorque = Vector3.new(math.huge, math.huge, math.huge)

                        VirtualRig.RightUpperArm.Aim.CFrame = Camera.CFrame * AccessorySettings.LimbOffset

                    elseif VirtualRig.RightUpperArm.Aim.MaxTorque ~= Vector3.new(0, 0, 0) then

                        VirtualRig.RightUpperArm.Aim.MaxTorque = Vector3.new(0, 0, 0)

                    end

                elseif AccurateHandPosition then

                    LocalPositioning = HandPosition

                end

                local Parent = RightHandGrip.Parent

                RightHandGrip.C1 = CFrame.new()

                RightHandGrip.C0 = RightHandGrip.C0:Lerp(WeldBase.CFrame:ToObjectSpace(HandPosition), Smoothness)

                RightHandGrip.Parent = nil

                RightHandGrip.Parent = Parent

                --

                local EquippedTool = GetExtraTool()

                if EquippedTool and EquippedTool:FindFirstChild("Handle") then

                    local EquippedGrip = GetGripForHandle(EquippedTool.Handle)

                    local Parent = EquippedGrip.Parent

                    local ArmBaseCFrame = ArmBase.CFrame

                    if ArmBase.Name == "Right Arm" then

                        ArmBaseCFrame = ArmBaseCFrame

                    end

                    EquippedGrip.C1 = EquippedTool.Grip

                    EquippedGrip.C0 = EquippedGrip.C0:Lerp(ArmBaseCFrame:ToObjectSpace(LocalPositioning), Smoothness)

                    EquippedGrip.Parent = nil

                    EquippedGrip.Parent = Parent

                end

            elseif LeftHandle and UserCFrame == Enum.UserCFrame.LeftHand and AccessorySettings.LeftArm then

                local HandPosition = Positioning

                if not LeftHandGrip or not LeftHandGrip.Parent then

                    LeftHandGrip = CreateRightGrip(LeftHandle)

                end

                if AccurateHandPosition then

                    HandPosition = HandPosition * CFrame.new(0, 0, 1)

                end

                if not VRReady then

                    HandPosition =

                        VirtualRig.LeftUpperArm.CFrame:Lerp(VirtualRig.LeftLowerArm.CFrame, 0.5) *

                        AccessorySettings.LimbOffset

                    --warn("Setting HandPosition to hands")

                    if Point1 then

                        VirtualRig.LeftUpperArm.Aim.MaxTorque = Vector3.new(math.huge, math.huge, math.huge)

                        VirtualRig.LeftUpperArm.Aim.CFrame = Camera.CFrame * AccessorySettings.LimbOffset

                    elseif VirtualRig.LeftUpperArm.Aim.MaxTorque ~= Vector3.new(0, 0, 0) then

                        VirtualRig.LeftUpperArm.Aim.MaxTorque = Vector3.new(0, 0, 0)

                    end

                end

                local Parent = LeftHandGrip.Parent

                LeftHandGrip.C1 = CFrame.new()

                LeftHandGrip.C0 = LeftHandGrip.C0:Lerp(WeldBase.CFrame:ToObjectSpace(HandPosition), Smoothness)

                LeftHandGrip.Parent = nil

                LeftHandGrip.Parent = Parent

            end

        end

        if RagdollEnabled then

            if UserCFrame == Enum.UserCFrame.Head and RagdollHeadMovement then

                MoveHead(Positioning)

            elseif UserCFrame == Enum.UserCFrame.RightHand then

                local Positioning = Positioning

                if not VRReady then

                    Positioning = VirtualRig.RightUpperArm.CFrame:Lerp(VirtualRig.RightLowerArm.CFrame, 0.5)

                elseif AccurateHandPosition then

                    Positioning = Positioning * CFrame.new(0, 0, 1)

                end

                if VRReady then

                    Positioning = Positioning * AccessorySettings.LimbOffset

                end

                MoveRightArm(Positioning)

                if Point2 then

                    VirtualRig.RightUpperArm.Aim.MaxTorque = Vector3.new(math.huge, math.huge, math.huge)

                    VirtualRig.RightUpperArm.Aim.CFrame = Camera.CFrame * AccessorySettings.LimbOffset

                elseif VirtualRig.RightUpperArm.Aim.MaxTorque ~= Vector3.new(0, 0, 0) then

                    VirtualRig.RightUpperArm.Aim.MaxTorque = Vector3.new(0, 0, 0)

                end

            elseif UserCFrame == Enum.UserCFrame.LeftHand then

                local Positioning = Positioning

                if not VRReady then

                    Positioning = VirtualRig.LeftUpperArm.CFrame:Lerp(VirtualRig.LeftLowerArm.CFrame, 0.5)

                elseif AccurateHandPosition then

                    Positioning = Positioning * CFrame.new(0, 0, 1)

                end

                if VRReady then

                    Positioning = Positioning * AccessorySettings.LimbOffset

                end

                MoveLeftArm(Positioning)

                if Point1 then

                    VirtualRig.LeftUpperArm.Aim.MaxTorque = Vector3.new(math.huge, math.huge, math.huge)

                    VirtualRig.LeftUpperArm.Aim.CFrame = Camera.CFrame * AccessorySettings.LimbOffset

                elseif VirtualRig.LeftUpperArm.Aim.MaxTorque ~= Vector3.new(0, 0, 0) then

                    VirtualRig.LeftUpperArm.Aim.MaxTorque = Vector3.new(0, 0, 0)

                end

            end

        end

        if UserCFrame == Enum.UserCFrame.Head then

            VirtualRig.Head.CFrame = Positioning

        elseif UserCFrame == Enum.UserCFrame.RightHand and VRReady then

            VirtualRig.RightHand.CFrame = Positioning

        elseif UserCFrame == Enum.UserCFrame.LeftHand and VRReady then

            VirtualRig.LeftHand.CFrame = Positioning

        end

        if not VRReady and VirtualRig.LeftHand.Anchored then

            VirtualRig.RightHand.Anchored = false

            VirtualRig.LeftHand.Anchored = false

        elseif VRReady and not VirtualRig.LeftHand.Anchored then

            VirtualRig.RightHand.Anchored = true

            VirtualRig.LeftHand.Anchored = true

        end

    end

    local CFrameChanged = VRService.UserCFrameChanged:Connect(OnUserCFrameChanged)

    local OnStepped =

        RunService.Stepped:Connect(

        function()

            for _, Part in pairs(VirtualRig:GetChildren()) do

                if Part:IsA("BasePart") then

                    Part.CanCollide = false

                end

            end

            if RagdollEnabled then

                for _, Part in pairs(Character:GetChildren()) do

                    if Part:IsA("BasePart") then

                        Part.CanCollide = false

                    end

                end

            end

            if NoCollision then

                for _, Player in pairs(Players:GetPlayers()) do

                    if Player ~= Client and Player.Character then

                        local Descendants = Player.Character:GetDescendants()

                        for i = 1, #Descendants do

                            local Part = Descendants[i]

                            if Part:IsA("BasePart") then

                                Part.CanCollide = false

                                Part.Velocity = Vector3.new()

                                Part.RotVelocity = Vector3.new()

                            end

                        end

                    end

                end

            end

        end

    )

    local OnRenderStepped =

        RunService.Stepped:Connect(

        function()

            Camera.CameraSubject = VirtualBody.Humanoid

            if RagdollEnabled then

                Character.hrpReplacement.CFrame = VirtualRig.UpperTorso.CFrame

                Character.hrpReplacement.Velocity = Vector3.new(0, 0, 0)

            end

            if not VRReady then

                OnUserCFrameChanged(Enum.UserCFrame.Head, CFrame.new(0, 0, 0))

                OnUserCFrameChanged(Enum.UserCFrame.RightHand, CFrame.new(0, 0, 0), true)

                OnUserCFrameChanged(Enum.UserCFrame.LeftHand, CFrame.new(0, 0, 0), true)

            end

        end

    )

    spawn(

        function()

            while Character and Character.Parent do

                FootYield()

                UpdateFooting()

            end

        end

    )

    --[[

    local OnInput =

        UserInputService.InputBegan:Connect(

        function(Input, Processed)

            if not Processed then

                if Input.KeyCode == Enum.KeyCode.LeftControl or Input.KeyCode == Enum.KeyCode.ButtonL2 then

                    Tween(

                        VirtualBody.Humanoid,

                        "Elastic",

                        "Out",

                        1,

                        {

                            CameraOffset = Vector3.new(0, StudsOffset - 1.5, 0)

                        }

                    )

                end

                if Input.KeyCode == Enum.KeyCode.X then

                    if RagdollEnabled and RagdollHeadMovement then

                        Network:Unclaim()

                        Respawn()

                    end

                end

                if Input.KeyCode == Enum.KeyCode.C then

                    VirtualBody:MoveTo(Mouse.Hit.p)

                    VirtualRig:MoveTo(Mouse.Hit.p)

                end

            end

            if Input.KeyCode == Enum.KeyCode.LeftShift or Input.KeyCode == Enum.KeyCode.ButtonR2 then

                Tween(

                    VirtualBody.Humanoid,

                    "Sine",

                    "Out",

                    1,

                    {

                        WalkSpeed = 16

                    }

                )

            end

            if not VRReady and Input.UserInputType == Enum.UserInputType.MouseButton1 then

                Point1 = true

            end

            if not VRReady and Input.UserInputType == Enum.UserInputType.MouseButton2 then

                Point2 = true

            end

            if VRReady and Input.KeyCode == Enum.KeyCode.ButtonY then

                Character:BreakJoints()

                if RagdollEnabled and RagdollHeadMovement then

                    Network:Unclaim()

                    Respawn()

                end

            end

        end

    )

    local OnInputEnded =

        UserInputService.InputEnded:Connect(

        function(Input, Processed)

            if not Processed then

                if Input.KeyCode == Enum.KeyCode.LeftControl or Input.KeyCode == Enum.KeyCode.ButtonL2 then

                    Tween(

                        VirtualBody.Humanoid,

                        "Elastic",

                        "Out",

                        1,

                        {

                            CameraOffset = Vector3.new(0, StudsOffset, 0)

                        }

                    )

                end

            end

            if Input.KeyCode == Enum.KeyCode.LeftShift or Input.KeyCode == Enum.KeyCode.ButtonR2 then

                Tween(

                    VirtualBody.Humanoid,