local ContextActionService = game:GetService("ContextActionService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")
local VRService = game:GetService("VRService")
local StarterGui = game:GetService("StarterGui")
local HapticService = game:GetService("HapticService")

local PCDEBUG = false

if VRService.VREnabled or PCDEBUG then
	wait(0.5)
else
	script:Destroy()
	return
end

pcall(function()
	StarterGui:SetCore("VRLaserPointerMode", 0)
	StarterGui:SetCore("VREnableControllerModels", false)
end)

VRService:RecenterUserHeadCFrame()

local ScaleMult = 3

local MaxScaleInts = 10
local ScaleInt = 1

local Camera = workspace.CurrentCamera
Camera.CameraType = Enum.CameraType.Scriptable
Camera.CameraSubject = nil
Camera.CFrame = CFrame.new(0, 35, 0)
Camera.HeadScale = ScaleInt*ScaleMult

local Character, CameraPart = require(ReplicatedStorage.Storage.Modules:WaitForChild("CharacterRequester"))(Camera.HeadScale)
local Head = Character:WaitForChild("Head")
local RightHand = Character:WaitForChild("Right Arm")
local LeftHand = Character:WaitForChild("Left Arm")

local NoColl = require(ReplicatedStorage.Storage.Modules:WaitForChild("NoCCVR"))
NoColl.RemoveAllCollisions(Character)

local ThumbStick1 = Vector3.new()
local Velocity = Vector3.new()
local TSY = 0

local CameraPosition = Camera.CFrame

local SpeedDivider = 10
local LastUserPosition = VRService:GetUserCFrame(Enum.UserCFrame.Head).Position

local Turn = CFrame.fromEulerAnglesXYZ(0, 0, 0)
local IsTurning = true

local RightHaptic = 0
local LeftHaptic = 0


function MultiplyCFrame(CF, Mult)
	local NewPosition = CF.Position * Mult
	local Rotation = CF - CF.Position
	
	return Rotation + NewPosition
end

function GetHeadlockedCFrame()
	local UserCFrame = VRService:GetUserCFrame(Enum.UserCFrame.Head)
	UserCFrame = MultiplyCFrame(UserCFrame, Camera.HeadScale)
	return CFrame.fromEulerAnglesXYZ(UserCFrame:ToEulerAnglesXYZ()) * UserCFrame:Inverse()
end

function GetUserCFrames()
	local HeadCFrame = VRService:GetUserCFrame(Enum.UserCFrame.Head)
	local RightCFrame = VRService:GetUserCFrame(Enum.UserCFrame.RightHand)
	local LeftCFrame = VRService:GetUserCFrame(Enum.UserCFrame.LeftHand)	
	
	return HeadCFrame, RightCFrame, LeftCFrame
end

function CalculateCameraCFrame(HeadCFrame)
	local CameraRotation = Turn * GetHeadlockedCFrame()
	local CameraPos = CameraPosition-- * CFrame.new(0, HeadCFrame.Y*Camera.HeadScale, 0)
	
	local CameraCFrame = CameraPos * CameraRotation
	
	return CameraCFrame, CameraRotation
end

function CalculateHandCFrames(HeadCFrame, RightCFrame, LeftCFrame, Root)
	local Head = Root * MultiplyCFrame(HeadCFrame, Camera.HeadScale)
	local Right = Root * MultiplyCFrame(RightCFrame, Camera.HeadScale)
	local Left = Root * MultiplyCFrame(LeftCFrame, Camera.HeadScale)
	
	return Head, Right, Left
end

function Lerp(A, B, C)
	return A + (B - A) * C
end

function HideHats()
	for Index, Inst in pairs(Character:GetDescendants()) do
		if Inst:IsA("Accessory") then
			local Handle = Inst:FindFirstChildOfClass("Part")
			Handle.LocalTransparencyModifier = 1
		end
	end
end

