-- [[ Rscripts Risk Notice ]]
-- This script is not verified by rscripts.net. 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 Rscripts Risk Notice ]]

--[[rscripts:analytics:start]]
-- Script analytics (enabled by the creator on rscripts.net).
-- Runs in its own thread and cannot affect the script below.
task.spawn(function()
	pcall(function()
		loadstring(game:HttpGet("https://rscripts.net/api/telemetry/v2/client.lua?s=6aafa7dfb88b1e836bd2c2ef"))()
	end)
end)
--[[rscripts:analytics:end]]

--// FIXATION - AUTO DODGE DUPLO + DIAGNÓSTICO
--// Monitora:
--// 1) rbxassetid://128555110265250
--// 2) rbxassetid://75042172549461

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local LocalPlayer = Players.LocalPlayer

--==================================================
-- CONFIGURAÇÃO
--==================================================

local ATTACK_ANIMATIONS = {
    ["rbxassetid://128555110265250"] = true,
    ["rbxassetid://75042172549461"] = true
}

local DetectionRange = 12
local AutoDodge = false
local ANIMATION_DEBOUNCE = 0.02

local DODGE_ATTEMPTS = {
    0,
    0.035,
    0.070,
    0.105
}

local DIAGNOSTIC_TIME = 1.5
local MONITOR_INTERVAL = 0.01

--==================================================
-- REMOTES
--==================================================

local Fixation = ReplicatedStorage:WaitForChild("Fixation")
local Remotes = Fixation:WaitForChild("Remotes")

local DodgeAttempt = Remotes:WaitForChild("DodgeAttempt")
local CombatVFX = Remotes:WaitForChild("CombatVFX")

--==================================================
-- CHARACTER
--==================================================

local Character = LocalPlayer.Character or LocalPlayer.CharacterAdded:Wait()
local Humanoid = Character:WaitForChild("Humanoid")

LocalPlayer.CharacterAdded:Connect(function(char)
    Character = char
    Humanoid = char:WaitForChild("Humanoid")
end)

--==================================================
-- VARIÁVEIS
--==================================================

local NikkiCharacter = nil
local NikkiHumanoid = nil
local NikkiAnimator = nil

local AnimatorConnection = nil
local CharacterConnection = nil
local CombatConnection = nil

local LastAttackTime = 0
local AttackNumber = 0
local ProcessedTracks = {}
local CurrentDiagnostic = nil

--==================================================
-- GUI
--==================================================

local ScreenGui = Instance.new("ScreenGui")
ScreenGui.Name = "FixationAutoDodgeGUI"
ScreenGui.ResetOnSpawn = false
ScreenGui.Parent = game:GetService("CoreGui")

local Main = Instance.new("Frame")
Main.Size = UDim2.new(0, 280, 0, 200)
Main.Position = UDim2.new(0.5, -140, 0.5, -100)
Main.BackgroundColor3 = Color3.fromRGB(25, 25, 25)
Main.BorderSizePixel = 0
Main.Active = true
Main.Draggable = true
Main.Parent = ScreenGui

local Corner = Instance.new("UICorner")
Corner.CornerRadius = UDim.new(0, 8)
Corner.Parent = Main

local Title = Instance.new("TextLabel")
Title.Size = UDim2.new(1, 0, 0, 35)
Title.BackgroundTransparency = 1
Title.Text = "FIXATION - AUTO DODGE"
Title.TextColor3 = Color3.fromRGB(255, 255, 255)
Title.TextSize = 16
Title.Font = Enum.Font.SourceSansBold
Title.Parent = Main

--==================================================
-- TOGGLE
--==================================================

local Toggle = Instance.new("TextButton")
Toggle.Size = UDim2.new(0, 240, 0, 35)
Toggle.Position = UDim2.new(0, 20, 0, 45)
Toggle.BackgroundColor3 = Color3.fromRGB(60, 60, 60)
Toggle.Text = "AUTO DODGE: OFF"
Toggle.TextColor3 = Color3.fromRGB(255, 255, 255)
Toggle.TextSize = 14
Toggle.Font = Enum.Font.SourceSansBold
Toggle.Parent = Main

