local WOLF_RANGE = 500
local HUMAN_RANGE = 3500
local TRAVEL_RANGE = 3500
local COUNTDOWN = 2
local BLOOD_LOW = 0.40
local BLOOD_TARGET = 0.90
local DRINK_DISTANCE = 3
local DRINK_COOLDOWN = 9
local DRINK_CHECK_DELAY = 3

local PAUSE_HEALTH = 0.30
local RESUME_HEALTH = 0.50
local PASS_START_DISTANCE = 6
local PASS_BEYOND = 1.5
local PASS_TIMEOUT = 1
local ATTACK_DISTANCE = 3
local BURST_DURATION = 0.45
local HOLD_TIME = 0.08
local GAP_TIME = 0.02

local Pathfinding = game:GetService("PathfindingService")
local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local Input = game:GetService("UserInputService")
local player = Players.LocalPlayer
local env = type(getgenv) == "function" and getgenv() or _G

local old = env.WolfShuttleController
if type(old) == "table" then
    if not old.stopped or (old.workerStarted and not old.workerFinished) then
        warn("[Farm] Existing run left unchanged. Press F6 to stop it before restarting.")
        return
    end
end
local oldTest = env.WolfClickTest
if type(oldTest) == "table" and type(oldTest.stop) == "function" then
    warn("[Farm] Stop the separate click test with F6 before starting this farmer.")
    return
end

local press, release = mouse1press, mouse1release
if type(press) ~= "function" or type(release) ~= "function" then
    warn("[Farm] Mouse press/release unavailable.")
    return
end

local inputOk, virtualInput = pcall(function()
    return Input:CreateVirtualInput()
end)
if not inputOk or not virtualInput then
    warn("[Farm] Automatic keyboard input unavailable.", virtualInput)
    return
end

local memory = env.WolfFarmMemory
if type(memory) ~= "table" or memory.server ~= game.JobId then
    memory = {server = game.JobId}
    env.WolfFarmMemory = memory
end

local state = {
    stopped = false, attackAllowed = false,
    mouseHeld = false, shiftHeld = false, eHeld = false,
    drinkRequested = false, drinkBusy = false,
    workerStarted = false, workerFinished = false,
    reason = "Stopped"
}

local character, humanoid, root, originalAutoRotate
local wolf, wolfRoot, wolfHumanoid
local human, humanRoot, humanHumanoid
local phase, phaseStarted = "approach", 0
local passDirection
local mode = "hunt"
local recovering = false
local nextWolfSearch, nextHumanSearch = 0, 0
local nextDrinkAt = tonumber(memory.nextDrinkAt) or 0
local nextLocationSearch = 0
local nextQuestCheck = 0
local drinkAt, bloodBeforeDrink, lastDrinkHuman
local awaitingBloodCheck = false
local ignoredHumans = {}
local status
local clicks, drinks = 0, 0
local connection
local bound, cleaned = false, false
local bindingName = "WolfContinuousShuttle"

local function flat(v)
    return Vector3.new(v.X, 0, v.Z)
end

local function report(message)
    if message ~= status then
        status = message
        print("[Farm]", message)
    end
end

local function bloodReading()
    local value = tonumber(player:GetAttribute("BloodThirst"))
    local maximum = tonumber(player:GetAttribute("MaxBloodThirst"))
    if not value or not maximum or maximum <= 0 then return nil end
    return value / maximum, value
end

local function releaseMouse()
    if not state.mouseHeld then return true end
    local ok, err = pcall(release)
    if ok then
        state.mouseHeld = false
    else
        warn("[Farm] Mouse release failed:", err)
        warn("[Farm] Physically press and release the left mouse button.")
    end
    return ok
end

local function releaseKey(field, key)
    if not state[field] then return true end
    local ok, err = pcall(function()
        virtualInput:SendKey(false, key, false)
    end)
    if ok then
        state[field] = false
    else
        warn("[Farm] Key release failed:", key.Name, err)
        warn("[Farm] Physically press and release that key.")
    end
    return ok
end

