Desarrollo de Bots de Discord: Guía Completa para Principiantes

Los bots de Discord se han convertido en una parte esencial de muchas comunidades online. Desde moderación automática hasta música y juegos, los bots pueden hacer que tu servidor de Discord sea más interactivo y funcional.

En este artículo, te guiaré a través del proceso de crear tu primer bot de Discord usando Node.js y la biblioteca discord.js.

¿Qué es un Bot de Discord?

Un bot de Discord es una aplicación automatizada que interactúa con usuarios en servidores de Discord. Los bots pueden realizar una variedad de tareas como:

• Moderar mensajes y usuarios
• Reproducir música
• Proporcionar información
• Administrar roles y permisos
• Juegos y entretenimiento
• Automatizar tareas repetitivas

Requisitos Previos

Antes de comenzar, necesitarás:

• Conocimientos básicos de JavaScript
• Node.js instalado en tu sistema
• Una cuenta de Discord
• Un servidor de Discord para probar tu bot (puedes crear uno de prueba)

Paso 1: Crear una Aplicación de Discord

Primero, necesitas crear una aplicación en el Discord Developer Portal.

1. Ve a https://discord.com/developers/applications
2. Haz clic en "New Application"
3. Dale un nombre a tu aplicación (por ejemplo, "Mi Primer Bot")
4. Acepta los términos y crea la aplicación

Crear el Bot

1. En el panel de tu aplicación, ve a la sección "Bot"
2. Haz clic en "Add Bot" y confirma
3. Aquí verás el token de tu bot (¡mantén esto en secreto!)
4. Bajo "Privileged Gateway Intents", habilita:
   • Message Content Intent (si quieres leer el contenido de los mensajes)
   • Server Members Intent (si necesitas información de miembros)

Paso 2: Invitar el Bot a tu Servidor

Para invitar tu bot a un servidor:

1. Ve a la sección "OAuth2" > "URL Generator"
2. Selecciona los scopes:
   • bot
   • applications.commands (para comandos de barra)
3. Selecciona los permisos que necesitas (por ejemplo, "Send Messages", "Read Message History")
4. Copia la URL generada y ábrela en tu navegador
5. Selecciona el servidor donde quieres agregar el bot

Paso 3: Configurar el Proyecto

Crea un nuevo directorio para tu proyecto y configura Node.js:

mkdir mi-bot-discord
cd mi-bot-discord
npm init -y

Instala discord.js:

npm install discord.js

Crea un archivo .env para almacenar tu token de forma segura:

npm install dotenv

Crea un archivo .env:

DISCORD_TOKEN=tu_token_aqui

Importante: Asegúrate de agregar .env a tu .gitignore para no compartir tu token.

Paso 4: Crear el Bot Básico

Crea un archivo index.js:

const { Client, GatewayIntentBits } = require('discord.js');
require('dotenv').config();

const client = new Client({
  intents: [
    GatewayIntentBits.Guilds,
    GatewayIntentBits.GuildMessages,
    GatewayIntentBits.MessageContent,
  ],
});

client.once('ready', () => {
  console.log(`¡Bot conectado como ${client.user.tag}!`);
});

client.on('messageCreate', (message) => {
  // Ignorar mensajes de otros bots
  if (message.author.bot) return;

  // Comando simple: !hola
  if (message.content === '!hola') {
    message.reply('¡Hola! ¿Cómo estás?');
  }

  // Comando con argumentos: !saludo nombre
  if (message.content.startsWith('!saludo')) {
    const args = message.content.slice(8).trim();
    if (args) {
      message.channel.send(`¡Hola, ${args}! 👋`);
    } else {
      message.reply('Por favor, menciona un nombre después de !saludo');
    }
  }
});

client.login(process.env.DISCORD_TOKEN);

Paso 5: Ejecutar el Bot

Ejecuta tu bot:

node index.js

Si todo está correcto, verás: ¡Bot conectado como TuBot#1234!

Prueba los comandos en tu servidor de Discord:

• Escribe !hola y el bot debería responder
• Escribe !saludo Aliencito y el bot deberá saludar

Mejorando el Bot: Sistema de Comandos

Para un bot más organizado, puedes crear un sistema de comandos:

Estructura de Carpetas

mi-bot-discord/
├── commands/
│   ├── ping.js
│   ├── ayuda.js
│   └── usuario.js
├── index.js
├── .env
└── package.json

Ejemplo: Comando ping.js

module.exports = {
  name: 'ping',
  description: 'Responde con Pong!',
  execute(message, args) {
    message.reply('Pong! 🏓');
  },
};

Bot con Sistema de Comandos

const { Client, GatewayIntentBits, Collection } = require('discord.js');
const fs = require('fs');
const path = require('path');
require('dotenv').config();

const client = new Client({
  intents: [
    GatewayIntentBits.Guilds,
    GatewayIntentBits.GuildMessages,
    GatewayIntentBits.MessageContent,
  ],
});

// Colección de comandos
client.commands = new Collection();

// Cargar comandos
const commandsPath = path.join(__dirname, 'commands');
const commandFiles = fs.readdirSync(commandsPath).filter(file => file.endsWith('.js'));

for (const file of commandFiles) {
  const filePath = path.join(commandsPath, file);
  const command = require(filePath);
  client.commands.set(command.name, command);
}

client.once('ready', () => {
  console.log(`¡Bot conectado como ${client.user.tag}!`);
});