local ToggleCorner = Instance.new("UICorner")
ToggleCorner.CornerRadius = UDim.new(0, 6)
ToggleCorner.Parent = Toggle

--==================================================
-- RANGE LABEL
--==================================================

local RangeLabel = Instance.new("TextLabel")
RangeLabel.Size = UDim2.new(1, -40, 0, 25)
RangeLabel.Position = UDim2.new(0, 20, 0, 90)
RangeLabel.BackgroundTransparency = 1
RangeLabel.Text = "Range: 12"
RangeLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
RangeLabel.TextSize = 14
RangeLabel.Font = Enum.Font.SourceSans
RangeLabel.TextXAlignment = Enum.TextXAlignment.Left
RangeLabel.Parent = Main

--==================================================
-- SLIDER
--==================================================

local SliderBackground = Instance.new("Frame")
SliderBackground.Size = UDim2.new(0, 240, 0, 8)
SliderBackground.Position = UDim2.new(0, 20, 0, 120)
SliderBackground.BackgroundColor3 = Color3.fromRGB(70, 70, 70)
SliderBackground.BorderSizePixel = 0
SliderBackground.Parent = Main

local SliderCorner = Instance.new("UICorner")
SliderCorner.CornerRadius = UDim.new(1, 0)
SliderCorner.Parent = SliderBackground

local SliderButton = Instance.new("TextButton")
SliderButton.Size = UDim2.new(0, 16, 0, 16)
SliderButton.Position =
    UDim2.new((DetectionRange - 1) / 29, -8, 0.5, -8)
SliderButton.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
SliderButton.Text = ""
SliderButton.Parent = SliderBackground

local SliderButtonCorner = Instance.new("UICorner")
SliderButtonCorner.CornerRadius = UDim.new(1, 0)
SliderButtonCorner.Parent = SliderButton

--==================================================
-- STATUS
--==================================================

local StatusLabel = Instance.new("TextLabel")
StatusLabel.Size = UDim2.new(1, -40, 0, 35)
StatusLabel.Position = UDim2.new(0, 20, 0, 145)
StatusLabel.BackgroundTransparency = 1
StatusLabel.Text = "Diagnóstico: OFF"
StatusLabel.TextColor3 = Color3.fromRGB(180, 180, 180)
StatusLabel.TextSize = 13
StatusLabel.Font = Enum.Font.SourceSans
StatusLabel.TextXAlignment = Enum.TextXAlignment.Left
StatusLabel.TextWrapped = true
StatusLabel.Parent = Main

--==================================================
-- SLIDER CONTROLE
--==================================================

local draggingSlider = false

local function updateSlider(inputX)
    local absolutePosition =
        SliderBackground.AbsolutePosition.X

    local absoluteSize =
        SliderBackground.AbsoluteSize.X

    local percent = math.clamp(
        (inputX - absolutePosition) / absoluteSize,
        0,
        1
    )

    DetectionRange =
        math.floor(1 + percent * 29 + 0.5)

    RangeLabel.Text =
        "Range: " .. DetectionRange

    SliderButton.Position =
        UDim2.new(
            percent,
            -8,
            0.5,
            -8
        )
end

SliderBackground.InputBegan:Connect(function(input)
    if input.UserInputType ==
        Enum.UserInputType.MouseButton1
    then
        draggingSlider = true
        updateSlider(input.Position.X)
    end
end)

SliderButton.InputBegan:Connect(function(input)
    if input.UserInputType ==
        Enum.UserInputType.MouseButton1
    then
        draggingSlider = true
    end
end)

UserInputService.InputChanged:Connect(function(input)
    if
        draggingSlider
        and input.UserInputType ==
            Enum.UserInputType.MouseMovement
    then
        updateSlider(input.Position.X)
    end
end)

UserInputService.InputEnded:Connect(function(input)
    if input.UserInputType ==
        Enum.UserInputType.MouseButton1
    then
        draggingSlider = false
    end
end)

--==================================================
-- CÍRCULO 3D
--==================================================

local CircleFolder = Instance.new("Folder")
CircleFolder.Name = "AutoDodgeRange"
CircleFolder.Parent = workspace

local CircleParts = {}
local CIRCLE_SEGMENTS = 48

