V1rpPizza script but i change the library from WindUI into Orion Library (NOT MY SCRIPT)

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local workspace = game:GetService("Workspace")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Client references
local LocalPlayer = Players.LocalPlayer
local PlayerGui = LocalPlayer:WaitForChild("PlayerGui", 10)

-- Load Orion Library
local OrionLib = loadstring(game:HttpGet(('https://raw.githubusercontent.com/jensonhirst/Orion/main/source')))()

-- Create main window
local Window = OrionLib:MakeWindow({
    Name         = "V1rpPizza",
    HidePremium  = false,
    SaveConfig   = true,
    ConfigFolder = "ElliotScript",
    IntroEnabled = true,
    IntroText    = "Elliot Script",
})

-- Create tab
local ElliotTab = Window:MakeTab({
    Name        = "Elliot",
    Icon        = "rbxassetid://4483345998",
    PremiumOnly = false,
})

ElliotTab:AddLabel("Elliot Aimbot")

-- ════════════════════════════════════════
--   VARIABLES
-- ════════════════════════════════════════

local AnimationId = "114155003741146"
local AimbotEnabled = false
local RenderConnection = nil
local AutoRotateBackup = nil
local PredictionDistance = 5
local VelocityThreshold = 16
local AimbotType = "Camera + Character"
local Humanoid, HumanoidRootPart = nil, nil
local Camera = workspace.CurrentCamera
local RequireAnimation = true

local IsThrowing = false
local ThrowTimestamp = 0
local ThrowDuration = 0.5

local ShowArc = false
local ArcFolder = nil
local ArcParts = {}
local ArcSegments = 50
local PizzaSpeed = 80
local PizzaGravity = 196.2
local ArcUpdateRate = 0.05
local PizzaThrowForce = 80
local PizzaUpwardComponent = 0.5

local LastPosition = nil
local LastRotation = nil
local LastUpdateTime = 0
local CurrentVelocity = Vector3.new(0, 0, 0)
local CurrentTurnRate = 0

-- ════════════════════════════════════════
--   CHARACTER SETUP
-- ════════════════════════════════════════

local function SetupCharacter(character)
    Humanoid = character:WaitForChild("Humanoid")
    HumanoidRootPart = character:WaitForChild("HumanoidRootPart")
    LastPosition = HumanoidRootPart.Position
    LastRotation = HumanoidRootPart.CFrame.LookVector
    LastUpdateTime = tick()
end

if LocalPlayer.Character then SetupCharacter(LocalPlayer.Character) end
LocalPlayer.CharacterAdded:Connect(function(char) SetupCharacter(char) end)

-- ════════════════════════════════════════
--   REMOTE HOOK (Pizza throw detection)
-- ════════════════════════════════════════

task.spawn(function()
    local success, remoteEvent = pcall(function()
        return ReplicatedStorage:WaitForChild("Modules", 5)
            :WaitForChild("Network", 5)
            :WaitForChild("RemoteEvent", 5)
    end)

    if success and remoteEvent then
        local oldNamecall
        oldNamecall = hookmetamethod(game, "__namecall", function(self, ...)
            local method = getnamecallmethod()
            local args = {...}
            if method == "FireServer" and self == remoteEvent then
                if args[1] == "UseActorAbility" and args[2] and args[2][1] then
                    local bufferData = args[2][1]
                    local ok, bufferString = pcall(function()
                        return buffer.tostring(bufferData)
                    end)
                    if ok and bufferString and string.find(bufferString, "ThrowPizza") then
                        IsThrowing = true
                        ThrowTimestamp = tick()
                    end
                end
            end
            return oldNamecall(self, ...)
        end)
    end
end)

-- ════════════════════════════════════════
--   ARC VISUALIZATION
-- ════════════════════════════════════════

local function CreateArcFolder()
    if ArcFolder then ArcFolder:Destroy() end
    ArcFolder = Instance.new("Folder")
    ArcFolder.Name = "PizzaArcVisualizer"
    ArcFolder.Parent = workspace
end

local function ClearArc()
    for _, part in ipairs(ArcParts) do
        if part and part.Parent then part:Destroy() end
    end
    ArcParts = {}
end

local function CreateArcSegment(position, index)
    local part = Instance.new("Part")
    part.Name = "ArcSegment_" .. index
    part.Size = Vector3.new(0.25, 0.25, 0.25)
    part.Position = position
    part.Anchored = true
    part.CanCollide = false
    part.Material = Enum.Material.Neon
    part.Shape = Enum.PartType.Ball
    part.Color = Color3.fromRGB(255, 0, 0)
    part.Transparency = 0.15
    part.Parent = ArcFolder
    return part
end

