-- [[ SHADOW CORE V9: ZERO DELAY ]] --
-- Ultra-responsive AlignPosition with instant reaction

local plr = game.Players.LocalPlayer
local char = plr.Character or plr.CharacterAdded:Wait()
local hrp = char:WaitForChild("HumanoidRootPart")
local hum = char:WaitForChild("Humanoid")
local run = game:GetService("RunService")
local uis = game:GetService("UserInputService")
local tools_storage = {}

-- [[ ОПТИМАЛЬНЫЕ НАСТРОЙКИ ДЛЯ НУЛЕВОЙ ЗАДЕРЖКИ ]] --
local config = {
    scale = 1.2,
    height = 4,
    speed = 2,
    
    -- CRITICAL: Physics Settings для минимальной задержки
    responsiveness = 200,      -- MAX значение (было 200)
    maxVelocity = math.huge,   -- Без ограничений
    maxForce = math.huge,      -- Максимальная сила
    rigidityEnabled = true,    -- ВКЛЮЧЕНО для жесткой связи
    
    -- Visual FX
    trailEnabled = true,
    glowEnabled = true,
    rainbowMode = false,
    
    -- Combat
    autoTarget = false,
    flingPower = 200,
    rageMode = false,
    
    currentFormation = "sword"
}

-- [[ FORMATIONS ]] --
local formations = {
    sword = function(i, num, t)
        local pHandle = math.floor(num * 0.15)
        local pGuard = math.floor(num * 0.20)
        local x, y = 0, 0
        
        if i <= pHandle then
            x = 0
            y = (i / pHandle) * 2
        elseif i <= pHandle + pGuard then
            local prog = (i - pHandle) / pGuard
            x = (prog - 0.5) * 4
            y = 2
        else
            local remaining = num - (pHandle + pGuard)
            local prog = (i - (pHandle + pGuard)) / remaining
            local width = 0.8 * (1 - prog)
            x = (i % 2 == 0 and width or -width)
            y = 2 + (prog * 12)
        end
        
        return Vector3.new(x, y, 0)
    end,
    
    tornado = function(i, num, t)
        local angle = (i / num) * math.pi * 2
        local height = (i / num) * 10
        local radius = 3 + math.sin(t * 2 + height) * 0.5
        
        return Vector3.new(
            math.cos(angle + t * 3) * radius,
            height,
            math.sin(angle + t * 3) * radius
        )
    end,
    
    shield = function(i, num, t)
        local layers = 3
        local layer = math.floor((i - 1) / (num / layers))
        local radius = 2 + layer * 1.5
        local itemsInLayer = math.ceil(num / layers)
        local angleStep = (math.pi * 2) / itemsInLayer
        local angle = ((i - 1) % itemsInLayer) * angleStep + t
        
        return Vector3.new(
            math.cos(angle) * radius,
            2 + math.sin(t * 2 + i) * 0.3,
            math.sin(angle) * radius
        )
    end,
    
    orbit = function(i, num, t)
        local angle = (i / num) * math.pi * 2
        local radius = 4
        
        return Vector3.new(
            math.cos(angle + t * 2) * radius,
            2 + math.sin(t * 4 + angle) * 1,
            math.sin(angle + t * 2) * radius
        )
    end
}

-- [[ СБОР ИНСТРУМЕНТОВ ]] --
for _, v in pairs(plr.Backpack:GetChildren()) do
    if v:IsA("Tool") then v.Parent = char end
end
task.wait(0.2)

