Scribd
Upload
325 views10 pages

Server Hop Configuration Script

The document is a Lua script for a Roblox game bot called 'Alt Hunter Pro', designed to scan for specific targets based on a defined pattern and report findings via a Discord webhook. It includes features such as server hopping, target scanning within a specified radius, and UI updates to reflect the current status and actions. The script also implements anti-detection measures and allows for configuration adjustments like scan radius and player limits.

Uploaded by

aopenhimer
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
325 views10 pages

Server Hop Configuration Script

The document is a Lua script for a Roblox game bot called 'Alt Hunter Pro', designed to scan for specific targets based on a defined pattern and report findings via a Discord webhook. It includes features such as server hopping, target scanning within a specified radius, and UI updates to reflect the current status and actions. The script also implements anti-detection measures and allows for configuration adjustments like scan radius and player limits.

Uploaded by

aopenhimer
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd

-- alt_hunter_pro_fixed.

lua
local CONFIG = {
GAME_ID = 109983668079237,
TARGET_PATTERN = "TralaleroTralala",
WEBHOOK_URL = "[Link]
GHdidQyljf3ONIvGebPSs7EqP_68sS_FV_nZc3bohUWlBv2BY3yy3iIMYmA",
SCAN_RADIUS = 5000,
SERVER_HOP_DELAY = 10,
MAX_SERVERS = 100,
DEBUG_MODE = true,
ANTI_DETECTION = true,
MAX_TARGETS = 3,
MIN_PLAYERS = 5,
MAX_PLAYERS = 30
}

-- Servicios esenciales
local Players = game:GetService("Players")
local HttpService = game:GetService("HttpService")
local TeleportService = game:GetService("TeleportService")
local Workspace = game:GetService("Workspace")
local RunService = game:GetService("RunService")
local CoreGui = game:GetService("CoreGui")
local LocalPlayer = [Link]

-- Variables para la UI
local UI = {
Enabled = true,
MainWindow = nil,
Tabs = {},
Status = {
Scanning = false,
TargetsFound = 0,
ServersScanned = 0,
CurrentAction = "Iniciando..."
}
}

-- Variables de estado
local HunterState = {
Active = false,
Paused = false,
LastScan = 0,
LastServerHop = 0,
Targets = {}
}

-- Función para actualizar la UI


local function updateUI()
if not [Link] then return end

if [Link] then
[Link] = "Estado: " .. [Link]
end

if [Link] then
[Link]()
end
if [Link] then
[Link]()
end
end

-- Escáner optimizado
local function deepScan()
local foundTargets = {}
local rootPart = [Link] and
[Link]:FindFirstChild("HumanoidRootPart")
if not rootPart then
[Link] = "Esperando personaje..."
updateUI()
return foundTargets
end

local rootPosition = [Link]


local startTime = [Link]()
local scannedInstances = 0
local targetLower = [Link](CONFIG.TARGET_PATTERN)

local isModel = [Link]("Model").ClassName


local isFolder = [Link]("Folder").ClassName

local function scanRecursive(parent)


for _, child in ipairs(parent:GetChildren()) do
if not [Link] then break end
while [Link] do [Link](1) end

scannedInstances = scannedInstances + 1

local childLower = [Link]([Link])


if [Link](childLower, targetLower, 1, true) then
local success, objectPos = pcall(function()
return child:GetPivot().Position
end)

if success then
local distance = (objectPos - rootPosition).Magnitude

if distance <= CONFIG.SCAN_RADIUS then


[Link](foundTargets, {
name = [Link],
fullName = child:GetFullName(),
position = objectPos,
distance = [Link](distance),
timestamp = [Link](),
instance = child
})

