local KeyGuardLibrary = loadstring(game:HttpGet("https://cdn.keyguardian.org/library/v1.0.0.lua"))()
local trueData = "04e57479ed6c46c28f7646cd037f27fe"
local falseData = "5050926da3c0437499002edcfb7b2849"

KeyGuardLibrary.Set({
	publicToken = "e92e2e0aa4f3484fac25ecad35fbbbb1",
	privateToken = "652dc0fbfc434d0f9809d01f7b9fed9a",
	trueData = trueData,
	falseData = falseData,
})

local Fluent = loadstring(game:HttpGet("https://github.com/dawid-scripts/Fluent/releases/latest/download/main.lua"))()
local key = script_key

local Window = Fluent:CreateWindow({
		Title = "Sushi Hub",
		SubTitle = "Sushi HUB",
		TabWidth = 160,
		Size = UDim2.fromOffset(200, 200),
		Acrylic = false,
		Theme = "Darker",
		MinimizeKey = Enum.KeyCode.LeftControl
})

local Tabs = {
		KeySys = Window:AddTab({ Title = "Key System", Icon = "key" }),
}

local Entkey = Tabs.KeySys:AddInput("Input", {
		Title = "Enter Key",
		Description = "Enter Key Here",
		Default = "",
		Placeholder = "Enter key…",
		Numeric = false,
		Finished = false,
		Callback = function(Value)
				key = Value
		end
})