-- [[ ИНИЦИАЛИЗАЦИЯ С ZERO-DELAY ФИЗИКОЙ ]] --
for _, v in pairs(char:GetChildren()) do
    if v:IsA("Tool") and v:FindFirstChild("Handle") then
        local h = v.Handle
        
        -- КРИТИЧНО: Минимизация массы и трения
        h.Massless = true
        h.CustomPhysicalProperties = PhysicalProperties.new(
            0.001,  -- Минимальная плотность
            0,      -- Нулевое трение
            0,      -- Нулевая эластичность
            0,      -- Нулевое сопротивление трения
            0       -- Нулевой вес
        )
        v.CanBeDropped = true
        
        local att0 = Instance.new("Attachment", h)
        local att1 = Instance.new("Attachment", hrp)
        
        -- ULTRA-RESPONSIVE AlignPosition
        local alignPos = Instance.new("AlignPosition", h)
        alignPos.Attachment0 = att0
        alignPos.Attachment1 = att1
        alignPos.MaxForce = math.huge
        alignPos.MaxVelocity = math.huge
        alignPos.Responsiveness = config.responsiveness  -- 200 = мгновенно
        alignPos.RigidityEnabled = config.rigidityEnabled  -- TRUE для жесткой связи
        alignPos.ReactionForceEnabled = false  -- Отключаем обратную реакцию для перфа
        alignPos.ApplyAtCenterOfMass = true   -- Применяем силу в центре масс
        
        -- ULTRA-RESPONSIVE AlignOrientation
        local alignRot = Instance.new("AlignOrientation", h)
        alignRot.Attachment0 = att0
        alignRot.Attachment1 = att1
        alignRot.MaxTorque = math.huge
        alignRot.MaxAngularVelocity = math.huge
        alignRot.Responsiveness = 200  -- Максимум
        alignRot.RigidityEnabled = true  -- Жесткая ротация
        alignRot.ReactionTorqueEnabled = false
        alignRot.PrimaryAxisOnly = false
        
        -- Visual FX
        local trail, glow
        
        if config.trailEnabled then
            trail = Instance.new("Trail", h)
            trail.Attachment0 = Instance.new("Attachment", h)
            trail.Attachment1 = Instance.new("Attachment", h)
            trail.Attachment1.Position = Vector3.new(0, 0, 1)
            trail.Lifetime = 0.3
            trail.MinLength = 0.05
            trail.Color = ColorSequence.new(Color3.fromRGB(255, 0, 0), Color3.fromRGB(0, 255, 255))
            trail.Transparency = NumberSequence.new(0.2, 1)
        end
        
        if config.glowEnabled then
            glow = Instance.new("PointLight", h)
            glow.Brightness = 2
            glow.Range = 10
            glow.Color = Color3.fromRGB(255, 100, 255)
        end
        
        local z_layer = math.random(-100, 100) / 10000
        
        local entry = {
            tool = v,
            handle = h,
            target = att1,
            layer = z_layer,
            components = {att0, att1, alignPos, alignRot},
            fx = {trail = trail, glow = glow}
        }
        table.insert(tools_storage, entry)
        
        v.AncestryChanged:Connect(function(_, newParent)
            if newParent ~= char then
                for _, comp in pairs(entry.components) do
                    pcall(function() comp:Destroy() end)
                end
                if h then h.CanCollide = true end
            end
        end)
    end
end

if char:FindFirstChild("RightHand") then 
    char.RightHand:Destroy()
elseif char:FindFirstChild("Right Arm") then
    local weld = char["Right Arm"]:FindFirstChild("RightGrip")
    if weld then weld:Destroy() end
end

-- [[ AUTO-TARGET ]] --
local currentTarget = nil

local function getClosestPlayer()
    local closest = nil
    local minDist = math.huge
    
    for _, p in pairs(game.Players:GetPlayers()) do
        if p ~= plr and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
            local dist = (p.Character.HumanoidRootPart.Position - hrp.Position).Magnitude
            if dist < minDist and dist < 50 then
                minDist = dist
                closest = p.Character.HumanoidRootPart
            end
        end
    end
    
    return closest
end

