-- [[ 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 ]]
-- ==========================================================
-- UNIFIED FORSAKEN EXPLOIT & FIXED AUTO-BLOCK MODULE
-- ==========================================================

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

local KillersFolder = workspace:WaitForChild("Players"):WaitForChild("Killers", 5)

-- --- CONFIGURATION VARIABLES ---
_G.AutoBlockEnabled = false
_G.AutoPunchEnabled = true
_G.wallCheckOn = false
_G.facingCheckEnabled = true
_G.customFacingDot = -0.3
_G.DetectionRange = 18
_G.blockDelay = 0

-- Debounce trackers to prevent remote spam bugs
local isBlocking = false
local isPunching = false

local trustedAnimationIds = {
    ["114506382930939"]=true, ["127245564598429"]=true, ["99829427721752"]=true, 
    ["138938529389204"]=true, ["111647315359080"]=true, ["92567970681901"]=true, 
    ["124269076578545"]=true, ["94958041603347"]=true, ["109667959938617"]=true, 
    ["130958529065375"]=true, ["118298475669935"]=true, ["126830014841198"]=true, 
    ["126355327951215"]=true, ["121086746534252"]=true, ["18885909645"]=true, 
    ["98456918873918"]=true, ["105458270463374"]=true, ["83829782357897"]=true, 
    ["125403313786645"]=true, ["82113744478546"]=true, ["70371667919898"]=true, 
    ["99135633258223"]=true, ["7167027849946"]=true, ["109230267448394"]=true, 
    ["139835501033932"]=true, ["126996426760253"]=true, ["88451353906104"]=true, 
    ["106538427162796"]=true, ["122709416391891"]=true, ["139309647473555"]=true, 
    ["90620531468240"]=true, ["91509234639766"]=true, ["99824350842479"]=true, 
    ["126171487400618"]=true, ["101101433684051"]=true, ["106860049270347"]=true, 
    ["70483423693126"]=true, ["126727756047566"]=true, ["137642639873297"]=true, 
    ["77375846492436"]=true, ["126681776859538"]=true, ["129976080405072"]=true, 
    ["121293883585738"]=true, ["81639435858902"]=true, ["137314737492715"]=true, 
    ["92173139187970"]=true, ["108196996477620"]=true, ["90819435118493"]=true,
    ["123172382755876"]=true, ["124705663396411"]=true, ["93069721274110"]=true
}

local function isFacingMe(targetRoot, myRoot)
    if not _G.facingCheckEnabled then return true end
    if not targetRoot or not myRoot then return false end
    local targetLook = targetRoot.CFrame.LookVector
    local dirToMe = (myRoot.Position - targetRoot.Position).Unit
    local dot = targetLook:Dot(dirToMe)
    return dot >= _G.customFacingDot
end

local function checkWall(targetRoot)
    local char = LocalPlayer.Character
    local hrp = char and char:FindFirstChild("HumanoidRootPart")
    if not hrp or not targetRoot then return false end
    local raycastParams = RaycastParams.new()
    raycastParams.FilterType = Enum.RaycastFilterType.Exclude
    raycastParams.FilterDescendantsInstances = {char, targetRoot.Parent}
    raycastParams.IgnoreWater = true
    local direction = targetRoot.Position - hrp.Position
    local raycastResult = workspace:Raycast(hrp.Position, direction, raycastParams)
    return raycastResult == nil
end

