local Rayfield = loadstring(game:HttpGet('https://sirius.menu/rayfield'))()

local Window = Rayfield:CreateWindow({
    Name = "Cryziie's Arsenal Script",
    Icon = 0,
    LoadingTitle = "taking suggestions dm @Cryziie on discord",
    LoadingSubtitle = "Presented by: Cryziie",
    ShowText = "taking suggestions dm @Cryziie on discord",
    Theme = "Default",
    ToggleUIKeybind = "K",
    DisableRayfieldPrompts = false,
    DisableBuildWarnings = false,
    ConfigurationSaving = {
        Enabled = true,
        FolderName = nil,
        FileName = "Big Hub"
    },
    Discord = {
        Enabled = false,
        Invite = "noinvitelink",
        RememberJoins = true
    },
    KeySystem = false,
    KeySettings = {
        Title = "Untitled",
        Subtitle = "Key System",
        Note = "No method of obtaining the key is provided",
        FileName = "Key",
        SaveKey = true,
        GrabKeyFromSite = false,
        Key = {"Hello"}
    }
})

local MainTab = Window:CreateTab("Movement", nil)


-- Infinite Jump Toggle
local InfiniteJumpEnabled = false
local InfiniteJumpConnection = nil

MainTab:CreateToggle({
    Name = "Infinite Jump",
    CurrentValue = false,
    Callback = function(Value)
        InfiniteJumpEnabled = Value
        
        -- Clean up existing connection if toggled off
        if not InfiniteJumpEnabled then
            if InfiniteJumpConnection then
                InfiniteJumpConnection:Disconnect()
                InfiniteJumpConnection = nil
            end
            return
        end

        -- Start connection when toggled on
        local Players = game:GetService("Players")
        local UserInputService = game:GetService("UserInputService")
        local player = Players.LocalPlayer

        InfiniteJumpConnection = UserInputService.InputBegan:Connect(function(input, gameProcessed)
            if gameProcessed then return end
            if not InfiniteJumpEnabled then return end

            if input.KeyCode == Enum.KeyCode.Space then
                local character = player.Character
                local humanoid = character and character:FindFirstChildOfClass("Humanoid")
                local rootPart = character and character:FindFirstChild("HumanoidRootPart")

                if humanoid and rootPart and humanoid:GetState() ~= Enum.HumanoidStateType.Dead then
                    humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
                    rootPart.AssemblyLinearVelocity = Vector3.new(rootPart.AssemblyLinearVelocity.X, humanoid.JumpPower, rootPart.AssemblyLinearVelocity.Z)
                end
            end
        end)
    end,
})

local Flying = false
local FlySpeedSetting = 50
local Players = game:GetService("Players")
local LocalPlayer = Players.LocalPlayer
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")

local function toggleFlight(enabled)
    if enabled then
        local character = LocalPlayer.Character or LocalPlayer.CharacterAdded:Wait()
        local root = character:WaitForChild("HumanoidRootPart")

        local bv = Instance.new("BodyVelocity")
        bv.MaxForce = Vector3.new(1e5, 1e5, 1e5)
        bv.Parent = root

        local bg = Instance.new("BodyGyro")
        bg.MaxTorque = Vector3.new(1e5, 1e5, 1e5)
        bg.CFrame = root.CFrame
        bg.Parent = root

        RunService.RenderStepped:Connect(function() 
            if Flying then
                local moveDirection = Vector3.new(0, 0, 0)
                if UserInputService:IsKeyDown(Enum.KeyCode.W) then moveDirection = moveDirection + workspace.CurrentCamera.CFrame.LookVector end
                if UserInputService:IsKeyDown(Enum.KeyCode.S) then moveDirection = moveDirection - workspace.CurrentCamera.CFrame.LookVector end
                if UserInputService:IsKeyDown(Enum.KeyCode.A) then moveDirection = moveDirection - workspace.CurrentCamera.CFrame.RightVector end
                if UserInputService:IsKeyDown(Enum.KeyCode.D) then moveDirection = moveDirection + workspace.CurrentCamera.CFrame.RightVector end
                if UserInputService:IsKeyDown(Enum.KeyCode.Space) then moveDirection = moveDirection + Vector3.new(0, 1, 0) end
                if UserInputService:IsKeyDown(Enum.KeyCode.LeftShift) then moveDirection = moveDirection - Vector3.new(0, 1, 0) end

                -- Update velocity only if there is a movement input
                if moveDirection.Magnitude > 0 then
                    bv.Velocity = moveDirection.Unit * FlySpeedSetting
                else
                    bv.Velocity = Vector3.new(0, 0, 0) -- Stop movement when no keys are pressed
                end
                
                -- Maintain vertical position to avoid any unintended downward movement
                bv.Velocity = Vector3.new(bv.Velocity.X, bv.Velocity.Y, bv.Velocity.Z)
            end
        end)
    else
        local character = LocalPlayer.Character
        if character and character:FindFirstChild("HumanoidRootPart") then
            for _, obj in pairs(character.HumanoidRootPart:GetChildren()) do
                if obj:IsA("BodyVelocity") or obj:IsA("BodyGyro") then
                    obj:Destroy()
                end
            end
        end
    end
