auto rrs farm

-- Kuchisake Radar: embedded runtime for guarded teleport reloads.
local source = [========[
return function(reloadSource, resume)
if game.GameId ~= 9199655655 then warn("Kuchisake Radar only runs in Gakuran"); return end
if not game:IsLoaded() then game.Loaded:Wait() end
local environment = (type(getgenv) == "function" and getgenv()) or _G
local compiler = assert(loadstring, "Kuchisake Radar requires loadstring")
local Rere
local previous = environment.__KuchisakeRadarRere
if type(previous) == "table" and type(previous.Stop) == "function" then previous:Stop() end
local app = {Alive = true, Connections = {}, Sounds = {}}
environment.__KuchisakeRadarRere = app
local function connect(signal, callback)
    local connection = signal:Connect(callback)
    table.insert(app.Connections, connection)
    return connection
end

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")
local Debris = game:GetService("Debris")
local LocalPlayer = Players.LocalPlayer or Players.PlayerAdded:Wait()

local function readServerMinutes()
    local world = ReplicatedStorage:FindFirstChild("World")
    local clock = world and world:FindFirstChild("MinutesOfDay")
    local value = clock and clock:IsA("NumberValue") and clock.Value
    if type(value) == "number" and value == value and value >= 0 and value < math.huge then return value % 1440 end
    return nil
end
app.InitialMinutes = readServerMinutes()

-- KUCHISAKE_AUTO_RELOAD_V1
do
    local HttpService = game:GetService("HttpService")
    local queue = queue_on_teleport or queueonteleport or (type(syn) == "table" and syn.queue_on_teleport)
    local path = "larp/config/KuchisakeRadar/AutoHop_" .. tostring(game.PlaceId) .. "_" .. tostring(LocalPlayer.UserId) .. ".json"
    local auto = {Enabled = resume == nil or resume.AutoEnabled == true, NextAttempt = 0, Status = "Auto: checking server time..."}
    app.Auto = auto
    auto.Ready = type(queue) == "function" and type(writefile) == "function" and type(readfile) == "function"
        and type(makefolder) == "function" and type(reloadSource) == "string" and #reloadSource > 0
    if not auto.Ready then
        auto.Enabled = false
        auto.Status = "Auto unavailable: teleport queue and writable workspace required"
    end
    local function inWindow(minutes) return minutes ~= nil and minutes >= 990 and minutes <= 1200 end
    function auto:Revoke()
        if not self.Nonce then return end
        local nonce = self.Nonce
        local ok, err = pcall(function()
            local record = HttpService:JSONDecode(readfile(path))
            if record.Nonce == nonce then
                record.Enabled = false
                writefile(path, HttpService:JSONEncode(record))
                local saved = HttpService:JSONDecode(readfile(path))
                assert(saved.Nonce == nonce and saved.Enabled == false, "reload cancellation was not saved")
            end
        end)
        if ok then self.Nonce = nil else warn("Kuchisake Radar: queued reload cancellation failed: " .. tostring(err)) end
    end
    function auto:Arm(id)
        assert(self.Ready, "Teleport queue and writable workspace required")
        self:Revoke()
        local nonce = HttpService:GenerateGUID(false)
        pcall(makefolder, "larp")
        pcall(makefolder, "larp/config")
        pcall(makefolder, "larp/config/KuchisakeRadar")
        local record = {Version = 1, Enabled = true, AutoEnabled = self.Enabled, Nonce = nonce,
            PlaceId = game.PlaceId, UserId = LocalPlayer.UserId, Destination = id, Origin = game.JobId, ExpiresAt = os.time() + 180,
            ServerListNextAt = app.Hop and app.Hop.NextRequestAt,
            AutoAttackEnabled = not app.Combat or app.Combat.Enabled,
            AutoParryEnabled = not app.Combat or app.Combat.ParryEnabled}
        self.Nonce = nonce
        writefile(path, HttpService:JSONEncode(record))
        local saved = HttpService:JSONDecode(readfile(path))
        assert(saved.Nonce == nonce and saved.Enabled == true, "reload state was not saved")
        -- Old queued attempts are inert: only the current nonce, account, place and destination may resume.
        local code = string.format([==[
if game.PlaceId ~= %d then return end
if not game:IsLoaded() then game.Loaded:Wait() end
local players = game:GetService("Players")
local player = players.LocalPlayer or players.PlayerAdded:Wait()
if player.UserId ~= %d or game.JobId ~= %q then return end
local service = game:GetService("HttpService")
local ok, record = pcall(function() return service:JSONDecode(readfile(%q)) end)
if not ok or type(record) ~= "table" or record.Version ~= 1 or record.Enabled ~= true
    or record.Nonce ~= %q or record.PlaceId ~= game.PlaceId or record.UserId ~= player.UserId
    or record.Destination ~= game.JobId or record.Origin == game.JobId
    or type(record.ExpiresAt) ~= "number" or record.ExpiresAt ~= record.ExpiresAt
    or record.ExpiresAt == math.huge or record.ExpiresAt < os.time() then return end
record.Enabled = false
local consumed = pcall(function()
    local path = %q
    writefile(path, service:JSONEncode(record))
    local saved = service:JSONDecode(readfile(path))
    assert(saved.Nonce == record.Nonce and saved.Enabled == false)
end)
if not consumed then return end
local source = %q
local factory = assert(loadstring(source, "KuchisakeRadar/Reload"))()
return factory(source, {AutoEnabled = record.AutoEnabled == true, ServerListNextAt = record.ServerListNextAt,
    AutoAttackEnabled = record.AutoAttackEnabled ~= false, AutoParryEnabled = record.AutoParryEnabled ~= false})
]==], game.PlaceId, LocalPlayer.UserId, id, path, nonce, path, reloadSource)
        queue(code)
    end
    function auto:SetEnabled(enabled)
        self.Enabled = enabled == true and self.Ready
        self.NextAttempt = 0
        if not self.Enabled then
            self:Revoke()
            if app.Hop and app.Hop.Automatic then app.Hop:Stop() end
            self.Status = self.Ready and "Auto: off" or "Auto unavailable: teleport queue and writable workspace required"
        end
    end
    function auto:Stop()
        self.Enabled = false
        self:Revoke()
        self.Status = "Auto: stopped"
    end
    function auto:AllowHop()
        local minutes = readServerMinutes()
        return self.Enabled and minutes ~= nil and not inWindow(minutes)
            and not (app.Combat and app.Combat:HasTarget())
    end
    function auto:Tick()
        if not app.Alive or not self.Enabled then return end
        if app.Combat and app.Combat.ScanTarget then app.Combat:ScanTarget() end
        if not app.Alive or not self.Enabled then return end
        if app.Combat and app.Combat:HasTarget() then
            self.Status = "Auto: staying (combat target active)"
            if app.Hop.Busy and app.Hop.Automatic and not app.Hop.Pending then app.Hop:Stop() end
            return
        end
        local minutes = readServerMinutes()
        if minutes == nil then self.Status = "Auto: waiting for server clock"; return end
        if inWindow(minutes) then
            self.Status = "Auto: staying (16:30-20:00)"
            if app.Hop.Busy and app.Hop.Automatic and not app.Hop.Pending then app.Hop:Stop() end
            return
        end
        if not app.Hop.Busy and os.clock() < self.NextAttempt then
            self.Status = "Auto: retry in " .. tostring(math.ceil(self.NextAttempt - os.clock())) .. "s"
            return
        end
        self.Status = "Auto: outside 16:30-20:00; finding another server"
        if not app.Hop.Busy and os.clock() >= self.NextAttempt then app.Hop:Start(true) end
    end
end
-- KUCHISAKE_AUTO_RELOAD_END

-- KUCHISAKE_MANUAL_SERVER_HOP_V1
do
    local HttpService = game:GetService("HttpService")
    local TeleportService = game:GetService("TeleportService")
    local historyKey = tostring(game.PlaceId) .. "_" .. tostring(LocalPlayer.UserId)
    local historyPath = "larp/config/KuchisakeRadar/ServerHistory_" .. historyKey .. ".json"
    local memory = environment.__KuchisakeRadarHopHistory
    if type(memory) ~= "table" then memory = {}; environment.__KuchisakeRadarHopHistory = memory end
    if type(memory[historyKey]) ~= "table" then memory[historyKey] = {} end
    local hop = {Busy = false, Epoch = 0, Visited = memory[historyKey], Status = "Server hop: ready", StorageNote = "memory only"}
    app.Hop = hop
    local requestApi = request or http_request or (type(http) == "table" and http.request)
    local rate = environment.__KuchisakeRadarServerApi
    if type(rate) ~= "table" then rate = {}; environment.__KuchisakeRadarServerApi = rate end
    local function finiteDelay(value)
        return type(value) == "number" and value == value and value >= 0 and value < math.huge
    end
    if not finiteDelay(rate.NextRequestAt) then rate.NextRequestAt = 0 end
    if not finiteDelay(rate.Failures) then rate.Failures = 0 end
    if resume and finiteDelay(resume.ServerListNextAt) then
        rate.NextRequestAt = math.max(rate.NextRequestAt, math.min(resume.ServerListNextAt, os.time() + 300))
    end
    hop.NextRequestAt = rate.NextRequestAt
    local function deferRequest(seconds)
        rate.NextRequestAt = math.max(rate.NextRequestAt, os.time() + seconds)
        hop.NextRequestAt = rate.NextRequestAt
    end
    local function validId(id) return type(id) == "string" and #id > 0 and #id <= 128 end
    local function active(epoch) return app.Alive and hop.Busy and hop.Epoch == epoch end
    local function cancel(thread)
        if thread and thread ~= coroutine.running() and type(task.cancel) == "function" then pcall(task.cancel, thread) end
    end
    function hop:Finish(text)
        if app.Auto and self.Pending then app.Auto:Revoke() end
        self.Busy = false
        self.Pending = nil
        self.Status = text
        cancel(self.Timeout)
        cancel(self.RequestTimeout)
        cancel(self.Thread)
        self.Timeout, self.RequestTimeout, self.Thread = nil, nil, nil
        if app.Auto then app.Auto.NextAttempt = os.clock() + math.max(5, rate.NextRequestAt - os.time()) end
    end
    function hop:Stop()
        self.Epoch += 1
        self:Finish("Server hop: stopped")
    end
    local function loadHistory()
        if type(isfile) ~= "function" or type(readfile) ~= "function" then return end
        local ok, exists = pcall(isfile, historyPath)
        if not ok then error("Cannot check saved server history") end
        if not exists then return end
        local bytes = readfile(historyPath)
        if type(bytes) ~= "string" or #bytes > 2 * 1024 * 1024 then error("Saved server history is too large") end
        local saved = HttpService:JSONDecode(bytes)
        if type(saved) ~= "table" or saved.Version ~= 1 or saved.PlaceId ~= game.PlaceId
            or saved.UserId ~= LocalPlayer.UserId or type(saved.Visited) ~= "table" then error("Invalid saved server history") end
        for id, stamp in pairs(saved.Visited) do
            if not validId(id) or type(stamp) ~= "number" or stamp ~= stamp or stamp <= 0 or stamp == math.huge then
                error("Invalid saved server history entry")
            end
        end
        for id, stamp in pairs(saved.Visited) do hop.Visited[id] = stamp end
    end
    local historyOk, historyError = pcall(loadHistory)
    if not historyOk then
        hop.HistoryError = "Server hop disabled: " .. tostring(historyError):sub(1,160)
        hop.Status = hop.HistoryError
    end
    if validId(game.JobId) then hop.Visited[game.JobId] = os.time() end
    if historyOk and type(writefile) == "function" and type(makefolder) == "function" then
        local saved = pcall(function()
            pcall(makefolder, "larp")
            pcall(makefolder, "larp/config")
            pcall(makefolder, "larp/config/KuchisakeRadar")
            writefile(historyPath, HttpService:JSONEncode({Version = 1, PlaceId = game.PlaceId, UserId = LocalPlayer.UserId, Visited = hop.Visited}))
        end)
        if saved then hop.StorageNote = "history saved" end
    end
    local function awaitRequest(epoch)
        while active(epoch) and os.time() < rate.NextRequestAt do
            hop.Status = "Server hop: API cooldown " .. tostring(math.ceil(rate.NextRequestAt - os.time())) .. "s"
            task.wait(math.min(1, rate.NextRequestAt - os.time()))
        end
        if not active(epoch) then return false end
        -- The native endpoint advertises 3 requests/minute; preserve pacing across queued reloads.
        deferRequest(22)
        return true
    end
    local function apiFailure(message, retryAfter)
        rate.Failures = math.min(rate.Failures + 1, 4)
        local delay = math.max(math.min(60 * 2 ^ (rate.Failures - 1), 300), retryAfter or 0)
        deferRequest(delay)
        error(message .. "; retry in " .. tostring(math.ceil(delay)) .. "s", 0)
    end
    local function fetchPage(url, epoch)
        if not awaitRequest(epoch) then return nil end
        local function callWithTimeout(callback)
            local timer = task.delay(30, function()
                if active(epoch) then hop:Finish("Server hop: HTTP timed out; retry later") end
            end)
            hop.RequestTimeout = timer
            local ok, response = pcall(callback)
            cancel(timer)
            if hop.RequestTimeout == timer then hop.RequestTimeout = nil end
            return ok, response
        end
        local body, status, headers
        if type(requestApi) == "function" then
            local ok, response = callWithTimeout(function() return requestApi({Url = url, Method = "GET"}) end)
            if not active(epoch) then return nil end
            if ok and type(response) == "table" and type(response.Body) == "string" then
                body, status, headers = response.Body, tonumber(response.StatusCode), response.Headers
            else
                -- Some executors reject Roblox URLs in request(); retain HttpGet compatibility, paced too.
                if not awaitRequest(epoch) then return nil end
            end
        end
        if not body then
            local ok, response = callWithTimeout(function() return game:HttpGet(url, false) end)
            if not active(epoch) then return nil end
            if not ok then apiFailure("Server list HTTP failed: " .. tostring(response):sub(1, 120)) end
            body = response
        end
        local normalized = {}
        if type(headers) == "table" then
            for key, value in pairs(headers) do normalized[string.lower(tostring(key))] = tostring(value) end
        end
        local retryAfter = tonumber(normalized["retry-after"])
        local reset = tonumber(normalized["x-ratelimit-reset"])
        if not finiteDelay(retryAfter) then retryAfter = nil end
        if not finiteDelay(reset) then reset = nil end
        if tonumber(normalized["x-ratelimit-remaining"]) == 0 and reset then deferRequest(math.min(reset + 1, 300)) end
        if status and (status < 200 or status >= 300) then
            apiFailure("Server list HTTP " .. tostring(status), math.min(math.max(retryAfter or 0, reset or 0), 300))
        end
        local ok, response = pcall(function() return HttpService:JSONDecode(body) end)
        if not ok or type(response) ~= "table" then apiFailure("Server list returned invalid JSON") end
        if type(response.data) ~= "table" then
            local detail = "missing data"
            if type(response.errors) == "table" then
                local first = response.errors[1]
                if type(first) == "table" then
                    local message = tostring(first.message or ""):gsub("[%c]", " "):sub(1, 100)
                    detail = "Roblox API error " .. tostring(first.code or "unknown") .. (message ~= "" and (": " .. message) or " (empty message)")
                end
            end
            apiFailure("Server list: " .. detail)
        end