-- CLOVR - FE FULL-BODY VR SCRIPT

-- April 21st Update - TOOL HOLDING ADDED

-- | made by 0866!!!!!!! and abacaxl!!!!!!!!

-- | tysm unverified

-- This is an older version of CLOVR, I found that the legs would 'walk' better in
this version than the one we released.

--Controls are a bit different from last release because this is older. Still works
good!

--RagDollEnabled is set to true, DON'T set it to false or CLOVR won't work. Feel
free to change the other settings though. -Abacaxl

--|| Settings:

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 = [Link]([Link](90), 0, 0);

}

local FootPlacementSettings = {
RightOffset = [Link](.5, 0, 0),
LeftOffset = [Link](-.5, 0, 0),
}

--|| Script:

local Script = nil;

Script = function()

--[[
Variables
--]]

local Players = game:GetService("Players")

local Client = [Link]
local Character = [Link] or [Link]:Wait()
local WeldBase = Character:WaitForChild("HumanoidRootPart")
local ArmBase = Character:FindFirstChild("RightHand") or
Character:FindFirstChild("Right Arm") or WeldBase
local Backpack = Client:WaitForChild("Backpack")
local Mouse = Client:GetMouse()

local Camera = [Link]

local VRService = game:GetService("VRService")

local VRReady = [Link]

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 = [Link]("Part")

[Link] = true
[Link] = 1
[Link] = false
[Link] = workspace

if RagdollEnabled then
 print("RagdollEnabled, thank you for using CLOVR!")
local NetworkAccess = [Link](function()
settings().[Link] = 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
[Link] = 0.1 [Link] = 0 end end
game:GetService("Players").[Link] =
[Link]([Link],[Link])
game:GetService("Players").[Link] = [Link]*[Link] end
end)
[Link](NetworkAccess)
end

--[[
Character Protection
--]]

local CharacterCFrame = [Link]

if not RagdollEnabled then

[Link]:Connect(function(Animation)
Animation:Stop()
end)

for _, Track in next, [Link]:GetPlayingAnimationTracks() do

Track:Stop()
end

if HideCharacter then
local Platform = [Link]("Part")

[Link] = true
[Link] = [Link](100, 5, 100)
[Link] = [Link](0, 10000, 0)
[Link] = 1
[Link] = workspace

Character:MoveTo([Link] + [Link](0, 5, 0))

wait(.5)
end

if AnchorCharacter then
for _, Part in pairs(Character:GetChildren()) do
if Part:IsA("BasePart") then
[Link] = true
end
end
end
end

--[[
Functions
--]]

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

local tweenInfo = [Link](Time, [Link][Style],
[Link][Direction])
 local tween = game:GetService("TweenService"):Create(Object, tweenInfo, Goal)

[Link]: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 = [Link]("Attachment", Part0 or Anchor)
local Attachment1 = [Link]("Attachment", Limb)

local Orientation = [Link]("AlignOrientation")

local Position = [Link]("AlignPosition")

Orientation.Attachment0 = Attachment1
Orientation.Attachment1 = Attachment0
[Link] = false
[Link] = 20000
[Link] = 40
[Link] = [Link]

Position.Attachment0 = Attachment1
Position.Attachment1 = Attachment0
[Link] = false
[Link] = 40000
[Link] = 40
[Link] = [Link]

[Link] = false

local Motor = GetMotorForLimb(Limb)

if Motor then
Motor:Destroy()
end

return function(CF, Local)

if Local then
[Link] = CF
else
[Link] = CF
end
end;
end

local function GetExtraTool()

for _, Tool in next, Character:GetChildren() do
if Tool:IsA("Tool") and not [Link]: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 = [Link]("Weld")

[Link] = "RightGrip"
RightGrip.Part1 = Handle
RightGrip.Part0 = WeldBase
[Link] = WeldBase

return RightGrip
end

local function CreateAccessory(Accessory, DeleteMeshes)

if not Accessory then
return
end

local HatAttachment = [Link]:FindFirstChildWhichIsA("Attachment")

local HeadAttachment = VirtualRig:FindFirstChild([Link], true)
local BasePart = [Link]

local HatAtt = [Link]

