-- Operation One: ESP + silent aim (GUI renderer, direct state-packet firing)
-- Interface: uip100 library (as used by trident). Everything else is op-one v3.
--
-- The game runs its weapon logic inside an Actor VM, so outgoing packets can't
-- be hooked. Instead the aim path builds the same packet the client would and
-- sends it through the equipped item's StateObject.remote:
--     ("shoot", lookCFrame, { { {Instance, Position, Normal} } })
-- Valid target instance for a player is a part of their Viewmodel in
-- Workspace.Viewmodels (head/torso/legs), and HitHum must NOT be present.

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local Workspace = game:GetService("Workspace")
local UIS = game:GetService("UserInputService")
local TweenService = game:GetService("TweenService")

local lp = Players.LocalPlayer
local cam = Workspace.CurrentCamera

if getgenv().OpOneCleanup then
	pcall(getgenv().OpOneCleanup)
end

-- wipe any menu left behind by an earlier run so only one live instance exists
do
	local containers = {}
	if gethui then table.insert(containers, gethui()) end
	local pg = lp:FindFirstChild("PlayerGui")
	if pg then table.insert(containers, pg) end
	if game:FindFirstChild("CoreGui") then table.insert(containers, game.CoreGui) end
	for _, c in ipairs(containers) do
		for _, obj in ipairs(c:GetChildren()) do
			if obj:IsA("ScreenGui") and obj.Name == "OpOneESP" then
				pcall(function() obj:Destroy() end)
			end
		end
	end
end

local Config = {
	ESP = true,
	Aim = true,
	TeamCheck = true,
	FOV = 260,
	MaxDist = 700,
	AimPart = "head", -- head | torso
	RateLimit = 0.06,
	Box = true,
	Name = true,
	Health = true,
	Distance = true,
	Debug = false,
}

-- visual settings (chams, tracers) — kept apart from the aim/esp core
local VIS = {
	autoFire = false,

	hitmarker = true,
	hitmarkerColor = Color3.fromRGB(255, 255, 255),
	hitmarkerSize = 9,
	hitmarkerLife = 0.22,

	chams = true,
	chamsThrough = true,
	chamsThermal = true,
	chamsRainbow = false,
	chamsFade = false,
	chamsFill = Color3.fromRGB(119, 120, 255),
	chamsFillAlpha = 80,
	chamsOutlineKind = true,
	chamsOutline = Color3.fromRGB(0, 0, 0),
	chamsOutlineAlpha = 80,

	matChams = false,
	matChamsColor = Color3.fromRGB(0, 255, 255),
	matChamsAlpha = 0.25,
	matChamsMaterial = "ForceField",
	matChamsPattern = "Wave",
	matChamsSpeed = 3,
	matChamsRainbow = false,

	vischeck = true,
	vischeckVisible = Color3.fromRGB(0, 255, 0),
	vischeckHidden = Color3.fromRGB(255, 0, 0),

	tracers = true,
	tracerColor = Color3.fromRGB(140, 200, 255),
	tracerLife = 0.22,
	tracerThickness = 0.07,

	marker = true,
	markerColor = Color3.fromRGB(255, 255, 255),
	markerSize = 22,
	markerLife = 0.35,
}

local spawnTracer
local spawnMarker
local openPath
local hitmark
local lastShotModel, lastShotAt = nil, 0

-- only the newest instance may fire or draw
local TOKEN = {}
getgenv().OpOneToken = TOKEN
local function superseded()
	return getgenv().OpOneToken ~= TOKEN
end

local COLORS = {
	enemy = Color3.fromRGB(255, 70, 70),
	team = Color3.fromRGB(80, 190, 255),
	zombie = Color3.fromRGB(130, 255, 130),
	npc = Color3.fromRGB(220, 220, 220),
	text = Color3.fromRGB(255, 255, 255),
}

----------------------------------------------------------------------
-- players / teams
----------------------------------------------------------------------

local function isEnemy(p)
	if p == lp then return false end
	if not Config.TeamCheck then return true end
	if p.Team and lp.Team then return p.Team ~= lp.Team end
	if p.TeamColor and lp.TeamColor then return p.TeamColor ~= lp.TeamColor end
	return p:GetAttribute("Team") ~= lp:GetAttribute("Team")
end

local function isZombie(model)
	if model.Name == "Walker" then return true end
	if model:FindFirstChild("Zombie") then return true end
	local ok, tagged = pcall(function() return model:HasTag("Zombie") end)
	if ok and tagged then return true end
	return model:GetAttribute("Zombie") ~= nil
end

local function viewmodelFor(player, model)
	local vmFolder = Workspace:FindFirstChild("Viewmodels")
	if not vmFolder then return nil end
	local localVm = vmFolder:FindFirstChild("LocalViewmodel")
	local root = model and model:FindFirstChild("HumanoidRootPart")
	if not root then return nil end
	local best, bestDist
	for _, vm in ipairs(vmFolder:GetChildren()) do
		if vm ~= localVm and vm:FindFirstChild("torso") then
			local d = (vm.torso.Position - root.Position).Magnitude
			if d < 25 and (not bestDist or d < bestDist) then best, bestDist = vm, d end
		end
	end
	return best
end

local function collectEntities()
	local out = {}
	if not Workspace:FindFirstChild("Viewmodels") then return out end

	for _, model in ipairs(Workspace:GetChildren()) do
		local hum = model:FindFirstChildOfClass("Humanoid")
		if hum and hum.Health > 0 and model ~= lp.Character and model.Name ~= lp.Name then
			local player = Players:FindFirstChild(model.Name)
			local kind, vm, part, aimable = nil, nil, nil, true
			if player and player ~= lp then
				vm = viewmodelFor(player, model)
				if vm then
					part = vm:FindFirstChild(Config.AimPart) or vm:FindFirstChild("head") or vm:FindFirstChild("torso")
				else
					part = model:FindFirstChild("head") or model:FindFirstChild("collision") or model:FindFirstChild("HumanoidRootPart")
					aimable = false
				end
				kind = isEnemy(player) and "enemy" or "team"
			elseif isZombie(model) then
				kind = "zombie"
				part = model:FindFirstChild("head") or model:FindFirstChild("collision") or model:FindFirstChild("HumanoidRootPart")
			else
				kind = "npc"
			end
			if part and kind ~= "npc" then
				table.insert(out, {
					model = model,
					hum = hum,
					part = part,
					vm = vm,
					kind = kind,
					aimable = aimable,
					name = player and player.Name or model.Name,
				})
			end
		end
	end
	return out
end

----------------------------------------------------------------------
-- gun access
----------------------------------------------------------------------

local function equippedGun()
	local vmFolder = Workspace:FindFirstChild("Viewmodels")
	local lv = vmFolder and vmFolder:FindFirstChild("LocalViewmodel")
	if not lv then return nil end
	for _, m in ipairs(lv:GetChildren()) do
		local g = m:FindFirstChild("Gun")
		local so = m:FindFirstChild("StateObject")
		if g and so and so:FindFirstChild("remote") then
			return m, g, so.remote
		end
	end
end

local function shotOrigin(item)
	local root = item:FindFirstChild("Root")
	local shoot = root and root:FindFirstChild("Shoot", true)
	if shoot and shoot:IsA("Attachment") then return shoot.WorldPosition end
	local muzzle = item:FindFirstChild("Shoot", true)
	if muzzle and muzzle:IsA("BasePart") then return muzzle.Position end
	return cam.CFrame.Position
