Project Remix - Silent Aim

-- init
if not game:IsLoaded() then
    game.Loaded:Wait()
end

if not syn or not protectgui then
    getgenv().protectgui = function() end
end

--[[
    Universal Silent Aim -> adapted for "Project Remix [Gun Game]" (place 15073271237)
    Executor target: Volt (docs.voltbz.net)

    Why this differs from the generic Universal Silent Aim:
      * Project Remix guns are HITSCAN via the game's own DamageService:Bulletcast /
        :PierceBulletcast (main-thread), NOT workspace:Raycast / FindPartOnRay / Mouse.Hit.
      * Projectile weapons (rockets / thrown / katana) fire via ProjectileService.NewProjectile.
      * Hit registration is CLIENT-AUTHORITATIVE: the weapon resolves the hit part with
        DamageService:GetHitTarget and applies damage with DamageService:Damage itself,
        so bending the cast direction (or projectile velocity) toward a target lands the hit.
      * The generic build hooked game.__namecall / Mouse.__index, which never intercept the
        game's custom cast methods (and the bullet SIMULATION runs inside a parallel Actor VM
        that main-thread hooks can't reach) -- so it did nothing here. This build hooks the
        real chokepoints instead.
]]

local SilentAimSettings = {
    Enabled = false,

    ClassName = "Project Remix Silent Aim - Averiias, Stefanuk12, xaxa (Bulletcast port)",
    ToggleKey = "RightAlt",

    TeamCheck = false,
    VisibleCheck = false,
    Wallbang = false,
    TargetPart = "HumanoidRootPart",

    FOVRadius = 130,
    FOVVisible = false,
    ShowSilentAimTarget = false,

    ProjectilePrediction = false,
    ProjectilePredictionAmount = 0.165,
    HitChance = 100
}

-- variables
getgenv().SilentAimSettings = SilentAimSettings
local MainFileName = "UniversalSilentAim"
local FileToSave = ""

local Camera = workspace.CurrentCamera
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local GuiService = game:GetService("GuiService")
local UserInputService = game:GetService("UserInputService")
local HttpService = game:GetService("HttpService")

local LocalPlayer = Players.LocalPlayer

local GetPlayers = Players.GetPlayers
local WorldToViewportPoint = Camera.WorldToViewportPoint
local GetPartsObscuringTarget = Camera.GetPartsObscuringTarget
local FindFirstChild = game.FindFirstChild
local RenderStepped = RunService.RenderStepped
local GetMouseLocation = UserInputService.GetMouseLocation

local resume = coroutine.resume
local create = coroutine.create

local ValidTargetParts = {"Head", "HumanoidRootPart"}
local PredictionAmount = 0.165

local mouse_box = Drawing.new("Square")
mouse_box.Visible = false
mouse_box.ZIndex = 999
mouse_box.Color = Color3.fromRGB(54, 57, 241)
mouse_box.Thickness = 20
mouse_box.Size = Vector2.new(20, 20)
mouse_box.Filled = true

local fov_circle = Drawing.new("Circle")
fov_circle.Thickness = 1
fov_circle.NumSides = 100
fov_circle.Radius = 180
fov_circle.Filled = false
fov_circle.Visible = false
fov_circle.ZIndex = 999
fov_circle.Transparency = 1
fov_circle.Color = Color3.fromRGB(54, 57, 241)

-- resolve the game's framework services (Volt: getrenv exposes the game's real _G)
local GameGlobal = getrenv()._G
local DamageService, ProjectileService
do
    local ok = pcall(function()
        DamageService = GameGlobal:GetService("DamageService")
        ProjectileService = GameGlobal:GetService("ProjectileService")
    end)
    if not ok or not DamageService then
        warn("[SilentAim] Could not resolve DamageService/ProjectileService -- game framework changed?")
    end
end

function CalculateChance(Percentage)
    -- // Floor the percentage
    Percentage = math.floor(Percentage)

    -- // Get the chance
    local chance = math.floor(Random.new():NextNumber(0, 1) * 100) / 100

    -- // Return
    return chance <= Percentage / 100
end

--[[file handling]] do
    if not isfolder(MainFileName) then
        makefolder(MainFileName)
    end

    if not isfolder(string.format("%s/%s", MainFileName, tostring(game.PlaceId))) then
        makefolder(string.format("%s/%s", MainFileName, tostring(game.PlaceId)))
    end
