-- [[ Rscripts Risk Notice ]]
-- This script is not verified by rscripts.net. Deal with caution.
--
-- Stay safe:
--   • Never log in on unofficial Roblox sites or lookalike domains.
--   • Real Roblox links use roblox.com (check the .com ending).
--   • Treat fake Roblox login / "claim reward" pages as phishing.
-- [[ End Rscripts Risk Notice ]]

-- ============================================================================
-- UNIVERSAL GHOST SCRIPT TERMINATOR
-- Forcefully disconnects all old executor loops running in the background
-- ============================================================================
if getconnections then
    pcall(function()
        for _, conn in ipairs(getconnections(game:GetService("RunService").RenderStepped)) do
            local fn = conn.Function
            if fn then
                local src = debug.info(fn, "s")
                -- Kills any previous executor scripts running from [string ""]
                if src == "" or src == '[string ""]' or tostring(src):find("string") then
                    pcall(function() conn:Disable() end)
                    pcall(function() conn:Disconnect() end)
                end
            end
        end
    end)
end

if getgenv().FNP_AutoPlayConnection then
    pcall(function() getgenv().FNP_AutoPlayConnection:Disconnect() end)
    getgenv().FNP_AutoPlayConnection = nil
end
if getgenv().FNP_Rayfield then
    pcall(function() getgenv().FNP_Rayfield:Destroy() end)
    getgenv().FNP_Rayfield = nil
end

local Rayfield = loadstring(game:HttpGet('https://raw.githubusercontent.com/SiriusSoftwareLtd/Rayfield/main/source.lua'))()
getgenv().FNP_Rayfield = Rayfield

local Window = Rayfield:CreateWindow({
   Name = "Friday Night Partying | VS Tabi",
   Icon = "smile",
   LoadingTitle = "Friday Night Partying",
   LoadingSubtitle = "by Acruise82",
   ShowText = "H",
   Theme = "Default",

   ToggleUIKeybind = Enum.KeyCode.Insert,

   DisableRayfieldPrompts = true,
   DisableBuildWarnings = true,

   ConfigurationSaving = {
      Enabled = false
   },

   Discord = {
      Enabled = true, -- Prompt the user to join your Discord server if their executor supports it
      Invite = "https://9P8H28hKs", -- The Discord invite code, do not include Discord.gg/. E.g. Discord.gg/ABCD would be ABCD
      RememberJoins = true
      },

   KeySystem = true,
   KeySettings = {
      Title = "Friday Night Partying",
      Subtitle = "Key System",
      Note = "Join discord for key : https://discord.gg/9P8H28hKs",
      FileName = "Key",
      SaveKey = true,
      GrabKeyFromSite = false,
      Key = {"mamababy"}
   }
})

Rayfield:Notify({
   Title = "Autoplayer Ready",
   Content = "Ghost scripts killed! Press INSERT for menu.",
   Duration = 5,
   Image = "smile",
})

--------------------------------------------------------------------------------
-- SERVICES & WASD CONTROLS
--------------------------------------------------------------------------------
local RunService = game:GetService("RunService")
local VirtualInputManager = game:GetService("VirtualInputManager")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local Players = game:GetService("Players")
local LocalPlayer = Players.LocalPlayer
local PlayerGui = LocalPlayer:WaitForChild("PlayerGui")

-- WASD Controls: Left (A), Down (S), Up (W), Right (D)
local LaneBinds = {
    [1] = Enum.KeyCode.A,
    [2] = Enum.KeyCode.S,
    [3] = Enum.KeyCode.W,
    [4] = Enum.KeyCode.D
}

local UserInputBindables = nil
local GoodhitFunc = nil

pcall(function()
    local Modules = ReplicatedStorage:WaitForChild("Modules", 2)
    if Modules then
        UserInputBindables = require(Modules:WaitForChild("UserInputBindables", 2))
    end
end)

pcall(function()
    if getgc then
        for _, obj in ipairs(getgc(true)) do
            if type(obj) == "function" then
                local name = debug.info and debug.info(obj, "n")
                if name == "Goodhit" then
                    GoodhitFunc = obj
                    break
                end
            end
        end
    end
end)

