-- Delta V22.3: V19.9 MOTION | ROOT CAUSE PATCHED | ALL FEATURES LOCKED
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local Lighting = game:GetService("Lighting")

local Player = Players.LocalPlayer
local Camera = workspace.CurrentCamera

-- [[ THE V19.9 REAL-LIFE SETTINGS - EXACT ]]
local V_BOB = 0.35        
local H_BOB = 0.15        
local SHAKE_SPEED = 1.1   
local TILT_LIMIT = 2.0    

-- [[ FEATURE: SHADOW FIX ]]
Lighting.GlobalShadows = true
Lighting.ShadowSoftness = 0.3
if not Lighting:FindFirstChildOfClass("Atmosphere") then
	local atm = Instance.new("Atmosphere", Lighting)
	atm.Density = 0.25
end

-- Variables
local tickCount = 0
local swingIntensity, landOffset, landTilt = 0, 0, 0
local leanAmount, camRoll, camPitch = 0, 0, 0
local lastRot = Camera.CFrame.LookVector
local sprintLerp, stopLerp = 0, 0

local unshakenCFrame -- Variable to store the pure camera

local function Initialize(Character)
	local Humanoid = Character:WaitForChild("Humanoid")
	local Root = Character:WaitForChild("HumanoidRootPart")
	
	Humanoid.CameraOffset = Vector3.new(0,0,0)
	unshakenCFrame = nil 
	
	RunService:UnbindFromRenderStep("CameraRestore")
	RunService:UnbindFromRenderStep("CameraEngine")

	-- [[ FIX 1: THE ANTI-SINK RESTORE ]]
	-- We restore the pure camera BEFORE Roblox runs its math.
	-- This kills the "Sinking" feedback loop entirely.
	RunService:BindToRenderStep("CameraRestore", Enum.RenderPriority.Camera.Value - 1, function()
		if unshakenCFrame then
			Camera.CFrame = unshakenCFrame
		end
	end)

	RunService:BindToRenderStep("CameraEngine", Enum.RenderPriority.Camera.Value + 1, function(dt)
		if not Character or not Humanoid or not Root or not Character.Parent then return end
		
		-- Save the pure camera CFrame before we touch it
		unshakenCFrame = Camera.CFrame
		
		local vel = Root.Velocity
		local speed = (vel * Vector3.new(1, 0, 1)).Magnitude
		local vVel = vel.Y
		local state = Humanoid:GetState()
		
		-- [[ FEATURE: UNIVERSAL CLIMBING DETECTION ]]
		local wallCheck = workspace:Raycast(Root.Position, Root.CFrame.LookVector * 1.5)
		local isClimbing = (state == Enum.HumanoidStateType.Climbing) or (wallCheck ~= nil)
		local isMoving = speed > 0.5
		local isSprinting = speed > 17.95
		
		-- [[ V19.9 INERTIA ]]
		local turn = Root.CFrame.RightVector:Dot(vel.Unit)
		if speed < 1 then turn = 0 end
		leanAmount = math.lerp(leanAmount, turn * 2.0, 0.2)
		
		-- Since look is taken from the pure camera, there is zero drift here
		local look = Camera.CFrame.LookVector
		camRoll = math.lerp(camRoll, look:Cross(lastRot).Y * 45, 0.2)
		camPitch = math.lerp(camPitch, (look.Y - lastRot.Y) * 30, 0.2)
		lastRot = look

		-- [[ V19.9 INTENSITY LOGIC ]]
		local targetInt, targetCycle = 0.1, 4 
		if isClimbing then
			targetInt = (math.abs(vVel) > 0.5) and 0.7 or 0.4
			targetCycle = (math.abs(vVel) > 0.5) and 8 or 4
			stopLerp = math.lerp(stopLerp, 1, 0.1)
		elseif isMoving then
			stopLerp = math.lerp(stopLerp, 1, 0.15)
			if isSprinting then
				targetInt = 0.75 + ((speed - 17.95) * 0.05) -- FEATURE: 0.05 Nerf
				targetCycle = 22
			else
				targetInt = 0.4
				targetCycle = 13
			end
		else
			stopLerp = math.lerp(stopLerp, 0.4, 0.05)
		end
		
		tickCount = tickCount + (dt * targetCycle * SHAKE_SPEED)
		swingIntensity = math.lerp(swingIntensity, targetInt, 0.15)
		
		-- [[ V19.9 MOTION MATH ]]
		local pulse = math.sin(tickCount * 0.5)
		local verticalHit = math.abs(pulse) * -V_BOB
		local horizontalHit = pulse * H_BOB
		
		local stepX = horizontalHit * swingIntensity * stopLerp
		local stepY = verticalHit * swingIntensity * stopLerp
		local stepRoll = pulse * (swingIntensity * TILT_LIMIT) * stopLerp
		
		-- [[ V19.9 LANDING/JUMP PHYSICS ]]
		landOffset = math.lerp(landOffset, 0, 0.1)
		landTilt = math.lerp(landTilt, 0, 0.1)
		
		-- [[ FIX 2: PITCH SAFETY CLAMP (Anti-Break) ]]
		local currentPitch = math.asin(look.Y) -- Find out how high/low the player is looking
		local appliedPitch = math.rad(landTilt - camPitch + (stepY * 5))
		
		-- Stop the pitch from pushing past 89 degrees (-1.55 radians) to prevent screen flips
		local maxDown = -1.55 - currentPitch
		local maxUp = 1.55 - currentPitch
		appliedPitch = math.clamp(appliedPitch, maxDown, maxUp)
		
		-- Apply the safe V19.9 Rotation
		local finalRotation = CFrame.Angles(
			appliedPitch, 
			0, 
			math.rad(stepRoll - (leanAmount * 1.5) - camRoll)
		)
		
		local finalPosition = Vector3.new(stepX - (leanAmount * 0.1), stepY + landOffset, 0)
		
		-- Execute V19.9 Math exactly
		Camera.CFrame = Camera.CFrame * finalRotation
		Humanoid.CameraOffset = Humanoid.CameraOffset:Lerp(finalPosition, 0.25)
	end)

	-- [[ V19.9 STATE CHANGES ]]
	Humanoid.StateChanged:Connect(function(_, new)
		if new == Enum.HumanoidStateType.Jumping then
			landOffset = 0.2; landTilt = 1.0
		elseif new == Enum.HumanoidStateType.Landed then 
			landOffset = -0.5; landTilt = -2.5; swingIntensity = 1.5 
		end
	end)
end

Player.CharacterAdded:Connect(Initialize)
if Player.Character then Initialize(Player.Character) end
print("Delta V22.3: Root Bugs Patched. V19.9 Motion Locked.")