Best Script

Script source Luau

Copy Script

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


-- Locals:
local Game = game
local Workspace = workspace
local GetService = Game.GetService
local HttpGet = Game.HttpGet
local NewVector2 = Vector2.new
local NewVector3 = Vector3.new
local NewColor3 = Color3.fromRGB
local NewInstance = Instance.new
local NewRaycastParams = RaycastParams.new
local Max = math.max
local Min = math.min
local Ceil = math.ceil
local Abs = math.abs
local Huge = math.huge
local Clock = os.clock
local Type = type
local Require = require
local HookFunction = hookfunction
local LoadString = loadstring
local TableInsert = table.insert
local TableSort = table.sort

-- Services:
local Players = GetService(Game, "Players")
local RunService = GetService(Game, "RunService")
local UserInputService = GetService(Game, "UserInputService")
local ReplicatedStorage = GetService(Game, "ReplicatedStorage")

-- Global Constants:
local OBSIDIAN_URL = "https://raw.githubusercontent.com/deividcomsono/Obsidian/main/Library.lua"

local Config = {
    SilentAim = false,
    FOVSize = 180,
    FOVColor = NewColor3(255, 255, 255),
    ShowFOV = false,
    HitPart = "Head",
    MaxFlightTicks = 100,
    NoAimAnimation = false,
    FullDrawTicks = 20,
    RageBot = false,
    RageDrawTicks = 20,
    RageShotDelay = 0.1,
    FastWalk = false,
    WalkSpeed = 24,
    HighlightChams = false,
    ChamsFillColor = NewColor3(255, 0, 0),
    ChamsFillTransparency = 0.61,
    ChamsOutlineColor = NewColor3(255, 255, 255),
    ChamsOutlineTransparency = 0.21,
}

local LocalPlayer = Players.LocalPlayer
local Client = LocalPlayer:WaitForChild("PlayerScripts"):WaitForChild("Client")
local Shared = ReplicatedStorage:WaitForChild("Shared")

local BowController = Require(Client:WaitForChild("BowController"))
local BowMovement = Require(Client:WaitForChild("BowMovement"))
local CombatClient = Require(Client:WaitForChild("CombatClient"))
local FirstPersonAnimationModule = Client:WaitForChild("FirstPersonAnimation")
local FirstPersonAnimation = Require(FirstPersonAnimationModule)
local TaCZMotion = Require(FirstPersonAnimationModule:WaitForChild("TaCZMotion"))
local BowMath = Require(Shared:WaitForChild("BowMath"))
local BowNet = Require(Shared:WaitForChild("BowNet"))
local BowConfig = Require(Shared:WaitForChild("BowConfig"))
local CharacterLife = Require(Shared:WaitForChild("CharacterLife"))
local EnchantEffects = Require(Shared:WaitForChild("EnchantEffects"))

-- Module:
local Archer = {}
type Archer = typeof(Archer)

local Interface = {}
type Interface = typeof(Interface)

