Humanized Aim Assistance Lua Script

-- rebind: min_sdk=0.1.0
-- rebind: name=Aim Trainer
-- rebind: description=Humanized aim assistance with prediction, acceleration, and smart triggering

local cfg = UI.Schema({
    -- Master
    enabled = UI.Toggle(true, { label = "Enable", group = "Master" }),
    
    -- Aim Assistance
    aim_strength = UI.Slider(100, { min = 0, max = 200, suffix = "%", label = "Aim Strength", group = "Aim Assistance" }),
    smoothing = UI.Slider(0.15, { min = 0, max = 0.5, step = 0.01, label = "Smoothing (0-0.5)", group = "Aim Assistance", tooltip = "Exponential smoothing factor. Higher = smoother but more lag" }),
    accel_start = UI.Slider(5, { min = 0, max = 50, suffix = "px", label = "Accel Start Distance", group = "Aim Assistance", tooltip = "Distance before acceleration kicks in" }),
    accel_curve = UI.Slider(1.8, { min = 0.5, max = 3.0, step = 0.1, label = "Accel Curve", group = "Aim Assistance", tooltip = "Higher = more aggressive acceleration" }),
    decel_factor = UI.Slider(0.85, { min = 0.5, max = 1.0, step = 0.05, label = "Deceleration", group = "Aim Assistance", tooltip = "Brake factor when approaching target" }),

    -- Prediction
    prediction_enabled = UI.Toggle(true, { label = "Enable Prediction", group = "Prediction" }),
    prediction_strength = UI.Slider(0.6, { min = 0, max = 1.0, step = 0.05, label = "Prediction Strength", group = "Prediction" }),
    jitter_amount = UI.Slider(1.5, { min = 0, max = 5, step = 0.1, label = "Human Jitter", group = "Prediction", tooltip = "Simulate natural hand tremor" }),

    -- Trigger Bot
    trigger_enabled = UI.Toggle(true, { label = "Enable Trigger Bot", group = "Trigger Bot" }),
    trigger_key = UI.Keybind("Mouse1", { label = "Trigger Key", group = "Trigger Bot" }),
    trigger_delay_min = UI.Slider(50, { min = 0, max = 500, suffix = "ms", label = "Min Reaction Time", group = "Trigger Bot" }),
    trigger_delay_max = UI.Slider(150, { min = 50, max = 1000, suffix = "ms", label = "Max Reaction Time", group = "Trigger Bot" }),
    trigger_hold_min = UI.Slider(20, { min = 10, max = 100, suffix = "ms", label = "Min Hold Duration", group = "Trigger Bot" }),
    trigger_hold_max = UI.Slider(60, { min = 20, max = 200, suffix = "ms", label = "Max Hold Duration", group = "Trigger Bot" }),

    -- Recoil Compensation
    recoil_enabled = UI.Toggle(true, { label = "Enable Recoil Comp", group = "Recoil" }),
    recoil_pattern_strength = UI.Slider(100, { min = 0, max = 200, suffix = "%", label = "Pattern Strength", group = "Recoil" }),
    recoil_vertical = UI.Slider(2.0, { min = 0.5, max = 5.0, step = 0.1, label = "Vertical Intensity", group = "Recoil" }),
    recoil_horizontal = UI.Slider(1.0, { min = 0, max = 3.0, step = 0.1, label = "Horizontal Intensity", group = "Recoil" }),

    -- Control
    toggle_key = UI.Keybind("F6", { label = "Master Toggle", group = "Control" }),
    aim_key = UI.Keybind("Mouse2", { label = "Aim Hold Key (optional)", group = "Control", tooltip = "Leave empty to always aim" }),
})

-- State tracking
local state = {
    aiming = false,
    prev_pos = { x = 0, y = 0 },
    vel = { x = 0, y = 0 },
    firing = false,
    fire_task = nil,
    recoil_task = nil,
}

-- Recoil pattern (spray simulation)
local recoil_pattern = {
    { x = 0, y = 2 },
    { x = 0, y = 3 },
    { x = -1, y = 4 },
    { x = -1, y = 3 },
    { x = 1, y = 2 },
    { x = 2, y = 1 },
    { x = 1, y = 1 },
    { x = -1, y = 2 },
    { x = 0, y = 2 },
    { x = 1, y = 1 },
}

local function lerp(a, b, t)
    return a + (b - a) * t
end

local function distance(dx, dy)
    return math.sqrt(dx * dx + dy * dy)
end

local function randomRange(min_val, max_val)
    return min_val + math.random() * (max_val - min_val)
end

