Blackhole v5.0 RESCRIPTED

-- [ Blackhole Alpha Release v5.0 RESCRIPTED ]
-- Integrated constraint-based gravity for even smoother simulations
-- Happy 3rd birthday, Blackhole 1.0! :D

local blackHole = script.Parent         -- Reference

-------------------------------------------------------
-- | CONTROL PANEL | -- (See Documentation for info) --
-------------------------------------------------------

-- {GRAVITY} --                         {G}
local gravity = 100                     -- Base gravitational constant
local alignSpeed = 5                    -- How quickly the AlignPosition responds
local forceCap = 4000                   -- Maximum force (constraint cap) Note that math.huge means infinity (for realistic gravity, higher cap = higher accuracy)
local range = 500                       -- Effective range of gravitational pull
local centerOfMassBased = false         -- Toggle force application at center of mass
local realisticGravity = false          -- Toggle inverse square law (closer objects have greater gravity)
local realGravDamping = 32              -- Factor to control gravity when `realisticGravity` is on (higher = faster)
local microGravity = false              -- Disable workspace gravity
local gravityEngine = "linear1"         -- Choose the gravity engine ("linear1", "linear2", "line", "vector", "align", "bodyvelocity", "bodyforce")
local gravitationMode = "universal"     -- "selective" (only tagged objects) vs "universal" (everything)
local attractionTag = "attractable"     -- Tag required if `gravitationMode` is selective

-- {ABSORPTION} --                      {A}
local absorption = true                 -- Absorb objects on contact
local growth = true                     -- Blackhole grows when absorbing objects
local growthDamping = 0.01              -- Damping factor for growth
local fading = true                     -- Fade objects out before absorption
local fadeDuration = 1                  -- Time (in seconds) to fade out
local anchoring = false                 -- Anchor objects when fading
local colorShift = true                 -- Change color of objects as they fade
local color = Color3.fromRGB(255, 0, 0) -- Target color for shifting (red by default)
local rocheFactor = 2                   -- Multiple of blackHole’s size at which non-gravity joints are removed (0 disables)
local merging = true                    -- Allow blackholes to merge

-- {SPECIAL EFFECTS} --                 {S}
local lensing = true                    -- Gravitational lensing effect
local lensingFactor = 2.5               -- Multiplier for the lensing effect’s radius
local lensingStrength = 100             -- Strength of lensing effect (don’t set too high)
local cameraDistortion = true           -- Camera FOV distortion when within range
local distortThreshold = 1              -- Percentage of range for FOV distortion threshold
local blackHoleSound = true             -- Toggle blackhole sound
local distortSound = false              -- Toggle pitch distortion when blackholes are near
local toggleEmitters = true             -- Turn VFX emitters on or off

-- {DEBUGGING} --
local logging = true                    -- Toggle logging output (note that not all errors are taken into account, just most)
local logSettings = true                -- Log detailed settings

------------------------
-- | CORE MECHANICS | --
------------------------

local camera = workspace.Camera     -- For camera distortion effects
local defaultFOV = camera.FieldOfView

-- Track previous size for proportional updates
local previousSize = blackHole.Size.X

-- Table to keep track of active constraints and attachments
local activeGravity = {}
local blackHoleAttachment = Instance.new("Attachment")
blackHoleAttachment.Parent = blackHole

-- Convert string inputs to lowercase for consistency
gravityEngine = gravityEngine:lower()
gravitationMode = gravitationMode:lower()

-- Helper: Clamp distance to a minimum value to avoid division by zero
local function clampDistance(dist)
    local minDist = 1
    return math.max(dist, minDist)
end

-- The master formula for modern gravities *insert angel chorus*
local masterFormula = function(object)
    local distance = (blackHole.Position - object.Position).Magnitude
    local effDist = clampDistance(distance)
    if realGravDamping < 0 then
        realGravDamping = 1 -- Prevent division by 0
    end
    -- Compute the gravitational force using Newtonian physics with conversion
    ------------------------------------------------------------------------------------------------------------
    local computedForce = (gravity * blackHole:GetMass() * object:GetMass()) / ((effDist / realGravDamping) ^ 2) -- ONLY APPLIES TO REALISTIC GRAVITY!
    ------------------------------------------------------------------------------------------------------------
    -- Clamp the force to forceCap so that it never exceeds this maximum
    return math.min(computedForce, forceCap)