do
    local ActiveRelease = nil
    local ActivePreview = nil
    local ActiveDrawingController = nil
    local CachedDraws = setmetatable({}, {__mode = "k"})
    local RageState = nil
    local NextRageShot = 0
    local HiddenShots = {}
    local HiddenArrows = {}
    local ChamsHighlights = {}

    -- Private Methods:
    local function TargetPart(Character, Player, InfectionMode, PartName)
        if not Character or Character.Name == "DeathModel" then
            return nil
        end
        if InfectionMode then
            local RoleSource = Player or Character
            if RoleSource:GetAttribute("InfectionRole") ~= "Zombie" then
                return nil
            end
        end
        if Player and Player:GetAttribute("MatchStatus") == "Dead" then
            return nil
        end

        local Humanoid = Character:FindFirstChildOfClass("Humanoid")
        if not Humanoid
            or CharacterLife.isDead(Humanoid)
            or Humanoid:GetState() == Enum.HumanoidStateType.Dead
        then
            return nil
        end

        local Part = Character:FindFirstChild(PartName or Config.HitPart)
        if Part and Part:IsA("BasePart") then
            return Part
        end
        return nil
    end

    local function UpdateChamsEntity(Entity, Character, Player)
        local Visible = Config.HighlightChams
            and Character
            and Character:IsDescendantOf(Workspace)
            and TargetPart(Character, Player, false, "HumanoidRootPart") ~= nil
        local Highlight = ChamsHighlights[Entity]

        if not Visible then
            if Highlight then
                Highlight.Enabled = false
                Highlight.Adornee = nil
                Highlight.Parent = nil
            end
            return
        end

        if not Highlight then
            Highlight = NewInstance("Highlight")
            Highlight.Name = "\0"
            Highlight.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
            ChamsHighlights[Entity] = Highlight
        end

        Highlight.FillColor = Config.ChamsFillColor
        Highlight.FillTransparency = Config.ChamsFillTransparency
        Highlight.OutlineColor = Config.ChamsOutlineColor
        Highlight.OutlineTransparency = Config.ChamsOutlineTransparency
        Highlight.Adornee = Character
        Highlight.Parent = Workspace
        Highlight.Enabled = true
    end

    local function UpdateChams()
        local Seen = {}
        for _, Player in Players:GetPlayers() do
            if Player ~= LocalPlayer then
                Seen[Player] = true
                UpdateChamsEntity(Player, Player.Character, Player)
            end
        end

        local Bots = Workspace:FindFirstChild("Bots")
        if Bots then
            for _, Bot in Bots:GetChildren() do
                if Bot:IsA("Model") then
                    Seen[Bot] = true
                    UpdateChamsEntity(Bot, Bot, nil)
                end
            end
        end

        for Entity, Highlight in ChamsHighlights do
            if not Seen[Entity] then
                Highlight:Destroy()
                ChamsHighlights[Entity] = nil
            end
        end
    end

    local function FindTarget()
        local Camera = Workspace.CurrentCamera
        if not Camera then
            return nil
        end

        local Mouse = UserInputService:GetMouseLocation()
        local BestPart = nil
        local BestDistance = Config.FOVSize
        local InfectionMode = LocalPlayer:GetAttribute("MatchMode") == "Infection"

        local function Consider(Character, Player)
            local Part = TargetPart(Character, Player, InfectionMode)
            if not Part then
                return
            end

            local Screen = Camera:WorldToViewportPoint(Part.Position)
            if Screen.Z <= 0 then
                return
            end

            local Distance = (NewVector2(Screen.X, Screen.Y) - Mouse).Magnitude
            if Distance >= BestDistance then
                return
            end

            BestDistance = Distance
            BestPart = Part
        end

        for _, Player in Players:GetPlayers() do
            if Player == LocalPlayer then
                continue
            end

            Consider(Player.Character, Player)
        end

        local Bots = Workspace:FindFirstChild("Bots")
        if Bots then
            for _, Bot in Bots:GetChildren() do
                if not Bot:IsA("Model") then
                    continue
                end

                Consider(Bot)
            end
        end

        return BestPart
    end

    local function PathClear(Part, Origin, Params)
        local Direction = Part.Position - Origin
        if Direction.Magnitude <= 0 then
            return false, nil
        end

        local Hit = Workspace:Raycast(Origin, Direction, Params)
        return Hit == nil, Hit and Hit.Instance
    end

    local function RageRaycastParams()
        local Params = NewRaycastParams()
        Params.FilterType = Enum.RaycastFilterType.Exclude
        Params.IgnoreWater = true
        Params.RespectCanCollide = true
        return Params
    end

    local function FindRageTarget(Controller, Origin)
        Origin = Origin or Controller:launchPoint()
        local Params = RageRaycastParams()
        local Choices = {}

        local function Consider(Character, Player)
            local Root = TargetPart(Character, Player, false, "HumanoidRootPart")
            if not Root then
                return
            end

            local Distance = (Root.Position - Origin).Magnitude
            local Parts = {Root}
            local Torso = Character:FindFirstChild("UpperTorso") or Character:FindFirstChild("Torso")
            local Head = Character:FindFirstChild("Head")
            if Torso and Torso:IsA("BasePart") then
                TableInsert(Parts, 1, Torso)
            end
            if Head and Head:IsA("BasePart") then
                TableInsert(Parts, Head)
            end

            Params.FilterDescendantsInstances = {LocalPlayer.Character, Controller.effects, Character}
            local Visible = false
            for Priority, Candidate in Parts do
                local Clear = PathClear(Candidate, Origin, Params)
                if Clear then
                    Visible = true
                    TableInsert(Choices, {Part = Candidate, Distance = Distance, Priority = Priority})
                end
            end

            if not Visible then
                return
            end

        end

        for _, Player in Players:GetPlayers() do
            if Player ~= LocalPlayer then
                Consider(Player.Character, Player)
            end
        end

        local Bots = Workspace:FindFirstChild("Bots")
        if Bots then
            for _, Bot in Bots:GetChildren() do
                if Bot:IsA("Model") then
                    Consider(Bot)
                end
            end
        end

        TableSort(Choices, function(Left, Right)
            if Left.Distance == Right.Distance then
                return Left.Priority < Right.Priority
            end
            return Left.Distance < Right.Distance
        end)
        local Closest = Choices[1]
        return Closest and Closest.Part, Choices
    end

    local function StopRage(Delay, CancelDraw)
        local State = RageState
        RageState = nil
        NextRageShot = Clock() + Delay

        if CancelDraw and State and State.Stage ~= "AwaitRelease" then
            State.Controller.network:send("Cancel")
        end
    end

    local function SolveDirection(Controller, Origin, ChargeTicks, Target, DrawId, Effects)
        local Seed = Controller.network and Controller.network.bowSeed
        DrawId = DrawId or Controller.drawId
        local Character = LocalPlayer.Character
        local Root = Character and Character:FindFirstChild("HumanoidRootPart")
        if not Seed or not DrawId or not Root or not Target or ChargeTicks == nil then
            return nil, "missing seed, draw ID, character root, target, or charge"
        end

        local Power = BowMath.powerTicks(ChargeTicks)
        if Power < 0.1 then
            return nil, "draw charge is below launch threshold"
        end

        Effects = Effects or Controller.drawEffects
        local SpeedBonus = 1 + (Effects and Effects.ArrowSpeedBonus or 0)
        local Speed = BowMath.f32(Power * 3 * SpeedBonus)
        if Speed <= 0 then
            return nil, "launch speed is zero"
        end

        local Spread = BowMath.launchSpread(BowNet.random(Seed, DrawId))
        local Source = BowMath.fromWorld(BowNet.clampVelocity(Root.AssemblyLinearVelocity) * BowConfig.Tick)
        local OriginBlocks = BowMath.fromWorld(Origin)
        local TargetRoot = Target.Parent and Target.Parent:FindFirstChild("HumanoidRootPart")
        local TargetVelocity = if TargetRoot and TargetRoot:IsA("BasePart")
            then TargetRoot.AssemblyLinearVelocity
            else Target.AssemblyLinearVelocity
        local Drag = BowMath.AirInertia

        local function Candidate(Ticks)
            local Sum = (1 - Drag ^ Ticks) / (1 - Drag)
            local GravityDrop = 0.05 * (Ticks - Sum) / (1 - Drag)
            local Future = Target.Position + TargetVelocity * (Ticks * BowConfig.Tick)
            local Destination = BowMath.fromWorld(Future)
            local Delta = NewVector3(
                Destination.x - OriginBlocks.x,
                Destination.y - OriginBlocks.y,
                Destination.z - OriginBlocks.z
            )
            local RequiredVelocity = NewVector3(
                Delta.X / Sum,
                (Delta.Y + GravityDrop) / Sum,
                Delta.Z / Sum
            )
            local Aim = NewVector3(
                (RequiredVelocity.X - Source.x) / Speed - Spread.x,
                RequiredVelocity.Y / Speed - Spread.y,
                (RequiredVelocity.Z - Source.z) / Speed - Spread.z
            )
            return Aim, Aim.Magnitude - 1
        end

        local PreviousTicks = 0.25
        local _, PreviousError = Candidate(PreviousTicks)
        local BestAim = nil
        local BestTicks = nil
        local BestError = Huge

        for Ticks = 0.5, Config.MaxFlightTicks, 0.5 do
            local Aim, Error = Candidate(Ticks)
            if Abs(Error) < BestError then
                BestAim = Aim
                BestTicks = Ticks
                BestError = Abs(Error)
            end

            if PreviousError > 0 and Error <= 0 then
                local Low, High = PreviousTicks, Ticks
                for _ = 1, 18 do
                    local Mid = (Low + High) * 0.5
                    local _, MidError = Candidate(Mid)
                    if MidError > 0 then
                        Low = Mid
                    else
                        High = Mid
                    end
                end
                Aim = Candidate((Low + High) * 0.5)
                if Aim.Magnitude > 0 then
                    return Aim.Unit, nil, {
                        FlightTicks = (Low + High) * 0.5,
                        Power = Power,
                        Speed = Speed,
                        Spread = Spread,
                        Source = Source,
                        Fallback = false,
                    }
                end
                return nil, "aim vector is zero"
            end

            PreviousTicks = Ticks
            PreviousError = Error
        end

        if not BestAim or BestAim.Magnitude <= 0 then
            return nil, "no usable trajectory"
        end

        return BestAim.Unit, nil, {
            FlightTicks = BestTicks,
            Power = Power,
            Speed = Speed,
            Spread = Spread,
            Source = Source,
            Fallback = true,
            Residual = BestError,
        }
    end

    local function TrajectoryClear(Controller, Origin, Target, Velocity, FlightTicks)
        local Params = RageRaycastParams()
        Params.FilterDescendantsInstances = {LocalPlayer.Character, Controller.effects, Target.Parent}

        local Position = BowMath.fromWorld(Origin)
        for Tick = 1, Ceil(FlightTicks) do
            local Fraction = Min(1, FlightTicks - Tick + 1)
            local Start = BowMath.toWorld(Position)
            local Segment = BowMath.toWorld(Velocity) * Fraction
            local Hit = Workspace:Raycast(Start, Segment, Params)
            if Hit then
                return false, Hit.Instance
            end
            Position, Velocity = BowMath.arrowStep(Position, Velocity)
        end

        return true, nil
    end

    -- Public Methods:
    function Archer.Init(self: Archer)
        Players.PlayerRemoving:Connect(function(Player)
            local Highlight = ChamsHighlights[Player]
            if Highlight then
                Highlight:Destroy()
                ChamsHighlights[Player] = nil
            end
        end)
        RunService.Heartbeat:Connect(UpdateChams)

        local OldMovementTick
        OldMovementTick = HookFunction(BowMovement.tick, function(Movement, ...)
            local Result = OldMovementTick(Movement, ...)
            local Humanoid = Movement.humanoid
            if Config.FastWalk and Movement.active and Humanoid and Humanoid:IsA("Humanoid") then
                Humanoid.WalkSpeed = Min(Config.WalkSpeed, 30)
            end
            return Result
        end)

        if Drawing and Type(Drawing.new) == "function" then
            local FOVCircle = Drawing.new("Circle")
            FOVCircle.Position = UserInputService:GetMouseLocation()
            FOVCircle.Visible = Config.SilentAim and Config.ShowFOV
            FOVCircle.Color = Config.FOVColor
            FOVCircle.Radius = Config.FOVSize
            FOVCircle.Transparency = 1
            FOVCircle.Filled = false
            FOVCircle.NumSides = 64

            RunService.PreRender:Connect(function()
                FOVCircle.Position = UserInputService:GetMouseLocation()
                FOVCircle.Visible = Config.SilentAim and Config.ShowFOV
                FOVCircle.Color = Config.FOVColor
                FOVCircle.Radius = Config.FOVSize
            end)
        end

        local OldChargeTicks
        OldChargeTicks = HookFunction(BowNet.chargeTicks, function(...)
            local Ticks = OldChargeTicks(...)
            if ActiveRelease then
                ActiveRelease.ChargeTicks = Ticks
            end
            return Ticks
        end)

        local OldRandom
        OldRandom = HookFunction(BowNet.random, function(Seed, DrawId)
            local Controller = ActivePreview
            if not Controller or (Type(Seed) == "number" and Type(DrawId) == "number") then
                return OldRandom(Seed, DrawId)
            end

            local Cached = CachedDraws[Controller]
            local CurrentId = Controller.drawId
            if Type(CurrentId) ~= "number" and Cached then
                CurrentId = Cached.Id
            end

            if Type(Seed) == "number" and Type(CurrentId) == "number" then
                DrawId = CurrentId
                Controller.previewDrawId = DrawId
                return OldRandom(Seed, DrawId)
            end

            Controller.trajectory:hide()
            return function()
                return 0.5
            end
        end)

        local OldPreviewTrajectory
        OldPreviewTrajectory = HookFunction(BowController.previewTrajectory, function(Controller, ...)
            if Controller.drawing and (not Controller.network or Type(Controller.network.bowSeed) ~= "number") then
                Controller.trajectory:hide()
                return
            end

            if Controller.drawing and Type(Controller.drawId) ~= "number" then
                local Cached = CachedDraws[Controller]
                if Cached and Type(Cached.Id) == "number" then
                    Controller.drawId = Cached.Id
                else
                    Controller.trajectory:hide()
                    return
                end
            end

            local Previous = ActivePreview
            ActivePreview = Controller
            local Result = OldPreviewTrajectory(Controller, ...)
            ActivePreview = Previous
            return Result
        end)

        local OldLaunchPoint
        OldLaunchPoint = HookFunction(BowController.launchPoint, function(Controller, ...)
            local Origin, Direction = OldLaunchPoint(Controller, ...)
            if not Config.SilentAim then
                return Origin, Direction
            end

            local State = ActiveRelease
            local IsRelease = State and State.Controller == Controller
            local IsPreview = ActivePreview == Controller and Controller.drawing
            if not IsRelease and not IsPreview then
                return Origin, Direction
            end

            local Target = FindTarget()
            if not Target then
                return Origin, Direction
            end

            local ChargeTicks = if IsRelease then State.ChargeTicks else Controller.previewTicks
            local Aim = SolveDirection(Controller, Origin, ChargeTicks, Target)
            if Aim then
                if IsRelease then
                    State.Direction = Aim
                    State.Origin = Origin
                end
                return Origin, Aim
            end
            return Origin, Direction
        end)

        local OldSend
        OldSend = HookFunction(CombatClient.send, function(Network, Action, Params)
            local State = ActiveRelease
            local Matched = Action == "Release" and State and State.Controller.network == Network
            if Matched and State.Direction then
                Params.direction = State.Direction
                Params.origin = State.Origin
            end
            local Result = OldSend(Network, Action, Params)
            if Action == "Draw" and Network.controller then
                CachedDraws[Network.controller] = {Id = Result}
            end
            return Result
        end)

        local OldReceive
        OldReceive = HookFunction(CombatClient.receive, function(Network, Action, Params, ...)
            if Params then
                if Action == "ArrowSpawn" and Params.userId == LocalPlayer.UserId and HiddenShots[Params.seq] then
                    HiddenArrows[Params.id] = Clock() + 75
                    return
                elseif Action == "ArrowHit" and (HiddenShots[Params.seq] or HiddenArrows[Params.id]) then
                    return
                elseif Action == "ArrowRemove" and HiddenArrows[Params.id] then
                    HiddenArrows[Params.id] = nil
                    return
                end
            end

            local Pending = Action == "Result" and Params and Network.pending[Params.seq]
            local Result = OldReceive(Network, Action, Params, ...)
            local State = RageState
            if not State or State.Controller.network ~= Network or not Pending then
                return Result
            end

            if Pending.action == "Draw" and Params.seq == State.DrawId then
                if Params.ok then
                    State.DrawStarted = Params.drawTime or State.DrawTime
                    State.Stage = "Charging"
                    State.StartedAt = Clock()
                else
                    StopRage(1, false)
                end
            elseif Pending.action == "Release" and Params.seq == State.ReleaseId then
                StopRage(if Params.ok then Config.RageShotDelay else Max(1, Config.RageShotDelay), false)
            end

            return Result
        end)

        local OldBeginDraw
        OldBeginDraw = HookFunction(BowController.beginDraw, function(Controller, ...)
            local WasDrawing = Controller.drawing
            local Result = OldBeginDraw(Controller, ...)
            if WasDrawing or not Controller.drawing then
                return Result
            end

            ActiveDrawingController = Controller
            return Result
        end)

        local OldAnimationUpdate
        OldAnimationUpdate = HookFunction(FirstPersonAnimation.update, function(Animation, Delta, Slot, Drawing, DrawTicks, ...)
            local Controller = ActiveDrawingController
            if Config.NoAimAnimation
                and Controller
                and Controller.firstPersonAnimation == Animation
                and Drawing
                and Slot == 1
            then
                DrawTicks = Max(DrawTicks, Config.FullDrawTicks)
            end

            return OldAnimationUpdate(Animation, Delta, Slot, Drawing, DrawTicks, ...)
        end)

        local OldMotionUpdate
        OldMotionUpdate = HookFunction(TaCZMotion.update, function(Motion, Delta, Drawing, DrawTicks, ...)
            local Result = OldMotionUpdate(Motion, Delta, Drawing, DrawTicks, ...)
            local Controller = ActiveDrawingController
            if Config.NoAimAnimation
                and Controller
                and Controller.firstPersonAnimation.tacz == Motion
                and Drawing
                and Motion.key == "tb23"
            then
                local Track = Motion.adsTrack
                if Track and Track.name == "pull_in" then
                    Track.start = Min(Track.start, Motion.clock - 0.2)
                end
            end

            return Result
        end)

        local OldRelease
        OldRelease = HookFunction(BowController.release, function(Controller, ...)
            local Previous = ActiveRelease
            local State = {Controller = Controller}
            ActiveRelease = State
            local Result = OldRelease(Controller, ...)
            ActiveRelease = Previous
            return Result
        end)

        RunService.Heartbeat:Connect(function()
            local Now = Clock()
            for Id, ExpiresAt in HiddenShots do
                if Now >= ExpiresAt then
                    HiddenShots[Id] = nil
                end
            end
            for Id, ExpiresAt in HiddenArrows do
                if Now >= ExpiresAt then
                    HiddenArrows[Id] = nil
                end
            end

            if not Config.RageBot then
                if RageState then
                    StopRage(0, true)
                end
                return
            end

            local Controller = BowController.active
            if not Controller
                or Controller.selectedSlot ~= 1
                or not Controller:alive()
                or not Controller.camera
                or not Controller.network
                or Type(Controller.network.bowSeed) ~= "number"
            then
                if RageState then
                    StopRage(Config.RageShotDelay, true)
                end
                return
            end

            local State = RageState
            if not State then
                if Now < NextRageShot or Controller.drawing then
                    return
                end

                local Character = LocalPlayer.Character
                local Root = Character and Character:FindFirstChild("HumanoidRootPart")
                local Target
                if Root then
                    Target = FindRageTarget(Controller)
                end
                if not Target then
                    return
                end

                State = {
                    Controller = Controller,
                    Stage = "AwaitDraw",
                    StartedAt = Now,
                    DrawTime = Workspace:GetServerTimeNow(),
                    DrawEffects = EnchantEffects.fromTool(Controller.equippedTool),
                }
                RageState = State
                State.DrawId = Controller.network:send("Draw", {time = State.DrawTime})
                if Type(State.DrawId) ~= "number" then
                    StopRage(Config.RageShotDelay, false)
                end
                return
            end

            if State.Controller ~= Controller then
                StopRage(Config.RageShotDelay, false)
                return
            end
            if Controller.drawing then
                StopRage(Config.RageShotDelay, false)
                return
            end
            if State.Stage == "AwaitDraw" then
                if Now - State.StartedAt > 2.5 then
                    StopRage(Config.RageShotDelay, true)
                end
                return
            end
            if State.Stage == "AwaitRelease" then
                if Now - State.StartedAt > 2.5 then
                    StopRage(Config.RageShotDelay, false)
                end
                return
            end
            if State.Stage ~= "Charging" then
                return
            end

            local DrawSpeed = 1 + (State.DrawEffects and State.DrawEffects.DrawSpeedBonus or 0)
            local ChargeTicks = BowNet.chargeTicks(State.DrawStarted, Workspace:GetServerTimeNow(), DrawSpeed)
            if ChargeTicks < Config.RageDrawTicks then
                return
            end

            local Origin = Controller:launchPoint()
            local _, Choices = FindRageTarget(Controller, Origin)
            if #Choices == 0 then
                StopRage(Config.RageShotDelay, true)
                return
            end

            local Root = LocalPlayer.Character and LocalPlayer.Character:FindFirstChild("HumanoidRootPart")
            if not Root then
                StopRage(Config.RageShotDelay, true)
                return
            end

            local SourceVelocity = BowNet.clampVelocity(Root.AssemblyLinearVelocity)
            local Source = BowMath.fromWorld(SourceVelocity * BowConfig.Tick)
            local SpeedBonus = 1 + (State.DrawEffects and State.DrawEffects.ArrowSpeedBonus or 0)
            local Target, Direction
            for _, Choice in Choices do
                local Candidate = Choice.Part
                if not Candidate.Parent then
                    continue
                end
                local Aim, _, Solution = SolveDirection(
                    Controller, Origin, ChargeTicks, Candidate, State.DrawId, State.DrawEffects
                )
                if not Aim or not Solution or Solution.Fallback then
                    continue
                end

                local Velocity = BowMath.launch(
                    Aim,
                    ChargeTicks,
                    Source,
                    BowNet.random(Controller.network.bowSeed, State.DrawId),
                    SpeedBonus
                )
                if not Velocity then
                    continue
                end

                local Clear = TrajectoryClear(Controller, Origin, Candidate, Velocity, Solution.FlightTicks)
                if not Clear then
                    continue
                end

                Target = Candidate
                Direction = Aim
                break
            end

            if not Target then
                if Now - State.StartedAt > 4 then
                    StopRage(Config.RageShotDelay, true)
                end
                return
            end

            State.Stage = "AwaitRelease"
            State.StartedAt = Now
            State.ReleaseId = Controller.network:send("Release", {
                drawId = State.DrawId,
                direction = Direction,
                origin = Origin,
                time = Workspace:GetServerTimeNow(),
                sourceVelocity = SourceVelocity,
                mobile = UserInputService.TouchEnabled,
            })
            if State.ReleaseId then
                HiddenShots[State.ReleaseId] = Now + 75
            end
            if RageState == State and not State.ReleaseId then
                StopRage(Config.RageShotDelay, false)
            end
        end)
    end
