Funky Claude (Funky Friday Autoplayer)

--[[ ============================================================
     FUNKY BOT — auto-player for "Funky Friday" (Lyte Interactive)

     Why the naive approach fails: the gameplay engine runs in a
     PARALLEL Actor VM. VirtualInputManager fires the InputAction and
     lights the receptor, but the Actor's scoring IGNORES synthetic
     input (anti-cheat). Reading note GUI geometry + pressing keys = 0 score.

     The fix (proven): run code INSIDE the Actor via run_on_actor, resolve
     the LIVE player field (ctx.VSRG.GameHandler.Field), and call the game's
     own judge  lane:Hit(true, os.clock())  at each note's Time. That is the
     exact path a real key press takes, so it scores. Verified: 149 combo.

     ACCURACY SLIDER: 100% = hit dead-on every note (Sick / blatant full combo).
     Lower % = random timing error (up to ~160ms) + a rising miss chance, so
     it looks like a human/bad player. Judge windows: +/-50ms => Sick, +/-200ms => hit.
     ============================================================ ]]

local Players       = game:GetService("Players")
local RunService    = game:GetService("RunService")
local TweenService  = game:GetService("TweenService")
local UserInputS    = game:GetService("UserInputService")
local LocalPlayer   = Players.LocalPlayer

if _G.FunkyBotUI then pcall(function() _G.FunkyBotUI.destroy() end) end
local Hub = {}
_G.FunkyBotUI = Hub

-- ===================== ACTOR-SIDE AUTOPLAYER LOOP =====================
-- runs inside ClientActor's VM; reads LocalPlayer attributes for control.
local ACTOR_SRC = [=[
local RunService = game:GetService("RunService")
local LP = game:GetService("Players").LocalPlayer
_G.FB = _G.FB or {}
if _G.FB.conn then pcall(function() _G.FB.conn:Disconnect() end) end
_G.FB.hits, _G.FB.frames = 0, 0

local function findCtx()
    for _, v in ipairs(getgc(true)) do
        if type(v) == "table" then
            local ok, has = pcall(function()
                return rawget(v, "VSRG") ~= nil and rawget(v, "Configs") ~= nil and rawget(v, "SettingsHandler") ~= nil
            end)
            if ok and has and v.VSRG and v.VSRG.GameHandler then return v end
        end
    end
end
local ctx = findCtx()
local seen = setmetatable({}, {__mode = "k"})   -- notes already handled
local emap = setmetatable({}, {__mode = "k"})   -- per-note assigned error/miss

_G.FB.conn = RunService.Heartbeat:Connect(function()
    _G.FB.frames = _G.FB.frames + 1
    LP:SetAttribute("FB_Frames", _G.FB.frames)
    local ok, err = pcall(function()
        if not LP:GetAttribute("FB_Enabled") then return end
        if not (ctx and ctx.VSRG and ctx.VSRG.GameHandler) then ctx = findCtx() end
        local gh = ctx and ctx.VSRG and ctx.VSRG.GameHandler
        local pf = gh and gh.Field                       -- the LIVE player field
        if not pf or not pf.Game or not pf.Lanes then return end
        local a  = LP:GetAttribute("FB_Accuracy") or 1
        local now = pf.Game.TimePosition
        for _, lane in pairs(pf.Lanes) do
            local notes = lane.Notes
            if notes then
                for _, note in pairs(notes) do
                    if type(note) == "table" and note.Time and not seen[note] then
                        local e = emap[note]
                        if not e then
                            if a >= 1 then
                                e = { err = 0, miss = false }
                            else
                                e = { err = (math.random()*2 - 1) * 0.16 * (1 - a),   -- +/- up to 160ms at a=0
                                      miss = (math.random() < 0.4 * (1 - a)) }        -- up to 40% miss at a=0
                            end
                            emap[note] = e
                        end
                        if now >= note.Time + e.err then
                            seen[note] = true
                            if not e.miss then
                                pcall(function() lane:Hit(true, os.clock()) end)
                                local len = note.Length or 0
                                task.delay(len > 0 and len or 0.03, function()
                                    pcall(function() lane:Hit(false, os.clock()) end)
                                end)
                                _G.FB.hits = _G.FB.hits + 1
                                LP:SetAttribute("FB_Hits", _G.FB.hits)
                            end
                        end
                    end
                end
            end
        end
    end)
    if not ok then LP:SetAttribute("FB_Err", tostring(err)) end
end)
print("[FUNKY BOT] actor loop installed (ctx=" .. tostring(ctx ~= nil) .. ")")
]=]