end

-- The legacy master formula for bodyforce and bodyvelocity
local legacyMasterFormula = function(object)
    local direction = blackHole.Position - object.Position
    local dist = clampDistance(direction.Magnitude)
    --------------------------------------------------------------------------
    local forceMag = (gravity * blackHole.Size.X * object.Size.X) / (dist ^ 2)
    --------------------------------------------------------------------------
    -- For BodyVelocity, if the object is too close to the blackHole, we nullify the force.
    if dist < blackHole.Size.X / 2 then
        forceMag = 0
    end
    return {
        distance = dist,
        direction = direction.Unit,
        force = forceMag,
    }
end

local whiteHoleMode = false -- secret event hehe
-- doesnt work if you force this to be true haha

-- Function to apply gravity to an object using the selected gravity engine
local function ApplyGravity(object)
    if activeGravity[object] then return end

    local objectAttachment = Instance.new("Attachment")
    objectAttachment.Parent = object

    local distance = (blackHole.Position - object.Position).Magnitude
    local effDist = clampDistance(distance)

    if gravityEngine == "linear1" or gravityEngine == "1.1" or gravityEngine == "linear2" or gravityEngine == "1.2" then
        local linearVel = Instance.new("LinearVelocity")
        linearVel.Attachment0 = objectAttachment
        linearVel.RelativeTo = Enum.ActuatorRelativeTo.World
        linearVel.MaxForce = forceCap

        -- Whitehole mode oh my goodness gracious
        if gravity < 0 then
            whiteHoleMode = true
        end

        if gravityEngine == "linear1" or gravityEngine == "1.1" then
            linearVel.VelocityConstraintMode = Enum.VelocityConstraintMode.Line
            local lineDir = (blackHole.Position - object.Position).Unit
            linearVel.LineDirection = lineDir
            linearVel.LineVelocity = gravity

        elseif gravityEngine == "linear2" or gravityEngine == "1.2" then
            linearVel.VelocityConstraintMode = Enum.VelocityConstraintMode.Vector
            local dist = (blackHole.Position - object.Position).Unit
            if realisticGravity then
                linearVel.VectorVelocity = dist * masterFormula(object)
            else
                local newVelocityMag = (distance > 0) and (gravity / distance) or 0
                linearVel.VectorVelocity = (blackHole.Position - object.Position).Unit * newVelocityMag * gravity
            end
        end

        linearVel.Parent = object
        activeGravity[object] = { constraint = linearVel, attachment = objectAttachment }

        -- LineForce-based gravity
    elseif gravityEngine == "line" or gravityEngine == "2" then
        local lineForce = Instance.new("LineForce")
        lineForce.Attachment0 = objectAttachment
        lineForce.Attachment1 = blackHoleAttachment
        lineForce.ApplyAtCenterOfMass = centerOfMassBased
        lineForce.MaxForce = forceCap

        if gravity < 0 then
            -- Swap attachments to reverse the force direction
            lineForce.MaxForce = -forceCap
            whiteHoleMode = true
        end

        if realisticGravity then
            lineForce.Magnitude = masterFormula(object)
        else
            lineForce.Magnitude = gravity
        end
        lineForce.Parent = object
        activeGravity[object] = { constraint = lineForce, attachment = objectAttachment }

        -- VectorForce-based gravity
    elseif gravityEngine == "vector" or gravityEngine == "3" then
        local vectorForce = Instance.new("VectorForce")
        vectorForce.Attachment0 = objectAttachment
        vectorForce.RelativeTo = Enum.ActuatorRelativeTo.Attachment1

        -- Whitehole mode
        if gravity < 0 then
            whiteHoleMode = true
        end

        if realisticGravity then
            local direction = (blackHole.Position - object.Position).Unit
            vectorForce.Force = direction * masterFormula(object)
        else
            vectorForce.Force = (blackHole.Position - object.Position).Unit * gravity
        end
        vectorForce.ApplyAtCenterOfMass = centerOfMassBased
        vectorForce.Parent = object
        activeGravity[object] = { constraint = vectorForce, attachment = objectAttachment }

        -- AlignPosition-based gravity
    elseif gravityEngine == "align" or gravityEngine == "4" then
        local alignPos = Instance.new("AlignPosition")
        alignPos.Attachment0 = objectAttachment
        alignPos.Attachment1 = blackHoleAttachment
        alignPos.MaxForce = forceCap
        alignPos.MaxVelocity = forceCap
        alignPos.Responsiveness = alignSpeed
        alignPos.ApplyAtCenterOfMass = centerOfMassBased
        alignPos.Parent = object
        activeGravity[object] = { constraint = alignPos, attachment = objectAttachment }

        -- Legacy BodyVelocity-based gravity (does not support models)
        -- The maths are untouched and are exactly identical to v4.0+
    elseif gravityEngine == "bodyvelocity" or gravityEngine == "speed" or gravityEngine == "5" then
        local legacy = legacyMasterFormula(object)
        if legacy.force == 0 then
            return
        end
        object.Velocity = object.Velocity + (legacy.direction * legacy.force)

        -- Whitehole mode
        if gravity < 0 then
            whiteHoleMode = true
        end

        -- Legacy BodyForce-based gravity (supports models)
    elseif gravityEngine == "bodyforce" or gravityEngine == "force" or gravityEngine == "6" then
        local legacy = legacyMasterFormula(object)
        local force = legacy.direction * legacy.force
        local bodyForce = object:FindFirstChild("BlackHoleBodyForce", true)
        if not bodyForce then
            bodyForce = Instance.new("BodyForce")
            bodyForce.Name = "BlackHoleBodyForce"
            bodyForce.Force = force
            bodyForce.Parent = object
        else
            bodyForce.Force = force
        end

        -- Whitehole mode
        if gravity < 0 then
            whiteHoleMode = true
        end
    end
