local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local TweenService = game:GetService("TweenService")
local CollectionService = game:GetService("CollectionService")

local player = Players.LocalPlayer
if not player then return end
if player:GetAttribute("ZenithGuardActive") then return end
player:SetAttribute("ZenithGuardActive", true)

local playerGui = player:WaitForChild("PlayerGui")

local CFG = {
	Speed = 400,
	Angular = 60,
	SoftSustain = 0.3,
	Rewind = 0.25,
	ShieldRadius = 90,
	PartLin = 150,
	PartAng = 120,
	FreezeTime = 0.35,
	LinkRadius = 70,
	SweepEvery = 2,
	ParkDistance = 100,
	HopMin = 40,
	HopCount = 6,
	Huge = 1e7,
	SpawnGrace = 0.35,
}

local function getRoot(char) return char and char:FindFirstChild("HumanoidRootPart") end
local function getHum(char) return char and char:FindFirstChildOfClass("Humanoid") end
local function alive(char)
	local h = getHum(char)
	return h ~= nil and h.Health > 0
end

local selfUntil = 0

local function banner()
	local gui = Instance.new("ScreenGui")
	gui.Name = "ZenithGuardNotice"
	gui.ResetOnSpawn = false
	gui.IgnoreGuiInset = true
	gui.DisplayOrder = 999
	gui.Parent = playerGui

	local label = Instance.new("TextLabel")
	label.AnchorPoint = Vector2.new(0.5, 0)
	label.Position = UDim2.new(0.5, 0, 0, 14)
	label.Size = UDim2.fromOffset(240, 30)
	label.BackgroundTransparency = 1
	label.Text = "ANTICHEAT ON"
	label.TextColor3 = Color3.fromRGB(238, 232, 222)
	label.TextStrokeColor3 = Color3.fromRGB(23, 21, 20)
	label.TextStrokeTransparency = 0.35
	label.TextSize = 20
	label.Font = Enum.Font.GothamBold
	label.TextTransparency = 1
	label.TextStrokeTransparency = 1
	label.Parent = gui

	task.spawn(function()
		local fade = TweenInfo.new(0.35, Enum.EasingStyle.Quad, Enum.EasingDirection.Out)
		TweenService:Create(label, fade, { TextTransparency = 0, TextStrokeTransparency = 0.35 }):Play()
		task.wait(2.6)
		TweenService:Create(label, fade, { TextTransparency = 1, TextStrokeTransparency = 1 }):Play()
		task.wait(0.5)
		gui:Destroy()
	end)
end

local tracked = {}

local function finite(v)
	local m = v.Magnitude
	return m == m and m < CFG.Huge
end

local function untrack(char)
	local e = tracked[char]
	if not e then return end
	for _, c in e.conns do c:Disconnect() end
	tracked[char] = nil
end

local function track(plr, char)
	if plr == player or tracked[char] then return end
	local e = {
		plr = plr, parts = {}, conns = {}, slot = plr.UserId % 7,
		parkUntil = 0, parked = false, parkPos = nil, realCF = nil,
		hotSince = nil, hotLast = 0, hops = {}, hopPos = nil, hopT = 0,
	}
	tracked[char] = e
	local function add(d)
		if d:IsA("BasePart") then e.parts[d] = true end
	end
	for _, d in char:GetDescendants() do add(d) end
	e.conns[1] = char.DescendantAdded:Connect(add)
	e.conns[2] = char.DescendantRemoving:Connect(function(d) e.parts[d] = nil end)
	e.conns[3] = char.AncestryChanged:Connect(function(_, parent)
		if not parent then untrack(char) end
	end)
end

local function watch(plr)
	if plr == player then return end
	plr.CharacterAdded:Connect(function(char) track(plr, char) end)
	if plr.Character then track(plr, plr.Character) end
end

for _, plr in Players:GetPlayers() do watch(plr) end
Players.PlayerAdded:Connect(watch)
Players.PlayerRemoving:Connect(function(plr)
	if plr.Character then untrack(plr.Character) end
end)