-- ===================== INJECT INTO ACTOR =====================
LocalPlayer:SetAttribute("FB_Enabled", false)
LocalPlayer:SetAttribute("FB_Accuracy", 1.0)
LocalPlayer:SetAttribute("FB_Hits", 0)

local injected = false
do
    local ok, actors = pcall(getactors)
    if ok and actors and run_on_actor then
        local actor
        for _, a in ipairs(actors) do if a.Name == "ClientActor" then actor = a end end
        actor = actor or actors[1]
        if actor then
            local ok2 = pcall(function() run_on_actor(actor, ACTOR_SRC) end)
            injected = ok2
        end
    end
end

-- ===================== UI =====================
local function descAccuracy(a)
    if a >= 1.0  then return "PERFECT / BLATANT", Color3.fromRGB(255,60,120) end
    if a >= 0.85 then return "Cracked", Color3.fromRGB(120,220,120) end
    if a >= 0.55 then return "Decent",  Color3.fromRGB(220,220,120) end
    if a >= 0.30 then return "Human",   Color3.fromRGB(230,170,90) end
    return "Sloppy", Color3.fromRGB(230,110,90)
end

local gui = Instance.new("ScreenGui")
gui.Name = "FunkyBotUI"; gui.ResetOnSpawn = false; gui.IgnoreGuiInset = true
gui.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
pcall(function() gui.Parent = game:GetService("CoreGui") end)
if not gui.Parent then gui.Parent = LocalPlayer:WaitForChild("PlayerGui") end
Hub.gui = gui

local main = Instance.new("Frame")
main.Size = UDim2.fromOffset(272, 210); main.Position = UDim2.fromOffset(30, 120)
main.BackgroundColor3 = Color3.fromRGB(20,18,28); main.BorderSizePixel = 0
main.Active = true; main.Draggable = true; main.Parent = gui
Instance.new("UICorner", main).CornerRadius = UDim.new(0,10)
local stroke = Instance.new("UIStroke", main); stroke.Color = Color3.fromRGB(255,60,120); stroke.Thickness = 1.5; stroke.Transparency = 0.2

local title = Instance.new("TextLabel")
title.Size = UDim2.new(1,0,0,38); title.BackgroundColor3 = Color3.fromRGB(255,60,120); title.BorderSizePixel=0
title.Text = "  FUNKY CLAUDE"; title.TextColor3 = Color3.new(1,1,1); title.Font = Enum.Font.GothamBlack
title.TextSize = 17; title.TextXAlignment = Enum.TextXAlignment.Left; title.Parent = main
Instance.new("UICorner", title).CornerRadius = UDim.new(0,10)

local toggle = Instance.new("TextButton")
toggle.Size = UDim2.new(1,-20,0,34); toggle.Position = UDim2.fromOffset(10,48)
toggle.BackgroundColor3 = Color3.fromRGB(70,45,55); toggle.BorderSizePixel=0
toggle.Text = "ENABLED: OFF"; toggle.TextColor3 = Color3.new(1,1,1); toggle.Font = Enum.Font.GothamBold; toggle.TextSize=15
toggle.AutoButtonColor = false; toggle.Parent = main
Instance.new("UICorner", toggle).CornerRadius = UDim.new(0,7)
local function refreshToggle()
    local on = LocalPlayer:GetAttribute("FB_Enabled")
    toggle.Text = "ENABLED: " .. (on and "ON" or "OFF")
    toggle.BackgroundColor3 = on and Color3.fromRGB(50,190,90) or Color3.fromRGB(70,45,55)
end
toggle.MouseButton1Click:Connect(function()
    LocalPlayer:SetAttribute("FB_Enabled", not LocalPlayer:GetAttribute("FB_Enabled"))
    refreshToggle()
end)
refreshToggle()

local accLbl = Instance.new("TextLabel")
accLbl.Size = UDim2.new(1,-20,0,20); accLbl.Position = UDim2.fromOffset(10,92)
accLbl.BackgroundTransparency = 1; accLbl.TextXAlignment = Enum.TextXAlignment.Left
accLbl.Font = Enum.Font.GothamMedium; accLbl.TextSize = 14; accLbl.Parent = main