end

-- Remove gravity constraints from an object
local function RemoveGravity(object)
    local data = activeGravity[object]
    if data then
        data.constraint:Destroy()
        data.attachment:Destroy()
        activeGravity[object] = nil
    end
end

-- Function to grow the black hole when it absorbs an object
local function GrowBlackHole(object)
    if growth and object:IsA("BasePart") then
        local avgSize = (object.Size.X + object.Size.Y + object.Size.Z) / 3
        local growthFactor = (1 / avgSize) * growthDamping
        blackHole.Size = blackHole.Size + Vector3.new(growthFactor, growthFactor, growthFactor)
        range = range + growthFactor
        gravity = gravity + growthFactor
        if gravity < 0 then gravity = gravity - growthFactor end
        blackHole:FindFirstChild("BlackholeSound", true).RollOffMinDistance = range
    end
end

-- Function to absorb (and remove) an object
local function AbsorbObject(object)
    if growth then
        GrowBlackHole(object)
    end
    RemoveGravity(object)
    object:Destroy()
end

local CollectionService = game:GetService("CollectionService")

-- Event listener for absorption on contact
if absorption then
    blackHole.Touched:Connect(function(hit)
        if hit:IsA("BasePart") and hit ~= blackHole then
            -- Merging logic for blackholes
            if merging and CollectionService:HasTag(hit, "Blackholev5") then
                local otherBlackHole = hit
                local currentSize = blackHole.Size.X
                local otherSize = otherBlackHole.Size.X
                if currentSize < otherSize then
                    local newSize = otherSize + currentSize
                    otherBlackHole.Size = Vector3.new(newSize, newSize, newSize)
                    if otherBlackHole:FindFirstChild("FX") and otherBlackHole:FindFirstChild("BlackholeSound", true) then
                        otherBlackHole:FindFirstChild("BlackholeSound", true).RollOffMaxDistance = otherBlackHole:FindFirstChild("BlackholeSound", true).RollOffMaxDistance + currentSize
                    end
                    blackHole:Destroy()
                elseif currentSize > otherSize then
                    local newSize = currentSize + otherSize
                    blackHole.Size = Vector3.new(newSize, newSize, newSize)
                    if blackHole:FindFirstChild("FX") and blackHole:FindFirstChild("BlackholeSound", true) then
                        otherBlackHole:FindFirstChild("BlackholeSound", true).RollOffMaxDistance = otherBlackHole:FindFirstChild("BlackholeSound", true).RollOffMaxDistance + otherSize
                    end
                    otherBlackHole:Destroy()
                else
                    local newSize = currentSize * 2
                    blackHole.Size = Vector3.new(newSize, newSize, newSize)
                    if blackHole:FindFirstChild("FX") and blackHole:FindFirstChild("BlackholeSound", true) then
                        otherBlackHole:FindFirstChild("BlackholeSound", true).RollOffMaxDistance = otherBlackHole:FindFirstChild("BlackholeSound", true).RollOffMaxDistance * 2
                    end
                    otherBlackHole:Destroy()
                end
                return
            end

            -- Normal absorption for non-blackhole objects
            if not hit.Anchored then
                if absorption then
                    if fading then
                        hit.Anchored = anchoring
                        hit.CanCollide = false
                        local startTransparency = hit.Transparency
                        local initialColor = hit.Color
                        local elapsed = 0
                        local heartbeat = game:GetService("RunService").Heartbeat
                        local connection
                        connection = heartbeat:Connect(function(delta)
                            elapsed = elapsed + delta
                            local progress = math.min(elapsed / fadeDuration, 1)
                            hit.Transparency = startTransparency + (1 - startTransparency) * progress
                            if colorShift then
                                hit.Color = initialColor:Lerp(color, progress)
                            end
                            if progress >= 1 then
                                connection:Disconnect()
                                AbsorbObject(hit)
                            end
                        end)
                    else
                        AbsorbObject(hit)
                    end
                end
            end
        end
    end)
