Einen eigenen Discord Command erstellen: Schritt-für-Schritt-Anleitung für Anfänger

Willkommen in der Welt der Discord Bots! Hast du dich jemals gefragt, wie diese Bots so viele coole Befehle ausführen können? In diesem Artikel zeigen wir dir, wie du deinen eigenen Discord Command erstellst – auch wenn du noch ein absoluter Anfänger bist. Keine Sorge, wir führen dich Schritt für Schritt durch den Prozess, so dass du am Ende des Artikels deinen eigenen, funktionierenden Command haben wirst.

Was brauchst du, um loszulegen?

Bevor wir mit dem Programmieren beginnen, stellen wir sicher, dass du alles hast, was du brauchst:

• Eine Discord-Konto: Das ist offensichtlich, aber ohne Discord-Konto kannst du keinen Bot erstellen, der darauf zugreift.
• Ein Discord-Server: Du brauchst einen Server, auf dem dein Bot laufen kann und auf dem du deine Commands testen kannst. Du kannst entweder einen bestehenden Server verwenden oder einen neuen erstellen.
• Node.js und npm (Node Package Manager): Wir werden JavaScript verwenden, um unseren Bot zu programmieren. Node.js ist eine JavaScript-Laufzeitumgebung, und npm ist ein Paketmanager, der es uns ermöglicht, benötigte Bibliotheken zu installieren. Du kannst beide von der offiziellen Node.js-Website herunterladen: https://nodejs.org/
• Ein Code-Editor: Ein Code-Editor hilft dir beim Schreiben und Organisieren deines Codes. Beliebte Optionen sind Visual Studio Code, Sublime Text oder Atom. Wähle den, mit dem du dich am wohlsten fühlst.

Schritt 1: Einen Discord Bot erstellen

Zuerst müssen wir einen Discord Bot in der Discord Developer Portal erstellen.

1. Gehe zum Discord Developer Portal und logge dich mit deinem Discord-Konto ein.
2. Klicke auf „New Application”.
3. Gib deiner App einen Namen (z.B. „MeinErsterBot”) und klicke auf „Create”.
4. Klicke im linken Menü auf „Bot”.
5. Klicke auf „Add Bot”. Bestätige, dass du einen Bot erstellen möchtest.

Wichtig: Aktiviere unter „Privileged Gateway Intents” die Optionen „PRESENCE INTENT”, „SERVER MEMBERS INTENT” und „MESSAGE CONTENT INTENT”. Diese Intents sind für viele Bot-Funktionen notwendig.

Jetzt brauchen wir den Bot-Token. Dies ist wie das Passwort für deinen Bot. Gehe im Bot-Bereich auf „Reset Token” und bestätige die Aktion. Bewahre deinen Token sicher auf und teile ihn niemals mit anderen!

Schritt 2: Den Bot auf deinen Server einladen

Damit dein Bot auf deinem Server interagieren kann, musst du ihn einladen.

1. Gehe im Developer Portal zum Abschnitt „OAuth2” und dann zu „URL Generator”.
2. Wähle im Abschnitt „Scopes” die Option „bot”.
3. Wähle im Abschnitt „Bot Permissions” die Berechtigungen aus, die dein Bot benötigt. Für den Anfang sind „Send Messages”, „Read Message History” und „Use Slash Commands” empfehlenswert.
4. Kopiere die generierte URL und füge sie in deinen Browser ein.
5. Wähle den Server aus, auf den du den Bot einladen möchtest, und klicke auf „Autorisieren”.

Schritt 3: Das Projekt einrichten

Jetzt richten wir unser Projekt lokal ein.

1. Erstelle einen neuen Ordner für dein Bot-Projekt (z.B. „mein-discord-bot”).
2. Öffne deinen Code-Editor und öffne den erstellten Ordner.
3. Öffne ein Terminal im Code-Editor (normalerweise über „View” -> „Terminal”).
4. Initialisiere ein neues Node.js-Projekt mit dem Befehl: npm init -y.
5. Installiere die benötigte Discord.js-Bibliothek: npm install discord.js.
6. Erstelle eine neue Datei namens `index.js`. Dies wird die Hauptdatei für unseren Bot sein.