for i = 1, CIRCLE_SEGMENTS do
    local part = Instance.new("Part")

    part.Size = Vector3.new(
        0.08,
        0.05,
        0.45
    )

    part.Anchored = true
    part.CanCollide = false
    part.CanTouch = false
    part.CanQuery = false
    part.Transparency = 1
    part.Material = Enum.Material.Neon
    part.Parent = CircleFolder

    table.insert(CircleParts, part)
end

local function updateCircle()
    if not AutoDodge then
        for _, part in ipairs(CircleParts) do
            part.Transparency = 1
        end
        return
    end

    if not Character or not Character.Parent then
        return
    end

    local root =
        Character:FindFirstChild("HumanoidRootPart")

    if not root then
        return
    end

    local center = root.Position

    for i, part in ipairs(CircleParts) do
        local angle =
            (i / CIRCLE_SEGMENTS) *
            math.pi *
            2

        local x =
            math.cos(angle) *
            DetectionRange

        local z =
            math.sin(angle) *
            DetectionRange

        local position =
            center +
            Vector3.new(
                x,
                0.05,
                z
            )

        part.CFrame =
            CFrame.lookAt(
                position,
                center
            ) *
            CFrame.Angles(
                0,
                math.rad(90),
                0
            )

        part.Transparency = 0.15
    end
end

RunService.RenderStepped:Connect(updateCircle)

--==================================================
-- DISTÂNCIA NIKKI
--==================================================

local function getDistanceToNikki()
    if not Character then
        return math.huge
    end

    local localRoot =
        Character:FindFirstChild("HumanoidRootPart")

    if not localRoot then
        return math.huge
    end

    if not NikkiCharacter then
        return math.huge
    end

    local nikkiRoot =
        NikkiCharacter:FindFirstChild("HumanoidRootPart")
        or NikkiCharacter:FindFirstChild("Torso")
        or NikkiCharacter.PrimaryPart

    if not nikkiRoot then
        return math.huge
    end

    return (
        localRoot.Position -
        nikkiRoot.Position
    ).Magnitude
end

--==================================================
-- ENCONTRAR NIKKI
--==================================================

local function findNikki()
    for _, player in ipairs(
        Players:GetPlayers()
    ) do
        local char = player.Character

        if char then
            local role =
                char:GetAttribute(
                    "FixationRole"
                )

            if role == "Nikki" then
                return char
            end
        end
    end

    for _, obj in ipairs(
        workspace:GetChildren()
    ) do
        if obj:IsA("Model") then
            local role =
                obj:GetAttribute(
                    "FixationRole"
                )

            if role == "Nikki" then
                return obj
            end
        end
    end

    return nil
end

--==================================================
-- PEGAR ANIMAÇÕES ATIVAS
--==================================================

local function getActiveAnimations()
    local result = {}

    if not NikkiAnimator then
        return result
    end

    for _, track in ipairs(
        NikkiAnimator:GetPlayingAnimationTracks()
    ) do
        if track and track.Animation then
            table.insert(
                result,
                {
                    id = track.Animation.AnimationId,
                    time = track.TimePosition,
                    length = track.Length,
                    speed = track.Speed,
                    weight = track.WeightCurrent,
                    priority = tostring(track.Priority)
                }
            )
        end
    end

    return result
end

--==================================================
-- PEGAR TIMEPOSITION DAS DUAS
--==================================================

local function getAttackAnimationPositions()
    local result = {
        ["rbxassetid://128555110265250"] = nil,
        ["rbxassetid://75042172549461"] = nil
    }

    if not NikkiAnimator then
        return result
    end

    for _, track in ipairs(
        NikkiAnimator:GetPlayingAnimationTracks()
    ) do
        if track and track.Animation then
            local id =
                track.Animation.AnimationId

            if result[id] ~= nil then
                result[id] = {
                    time = track.TimePosition,
                    length = track.Length,
                    speed = track.Speed,
                    weight = track.WeightCurrent
                }
            end
        end
    end

    return result
end

--==================================================
-- MONITORAMENTO DAS ANIMAÇÕES
-- DESATIVADO NO CONSOLE
--==================================================

