--[[
	Combat GUI - By Prim Hub!
]]

local UI = loadstring(game:HttpGet("https://raw.githubusercontent.com/cueshut/saves/main/compact"))()
UI = UI.init("Combat GUI", "By Prim Hub!", "COMBAT")

-- Services
local Players = game:GetService("Players")
local TweenService = game:GetService("TweenService")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local Workspace = game:GetService("Workspace")
local VirtualInputManager = game:GetService("VirtualInputManager")

local player = Players.LocalPlayer
local character = player.Character
local humanoid = character and character:FindFirstChild("Humanoid")
local humanoidRootPart = character and character:FindFirstChild("HumanoidRootPart")

-- Сохранение состояний функций
local functionStates = {
    kibaEnabled = false,
    instantEnabled = false,
    oreoEnabled = false,
    speedEnabled = false,
    jumpEnabled = false,
    kyotoEnabled = false,
    autoBlockEnabled = false
}

-- Переменные для Speed и Jump
local tspeed = 0.1
local tpwalking = false

-- Переменные для Kyoto
local kyotoCooldown = false

-- Переменные для Auto Block
local detectActive = false
local comboIDs = {10480793962, 10480796021}
local allIDs = {
    Saitama = {
        10469493270, 10469630950, 10469639222, 10469643643,
        special = 10479335397
    },
    Garou = {
        13532562418, 13532600125, 13532604085, 13294471966,
        special = 10479335397
    },
    Cyborg = {
        13491635433, 13296577783, 13295919399, 13295936866,
        special = 10479335397
    },
    Sonic = {
        13370310513, 13390230973, 13378751717, 13378708199,
        special = 13380255751
    }
}

-- Функция для отправки remote
local function fireRemote(goal, mobile)
    local args = {{
        Goal = goal,
        Key = (goal == "KeyPress" or goal == "KeyRelease") and Enum.KeyCode.F or nil,
        Mobile = mobile or nil
    }}
    if player.Character and player.Character:FindFirstChild("Communicate") then
        player.Character.Communicate:FireServer(unpack(args))
    end
end

-- Функция Kyoto
local function executeKyoto()
    if kyotoCooldown then return end
    kyotoCooldown = true
    
    -- Flowing Water
    local args1 = {
        [1] = {
            ["Tool"] = player.Backpack:FindFirstChild("Flowing Water"),
            ["Goal"] = "Console Move"
        }
    }
    if player.Character and player.Character:FindFirstChild("Communicate") then
        player.Character.Communicate:FireServer(unpack(args1))
    end

    task.wait(2.15)

    local char = player.Character
    if not char or not char:FindFirstChild("HumanoidRootPart") then 
        kyotoCooldown = false
        return 
    end
    local hrp = char.HumanoidRootPart

    local forward = hrp.CFrame.LookVector.Unit
    local distance = 20
    local duration = 0.1
    local goalPos = hrp.Position + forward * distance
    local tween = TweenService:Create(hrp, TweenInfo.new(duration), {
        CFrame = CFrame.new(goalPos, goalPos + forward)
    })
    tween:Play()
    tween.Completed:Wait()

    hrp.CFrame = hrp.CFrame * CFrame.Angles(0, math.rad(180), 0)

    -- Lethal Whirlwind Stream
    local args = {
        [1] = {
            ["Tool"] = player.Backpack:FindFirstChild("Lethal Whirlwind Stream"),
            ["Goal"] = "Console Move"
        }
    }
    if player.Character and player.Character:FindFirstChild("Communicate") then
        player.Character.Communicate:FireServer(unpack(args))
    end
    
    task.wait(3)
    kyotoCooldown = false
end