local function CalculatePlayerMovement()
    if not HumanoidRootPart then return end
    local currentTime = tick()
    local deltaTime = currentTime - LastUpdateTime
    if deltaTime > 0 then
        local currentPos = HumanoidRootPart.Position
        local displacement = currentPos - LastPosition
        CurrentVelocity = displacement / deltaTime
        local currentLookVector = HumanoidRootPart.CFrame.LookVector
        local dotProduct = math.clamp(LastRotation:Dot(currentLookVector), -1, 1)
        local angleChange = math.acos(dotProduct)
        CurrentTurnRate = angleChange / deltaTime
        LastPosition = currentPos
        LastRotation = currentLookVector
        LastUpdateTime = currentTime
    end
end

local function CalculateTrajectoryArc(startPos, targetPos, lookVector)
    local throwDirection = (lookVector + Vector3.new(0, PizzaUpwardComponent, 0)).Unit
    local initialVelocity = throwDirection * PizzaThrowForce
    local maxTime = 3
    local points = {}
    local timeStep = maxTime / ArcSegments
    local lastPos = startPos
    local rayParams = RaycastParams.new()
    rayParams.FilterType = Enum.RaycastFilterType.Exclude
    rayParams.FilterDescendantsInstances = {LocalPlayer.Character, ArcFolder}
    rayParams.IgnoreWater = false

    for i = 0, ArcSegments do
        local t = i * timeStep
        local pos = startPos + initialVelocity * t + Vector3.new(0, -0.5 * PizzaGravity * t * t, 0)
        if i > 0 then
            local direction = pos - lastPos
            local distance = direction.Magnitude
            if distance > 0 then
                local rayResult = workspace:Raycast(lastPos, direction.Unit * distance, rayParams)
                if rayResult then
                    table.insert(points, rayResult.Position)
                    break
                end
            end
        end
        if pos.Y < -100 then break end
        table.insert(points, pos)
        lastPos = pos
    end
    return points
end