end

----------------------------------------------------------------------
-- targeting
----------------------------------------------------------------------

local function screenPos(world)
	local p, onScreen = cam:WorldToViewportPoint(world)
	if p.Z <= 0 then return nil end
	return Vector2.new(p.X, p.Y), onScreen
end

local function getTarget()
	local vp = cam.ViewportSize
	local center = Vector2.new(vp.X / 2, vp.Y / 2)
	local camPos = cam.CFrame.Position
	local best, bestScore
	for _, e in ipairs(collectEntities()) do
		if e.kind ~= "team" and e.aimable ~= false then
			local dist = (e.part.Position - camPos).Magnitude
			if dist <= Config.MaxDist then
				local sp = screenPos(e.part.Position)
				if sp then
					local score = (sp - center).Magnitude
					if score <= Config.FOV and (not bestScore or score < bestScore) then
						best, bestScore = e, score
					end
				end
			end
		end
	end
	return best
end

----------------------------------------------------------------------
-- firing
----------------------------------------------------------------------

local lastShot = 0
local firing = false
local shotsTotal = 0
local lastFireAt = 0

local function sendShot()
	if superseded() then return end
	if not Config.Aim then return end
	local item, gun, remote = equippedGun()
	if not item then return end
	if gun:FindFirstChild("mag") and gun.mag.Value <= 0 then return end
	if gun:FindFirstChild("chambered") and gun.chambered.Value == false then return end

	local now = os.clock()
	if now - lastShot < Config.RateLimit then return end

	local target = getTarget()
	if not target then return end

	lastShot = now
	local origin = shotOrigin(item)
	local pos = target.part.Position
	local cf = CFrame.lookAt(origin, pos)
	local hit = { Instance = target.part, Position = pos, Normal = (origin - pos).Unit }
	local ok, err = pcall(function()
		remote:FireServer("shoot", cf, { { hit } })
	end)
	if not ok and Config.Debug then
		print("[opone] fire error: " .. tostring(err))
	end
	shotsTotal += 1
	lastFireAt = now
	lastShotModel = target.model
	lastShotAt = now
	-- the round physically reaches the body: the same chain the server resolves
	if openPath(origin, target) then
		hitmark(false)
		if VIS.marker then
			spawnMarker(pos, VIS.markerColor, VIS.markerSize, VIS.markerLife)
		end
	end
	if VIS.tracers then
		spawnTracer(origin, pos, VIS.tracerColor, VIS.tracerLife, VIS.tracerThickness)
	end
	getgenv().OpOneLastShot = { target = target.name, at = now }
end

-- Per-instance weak set: the button keeps its callbacks for as long as it lives,
-- so it only ever needs hooking once by this instance. The attribute is only a
-- marker for reading from outside, never a gate: a button that already carries it
-- (from an earlier execution, or from a reload) still gets this instance's hooks.
local hookedButtons = setmetatable({}, { __mode = "k" })
local hookedCount = 0
local currentShootButton = nil

local function hookFireButton(btn)
	if not btn or hookedButtons[btn] then return end
	hookedButtons[btn] = true
	hookedCount += 1
	currentShootButton = btn
	pcall(function() btn:SetAttribute("OpHooked", true) end)
	-- the game's own handlers stay attached: the shot has to look and sound real,
	-- the packet only steers where it lands
	btn.MouseButton1Down:Connect(function()
		if superseded() then return end
		firing = true
	end)
	btn.MouseButton1Up:Connect(function() firing = false end)
	btn.MouseLeave:Connect(function() firing = false end)
end

task.spawn(function()
	while true do
		-- a teardown in the middle of a scan must not kill the task: every round
		-- rebuilds the hud, and this loop is the only thing that re-arms the button
		pcall(function()
			local pg = lp:FindFirstChild("PlayerGui")
			if pg then
				for _, d in ipairs(pg:GetDescendants()) do
					if d:IsA("GuiButton") and d.Name:lower():find("shoot") then
						hookFireButton(d)
					end
				end
			end
		end)
		task.wait(1)
	end
end)

UIS.InputBegan:Connect(function(input, gp)
	if gp or superseded() then return end
	if input.UserInputType == Enum.UserInputType.MouseButton1 then firing = true end
end)
UIS.InputEnded:Connect(function(input)
	if input.UserInputType == Enum.UserInputType.MouseButton1 then firing = false end
end)

RunService.Heartbeat:Connect(function()
	if superseded() then return end
	if firing and Config.Aim then
		sendShot()
	end
	if VIS.autoFire and Config.Aim then
		local item = equippedGun()
		if item then
			local target = getTarget()
			if target and openPath(shotOrigin(item), target) then
				sendShot()
			end
		end
	end
end)

----------------------------------------------------------------------
-- esp (screen-space instances)
----------------------------------------------------------------------

local gui = Instance.new("ScreenGui")
gui.Name = "OpOneESP"
gui.ResetOnSpawn = false
gui.IgnoreGuiInset = true
gui.DisplayOrder = 999
gui.Parent = lp:WaitForChild("PlayerGui")

local pool = {}

local function newDraw()
	local frame = Instance.new("Frame")
	frame.Name = "Box"
	frame.BackgroundTransparency = 1
	frame.BorderSizePixel = 0
	frame.Visible = false
	frame.Parent = gui

	local stroke = Instance.new("UIStroke")
	stroke.Thickness = 1.5
	stroke.ApplyStrokeMode = Enum.ApplyStrokeMode.Border
	stroke.Parent = frame

	local name = Instance.new("TextLabel")
	name.BackgroundTransparency = 1
	name.AnchorPoint = Vector2.new(0.5, 1)
	name.Position = UDim2.new(0.5, 0, 0, -2)
	name.Size = UDim2.new(2, 0, 0, 16)
	name.Font = Enum.Font.GothamBold
	name.TextSize = 13
	name.TextStrokeTransparency = 0
	name.Text = ""
	name.Parent = frame

	local dist = Instance.new("TextLabel")
	dist.BackgroundTransparency = 1
	dist.AnchorPoint = Vector2.new(0.5, 0)
	dist.Position = UDim2.new(0.5, 0, 1, 2)
	dist.Size = UDim2.new(2, 0, 0, 14)
	dist.Font = Enum.Font.Gotham
	dist.TextSize = 11
	dist.TextStrokeTransparency = 0
	dist.Text = ""
	dist.Parent = frame

	local hpBg = Instance.new("Frame")
	hpBg.BackgroundColor3 = Color3.new(0, 0, 0)
	hpBg.BackgroundTransparency = 0.4
	hpBg.BorderSizePixel = 0
	hpBg.AnchorPoint = Vector2.new(1, 0)
	hpBg.Position = UDim2.new(0, -4, 0, 0)
	hpBg.Size = UDim2.new(0, 3, 1, 0)
	hpBg.Parent = frame

	local hp = Instance.new("Frame")
	hp.BackgroundColor3 = Color3.fromRGB(70, 255, 110)
	hp.BorderSizePixel = 0
	hp.AnchorPoint = Vector2.new(0, 1)
	hp.Position = UDim2.new(0, 0, 1, 0)
	hp.Size = UDim2.new(1, 0, 1, 0)
	hp.Parent = hpBg

	return { frame = frame, stroke = stroke, name = name, dist = dist, hpBg = hpBg, hp = hp }