[Link] = [Link]("Objetivo
encontrado a %d studs", distance)
updateUI()
end
end
end

local childClass = [Link]


if childClass == isModel or childClass == isFolder then
scanRecursive(child)
end
end
end

local priorityAreas = {
Workspace,
Workspace:FindFirstChild("Map") or Workspace,
Workspace:FindFirstChild("GameObjects") or Workspace,
Workspace:FindFirstChild("Workspace") or Workspace
}

[Link] = "Escaneando entorno..."


updateUI()

for _, area in ipairs(priorityAreas) do


if not [Link] then break end
local success, err = pcall(scanRecursive, area)
if not success and CONFIG.DEBUG_MODE then
warn("Error escaneando área:", area:GetFullName(), "| Error:", err)
end
end

[Link](foundTargets, function(a, b) return [Link] < [Link] end)

if CONFIG.DEBUG_MODE then
print([Link]("🔍 Escaneo completado en %.2fs | %d instancias | %d
objetivos",
[Link]() - startTime, scannedInstances, #foundTargets))
end

[Link] = [Link]("Escaneo completado (%d obj)",


#foundTargets)
updateUI()

return foundTargets
end

-- Sistema de reportes mejorado


local function sendHunterReport(targets, jobId)
local embeds = {}
local content = nil

if #targets > 0 then


content = "@everyone 🎯 OBJETIVO ENCONTRADO"
local playerCount = #Players:GetPlayers()

for i, target in ipairs(targets) do


if i <= 3 then
local embedColor = i == 1 and 65280 or (i == 2 and 16753920 or
16711680)

[Link](embeds, {
title = [Link]("🎯 OBJETO #%d - %d studs", i,
[Link]),
description = [Link]("```%s```", [Link]),
color = embedColor,
fields = {
{name = "📍 Posición", value = [Link]("X: %.1f | Y:
%.1f | Z: %.1f",
[Link].X, [Link].Y,
[Link].Z)},
{name = "🕒 Hora", value = [Link]("%H:%M:%S",
[Link])},
{name = "👥 Jugadores", value = playerCount},
{name = "🔗 Enlace directo", value = [Link]("[Unirse
al servidor](roblox://placeId=%d&gameInstanceId=%s)",
CONFIG.GAME_ID, jobId)}
},
footer = {text = [Link]("Servidor: %s", jobId)}
})
end
end
else
[Link](embeds, {
title = "🔍 ESCANEO COMPLETADO",
description = "No se encontraron objetivos coincidentes",
color = 8421504,
fields = {
{name = "🔎 Patrón buscado", value = [Link]("```%s```",
CONFIG.TARGET_PATTERN)},
{name = "📏 Radio de búsqueda", value = [Link]("%d studs",
CONFIG.SCAN_RADIUS)},
{name = "🆔 ID Servidor", value = jobId or [Link]}
},
footer = {text = [Link]("%H:%M:%S")}
})
end

local payload = {
username = "AltHunter Pro",
avatar_url = "[Link]
content = content,
embeds = embeds
}

local maxAttempts = 3
local attempts = 0
local success = false

repeat
attempts += 1
success = pcall(function()
local response
if syn and [Link] then
response = [Link]({
Url = CONFIG.WEBHOOK_URL,
Method = "POST",
Headers = {["Content-Type"] = "application/json"},
Body = HttpService:JSONEncode(payload),
Timeout = 10
})

if [Link] ~= 204 then


error("Código de estado: "..[Link])
end
else
HttpService:PostAsync(CONFIG.WEBHOOK_URL,
HttpService:JSONEncode(payload))
end
end)

if not success and attempts < maxAttempts then


[Link](2 ^ attempts)
end
until success or attempts >= maxAttempts

if not success and CONFIG.DEBUG_MODE then


warn("⚠️ Error al enviar reporte después de", attempts, "intentos")
end

return success
end

-- Obtención de servidores mejorada


local function getActiveServers()
local servers = {}

[Link] = "Buscando servidores..."


updateUI()

local success, response = pcall(function()


return game:HttpGet([Link](
"[Link]
sortOrder=Asc&limit=%d",
CONFIG.GAME_ID, CONFIG.MAX_SERVERS
), true, {["Cache-Control"] = "no-cache"})
end)

if success then
local data = HttpService:JSONDecode(response)
for _, server in ipairs([Link]) do
if [Link] and [Link] >= CONFIG.MIN_PLAYERS and
[Link] <= CONFIG.MAX_PLAYERS then
[Link](servers, {
id = [Link],
players = [Link],
ping = [Link](50, 150)
})
end
end

[Link](servers, function(a, b)
return [Link] < [Link] or ([Link] == [Link] and [Link] > [Link])
end)
else
if CONFIG.DEBUG_MODE then
warn("⚠️ Error al obtener servidores:", response)
if [Link] ~= "" then
[Link](servers, {id = [Link], players =
#Players:GetPlayers(), ping = 100})
end
end
end

return servers
end
-- Unión a servidores mejorada
local function joinServer(serverInfo)
local jobId = [Link]
local attempts = 0
local maxAttempts = 3
local success = false

[Link] = [Link]("Uniendo a servidor (%d/%d jug)",


[Link], CONFIG.MAX_PLAYERS)
updateUI()

if CONFIG.DEBUG_MODE then
print([Link]("🛫 Intentando unirse a %s (%d jugadores, ping: %dms)",
jobId, [Link], [Link]))
end

repeat
attempts += 1
success = pcall(function()
if [Link] then
TeleportService:AbortTeleport()
[Link](0.5)
end

TeleportService:TeleportToPlaceInstance(CONFIG.GAME_ID, jobId,
LocalPlayer)
end)

if success then
local loadStart = [Link]()
local loaded = false

while [Link]() - loadStart < 30 do


if game:IsLoaded() and Workspace:FindFirstChildWhichIsA("BasePart")
then
loaded = true
break
end
[Link](1)
end

if not loaded then


if CONFIG.DEBUG_MODE then
warn("⚠️ Timeout de carga para servidor:", jobId)
end
success = false
else
local charStart = [Link]()
while [Link]() - charStart < 15 do
if [Link] and
[Link]:FindFirstChild("HumanoidRootPart") then
break
end
[Link](1)
end

if not [Link] then


if CONFIG.DEBUG_MODE then
warn("⚠️ No se pudo cargar el personaje en servidor:",
jobId)
end
success = false
end
end
end

if not success and attempts < maxAttempts then


local delay = [Link](5 * attempts, 15)
[Link](delay)
end
until success or attempts >= maxAttempts

return success
end

-- Ciclo principal de búsqueda (definido después de todas las funciones que usa)
local function huntingLoop()
print("\n=== INICIANDO ALT HUNTER PRO ===")
print([Link]("🔍 Buscando '%s' en radio de %d studs",
CONFIG.TARGET_PATTERN, CONFIG.SCAN_RADIUS))

[Link] = 0
[Link] = 0
[Link] = "Iniciando búsqueda..."
updateUI()

local stopFile = "alt_hunter_stop.txt"


if isfile and isfile(stopFile) then
delfile(stopFile)
end

while [Link] do
if isfile and isfile(stopFile) then
print("🛑 Detención emergente activada. Finalizando ejecución.")
[Link] = "Detenido por archivo de parada"
updateUI()
sendHunterReport({}, [Link])
return
end

while [Link] do
[Link] = "Búsqueda en pausa..."
updateUI()
[Link](1)
end

local servers = getActiveServers()


[Link] = [Link] + #servers
updateUI()

if #servers == 0 then
warn("❌ No se obtuvieron servidores válidos. Reintentando en 2
minutos...")
[Link] = "Esperando servidores..."
updateUI()
[Link](120)
continue
end

if CONFIG.DEBUG_MODE then
print([Link]("🌐 %d servidores disponibles | %d analizados hasta
ahora",
#servers, [Link]))
end

for _, server in ipairs(servers) do


if not [Link] then break end
while [Link] do [Link](1) end

if joinServer(server) then
if CONFIG.ANTI_DETECTION then
CONFIG.SERVER_HOP_DELAY = [Link](CONFIG.SERVER_HOP_DELAY-
2, CONFIG.SERVER_HOP_DELAY+5)
[Link]([Link](1, 3))
end

local scanStart = [Link]()


[Link] = deepScan()
local scanTime = [Link]() - scanStart

if #[Link] > 0 then


[Link] = [Link] +
#[Link]
updateUI()
sendHunterReport([Link], [Link])

if [Link][1].distance < 100 then


print("🎯 Objetivo principal encontrado! Finalizando
búsqueda.")
[Link] = "Objetivo principal encontrado!"
updateUI()
return
else
print("🎯 Objetivo encontrado pero continuando búsqueda...")
end
elseif CONFIG.DEBUG_MODE then
print([Link]("🔍 Escaneo completado en %.1fs - Sin
objetivos", scanTime))
end

if [Link] % 10 == 0 then
sendHunterReport({}, [Link])
end
end

local delay = CONFIG.SERVER_HOP_DELAY


if #[Link] > 0 then
delay = delay * 2
end
[Link](delay)
end

if CONFIG.DEBUG_MODE then
local elapsed = [Link]() - [Link]
print([Link]("🔁 Ciclo completado | %d servidores | %d objetivos
| %02d:%02d ejecutándose",
[Link], [Link], elapsed/60,
elapsed%60))
end

[Link] = "Refrescando lista de servidores..."


updateUI()
[Link](30)
end

[Link] = "Búsqueda detenida"


updateUI()
end

-- Función para iniciar la caza de manera segura


local function startHunting()
if huntingLoop then
[Link](huntingLoop)()
else
warn("Error: huntingLoop no está definida")
end
end

-- [Resto del código de la UI (createUI, etc.) permanece igual]

-- Inicialización corregida
local function initialize()
if not [Link] then
if [Link] then
[Link] = "Estado: Esperando personaje..."
end
[Link]:Wait()
end

createUI()

if syn and syn.is_beta then


syn.toast_notification("Alt Hunter Pro", "Presiona F5 para mostrar/ocultar
la interfaz", 5)

local UIVisible = true


game:GetService("UserInputService").InputBegan:Connect(function(input,
processed)
if not processed and [Link] == [Link].F5 then
UIVisible = not UIVisible
if [Link] then
[Link] = UIVisible
end
end
end)
end

[Link] = [Link]()
updateUI()

print("\n=== ALT HUNTER PRO INICIALIZADO ===")


print("Configuración actual:")
for k, v in pairs(CONFIG) do
print([Link]("%s: %s", k, tostring(v)))
end
if [Link] then
print("\nInterfaz de usuario disponible. Usa los controles para iniciar la
búsqueda.")
end
end

-- Iniciar el script de manera segura


local success, err = pcall(initialize)
if not success then
warn("Error durante la inicialización:", err)
end

Common questions

Powered by AI

The script sorts the found targets based on proximity to the player, ensuring that closer targets are prioritized. This is done by sorting the "foundTargets" list by distance before any reporting occurs. For reporting, a detailed message is crafted using Discord webhooks with the targets as embeds. Each target report includes details like distance, position, timestamp, and player count, and is color-coded based on priority. If targets are found, a notification is sent to alert users. Additionally, the script attempts multiple times to send these reports to ensure delivery, retrying if it encounters an error during the process .

The script employs several measures to avoid detection while server hopping. It randomly adjusts the delay between server hops, within a specified range, to prevent predictable patterns. Additionally, it introduces random pauses between actions and utilizes an "ANTI_DETECTION" configuration that essentially varies the server hopping delay further. The script also interacts with and attempts to abort any initiated teleports to prevent unintended teleportation actions that might raise suspicion. These strategies reduce the chance of being detected as an automated process by creating more human-like behavior patterns .

The script adapts its behavior dynamically based on game conditions and configuration settings. For instance, it uses conditions like whether targets are found to adjust server hopping delay. It further adapts by pausing scanning operations when paused by user directives, waiting for specified conditions like target distance to alter its search strategy, and even adapting network requests if the initial attempts fail. These adaptive mechanisms ensure the script operates efficiently and effectively under varying conditions, maintaining operability despite external changes and user-specified configurations .

The Alt Hunter Pro script employs a combination of error handling techniques using pcall (protected call) functions to safely execute potentially error-prone code blocks, such as acquiring game server data or sending reports over HTTP. When an error is encountered during these operations, such as failure to acquire server data or incorrect HTTP responses, the script logs the errors to the console (if debugging is enabled) and retries the operation after a short delay. This ensures robustness by not crashing the entire script when an error occurs but rather handling it gracefully with retries .

Optimizing server list retrieval is crucial to ensure that the script quickly finds and connects to the most suitable servers, improving efficiency and reducing wait times. The script fetches a list of active servers with a public API call, filtering only those that meet specific player count criteria. It sorts these servers first by ascending ping and then by descending player count to prioritize connectivity and potential discoveries. This optimization ensures that the script connects to servers swiftly, reducing delays and enhancing the hunting process efficiency significantly .

The script integrates with Discord to report scanning results by crafting JSON payloads that include a combination of regular messages and richly formatted embeds for detail enhancement. Embeds are utilized to format detailed information about each target, including distance and position, which are visually distinct due to color coding. To ensure message delivery, the script attempts to send each report up to three times. If it fails to receive a successful status code from Discord's webhook API, it waits progressively longer between retries before abating the attempt. This approach maximizes the likelihood of successful delivery while minimizing server load .

The "deepScan" function is designed to search the game environment iteratively, looking for specific game objects that match a pre-defined pattern within a certain scan radius. It uses recursive scanning to traverse through game instances, checking each child's name against the target pattern. If a match is found, it calculates the distance of the target from the player's position and adds it to a list of found targets. These results are then updated in the user interface, ensuring that the status is clear and up-to-date. This function not only identifies potential targets but also considers scan performance and accuracy .

The script's initialization is designed to be both comprehensive and error-tolerant. It starts by waiting for the player's character to load and creating a user interface for interaction. The initialization includes error handling by using pcall to safely execute parts of the initialization process. If any errors occur, they are logged for debugging instead of crashing the script. By preparing the character and UI setup first, the script ensures that the dependencies are ready before executing the main logic, thereby minimizing problems during runtime and allowing for detailed introspection and debugging .

The script enhances user interaction by capturing specific user input events, such as pressing F5, to toggle the user interface visibility. This interaction allows users to choose when they see the interface without needing to stop or alter the script's execution. The script uses the "InputBegan" event from the UserInputService, listening for the F5 key press to show or hide the UI main window dynamically. This feature provides a more interactive and customizable experience for the user, enabling more direct control over the script's display and operation status .

The script manages the user interface by using a dedicated set of variables and functions to update UI elements in real-time. The "updateUI" function checks for the presence of the main window and updates several components like status labels and statistics. This function is called throughout the script whenever the status or action changes, ensuring that users are provided with current information. It shows the current action status, scan progress, and other important metrics in the interface, keeping users informed and engaged with the script's operations .

You might also like