end

MainTab:CreateToggle({
    Name = "Flight Mode",
    Info = "Activating this instantly starts flying. Deactivating stops it.",
    CurrentValue = false,
    Flag = "FlightToggleClean",
    Callback = function(Value)
        Flying = Value
        toggleFlight(Value)
    end,
})

-- Flight Speed Slider
MainTab:CreateSlider({
    Name = "Fly Speed",
    Info = "Adjusts your velocity while flying.",
    Range = {0, 400},
    Increment = 5,
    Suffix = " Speed",
    CurrentValue = 50,
    Flag = "FlySpeedSlider",
    Callback = function(Value)
        FlySpeedSetting = Value
        local Player = Players.LocalPlayer
        if not Player.Character or not Player.Character:FindFirstChild("Humanoid") then return end
        if Player.Character.Humanoid:GetState() == Enum.HumanoidStateType.Freefall then
            Player.Character.Humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
        end
    end,
})

MainTab:CreateToggle({
    Name = "No Clip",
    Info = "Enable/Disable No Clip (pass through walls)",
    CurrentValue = false,
    Flag = "NoClipToggle",
    Callback = function(Value)
        NoClipEnabled = Value
        local character = LocalPlayer.Character or LocalPlayer.CharacterAdded:Wait()
        
        for _, part in pairs(character:GetChildren()) do
            if part:IsA("BasePart") then
                part.CanCollide = not NoClipEnabled -- Disable collisions in No Clip mode
            end
        end

        if NoClipEnabled then
            RunService.Stepped:Connect(function()
                if NoClipEnabled then
                    local root = character:FindFirstChild("HumanoidRootPart")
                    if root then
                        root.Position = root.Position -- This will continuously set position, preventing it from snapping back
                    end
                end
            end)
        end
    end,
})

local Divider = MainTab:CreateDivider()
local Paragraph = MainTab:CreateParagraph({Title = "I am still learning and definitely taking suggestions for features to add just dm @Cryziie on discord", Content = ""})
local Paragraph = MainTab:CreateParagraph({Title = "this also works on other games too i know flight works on jailbreak mm2 just try it out and LMKK watchu think PLEASEE", Content = ""})

local SecondTab = Window:CreateTab("Aimbot", nil)

-- ESP Setup
local ESPEnabled = false
local Camera = workspace.CurrentCamera
local Cache = {}

local function CleanPlayerESP(player)
    if Cache[player] then
        if Cache[player].Line then 
            Cache[player].Line:Destroy() 
            Cache[player].Line = nil
        end
        if Cache[player].Text then 
            Cache[player].Text:Destroy() 
            Cache[player].Text = nil
        end
        if Cache[player].Highlight then 
            Cache[player].Highlight:Destroy() 
            Cache[player].Highlight = nil
        end
        Cache[player] = nil
    end
end