client.on('messageCreate', (message) => {
  if (message.author.bot) return;

  // Prefijo de comandos
  const prefix = '!';
  if (!message.content.startsWith(prefix)) return;

  const args = message.content.slice(prefix.length).trim().split(/ +/);
  const commandName = args.shift().toLowerCase();

  const command = client.commands.get(commandName);
  if (!command) return;

  try {
    command.execute(message, args);
  } catch (error) {
    console.error(error);
    message.reply('Hubo un error al ejecutar ese comando.');
  }
});

client.login(process.env.DISCORD_TOKEN);

Comandos de Barra (Slash Commands)

Los comandos de barra son más modernos y fáciles de usar. Aquí tienes un ejemplo:

const { SlashCommandBuilder } = require('discord.js');

module.exports = {
  data: new SlashCommandBuilder()
    .setName('usuario')
    .setDescription('Muestra información del usuario')
    .addUserOption(option =>
      option.setName('usuario')
        .setDescription('El usuario del cual quieres información')
        .setRequired(false)),
  async execute(interaction) {
    const usuario = interaction.options.getUser('usuario') || interaction.user;
    await interaction.reply(`Usuario: ${usuario.tag}\nID: ${usuario.id}`);
  },
};

Para registrar comandos de barra, necesitas un script adicional:

const { REST, Routes } = require('discord.js');
const { clientId, guildId, token } = require('./config.json');
const fs = require('fs');

const commands = [];
const commandFiles = fs.readdirSync('./commands').filter(file => file.endsWith('.js'));

for (const file of commandFiles) {
  const command = require(`./commands/${file}`);
  commands.push(command.data.toJSON());
}

const rest = new REST({ version: '10' }).setToken(token);

(async () => {
  try {
    console.log('Registrando comandos de barra...');

    await rest.put(
      Routes.applicationGuildCommands(clientId, guildId),
      { body: commands },
    );

    console.log('Comandos de barra registrados exitosamente!');
  } catch (error) {
    console.error(error);
  }
})();

Mejores Prácticas

1. Manejo de Errores

Siempre maneja los errores adecuadamente:

try {
  // código del comando
} catch (error) {
  console.error('Error:', error);
  await interaction.reply({ 
    content: 'Hubo un error al ejecutar este comando.', 
    ephemeral: true 
  });
}

2. Validación de Permisos

Verifica que el usuario tenga los permisos necesarios:

if (!interaction.member.permissions.has('ADMINISTRATOR')) {
  return interaction.reply({ 
    content: 'No tienes permisos para usar este comando.', 
    ephemeral: true 
  });
}

3. Rate Limiting

Implementa rate limiting para evitar spam:

const cooldowns = new Map();

// En tu comando
const cooldownTime = 5000; // 5 segundos
const cooldownKey = `${interaction.user.id}-${commandName}`;

if (cooldowns.has(cooldownKey)) {
  const expirationTime = cooldowns.get(cooldownKey) + cooldownTime;
  if (Date.now() < expirationTime) {
    const timeLeft = (expirationTime - Date.now()) / 1000;
    return interaction.reply({ 
      content: `Espera ${timeLeft.toFixed(1)} segundos antes de usar este comando nuevamente.`, 
      ephemeral: true 
    });
  }
}

cooldowns.set(cooldownKey, Date.now());

4. Variables de Entorno

Nunca hardcodees tokens o información sensible. Usa variables de entorno:

require('dotenv').config();
const token = process.env.DISCORD_TOKEN;

5. Logging

Implementa un sistema de logging para debugging:

const { createLogger, format, transports } = require('winston');

const logger = createLogger({
  level: 'info',
  format: format.combine(
    format.timestamp(),
    format.printf(({ timestamp, level, message }) => {
      return `${timestamp} [${level}]: ${message}`;
    })
  ),
  transports: [
    new transports.File({ filename: 'bot.log' }),
    new transports.Console()
  ]
});

Despliegue

Para mantener tu bot en línea 24/7, puedes usar:

• PM2: Para gestión de procesos Node.js
• Heroku: Plataforma cloud gratuita
• Railway: Alternativa moderna a Heroku
• VPS: Servidor privado virtual (más control)

Ejemplo con PM2:

npm install -g pm2
pm2 start index.js --name discord-bot
pm2 save
pm2 startup

Recursos Útiles

• Documentación de discord.js
• Guía de discord.js
• Discord Developer Portal
• Discord API Server - Comunidad de ayuda

Ejemplos de Bots Populares

Algunos bots populares de Discord que puedes usar como inspiración:

• MEE6: Moderación y niveles
• Dyno: Moderación avanzada
• Groovy/Rythm: Música (ya no disponible, pero puedes crear uno similar)
• Dank Memer: Entretenimiento y memes

Conclusión

Crear un bot de Discord puede ser un proyecto divertido y educativo. Comienza con algo simple y gradualmente agrega más funcionalidades. Recuerda:

• Mantén tu token seguro
• Maneja errores adecuadamente
• Respeta los límites de la API de Discord
• Prueba tu bot en un servidor de desarrollo antes de hacerlo público

Si tienes preguntas o quieres compartir tu bot, ¡déjame saber en los comentarios!

Proyectos Relacionados

Si te interesa el desarrollo de bots de Discord, puedes revisar mi proyecto Mewwme's, un bot de música de Discord que desarrollé.

¿Tienes experiencia desarrollando bots de Discord? ¡Comparte tus consejos y trucos en los comentarios!

Enlaces Relacionados

• Mi Portafolio
• Blog
• GitHub
• Discord