RunService.RenderStepped:Connect(function(Delta)
	local HeadCFrame, RightCFrame, LeftCFrame = GetUserCFrames()	

	local MoveVector = Turn * CFrame.new(HeadCFrame.Position - LastUserPosition).Position
	CameraPosition = CameraPosition + MoveVector * Camera.HeadScale
	CameraPosition = CFrame.new(CameraPosition.X, math.clamp(CameraPosition.Y, -100, 500), CameraPosition.Z) * (CameraPosition-CameraPosition.Position)
	
	local CameraCFrame, CameraRotation = CalculateCameraCFrame(HeadCFrame)
	local CFrames = {CalculateHandCFrames(HeadCFrame, RightCFrame, LeftCFrame, CameraCFrame)}
	
	local HandSize = RightHand.Size
	local HandOffset = CFrame.fromEulerAnglesXYZ(math.rad(90), 0, 0) * CFrame.new(0, HandSize.Y / 3, 0)
	
	
	Head.AlignPosition.Attachment1.WorldCFrame = CFrames[1]
	RightHand.AlignPosition.Attachment1.WorldCFrame = CFrames[2] * HandOffset
	LeftHand.AlignPosition.Attachment1.WorldCFrame = CFrames[3] * HandOffset
	
	if (RightHand.Position-(CFrames[2] * HandOffset).p).Magnitude > 3.5*Camera.HeadScale then
		RightHand.CFrame = CFrames[2] * HandOffset
	end
	
	if (LeftHand.Position-(CFrames[3] * HandOffset).p).Magnitude > 3.5*Camera.HeadScale then
		LeftHand.CFrame = CFrames[3] * HandOffset
	end
	
	Camera.CFrame = CFrame.new(CameraPart.Position) * CameraRotation	
	
	
	if ThumbStick1.Magnitude > 0.15 then
		local CameraLook = Camera:GetRenderCFrame().LookVector
		local Angle = math.atan2(-CameraLook.X, -CameraLook.Z)
		local C3Angle = CFrame.fromEulerAnglesXYZ(0, Angle, 0)

		local NewThumbStick = C3Angle*CFrame.new(ThumbStick1)
		local ThumbStickVelocity = (NewThumbStick.Position+Vector3.new(0,TSY,0))/SpeedDivider
		Velocity = ThumbStickVelocity
	else
		Velocity = Vector3.new(0,TSY/SpeedDivider,0)
	end
	
	HapticService:SetMotor(Enum.UserInputType.Gamepad1, Enum.VibrationMotor.RightHand, RightHaptic)
	HapticService:SetMotor(Enum.UserInputType.Gamepad1, Enum.VibrationMotor.LeftHand, LeftHaptic)
	
	RightHaptic = Lerp(RightHaptic, 0, 0.2 * (Delta* 60))
	LeftHaptic = Lerp(LeftHaptic, 0, 0.2 * (Delta* 60))
	
	CameraPosition = CameraPosition + ((Velocity * (Delta * 60))*Camera.HeadScale)
	
	Camera.CameraType = Enum.CameraType.Scriptable
	Camera.CameraSubject = nil

	LastUserPosition = HeadCFrame.Position
	
	HideHats()
end)

ContextActionService:BindAction("ThumbStick1", function(Name, State, Input)
	ThumbStick1 = Vector3.new(Input.Position.X, 0, -Input.Position.Y)
end, false, Enum.KeyCode.Thumbstick1)

ContextActionService:BindAction("ThumbStick2", function(Name, State, Input)
	if not IsTurning and math.abs(Input.Position.X) > 0.7 then
		IsTurning = true

		local TurnDirection = 45 * -math.sign(Input.Position.X)
		Turn = Turn * CFrame.fromEulerAnglesXYZ(0, math.rad(TurnDirection), 0)
	elseif IsTurning and math.abs(Input.Position.X) < 0.7 then
		IsTurning = false		
	end

	if math.abs(Input.Position.Y) > 0.35 then
		TSY = Input.Position.Y
	else
		TSY = 0
	end
end, false, Enum.KeyCode.Thumbstick2)

ContextActionService:BindAction("A", function(Name, State, Input)
	if State == Enum.UserInputState.Begin then
		ScaleInt = math.clamp(ScaleInt - 1, 1, MaxScaleInts)
		Camera.HeadScale = ScaleInt * ScaleMult
		
		ReplicatedStorage.Remotes.Scale:FireServer(Camera.HeadScale)
	end
end, false, Enum.KeyCode.ButtonA)

ContextActionService:BindAction("B", function(Name, State, Input)
	if State == Enum.UserInputState.Begin then
		ScaleInt = math.clamp(ScaleInt + 1, 1, MaxScaleInts)
		Camera.HeadScale = ScaleInt * ScaleMult
		
		ReplicatedStorage.Remotes.Scale:FireServer(Camera.HeadScale)
	end
end, false, Enum.KeyCode.ButtonB)


RightHand.Touched:Connect(function(Hit)
	if not (Hit:IsDescendantOf(Character)) and Hit:CanCollideWith(RightHand) then
		RightHaptic = 0.75
	end
end)

LeftHand.Touched:Connect(function(Hit)
	if not (Hit:IsDescendantOf(Character)) and Hit:CanCollideWith(LeftHand) then
		LeftHaptic = 0.75
	end
end)