-- Функция Auto Block
local function checkAnims()
    for _, otherPlayer in pairs(Players:GetPlayers()) do
        if otherPlayer ~= player and otherPlayer.Character and otherPlayer.Character.Parent == workspace:FindFirstChild("Live") then
            local char = otherPlayer.Character
            local hrp = char:FindFirstChild("HumanoidRootPart")
            local hum = char:FindFirstChildWhichIsA("Humanoid")
            local myHRP = player.Character and player.Character:FindFirstChild("HumanoidRootPart")
            if hrp and hum and myHRP then
                local dist = (hrp.Position - myHRP.Position).Magnitude
                local animator = hum:FindFirstChildOfClass("Animator")
                if animator then
                    local anims = {}
                    for _, track in ipairs(animator:GetPlayingAnimationTracks()) do
                        local id = tonumber(track.Animation.AnimationId:match("%d+"))
                        if id then anims[id] = true end
                    end

                    -- Проверка комбо
                    local comboCount = 0
                    for _, id in ipairs(comboIDs) do
                        if anims[id] then comboCount += 1 end
                    end

                    -- Проверка ID групп
                    for _, group in pairs(allIDs) do
                        local normalHits, special = 0, anims[group.special]
                        for i = 1, 4 do
                            if anims[group[i]] then normalHits += 1 end
                        end

                        if comboCount == 2 and normalHits >= 2 and dist <= 50 then
                            fireRemote("KeyPress") 
                            task.wait(0.7)
                            fireRemote("KeyRelease")
                            break
                        elseif normalHits > 0 and dist <= 30 then
                            fireRemote("KeyPress") 
                            task.wait(0.15)
                            fireRemote("KeyRelease")
                            break
                        elseif special and dist <= 50 then
                            fireRemote("KeyPress")
                            task.delay(0.6, function()
                                fireRemote("KeyRelease")
                            end)
                            break
                        end
                    end
                end
            end
        end
    end
end

-- Автоматическая настройка при респавне
player.CharacterAdded:Connect(function(char)
    character = char
    humanoid = character:WaitForChild("Humanoid")
    humanoidRootPart = character:WaitForChild("HumanoidRootPart")
    
    -- Восстановление функций после респавна
    task.wait(2)
    if functionStates.speedEnabled then
        tpwalking = true
    end
    if functionStates.jumpEnabled then
        humanoid.UseJumpPower = not functionStates.jumpEnabled
    end
    if functionStates.kibaEnabled then
        kibaSetupCharacter(char)
    end
    if functionStates.instantEnabled then
        instantSetupMonitor()
    end
end)

local MainTab = UI:AddTab("Main", "Main Functions") do
    local Section = MainTab:AddSeperator("Movement") do
        
        -- Speed Boost Function
        local SpeedToggle = Section:AddToggle({
            title = "Speed Boost",
            desc = "Enable speed boost movement",
            callback = function(state)
                functionStates.speedEnabled = state
                tpwalking = state
            end
        })

        Section:AddSlider({
            title = "Change the speed",
            values = {min = 0.1, max = 5, default = 0.1},
            callback = function(value)
                tspeed = value
            end
        })

        -- Jump Boost Function
        local JumpToggle = Section:AddToggle({
            title = "Jump Boost", 
            desc = "Enable enhanced jumping",
            callback = function(state)
                functionStates.jumpEnabled = state
                if humanoid then
                    humanoid.UseJumpPower = not state
                end
            end
        })

        Section:AddSlider({
            title = "Change the power jump",
            values = {min = 7.2, max = 500, default = 7.2},
            callback = function(value)
                if humanoid then
                    humanoid.JumpHeight = value
                end
            end
        })

        -- No Cooldown Dash Function (Patched - ничего не делает)
        Section:AddToggle({
            title = "No Cooldown Dash [Patched]",
            desc = "This feature is currently patched",
            callback = function(state)
                -- Ничего не делаем, функция патчена
            end
        })

    end
end