end

-- functions
local function GetFiles() -- credits to the linoria lib for this function, listfiles returns the files full path and its annoying
    local out = {}
    local Files = listfiles(string.format("%s/%s", MainFileName, tostring(game.PlaceId)))
    for i = 1, #Files do
        local file = Files[i]
        if file:sub(-4) == '.lua' then
            local pos = file:find('.lua', 1, true)
            local start = pos

            local char = file:sub(pos, pos)
            while char ~= '/' and char ~= '\\' and char ~= '' do
                pos = pos - 1
                char = file:sub(pos, pos)
            end

            if char == '/' or char == '\\' then
                table.insert(out, file:sub(pos + 1, start - 1))
            end
        end
    end

    return out
end

local function UpdateFile(FileName)
    assert(FileName and FileName ~= "", "oopsies")
    writefile(string.format("%s/%s/%s.lua", MainFileName, tostring(game.PlaceId), FileName), HttpService:JSONEncode(SilentAimSettings))
end

local function LoadFile(FileName)
    assert(FileName and FileName ~= "", "oopsies")

    local File = string.format("%s/%s/%s.lua", MainFileName, tostring(game.PlaceId), FileName)
    local ConfigData = HttpService:JSONDecode(readfile(File))
    for Index, Value in next, ConfigData do
        SilentAimSettings[Index] = Value
    end
end

local function getPositionOnScreen(Vector)
    -- WorldToViewportPoint matches UserInputService:GetMouseLocation (both include the GUI inset)
    local Vec3, OnScreen = WorldToViewportPoint(Camera, Vector)
    return Vector2.new(Vec3.X, Vec3.Y), OnScreen
end

local function getMousePosition()
    return GetMouseLocation(UserInputService)
end

-- Project Remix characters live in workspace.Characters. The authoritative root is a
-- top-level HumanoidRootPart (CollisionGroup "PlayerRoot"); the visible/hittable R15 limbs
-- (CollisionGroup "Hitbox") sit under a "Playermodel" submodel, with the head as "HeadHitbox".
local function isDead(Character)
    local health = Character:GetAttribute("Health")
    if health ~= nil then
        return health <= 0
    end
    local humanoid = Character:FindFirstChildOfClass("Humanoid")
    if humanoid then
        return humanoid.Health <= 0
    end
    return false
end

local function resolvePart(Character, partName)
    if partName == "Head" then
        local playermodel = FindFirstChild(Character, "Playermodel")
        if playermodel then
            return FindFirstChild(playermodel, "HeadHitbox")
                or FindFirstChild(playermodel, "Head")
                or FindFirstChild(playermodel, "UpperTorso")
                or FindFirstChild(Character, "HumanoidRootPart")
        end
        return FindFirstChild(Character, "HumanoidRootPart")
    end
    -- default / HumanoidRootPart
    return FindFirstChild(Character, "HumanoidRootPart")
        or (FindFirstChild(Character, "Playermodel") and FindFirstChild(FindFirstChild(Character, "Playermodel"), "UpperTorso"))
end