local HeadAtt = [Link]

if DeleteMeshes then
if [Link]:FindFirstChild("Mesh") then
[Link]: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

[Link] = true
[Link] = 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()
[Link] = 1
end)

pcall(function()
[Link] = 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)

[Link](HeadAccessories, {Handle, RightGrip, HatAtt,

HeadAtt, BasePart})

do
[Link] = 1
end

if not WearAllAccessories then

break
end
end
end
end

--[[
VR Replication Setup
--]]

if not RagdollEnabled then

LeftHandle, LeftHandGrip =
CreateAccessory(Character:FindFirstChild([Link]),
[Link])
RightHandle, RightHandGrip =
CreateAccessory(Character:FindFirstChild([Link]),
[Link])
 LeftHipHandle, LeftLegGrip =
CreateAccessory(Character:FindFirstChild([Link]),
[Link])
RightHipHandle, RightLegGrip =
CreateAccessory(Character:FindFirstChild([Link]),
[Link])
TorsoHandle, TorsoGrip =
CreateAccessory(Character:FindFirstChild([Link]),
[Link])
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([Link])

if RagdollHeadMovement then
for _, Accessory in next, Character:GetChildren() do
if Accessory:IsA("Accessory") and
Accessory:FindFirstChild("Handle") then
local Attachment1 =
[Link]:FindFirstChildWhichIsA("Attachment")
local Attachment0 =
Character:FindFirstChild(tostring(Attachment1), true)

local Orientation = [Link]("AlignOrientation")

local Position = [Link]("AlignPosition")

print(Attachment1, Attachment0, Accessory)

Orientation.Attachment0 = Attachment1
Orientation.Attachment1 = Attachment0
[Link] = false
[Link] = true
[Link] = 20000
[Link] = 40
[Link] = [Link]

Position.Attachment0 = Attachment1
Position.Attachment1 = Attachment0
[Link] = false
[Link] = true
[Link] = 40000
[Link] = 40
[Link] = [Link]
end
end
end
end

--[[
 Movement
--]]

[Link] = "VirtualRig"
[Link] = CharacterCFrame.p
[Link] = CharacterCFrame.p
[Link] = workspace
VirtualRig:SetPrimaryPartCFrame(CharacterCFrame)

[Link] = 0
VirtualRig:BreakJoints()
--

[Link] = workspace
[Link] = "VirtualBody"
[Link] = 8
[Link] = [Link](0, StudsOffset, 0)
VirtualBody:SetPrimaryPartCFrame(CharacterCFrame)

[Link]:Connect(function()
print("Virtual death")
if AutoRespawn then
Character:BreakJoints()

if RagdollHeadMovement and RagdollEnabled then

Network:Unclaim()
Respawn()
end
end
end)
--

[Link] = [Link]

[Link] = 0
[Link] = 1

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

if Part:IsA("BasePart") then
[Link] = 1
end
end

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

if Part:IsA("BasePart") then
[Link] = 1
end
end

if not VRReady then

[Link] = true
[Link] = true
end

local OnMoving = [Link]:Connect(function()

local Direction = [Link]
local Start = [Link]
local Point = Start + Direction * 6
 [Link]:MoveTo(Point)
end)

[Link]:Connect(function()
[Link] = true
end)

[Link]:Connect(function()
[Link] = true
end)

--[[
VR Replication
--]]

if RagdollEnabled then
for _, Part in pairs(Character:GetDescendants()) do
if Part:IsA("BasePart") and [Link] == "Handle" and
[Link]:IsA("Accessory") then
[Link] = 1
elseif Part:IsA("BasePart") and [Link] < 0.5 and [Link]
~= "Head" then
[Link] = 0.5
elseif Part:IsA("BasePart") and [Link] == "Head" then
[Link] = 1
end

if not Part:IsA("BasePart") and not Part:IsA("AlignPosition") and not

Part:IsA("AlignOrientation") then
pcall(function()
[Link] = 1
end)

pcall(function()
[Link] = false
end)
end
end
end

local FootUpdateDebounce = tick()

local function FloorRay(Part, Distance)