local function CreateESP(player)
    if player == LocalPlayer then return end

    local connection
    connection = RunService.RenderStepped:Connect(function()
        local character = player.Character
        local root = character and character:FindFirstChild("HumanoidRootPart")
        local humanoid = character and character:FindFirstChildOfClass("Humanoid")

        if not character or not root or not humanoid or humanoid.Health <= 0 then
            CleanPlayerESP(player)
            return
        end

        if not ESPEnabled then
            return 
        end
        
        local screenPos, onScreen = Camera:WorldToViewportPoint(root.Position)

        if onScreen then
            if not Cache[player] then
                Cache[player] = {}
            end

            -- ESP Highlight
            if not Cache[player].Highlight or not Cache[player].Highlight.Parent then
                local highlight = Instance.new("Highlight")
                highlight.Name = "ESPOutline"
                highlight.FillColor = Color3.fromRGB(255, 0, 0)
                highlight.FillTransparency = 0.6
                highlight.OutlineColor = Color3.fromRGB(255, 0, 0)
                highlight.OutlineTransparency = 0
                highlight.Adornee = character
                highlight.Parent = character
                Cache[player].Highlight = highlight
            else
                Cache[player].Highlight.Enabled = true
            end

            -- Tracer Lines
            if not Cache[player].Line then
                local line = Drawing.new("Line")
                line.Color = Color3.fromRGB(255, 0, 0)
                line.Thickness = 2
                line.Transparency = 1
                Cache[player].Line = line
            end
            Cache[player].Line.From = Vector2.new(Camera.ViewportSize.X / 2, Camera.ViewportSize.Y)
            Cache[player].Line.To = Vector2.new(screenPos.X, screenPos.Y)
            Cache[player].Line.Visible = true

            -- Distance Text Tracking
            if not Cache[player].Text then
                local text = Drawing.new("Text")
                text.Color = Color3.fromRGB(255, 255, 255)
                text.Size = 18
                text.Center = true
                text.Outline = true
                text.OutlineColor = Color3.fromRGB(0, 0, 0)
                Cache[player].Text = text
            end

            local distance = math.floor((LocalPlayer.Character and LocalPlayer.Character:FindFirstChild("HumanoidRootPart") and (LocalPlayer.Character.HumanoidRootPart.Position - root.Position).Magnitude) or 0)
            Cache[player].Text.Text = string.format("%s\n[%d studs]", player.Name, distance)
            Cache[player].Text.Position = Vector2.new(screenPos.X, screenPos.Y - 45)
            Cache[player].Text.Visible = true
        else
            CleanPlayerESP(player)
        end
    end)

    player.CharacterRemoving:Connect(function() CleanPlayerESP(player) end)
end

-- ESP
SecondTab:CreateToggle({
    Name = "ESP",
    Info = "Toggle Enemy ESP on/off.",
    CurrentValue = false,
    Flag = "ESPToggle",
    Callback = function(Value)
        ESPEnabled = Value
        if Value then
            for _, p in pairs(Players:GetPlayers()) do CreateESP(p) end
            Players.PlayerAdded:Connect(CreateESP)
        else
            for _, p in pairs(Players:GetPlayers()) do CleanPlayerESP(p) end
        end
    end,
})

-- END OF ESP

-- AIMBOT
local AimbotEnabled = false
local AimbotMaxDistance = 1000
local AimbotConn = nil
local AimbotFOV = 60 -- Default FOV value
local ignoredUsernames = {} -- List of usernames to ignore

local function GetClosestEnemy()
    local closest = nil
    local shortestDist = AimbotMaxDistance
    local myChar = LocalPlayer.Character
    local myRoot = myChar and myChar:FindFirstChild("HumanoidRootPart")
    if not myRoot then return nil end

    for _, plr in ipairs(Players:GetPlayers()) do
        -- Check if the enemy is not the local player, is not on the same team, is not in the ignore list,
        -- not below the map (Y-coordinate < 0), and is alive
        local char = plr.Character
        local root = char and char:FindFirstChild("HumanoidRootPart")
        if plr ~= LocalPlayer and plr.Team ~= LocalPlayer.Team and not table.find(ignoredUsernames, plr.Name) and root and root.Position.Y >= 0 then
            local head = char and char:FindFirstChild("Head")
            local humanoid = char and char:FindFirstChildOfClass("Humanoid")
            if head and humanoid and humanoid.Health > 0 then
                local dist = (head.Position - myRoot.Position).Magnitude
                if dist < shortestDist then
                    shortestDist = dist
                    closest = head
                end
            end
        end
    end
    
    return closest
end