local function raise(e, secs, now)
	e.parkUntil = math.max(e.parkUntil, now + secs)
end

local function detect(e, root, now)
	local pos = root.Position
	local pp = e.parkPos
	if pp and (pos - pp).Magnitude < 0.05 then return end
	local lv, av = root.AssemblyLinearVelocity, root.AssemblyAngularVelocity
	local lm, am = lv.Magnitude, av.Magnitude
	if not (lm < CFG.Huge and am < CFG.Huge and pos.Magnitude < CFG.Huge) then
		e.hopPos = nil
		raise(e, 8, now)
		return
	end
	e.realCF = root.CFrame

	if am > CFG.Angular * 1.5 or lm > CFG.Speed * 2 then
		e.hotSince = e.hotSince or now
		e.hotLast = now
		if now - e.hotSince >= 0.25 then raise(e, 6, now) end
	elseif e.hotSince and now - e.hotLast > 0.2 then
		e.hotSince = nil
	end

	local prev = e.hopPos
	if prev then
		local d = (pos - prev).Magnitude
		if d >= CFG.HopMin and d > lm * math.max(now - e.hopT, 0.016) * 1.6 + 12 then
			local list = e.hops
			list[#list + 1] = now
			while #list > 0 and now - list[1] > 1 do table.remove(list, 1) end
			if #list >= CFG.HopCount then
				table.clear(list)
				raise(e, 8, now)
			end
		end
	end
	e.hopPos, e.hopT = pos, now
end

local function parkChar(e, char, root, myRoot)
	local spot = myRoot.Position + Vector3.new(e.slot * 7 - 21, CFG.ParkDistance, 0)
	e.parked, e.parkPos = true, spot
	local ok = pcall(function() char:PivotTo(CFrame.new(spot)) end)
	local broken = not ok or not finite(root.Position)
	for part in e.parts do
		if part.Parent then
			if broken then part.CFrame = CFrame.new(spot) end
			part.AssemblyLinearVelocity = Vector3.zero
			part.AssemblyAngularVelocity = Vector3.zero
		end
	end
end

local function unparkChar(e, char)
	e.parked, e.parkPos, e.hopPos = false, nil, nil
	local cf = e.realCF
	if cf and finite(cf.Position) then pcall(function() char:PivotTo(cf) end) end
end

local overlap = OverlapParams.new()
overlap.FilterType = Enum.RaycastFilterType.Exclude
local looseOff = {}
local looseP, looseT = setmetatable({}, { __mode = "k" }), setmetatable({}, { __mode = "k" })
local seatCache = setmetatable({}, { __mode = "k" })
local shieldN = 0

local function topModel(part)
	local top = part
	while top.Parent and top.Parent ~= workspace do top = top.Parent end
	return top
end

local function hasSeat(model)
	local c = seatCache[model]
	if c == nil then
		c = false
		for _, d in model:GetDescendants() do
			if d:IsA("Seat") or d:IsA("VehicleSeat") then c = true break end
		end
		seatCache[model] = c
	end
	return c
end

local function shieldInfo(part)
	if CollectionService:HasTag(part, "ZG_Keep") then return false end
	local m = part:FindFirstAncestorOfClass("Model")
	if m and m:FindFirstChildOfClass("Humanoid") then return false end
	local top = topModel(part)
	return true, top:IsA("Model") and hasSeat(top)
end

local function fast(part, k)
	return not (part.AssemblyLinearVelocity.Magnitude <= CFG.PartLin * k)
		or not (part.AssemblyAngularVelocity.Magnitude <= CFG.PartAng * k)
end

local function hopped(part, now)
	local pos = part.Position
	local prev, pt = looseP[part], looseT[part]
	if not prev then
		looseP[part], looseT[part] = pos, now
		return false
	end
	local dt = now - pt
	if dt < 0.03 then return false end
	looseP[part], looseT[part] = pos, now
	if dt > 0.5 then return false end
	return not ((pos - prev).Magnitude / dt <= CFG.Speed)
end

RunService.Stepped:Connect(function()
	local now0 = os.clock()
	local myRoot0 = getRoot(player.Character)
	for char, e in tracked do
		if char.Parent then
			local root = getRoot(char)
			if root then
				detect(e, root, now0)
				if myRoot0 and e.parkUntil > now0 then
					local hum = getHum(char)
					if hum and hum.SeatPart and finite(root.Position) then
						if e.parked then unparkChar(e, char) end
					else
						parkChar(e, char, root, myRoot0)
					end
				elseif e.parked then
					unparkChar(e, char)
				end
			else
				e.hopPos = nil
			end
			for part in e.parts do
				if part.Parent and part.CanCollide then part.CanCollide = false end
			end
		end
	end

	shieldN += 1
	if shieldN % 2 ~= 0 then return end
	local now = os.clock()
	for part, due in looseOff do
		if not part.Parent then
			looseOff[part] = nil
		elseif now >= due then
			part.CanCollide = true
			looseOff[part] = nil
		end
	end
	local myChar = player.Character
	local myRoot = getRoot(myChar)
	if not myRoot then return end
	overlap.FilterDescendantsInstances = { myChar }
	local myHum = getHum(myChar)
	local mySeat = myHum and myHum.SeatPart
	local myAssembly = mySeat and mySeat.AssemblyRootPart
	for _, p in workspace:GetPartBoundsInRadius(myRoot.Position, CFG.ShieldRadius, overlap) do
		if looseOff[p] then
			if fast(p, 0.5) then looseOff[p] = now + 3 end
		elseif not p.Anchored and p.CanCollide and (fast(p, 1) or hopped(p, now)) then
			local ok, vehicle = shieldInfo(p)
			if ok and (not vehicle or fast(p, 2.7)) and not (myAssembly and p.AssemblyRootPart == myAssembly) then
				looseOff[p] = now + 3
				p.CanCollide = false
			end
		end
	end
end)

task.spawn(function()
	while true do
		task.wait(CFG.SweepEvery)
		for char in tracked do
			for _, d in char:GetDescendants() do
				if d:IsA("BasePart") and d.CanCollide then d.CanCollide = false end
			end
		end
	end
end)

-- own movement: fling, void
local hist, histT = {}, 0
local softT, spawnUntil = 0, 0
local frozenRoot, freezeUntil = nil, 0
local lastRoot, lastGround = nil, nil
local lastHum = nil

local function jumpVel(hum)
	local v = hum.JumpPower
	if hum.UseJumpPower == false then
		v = math.sqrt(2 * workspace.Gravity * (hum.JumpHeight or 7.2))
	end
	return tonumber(v) or 50
end

local function blockRagdoll(hum)
	pcall(function()
		hum:SetStateEnabled(Enum.HumanoidStateType.FallingDown, false)
		hum:SetStateEnabled(Enum.HumanoidStateType.Ragdoll, false)
	end)
end

local VEHICLE_WORDS = { "vehicle", "car", "tank", "truck", "jeep", "heli", "boat", "bike", "apc", "buggy", "train", "bus", "ship", "plane", "lift", "elevator" }
local lastUnsit = 0

local function isVehicleSeat(seat)
	if seat:IsA("VehicleSeat") then return true end
	local m = seat
	while m and m ~= workspace do
		if CollectionService:HasTag(m, "Vehicle") then return true end
		local n = string.lower(m.Name)
		for _, w in VEHICLE_WORDS do
			if string.find(n, w, 1, true) then return true end
		end
		m = m.Parent
	end
	return false
end

local function forcedSeat(seat)
	local model = seat:FindFirstAncestorOfClass("Model")
	while model do
		local plr = Players:GetPlayerFromCharacter(model)
		if plr then return plr ~= player end
		local parent = model.Parent
		model = parent and parent:FindFirstAncestorOfClass("Model") or nil
	end
	return not isVehicleSeat(seat) and seat.AssemblyLinearVelocity.Magnitude > 90
end

local under = { ref = nil, t = 0, cf = nil, ok = 0, void = 0, vy = nil }
local underRp = RaycastParams.new()
underRp.FilterType = Enum.RaycastFilterType.Exclude
underRp.RespectCanCollide = true

local function resetUnder()
	under.ref, under.cf, under.ok, under.void, under.vy = nil, nil, 0, 0, nil
end

local function underStep(char, root, hum, vel, now, dt)
	local pos = root.Position
	local vy = vel.Y
	local prevVy = under.vy
	under.vy = vy
	if hum.FloorMaterial ~= Enum.Material.Air then
		if vel.Magnitude < 450 and vy > -20 then
			under.ref, under.t = pos, now
			under.ok += 1
			if under.ok >= 3 then under.cf = root.CFrame end
		else
			under.ok = 0
		end
		under.void = 0
		return
	end
	under.ok = 0
	local ref = under.ref
	if not ref then return end
	local t = now - under.t
	local drop = ref.Y - pos.Y
	local g = workspace.Gravity
	local fastDrop = drop > 0.5 * g * t * t + 14 + hum.HipHeight
	local falling = false
	if not fastDrop and drop > 14 and vy <= -30 then
		local acc = prevVy and (vy - prevVy) / math.max(dt, 0.004) or 0
		falling = acc <= -0.5 * g or vy <= -150
	end
	if not (fastDrop or falling) then
		under.void = 0
		return
	end
	under.void += dt
	if under.void < 0.12 then return end
	underRp.FilterDescendantsInstances = { char }
	if workspace:Raycast(pos, Vector3.new(0, -3000, 0), underRp) then
		under.ref, under.void = nil, 0
		return
	end
	if (not fastDrop or workspace.StreamingEnabled) and not workspace:Raycast(pos, Vector3.new(0, 3000, 0), underRp) then
		return
	end
	local target = under.cf or lastGround
	if not target then return end
	under.ref, under.void = nil, 0
	selfUntil = now + 0.6
	root.AssemblyLinearVelocity = Vector3.zero
	root.AssemblyAngularVelocity = Vector3.zero
	char:PivotTo(target + Vector3.new(0, 2, 0))
	hist = {}
end

local function freeze(root)
	if root.Anchored then return end
	root.Anchored = true
	frozenRoot = root
	freezeUntil = os.clock() + CFG.FreezeTime
end

RunService.Heartbeat:Connect(function(dt)
	local now = os.clock()
	if frozenRoot and (now >= freezeUntil or not frozenRoot.Parent) then
		if frozenRoot.Parent then
			frozenRoot.AssemblyLinearVelocity = Vector3.zero
			frozenRoot.AssemblyAngularVelocity = Vector3.zero
			frozenRoot.Anchored = false
		end
		frozenRoot = nil
	end

	local char = player.Character
	local root, hum = getRoot(char), getHum(char)
	if not (root and hum and hum.Health > 0) then
		hist, lastGround, lastRoot = {}, nil, nil
		resetUnder()
		return
	end
	if frozenRoot then return end
	if lastRoot ~= root then
		lastRoot = root
		hist, softT = {}, 0
		spawnUntil = now + CFG.SpawnGrace
		resetUnder()
	end
	if lastHum ~= hum then
		lastHum = hum
		blockRagdoll(hum)
	end
	local st = hum:GetState()
	if st == Enum.HumanoidStateType.FallingDown or st == Enum.HumanoidStateType.Ragdoll then
		hum:ChangeState(Enum.HumanoidStateType.GettingUp)
	end

	local seatPart = hum.SeatPart
	if seatPart and now - lastUnsit > 0.4 and forcedSeat(seatPart) then
		lastUnsit = now
		hum.Sit = false
		hum:ChangeState(Enum.HumanoidStateType.Jumping)
		local weld = seatPart:FindFirstChild("SeatWeld")
		if weld then pcall(function() weld:Destroy() end) end
		seatPart = nil
	end
	local seated = seatPart ~= nil
	local vel = root.AssemblyLinearVelocity
	local angV = root.AssemblyAngularVelocity
	local broken = not (finite(vel) and finite(angV) and finite(root.Position))
	local horiz = Vector3.new(vel.X, 0, vel.Z).Magnitude
	local up = math.max(vel.Y, 0)
	local down = math.max(-vel.Y, 0)
	local jv = jumpVel(hum)

	local limit = math.max(CFG.Speed, jv * 3)
	local soft = math.max(limit * 0.45, hum.WalkSpeed * 3.5, jv * 2)
	if horiz > soft and not seated and now > selfUntil then
		softT += dt
	else
		softT = 0
	end

	local angBad = angV.Magnitude > CFG.Angular
	local hard = math.max(horiz, up) > limit or down > math.max(limit, 470)
	local bad = not seated and (broken or (now > spawnUntil and (hard or angBad or softT > CFG.SoftSustain)))

	if bad then
		local target
		for i = #hist, 1, -1 do
			if hist[i].t <= now - CFG.Rewind then target = hist[i].cf break end
		end
		target = target or (hist[1] and hist[1].cf) or lastGround or under.cf
		root.AssemblyLinearVelocity = Vector3.zero
		root.AssemblyAngularVelocity = Vector3.zero
		if target then
			selfUntil = now + 0.4
			root.CFrame = target
		end
		hist, softT = {}, 0
		freeze(root)
	elseif not seated then
		histT += dt
		if histT >= 0.08 then
			histT = 0
			local calm = horiz < soft and up < soft and down < limit * 0.5 and angV.Magnitude < CFG.Angular * 0.5
			if calm then
				hist[#hist + 1] = { t = now, cf = root.CFrame }
				while #hist > 0 and now - hist[1].t > 3 do table.remove(hist, 1) end
			end
		end
		if horiz < soft and up < soft and down < limit * 0.5 and angV.Magnitude < CFG.Angular * 0.5
			and hum.FloorMaterial ~= Enum.Material.Air then
			lastGround = root.CFrame + Vector3.new(0, 2, 0)
		end
	else
		hist = {}
	end

	if lastGround and root.Position.Y < workspace.FallenPartsDestroyHeight + 80 then
		selfUntil = now + 0.5
		root.AssemblyLinearVelocity = Vector3.zero
		root.AssemblyAngularVelocity = Vector3.zero
		char:PivotTo(lastGround)
	end

	if not seated and now > selfUntil and now > spawnUntil and not broken then
		underStep(char, root, hum, vel, now, dt)
	else
		under.ref, under.ok, under.void, under.vy = nil, 0, 0, nil
	end
end)

-- foreign links, riders, cages, loud sounds
local FORCE = {
	AlignPosition = true, AlignOrientation = true, LinearVelocity = true, VectorForce = true,
	AngularVelocity = true, Torque = true, BallSocketConstraint = true, RopeConstraint = true,
	SpringConstraint = true, RodConstraint = true, HingeConstraint = true,
}
local SINGLE = { LinearVelocity = true, VectorForce = true, AngularVelocity = true, Torque = true }
local JOINT = { Weld = true, WeldConstraint = true, Motor6D = true, ManualWeld = true, Snap = true }

local function ownerOf(inst)
	local m = inst
	while m and m ~= workspace do
		if m:IsA("Model") then
			local plr = Players:GetPlayerFromCharacter(m)
			if plr then return plr end
		end
		m = m.Parent
	end
	return nil
end
local function isMine(p, myChar) return p ~= nil and myChar ~= nil and p:IsDescendantOf(myChar) end
local function isForeign(p)
	if not p then return false end
	local o = ownerOf(p)
	return o ~= nil and o ~= player
end

local function linkBad(d, myChar)
	local cn = d.ClassName
	if FORCE[cn] then
		local a0, a1 = d.Attachment0, d.Attachment1
		local p0 = a0 and a0.Parent
		local p1 = a1 and a1.Parent
		if SINGLE[cn] then
			local o = ownerOf(d)
			return isMine(p0, myChar) and o ~= nil and o ~= player
		end
		return (isMine(p0, myChar) and isForeign(p1)) or (isMine(p1, myChar) and isForeign(p0))
	elseif JOINT[cn] then
		local p0, p1 = d.Part0, d.Part1
		return (isMine(p0, myChar) and isForeign(p1)) or (isMine(p1, myChar) and isForeign(p0))
	end
	return false
end

local function sweep(model, myChar)
	for _, d in model:GetDescendants() do
		local cn = d.ClassName
		if (FORCE[cn] or JOINT[cn]) and linkBad(d, myChar) then
			pcall(function() d:Destroy() end)
		end
	end
end

local released = {}
local function release(part, secs)
	if part.Parent and part.CanCollide then
		part.CanCollide = false
		released[part] = os.clock() + secs
	end
end

local fresh = {}
local bootAt = os.clock()
workspace.DescendantAdded:Connect(function(d)
	if workspace.StreamingEnabled or os.clock() - bootAt < 25 then return end
	if d:IsA("BasePart") and d.CanCollide and d.ClassName ~= "Terrain" then
		fresh[#fresh + 1] = { p = d, t = os.clock() }
		if #fresh > 300 then table.remove(fresh, 1) end
	end
end)

local rideT, posHist = {}, {}
local sounded = setmetatable({}, { __mode = "k" })
local a1, a2, a3 = 0, 0, 0

RunService.Heartbeat:Connect(function(dt)
	local myChar = player.Character
	local myRoot = getRoot(myChar)
	local now = os.clock()
	for part, due in released do
		if not myRoot or now >= due or not part.Parent then
			if part.Parent then part.CanCollide = true end
			released[part] = nil
		end
	end
	if not (myRoot and alive(myChar)) then return end

	a1 += dt
	if a1 >= 0.5 then
		a1 = 0
		sweep(myChar, myChar)
		for _, plr in Players:GetPlayers() do
			local char = plr ~= player and plr.Character
			local r = char and getRoot(char)
			if r and (r.Position - myRoot.Position).Magnitude < CFG.LinkRadius then sweep(char, myChar) end
		end

		if not workspace.StreamingEnabled and #fresh > 0 then
			posHist[#posHist + 1] = { t = now, p = myRoot.Position }
			while #posHist > 0 and now - posHist[1].t > 1.6 do table.remove(posHist, 1) end
			local still = true
			for _, h in posHist do
				if (h.p - myRoot.Position).Magnitude > 3 then still = false end
			end
			local near = {}
			for i = #fresh, 1, -1 do
				local f = fresh[i]
				if not f.p.Parent or now - f.t > 4 then
					table.remove(fresh, i)
				elseif ownerOf(f.p) == nil then
					local pos = f.p.Position
					if (pos - myRoot.Position).Magnitude < 14 and pos.Y > myRoot.Position.Y - 1.5 then
						near[#near + 1] = f.p
					end
				end
			end
			if still and #posHist >= 3 and #near >= 4 then
				for _, p in near do release(p, 12) end
			end
		end
	end

	a2 += dt
	if a2 >= 0.25 then
		local step = a2
		a2 = 0
		local seen = {}
		for _, plr in Players:GetPlayers() do
			if plr ~= player then
				local r = getRoot(plr.Character)
				if r then
					local d = r.Position - myRoot.Position
					local flat = Vector3.new(d.X, 0, d.Z).Magnitude
					if flat < 3.6 and d.Y > 1.2 and d.Y < 7 then
						seen[plr] = true
						rideT[plr] = (rideT[plr] or 0) + step
						if rideT[plr] > 1.4 then
							for _, part in plr.Character:GetDescendants() do
								if part:IsA("BasePart") then release(part, 3) end
							end
						end
					end
				end
			end
		end
		for plr in rideT do
			if not seen[plr] then rideT[plr] = nil end
		end
	end

	a3 += dt
	if a3 >= 1.5 then
		a3 = 0
		for _, plr in Players:GetPlayers() do
			local char = plr ~= player and plr.Character
			if char then
				for _, d in char:GetDescendants() do
					if d:IsA("Sound") and d.Playing and (d.Volume > 4 or d.PlaybackLoudness > 500) then
						d.Volume = math.min(d.Volume, 0.5)
						sounded[d] = true
					end
				end
			end
		end
	end
end)

banner()