-- [[ PHYSICS LOOP - Optimized ]] --
local physics_loop = run.Heartbeat:Connect(function()
    pcall(function()
        setsimulationradius(math.huge, math.huge)
        plr.MaximumSimulationRadius = math.huge
    end)
    
    if config.autoTarget then
        currentTarget = getClosestPlayer()
        if currentTarget and config.rageMode then
            hrp.CFrame = CFrame.new(hrp.Position, currentTarget.Position)
        end
    end
    
    for _, data in pairs(tools_storage) do
        if data.handle and data.handle.Parent then
            -- NETLESS Velocity
            data.handle.AssemblyLinearVelocity = Vector3.new(25.5, 0, 0)
            
            -- Ghost Mode
            data.handle.CanCollide = false
            data.handle.CanTouch = false
            data.handle.CanQuery = false
            
            -- Fling Attack
            if config.rageMode and currentTarget then
                local dir = (currentTarget.Position - data.handle.Position).Unit
                data.handle.AssemblyLinearVelocity = dir * config.flingPower
            end
        end
    end
end)

-- [[ ANIMATION LOOP - RenderStepped для минимальной задержки ]] --
local rotation = 0
local time = 0

local anim_loop = run.RenderStepped:Connect(function(dt)
    if not char or not hrp then return end
    
    rotation = rotation + config.speed * dt
    time = time + dt
    local num = #tools_storage
    
    local formationFunc = formations[config.currentFormation] or formations.sword
    
    for i, data in pairs(tools_storage) do
        local localPos = formationFunc(i, num, time)
        
        localPos = localPos * config.scale
        localPos = localPos + Vector3.new(0, config.height, data.layer)
        
        local rotatedPos = CFrame.Angles(0, rotation, 0) * localPos
        
        if data.target then
            data.target.Position = rotatedPos
            data.target.Rotation = Vector3.new(0, math.deg(rotation), 90)
        end
        
        if config.rainbowMode and data.fx.glow then
            local hue = (time + i / num) % 1
            data.fx.glow.Color = Color3.fromHSV(hue, 1, 1)
        end
    end
end)

-- [[ HOTKEYS ]] --
uis.InputBegan:Connect(function(input, gpe)
    if gpe then return end
    
    if input.KeyCode == Enum.KeyCode.R then
        config.rageMode = not config.rageMode
        game.StarterGui:SetCore("SendNotification", {
            Title = "RAGE MODE";
            Text = config.rageMode and "ENABLED" or "DISABLED";
            Duration = 2;
        })
    elseif input.KeyCode == Enum.KeyCode.T then
        config.autoTarget = not config.autoTarget
        game.StarterGui:SetCore("SendNotification", {
            Title = "AUTO-TARGET";
            Text = config.autoTarget and "ENABLED" or "DISABLED";
            Duration = 2;
        })
    elseif input.KeyCode == Enum.KeyCode.F then
        local formations_list = {"sword", "tornado", "shield", "orbit"}
        local currentIdx = table.find(formations_list, config.currentFormation) or 1
        currentIdx = (currentIdx % #formations_list) + 1
        config.currentFormation = formations_list[currentIdx]
        
        game.StarterGui:SetCore("SendNotification", {
            Title = "FORMATION";
            Text = config.currentFormation:upper();
            Duration = 2;
        })
    elseif input.KeyCode == Enum.KeyCode.V then
        config.rainbowMode = not config.rainbowMode
    end
end)

-- [[ CLEANUP ]] --
hum.Died:Connect(function()
    if anim_loop then anim_loop:Disconnect() end
    if physics_loop then physics_loop:Disconnect() end
    
    for _, data in pairs(tools_storage) do
        for _, comp in pairs(data.components) do
            pcall(function() comp:Destroy() end)
        end
        if data.handle then data.handle.CanCollide = true end
    end
    script:Destroy()
end)

game.StarterGui:SetCore("SendNotification", {
    Title = "SHADOW CORE V9: ZERO DELAY";
    Text = "Ultra-Responsive Physics | R=Rage | T=Target | F=Form";
    Duration = 7;
})