local TechTab = UI:AddTab("Tech [All]", "All Combat Functions") do
    local Section = TechTab:AddSeperator("Combat Functions") do
        
        -- Kiba [v1] Function
        local kibaAnimationIds = {
            ["rbxassetid://10503381238"] = true,
            ["rbxassetid://13379003796"] = true,
        }

        local TWEEN_HEIGHT_OFFSET = Vector3.new(0, 5, 0)
        local kibaToggleConnection
        local kibaAimlockConnection
        local kibalockedTarget = nil

        local function kibaStartAimlock(target)
            if kibaAimlockConnection then kibaAimlockConnection:Disconnect() end

            local cam = Workspace.CurrentCamera
            local character = player.Character
            local lockTime = 0.65
            local chaosTime = 0.15
            local startTime = tick()

            kibaAimlockConnection = RunService.RenderStepped:Connect(function()
                if not (target and target.Parent and target:FindFirstChild("HumanoidRootPart")) then return end
                if not (character and character:FindFirstChild("HumanoidRootPart")) then return end

                local now = tick()
                local targetPos = target.HumanoidRootPart.Position
                local camPos = cam.CFrame.Position

                if now - startTime < chaosTime then
                    local angleX = math.rad(math.random(-15, 25))
                    local angleY = math.rad(math.random(-15, 25))
                    local baseCFrame = CFrame.new(camPos, targetPos)
                    local newLook = baseCFrame * CFrame.Angles(angleY, angleX, 0)
                    cam.CFrame = newLook
                else
                    cam.CFrame = CFrame.new(camPos, targetPos)
                end

                character.HumanoidRootPart.CFrame = CFrame.new(character.HumanoidRootPart.Position, cam.CFrame.Position + cam.CFrame.LookVector)
            end)

            task.delay(lockTime, function()
                if kibaAimlockConnection then
                    kibaAimlockConnection:Disconnect()
                    kibaAimlockConnection = nil
                    kibalockedTarget = nil
                end
            end)
        end

        local function kibaSetupCharacter(character)
            if kibaToggleConnection then kibaToggleConnection:Disconnect() end
            if kibaAimlockConnection then kibaAimlockConnection:Disconnect() end
            kibalockedTarget = nil

            if not functionStates.kibaEnabled then return end

            local isTweening = false
            local lastPlaying = false
            local cooldown = false

            kibaToggleConnection = RunService.RenderStepped:Connect(function()
                local hrp = character:FindFirstChild("HumanoidRootPart")
                local humanoid = character:FindFirstChild("Humanoid")
                if not character or not hrp or not humanoid then return end

                local isPlaying = false
                for _, track in ipairs(humanoid:GetPlayingAnimationTracks()) do
                    if track.Animation and kibaAnimationIds[track.Animation.AnimationId] then
                        isPlaying = true
                        break
                    end
                end

                if isPlaying and not isTweening and not lastPlaying and not cooldown then
                    isTweening = true
                    lastPlaying = true
                    cooldown = true

                    task.delay(0.18, function()
                        local target = nil
                        local shortestDist = 15
                        local live = Workspace:FindFirstChild("Live")
                        if live then
                            for _, model in ipairs(live:GetChildren()) do
                                if model:IsA("Model") and model ~= character then
                                    local root = model:FindFirstChild("HumanoidRootPart") or model:FindFirstChild("Head") or model:FindFirstChild("UpperTorso")
                                    if root then
                                        local dist = (hrp.Position - root.Position).Magnitude
                                        if dist < shortestDist then
                                            shortestDist = dist
                                            target = model
                                        end
                                    end
                                end
                            end
                        end

                        if target and target:FindFirstChild("HumanoidRootPart") then
                            local targetPos = target.HumanoidRootPart.Position + TWEEN_HEIGHT_OFFSET
                            local targetCF = CFrame.new(targetPos)
                            local tween = TweenService:Create(hrp, TweenInfo.new(0.1, Enum.EasingStyle.Linear), {
                                CFrame = targetCF
                            })
                            tween:Play()
                            tween.Completed:Wait()

                            local bodyPosition = Instance.new("BodyPosition")
                            bodyPosition.MaxForce = Vector3.new(1e5, 1e5, 1e5)
                            bodyPosition.P = 10000
                            bodyPosition.D = 100
                            bodyPosition.Position = targetPos
                            bodyPosition.Parent = hrp

                            task.delay(0.76, function()
                                bodyPosition:Destroy()
                            end)

                            local remote = character:FindFirstChild("Communicate")
                            if remote then
                                local args = {
                                    {
                                        Dash = Enum.KeyCode.W,
                                        Key = Enum.KeyCode.Q,
                                        Goal = "KeyPress"
                                    }
                                }
                                remote:FireServer(unpack(args))
                            end

                            kibalockedTarget = target
                            kibaStartAimlock(kibalockedTarget)
                        end

                        isTweening = false
                        task.delay(4, function()
                            cooldown = false
                        end)
                    end)
                elseif not isPlaying then
                    lastPlaying = false
                end
            end)
        end

        Section:AddToggle({
            title = "Kiba [v1]",
            desc = "Kiba [v1 TESH] - Auto teleport and aimlock system",
            callback = function(state)
                functionStates.kibaEnabled = state
                if functionStates.kibaEnabled then
                    if player.Character then
                        kibaSetupCharacter(player.Character)
                    end
                else
                    if kibaToggleConnection then
                        kibaToggleConnection:Disconnect()
                    end
                end
            end
        })

        -- Instant Twisted Function
        local instantAnimationId = "rbxassetid://13294471966"
        local instantDebounce = false

        local function instantSwipeAndDash()
            local args = {
                [1] = {
                    ["Dash"] = Enum.KeyCode.W,
                    ["Key"] = Enum.KeyCode.Q,
                    ["Goal"] = "KeyPress"
                }
            }
            local char = player.Character
            if char and char:FindFirstChild("Communicate") then
                char.Communicate:FireServer(unpack(args))
            end

            local cam = Workspace.CurrentCamera
            local startCFrame = cam.CFrame
            local leftCFrame = startCFrame * CFrame.Angles(40, math.rad(-90), 180)

            cam.CameraType = Enum.CameraType.Scriptable
            local tween1 = TweenService:Create(cam, TweenInfo.new(0.1, Enum.EasingStyle.Sine, Enum.EasingDirection.Out), {CFrame = leftCFrame})
            tween1:Play()
            tween1.Completed:Wait()

            wait(0.00001)
            local tween2 = TweenService:Create(cam, TweenInfo.new(0.001, Enum.EasingStyle.Sine, Enum.EasingDirection.Out), {CFrame = startCFrame})
            tween2:Play()
            tween2.Completed:Wait()

            wait(0.1)
            local angledCFrame = startCFrame * CFrame.Angles(math.rad(-6), math.rad(20), 0)
            local tween3 = TweenService:Create(cam, TweenInfo.new(0.0001, Enum.EasingStyle.Sine, Enum.EasingDirection.Out), {CFrame = angledCFrame})
            tween3:Play()
            tween3.Completed:Wait()

            cam.CameraType = Enum.CameraType.Custom
        end

        local function instantSetupMonitor()
            local function onAnimPlayed(track)
                if not functionStates.instantEnabled then return end
                if track.Animation and track.Animation.AnimationId == instantAnimationId then
                    if instantDebounce then return end
                    instantDebounce = true

                    local char = player.Character
                    local hrp = char and char:FindFirstChild("HumanoidRootPart")
                    if hrp then
                        local back = hrp.CFrame.LookVector * -1
                        hrp.CFrame = hrp.CFrame + back
                    end

                    task.delay(0.25, function()
                        instantSwipeAndDash()
                        wait(5)
                        instantDebounce = false
                    end)
                end
            end

            local function bindAnimator(animator)
                animator.AnimationPlayed:Connect(onAnimPlayed)
            end

            local char = player.Character or player.CharacterAdded:Wait()
            local humanoid = char:WaitForChild("Humanoid")
            local animator = humanoid:FindFirstChildOfClass("Animator")

            if animator then
                bindAnimator(animator)
            else
                humanoid.ChildAdded:Connect(function(child)
                    if child:IsA("Animator") then
                        bindAnimator(child)
                    end
                end)
            end
        end

        Section:AddToggle({
            title = "Instant Twisted",
            desc = "Instant Twisted [TESH] - Auto swipe and dash on animation",
            callback = function(state)
                functionStates.instantEnabled = state
                if functionStates.instantEnabled then
                    if player.Character then
                        instantSetupMonitor()
                    end
                end
            end
        })

        -- Oreo Dash [Beta] Function
        local oreoAnimationId1List = {
            ["rbxassetid://13532604085"] = true,
            ["rbxassetid://10469639222"] = true,
        }

        local oreoAnimationId2List = {
            ["rbxassetid://10503381238"] = true,
        }

        local oreoLastTime1 = 0
        local oreoLastTime2 = 0
        local oreoCamLocked = false

        local function oreoFindNearestTorso()
            local nearest, minDist = nil, 10
            for _, model in ipairs(Workspace:GetChildren()) do
                if model:IsA("Model") and model ~= player.Character then
                    local torso = model:FindFirstChild("Torso") or model:FindFirstChild("UpperTorso")
                    if torso and (model:FindFirstChild("Humanoid") or model.Name == "Weakest Dummy") then
                        local dist = (torso.Position - player.Character.HumanoidRootPart.Position).Magnitude
                        if dist <= minDist then
                            minDist = dist
                            nearest = torso
                        end
                    end
                end
            end
            return nearest
        end

        local function oreoSwipeCameraBack(char, onFinish)
            local cam = Workspace.CurrentCamera
            local hrp = char:FindFirstChild("HumanoidRootPart")
            if not hrp then return end
            local camOffset = cam.CFrame.Position - hrp.Position
            local dir = Vector3.new(camOffset.X, 0, camOffset.Z).Unit
            local distance = camOffset.Magnitude
            local newPos = hrp.Position - dir * distance + Vector3.new(0, 2, 0)
            local lookAt = hrp.Position + Vector3.new(0, 1.5, 0)
            local newCF = CFrame.new(newPos, lookAt)
            TweenService:Create(cam, TweenInfo.new(0.2), { CFrame = newCF }):Play()
            if onFinish then task.delay(0.2, onFinish) end
        end

        local function oreoRotateBodyAndCameraRight(char)
            local cam = Workspace.CurrentCamera
            local hrp = char:FindFirstChild("HumanoidRootPart")
            if not hrp then return end

            local yaw = math.rad(44.6)
            local newCF = hrp.CFrame * CFrame.Angles(0, yaw, 0)

            hrp.CFrame = newCF

            local camOffset = cam.CFrame.Position - hrp.Position
            local dist = camOffset.Magnitude
            local dir = hrp.CFrame.LookVector
            local camPos = hrp.Position - dir * dist + Vector3.new(0, 2, 0)
            local lookAt = hrp.Position + Vector3.new(0, 1.5, 0)
            local camCF = CFrame.new(camPos, lookAt)

            TweenService:Create(cam, TweenInfo.new(0.15), { CFrame = camCF }):Play()

            oreoCamLocked = true
            task.delay(0.2, function()
                oreoCamLocked = false
            end)
        end

        local oreoConnection = RunService.Heartbeat:Connect(function()
            if not functionStates.oreoEnabled then return end

            local char = player.Character
            local humanoid = char and char:FindFirstChildWhichIsA("Humanoid")
            local hrp = char and char:FindFirstChild("HumanoidRootPart")
            if not humanoid or not hrp then return end

            for _, anim in pairs(humanoid:GetPlayingAnimationTracks()) do
                local id = anim.Animation and anim.Animation.AnimationId

                if oreoAnimationId1List[id] and tick() - oreoLastTime1 > 1.2 then
                    oreoLastTime1 = tick()
                    task.delay(0.1, function()
                        oreoRotateBodyAndCameraRight(char)
                    end)

                elseif oreoAnimationId2List[id] and tick() - oreoLastTime2 > 1.5 then
                    oreoLastTime2 = tick()
                    task.delay(0.3, function()
                        local targetTorso = oreoFindNearestTorso()
                        if targetTorso then
                            local toPos = targetTorso.Position + Vector3.new(0, 1.5, 0)
                            local newCF = CFrame.new(toPos, toPos + hrp.CFrame.LookVector)
                            TweenService:Create(hrp, TweenInfo.new(0.25), { CFrame = newCF }):Play()
                            task.wait(0.26)
                        end

                        hrp.Velocity = Vector3.new(hrp.Velocity.X, 60, hrp.Velocity.Z)

                        local remote = char:FindFirstChild("Communicate")
                        if remote then
                            local args = {
                                {
                                    ["Dash"] = Enum.KeyCode.W,
                                    ["Key"] = Enum.KeyCode.Q,
                                    ["Goal"] = "KeyPress"
                                }
                            }
                            pcall(function()
                                remote:FireServer(unpack(args))
                            end)
                        end

                        VirtualInputManager:SendKeyEvent(true, Enum.KeyCode.W, false, game)
                        task.wait(0.23)
                        oreoSwipeCameraBack(char, function()
                            task.wait(0.3)
                            VirtualInputManager:SendKeyEvent(false, Enum.KeyCode.W, false, game)
                        end)
                    end)
                end
            end
        end)

        Section:AddToggle({
            title = "Oreo Dash [Beta]",
            desc = "Oreo Dash [Beta TESH] - Advanced dash and camera control",
            callback = function(state)
                functionStates.oreoEnabled = state
            end
        })

    end