end

local function getDraw(i)
	if not pool[i] then pool[i] = newDraw() end
	return pool[i]
end

local fovSegments = {}
for i = 1, 36 do
	local s = Instance.new("Frame")
	s.Name = "FovDot"
	s.BackgroundColor3 = Color3.new(1, 1, 1)
	s.BackgroundTransparency = 0.55
	s.BorderSizePixel = 0
	s.AnchorPoint = Vector2.new(0.5, 0.5)
	s.Size = UDim2.fromOffset(2, 2)
	s.Visible = false
	s.Parent = gui
	fovSegments[i] = s
end

local function updateFovRing()
	local vp = cam.ViewportSize
	local cx, cy = vp.X / 2, vp.Y / 2
	for i = 1, #fovSegments do
		local s = fovSegments[i]
		s.Visible = Config.Aim
		if Config.Aim then
			local a = (i / #fovSegments) * math.pi * 2
			s.Position = UDim2.fromOffset(cx + math.cos(a) * Config.FOV, cy + math.sin(a) * Config.FOV)
		end
	end
end

----------------------------------------------------------------------
-- chams
----------------------------------------------------------------------

local CHAM_PATTERNS = { "Static", "Wave", "Pulse", "Noise", "Lightning", "Scanline", "Grid" }
local CHAM_MATERIALS = { "ForceField", "Neon", "Glass", "Plastic", "SmoothPlastic", "Metal", "Foil",
	"Ice", "Marble", "Granite", "Slate", "Concrete", "Wood", "Fabric" }

local chamStates = {}

local function chamStateFor(model)
	local s = chamStates[model]
	if not s then
		local highlight = Instance.new("Highlight")
		highlight.Name = "OpOneChams"
		highlight.Enabled = false
		highlight.FillTransparency = 1
		highlight.OutlineTransparency = 0
		highlight.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
		highlight.Parent = gui
		s = { highlight = highlight, matStore = {} }
		chamStates[model] = s
	end
	return s
end

-- One value in 0..1 per part that multiplies the colour, so the same code drives
-- every pattern.
local function patternValue(part, mode, speed)
	local t = os.clock() * (speed or 3)
	if mode == "Wave" then
		return (math.sin(t + part.Position.X * 0.2 + part.Position.Y * 0.2) + 1) * 0.5
	elseif mode == "Pulse" then
		return (math.sin(t * 2) + 1) * 0.5
	elseif mode == "Noise" then
		return (math.noise(part.Position.X * 0.1, part.Position.Y * 0.1, t * 0.5) + 1) * 0.5
	elseif mode == "Lightning" then
		return math.abs(math.sin(t * 12 + part.Position.X)) * 0.8 + 0.2
	elseif mode == "Scanline" then
		return math.clamp(math.sin(t + part.Position.Y * 0.5) * 1.2, 0, 1)
	elseif mode == "Grid" then
		return (math.abs(math.sin(part.Position.X * 0.3 + t * 1.5))
			+ math.abs(math.sin(part.Position.Y * 0.3 + t * 1.5))) * 0.5
	end
	return 1
end

local function shouldCham(part)
	if not part:IsA("BasePart") then return false end
	if part.Transparency >= 1 then return false end
	local parent = part.Parent
	if parent and parent:IsA("Accessory") then return false end
	return true
end

local function applyMaterial(body, store, color, material, pattern, alpha, speed)
	for _, part in ipairs(body:GetDescendants()) do
		if shouldCham(part) then
			if not store[part] then
				store[part] = { Material = part.Material, Color = part.Color, Transparency = part.Transparency }
			end
			local value = patternValue(part, pattern, speed)
			pcall(function()
				if Enum.Material[material] then part.Material = Enum.Material[material] end
				part.Color = Color3.new(color.R * value, color.G * value, color.B * value)
				part.Transparency = alpha
			end)
		end
	end
end

local function restoreMaterial(store)
	for part, data in pairs(store) do
		if part and part.Parent then
			pcall(function()
				part.Material = data.Material
				part.Color = data.Color
				part.Transparency = data.Transparency
			end)
		end
		store[part] = nil
	end
end

----------------------------------------------------------------------
-- tracers
----------------------------------------------------------------------

local tracerPool = {}
local tracerIndex = 0

function spawnTracer(from, to, color, life, thickness)
	if typeof(from) ~= "Vector3" or typeof(to) ~= "Vector3" then return end
	local delta = to - from
	local length = delta.Magnitude
	if length < 1 then return end
	tracerIndex = (tracerIndex % 32) + 1
	local part = tracerPool[tracerIndex]
	if not part or not part.Parent then
		part = Instance.new("Part")
		part.Name = "OpOneTracer"
		part.Anchored = true
		part.CanCollide = false
		part.CanQuery = false
		part.CanTouch = false
		part.CastShadow = false
		part.Material = Enum.Material.Neon
		part.Size = Vector3.new(0.07, 0.07, 1)
		part.Transparency = 1
		part.Parent = Workspace
		tracerPool[tracerIndex] = part
	end
	local size = thickness or 0.07
	local start = from + delta.Unit * 1.2
	local span = to - start
	part.Size = Vector3.new(size, size, math.max(span.Magnitude, 0.1))
	part.CFrame = CFrame.lookAt(start + span * 0.5, to)
	part.Color = color or Color3.fromRGB(140, 200, 255)
	part.Transparency = 0.05
	TweenService:Create(part, TweenInfo.new(life or 0.22), { Transparency = 1 }):Play()
end

----------------------------------------------------------------------
-- world hitmarker (pinned at the impact, as in trident)
----------------------------------------------------------------------

local markerPool = {}
local markerIndex = 0

function spawnMarker(position, color, size, life)
	if typeof(position) ~= "Vector3" then return end
	markerIndex = (markerIndex % 24) + 1
	local entry = markerPool[markerIndex]
	if not entry or not entry.part.Parent then
		local part = Instance.new("Part")
		part.Name = "OpOneHitmark"
		part.Anchored = true
		part.CanCollide = false
		part.CanQuery = false
		part.CanTouch = false
		part.CastShadow = false
		part.Transparency = 1
		part.Size = Vector3.new(0.2, 0.2, 0.2)
		part.Parent = Workspace

		local gui = Instance.new("BillboardGui")
		gui.Name = "Mark"
		gui.AlwaysOnTop = true
		gui.LightInfluence = 0
		gui.Adornee = part
		gui.Size = UDim2.fromOffset(22, 22)
		gui.Parent = part

		local arms = {}
		for i = 1, 2 do
			local arm = Instance.new("Frame")
			arm.BackgroundColor3 = Color3.new(1, 1, 1)
			arm.BorderSizePixel = 0
			arm.AnchorPoint = Vector2.new(0.5, 0.5)
			arm.Position = UDim2.fromScale(0.5, 0.5)
			arm.Size = UDim2.new(0, 2, 0.82, 0)
			arm.Rotation = i == 1 and 45 or -45
			arm.Parent = gui
			arms[i] = arm
		end
		entry = { part = part, gui = gui, arms = arms }
		markerPool[markerIndex] = entry
	end

	local px = size or 22
	local dur = life or 0.35
	entry.part.Position = position
	entry.gui.Size = UDim2.fromOffset(px, px)
	for _, arm in ipairs(entry.arms) do
		arm.BackgroundColor3 = color or Color3.new(1, 1, 1)
		arm.BackgroundTransparency = 0
	end
	TweenService:Create(entry.gui, TweenInfo.new(dur), {
		Size = UDim2.fromOffset(px * 0.55, px * 0.55),
	}):Play()
	for _, arm in ipairs(entry.arms) do
		TweenService:Create(arm, TweenInfo.new(dur), { BackgroundTransparency = 1 }):Play()
	end
end

----------------------------------------------------------------------
-- local viewmodel
----------------------------------------------------------------------

local function localViewmodel()
	local folder = Workspace:FindFirstChild("Viewmodels")
	return folder and folder:FindFirstChild("LocalViewmodel")
end

----------------------------------------------------------------------
-- auto fire on an open shot path
----------------------------------------------------------------------

local autoParams = RaycastParams.new()
autoParams.FilterType = Enum.RaycastFilterType.Exclude
autoParams.IgnoreWater = true
autoParams.RespectCanCollide = true

function openPath(origin, target)
	if not target or not target.part then return false end
	local ignore = { lp.Character }
	if target.vm then table.insert(ignore, target.vm) end
	local lv = localViewmodel()
	if lv then table.insert(ignore, lv) end
	local ok, result = pcall(function()
		autoParams.FilterDescendantsInstances = ignore
		return Workspace:Raycast(origin, target.part.Position - origin, autoParams)
	end)
	if not ok then return false end
	if result == nil then return true end
	-- stopping on the target's own body means the round reached them
	return target.model ~= nil and result.Instance:IsDescendantOf(target.model)
end

----------------------------------------------------------------------
-- hitmarker
----------------------------------------------------------------------

local hitArms = {}
for i = 1, 4 do
	local f = Instance.new("Frame")
	f.Name = "HitArm"
	f.BackgroundColor3 = VIS.hitmarkerColor
	f.BorderSizePixel = 0
	f.AnchorPoint = Vector2.new(0.5, 0.5)
	f.Visible = false
	f.ZIndex = 20
	f.Parent = gui
	hitArms[i] = f
end

local hitUntil = 0
local hitKill = false
local hitCount = 0

function hitmark(kill)
	hitCount += 1
	hitUntil = os.clock() + (VIS.hitmarkerLife or 0.22)
	hitKill = kill and true or false
end

local function drawHitmarker()
	local now = os.clock()
	local left = hitUntil - now
	if not VIS.hitmarker or left <= 0 then
		for _, f in ipairs(hitArms) do f.Visible = false end
		return
	end
	local vp = cam.ViewportSize
	local cx, cy = vp.X / 2, vp.Y / 2
	local frac = math.clamp(left / math.max(VIS.hitmarkerLife or 0.22, 0.01), 0, 1)
	local len = (VIS.hitmarkerSize or 9) * (0.75 + 0.25 * frac)
	local gap = len * 0.45
	local color = hitKill and Color3.fromRGB(255, 80, 80) or VIS.hitmarkerColor
	for i, f in ipairs(hitArms) do
		local sx = (i == 1 or i == 3) and -1 or 1
		local sy = (i <= 2) and -1 or 1
		f.Visible = true
		f.BackgroundColor3 = color
		f.Position = UDim2.fromOffset(cx + sx * (gap + len * 0.5), cy + sy * (gap + len * 0.5))
		f.Size = UDim2.fromOffset(len, 2)
		f.Rotation = (sx == sy) and 45 or -45
	end
end

----------------------------------------------------------------------
-- vischeck chams (two highlights per target: red silhouette, green behind depth)
----------------------------------------------------------------------

local VISCHECK = {}

do
	local CollectionService = game:GetService("CollectionService")

	local TAG = "Chams"
	local VISIBLE_COLOR = VIS.vischeckVisible
	local HIDDEN_COLOR = VIS.vischeckHidden
	local GAP_PER_STUD = 1e-4
	local MIN_GAP = 1e-4
	local GAP_RESCALE = 2
	local OPAQUE_MAX = 0.01
	local SKINNED_GAP_SCALE = 4
	local MIN_SIZE = 0.001
	local CULL_RADIUS_SCALE = 1.5
	local CULL_MARGIN = 2
	local SLEEP_HYSTERESIS = 2

	local localPlayer = Players.LocalPlayer
	local camera = workspace.CurrentCamera

	local ghostRoot = Instance.new("Folder")
	ghostRoot.Name = "ChamsGhosts"
	ghostRoot.Parent = workspace

	local cameraConn = workspace:GetPropertyChangedSignal("CurrentCamera"):Connect(function()
		camera = workspace.CurrentCamera
	end)

	local entries = {}
	local list = {}

	local function makeHighlight(adornee, depthMode, color)
		local h = Instance.new("Highlight")
		h.Adornee = adornee
		h.DepthMode = depthMode
		h.FillColor = color
		h.FillTransparency = 0
		h.OutlineTransparency = 1
		h.Parent = ghostRoot
		return h
	end

	local function applyGap(e, dist)
		local gap = math.max(MIN_GAP, dist * GAP_PER_STUD)
		local sign = e.character and -2 or 2
		local minSize = Vector3.one * MIN_SIZE
		for i, g in e.dst do
			local base = e.baseSize[i]
			local size = (base + Vector3.one * (sign * gap * e.gapScale[i])):Max(minSize)
			g.Size = size
			local mesh = e.fileMeshes[i]
			if mesh then
				mesh.Scale = e.baseMeshScale[i] * size / base
			end
		end
		e.gapDist = dist
	end

	local function rebuild(e, camPos)
		e.dirty = false
		for _, c in e.partConns do
			c:Disconnect()
		end
		table.clear(e.partConns)
		for _, c in e.ghost:GetChildren() do
			if c:IsA("BasePart") then
				c:Destroy()
			end
		end
		table.clear(e.src)
		table.clear(e.dst)
		table.clear(e.welds)
		table.clear(e.baseSize)
		table.clear(e.gapScale)
		table.clear(e.fileMeshes)
		table.clear(e.baseMeshScale)

		local target = e.target
		local function markDirty()
			e.dirty = true
		end
		local candidates = target:IsA("BasePart") and { target } or target:GetDescendants()
		for _, d in candidates do
			if not d:IsA("BasePart") then
				continue
			end
			table.insert(e.partConns, d:GetPropertyChangedSignal("Transparency"):Connect(markDirty))
			table.insert(e.partConns, d:GetPropertyChangedSignal("Size"):Connect(markDirty))
			if d.Transparency > OPAQUE_MAX then
				continue
			end

			local archivable = d.Archivable
			d.Archivable = true
			local g = d:Clone()
			d.Archivable = archivable
			local fileMesh = false
			for _, child in g:GetChildren() do
				if child:IsA("DataModelMesh") then
					if child:IsA("SpecialMesh") and child.MeshType == Enum.MeshType.FileMesh then
						fileMesh = child
					end
				else
					child:Destroy()
				end
			end
			for _, tag in g:GetTags() do
				g:RemoveTag(tag)
			end
			g.Anchored = false
			g.Massless = true
			g.CanCollide = false
			g.CanQuery = false
			g.CanTouch = false
			g.CastShadow = false
			g.Transparency = 0
			g.CFrame = d.CFrame
			local w = Instance.new("Weld")
			w.Part0 = d
			w.Part1 = g
			w.Parent = g
			g.Parent = e.ghost

			table.insert(e.src, d)
			table.insert(e.dst, g)
			table.insert(e.welds, w)
			table.insert(e.baseSize, d.Size)
			table.insert(e.gapScale, d:IsA("MeshPart") and d.HasSkinnedMesh and SKINNED_GAP_SCALE or 1)
			table.insert(e.fileMeshes, fileMesh)
			table.insert(e.baseMeshScale, fileMesh and fileMesh.Scale or Vector3.one)
		end

		local root = nil
		if target:IsA("Model") then
			root = target.PrimaryPart or target:FindFirstChild("HumanoidRootPart")
		end
		if not root then
			root = target:IsA("BasePart") and target or target:FindFirstChildWhichIsA("BasePart", true)
		end
		e.root = root
		local radius = 0
		if root then
			local rootPos = root.Position
			for _, p in e.src do
				radius = math.max(radius, (p.Position - rootPos).Magnitude + p.Size.Magnitude * 0.5)
			end
		end
		e.radius = radius * CULL_RADIUS_SCALE + CULL_MARGIN
		e.awake = true
		applyGap(e, root and (root.Position - camPos).Magnitude or 0)
	end

	local function remove(target)
		local e = entries[target]
		if not e then
			return
		end
		entries[target] = nil
		local i = table.find(list, e)
		if i then
			list[i] = list[#list]
			list[#list] = nil
		end
		for _, c in e.conns do
			c:Disconnect()
		end
		for _, c in e.partConns do
			c:Disconnect()
		end
		e.red:Destroy()
		e.green:Destroy()
		e.ghost:Destroy()
	end

	local function add(target)
		if entries[target] or not (target:IsA("Model") or target:IsA("BasePart")) then
			return
		end
		if target == localPlayer.Character or not target:IsDescendantOf(workspace) then
			return
		end
		local character = target:IsA("Model") and target:FindFirstChildOfClass("Humanoid") ~= nil
		local ghost = Instance.new("Model")
		ghost.Name = target.Name .. "_ChamsGhost"
		if not character then
			local h = Instance.new("Humanoid")
			h.EvaluateStateMachine = false
			h.RequiresNeck = false
			h.BreakJointsOnDeath = false
			h.DisplayDistanceType = Enum.HumanoidDisplayDistanceType.None
			h.HealthDisplayType = Enum.HumanoidHealthDisplayType.AlwaysOff
			h.Parent = ghost
		end
		ghost.Parent = ghostRoot

		local e = {
			target = target,
			character = character,
			ghost = ghost,
			red = makeHighlight(character and ghost or target, Enum.HighlightDepthMode.AlwaysOnTop, HIDDEN_COLOR),
			green = makeHighlight(character and target or ghost, Enum.HighlightDepthMode.Occluded, VISIBLE_COLOR),
			root = nil,
			radius = 0,
			awake = true,
			src = {},
			dst = {},
			welds = {},
			baseSize = {},
			gapScale = {},
			fileMeshes = {},
			baseMeshScale = {},
			gapDist = 0,
			dirty = false,
			conns = {},
			partConns = {},
		}

		if target:IsA("Model") then
			local function onDescendant(d)
				if d:IsA("BasePart") then
					e.dirty = true
				end
			end
			table.insert(e.conns, target.DescendantAdded:Connect(onDescendant))
			table.insert(e.conns, target.DescendantRemoving:Connect(onDescendant))
		end
		table.insert(e.conns, target.AncestryChanged:Connect(function()
			if not target:IsDescendantOf(workspace) then
				remove(target)
			end
		end))

		entries[target] = e
		table.insert(list, e)
		rebuild(e, camera and camera.CFrame.Position or Vector3.zero)
	end

	local tagAdded = CollectionService:GetInstanceAddedSignal(TAG):Connect(add)
	local tagRemoved = CollectionService:GetInstanceRemovedSignal(TAG):Connect(remove)
	for _, inst in CollectionService:GetTagged(TAG) do
		add(inst)
	end

	local function sleep(e)
		e.awake = false
		for i, g in e.dst do
			e.welds[i].Enabled = false
			g.Anchored = true
		end
	end

	local wakeEntries = {}
	local wakeParts = {}
	local wakeCFrames = {}

	local function step()
		local cam = camera
		if not cam then
			return
		end
		local camCF = cam.CFrame
		local camPos = camCF.Position
		local look, right, up = camCF.LookVector, camCF.RightVector, camCF.UpVector
		local vp = cam.ViewportSize
		local tanY = math.tan(math.rad(cam.FieldOfView) * 0.5)
		local tanX = tanY * vp.X / vp.Y
		local secX = math.sqrt(1 + tanX * tanX)
		local secY = math.sqrt(1 + tanY * tanY)
		local n = 0

		for _, e in list do
			if e.dirty then
				rebuild(e, camPos)
			end
			local root = e.root
			if not root then
				continue
			end
			local rel = root.Position - camPos
			local z = rel:Dot(look)
			local r = e.awake and e.radius * SLEEP_HYSTERESIS or e.radius
			local onScreen = z >= -r
				and math.abs(rel:Dot(right)) <= z * tanX + r * secX
				and math.abs(rel:Dot(up)) <= z * tanY + r * secY

			if not onScreen then
				if e.awake then
					sleep(e)
				end
				continue
			end
			if not e.awake then
				e.awake = true
				table.insert(wakeEntries, e)
				local src = e.src
				for i, g in e.dst do
					n += 1
					wakeParts[n] = g
					wakeCFrames[n] = src[i].CFrame
				end
			end
			local dist = rel.Magnitude
			if dist > e.gapDist * GAP_RESCALE or dist * GAP_RESCALE < e.gapDist then
				applyGap(e, dist)
			end
		end

		if wakeEntries[1] then
			workspace:BulkMoveTo(wakeParts, wakeCFrames, Enum.BulkMoveMode.FireCFrameChanged)
			for _, e in wakeEntries do
				for i, g in e.dst do
					g.Anchored = false
					e.welds[i].Enabled = true
				end
			end
			table.clear(wakeEntries)
			table.clear(wakeParts)
			table.clear(wakeCFrames)
		end
	end

	RunService:BindToRenderStep("OpOneVischeck", Enum.RenderPriority.Camera.Value + 1, step)

	VISCHECK.recolor = function(visColor, hidColor)
		VISIBLE_COLOR = visColor
		HIDDEN_COLOR = hidColor
		for _, e in list do
			e.green.FillColor = visColor
			e.red.FillColor = hidColor
		end
	end

	VISCHECK.count = function()
		return #list
	end

	VISCHECK.shutdown = function()
		RunService:UnbindFromRenderStep("OpOneVischeck")
		tagAdded:Disconnect()
		tagRemoved:Disconnect()
		cameraConn:Disconnect()
		for _, e in list do
			for _, c in e.conns do pcall(function() c:Disconnect() end) end
			for _, c in e.partConns do pcall(function() c:Disconnect() end) end
			local ok = pcall(function() e.red:Destroy() end)
			pcall(function() e.green:Destroy() end)
			pcall(function() e.ghost:Destroy() end)
		end
		table.clear(list)
		table.clear(entries)
		pcall(function() ghostRoot:Destroy() end)
	end
end

-- tag reconciliation: bodies that are drawn this frame carry the Chams tag,
-- everything else gives it up so its ghost is torn down
local chamsTagged = {}

local function syncChamsTags(entities, on)
	local seen = {}
	if on then
		for _, e in ipairs(entities) do
			local body = e.vm
			if body then
				seen[body] = true
				if not chamsTagged[body] then
					chamsTagged[body] = true
					pcall(function()
						if not body:HasTag("Chams") then body:AddTag("Chams") end
					end)
				end
			end
		end
	end
	for body in pairs(chamsTagged) do
		if not seen[body] then
			chamsTagged[body] = nil
			pcall(function() body:RemoveTag("Chams") end)
		end
	end
end

----------------------------------------------------------------------
-- interface (uip100, same library trident loads)
----------------------------------------------------------------------

local UI = {}
local HUD = {}
local info, Watermark, uiWindow

do
	local Library = loadstring(game:HttpGet("https://pastebin.com/raw/ncKGkPTW"))()

	Library.Folders = {
		Directory = "uip100",
		Configs = "uip100/Configs",
		Assets = "uip100/Assets",
	}
	pcall(function()
		for _, folder in pairs(Library.Folders) do
			if type(isfolder) == "function" and not isfolder(folder) then makefolder(folder) end
		end
	end)

	pcall(function() Library:ChangeTheme("Accent", Color3.fromRGB(0, 190, 180)) end)

	local Window = Library:Window({ Name = "Operation One", MobileButtonText = "OpOne" })
	Watermark = Library:Watermark("op-one")
	local KeybindList = Library:KeybindList()

	local AimPage = Window:Page({ Name = "Aim", Columns = 2 })
	local VisualPage = Window:Page({ Name = "Visuals", Columns = 2 })
	local MiscPage = Window:Page({ Name = "Misc", Columns = 2 })

	local Controls = {}
	local function track(Element, Get)
		table.insert(Controls, { Element = Element, Get = Get })
		return Element
	end

	local function Toggle(Parent, Name, Flag, Get, Set)
		return track(Parent:Toggle({
			Name = Name,
			Flag = Flag,
			Default = Get(),
			Callback = Set,
		}), Get)
	end

	local function Slider(Parent, Name, Flag, Min, Max, Get, Set, Decimals, Suffix)
		return track(Parent:Slider({
			Name = Name,
			Flag = Flag,
			Min = Min,
			Max = Max,
			Decimals = Decimals or 1,
			Suffix = Suffix or "",
			Default = Get(),
			Callback = Set,
		}), Get)
	end

	local function Dropdown(Parent, Name, Flag, Items, Get, Set)
		return track(Parent:Dropdown({
			Name = Name,
			Flag = Flag,
			Items = Items,
			Default = Get(),
			Callback = Set,
		}), Get)
	end

	local function Colour(Parent, Name, Flag, Get, Set)
		return track(Parent:Label(Name):Colorpicker({
			Flag = Flag,
			Default = Get(),
			Callback = Set,
		}), Get)
	end

	local function Keyed(Element, Flag, Key, Mode, Get)
		local value = Get()
		Element:Keybind({ Flag = Flag, Default = Key, Mode = Mode })
		Element:Set(value)
		return Element
	end

	UI.sync = function()
		for _, entry in ipairs(Controls) do
			pcall(function() entry.Element:Set(entry.Get()) end)
		end
	end

	-- ---------------------------------------------------------------- aim
	local Aim = AimPage:Section({ Name = "Silent aim", Side = 1 })

	Keyed(Toggle(Aim, "Enable silent aim", "C_aim",
		function() return Config.Aim end,
		function(v) Config.Aim = v; if not v then firing = false end end),
		"K_aim", Enum.KeyCode.X, "Toggle", function() return Config.Aim end)

	Toggle(Aim, "Team check", "C_team",
		function() return Config.TeamCheck end,
		function(v) Config.TeamCheck = v end)

	Dropdown(Aim, "Aim part", "C_part", { "Head", "Torso" },
		function() return Config.AimPart == "torso" and "Torso" or "Head" end,
		function(v) Config.AimPart = string.lower(v) end)

	Slider(Aim, "FOV", "C_fov", 40, 520,
		function() return Config.FOV end,
		function(v) Config.FOV = v end, 1, " px")

	Slider(Aim, "Max distance", "C_maxdist", 100, 2000,
		function() return Config.MaxDist end,
		function(v) Config.MaxDist = v end, 1, " studs")

	Slider(Aim, "Fire rate", "C_rate", 0.01, 0.5,
		function() return Config.RateLimit end,
		function(v) Config.RateLimit = v end, 0.001, " s")

	Toggle(Aim, "Auto fire (open shot path)", "C_autoFire",
		function() return VIS.autoFire end,
		function(v) VIS.autoFire = v end)

	local Status = AimPage:Section({ Name = "Status", Side = 2 })

	HUD.target = Status:Label("target -")
	HUD.entities = Status:Label("entities 0")
	HUD.shots = Status:Label("shots 0")
	HUD.errors = Status:Label("no errors")

	-- ---------------------------------------------------------------- visuals
	local Esp = VisualPage:Section({ Name = "ESP", Side = 1 })

	Keyed(Toggle(Esp, "Enable ESP", "V_esp",
		function() return Config.ESP end,
		function(v)
			Config.ESP = v
			if not v then
				for _, d in ipairs(pool) do d.frame.Visible = false end
			end
		end),
		"K_esp", Enum.KeyCode.V, "Toggle", function() return Config.ESP end)

	Toggle(Esp, "Box", "V_box",
		function() return Config.Box end,
		function(v) Config.Box = v end)

	Toggle(Esp, "Name", "V_name",
		function() return Config.Name end,
		function(v) Config.Name = v end)

	Toggle(Esp, "Health bar", "V_health",
		function() return Config.Health end,
		function(v) Config.Health = v end)

	Toggle(Esp, "Distance", "V_distance",
		function() return Config.Distance end,
		function(v) Config.Distance = v end)

	local Highlight = VisualPage:Section({ Name = "Chams", Side = 1 })

	Keyed(Toggle(Highlight, "Chams", "V_chams",
		function() return VIS.chams end,
		function(v) VIS.chams = v end),
		"K_chams", Enum.KeyCode.C, "Toggle", function() return VIS.chams end)

	Toggle(Highlight, "Through walls", "V_chamsThrough",
		function() return VIS.chamsThrough end,
		function(v) VIS.chamsThrough = v end)

	Toggle(Highlight, "Thermal breathing", "V_chamsThermal",
		function() return VIS.chamsThermal end,
		function(v) VIS.chamsThermal = v end)

	Toggle(Highlight, "Rainbow fill", "V_chamsRainbow",
		function() return VIS.chamsRainbow end,
		function(v) VIS.chamsRainbow = v end)

	Toggle(Highlight, "Fade with distance", "V_chamsFade",
		function() return VIS.chamsFade end,
		function(v) VIS.chamsFade = v end)

	Colour(Highlight, "Fill colour", "V_chamsFill",
		function() return VIS.chamsFill end,
		function(v) VIS.chamsFill = v end)

	Slider(Highlight, "Fill alpha", "V_chamsFillAlpha", 0, 100,
		function() return VIS.chamsFillAlpha end,
		function(v) VIS.chamsFillAlpha = v end, 1, "%")

	Toggle(Highlight, "Outline uses entity colour", "V_chamsOutlineKind",
		function() return VIS.chamsOutlineKind end,
		function(v) VIS.chamsOutlineKind = v end)

	Colour(Highlight, "Outline colour", "V_chamsOutline",
		function() return VIS.chamsOutline end,
		function(v) VIS.chamsOutline = v end)

	Slider(Highlight, "Outline alpha", "V_chamsOutlineAlpha", 0, 100,
		function() return VIS.chamsOutlineAlpha end,
		function(v) VIS.chamsOutlineAlpha = v end, 1, "%")

	local Material = VisualPage:Section({ Name = "Material chams", Side = 2 })

	Toggle(Material, "Chams on body parts", "V_matChams",
		function() return VIS.matChams end,
		function(v) VIS.matChams = v end)

	Toggle(Material, "Rainbow body", "V_matChamsRainbow",
		function() return VIS.matChamsRainbow end,
		function(v) VIS.matChamsRainbow = v end)

	Dropdown(Material, "Material", "V_matChamsMaterial", CHAM_MATERIALS,
		function() return VIS.matChamsMaterial end,
		function(v) VIS.matChamsMaterial = v end)

	Dropdown(Material, "Pattern", "V_matChamsPattern", CHAM_PATTERNS,
		function() return VIS.matChamsPattern end,
		function(v) VIS.matChamsPattern = v end)

	Colour(Material, "Body colour", "V_matChamsColor",
		function() return VIS.matChamsColor end,
		function(v) VIS.matChamsColor = v end)

	Slider(Material, "Body alpha", "V_matChamsAlpha", 0, 1,
		function() return VIS.matChamsAlpha end,
		function(v) VIS.matChamsAlpha = v end, 0.01)

	Slider(Material, "Pattern speed", "V_matChamsSpeed", 0.5, 12,
		function() return VIS.matChamsSpeed end,
		function(v) VIS.matChamsSpeed = v end, 0.1)

	local Vischeck = VisualPage:Section({ Name = "Vischeck chams", Side = 2 })

	Toggle(Vischeck, "Vischeck chams (green visible / red hidden)", "V_vischeck",
		function() return VIS.vischeck end,
		function(v) VIS.vischeck = v end)

	Colour(Vischeck, "Visible colour", "V_vischeckVisible",
		function() return VIS.vischeckVisible end,
		function(v)
			VIS.vischeckVisible = v
			VISCHECK.recolor(VIS.vischeckVisible, VIS.vischeckHidden)
		end)

	Colour(Vischeck, "Hidden colour", "V_vischeckHidden",
		function() return VIS.vischeckHidden end,
		function(v)
			VIS.vischeckHidden = v
			VISCHECK.recolor(VIS.vischeckVisible, VIS.vischeckHidden)
		end)

	local HitSec = VisualPage:Section({ Name = "Hitmarker", Side = 2 })

	Toggle(HitSec, "Hitmarker", "V_hitmarker",
		function() return VIS.hitmarker end,
		function(v) VIS.hitmarker = v end)

	Colour(HitSec, "Colour", "V_hitmarkerColor",
		function() return VIS.hitmarkerColor end,
		function(v) VIS.hitmarkerColor = v end)

	Slider(HitSec, "Size", "V_hitmarkerSize", 4, 20,
		function() return VIS.hitmarkerSize end,
		function(v) VIS.hitmarkerSize = v end, 1, " px")

	local Tracers = VisualPage:Section({ Name = "Tracers & hitmarker", Side = 2 })

	Toggle(Tracers, "Bullet tracers", "V_tracers",
		function() return VIS.tracers end,
		function(v) VIS.tracers = v end)

	Colour(Tracers, "Tracer colour", "V_tracerColor",
		function() return VIS.tracerColor end,
		function(v) VIS.tracerColor = v end)

	Slider(Tracers, "Tracer life", "V_tracerLife", 0.05, 1,
		function() return VIS.tracerLife end,
		function(v) VIS.tracerLife = v end, 0.001, " s")

	Slider(Tracers, "Tracer thickness", "V_tracerThickness", 0.01, 0.8,
		function() return VIS.tracerThickness end,
		function(v) VIS.tracerThickness = v end, 0.01)

	Toggle(Tracers, "Impact hitmarker", "V_marker",
		function() return VIS.marker end,
		function(v) VIS.marker = v end)

	Colour(Tracers, "Impact colour", "V_markerColor",
		function() return VIS.markerColor end,
		function(v) VIS.markerColor = v end)

	Slider(Tracers, "Impact size", "V_markerSize", 8, 48,
		function() return VIS.markerSize end,
		function(v) VIS.markerSize = v end, 1, " px")

	Slider(Tracers, "Impact life", "V_markerLife", 0.1, 1.5,
		function() return VIS.markerLife end,
		function(v) VIS.markerLife = v end, 0.001, " s")

	-- ---------------------------------------------------------------- misc
	local Misc = MiscPage:Section({ Name = "Menu", Side = 2 })

	Toggle(Misc, "Debug output", "M_debug",
		function() return Config.Debug end,
		function(v) Config.Debug = v end)

	info = Misc:Label("idle")

	Misc:Label("Panic (unload)"):Keybind({
		Name = "Panic",
		Flag = "K_panic",
		Default = Enum.KeyCode.Delete,
		Mode = "Hold",
		Callback = function(state)
			if state and getgenv().OpOneCleanup then pcall(getgenv().OpOneCleanup) end
		end,
	})

	Misc:Label("Show / hide menu"):Keybind({
		Name = "Show / hide menu",
		Flag = "K_window",
		Default = Enum.KeyCode.RightControl,
		Mode = "Hold",
		Callback = function(state)
			if uiWindow then uiWindow:SetOpen(state) end
		end,
	})

	Misc:Button({
		Name = "Unload",
		Callback = function()
			if getgenv().OpOneCleanup then pcall(getgenv().OpOneCleanup) end
		end,
	})

	Library:CreateSettingsPage(Window, KeybindList, Watermark)

	uiWindow = Window
	Window:SetOpen(true)
	UI.sync()
end

----------------------------------------------------------------------
-- render
----------------------------------------------------------------------

local lastTarget
local lastSync = 0

local function render()
	local used = 0
	local chamSeen = {}
	local chamsActive = VIS.chams or VIS.matChams
	local now = os.clock()

	local entities = collectEntities()
	syncChamsTags(entities, VIS.vischeck)

	for _, e in ipairs(entities) do
		local rootPos = e.vm and e.vm.torso and e.vm.torso.Position
			or (e.model:FindFirstChild("HumanoidRootPart") and e.model.HumanoidRootPart.Position)
		if rootPos then
			local dist = (rootPos - cam.CFrame.Position).Magnitude
			if dist <= Config.MaxDist then
				local body = e.vm or e.model

				-- kill upgrade: the body leaving the world right after our shot
				if lastShotModel and os.clock() - lastShotAt < 1.5 and lastShotModel.Parent == nil then
					hitmark(true)
					lastShotModel = nil
				end

				if chamsActive then
					local s = chamStateFor(e.model)
					chamSeen[e.model] = true

					if VIS.chams and not VIS.vischeck then
						local breathe = 1
						if VIS.chamsThermal then
							breathe = (math.atan(math.sin(now * 2)) * 2 / math.pi + 1) * 0.5
							breathe = 0.35 + 0.65 * breathe
						end
						local fade = 1
						if VIS.chamsFade then
							fade = math.clamp(1 - dist / math.max(Config.MaxDist, 1), 0.2, 1)
						end
						local fill = VIS.chamsFill
						local outline = VIS.chamsOutlineKind and (COLORS[e.kind] or COLORS.npc) or VIS.chamsOutline
						if VIS.chamsRainbow then
							local hue = (now % 5) / 5
							fill = Color3.fromHSV(hue, 1, 1)
							outline = Color3.fromHSV((hue + 0.5) % 1, 1, 1)
						end
						s.highlight.Adornee = body
						s.highlight.FillColor = fill
						s.highlight.OutlineColor = outline
						s.highlight.FillTransparency = math.clamp(1 - (VIS.chamsFillAlpha / 100) * breathe * fade, 0, 1)
						s.highlight.OutlineTransparency = math.clamp(1 - (VIS.chamsOutlineAlpha / 100) * breathe * fade, 0, 1)
						s.highlight.DepthMode = VIS.chamsThrough
							and Enum.HighlightDepthMode.AlwaysOnTop
							or Enum.HighlightDepthMode.Occluded
						s.highlight.Enabled = true
					else
						s.highlight.Enabled = false
					end

					if VIS.matChams then
						local matColor = VIS.matChamsColor
						if VIS.matChamsRainbow then
							matColor = Color3.fromHSV((now % 5) / 5, 1, 1)
						end
						applyMaterial(body, s.matStore, matColor, VIS.matChamsMaterial,
							VIS.matChamsPattern, VIS.matChamsAlpha, VIS.matChamsSpeed)
					elseif next(s.matStore) then
						restoreMaterial(s.matStore)
					end
				end

				local sp = Config.ESP and screenPos(rootPos) or nil
				if sp then
					local _, size = e.model:GetBoundingBox()
					local half = size.Y / 2
					local width = math.max(size.X, size.Z) * 0.9
					local right = cam.CFrame.RightVector * (width / 2)
					local tl = screenPos(rootPos + Vector3.new(0, half, 0) - right)
					local br = screenPos(rootPos - Vector3.new(0, half, 0) + right)

					if tl and br then
						used += 1
						local d = getDraw(used)
						local color = COLORS[e.kind] or COLORS.npc
						local x = math.min(tl.X, br.X)
						local y = math.min(tl.Y, br.Y)
						local w = math.max(math.abs(br.X - tl.X), 6)
						local h = math.max(math.abs(br.Y - tl.Y), 12)

						d.frame.Visible = true
						d.frame.Position = UDim2.fromOffset(x, y)
						d.frame.Size = UDim2.fromOffset(w, h)
						d.stroke.Color = color

						d.name.Visible = Config.Name
						d.name.Text = e.name:sub(1, 16)
						d.name.TextColor3 = color

						d.dist.Visible = Config.Distance
						d.dist.Text = string.format("%d m  %d hp", math.floor(dist), math.floor(e.hum.Health))

						d.hpBg.Visible = Config.Health
						if Config.Health then
							local frac = math.clamp(e.hum.Health / math.max(e.hum.MaxHealth, 1), 0, 1)
							d.hp.Size = UDim2.new(1, 0, frac, 0)
							d.hp.BackgroundColor3 = Color3.fromRGB(
								math.floor(255 * (1 - frac)),
								math.floor(80 + 175 * frac),
								70
							)
						end
					end
				end
			end
		end
	end

	for i = used + 1, #pool do
		pool[i].frame.Visible = false
	end

	-- entities no longer drawn lose their highlight and get their body back
	for model, s in pairs(chamStates) do
		if not chamSeen[model] then
			s.highlight.Enabled = false
			if next(s.matStore) then restoreMaterial(s.matStore) end
		end
		if model.Parent == nil then
			s.highlight:Destroy()
			restoreMaterial(s.matStore)
			chamStates[model] = nil
		end
	end

	updateFovRing()
	drawHitmarker()

	lastTarget = getTarget()

	if os.clock() - lastSync > 0.2 then
		lastSync = os.clock()
		if UI.sync then pcall(UI.sync) end
		if Watermark then
			pcall(function()
				Watermark:SetVisibility(true)
				Watermark:SetText(string.format("trident op1   aim %s   esp %s   fov %d   %s",
					Config.Aim and "on" or "off", Config.ESP and "on" or "off",
					math.floor(Config.FOV + 0.5), Config.AimPart))
			end)
		end
		pcall(function()
			if HUD.target then
				HUD.target:SetText(lastTarget
					and string.format("target %s   %d studs", lastTarget.name,
						math.floor((lastTarget.part.Position - cam.CFrame.Position).Magnitude))
					or "target -")
			end
			if HUD.entities then HUD.entities:SetText("entities " .. tostring(used)) end
			if HUD.shots then HUD.shots:SetText("shots " .. tostring(shotsTotal)) end
			if HUD.errors then HUD.errors:SetText("no errors") end
			if info then info:SetText(lastTarget and ("lock: " .. lastTarget.name) or "no target") end
		end)
	end
end

local renderConn = RunService.RenderStepped:Connect(function()
	if superseded() then
		if renderConn then renderConn:Disconnect() end
		pcall(function() gui:Destroy() end)
		return
	end
	local ok, err = pcall(render)
	if not ok then warn("[opone] render: " .. tostring(err)) end
end)

getgenv().OpOneCleanup = function()
	if getgenv().OpOneToken == TOKEN then getgenv().OpOneToken = nil end
	if renderConn then renderConn:Disconnect() end
	for _, d in ipairs(pool) do pcall(function() d.frame:Destroy() end) end
	for _, s in ipairs(fovSegments) do pcall(function() s:Destroy() end) end
	for model, s in pairs(chamStates) do
		pcall(function()
			s.highlight:Destroy()
			restoreMaterial(s.matStore)
		end)
		chamStates[model] = nil
	end
	for _, part in ipairs(tracerPool) do
		pcall(function() part:Destroy() end)
	end
	table.clear(tracerPool)
	for _, entry in ipairs(markerPool) do
		pcall(function() entry.part:Destroy() end)
	end
	table.clear(markerPool)
	pcall(syncChamsTags, {}, false)
	pcall(VISCHECK.shutdown)
	pcall(function() gui:Destroy() end)
	pcall(function()
		local lib = getgenv().Library
		if lib then lib:Unload() end
	end)
	getgenv().OpOneCleanup = nil
end

getgenv().OpOneConfig = Config
getgenv().OpOneVIS = VIS
getgenv().OpOneVISCHECK = VISCHECK

getgenv().OpOneDebug = {
	fire = sendShot,
	tracer = spawnTracer,
	marker = spawnMarker,
	chams = chamStates,
	vis = VIS,
	config = Config,
	state = function()
		return {
			firing = firing,
			shots = shotsTotal,
			lastFire = lastFireAt,
			hooked = hookedCount,
			hits = hitCount,
			now = os.clock(),
		}
	end,
}
getgenv().OpOneTarget = function() return lastTarget end
getgenv().OpOneFire = function() sendShot() end

print("[opone] loaded - esp=" .. tostring(Config.ESP) .. " aim=" .. tostring(Config.Aim) .. " part=" .. Config.AimPart)