-- Humanized acceleration curve
local function computeMovement(target_x, target_y, current_x, current_y)
    local dx = target_x - current_x
    local dy = target_y - current_y
    local dist = distance(dx, dy)

    if dist < 0.1 then
        return 0, 0
    end

    -- Normalize direction
    local dir_x = dx / dist
    local dir_y = dy / dist

    -- Acceleration phase
    local accel = 1.0
    if dist > cfg.accel_start then
        local accel_dist = dist - cfg.accel_start
        accel = 1.0 + math.pow(accel_dist / 100, cfg.accel_curve) * (cfg.aim_strength / 100)
    end

    -- Deceleration when close
    if dist < cfg.accel_start * 2 then
        accel = accel * cfg.decel_factor
    end

    -- Apply smoothing (exponential moving average)
    state.vel.x = lerp(state.vel.x, dir_x * dist * accel, cfg.smoothing)
    state.vel.y = lerp(state.vel.y, dir_y * dist * accel, cfg.smoothing)

    -- Add human jitter
    if cfg.jitter_amount > 0 then
        state.vel.x = state.vel.x + (math.random() - 0.5) * cfg.jitter_amount
        state.vel.y = state.vel.y + (math.random() - 0.5) * cfg.jitter_amount
    end

    return state.vel.x, state.vel.y
end

-- Predictive aiming (assumes target moves predictably)
local function getPredictedPosition(target_x, target_y)
    if not cfg.prediction_enabled then
        return target_x, target_y
    end

    -- Simulate simple target movement prediction
    -- In real use, you'd track target velocity from screen analysis
    local pred_x = target_x + (math.random() - 0.5) * 20 * cfg.prediction_strength
    local pred_y = target_y + (math.random() - 0.5) * 20 * cfg.prediction_strength

    return pred_x, pred_y
end

-- Trigger bot with randomized reaction time
local function triggerBot()
    if not cfg.trigger_enabled or state.firing then
        return
    end

    state.firing = true

    state.fire_task = Run(function()
        -- Random reaction delay
        local delay = randomRange(cfg.trigger_delay_min, cfg.trigger_delay_max)
        Sleep(delay)

        -- Random hold duration
        local hold = randomRange(cfg.trigger_hold_min, cfg.trigger_hold_max)

        HID.Down(cfg.trigger_key)
        Sleep(hold)
        HID.Up(cfg.trigger_key)

        state.firing = false
    end)
end

-- Recoil compensation spray pattern
local function applyRecoilCompensation()
    if not cfg.recoil_enabled or state.recoil_task then
        return
    end

    state.recoil_task = Run(function()
        local idx = 1
        while state.firing and idx <= #recoil_pattern do
            local step = recoil_pattern[idx]
            local comp_x = step.x * cfg.recoil_horizontal * (cfg.recoil_pattern_strength / 100)
            local comp_y = step.y * cfg.recoil_vertical * (cfg.recoil_pattern_strength / 100)

            HID.Move(-comp_x, -comp_y)
            Sleep(15)

            idx = idx + 1
        end
        state.recoil_task = nil
    end)
end

-- Main aiming loop (OnTick is high frequency)
function OnTick()
    if not cfg.enabled then
        return
    end

    -- Check if we should be aiming
    if cfg.aim_key ~= "" then
        state.aiming = Input.IsDown(cfg.aim_key)
    else
        state.aiming = true
    end

    if not state.aiming then
        return
    end

    -- Simulated target position (in real use, you'd detect this from screen)
    -- For now, we target the center of the screen
    local screen_w, screen_h = System.Screen()
    local target_x = screen_w / 2
    local target_y = screen_h / 2

    -- Apply prediction
    local pred_x, pred_y = getPredictedPosition(target_x, target_y)

    -- Get current mouse position
    local cur_pos = Input.GetMousePos()
    local cur_x, cur_y = cur_pos.x, cur_pos.y

    -- Compute humanized movement
    local move_x, move_y = computeMovement(pred_x, pred_y, cur_x, cur_y)

    -- Apply movement
    if distance(move_x, move_y) > 0.1 then
        HID.Move(move_x, move_y)
    end
end

-- Input hooks
function OnDown(key)
    if key == cfg.toggle_key then
        cfg.enabled = not cfg.enabled
        UI.Notify(cfg.enabled and "Aim Trainer ON" or "Aim Trainer OFF", "info")
        return false
    end

    if cfg.trigger_enabled and key == cfg.trigger_key and state.aiming then
        triggerBot()
        applyRecoilCompensation()
        return false
    end

    return true
end

function OnUp(key)
    if cfg.trigger_enabled and key == cfg.trigger_key then
        if state.fire_task and state.fire_task:IsRunning() then
            state.fire_task:Cancel()
            HID.Up(cfg.trigger_key)
            state.fire_task = nil
        end
        state.firing = false
        return false
    end
    return true
end

function OnBlur()
    if state.fire_task and state.fire_task:IsRunning() then
        state.fire_task:Cancel()
        HID.Up(cfg.trigger_key)
    end
    if state.recoil_task and state.recoil_task:IsRunning() then
        state.recoil_task:Cancel()
    end
    state.aiming = false
    state.firing = false
end

function OnStop()
    if state.fire_task and state.fire_task:IsRunning() then
        state.fire_task:Cancel()
        HID.Up(cfg.trigger_key)
    end
    if state.recoil_task and state.recoil_task:IsRunning() then
        state.recoil_task:Cancel()
    end
end