SecondTab:CreateToggle({
    Name = "Aimbot",
    Info = "Automatically locks onto the nearest enemy.",
    CurrentValue = false,
    Flag = "AimbotToggle",
    Callback = function(Value)
        AimbotEnabled = Value
        if AimbotConn then AimbotConn:Disconnect() AimbotConn = nil end

        if Value then
            AimbotConn = RunService.RenderStepped:Connect(function()
                if AimbotEnabled then
                    local target = GetClosestEnemy()
                    if target then
                        -- Aim directly at the target
                        local camera = workspace.CurrentCamera
                        local targetPosition = target.Position
                        camera.CFrame = CFrame.new(camera.CFrame.Position, targetPosition)

                        -- Automatically shoot at the target
                        ShootAtTarget(target) -- Call to shoot directly at the target
                    end
                end
            end)
        end
    end,
})

-- Function to handle shooting logic to hit the target
local function ShootAtTarget(target)
    -- Create a bullet part
    local bullet = Instance.new("Part")
    bullet.Size = Vector3.new(0.1, 0.1, 1) -- Size of the bullet
    bullet.Position = LocalPlayer.Character.HumanoidRootPart.Position + Vector3.new(0, 1, 0) -- Start just above the character
    bullet.Anchored = false
    bullet.CanCollide = false
    bullet.Material = Enum.Material.Neon
    bullet.BrickColor = BrickColor.new("Bright red")
    bullet.Parent = workspace

    -- Calculate the direction to the nearest target
    local direction = (target.Position - bullet.Position).unit
    bullet.Velocity = direction * 100 -- Set bullet speed (adjust as needed)

    -- Optionally, add a lifetime for the bullet
    game.Debris:AddItem(bullet, 5) -- Remove bullet after 5 seconds

    print("Shooting at target: " .. target.Name)
    -- Add additional logic for dealing damage or effects here.
end

SecondTab:CreateSlider({
    Name = "Aimbot Max Distance",
    Info = "Maximum studs the aimbot will reach",
    Range = {50, 2000},
    Increment = 50,
    Suffix = " studs",
    CurrentValue = 1000,
    Flag = "AimbotDistance",
    Callback = function(Value)
        AimbotMaxDistance = Value
    end,
})

SecondTab:CreateSlider({
    Name = "Aimbot FOV",
    Info = "Field of View for Aimbot (degrees)",
    Range = {10, 120}, -- Minimum and maximum FOV
    Increment = 5,
    Suffix = " degrees",
    CurrentValue = AimbotFOV,
    Flag = "AimbotFOVSlider",
    Callback = function(Value)
        AimbotFOV = Value
    end,
})

-- Add Ignore Usernames UI Element
SecondTab:CreateInput({
    Name = "Ignore Username",
    PlaceholderText = "Enter the username to ignore",
    RemoveTextAfterFocusLost = true,
    Callback = function(username)
        if username and username ~= "" then
            table.insert(ignoredUsernames, username)
            print(username .. " has been added to ignore list.")
        end
    end,
})

-- Remove from Ignore Usernames
SecondTab:CreateInput({
    Name = "Remove Ignore Username",
    PlaceholderText = "Enter username to remove",
    RemoveTextAfterFocusLost = true,
    Callback = function(username)
        for i = #ignoredUsernames, 1, -1 do
            if ignoredUsernames[i] == username then
                table.remove(ignoredUsernames, i)
                print(username .. " has been removed from ignore list.")
                break
            end
        end
    end,
})

-- END OF AIMBOT

local ThirdTab = Window:CreateTab("Graphics", nil)

local Divider = ThirdTab:CreateDivider()
local Paragraph = ThirdTab:CreateParagraph({Title = "FOR THE BEST NIGHT MODE RESULTS PLEASE", Content = ""})
local Paragraph = ThirdTab:CreateParagraph({Title = "Turn on NIGHT MODE AND THEN FULLBRIGHT", Content = ""})


