Bot de automatización

// ── Conexión WebSocket al servidor del juego ──
const webSocket = new WebSocket(
  `wss://${botConfig.gameURL}/`
)

webSocket.onopen = () => {
  // 1. Version check (XML)
  webSocket.send(
    '<msg t="sys"><body action="verChk" r="0">'
    + '<ver v="166"/></body></msg>'
  )
}

webSocket.onmessage = ({ data: message }) => {
  // ── SmartFox %xt% frames ──
  if (message.charAt(0) === "%") {
    let [,,cmd,, r, obj] = message.split("%")
    const result = Number(r)
    obj = JSON.parse(obj)

    // "gbd" = game bulk data → emitir cada clave
    if (cmd === "gbd")
      for (const [key, value] of Object.entries(obj))
        xtHandler.emit(key, value, 0)
    else
      xtHandler.emit(cmd, obj, result)
  }
  // ── XML handshake responses ──
  else if (message.includes("apiOK")) {
    webSocket.send(`<msg t="sys"><body action="login"
      r="0"><login z="${botConfig.gameServer}">
      <nick><![CDATA[]]></nick>
      <pword><![CDATA[undefined%en%0]]></pword>
      </login></body></msg>`)
  }
}

// ── Rate limiter: 5 mensajes/seg ──
const limiter = new RateLimiter({
  tokensPerInterval: 5, interval: "sec"
})

async function sendXT(cmdName, paramObj) {
  await limiter.removeTokens(1)
  webSocket.send(
    `%xt%${botConfig.gameServer}%${cmdName}%1%${paramObj}%`
  )
}

// ── Espera la respuesta del servidor ──
const waitForResult = (key, timeout, func) =>
  new Promise((resolve, reject) => {
    func ??= _ => true
    let timer = setTimeout(() => {
      xtHandler.removeListener(key, handler)
      reject("TIMED_OUT")
    }, timeout * (ggeConfig.timeoutMultiplier ?? 1) * 5)

    const handler = (data, result) => {
      if (!func(Object(data), Number(result))) return
      xtHandler.removeListener(key, handler)
      clearInterval(timer)
      resolve([Object(data), Number(result)])
    }
    xtHandler.addListener(key, handler)
  })

async function createBot(uuid, user) {
  // Asignar plugins activos y servidor
  plugins.forEach(plugin => {
    data.plugins[plugin.key] ??= {}
    if (plugin.force)
      data.plugins[plugin.key].state = true
    if (data.plugins[plugin.key]?.state)
      data.plugins[plugin.key].filename = plugin.filename
  })
  const instance = instances.find(
    e => Number(e.gameID) == data.server
  )
  data.gameURL ??= instance.gameURL
  data.gameServer ??= instance.gameServer

  // Crear worker con config completa
  const worker = new Worker('./ggeBot.js', {
    workerData: { ...data, discordData }
  })
  botMap.set(user.id, worker)

  // Auto-restart on exit
  worker.on('exit', () => {
    if (getSpecificUser(uuid, user).state == true) {
      setTimeout(() => createBot(uuid, user),
        1000 * (ggeConfig.secondsTillRestartBot ?? 10))
    }
  })
}

// ── Auto-discovery de plugins ──
const dir = fs.readdirSync(__dirname, { recursive: true })
dir.forEach(file => {
  if (path.extname(file) != ".js") return
  plugins.push([
    `plugins/${file.slice(0, -3)}`,
    require(path.join(__dirname, file))
  ])
})

// ── Plugin de ataque: metadata + cálculos ──
// En el hilo principal → exportar opciones
if (require('worker_threads').isMainThread) {
  return module.exports = {
    force: true,
    pluginOptions: [
      { type: "Text", key: "attackDelaySeconds",
        default: "4.5" },
      { type: "Text", key: "attackDelayRandomizationSeconds",
        default: "2.5" },
      { type: "Text", key: "attackLimit" }
    ]
  }
}

// En el worker → lógica de cálculo
const getMaxAttackers = targetLevel =>
  targetLevel <= 69
    ? Math.min(260, 5 * targetLevel + 8)
    : 320