end

if microGravity then
    workspace.Gravity = 0
end

-- Blackhole sound setup
if blackHoleSound then
    blackHole:FindFirstChild("BlackholeSound", true).Playing = true
    blackHole:FindFirstChild("BlackholeSound", true).RollOffMaxDistance = range
end

-- Glint VFX
if toggleEmitters then
    blackHole:FindFirstChild("Glint", true).Enabled = true
else
    blackHole:FindFirstChild("Glint", true).Enabled = false
end

-- Whitehole mode (if negative gravity/growth damping)
if gravity < 0 and (gravityEngine == "linear1" or gravityEngine == "linear2" or gravityEngine == "1.1" or gravityEngine == "1.2" or gravityEngine == "line" or
    gravityEngine == "2" or gravityEngine == "vector" or gravityEngine == "3" or gravityEngine == "bodyvelocity" or gravityEngine == "5" or gravityEngine == "bodyforce" or
    gravityEngine == "6") then
    local pureWhite = Color3.fromRGB(255, 255, 255)
    blackHole:FindFirstChild("EventHorizon", true).FillColor = pureWhite
    blackHole:FindFirstChild("EventHorizon", true).OutlineColor = pureWhite
    blackHole:FindFirstChild("Glint", true).Color = ColorSequence.new(pureWhite)
    blackHole:FindFirstChild("AccretionLight", true).Color = pureWhite
    blackHole:FindFirstChild("Sparks", true).Enabled = toggleEmitters
    blackHole:FindFirstAncestorWhichIsA("Model").Name = "Whitehole v5 Alpha"
    blackHole.Color = pureWhite
    blackHole.Name = "Whitehole_v5"
    blackHole.CastShadow = false
    absorption = false
    cameraDistortion = false
    distortSound = false
    whiteHoleMode = true
end