local function remoteBlock()
    if isBlocking then return end
    isBlocking = true

    local networkRemote = ReplicatedStorage:FindFirstChild("Modules") 
        and ReplicatedStorage.Modules:FindFirstChild("Network") 
        and ReplicatedStorage.Modules.Network:FindFirstChild("Network") 
        and ReplicatedStorage.Modules.Network.Network:FindFirstChild("RemoteEvent")
        
    if networkRemote then
        pcall(function()
            networkRemote:FireServer(
                "UseActorAbility",
                {
                    (function(bytes)
                        local b = buffer.create(#bytes)
                        for i = 1, #bytes do
                            buffer.writeu8(b, i - 1, bytes[i])
                        end
                        return b
                    end)({ 3, 5, 0, 0, 0, 66, 108, 111, 99, 107 })
                }
            )
        end)
    end
    
    task.delay(0.4, function()
        isBlocking = false
    end)
end

local function remotePunch()
    if isPunching then return end
    isPunching = true

    local networkRemote = ReplicatedStorage:FindFirstChild("Modules") 
        and ReplicatedStorage.Modules:FindFirstChild("Network") 
        and ReplicatedStorage.Modules.Network:FindFirstChild("Network") 
        and ReplicatedStorage.Modules.Network.Network:FindFirstChild("RemoteEvent")
        
    if networkRemote then
        pcall(function()
            networkRemote:FireServer(
                "UseActorAbility",
                {
                    (function(bytes)
                        local b = buffer.create(#bytes)
                        for i = 1, #bytes do
                            buffer.writeu8(b, i - 1, bytes[i])
                        end
                        return b
                    end)({ 3, 5, 0, 0, 0, 80, 117, 110, 99, 104 })
                }
            )
        end)
    end
    
    task.delay(0.4, function()
        isPunching = false
    end)
end

local function executeBlockAction()
    if _G.blockDelay > 0 then 
        task.wait(_G.blockDelay) 
    end
    remoteBlock()
end

local function setupPredictiveBlock(humanoid, targetRoot)
    humanoid.AnimationPlayed:Connect(function(track)
        if _G.AutoBlockEnabled then
            local anim = track.Animation
            if anim and anim.AnimationId then
                local id = string.match(anim.AnimationId, "%d+")
                local animName = anim.Name:lower()

                local myChar = LocalPlayer.Character
                local myRoot = myChar and myChar:FindFirstChild("HumanoidRootPart")
                if not myRoot then return end

                local dist = (targetRoot.Position - myRoot.Position).Magnitude
                
                if dist <= _G.DetectionRange then
                    if _G.wallCheckOn and not checkWall(targetRoot) then return end
                    if not isFacingMe(targetRoot, myRoot) then return end

                    if trustedAnimationIds[id] or animName:find("slash") or animName:find("attack") or animName:find("swing") or (track.Length >= 0.3 and track.Length <= 3 and animName:find("hit")) then
                        executeBlockAction() 
                    end
                end
            end
        end
    end)
end

local function connectNetwork()
    local networkModule = ReplicatedStorage:WaitForChild("Modules", 5)
    if networkModule then
        local netContainer = networkModule:FindFirstChild("Network", true)
        if netContainer then
            local network = require(netContainer:FindFirstChild("Network") or netContainer)
            if network and typeof(network.SetConnection) == "function" then
                network:SetConnection(("%*1337ParryIcon"):format(LocalPlayer.Name), "REMOTE_EVENT", function(blocked)
                    if blocked and _G.AutoPunchEnabled then
                        remotePunch()
                    end
                end)
            end
        end
    end
end

pcall(connectNetwork)
LocalPlayer.CharacterAdded:Connect(function()
    task.wait(0.9)
    pcall(connectNetwork)
end)

RunService.RenderStepped:Connect(function()
    if not _G.AutoBlockEnabled then return end 
    local myChar = LocalPlayer.Character
    local myRoot = myChar and myChar:FindFirstChild("HumanoidRootPart")
    if not myRoot then return end

    if KillersFolder then
        for _, killer in ipairs(KillersFolder:GetChildren()) do
            local root = killer:FindFirstChild("HumanoidRootPart")
            local humanoid = killer:FindFirstChildOfClass("Humanoid")
            
            if root and humanoid then
                if not humanoid:FindFirstChild("BlockPredictSetup") then
                    local tag = Instance.new("BoolValue")
                    tag.Name = "BlockPredictSetup"
                    tag.Parent = humanoid
                    setupPredictiveBlock(humanoid, root)
                end
            end
        end
    end
end)

-- ==========================================================
-- RAYFIELD UI INITIALIZATION & MODULE TABS
-- ==========================================================
local success, Rayfield = pcall(function()
    return loadstring(game:HttpGet("https://sirius.menu/gen2"))()
end)

if not success or not Rayfield then
    warn("Rayfield failed to load. Check internet or executor.")
    return
end

local window = Rayfield:CreateWindow({
   name = "Forsaken Exploit",
   subtitle = "Mobile Safe Mode",
})

local mainTab = window:CreateTab({ name = "Generator Solver", icon = 4483362458 })
local combatTab = window:CreateTab({ name = "Combat", icon = 4483362458 })
local visualTab = window:CreateTab({ name = "Visuals (ESP)", icon = 4483362458 })

-- ==========================================================
-- 1. GENERATOR AUTO-SOLVE
-- ==========================================================
local function isNeighbour(r1, c1, r2, c2)
    return (math.abs(r1 - r2) == 1 and c1 == c2) or (math.abs(c1 - c2) == 1 and r1 == r2)
end

_G.AutoSolveGen = false
_G.SolveDelay = 7.5

mainTab:CreateToggle({
   name = "Auto-Solve (Safe Loop)",
   callback = function(value)
      _G.AutoSolveGen = value
      
      if value then
         if not getgc then
            Rayfield:Notify({Title = "Error", Content = "Your mobile executor does not support getgc()!", Duration = 5})
            return
         end
         
         task.spawn(function()
            while _G.AutoSolveGen do
               task.wait(0.5)
               
               pcall(function()
                   for _, obj in ipairs(getgc(true)) do
                      if type(obj) == "table" and rawget(obj, "gameEnded") == false and rawget(obj, "targetPairs") and rawget(obj, "Solution") and not obj.currentlySolving then
                         
                         obj.currentlySolving = true 
                         local perfectlyOrderedPaths = {}
                         
                         for colorIndex, targetPair in ipairs(obj.targetPairs) do
                             local startNode = targetPair[1]
                             local unsortedPool = obj.Solution[colorIndex]
                             
                             local sortedPath = {}
                             local visited = {}
                             
                             local current = startNode
                             table.insert(sortedPath, {row = current.row, col = current.col})
                             
                             for k, v in ipairs(unsortedPool) do
                                 if v.row == current.row and v.col == current.col then
                                     visited[k] = true
                                     break
                                 end
                             end
                             
                             while #sortedPath < #unsortedPool do
                                 local foundNext = false
                                 for k, v in ipairs(unsortedPool) do
                                     if not visited[k] and isNeighbour(current.row, current.col, v.row, v.col) then
                                         table.insert(sortedPath, {row = v.row, col = v.col})
                                         visited[k] = true
                                         current = v
                                         foundNext = true
                                         break
                                     end
                                 end
                                 if not foundNext then break end
                             end
                             
                             perfectlyOrderedPaths[colorIndex] = sortedPath
                         end
                         
                         task.wait(_G.SolveDelay)
                         if not _G.AutoSolveGen then break end 
                         
                         obj.paths = perfectlyOrderedPaths
                         
                         if not obj.completedEvent then
                            obj.completedEvent = Instance.new("BindableEvent")
                         end
                         
                         pcall(function()
                             if type(obj.EndGame) == "function" then
                                 obj:EndGame(true)
                             elseif type(obj.checkForWin) == "function" then
                                 obj:checkForWin()
                             end
                         end)
                      end
                   end
               end)
            end
         end)
      end
   end,
})

mainTab:CreateSlider({
   name = "Solve Delay (Seconds)",
   range = {2, 10},
   increment = 0.5,
   suffix = "s",
   currentValue = 7.5,
   callback = function(value)
      _G.SolveDelay = value
   end,
})

-- ==========================================================
-- 2. COMBAT TAB CONTROLS (AUTO BLOCK & COUNTER)
-- ==========================================================
combatTab:CreateToggle({
   name = "Auto-Block & Counter Module",
   currentValue = false,
   callback = function(value)
      _G.AutoBlockEnabled = value
   end,
})

combatTab:CreateToggle({
   name = "Auto-Punch on Block",
   currentValue = true,
   callback = function(value)
      _G.AutoPunchEnabled = value
   end,
})

combatTab:CreateSlider({
   name = "Detection Range (Studs)",
   range = {5, 30},
   increment = 1,
   suffix = " studs",
   currentValue = 18,
   callback = function(value)
      _G.DetectionRange = value
   end,
})

-- ==========================================================
-- 3. VISUALS (ESP & NAME TAGS)
-- ==========================================================
_G.SurvivorESP = false
_G.KillerESP = false
_G.GenESP = false
_G.ItemESP = false

local function getTargetPart(target)
   if not target then return nil end
   if target:IsA("BasePart") then return target end
   if target:IsA("Model") then
      return target.PrimaryPart 
         or target:FindFirstChild("Head") 
         or target:FindFirstChild("HumanoidRootPart") 
         or target:FindFirstChildOfClass("BasePart")
   end
   return target:FindFirstChildOfClass("BasePart")
end

local function inLobby(target)
   if not target then return false end
   local map = workspace:FindFirstChild("Map")
   if map then
      local lobby = map:FindFirstChild("Lobby")
      if lobby and (target:IsDescendantOf(lobby) or target == lobby) then
         return true
      end
   end
   return false
end

local function addHighlight(target, color, hlName)
   pcall(function()
       if not target:FindFirstChild(hlName) then
          local hl = Instance.new("Highlight")
          hl.Name = hlName
          hl.Adornee = target
          hl.FillColor = color
          hl.OutlineColor = Color3.fromRGB(255, 255, 255)
          hl.FillTransparency = 0.4
          hl.OutlineTransparency = 0
          hl.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
          hl.Parent = target
       end
   end)
end

local function removeHighlight(target, hlName)
   pcall(function()
       local hl = target:FindFirstChild(hlName)
       if hl then hl:Destroy() end
   end)
end

local function createOrUpdateTag(target, tagText, color, tagName)
   pcall(function()
       local part = getTargetPart(target)
       if not part then return end
       
       local tag = part:FindFirstChild(tagName)
       if not tag then
          tag = Instance.new("BillboardGui")
          tag.Name = tagName
          tag.Adornee = part
          tag.Size = UDim2.new(0, 200, 0, 40)
          tag.StudsOffset = Vector3.new(0, 2.5, 0)
          tag.AlwaysOnTop = true
          
          local label = Instance.new("TextLabel")
          label.Name = "TagLabel"
          label.Size = UDim2.new(1, 0, 1, 0)
          label.BackgroundTransparency = 1
          label.TextColor3 = Color3.fromRGB(255, 255, 255) 
          label.TextStrokeTransparency = 0
          label.TextStrokeColor3 = color 
          label.Font = Enum.Font.GothamBold
          label.TextSize = 14
          label.RichText = true
          label.Parent = tag
          
          tag.Parent = part
       end
       
       local label = tag:FindFirstChild("TagLabel")
       if label then
          label.Text = tagText
          label.TextStrokeColor3 = color 
       end
   end)
end

local function removeTag(target, tagName)
   pcall(function()
       local part = getTargetPart(target)
       if part then
          local tag = part:FindFirstChild(tagName)
          if tag then tag:Destroy() end
       end
   end)
end

local function isKiller(player)
   if not player or not player.Character then return false end
   local char = player.Character
   local hum = char:FindFirstChildOfClass("Humanoid")
   
   if player:GetAttribute("Role") == "Killer" or player:GetAttribute("IsKiller") == true or char:GetAttribute("IsKiller") then
      return true
   end
   local roleVal = player:FindFirstChild("Role") or char:FindFirstChild("Role")
   if roleVal and roleVal:IsA("ValueBase") and tostring(roleVal.Value):lower():find("killer") then
      return true
   end
   if player.Team and string.find(string.lower(player.Team.Name), "killer") then
      return true
   end
   if hum and hum.MaxHealth > 150 then
      return true
   end
   if char:FindFirstChild("Killer") or char:FindFirstChild("Weapon") then
      return true
   end
   return false
end

local function isGeneratorCompleted(obj)
   if not obj or not obj:IsA("Model") then return false end

   local progress = obj:GetAttribute("Progress") or obj:GetAttribute("RepairProgress")
   if type(progress) == "number" and progress >= 100 then
      return true
   end
   
   for _, child in ipairs(obj:GetChildren()) do
      if (child.Name == "Progress" or child.Name == "RepairProgress") and (child:IsA("NumberValue") or child:IsA("IntValue")) then
         if child.Value >= 100 then return true end
      end
   end

   local prompt = obj:FindFirstChildOfClass("ProximityPrompt") or obj:FindFirstChild("Prompt", true)
   if prompt and prompt:IsA("ProximityPrompt") and not prompt.Enabled then
      return true
   end

   return false
end

-- SURVIVOR ESP
visualTab:CreateToggle({
   name = "Survivor ESP",
   callback = function(value)
      _G.SurvivorESP = value
      task.spawn(function()
         while _G.SurvivorESP do
            task.wait(0.1)
            for _, p in ipairs(Players:GetPlayers()) do
               if p ~= localPlayer and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
                  local char = p.Character
                  if not isKiller(p) and not inLobby(char) then
                     local hum = char:FindFirstChildOfClass("Humanoid")
                     addHighlight(char, Color3.fromRGB(0, 170, 255), "TYRIX_Survivor_HL")
                     local hp = hum and math.floor(hum.Health) or 0
                     local maxHp = hum and math.floor(hum.MaxHealth) or 100
                     local survivorName = char:GetAttribute("Survivor") or char:GetAttribute("Character") or char.Name
                     local tagText = string.format("Survivor: %s\nHP: %d/%d", survivorName, hp, maxHp)
                     createOrUpdateTag(char, tagText, Color3.fromRGB(0, 170, 255), "TYRIX_Survivor_Tag")
                  else
                     removeHighlight(char, "TYRIX_Survivor_HL")
                     removeTag(char, "TYRIX_Survivor_Tag")
                  end
               end
            end
         end
         for _, p in ipairs(Players:GetPlayers()) do
            if p.Character then 
               removeHighlight(p.Character, "TYRIX_Survivor_HL")
               removeTag(p.Character, "TYRIX_Survivor_Tag")
            end
         end
      end)
   end,
})

-- KILLER ESP
visualTab:CreateToggle({
   name = "Killer ESP",
   callback = function(value)
      _G.KillerESP = value
      task.spawn(function()
         while _G.KillerESP do
            task.wait(0.1)
            for _, p in ipairs(Players:GetPlayers()) do
               if p ~= localPlayer and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
                  local char = p.Character
                  if isKiller(p) and not inLobby(char) then
                     local hum = char:FindFirstChildOfClass("Humanoid")
                     addHighlight(char, Color3.fromRGB(255, 0, 0), "TYRIX_Killer_HL")
                     local hp = hum and math.floor(hum.Health) or 0
                     local maxHp = hum and math.floor(hum.MaxHealth) or 500
                     local killerClass = char:GetAttribute("Killer") or char:GetAttribute("Character") or char.Name
                     local tagText = string.format("KILLER: %s\nHP: %d/%d", killerClass, hp, maxHp)
                     createOrUpdateTag(char, tagText, Color3.fromRGB(255, 50, 50), "TYRIX_Killer_Tag")
                  else
                     removeHighlight(char, "TYRIX_Killer_HL")
                     removeTag(char, "TYRIX_Killer_Tag")
                  end
               end
            end
         end
         for _, p in ipairs(Players:GetPlayers()) do
            if p.Character then 
               removeHighlight(p.Character, "TYRIX_Killer_HL")
               removeTag(p.Character, "TYRIX_Killer_Tag")
            end
         end
      end)
   end,
})

-- GENERATOR ESP
visualTab:CreateToggle({
   name = "Generator ESP",
   callback = function(value)
      _G.GenESP = value
      task.spawn(function()
         while _G.GenESP do
            task.wait(0.5)
            for _, obj in ipairs(workspace:GetDescendants()) do
               if obj:IsA("Model") and (string.lower(obj.Name):find("generator") or obj:FindFirstChild("Puzzle")) then
                  if not inLobby(obj) then
                     if isGeneratorCompleted(obj) then
                        removeHighlight(obj, "TYRIX_Gen_HL")
                        removeTag(obj, "TYRIX_Gen_Tag")
                     else
                        local cyanColor = Color3.fromRGB(0, 240, 255)
                        addHighlight(obj, cyanColor, "TYRIX_Gen_HL")
                        
                        local progress = obj:GetAttribute("Progress") or obj:GetAttribute("RepairProgress")
                        local subStatus = "OBJECTIVE"
                        if type(progress) == "number" then
                           subStatus = string.format("Progress: %d%%", math.floor(progress))
                        end
                        
                        local tagText = string.format("GENERATOR\n%s", subStatus)
                        createOrUpdateTag(obj, tagText, cyanColor, "TYRIX_Gen_Tag")
                     end
                  else
                     removeHighlight(obj, "TYRIX_Gen_HL")
                     removeTag(obj, "TYRIX_Gen_Tag")
                  end
               end
            end
         end
         for _, obj in ipairs(workspace:GetDescendants()) do
            if obj:IsA("Model") and (string.lower(obj.Name):find("generator") or obj:FindFirstChild("Puzzle")) then
               removeHighlight(obj, "TYRIX_Gen_HL")
               removeTag(obj, "TYRIX_Gen_Tag")
            end
         end
      end)
   end,
})

-- ITEM ESP
local function getItemInfo(obj)
   local lower = string.lower(obj.Name)
   if lower:find("medkit") or lower:find("med kit") then
      return "Medkit", Color3.fromRGB(255, 70, 70) 
   elseif lower:find("cola") or lower:find("bloxy") then
      return "Bloxy Cola", Color3.fromRGB(255, 170, 0) 
   end
   return nil, nil
end

visualTab:CreateToggle({
   name = "Item ESP (Medkit & Cola)",
   callback = function(value)
      _G.ItemESP = value
      task.spawn(function()
         while _G.ItemESP do
            task.wait(0.5)
            local itemLocations = workspace:FindFirstChild("Map") 
               and workspace.Map:FindFirstChild("Ingame") 
               and workspace.Map.Ingame:FindFirstChild("Map") 
               and workspace.Map.Ingame.Map:FindFirstChild("ItemLocations")
            
            local searchFolder = itemLocations and itemLocations:GetDescendants() or workspace:GetDescendants()
            
            for _, obj in ipairs(searchFolder) do
               local formattedName, itemColor = getItemInfo(obj)
               if formattedName then
                  local isEquippedOrHeld = obj:IsDescendantOf(Players) or (obj.Parent and obj.Parent:FindFirstChildOfClass("Humanoid"))
                  if not isEquippedOrHeld and not inLobby(obj) then
                     local targetPart = getTargetPart(obj)
                     if targetPart then
                        addHighlight(targetPart, itemColor, "TYRIX_Item_HL")
                        local tagText = string.format("<b>%s</b>", formattedName)
                        createOrUpdateTag(targetPart, tagText, itemColor, "TYRIX_Item_Tag")
                     end
                  else
                     local targetPart = getTargetPart(obj)
                     if targetPart then
                        removeHighlight(targetPart, "TYRIX_Item_HL")
                        removeTag(targetPart, "TYRIX_Item_Tag")
                     end
                  end
               end
            end
         end
         for _, obj in ipairs(workspace:GetDescendants()) do
            if getItemInfo(obj) then
               local targetPart = getTargetPart(obj)
               if targetPart then
                  removeHighlight(targetPart, "TYRIX_Item_HL")
                  removeTag(targetPart, "TYRIX_Item_Tag")
               end
            end
         end
      end)
   end,
})