local Position = [Link].p
local Target = Position - [Link](0, Distance, 0)
local Line = [Link](Position, (Target - Position).Unit * Distance)

local FloorPart, FloorPosition, FloorNormal =

workspace:FindPartOnRayWithIgnoreList(Line, {VirtualRig, VirtualBody, Character})

if FloorPart then
return FloorPart, FloorPosition, FloorNormal, (FloorPosition -
Position).Magnitude
else
return nil, Target, [Link](), Distance
end
end
local function Flatten(CF)
local X,Y,Z = CF.X,CF.Y,CF.Z
local LX,LZ = [Link].X,[Link].Z

return [Link](X,Y,Z) * [Link](0,math.atan2(LX,LZ),0)

end

local FootTurn = 1

local function FootReady(Foot, Target)

local MaxDist

if [Link] > 0 then

MaxDist = .5
else
MaxDist = 1
end

local PastThreshold = ([Link] - [Link]).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 = [Link]
local LeftFooting = [Link]
local LowerTorso = [Link]

local Yield = tick()

repeat
[Link]:Wait()
if
([Link] - [Link]).Y > 4
or
([Link] - [Link]).Y > 4
or
(([Link] - [Link]) * [Link](1,
0, 1)).Magnitude > 4
or
(([Link] - [Link]) * [Link](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([Link], 3)

Dist = [Link](Dist, 0, 5)

local FootTarget =
[Link] *
[Link]([Link]) -
[Link](0, Dist, 0) +
[Link] * ([Link] / 8)
* 2

if FootReady([Link], FootTarget) then

[Link] = FootTarget.p
[Link] =
Flatten([Link])
end

FootYield()

local FootTarget =
[Link] *
[Link]([Link]) -
[Link](0, Dist, 0) +
[Link] * ([Link] / 8)
* 2

if FootReady([Link], FootTarget) then

[Link] = FootTarget.p
[Link] =
Flatten([Link])
end
end

local function UpdateTorsoPosition()

if not RagdollEnabled then
if TorsoHandle then
local Positioning = [Link]

if not TorsoGrip or not [Link] then

TorsoGrip = CreateRightGrip(TorsoHandle)
end

local Parent = [Link]

TorsoGrip.C1 = [Link]()
TorsoGrip.C0 =
TorsoGrip.C0:Lerp([Link]:ToObjectSpace(Positioning * [Link](0, -0.25,
0) * [Link]), Smoothness)
[Link] = nil
[Link] = Parent
end
else
local Positioning = [Link]

MoveTorso(Positioning * [Link](0, -0.25, 0))

 MoveRoot(Positioning * [Link](0, -0.25, 0))
end
end

local function UpdateLegPosition()

if not RagdollEnabled then
if RightHipHandle then
local Positioning =
[Link]
: Lerp([Link], 0.5)
+ [Link](0, 0.5, 0)

if not RightHipHandle or not [Link] then

RightLegGrip = CreateRightGrip(RightHipHandle)
end

local Parent = [Link]

RightLegGrip.C1 = [Link]()
RightLegGrip.C0 =
RightLegGrip.C0:Lerp([Link]:ToObjectSpace(Positioning *
[Link]), Smoothness)
[Link] = nil
[Link] = Parent
end

if LeftHipHandle then
local Positioning =
[Link]
: Lerp([Link], 0.5)
+ [Link](0, 0.5, 0)

if not LeftLegGrip or not [Link] then

LeftLegGrip = CreateRightGrip(LeftHipHandle)
end

local Parent = [Link]

LeftLegGrip.C1 = [Link]()
LeftLegGrip.C0 =
LeftLegGrip.C0:Lerp([Link]:ToObjectSpace(Positioning *
[Link]), Smoothness)
[Link] = nil
[Link] = Parent
end
else
do
local Positioning =
[Link]
: Lerp([Link], 0.5)
* [Link](0, [Link](180), 0)
+ [Link](0, 0.5, 0)

MoveRightLeg(Positioning)
end

do
local Positioning =
[Link]
 : Lerp([Link], 0.5)
* [Link](0, [Link](180), 0)
+ [Link](0, 0.5, 0)

MoveLeftLeg(Positioning)
end
end
end

warn("VRReady is", VRReady)

local function OnUserCFrameChanged(UserCFrame, Positioning, IgnoreTorso)

local Positioning = [Link] * Positioning

if not IgnoreTorso then

UpdateTorsoPosition()
UpdateLegPosition()
end

if not RagdollEnabled then

if UserCFrame == [Link] and [Link] then
for _, Table in next, HeadAccessories do
local Handle, RightGrip, HatAtt, HeadAtt, BasePart =
unpack(Table)
local LocalPositioning = Positioning

if not RightGrip or not [Link] then

RightGrip = CreateRightGrip(Handle)
Table[2] = RightGrip
end

local Parent = [Link]

if BasePart then
LocalPositioning = [Link] * HeadAtt
end

RightGrip.C1 = HatAtt
RightGrip.C0 =
RightGrip.C0:Lerp([Link]:ToObjectSpace(LocalPositioning), Smoothness)
[Link] = nil
[Link] = Parent
end

elseif RightHandle and UserCFrame == [Link] and

[Link] then
local HandPosition = Positioning
local LocalPositioning = Positioning

if not RightHandGrip or not [Link] then

RightHandGrip = CreateRightGrip(RightHandle)
end

if AccurateHandPosition then
HandPosition = HandPosition * [Link](0, 0, 1)
end

if not VRReady then

local HeadRotation = [Link] - [Link].p
 HandPosition =
[Link]:Lerp([Link], 0.5) *
[Link]

--LocalPositioning = (HeadRotation + (HandPosition *

[Link](0, 0, 1)).p) * [Link]([Link](-45), 0, 0)
LocalPositioning = HandPosition * [Link](0, 0, 1) *
[Link]([Link](-180), 0, 0)

if Point2 then
[Link] =
[Link]([Link], [Link], [Link])
[Link] = [Link] *
[Link]
elseif [Link] ~=
[Link](0, 0, 0) then
[Link] =
[Link](0, 0, 0)
end
elseif AccurateHandPosition then
LocalPositioning = HandPosition
end

local Parent = [Link]

RightHandGrip.C1 = [Link]()
RightHandGrip.C0 =
RightHandGrip.C0:Lerp([Link]:ToObjectSpace(HandPosition), Smoothness)
[Link] = nil
[Link] = Parent

--

local EquippedTool = GetExtraTool()

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

local EquippedGrip = GetGripForHandle([Link])
local Parent = [Link]

local ArmBaseCFrame = [Link]

if [Link] == "Right Arm" then
ArmBaseCFrame = ArmBaseCFrame
end

EquippedGrip.C1 = [Link]
EquippedGrip.C0 =
EquippedGrip.C0:Lerp(ArmBaseCFrame:ToObjectSpace(LocalPositioning), Smoothness)
[Link] = nil
[Link] = Parent
end

elseif LeftHandle and UserCFrame == [Link] and

[Link] then
local HandPosition = Positioning

if not LeftHandGrip or not [Link] then

LeftHandGrip = CreateRightGrip(LeftHandle)
end
 if AccurateHandPosition then
HandPosition = HandPosition * [Link](0, 0, 1)
end

if not VRReady then

HandPosition =
[Link]:Lerp([Link], 0.5) *
[Link]
--warn("Setting HandPosition to hands")
if Point1 then
[Link] =
[Link]([Link], [Link], [Link])
[Link] = [Link] *
[Link]
elseif [Link] ~=
[Link](0, 0, 0) then
[Link] =
[Link](0, 0, 0)
end
end

local Parent = [Link]

LeftHandGrip.C1 = [Link]()
LeftHandGrip.C0 =
LeftHandGrip.C0:Lerp([Link]:ToObjectSpace(HandPosition), Smoothness)
[Link] = nil
[Link] = Parent

end
end

if RagdollEnabled then
if UserCFrame == [Link] and RagdollHeadMovement then
MoveHead(Positioning)
elseif UserCFrame == [Link] then
local Positioning = Positioning

if not VRReady then

Positioning =
[Link]:Lerp([Link], 0.5)
elseif AccurateHandPosition then
Positioning = Positioning * [Link](0, 0, 1)
end

if VRReady then
Positioning = Positioning * [Link]
end

MoveRightArm(Positioning)

if Point2 then
[Link] =
[Link]([Link], [Link], [Link])
[Link] = [Link] *
[Link]
elseif [Link] ~= [Link](0,
0, 0) then
 [Link] = [Link](0, 0,
0)
end
elseif UserCFrame == [Link] then
local Positioning = Positioning

if not VRReady then

Positioning =
[Link]:Lerp([Link], 0.5)
elseif AccurateHandPosition then
Positioning = Positioning * [Link](0, 0, 1)
end

if VRReady then
Positioning = Positioning * [Link]
end

MoveLeftArm(Positioning)

if Point1 then
[Link] =
[Link]([Link], [Link], [Link])
[Link] = [Link] *
[Link]
elseif [Link] ~= [Link](0, 0,
0) then
[Link] = [Link](0, 0,
0)
end
end
end

if UserCFrame == [Link] then

[Link] = Positioning

elseif UserCFrame == [Link] and VRReady then

[Link] = Positioning

elseif UserCFrame == [Link] and VRReady then

[Link] = Positioning

end

if not VRReady and [Link] then

[Link] = false
[Link] = false
elseif VRReady and not [Link] then
[Link] = true
[Link] = true
end
end

local CFrameChanged = [Link]:Connect(OnUserCFrameChanged)

local OnStepped = [Link]:Connect(function()

for _, Part in pairs(VirtualRig:GetChildren()) do
if Part:IsA("BasePart") then
[Link] = false
end
 end

if RagdollEnabled then
for _, Part in pairs(Character:GetChildren()) do
if Part:IsA("BasePart") then
[Link] = false
end
end
end

if NoCollision then
for _, Player in pairs(Players:GetPlayers()) do
if Player ~= Client and [Link] then
local Descendants = [Link]:GetDescendants()
for i = 1, #Descendants do
local Part = Descendants[i]
if Part:IsA("BasePart") then
[Link] = false
[Link] = [Link]()
[Link] = [Link]()
end
end
end
end
end
end)

local OnRenderStepped = [Link]:Connect(function()

[Link] = [Link]

if RagdollEnabled then
[Link] = [Link]
[Link] = [Link](0, 0, 0)
end

if not VRReady then

OnUserCFrameChanged([Link], [Link](0, 0, 0))

OnUserCFrameChanged([Link], [Link](0, 0, 0),

true)
OnUserCFrameChanged([Link], [Link](0, 0, 0),
true)
end
end)

spawn(function()
while Character and [Link] do
FootYield()
UpdateFooting()
end
end)

--[[
Non-VR Support + VR Mechanics
--]]

local OnInput = [Link]:Connect(function(Input, Processed)

if not Processed then
if [Link] == [Link] or [Link] ==
[Link].ButtonL2 then
Tween([Link], "Elastic", "Out", 1, {
CameraOffset = [Link](0, StudsOffset - 1.5, 0)
})
end

if [Link] == [Link].X then

if RagdollEnabled and RagdollHeadMovement then
Network:Unclaim()
Respawn()
end
end

if [Link] == [Link].C then

VirtualBody:MoveTo([Link].p)
VirtualRig:MoveTo([Link].p)
end
end

if [Link] == [Link] or [Link] ==

[Link].ButtonR2 then
Tween([Link], "Sine", "Out", 1, {
WalkSpeed = 16
})
end

if not VRReady and [Link] == [Link].MouseButton1

then
Point1 = true
end

if not VRReady and [Link] == [Link].MouseButton2

then
Point2 = true
end

if VRReady and [Link] == [Link] then

Character:BreakJoints()

if RagdollEnabled and RagdollHeadMovement then

Network:Unclaim()
Respawn()
end
end
end)

local OnInputEnded = [Link]:Connect(function(Input, Processed)

if not Processed then
if [Link] == [Link] or [Link] ==
[Link].ButtonL2 then
Tween([Link], "Elastic", "Out", 1, {
CameraOffset = [Link](0, StudsOffset, 0)
})
end
end

if [Link] == [Link] or [Link] ==

[Link].ButtonR2 then
Tween([Link], "Sine", "Out", 1, {
 WalkSpeed = 8
})
end

if not VRReady and [Link] == [Link].MouseButton1

then
Point1 = false
end

if not VRReady and [Link] == [Link].MouseButton2

then
Point2 = false
end
end)

--[[
Proper Cleanup
--]]

local OnReset

OnReset = [Link]:Connect(function()
OnReset:Disconnect();
CFrameChanged:Disconnect();
OnStepped:Disconnect();
OnRenderStepped:Disconnect();
OnMoving:Disconnect();
OnInput:Disconnect();
OnInputEnded:Disconnect();

VirtualRig:Destroy();
VirtualBody:Destroy();

if RagdollEnabled then
Network:Unclaim();
end

if AutoRun then
delay(2, function()
Script()
end)
end
end)

if ChatEnabled then
spawn(ChatHUDFunc)
end

if ViewportEnabled then
spawn(ViewHUDFunc)
end

do
--[[
Functions
--]]

local Players = game:GetService("Players")

local Client = [Link]
 local VRService = game:GetService("VRService")
local VRReady = [Link]

local UserInputService = game:GetService("UserInputService")

local RunService = game:GetService("RunService")

local Camera = [Link]

--[[
Code
--]]

if VRReady then
local Pointer = game:GetObjects("rbxassetid://4476173280")[1]

[Link] = workspace
[Link] = false
[Link] = false

local RenderStepped = [Link]:Connect(function()

if [Link] then
local RightHand = [Link] *
VRService:GetUserCFrame([Link])
local Target = RightHand * [Link](0, 0, -10)

local Line = [Link](RightHand.p, (Target.p -

RightHand.p).Unit * 128)
local Part, Position =
workspace:FindPartOnRayWithIgnoreList(Line, {VirtualRig, VirtualBody, Character,
Pointer})

local Distance = (Position - RightHand.p).Magnitude

[Link] = [Link](0, 0, -Distance)

[Link] = RightHand
end
end)

local Input = [Link]:Connect(function(Input)

if [Link] == [Link] then
[Link] = not [Link]
[Link] = not
[Link]
end
end)

--

local CharacterAdded

CharacterAdded = [Link]:Connect(function()
RenderStepped:Disconnect()
Input:Disconnect()
CharacterAdded:Disconnect()

Pointer:Destroy()
Pointer = nil
end)
 else
return
end
end

end;

Permadeath = function()
local ch = [Link]
local prt=[Link]("Model", workspace)
local z1 = [Link]("Part", prt)
[Link]="Torso"
[Link] = false
[Link] = true
local z2 =[Link]("Part", prt)
[Link]="Head"
[Link] = true
[Link] = false
local z3 =[Link]("Humanoid", prt)
[Link]="Humanoid"
[Link] = [Link](0,9999,0)
[Link] = [Link](0,9991,0)
[Link]=prt
wait(5)
warn("50%")
[Link]=ch
wait(6)
warn("100%")
end;

Respawn = function()
local ch = [Link]

local prt=[Link]("Model", workspace)

local z1 = [Link]("Part", prt)
[Link]="Torso"
[Link] = false
[Link] = true
local z2 =[Link]("Part", prt)
[Link]="Head"
[Link] = true
[Link] = false
local z3 =[Link]("Humanoid", prt)
[Link]="Humanoid"
[Link] = [Link](0,9999,0)
[Link] = [Link](0,9991,0)
[Link]=prt
wait(5)
[Link]=ch
end;

ChatHUDFunc = function()
--[[
Variables
--]]

local UserInputService = game:GetService("UserInputService")

local RunService = game:GetService("RunService")
local VRService = game:GetService("VRService")
local VRReady = [Link]

local Players = game:GetService("Players")

local Client = [Link]

local ChatHUD = game:GetObjects("rbxassetid://4476067885")[1]

local GlobalFrame = [Link]
local Template = [Link]
local LocalFrame = [Link]
local Global = [Link]
local Local = [Link]

local Camera = [Link]

[Link] = nil
[Link] = game:GetService("CoreGui")

--[[
Code
--]]

local Highlight = [Link].BackgroundColor3

local Deselected = [Link].BackgroundColor3

local OpenGlobalTab = function()

[Link].BackgroundColor3 = Highlight
[Link].BackgroundColor3 = Deselected

[Link] = [Link]
[Link] = [Link]

[Link] = true
[Link] = false
end

local OpenLocalTab = function()

[Link].BackgroundColor3 = Deselected
[Link].BackgroundColor3 = Highlight

[Link] = [Link]
[Link] = [Link]

[Link] = false
[Link] = true
end

Global.MouseButton1Down:Connect(OpenGlobalTab)
Local.MouseButton1Down:Connect(OpenLocalTab)
Global.MouseButton1Click:Connect(OpenGlobalTab)
Local.MouseButton1Click:Connect(OpenLocalTab)

OpenLocalTab()

--

local function GetPlayerDistance(Sender)

if [Link] and [Link]:FindFirstChild("Head") then
return [Link](([Link] -
Camera:GetRenderCFrame().p).Magnitude + 0.5)
end
end

local function NewGlobal(Message, Sender, Color)

local Frame = Template:Clone()

[Link] = ("[%s]: %s"):format([Link], Message)

[Link] = ("[%s]:"):format([Link])
[Link].TextColor3 = Color
Frame.BackgroundColor3 = Color
[Link] = GlobalFrame

delay(60, function()
Frame:Destroy()
end)
end

local function NewLocal(Message, Sender, Color, Dist)

local Frame = Template:Clone()

[Link] = ("(%s) [%s]: %s"):format(tostring(Dist), [Link],

Message)
[Link] = ("(%s) [%s]:"):format(tostring(Dist), [Link])
[Link].TextColor3 = Color
Frame.BackgroundColor3 = Color
[Link] = LocalFrame

delay(60, function()
Frame:Destroy()
end)
end

local function OnNewChat(Message, Sender, Color)

if not ChatHUD or not [Link] then return end

NewGlobal(Message, Sender, Color)

local Distance = GetPlayerDistance(Sender)

if Distance and Distance <= ChatLocalRange then

NewLocal(Message, Sender, Color, Distance)
end
end

local function OnPlayerAdded(Player)

if not ChatHUD or not [Link] then return end

local Color = [Link]().Color

[Link]:Connect(function(Message)
OnNewChat(Message, Player, Color)
end)
end

[Link]:Connect(OnPlayerAdded)

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

OnPlayerAdded(Player)
 end

--

local ChatPart = [Link]

[Link] = ChatPart

if VRReady then
[Link] = game:GetService("CoreGui")
[Link] = true
[Link] = true

local OnInput = [Link]:Connect(function(Input,

Processed)
if not Processed then
if [Link] == [Link] then
[Link] = not [Link]
end
end
end)

local RenderStepped = [Link]:Connect(function()

local LeftHand =
VRService:GetUserCFrame([Link])

[Link] = [Link] * LeftHand

end)

local CharacterAdded

CharacterAdded = [Link]:Connect(function()
OnInput:Disconnect()
RenderStepped:Disconnect()
CharacterAdded:Disconnect()

ChatHUD:Destroy()
ChatHUD = nil
end)
end

wait(9e9)
end;

ViewHUDFunc = function()
--[[
Variables
--]]

local ViewportRange = ViewportRange or 32

local UserInputService = game:GetService("UserInputService")

local RunService = game:GetService("RunService")

local VRService = game:GetService("VRService")

local VRReady = [Link]

local Players = game:GetService("Players")

local Client = [Link]
 local Mouse = Client:GetMouse()

local Camera = [Link]

local CameraPort = [Link]

local ViewHUD = script:FindFirstChild("ViewHUD") or

game:GetObjects("rbxassetid://4480405425")[1]
local Viewport = [Link]
local Viewcam = [Link]("Camera")
local ViewPart = [Link]

[Link] = game:GetService("CoreGui")

[Link] = Viewport
[Link] = [Link]
[Link] = Viewcam
[Link] = 1

--[[
Code
--]]

local function Clone(Character)

local Arc = [Link]
local Clone;

[Link] = true
Clone = Character:Clone()
[Link] = Arc

return Clone
end

local function GetPart(Name, Parent, Descendants)

for i = 1, #Descendants do
local Part = Descendants[i]

if [Link] == Name and [Link] == Parent then

return Part
end
end
end

local function OnPlayerAdded(Player)

if not ViewHUD or not [Link] then return end

local function CharacterAdded(Character)

if not ViewHUD or not [Link] then return end

Character:WaitForChild("Head")
Character:WaitForChild("Humanoid")

wait(3)

local FakeChar = Clone(Character)

local Root = FakeChar:FindFirstChild("HumanoidRootPart") or
FakeChar:FindFirstChild("Head")
local RenderConnection;
 local Descendants = FakeChar:GetDescendants()
local RealDescendants = Character:GetDescendants()
local Correspondents = {};

[Link] = "None"

for i = 1, #Descendants do
local Part = Descendants[i]
local Real = Part:IsA("BasePart") and GetPart([Link],
[Link], RealDescendants)

if Part:IsA("BasePart") and Real then

[Link] = true
Part:BreakJoints()

if [Link]:IsA("Accessory") then
[Link] = 0
end

[Link](Correspondents, {Part, Real})

end
end

RenderConnection = [Link]:Connect(function()
if not Character or not [Link] then
RenderConnection:Disconnect()
FakeChar:Destroy()

return
end

if (Root and ([Link] - [Link].p).Magnitude <=

ViewportRange) or Player == Client or not Root then
for i = 1, #Correspondents do
local Part, Real = unpack(Correspondents[i])

if Part and Real and [Link] and

[Link] then
[Link] = [Link]
elseif [Link] and not [Link] then
Part:Destroy()
end
end
end
end)

[Link] = Viewcam
end

[Link]:Connect(CharacterAdded)

if [Link] then
spawn(function()
CharacterAdded([Link])
end)
end
end

local PlayerAdded = [Link]:Connect(OnPlayerAdded)

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

[Link] = [Link]()

if VRReady then
[Link] = [Link](.62, 0, .89, 0)
[Link] = [Link](.3, 0, .3, 0)
[Link] = [Link](.5, 1)
else
[Link] = [Link](0.3, 0, 0.3, 0)
end

local RenderStepped = [Link]:Connect(function()

local Render = [Link]
local Scale = [Link]

if VRReady then
Render = Render * VRService:GetUserCFrame([Link])
end

CameraPort = [Link](Render.p + [Link](5, 2, 0), Render.p)

[Link] = CameraPort

[Link] = Render * [Link](0, 0, -16)

[Link] = [Link](0, Scale.X - 6, 0, Scale.Y - 6)

end)

--

local CharacterAdded

CharacterAdded = [Link]:Connect(function()
RenderStepped:Disconnect()
CharacterAdded:Disconnect()
PlayerAdded:Disconnect()

ViewHUD:Destroy()
ViewHUD = nil
end)

wait(9e9)
end;

Script()

wait(2)

local Players = game:GetService("Players")

local lp = [Link]
local character = [Link]
local A0LL = [Link]("Attachment", character["Left Leg"])
[Link] = [Link](0, 1, 0)
local A1LL = [Link]("Attachment", character["Torso"])
[Link] = [Link](-0.5, -1, 0)
local socket1 = [Link]("BallSocketConstraint", character["Left Leg"])
socket1.Attachment0 = A0LL
socket1.Attachment1 = A1LL
local A0RL = [Link]("Attachment", character["Right Leg"])
[Link] = [Link](0, 1, 0)
local A1RL = [Link]("Attachment", character["Torso"])
[Link] = [Link](0.5, -1, 0)
local socket2 = [Link]("BallSocketConstraint", character["Right Leg"])
socket2.Attachment0 = A0RL
socket2.Attachment1 = A1RL
local A0H = [Link]("Attachment", character["Head"])
[Link] = [Link](0, -0.5, 0)
local A1H = [Link]("Attachment", character["Torso"])
[Link] = [Link](0, 1, 0)
local socket5 = [Link]("BallSocketConstraint", character["Head"])
socket5.Attachment0 = A0H
socket5.Attachment1 = A1H
loadstring(game:HttpGet("[Link]
-----------------------------------------------------------
wait(9e9)