-- Lensing effect setup
if lensing then
    local lensingPart = blackHole.Parent:FindFirstChild("Lensing", true)
    if lensingPart then
        if gravity < 0 then
            lensingPart.Size = Vector3.new(0, 0, 0)
        else
            lensingPart.Size = blackHole.Size * lensingFactor
            lensingPart.Transparency = lensingStrength
            if lensingPart.Transparency < 15 then
                lensingPart.Lensing.Adornee = lensingPart.LensingAttachment
            else
                lensingPart.Lensing.Adornee = lensingPart
            end
        end
    end
else
    local lensingPart = blackHole.Parent:FindFirstChild("Lensing", true)
    if lensingPart then
        lensingPart:Destroy()
    end
end

-- Cache initial values (run once)
local initialBlackHoleSize = blackHole.Size.X
local initialGlintSize, initialSparksSize

local fx = blackHole:FindFirstChild("FX")
if fx then
    local glint = fx:FindFirstChild("Glint")
    if glint and glint.Size and #glint.Size.Keypoints > 0 then
        initialGlintSize = glint.Size.Keypoints[1].Value
    end
    local sparks = fx:FindFirstChild("Sparks")
    if sparks and sparks.Size and #sparks.Size.Keypoints > 0 then
        initialSparksSize = sparks.Size.Keypoints[1].Value
    end
end