end

do
    -- Public Methods:
    function Interface.Init(self: Interface)
        local Library = LoadString(HttpGet(Game, OBSIDIAN_URL))()
        local Window = Library:CreateWindow({
            Title = "Archer",
            Footer = "",
            AutoShow = true,
            Center = true,
        })

        local Main = Window:AddTab("Main", "crosshair")
        local CombatGroup = Main:AddGroupbox({Side = "Left", Name = "Combat"})
        local MiscGroup = Main:AddGroupbox({Side = "Right", Name = "Misc"})
        local ESPGroup = Main:AddGroupbox({Side = "Right", Name = "ESP"})

        CombatGroup:AddToggle("RageBot", {
            Text = "Auto Kill",
            Default = Config.RageBot,
            Callback = function(Value)
                Config.RageBot = Value
            end,
        })

        CombatGroup:AddToggle("SilentAim", {
            Text = "Silent Aim",
            Default = Config.SilentAim,
            Callback = function(Value)
                Config.SilentAim = Value
            end,
        })

        CombatGroup:AddToggle("ShowFOV", {
            Text = "Show FOV",
            Default = Config.ShowFOV,
            Callback = function(Value)
                Config.ShowFOV = Value
            end,
        })

        CombatGroup:AddSlider("FOVSize", {
            Text = "FOV Size",
            Default = Config.FOVSize,
            Min = 25,
            Max = 600,
            Rounding = 0,
            Suffix = "px",
            Callback = function(Value)
                Config.FOVSize = Value
            end,
        })

        CombatGroup:AddLabel("FOV Color"):AddColorPicker("FOVColor", {
            Default = Config.FOVColor,
            Title = "FOV Color",
            Callback = function(Value)
                Config.FOVColor = Value
            end,
        })

        CombatGroup:AddDropdown("HitPart", {
            Text = "Hit Part",
            Values = {"Head", "HumanoidRootPart"},
            Default = Config.HitPart,
            Callback = function(Value)
                Config.HitPart = Value
            end,
        })

        MiscGroup:AddToggle("NoAimAnimation", {
            Text = "No Aim Animation",
            Tooltip = "Visual draw animation only; charge is still determined by the game.",
            Default = Config.NoAimAnimation,
            Callback = function(Value)
                Config.NoAimAnimation = Value
            end,
        })

        MiscGroup:AddToggle("FastWalk", {
            Text = "Fast Walk",
            Default = Config.FastWalk,
            Callback = function(Value)
                Config.FastWalk = Value
            end,
        })

        MiscGroup:AddSlider("WalkSpeed", {
            Text = "Walk Speed",
            Default = Config.WalkSpeed,
            Min = 16,
            Max = 30,
            Rounding = 0,
            Suffix = " studs/s",
            Callback = function(Value)
                Config.WalkSpeed = Value
            end,
        })

        ESPGroup:AddToggle("HighlightChams", {
            Text = "Highlight Chams",
            Default = Config.HighlightChams,
            Callback = function(Value)
                Config.HighlightChams = Value
            end,
        })

        ESPGroup:AddLabel("Fill Color"):AddColorPicker("ChamsFillColor", {
            Default = Config.ChamsFillColor,
            Title = "Fill Color",
            Callback = function(Value)
                Config.ChamsFillColor = Value
            end,
        })

        ESPGroup:AddSlider("ChamsFillTransparency", {
            Text = "Fill Transparency",
            Default = Config.ChamsFillTransparency * 100,
            Min = 0,
            Max = 100,
            Rounding = 0,
            Suffix = "%",
            Callback = function(Value)
                Config.ChamsFillTransparency = Value / 100
            end,
        })

        ESPGroup:AddLabel("Outline Color"):AddColorPicker("ChamsOutlineColor", {
            Default = Config.ChamsOutlineColor,
            Title = "Outline Color",
            Callback = function(Value)
                Config.ChamsOutlineColor = Value
            end,
        })

        ESPGroup:AddSlider("ChamsOutlineTransparency", {
            Text = "Outline Transparency",
            Default = Config.ChamsOutlineTransparency * 100,
            Min = 0,
            Max = 100,
            Rounding = 0,
            Suffix = "%",
            Callback = function(Value)
                Config.ChamsOutlineTransparency = Value / 100
            end,
        })

        Library.ToggleKeybind = Enum.KeyCode.RightShift
    end
end

Archer:Init()
Interface:Init()

Review the source before using it. Executions count successful copies, capped at 10 per user and network per script in 24 hours.