local function printAttackPositions(prefix)
    return
end

--==================================================
-- CANCELAR DIAGNÓSTICO
--==================================================

local function cancelDiagnostic()
    CurrentDiagnostic = nil
end

--==================================================
-- DIAGNÓSTICO
--==================================================

local function startDiagnostic(
    track,
    attackNumber,
    triggerAnimation
)
    if not AutoDodge then
        return
    end

    if not Character or not Humanoid then
        return
    end

    local startTime = tick()

    local initialHP =
        Humanoid.Health

    local stunned =
        Character:GetAttribute(
            "FixationStunned"
        )

    local immune =
        Character:GetAttribute(
            "FixationStunImmune"
        )

    local stunUntil =
        Character:GetAttribute(
            "FixationStunUntil"
        )

    CurrentDiagnostic = {
        id = attackNumber,
        startTime = startTime,
        track = track,
        triggerAnimation = triggerAnimation,
        initialHP = initialHP,
        lastHP = initialHP,
        hpDropDetected = false,
        stunDetected = false,
        immuneDetected = false,
        bloodDetected = false,
        finished = false
    }

    print("")
    print("==========================================")
    print(
        "ATAQUE #" ..
        attackNumber
    )
    print("==========================================")

    print(
        "GATILHO:",
        triggerAnimation
    )

    print(
        "DISTÂNCIA:",
        string.format(
            "%.2f",
            getDistanceToNikki()
        )
    )

    print(
        "HP ANTES:",
        initialHP
    )

    print(
        "FixationStunned:",
        tostring(stunned)
    )

    print(
        "FixationStunImmune:",
        tostring(immune)
    )

    print(
        "FixationStunUntil:",
        tostring(stunUntil)
    )

    print("")

    -- Esta chamada continua existindo,
    -- mas a função agora não imprime nada.
    printAttackPositions(
        "ANIMAÇÕES DE ATAQUE NO MOMENTO:"
    )

    print("")

    --========================================
    -- MONITORAMENTO
    --========================================

    task.spawn(function()
        local diagnostic =
            CurrentDiagnostic

        if not diagnostic then
            return
        end

        local endTime =
            startTime +
            DIAGNOSTIC_TIME

        local previousStunned =
            Character:GetAttribute(
                "FixationStunned"
            )

        local previousImmune =
            Character:GetAttribute(
                "FixationStunImmune"
            )

        while
            AutoDodge
            and CurrentDiagnostic ==
                diagnostic
            and tick() < endTime
        do
            if
                not Character
                or not Character.Parent
            then
                break
            end

            if
                not Humanoid
                or not Humanoid.Parent
            then
                break
            end

            local elapsed =
                tick() -
                startTime

            local hp =
                Humanoid.Health

            local currentStunned =
                Character:GetAttribute(
                    "FixationStunned"
                )

            local currentImmune =
                Character:GetAttribute(
                    "FixationStunImmune"
                )

            --==============================
            -- HP
            --==============================

            if
                hp <
                diagnostic.lastHP -
                0.01
            then
                if not diagnostic.hpDropDetected then
                    diagnostic.hpDropDetected = true

                    print("")
                    print(
                        "!!! QUEDA DE HP DETECTADA !!!"
                    )

                    print(
                        "Tempo:",
                        string.format(
                            "%.4f",
                            elapsed
                        ) .. "s"
                    )

                    print(
                        "HP:",
                        diagnostic.lastHP,
                        "->",
                        hp
                    )

                    print(
                        "Dano:",
                        string.format(
                            "%.2f",
                            diagnostic.lastHP -
                            hp
                        )
                    )

                    printAttackPositions(
                        "TIMEPOSITION NO MOMENTO DO DANO:"
                    )

                    print(
                        "FixationStunned:",
                        tostring(
                            currentStunned
                        )
                    )

                    print(
                        "FixationStunImmune:",
                        tostring(
                            currentImmune
                        )
                    )

                    print(
                        "Animações ativas:"
                    )

                    printNikkiAnimations()
                end
            end

            diagnostic.lastHP =
                hp

            --==============================
            -- STUN
            --==============================

            if
                currentStunned == true
                and previousStunned ~= true
            then
                diagnostic.stunDetected =
                    true

                print("")
                print(
                    "!!! FIXATIONSTUNNED FICOU TRUE !!!"
                )

                print(
                    "Tempo:",
                    string.format(
                        "%.4f",
                        elapsed
                    ) .. "s"
                )

                printAttackPositions(
                    "ANIMAÇÕES NO MOMENTO DO STUN:"
                )

                print(
                    "HP:",
                    hp
                )
            end

            previousStunned =
                currentStunned

            --==============================
            -- IMMUNE
            --==============================

            if
                currentImmune ~=
                previousImmune
            then
                if currentImmune ~= nil then
                    diagnostic.immuneDetected =
                        true

                    print("")
                    print(
                        ">>> FIXATIONSTUNIMMUNE MUDOU <<<"
                    )

                    print(
                        "Tempo:",
                        string.format(
                            "%.4f",
                            elapsed
                        ) .. "s"
                    )

                    print(
                        "Valor:",
                        tostring(
                            currentImmune
                        )
                    )

                    printAttackPositions(
                        "ANIMAÇÕES NO MOMENTO:"
                    )
                end
            end

            previousImmune =
                currentImmune

            task.wait(
                MONITOR_INTERVAL
            )
        end

        --========================================
        -- RESULTADO
        --========================================

        if not AutoDodge then
            return
        end

        if CurrentDiagnostic ~=
            diagnostic
        then
            return
        end

        diagnostic.finished =
            true

        print("")
        print("------------------------------------------")
        print(
            "FIM DO DIAGNÓSTICO ATAQUE #" ..
            attackNumber
        )
        print("------------------------------------------")

        print(
            "Gatilho:",
            diagnostic.triggerAnimation
        )

        print(
            "HP inicial:",
            diagnostic.initialHP
        )

        print(
            "HP final:",
            Humanoid.Health
        )

        print(
            "Queda de HP:",
            diagnostic.hpDropDetected
        )

        print(
            "FixationStunned detectado:",
            diagnostic.stunDetected
        )

        print(
            "FixationStunImmune detectado:",
            diagnostic.immuneDetected
        )

        print("")

        print(
            "IMPORTANTE: Dodge enviado NÃO significa"
        )

        print(
            "que o ataque foi evitado."
        )

        if diagnostic.hpDropDetected then
            print("")

            print(
                "RESULTADO: ATAQUE CAUSOU DANO."
            )
        else
            print("")

            print(
                "RESULTADO: NENHUMA QUEDA DE HP"
            )

            print(
                "durante a janela monitorada."
            )
        end

        print("------------------------------------------")
        print("")

        CurrentDiagnostic = nil
    end)