-- Main update loop
game:GetService("RunService").Heartbeat:Connect(function()
    -- Apply or remove gravity for parts in the workspace
    for _, object in pairs(workspace:GetDescendants()) do
        if object:IsA("BasePart") and object ~= blackHole and not object.Anchored then
            local distance = (blackHole.Position - object.Position).Magnitude
            local hasTag = CollectionService:HasTag(object, attractionTag)
            if (gravitationMode == "selective" and hasTag and distance <= range) or (gravitationMode == "universal" and distance <= range and
                not CollectionService:HasTag(object, "BHcosmetic")) then
                ApplyGravity(object)
            else
                RemoveGravity(object)
            end
        elseif activeGravity[object] then
            RemoveGravity(object)
        end
    end

    -- Update active gravity constraints so they always point toward the black hole
    for object, data in pairs(activeGravity) do
        local distance = (blackHole.Position - object.Position).Magnitude
        if object:IsDescendantOf(workspace) and distance <= range then
            local newDir = (blackHole.Position - object.Position).Unit
            local effDist = clampDistance(distance)

            if data.constraint:IsA("VectorForce") then
                if realisticGravity then
                    data.constraint.Force = newDir * masterFormula(object)
                else
                    data.constraint.Force = newDir * gravity
                end
            elseif data.constraint:IsA("LinearVelocity") then
                if data.constraint.VelocityConstraintMode == Enum.VelocityConstraintMode.Line then
                    data.constraint.LineDirection = newDir
                    if realisticGravity then
                        data.constraint.LineVelocity = masterFormula(object)
                    else
                        data.constraint.LineVelocity = gravity
                    end
                else
                    local newVelocityMag = masterFormula(object) or 0
                    data.constraint.VectorVelocity = newDir * newVelocityMag
                end
            elseif data.constraint:IsA("LineForce") then
                if realisticGravity then
                    data.constraint.Magnitude = masterFormula(object)
                else
                    data.constraint.Magnitude = gravity
                end
            elseif data.constraint:IsA("BodyVelocity") then
                local direction = blackHole.Position - object.Position
                local dist = clampDistance(direction.Magnitude)
                local forceMag = (gravity * blackHole.Size.X * object.Size.X) / (dist ^ 2)
                data.constraint.Velocity = object.Velocity + (direction.Unit * forceMag)
            end
        end
    end

    -- Remove non-gravity constraints/joints from objects within the Roche radius
    local rocheRadius = rocheFactor * blackHole.Size.X
    if rocheRadius >= blackHole.Size.X then
        for _, object in pairs(workspace:GetDescendants()) do
            if object:IsA("BasePart") and object ~= blackHole then
                local dist = (blackHole.Position - object.Position).Magnitude
                if dist <= rocheRadius and not CollectionService:HasTag(object, "BHcosmetic") then
                    for _, child in pairs(object:GetChildren()) do
                        if child:IsA("Constraint") then
                            if not (activeGravity[object] and activeGravity[object].constraint == child) then
                                local cname = child.ClassName
                                if cname ~= "LinearVelocity" and cname ~= "LineForce" and cname ~= "VectorForce" and cname ~= "AlignPosition" then
                                    child:Destroy()
                                end
                            end
                        elseif child:IsA("JointInstance") then
                            child:Destroy()
                        end
                    end
                end
            end
        end
    end

    -- Camera distortion effect
    if cameraDistortion and camera then
        local camPos = camera.CFrame.Position
        local distance = (blackHole.Position - camPos).Magnitude
        local newFOV
        if distance >= range then
            newFOV = defaultFOV
        elseif distance <= range * (distortThreshold / 100) then
            newFOV = 120
        else
            local t = (range - distance) / (range - distortThreshold)
            newFOV = defaultFOV + t * (120 - defaultFOV)
        end
        camera.FieldOfView = newFOV
    end

    -- Sound pitch distortion effect for nearby blackholes
    if distortSound then
        local closestDist = math.huge
        for _, bh in pairs(CollectionService:GetTagged("Blackholev5")) do
            if bh ~= blackHole and bh:IsDescendantOf(workspace) then
                local d = (blackHole.Position - bh.Position).Magnitude
                if d < closestDist then
                    closestDist = d
                end
            end
        end
        local newPitch = 1
        if closestDist < math.huge then
            if closestDist <= range / 2 then
                newPitch = 1 - (closestDist / range)
            else
                newPitch = 1
            end
        end
        local pitchEffect = blackHole:FindFirstChild("BlackholeSound", true).PitchDistortion
        if pitchEffect then
            pitchEffect.Octave = newPitch
        end
    end

    -- Update Glint and Sparks emitters, range, sound, and lensing based on blackHole size changes
    local currentSize = blackHole.Size.X
    if currentSize > previousSize then  -- only update when growing
        local scaleFactor = currentSize / initialBlackHoleSize

        if fx then
            -- Update Glint emitter size based on the original size
            local glint = fx:FindFirstChild("Glint")
            if glint then
                glint.Size = NumberSequence.new(initialGlintSize * scaleFactor)
            end
            -- Update Sparks emitter size based on the original size
            local sparks = fx:FindFirstChild("Sparks")
            if sparks then
                sparks.Size = NumberSequence.new(initialSparksSize * scaleFactor)
            end
            -- Lensing effect update
            if lensing then
                local lensingPart = blackHole.Parent:FindFirstChild("Lensing", true)
                if lensingPart then
                    lensingPart.Size = blackHole.Size * lensingFactor
                end
            end
        end
        -- You can update other properties (range, sound, etc.) as before
        range = range * (currentSize / previousSize)
        blackHole:FindFirstChild("BlackholeSound", true).RollOffMaxDistance = range

        previousSize = currentSize
    end
end)

