One place for hosting & domains

      Bot

      Building a Discord Bot in Python


      How to Join

      This Tech Talk is free and open to everyone. Register below to get a link to join the live stream or receive the video recording after it airs.

      Date Time RSVP
      September 8, 2021 11 a.m.–12 p.m. ET / 3–4 p.m. GMT

      About the Talk

      Discord is becoming an ever more popular tool for open source communities to connect. Discord isn’t just a great chat and voice app, it also has a rich ecosystem for extending and building bots. Get an overview of the Discord Python library, how Discord handles events, and build your first Discord bot!

      What You’ll Learn

      How to build and deploy your very own Discord bot

      This Talk Is Designed For

      Developers who want to build discord bots

      Resources

      Discord Developer Documentation
      Discord API Documentation
      DigitalOcean Droplets + Docs
      DigitalOcean App Platform + Docs

      To join the live Tech Talk, register here.



      Source link

      How To Build a Discord Bot in Python on Ubuntu 20.04


      The author selected the Free and Open Source Fund to receive a donation as part of the Write for DOnations program.

      Introduction

      Discord is a popular voice and text messaging platform used by gamers, open-source communities, conference organizers, and more. It has gained popularity due to features like superb voice chat, various text channels, and extensibility using automated assistants or “bots.”

      In this guide, you will build a Discord bot using the Python programming language and deploy it to an Ubuntu 20.04 server. You’ll be using the Discord Python library, discord.py, to program your bot.

      Note: Discord has two different names for their chat/voice rooms. They refer to these as both Servers and Guilds, depending on where you are in the documentation. For this tutorial, we will use the term Guild. Just know that these terms can be used interchangeably and often are in the official Discord documentation.

      Prerequisites

      To complete this tutorial, you’ll need:

      Step 1 — Creating a Bot User For Your Discord Guild

      Before you start coding, you need to create and register your bot in the Discord developer portal.

      Sign in to the developer portal and click on the New Application button to start the process. A Discord application allows you to interact with the Discord API. Bots are bound to applications; that is how they function.

      Click the New Application Button

      Next, add a name for the application in the modal and press the Create button. For this tutorial, we’ll name ours SammySharkBot.

      Name Your Application

      Discord will create your application. Next, you’ll note a page with information regarding your bot. You can choose to add a picture to serve as an icon for your bot. Click on the Choose a Neat Icon button in the App Icon section of the page. This is not required.

      Add an optional icon for your bot

      If you did upload an icon, you’d note a dialog box prompting you to save your changes. Press Save Changes to save your icon.

      Save your changes

      Now that you’ve set up your application, it’s time to create a bot that is associated with the application. Navigate to the Bot link in the Settings navigation pane on the left-hand side of the screen.

      Add a bot to your application

      Now click the Add Bot button to add the bot to your application.

      Confirm the creation of the bot

      Once you’ve done that, a Bot will appear with the optional icon you set up earlier. Remember this page; you’ll need to come back to it later to retrieve the API Token.

      Bot confirmation page

      You’ll be prompted with a modal that states Adding a bot user gives your app visible life in Discord. However, this action is irrevocable! Choose wisely. Go ahead and press Yes, do it! to create the bot user.

      Next, navigate to the OAuth2 link in the Settings navigation pane on the left-hand side of the screen. You need to add the appropriate permissions so your bot can function properly.

      Navigate to OAuth2 menu

      You’ll need to add the scopes in which your bot can function. Only check the bot option because that’s all you want this bot to do. For more information about the other scopes, visit the Discord OAuth2 Documentation.

      Add bot designation

      Now scroll down and give your bot the following permissions: View Channels, Send Messages, Read Message History. This will give your bot a limited set of actions that it can perform. If you want to create a bot with no restrictions, you can select the Administrator option; this is not recommended.

      Once you have done this, a Discord URL followed by a Copy button will appear. Click that button to copy the link and open it in a new window in your browser.

      Add bot permissions and copy the link

      A prompt will appear for your bot to connect your Guild. You may have permission to install bots in multiple Guilds, so you may note more than one here. Select the Guild you wish to install your bot into and click Authorize.

      Add bot to your Guild

      Before a bot is added to your Guild, Discord shows you all the permissions the bot will have. This ensures that you are aware of what you are installing. If you don’t want the bot to have a specific permission, you can uncheck it. However, don’t do that for this bot because the bot won’t work otherwise. Click Authorize to accept and add the bot to your Guild.

      Authorize bot permissions

      Go back to your Guild and check the channel where posts about new members appear. You will note that your bot joined your Guild. Your bot will also appear in the member list on the right-hand side, although the bot will appear offline; this will change after you start the bot code.

      Check if your bot joined your guild

      Now that your bot is added to your Guild, you are ready to bring it to life with some Python code.

      Step 2 — Creating a Python Virtual Environment for Your Project

      Before you get started coding, you need to set up your Python developer environment. In this step, you will install and activate your Python requirements within a virtual environment for easier management.

      First, create a directory in your home directory that you can use to store all of your virtual environments:

      Now create your virtual environment using Python:

      • python3 -m venv ~/.venvs/discord

      This will create a directory called discord within your .venvs directory. Inside, it will install a local version of Python and a local version of pip. You can use this to install and configure an isolated Python environment for your project.

      Before you install your project’s Python requirements, activate the virtual environment:

      • source ~/.venvs/discord/bin/activate

      Your prompt should change to indicate that you are now operating within a Python virtual environment. It will look something like this: (discord)user@host:~$.

      With your virtual environment active, install discord.py with the local instance of pip:

      Note: Once you have activate your virtual environment (when your prompt has (discord) preceding it), use pip instead of pip3, even if you are using Python 3. The virtual environment’s copy of the tool is always named pip, regardless of the Python version.

      Now that you have the Discord package installed, you will need to save this requirement and its dependencies. This is good practice so you can recreate your developer environment as needed.

      Use pip to save your environment’s information to a requirements.txt file:

      • pip freeze > requirements.txt

      You now have the libraries necessary to build a discord bot.

      Step 3 — Building a Minimal Discord Bot

      You will now begin coding your Discord bot. Once completed, your bot will listen for certain phrases shared in a text chat, and then it will respond to them accordingly. Specifically, your bot will flip a coin on behalf of the users.

      In this step, you will build a minimal version of your bot. You will then add more functionality in Step 4 and Step 5.

      To begin, open a file named bot.py in your preferred text editor:

      Now add the following imports to the file: os, random, and discord. The os library will allow you to read valuable information, such as API Tokens and Guild Name from your environment variables. The random library will allow you to generate the output for your random events. And the discord library will provide you with the methods, objects, and decorators required to interact with the discord API. The code is as follows:

      bot.py

      import os
      import random
      import discord
      

      Next, you will need to retrieve the Discord API token and your bot’s guild from environment variables. You’ll use the method getenv from the os library in the Python standard library. Append the following code to bot.py:

      bot.py

      ...
      
      token = os.getenv("DISCORD_TOKEN")
      my_guild = os.getenv("DISCORD_GUILD")
      

      In version 1.5 of discord.py, Intents were introduced. This was a breaking change from prior versions of Discord libraries that allowed bots to subscribe to certain events that happen within the Guild. For this tutorial, you’ll set the client’s available intents to default, but you may need to revisit if you plan on interacting with the GUILD_PRESENCES or GUILD_MEMBERS intents. These are Privileged Gateway Intents.

      Append the following code to bot.py to properly set up the intents:

      bot.py

      ...
      
      intents = discord.Intents.default()
      client = discord.Client(intents=intents)
      

      Now, let’s write some code that responds to an event in Discord. Events are actions that happen on the Discord Guild, such as sending a message or joining a channel. For a full list of supported events, check the Discord Event Reference API.

      The first segment of code will activate on the on_ready event. This event triggers when your bot loads into a Guild. Note that the Discord API does not guarantee that this event only happens once. If you are planning on putting code here that should only run once, do some checks to ensure that it indeed only executes once.

      You’ll write a print statement that prints when your bot has successfully connected to your Guild. Discord bots require the use of async methods so that the bot sits in a ready state and waits for calls.

      Append the following code to the end of bot.py:

      bot.py

      ...
      
      @client.event
      async def on_ready():
          for guild in client.guilds:
              if guild.name == my_guild:
                  break
      
          print(
              f"{client.user} is connected to the following guild:n"
              f"{guild.name}(id: {guild.id})"
          )
      

      You use a for loop to find your Guild among all available Guilds, and then you print information about the Guild and your connection to it.

      Finally, you need to tell the client to run when the script is executed using your API token. Append the following line to bot.py to run your bot:

      bot.py

      ...
      
      client.run(token)
      

      At this point, your code should look like this:

      bot.py

      import os
      import random
      import discord
      
      token = os.getenv("DISCORD_TOKEN")
      my_guild = os.getenv("DISCORD_GUILD")
      
      intents = discord.Intents.default()
      client = discord.Client(intents=intents)
      
      @client.event
      async def on_ready():
          for guild in client.guilds:
              if guild.name == my_guild:
                  break
      
          print(
              f"{client.user} is connected to the following guild:n"
              f"{guild.name}(id: {guild.id})"
          )
      
      client.run(token)
      

      You have just written the skeleton code that will allow your bot to connect to a Guild. Now you will test your bot’s basic functionality.

      Step 4 — Testing Your Bot Locally

      Before you code any more, check that your bot can connect to Discord. Navigate back to the discord developer panel and click on the Bot link in the navigation bar on the left. From here, locate the Token underneath the bot username and click the Copy button to copy the token to your clipboard.

      Get Bot Token

      Once you have copied the token, return to the terminal with your activated virtual environment. Export the Discord token so it is available in the environment variables for your bot to read on startup:

      • export DISCORD_TOKEN=YOUR_DISCORD_TOKEN

      Now you need to get the Guild name that your bot will join. Navigate to your Discord Guild. The Guild name should be in the top left-hand corner of your Guild page. This was the name you chose when you created a Guild in the prerequisites section.

      Get Guild Name

      Now, export the Discord Guild so it is available in the environment variables for your bot to read on startup:

      • export DISCORD_GUILD=YOUR_DISCORD_GUILD

      Now that you have exported the necessary environment variables, you are ready to test your bot:

      Run the application:

      It might take a few seconds, but you will receive an output like this. Note that your bot number and id will differ:

      Output

      SammySharkBot#8143 is connected to the following Guild: SammyShark(id: 801529616116350998)

      Navigate back to your Discord Guild and you will note that your bot now has a green circle near its name. This indicates that the bot is online.

      Verify your bot is online

      You may notice in your terminal that your code does not terminate. This is because the bot is a constantly running process. To stop your bot at any time, press the CTRL + C key combo.

      Step 5 — Extending the Discord Bot to Perform Random Tasks

      Now that your bot is working, it’s time to extend its functionality. For your bot to respond to messages sent in the text chat, you’ll need to listen to the on_message event. This function takes in one argument, message, which contains the message object, including various attributes and methods for responding to messages.

      One thing that you’ll need to ensure is that your bot doesn’t answer itself. If the bot were to interpret its own message as a trigger, then it would create an infinite loop. To avoid this, check that the user sending the message isn’t the bot.

      Append the following code to bot.py to declare the on_message function and to check who sent the message:

      bot.py

      ...
      @client.event
      async def on_message(message):
          if message.author == client.user:
              return
      

      Lastly, add the code to flip the coin. You will also perform a string manipulation on the message content to lower case (or upper, if you prefer) so you don’t have to worry about matching exact case in strings. Use the randint() function in the Python random library to simulate flipping a coin. Finally, once you have crafted a message, you will send it to the channel using the method for sending a message. Remember, this is asynchronous programming, so you’ll have to use the await keyword when sending the message.

      Append the following code to bot.py within the on_message function; this will add the coin-flipping functionality:

      bot.py

          message_content = message.content.lower()
          if "flip a coin" in message_content:
              rand_int = random.randint(0, 1)
              if rand_int == 0:
                  results = "Heads"
              else:
                  results = "Tails"
              await message.channel.send(results)
      

      What follows is the finished code for the bot. Ensure that your code looks like this, or copy and paste this code:

      bot.py

      import os
      import random
      import discord
      
      token = os.getenv("DISCORD_TOKEN")
      my_guild = os.getenv("DISCORD_GUILD")
      
      intents = discord.Intents.default()
      client = discord.Client(intents=intents)
      
      
      @client.event
      async def on_ready():
          for guild in client.guilds:
              if guild.name == my_guild:
                  break
      
          print(
              f"{client.user} is connected to the following guild:n"
              f"{guild.name}(id: {guild.id})"
          )
      
      
      @client.event
      async def on_message(message):
          if message.author == client.user:
              return
      
          message_content = message.content.lower()
          if "flip a coin" in message_content:
              rand_int = random.randint(0, 1)
              if rand_int == 0:
                  results = "Heads"
              else:
                  results = "Tails"
              await message.channel.send(results)
      
      client.run(token)
      

      Now that the bot is finished, it’s time to test it. Save and close the file.

      Rerun the app:

      After the app connects to your Guild, navigate to the #general channel in your Discord Guild. Type flip a coin in the text chat, and the bot will respond with either Heads or Tails.

      Your bot should respond with Heads or Tails

      Now that you have confirmed that your bot is functional, you are ready to deploy it to production on an Ubuntu 20.04 server.

      Step 6 — Deploying to Ubuntu 20.04

      You can leave your bot running from your local machine, but having to leave a terminal active or worry about power outages can be annoying. For convenience, you can deploy it to a server.

      It is best practice to run your bot as a non-root user. This tutorial uses the username sammy.

      First, copy your code and Python library requirements to the server using the scp command. Send everything to your user’s root directory:

      • scp bot.py requirements.txt sammy@your_server_ip:~

      Next, ssh into your server:

      You will now enter commands into the server’s terminal.

      You need to install the proper Python system packages to run your bot on your server.

      Install python3, python3-venv, and screen:

      • sudo apt update && sudo apt install python3 python3-venv screen

      Now, you’re going to use a tool called screen to create a virtual terminal. Without this tool, if you were to exit your terminal while the bot was running, the process would terminate, and your bot would go offline. With this tool, you can connect and disconnect to sessions so your code remains running. To learn more about screen, check out our tutorial on installing and using screen.

      To start a screen session, use the following command:

      screen will prompt you with a license agreement. Press Return to continue.

      Now that you have a virtual session set up, you need to create a Python virtual environment to run your code.

      First, like before, create a directory to store your virtual environments:

      Then create a new virtual environment:

      • python3 -m venv ~/.venvs/discord

      Activate the virtual environment:

      • source ~/.venvs/discord/bin/activate

      Next, install the necessary libraries using pip:

      • pip install -r requirements.txt

      Before you can run your bot, you’ll need to export the DISCORD_TOKEN and DISCORD_GUILD so your bot can access the API Key and Guild information:

      • export DISCORD_TOKEN=YOUR_DISCORD_TOKEN
      • export DISCORD_GUILD=YOUR_DISCORD_GUILD

      Finally, run your bot:

      Your bot will start up and start accepting messages. You can disconnect from the screen session using the key combination CTRL + A + D. When you are ready to reconnect to the session, you can use this screen command:

      You have successfully built a Discord bot using Python. The application runs on a server and responds to certain phrases shared in a Guild.

      Conclusion

      In this tutorial, you set up a Discord Guild, built a Discord bot, installed the bot in your Guild, and deployed the bot to an Ubuntu 20.04 server. You’ve only begun to explore the Discord API. Bots are powerful and extendable. To explore other capabilities, check out the discord.py API docs.

      Alternately, if you wish learn more about Python programming, visit our tutorial series, How To Code in Python 3.



      Source link

      Cómo crear un bot de Discord con Node.js


      El autor seleccionó Free and Open Source Fund para recibir una donación como parte del programa Write for DOnations.

      Introducción

      Discord es una aplicación de chat que permite a millones de usuarios de todo el mundo transmitir mensajes y voz en línea en comunidades llamadas gremios o servidores. Discord también proporciona una amplia API que los desarrolladores pueden usar para crear potentes bots de Discord. Los bots pueden realizar diversas acciones, como enviar mensajes a servidores, mensajes directos a usuarios, moderar servidores y reproducir audio en los chats de voz. Esto permite a los desarrolladores crear bots potentes que incluyen funciones avanzadas y complejas como herramientas de moderación o, incluso, juegos. Por ejemplo, el bot de utilidad Dyno sirve a millones de gremios y contiene características útiles como la protección contra spam, un reproductor de música y otras funciones útiles. Aprender a crear bots de Discord le permite implementar muchas posibilidades, con las que miles de personas podrían interactuar cada día.

      En este tutorial, creará un bot de Discord desde cero, usando Node.js y la biblioteca de Discord.js, que permite a los usuarios interactuar directamente con la API de Discord. Configurará un perfil para un bot de Discord, obtendrá tokens de autenticación para el bot y lo programará con la capacidad de procesar comandos con argumentos, desde los usuarios.

      Requisitos previos

      Para comenzar, necesitará lo siguiente:

      Paso 1: Configurar un bot de Discord

      En este paso, utilizará la GUI de desarrolladores de Discord para configurar un bot de Discord y obtener el token de bot, que pasará a su programa.

      Para registrar un bot en la plataforma Discord, utilice el panel de aplicación de Discord. Aquí los desarrolladores pueden crear aplicaciones de Discord incluyendo bots de Discord.

      Imagen del panel de aplicación de Discord después de visitar https://discord.com/developers/applications primero

      Para comenzar, haga clic en Nueva aplicación. Discord le solicitará que introduzca un nombre para su nueva aplicación. A continuación, haga clic en Crear para crear la aplicación.

      Imagen del mensaje para crear una aplicación, con

      Nota: El nombre de su aplicación es independiente del nombre del bot, y el bot no tiene el mismo nombre que la aplicación.

      Ahora, abra el panel de su aplicación. Para agregar un bot a la aplicación, diríjase a la pestaña Bot en la barra de navegación a la izquierda.

      Imagen de la pestaña bot del panel de aplicación

      Haga clic en el botón Añadir bot para agregar un bot a la aplicación. Haga clic en el botón Sí, ¡hazlo! cuando le pida la confirmación. A continuación, estará en un panel que contiene detalles sobre el nombre de su bot, el token de autenticación y la imagen de perfil.

      Panel que contiene detalles de su bot

      Puede modificar el nombre o la imagen de su bot, aquí, en el panel. También necesita copiar el token de autenticación del bot haciendo clic en Haga clic para mostrar Token y copiando el token que aparece.

      Advertencia: Nunca comparta ni suba su token de bot, ya que permite a cualquier persona iniciar sesión en su bot.

      Ahora, necesita crear una invitación que le permita agregar los gremios de Discord del bot donde puede probar el bot. Primero, vaya a la pestaña OAuth2 del panel de aplicación. Para crear una invitación, desplácese hacia abajo y seleccione bot en alcances. También debe establecer permisos para controlar las acciones que puede realizar su bot en los gremios. A los efectos de este tutorial, seleccione Administrador, que le dará a su bot permiso para realizar casi todas las acciones en los gremios. Copie el enlace con el botón Copiar.

      Pestaña OAuth2, con el alcance configurado en

      A continuación, añada el bot a un servidor. Siga el enlace de invitación que acaba de crear. Puede agregar el bot a cualquier servidor que posea, o en el que tenga permisos de administrador, desde el menú desplegable.

      Página desde el siguiente enlace de invitación, que permite a los usuarios agregar el bot a los servidores

      Ahora haga clic en Continuar. Asegúrese de tener marcada la casilla junto a Administrador: esto concederá los permisos de administrador de bot. A continuación, haga clic en Autorizar. Discord le solicitará que resuelva un CAPTCHA antes de que el bot se una al servidor. Ahora, tendrá el bot de Discord en la lista de miembros en el servidor al que añadió el bot debajo de sin conexión.

      Lista de miembros de un servidor de Discord con el bot recientemente creado en la sección

      Ha creado correctamente un bot de Discord y lo ha añadido a un servidor. A continuación, escribirá un programa para iniciar sesión en el bot.

      Paso 2: Crear su proyecto

      En este paso, configurará el entorno de codificación básico donde creará su bot e iniciará sesión en el bot de forma programática.

      Primero, debe configurar una carpeta de proyecto y los archivos de proyecto necesarios para el bot.

      Cree su carpeta de proyecto:

      Vaya a la carpeta de proyecto que acaba de crear:

      A continuación, utilice su editor de texto para crear un archivo llamado config.json para almacenar el token de autenticación de su bot:

      A continuación, añada el siguiente código al archivo config, sustituyendo el texto resaltado por el token de autenticación de su bot:

      config.json

      {
          "BOT_TOKEN": "YOUR BOT TOKEN"
      }
      

      Guarde el archivo y ciérrelo.

      A continuación, creará un archivo package.json que almacenará los detalles de su proyecto e información sobre las dependencias que utilizará para el proyecto. Creará un archivo package.json ejecutando el siguiente comando npm:

      npm le solicitará varios datos sobre su proyecto. Si desea obtener información sobre cómo completar las preguntas, puede leer sobre ellos en Cómo usar módulos Node.js con npm y package.json.

      Ahora, instalará el paquete discord.js que utilizará para interactuar con la API de Discord. Puede instalar discord.js a través de npm con el siguiente comando:

      Ahora ha configurado el archivo de configuración y ha instalado la dependencia necesaria, está listo para comenzar a crear su bot. En una aplicación en el mundo real, un bot grande se dividiría en muchos archivos, pero a efectos de este tutorial, el código para su bot estará en un solo archivo.

      Primero, cree un archivo llamado index.js en la carpeta discord-bot para el código:

      Comience a codificar el bot pidiendo la dependencia de discord.js y el archivo config con el token de bot:

      index.js

      const Discord = require("discord.js");
      const config = require("./config.json");
      

      A continuación, añada las siguientes dos líneas de código:

      index.js

      ...
      const client = new Discord.Client();
      
      client.login(config.BOT_TOKEN);
      

      Guarde y cierre su archivo.

      La primera línea de código crea un nuevo Discord.Client y lo asigna a la constante client. Este cliente es en parte cómo interactúa con la API de Discord y cómo le notificará eventos como mensajes nuevos. El cliente, en efecto, representa el bot de Discord.

      La segunda línea de código utiliza el método login en client para iniciar sesión en el bot de Discord que creó, usando el token en el archivo config.json como contraseña. El token permite a la API de Discord saber para qué bot es el programa y que está autenticado para usar el bot.

      Ahora, ejecute el archivo index.js usando Node:

      El estado de su bot cambiará a “en línea” en el servidor de Discord al que lo añadió.

      Imagen del bot en línea

      Ha configurado correctamente un entorno de codificación y ha creado el código básico para iniciar sesión en un bot de Discord. En el siguiente paso, manejará los comandos de usuario y hará que su bot realice acciones, como enviar mensajes.

      Paso 3: Cómo manejar su primer comando de usuario

      En este paso, creará un bot que puede manejar los comandos de usuario. Implementará su primer comando de ping, que responderá con "pong" y el tiempo que toma para responder al comando.

      Primero, necesita detectar y recibir cualquier mensaje que los usuarios envíen, para que pueda procesar cualquier comando. Con el método on en el cliente de Discord, Discord le enviará una notificación sobre eventos nuevos. El método on toma dos argumentos: el nombre de un evento a esperar y una función a ejecutar cada vez que se produce ese evento. Con este método, puede esperar el evento message: se producirá cada vez que se envía un mensaje a un gremio donde el bot tiene permiso para ver mensajes. Por tanto, vamos a crear una función, que se ejecuta cada vez que se envía un mensaje, para procesar comandos.

      Primero, abra su archivo:

      Añada el siguiente código a su archivo:

      index.js

      ...
      const client = new Discord.Client();
      
      
      client.on("message", function(message) { 
                                               
      });                                      
      
      client.login(config.BOT_TOKEN);
      

      Esta función, que se ejecuta en el evento message, toma message como un parámetro. message tendrá el valor de una instancia de mensaje de Discord.js, que contiene información sobre el mensaje enviado y los métodos para ayudar a responder al bot.

      Ahora, añada la siguiente línea de código a su función de manejo de comandos:

      index.js

      ...
      client.on("message", function(message) {
        if (message.author.bot) return;
      });
      ...
      

      Esta línea comprueba si el autor del mensaje es un bot y, si es así, deja de procesar el comando. Esto es importante, ya que generalmente no quiere procesar o responder a los mensajes de bots. Por lo general, los bots no necesitan o no quieren usar nuestro bot, por lo que ignorar sus mensajes ahorra potencia de procesamiento y ayuda a evitar respuestas accidentales.

      Ahora, escribirá un controlador de comandos. Para ello, es bueno entender el formato habitual de un comando de Discord. Normalmente, la estructura de un comando de Discord contiene tres partes en el siguiente orden: un prefijo, un nombre de comando y (a veces) argumentos de comandos.

      Una imagen de un comando típico de Discord que se lee

      • Prefijo: el prefijo puede ser cualquier cosa, pero, por lo general, es un signo de puntuación o una frase abstracta que normalmente no estaría al principio de un mensaje. Esto significa que, cuando incluya el prefijo al inicio del mensaje, el bot sabrá que la intención de este comando es para que un bot lo procese.

      • Nombre de comando: el nombre del comando que el usuario quiere usar. Esto significa que el bot puede soportar múltiples comandos con diferentes funciones y permitir a los usuarios elegir entre ellos al proporcionar un nombre de comando diferente.

      • Argumentos: a veces, si el comando requiere o utiliza información adicional del usuario, este puede proporcionar argumentos después del nombre de comando, con cada argumento separado por un espacio.

      Nota: No hay estructura de comandos forzada, y los bots pueden procesar los comandos como quieran, pero la estructura que se presenta aquí es una estructura eficiente que la gran mayoría de bots utilizan.

      Para comenzar a crear un analizador sintáctico de comandos que maneje este formato, añada las siguientes líneas de código a la función de manejo de mensajes:

      index.js

      ...
      const prefix = "!";
      
      client.on("message", function(message) {
        if (message.author.bot) return;
        if (!message.content.startsWith(prefix)) return;
      });
      ...
      

      Añada la primera línea de código para asignar el valor "!" a la constante prefix, que utilizará como prefijo del bot.

      La segunda línea de código que añade comprueba si el contenido del mensaje que el bot está procesando comienza con el prefijo que configuró y, si no lo hace, deja de procesarlo.

      Ahora, debe convertir el resto del mensaje en un nombre de comando y cualquier argumento que pueda existir en el mensaje. Añada las siguientes líneas resaltadas:

      index.js

      ...
      client.on("message", function(message) {
        if (message.author.bot) return;
        if (!message.content.startsWith(prefix)) return;
      
        const commandBody = message.content.slice(prefix.length);
        const args = commandBody.split(' ');
        const command = args.shift().toLowerCase();
      });
      ...
      

      Utilice la primera línea aquí para eliminar el prefijo del contenido de mensaje y asignar el resultado a la constante commandBody. Esto es necesario, ya que no quiere incluir el prefijo en el nombre de comando analizado.

      La segunda línea toma el mensaje con el prefijo eliminado y utiliza el método split en él, con un espacio como separador. Esto lo divide en una matriz de subcadenas y hace una división dondequiera que haya un espacio. Esto crea una matriz que contiene el nombre de comando y, por tanto, si se incluye en el mensaje, cualquier argumento. Asigna esta matriz a la constante args.

      La tercera línea elimina el primer elemento de la matriz de args (que será el nombre de comando que se proporciona), lo convierte en minúscula y, luego, lo asigna a la constante command. Esto le permite aislar el nombre de comando y dejar solo argumentos en la matriz. También utiliza el método toLowerCase, ya que los comandos no suelen distinguir entre minúsculas y mayúsculas en bots de Discord.

      Completó la construcción de un analizador de comandos, implementó un prefijo requerido y obtuvo el nombre de comando y cualquier argumento de los mensajes. Ahora, implementará y creará el código para los comandos específicos.

      Añada el siguiente código para comenzar a implementar el comando ping:

      index.js

      ...
        const args = commandBody.split(' ');
        const command = args.shift().toLowerCase();
      
        if (command === "ping") {
                                 
        }                        
      });
      ...
      

      Esta instrucción if comprueba si el nombre de comando que analizó (asignado a la constante command) coincide con "ping". Si lo hace, indica que el usuario quiere usar el comando "ping". Anidará el código para el comando específico dentro del bloque de instrucción if. Repetirá este patrón para otros comandos que desee implementar.

      Ahora, puede implementar el código para el comando "ping":

      index.js

      ...
        if (command === "ping") {
          const timeTaken = Date.now() - message.createdTimestamp;
          message.reply(`Pong! This message had a latency of ${timeTaken}ms.`);
        }
      ...
      

      Guarde y cierre su archivo.

      Añada el bloque de comandos "ping" que calcula la diferencia entre el tiempo actual, que se encuentra usando el método now en el objeto Date y la marca de tiempo cuando el mensaje se creó en milisegundos. Esto calcula cuánto tiempo tardó el mensaje en procesarse y el "ping" del bot.

      La segunda línea responde al comando del usuario usando el método reply en la constante message. El método reply avisa (que notifica al usuario e indica el mensaje para el usuario especificado) al usuario que invocó el comando, seguido por el contenido proporcionado como el primer argumento al método. Proporciona una plantilla literal que contiene un mensaje y el ping calculado como la respuesta que el método reply utilizará.

      Esto concluye la implementación del comando "ping".

      Ejecute su bot usando el siguiente comando (en la misma carpeta que index.js):

      Ahora puede usar el comando "! ping" en cualquier canal que el bot pueda ver y enviar un mensaje, lo que resulta en una respuesta.

      Imagen de bot replicando en Discord a

      Ha creado correctamente un bot que puede manejar los comandos de usuario y ha implementado su primer comando. En el siguiente paso, continuará desarrollando su bot implementando un comando sum.

      Paso 4: Cómo implementar el comando sum

      Ahora, extenderá su programa implementando el comando "! sum". El comando tomará cualquier número de argumentos y los agregará juntos, antes de devolver la suma de todos los argumentos al usuario.

      Si su bot de Discord aún se está ejecutando, puede detener su proceso con CTRL + C.

      Abra su archivo index.js de nuevo:

      Para comenzar a implementar el comando "! sum", usará un bloque else-if. Después de comprobar el nombre de comando ping, comprobará si el nombre de comando es igual a "sum". Usamos un bloque else-if, ya que solo un comando se procesará a la vez, de forma que si el programa coincide con el nombre de comando "ping", no tiene que verificar el comando "sum". Añada las siguientes líneas resaltadas a su archivo:

      index.js

      ...
        if (command === "ping") {
          const timeTaken = Date.now() - message.createdTimestamp;
          message.reply(`Ping! This message had a latency of ${timeTaken}ms.`);
        }
      
        else if (command === "sum") {
                                     
        }                            
      });
      ...
      

      Puede comenzar a implementar el código para el comando "sum". El código para el comando "sum" entrará en el bloque else-if que acaba de crear. Ahora, añada el siguiente código:

      index.js

      ...
        else if (command === "sum") {
          const numArgs = args.map(x => parseFloat(x));
          const sum = numArgs.reduce((counter, x) => counter += x);
          message.reply(`The sum of all the arguments you provided is ${sum}!`);
        }
      ...
      

      Utilice el método map de la lista de argumentos para crear una nueva lista usando la función parseFloat en cada elemento de la matriz de args. Esto crea una nueva matriz (asignada a la constante numArgs) en la que todos los elementos son números en vez de cadenas. Esto significa que más tarde puede encontrar correctamente la suma de los números sumándolos.

      La segunda línea utiliza el método reduce en la constante numArgs que proporcionan una función que suma todos los elementos de la lista. Asignó la suma de todos los elementos en numArgs a la constante sum.

      A continuación, utilice el método reply en el objeto de mensaje para responder al comando del usuario con una plantilla literal, que contiene la suma de todos los argumentos que el usuario envía al bot.

      Esto concluye la implementación del comando "sum". Ahora, ejecute su bot usando el siguiente comando (en la misma carpeta que index.js):

      Ahora, puede usar el comando "! sum" en cualquier canal que pueda ver el bot y enviar mensajes.

      Imagen del bot respondiendo

      A continuación, se muestra una versión completa de la secuencia de comandos del bot index.js:

      index.js

      const Discord = require("discord.js");
      const config = require("./config.json");
      
      const client = new Discord.Client();
      
      const prefix = "!";
      
      client.on("message", function(message) {
        if (message.author.bot) return;
        if (!message.content.startsWith(prefix)) return;
      
        const commandBody = message.content.slice(prefix.length);
        const args = commandBody.split(' ');
        const command = args.shift().toLowerCase();
      
        if (command === "ping") {
          const timeTaken = Date.now() - message.createdTimestamp;
          message.reply(`Pong! This message had a latency of ${timeTaken}ms.`);
        }
      
        else if (command === "sum") {
          const numArgs = args.map(x => parseFloat(x));
          const sum = numArgs.reduce((counter, x) => counter += x);
          message.reply(`The sum of all the arguments you provided is ${sum}!`);
        }
      });
      
      client.login(config.BOT_TOKEN);
      

      En este paso, ha desarrollado aún más su bot de Discord implementando el comando sum.

      Conclusión

      Ha implementado correctamente un bot de Discord que puede manejar varios comandos de usuario y argumentos de comandos. Si desea ampliar su bot, posiblemente pueda implementar más comandos o probar más partes de la API de Discord para crear un bot de Discord potente. Puede revisar la documentación de Discord.js o la documentación de la API de Discord para ampliar sus conocimiento de la API de Discord.

      Al crear bots de Discord, siempre debe tener en cuenta los términos de servicio de la API de Discord, que describe cómo los desarrolladores deben usarla. También puede leer este conjunto de directrices sobre cómo implementar mejor un bot de Discord y proporciona consejos sobre cómo diseñar bots de Discord. Si desea obtener más información sobre Node.js consulte nuestra serie Cómo crear códigos en Node.js.



      Source link