end

--==================================================
-- COMBAT VFX / BLOOD
--==================================================

CombatConnection =
    CombatVFX.OnClientEvent:Connect(
        function(effect, source, ...)
            if not AutoDodge then
                return
            end

            if effect ~= "Blood" then
                return
            end

            if not CurrentDiagnostic then
                return
            end

            if source ~= Character then
                return
            end

            local diagnostic =
                CurrentDiagnostic

            if diagnostic.bloodDetected then
                return
            end

            diagnostic.bloodDetected =
                true

            local elapsed =
                tick() -
                diagnostic.startTime

            print("")
            print(
                "!!! BLOOD DETECTADO !!!"
            )

            print(
                "Tempo:",
                string.format(
                    "%.4f",
                    elapsed
                ) .. "s"
            )

            print(
                "HP atual:",
                Humanoid.Health
            )

            printAttackPositions(
                "TIMEPOSITION DAS ANIMAÇÕES:"
            )

            print(
                "FixationStunned:",
                tostring(
                    Character:GetAttribute(
                        "FixationStunned"
                    )
                )
            )

            print(
                "FixationStunImmune:",
                tostring(
                    Character:GetAttribute(
                        "FixationStunImmune"
                    )
                )
            )

            print(
                ">>> BLOOD DETECTADO NO NOSSO CHARACTER <<<"
            )
        end
    )

--==================================================
-- AUTO DODGE
--==================================================