Schritt 4: Grundgerüst des Bots

In `index.js` schreiben wir den grundlegenden Code, um unseren Bot einzuloggen und zu überprüfen, ob er online ist.

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

// Ersetze 'YOUR_BOT_TOKEN' mit deinem echten Bot-Token
const token = 'YOUR_BOT_TOKEN';

// Erstelle eine neue Instanz des Clients
const client = new Client({ intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages, GatewayIntentBits.MessageContent] });

client.once(Events.ClientReady, c => {
    console.log(`Eingeloggt als ${c.user.tag}!`);
});

client.login(token);

Erklärung:

• require('discord.js') importiert die Discord.js-Bibliothek.
• const token = 'YOUR_BOT_TOKEN'; speichert deinen Bot-Token. Ersetze ‘YOUR_BOT_TOKEN’ mit deinem echten Token!
• new Client({ intents: [...] }) erstellt eine neue Client-Instanz mit den benötigten Intents. Die Intents legen fest, welche Ereignisse dein Bot empfangen kann.
• client.once(Events.ClientReady, c => { ... }) ist ein Event-Listener, der ausgelöst wird, wenn der Bot erfolgreich eingeloggt ist.
• client.login(token) loggt den Bot mit deinem Token ein.

Um den Bot zu starten, führe den Befehl node index.js im Terminal aus. Wenn alles gut geht, solltest du im Terminal die Meldung „Eingeloggt als [DeinBotName]!” sehen.

Schritt 5: Einen einfachen Command erstellen

Jetzt erstellen wir unseren ersten Discord Command. Wir werden einen einfachen „/ping” Command erstellen, der mit „Pong!” antwortet.

1. Erstelle einen neuen Ordner namens „commands”.
2. Erstelle im „commands”-Ordner eine neue Datei namens `ping.js`.

In `ping.js` schreiben wir den Code für unseren Command:

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

module.exports = {
    data: new SlashCommandBuilder()
        .setName('ping')
        .setDescription('Antwortet mit Pong!'),
    async execute(interaction) {
        await interaction.reply('Pong!');
    },
};

Erklärung:

• SlashCommandBuilder wird verwendet, um unseren Slash Command zu definieren.
• .setName('ping') setzt den Namen des Commands auf „ping”.
• .setDescription('Antwortet mit Pong!') setzt die Beschreibung des Commands.
• async execute(interaction) ist die Funktion, die ausgeführt wird, wenn der Command aufgerufen wird.
• await interaction.reply('Pong!') sendet eine Antwort mit dem Text „Pong!”.

Schritt 6: Commands registrieren und verarbeiten

Jetzt müssen wir unseren Command registrieren und verarbeiten. Wir passen `index.js` an:

const fs = require('node:fs');
const path = require('node:path');
const { Client, Collection, Events, GatewayIntentBits } = require('discord.js');

// Ersetze 'YOUR_BOT_TOKEN' mit deinem echten Bot-Token
const token = 'YOUR_BOT_TOKEN';

// Erstelle eine neue Instanz des Clients
const client = new Client({ intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages, GatewayIntentBits.MessageContent] });

// Command-Handler
client.commands = new Collection();
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);
    // Setze einen neuen Eintrag in der Collection mit dem Namen des Commands als Key und dem Command-Modul als Wert
    if ('data' in command && 'execute' in command) {
        client.commands.set(command.data.name, command);
    } else {
        console.log(`[WARNUNG] Der Command unter ${filePath} hat eine fehlende "data" oder "execute" Eigenschaft.`);
    }
}

client.once(Events.ClientReady, c => {
    console.log(`Eingeloggt als ${c.user.tag}!`);
});

