Hypershot Script Mobile, PC - Aimbot, ESP Players, Hitbox

SCRIPT DETAILS

Project Information

Project overview
Developer KrakenWare, RScritps, quantumloader, n1hitt
Scripts available: 0
Detection status UNDETECTED
Published November 6, 2026 at 5:40 AM
Version 1.1.8
Supported platforms PC (Windows, MacOS) - Mobile (iOS, Android)
Community & updates
COMMUNITY RATING

Was this script useful?

Your vote helps other players evaluate this publication.

Hypershot Script

Some of the best scripts for the Mobile and PC versions of the Roblox game Hypershot, featuring Aimbot, ESP Players, Hitbox, FOV settings, and much more, are available on this page. This is an excellent script with a user-friendly GUI and simple settings that even a novice who has never run scripts before can handle. Using this script, you can enable the function for accurate shooting, adjust the crosshair, see enemies through walls on any map, run fast, super jump, and many other settings that are updated and improved every day so that players have no problems while playing.

Here you will find only verified and working scripts for the popular shooter Hypershot. Please note that the game may be updated and some features may stop working, so keep an eye on this publication so you don't miss the latest versions of scripts for Hypershot Roblox.

The Best Scripts and Hacks Hypershot PC, Mobile

Hypershot Script Selux Hub (NO KEY) | AFK Auto Fire, Silent Aim

--[[ hypershot.lua - "Hypershot!" (Frosted Studio)

  Places, out of the game's own Modules.GetPlaceType: Main 17516596118, Mobile
  131008473296170, GunGame 122181485177067, MainForNewPlayers 100040622766961,
  Duels 108428559529058, Beginner 86696142930150, GoldenOne / TwitchGauntlet
  103420430505525, DuelHub 134474332601640, SniperOnly 92980558919575. The hub
  entry lists them all and also detects by content.

  Everything below was measured on a live server (Beginner place, CTF and TDM,
  2026-09-19) before a line of it was written.

  * TARGETS ARE TWO LISTS. Real players are ordinary R15 characters in the
    Workspace; bots are Models in `workspace.Mobs` carrying `Bot = true` and a
    `__Bot` name suffix (`GlobalStuff:RemoveBotSuffix` strips it - on screen they
    are indistinguishable from real players). A dead body is moved into
    `workspace.IgnoreThese`. 200 HP for everybody.
  * THE TEAM IS AN ATTRIBUTE, not Player.Team: `Team` on the Player and on the
    character, -1 meaning free-for-all. `GlobalStuff:SameTeam` is the game's own
    check and this script calls it rather than re-implementing it.
  * THE CAMERA IS THE GAME'S OWN. CameraType is Scriptable and the controller
    rebuilds the view every frame out of angles it keeps in
    `ActionHandler:GetCamRot()`. Measured: a direct camera.CFrame write kept
    0.11 deg of 10 after two frames, `ActionHandler:UpdateCamRot` kept 14.96 of
    15 - so the aim writes the game's angles, exactly the way the game's own
    console/mobile aim assist (CameraController.AA) does. No hook, no mouse
    calibration. The mouse path is a dropdown; its scale is `Shared.CurrSens`,
    read, not learned.
  * THE CLIENT REPORTS ITS OWN HITS. Gun.Shoot raycasts from the camera towards
    `GameUIMod:GetMousePos()`, then sends `Shoot(aimPoints, origin, ..., camCF)`
    and `Damage(index, time, origin, {{part, pos}}, gen)`. Measured against a
    target's Humanoid.Health (server owned):
      - an aimed shot                                 200 -> 152
      - the SAME shot bent 35.7 deg off the camera    200 -> 152   (silent aim)
      - three Shoot() calls with no gap at all        200 -> 65 = 3 x 45
    So the server checks neither the angle between the camera and the shot nor
    the fire rate of a three-shot burst.
  * THE GAME HAS ITS OWN CLICK PATH. `Shared.MouseDown = true` +
    `Controller:LeftClick()` is exactly what the mouse handler and the game's
    own auto fire do. Measured: 0.3s held -> 3 shots, 200 -> 56. It has to run
    at thread identity 2 - from a higher one a lazy require inside throws
    "Cannot require a non-RobloxScript module from a RobloxScript".

  WHAT THIS SCRIPT DELIBERATELY DOES NOT DO, AND WHY
  * No hookmetamethod, no hookfunction, no getgc. ReplicatedFirst.LocalScript is
    a Luraph-protected anticheat answering the server through the
    `Aishiteru` RemoteFunction; its string table carries
    `_______ is not a valid member of DataModel`, `:(%d+)[:`, `(internal)`,
    `stack overflow` and `hb_hook_internal` - the metamethod-hook probe - and
    `VirtualInputManager`. So nothing here hooks a metamethod and nothing sends
    input through VirtualInputManager.
  * Duels are RECORDED. ControllerStuff.KeyframeBuffer writes camera angles,
    every shot and every hit at a fixed rate while `DuelID` is set, and the
    server pulls it with `KeyframePull`. A bent shot is a shot whose hit does
    not match the recorded view, so silent aim and rapid fire switch themselves
    off in a duel unless told otherwise.
]]

local Players           = game:GetService("Players")
local RunService        = game:GetService("RunService")
local UserInputService  = game:GetService("UserInputService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local CoreGui
do
    local ok, svc = pcall(game.GetService, game, "CoreGui")
    CoreGui = ok and svc or nil
end

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

local GEN = (_G.__HYPER or 0) + 1
_G.__HYPER = GEN

local function claimIdentity()
    if setthreadidentity then pcall(setthreadidentity, 8) end
    task.wait()
end

-- The game's own code has to be called the way a LocalScript would call it.
local function gameIdentity()
    if setthreadidentity then pcall(setthreadidentity, 2) end
end

local function waitFor(parent, name, timeout)
    if not parent then return nil end
    local ok, child = pcall(function() return parent:WaitForChild(name, timeout or 10) end)
    if ok then return child end
    return nil
end

-- Resolved through getgenv first: a loadstring'd chunk's env hands the executor
-- globals through __index, and a raw read misses them (phantomforces.lua).
local function execFn(name)
    local ok, fn = pcall(function()
        local g = getgenv and getgenv()
        return (g and g[name]) or getfenv()[name]
    end)
    if ok and type(fn) == "function" then return fn end
    return nil
end

--------------------------------------------------------------------------------
-- config
--------------------------------------------------------------------------------

local CONFIG = {
    -- ESP ----------------------------------------------------------------------
    box        = true,
    boxFilled  = false,
    name       = true,
    health     = true,
    botTag     = true,
    weaponTag  = true,
    protTag    = true,
    distance   = true,
    tracer     = false,
    headDot    = false,
    skeleton   = false,
    chams      = false,
    showTeam   = false,
    visCheck   = true,
    maxDist    = 1500,
    textSize   = 14,
    textFont   = "System",
    textOutline = true,
    textShrink = false,

    colEnemy   = Color3.fromRGB(255, 72, 88),
    colBot     = Color3.fromRGB(255, 176, 60),
    colTeam    = Color3.fromRGB(80, 170, 255),
    colProt    = Color3.fromRGB(120, 140, 165),
    colCham    = Color3.fromRGB(255, 72, 88),
    colChamOwn = false,
    colFov     = Color3.fromRGB(255, 255, 255),
    colSilent  = Color3.fromRGB(255, 90, 200),

    chamStyle  = "Fill",
    chamRainbow = false,

    -- visuals ------------------------------------------------------------------
    crosshair  = false,
    crossSize  = 8,
    crossGap   = 3,
    crossDot   = true,
    crossThick = 1,
    colCross   = Color3.fromRGB(90, 255, 140),

    -- aim assist ---------------------------------------------------------------
    aim        = false,
    aimActive  = "Hotkey",
    aimKey     = "MouseButton2",
    aimPart    = "Head",
    aimPick    = "Crosshair",
    aimSticky  = true,
    aimVisible = true,
    aimSkipProt = true,
    aimMaxDist = 500,
    aimReady   = true,
    aimAds     = "Always",
    aimCurve   = "Ease out",
    aimPath    = "Game camera",
    aimFov     = 120,
    aimSmoothH = 20,
    aimSmoothV = 24,
    aimFire    = false,
    aimHitPct  = 100,
    aimKillMs  = 300,
    aimFirstMs = 0,
    aimCircle  = true,

    -- trigger ------------------------------------------------------------------
    trig       = false,
    trigActive = "Hotkey",
    trigKey    = "C",
    trigDelayMin = 40,
    trigDelayMax = 110,
    trigHoldMs = 180,
    trigHitPct = 100,
    trigHeadOnly = false,
    trigSkipProt = true,
    trigMaxDist = 500,
    trigAds    = "Always",

    -- silent aim ---------------------------------------------------------------
    silent       = false,
    silentActive = "Hotkey",
    silentKey    = "F",
    silentPart   = "Head",
    silentPick   = "Crosshair",
    silentFov    = 90,
    silentCircle = true,
    silentMode   = "FOV circle",   -- or "Whole screen"
    silentLine   = true,           -- a line from the crosshair to the current silent target
    silentSkipProt = true,
    silentMaxDist = 500,
    silentDuel   = false,   -- also in a duel, where every shot is recorded

    -- gun mods -----------------------------------------------------------------
    noRecoil   = false,
    noKick     = false,
    noSpread   = false,
    rapid      = false,
    rapidMult  = 1.3,
    modsDuel   = false,

    -- more gun mods -------------------------------------------------------------
    noSway     = false,
    instantAds = false,
    fastReload = false,
    reloadMult = 2,
    fastEquip  = false,
    equipMult  = 3,
    predict    = true,    -- lead moving targets with projectile weapons
    silentHitPct = 100,

    -- world & visuals -----------------------------------------------------------
    pickupEsp  = false,
    projEsp    = false,
    tracers    = false,
    tracerLife = 0.6,
    colTracer  = Color3.fromRGB(255, 220, 90),
    colPickup  = Color3.fromRGB(120, 255, 170),
    vmColour   = false,
    vmMaterial = "ForceField",
    colVm      = Color3.fromRGB(140, 90, 255),
    fovOn      = false,
    fovValue   = 100,
    fullbright = false,
    noFog      = false,
    noEffects  = false,
    timeOn     = false,
    timeValue  = 14,

    -- more movement ---------------------------------------------------------------
    jumpOn     = false,
    jumpHeight = 18,
    infJump    = false,
    noSlideCd  = false,

    -- misc ---------------------------------------------------------------------------
    autoSpawn  = false,
    antiAfk    = false,
    staffAlert = true,
    staffPanic = false,
    streamer   = false,
    streamerName = "Player",
    skinOn     = false,
    skinName   = "Army Camo",
    killVfxOn  = false,
    killVfx    = "",

    -- movement -----------------------------------------------------------------
    speed      = false,
    speedAdd   = 8,       -- studs/s on top of the game's own speed (16, +9 sprinting)
    fly        = false,
    flySpeed   = 50,
    flyKey     = "X",     -- toggles fly while playing
    moveDuel   = false,

    -- humaniser ----------------------------------------------------------------
    hum          = true,
    humWindupMin = 40,
    humWindupMax = 130,
    humOffsetPct = 30,
    humJitter    = 0.8,
    humJitterHz  = 1.4,
    humOvershoot = 25,
    humOverDeg   = 1.6,
    humHeadPct   = 55,
    humMissPct   = 0,
    humBreakPct  = 6,
    humBreakMs   = 180,
    humFatigue   = 20,
    humCooldown  = 120,
    humReactSd   = 22,
    humPanelPause = true,
    humBotOnly   = false,
    humTurnCap   = 320,
    humDeadzone  = 2,
    humMoveFov   = 75,
    humSwitchMs  = 350,
    humRerollMs  = 900,
    specPause    = false,

    panicKey     = "End",
}

local DRAWINGS = {
    "box", "boxFilled", "name", "health", "botTag", "weaponTag", "protTag",
    "distance", "tracer", "headDot", "skeleton", "chams",
}

local function anyDrawing()
    for _, key in ipairs(DRAWINGS) do
        if CONFIG[key] then return true end
    end
    return false
end

local PRESETS = {
    ["Legit"] = {
        aimFov = 50, aimSmoothH = 34, aimSmoothV = 46, aimPart = "Body",
        aimFire = false, aimVisible = true, aimCurve = "Human",
        trigDelayMin = 110, trigDelayMax = 240, trigHitPct = 85,
        hum = true, humTurnCap = 180, humDeadzone = 4, humWindupMin = 90,
        humWindupMax = 240, humOffsetPct = 50, humHeadPct = 25, humOvershoot = 45,
        humBreakPct = 12, humMissPct = 8, humFatigue = 40, humCooldown = 260,
        humMoveFov = 45,
    },
    ["Normal"] = {
        aimFov = 120, aimSmoothH = 20, aimSmoothV = 24, aimPart = "Head",
        aimFire = false, aimVisible = true, aimCurve = "Ease out",
        trigDelayMin = 40, trigDelayMax = 110, trigHitPct = 100,
        hum = true, humTurnCap = 320, humDeadzone = 2, humWindupMin = 40,
        humWindupMax = 130, humOffsetPct = 30, humHeadPct = 55, humOvershoot = 25,
        humBreakPct = 6, humMissPct = 0, humFatigue = 20, humCooldown = 120,
        humMoveFov = 75,
    },
    ["Raw"] = {
        aimFov = 400, aimSmoothH = 2, aimSmoothV = 2, aimPart = "Head",
        aimFire = true, aimVisible = true, aimCurve = "Linear",
        trigDelayMin = 0, trigDelayMax = 10, trigHitPct = 100,
        hum = false, humTurnCap = 3000, humDeadzone = 0, humWindupMin = 0,
        humWindupMax = 0, humOffsetPct = 0, humHeadPct = 100, humOvershoot = 0,
        humBreakPct = 0, humMissPct = 0, humFatigue = 0, humCooldown = 0,
        humMoveFov = 100,
    },
}

local STATE = {
    note       = "",
    targets    = 0, bots = 0, humans = 0,
    target     = "-", targetKind = "-",
    paused     = "",
    aimDps     = 0, aimDpsPeak = 0,
    trigOn     = false, underCross = "-", trigShots = 0,
    lastKey    = "-",
    touch      = false,
    deployed   = false,
    duel       = false,
    spectators = 0,
    silentOn   = false, silentTarget = "-", silentNote = "-", silentBent = 0,
    silentSeen = 0,
    mods       = "-",
    weapon     = "-",
    chams      = "-",
    kills = 0, deaths = 0, assists = 0, damage = 0,
    sessionKills = 0, sessionDeaths = 0,
}

local COLOUR = {
    hpGood = Color3.fromRGB(90, 220, 120),
    hpBad  = Color3.fromRGB(230, 80, 60),
    text   = Color3.fromRGB(235, 235, 240),
    black  = Color3.fromRGB(0, 0, 0),
}

local function note(text) STATE.note = tostring(text) end

local function dimmed(colour)
    local h, s, v = Color3.toHSV(colour)
    return Color3.fromHSV(h, s * 0.9, v * 0.55)
end

--------------------------------------------------------------------------------
-- the game's own modules
--------------------------------------------------------------------------------

local function tryRequire(inst)
    if not inst then return nil end
    local ok, value = pcall(require, inst)
    if ok then return value end
    return nil
end

local Modules  = waitFor(ReplicatedStorage, "Modules", 10)
local GS       = tryRequire(Modules and Modules:FindFirstChild("GlobalStuff"))
local CC       = tryRequire(Modules and Modules:FindFirstChild("ClientCharacters"))
local GameInfo = ReplicatedStorage:FindFirstChild("GameInfo")
local StatsDir = ReplicatedStorage:FindFirstChild("PlayerStats")

if not GS then note("GlobalStuff missing - team and alive checks fall back to attributes") end

-- The in-match controller lives in PlayerGui.ControllerGUI, which is only there
-- while deployed and is replaced on every respawn. It is resolved lazily and
-- only required once it has existed for a moment: the game requires these
-- modules itself on spawn, and requiring one before it did would run it in THIS
-- thread's context instead of the game's.
local CTL = { gui = nil, at = 0, ready = false }

local function ctl()
    local pg = plr:FindFirstChildOfClass("PlayerGui")
    local cg = pg and pg:FindFirstChild("ControllerGUI")
    local root = cg and cg:FindFirstChild("NewMainLocal")
    if root ~= CTL.gui then CTL = { gui = root, at = os.clock(), ready = false } end
    if not root then return nil end
    if CTL.ready then return CTL end
    if os.clock() - CTL.at < 1.5 then return nil end
    CTL.Shared     = tryRequire(root:FindFirstChild("Shared"))
    CTL.Controller = tryRequire(root:FindFirstChild("Controller"))
    local tools = root:FindFirstChild("Tools")
    local tool  = tools and tools:FindFirstChild("Tool")
    CTL.Gun     = tryRequire(tool and tool:FindFirstChild("Gun"))
    CTL.ready   = CTL.Shared ~= nil
    return CTL.ready and CTL or nil
end

local AHC = { inst = nil, mod = nil }
local function actionHandler()
    local pg = plr:FindFirstChildOfClass("PlayerGui")
    local fp = pg and pg:FindFirstChild("FirstPersonGUI")
    local m  = fp and fp:FindFirstChild("ActionHandler")
    if m ~= AHC.inst then AHC = { inst = m, mod = tryRequire(m) } end
    return AHC.mod
end

local UIMC = { inst = nil, mod = nil }
local function gameUIMod()
    local pg = plr:FindFirstChildOfClass("PlayerGui")
    local g  = pg and pg:FindFirstChild("GameUI")
    local m  = g and g:FindFirstChild("GameUIMod")
    if m ~= UIMC.inst then UIMC = { inst = m, mod = tryRequire(m) } end
    return UIMC.mod
end

local function currentTool()
    local c = ctl()
    return c and c.Shared and c.Shared.CurrTool or nil, c
end

local function inDuel() return plr:GetAttribute("DuelID") ~= nil end

--------------------------------------------------------------------------------
-- combatants
--------------------------------------------------------------------------------

local function sameTeam(a, b)
    if GS then
        local ok, same = pcall(GS.SameTeam, GS, a, b)
        if ok then return same == true end
    end
    local ta = a and a:GetAttribute("Team")
    local tb = b and b:GetAttribute("Team")
    if ta == nil or tb == nil or ta == -1 or tb == -1 then return false end
    return ta == tb
end

local function charOf(p)
    if CC then
        local ok, c = pcall(CC.GetCharacter, CC, p)
        if ok and c then return c end
    end
    return p.Character
end

local combatCache, combatAt = {}, 0

local function combatants()
    local now = os.clock()
    if now - combatAt < 0.2 then return combatCache end
    combatAt = now
    local list = {}
    for _, p in ipairs(Players:GetPlayers()) do
        if p ~= plr then
            local char = charOf(p)
            if char and char.Parent then
                list[#list + 1] = { model = char, name = p.Name, player = p, bot = false,
                    team = sameTeam(plr, p) }
            end
        end
    end
    local mobs = workspace:FindFirstChild("Mobs")
    if mobs then
        for _, m in ipairs(mobs:GetChildren()) do
            if m:IsA("Model") then
                local shown = m.Name
                if GS then
                    local ok, n = pcall(GS.RemoveBotSuffix, GS, m.Name)
                    if ok and n then shown = n end
                end
                list[#list + 1] = { model = m, name = shown, player = nil,
                    bot = m:GetAttribute("Bot") == true, mob = m:GetAttribute("Bot") ~= true,
                    team = sameTeam(plr, m) }
            end
        end
    end
    combatCache = list
    return list
end

local function aliveOf(model)
    if not model or not model.Parent then return nil end
    if model:GetAttribute("LobbyCharacter") == true then return nil end
    local hum = model:FindFirstChildWhichIsA("Humanoid")
    if not hum or hum.Health <= 0 then return nil end
    local root = model:FindFirstChild("HumanoidRootPart")
    if not root or not model:FindFirstChild("Head") then return nil end
    return hum.Health, hum.MaxHealth, root, hum
end

-- GlobalStuff:CanHit returns nothing for a character carrying a ForceField, so
-- that is what spawn protection is here: the game's own shot ignores them.
local function protectedOf(model)
    return model ~= nil and model:FindFirstChild("ForceField") ~= nil
end

local function weaponOf(model)
    local w = model:GetAttribute("Weapon")
    if w then return tostring(w) end
    local slot = model:GetAttribute("CurrentTool")
    if slot then
        local name = model:GetAttribute("Weapon" .. tostring(slot))
        if name then return tostring(name) end
    end
    return nil
end

local function headPart(model)
    return model:FindFirstChild("HeadHB") or model:FindFirstChild("Head")
end

local function bodyPart(model)
    return model:FindFirstChild("UpperTorso") or model:FindFirstChild("HumanoidRootPart")
end

--------------------------------------------------------------------------------
-- the crosshair and the bullet
--------------------------------------------------------------------------------

local function crosshairPos()
    local vp = camera.ViewportSize
    local ok, locked = pcall(function()
        return UserInputService.MouseBehavior == Enum.MouseBehavior.LockCenter
    end)
    if (ok and locked) or STATE.touch then return Vector2.new(vp.X / 2, vp.Y / 2) end
    local ok2, pos = pcall(function() return UserInputService:GetMouseLocation() end)
    if ok2 and pos then return pos end
    return Vector2.new(vp.X / 2, vp.Y / 2)
end

-- Hitscan's own reach: `WSettings.MaxDist or 500`.
local function weaponRange()
    local tool = currentTool()
    local w = tool and tool.WSettings
    return (w and tonumber(w.MaxDist)) or 500
end

-- The bullet's own filter, rebuilt from GExtra.SetUp: IgnoreThese (bodies,
-- effects, the viewmodel), our character, and every mob on our side.
local ignoreList, ignoreAt = {}, 0
local rayParams = RaycastParams.new()
rayParams.FilterType = Enum.RaycastFilterType.Exclude