local Checkkey = Tabs.KeySys:AddButton({
		Title = "Check Key",
		Description = "Enter Key before pressing this button",
		Callback = function()
				local response = KeyGuardLibrary.validateDefaultKey(key)
				if response == trueData then
						print("Key is valid")
						local Library = loadstring(game:HttpGet("https://raw.githubusercontent.com/bloodball/-back-ups-for-libs/main/cat"))() -- you can go into the github link and copy all of it and modify it for yourself.
local Window = Library:CreateWindow("Volleyball 4.2 by sushijimas", Vector2.new(492, 598), Enum.KeyCode.RightControl) -- you can change your UI keybind

local AimingTab = Window:CreateTab("Player") -- you can rename this tab to whatever you want
local ConfigTab = Window:CreateTab("Config")

-- First Section for movement
local OtherSection = AimingTab:CreateSector("Others", "right")

OtherSection:AddButton("Ball Trajectory", function(IhateGayPeople)
    repeat wait() until workspace:FindFirstChild("Ball")

    local UserInputService = game:GetService("UserInputService")
    local RunService = game:GetService("RunService")

    local markers = {}

    local function PHYSICS_STUFF(velocity, position)
        local acceleration = -workspace.Gravity
        local timeToLand = (-velocity.y - math.sqrt(velocity.y * velocity.y - 4 * 0.5 * acceleration * position.y)) / (2 * 0.5 * acceleration)
        local horizontalVelocity = Vector3.new(velocity.x, 0, velocity.z)
        local landingPosition = position + horizontalVelocity * timeToLand + Vector3.new(0, -position.y, 0)
        return landingPosition
    end

    local function createMarker()
        local marker = Instance.new("Part")
        marker.Name = "Marker"
        marker.Size = Vector3.new(3, 3, 3)
        marker.Shape = Enum.PartType.Ball
        marker.BrickColor = BrickColor.new("Bright red")
        marker.CanCollide = false
        marker.Anchored = true
        marker.Parent = workspace
        marker.Transparency = 0.5
        marker.Material = Enum.Material.Neon
        return marker
    end

    -- Criar os marcadores para a trajetória
    RunService:BindToRenderStep("VisualizeLandingPosition", Enum.RenderPriority.Camera.Value, function()
        -- Limpar os marcadores existentes
        for _, marker in ipairs(markers) do
            marker:Destroy()
        end
        markers = {}

        -- Adicionar marcadores para cada bola
        for _, ballModel in ipairs(workspace:GetChildren()) do
            if ballModel:IsA("Model") and ballModel.Name == "Ball" then
                local ball = ballModel:FindFirstChild("BallPart")
                if ball then
                    local marker = createMarker()
                    local initialVelocity = ballModel.Velocity
                    local landingPosition = PHYSICS_STUFF(initialVelocity.Value, ball.Position)
                    marker.CFrame = CFrame.new(landingPosition)
                    table.insert(markers, marker)
                end
            end
        end
    end)
end)


OtherSection:AddTextbox("Jump Power", nil, function(State)
    local player = game.Players.LocalPlayer
    -- Tenta converter o valor inserido para um número
    local jumpPower = tonumber(State)  -- Aqui usamos o parâmetro 'State', que é o valor da caixa de texto
    if jumpPower then
        -- Define a altura do salto
        game.Workspace[player.Name].Humanoid.JumpHeight = jumpPower
        game.Workspace[player.Name].Humanoid.UseJumpPower = false
        print("Jump power set to:", jumpPower) -- Exibe o novo valor no console
    else
        print("Invalid input. Please enter a number.") -- Mensagem de erro se o input não for um número
    end
end)



OtherSection:AddToggle("Jump Aimbot", false, function(first)
    if first then
        local Players = game:GetService("Players")
        local uis = game:GetService('UserInputService')

        local function makeCharacterLookAtCamera()
            local player = Players.LocalPlayer
            local character = player.Character
            if character then
                local humanoidRootPart = character:WaitForChild("HumanoidRootPart")
                if humanoidRootPart then
                    local Camera = workspace.CurrentCamera
                    local cameraLookDirection = Camera.CFrame.LookVector
                    humanoidRootPart.CFrame = CFrame.new(humanoidRootPart.Position,
                        humanoidRootPart.Position + Vector3.new(cameraLookDirection.X, 0, cameraLookDirection.Z))
                end
            end
        end

        uis.JumpRequest:Connect(function()
            makeCharacterLookAtCamera()
        end)
    else
        -- Lógica para desativar o comportamento, caso necessário
    end
end)

OtherSection:AddToggle("Spike ESP", false, function(first)
    if first then
        -- Ativado, executa as ações de rastrear e desenhar linhas

        local Players = game:GetService("Players")
        local RunService = game:GetService("RunService")

        local localPlayer = Players.LocalPlayer -- Automatically get the local player's object

        -- Tabela para armazenar as linhas de cada jogador
        local playerLines = {}

        -- Função para criar ou atualizar a linha
        local function updateLine(player)
            -- Exclui você (o desenvolvedor) da lógica
            if player == localPlayer then
                return
            end

            local character = player.Character
            if character and character:FindFirstChild("HumanoidRootPart") then
                local rootPart = character.HumanoidRootPart
                local humanoid = character:FindFirstChild("Humanoid")

                -- Verifica se o jogador está no ar (pulo ou queda)
                if humanoid and (humanoid:GetState() == Enum.HumanoidStateType.Jumping or humanoid:GetState() == Enum.HumanoidStateType.Freefall) then
                    local direction = rootPart.CFrame.LookVector
                    local startPosition = rootPart.Position
                    local endPosition = startPosition + (direction * 15) -- Aumenta o comprimento para 15 metros

                    -- Verifica se a linha já existe, se não, cria uma nova
                    if not playerLines[player.UserId] then
                        local line = Instance.new("Part")
                        line.Size = Vector3.new(0.5, 0.5, 15) -- Aumenta a largura e a espessura
                        line.Anchored = true
                        line.CanCollide = false
                        line.Color = Color3.new(1, 1, 1) -- Cor branca
                        line.Material = Enum.Material.SmoothPlastic -- Material menos brilhante
                        line.Parent = workspace

                        -- Armazena a linha na tabela
                        playerLines[player.UserId] = line
                    end

                    -- Atualiza a posição e orientação da linha
                    local line = playerLines[player.UserId]
                    line.CFrame = CFrame.new((startPosition + endPosition) / 2, endPosition)
                else
                    -- Se o jogador não está no ar, destrói a linha se existir
                    local line = playerLines[player.UserId]
                    if line then
                        line:Destroy()
                        playerLines[player.UserId] = nil
                    end
                end
            end
        end

        -- Função para verificar se o humanoide está presente e conectar ao evento de pulo
        local function onPlayerAdded(player)
            player.CharacterAdded:Connect(function(character)
                local humanoid = character:WaitForChild("Humanoid")
                humanoid.Jumping:Connect(function()
                    updateLine(player) -- Ativa a linha quando o jogador pula
                end)
            end)
        end

        -- Conectar a todos os jogadores já presentes
        for _, player in ipairs(Players:GetPlayers()) do
            onPlayerAdded(player)
        end

        -- Conectar a função ao evento de renderização
        RunService.RenderStepped:Connect(function()
            for _, player in ipairs(Players:GetPlayers()) do
                updateLine(player)
            end
        end)

        -- Conectar ao evento de adição de novos jogadores
        Players.PlayerAdded:Connect(onPlayerAdded)

        print("Spike ESP ativado")
    else
        -- Desativado, destrói as linhas e limpa a tabela
        for _, line in pairs(playerLines) do
            line:Destroy()
        end
        playerLines = {} -- Limpa a tabela de linhas
        print("Spike ESP desativado")
    end
end)







---------------------------------------------------------------------------------------
-----------------------------MiscSection-----------------------------------------------
---------------------------------------------------------------------------------------

-- Misc Section for additional functionalities
local MiscSection = AimingTab:CreateSector("Misc", "left")

MiscSection:AddButton("Infinite Stamina", function()
    local function searchAndModifyFunctionsWithConstant()
        local gc = getgc(true)  -- Get all garbage-collected objects
        local targetConstant = 0.6  -- Constant we want to search for
        local foundFunctions = {}

        -- Iterate through all items in the garbage collector
        for _, item in pairs(gc) do
            if type(item) == "function" and not is_synapse_function(item) then
                local success, constants = pcall(debug.getconstants, item)

                -- If constants were successfully retrieved, search for the target value
                if success then
                    for _, constant in pairs(constants) do
                        if constant == targetConstant then
                            table.insert(foundFunctions, item)

                            -- Modify the 8th constant if it exists
                            if constants[8] then
                                pcall(function() debug.setconstant(item, 8, math.huge) end)  -- Adjust the 8th constant to a very large value
                            end

                            -- Modify the 10th constant if it exists
                            if constants[10] then
                                pcall(function() debug.setconstant(item, 10, math.huge) end)  -- Adjust the 10th constant to a very large value
                            end

                            break  -- No need to continue checking this function
                        end
                    end
                end
            end
        end
    end

    -- Execute the search and modification
    searchAndModifyFunctionsWithConstant()
    print("Infinite Stamina Enabled")  -- Message when infinite stamina is enabled
end)

MiscSection:AddSlider("Fov Changer", 0, 70, 120, 1, function(State)
    -- Altera o campo de visão (FOV) da câmera
    workspace.CurrentCamera.FieldOfView = State
end)

MiscSection:AddSlider("Spike Strenght", 1, 1, 4, 1, function(value)
    local tiltValues = {4000, 5500, 7000, 9000}
    game.Players.LocalPlayer.Character.HumanoidRootPart.Tilt.P = tiltValues[value]
end)


MiscSection:AddButton("Ball Hitbox", function()
    local ballSize = 3  -- Define o tamanho fixo para a bola
    local connection  -- Variável para armazenar a conexão do evento

    local function resizeExistingBalls()
        for _, ballModel in ipairs(workspace:GetChildren()) do
            if ballModel:IsA("Model") and ballModel.Name == "Ball" then
                local ballPart = ballModel:FindFirstChild("BallPart")
                if ballPart then
                    ballPart.Size = Vector3.new(ballSize, ballSize, ballSize)
                end
            end
        end
    end

    -- Redimensiona as bolas já existentes
    resizeExistingBalls()

    -- Se já houver uma conexão ativa, evita criar outra
    if connection then connection:Disconnect() end

    -- Conecta ao evento para modificar novas bolas automaticamente
    connection = workspace.ChildAdded:Connect(function(child)
        if child:IsA("Model") and child.Name == "Ball" then
            local ballPart = child:WaitForChild("BallPart")
            ballPart.Size = Vector3.new(ballSize, ballSize, ballSize)
        end
    end)
end)

local RotationEnabled = false
local RotationConnection

MiscSection:AddToggle("Rotate Camera", false, function(State)
    RotationEnabled = State

    if RotationEnabled then
        -- Inicia o loop de rotação da câmera
        local player = game.Players.LocalPlayer
        RotationConnection = game:GetService("RunService").RenderStepped:Connect(function()
            if player.Character and player.Character:FindFirstChild("Humanoid") then
                player.Character.Humanoid.AutoRotate = true
            end
        end)
    else
        -- Desativa a rotação e desconecta o loop
        if RotationConnection then
            RotationConnection:Disconnect()
            RotationConnection = nil
        end
    end
end)






local AiSection = AimingTab:CreateSector("Ai", "right")

local Xxxx = AiSection:AddToggle("Auto Dive", false, function(Value)
    local player = game.Players.LocalPlayer
    local RunService = game:GetService("RunService")
    local VirtualInputManager = game:GetService("VirtualInputManager")
    local UserInputService = game:GetService("UserInputService")

    local function calculateLandingPosition(velocity, position)
        local gravity = workspace.Gravity
        local timeToLand = (-velocity.Y + math.sqrt(velocity.Y^2 + 2 * gravity * position.Y)) / gravity
        local horizontalVelocity = Vector3.new(velocity.X, 0, velocity.Z)
        local landingPosition = position + horizontalVelocity * timeToLand + Vector3.new(0, -position.Y, 0)
        return landingPosition, timeToLand
    end

    if Value then
        RunService:BindToRenderStep("CheckNearestBall", Enum.RenderPriority.Camera.Value, function()
            local character = player.Character
            if character and character:FindFirstChild("HumanoidRootPart") then
                local humanoidRootPart = character.HumanoidRootPart
                local humanoid = character:FindFirstChild("Humanoid")
                local maxDetectionRange = 7
                local nearestBall = nil
                local nearestDistance = math.huge
                local landingPosition, timeToLand

                for _, ballModel in ipairs(workspace:GetChildren()) do
                    if ballModel:IsA("Model") and ballModel.Name == "Ball" then
                        local ballPart = ballModel:FindFirstChild("BallPart")
                        if ballPart then
                            local distance = (ballPart.Position - humanoidRootPart.Position).magnitude
                            if distance <= maxDetectionRange then
                                landingPosition, timeToLand = calculateLandingPosition(ballPart.Velocity, ballPart.Position)

                                if distance < nearestDistance then
                                    nearestDistance = distance
                                    nearestBall = ballPart
                                end
                            end
                        end
                    end
                end

                if nearestBall and landingPosition then
                    if landingPosition.Y <= 0 and timeToLand > 0 then
                        if humanoid:GetState() ~= Enum.HumanoidStateType.Physics and humanoid:GetState() ~= Enum.HumanoidStateType.Seated then
                            humanoidRootPart.CFrame = CFrame.lookAt(
                                humanoidRootPart.Position,
                                Vector3.new(landingPosition.X, humanoidRootPart.Position.Y, landingPosition.Z)
                            )
                        end

                        local pressTime = timeToLand - 0.3
                        if tick() >= pressTime then
                            VirtualInputManager:SendKeyEvent(true, "Three", false, game)
                            VirtualInputManager:SendKeyEvent(false, "Three", false, game)
                        end
                    end
                end
            end
        end)
    else
        RunService:UnbindFromRenderStep("CheckNearestBall")
    end
end)

Xxxx:AddKeybind()


local ToggleReceive = AiSection:AddToggle("Auto Receive", false, function(Value)
    local player = game.Players.LocalPlayer
    local RunService = game:GetService("RunService")

    if Value then
        RunService:BindToRenderStep("CheckNearestBallReceive", Enum.RenderPriority.Camera.Value, function()
            local character = player.Character or player.CharacterAdded:Wait()
            local humanoid = character:FindFirstChild("Humanoid")
            local maxDetectionRange = 7
            local nearestBall = nil
            local nearestDistance = math.huge

            for _, ballModel in ipairs(workspace:GetChildren()) do
                if ballModel:IsA("Model") and ballModel.Name == "Ball" then
                    local ballPart = ballModel:FindFirstChild("BallPart")
                    if ballPart then
                        local distance = (ballPart.Position - character.HumanoidRootPart.Position).magnitude
                        if distance <= maxDetectionRange and distance < nearestDistance then
                            nearestDistance = distance
                            nearestBall = ballPart
                        end
                    end
                end
            end

            if nearestBall then
                local args = {"Receiving"}
                game:GetService("ReplicatedStorage"):WaitForChild("Remotes"):WaitForChild("PlayerAction"):FireServer(unpack(args))

                local animation = game:GetService("ReplicatedStorage").Assets.Animations.Receive.Default
                local animationTrack = humanoid:LoadAnimation(animation)
                animationTrack:Play()
            end
        end)
    else
        RunService:UnbindFromRenderStep("CheckNearestBallReceive")
    end
end)

ToggleReceive:AddKeybind()

local AiAttack = AiSection:AddToggle("Auto Attack", false, function(Value)
    local player = game.Players.LocalPlayer
    local RunService = game:GetService("RunService")
    local VirtualInputManager = game:GetService("VirtualInputManager")

    if Value then
        RunService:BindToRenderStep("CheckNearestBall", Enum.RenderPriority.Camera.Value, function()
            local character = player.Character or player.CharacterAdded:Wait()
            local humanoid = character:FindFirstChild("Humanoid")
            local maxDetectionRange = 7
            local nearestBall = nil
            local nearestDistance = math.huge

            for _, ballModel in ipairs(workspace:GetChildren()) do
                if ballModel:IsA("Model") and ballModel.Name == "Ball" then
                    local ballPart = ballModel:FindFirstChild("BallPart")
                    if ballPart then
                        local distance = (ballPart.Position - character.HumanoidRootPart.Position).magnitude
                        if distance <= maxDetectionRange and distance < nearestDistance then
                            nearestDistance = distance
                            nearestBall = ballPart
                        end
                    end
                end
            end

            if nearestBall then
                -- Simula um clique do botão esquerdo do mouse
                VirtualInputManager:SendMouseButtonEvent(0, 0, 0, true, game, 0)
                VirtualInputManager:SendMouseButtonEvent(0, 0, 0, false, game, 0)
            end
        end)
    else
        RunService:UnbindFromRenderStep("CheckNearestBall")
    end
end)


AiAttack:AddKeybind()


local CourtSection = AimingTab:CreateSector("Court", "left")

CourtSection:AddButton("Lockcourt Delete", function(IhateGayPeople)
    game.Workspace.LockCourt:Destroy()
end)

CourtSection:AddButton("Ceiling Delete", function(IhateGayPeople)
    game.Workspace.Ceiling:Destroy()
end)

CourtSection:AddButton("No Line Fault", function(IhateGayPeople)
    game.Workspace.ServeLF.Size = Vector3.new(0.001, 1, 0.001)
end)

CourtSection:AddButton("No Backrow Line Fault", function(IhateGayPeople)
    game.Workspace.BackrowLF.Size = Vector3.new(0.001, 1, 0.001)

end)

local RedSection = AimingTab:CreateSector("Red Team", "right")

RedSection:AddButton("Join Random Frontrow", function(IhateGayPeople)
    local teamName = "RedPlayers"
    local remote = game:GetService("ReplicatedStorage"):WaitForChild("Remotes"):WaitForChild("Pickups")

    for position = 2, 4 do
        local args = {
            [1] = "JoinTeam",
            [2] = {
                ["teamName"] = teamName,
                ["position"] = position
            }
        }
        remote:FireServer(unpack(args))
    end
end)

RedSection:AddButton("Join Random Backrow", function(IhateGayPeople)
    local teamName = "RedPlayers"
    local remote = game:GetService("ReplicatedStorage"):WaitForChild("Remotes"):WaitForChild("Pickups")

    local positions = {1, 5, 6}

    for _, position in ipairs(positions) do
        local args = {
            [1] = "JoinTeam",
            [2] = {
                ["teamName"] = teamName,
                ["position"] = position
            }
        }
        remote:FireServer(unpack(args))
    end
end)

local BlueSection = AimingTab:CreateSector("Blue Team", "left")

BlueSection:AddButton("Join Random Frontrow", function(IhateGayPeople)
    local teamName = "BluePlayers"
    local remote = game:GetService("ReplicatedStorage"):WaitForChild("Remotes"):WaitForChild("Pickups")

    for position = 2, 4 do
        local args = {
            [1] = "JoinTeam",
            [2] = {
                ["teamName"] = teamName,
                ["position"] = position
            }
        }
        remote:FireServer(unpack(args))
    end

end)

BlueSection:AddButton("Join Random Backrow", function(IhateGayPeople)
    local teamName = "BluePlayers"
    local remote = game:GetService("ReplicatedStorage"):WaitForChild("Remotes"):WaitForChild("Pickups")

    local positions = {1, 5, 6}

    for _, position in ipairs(positions) do
        local args = {
            [1] = "JoinTeam",
            [2] = {
                ["teamName"] = teamName,
                ["position"] = position
            }
        }
        remote:FireServer(unpack(args))
    end
end)
-- Config System for saving settings
ConfigTab:CreateConfigSystem("left") --this is the config system

				else
						print("Key is invalid")
				end
		end
})



Window:SelectTab(1)