local function sprint(enabled)
    if enabled then
        if not state.shiftHeld then
            state.shiftHeld = true
            virtualInput:SendKey(true, Enum.KeyCode.LeftShift, false)
        end
    elseif not releaseKey("shiftHeld", Enum.KeyCode.LeftShift) then
        error("Shift release failed")
    end
end

local function stopMovement()
    if humanoid and humanoid.Parent then
        humanoid:Move(Vector3.zero, false)
        if originalAutoRotate ~= nil then
            humanoid.AutoRotate = originalAutoRotate
        end
    end
end

local resetNavigation

local function cleanup()
    if cleaned then return end
    cleaned = true
    if resetNavigation then resetNavigation() end
    state.attackAllowed = false
    state.drinkRequested = false
    releaseMouse()
    releaseKey("eHeld", Enum.KeyCode.E)
    releaseKey("shiftHeld", Enum.KeyCode.LeftShift)
    if connection then connection:Disconnect() end

    if env.WolfShuttleController == state then
        if bound then RunService:UnbindFromRenderStep(bindingName) end
        pcall(stopMovement)
        -- Retain the stopped controller until its input worker has exited.
        env.WolfSprintTestRunning = nil
    end
end

state.stop = function(reason)
    state.stopped = true
    state.reason = reason or "Stopped"
    cleanup()
end

env.WolfShuttleController = state
env.WolfSprintTestRunning = true

connection = Input.InputBegan:Connect(function(key)
    if key.KeyCode == Enum.KeyCode.F6 then state.stop("F6 pressed") end
end)

local function pause(message)
    if resetNavigation then resetNavigation() end
    state.attackAllowed = false
    state.drinkRequested = false
    phase = "approach"
    stopMovement()
    sprint(false)
    if not releaseMouse() then error("Mouse release failed") end
    if not releaseKey("eHeld", Enum.KeyCode.E) then
        error("E release failed")
    end
    report(message)
end

local function alive(model, modelRoot, modelHumanoid)
    return model and model.Parent
        and modelRoot and modelRoot.Parent
        and modelHumanoid and modelHumanoid.Parent
        and modelHumanoid.Health > 0
end

-- Inspect only each candidate NPC, never the entire Workspace.
local function isQuestNPC(model)
    local function mentionsQuest(value)
        return type(value) == "string"
            and string.find(string.lower(value), "quest", 1, true) ~= nil
    end
    if mentionsQuest(model.Name) then return true end
    for _, item in ipairs(model:GetDescendants()) do
        if mentionsQuest(item.Name) then return true end
        if item:IsA("TextLabel") or item:IsA("TextButton") then
            if mentionsQuest(item.Text) then return true end
        elseif item:IsA("ProximityPrompt") then
            if mentionsQuest(item.ActionText) or mentionsQuest(item.ObjectText) then
                return true
            end
        end
    end
    return false
end

local function hasHumanLabel(model)
    if not model or not model:IsA("Model") then return false end
    for _, item in ipairs(model:GetDescendants()) do
        if item:IsA("TextLabel") or item:IsA("TextButton") then
            local text = item.Text
            if item.RichText then text = text:gsub("<[^>]*>", "") end
            text = text:match("^%s*(.-)%s*$")
            if string.lower(text) == "human" then
                local parent = item
                local visible, overhead = true, false
                while parent and parent ~= model do
                    if parent:IsA("GuiObject") and not parent.Visible then
                        visible = false
                    end
                    if parent:IsA("BillboardGui") then
                        overhead = true
                        if not parent.Enabled then visible = false end
                    end
                    parent = parent.Parent
                end
                if overhead and visible then return true end
            end
        end
    end
    return false
end

local function nearest(folder, range, humansOnly)
    if not folder then return nil end
    local selected, selectedRoot, selectedHumanoid
    local closest = range

    for _, model in ipairs(folder:GetChildren()) do
        local allowed = not humansOnly or (hasHumanLabel(model) and not isQuestNPC(model))
        local ignored = humansOnly and ignoredHumans[model]
            and ignoredHumans[model] > os.clock()

        if model:IsA("Model") and allowed and not ignored then
            local h = model:FindFirstChildOfClass("Humanoid")
            local r = model:FindFirstChild("HumanoidRootPart")
            if h and h.Health > 0 and r and r:IsA("BasePart") then
                local distance = (r.Position - root.Position).Magnitude
                if distance <= closest then
                    selected, selectedRoot, selectedHumanoid = model, r, h
                    closest = distance
                end
            end
        end
    end

    return selected, selectedRoot, selectedHumanoid