local function UpdateArcVisualization(target)
    if not ShowArc or not HumanoidRootPart then ClearArc(); return end
    local character = LocalPlayer.Character
    local leftArm = character:FindFirstChild("Left Arm")
        or character:FindFirstChild("LeftHand")
        or character:FindFirstChild("LeftLowerArm")
    local startPos
    if leftArm then
        startPos = leftArm.Position
    else
        startPos = HumanoidRootPart.Position + Vector3.new(-1, 1, 0)
            + (HumanoidRootPart.CFrame.LookVector * 2)
    end
    local lookVector = HumanoidRootPart.CFrame.LookVector
    local arcPoints = CalculateTrajectoryArc(startPos, nil, lookVector)
    ClearArc()
    for i, point in ipairs(arcPoints) do
        local isLastPoint = (i == #arcPoints)
        local part = CreateArcSegment(point, i)
        if isLastPoint and #arcPoints > 1 then
            part.Size = Vector3.new(0.5, 0.5, 0.5)
            part.Color = Color3.fromRGB(255, 255, 0)
            part.Transparency = 0
        end
        table.insert(ArcParts, part)
    end
end

-- ════════════════════════════════════════
--   TARGET FINDING & AIMING
-- ════════════════════════════════════════

local function FindTarget()
    local survivorsFolder = workspace:FindFirstChild("Players")
        and workspace.Players:FindFirstChild("Survivors")
    if not survivorsFolder then
        survivorsFolder = workspace:FindFirstChild("Survivors")
        if not survivorsFolder then return nil end
    end
    if not HumanoidRootPart then return nil end

    local target, lowestHealth = nil, math.huge
    local closestTarget, closestDistance = nil, math.huge

    for _, survivor in ipairs(survivorsFolder:GetChildren()) do
        if survivor ~= LocalPlayer.Character then
            local hum = survivor:FindFirstChildOfClass("Humanoid")
            local root = survivor:FindFirstChild("HumanoidRootPart")
            if hum and root and hum.Health > 0 then
                if hum.Health < lowestHealth then
                    target = root
                    lowestHealth = hum.Health
                end
                local distance = (root.Position - HumanoidRootPart.Position).Magnitude
                if distance < closestDistance then
                    closestTarget = root
                    closestDistance = distance
                end
            end
        end
    end
    return target or closestTarget
end

local function AimAt(target)
    if not target or not target.Parent then return end
    local velocity = target.AssemblyLinearVelocity
    local position = target.Position
    local lookVector = target.CFrame.LookVector
    local predictedPos = position + (lookVector * 2)
    local isMovingFast = velocity.Magnitude > VelocityThreshold
    if isMovingFast then
        predictedPos = predictedPos + (velocity.Unit * PredictionDistance)
    end

    if AimbotType == "HRP Aimbot" or AimbotType == "Camera + Character" then
        if HumanoidRootPart then
            if not AutoRotateBackup then AutoRotateBackup = Humanoid.AutoRotate end
            Humanoid.AutoRotate = false
            HumanoidRootPart.AssemblyAngularVelocity = Vector3.new(0, 0, 0)
            local direction = (predictedPos - HumanoidRootPart.Position)
            local directionFlat = Vector3.new(direction.X, 0, direction.Z).Unit
            local targetCFrame = CFrame.new(HumanoidRootPart.Position,
                HumanoidRootPart.Position + directionFlat)
            local currentCFrame = HumanoidRootPart.CFrame
            local newCFrame = currentCFrame:Lerp(targetCFrame, 0.35)
            HumanoidRootPart.CFrame = CFrame.new(currentCFrame.Position)
                * (newCFrame - newCFrame.Position)
        end
    end

    if AimbotType == "Camera Aimbot" or AimbotType == "Camera + Character" then
        Camera.CFrame = CFrame.lookAt(Camera.CFrame.Position, predictedPos)
    end
end

-- ════════════════════════════════════════
--   UI CONTROLS
-- ════════════════════════════════════════

ElliotTab:AddSlider({
    Name      = "Prediction Studs",
    Min       = 0,
    Max       = 50,
    Default   = 5,
    Color     = Color3.fromRGB(255, 255, 255),
    Increment = 1,
    ValueName = "studs",
    Callback  = function(value) PredictionDistance = value end,
})

ElliotTab:AddSlider({
    Name      = "Aim Duration (seconds)",
    Min       = 0.1,
    Max       = 2,
    Default   = 0.5,
    Color     = Color3.fromRGB(255, 255, 255),
    Increment = 0.1,
    ValueName = "s",
    Callback  = function(value) ThrowDuration = value end,
})

ElliotTab:AddSlider({
    Name      = "Pizza Throw Force",
    Min       = 50,
    Max       = 150,
    Default   = 80,
    Color     = Color3.fromRGB(255, 255, 255),
    Increment = 5,
    ValueName = "",
    Callback  = function(value) PizzaThrowForce = value end,
})

ElliotTab:AddSlider({
    Name      = "Arc Segments",
    Min       = 20,
    Max       = 100,
    Default   = 50,
    Color     = Color3.fromRGB(255, 255, 255),
    Increment = 5,
    ValueName = "",
    Callback  = function(value) ArcSegments = value end,
})

ElliotTab:AddDropdown({
    Name     = "Aimbot Type",
    Default  = "Camera + Character",
    Options  = { "HRP Aimbot", "Camera Aimbot", "Camera + Character" },
    Callback = function(option) AimbotType = option end,
})

ElliotTab:AddLabel("───────────────────")

ElliotTab:AddToggle({
    Name     = "Show Pizza Arc",
    Default  = false,
    Callback = function(value)
        ShowArc = value
        if value then
            CreateArcFolder()
        else
            ClearArc()
            if ArcFolder then ArcFolder:Destroy(); ArcFolder = nil end
        end
    end,
})

ElliotTab:AddToggle({
    Name     = "Require Throw Animation",
    Default  = true,
    Callback = function(value) RequireAnimation = value end,
})

ElliotTab:AddLabel("───────────────────")

ElliotTab:AddToggle({
    Name     = "Elliot Aimbot",
    Default  = false,
    Callback = function(value)
        AimbotEnabled = value
        if value then
            RenderConnection = RunService.RenderStepped:Connect(function()
                if not AimbotEnabled or not Humanoid or not HumanoidRootPart then return end

                CalculatePlayerMovement()

                if IsThrowing and (tick() - ThrowTimestamp) > ThrowDuration then
                    IsThrowing = false
                end

                if ShowArc then
                    UpdateArcVisualization(FindTarget())
                end

                local shouldAim = RequireAnimation and IsThrowing or not RequireAnimation
                if not shouldAim then
                    if AutoRotateBackup ~= nil then
                        Humanoid.AutoRotate = AutoRotateBackup
                        AutoRotateBackup = nil
                    end
                    return
                end

                local target = FindTarget()
                if not target then
                    if AutoRotateBackup ~= nil then
                        Humanoid.AutoRotate = AutoRotateBackup
                        AutoRotateBackup = nil
                    end
                    return
                end

                AimAt(target)
            end)
        else
            if RenderConnection then RenderConnection:Disconnect(); RenderConnection = nil end
            if AutoRotateBackup ~= nil then
                Humanoid.AutoRotate = AutoRotateBackup
                AutoRotateBackup = nil
            end
            ClearArc()
        end
    end,
})

-- ════════════════════════════════════════
--   INIT
-- ════════════════════════════════════════

OrionLib:Init()