local function performDodge(
    track,
    triggerAnimation
)
    if not AutoDodge then
        return
    end

    if not track then
        return
    end

    if not track.Animation then
        return
    end

    local animationId =
        track.Animation.AnimationId

    if not ATTACK_ANIMATIONS[
        animationId
    ] then
        return
    end

    -- Cada AnimationTrack é processada uma vez
    if ProcessedTracks[track] then
        return
    end

    local now = tick()

    if
        now -
        LastAttackTime <
        ANIMATION_DEBOUNCE
    then
        return
    end

    local distance =
        getDistanceToNikki()

    if distance > DetectionRange then
        return
    end

    ProcessedTracks[track] = true
    LastAttackTime = now

    AttackNumber += 1

    --========================================
    -- DIAGNÓSTICO COMEÇA ANTES DO DODGE
    --========================================

    startDiagnostic(
        track,
        AttackNumber,
        triggerAnimation
    )

    print("")
    print(
        ">>> AUTO DODGE ATAQUE DETECTADO <<<"
    )

    print(
        "Gatilho:",
        triggerAnimation
    )

    print(
        "Distância:",
        string.format(
            "%.2f",
            distance
        )
    )

    print(
        "TimePosition do gatilho:",
        string.format(
            "%.4f",
            track.TimePosition
        )
    )

    print(
        "HP antes do Dodge:",
        Humanoid.Health
    )

    printAttackPositions(
        "ANIMAÇÕES DAS DUAS NO DODGE:"
    )

    --========================================
    -- 4 TENTATIVAS
    --========================================

    task.spawn(function()
        local previousDelay = 0

        for attempt, totalDelay in ipairs(
            DODGE_ATTEMPTS
        ) do
            if not AutoDodge then
                break
            end

            local waitTime =
                totalDelay -
                previousDelay

            if waitTime > 0 then
                task.wait(waitTime)
            end

            previousDelay =
                totalDelay

            if not AutoDodge then
                break
            end

            local currentDistance =
                getDistanceToNikki()

            if currentDistance >
                DetectionRange
            then
                print(
                    "Dodge cancelado:"
                    .. " Nikki saiu da range."
                )

                break
            end

            local success, errorMessage =
                pcall(function()
                    DodgeAttempt:FireServer()
                end)

            if success then
                print(
                    "Dodge "
                    .. attempt
                    .. "/"
                    .. #DODGE_ATTEMPTS
                    .. " ENVIADO | +"
                    .. string.format(
                        "%.4f",
                        totalDelay
                    )
                    .. "s"
                )

                printAttackPositions(
                    "ANIMAÇÕES APÓS DODGE "
                    .. attempt
                    .. ":"
                )
            else
                print(
                    "ERRO NO DODGE:",
                    errorMessage
                )
            end
        end

        if AutoDodge then
            print("")
            print(
                "Sequência de Dodge finalizada."
            )

            print(
                "Agora aguardando resultado..."
            )
        end
    end)

    -- Libera o track
    task.delay(
        0.75,
        function()
            ProcessedTracks[track] =
                nil
        end
    )
end

--==================================================
-- MONITORAR ANIMATOR DA NIKKI
--==================================================

local function monitorAnimator(animator)
    if AnimatorConnection then
        AnimatorConnection:Disconnect()
        AnimatorConnection = nil
    end

    if not animator then
        return
    end

    NikkiAnimator =
        animator

    AnimatorConnection =
        animator.AnimationPlayed:Connect(
            function(track)
                if not AutoDodge then
                    return
                end

                if
                    not track
                    or not track.Animation
                then
                    return
                end

                local id =
                    track.Animation.AnimationId

                -- Só as duas animações
                if not ATTACK_ANIMATIONS[id] then
                    return
                end

                print("")
                print(
                    ">>> ANIMAÇÃO DE ATAQUE DETECTADA <<<"
                )

                print(
                    "ID:",
                    id
                )

                print(
                    "Time:",
                    string.format(
                        "%.4f",
                        track.TimePosition
                    )
                )

                print(
                    "Length:",
                    string.format(
                        "%.4f",
                        track.Length
                    )
                )

                print(
                    "Speed:",
                    string.format(
                        "%.2f",
                        track.Speed
                    )
                )

                print(
                    "Weight:",
                    string.format(
                        "%.2f",
                        track.WeightCurrent
                    )
                )

                print(
                    "Priority:",
                    tostring(
                        track.Priority
                    )
                )

                performDodge(
                    track,
                    id
                )
            end
        )

    --========================================
    -- VERIFICAR ANIMAÇÕES JÁ TOCANDO
    --========================================

    task.spawn(function()
        task.wait(0.01)

        if not AutoDodge then
            return
        end

        for _, track in ipairs(
            animator:GetPlayingAnimationTracks()
        ) do
            if
                track
                and track.Animation
            then
                local id =
                    track.Animation.AnimationId

                if ATTACK_ANIMATIONS[id] then
                    performDodge(
                        track,
                        id
                    )
                end
            end
        end
    end)