ThirdTab:CreateToggle({
    Name = "Fullbright",
    CurrentValue = false,
    Flag = "FullbrightToggle",
    Callback = function(Value)
        if Value then
            game:GetService("Lighting").Brightness = 2
            game:GetService("Lighting").ClockTime = 14
            game:GetService("Lighting").FogEnd = 100000
            game:GetService("Lighting").GlobalShadows = false
            game:GetService("Lighting").OutdoorAmbient = Color3.fromRGB(128, 128, 128)
        else
            game:GetService("Lighting").Brightness = 1
            game:GetService("Lighting").ClockTime = 8
            game:GetService("Lighting").FogEnd = 100000
            game:GetService("Lighting").GlobalShadows = true
            game:GetService("Lighting").OutdoorAmbient = Color3.fromRGB(70, 70, 70)
        end
    end,
})



-- Toggle State Variables to restore original settings
local originalMaterials = {}
local originalShadows = game.Lighting.GlobalShadows

-- Low Graphics Toggle
local Toggle = ThirdTab:CreateToggle({
   Name = "Lowest Graphics Mode",
   CurrentValue = false,
   Flag = "LowGraphicsToggle", 
   Callback = function(Value)
      if Value then
         -- TURN ON LOW GRAPHICS
         
         -- 1. Optimize Lighting and Shadows
         game.Lighting.GlobalShadows = false
         game.Lighting.FogEnd = 9e9
         
         -- 2. Force smooth plastic material on workspace parts to boost FPS
         for _, desc in pairs(workspace:GetDescendants()) do
            if desc:IsA("BasePart") and desc.ClassName ~= "Terrain" then
               originalMaterials[desc] = desc.Material
               desc.Material = Enum.Material.SmoothPlastic
            end
         end
         
         -- 3. Turn off demanding post-processing effects
         for _, fx in pairs(game.Lighting:GetChildren()) do
            if fx:IsA("PostEffect") or fx:IsA("BloomEffect") or fx:IsA("BlurEffect") or fx:IsA("SunRaysEffect") or fx:IsA("DepthOfFieldEffect") then
               fx.Enabled = false
            end
         end
         
      else
         -- TURN OFF LOW GRAPHICS (Restore Original Settings)
         
         -- 1. Restore Shadows
         game.Lighting.GlobalShadows = originalShadows
         
         -- 2. Restore Original Materials
         for part, material in pairs(originalMaterials) do
            if part and part.Parent then
               part.Material = material
            end
         end
         table.clear(originalMaterials)
         
         -- 3. Restore Post-Processing Effects
         for _, fx in pairs(game.Lighting:GetChildren()) do
            if fx:IsA("PostEffect") or fx:IsA("BloomEffect") or fx:IsA("BlurEffect") or fx:IsA("SunRaysEffect") or fx:IsA("DepthOfFieldEffect") then
               fx.Enabled = true
            end
         end
         
      end
   end,
})

local NightToggle = ThirdTab:CreateToggle({
   Name = "Night Mode turn on fullbright after night mode",
   CurrentValue = false,
   Flag = "ForceNightTime",
   Callback = function(Value)
      -- Disconnect any previous loop to prevent stacking
      if _G.NightLoop then 
         _G.NightLoop:Disconnect() 
         _G.NightLoop = nil
      end
      
      if Value then
         -- Set initial midnight settings
         game.Lighting.ClockTime = 0
         game.Lighting.Ambient = Color3.fromRGB(30, 30, 40)       -- Soft dark blue tint
         game.Lighting.OutdoorAmbient = Color3.fromRGB(15, 15, 20) -- Darker shadows
         
         -- Loop to constantly freeze time if the server tries to change it
         _G.NightLoop = game:GetService("RunService").Heartbeat:Connect(function()
            game.Lighting.ClockTime = 0
         end)
      else
         -- Restore standard daytime defaults
         game.Lighting.ClockTime = 14 -- 2:00 PM standard time
         game.Lighting.Ambient = Color3.fromRGB(128, 128, 128)
         game.Lighting.OutdoorAmbient = Color3.fromRGB(128, 128, 128)
      end
   end,
})