end

local MobileTab = UI:AddTab("Mobile", "Mobile Functions") do
    local Section = MobileTab:AddSeperator("Mobile Functions") do
        
        -- Kyoto [Mobile] Function
        Section:AddToggle({
            title = "Kyoto [Mobile]",
            desc = "Auto execute Kyoto combo",
            callback = function(state)
                functionStates.kyotoEnabled = state
                if state then
                    -- Запускаем Kyoto комбо
                    executeKyoto()
                end
            end
        })

        -- Auto Block [V2] Function
        Section:AddToggle({
            title = "Auto Block [V2]",
            desc = "Auto block enemy attacks",
            callback = function(state)
                functionStates.autoBlockEnabled = state
                detectActive = state
            end
        })

    end
end

-- Система Speed Boost
RunService.Heartbeat:Connect(function()
    if tpwalking and character and humanoid and humanoidRootPart then
        if humanoid.MoveDirection.Magnitude > 0 then
            humanoidRootPart.CFrame = humanoidRootPart.CFrame + (humanoid.MoveDirection * tspeed)
        end
    end
end)

-- Система Auto Block
RunService.Heartbeat:Connect(function()
    if detectActive and functionStates.autoBlockEnabled then
        pcall(checkAnims)
    end
end)

-- Автоматическая настройка если персонаж уже есть
if player.Character then
    if functionStates.kibaEnabled then
        kibaSetupCharacter(player.Character)
    end
    if functionStates.instantEnabled then
        instantSetupMonitor()
    end
end