local track = Instance.new("Frame")
track.Size = UDim2.new(1,-20,0,14); track.Position = UDim2.fromOffset(10,118)
track.BackgroundColor3 = Color3.fromRGB(45,42,55); track.BorderSizePixel=0; track.Parent = main
Instance.new("UICorner", track).CornerRadius = UDim.new(1,0)
local fill = Instance.new("Frame")
fill.Size = UDim2.new(1,0,1,0); fill.BackgroundColor3 = Color3.fromRGB(255,60,120); fill.BorderSizePixel=0; fill.Parent = track
Instance.new("UICorner", fill).CornerRadius = UDim.new(1,0)
local knob = Instance.new("Frame")
knob.Size = UDim2.fromOffset(20,20); knob.AnchorPoint = Vector2.new(0.5,0.5)
knob.Position = UDim2.new(1,0,0.5,0); knob.BackgroundColor3 = Color3.new(1,1,1); knob.BorderSizePixel=0; knob.Parent = track
Instance.new("UICorner", knob).CornerRadius = UDim.new(1,0)

local function applyAcc(a)
    a = math.clamp(a, 0, 1)
    LocalPlayer:SetAttribute("FB_Accuracy", a)
    fill.Size = UDim2.new(a,0,1,0); knob.Position = UDim2.new(a,0,0.5,0)
    local d, c = descAccuracy(a)
    accLbl.Text = ("Accuracy: %d%%  —  %s"):format(math.floor(a*100+0.5), d)
    accLbl.TextColor3 = c; fill.BackgroundColor3 = c
end
local dragging = false
local function setFromX(px) applyAcc((px - track.AbsolutePosition.X) / track.AbsoluteSize.X) end
track.InputBegan:Connect(function(i) if i.UserInputType==Enum.UserInputType.MouseButton1 or i.UserInputType==Enum.UserInputType.Touch then dragging=true; setFromX(i.Position.X) end end)
knob.InputBegan:Connect(function(i) if i.UserInputType==Enum.UserInputType.MouseButton1 or i.UserInputType==Enum.UserInputType.Touch then dragging=true end end)
UserInputS.InputChanged:Connect(function(i) if dragging and (i.UserInputType==Enum.UserInputType.MouseMovement or i.UserInputType==Enum.UserInputType.Touch) then setFromX(i.Position.X) end end)
UserInputS.InputEnded:Connect(function(i) if i.UserInputType==Enum.UserInputType.MouseButton1 or i.UserInputType==Enum.UserInputType.Touch then dragging=false end end)

local status = Instance.new("TextLabel")
status.Size = UDim2.new(1,-20,0,18); status.Position = UDim2.fromOffset(10,150)
status.BackgroundTransparency = 1; status.TextXAlignment = Enum.TextXAlignment.Left
status.Font = Enum.Font.Code; status.TextSize = 12; status.TextColor3 = Color3.fromRGB(150,255,170); status.Parent = main

local hint = Instance.new("TextLabel")
hint.Size = UDim2.new(1,-20,0,30); hint.Position = UDim2.fromOffset(10,174)
hint.BackgroundTransparency = 1; hint.TextXAlignment = Enum.TextXAlignment.Left; hint.TextYAlignment = Enum.TextYAlignment.Top
hint.TextWrapped = true; hint.Text = injected and "Runs inside the game engine. Slide right = full-combo; left = misses."
    or "WARNING: actor injection failed — executor may not support run_on_actor."
hint.TextColor3 = injected and Color3.fromRGB(150,150,160) or Color3.fromRGB(255,120,120)
hint.Font = Enum.Font.Gotham; hint.TextSize = 11; hint.Parent = main

local statusConn = RunService.Heartbeat:Connect(function()
    if not status.Parent then return end
    status.Text = ("notes hit: %d"):format(LocalPlayer:GetAttribute("FB_Hits") or 0)
    refreshToggle()  -- keep button in sync even if state is set externally
end)

applyAcc(LocalPlayer:GetAttribute("FB_Accuracy") or 1.0)

function Hub.destroy()
    LocalPlayer:SetAttribute("FB_Enabled", false)
    pcall(function() statusConn:Disconnect() end)
    if Hub.gui then pcall(function() Hub.gui:Destroy() end) end
    _G.FunkyBotUI = nil
end

print("[FUNKY BOT] Loaded (actor-injected=" .. tostring(injected) .. "). Enable + slide accuracy. 100% = blatant full-combo.")