local function bulletIgnore()
    local now = os.clock()
    if now - ignoreAt < 1 and #ignoreList > 0 then return ignoreList end
    ignoreAt = now
    local list = {}
    local ig = workspace:FindFirstChild("IgnoreThese")
    if ig then list[#list + 1] = ig end
    if plr.Character then list[#list + 1] = plr.Character end
    local mobs = workspace:FindFirstChild("Mobs")
    if mobs then
        for _, m in ipairs(mobs:GetChildren()) do
            if sameTeam(plr, m) then list[#list + 1] = m end
        end
    end
    ignoreList = list
    return list
end

local function castTo(toPos, extra)
    local origin = camera.CFrame.Position
    local dir = toPos - origin
    if dir.Magnitude < 0.05 then return nil end
    local list = bulletIgnore()
    if extra then
        list = table.clone(list)
        list[#list + 1] = extra
    end
    rayParams.FilterDescendantsInstances = list
    return workspace:Raycast(origin, dir, rayParams)
end

-- Clear line to the part: a ray that also ignores the target reaches its end.
local function visibleTo(model, part)
    if not part then return false end
    return castTo(part.Position, model) == nil
end

local function modelFromPart(inst)
    local node = inst
    while node and node ~= workspace do
        if node:IsA("Model") and node:FindFirstChildWhichIsA("Humanoid") then return node end
        node = node.Parent
    end
    return nil
end

-- What the next shot would hit, asked the way Hitscan asks it.
local function underCrosshair()
    local origin = camera.CFrame.Position
    local aimPt
    local U = gameUIMod()
    local orig = U and ((_G.__HYPER_MP or {})[U] or U.GetMousePos)
    if orig then
        local ok, pos = pcall(orig, U)
        if ok and typeof(pos) == "Vector3" then aimPt = pos end
    end
    aimPt = aimPt or (origin + camera.CFrame.LookVector * 1000)
    local dir = aimPt - origin
    if dir.Magnitude < 0.05 then return nil end
    local range = math.min(CONFIG.trigMaxDist, weaponRange())
    rayParams.FilterDescendantsInstances = bulletIgnore()
    local hit = workspace:Raycast(origin, dir.Unit * range, rayParams)
    if not hit or not hit.Instance then return nil end
    local model = modelFromPart(hit.Instance)
    if not model or model == plr.Character then return nil end
    if GS then
        local ok, can = pcall(GS.CanHit, GS, plr, hit.Instance)
        if not ok or not can then return nil end
    elseif not aliveOf(model) then
        return nil
    end
    return model, hit.Instance
end

--------------------------------------------------------------------------------
-- drawing
--------------------------------------------------------------------------------

local FONTS = { UI = 0, System = 1, Plex = 2, Monospace = 3 }
local FONTLIST = { "System", "UI", "Plex", "Monospace" }

local function fontId()
    local id = FONTS[CONFIG.textFont]
    if id == nil then return 1 end
    if Drawing and Drawing.Fonts then
        local named = Drawing.Fonts[CONFIG.textFont]
        if named ~= nil then return named end
    end
    return id
end

local drawn = {}
local pool  = {}

if _G.__HYPER_POOL then
    for _, obj in ipairs(_G.__HYPER_POOL) do pcall(function() obj:Remove() end) end
end
_G.__HYPER_POOL = pool

local function make(kind, props)
    local obj = Drawing.new(kind)
    obj.Visible = false
    for k, v in pairs(props or {}) do obj[k] = v end
    table.insert(pool, obj)
    return obj
end

local BONES = {
    { "Head", "UpperTorso" }, { "UpperTorso", "LowerTorso" },
    { "UpperTorso", "LeftUpperArm" }, { "LeftUpperArm", "LeftLowerArm" },
    { "LeftLowerArm", "LeftHand" },
    { "UpperTorso", "RightUpperArm" }, { "RightUpperArm", "RightLowerArm" },
    { "RightLowerArm", "RightHand" },
    { "LowerTorso", "LeftUpperLeg" }, { "LeftUpperLeg", "LeftLowerLeg" },
    { "LeftLowerLeg", "LeftFoot" },
    { "LowerTorso", "RightUpperLeg" }, { "RightUpperLeg", "RightLowerLeg" },
    { "RightLowerLeg", "RightFoot" },
}

local function objectsFor(model)
    local set = drawn[model]
    if set then return set end
    set = {
        outline = make("Square", { Thickness = 3, Filled = false, ZIndex = 1,
            Color = COLOUR.black, Transparency = 0.6 }),
        box     = make("Square", { Thickness = 1, Filled = false, ZIndex = 2 }),
        fill    = make("Square", { Filled = true, ZIndex = 0, Transparency = 0.18 }),
        hpBg    = make("Square", { Filled = true, ZIndex = 1, Color = COLOUR.black,
            Transparency = 0.6 }),
        hp      = make("Square", { Filled = true, ZIndex = 2 }),
        name    = make("Text", { Size = 13, Center = true, Outline = true,
            Font = 1, Color = COLOUR.text, ZIndex = 3 }),
        info    = make("Text", { Size = 12, Center = true, Outline = true,
            Font = 1, Color = COLOUR.text, ZIndex = 3 }),
        tracer  = make("Line", { Thickness = 1, ZIndex = 1 }),
        head    = make("Circle", { Thickness = 1, Filled = false, NumSides = 14,
            ZIndex = 3 }),
        bones   = {},
    }
    for i = 1, #BONES do
        set.bones[i] = make("Line", { Thickness = 1, ZIndex = 2 })
    end
    drawn[model] = set
    return set
end

local function hideSet(set)
    set.outline.Visible = false
    set.box.Visible     = false
    set.fill.Visible    = false
    set.hpBg.Visible    = false
    set.hp.Visible      = false
    set.name.Visible    = false
    set.info.Visible    = false
    set.tracer.Visible  = false
    set.head.Visible    = false
    for _, line in ipairs(set.bones) do line.Visible = false end
end

local function hideAll()
    for _, set in pairs(drawn) do hideSet(set) end
end

--------------------------------------------------------------------------------
-- chams
--------------------------------------------------------------------------------
--
-- Every character already carries the game's own `PlayerOutline` Highlight. Ours
-- lives under gethui()/CoreGui with an Adornee instead, outside the game tree,
-- and every instance touch is guarded - one throwing Highlight must never take
-- the render pass with it (the Deagle Arena lesson).

local chamsFolder = nil
local chamsBroken = nil

local function chamsAlive()
    local ok, alive = pcall(function()
        return chamsFolder ~= nil and chamsFolder.Parent ~= nil
    end)
    return ok and alive == true
end

local function chamsRoot()
    if chamsAlive() then return chamsFolder end
    if chamsBroken then return nil end
    local roots = {}
    local ok, hidden = pcall(function() return gethui and gethui() or nil end)
    if ok and hidden then roots[#roots + 1] = hidden end
    if CoreGui then roots[#roots + 1] = CoreGui end
    local pg = plr and plr:FindFirstChildOfClass("PlayerGui")
    if pg then roots[#roots + 1] = pg end
    for _, root in ipairs(roots) do
        local made = nil
        pcall(function()
            local previous = root:FindFirstChild("SeluxHyperChams")
            if previous then previous:Destroy() end
            local folder = Instance.new("Folder")
            folder.Name = "SeluxHyperChams"
            folder.Parent = root
            made = folder
        end)
        if made then
            chamsFolder = made
            chamsBroken = nil
            return chamsFolder
        end
    end
    chamsBroken = "no container this executor will accept"
    return nil
end

pcall(chamsRoot)

local highlights = {}

local CHAM_STYLES = {
    ["Fill"]         = { fill = 0.35, out = 0,    depth = "AlwaysOnTop" },
    ["Solid"]        = { fill = 0,    out = 0,    depth = "AlwaysOnTop" },
    ["Outline"]      = { fill = 1,    out = 0,    depth = "AlwaysOnTop" },
    ["Glow"]         = { fill = 0.78, out = 0.15, depth = "AlwaysOnTop", boost = 1.6 },
    ["Ghost"]        = { fill = 0.6,  out = 0.4,  depth = "AlwaysOnTop", boost = 0.55 },
    ["Wall only"]    = { fill = 0.35, out = 0,    depth = "Occluded" },
}
local CHAM_LIST = { "Fill", "Solid", "Outline", "Glow", "Ghost", "Wall only" }

local function chamFor(model)
    local hl = highlights[model]
    if hl then
        local ok, alive = pcall(function() return hl.Parent ~= nil end)
        if ok and alive then return hl end
    end
    if chamsBroken then return nil end
    local folder = chamsRoot()
    if not folder then return nil end
    local made = nil
    local ok, err = pcall(function()
        local h = Instance.new("Highlight")
        h.FillTransparency = 0.35
        h.OutlineTransparency = 0
        h.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
        h.Parent = folder
        made = h
    end)
    if not ok or not made then
        chamsBroken = tostring(err):sub(1, 60)
        note("chams off: " .. tostring(chamsBroken))
        return nil
    end
    highlights[model] = made
    return made
end

local function applyCham(hl, base)
    local style = CHAM_STYLES[CONFIG.chamStyle] or CHAM_STYLES["Fill"]
    local col = base
    if CONFIG.chamRainbow then
        col = Color3.fromHSV((os.clock() * 0.25) % 1, 0.85, 1)
    elseif CONFIG.colChamOwn then
        col = CONFIG.colCham
    end
    if style.boost then
        local h, s, v = Color3.toHSV(col)
        col = Color3.fromHSV(h, math.clamp(s * (style.boost > 1 and 0.75 or 1), 0, 1),
            math.clamp(v * style.boost, 0, 1))
    end
    hl.FillTransparency = style.fill
    hl.OutlineTransparency = style.out
    hl.DepthMode = Enum.HighlightDepthMode[style.depth]
    hl.FillColor = col
    hl.OutlineColor = col
    hl.Enabled = true
end

local function chamOff(model)
    local hl = highlights[model]
    if hl then pcall(function() hl.Enabled = false hl.Adornee = nil end) end
end

local function clearChams()
    for model in pairs(highlights) do chamOff(model) end
end

--------------------------------------------------------------------------------
-- static overlays
--------------------------------------------------------------------------------

local fovCircle = make("Circle", { Thickness = 1, NumSides = 48, Filled = false,
    Transparency = 0.5, ZIndex = 1 })
local silentCircle = make("Circle", { Thickness = 1, NumSides = 48, Filled = false,
    Transparency = 0.55, ZIndex = 1 })

-- Forward-declared: the silent aim state is defined further down, and a local is
-- invisible above its own definition. The silent section fills this in.
local SIL_POINT = function() return nil end

-- Everything the second feature round added lives in THIS one table, filled in
-- by a single do-block further down. Luau allows 200 locals per function and the
-- main chunk of this file is close to it; a table costs one register however
-- many features it carries.
local EXTRA = {}

local silentLineObj = make("Line", { Thickness = 1.5, ZIndex = 4, Transparency = 0.9 })
local silentDot = make("Circle", { Thickness = 1.5, NumSides = 16, Filled = false,
    Radius = 6, ZIndex = 4 })

local crossLines = {}
for i = 1, 4 do crossLines[i] = make("Line", { Thickness = 1, ZIndex = 4 }) end
local crossDot = make("Circle", { Filled = true, NumSides = 8, Radius = 1, ZIndex = 4 })

local function drawCrosshair(mid)
    local on = CONFIG.crosshair
    for i = 1, 4 do crossLines[i].Visible = on end
    crossDot.Visible = on and CONFIG.crossDot
    if not on then return end
    local g, s, t = CONFIG.crossGap, CONFIG.crossSize, CONFIG.crossThick
    local dirs = {
        { Vector2.new(0, -g), Vector2.new(0, -g - s) },
        { Vector2.new(0,  g), Vector2.new(0,  g + s) },
        { Vector2.new(-g, 0), Vector2.new(-g - s, 0) },
        { Vector2.new( g, 0), Vector2.new( g + s, 0) },
    }
    for i = 1, 4 do
        local line = crossLines[i]
        line.From = mid + dirs[i][1]
        line.To   = mid + dirs[i][2]
        line.Thickness = t
        line.Color = CONFIG.colCross
    end
    if crossDot.Visible then
        crossDot.Position = mid
        crossDot.Radius = math.max(1, t)
        crossDot.Color = CONFIG.colCross
    end
end

--------------------------------------------------------------------------------
-- the render pass
--------------------------------------------------------------------------------

local function renderPass()
    if _G.__HYPER ~= GEN then return end
    local mid = crosshairPos()

    fovCircle.Visible = CONFIG.aim and CONFIG.aimCircle
    if fovCircle.Visible then
        fovCircle.Position = mid
        fovCircle.Radius = CONFIG.aimFov
        fovCircle.Color = CONFIG.colFov
    end
    -- Where the next shot will go. Without it a target just outside the circle
    -- and a broken silent aim look exactly the same.
    local sp = nil
    if STATE.silentOn and CONFIG.silentLine then sp = SIL_POINT() end
    local spv = nil
    if sp then spv = camera:WorldToViewportPoint(sp) end
    local showLine = spv ~= nil and spv.Z > 0
    silentLineObj.Visible = showLine
    silentDot.Visible = showLine
    if showLine then
        local p2 = Vector2.new(spv.X, spv.Y)
        silentLineObj.From = mid
        silentLineObj.To = p2
        silentLineObj.Color = CONFIG.colSilent
        silentDot.Position = p2
        silentDot.Color = CONFIG.colSilent
    end

    silentCircle.Visible = CONFIG.silent and CONFIG.silentCircle
        and CONFIG.silentMode ~= "Whole screen"
    if silentCircle.Visible then
        silentCircle.Position = mid
        silentCircle.Radius = CONFIG.silentFov
        silentCircle.Color = CONFIG.colSilent
    end
    drawCrosshair(mid)
    if EXTRA.render then
        local ok, err = pcall(EXTRA.render, mid)
        if not ok then note("world esp: " .. tostring(err)) end
    end

    if not anyDrawing() then
        hideAll()
        clearChams()
        STATE.targets, STATE.bots, STATE.humans = 0, 0, 0
        return
    end

    local vp = camera.ViewportSize
    local camPos = camera.CFrame.Position
    local count, bots, humans = 0, 0, 0
    local face = fontId()
    local seenModels = {}

    for _, entry in ipairs(combatants()) do
        local model = entry.model
        seenModels[model] = true
        local set = objectsFor(model)
        local hp, maxHp, root = aliveOf(model)
        local wanted = root and (not entry.team or CONFIG.showTeam)

        if not wanted then
            hideSet(set)
            chamOff(model)
        else
            local dist = (camPos - root.Position).Magnitude
            if dist > CONFIG.maxDist then
                hideSet(set)
                chamOff(model)
            else
                local prot = protectedOf(model)
                local seen = true
                if CONFIG.visCheck and not entry.team then
                    seen = visibleTo(model, headPart(model)) or visibleTo(model, bodyPart(model))
                end
                local base
                if entry.team then base = CONFIG.colTeam
                elseif entry.bot or entry.mob then base = CONFIG.colBot
                else base = CONFIG.colEnemy end
                if prot and CONFIG.protTag and not entry.team then base = CONFIG.colProt end
                local col = seen and base or dimmed(base)

                -- A Highlight is 3D and works off-screen and through walls, so it is
                -- applied before the on-screen gate (the mvsd lesson).
                if CONFIG.chams and not chamsBroken then
                    local hl = chamFor(model)
                    if hl then
                        pcall(function()
                            hl.Adornee = model
                            applyCham(hl, base)
                        end)
                    end
                else
                    chamOff(model)
                end

                local head = model:FindFirstChild("Head")
                local lf = model:FindFirstChild("LeftFoot")
                local rf = model:FindFirstChild("RightFoot")
                local topPos = head
                    and (head.Position + Vector3.new(0, head.Size.Y / 2 + 0.35, 0))
                    or (root.Position + Vector3.new(0, 3, 0))
                local low = lf
                if lf and rf then low = (lf.Position.Y <= rf.Position.Y) and lf or rf
                elseif rf then low = rf end
                local botPos = low
                    and (low.Position - Vector3.new(0, low.Size.Y / 2, 0))
                    or (root.Position - Vector3.new(0, 3, 0))

                local sTop = camera:WorldToViewportPoint(topPos)
                local sBot = camera:WorldToViewportPoint(botPos)
                local behind = sTop.Z <= 0 or sBot.Z <= 0
                local h = math.max(math.abs(sBot.Y - sTop.Y), 4)
                local w = h * 0.52
                local cx = (sTop.X + sBot.X) / 2
                local minX, minY = cx - w / 2, math.min(sTop.Y, sBot.Y)
                local maxX, maxY = minX + w, minY + h
                local onScreen = not behind
                    and maxX > 0 and minX < vp.X and maxY > 0 and minY < vp.Y

                if not onScreen then
                    hideSet(set)
                else
                    count = count + 1
                    if entry.bot or entry.mob then bots = bots + 1 else humans = humans + 1 end
                    local pos = Vector2.new(minX, minY)
                    local siz = Vector2.new(w, h)

                    set.box.Visible = CONFIG.box
                    set.outline.Visible = CONFIG.box
                    if CONFIG.box then
                        set.box.Position = pos      set.box.Size = siz
                        set.box.Color = col
                        set.outline.Position = pos  set.outline.Size = siz
                    end
                    set.fill.Visible = CONFIG.box and CONFIG.boxFilled
                    if set.fill.Visible then
                        set.fill.Position = pos  set.fill.Size = siz
                        set.fill.Color = col
                    end

                    set.hpBg.Visible = CONFIG.health
                    set.hp.Visible   = CONFIG.health
                    if CONFIG.health then
                        local frac = math.clamp(hp / math.max(maxHp, 1), 0, 1)
                        set.hpBg.Position = Vector2.new(minX - 6, minY)
                        set.hpBg.Size     = Vector2.new(3, h)
                        set.hp.Position   = Vector2.new(minX - 6, minY + h * (1 - frac))
                        set.hp.Size       = Vector2.new(3, h * frac)
                        set.hp.Color      = COLOUR.hpBad:Lerp(COLOUR.hpGood, frac)
                    end

                    local ts = CONFIG.textSize
                    if CONFIG.textShrink then
                        ts = math.clamp(h * 0.22, math.max(12, CONFIG.textSize - 2),
                            CONFIG.textSize)
                    end
                    ts = math.floor(ts + 0.5)

                    set.name.Visible = CONFIG.name
                    if CONFIG.name then
                        local label = entry.name
                        if CONFIG.botTag then
                            local tag = entry.mob and "[MOB] " or (entry.bot and "[BOT] " or "[P] ")
                            label = tag .. label
                        end
                        set.name.Size = ts
                        set.name.Font = face
                        set.name.Outline = CONFIG.textOutline
                        set.name.Position = Vector2.new(minX + w / 2, minY - (ts + 3))
                        set.name.Text = label
                        set.name.Color = col
                    end

                    local bits = {}
                    if CONFIG.weaponTag then
                        local wpn = weaponOf(model)
                        if wpn then bits[#bits + 1] = wpn end
                    end
                    if CONFIG.health then bits[#bits + 1] = string.format("%d", math.floor(hp)) end
                    if CONFIG.distance then bits[#bits + 1] = string.format("%dm", math.floor(dist)) end
                    if CONFIG.protTag and prot then bits[#bits + 1] = "PROT" end
                    if model:GetAttribute("HasHelmet") then bits[#bits + 1] = "HELM" end
                    if model:GetAttribute("Shield") then bits[#bits + 1] = "SHIELD" end
                    set.info.Visible = #bits > 0
                    if set.info.Visible then
                        set.info.Size = math.max(12, ts - 1)
                        set.info.Font = face
                        set.info.Outline = CONFIG.textOutline
                        set.info.Position = Vector2.new(minX + w / 2, maxY + 2)
                        set.info.Text = table.concat(bits, "  ")
                        set.info.Color = col
                    end

                    set.tracer.Visible = CONFIG.tracer
                    if CONFIG.tracer then
                        set.tracer.From = Vector2.new(vp.X / 2, vp.Y)
                        set.tracer.To   = Vector2.new(minX + w / 2, maxY)
                        set.tracer.Color = col
                    end

                    set.head.Visible = CONFIG.headDot and head ~= nil
                    if set.head.Visible then
                        local sp = camera:WorldToViewportPoint(head.Position)
                        set.head.Position = Vector2.new(sp.X, sp.Y)
                        set.head.Radius = math.max(1.5, h * 0.075)
                        set.head.Color = col
                    end

                    if CONFIG.skeleton then
                        for i, bone in ipairs(BONES) do
                            local a = model:FindFirstChild(bone[1])
                            local b = model:FindFirstChild(bone[2])
                            local line = set.bones[i]
                            if a and b then
                                local pa = camera:WorldToViewportPoint(a.Position)
                                local pb = camera:WorldToViewportPoint(b.Position)
                                if pa.Z > 0 and pb.Z > 0 then
                                    line.Visible = true
                                    line.From = Vector2.new(pa.X, pa.Y)
                                    line.To   = Vector2.new(pb.X, pb.Y)
                                    line.Color = col
                                else
                                    line.Visible = false
                                end
                            else
                                line.Visible = false
                            end
                        end
                    else
                        for _, line in ipairs(set.bones) do line.Visible = false end
                    end
                end
            end
        end
    end

    for model, set in pairs(drawn) do
        if not seenModels[model] or not model.Parent then
            hideSet(set)
            if not model.Parent then
                local hl = highlights[model]
                if hl then pcall(function() hl:Destroy() end) highlights[model] = nil end
                drawn[model] = nil
            end
        end
    end

    STATE.targets, STATE.bots, STATE.humans = count, bots, humans
end

--------------------------------------------------------------------------------
-- key binding
--------------------------------------------------------------------------------

local function keyDisplay(name)
    local n = tostring(name)
    local side = n:match("^MouseButton(%d)$")
    if side then return "MOUSE " .. side end
    return string.upper(n)
end

local keyCache = {}

local function resolveKey(name)
    local hit = keyCache[name]
    if hit ~= nil then return hit end
    local entry = false
    if name:sub(1, 11) == "MouseButton" then
        local ok, value = pcall(function() return Enum.UserInputType[name] end)
        if ok and value then entry = { mouse = value } end
    else
        local ok, value = pcall(function() return Enum.KeyCode[name] end)
        if ok and value then entry = { key = value } end
    end
    keyCache[name] = entry
    return entry
end

local function keyHeld(name)
    if not name or name == "" then return false end
    local spec = resolveKey(name)
    if not spec then return false end
    if spec.mouse then return UserInputService:IsMouseButtonPressed(spec.mouse) end
    return UserInputService:IsKeyDown(spec.key)
end

local capturing = nil
local armedGuard = false

local function arm(fn)
    capturing = fn
    armedGuard = true
    task.spawn(function()
        while UserInputService:IsMouseButtonPressed(Enum.UserInputType.MouseButton1) do
            task.wait()
        end
        task.wait(0.06)
        armedGuard = false
    end)
end

local function capture(name)
    local fn = capturing
    if not fn then return end
    capturing = nil
    armedGuard = false
    STATE.lastKey = tostring(name)
    fn(name)
end

UserInputService.InputBegan:Connect(function(input)
    if _G.__HYPER ~= GEN or not capturing or armedGuard then return end
    if input.UserInputType ~= Enum.UserInputType.Keyboard then return end
    if input.KeyCode == Enum.KeyCode.Escape then capture(nil) return end
    if input.KeyCode == Enum.KeyCode.Unknown then return end
    capture(input.KeyCode.Name)
end)

UserInputService.InputEnded:Connect(function(input)
    if _G.__HYPER ~= GEN or not capturing or armedGuard then return end
    local name = input.UserInputType.Name
    if name:sub(1, 11) ~= "MouseButton" then return end
    capture(name)
end)

--------------------------------------------------------------------------------
-- a client with no mouse and no keyboard
--------------------------------------------------------------------------------
--
-- Hypershot is played on phones (the `IsPhone` attribute is on everybody). A
-- hotkey a phone cannot press falls back to holding the screen, so a saved
-- desktop config comes back working. Firing needs no executor click function at
-- all here - it goes through the game's own click path - so the trigger works
-- on a phone as it is.

local TOUCH = false
pcall(function()
    TOUCH = UserInputService.TouchEnabled
        and not UserInputService.MouseEnabled
        and not UserInputService.KeyboardEnabled
end)
if _G.__HYPER_FORCE_TOUCH then TOUCH = true end
STATE.touch = TOUCH

local touches = setmetatable({}, { __mode = "k" })

local function screenHeld()
    local n = 0
    for input in pairs(touches) do
        local ok, state = pcall(function() return input.UserInputState end)
        if ok and state ~= Enum.UserInputState.End
            and state ~= Enum.UserInputState.Cancel then
            n = n + 1
        else
            touches[input] = nil
        end
    end
    return n > 0
end

UserInputService.InputBegan:Connect(function(input)
    if _G.__HYPER ~= GEN then return end
    if input.UserInputType == Enum.UserInputType.Touch then touches[input] = true end
end)

UserInputService.InputEnded:Connect(function(input)
    if _G.__HYPER ~= GEN then return end
    if input.UserInputType == Enum.UserInputType.Touch then touches[input] = nil end
end)

local function reachable(name)
    if not name or name == "" then return false end
    local spec = resolveKey(name)
    if not spec then return false end
    local ok, enabled = pcall(function()
        if spec.mouse then return UserInputService.MouseEnabled end
        return UserInputService.KeyboardEnabled
    end)
    return ok and enabled and true or false
end

local function hotkeyHeld(name)
    if TOUCH and not reachable(name) then return screenHeld() end
    return keyHeld(name)
end

-- "Is the player shooting" is the game's own flag, so it is right for a mouse,
-- a phone and a controller alike.
local function firing()
    local c = ctl()
    return c ~= nil and c.Shared.MouseDown == true
end

local panicHandlers = {}

UserInputService.InputBegan:Connect(function(input, processed)
    if _G.__HYPER ~= GEN or processed or capturing then return end
    if input.UserInputType ~= Enum.UserInputType.Keyboard then return end
    local spec = resolveKey(CONFIG.panicKey)
    if not spec or not spec.key or input.KeyCode ~= spec.key then return end
    if EXTRA.panic then EXTRA.panic("panic key") return end
    CONFIG.aim, CONFIG.trig, CONFIG.aimFire, CONFIG.silent = false, false, false, false
    CONFIG.rapid, CONFIG.fly, CONFIG.speed = false, false, false
    for _, fn in ipairs(panicHandlers) do pcall(fn) end
    note("PANIC - aim, trigger, silent aim, rapid fire, fly and speed off")
end)

--------------------------------------------------------------------------------
-- the humaniser
--------------------------------------------------------------------------------

local PAUSE = { reason = "", until_ = 0 }

local function pauseFor(ms, reason)
    local until_ = os.clock() + ms / 1000
    if until_ > PAUSE.until_ then
        PAUSE.until_ = until_
        PAUSE.reason = reason
    end
end

local function humanPaused()
    if PAUSE.until_ > os.clock() then return PAUSE.reason end
    return nil
end

local function gauss(mean, sd)
    local u1 = math.random()
    local u2 = math.random()
    if u1 < 1e-9 then u1 = 1e-9 end
    return mean + math.sqrt(-2 * math.log(u1)) * math.cos(2 * math.pi * u2) * sd
end

local engagement = nil

local function newEngagement(model, name)
    local head = true
    if CONFIG.hum then head = math.random(100) <= CONFIG.humHeadPct end
    engagement = {
        model    = model,
        name     = name,
        t0       = os.clock(),
        seed     = math.random() * 1000,
        ox       = (math.random() - 0.5) * 2,
        oy       = (math.random() - 0.5) * 2,
        oz       = (math.random() - 0.5) * 2,
        windup   = CONFIG.hum
            and math.random(math.min(CONFIG.humWindupMin, CONFIG.humWindupMax),
                math.max(CONFIG.humWindupMin, CONFIG.humWindupMax)) / 1000
            or 0,
        head     = head,
        over     = CONFIG.hum and (math.random(100) <= CONFIG.humOvershoot),
        breakTil = 0,
        lockUntil = os.clock() + CONFIG.humSwitchMs / 1000,
        rerollAt  = os.clock() + CONFIG.humRerollMs / 1000,
    }
    return engagement
end

local function rerollOffset()
    if not engagement then return end
    if not CONFIG.hum or CONFIG.humRerollMs <= 0 then return end
    if os.clock() < engagement.rerollAt then return end
    engagement.ox = (math.random() - 0.5) * 2
    engagement.oy = (math.random() - 0.5) * 2
    engagement.oz = (math.random() - 0.5) * 2
    engagement.rerollAt = os.clock() + CONFIG.humRerollMs / 1000
end

local function endEngagement()
    if engagement and CONFIG.hum and CONFIG.humCooldown > 0 then
        pauseFor(CONFIG.humCooldown, "cooldown")
    end
    engagement = nil
end

local function humanAimPoint(part, dist)
    local pos = part.Position
    if not CONFIG.hum or not engagement then return pos end
    local size = part.Size
    local k = CONFIG.humOffsetPct / 100 * 0.5
    pos = pos + Vector3.new(engagement.ox * size.X * k,
        engagement.oy * size.Y * k,
        engagement.oz * size.Z * k)
    if CONFIG.humJitter > 0 then
        local t = os.clock() * CONFIG.humJitterHz
        local s = engagement.seed
        local amp = CONFIG.humJitter * math.clamp(dist / 100, 0.25, 4)
        pos = pos + Vector3.new(
            math.noise(t, s) * amp,
            math.noise(t, s + 17.3) * amp * 0.6,
            math.noise(t, s + 41.7) * amp)
    end
    return pos
end

local function panelOpen()
    local win = _G.__HYPER_WIN
    local root = win and win.root
    if not root or not root.Parent then return false end
    local ok, vis = pcall(function() return root.Visible end)
    return ok and vis == true
end

-- `SpectatorCount` is on every player and counts who is watching them. Late in a
-- round everybody alive is watched, so this is a switch, not a default.
local function spectated()
    return (tonumber(plr:GetAttribute("SpectatorCount")) or 0) > 0
end

local function assistBlocked()
    local why = humanPaused()
    if why then return why end
    if CONFIG.hum and CONFIG.humPanelPause and panelOpen() then return "panel open" end
    if CONFIG.specPause and spectated() then return "spectated" end
    return nil
end

--------------------------------------------------------------------------------
-- aim assist
--------------------------------------------------------------------------------

local lastKillAt = 0
local stickyModel = nil

local function aimActive()
    if not CONFIG.aim then return false end
    if CONFIG.aimActive == "Always" then return true end
    if CONFIG.aimActive == "Screen held" then return screenHeld() end
    if CONFIG.aimActive == "While firing" then return firing() end
    return hotkeyHeld(CONFIG.aimKey)
end

local function adsGate(mode)
    if mode == "Always" then return true end
    local c = ctl()
    local on = c ~= nil and c.Shared.Scoping == true
    if mode == "Scoped only" then return on end
    return not on
end

-- Knives, projectile launchers and an empty or reloading gun: nothing to assist.
local function gunReady()
    local tool, c = currentTool()
    if not tool or not tool.WSettings then return false, "no gun" end
    local w = tool.WSettings
    if w.IsMelee then return false, "melee in hand" end
    if c.Shared.Reloading then return false, "reloading" end
    if (tonumber(tool.Ammo) or 0) <= 0 then return false, "empty" end
    if c.Shared.Dead then return false, "dead" end
    return true
end

local function movingFrac()
    local char = plr.Character
    local root = char and char:FindFirstChild("HumanoidRootPart")
    if not root then return 0 end
    local v = root.AssemblyLinearVelocity
    local speed = Vector3.new(v.X, 0, v.Z).Magnitude
    local hum = char:FindFirstChildWhichIsA("Humanoid")
    local maxSpeed = (hum and hum.WalkSpeed) or 16
    return math.clamp(speed / math.max(maxSpeed, 1), 0, 1)
end

local function targetPart(model, want)
    want = want or CONFIG.aimPart
    if want == "Head" then return headPart(model) or bodyPart(model) end
    if want == "Nearest" then
        local mid = crosshairPos()
        local best, bestD
        for _, part in ipairs({ headPart(model), bodyPart(model) }) do
            local sp = camera:WorldToViewportPoint(part.Position)
            if sp.Z > 0 then
                local d = (Vector2.new(sp.X, sp.Y) - mid).Magnitude
                if not bestD or d < bestD then best, bestD = part, d end
            end
        end
        return best or bodyPart(model)
    end
    return bodyPart(model)
end

local function eligible(entry)
    if entry.team then return false end
    if CONFIG.humBotOnly and not (entry.bot or entry.mob) then return false end
    return true
end

-- One candidate walk for the aim and the silent aim, which differ only in their
-- window, their part and their range.
local function bestTarget(fov, part, maxDist, needVisible, skipProt, pickBy)
    local mid = crosshairPos()
    local camPos = camera.CFrame.Position
    local range = math.min(maxDist, weaponRange())
    local best, bestScore
    for _, entry in ipairs(combatants()) do
        if eligible(entry) then
            local hp, _, root = aliveOf(entry.model)
            if hp and not (skipProt and protectedOf(entry.model)) then
                local p = targetPart(entry.model, part)
                local dist = (camPos - root.Position).Magnitude
                if p and dist <= range then
                    local sp = camera:WorldToViewportPoint(p.Position)
                    if sp.Z > 0 then
                        local px = (Vector2.new(sp.X, sp.Y) - mid).Magnitude
                        if px <= fov and ((not needVisible) or visibleTo(entry.model, p)) then
                            local score
                            if pickBy == "Closest" then score = dist
                            elseif pickBy == "Lowest HP" then score = hp
                            else score = px end
                            if not bestScore or score < bestScore then
                                best = { entry = entry, part = p, px = px }
                                bestScore = score
                            end
                        end
                    end
                end
            end
        end
    end
    return best
end

local function pickTarget()
    local fov = CONFIG.aimFov
    if CONFIG.hum and CONFIG.humMoveFov < 100 then
        fov = fov * (1 - movingFrac() * (1 - CONFIG.humMoveFov / 100))
    end
    return bestTarget(fov, CONFIG.aimPart, CONFIG.aimMaxDist, CONFIG.aimVisible,
        CONFIG.aimSkipProt, CONFIG.aimPick)
end

local function approach(smooth, dt)
    local base = 1 / math.max(1, smooth)
    return 1 - (1 - base) ^ math.max(dt * 60, 0.0001)
end

local function angleDelta(a, b)
    local d = (b - a) % (math.pi * 2)
    if d > math.pi then d = d - math.pi * 2 end
    return d
end

local function curveFactor(progress)
    if CONFIG.aimCurve == "Linear" then return 1 end
    if CONFIG.aimCurve == "Human" then
        local x = math.clamp(1 - progress, 0, 1)
        return 0.35 + 1.3 * math.sin(x * math.pi)
    end
    return 1
end

-- The view the game keeps, in the game's own convention (CameraController.AA):
-- yaw = atan2(dx, dz) + pi, pitch = atan2(dy, horizontal) minus the recoil
-- spring's current pitch, because the spring is added on top of these angles.
local function wantAngles(from, to, A)
    local v = to - from
    local yaw = math.atan2(v.X, v.Z) + math.pi
    local pitch = math.atan2(v.Y, Vector3.new(v.X, 0, v.Z).Magnitude)
    local ok, spring = pcall(function() return A:GetCamRecoilSpring() end)
    if ok and spring then pitch = pitch - spring.Position.Y end
    return yaw, math.clamp(pitch, -1.55, 1.55)
end

local mouseMove = execFn("mousemoverel")

local function moveView(A, curYaw, curPitch, stepYaw, stepPitch)
    -- A phone has no mouse: mousemoverel there moves a cursor nobody sees, so the
    -- view "follows the mouse" instead of the target (reported 2026-10-03 from a
    -- Delta phone). Touch clients always take the game-camera path.
    if CONFIG.aimPath == "Mouse" and mouseMove and not TOUCH then
        local c = ctl()
        local sens = c and tonumber(c.Shared.CurrSens) or 0
        if sens > 0 then
            -- UpdateCamRot(dx*sens, dy*sens) SUBTRACTS both, so a positive x turns
            -- yaw down and a positive y lowers the pitch.
            local dx = -stepYaw / sens
            local dy = -stepPitch / sens
            local settings = c.Shared.MenuCoreData and c.Shared.MenuCoreData.Settings
            if settings and settings["Invert Camera X"] then dx = -dx end
            if settings and settings["Invert Camera Y"] then dy = -dy end
            if math.abs(dx) < 1 and math.abs(dy) < 1 then return end
            pcall(mouseMove, math.floor(dx + 0.5), math.floor(dy + 0.5))
            return
        end
    end
    pcall(function()
        A:UpdateCamRot(Vector2.new(curYaw + stepYaw, curPitch + stepPitch), 0, 0)
    end)
end

local function aimPass(dt)
    if _G.__HYPER ~= GEN then return end
    STATE.aimDps = 0

    local blocked = assistBlocked()
    STATE.paused = blocked or ""
    if blocked then
        STATE.target, STATE.targetKind = "-", "-"
        stickyModel = nil
        endEngagement()
        return
    end
    if not aimActive() then
        STATE.target, STATE.targetKind = "-", "-"
        stickyModel = nil
        if engagement then endEngagement() end
        return
    end
    local c = ctl()
    local A = actionHandler()
    if not c or not A then
        STATE.paused = "not deployed"
        STATE.target = "-"
        stickyModel = nil
        return
    end
    if CONFIG.aimReady then
        local ok, why = gunReady()
        if not ok then STATE.paused = why return end
    end
    if not adsGate(CONFIG.aimAds) then
        STATE.paused = "scope condition"
        STATE.target = "-"
        stickyModel = nil
        if engagement then endEngagement() end
        return
    end
    if os.clock() * 1000 - lastKillAt < CONFIG.aimKillMs then
        STATE.paused = "after kill"
        STATE.target = "-"
        return
    end

    local pick
    if CONFIG.aimSticky and stickyModel then
        local hp = aliveOf(stickyModel)
        if hp and not (CONFIG.aimSkipProt and protectedOf(stickyModel)) then
            local part = targetPart(stickyModel)
            if part then
                local sp = camera:WorldToViewportPoint(part.Position)
                local px = (Vector2.new(sp.X, sp.Y) - crosshairPos()).Magnitude
                if sp.Z > 0 and px <= CONFIG.aimFov * 1.35
                    and ((not CONFIG.aimVisible) or visibleTo(stickyModel, part)) then
                    pick = { entry = { model = stickyModel, name = stickyModel.Name,
                        bot = stickyModel:GetAttribute("Bot") == true }, part = part, px = px }
                end
            end
        end
    end
    pick = pick or pickTarget()

    if not pick or not pick.part or not pick.part.Parent then
        STATE.target, STATE.targetKind = "-", "-"
        stickyModel = nil
        if engagement then endEngagement() end
        return
    end

    if engagement and engagement.model ~= pick.entry.model and CONFIG.hum
        and os.clock() < engagement.lockUntil and aliveOf(engagement.model) then
        local heldPart = targetPart(engagement.model)
        if heldPart then
            pick = { entry = { model = engagement.model, name = engagement.name,
                bot = engagement.model:GetAttribute("Bot") == true }, part = heldPart, px = pick.px }
        end
    end

    if not engagement or engagement.model ~= pick.entry.model then
        newEngagement(pick.entry.model, pick.entry.name)
    end
    rerollOffset()
    stickyModel = pick.entry.model
    STATE.target = pick.entry.name
    STATE.targetKind = pick.entry.bot and "bot" or "player"

    local now = os.clock()
    if now - engagement.t0 < engagement.windup then
        STATE.paused = "wind-up"
        return
    end
    if CONFIG.hum and CONFIG.humBreakPct > 0 then
        if now < engagement.breakTil then STATE.paused = "break-off" return end
        if math.random() < (CONFIG.humBreakPct / 100) * dt then
            engagement.breakTil = now + CONFIG.humBreakMs / 1000
            return
        end
    end
    if CONFIG.hum and CONFIG.humDeadzone > 0 and pick.px <= CONFIG.humDeadzone then
        STATE.paused = "deadzone"
        return
    end

    local smoothH, smoothV = CONFIG.aimSmoothH, CONFIG.aimSmoothV
    if CONFIG.hum and CONFIG.humFatigue > 0 then
        local held = math.max(0, now - engagement.t0 - 1)
        local mult = 1 + held * (CONFIG.humFatigue / 100)
        smoothH, smoothV = smoothH * mult, smoothV * mult
    end

    local cf = camera.CFrame
    local pos = cf.Position
    local part = pick.part
    -- The humaniser's head share: an engagement goes for the head only some of
    -- the time, so the headshot count is not a flat hundred (or a flat zero).
    if CONFIG.hum and CONFIG.aimPart ~= "Nearest" then
        part = engagement.head and (headPart(pick.entry.model) or part)
            or (bodyPart(pick.entry.model) or part)
    end
    local dist = (pos - part.Position).Magnitude
    local aimAt = humanAimPoint(part, dist)
    if EXTRA.lead then aimAt = EXTRA.lead(pick.entry.model, aimAt) end
    if CONFIG.hum and engagement.over
        and (now - engagement.t0) < engagement.windup + 0.09 then
        local side = (engagement.ox >= 0) and 1 or -1
        aimAt = aimAt + cf.RightVector * side * math.rad(CONFIG.humOverDeg) * dist
    end

    local ok, rot = pcall(function() return A:GetCamRot() end)
    if not ok or typeof(rot) ~= "Vector2" then STATE.paused = "no camera angles" return end
    local curYaw, curPitch = rot.X, rot.Y
    local wantYaw, wantPitch = wantAngles(pos, aimAt, A)
    local dYaw = angleDelta(curYaw, wantYaw)
    local dPitch = wantPitch - curPitch

    local progress = math.clamp(math.max(math.abs(dYaw), math.abs(dPitch)) / 0.5, 0, 1)
    local shape = curveFactor(progress)
    local stepYaw   = dYaw   * math.clamp(approach(smoothH, dt) * shape, 0, 1)
    local stepPitch = dPitch * math.clamp(approach(smoothV, dt) * shape, 0, 1)

    if CONFIG.hum and CONFIG.humTurnCap > 0 then
        local mag = math.sqrt(stepYaw * stepYaw + stepPitch * stepPitch)
        local cap = math.rad(CONFIG.humTurnCap) * math.max(dt, 1e-4)
        if mag > cap and mag > 0 then
            local k = cap / mag
            stepYaw, stepPitch = stepYaw * k, stepPitch * k
        end
    end

    local applied = math.deg(math.sqrt(stepYaw * stepYaw + stepPitch * stepPitch))
    STATE.aimDps = applied / math.max(dt, 1e-4)
    if STATE.aimDps > STATE.aimDpsPeak then STATE.aimDpsPeak = STATE.aimDps end

    moveView(A, curYaw, curPitch, stepYaw, stepPitch)
end

--------------------------------------------------------------------------------
-- silent aim - bend the shot, never claim it
--------------------------------------------------------------------------------
--
-- Gun.Shoot asks `GameUIMod:GetMousePos()` where the crosshair points and
-- raycasts there from the camera. While armed, that one call - and only when
-- Shoot is the caller - answers the target's position instead. The game then
-- does its own ray, its own hit and its own two packets; nothing is forged. The
-- ray still has to reach the target, so a wall stops a bent shot exactly like a
-- straight one.
--
-- It is a plain table field, not a hook, and it is only in place while the key
-- is held: armed off means the game's own function is back. The original is kept
-- in _G per GameUIMod table, so a re-execute restores the real one instead of
-- mistaking the previous run's replacement for it.

local MP = _G.__HYPER_MP or setmetatable({}, { __mode = "k" })
_G.__HYPER_MP = MP
for U, orig in pairs(MP) do
    pcall(function() U.GetMousePos = orig end)
    MP[U] = nil
end

local SIL = { point = nil, installedOn = nil }
SIL_POINT = function() return SIL.point end

local function silentUninstall()
    for U, orig in pairs(MP) do
        pcall(function() U.GetMousePos = orig end)
        MP[U] = nil
    end
    SIL.installedOn = nil
end

local function silentInstall()
    local U = gameUIMod()
    if not U or type(U.GetMousePos) ~= "function" then return false end
    if MP[U] then return true end
    local c = ctl()
    if not (c and c.Gun and type(c.Gun.Shoot) == "function") then return false end
    local orig = U.GetMousePos
    MP[U] = orig
    U.GetMousePos = function(...)
        local pt = SIL.point
        -- Gun.Shoot is looked up LIVE: a respawn rebuilds the controller and with
        -- it the Shoot function, and a captured one would never match again.
        local gun = CTL.Gun
        if pt and gun then
            -- The caller is searched a few levels up, NOT read at level 2. When the
            -- GAME's own thread (the mouse handler) calls an executor closure,
            -- Potassium puts a C frame in between, so level 2 reads "[C]" and Shoot
            -- sits one level higher. A shot fired from the script's own thread has
            -- no such frame. Measured: 70 real mouse shots, 0 bent, while every
            -- script-fired shot bent - the whole "silent aim does nothing" report.
            local shoot = gun.Shoot
            for level = 2, 5 do
                local f = debug.info(level, "f")
                if f == nil then break end
                if f == shoot then
                    -- Hit chance below 100 lets that one shot go where you aim.
                    if CONFIG.silentHitPct < 100 and math.random(100) > CONFIG.silentHitPct then
                        break
                    end
                    STATE.silentBent = STATE.silentBent + 1
                    return pt
                end
            end
        end
        return orig(...)
    end
    SIL.installedOn = U
    return true
end

-- Would a bullet aimed at `pos` land on `model`? Asked with the bullet's OWN
-- filter, target included - which is the whole point: hats and accessories are
-- not in the game's ignore list, Hitscan stops on them, CanHit answers no (an
-- Accessory has no Humanoid) and the shot is spent. That is what made a
-- head-aimed silent shot look like it "sometimes does nothing".
local function shotLands(model, pos)
    local origin = camera.CFrame.Position
    local dir = pos - origin
    if dir.Magnitude < 0.05 then return false end
    rayParams.FilterDescendantsInstances = bulletIgnore()
    local hit = workspace:Raycast(origin, dir.Unit * (dir.Magnitude + 2), rayParams)
    if not hit or modelFromPart(hit.Instance) ~= model then return false end
    if GS then
        local ok, can = pcall(GS.CanHit, GS, plr, hit.Instance)
        return ok and can == true, hit.Instance.Name
    end
    return true, hit.Instance.Name
end

-- The first point on the wanted part that a bullet really reaches, then the
-- rest of the body. A face-height point under the hat brim first, because the
-- centre of the head is exactly where a hat sits.
local function landingPoint(model, want)
    local head = model:FindFirstChild("Head")
    local body = model:FindFirstChild("UpperTorso")
    local root = model:FindFirstChild("HumanoidRootPart")
    local low  = model:FindFirstChild("LowerTorso")
    local points = {}
    local function add(part, offsetY)
        if part then points[#points + 1] = part.Position + Vector3.new(0, offsetY or 0, 0) end
    end
    if want == "Head" then
        add(head, head and -head.Size.Y * 0.2) add(head) add(body) add(root) add(low)
    else
        add(body) add(root) add(low) add(head, head and -head.Size.Y * 0.2)
    end
    for _, pos in ipairs(points) do
        local ok, name = shotLands(model, pos)
        if ok then return pos, name end
    end
    return nil
end

local function silentArmed()
    if not CONFIG.silent then return false, "off" end
    if inDuel() and not CONFIG.silentDuel then return false, "duel - every shot is recorded" end
    local blocked = assistBlocked()
    if blocked then return false, blocked end
    if CONFIG.silentActive == "Always" then return true end
    if CONFIG.silentActive == "Screen held" then return screenHeld(), "waiting for a finger" end
    local held = hotkeyHeld(CONFIG.silentKey)
    return held, "waiting for " .. keyDisplay(CONFIG.silentKey)
end

local function silentPass()
    local armed, why = silentArmed()
    local c = ctl()
    if not armed or not c then
        SIL.point = nil
        STATE.silentOn = false
        STATE.silentTarget = "-"
        STATE.silentNote = armed and "not deployed" or tostring(why or "-")
        if SIL.installedOn or next(MP) then silentUninstall() end
        return
    end
    if not silentInstall() then
        SIL.point = nil
        STATE.silentOn = false
        STATE.silentNote = "GameUIMod / Gun.Shoot not found"
        return
    end
    STATE.silentOn = true

    -- The visibility test IS the landing test: a target counts when some point of
    -- its body is reachable by the bullet's own ray, not only when the exact
    -- centre of its head is. Testing the centre alone skipped everybody half
    -- behind cover - the case silent aim is for. Cheap screen checks first, the
    -- rays only for the ones that pass them.
    local mid = crosshairPos()
    local camPos = camera.CFrame.Position
    local range = math.min(CONFIG.silentMaxDist, weaponRange())
    local wholeScreen = CONFIG.silentMode == "Whole screen"
    local vp = camera.ViewportSize
    local cands = {}
    for _, entry in ipairs(combatants()) do
        if eligible(entry) then
            local hp, _, root = aliveOf(entry.model)
            if hp and not (CONFIG.silentSkipProt and protectedOf(entry.model)) then
                local dist = (camPos - root.Position).Magnitude
                if dist <= range then
                    local sp = camera:WorldToViewportPoint(root.Position)
                    local px = (Vector2.new(sp.X, sp.Y) - mid).Magnitude
                    local onScreen = sp.Z > 0 and sp.X >= 0 and sp.X <= vp.X and sp.Y >= 0 and sp.Y <= vp.Y
                    if onScreen and (wholeScreen or px <= CONFIG.silentFov + 40) then
                        local score
                        if CONFIG.silentPick == "Closest" then score = dist
                        elseif CONFIG.silentPick == "Lowest HP" then score = hp
                        else score = px end
                        cands[#cands + 1] = { entry = entry, score = score, px = px }
                    end
                end
            end
        end
    end
    table.sort(cands, function(a, b) return a.score < b.score end)

    local chosen, point, partName
    for _, cand in ipairs(cands) do
        local pos, name = landingPoint(cand.entry.model, CONFIG.silentPart)
        if pos then
            local sp = camera:WorldToViewportPoint(pos)
            local px = (Vector2.new(sp.X, sp.Y) - mid).Magnitude
            if wholeScreen or px <= CONFIG.silentFov then
                chosen, point, partName = cand, pos, name
                break
            end
        end
    end
    STATE.silentSeen = #cands

    if not chosen then
        SIL.point = nil
        STATE.silentTarget = "-"
        STATE.silentNote = (#cands > 0) and "enemies near the circle, but no body point a bullet can reach"
            or (wholeScreen and "nobody on screen in range" or "nobody inside the circle")
        return
    end
    if EXTRA.lead then point = EXTRA.lead(chosen.entry.model, point) end
    SIL.point = point
    STATE.silentTarget = chosen.entry.name .. (chosen.entry.bot and "  (bot)" or "  (player)")
    STATE.silentNote = "shots go to " .. tostring(partName)
end

--------------------------------------------------------------------------------
-- gun mods - the weapon's own numbers
--------------------------------------------------------------------------------
--
-- Recoil, spread and fire rate are all read out of the tool's WSettings table
-- every shot (ViewModel.Recoil and GExtra), so each mod is a field write with
-- the original kept aside and put back when it is switched off. The originals
-- live in _G so a re-execute never records an already-zeroed value as original.
--
--   camera recoil    MinCamRecoil / MaxCamRecoil  - the spring on the VIEW
--   viewmodel kick   Min/Max RotRecoil, TransRecoil - the gun model only
--   spread           Spread, BaseSpread - the cone in ConeOfFire
--   fire rate        Debounce - the gap GetDebounce() hands the Auto loop
--
-- All four act on where the CLIENT'S own ray goes, and the client reports the
-- hit - so a tighter cone is a real hit. The fire rate was measured once: three
-- shots with no gap all counted.

local NILV = "__selux_nil"
local ORIG = _G.__HYPER_ORIG or setmetatable({}, { __mode = "k" })
_G.__HYPER_ORIG = ORIG

local function setField(W, key, value)
    local o = ORIG[W]
    if not o then o = {} ORIG[W] = o end
    if o[key] == nil then
        local cur = W[key]
        o[key] = (cur == nil) and NILV or cur
    end
    W[key] = value
end

local function restoreField(W, key)
    local o = ORIG[W]
    if not o or o[key] == nil then return end
    local v = o[key]
    W[key] = (v ~= NILV) and v or nil
    o[key] = nil
end

local function original(W, key)
    local o = ORIG[W]
    if o and o[key] ~= nil then
        local v = o[key]
        return (v ~= NILV) and v or nil
    end
    return W[key]
end

local ZERO = Vector3.new(0, 0, 0)
local MOD_FIELDS = {
    noRecoil = { "MinCamRecoil", "MaxCamRecoil" },
    noKick   = { "MinRotRecoil", "MaxRotRecoil", "MinTransRecoil", "MaxTransRecoil" },
    noSpread = { "Spread", "BaseSpread" },
    rapid    = { "Debounce" },
}

local function modsAllowed()
    return (not inDuel()) or CONFIG.modsDuel
end

-- WalkSpeed is the game's own sum (MovementController.UpdateWS):
--   BaseWS (16) + CurrTool.WSettings.WSDelta + 9 sprinting + passives/coils
-- so the boost is added to WSDelta of EVERY tool, the knife included, and the
-- game recomputes the speed itself. Nothing fights its controller that way, and
-- the sprint/slide/slow rules all keep working on top of it.
local lastSpeed = nil

local function moveAllowed()
    return (not inDuel()) or CONFIG.moveDuel
end

local function applySpeed(c)
    local want = (CONFIG.speed and moveAllowed()) and CONFIG.speedAdd or 0
    for _, tool in pairs(c.Shared.Tools) do
        local W = type(tool) == "table" and tool.WSettings
        if type(W) == "table" then
            if want ~= 0 then
                local base = tonumber(original(W, "WSDelta")) or 0
                if W.WSDelta ~= base + want then setField(W, "WSDelta", base + want) end
            else
                restoreField(W, "WSDelta")
            end
        end
    end
    if want ~= lastSpeed then
        lastSpeed = want
        -- UpdateWS runs on the game's own events (sprint, equip); nudge it once so
        -- the change shows up now rather than on the next sprint.
        task.spawn(function()
            gameIdentity()
            pcall(function() c.Controller:UpdateWS() end)
        end)
    end
end

local function applyMods()
    local c = ctl()
    if not c or type(c.Shared.Tools) ~= "table" then return end
    pcall(applySpeed, c)
    if EXTRA.applyGun then
        local ok, err = pcall(EXTRA.applyGun, c)
        if not ok then note("gun extras: " .. tostring(err)) end
    end
    local allowed = modsAllowed()
    local active = {}
    for _, tool in pairs(c.Shared.Tools) do
        local W = type(tool) == "table" and tool.WSettings
        if type(W) == "table" and not W.IsMelee then
            for mod, fields in pairs(MOD_FIELDS) do
                -- While silent aim is armed the cone is closed too: Hitscan spreads the
                -- bent point exactly like a straight one, and at 200+ studs even two
                -- degrees of cone put the shot a head's width off.
                local on = (CONFIG[mod] or (mod == "noSpread" and STATE.silentOn)) and allowed
                for _, key in ipairs(fields) do
                    if on then
                        local base = original(W, key)
                        if base ~= nil then
                            if mod == "rapid" then
                                local want = tonumber(base) and (base / math.max(1, CONFIG.rapidMult))
                                if want and W[key] ~= want then setField(W, key, want) end
                            elseif typeof(base) == "Vector3" then
                                if W[key] ~= ZERO then setField(W, key, ZERO) end
                            elseif type(base) == "number" then
                                if W[key] ~= 0 then setField(W, key, 0) end
                            end
                            active[mod] = true
                        end
                    else
                        restoreField(W, key)
                    end
                end
            end
        end
    end
    local names = {}
    if active.noRecoil then names[#names + 1] = "no recoil" end
    if active.noKick then names[#names + 1] = "no kick" end
    if active.noSpread then names[#names + 1] = "no spread" end
    if active.rapid then names[#names + 1] = string.format("rapid x%.2f", CONFIG.rapidMult) end
    if not allowed and (CONFIG.noRecoil or CONFIG.noKick or CONFIG.noSpread or CONFIG.rapid) then
        names = { "paused - duel" }
    end
    STATE.mods = (#names > 0) and table.concat(names, ", ") or "none"
end

local function restoreAllMods()
    for W, fields in pairs(ORIG) do
        for key in pairs(fields) do restoreField(W, key) end
    end
end

--------------------------------------------------------------------------------
-- fly
--------------------------------------------------------------------------------
--
-- The root part's velocity is written every Heartbeat - no BodyMover, no
-- LinearVelocity, no instance of any kind: GlobalStuff has a
-- CreateProtectedBodyMover, which says the game keeps track of its own movers.
-- Heartbeat runs after the physics step, so the step before the next write still
-- applies one frame of gravity; that frame is paid back in advance.
--
-- Direction: forward/back and strafe come from Humanoid.MoveDirection (so WASD,
-- a gamepad stick and the phone joystick all work), taken along the CAMERA's
-- look so pointing the view up flies up. Space / LeftControl add straight up and
-- down on a keyboard.

local flyWas = false

local function flyStep(dt)
    local char = plr.Character
    local root = char and char:FindFirstChild("HumanoidRootPart")
    local hum = char and char:FindFirstChildWhichIsA("Humanoid")
    local on = CONFIG.fly and moveAllowed() and root and hum and hum.Health > 0
        and char:GetAttribute("LobbyCharacter") ~= true
    if not on then
        if flyWas and root then
            pcall(function() root.AssemblyLinearVelocity = Vector3.new(0, 0, 0) end)
        end
        flyWas = false
        return
    end
    flyWas = true
    local cf = camera.CFrame
    local look = cf.LookVector
    local flat = Vector3.new(look.X, 0, look.Z)
    flat = flat.Magnitude > 1e-3 and flat.Unit or Vector3.new(0, 0, -1)
    local rightFlat = Vector3.new(cf.RightVector.X, 0, cf.RightVector.Z)
    rightFlat = rightFlat.Magnitude > 1e-3 and rightFlat.Unit or Vector3.new(1, 0, 0)
    local md = hum.MoveDirection
    local fwd = md:Dot(flat)
    local side = md:Dot(rightFlat)
    local dir = look * fwd + rightFlat * side
    if not TOUCH then
        if UserInputService:IsKeyDown(Enum.KeyCode.Space) then dir = dir + Vector3.new(0, 1, 0) end
        if UserInputService:IsKeyDown(Enum.KeyCode.LeftControl) then dir = dir - Vector3.new(0, 1, 0) end
    end
    local vel = (dir.Magnitude > 1e-3) and dir.Unit * CONFIG.flySpeed or Vector3.new(0, 0, 0)
    vel = vel + Vector3.new(0, workspace.Gravity * math.max(dt, 1 / 240), 0)
    pcall(function() root.AssemblyLinearVelocity = vel end)
end

-- The panel is built further down; its fly switch is handed in here so the
-- hotkey can move it too (a local declared below this line would be invisible).
local FLY_UI = {}

UserInputService.InputBegan:Connect(function(input, processed)
    if _G.__HYPER ~= GEN or processed or capturing then return end
    if input.UserInputType ~= Enum.UserInputType.Keyboard then return end
    local spec = resolveKey(CONFIG.flyKey or "")
    if not spec or not spec.key or input.KeyCode ~= spec.key then return end
    CONFIG.fly = not CONFIG.fly
    if FLY_UI.handle then pcall(function() FLY_UI.handle:set(CONFIG.fly) end) end
    note(CONFIG.fly and "fly on" or "fly off")
end)

--------------------------------------------------------------------------------
-- trigger and auto fire - the game's own click
--------------------------------------------------------------------------------
--
-- `Shared.MouseDown = true` + `Controller:LeftClick()` is what the game's mouse
-- handler does on MouseButton1 and what its own console auto fire does. A semi
-- auto fires once per click; an automatic keeps firing while MouseDown stays true.
-- No executor click function, no VirtualInputManager - the anticheat names that
-- one - and it works on a phone as it is.

local weHold = false

-- LeftClick -> ToolLeftClick -> Activate is SYNCHRONOUS, and for an automatic
-- Activate is the whole Auto.ShootLogic loop: it only returns once MouseDown goes
-- false again. Called inline it would park this thread until the button is
-- released - which only this thread does. The game's own mouse handler calls it
-- from an input event thread for the same reason; this spawns one, and the
-- spawned thread inherits identity 2.
local function pressFire(c)
    if not c.Controller then return false end
    c.Shared.MouseDown = true
    weHold = true
    task.spawn(function()
        local ok, err = pcall(function() c.Controller:LeftClick() end)
        if not ok then note("click: " .. tostring(err)) end
    end)
    STATE.trigShots = STATE.trigShots + 1
    return true
end

local function releaseFire(c)
    if not weHold then return end
    weHold = false
    -- Never let go of a button the player is physically holding.
    if UserInputService:IsMouseButtonPressed(Enum.UserInputType.MouseButton1) then return end
    if c then c.Shared.MouseDown = false end
end

local function trigActive()
    if not CONFIG.trig then return false end
    if CONFIG.trigActive == "Always" then return true end
    if CONFIG.trigActive == "Screen held" then return screenHeld() end
    return hotkeyHeld(CONFIG.trigKey)
end

local function trigWants(model, part)
    if not model then return false end
    if CONFIG.humBotOnly and model:GetAttribute("Bot") ~= true then return false end
    if CONFIG.trigSkipProt and protectedOf(model) then return false end
    if CONFIG.trigHeadOnly and not (part and (part.Name == "Head" or part.Name == "HeadHB")) then
        return false
    end
    return true
end

task.spawn(function()
    claimIdentity()
    gameIdentity()
    local nextAt, holdUntil = 0, 0
    while _G.__HYPER == GEN do
        local ok, err = pcall(function()
            local c = ctl()
            local model, part = nil, nil
            if c then model, part = underCrosshair() end
            STATE.underCross = model and (model.Name .. "  " .. (part and part.Name or "")) or "-"

            local wantTrig = trigActive() and not assistBlocked()
            local wantAuto = CONFIG.aim and CONFIG.aimFire and STATE.target ~= "-"
                and not assistBlocked()
                and not (engagement and os.clock() - engagement.t0 < engagement.windup)
            STATE.trigOn = wantTrig

            if not c or not (wantTrig or wantAuto) then
                if weHold then releaseFire(c) end
                return
            end
            local ready = gunReady()
            if not ready or not adsGate(CONFIG.trigAds) or not trigWants(model, part) then
                if weHold and os.clock() > holdUntil then releaseFire(c) end
                return
            end
            local tool = c.Shared.CurrTool
            local auto = tool and tool.IsAuto == true

            if weHold and auto then
                holdUntil = os.clock() + CONFIG.trigHoldMs / 1000
                return
            end
            local now = os.clock() * 1000
            if now < nextAt then return end

            local pct = CONFIG.trigHitPct
            if CONFIG.hum and CONFIG.humMissPct > 0 then pct = math.max(1, pct - CONFIG.humMissPct) end
            if math.random(100) > pct then
                nextAt = now + 250
                return
            end

            local lo = math.min(CONFIG.trigDelayMin, CONFIG.trigDelayMax)
            local hi = math.max(CONFIG.trigDelayMin, CONFIG.trigDelayMax)
            local wait
            if CONFIG.hum then
                wait = math.clamp(gauss((lo + hi) / 2, math.max(1, CONFIG.humReactSd)),
                    math.max(0, lo - 20), hi + 60)
            else
                wait = (hi > 0) and math.random(lo, hi) or 0
            end
            if wait > 0 then task.wait(wait / 1000) end

            -- Re-check after the reaction delay, or the shot goes where the enemy
            -- was a moment ago.
            local again, againPart = underCrosshair()
            if not trigWants(again, againPart) or not gunReady() then return end

            if pressFire(c) then
                if auto then
                    holdUntil = os.clock() + CONFIG.trigHoldMs / 1000
                else
                    task.wait(0.03)
                    releaseFire(c)
                    local deb = tonumber(tool and tool.WSettings and tool.WSettings.Debounce) or 0.2
                    nextAt = os.clock() * 1000 + deb * 1000 * (CONFIG.hum and (1 + math.random() * 0.35) or 1)
                end
            end
        end)
        if not ok then note("trigger: " .. tostring(err)) end
        task.wait(0.01)
    end
    pcall(function() releaseFire(ctl()) end)
end)

-- A kill pauses the aim; a model that vanished while it was the target counts.
task.spawn(function()
    claimIdentity()
    local seen = setmetatable({}, { __mode = "k" })
    while _G.__HYPER == GEN do
        pcall(function()
            for _, entry in ipairs(combatants()) do
                local hp = aliveOf(entry.model) or 0
                local was = seen[entry.model]
                if was and was > 0 and hp <= 0 and entry.model == stickyModel then
                    lastKillAt = os.clock() * 1000
                    stickyModel = nil
                    endEngagement()
                end
                seen[entry.model] = hp
            end
            if stickyModel and not stickyModel.Parent then
                lastKillAt = os.clock() * 1000
                stickyModel = nil
                endEngagement()
            end
        end)
        task.wait(0.1)
    end
end)

-- Gun mods are re-applied on a timer: a respawn hands out fresh tool objects.
task.spawn(function()
    claimIdentity()
    while _G.__HYPER == GEN do
        local ok, err = pcall(applyMods)
        if not ok then note("mods: " .. tostring(err)) end
        task.wait(0.25)
    end
    pcall(restoreAllMods)
end)

--------------------------------------------------------------------------------
-- the second round: more gun mods, world, visuals, movement, misc
--------------------------------------------------------------------------------
--
-- Every mechanism below was read out of THIS game's code - the comment on each
-- names where. A technique that works in one game says nothing about the next.

do
    local Lighting = game:GetService("Lighting")
    local TeleportService = game:GetService("TeleportService")
    local HttpService = game:GetService("HttpService")

    -- projectile lead --------------------------------------------------------------
    -- ProjectileMod.new(origin, target, WSettings.ProjSpeed, ignore, width, ProjGravity):
    -- pos(t) = origin + v*t - (0, g*t*t/2, 0), g = ProjGravity or workspace.Gravity.
    -- Hitscan guns get no lead at all - their ray is instant.
    function EXTRA.lead(model, pos)
        if not CONFIG.predict then return pos end
        local tool = currentTool()
        local w = tool and tool.WSettings
        local speed = w and w.Projectile and tonumber(w.ProjSpeed)
        if not speed or speed <= 0 then return pos end
        local g = tonumber(w.ProjGravity) or workspace.Gravity
        local root = model and model:FindFirstChild("HumanoidRootPart")
        local vel = root and root.AssemblyLinearVelocity or Vector3.new()
        local origin = camera.CFrame.Position
        local aim = pos
        for _ = 1, 3 do
            local t = (aim - origin).Magnitude / speed
            aim = pos + vel * t + Vector3.new(0, 0.5 * g * t * t, 0)
        end
        return aim
    end

    -- sway, ADS, reload and equip speed ----------------------------------------------
    -- ViewModel.UpdateViewModel skips the whole bob when Shared.NoSway is set (the
    -- game's own flag, used while inspecting); the scope lerp runs at
    -- 0.3 * WSettings.ScopeSpeed; reload and equip are ANIMATIONS whose speed is
    -- the AnimSpeed attribute on IgnoreThese.MyArms.Anims.<name>, and the reload
    -- ends on the animation's marker - so a faster animation is a faster reload.
    local swayWas = false
    local ANIMORIG = setmetatable({}, { __mode = "k" })

    -- ANY animation whose name contains "reload", not a fixed list: the first build
    -- matched Reload / ReloadStart / ReloadEnd only, and "fast reload works but not
    -- every time" was the report that came back.
    local function isReloadAnim(name)
        return string.find(string.lower(name), "reload", 1, true) ~= nil
    end

    local function animSpeed(a)
        local allowed = modsAllowed()
        local mult = nil
        if isReloadAnim(a.Name) and CONFIG.fastReload and allowed then mult = CONFIG.reloadMult
        elseif a.Name == "Equip" and CONFIG.fastEquip and allowed then mult = CONFIG.equipMult end
        local stored = ANIMORIG[a]
        if mult then
            if stored == nil then
                stored = a:GetAttribute("AnimSpeed") or NILV
                ANIMORIG[a] = stored
            end
            local want = ((stored == NILV) and 1 or stored) * mult
            if a:GetAttribute("AnimSpeed") ~= want then a:SetAttribute("AnimSpeed", want) end
        elseif stored ~= nil then
            a:SetAttribute("AnimSpeed", (stored ~= NILV) and stored or nil)
            ANIMORIG[a] = nil
        end
    end

    local function myArms()
        local ig = workspace:FindFirstChild("IgnoreThese")
        return ig and ig:FindFirstChild("MyArms")
    end

    local function animSpeeds()
        local arms = myArms()
        local anims = arms and arms:FindFirstChild("Anims")
        if not anims then return end
        for _, a in ipairs(anims:GetChildren()) do pcall(animSpeed, a) end
    end

    -- An equip animation starts the moment the weapon is swapped, so a 0.25s loop
    -- would miss it. New animations are caught as they are parented.
    do
        local ig = workspace:FindFirstChild("IgnoreThese")
        if ig then
            ig.DescendantAdded:Connect(function(d)
                if _G.__HYPER ~= GEN then return end
                if d:IsA("Animation") and (CONFIG.fastReload or CONFIG.fastEquip) then
                    local parent = d.Parent
                    if parent and parent.Name == "Anims" and parent.Parent and parent.Parent.Name == "MyArms" then
                        pcall(animSpeed, d)
                    end
                end
            end)
        end
    end

    -- skins and kill effects - CLIENT SIDE ONLY ---------------------------------------
    -- ViewModel.Equip applies tool.SkinData with SkinModule:ApplySkin; the server
    -- builds SkinData from YOUR inventory (SpawnData), and other players read the
    -- skin off the server's Tool attributes. So this changes what you see and
    -- nothing anybody else sees. GunSkins is one global list: any skin fits any gun.
    local skinFolder = ReplicatedStorage:FindFirstChild("Modules")
        and ReplicatedStorage.Modules:FindFirstChild("SkinModules")
    local skinModuleInst = skinFolder and skinFolder:FindFirstChild("SkinModule")
    local SkinModule = tryRequire(skinModuleInst)
    local GunSkins = tryRequire(skinModuleInst and skinModuleInst:FindFirstChild("GunSkins"))
    EXTRA.skinList = {}
    if type(GunSkins) == "table" then
        for name in pairs(GunSkins) do EXTRA.skinList[#EXTRA.skinList + 1] = tostring(name) end
        table.sort(EXTRA.skinList)
    end
    EXTRA.killList = {}
    do
        local kv = ReplicatedStorage:FindFirstChild("KillVFX")
        local assets = kv and kv:FindFirstChild("Assets")
        if assets then
            for _, a in ipairs(assets:GetChildren()) do EXTRA.killList[#EXTRA.killList + 1] = a.Name end
            table.sort(EXTRA.killList)
        end
    end
    if CONFIG.killVfx == "" and EXTRA.killList[1] then CONFIG.killVfx = EXTRA.killList[1] end

    local SKINORIG = setmetatable({}, { __mode = "k" })
    local skinShown = { model = nil, name = nil }

    local function applySkins(c)
        local on = CONFIG.skinOn and CONFIG.skinName ~= ""
        for _, tool in pairs(c.Shared.Tools) do
            if type(tool) == "table" and type(tool.WSettings) == "table" then
                if on then
                    if SKINORIG[tool] == nil then SKINORIG[tool] = tool.SkinData or false end
                    local cur = tool.SkinData
                    if not (type(cur) == "table" and cur.SkinName == CONFIG.skinName) then
                        tool.SkinData = { SkinName = CONFIG.skinName, IsCE = false }
                    end
                elseif SKINORIG[tool] ~= nil then
                    tool.SkinData = SKINORIG[tool] or nil
                    SKINORIG[tool] = nil
                end
            end
        end
        -- The gun already in hand only gets SkinData on its NEXT equip; this paints
        -- it now, once per model and skin.
        local arms = myArms()
        local wm = arms and arms:FindFirstChild("WModel")
        local want = on and CONFIG.skinName or nil
        if wm and SkinModule and want and (skinShown.model ~= wm or skinShown.name ~= want) then
            skinShown.model, skinShown.name = wm, want
            task.spawn(function()
                gameIdentity()
                local ok, err = pcall(function() SkinModule:ApplySkin(wm, { SkinName = want }) end)
                if not ok then note("skin: " .. tostring(err)) end
            end)
        end
        if not on then skinShown.model, skinShown.name = nil, nil end
    end

    -- GExtra.PredictKills plays MenuCoreData.EquippedKillVFX[weapon] for YOUR kills
    -- (KillPredictor, gated on the ClientKillPredict attribute); everybody else sees
    -- the server's DeathEffect attribute.
    local KVORIG = setmetatable({}, { __mode = "k" })

    local function applyKillVfx(c)
        local data = c.Shared.MenuCoreData
        if type(data) ~= "table" then return end
        if type(data.EquippedKillVFX) ~= "table" then data.EquippedKillVFX = {} end
        local eq = data.EquippedKillVFX
        if CONFIG.killVfxOn and CONFIG.killVfx ~= "" then
            if not KVORIG[eq] then KVORIG[eq] = table.clone(eq) end
            for _, tool in pairs(c.Shared.Tools) do
                if type(tool) == "table" and tool.Name and eq[tool.Name] ~= CONFIG.killVfx then
                    eq[tool.Name] = CONFIG.killVfx
                end
            end
        elseif KVORIG[eq] then
            local orig = KVORIG[eq]
            table.clear(eq)
            for k, v in pairs(orig) do eq[k] = v end
            KVORIG[eq] = nil
        end
    end

    function EXTRA.applyGun(c)
        local allowed = modsAllowed()
        if CONFIG.noSway and allowed then
            c.Shared.NoSway = true
            swayWas = true
        elseif swayWas then
            c.Shared.NoSway = false
            swayWas = false
        end
        for _, tool in pairs(c.Shared.Tools) do
            local W = type(tool) == "table" and tool.WSettings
            if type(W) == "table" and not W.IsMelee then
                if CONFIG.instantAds and allowed then
                    if W.ScopeSpeed ~= 60 then setField(W, "ScopeSpeed", 60) end
                else
                    restoreField(W, "ScopeSpeed")
                end
            end
        end
        animSpeeds()
        pcall(applySkins, c)
        pcall(applyKillVfx, c)
    end

    -- world ---------------------------------------------------------------------------
    -- The camera's field of view is the game's own setting (MenuCoreData.Settings
    -- .FOV, 90 by default), so that is what is written - a camera.FieldOfView write
    -- would be overwritten by the Scriptable camera every frame. Lighting is plain
    -- Lighting, captured when a switch goes on and put back when it goes off.
    local LIGHTORIG = {}
    local was = {}
    local fovOrig = nil
    local EFFECT_CLASSES = { DepthOfFieldEffect = true, BloomEffect = true, SunRaysEffect = true }
    local effOrig = setmetatable({}, { __mode = "k" })

    local function capture(group, fields)
        if LIGHTORIG[group] then return end
        local t = {}
        for _, f in ipairs(fields) do t[f] = Lighting[f] end
        LIGHTORIG[group] = t
    end

    local function restore(group)
        local t = LIGHTORIG[group]
        if not t then return end
        for f, v in pairs(t) do pcall(function() Lighting[f] = v end) end
        LIGHTORIG[group] = nil
    end

    local function world()
        if CONFIG.fullbright then
            capture("bright", { "Brightness", "GlobalShadows", "Ambient", "OutdoorAmbient" })
            Lighting.Brightness = 2
            Lighting.GlobalShadows = false
            Lighting.Ambient = Color3.new(1, 1, 1)
            Lighting.OutdoorAmbient = Color3.new(1, 1, 1)
        elseif was.bright then restore("bright") end
        was.bright = CONFIG.fullbright

        if CONFIG.timeOn then
            capture("time", { "ClockTime" })
            Lighting.ClockTime = CONFIG.timeValue
        elseif was.time then restore("time") end
        was.time = CONFIG.timeOn

        local atm = Lighting:FindFirstChildOfClass("Atmosphere")
        if CONFIG.noFog then
            capture("fog", { "FogEnd", "FogStart" })
            Lighting.FogEnd = 1e9
            Lighting.FogStart = 1e9 - 1
            if atm then
                if not effOrig[atm] then effOrig[atm] = { atm.Density, atm.Haze } end
                atm.Density, atm.Haze = 0, 0
            end
        elseif was.fog then
            restore("fog")
            if atm and effOrig[atm] then
                atm.Density, atm.Haze = effOrig[atm][1], effOrig[atm][2]
                effOrig[atm] = nil
            end
        end
        was.fog = CONFIG.noFog

        for _, e in ipairs(Lighting:GetChildren()) do
            if EFFECT_CLASSES[e.ClassName] then
                if CONFIG.noEffects then
                    if effOrig[e] == nil then effOrig[e] = e.Enabled end
                    e.Enabled = false
                elseif effOrig[e] ~= nil then
                    e.Enabled = effOrig[e]
                    effOrig[e] = nil
                end
            end
        end

        local c = ctl()
        local set = c and c.Shared.MenuCoreData and c.Shared.MenuCoreData.Settings
        if type(set) == "table" then
            if CONFIG.fovOn then
                if fovOrig == nil then fovOrig = set.FOV end
                set.FOV = CONFIG.fovValue
            elseif fovOrig ~= nil then
                set.FOV = fovOrig
                fovOrig = nil
            end
        end
    end

    -- viewmodel colour - your own arms and gun in IgnoreThese.MyArms, local only ------
    local VMORIG = setmetatable({}, { __mode = "k" })
    local function viewmodel()
        local arms = myArms()
        if not arms then return end
        local on = CONFIG.vmColour
        if not on and next(VMORIG) == nil then return end
        local mat = Enum.Material.ForceField
        pcall(function() mat = Enum.Material[CONFIG.vmMaterial] end)
        for _, p in ipairs(arms:GetDescendants()) do
            if p:IsA("BasePart") then
                if on and p.Transparency < 1 then
                    if not VMORIG[p] then VMORIG[p] = { p.Color, p.Material } end
                    p.Color = CONFIG.colVm
                    p.Material = mat
                elseif not on and VMORIG[p] then
                    p.Color, p.Material = VMORIG[p][1], VMORIG[p][2]
                    VMORIG[p] = nil
                end
            end
        end
    end

    task.spawn(function()
        claimIdentity()
        while _G.__HYPER == GEN do
            local ok, err = pcall(world)
            if not ok then note("world: " .. tostring(err)) end
            pcall(viewmodel)
            task.wait(0.3)
        end
        -- Unloaded: put the world back the way the game had it.
        CONFIG.fullbright, CONFIG.timeOn, CONFIG.noFog, CONFIG.noEffects, CONFIG.fovOn =
            false, false, false, false, false
        CONFIG.vmColour = false
        pcall(world)
        pcall(viewmodel)
    end)

    -- pickups, projectiles and bullet tracers -----------------------------------------
    -- IgnoreThese.Pickups.<Loot|Heals|Capsules|Ammo|event>.<item> and
    -- IgnoreThese.Projectiles are the game's own folders.
    local itemPool, tracerPool, tracers = {}, {}, {}

    local function itemText(i)
        local t = itemPool[i]
        if not t then
            t = make("Text", { Size = 13, Center = true, Outline = true, Font = 1, ZIndex = 3 })
            itemPool[i] = t
        end
        return t
    end

    local function tracerLine(i)
        local l = tracerPool[i]
        if not l then
            l = make("Line", { Thickness = 1.5, ZIndex = 3 })
            tracerPool[i] = l
        end
        return l
    end

    local function posOf(inst)
        if inst:IsA("BasePart") then return inst.Position end
        if inst:IsA("Model") then
            local ok, cf = pcall(inst.GetPivot, inst)
            if ok then return cf.Position end
        end
        local p = inst:FindFirstChildWhichIsA("BasePart", true)
        return p and p.Position
    end

    function EXTRA.render()
        local used = 0
        local camPos = camera.CFrame.Position
        local face = fontId()
        local function label(pos, text, col)
            if used >= 80 then return end
            local sp = camera:WorldToViewportPoint(pos)
            if sp.Z <= 0 then return end
            used = used + 1
            local t = itemText(used)
            t.Position = Vector2.new(sp.X, sp.Y)
            t.Text = text
            t.Color = col
            t.Font = face
            t.Size = math.max(12, CONFIG.textSize - 1)
            t.Outline = CONFIG.textOutline
            t.Visible = true
        end
        local ig = workspace:FindFirstChild("IgnoreThese")
        if ig and CONFIG.pickupEsp then
            local pick = ig:FindFirstChild("Pickups")
            if pick then
                for _, cat in ipairs(pick:GetChildren()) do
                    for _, item in ipairs(cat:GetChildren()) do
                        local pos = posOf(item)
                        if pos then
                            local d = (pos - camPos).Magnitude
                            if d <= CONFIG.maxDist then
                                label(pos, string.format("%s  %dm", cat.Name, d), CONFIG.colPickup)
                            end
                        end
                    end
                end
            end
        end
        if ig and CONFIG.projEsp then
            local proj = ig:FindFirstChild("Projectiles")
            if proj then
                for _, p in ipairs(proj:GetChildren()) do
                    local pos = posOf(p)
                    if pos then
                        label(pos, string.format("! %s  %dm", p.Name, (pos - camPos).Magnitude),
                            Color3.fromRGB(255, 80, 80))
                    end
                end
            end
        end
        for i = used + 1, #itemPool do itemPool[i].Visible = false end

        local now = os.clock()
        for i = #tracers, 1, -1 do
            if now - tracers[i].t0 > CONFIG.tracerLife then table.remove(tracers, i) end
        end
        local n = 0
        if CONFIG.tracers then
            for _, tr in ipairs(tracers) do
                local a = camera:WorldToViewportPoint(tr.from)
                local b = camera:WorldToViewportPoint(tr.to)
                if a.Z > 0 and b.Z > 0 then
                    n = n + 1
                    local l = tracerLine(n)
                    l.From = Vector2.new(a.X, a.Y)
                    l.To = Vector2.new(b.X, b.Y)
                    l.Color = CONFIG.colTracer
                    l.Transparency = math.clamp(1 - (now - tr.t0) / CONFIG.tracerLife, 0.05, 1)
                    l.Visible = true
                end
            end
        end
        for i = n + 1, #tracerPool do tracerPool[i].Visible = false end
    end

    -- A shot is an ammo drop on the tool in hand; its line runs from the gun's own
    -- Tip part to where the bullet's ray ends (the bent point while silent aim has
    -- one, so the tracer shows where the shot really went).
    do
        local lastAmmo, lastTool = nil, nil
        RunService.Heartbeat:Connect(function()
            if _G.__HYPER ~= GEN then return end
            if not CONFIG.tracers then lastAmmo = nil return end
            local tool = currentTool()
            local ammo = tool and tonumber(tool.Ammo)
            if tool and tool == lastTool and lastAmmo and ammo and ammo < lastAmmo then
                local shots = math.min(lastAmmo - ammo, 5)
                local cf = camera.CFrame
                local range = weaponRange()
                local target = SIL.point or (cf.Position + cf.LookVector * range)
                local dir = (target - cf.Position)
                if dir.Magnitude > 0.05 then
                    rayParams.FilterDescendantsInstances = bulletIgnore()
                    local hit = workspace:Raycast(cf.Position, dir.Unit * range, rayParams)
                    local to = hit and hit.Position or (cf.Position + dir.Unit * range)
                    local from = cf.Position + cf.LookVector * 2 - cf.UpVector * 0.4 + cf.RightVector * 0.5
                    local arms = myArms()
                    local tip = arms and arms:FindFirstChild("Tip", true)
                    if tip and tip:IsA("BasePart") then from = tip.Position end
                    for _ = 1, shots do
                        tracers[#tracers + 1] = { from = from, to = to, t0 = os.clock() }
                    end
                    while #tracers > 40 do table.remove(tracers, 1) end
                end
            end
            lastAmmo, lastTool = ammo, tool
        end)
    end

    -- jump, air jump, slide cooldown ---------------------------------------------------
    -- MovementController sets Humanoid.JumpHeight from GetJumpHeight() (7, +3
    -- Lightweight, +10 Gravity coil) on its own events, so the height is held every
    -- frame and handed back to GetJumpHeight() when switched off. CanSlide gates on
    -- `tick() - lastSlide < cooldown` with both as upvalues (2 and 3); the cooldown
    -- is re-set to 0.2-0.5s at the end of every slide, so it is held at 0.
    local jumpWas, slideWas = false, false
    local slideOrig = nil
    RunService.Heartbeat:Connect(function()
        if _G.__HYPER ~= GEN then return end
        local char = plr.Character
        local hum = char and char:FindFirstChildWhichIsA("Humanoid")
        local c = ctl()
        local allowed = moveAllowed()
        if hum then
            if CONFIG.jumpOn and allowed then
                if hum.JumpHeight ~= CONFIG.jumpHeight then hum.JumpHeight = CONFIG.jumpHeight end
                jumpWas = true
            elseif jumpWas then
                jumpWas = false
                local h = 7
                if c then
                    local ok, v = pcall(function() return c.Controller:GetJumpHeight() end)
                    if ok and tonumber(v) then h = v end
                end
                hum.JumpHeight = h
            end
        end
        local f = c and c.Controller and c.Controller.CanSlide
        if type(f) == "function" and debug.getupvalue and debug.setupvalue then
            if CONFIG.noSlideCd and allowed then
                local ok, last = pcall(debug.getupvalue, f, 2)
                local ok2, cd = pcall(debug.getupvalue, f, 3)
                if ok and ok2 and type(last) == "number" and type(cd) == "number" and cd <= 2 then
                    if not slideWas then slideOrig = cd end
                    if cd ~= 0 then pcall(debug.setupvalue, f, 3, 0) end
                    slideWas = true
                end
            elseif slideWas then
                slideWas = false
                pcall(debug.setupvalue, f, 3, slideOrig or 0.5)
                slideOrig = nil
            end
        end
    end)

    UserInputService.JumpRequest:Connect(function()
        if _G.__HYPER ~= GEN or not CONFIG.infJump or not moveAllowed() then return end
        local char = plr.Character
        local hum = char and char:FindFirstChildWhichIsA("Humanoid")
        if hum and hum.Health > 0 and hum:GetState() == Enum.HumanoidStateType.Freefall then
            hum:ChangeState(Enum.HumanoidStateType.Jumping)
        end
    end)

    -- auto spawn -------------------------------------------------------------------
    -- The Spawn button runs HomeFrame.TrySpawn(), which has its own debounce and
    -- sends FireServer("Spawn", IS_MOBILE). Called directly, once every few
    -- seconds - NEVER by firing the button's connections (three of those in a row
    -- teleported the account into the Trading Plaza), and never TrySpawn(true),
    -- which spends a paid instant revive.
    STATE.spawns = 0
    task.spawn(function()
        claimIdentity()
        gameIdentity()
        local lastTry = 0
        while _G.__HYPER == GEN do
            pcall(function()
                if not CONFIG.autoSpawn then return end
                local char = plr.Character
                if char and char:GetAttribute("LobbyCharacter") ~= true then return end
                if not (GameInfo and GameInfo:GetAttribute("GameInProgress")) then return end
                if not plr:GetAttribute("MenuLoaded") then return end
                if os.clock() - lastTry < 5 then return end
                local pg = plr:FindFirstChildOfClass("PlayerGui")
                local menu = pg and pg:FindFirstChild("MenuUI")
                local ml = menu and menu:FindFirstChild("MenuLocal")
                local hf = ml and ml:FindFirstChild("HomeFrame")
                local mod = tryRequire(hf)
                if type(mod) == "table" and type(mod.TrySpawn) == "function" then
                    lastTry = os.clock()
                    mod:TrySpawn()
                    STATE.spawns = STATE.spawns + 1
                end
            end)
            task.wait(1)
        end
    end)

    -- anti-AFK -----------------------------------------------------------------------
    -- A short step and a hop after 50s without input, so the game sees a moving
    -- character. Roblox's own 20-minute idle kick only listens to real input, and
    -- the usual fix for that - VirtualUser:CaptureController - is a string in this
    -- game's anticheat, so it is deliberately not used.
    STATE.afkNudges = 0
    task.spawn(function()
        claimIdentity()
        local lastNudge = os.clock()
        while _G.__HYPER == GEN do
            pcall(function()
                if not CONFIG.antiAfk then lastNudge = os.clock() return end
                local c = ctl()
                local lastInput = c and tonumber(c.Shared.LastMouseInput) or 0
                local idle = math.min(tick() - lastInput, os.clock() - lastNudge)
                if c == nil then idle = os.clock() - lastNudge end
                if idle < 50 then return end
                local hum = plr.Character and plr.Character:FindFirstChildWhichIsA("Humanoid")
                if hum and hum.Health > 0 then
                    local a = math.random() * math.pi * 2
                    hum:Move(Vector3.new(math.cos(a), 0, math.sin(a)), false)
                    task.wait(0.2)
                    hum:Move(Vector3.new(), false)
                    hum.Jump = true
                end
                lastNudge = os.clock()
                STATE.afkNudges = STATE.afkNudges + 1
            end)
            task.wait(5)
        end
    end)

    -- staff ---------------------------------------------------------------------------
    -- Every player carries the attribute CanAccessAdminPanel (false for the rest of
    -- us), and the game belongs to a group, so a high rank in it is the second tell.
    EXTRA.staff = {}
    local rankCache = {}
    local function checkStaff(p)
        if p == plr then return end
        local why = nil
        if p:GetAttribute("CanAccessAdminPanel") == true then why = "admin panel" end
        -- Frosted Studio's roles, read from GroupService: 1 Member/Fans, 2 Testers,
        -- 3 Content Creators, 4 Contributors, 5 Developer, 6 Contributors2, 255
        -- owner. Everything from 2 up is somebody on the inside of the game.
        if not why and game.CreatorType == Enum.CreatorType.Group then
            local entry = rankCache[p.UserId]
            if entry == nil then
                local ok, r = pcall(p.GetRankInGroup, p, game.CreatorId)
                local okRole, role = pcall(p.GetRoleInGroup, p, game.CreatorId)
                entry = { rank = (ok and tonumber(r)) or 0, role = okRole and tostring(role) or "?" }
                rankCache[p.UserId] = entry
            end
            if entry.rank >= 2 then why = entry.role .. " (rank " .. entry.rank .. ")" end
        end
        if why then
            if not EXTRA.staff[p.Name] then
                EXTRA.staff[p.Name] = why
                if CONFIG.staffAlert then note("STAFF in this server: " .. p.Name .. " (" .. why .. ")") end
                if CONFIG.staffPanic then EXTRA.panic("staff: " .. p.Name) end
            end
        else
            EXTRA.staff[p.Name] = nil
        end
    end

    function EXTRA.panic(reason)
        CONFIG.aim, CONFIG.trig, CONFIG.aimFire, CONFIG.silent = false, false, false, false
        CONFIG.rapid, CONFIG.fly, CONFIG.speed = false, false, false
        CONFIG.jumpOn, CONFIG.infJump, CONFIG.noSlideCd = false, false, false
        for _, fn in ipairs(panicHandlers) do pcall(fn) end
        note("PANIC (" .. tostring(reason) .. ") - aim, trigger, silent, rapid, movement off")
    end

    task.spawn(function()
        claimIdentity()
        while _G.__HYPER == GEN do
            for _, p in ipairs(Players:GetPlayers()) do pcall(checkStaff, p) end
            for name in pairs(EXTRA.staff) do
                if not Players:FindFirstChild(name) then EXTRA.staff[name] = nil end
            end
            task.wait(8)
        end
    end)

    -- rejoin / server hop ------------------------------------------------------------
    function EXTRA.rejoin()
        pcall(function() TeleportService:TeleportToPlaceInstance(game.PlaceId, game.JobId, plr) end)
    end

    function EXTRA.hop()
        local ok, body = pcall(function()
            return game:HttpGet("https://games.roblox.com/v1/games/" .. game.PlaceId
                .. "/servers/Public?sortOrder=Desc&limit=100")
        end)
        if ok and body then
            local ok2, data = pcall(HttpService.JSONDecode, HttpService, body)
            if ok2 and type(data) == "table" and type(data.data) == "table" then
                local pool = {}
                for _, s in ipairs(data.data) do
                    if s.id ~= game.JobId and tonumber(s.playing) and tonumber(s.maxPlayers)
                        and s.playing < s.maxPlayers - 1 then
                        pool[#pool + 1] = s.id
                    end
                end
                if #pool > 0 then
                    local id = pool[math.random(#pool)]
                    note("server hop -> " .. tostring(id):sub(1, 8))
                    pcall(function() TeleportService:TeleportToPlaceInstance(game.PlaceId, id, plr) end)
                    return
                end
            end
        end
        note("server hop: no list, joining any server")
        pcall(function() TeleportService:Teleport(game.PlaceId, plr) end)
    end

    -- streamer mode - your name in YOUR screen's labels only --------------------------
    task.spawn(function()
        claimIdentity()
        while _G.__HYPER == GEN do
            pcall(function()
                if not CONFIG.streamer then return end
                local pg = plr:FindFirstChildOfClass("PlayerGui")
                if not pg then return end
                local fake = CONFIG.streamerName
                local names = { plr.Name, plr.DisplayName }
                for _, d in ipairs(pg:GetDescendants()) do
                    if (d:IsA("TextLabel") or d:IsA("TextButton")) and d.Text ~= "" then
                        local txt = d.Text
                        for _, n in ipairs(names) do
                            if n ~= fake and txt:find(n, 1, true) then
                                txt = txt:gsub(n:gsub("%p", "%%%0"), fake)
                            end
                        end
                        if txt ~= d.Text then d.Text = txt end
                    end
                end
            end)
            task.wait(1)
        end
    end)
end

--------------------------------------------------------------------------------
-- the frame bindings
--------------------------------------------------------------------------------

for _, name in ipairs({ "SeluxHyperAim", "SeluxHyperESP" }) do
    pcall(function() RunService:UnbindFromRenderStep(name) end)
end

task.spawn(function()
claimIdentity()
if _G.__HYPER ~= GEN then return end

RunService:BindToRenderStep("SeluxHyperAim", Enum.RenderPriority.Camera.Value - 1,
    function(dt)
        if _G.__HYPER ~= GEN then
            pcall(function() RunService:UnbindFromRenderStep("SeluxHyperAim") end)
            pcall(silentUninstall)
            return
        end
        local ok, err = pcall(function()
            aimPass(dt)
            silentPass()
        end)
        if not ok then note("aim: " .. tostring(err)) end
    end)

RunService:BindToRenderStep("SeluxHyperESP", Enum.RenderPriority.Camera.Value + 2,
    function()
        if _G.__HYPER ~= GEN then
            pcall(function() RunService:UnbindFromRenderStep("SeluxHyperESP") end)
            hideAll()
            return
        end
        local ok, err = pcall(renderPass)
        if not ok then note("esp: " .. tostring(err)) end
    end)
end)

-- A position jump the velocity cannot explain is the server putting the root part
-- back. Counted, so the readout says whether speed and fly are being pulled back
-- rather than leaving it to a feeling. Respawns (a jump of hundreds of studs
-- together with a new character) are not counted.
local snap = { pos = nil, char = nil, count = 0, last = 0 }

local function snapWatch(dt)
    local char = plr.Character
    local root = char and char:FindFirstChild("HumanoidRootPart")
    if not root then snap.pos = nil return end
    local pos = root.Position
    if snap.pos and snap.char == char then
        local expected = snap.pos + root.AssemblyLinearVelocity * dt
        local off = (pos - expected).Magnitude
        if off > 6 and off < 300 then
            snap.count = snap.count + 1
            snap.last = os.clock()
        end
    end
    snap.pos, snap.char = pos, char
end

local flyConn
flyConn = RunService.Heartbeat:Connect(function(dt)
    if _G.__HYPER ~= GEN then
        if flyConn then flyConn:Disconnect() end
        return
    end
    local ok, err = pcall(flyStep, dt)
    if not ok then note("fly: " .. tostring(err)) end
    pcall(snapWatch, dt)
end)

workspace:GetPropertyChangedSignal("CurrentCamera"):Connect(function()
    if workspace.CurrentCamera then camera = workspace.CurrentCamera end
end)

--------------------------------------------------------------------------------
-- panel
--------------------------------------------------------------------------------

local UI = (_G.__SEL and _G.__SEL.ui) or loadstring(readfile("ui-template.lua"))()
if _G.__HYPER_WIN then pcall(function() _G.__HYPER_WIN:Destroy() end) end
if UI.sweep then UI.sweep("HypershotPanel") end

UI.config("hypershot", CONFIG)

local win = UI.Window({
    name = "HypershotPanel",
    title = "HYPER", accentTitle = "SHOT", subtitle = "seltonmt",
    badge = "◎", width = 820, height = 582,
})
_G.__HYPER_WIN = win

local CTLS = {}
local function reg(key, handle)
    CTLS[key] = handle
    return handle
end

local function applyPreset(name)
    local set = PRESETS[name]
    if not set then return end
    for key, value in pairs(set) do
        CONFIG[key] = value
        local handle = CTLS[key]
        if handle then pcall(function() handle:set(value) end) end
    end
    stickyModel = nil
    endEngagement()
    note("preset: " .. name)
end

local TEXT_ATTR = "SxText"
local function setButton(button, text)
    pcall(function()
        button:SetAttribute(TEXT_ATTR, text)
        button.Text = UI.t(text)
    end)
end

local function bindButton(card, caption, get, set)
    local button
    local function paint()
        setButton(button, caption .. ": " .. keyDisplay(get()))
    end
    button = card:Button(caption .. ": " .. keyDisplay(get()), function()
        if capturing then return end
        if TOUCH then
            setButton(button, caption .. ": no keyboard on this device")
            task.delay(2.5, paint)
            return
        end
        setButton(button, "PRESS A KEY OR MOUSE BUTTON  -  ESC CANCELS")
        arm(function(name)
            if name then set(name) end
            paint()
        end)
    end, UI.theme.band)
    return paint
end

-- ESP --------------------------------------------------------------------------

do
local espPage = win:Page("ESP", UI.icon.eye)

local drawCard = espPage:Card("DRAWING", 1):Accent()
drawCard:Toggle("Box", CONFIG.box, function(v) CONFIG.box = v end,
    "projected head to feet, so it scales with range by itself", UI.theme.good)
drawCard:Toggle("Filled box", CONFIG.boxFilled, function(v) CONFIG.boxFilled = v end)
drawCard:Toggle("Name", CONFIG.name, function(v) CONFIG.name = v end)
drawCard:Toggle("Bot marker", CONFIG.botTag, function(v) CONFIG.botTag = v end,
    "[BOT] or [P] - bots carry real-looking names and the HUD never says which is which",
    UI.theme.good)
drawCard:Toggle("Weapon", CONFIG.weaponTag, function(v) CONFIG.weaponTag = v end,
    "what they are holding, read from their own character")
drawCard:Toggle("Health bar", CONFIG.health, function(v) CONFIG.health = v end,
    "200 HP for everybody")
drawCard:Toggle("Distance", CONFIG.distance, function(v) CONFIG.distance = v end)
drawCard:Toggle("Spawn protection", CONFIG.protTag, function(v) CONFIG.protTag = v end,
    "greys them out - the game's own shot ignores a ForceField", UI.theme.warn)
drawCard:Toggle("Head dot", CONFIG.headDot, function(v) CONFIG.headDot = v end)
drawCard:Toggle("Skeleton", CONFIG.skeleton, function(v) CONFIG.skeleton = v end)
drawCard:Toggle("Tracer", CONFIG.tracer, function(v) CONFIG.tracer = v end)

local modeCard = espPage:Card("RANGE & VIEW", 2)
modeCard:Toggle("Wall check", CONFIG.visCheck, function(v) CONFIG.visCheck = v end,
    "the bullet's own filter: dead bodies, effects and your own team do not count as walls",
    UI.theme.good)
modeCard:Toggle("Show teammates", CONFIG.showTeam, function(v) CONFIG.showTeam = v end,
    "in their own colour; the aim and the trigger never touch them")
modeCard:Slider("Max distance", 100, 3000, CONFIG.maxDist, function(v)
    CONFIG.maxDist = v
end, "how far the ESP draws - the guns reach 500 studs")
modeCard:Slider("Text size", 12, 26, CONFIG.textSize, function(v) CONFIG.textSize = v end,
    "whole pixels; below 12 every Drawing face turns to mush")
modeCard:Dropdown("Font", FONTLIST, CONFIG.textFont, function(v) CONFIG.textFont = v end)
modeCard:Toggle("Text outline", CONFIG.textOutline, function(v) CONFIG.textOutline = v end)
modeCard:Toggle("Shrink with distance", CONFIG.textShrink, function(v)
    CONFIG.textShrink = v
end)

local colCard = espPage:Card("COLOURS", 1)
colCard:Colour("Real players", CONFIG.colEnemy, function(c) CONFIG.colEnemy = c end,
    "behind a wall the same colour is drawn at 55% brightness")
colCard:Colour("Bots", CONFIG.colBot, function(c) CONFIG.colBot = c end)
colCard:Colour("Teammates", CONFIG.colTeam, function(c) CONFIG.colTeam = c end)
colCard:Colour("Spawn protected", CONFIG.colProt, function(c) CONFIG.colProt = c end)
colCard:Colour("FOV circle", CONFIG.colFov, function(c) CONFIG.colFov = c end)

local chamCard = espPage:Card("CHAMS", 2)
chamCard:Toggle("Chams", CONFIG.chams, function(v)
    CONFIG.chams = v
    if not v then clearChams() end
end, "every character already carries the game's own outline, so ours lives outside the game tree",
    UI.theme.warn)
chamCard:Dropdown("Style", CHAM_LIST, CONFIG.chamStyle, function(v) CONFIG.chamStyle = v end)
chamCard:Toggle("Rainbow", CONFIG.chamRainbow, function(v) CONFIG.chamRainbow = v end)
chamCard:Toggle("Own cham colour", CONFIG.colChamOwn, function(v) CONFIG.colChamOwn = v end)
chamCard:Colour("Cham colour", CONFIG.colCham, function(c) CONFIG.colCham = c end)

local visCard = espPage:Card("CROSSHAIR", 0)
visCard:Toggle("Custom crosshair", CONFIG.crosshair, function(v) CONFIG.crosshair = v end)
visCard:Slider("Length", 2, 30, CONFIG.crossSize, function(v) CONFIG.crossSize = v end)
visCard:Slider("Gap", 0, 20, CONFIG.crossGap, function(v) CONFIG.crossGap = v end)
visCard:Slider("Thickness", 1, 5, CONFIG.crossThick, function(v) CONFIG.crossThick = v end)
visCard:Toggle("Centre dot", CONFIG.crossDot, function(v) CONFIG.crossDot = v end)
visCard:Colour("Crosshair colour", CONFIG.colCross, function(c) CONFIG.colCross = c end)
end

-- AIM --------------------------------------------------------------------------

local aimOut

do
local aimPage = win:Page("AIM", UI.icon.target)

local aimCard = aimPage:Card("ACTIVATION", 1):Accent()
reg("aim", aimCard:Toggle("Aim enabled", CONFIG.aim, function(v)
    CONFIG.aim = v
    note(v and "aim on" or "aim off")
end, "turns the game's own camera angles - the same call its console aim assist makes",
    UI.theme.warn))
aimCard:Dropdown("Trigger", { "Hotkey", "Always", "While firing", "Screen held" },
    CONFIG.aimActive, function(v) CONFIG.aimActive = v end)
bindButton(aimCard, "AIM KEY", function() return CONFIG.aimKey end,
    function(v) CONFIG.aimKey = v end)
if TOUCH then
    aimCard:Label("This device has no keyboard and no mouse - a hotkey it cannot press falls back to holding the screen.")
end
reg("aimPart", aimCard:Dropdown("Aim at", { "Head", "Body", "Nearest" },
    CONFIG.aimPart, function(v) CONFIG.aimPart = v end))
aimCard:Dropdown("Pick target by", { "Crosshair", "Closest", "Lowest HP" },
    CONFIG.aimPick, function(v) CONFIG.aimPick = v end)
reg("aimCurve", aimCard:Dropdown("Travel curve", { "Ease out", "Linear", "Human" },
    CONFIG.aimCurve, function(v) CONFIG.aimCurve = v end))
aimCard:Label("View path: a camera write is thrown away here (0.11 of 10 deg kept), the game's own angles hold (14.96 of 15). Mouse moves the real cursor instead, scaled by the game's own sensitivity.")
aimCard:Dropdown("View path", { "Game camera", "Mouse" }, CONFIG.aimPath,
    function(v) CONFIG.aimPath = v end)

local tuneCard = aimPage:Card("TUNING", 2)
reg("aimFov", tuneCard:Slider("FOV (pixels)", 5, 600, CONFIG.aimFov,
    function(v) CONFIG.aimFov = v end, "only targets inside this circle around the crosshair"))
reg("aimSmoothH", tuneCard:Slider("Smooth H", 1, 100, CONFIG.aimSmoothH,
    function(v) CONFIG.aimSmoothH = v end,
    "horizontal; 1 = instant, 50 = about a second, frame rate independent"))
reg("aimSmoothV", tuneCard:Slider("Smooth V", 1, 100, CONFIG.aimSmoothV,
    function(v) CONFIG.aimSmoothV = v end,
    "vertical - slower than H takes the give-away snap off the head"))
tuneCard:Slider("Max distance", 50, 500, CONFIG.aimMaxDist, function(v)
    CONFIG.aimMaxDist = v
end, "a gun's own ray stops at its MaxDist, 500 unless the weapon says otherwise")
reg("aimVisible", tuneCard:Toggle("Visible only", CONFIG.aimVisible,
    function(v) CONFIG.aimVisible = v end,
    "never aims at somebody the bullet ray cannot reach", UI.theme.good))
tuneCard:Toggle("Sticky target", CONFIG.aimSticky, function(v)
    CONFIG.aimSticky = v
    stickyModel = nil
end, "holds one target instead of flicking to whoever is a pixel closer", UI.theme.good)
tuneCard:Toggle("Skip spawn protected", CONFIG.aimSkipProt, function(v)
    CONFIG.aimSkipProt = v
end, "the game's own shot ignores a ForceField", UI.theme.good)
tuneCard:Toggle("Only while the gun can fire", CONFIG.aimReady, function(v)
    CONFIG.aimReady = v
end, "no tracking with a knife, an empty magazine or during a reload")
tuneCard:Toggle("Projectile prediction", CONFIG.predict, function(v)
    CONFIG.predict = v
end, "leads moving targets with bows and launchers - the game's own ProjSpeed and gravity; hitscan guns need none",
    UI.theme.good)
tuneCard:Dropdown("Scope condition", { "Always", "Scoped only", "Not scoped" },
    CONFIG.aimAds, function(v) CONFIG.aimAds = v end)

local fireCard = aimPage:Card("AUTO FIRE", 1)
reg("aimFire", fireCard:Toggle("Auto fire", CONFIG.aimFire,
    function(v) CONFIG.aimFire = v end,
    "fires through the game's own click while a target is on the crosshair", UI.theme.warn))
reg("aimHitPct", fireCard:Slider("Hit chance %", 1, 100, CONFIG.aimHitPct, function(v)
    CONFIG.aimHitPct = v
end, "below 100 deliberately skips shots"))
fireCard:Slider("Delay after kill (ms)", 0, 1500, CONFIG.aimKillMs, function(v)
    CONFIG.aimKillMs = v
end, "do not stay glued to a corpse - the most obvious tell there is")
fireCard:Toggle("Draw FOV circle", CONFIG.aimCircle, function(v) CONFIG.aimCircle = v end)

aimOut = aimPage:Card("TARGET", 2):Readout(7)
end

-- TRIGGER ----------------------------------------------------------------------

local trigOut

do
local trigPage = win:Page("TRIGGER", UI.icon.bolt)

local trigCard = trigPage:Card("TRIGGERBOT", 1):Accent()
reg("trig", trigCard:Toggle("Trigger enabled", CONFIG.trig, function(v)
    CONFIG.trig = v
    note(v and "trigger on" or "trigger off")
end, "fires when an enemy is under the crosshair - through the game's own click",
    UI.theme.warn))
trigCard:Dropdown("Trigger", { "Hotkey", "Always", "Screen held" }, CONFIG.trigActive,
    function(v) CONFIG.trigActive = v end)
bindButton(trigCard, "TRIGGER KEY", function() return CONFIG.trigKey end,
    function(v) CONFIG.trigKey = v end)
trigCard:Toggle("Head only", CONFIG.trigHeadOnly, function(v) CONFIG.trigHeadOnly = v end,
    "fires only when the ray lands on the head")
trigCard:Toggle("Skip spawn protected", CONFIG.trigSkipProt, function(v)
    CONFIG.trigSkipProt = v
end, "a shot at a ForceField does nothing", UI.theme.good)
trigCard:Dropdown("Scope condition", { "Always", "Scoped only", "Not scoped" },
    CONFIG.trigAds, function(v) CONFIG.trigAds = v end)
trigCard:Label("The trigger asks the game's own CanHit, so a teammate, a ForceField or a dead body can never set it off. Measured: 0.3s held on an automatic = 3 shots, 200 -> 56 HP.")

local trigTime = trigPage:Card("TIMING", 2)
reg("trigDelayMin", trigTime:Slider("Reaction min (ms)", 0, 500, CONFIG.trigDelayMin,
    function(v) CONFIG.trigDelayMin = v end,
    "with the humaniser on this is a bell curve, not a flat band"))
reg("trigDelayMax", trigTime:Slider("Reaction max (ms)", 0, 500, CONFIG.trigDelayMax,
    function(v) CONFIG.trigDelayMax = v end))
trigTime:Slider("Keep firing (ms)", 0, 800, CONFIG.trigHoldMs, function(v)
    CONFIG.trigHoldMs = v
end, "automatics: how long the button stays down after the target leaves the crosshair")
reg("trigHitPct", trigTime:Slider("Hit chance %", 1, 100, CONFIG.trigHitPct,
    function(v) CONFIG.trigHitPct = v end))
trigTime:Slider("Max distance", 50, 500, CONFIG.trigMaxDist, function(v)
    CONFIG.trigMaxDist = v
end)

trigOut = trigPage:Card("STATUS", 1):Readout(6)
end

-- SILENT -----------------------------------------------------------------------

local silentOut

do
local silentPage = win:Page("SILENT", UI.icon.sword)

local sCard = silentPage:Card("SILENT AIM", 1):Accent()
sCard:Label("Bends the shot instead of the view: the gun's own ray goes to the target, the game reports its own hit. Measured against the target's HP: an aimed shot 200 -> 152, the same shot 35.7 deg off the camera 200 -> 152. A wall still stops it. Off by default, in no preset.")
reg("silent", sCard:Toggle("Silent aim", CONFIG.silent, function(v)
    CONFIG.silent = v
    note(v and "silent aim ARMED" or "silent aim off")
end, "the loudest thing in this panel - the kill feed shows hits your view never pointed at",
    UI.theme.bad))
reg("silentMode", sCard:Dropdown("Reach", { "FOV circle", "Whole screen" }, CONFIG.silentMode,
    function(v) CONFIG.silentMode = v end))
reg("silentFov", sCard:Slider("FOV (pixels)", 5, 600, CONFIG.silentFov, function(v)
    CONFIG.silentFov = v
end, "a target has to be inside this circle"))
sCard:Toggle("Show the target", CONFIG.silentLine, function(v) CONFIG.silentLine = v end,
    "a line from the crosshair to where the next shot will go", UI.theme.good)
sCard:Toggle("Draw the circle", CONFIG.silentCircle, function(v)
    CONFIG.silentCircle = v
end, "the circle IS the reach of this feature", UI.theme.good)
sCard:Colour("Circle colour", CONFIG.colSilent, function(c) CONFIG.colSilent = c end)
sCard:Dropdown("Trigger", { "Hotkey", "Always", "Screen held" }, CONFIG.silentActive,
    function(v) CONFIG.silentActive = v end)
bindButton(sCard, "SILENT KEY", function() return CONFIG.silentKey end,
    function(v) CONFIG.silentKey = v end)
sCard:Dropdown("Aim at", { "Head", "Body" }, CONFIG.silentPart,
    function(v) CONFIG.silentPart = v end)
sCard:Dropdown("Pick target by", { "Crosshair", "Closest", "Lowest HP" },
    CONFIG.silentPick, function(v) CONFIG.silentPick = v end)
sCard:Toggle("Skip spawn protected", CONFIG.silentSkipProt, function(v)
    CONFIG.silentSkipProt = v
end, "a ForceField absorbs the shot", UI.theme.good)
sCard:Slider("Max distance", 50, 500, CONFIG.silentMaxDist, function(v)
    CONFIG.silentMaxDist = v
end)
sCard:Slider("Hit chance %", 1, 100, CONFIG.silentHitPct, function(v)
    CONFIG.silentHitPct = v
end, "below 100 some shots are left where you aimed - a perfect hit rate is its own tell")
sCard:Toggle("Also in duels", CONFIG.silentDuel, function(v)
    CONFIG.silentDuel = v
end, "a duel records your camera and every shot for the server - off means silent aim sleeps there",
    UI.theme.bad)

silentOut = silentPage:Card("STATUS", 2):Readout(8)
end

-- GUN --------------------------------------------------------------------------

local gunOut

do
local gunPage = win:Page("GUN", UI.icon.wrench)

local modCard = gunPage:Card("GUN MODS", 1):Accent()
modCard:Label("Each one rewrites a number in your weapon's own settings table and puts the original back when switched off. The client reports its own hits, so a tighter cone lands as a real hit.")
reg("noRecoil", modCard:Toggle("No recoil", CONFIG.noRecoil, function(v)
    CONFIG.noRecoil = v
end, "zeroes MinCamRecoil / MaxCamRecoil - the spring that kicks your view", UI.theme.warn))
reg("noKick", modCard:Toggle("No viewmodel kick", CONFIG.noKick, function(v)
    CONFIG.noKick = v
end, "the gun model only - cosmetic, it does not move the shot"))
reg("noSpread", modCard:Toggle("No spread", CONFIG.noSpread, function(v)
    CONFIG.noSpread = v
end, "zeroes Spread / BaseSpread - every bullet goes exactly where you aim", UI.theme.warn))
reg("rapid", modCard:Toggle("Rapid fire", CONFIG.rapid, function(v)
    CONFIG.rapid = v
end, "shortens the gap between shots - three shots with no gap all counted when measured",
    UI.theme.bad))
-- Whole-number slider, so the multiplier is set as a percentage.
modCard:Slider("Fire rate %", 100, 300, math.floor(CONFIG.rapidMult * 100 + 0.5), function(v)
    CONFIG.rapidMult = v / 100
end, "130 = 30% faster; the server was only ever tested on a 3-shot burst")
modCard:Toggle("Also in duels", CONFIG.modsDuel, function(v)
    CONFIG.modsDuel = v
end, "duels are recorded; off means the mods pause there and the originals come back",
    UI.theme.bad)

local handCard = gunPage:Card("HANDLING", 1)
handCard:Toggle("No sway / bob", CONFIG.noSway, function(v) CONFIG.noSway = v end,
    "the game's own NoSway flag - the one it sets while you inspect a gun")
handCard:Toggle("Instant ADS", CONFIG.instantAds, function(v) CONFIG.instantAds = v end,
    "ScopeSpeed - the scope-in animation only; the scoped spread applies the moment you press it")
reg("fastReload", handCard:Toggle("Fast reload", CONFIG.fastReload, function(v)
    CONFIG.fastReload = v
end, "speeds up the reload ANIMATION, which is what ends the reload here", UI.theme.warn))
handCard:Slider("Reload speed x", 1, 5, CONFIG.reloadMult, function(v) CONFIG.reloadMult = v end)
handCard:Toggle("Fast equip", CONFIG.fastEquip, function(v) CONFIG.fastEquip = v end,
    "the swap waits for the equip animation's DoneEquip marker - faster animation, faster swap")
handCard:Slider("Equip speed x", 1, 6, CONFIG.equipMult, function(v) CONFIG.equipMult = v end)

gunOut = gunPage:Card("YOUR WEAPON", 2):Readout(9)
end

-- MOVE -------------------------------------------------------------------------

local moveOut

do
local movePage = win:Page("MOVE", UI.icon.wave)

local speedCard = movePage:Card("WALKSPEED", 1):Accent()
speedCard:Label("Added to the game's own speed rather than written over it: the game sums BaseWS 16 + your weapon's WSDelta + 9 while sprinting, and this raises the weapon part. Sprint, slide and slows keep working on top.")
reg("speed", speedCard:Toggle("Speed boost", CONFIG.speed, function(v)
    CONFIG.speed = v
end, "movement is client-driven in Roblox - whether the server pulls you back is on the readout",
    UI.theme.warn))
speedCard:Slider("Extra speed (studs/s)", 1, 40, CONFIG.speedAdd, function(v)
    CONFIG.speedAdd = v
end, "normal is 16 walking, 25 sprinting")

local flyCard = movePage:Card("FLY", 2)
FLY_UI.handle = reg("fly", flyCard:Toggle("Fly", CONFIG.fly, function(v)
    CONFIG.fly = v
end, "WASD along the view, Space up, Ctrl down - on a phone the joystick flies where you look",
    UI.theme.bad))
flyCard:Slider("Fly speed", 10, 150, CONFIG.flySpeed, function(v)
    CONFIG.flySpeed = v
end)
bindButton(flyCard, "FLY KEY", function() return CONFIG.flyKey end,
    function(v) CONFIG.flyKey = v end)
flyCard:Toggle("Also in duels", CONFIG.moveDuel, function(v)
    CONFIG.moveDuel = v
end, "duels are recorded - off means speed and fly pause there", UI.theme.bad)

local jumpCard = movePage:Card("JUMP & SLIDE", 1)
reg("jumpOn", jumpCard:Toggle("High jump", CONFIG.jumpOn, function(v) CONFIG.jumpOn = v end,
    "holds Humanoid.JumpHeight - the game's own is 7 (+3 Lightweight, +10 Gravity coil)", UI.theme.warn))
jumpCard:Slider("Jump height", 7, 60, CONFIG.jumpHeight, function(v) CONFIG.jumpHeight = v end)
reg("infJump", jumpCard:Toggle("Air jump", CONFIG.infJump, function(v) CONFIG.infJump = v end,
    "jump again while falling", UI.theme.warn))
reg("noSlideCd", jumpCard:Toggle("No slide cooldown", CONFIG.noSlideCd, function(v)
    CONFIG.noSlideCd = v
end, "the 0.2-0.5s the game waits between slides (MovementController.CanSlide)"))

moveOut = movePage:Card("STATUS", 0):Readout(5)
end

-- WORLD ------------------------------------------------------------------------

do
local worldPage = win:Page("WORLD", UI.icon.map)

local visCard = worldPage:Card("VIEW", 1):Accent()
visCard:Toggle("Field of view", CONFIG.fovOn, function(v) CONFIG.fovOn = v end,
    "writes the game's own FOV setting (90 by default) - a camera write would be undone every frame")
visCard:Slider("FOV", 60, 120, CONFIG.fovValue, function(v) CONFIG.fovValue = v end)
visCard:Toggle("Fullbright", CONFIG.fullbright, function(v) CONFIG.fullbright = v end,
    "no shadows, full ambient light - put back exactly as it was when switched off")
visCard:Toggle("Custom time", CONFIG.timeOn, function(v) CONFIG.timeOn = v end)
visCard:Slider("Time of day", 0, 24, CONFIG.timeValue, function(v) CONFIG.timeValue = v end)
visCard:Toggle("No fog", CONFIG.noFog, function(v) CONFIG.noFog = v end)
visCard:Toggle("No blur / bloom / sun rays", CONFIG.noEffects, function(v) CONFIG.noEffects = v end,
    "depth of field, bloom and sun rays only - the menu blurs are left to the game")

local itemCard = worldPage:Card("ITEMS & TRACERS", 2)
itemCard:Toggle("Pickups", CONFIG.pickupEsp, function(v) CONFIG.pickupEsp = v end,
    "loot, heals, ammo, capsules and event items - the game's IgnoreThese.Pickups")
itemCard:Colour("Pickup colour", CONFIG.colPickup, function(c) CONFIG.colPickup = c end)
itemCard:Toggle("Grenades & projectiles", CONFIG.projEsp, function(v) CONFIG.projEsp = v end,
    "everything in IgnoreThese.Projectiles, in red")
itemCard:Toggle("Bullet tracers", CONFIG.tracers, function(v) CONFIG.tracers = v end,
    "your own shots, from the gun's tip to where the ray ends - the bent point while silent aim has one")
-- The template's slider is whole numbers only, so the life is set in ms.
itemCard:Slider("Tracer life (ms)", 100, 3000, math.floor(CONFIG.tracerLife * 1000 + 0.5),
    function(v) CONFIG.tracerLife = v / 1000 end)
itemCard:Colour("Tracer colour", CONFIG.colTracer, function(c) CONFIG.colTracer = c end)

local vmCard = worldPage:Card("VIEWMODEL", 1)
vmCard:Toggle("Colour your gun and arms", CONFIG.vmColour, function(v) CONFIG.vmColour = v end,
    "only you see it")
vmCard:Dropdown("Material", { "ForceField", "Neon", "Glass", "SmoothPlastic", "Foil" },
    CONFIG.vmMaterial, function(v) CONFIG.vmMaterial = v end)
vmCard:Colour("Colour", CONFIG.colVm, function(c) CONFIG.colVm = c end)
end

-- MISC -------------------------------------------------------------------------

local miscOut

do
local miscPage = win:Page("MISC", UI.icon.gear)

local sessCard = miscPage:Card("SESSION", 1):Accent()
sessCard:Toggle("Auto respawn", CONFIG.autoSpawn, function(v) CONFIG.autoSpawn = v end,
    "presses the game's own spawn (HomeFrame.TrySpawn) after a death - never the paid instant revive")
sessCard:Toggle("Anti-AFK", CONFIG.antiAfk, function(v) CONFIG.antiAfk = v end,
    "a step and a hop after 50s idle; Roblox's own 20-minute kick needs VirtualUser, which the anticheat names - not used")
sessCard:Button("REJOIN THIS SERVER", function() EXTRA.rejoin() end, UI.theme.band)
sessCard:Button("SERVER HOP", function() EXTRA.hop() end, UI.theme.band)

local staffCard = miscPage:Card("STAFF", 2)
staffCard:Toggle("Staff alert", CONFIG.staffAlert, function(v) CONFIG.staffAlert = v end,
    "CanAccessAdminPanel on a player, or a tester / creator / developer rank in the game's group", UI.theme.good)
staffCard:Toggle("Panic when staff joins", CONFIG.staffPanic, function(v) CONFIG.staffPanic = v end,
    "switches aim, trigger, silent aim, rapid fire and movement off by itself", UI.theme.warn)
staffCard:Toggle("Streamer mode", CONFIG.streamer, function(v) CONFIG.streamer = v end,
    "your name in your own screen's labels is replaced - nobody else is affected")
staffCard:Dropdown("Shown name", { "Player", "Guest", "Selux", "Hidden" }, CONFIG.streamerName,
    function(v) CONFIG.streamerName = v end)

local skinCard = miscPage:Card("SKINS - ONLY YOU SEE THEM", 1)
skinCard:Label("The server builds your skins from your own inventory and other players read them from the server, so these change your screen and nobody else's.")
skinCard:Toggle("Skin changer", CONFIG.skinOn, function(v) CONFIG.skinOn = v end)
if #EXTRA.skinList > 0 then
    skinCard:Dropdown("Skin", EXTRA.skinList, CONFIG.skinName, function(v) CONFIG.skinName = v end)
end
skinCard:Toggle("Kill effect", CONFIG.killVfxOn, function(v) CONFIG.killVfxOn = v end,
    "the effect YOUR kills play on your screen")
if #EXTRA.killList > 0 then
    skinCard:Dropdown("Effect", EXTRA.killList, CONFIG.killVfx, function(v) CONFIG.killVfx = v end)
end

miscOut = miscPage:Card("STATUS", 2):Readout(7)
end

-- HUMAN ------------------------------------------------------------------------

local humOut

do
local humPage = win:Page("HUMAN", UI.icon.shield)

local preCard = humPage:Card("PRESETS", 1):Accent()
preCard:Label("Three sets that write every number on this page at once. Everything stays editable afterwards.")
preCard:Button("LEGIT", function() applyPreset("Legit") end, UI.theme.good)
preCard:Button("NORMAL", function() applyPreset("Normal") end, UI.theme.band)
preCard:Button("RAW", function() applyPreset("Raw") end, UI.theme.bad)
reg("hum", preCard:Toggle("Humaniser", CONFIG.hum, function(v) CONFIG.hum = v end,
    "off means every number below is ignored", UI.theme.warn))
preCard:Toggle("Bots only", CONFIG.humBotOnly, function(v)
    CONFIG.humBotOnly = v
    stickyModel = nil
end, "aim, trigger and silent aim never touch a real player", UI.theme.good)

local tellCard = humPage:Card("TELLS", 2)
reg("humTurnCap", tellCard:Slider("Turn speed cap (deg/s)", 40, 3000, CONFIG.humTurnCap,
    function(v) CONFIG.humTurnCap = v end,
    "the big one - a fast human flick is roughly 400-900 deg/s"))
reg("humDeadzone", tellCard:Slider("Deadzone (px)", 0, 20, CONFIG.humDeadzone,
    function(v) CONFIG.humDeadzone = v end, "inside this the view is left completely alone"))
reg("humWindupMin", tellCard:Slider("Wind-up min (ms)", 0, 400, CONFIG.humWindupMin,
    function(v) CONFIG.humWindupMin = v end,
    "nothing moves for this long after a target is acquired"))
reg("humWindupMax", tellCard:Slider("Wind-up max (ms)", 0, 600, CONFIG.humWindupMax,
    function(v) CONFIG.humWindupMax = v end))
reg("humOffsetPct", tellCard:Slider("Aim offset (% of the part)", 0, 90,
    CONFIG.humOffsetPct, function(v) CONFIG.humOffsetPct = v end,
    "never the exact centre of the hitbox twice"))
reg("humRerollMs", tellCard:Slider("Re-roll the offset (ms)", 200, 4000,
    CONFIG.humRerollMs, function(v) CONFIG.humRerollMs = v end))
reg("humJitter", tellCard:Slider("Drift (studs at 100m)", 0, 4, CONFIG.humJitter,
    function(v) CONFIG.humJitter = v end,
    "a smooth random walk, not per-frame noise - noise reads as a stutter"))
reg("humOvershoot", tellCard:Slider("Overshoot %", 0, 100, CONFIG.humOvershoot,
    function(v) CONFIG.humOvershoot = v end, "a flick that stops dead on target is not a hand"))
reg("humHeadPct", tellCard:Slider("Head share %", 0, 100, CONFIG.humHeadPct,
    function(v) CONFIG.humHeadPct = v end,
    "head every single time is its own pattern - the rest go to the body"))
reg("humBreakPct", tellCard:Slider("Break off % per second", 0, 40, CONFIG.humBreakPct,
    function(v) CONFIG.humBreakPct = v end,
    "scaled by dt, so it behaves the same at 60 and at 240 FPS"))
reg("humFatigue", tellCard:Slider("Fatigue % per second", 0, 120, CONFIG.humFatigue,
    function(v) CONFIG.humFatigue = v end))
reg("humCooldown", tellCard:Slider("Pause between engagements (ms)", 0, 1200,
    CONFIG.humCooldown, function(v) CONFIG.humCooldown = v end))
reg("humSwitchMs", tellCard:Slider("Target switch lock (ms)", 0, 1500,
    CONFIG.humSwitchMs, function(v) CONFIG.humSwitchMs = v end,
    "stops the twitch between two targets a pixel apart"))
reg("humMoveFov", tellCard:Slider("FOV while moving %", 10, 100, CONFIG.humMoveFov,
    function(v) CONFIG.humMoveFov = v end))
reg("humMissPct", tellCard:Slider("Deliberate misses %", 0, 40, CONFIG.humMissPct,
    function(v) CONFIG.humMissPct = v end))
reg("humReactSd", tellCard:Slider("Reaction spread (ms)", 1, 120, CONFIG.humReactSd,
    function(v) CONFIG.humReactSd = v end))

local safeCard = humPage:Card("SAFETY", 1)
safeCard:Toggle("Off while the panel is open", CONFIG.humPanelPause, function(v)
    CONFIG.humPanelPause = v
end, "nothing should assist while you are clicking in here")
safeCard:Toggle("Pause while spectated", CONFIG.specPause, function(v)
    CONFIG.specPause = v
end, "reads SpectatorCount - late in a round everybody alive is watched, so this is off by default")
safeCard:Label("Panic key: switches aim, trigger, auto fire, silent aim and rapid fire off at once")
bindButton(safeCard, "PANIC KEY", function() return CONFIG.panicKey end,
    function(v) CONFIG.panicKey = v end)
table.insert(panicHandlers, function()
    for _, key in ipairs({ "aim", "trig", "aimFire", "silent", "rapid", "fly", "speed",
        "jumpOn", "infJump", "noSlideCd" }) do
        local handle = CTLS[key]
        if handle then pcall(function() handle:set(false) end) end
    end
end)

humOut = humPage:Card("STATUS", 1):Readout(6)
end

-- ROUND ------------------------------------------------------------------------

local roundOut, listOut, statOut

do
local infoPage = win:Page("ROUND", UI.icon.list)
roundOut = infoPage:Card("ROUND", 1):Readout(7)
statOut  = infoPage:Card("YOU", 2):Readout(8)
listOut  = infoPage:Card("TARGETS", 0):Readout(11, function(text)
    if text:find("%[BOT%]") then return Color3.fromRGB(255, 176, 60) end
    if text:find("%[P%]") then return Color3.fromRGB(255, 110, 120) end
    return nil
end)
end

--------------------------------------------------------------------------------
-- the panel refresh
--------------------------------------------------------------------------------

local function statOf(name, key)
    local folder = StatsDir and StatsDir:FindFirstChild(name)
    local v = folder and folder:FindFirstChild(key)
    return v and tonumber(v.Value) or nil
end

local function gameMode()
    if not GameInfo then return "-" end
    local name = GameInfo:GetAttribute("GamemodeName")
    if name then return tostring(name) end
    for _, v in ipairs(GameInfo:GetChildren()) do
        if v:IsA("BoolValue") and v.Value then return v.Name end
    end
    return "-"
end

local function clock(sec)
    sec = math.max(0, math.floor(tonumber(sec) or 0))
    return string.format("%d:%02d", math.floor(sec / 60), sec % 60)
end

local baseKills, baseDeaths = nil, nil

task.spawn(function()
    claimIdentity()
    while _G.__HYPER == GEN do
        local ok, err = pcall(function()
            local c = ctl()
            local tool = c and c.Shared.CurrTool
            STATE.deployed = c ~= nil and not c.Shared.Dead
            STATE.duel = inDuel()
            STATE.spectators = tonumber(plr:GetAttribute("SpectatorCount")) or 0
            STATE.weapon = tool and tostring(tool.Name) or "-"

            STATE.kills   = statOf(plr.Name, "Kills") or 0
            STATE.deaths  = statOf(plr.Name, "Deaths") or 0
            STATE.assists = statOf(plr.Name, "Assists") or 0
            STATE.damage  = statOf(plr.Name, "DamageDealt") or 0
            if baseKills == nil then baseKills, baseDeaths = STATE.kills, STATE.deaths end
            -- PlayerStats is per MATCH: a new match resets it, and the session base
            -- follows it down rather than showing a negative count.
            if STATE.kills < baseKills or STATE.deaths < baseDeaths then
                baseKills, baseDeaths = STATE.kills, STATE.deaths
            end
            STATE.sessionKills = STATE.kills - baseKills
            STATE.sessionDeaths = STATE.deaths - baseDeaths

            local myTeam = plr:GetAttribute("Team")
            local s1 = GameInfo and GameInfo:FindFirstChild("TeamScores")
                and GameInfo.TeamScores:FindFirstChild("Team1")
            local s2 = GameInfo and GameInfo:FindFirstChild("TeamScores")
                and GameInfo.TeamScores:FindFirstChild("Team2")
            local mine, theirs = "-", "-"
            if s1 and s2 then
                if myTeam == 2 then mine, theirs = s2.Value, s1.Value
                else mine, theirs = s1.Value, s2.Value end
            end

            local camPos = camera.CFrame.Position
            local rows = {}
            for _, entry in ipairs(combatants()) do
                if not entry.team or CONFIG.showTeam then
                    local hp, _, root = aliveOf(entry.model)
                    local dist = root and math.floor((camPos - root.Position).Magnitude) or nil
                    local kills = entry.player and statOf(entry.player.Name, "Kills")
                        or statOf(entry.model.Name, "Kills")
                    rows[#rows + 1] = {
                        alive = hp ~= nil,
                        dist = dist or 99999,
                        line = string.format(" %-5s %-17s %-6s %-20s %-5s %-6s %s",
                            entry.mob and "[MOB]" or (entry.bot and "[BOT]" or "[P]"),
                            tostring(entry.name):sub(1, 17),
                            hp and (math.floor(hp) .. "hp") or "DEAD",
                            tostring(weaponOf(entry.model) or "-"):sub(1, 20),
                            kills and tostring(kills) or "-",
                            dist and (dist .. "m") or "-",
                            entry.team and "TEAM" or (protectedOf(entry.model) and "PROT" or "")),
                    }
                end
            end
            table.sort(rows, function(a, b)
                if a.alive ~= b.alive then return a.alive end
                return a.dist < b.dist
            end)
            local lines = { " KIND  NAME              HP     WEAPON               K     DIST   STATE" }
            for i = 1, math.min(#rows, 10) do lines[#lines + 1] = rows[i].line end
            if #rows == 0 then lines[#lines + 1] = "  nobody here - in the lobby?" end
            pcall(function() listOut:set(lines) end)

            pcall(function()
                roundOut:set({
                    "  mode      " .. gameMode() .. "   map "
                        .. tostring(GameInfo and GameInfo:GetAttribute("MapName") or "-"),
                    "  score     " .. tostring(mine) .. " : " .. tostring(theirs)
                        .. "   to " .. tostring(GameInfo and GameInfo:GetAttribute("ScoreLimit") or "-")
                        .. "   time " .. clock(GameInfo and GameInfo:GetAttribute("Timer")),
                    "  team      " .. tostring(myTeam or "-")
                        .. ((myTeam == -1) and "  (free for all)" or ""),
                    "  state     " .. (STATE.deployed and "deployed" or "lobby / dead")
                        .. (STATE.duel and "   DUEL - recorded" or ""),
                    string.format("  drawn     %d  (%d bots, %d players)", STATE.targets,
                        STATE.bots, STATE.humans),
                    "  watching  " .. tostring(STATE.spectators) .. " spectator(s)",
                    "  chams     " .. (chamsBroken and ("OFF - " .. tostring(chamsBroken))
                        or (CONFIG.chams and "on" or "available, switched off")),
                })
            end)

            pcall(function()
                statOut:set({
                    string.format("  %s   level %s   %s RR", tostring(plr:GetAttribute("Rank") or "-"),
                        tostring(plr:GetAttribute("Level") or "-"),
                        tostring(plr:GetAttribute("RankRR") or "-")),
                    string.format("  match     %d kills  %d deaths  %d assists", STATE.kills,
                        STATE.deaths, STATE.assists),
                    string.format("  damage    %d", STATE.damage),
                    string.format("  session   +%d kills  +%d deaths", STATE.sessionKills,
                        STATE.sessionDeaths),
                    "  weapon    " .. STATE.weapon,
                    "  flags     sss " .. tostring(plr:GetAttribute("sss") == true)
                        .. "   (spread re-roll in the game's own Hitscan)",
                    "  anticheat Luraph client check via Aishiteru - this script",
                    "            hooks nothing and uses no VirtualInputManager",
                })
            end)

            pcall(function()
                aimOut:set({
                    "  target   " .. tostring(STATE.target) .. "  (" .. tostring(STATE.targetKind) .. ")",
                    "  active   " .. (CONFIG.aim and CONFIG.aimActive or "off")
                        .. (CONFIG.aimActive == "Hotkey"
                            and ("  " .. (reachable(CONFIG.aimKey) and keyDisplay(CONFIG.aimKey) or "screen")) or ""),
                    string.format("  now      FOV %dpx   H %d   V %d   at %s",
                        CONFIG.aimFov, CONFIG.aimSmoothH, CONFIG.aimSmoothV, CONFIG.aimPart),
                    "  path     " .. CONFIG.aimPath .. ((CONFIG.aimPath == "Mouse" and not mouseMove)
                        and "  (no mousemoverel - using the game camera)" or ""),
                    "  blocked  " .. ((STATE.paused ~= "") and STATE.paused or "no"),
                    string.format("  turning  %.0f deg/s   peak %.0f   cap %d",
                        STATE.aimDps, STATE.aimDpsPeak, CONFIG.humTurnCap),
                    "  weapon   " .. STATE.weapon,
                })
            end)

            pcall(function()
                trigOut:set({
                    "  state     " .. (CONFIG.trig and (STATE.trigOn and "armed"
                        or ("waiting for " .. (reachable(CONFIG.trigKey) and keyDisplay(CONFIG.trigKey)
                            or "a finger on the screen"))) or "off"),
                    "  crosshair " .. tostring(STATE.underCross),
                    "  click     the game's own (MouseDown + Controller:LeftClick)",
                    string.format("  clicks    %d   reaction %d-%dms", STATE.trigShots,
                        CONFIG.trigDelayMin, CONFIG.trigDelayMax),
                    "  weapon    " .. STATE.weapon .. ((tool and tool.IsAuto) and "  (automatic)" or ""),
                    "  holding   " .. tostring(weHold),
                })
            end)

            pcall(function()
                silentOut:set({
                    "  state     " .. (CONFIG.silent and (STATE.silentOn and "ARMED" or "idle") or "off"),
                    "  target    " .. tostring(STATE.silentTarget),
                    "  note      " .. tostring(STATE.silentNote),
                    string.format("  bent      %d shots so far", STATE.silentBent),
                    "  installed " .. tostring(SIL.installedOn ~= nil)
                        .. "   (the game's own GetMousePos is back when idle)",
                    "  MEASURED  aimed 200 -> 152   35.7 deg off camera 200 -> 152",
                    "            the server does not compare the shot to your view",
                    "  duels     " .. (CONFIG.silentDuel and "ON - every shot is recorded" or "sleeps there"),
                })
            end)

            pcall(function()
                local w = tool and tool.WSettings or {}
                local deb = tonumber(original(w, "Debounce")) or 0
                gunOut:set({
                    "  weapon    " .. STATE.weapon .. "   " .. tostring(w.Type or ""),
                    string.format("  damage    %s body   %s head", tostring(w.Damage or "-"),
                        tostring(w.HeadDamage or "-")),
                    string.format("  fire      %.3fs between shots  (%d rpm)%s", deb,
                        deb > 0 and math.floor(60 / deb) or 0, (tool and tool.IsAuto) and "  auto" or ""),
                    string.format("  spread    %s  base %s", tostring(original(w, "Spread") or "-"),
                        tostring(original(w, "BaseSpread") or "-")),
                    string.format("  ammo      %s / %s   range %s", tostring(tool and tool.Ammo or "-"),
                        tostring(w.Ammo or "-"), tostring(w.MaxDist or 500)),
                    "  active    " .. tostring(STATE.mods),
                    "  MEASURED  3 shots, no gap, P90 45 dmg: 200 -> 65 = all 3 counted",
                    "  recoil    camera = MinCamRecoil/MaxCamRecoil, the rest is",
                    "            the viewmodel (ViewModel.Recoil)",
                })
            end)

            pcall(function()
                local char = plr.Character
                local hum = char and char:FindFirstChildWhichIsA("Humanoid")
                local root = char and char:FindFirstChild("HumanoidRootPart")
                local v = root and root.AssemblyLinearVelocity or Vector3.new()
                moveOut:set({
                    string.format("  walkspeed %s   moving %.0f studs/s flat, %.0f vertical",
                        hum and string.format("%.1f", hum.WalkSpeed) or "-",
                        Vector3.new(v.X, 0, v.Z).Magnitude, v.Y),
                    "  speed     " .. (CONFIG.speed and ("+" .. CONFIG.speedAdd) or "off")
                        .. "   fly " .. (CONFIG.fly and ("on, " .. CONFIG.flySpeed .. " studs/s") or "off")
                        .. "   key " .. keyDisplay(CONFIG.flyKey),
                    string.format("  pulled back by the server  %d time(s)%s", snap.count,
                        snap.count > 0 and string.format(", last %.0fs ago", os.clock() - snap.last) or ""),
                    "  duel      " .. (STATE.duel and (CONFIG.moveDuel and "ON in this duel" or "paused - duel")
                        or "not in a duel"),
                    "  height    " .. (root and string.format("%.0f", root.Position.Y) or "-"),
                })
            end)

            pcall(function()
                local staff = {}
                for name, why in pairs(EXTRA.staff or {}) do staff[#staff + 1] = name .. " (" .. why .. ")" end
                local c2 = ctl()
                local set = c2 and c2.Shared.MenuCoreData and c2.Shared.MenuCoreData.Settings
                miscOut:set({
                    "  staff     " .. ((#staff > 0) and table.concat(staff, ", ") or "none seen"),
                    "  spawns    " .. tostring(STATE.spawns or 0) .. " by auto respawn"
                        .. "   afk nudges " .. tostring(STATE.afkNudges or 0),
                    "  fov       setting " .. tostring(set and set.FOV or "-")
                        .. "   camera " .. string.format("%.0f", camera.FieldOfView),
                    "  skin      " .. (CONFIG.skinOn and CONFIG.skinName or "off")
                        .. "   kill effect " .. (CONFIG.killVfxOn and CONFIG.killVfx or "off"),
                    "  skins and kill effects are drawn on YOUR screen only",
                    "  place     " .. tostring(game.PlaceId),
                    "  server    " .. tostring(game.JobId):sub(1, 18),
                })
            end)

            pcall(function()
                humOut:set({
                    "  humaniser " .. (CONFIG.hum and "on" or "OFF"),
                    "  blocked   " .. ((STATE.paused ~= "") and STATE.paused or "no"),
                    "  scope     " .. (CONFIG.humBotOnly and "bots only" or "everybody"),
                    "  engagement " .. (engagement and string.format("%s  %s  %.1fs", engagement.name,
                        engagement.head and "head" or "body", os.clock() - engagement.t0) or "-"),
                    string.format("  turning   %.0f deg/s   peak %.0f   cap %d",
                        STATE.aimDps, STATE.aimDpsPeak, CONFIG.humTurnCap),
                    "  panel     " .. (panelOpen() and "open" or "closed")
                        .. "   panic " .. keyDisplay(CONFIG.panicKey)
                        .. "   spectators " .. tostring(STATE.spectators),
                })
            end)

            pcall(function()
                win:SetStat(1, tostring(STATE.kills), "kills")
                win:SetStat(2, tostring(STATE.deaths), "deaths")
                win:SetStat(3, tostring(STATE.targets), "drawn")
                win:SetNote(STATE.note ~= "" and STATE.note or "Ready")
                win:SetStatus(string.format("%s   %s   %s   %d bots / %d players",
                    gameMode(),
                    STATE.deployed and "deployed" or "lobby",
                    STATE.duel and "DUEL" or clock(GameInfo and GameInfo:GetAttribute("Timer")),
                    STATE.bots, STATE.humans))
            end)
        end)
        if not ok then note("ui: " .. tostring(err)) end
        task.wait(0.4)
    end
end)

-- A switch whose master is off reads as a dead toggle; flipping it on arms the
-- master with it and says so (the auto-arm rule from the shooter genre file).
local ARM_AIM = { "aimFire", "aimCircle" }

task.spawn(function()
    claimIdentity()
    local was = {}
    for _, key in ipairs(ARM_AIM) do was[key] = CONFIG[key] and true or false end
    while _G.__HYPER == GEN do
        for _, key in ipairs(ARM_AIM) do
            local on = CONFIG[key] and true or false
            if on and not was[key] and not CONFIG.aim then
                CONFIG.aim = true
                local handle = CTLS["aim"]
                if handle then pcall(function() handle:set(true) end) end
                note("Aim was off - switched on with it")
            end
            was[key] = on
        end
        task.wait(0.2)
    end
end)

pcall(function() win:Home() end)
win:Refresh()

--------------------------------------------------------------------------------

_G.__HYPER_DBG = {
    CONFIG = CONFIG, STATE = STATE, SIL = SIL, MP = MP, ORIG = ORIG,
    ctl = ctl, actionHandler = actionHandler, gameUIMod = gameUIMod,
    currentTool = currentTool, gunReady = gunReady, inDuel = inDuel,
    combatants = combatants, aliveOf = aliveOf, protectedOf = protectedOf,
    sameTeam = sameTeam, weaponOf = weaponOf, headPart = headPart, bodyPart = bodyPart,
    visibleTo = visibleTo, underCrosshair = underCrosshair, bulletIgnore = bulletIgnore,
    weaponRange = weaponRange, crosshairPos = crosshairPos,
    bestTarget = bestTarget, pickTarget = pickTarget, aimPass = aimPass,
    wantAngles = wantAngles, moveView = moveView,
    silentInstall = silentInstall, silentUninstall = silentUninstall, silentPass = silentPass,
    shotLands = shotLands, landingPoint = landingPoint,
    applyMods = applyMods, restoreAllMods = restoreAllMods, applySpeed = applySpeed,
    flyStep = flyStep, snap = snap, modelFromPart = modelFromPart,
    pressFire = pressFire, releaseFire = releaseFire,
    renderPass = renderPass, hideAll = hideAll, clearChams = clearChams,
    applyPreset = applyPreset, PRESETS = PRESETS, CTLS = CTLS,
    note = note, panelOpen = panelOpen, assistBlocked = assistBlocked,
    TOUCH = TOUCH, screenHeld = screenHeld, reachable = reachable, hotkeyHeld = hotkeyHeld,
    GS = GS, CC = CC, EXTRA = EXTRA,
}

if TOUCH then note("phone: hotkeys hold the screen instead") end

print("[hypershot] gen " .. GEN .. " ready - RightShift for the panel"
    .. (TOUCH and "  (touch client)" or ""))

Hypershot Script 2026 (Zephyr UI) | Slient Aim, ESP, FOV and More

Hypershot Script 2026 (Zephyr UI)

loadstring(game:HttpGet("https://raw.githubusercontent.com/TheRealAvrwm/Zephyr-V2/refs/heads/main/Hypershot.lua", true))()

Script Hypershot PC and Mobile: Aimbot, ESP, Wallhack, Kill Aura

Script Hypershot PC and Mobile

loadstring(game:HttpGet("https://pastebin.com/raw/RZK9XdtH"))()

[👾HACKER] Hypershot Best Script - ESP Bots, Players, Aimbot Bots Or Players

Hypershot Best Script - ESP Bots, Players, Aimbot Bots Or Players

loadstring(game:HttpGet("https://raw.githubusercontent.com/Kenniel123/HyperShot/refs/heads/main/Legit%20HyperShot"))()

Hypershot Script Z3US - LegitBot, RageBot, ESP, Aimbot and More

Hypershot Script

loadstring(game:HttpGet("https://raw.githubusercontent.com/blackowl1231/Z3US/refs/heads/main/main.lua"))()

Hypershot New Script - Super Aimbot, ESP, Fun

Hypershot New Script - Super Aimbot, ESP, Fun

loadstring(game:HttpGet("https://raw.githubusercontent.com/FeykHere/FeykhubOrignal/refs/heads/main/Feykhubloader"))()

[⚡CONTENT UPD] Hypershot Script Flow Hub - Aimbot, Hitbox Expander, ESP, Inf Ammo

Hypershot Script - Aimbot, Hitbox Expander, ESP, Inf Ammo

local key = 'scriptkey'

shared = shared or {}
shared.__KEY_INPUT = key

loadstring(game:HttpGet("https://raw.githubusercontent.com/n1hitt/haunt.lol/refs/heads/main/rewind"))()

Hypershot Script Roblox (No Key) - Silent Aim

local Players = game:GetService("Players")
local LocalPlayer = Players.LocalPlayer
local Camera = workspace.CurrentCamera
local Mouse = LocalPlayer:GetMouse()
local WorldToScreenPoint = Camera.WorldToScreenPoint
local GetPlayers = Players.GetPlayers
local FindFirstChild = game.FindFirstChild
local function GetOnScreenPosition(V3)
    local Position, IsVisible = WorldToScreenPoint(Camera, V3)
    return Vector2.new(Position.X, Position.Y), IsVisible
end
local function GetDirection(Origin, Position)
    return (Position - Origin).Unit * (Origin - Position).Magnitude
end
local function GetMousePosition()
    return Vector2.new(Mouse.X, Mouse.Y)
end
local function GetClosestPlayer()
    local Closest, Distance = nil, 10000
    for _, Player in next, GetPlayers(Players) do
        if Player ~= LocalPlayer then
            local Character = Player.Character
            local Head = Character and FindFirstChild(Character, "Head")
            local Humanoid = Character and FindFirstChild(Character, "Humanoid")
            if Head and (Humanoid and Humanoid.Health > 0) then
                local ScreenPos, IsVisible = GetOnScreenPosition(Head.Position)
                if IsVisible then
                    local _Distance = (GetMousePosition() - ScreenPos).Magnitude
                    if _Distance <= Distance then
                        Closest = Head
                        Distance = _Distance
                    end
                end
            end
        end
    end
    return Closest, Distance
end
local oldNamecall
oldNamecall =
    hookmetamethod(
    game,
    "__namecall",
    function(...)
        local Method = getnamecallmethod()
        local Arguments = {...}
        if Arguments[1] == workspace and Method == "Raycast" then
            if typeof(Arguments[#Arguments]) ~= "RaycastParams" then
                return oldNamecall(...)
            end
            local HitPart = GetClosestPlayer()
            if HitPart then
                Arguments[3] = GetDirection(Arguments[2], HitPart.Position)
                return oldNamecall(unpack(Arguments))
            end
        end
        return oldNamecall(...)
    end
)

Hypershot Script PC Work - Gun Mods, ESP, No Cooldowns

Hypershot Script PC Work

loadstring(game:HttpGet("https://pastebin.com/raw/RUjauPW6"))()

Hypershot Script - Aimbot, Rapid Fire, Auto Spawn

Hypershot Script Rinns Hub

loadstring(game:HttpGet("https://raw.githubusercontent.com/Seisen88/Seisen-Hub-List/refs/heads/main/main.lua"))()

Hypershot Hack GUI - Aimbot, ESP, Rapid Fire, Kill All

Hypershot Hack GUI

loadstring(game:HttpGet("https://pastefy.app/ULaWpxKm/raw"))()

Hypershot Script PC, Mobile - Aimbot, ESP, Fov, Line

The Best Script Hypershot

loadstring(game:HttpGet("https://pastebin.com/raw/BrJcNZTh"))()

Hypershot Script No Key - Simple HitBox

loadstring(game:HttpGet('https://raw.githubusercontent.com/abramsonhan/RScritps/refs/heads/main/Hypershot%3A%20Hitbox%20Extenderw12312312'))()

NEW! Hypershot (Gunfight) - Gun Mode

for _, v in next, getgc(true) do
    if typeof(v) == 'table' and rawget(v, 'Spread') then
        rawset(v, 'Spread', 0)
        rawset(v, 'BaseSpread', 0)
        rawset(v, 'MinCamRecoil', Vector3.new())
        rawset(v, 'MaxCamRecoil', Vector3.new())
        rawset(v, 'MinRotRecoil', Vector3.new())
        rawset(v, 'MaxRotRecoil', Vector3.new())
        rawset(v, 'MinTransRecoil', Vector3.new())
        rawset(v, 'MaxTransRecoil', Vector3.new())
        rawset(v, 'ScopeSpeed', 100)
        print('ok')
    end
end

Hitbox Expander Script Hypershot

-- Hitbox Expander
 
-- Credits to the owners
 
loadstring(game:HttpGet("https://raw.githubusercontent.com/hm5650/Hitblox/refs/heads/main/Hitblox"))()

ChangeLogs:

6-11-2026, 05:40: - Added Hypershot Script Selux Hub (NO KEY) | AFK Auto Fire, Silent Aim

Comments: 1 Views: 329 215

1 comments

  1. tapnstomp
    User
     1
     0
    24 November 2025 05:42

    Mobile support is HUGE. Used it on my tablet and it legit feels smoother than most PC-only scripts.


EXPLORE

Game hubs

R Roblox Scripts Game-specific scripts & updates CS2 CS2 Cheats ESP, aimbot, wallhack & more
ROBLOX TOOLKIT

Useful resources

Roblox ExecutorsBrowse available tools Roblox Game CodesCodes, rewards and boosts How to use scriptsRead the beginner's guide
COMMUNITY

New comments

View all
olchype
mdr100
KEEP EXPLORING

Related publications

Stay safe

Review each post's source, status and compatibility notes. Never share your game account password or download unknown files blindly.