-- Color Vibrance Toggle
ThirdTab:CreateToggle({
   Name = "Color Vibrance",
   CurrentValue = false,
   Flag = "VibranceMode",
   Callback = function(Value)
      -- Find or create a dedicated ColorCorrection instance for vibrance
      local vibranceCorrection = game.Lighting:FindFirstChild("VibranceColorCorrection") or Instance.new("ColorCorrectionEffect")
      
      if Value then
         vibranceCorrection.Name = "VibranceColorCorrection"
         vibranceCorrection.Saturation = 0.45   -- Strongly enhances and pops all world colors
         vibranceCorrection.Contrast = 0.15     -- Slightly deepens the image to keep colors crisp
         vibranceCorrection.Brightness = 0.02   -- Minor tint adjustment to keep whites clean
         vibranceCorrection.Parent = game.Lighting
      else
         -- Safely clean up and restore game default visuals
         if game.Lighting:FindFirstChild("VibranceColorCorrection") then
            game.Lighting.VibranceColorCorrection:Destroy()
         end
      end
   end,
})

-- Realistic Graphics Engine Toggle
ThirdTab:CreateToggle({
   Name = "Realistic Mode",
   CurrentValue = false,
   Flag = "RealisticMode",
   Callback = function(Value)
      -- Find or create instances for high-end cinematic layering
      local colorCorrection = game.Lighting:FindFirstChild("RealColor") or Instance.new("ColorCorrectionEffect")
      local bloom = game.Lighting:FindFirstChild("RealBloom") or Instance.new("BloomEffect")
      local sunRays = game.Lighting:FindFirstChild("RealSunRays") or Instance.new("SunRaysEffect")
      local atmosphere = game.Lighting:FindFirstChild("RealAtmosphere") or Instance.new("Atmosphere")
      
      if Value then
         -- 1. Force Advanced Global Illumination & Dynamic Shadows
         game.Lighting.Technology = Enum.Technology.Future
         game.Lighting.GlobalShadows = true
         game.Lighting.Brightness = 2.5
         game.Lighting.EnvironmentSpecularScale = 1
         game.Lighting.EnvironmentDiffuseScale = 1
         
         -- 2. Color Tone Mapping (Replicates realistic camera sensor values)
         colorCorrection.Name = "RealColor"
         colorCorrection.Brightness = -0.02   -- Softly curbs overexposed sunlight
         colorCorrection.Contrast = 0.18      -- Deepens shadows without losing part textures
         colorCorrection.Saturation = 0.08    -- Subtle color pop without looking cartoonish
         colorCorrection.TintColor = Color3.fromRGB(255, 250, 245) -- Warm sunlight balance
         colorCorrection.Parent = game.Lighting
         
         -- 3. Realistic Light Bleed & Atmosphere
         bloom.Name = "RealBloom"
         bloom.Intensity = 0.35               -- Soft, natural glare
         bloom.Size = 24                      -- Smooth blend radius
         bloom.Threshold = 0.9                -- Only glows true light sources (sun, neon)
         bloom.Parent = game.Lighting
         
         -- 4. Dynamic Volumetric Sun Rays
         sunRays.Name = "RealSunRays"
         sunRays.Intensity = 0.25             -- Real god-rays shining past corners
         sunRays.Spread = 0.7                 -- Wide cinematic dispersion
         sunRays.Parent = game.Lighting

         -- 5. Horizon Air Density (Blends the sky naturally with the world)
         atmosphere.Name = "RealAtmosphere"
         atmosphere.Density = 0.3             -- Realistic atmospheric air thickness
         atmosphere.Offset = 0.25             -- Horizon glare placement
         atmosphere.Glare = 1                 -- Sun ring scatter effect
         atmosphere.Haze = 0.5                -- Soft mountain distance mist
         atmosphere.Parent = game.Lighting
      else
         -- Revert to traditional safe engine defaults
         game.Lighting.Technology = Enum.Technology.ShadowMap
         game.Lighting.Brightness = 1
         game.Lighting.EnvironmentSpecularScale = 0
         game.Lighting.EnvironmentDiffuseScale = 0
         
         if game.Lighting:FindFirstChild("RealColor") then game.Lighting.RealColor:Destroy() end
         if game.Lighting:FindFirstChild("RealBloom") then game.Lighting.RealBloom:Destroy() end
         if game.Lighting:FindFirstChild("RealSunRays") then game.Lighting.RealSunRays:Destroy() end
         if game.Lighting:FindFirstChild("RealAtmosphere") then game.Lighting.RealAtmosphere:Destroy() end
      end
   end,
})