-- Logging and error handling. Its all on me, dont worry
if logging then
    local gE = gravityEngine
    local gM = gravitationMode
    local aT = attractionTag
    print("{-- | Blackhole v5 Alpha Logger | --}")
    if gE == "linear1" or gE == "1.1" or gE == "linear2" or gE == "1.2" then
        print("{BHv5: Running LinearVelocity gravity}")
    elseif gE == "line" or gE == "2" then
        print("{BHv5: Running LineForce gravity}")
    elseif gE == "vector" or gE == "3" then
        print("{BHv5: Running VectorForce gravity}")
    elseif gE == "align" or gE == "4" then
        print("{BHv5: Running AlignPosition gravity}")
    elseif gE == "bodyvelocity" or gE == "speed" or gE == "5" then
        print("{BHv5: Running LEGACY BodyVelocity gravity}")
        print("{   BodyVelocity is unstable but accurate. It does NOT support models!}")
        print("{   Consider this when running it}")
    elseif gE == "bodyforce" or gE == "force" or gE == "6" then
        print("{BHv5: Running LEGACY BodyForce gravity}")
        print("{   BodyVelocity is stable but inaccurate. This supports models}")
        print("{   Consider this when running it}")
    else
        warn("{BHv5: Unrecognised gravity engine: '" .. tostring(gE) .. "'")
        warn("{   Switching to default gravity}")
        gravityEngine = "1.1"
    end
    if gM == "universal" or gM == "selective" then
        print("{BHv5: Set to " .. tostring(gM:upper()) .. " gravitation}")
    else
        warn("{BHv5: Unrecognised mode: '" .. tostring(gM) .. "'")
        warn("{   Setting to default gravitation mode}")
        gravitationMode = "universal"
    end
    print("{BHv5: Current attraction tag is '" .. tostring(aT) .. "'}")
    if logSettings then
        print("{v5 Settings}")
        print("{G  Current gravity is " .. tostring(gravity) .. "}")
        if whiteHoleMode == true then warn("{G  Blackhole has negative gravity! (whitehole mode)}") blackHole.Parent:FindFirstChild("Lensing", true):Destroy() end
        if range < 0 then warn("{G  Range cannot be less than 0! Please enter a positive integer}") else print("{G  Initial range is " .. tostring(range) .. "}") end
        if gE == "align" or gE == "4" then
            print("{G  Aligning speed is " .. tostring(alignSpeed) .. "}")
        end
        if realisticGravity then print("{G  Realistic gravity is Enabled}") else
            print("{G  Realistic gravity is Disabled}")
        end
        if realGravDamping < 0 then warn("{G  Realistic Gravity Damping cannot be less than zero! (set to 1)}") end
        if microGravity then print("{G  Workspace gravity is Disabled}") else
            print("{G  Workspace gravity is Enabled}")
        end
        if absorption then print("{A  Absorption is Enabled}") else
            print("{A  Absorption is Disabled}")
        end
        if growth then print("{A  The blackhole can grow with a damping of " .. tostring(growthDamping) .. "}") else
            print("{A  The Blackhole cannot grow}")
        end
        local sT = " seconds}"
        if fadeDuration == 1 then sT = " second}" else sT = " seconds}" end
        if fading then
            print("{A  Absorbed objects can fade out for " .. tostring(fadeDuration) .. sT)
            if colorShift then print("{A  Objects shift in color when fading}") else
                print("{A  Objects do not shift in color when fading}")
            end
        else
            print("{A  Absorbed objects do not fade out, therefore it cannot shift in color}")
        end
        if anchoring then print("{A  Objects freeze when fading}") else
            print("{A  Objects do not freeze when fading}")
        end
        print("{A  Fragmentation occurs at " .. tostring(rocheFactor) .. "x the blackhole's radius}")
        if merging then print("{A  Blackholes can merge}") else
            print("{A  Blackholes cannot merge}")
        end
        if lensing then print("{S  Light is bent within " .. tostring(lensingFactor) .. "x the blackhole's radius with an intensity of " .. tostring(lensingStrength .. "}")) else
            print("{S  Light is not bent around the blackhole}")
        end
        if cameraDistortion then print("{S  FOV is alterable within range until " .. tostring(distortThreshold) .. "% of it (in editor/server mode)}") else
            print("{S  FOV is not altered within range}")
        end
        if blackHoleSound then print("{S  The blackhole has sound}") else
            print("{S  The blackhole does not have sound}")
        end
        if distortSound then print("{S  The blackhole sound is alterable within range [BETA]}") else
            print("{S  The blackhole sound is not alterable}")
        end
        if toggleEmitters then print("{S  Visual effects are Enabled}") else print("{S  Visual effects are Disabled}") end
        print("{S  Glint size should be proportional as long as the blackhole is a model}")
    else
        print("{BHv5: Settings report is disabled}")
    end
    print("{Programming by zaragosa126}")
end