end

local function aim(position)
    local camera = workspace.CurrentCamera
    if camera and (position - camera.CFrame.Position).Magnitude > 0.1 then
        camera.CFrame = CFrame.lookAt(camera.CFrame.Position, position)
    end
end

local function face(position)
    local delta = flat(position - root.Position)
    if delta.Magnitude > 0.05 then
        root.CFrame = CFrame.lookAt(root.Position, root.Position + delta.Unit)
    end
end

-- ComputeAsync runs in a separate task, never inside the render callback.
local nav = {generation = 0, busy = false, failures = 0, retryAt = 0}
local departureRequested = false

resetNavigation = function()
    nav.generation = nav.generation + 1
    if nav.blocked then nav.blocked:Disconnect(); nav.blocked = nil end
    if nav.path then nav.path:Destroy(); nav.path = nil end
    nav.points, nav.goal, nav.anchor = nil, nil, nil
    nav.needsRetry = false
    nav.directAnchor, nav.directSince = nil, nil
    nav.detour = false
    nav.nextObstacleCheck = 0
    nav.closeAnchor = nil
    nav.failures, nav.retryAt = 0, 0
    -- A pending computation must finish before another one may start.
end

local function retryRoute(reason)
    if nav.blocked then nav.blocked:Disconnect(); nav.blocked = nil end
    if nav.path then nav.path:Destroy(); nav.path = nil end
    nav.points = nil
    nav.failures = nav.failures + 1
    nav.retryAt = os.clock() + 1
    humanoid:Move(Vector3.zero, false)
    warn("[Travel]", reason, "Retry", nav.failures, "of 3")
    if nav.failures >= 3 then
        state.stop("Travel could not find or follow a route after three attempts")
    end
end