local function sendLaneInput(lane, isDown)
    local key = LaneBinds[lane]
    if not key then return end

    if firesignal and UserInputBindables and UserInputBindables.InputEvents then
        local signal = isDown and UserInputBindables.InputEvents.Began or UserInputBindables.InputEvents.Ended
        if signal then
            pcall(firesignal, signal, "Direction" .. lane, nil, false)
        end
    end

    if setthreadidentity then pcall(setthreadidentity, 8) end
    pcall(function()
        VirtualInputManager:SendKeyEvent(isDown, key, false, game)
    end)
end

--------------------------------------------------------------------------------
-- FNP ENGINE HOOK (2X SPEED OPTIMIZED)
--------------------------------------------------------------------------------
local activeNotes = {}
local NoteModule, Conductor

pcall(function()
    local Modules = ReplicatedStorage:WaitForChild("Modules", 5)
    if Modules then
        NoteModule = require(Modules:WaitForChild("Note", 5))
        Conductor = require(Modules:WaitForChild("Conductor", 5))
    end
end)

if NoteModule and type(NoteModule.SpawnNote) == "function" then
    local oldSpawn = NoteModule.SpawnNote
    NoteModule.SpawnNote = function(note)
        local result = oldSpawn(note)
        if type(note) == "table" and note.MustPress then
            if note.shouldPress ~= false then
                table.insert(activeNotes, note)
            end
        end
        return result
    end
end

--------------------------------------------------------------------------------
-- AUTO PLAY TAB
--------------------------------------------------------------------------------
local AutoPlayTab = Window:CreateTab("Auto Play", "smile")

AutoPlayTab:CreateSection("Autoplayer Controls (WASD)")

local autoPlayConnection = nil
local targetAccuracy = 100
local imperfectMode = false
local triggeredNotes = {}
local heldLanes = {}
local releaseAt = {}

-- Live Accuracy & Mode Resolver
local function getLiveAccuracy()
    if Rayfield and Rayfield.Flags and Rayfield.Flags["AccuracySlider"] then
        local val = Rayfield.Flags["AccuracySlider"].CurrentValue
        if type(val) == "number" then return val end
        if tonumber(val) then return tonumber(val) end
    end
    return tonumber(targetAccuracy) or 100
end

local function getLiveImperfectMode()
    if Rayfield and Rayfield.Flags and Rayfield.Flags["ImperfectHitsToggle"] ~= nil then
        return Rayfield.Flags["ImperfectHitsToggle"].CurrentValue == true
    end
    return imperfectMode == true
end

local function triggerPhysicalHit(lane, isSustain)
    local now = os.clock()
    if heldLanes[lane] then
        sendLaneInput(lane, false)
    end

    sendLaneInput(lane, true)
    heldLanes[lane] = true

    releaseAt[lane] = now + (isSustain and 0.16 or 0.014)
end

local function getActiveNoteContainer()
    for _, name in ipairs({"BFNotes", "DadNotes"}) do
        for _, desc in ipairs(PlayerGui:GetDescendants()) do
            if desc:IsA("GuiObject") and desc.Name == name and desc.Visible then
                if #desc:GetChildren() >= 4 then
                    return desc
                end
            end
        end
    end
    return nil
end