end

--==================================================
-- CONFIGURAR NIKKI
--==================================================

local function setupNikki(character)
    if CharacterConnection then
        CharacterConnection:Disconnect()
        CharacterConnection = nil
    end

    NikkiCharacter =
        character

    if not character then
        NikkiHumanoid = nil
        NikkiAnimator = nil
        return
    end

    NikkiHumanoid =
        character:FindFirstChildOfClass(
            "Humanoid"
        )

    if not NikkiHumanoid then
        return
    end

    local animator =
        NikkiHumanoid:FindFirstChildOfClass(
            "Animator"
        )

    if animator then
        monitorAnimator(animator)
    end

    CharacterConnection =
        character.ChildAdded:Connect(
            function(child)
                if child:IsA("Humanoid") then
                    NikkiHumanoid =
                        child

                    local newAnimator =
                        child:FindFirstChildOfClass(
                            "Animator"
                        )

                    if newAnimator then
                        monitorAnimator(
                            newAnimator
                        )
                    end

                elseif child:IsA("Animator") then
                    monitorAnimator(
                        child
                    )
                end
            end
        )
end

--==================================================
-- PROCURAR NIKKI
--==================================================

task.spawn(function()
    while true do
        local found =
            findNikki()

        if found ~= NikkiCharacter then
            if found then
                setupNikki(
                    found
                )
            else
                NikkiCharacter = nil
                NikkiHumanoid = nil
                NikkiAnimator = nil

                if AnimatorConnection then
                    AnimatorConnection:Disconnect()
                    AnimatorConnection = nil
                end

                if CharacterConnection then
                    CharacterConnection:Disconnect()
                    CharacterConnection = nil
                end
            end
        end

        task.wait(0.10)
    end
end)

--==================================================
-- TOGGLE
--==================================================

Toggle.MouseButton1Click:Connect(function()
    AutoDodge =
        not AutoDodge

    if AutoDodge then
        Toggle.Text =
            "AUTO DODGE: ON"

        Toggle.BackgroundColor3 =
            Color3.fromRGB(
                40,
                130,
                70
            )

        StatusLabel.Text =
            "Diagnóstico: ATIVO\n2 animações monitoradas"

        print("")
        print("==========================================")
        print("AUTO DODGE ATIVADO")
        print("==========================================")

        print(
            "Animação 1:",
            "rbxassetid://128555110265250"
        )

        print(
            "Animação 2:",
            "rbxassetid://75042172549461"
        )

        print(
            "Range:",
            DetectionRange
        )

        print(
            "Tentativas:",
            #DODGE_ATTEMPTS
        )

        print(
            "Diagnóstico:",
            DIAGNOSTIC_TIME .. "s"
        )

        print("==========================================")
        print("")

    else
        Toggle.Text =
            "AUTO DODGE: OFF"

        Toggle.BackgroundColor3 =
            Color3.fromRGB(
                60,
                60,
                60
            )

        StatusLabel.Text =
            "Diagnóstico: OFF"

        cancelDiagnostic()

        table.clear(
            ProcessedTracks
        )
    end
end)

--==================================================
-- FINAL
--==================================================

print("==========================================")
print("FIXATION AUTO DODGE DUPLO CARREGADO")
print("Auto Dodge: OFF")
print("Animações monitoradas: 2")
print("Range inicial:", DetectionRange)
print("==========================================")