local function requestRoute(position)
    if nav.busy or state.stopped or os.clock() < nav.retryAt then return end
    nav.busy = true
    nav.started = os.clock()
    local generation = nav.generation
    local start = root.Position
    local goal = position
    -- Only calculate a local route, never the entire long trip.
    if (goal - start).Magnitude > 100 then
        goal = start + (goal - start).Unit * 80
        local params = RaycastParams.new()
        params.FilterType = Enum.RaycastFilterType.Exclude
        params.FilterDescendantsInstances = {character}
        local ground = workspace:Raycast(goal + Vector3.new(0, 15, 0),
            Vector3.new(0, -60, 0), params)
        if ground then goal = ground.Position end
        if (goal - start).Magnitude > 100 then
            nav.busy = false
            retryRoute("Local ground destination exceeds 100 studs")
            return
        end
    end
    task.spawn(function()
        local path
        local success, result = false, "No usable approach point"
        local candidates = {goal}
        if mode == "feed" and humanRoot and humanRoot.Parent
            and (goal - humanRoot.Position).Magnitude < 5 then
            candidates = {}
            local params = RaycastParams.new()
            params.FilterType = Enum.RaycastFilterType.Exclude
            local exclude = {character}
            local humansFolder = workspace:FindFirstChild("Humans")
            if humansFolder then table.insert(exclude, humansFolder) end
            params.FilterDescendantsInstances = exclude
            local toward = flat(start - goal)
            local baseAngle = math.atan2(toward.Z, toward.X)
            for _, radius in ipairs({4, 7}) do
                for _, turn in ipairs({0, math.pi / 2, -math.pi / 2, math.pi}) do
                    local angle = baseAngle + turn
                    local offset = goal + Vector3.new(math.cos(angle)*radius, 0,
                        math.sin(angle)*radius)
                    local hit = workspace:Raycast(offset + Vector3.new(0, 8, 0),
                        Vector3.new(0, -24, 0), params)
                    if hit and hit.Normal.Y > 0.5 then
                        table.insert(candidates, hit.Position)
                    end
                end
            end
        end
        for _, candidate in ipairs(candidates) do
            if state.stopped or generation ~= nav.generation then break end
            success, result = pcall(function()
                path = Pathfinding:CreatePath({
                    AgentRadius = 2, AgentHeight = 5,
                    AgentCanJump = true, WaypointSpacing = 6
                })
                path:ComputeAsync(start, candidate)
                if path.Status ~= Enum.PathStatus.Success then
                    error("Path status: " .. tostring(path.Status))
                end
                return path:GetWaypoints()
            end)
            if success and #result >= 2 then
                goal = candidate
                break
            end
            if path then path:Destroy(); path = nil end
            task.wait(0.05)
        end
        nav.busy = false
        if state.stopped or env.WolfShuttleController ~= state
            or generation ~= nav.generation then
            if path then path:Destroy() end
            return
        end
        if not success or #result < 2 then
            warn("[Travel detail]", success and "Path returned fewer than two waypoints" or tostring(result))
            warn("[Travel detail] Mode:", mode, "Distance:", math.floor((goal - start).Magnitude))
            warn("[Travel detail] Start:", start, "Destination:", goal)
            if path then path:Destroy() end
            retryRoute("Path calculation failed; see Travel detail above")
            return
        end
        nav.path, nav.points, nav.index = path, result, 2
        nav.anchor, nav.progressAt = root.Position, os.clock()
        nav.jumpIndex = nil
        nav.blocked = path.Blocked:Connect(function(index)
            if generation == nav.generation and nav.points and index >= nav.index then
                nav.needsRetry = true
            end
        end)
        print("[Travel] Route ready; waypoints:", #result)
    end)
end

-- Check a small corridor ahead while sprinting directly between areas.
-- This is local obstacle detection, not a scan of the map.
local function obstacleAhead(direction)
    local params = RaycastParams.new()
    params.FilterType = Enum.RaycastFilterType.Exclude
    params.RespectCanCollide = true
    local excluded = {character}
    for _, name in ipairs({"Humans", "Spawn4Werewolves"}) do
        local folder = workspace:FindFirstChild(name)
        if folder then table.insert(excluded, folder) end
    end
    params.FilterDescendantsInstances = excluded
    local speed = flat(root.AssemblyLinearVelocity).Magnitude
    local lookAhead = math.clamp(speed * 0.65 + 8, 18, 70)
    local side = Vector3.new(-direction.Z, 0, direction.X)
    for _, height in ipairs({0, 2}) do
        for _, offset in ipairs({-2, 0, 2}) do
            local origin = root.Position + side * offset + Vector3.new(0, height, 0)
            if workspace:Raycast(origin, direction * lookAhead, params) then
                return true
            end
        end
    end
    return false
end

local function travel(position)
    local now = os.clock()
    if not nav.goal
        or ((position - nav.goal).Magnitude > 12 and not nav.points and not nav.busy)
        or (mode == "feed" and nav.humanTarget ~= human)
        or (nav.lastUsed and now - nav.lastUsed > 0.3) then
        resetNavigation()
        nav.goal = position
        nav.humanTarget = human
    end
    nav.lastUsed = now
    humanoid.AutoRotate = true
    local distance = flat(position - root.Position).Magnitude
    sprint(not (mode == "feed" and distance <= 8))

    -- Finish the last few studs without repeatedly pathfinding to an NPC.
    -- Only do so with a clear line and a bounded progress check.
    if mode == "feed" and humanRoot and humanRoot.Parent and distance <= 8 then
        local params = RaycastParams.new()
        params.FilterType = Enum.RaycastFilterType.Exclude
        params.FilterDescendantsInstances = {character, human}
        local obstruction = workspace:Raycast(root.Position,
            humanRoot.Position - root.Position, params)
        if not obstruction then
            if not nav.closeAnchor then
                nav.closeAnchor, nav.closeAt = root.Position, now
            elseif flat(root.Position - nav.closeAnchor).Magnitude >= 1 then
                nav.closeAnchor, nav.closeAt = root.Position, now
            elseif now - nav.closeAt >= 3 then
                nav.closeAnchor = nil
                retryRoute("Final drinking approach made no progress")
                return distance
            end
            if now < nav.retryAt then
                humanoid:Move(Vector3.zero, false)
                return distance
            end
            sprint(false)
            local delta = flat(humanRoot.Position - root.Position)
            humanoid:Move(delta.Magnitude > 0.05 and delta.Unit or Vector3.zero, false)
            aim(humanRoot.Position)
            return distance
        end
    else
        nav.closeAnchor = nil
    end

    -- Long journeys use direct sprinting. Route only near the destination,
    -- when leaving the feeding area, or after direct travel gets stuck.
    if distance > 100 and not departureRequested and not nav.detour
        and not nav.points and not nav.busy then
        if not nav.directAnchor then
            nav.directAnchor, nav.directSince = root.Position, now
        elseif flat(root.Position - nav.directAnchor).Magnitude >= 3 then
            nav.directAnchor, nav.directSince = root.Position, now
        elseif now - nav.directSince >= 3 then
            nav.detour = true
            print("[Travel] Direct sprint stalled; requesting a local detour.")
        end
        if not nav.detour and now >= (nav.nextObstacleCheck or 0) then
            nav.nextObstacleCheck = now + 0.1
            local direction = flat(position - root.Position).Unit
            if obstacleAhead(direction) then
                nav.detour = true
                humanoid:Move(Vector3.zero, false)
                local velocity = root.AssemblyLinearVelocity
                root.AssemblyLinearVelocity = Vector3.new(0, velocity.Y, 0)
                print("[Travel] Obstacle ahead; stopping direct sprint for a local route.")
            end
        end
        if not nav.detour then
            local delta = flat(position - root.Position)
            humanoid:Move(delta.Unit, false)
            aim(position)
            return distance
        end
    end

    if nav.busy then
        humanoid:Move(Vector3.zero, false)
        if now - nav.started > 12 then
            state.stop("Travel path calculation timed out")
        end
        return distance
    end
    if nav.needsRetry then
        nav.needsRetry = false
        retryRoute("Route became blocked")
        return distance
    end
    if not nav.points then
        humanoid:Move(Vector3.zero, false)
        requestRoute(position)
        return distance
    end

    local waypoint = nav.points[nav.index]
    while waypoint do
        local delta = flat(waypoint.Position - root.Position)
        local previous = nav.points[nav.index - 1].Position
        local segment = flat(waypoint.Position - previous)
        local passed = segment.Magnitude > 0.01
            and delta:Dot(segment.Unit) <= 0 and delta.Magnitude < 8
        local nearHeight = math.abs(root.Position.Y - waypoint.Position.Y) < 8
        if nearHeight and (delta.Magnitude <= 2 or passed) then
            nav.index = nav.index + 1
            waypoint = nav.points[nav.index]
        else
            break
        end
    end
    if not waypoint then
        departureRequested = false
        resetNavigation()
        humanoid:Move(Vector3.zero, false)
        return distance
    end

    if flat(root.Position - nav.anchor).Magnitude >= 3 then
        nav.anchor, nav.progressAt = root.Position, now
        nav.failures = 0
    elseif now - nav.progressAt >= 3 then
        retryRoute("No movement progress for three seconds")
        return distance
    end

    if waypoint.Action == Enum.PathWaypointAction.Jump and nav.jumpIndex ~= nav.index then
        humanoid.Jump = true
        nav.jumpIndex = nav.index
    end
    local delta = flat(waypoint.Position - root.Position)
    humanoid:Move(delta.Magnitude > 0.05 and delta.Unit or Vector3.zero, false)
    aim(waypoint.Position + Vector3.new(0, 2, 0))
    return distance
end

local function brake()
    humanoid:Move(Vector3.zero, false)
    local velocity = root.AssemblyLinearVelocity
    root.AssemblyLinearVelocity = Vector3.new(0, velocity.Y, 0)
end

local function clearTargets()
    wolf, wolfRoot, wolfHumanoid = nil, nil, nil
    human, humanRoot, humanHumanoid = nil, nil, nil
    phase = "approach"
end

local ok, err = pcall(function()
    print("[Farm] Starts in 2 seconds. Focus game; keep Alt lock on.")
    print("[Farm] Automatic Shift. Continuous run. F6 shuts down.")

    local readyAt = os.clock() + COUNTDOWN
    while os.clock() < readyAt do
        if state.stopped or env.WolfShuttleController ~= state then return end
        task.wait(0.05)
    end
    if state.stopped or env.WolfShuttleController ~= state then return end

    local function update()
        state.attackAllowed = false
        if state.stopped or env.WolfShuttleController ~= state then return end

        local now = os.clock()
        if player.Character ~= character then
            pause("Waiting for character.")
            character = player.Character
            humanoid, root, originalAutoRotate = nil, nil, nil
            recovering = false
            awaitingBloodCheck = false
            nextWolfSearch, nextHumanSearch = 0, 0
            clearTargets()
        end

        if not character or not character.Parent then
            pause("Waiting for respawn.")
            return
        end

        humanoid = character:FindFirstChildOfClass("Humanoid")
        root = character:FindFirstChild("HumanoidRootPart")
        if not humanoid or not root then
            pause("Waiting for character to load.")
            return
        end

        if originalAutoRotate == nil then
            originalAutoRotate = humanoid.AutoRotate
            for _, name in ipairs({
                "WolfHoverPosition", "WolfHoverOrientation", "WolfHoverAttachment"
            }) do
                local object = root:FindFirstChild(name)
                if object then object:Destroy() end
            end
        end

        if humanoid.Health <= 0 then
            pause("Waiting for respawn.")
            return
        end

        local health = humanoid.Health / math.max(humanoid.MaxHealth, 1)
        if health <= PAUSE_HEALTH then recovering = true end
        if recovering and health < RESUME_HEALTH then
            pause("Recovering health; resumes at 50%.")
            return
        end
        recovering = false

        local bloodRatio, bloodValue = bloodReading()
        if not bloodRatio then
            pause("Waiting for BloodThirst and MaxBloodThirst values.")
            return
        end

        -- Travel discovery is independent of the local combat radius.
        if now >= nextLocationSearch then
            nextLocationSearch = now + 2
            local candidate, candidateRoot = nearest(
                workspace:FindFirstChild("Spawn4Werewolves"), TRAVEL_RANGE, false)
            if candidate then memory.wolfPosition = candidateRoot.Position end
        end

        -- Remember a loaded human location for later long-distance travel.
        if mode ~= "feed" and now >= nextHumanSearch then
            nextHumanSearch = now + 2
            local candidate, candidateRoot =
                nearest(workspace:FindFirstChild("Humans"), HUMAN_RANGE, true)
            if candidate then memory.humanPosition = candidateRoot.Position end
        end

        if bloodRatio <= BLOOD_LOW and mode ~= "feed" then
            if alive(wolf, wolfRoot, wolfHumanoid) then
                memory.wolfPosition = wolfRoot.Position
            end
            mode = "feed"
            phase = "approach"
            human, humanRoot, humanHumanoid = nil, nil, nil
            nextHumanSearch = 0
            report("Low blood: starting human refill trip.")
        end

        if mode == "feed" then
            if awaitingBloodCheck and drinkAt
                and now - drinkAt >= DRINK_CHECK_DELAY then

                awaitingBloodCheck = false
                if bloodValue > bloodBeforeDrink + 0.5 then
                    print("[Farm] Blood increased:",
                        bloodBeforeDrink, "->", bloodValue)
                else
                    print("[Farm] No blood increase detected after E.")
                    if lastDrinkHuman then
                        ignoredHumans[lastDrinkHuman] = now + 30
                    end
                    human, humanRoot, humanHumanoid = nil, nil, nil
                    nextHumanSearch = 0
                end
            end

            if bloodRatio >= BLOOD_TARGET
                and not state.drinkBusy and not awaitingBloodCheck then
                state.drinkRequested = false
                mode = "return"
                resetNavigation()
                departureRequested = true
                clearTargets()
                report("Blood refilled: returning to the wolf area.")
                return
            end

            if state.drinkBusy or awaitingBloodCheck then
                stopMovement()
                sprint(false)
                if humanRoot and humanRoot.Parent then
                    aim(humanRoot.Position)
                    face(humanRoot.Position)
                end
                report("Waiting for the drink result.")
                return
            end

            if human and now >= nextQuestCheck then
                nextQuestCheck = now + 1
                if not hasHumanLabel(human) or isQuestNPC(human) then
                    print("[Farm] Skipping NPC without a confirmed Human label:", human:GetFullName())
                    ignoredHumans[human] = now + 10
                    human, humanRoot, humanHumanoid = nil, nil, nil
                    memory.humanPosition = nil
                    state.drinkRequested = false
                    resetNavigation()
                    nextHumanSearch = 0
                end
            end

            if not alive(human, humanRoot, humanHumanoid) then
                human, humanRoot, humanHumanoid = nil, nil, nil
                if now >= nextHumanSearch then
                    nextHumanSearch = now + 1
                    human, humanRoot, humanHumanoid =
                        nearest(workspace:FindFirstChild("Humans"), HUMAN_RANGE, true)
                end
            end

            if not human then
                state.drinkRequested = false
                if memory.humanPosition
                    and flat(memory.humanPosition - root.Position).Magnitude > 15 then
                    report("Sprinting to the last known human location.")
                    travel(memory.humanPosition)
                else
                    pause(memory.humanPosition
                        and "At saved human area: waiting for a living Human to load."
                        or "Human location unknown. Move toward humans; this run keeps checking.")
                end
                return
            end

            memory.humanPosition = humanRoot.Position
            local distance = (humanRoot.Position - root.Position).Magnitude

            if distance > DRINK_DISTANCE then
                state.drinkRequested = false
                report("Sprinting to a human.")
                travel(humanRoot.Position)
                return
            end

            brake()
            sprint(false)
            humanoid.AutoRotate = false
            aim(humanRoot.Position)
            face(humanRoot.Position)

            if now < nextDrinkAt then
                report("At human: waiting for nine-second drinking cooldown.")
            else
                state.drinkRequested = true
                report("At human: requesting one E press.")
            end
            return
        end

        if mode == "return" then
            if memory.wolfPosition
                and flat(memory.wolfPosition - root.Position).Magnitude > 75 then
                report("Sprinting back to the saved wolf area.")
                travel(memory.wolfPosition)
                return
            end
            mode = "hunt"
            nextWolfSearch = 0
        end

        local wolfFolder = workspace:FindFirstChild("Spawn4Werewolves")
        if not wolfFolder then
            if memory.wolfPosition
                and flat(memory.wolfPosition - root.Position).Magnitude > 75 then
                report("Sprinting toward the saved wolf area; waiting for wolves to load.")
                travel(memory.wolfPosition)
            else
                pause("Wolf area unknown or not loaded. Move toward wolves; this run keeps checking.")
            end
            return
        end

        if not alive(wolf, wolfRoot, wolfHumanoid) then
            wolf, wolfRoot, wolfHumanoid = nil, nil, nil
            phase = "approach"

            if now >= nextWolfSearch then
                nextWolfSearch = now + 1
                wolf, wolfRoot, wolfHumanoid =
                    nearest(wolfFolder, WOLF_RANGE, false)
            end

            if not wolf then
                if memory.wolfPosition
                    and flat(memory.wolfPosition - root.Position).Magnitude > 75 then
                    report("Sprinting to the saved wolf area.")
                    travel(memory.wolfPosition)
                else
                    pause(memory.wolfPosition
                        and "At saved wolf area: waiting for a living wolf within 500 studs."
                        or "No loaded wolf within 3500 studs and no saved location. Move toward wolves; no rerun needed.")
                end
                return
            end
            print("[Farm] Selected wolf:", wolf.Name)
        end

        memory.wolfPosition = wolfRoot.Position
        -- Release during the stationary burst so the next moving pass
        -- sends a fresh Shift press instead of trusting a stale held flag.
        sprint(phase ~= "burst")
        report("Fighting wolves.")

        local center = wolfRoot.Position
        aim(center)
        local delta = flat(center - root.Position)
        local distance = delta.Magnitude
        local direction
        if distance > 0.05 then
            direction = delta.Unit
        else
            local facing = flat(root.CFrame.LookVector)
            direction = facing.Magnitude > 0.05
                and facing.Unit or Vector3.new(0, 0, -1)
        end

        if phase == "approach" then
            humanoid.AutoRotate = true
            humanoid:Move(direction, false)
            if distance <= PASS_START_DISTANCE then
                passDirection = direction
                phaseStarted = now
                phase = "pass"
            end
            return
        end

        if phase == "pass" then
            local progress = flat(root.Position - center):Dot(passDirection)
            if progress >= PASS_BEYOND then
                brake()
                if distance <= ATTACK_DISTANCE then
                    phase = "burst"
                    phaseStarted = now
                    sprint(false)
                else
                    phase = "approach"
                    return
                end
            elseif now - phaseStarted >= PASS_TIMEOUT then
                phase = "approach"
                return
            else
                humanoid.AutoRotate = true
                humanoid:Move(passDirection, false)
                return
            end
        end

        if phase == "burst" then
            humanoid:Move(Vector3.zero, false)
            humanoid.AutoRotate = false
            if now - phaseStarted >= BURST_DURATION
                or distance > ATTACK_DISTANCE then
                phase = "approach"
                return
            end
            face(center)
            state.attackAllowed = true
        end
    end

    RunService:BindToRenderStep(
        bindingName,
        Enum.RenderPriority.Last.Value - 1,
        function()
            local frameOk, frameError = pcall(update)
            if not frameOk then
                warn("[Farm]", frameError)
                state.stop("Movement, refill, or camera error")
            end
        end
    )
    bound = true

    state.workerStarted = true
    task.spawn(function()
        local workerOk, workerError = pcall(function()
            while not state.stopped and env.WolfShuttleController == state do
                local characterReady = character == player.Character
                    and humanoid and humanoid.Parent and humanoid.Health > 0
                    and root and root.Parent

                if characterReady and mode == "feed"
                    and state.drinkRequested and not state.drinkBusy
                    and alive(human, humanRoot, humanHumanoid)
                    and hasHumanLabel(human) and not isQuestNPC(human)
                    and os.clock() >= nextDrinkAt
                    and (humanRoot.Position - root.Position).Magnitude
                        <= DRINK_DISTANCE then

                    state.drinkRequested = false
                    state.drinkBusy = true
                    local _, bloodValue = bloodReading()
                    bloodBeforeDrink = bloodValue
                    lastDrinkHuman = human
                    drinkAt = os.clock()
                    nextDrinkAt = drinkAt + DRINK_COOLDOWN
                    memory.nextDrinkAt = nextDrinkAt
                    awaitingBloodCheck = true

                    sprint(false)
                    state.eHeld = true
                    virtualInput:SendKey(true, Enum.KeyCode.E, false)
                    task.wait(0.08)

                    if not releaseKey("eHeld", Enum.KeyCode.E) then
                        error("E release failed")
                    end
                    state.drinkBusy = false
                    if state.stopped or env.WolfShuttleController ~= state then break end
                    drinks = drinks + 1
                    print("[Farm] E sent; checking blood increase.")

                elseif characterReady and mode == "hunt"
                    and state.attackAllowed
                    and humanoid.Health > humanoid.MaxHealth * PAUSE_HEALTH
                    and alive(wolf, wolfRoot, wolfHumanoid)
                    and flat(wolfRoot.Position - root.Position).Magnitude
                        <= ATTACK_DISTANCE then

                    state.mouseHeld = true
                    press()
                    task.wait(HOLD_TIME)

                    if not releaseMouse() then error("Mouse release failed") end
                    if state.stopped or env.WolfShuttleController ~= state then break end
                    clicks = clicks + 1
                    task.wait(GAP_TIME)
                else
                    task.wait(0.01)
                end
            end
        end)

        releaseMouse()
        releaseKey("eHeld", Enum.KeyCode.E)
        state.drinkBusy = false
        if not workerOk then
            warn("[Farm]", workerError)
            state.stop("Input error")
        end
        state.workerFinished = true
    end)

    while not state.stopped and env.WolfShuttleController == state do
        task.wait(0.1)
    end
end)

if not ok then
    warn("[Farm]", err)
    state.reason = "Script error"
end

state.stopped = true
cleanup()
print("[Farm] Stopped:", state.reason)
print("[Farm] Completed attack click pairs:", clicks)
print("[Farm] Drinking attempts:", drinks)