if _G.XenoLoaded then 
    return 
end
_G.XenoLoaded = true
local Rayfield = loadstring(game:HttpGet('https://sirius.menu/rayfield'))()
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local PathfindingService = game:GetService("PathfindingService")
local VirtualUser = game:GetService("VirtualUser")
local LocalPlayer = game.Players.LocalPlayer

-- Remotes
local remotes = ReplicatedStorage:WaitForChild("Remotes")
local bustStart = remotes:WaitForChild("AttemptATMBustStart")
local bustEnd = remotes:WaitForChild("AttemptATMBustComplete")
local RemoteStart = remotes:WaitForChild("RequestStartJobSession")
local RemoteEnd = remotes:WaitForChild("RequestEndJobSession")

local antiAfkConnection

local function ExecuteServerHop()
    local HttpService = game:GetService("HttpService")
    local TeleportService = game:GetService("TeleportService")
    local PlaceID = game.PlaceId
    
    -- KOLEJKOWANIE (Tylko tu, tuż przed teleportem)
    local qot = syn and syn.queue_on_teleport or queue_on_teleport or (fluxus and fluxus.queue_on_teleport)
    if qot then
        qot([[
            repeat task.wait() until game:IsLoaded()
            loadstring(game:HttpGet("https://raw.githubusercontent.com/xxCichyxx/rbxscripts/refs/heads/main/DrivingEmpireXeno.lua"))()
        ]])
    end

    local success = false
    local attempts = 0
    
    while not success and attempts < 10 do
        attempts = attempts + 1
        local url = 'https://games.roblox.com/v1/games/' .. PlaceID .. '/servers/Public?sortOrder=Desc&limit=100'
        
        local pcall_success, response = pcall(function()
            return HttpService:JSONDecode(game:HttpGet(url))
        end)

        if pcall_success and response and response.data then
            local candidates = {}
            for _, server in pairs(response.data) do
                if server.id ~= game.JobId and tonumber(server.playing) < tonumber(server.maxPlayers) then
                    table.insert(candidates, server)
                end
            end

            table.sort(candidates, function(a, b) return a.playing <b> 0 then
                local range = math.min(5, #candidates)
                local target = candidates[math.random(1, range)]
                
                pcall(function()
                    TeleportService:TeleportToPlaceInstance(PlaceID, target.id, game.Players.LocalPlayer)
                    success = true
                end)
            end
        end
        if not success then task.wait(1.5) end
    end
end

-- Ustawienia domyślne (Zmienne globalne)
_G.SpeedEnabled = false
_G.SpeedMode = "Legit"
_G.SpeedValue = 16

local Window = Rayfield:CreateWindow({
   Name = "Driving Empire🏎️ Car Racing",
   Icon = "car",
   LoadingTitle = "Driving Empire🏎️",
   LoadingSubtitle = "by XenoScriptsPL",
   ConfigurationSaving = {
      Enabled = true,
      FolderName = "DrivingEmpireScripts",
      FileName = "DrivingEmpireHub"
   },
})

-- Zakładki
local TabPlayer = Window:CreateTab("Player", "user")
local TabVehicle = Window:CreateTab("Vehicle", "car-front")
local TabFarm = Window:CreateTab("Farms", "tractor")
local TabStats = Window:CreateTab("Statistics", "bar-chart-2")
local TabVisuals = Window:CreateTab("Visuals", "eye")
local TabJobs = Window:CreateTab("Jobs", "briefcase")
local TabTest = Window:CreateTab("Test", "user")

-- SEKCJA PLAYER

local function GetMyVehicle()
    local folder = workspace:FindFirstChild("Vehicles")
    if not folder then return nil end
    for _, veh in pairs(folder:GetChildren()) do
        local owner = veh:FindFirstChild("Owner")
        if owner and owner.Value == LocalPlayer.Name then
            return veh
        end
    end
    return nil
end
local SelectedPlayerName = nil
local PlayerDropdown
local function getPlayerNames()
    local names = {}
    for _, player in pairs(Players:GetPlayers()) do
        if player ~= LocalPlayer then -- Nie dodajemy siebie do listy
            table.insert(names, player.Name)
        end
    end
    return names
end
local TeleportSection = TabPlayer:CreateSection("General")
TabPlayer:CreateToggle({
   Name = "Anti-AFK",
   CurrentValue = false,
   Flag = "AntiAfkToggle",
   Callback = function(Value)
      if Value then
         -- Włączanie Anti-AFK
         if antiAfkConnection then antiAfkConnection:Disconnect() end
         antiAfkConnection = LocalPlayer.Idled:Connect(function()
            VirtualUser:CaptureController()
            VirtualUser:ClickButton2(Vector2.new(), workspace.CurrentCamera.CFrame)
         end)
         Rayfield:Notify({Title = "Player Settings", Content = "Anti-AFK został aktywowany!", Duration = 3})
      else
         -- Wyłączanie Anti-AFK
         if antiAfkConnection then
            antiAfkConnection:Disconnect()
            antiAfkConnection = nil
         end
         Rayfield:Notify({Title = "Player Settings", Content = "Anti-AFK został wyłączony.", Duration = 3})
      end
   end,
})
TabPlayer:CreateButton({
   Name = "🚀 Server Hop",
   Callback = function()
      Rayfield:Notify({Title = "Server Hop", Content = "Szukanie serwera...", Duration = 3})
      ExecuteServerHop()
   end,
})
-- =============================================================================
-- KONFIGURACJA I ZMIENNE
-- =============================================================================
local BypassActive = false
local HookInstalled = false
local BlockCount = 0

local TargetRemotes = {
    ["StarwatchClientEventIngestor"] = true, ["_network"] = true,
    ["rsp"] = true, ["rps"] = true, ["rsi"] = true, ["rs"] = true, ["rsw"] = true,
    ["ptsstop"] = true, ["ptsstart"] = true, ["SdkTelemetryRemote"] = true,
    ["TeleportInfo"] = true, ["SendLogString"] = true, ["GetClientLogs"] = true,
    ["GetClientFPS"] = true, ["GetClientPing"] = true, ["GetClientMemoryUsage"] = true,
    ["GetClientPerformanceStats"] = true, ["GetClientReport"] = true,
    ["RepBL"] = true, ["UnauthorizedTeleport"] = true, ["ClientDetectedSoftlock"] = true,
    ["loadTime"] = true, ["InformLoadingEventFunnel"] = true, ["InformGeneralEventFunnel"] = true
}

local BypassLabel = TabPlayer:CreateLabel("Bypass: System Uzbrojony (Czekam na aktywację)")

-- =============================================================================
-- 1. INSTALACJA NATYCHMIASTOWA (EARLY HOOK)
-- =============================================================================
local function InstallEarlyHook()
    if HookInstalled then return end
    
    local success, err = pcall(function()
        local oldNamecall
        oldNamecall = hookmetamethod(game, "__namecall", function(self, ...)
            local method = getnamecallmethod()
            local args = {...}
            
            if BypassActive and (method == "FireServer" or method == "InvokeServer") then
                local remoteName = tostring(self)
                
                -- [LOGIKA BLOKOWANIA]
                local shouldBlock = false
                
                -- A. Sprawdzanie czarnej listy nazw
                if TargetRemotes[remoteName] then
                    shouldBlock = true
                end
                
                -- B. Sprawdzanie dynamicznych ID (Naprawiony wzorzec: 8 znaków hex + myślnik)
                -- Zapobiega to blokowaniu "Attempt" i "Capture"
                if not shouldBlock and string.match(remoteName, "^%x%x%x%x%x%x%x%x%-") then
                    shouldBlock = true
                end
                
                -- C. Blokada specyficzna: Location -> Boats
                if not shouldBlock and remoteName == "Location" and args[1] == "Enter" and args[2] == "Boats" then
                    shouldBlock = true
                end

                -- [WYKONANIE BLOKADY]
                if shouldBlock then
                    BlockCount = BlockCount + 1
                    return nil 
                end
            end
            
            return oldNamecall(self, ...)
        end)
    end)
    
    if success then
        HookInstalled = true
        print("[BYPASS] Hook zainstalowany pomyślnie.")
    else
        warn("[BYPASS] Błąd krytyczny: " .. tostring(err))
    end
end

InstallEarlyHook()

-- =============================================================================
-- 3. PĘTLA MONITORUJĄCA I SYNCHRONIZUJĄCA
-- =============================================================================
task.spawn(function()
    while true do
        if BypassActive then
            local remotesFolder = game:GetService("ReplicatedStorage"):FindFirstChild("Remotes")
            
            if remotesFolder then
                BypassLabel:Set("Status: 🔒 AKTYWNY ("..BlockCount.." zablokowanych)")
                
                local children = remotesFolder:GetChildren()
                for _, remote in ipairs(children) do
                    local n = remote.Name
                    -- Automatyczne dodawanie nowych GUIDów do listy (z bezpiecznym wzorcem)
                    if string.match(n, "^%x%x%x%x%x%x%x%x%-") and not TargetRemotes[n] then
                        TargetRemotes[n] = true
                    end
                end
            else
                BypassLabel:Set("Status: ⏳ Oczekiwanie na silnik gry...")
            end
        else
            BypassLabel:Set("Status: 💤 Wyłączony")
        end
        task.wait(2)
    end
end)

-- =============================================================================
-- 4. TOGGLE
-- =============================================================================
TabPlayer:CreateToggle({
    Name = "Bypass Monitor Events Exe LvL 8",
    CurrentValue = false,
    Flag = "BypassToggle",
    Callback = function(Value)
        BypassActive = Value
        if Value then
            BlockCount = 0
            Rayfield:Notify({
                Title = "Bypass Aktywny",
                Content = "Blokowanie logów, rsp/rps i łodzi aktywne.",
                Duration = 3,
                Image = 4483362458,
            })
        else
            BypassLabel:Set("Status: 💤 Wyłączony")
        end
    end,
})
local TeleportSection = TabPlayer:CreateSection("Player Teleport")

-- Zmienna przechowująca wybranego gracza
local SelectedPlayerName = nil

-- 1. DROPDOWN (Wybór gracza)
local PlayerDropdown = TabPlayer:CreateDropdown({
   Name = "Select Player",
   Options = getPlayerNames(), 
   CurrentOption = "",
   MultipleOptions = false,
   Flag = "TargetPlayerDropdown",
   Callback = function(Option)
      SelectedPlayerName = Option[1]
   end,
})

-- 2. PRZYCISK ODŚWIEŻANIA (Manualny)
TabPlayer:CreateButton({
   Name = "Refresh Player List",
   Callback = function()
      if PlayerDropdown then
         local names = getPlayerNames()
         PlayerDropdown:Set(names)
         Rayfield:Notify({
            Title = "List Updated",
            Content = "Found " .. #names .. " players in Workspace.",
            Duration = 3
         })
      end
   end,
})

TabPlayer:CreateButton({
   Name = "Teleport To Player",
   Callback = function()
      if not SelectedPlayerName then return end
      
      local targetPlayer = Players:FindFirstChild(SelectedPlayerName)
      if not targetPlayer or not targetPlayer.Character then return end
      
      -- ODCZYT WORLD PIVOT (Niezależnie od tego czy gracz jest w aucie czy nie)
      -- GetPivot() zwraca CFrame całego modelu z Workspace
      local targetPivot = targetPlayer.Character:GetPivot()
      local destCFrame = targetPivot * CFrame.new(0, 8, 0) -- 8 studów nad cel
      
      local myVeh = GetMyVehicle()
      local isDriving = myVeh and myVeh:FindFirstChild("Driver") and myVeh.Driver.Value == LocalPlayer

      if isDriving and myVeh then
          -- --- TELEPORTACJA POJAZDU ---
          local allParts = {}
          for _, p in pairs(myVeh:GetDescendants()) do
              if p:IsA("BasePart") then table.insert(allParts, p) end
          end

          -- Pivot pojazdu jako punkt odniesienia
          local currentVehPivot = myVeh:GetPivot()
          
          -- Zamrożenie
          for _, p in pairs(allParts) do p.Anchored = true end

          -- Przesunięcie całego modelu auta do pozycji docelowej
          -- Używamy PivotTo, aby zachować strukturę auta
          myVeh:PivotTo(destCFrame)

          task.wait(0.2)

          -- Odmrożenie i czyszczenie fizyki
          for _, p in pairs(allParts) do
              p.AssemblyLinearVelocity = Vector3.new(0,0,0)
              p.AssemblyAngularVelocity = Vector3.new(0,0,0)
              p.Anchored = false
          end
      else
          -- --- TELEPORTACJA GRACZA ---
          if LocalPlayer.Character then
              LocalPlayer.Character:PivotTo(destCFrame)
          end
      end
   end,
})
local PlayerSection = TabPlayer:CreateSection("Movement Settings")
TabPlayer:CreateToggle({
   Name = "Speed",
   CurrentValue = false,
   Flag = "SpeedToggle",
   Callback = function(Value)
      _G.SpeedEnabled = Value
      -- Reset WalkSpeed do normalnej wartości przy wyłączeniu
      if not Value then
          pcall(function() LocalPlayer.Character.Humanoid.WalkSpeed = 16 end)
      end
   end,
})

TabPlayer:CreateDropdown({
   Name = "Speed Mode",
   Options = {"Legit", "HVH", "Normal", "CFrame"},
   CurrentOption = {"Legit"},
   MultipleOptions = false,
   Flag = "SpeedMode",
   Callback = function(Options)
      _G.SpeedMode = Options[1]
   end,
})

TabPlayer:CreateSlider({
   Name = "Custom Speed",
   Range = {0, 300},
   Increment = 1,
   Suffix = " Studs",
   CurrentValue = 16,
   Flag = "SpeedValue",
   Callback = function(Value)
      _G.SpeedValue = Value
   end,
})

-- FUNKCJA SPRAWDZAJĄCA RUCH
local function isMoving()
    local character = LocalPlayer.Character
    local camera = workspace.CurrentCamera

    if not character or not character:FindFirstChild("HumanoidRootPart") then
        return false, Vector3.new()
    end

    local moveDirection = camera.CFrame.LookVector
    moveDirection = Vector3.new(moveDirection.X, 0, moveDirection.Z)
    if moveDirection.Magnitude > 0 then
        moveDirection = moveDirection.Unit
    end

    local movement = Vector3.new()

    if UserInputService:IsKeyDown(Enum.KeyCode.W) then
        movement = movement + moveDirection
    end
    if UserInputService:IsKeyDown(Enum.KeyCode.S) then
        movement = movement - moveDirection
    end
    if UserInputService:IsKeyDown(Enum.KeyCode.D) then
        movement = movement + Vector3.new(-moveDirection.Z, 0, moveDirection.X)
    end
    if UserInputService:IsKeyDown(Enum.KeyCode.A) then
        movement = movement + Vector3.new(moveDirection.Z, 0, -moveDirection.X)
    end

    if movement.Magnitude > 0 then
        return true, movement.Unit
    else
        return false, Vector3.new()
    end
end

-- GŁÓWNA PĘTLA LOGIKI
RunService.RenderStepped:Connect(function() 
    if _G.SpeedEnabled then 
        local character = LocalPlayer.Character
        if character and character:FindFirstChild("Humanoid") and character:FindFirstChild("HumanoidRootPart") then
            
            local moving, direction = isMoving()
            local humanoid = character:FindFirstChildOfClass("Humanoid")
            local hrp = character:FindFirstChild("HumanoidRootPart")
            local wartoscspeed = _G.SpeedValue or 16

            if moving then
                if _G.SpeedMode == "Normal" then
                    humanoid.WalkSpeed = wartoscspeed
                elseif _G.SpeedMode == "CFrame" then
                    hrp.CFrame = hrp.CFrame + (direction * (wartoscspeed / 50))
                elseif _G.SpeedMode == "Legit" then
                    -- Movement bazujący na Velocity (trudniejszy do wykrycia przez proste anty-cheaty)
                    hrp.Velocity = Vector3.new(direction.X * wartoscspeed, hrp.Velocity.Y, direction.Z * wartoscspeed)
                elseif _G.SpeedMode == "HVH" then
                    -- Bypassy i agresywny ruch (np. BunnyHop)
                    if UserInputService:IsKeyDown(Enum.KeyCode.Space) then
                        humanoid.Jump = true
                        hrp.Velocity = Vector3.new(direction.X * wartoscspeed, hrp.Velocity.Y, direction.Z * wartoscspeed)
                    else
                        hrp.Velocity = Vector3.new(direction.X * wartoscspeed, hrp.Velocity.Y, direction.Z * wartoscspeed)
                    end
                end
            else
                -- Zatrzymanie Velocity jeśli nie naciskamy klawiszy (zapobiega ślizganiu się)
                if _G.SpeedMode == "Legit" or _G.SpeedMode == "HVH" then
                    hrp.Velocity = Vector3.new(0, hrp.Velocity.Y, 0)
                end
            end
        end
    end
end)

----------- Fly Mode --------------------
-- ZMIENNE DLA FLY
local flyConnection
_G.FlySpeed = _G.FlySpeed or 50
_G.FlyEnabled = false

local FlySection = TabPlayer:CreateSection("Flight Settings")

TabPlayer:CreateToggle({
   Name = "Flight",
   CurrentValue = false,
   Flag = "FlyToggle",
   Callback = function(Value)
      _G.FlyEnabled = Value
      
      -- Resetowanie starego połączenia
      if flyConnection then 
         flyConnection:Disconnect() 
         flyConnection = nil 
      end
      
      if _G.FlyEnabled then
         local char = LocalPlayer.Character
         local hrp = char and char:FindFirstChild("HumanoidRootPart")
         local humanoid = char and char:FindFirstChildOfClass("Humanoid")
         
         if not hrp or not humanoid then 
            _G.FlyEnabled = false
            return 
         end

         -- Tworzenie instancji lotu bezpośrednio w HumanoidRootPart
         local vFly = hrp:FindFirstChild("IY_FlyVelocity") or Instance.new("BodyVelocity")
         vFly.Name = "IY_FlyVelocity"
         vFly.Parent = hrp
         vFly.MaxForce = Vector3.new(9e9, 9e9, 9e9)
         vFly.Velocity = Vector3.new(0, 0, 0)

         local vGyro = hrp:FindFirstChild("IY_FlyGyro") or Instance.new("BodyGyro")
         vGyro.Name = "IY_FlyGyro"
         vGyro.Parent = hrp
         vGyro.MaxTorque = Vector3.new(9e9, 9e9, 9e9)
         vGyro.CFrame = hrp.CFrame

         humanoid.PlatformStand = true
         
         -- Główna pętla lotu
         flyConnection = RunService.RenderStepped:Connect(function()
            if _G.FlyEnabled and char and hrp and humanoid then
               local camera = workspace.CurrentCamera
               local direction = Vector3.new(0,0,0)
               
               -- Sterowanie
               if UserInputService:IsKeyDown(Enum.KeyCode.W) then direction = direction + camera.CFrame.LookVector end
               if UserInputService:IsKeyDown(Enum.KeyCode.S) then direction = direction - camera.CFrame.LookVector end
               if UserInputService:IsKeyDown(Enum.KeyCode.D) then direction = direction + camera.CFrame.RightVector end
               if UserInputService:IsKeyDown(Enum.KeyCode.A) then direction = direction - camera.CFrame.RightVector end
               if UserInputService:IsKeyDown(Enum.KeyCode.Space) then direction = direction + Vector3.new(0, 1, 0) end
               if UserInputService:IsKeyDown(Enum.KeyCode.LeftShift) then direction = direction - Vector3.new(0, 1, 0) end
               
               vGyro.CFrame = camera.CFrame
               
               if direction.Magnitude > 0 then
                  vFly.Velocity = direction.Unit * _G.FlySpeed
               else
                  vFly.Velocity = Vector3.new(0, 0, 0)
               end
            else
               -- Jeśli postać zginie lub Fly zostanie wyłączony w inny sposób
               if flyConnection then flyConnection:Disconnect() flyConnection = nil end
            end
         end)
      else
         -- WYŁĄCZENIE I CZYSZCZENIE
         if flyConnection then 
            flyConnection:Disconnect() 
            flyConnection = nil 
         end
         
         pcall(function()
            local char = LocalPlayer.Character
            if char then
               local hum = char:FindFirstChildOfClass("Humanoid")
               if hum then hum.PlatformStand = false end
               
               local hrp = char:FindFirstChild("HumanoidRootPart")
               if hrp then
                  if hrp:FindFirstChild("IY_FlyVelocity") then hrp.IY_FlyVelocity:Destroy() end
                  if hrp:FindFirstChild("IY_FlyGyro") then hrp.IY_FlyGyro:Destroy() end
               end
            end
         end)
      end
   end,
})
TabPlayer:CreateSlider({
   Name = "Fly Speed",
   Range = {0, 500},
   Increment = 1,
   Suffix = " Velocity",
   CurrentValue = 50,
   Flag = "FlySpeedValue",
   Callback = function(Value)
      _G.FlySpeed = Value
   end,
})

------------------- ESP Mode ----------------------------

-- ==========================================
-- KONFIGURACJA I ZMIENNE ESP
-- ==========================================
_G.ESP_Enabled = false
_G.ESP_Targets = {
    Players = true,
    Police = true,
    Criminals = true
}
_G.ESP_Settings = {
    Boxes = false,
    Tracers = false,
    Skeletons = false,
    Names = false,
    Thickness = 1,
}

local ESP_Objects = {}
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local Camera = workspace.CurrentCamera

-- FUNKCJA POBIERANIA KOLORU ROLI
local function GetJobColor(player)
    local job = player:GetAttribute("JobId")
    if job == "Security" then return Color3.fromRGB(0, 0, 255)    -- Deep Blue
    elseif job == "Criminal" then return Color3.fromRGB(255, 0, 0) -- Really Red
    end
    return Color3.fromRGB(0, 255, 0) -- Neutral Lime
end

-- FUNKCJA TWORZENIA OBIEKTÓW RYSUNKOWYCH
local function CreateESP(player)
    if ESP_Objects[player] then return end
    local objects = {
        Box = Drawing.new("Square"),
        Tracer = Drawing.new("Line"),
        Name = Drawing.new("Text"),
        Skeleton = {
            Spine = Drawing.new("Line"),
            LeftArm = Drawing.new("Line"),
            RightArm = Drawing.new("Line"),
            LeftLeg = Drawing.new("Line"),
            RightLeg = Drawing.new("Line")
        }
    }
    -- Ustawienia bazowe
    objects.Box.Filled = false
    objects.Name.Center = true
    objects.Name.Outline = true
    objects.Name.Size = 14
    ESP_Objects[player] = objects
end

local function RemoveESP(player)
    if ESP_Objects[player] then
        local obj = ESP_Objects[player]
        obj.Box:Remove()
        obj.Tracer:Remove()
        obj.Name:Remove()
        for _, line in pairs(obj.Skeleton) do line:Remove() end
        ESP_Objects[player] = nil
    end
end

-- Inicjalizacja graczy
for _, p in pairs(Players:GetPlayers()) do if p ~= LocalPlayer then CreateESP(p) end end
Players.PlayerAdded:Connect(CreateESP)
Players.PlayerRemoving:Connect(RemoveESP)

-- ==========================================
-- INTERFEJS UŻYTKOWNIKA (TabVisuals)
-- ==========================================
local SectionMaster = TabVisuals:CreateSection("Master Control")

TabVisuals:CreateToggle({
    Name = "Enable ESP",
    CurrentValue = false,
    Flag = "ESP_Master",
    Callback = function(v) _G.ESP_Enabled = v end,
})

local SectionTargets = TabVisuals:CreateSection("Targets (Filters)")

TabVisuals:CreateToggle({
    Name = "Players (Neutral)",
    CurrentValue = true,
    Flag = "Target_P",
    Callback = function(v) _G.ESP_Targets.Players = v end,
})

TabVisuals:CreateToggle({
    Name = "Police (Security)",
    CurrentValue = true,
    Flag = "Target_Pol",
    Callback = function(v) _G.ESP_Targets.Police = v end,
})

TabVisuals:CreateToggle({
    Name = "Criminals",
    CurrentValue = true,
    Flag = "Target_Crim",
    Callback = function(v) _G.ESP_Targets.Criminals = v end,
})

local SectionStyles = TabVisuals:CreateSection("Visual Styles")

TabVisuals:CreateToggle({
    Name = "Boxes 2D",
    CurrentValue = false,
    Flag = "ESP_Box",
    Callback = function(v) _G.ESP_Settings.Boxes = v end,
})

TabVisuals:CreateToggle({
    Name = "Tracers",
    CurrentValue = false,
    Flag = "ESP_Tracers",
    Callback = function(v) _G.ESP_Settings.Tracers = v end,
})

TabVisuals:CreateToggle({
    Name = "Skeletons",
    CurrentValue = false,
    Flag = "ESP_Skeleton",
    Callback = function(v) _G.ESP_Settings.Skeletons = v end,
})

TabVisuals:CreateToggle({
    Name = "Show Names & Distance",
    CurrentValue = false,
    Flag = "ESP_Names",
    Callback = function(v) _G.ESP_Settings.Names = v end,
})

TabVisuals:CreateSlider({
    Name = "Line Thickness",
    Range = {1, 5},
    Increment = 0.5,
    Suffix = "px",
    CurrentValue = 1,
    Flag = "ESP_Thick",
    Callback = function(v) _G.ESP_Settings.Thickness = v end,
})

-- ==========================================
-- GŁÓWNA LOGIKA RENDEROWANIA (Loop)
-- ==========================================
local function GetDynamicColor(player)
    local job = player:GetAttribute("JobId")
    
    -- Jeśli to Policja I toggle Police jest włączony -> Niebieski
    if job == "Security" and _G.ESP_Targets.Police then
        return Color3.fromRGB(0, 0, 255)
    end
    
    -- Jeśli to Kryminalista I toggle Criminals jest włączony -> Czerwony
    if job == "Criminal" and _G.ESP_Targets.Criminals then
        return Color3.fromRGB(255, 0, 0)
    end
    
    -- W każdym innym przypadku (neutralny gracz LUB wyłączony toggle roli) -> Lime
    return Color3.fromRGB(0, 255, 0)
end

RunService.RenderStepped:Connect(function()
    for player, obj in pairs(ESP_Objects) do
        local char = player.Character
        local hrp = char and char:FindFirstChild("HumanoidRootPart")
        local hum = char and char:FindFirstChildOfClass("Humanoid")
        
        -- LOGIKA WIDOCZNOŚCI:
        -- Jeśli ESP jest włączone I ogólny toggle Players jest włączony -> Pokazuj wszystkich
        local isTarget = _G.ESP_Enabled and _G.ESP_Targets.Players 

        if isTarget and hrp and hum and hum.Health > 0 then
            local pos, onScreen = Camera:WorldToViewportPoint(hrp.Position)
            
            if onScreen then
                -- Kolor zmieni się na niebieski/czerwony tylko jeśli toggle roli jest ON
                local color = GetDynamicColor(player)
                local dist = math.floor((Camera.CFrame.p - hrp.Position).magnitude)
                local thickness = _G.ESP_Settings.Thickness

                -- RENDER BOX 2D
                if _G.ESP_Settings.Boxes then
                    local sizeX = 2000 / pos.Z
                    local sizeY = 3000 / pos.Z
                    obj.Box.Visible = true
                    obj.Box.Color = color
                    obj.Box.Thickness = thickness
                    obj.Box.Size = Vector2.new(sizeX, sizeY)
                    obj.Box.Position = Vector2.new(pos.X - sizeX / 2, pos.Y - sizeY / 2)
                else obj.Box.Visible = false end

                -- RENDER TRACERS
                if _G.ESP_Settings.Tracers then
                    obj.Tracer.Visible = true
                    obj.Tracer.Color = color
                    obj.Tracer.Thickness = thickness
                    obj.Tracer.From = Vector2.new(Camera.ViewportSize.X / 2, Camera.ViewportSize.Y)
                    obj.Tracer.To = Vector2.new(pos.X, pos.Y)
                else obj.Tracer.Visible = false end

                -- RENDER NAMES
                if _G.ESP_Settings.Names then
                    obj.Name.Visible = true
                    obj.Name.Color = Color3.new(1,1,1)
                    obj.Name.Position = Vector2.new(pos.X, pos.Y - (3000 / pos.Z) / 2 - 20)
                    obj.Name.Text = string.format("%s\n[%s studs]", player.Name, dist)
                else obj.Name.Visible = false end

                -- RENDER SKELETON (R15/R6 Basic)
                if _G.ESP_Settings.Skeletons and char:FindFirstChild("Head") then
                    local headPos = Camera:WorldToViewportPoint(char.Head.Position)
                    obj.Skeleton.Spine.Visible = true
                    obj.Skeleton.Spine.From = Vector2.new(headPos.X, headPos.Y)
                    obj.Skeleton.Spine.To = Vector2.new(pos.X, pos.Y)
                    obj.Skeleton.Spine.Color = color
                    obj.Skeleton.Spine.Thickness = thickness
                else
                    for _, l in pairs(obj.Skeleton) do l.Visible = false end
                end
            else
                -- Poza ekranem
                obj.Box.Visible = false
                obj.Tracer.Visible = false
                obj.Name.Visible = false
                for _, l in pairs(obj.Skeleton) do l.Visible = false end
            end
        else
            -- Wyłączone
            obj.Box.Visible = false
            obj.Tracer.Visible = false
            obj.Name.Visible = false
            for _, l in pairs(obj.Skeleton) do l.Visible = false end
        end
    end
end)

---------- Job Joiner ----------------------
local JobActions = TabJobs:CreateSection("Jobs Joiner")

-- PRZYCISK: POLICE JOB
TabJobs:CreateButton({
   Name = "Police Job (Join/Leave)",
   Callback = function()
       local currentJob = LocalPlayer:GetAttribute("JobId")
       
       if currentJob == "Security" then
           -- Jeśli jesteśmy policjantem, to wychodzimy
           local args = {"jobPad"}
           RemoteEnd:FireServer(unpack(args))
           else
           -- Jeśli nie jesteśmy, to dołączamy (nawet jeśli jesteśmy w Criminalu, gra nas przełączy)
           local args = {"Security", "jobPad"}
           RemoteStart:FireServer(unpack(args))       
           end
   end,
})

-- PRZYCISK: CRIMINAL JOB
TabJobs:CreateButton({
   Name = "Criminal Job (Join/Leave)",
   Callback = function()
       local currentJob = LocalPlayer:GetAttribute("JobId")
       
       if currentJob == "Criminal" then
           -- Jeśli jesteśmy kryminalistą, to wychodzimy
           local args = {"jobPad"}
           RemoteEnd:FireServer(unpack(args))
       else
           -- Jeśli nie jesteśmy, to dołączamy
           local args = {"Criminal", "jobPad"}
           RemoteStart:FireServer(unpack(args))
       end
   end,
})

-- Dodatkowy wskaźnik statusu pod przyciskami
local StatusSection = TabJobs:CreateSection("Current Status")
local CurrentJobLabel = TabJobs:CreateLabel("Current Role: Unknown")

task.spawn(function()
    while task.wait(1) do
        local job = LocalPlayer:GetAttribute("JobId")
        if job == "Security" then
            CurrentJobLabel:Set("Current Role: Police Officer 👮")
        elseif job == "Criminal" then
            CurrentJobLabel:Set("Current Role: Criminal 😈")
        else
            CurrentJobLabel:Set("Current Role: Citizen 🚶")
        end
    end
end)

------------- Vehicle Info ------------------
local VehInfoSection = TabVehicle:CreateSection("Active Vehicle Statistics")

local ModelLabel = TabVehicle:CreateLabel("Current Model: None")
local SeatLabel = TabVehicle:CreateLabel("Status: On Foot")
local PartsLabel = TabVehicle:CreateLabel("Parts Detected: 0")
local SpeedLabel = TabVehicle:CreateLabel("Current Speed: 0 SPS")
local rainbowEnabled = false
local originalColors = {} -- Przechowywanie kolorów: [Part] = Color3

-- 4. Przełącznik ESP / Rainbow RGB
local RainbowToggle = TabVehicle:CreateToggle({
   Name = "Vehicle RGB ESP",
   CurrentValue = false,
   Flag = "VehRGBToggle",
   Callback = function(Value)
      rainbowEnabled = Value
      
      -- Jeśli wyłączamy, przywracamy kolory natychmiast
      if not Value then
          for part, color in pairs(originalColors) do
              if part and part.Parent then
                  part.Color = color
              end
          end
          table.clear(originalColors) -- Czyścimy bazę po przywróceniu
      end
   end,
})
-- Zmienne sterujące
local physicsEnabled = false -- Stan przełącznika
local accelPower = 0  
local brakeForce = 0  

-- 1. Przełącznik Główny
local MainToggle = TabVehicle:CreateToggle({
   Name = "Toggle Custom Modifier",
   CurrentValue = false,
   Flag = "VehPhysicsToggle",
   Callback = function(Value)
      physicsEnabled = Value
   end,
})

-- 2. Slider: Acceleration (W obie strony)
local AccelSlider = TabVehicle:CreateSlider({
    Name = "Acceleration Power",
    Range = {0, 100},
    Increment = 1,
    Suffix = " Boost",
    CurrentValue = 0,
    Flag = "VehAccelPower",
    Callback = function(Value)
        accelPower = Value
    end,
})

-- 3. Slider: Brake Force (Kotwica)
local BrakeSlider = TabVehicle:CreateSlider({
    Name = "Brake Force",
    Range = {0, 150},
    Increment = 1,
    Suffix = " Grip",
    CurrentValue = 0,
    Flag = "VehBrakeForce",
    Callback = function(Value)
        brakeForce = Value
    end,
})

task.spawn(function()
    local hue = 0
    while task.wait() do
        if rainbowEnabled then
            local myVeh = GetMyVehicle()
            if myVeh then
                -- Pobieramy absolutnie wszystko co jest w aucie
                local allObjects = myVeh:GetDescendants()
                
                hue = (hue + 1) % 360
                local rainbowColor = Color3.fromHSV(hue / 360, 0.9, 1) 
                
                for _, obj in pairs(allObjects) do
                    -- Sprawdzamy czy obiekt to jakakolwiek część (MeshPart, Part, Wedge itd.)
                    if obj:IsA("BasePart") then
                        -- Zapisujemy kolor tylko raz (przy pierwszym wykryciu części)
                        if not originalColors[obj] then
                            originalColors[obj] = obj.Color
                        end
                        -- Nakładamy kolor
                        obj.Color = rainbowColor
                    end
                end
            end
        else
            -- Jeśli wyłączone, pętla czeka dłużej, żeby nie obciążać procesora
            task.wait(0.3)
        end
    end
end)
-- GŁÓWNA PĘTLA
task.spawn(function()
    while task.wait(0.1) do
        local myVeh = GetMyVehicle()
        
        if myVeh then
            local seat = myVeh:FindFirstChild("VehicleSeat")
            
            -- UI: Nazwa i Status
            local carType = myVeh:FindFirstChild("CarType")
            ModelLabel:Set("Current Model: " .. tostring(carType and carType.Value or myVeh.Name))
            
            local driverObj = myVeh:FindFirstChild("Driver")
            SeatLabel:Set((driverObj and driverObj.Value == LocalPlayer) and "Status: Driving 🏎️" or "Status: Outside 🚶")

            -- UI: Liczenie części
            local allParts = myVeh:GetDescendants()
            local partCount = 0
            for _, p in pairs(allParts) do
                if p:IsA("BasePart") then partCount = partCount + 1 end
            end
            PartsLabel:Set("Parts Detected: " .. tostring(partCount))

            if seat then
                local velocity = seat.AssemblyLinearVelocity
                local speed = velocity.Magnitude
                SpeedLabel:Set("Current Speed: " .. math.floor(speed) .. " SPS")

                -- LOGIKA FIZYKI (Tylko gdy Toggle jest włączony)
                if physicsEnabled then
                    -- Odblokowanie MaxSpeed w siedzeniu
                    if seat.MaxSpeed  0 and math.abs(throttle) > 0 then
                        -- Sprawdzanie czy auto porusza się przodem czy tyłem
                        local isMovingForward = seat.CFrame.LookVector:Dot(velocity) > 0
                        
                        if throttle > 0 then -- Naciskasz W (Gaz)
                            if isMovingForward or speed < 3 then
                                -- Boost do przodu
                                seat.AssemblyLinearVelocity = velocity + (seat.CFrame.LookVector * (accelPower / 5))
                            else
                                -- Kontra (Hamowanie silne)
                                seat.AssemblyLinearVelocity = velocity * (1 - (brakeForce / 200))
                            end
                        elseif throttle < 0 then -- Naciskasz S (Wsteczny)
                            if not isMovingForward or speed  3 do
        if not ATMFlag.Search or (tick() - startT) > timeout then break end
        
        human:MoveTo(destination)
        
        -- Jeśli utknie (prędkość bliska 0), niech podskoczy
        if root.AssemblyLinearVelocity.Magnitude < 0.5 then
            human.Jump = true
        end
        
        task.wait(0.1)
    end
end

local function IsPoliceNearby(radius)
    local root = LocalPlayer.Character and LocalPlayer.Character:FindFirstChild("HumanoidRootPart")
    if not root then return false end
    for _, p in ipairs(Players:GetPlayers()) do
        if p ~= LocalPlayer and p:GetAttribute("JobId") == "Security" then
            local otherRoot = p.Character and p.Character:FindFirstChild("HumanoidRootPart")
            if otherRoot and (root.Position - otherRoot.Position).Magnitude = limit then
        setStatus("Limit osiągnięty ("..currentCrimes..") - Sprzedaż...")
        
        -- Pętla sprzedaży dopóki worki nie znikną
        while currentCrimes >= limit and ATMFlag.Search do
            SetNoclip(true) -- Upewniamy się, że noclip działa przy sprzedaży
            tpTo(sellPos1)
            task.wait(Config.task1)
            setStatus("Idę do punktu sprzedaży...")
            SimpleGoTo(sellPos2, 2)
            task.wait(Config.task2) -- Czas na przetworzenie sprzedaży przez serwer
            
            currentCrimes = LocalPlayer.Character and LocalPlayer.Character:GetAttribute("CrimesCommitted") or 0
        end
        
        setStatus("Sprzedano! Wracam do pracy.")
        return true -- Zwraca true, jeśli sprzedaż się odbyła
    end
    return false
end
local function SmartBust(targetSpawner, atmModel)
    if not ATMFlag.Search then return end
    
    local safePos = platformPositions[math.random(1, #platformPositions)]
    local root = LocalPlayer.Character and LocalPlayer.Character:FindFirstChild("HumanoidRootPart")

    -- KROK 1: Start
    setStatus("Rozpoczynanie rabunku...")
    if root then root.AssemblyLinearVelocity = Vector3.new(0,0,0) end
    tpTo(targetSpawner.Position)
    task.wait(Config.task3)
    
    bustStart:InvokeServer(atmModel)
    
    -- KROK 2: Ucieczka na bezpieczną platformę
    setStatus("Czekanie w bezpiecznym miejscu...")
    tpTo(safePos)
    task.wait(Config.task4) -- Lekko wydłużone dla bezpieczeństwa
    
    -- KROK 3: Odbiór
    setStatus("Odbiór łupu...")
    if root then root.AssemblyLinearVelocity = Vector3.new(0,0,0) end
    tpTo(targetSpawner.Position)
    task.wait(Config.task5)
    bustEnd:InvokeServer(atmModel)
    
    task.wait(Config.task6)
    tpTo(safePos)
    
    -- KLUCZOWE: Sprawdź limit natychmiast po rabunku!
    CheckBagLimit()
end

-- =============================================================================
-- 5. GŁÓWNA PĘTLA (START_LOOP)
-- =============================================================================

local function StartLoop()
    task.spawn(function()
        while ATMFlag.Search do
            -- 1. Sprawdź limit przed rozpoczęciem nowej rundy platform
            CheckBagLimit()

            -- 2. Przeszukiwanie platform
            for _, platformPos in ipairs(platformPositions) do
                if not ATMFlag.Search then break end
                
                -- Sprawdź limit przed skokiem na KAŻDĄ kolejną platformę
                -- (Zapobiega to lataniu z pełnymi workami po mapie)
                if CheckBagLimit() then
                    -- Jeśli sprzedał, wróć na platformę startową ronde
                    tpTo(platformPos) 
                end
                
                SetNoclip(true)
                setWeight(true)
                
                setStatus("Skanowanie platformy...")
                tpTo(platformPos)
                task.wait(Config.task7) -- Czas na załadowanie się ATM w streamingu

                local spawner, atm = GetAvailableATM()
                if spawner and atm then
                    SmartBust(spawner, atm)
                    setStatus("Przerwa techniczna (Cooldown)...")
                    task.wait(Config.task8)
                end
            end
            task.wait(0.1)
        end
    end)
end
-- =============================================================================
-- 6. START / STOP (ZARZĄDZANIE KROKAMI)
-- =============================================================================

function StartATMFarm()
    if ATMFlag.Search then return end
    ATMFlag.Search = true

    -- KROK 1: Drużyna
    setStatus("Krok 1: Weryfikacja drużyny")
    pcall(function() RemoteStart:FireServer("Criminal", "jobPad") end)
    task.wait(0.5)

    -- KROK 2: Platformy
    setStatus("Krok 2: Tworzenie platform")
    removeAllPlatforms()
    createAllPlatforms()
    task.wait(0.5)

    -- KROK 3: Fizyka i Noclip
    setStatus("Krok 3: Wczytywanie Funkcji")
    SetNoclip(true)
    setWeight(true)
    task.wait(1)

    -- Rozpoczęcie pętli
    StartLoop()
end

function StopATMFarm()
    if not ATMFlag.Search then return end
    ATMFlag.Search = false
    setStatus("Zatrzymywanie...")
    
    tpTo(spawnPos)
    task.wait(0.5)
    
    pcall(function() RemoteEnd:FireServer("jobPad") end)
    SetNoclip(false)
    setWeight(false)
    removeAllPlatforms()
    setStatus("Farma wyłączona")
end

-- =============================================================================
-- 7. INTERFEJS UŻYTKOWNIKA (RAYFIELD)
-- =============================================================================

TabFarm:CreateToggle({
    Name = "Uruchom ATM Farm",
    CurrentValue = false,
    Flag = "ATMFarmToggle",
    Callback = function(Value)
        if Value then StartATMFarm() else StopATMFarm() end
    end,
})

TabFarm:CreateSlider({
    Name = "Limit Worków",
    Range = {6, 200},
    Increment = 1,
    Suffix = "Bags",
    CurrentValue = 25,
    Flag = "BagSlider",
    Callback = function(Value) end,
})
StatusLabel = TabFarm:CreateLabel("Status: Oczekiwanie...")
ProgressLabel = TabFarm:CreateLabel("Postęp worków: 0 / 0")
TabFarm:CreateLabel("⚙️ KONFIGURACJA PRĘDKOŚCI Farmy (DELAYS)")
TabFarm:CreateInput({
    Name = "Task 1: Teleport SellPos1",
    PlaceholderText = "Obecnie: " .. Config.task1,
    RemoveTextAfterFocusLost = false,
    Callback = function(Text)
        local val = tonumber(Text)
        if val then Config.task1 = val notifyUpdate("Task 1", val) end
    end,
})

-- Task 2
TabFarm:CreateInput({
    Name = "Task 2: Przetwarzanie Sprzedaży",
    PlaceholderText = "Obecnie: " .. Config.task2,
    RemoveTextAfterFocusLost = false,
    Callback = function(Text)
        local val = tonumber(Text)
        if val then Config.task2 = val notifyUpdate("Task 2", val) end
    end,
})

-- TabFarm 3
TabFarm:CreateInput({
    Name = "Task 3: Wczytanie ATM (Start)",
    PlaceholderText = "Obecnie: " .. Config.task3,
    RemoveTextAfterFocusLost = false,
    Callback = function(Text)
        local val = tonumber(Text)
        if val then Config.task3 = val notifyUpdate("Task 3", val) end
    end,
})

-- Task 4
TabFarm:CreateInput({
    Name = "Task 4: Cooldown Rabunku",
    PlaceholderText = "Obecnie: " .. Config.task4,
    RemoveTextAfterFocusLost = false,
    Callback = function(Text)
        local val = tonumber(Text)
        if val then Config.task4 = val notifyUpdate("Task 4", val) end
    end,
})

-- Task 5
TabFarm:CreateInput({
    Name = "Task 5: Wczytanie ATM (Odbiór)",
    PlaceholderText = "Obecnie: " .. Config.task5,
    RemoveTextAfterFocusLost = false,
    Callback = function(Text)
        local val = tonumber(Text)
        if val then Config.task5 = val notifyUpdate("Task 5", val) end
    end,
})

-- Task 6
TabFarm:CreateInput({
    Name = "Task 6: Finalizacja Rabunku",
    PlaceholderText = "Obecnie: " .. Config.task6,
    RemoveTextAfterFocusLost = false,
    Callback = function(Text)
        local val = tonumber(Text)
        if val then Config.task6 = val notifyUpdate("Task 6", val) end
    end,
})

-- Task 7
TabFarm:CreateInput({
    Name = "Task 7: Ładowanie Platform",
    PlaceholderText = "Obecnie: " .. Config.task7,
    RemoveTextAfterFocusLost = false,
    Callback = function(Text)
        local val = tonumber(Text)
        if val then Config.task7 = val notifyUpdate("Task 7", val) end
    end,
})

-- Task 8
TabFarm:CreateInput({
    Name = "Task 8: Przerwa Chwilowa",
    PlaceholderText = "Obecnie: " .. Config.task8,
    RemoveTextAfterFocusLost = false,
    Callback = function(Text)
        local val = tonumber(Text)
        if val then Config.task8 = val notifyUpdate("Task 8", val) end
    end,
})

--- Przycisk Resetu ---
TabFarm:CreateButton({
    Name = "♻️ RESETUJ WSZYSTKIE OPÓŹNIENIA",
    Callback = function()
        Config.task1 = 0.5
        Config.task2 = 2.0
        Config.task3 = 0.15
        Config.task4 = 5.0
        Config.task5 = 0.15
        Config.task6 = 0.0
        Config.task7 = 5.0
        Config.task8 = 0.0
        Rayfield:Notify({
            Title = "Reset Konfiguracji",
            Content = "Przywrócono wartości domyślne.",
            Duration = 3,
            Image = 4483362458,
        })
    end,
})

-- Pętla UI (Progress)
task.spawn(function()
    while true do
        pcall(function()
            if ProgressLabel and LocalPlayer.Character then
                local cur = LocalPlayer.Character:GetAttribute("CrimesCommitted") or 0
                local lim = (Rayfield.Flags.BagSlider and Rayfield.Flags.BagSlider.CurrentValue) or 0
                ProgressLabel:Set("Postęp worków: " .. cur .. " / " .. lim)
                if cur >= lim and lim > 0 then
                    ProgressLabel:Set("Postęp worków: " .. cur .. " / " .. lim .. " (FULL! 💰)")
                end
            end
        end)
        task.wait(0.5)
    end
end)

Rayfield:LoadConfiguration()