-- Toggle Auto Play
local Toggle = AutoPlayTab:CreateToggle({
   Name = "auto play",
   CurrentValue = false,
   Flag = "Toggle1",
   Callback = function(Value)
       if Value then
           if autoPlayConnection then autoPlayConnection:Disconnect() end
           table.clear(triggeredNotes)
           table.clear(heldLanes)
           table.clear(releaseAt)

           autoPlayConnection = RunService.RenderStepped:Connect(function()
               local now = os.clock()

               -- Key releases
               for lane = 1, 4 do
                   if releaseAt[lane] and now >= releaseAt[lane] then
                       sendLaneInput(lane, false)
                       heldLanes[lane] = nil
                       releaseAt[lane] = nil
                   end
               end

               local liveAcc = getLiveAccuracy()
               local liveImperfect = getLiveImperfectMode()

               -- =============================================================
               -- METHOD 1: Direct Conductor Engine (Chronologically Sorted)
               -- =============================================================
               if Conductor and type(Conductor.SongPos) == "number" and #activeNotes > 0 then
                   local songPos = Conductor.SongPos

                   local dueNotes = {}
                   for i = #activeNotes, 1, -1 do
                       local note = activeNotes[i]
                       local strumTime = tonumber(note.StrumTime) or 0

                       if note.GoodHit or note.TooLate or (songPos > strumTime + 450) then
                           triggeredNotes[note] = nil
                           table.remove(activeNotes, i)
                       elseif note.MustPress and not triggeredNotes[note] and not note.GoodHit and not note.TooLate then
                           local isReady = (songPos >= strumTime - 35) or (note.CanBeHit and songPos >= strumTime - 50)
                           if isReady then
                               table.insert(dueNotes, note)
                           end
                       end
                   end

                   table.sort(dueNotes, function(a, b)
                       local aTime = tonumber(a.StrumTime) or 0
                       local bTime = tonumber(b.StrumTime) or 0
                       if aTime ~= bTime then
                           return aTime < bTime
                       end
                       return (not a.IsSustain) and b.IsSustain
                   end)

                   for _, note in ipairs(dueNotes) do
                       if not triggeredNotes[note] then
                           triggeredNotes[note] = true

                           local roll = math.random(1, 100)
                           local isSick = (liveAcc >= 100) or (roll <= liveAcc)
                           local lane = (tonumber(note.NoteData) or 0) + 1
                           local isSustain = note.IsSustain or (note.SustainLength and note.SustainLength > 0)

                           if isSick then
                               if GoodhitFunc then pcall(GoodhitFunc, note) end
                               triggerPhysicalHit(lane, isSustain)
                           elseif liveImperfect then
                               -- Imperfect hit delayed for Good/Bad
                               task.delay(0.06, function()
                                   if GoodhitFunc then pcall(GoodhitFunc, note) end
                                   triggerPhysicalHit(lane, isSustain)
                               end)
                           else
                               -- Complete Miss
                           end
                       end
                   end
                   return
               end

               -- =============================================================
               -- METHOD 2: Visual Fallback
               -- =============================================================
               local container = getActiveNoteContainer()
               if not container or not container.Parent then
                   for lane = 1, 4 do
                       if heldLanes[lane] then
                           sendLaneInput(lane, false)
                           heldLanes[lane] = nil
                       end
                   end
                   return
               end

               local receptors = {}
               local notes = {}

               for _, child in ipairs(container:GetChildren()) do
                   if (child:IsA("ImageLabel") or child:IsA("ImageButton") or child:IsA("GuiObject")) and child.Visible and child.ImageTransparency < 0.95 then
                       local name = tostring(child.Name or ""):gsub("%z", ""):gsub("%s+", "")
                       if name == "" or name == "0" or name == "1" or name == "2" or name == "3" then
                           table.insert(receptors, child)
                       else
                           table.insert(notes, child)
                       end
                   end
               end

               if #receptors < 4 then
                   table.clear(receptors)
                   table.clear(notes)
                   for _, child in ipairs(container:GetChildren()) do
                       if child:IsA("GuiObject") and child.Visible and child.ImageTransparency < 0.95 then
                           if child.ZIndex == 1 and child.AbsoluteSize.X > 20 then
                               table.insert(receptors, child)
                           else
                               table.insert(notes, child)
                           end
                       end
                   end
               end

               table.sort(receptors, function(a, b)
                   return a.AbsolutePosition.X < b.AbsolutePosition.X
               end)

               if #receptors < 4 then return end

               local targetRecY = receptors[1].AbsolutePosition.Y + (receptors[1].AbsoluteSize.Y / 2)

               table.sort(notes, function(a, b)
                   local aCenter = a.AbsolutePosition.Y + (a.AbsoluteSize.Y / 2)
                   local bCenter = b.AbsolutePosition.Y + (b.AbsoluteSize.Y / 2)
                   return math.abs(aCenter - targetRecY) < math.abs(bCenter - targetRecY)
               end)

               for _, note in ipairs(notes) do
                   if not triggeredNotes[note] and note.Visible and note.ImageTransparency < 0.9 then
                       local noteName = note.Name:lower()

                       if noteName:find("mine") or noteName:find("hurt") or noteName:find("kill") or noteName:find("bomb") or noteName:find("death") or noteName:find("poison") then
                           triggeredNotes[note] = true
                       else
                           local noteCenterX = note.AbsolutePosition.X + (note.AbsoluteSize.X / 2)
                           local currentCenterY = note.AbsolutePosition.Y + (note.AbsoluteSize.Y / 2)

                           local lane = 1
                           local minDiffX = math.huge
                           for i = 1, 4 do
                               local recX = receptors[i].AbsolutePosition.X + (receptors[i].AbsoluteSize.X / 2)
                               local diff = math.abs(noteCenterX - recX)
                               if diff < minDiffX then
                                   minDiffX = diff
                                   lane = i
                               end
                           end

                           local rec = receptors[lane]
                           local recY = rec.AbsolutePosition.Y + (rec.AbsoluteSize.Y / 2)
                           local distanceY = math.abs(currentCenterY - recY)

                           if distanceY <= 55 and minDiffX <= rec.AbsoluteSize.X then
                               triggeredNotes[note] = true

                               local roll = math.random(1, 100)
                               local isSick = (liveAcc >= 100) or (roll <= liveAcc)
                               local isSustain = note.AbsoluteSize.Y > rec.AbsoluteSize.Y * 1.3

                               if isSick then
                                   triggerPhysicalHit(lane, isSustain)
                               elseif liveImperfect then
                                   task.delay(0.06, function()
                                       triggerPhysicalHit(lane, isSustain)
                                   end)
                               else
                                   -- Complete Miss
                               end
                           end
                       end
                   end
               end
           end)
           getgenv().FNP_AutoPlayConnection = autoPlayConnection
       else
           if autoPlayConnection then
               autoPlayConnection:Disconnect()
               autoPlayConnection = nil
               getgenv().FNP_AutoPlayConnection = nil
           end
           for lane = 1, 4 do
               sendLaneInput(lane, false)
           end
           table.clear(heldLanes)
           table.clear(releaseAt)
       end
   end,
})