client.on(Events.InteractionCreate, async interaction => {
    if (!interaction.isChatInputCommand()) return;

    const command = client.commands.get(interaction.commandName);

    if (!command) return;

    try {
        await command.execute(interaction);
    } catch (error) {
        console.error(error);
        await interaction.reply({ content: 'Da gab es einen Fehler beim Ausführen dieses Commands!', ephemeral: true });
    }
});

client.login(token);

Erklärung:

• Wir importieren `fs` und `path`, um unsere Command-Dateien zu lesen.
• Wir erstellen eine `Collection`, um unsere Commands zu speichern.
• Wir lesen alle JavaScript-Dateien im „commands”-Ordner und laden sie als Commands.
• Wir registrieren einen Event-Listener für `Events.InteractionCreate`. Dieser wird ausgelöst, wenn ein Benutzer einen Command ausführt.
• Wir überprüfen, ob der Command existiert und führen ihn aus.
• Wir fangen Fehler ab und senden eine Fehlermeldung an den Benutzer.

Schritt 7: Commands registrieren (Deployment)

Die Commands müssen registriert werden, bevor Discord sie erkennt. Dies geschieht am einfachsten mit einem separaten Skript. Erstelle eine Datei namens `deploy-commands.js`:

const { REST, Routes } = require('discord.js');
const fs = require('node:fs');
const path = require('node:path');

// Ersetze 'YOUR_BOT_TOKEN' mit deinem echten Bot-Token
const token = 'YOUR_BOT_TOKEN';
// Ersetze 'YOUR_CLIENT_ID' mit der Client ID deines Bots (findest du im Developer Portal)
const clientId = 'YOUR_CLIENT_ID';
// Ersetze 'YOUR_GUILD_ID' mit der Server ID, auf dem du die Commands registrieren möchtest (optional, für Testzwecke)
const guildId = 'YOUR_GUILD_ID'; // Optional: Nur für Test-Server

const commands = [];
// Schnapp dir alle Command-Dateien aus dem commands-Ordner
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);
    if ('data' in command && 'execute' in command) {
        commands.push(command.data.toJSON());
    } else {
        console.log(`[WARNUNG] Der Command unter ${filePath} hat eine fehlende "data" oder "execute" Eigenschaft.`);
    }
}

// Erstelle eine REST-Instanz für die API
const rest = new REST({ version: '10' }).setToken(token);

// Deploye die Commands!
(async () => {
    try {
        console.log(`Starte das Aktualisieren von ${commands.length} (/) Commands.`);

        // Die Methode put wird verwendet, um die vollständige Liste der Commands zu aktualisieren
        const data = await rest.put(
            guildId ? Routes.applicationGuildCommands(clientId, guildId) : Routes.applicationCommands(clientId),
            { body: commands },
        );

        console.log(`Erfolgreich ${data.length} (/) Commands aktualisiert.`);
    } catch (error) {
        // Und natürlich nicht zu vergessen, jeden Fehler zu loggen!
        console.error(error);
    }
})();

Wichtig: Ersetze `YOUR_BOT_TOKEN`, `YOUR_CLIENT_ID` und `YOUR_GUILD_ID` (falls du es nur auf einem Testserver ausprobieren willst) mit deinen korrekten Werten!

Führe dann den Befehl node deploy-commands.js aus. Nach erfolgreicher Ausführung solltest du eine Meldung im Terminal sehen, die bestätigt, dass die Commands aktualisiert wurden. Es kann einige Zeit dauern, bis die Commands in Discord angezeigt werden.

Schritt 8: Testen deines Commands

Gehe jetzt auf deinen Discord-Server. Gib `/ping` in eine Textkanal ein und drücke Enter. Dein Bot sollte mit „Pong!” antworten.

Glückwunsch!

Du hast erfolgreich deinen ersten Discord Command erstellt! Dies ist nur der Anfang. Du kannst jetzt komplexere Commands erstellen, die mit APIs interagieren, Daten verarbeiten und vieles mehr. Experimentiere, lerne und hab Spaß!