local function getAimPart(Character)
    local target = Options and Options.TargetPart.Value or SilentAimSettings.TargetPart
    if target == "Random" then
        target = ValidTargetParts[math.random(1, #ValidTargetParts)]
    end
    return resolvePart(Character, target)
end

-- Project Remix does NOT use Roblox's native Player.Team (always nil). Teams are a player
-- attribute "Team" (integer), only meaningful when workspace attribute "TeamsEnabled" is true
-- (FFA modes leave it false, so every player is a valid target regardless of Team).
local function isSameTeam(Player)
    if not workspace:GetAttribute("TeamsEnabled") then return false end
    local myTeam = LocalPlayer:GetAttribute("Team")
    local theirTeam = Player:GetAttribute("Team")
    return myTeam ~= nil and theirTeam ~= nil and myTeam == theirTeam
end

local function IsCharacterVisible(Character, Root)
    local LocalCharacter = LocalPlayer.Character
    if not LocalCharacter then return true end

    local CastPoints = {Root.Position, LocalCharacter, Character}
    local IgnoreList = {LocalCharacter, Character}
    local Obscuring = #GetPartsObscuringTarget(Camera, CastPoints, IgnoreList)
    return Obscuring == 0
end

-- returns the BasePart to aim at (respecting FOV / team / visible / health checks)
local function getTarget()
    local mousePosition = getMousePosition()
    local radius = (Options and Options.Radius.Value) or SilentAimSettings.FOVRadius or 2000

    local closestPart
    local closestCharacter
    local closestDistance

    for _, Player in next, GetPlayers(Players) do
        if Player == LocalPlayer then continue end
        if Options and Toggles.TeamCheck.Value and isSameTeam(Player) then continue end

        local Character = Player.Character
        if not Character then continue end
        if isDead(Character) then continue end

        local Root = FindFirstChild(Character, "HumanoidRootPart")
        if not Root then continue end

        -- Wallbang bypasses the line-of-sight requirement (the cast is redirected to ignore geometry)
        if Options and Toggles.VisibleCheck.Value and not (Toggles.Wallbang and Toggles.Wallbang.Value)
            and not IsCharacterVisible(Character, Root) then continue end

        local ScreenPosition, OnScreen = getPositionOnScreen(Root.Position)
        if not OnScreen then continue end

        local Distance = (mousePosition - ScreenPosition).Magnitude
        if Distance <= radius and (not closestDistance or Distance < closestDistance) then
            local aimPart = getAimPart(Character)
            if aimPart then
                closestDistance = Distance
                closestPart = aimPart
                closestCharacter = Character
            end
        end
    end

    return closestPart, closestCharacter
end

-- ui creating & handling
local Library = loadstring(game:HttpGet("https://raw.githubusercontent.com/violin-suzutsuki/LinoriaLib/main/Library.lua"))()
Library:SetWatermark("github.com/Averiias")

local Window = Library:CreateWindow({Title = 'Project Remix Silent Aim', Center = true, AutoShow = true, TabPadding = 8, MenuFadeTime = 0.2})
local GeneralTab = Window:AddTab("General")
local MainBOX = GeneralTab:AddLeftTabbox("Main") do
    local Main = MainBOX:AddTab("Main")

    Main:AddToggle("aim_Enabled", {Text = "Enabled"}):AddKeyPicker("aim_Enabled_KeyPicker", {Default = "RightAlt", SyncToggleState = true, Mode = "Toggle", Text = "Enabled", NoUI = false})
    Options.aim_Enabled_KeyPicker:OnClick(function()
        SilentAimSettings.Enabled = not SilentAimSettings.Enabled

        Toggles.aim_Enabled.Value = SilentAimSettings.Enabled
        Toggles.aim_Enabled:SetValue(SilentAimSettings.Enabled)

        mouse_box.Visible = SilentAimSettings.Enabled and Toggles.MousePosition.Value
    end)

    Main:AddToggle("TeamCheck", {Text = "Team Check", Default = SilentAimSettings.TeamCheck}):OnChanged(function()
        SilentAimSettings.TeamCheck = Toggles.TeamCheck.Value
    end)
    Main:AddToggle("VisibleCheck", {Text = "Visible Check", Default = SilentAimSettings.VisibleCheck}):OnChanged(function()
        SilentAimSettings.VisibleCheck = Toggles.VisibleCheck.Value
    end)
    Main:AddToggle("Wallbang", {Text = "Wallbang", Tooltip = "Redirects the shot to ignore geometry so it hits the target through walls (hitscan guns).", Default = SilentAimSettings.Wallbang}):OnChanged(function()
        SilentAimSettings.Wallbang = Toggles.Wallbang.Value
    end)
    Main:AddDropdown("TargetPart", {AllowNull = true, Text = "Target Part", Default = SilentAimSettings.TargetPart, Values = {"Head", "HumanoidRootPart", "Random"}}):OnChanged(function()
        SilentAimSettings.TargetPart = Options.TargetPart.Value
    end)
    Main:AddSlider('HitChance', {
        Text = 'Hit chance',
        Default = 100,
        Min = 0,
        Max = 100,
        Rounding = 1,

        Compact = false,
    })
    Options.HitChance:OnChanged(function()
        SilentAimSettings.HitChance = Options.HitChance.Value
    end)
end

local MiscellaneousBOX = GeneralTab:AddLeftTabbox("Miscellaneous")
local FieldOfViewBOX = GeneralTab:AddLeftTabbox("Field Of View") do
    local Main = FieldOfViewBOX:AddTab("Visuals")

    Main:AddToggle("Visible", {Text = "Show FOV Circle"}):AddColorPicker("Color", {Default = Color3.fromRGB(54, 57, 241)}):OnChanged(function()
        fov_circle.Visible = Toggles.Visible.Value
        SilentAimSettings.FOVVisible = Toggles.Visible.Value
    end)
    Main:AddSlider("Radius", {Text = "FOV Circle Radius", Min = 0, Max = 360, Default = 130, Rounding = 0}):OnChanged(function()
        fov_circle.Radius = Options.Radius.Value
        SilentAimSettings.FOVRadius = Options.Radius.Value
    end)
    Main:AddToggle("MousePosition", {Text = "Show Silent Aim Target"}):AddColorPicker("MouseVisualizeColor", {Default = Color3.fromRGB(54, 57, 241)}):OnChanged(function()
        mouse_box.Visible = Toggles.MousePosition.Value and Toggles.aim_Enabled.Value
        mouse_box.Color = Options.MouseVisualizeColor.Value
        SilentAimSettings.ShowSilentAimTarget = Toggles.MousePosition.Value
    end)
    local PredictionTab = MiscellaneousBOX:AddTab("Prediction")
    PredictionTab:AddToggle("Prediction", {Text = "Projectile Lead Prediction", Tooltip = "Only affects projectile weapons (rockets / thrown). Hitscan guns are instant and need no lead."}):OnChanged(function()
        SilentAimSettings.ProjectilePrediction = Toggles.Prediction.Value
    end)
    PredictionTab:AddSlider("Amount", {Text = "Prediction Amount", Min = 0.165, Max = 1, Default = 0.165, Rounding = 3}):OnChanged(function()
        PredictionAmount = Options.Amount.Value
        SilentAimSettings.ProjectilePredictionAmount = Options.Amount.Value
    end)
end

local CreateConfigurationBOX = GeneralTab:AddRightTabbox("Create Configuration") do
    local Main = CreateConfigurationBOX:AddTab("Create Configuration")

    Main:AddInput("CreateConfigTextBox", {Default = "", Numeric = false, Finished = false, Text = "Create Configuration to Create", Tooltip = "Creates a configuration file containing settings you can save and load", Placeholder = "File Name here"}):OnChanged(function()
        if Options.CreateConfigTextBox.Value and string.len(Options.CreateConfigTextBox.Value) ~= 0 then
            FileToSave = Options.CreateConfigTextBox.Value
        end
    end)

    Main:AddButton("Create Configuration File", function()
        if FileToSave ~= "" and FileToSave ~= nil then
            UpdateFile(FileToSave)
        end
    end)
end

local SaveConfigurationBOX = GeneralTab:AddRightTabbox("Save Configuration") do
    local Main = SaveConfigurationBOX:AddTab("Save Configuration")
    Main:AddDropdown("SaveConfigurationDropdown", {AllowNull = true, Values = GetFiles(), Text = "Choose Configuration to Save"})
    Main:AddButton("Save Configuration", function()
        if Options.SaveConfigurationDropdown.Value then
            UpdateFile(Options.SaveConfigurationDropdown.Value)
        end
    end)
end

local LoadConfigurationBOX = GeneralTab:AddRightTabbox("Load Configuration") do
    local Main = LoadConfigurationBOX:AddTab("Load Configuration")

    Main:AddDropdown("LoadConfigurationDropdown", {AllowNull = true, Values = GetFiles(), Text = "Choose Configuration to Load"})
    Main:AddButton("Load Configuration", function()
        if table.find(GetFiles(), Options.LoadConfigurationDropdown.Value) then
            LoadFile(Options.LoadConfigurationDropdown.Value)

            Toggles.TeamCheck:SetValue(SilentAimSettings.TeamCheck)
            Toggles.VisibleCheck:SetValue(SilentAimSettings.VisibleCheck)
            Toggles.Wallbang:SetValue(SilentAimSettings.Wallbang)
            Options.TargetPart:SetValue(SilentAimSettings.TargetPart)
            Toggles.Visible:SetValue(SilentAimSettings.FOVVisible)
            Options.Radius:SetValue(SilentAimSettings.FOVRadius)
            Toggles.MousePosition:SetValue(SilentAimSettings.ShowSilentAimTarget)
            Toggles.Prediction:SetValue(SilentAimSettings.ProjectilePrediction)
            Options.Amount:SetValue(SilentAimSettings.ProjectilePredictionAmount)
            Options.HitChance:SetValue(SilentAimSettings.HitChance)
        end
    end)
end

resume(create(function()
    RenderStepped:Connect(function()
        if Toggles.MousePosition.Value and Toggles.aim_Enabled.Value then
            local part = getTarget()
            if part then
                local root = (part.Parent and part.Parent:IsA("Model") and part.Parent.PrimaryPart) or part
                local ViewportPoint, IsOnScreen = WorldToViewportPoint(Camera, root.Position)

                mouse_box.Visible = IsOnScreen
                mouse_box.Position = Vector2.new(ViewportPoint.X, ViewportPoint.Y)
            else
                mouse_box.Visible = false
                mouse_box.Position = Vector2.new()
            end
        end

        if Toggles.Visible.Value then
            fov_circle.Visible = Toggles.Visible.Value
            fov_circle.Color = Options.Color.Value
            fov_circle.Position = getMousePosition()
        end
    end)
end))

-- hooks
-- Guns are hitscan: DamageService:Bulletcast(self, origin, radius, direction, params, name)
-- and :PierceBulletcast(self, origin, radius, direction, params). We bend `direction` toward
-- the target (preserving its magnitude = weapon range). The cast then returns the target's
-- hitbox, the weapon resolves the player with GetHitTarget and applies damage itself.
--
-- Wallbang: bending the direction alone still lets the cast stop on a wall between the muzzle
-- and the target. When Wallbang is on we swap in a RaycastParams that ONLY includes the target
-- character (Include filter), so the ray ignores all geometry and lands on the target's hitbox.
-- Body damage is applied client-side, so this registers through walls.
local function wallbangParams(character)
    local params = RaycastParams.new()
    params.FilterType = Enum.RaycastFilterType.Include
    params.FilterDescendantsInstances = { character }
    params.RespectCanCollide = false
    params.IgnoreWater = true
    return params
end

-- redirects a hitscan cast at the current target; returns (direction, params) to pass through
local function aimCast(origin, direction, params)
    if typeof(origin) ~= "Vector3" or typeof(direction) ~= "Vector3" or direction.Magnitude == 0 then
        return direction, params
    end
    local part, character = getTarget()
    if not part then return direction, params end

    direction = (part.Position - origin).Unit * direction.Magnitude
    if Toggles.Wallbang and Toggles.Wallbang.Value and character then
        params = wallbangParams(character)
    end
    return direction, params
end

local shouldAim = function()
    return Toggles.aim_Enabled.Value and not checkcaller() and CalculateChance(SilentAimSettings.HitChance)
end

if DamageService then
    local oldBulletcast
    oldBulletcast = hookfunction(DamageService.Bulletcast, newcclosure(function(self, origin, radius, direction, params, name)
        if shouldAim() then
            direction, params = aimCast(origin, direction, params)
        end
        return oldBulletcast(self, origin, radius, direction, params, name)
    end))

    local oldPierce
    oldPierce = hookfunction(DamageService.PierceBulletcast, newcclosure(function(self, origin, radius, direction, params)
        if shouldAim() then
            direction, params = aimCast(origin, direction, params)
        end
        return oldPierce(self, origin, radius, direction, params)
    end))
end

-- Projectile weapons: ProjectileService.NewProjectile(Player, Type, Position, Velocity, ...)
-- Bend the initial Velocity toward the target (preserving speed). Optional linear lead
-- prediction accounts for projectile travel time.
if ProjectileService then
    local oldNewProjectile
    oldNewProjectile = hookfunction(ProjectileService.NewProjectile, newcclosure(function(player, projectileType, position, velocity, ...)
        if shouldAim() and typeof(position) == "Vector3" and typeof(velocity) == "Vector3" and velocity.Magnitude > 0 then
            local part = getTarget()
            if part then
                local aimPoint = part.Position
                if Toggles.Prediction.Value then
                    local targetVelocity = part.AssemblyLinearVelocity
                    local speed = velocity.Magnitude
                    if speed > 0 then
                        local travelTime = (aimPoint - position).Magnitude / speed
                        aimPoint = aimPoint + targetVelocity * (travelTime + PredictionAmount)
                    end
                end
                velocity = (aimPoint - position).Unit * velocity.Magnitude
            end
        end
        return oldNewProjectile(player, projectileType, position, velocity, ...)
    end))
end