-- Accuracy Slider (0% to 100%)
AutoPlayTab:CreateSlider({
   Name = "Accuracy",
   Range = {0, 100},
   Increment = 1,
   Suffix = "%",
   CurrentValue = 100,
   Flag = "AccuracySlider",
   Callback = function(Value)
       targetAccuracy = tonumber(Value) or 100
   end,
})

-- Miss Behavior Toggle
AutoPlayTab:CreateToggle({
   Name = "Imperfect Hits (Good/Bad instead of Miss)",
   CurrentValue = false,
   Flag = "ImperfectHitsToggle",
   Callback = function(Value)
       imperfectMode = Value
   end,
})

--------------------------------------------------------------------------------
-- SETTINGS TAB & UNLOAD BUTTON
--------------------------------------------------------------------------------
local SettingsTab = Window:CreateTab("Settings", "settings")

SettingsTab:CreateSection("Script Management")

SettingsTab:CreateButton({
   Name = "Unload Script",
   Callback = function()
       if autoPlayConnection then
           autoPlayConnection:Disconnect()
           autoPlayConnection = nil
       end
       getgenv().FNP_AutoPlayConnection = nil

       for lane = 1, 4 do
           sendLaneInput(lane, false)
       end
       table.clear(heldLanes)
       table.clear(activeNotes)
       table.clear(triggeredNotes)
       table.clear(releaseAt)

       Rayfield:Destroy()
       getgenv().FNP_Rayfield = nil
   end,
})

LocalPlayer.CharacterRemoving:Connect(function()
    for lane = 1, 4 do
        sendLaneInput(lane, false)
    end
    table.clear(heldLanes)
    table.clear(releaseAt)
end)