Aller au contenu
Retour aux projets

Perso2020

LobbyBot 2.0, bots Fortnite

Système complet de bots Fortnite avec gestion multi-comptes, bot Discord central, dashboard web temps réel et communauté de 8 500+ membres. Projet initié pendant le COVID à 16 ans, devenu mon plus gros projet personnel.

Durée
Projet personnel continu, depuis 2020
Équipe
Projet individuel, communauté de plus de 8 500 membres Discord
Mon rôle
Développeur unique : conception, développement, maintenance et gestion de communauté
TechnologiesNode.jsPythonDiscord.jsExpressSocket.IOPostgreSQLDockerOAuth2WebSocketAsyncio
LobbyBot 2.0, bots Fortnite

Contexte

LobbyBot 2.0 est mon plus gros projet personnel. Il a démarré en 2020, pendant le COVID, alors que j'avais 16 ans. À l'origine, c'était simplement des bots Fortnite en Python qui permettaient aux joueurs de voir tous les skins et danses du jeu. Le projet était financé par la publicité de mon code créateur Epic Games (10% de rémunération sur chaque achat effectué par mes soutiens sur le store Epic Games).

Les joueurs utilisaient les bots pour prévisualiser les skins et danses à venir dans la boutique, mais aussi pour jouer avec eux afin de faciliter leur progression et éviter de tomber contre des joueurs trop forts. J'ai eu plusieurs contacts avec Epic Games qui m'ont autorisé à faire ces bots.

Ce petit projet initié pendant le confinement est devenu, et reste encore aujourd'hui, mon plus gros projet personnel. La communauté compte plus de 8 500 membres sur Discord qui suivent activement le projet. Au fil des années, j'ai considérablement amélioré le code : passage du simple script Python à une architecture complète avec un bot Discord central en Node.js, un dashboard web en temps réel, une base de données PostgreSQL, et le tout orchestré avec Docker.

Les améliorations majeures incluent : l'automatisation de la création de nouveaux bots quand un bot atteint sa limite d'amis, l'automatisation du relancement des bots en cas de crash ou de redémarrage serveur, et un système de load balancing intelligent qui sélectionne automatiquement le bot le moins chargé pour chaque nouvel ami.

Objectifs

  1. 01Système multi-bots : Gérer un nombre illimité de bots Fortnite simultanément avec un load balancing intelligent (seuil de 900 amis par bot)
  2. 02Bot Discord central : Permettre aux 8 500+ membres de la communauté d'interagir avec les bots Fortnite via des commandes Discord (/add, /login, /list, /shop, /locker...)
  3. 03Dashboard web temps réel : Interface de contrôle permettant de voir l'état des bots, leurs amis, et de les gérer (kick, promote, privacy) via Socket.IO
  4. 04Automatisation complète : Création automatique de bots, relancement en cas de crash, et gestion autonome des listes d'amis
  5. 05Internationalisation : Support multilingue (FR/EN/ES/DE) pour la communauté internationale

Approche technique

Le projet a évolué d'un simple script Python vers une architecture distribuée complète :

  • Phase 1 (2020) : Bots Python simples utilisant les API non-documentées d'Epic Games, avec authentification OAuth2 et gestion basique des amis et skins.
  • Phase 2 (évolution) : Migration vers une architecture Node.js pour le bot Discord central, avec Discord.js pour gérer les commandes de la communauté.
  • Phase 3 (actuelle, LobbyBot 2.0) : Architecture complète avec trois composants principaux orchestrés par Docker :

1. Discord Manager (Node.js) : Le cœur du système. Gère tous les bots simultanément, le load balancing, les commandes Discord, et la communication avec la base de données PostgreSQL.

2. Dashboard Web (Node.js/Express/Socket.IO) : Interface de contrôle en temps réel avec un design "Space/Starfield". Communication instantanée avec le Manager via Socket.IO.

3. Base de données PostgreSQL : Stockage des comptes bots, utilisateurs, préférences de langue, et statistiques.

Le système de load balancing sélectionne automatiquement le bot ayant le moins d'amis (< 900) pour chaque nouvelle demande d'ajout. Si tous les bots sont pleins, un nouveau bot est créé automatiquement.

Architecture

Architecture distribuée Docker multi-services :

  • lobbybot2.0-discord/ (Node.js) : Manager central
  • 'src/managers/' : Gestionnaires principaux (Bots, Database, User, API, Discord)
  • 'src/commands/' : Commandes Discord (/login, /add, /list, /shop, /locker, /admin...)
  • 'src/actions/' : Logique des actions Fortnite (Skin, Party, Friends)
  • 'src/utils/' : Utilitaires (Locales i18n, helpers)
  • lobbybot2.0-website/ (Node.js/Express) : Dashboard web
  • Backend Express + Socket.IO pour la communication temps réel
  • Frontend HTML5/CSS3/Vanilla JS avec design "Space/Starfield"
  • Affichage de l'état des bots, amis, contrôles (Kick, Promote, Privacy)
  • PostgreSQL : Base de données partagée (comptes, utilisateurs, préférences)
  • Docker Compose : Orchestration des trois services

Compétences développées

Architecture distribuée & Docker

Conception et déploiement d'une architecture multi-services avec Docker Compose : Manager Node.js, Dashboard web, et base de données PostgreSQL communiquant en temps réel.

Gestion de communauté & produit

Animation d'une communauté de 8 500+ membres Discord, gestion des retours utilisateurs, évolution continue du produit sur 5+ ans, et financement via code créateur Epic Games.

Communication temps réel (Socket.IO)

Implémentation de communications bidirectionnelles en temps réel entre le Dashboard web et le Manager via Socket.IO pour le contrôle instantané des bots.

Automatisation & Load Balancing

Système intelligent de répartition de charge entre les bots, création automatique de nouveaux bots, et relancement automatique en cas de crash ou redémarrage serveur.

Extraits de code

Load Balancing intelligent des bots
javascript
1// LobbyBot 2.0 - Bot Manager avec load balancing
2class BotManager {
3  constructor() {
4    this.bots = new Map();  // Map<botId, BotInstance>
5    this.FRIEND_LIMIT = 900;
6  }
7
8  async selectOptimalBot() {
9    // 1. Filtrer les bots disponibles (< 900 amis)
10    const availableBots = Array.from(this.bots.values())
11      .filter(bot => bot.isReady && bot.friendCount < this.FRIEND_LIMIT)
12      .sort((a, b) => a.friendCount - b.friendCount);
13
14    if (availableBots.length > 0) {
15      // 2. Retourner le bot avec le moins d'amis
16      const selectedBot = availableBots[0];
17      return selectedBot;
18    }
19
20    // 3. Si tous les bots sont pleins, creer automatiquement un nouveau bot
21    const newBot = await this.createNewBot();
22    return newBot;
23  }
24
25  async addFriend(epicUsername) {
26    const bot = await this.selectOptimalBot();
27
28    try {
29      await bot.addFriend(epicUsername);
30      bot.friendCount++;
31
32      // Sauvegarder en base de donnees PostgreSQL
33      await db.query(
34        'UPDATE bots SET friend_count = $1 WHERE account_id = $2',
35        [bot.friendCount, bot.accountId]
36      );
37
38      return { success: true, bot: bot.displayName };
39    } catch (error) {
40      return { success: false, error: error.message };
41    }
42  }
43}

Ce code implémente le système de load balancing du Bot Manager. La méthode selectOptimalBot() filtre les bots disponibles (< 900 amis), les trie par nombre d'amis croissant, et retourne le moins chargé. Si tous les bots sont pleins, un nouveau bot est automatiquement créé depuis le pool PostgreSQL.

Communication temps réel Socket.IO Dashboard
javascript
1// LobbyBot 2.0 - Dashboard Socket.IO Server
2const express = require('express');
3const socketIo = require('socket.io');
4const server = require('http').createServer(express());
5const io = socketIo(server);
6
7// Connexion au Discord Manager via Socket.IO
8const managerSocket = require('socket.io-client')('http://localhost:3001');
9
10io.on('connection', (clientSocket) => {
11  // 1. Envoyer etat initial des bots au client
12  managerSocket.emit('get_all_bots_status', (botsData) => {
13    clientSocket.emit('initial_state', {
14      bots: botsData.bots,
15      totalFriends: botsData.totalFriends,
16      activeBots: botsData.activeBots
17    });
18  });
19
20  // 2. Ecouter les mises a jour en temps reel du Manager
21  managerSocket.on('bot_status_update', (data) => {
22    io.emit('bot_update', {
23      botId: data.botId,
24      displayName: data.displayName,
25      friendCount: data.friendCount,
26      status: data.status
27    });
28  });
29
30  // 3. Actions depuis le dashboard vers le Manager
31  clientSocket.on('kick_friend', async (data) => {
32    managerSocket.emit('kick_friend', {
33      botId: data.botId,
34      friendId: data.friendId
35    }, (response) => {
36      clientSocket.emit('kick_response', response);
37    });
38  });
39});

Ce code gère la communication temps réel entre le Dashboard web et le Discord Manager via Socket.IO. Le serveur Dashboard écoute les connexions clients, envoie l'état initial des bots, propage les mises à jour en temps réel et gère les actions utilisateur (kick, changement de skin).

Résultats & bilan

LobbyBot 2.0 est un projet actif depuis 2020 avec des résultats concrets :

  • 8 500+ membres Discord suivant activement le projet et utilisant les bots au quotidien
  • Système multi-bots fonctionnel avec load balancing intelligent et création automatique de nouveaux bots
  • Dashboard web temps réel permettant le monitoring et le contrôle de tous les bots
  • Autorisation officielle d'Epic Games obtenue après plusieurs échanges directs
  • Financement autonome via le système de code créateur Epic Games (10% de commission)
  • 5+ ans de maintenance continue, avec des évolutions majeures (Python → Node.js, scripts → architecture Docker)
  • Internationalisation complète en 4 langues (FR/EN/ES/DE) pour la communauté internationale

Ce projet, initié à 16 ans pendant le COVID, est devenu et reste mon plus gros projet personnel, démontrant ma capacité à mener un projet de A à Z sur le long terme.

Réflexion & apprentissages

LobbyBot 2.0 est le projet qui m'a le plus appris en dehors du cadre scolaire :

  1. 01L'évolution technique sur 5 ans m'a fait passer de simples scripts Python à une architecture distribuée complète avec Docker. Chaque itération m'a poussé à apprendre de nouvelles technologies pour résoudre des problèmes concrets : Node.js pour la performance, PostgreSQL pour la persistance, Socket.IO pour le temps réel, Docker pour le déploiement.
  1. 02La gestion d'une communauté de 8 500+ membres m'a enseigné des compétences non-techniques essentielles : communication, gestion des attentes, priorisation des fonctionnalités basée sur les retours utilisateurs, et la responsabilité de maintenir un service utilisé quotidiennement.
  1. 03Le contact avec Epic Games m'a appris à interagir professionnellement avec une grande entreprise, à présenter mon projet de manière convaincante et à respecter leurs conditions d'utilisation.
  1. 04La maintenance sur le long terme est la leçon la plus importante : les API changent, les serveurs crashent, les utilisateurs ont des besoins qui évoluent. Ce projet m'a enseigné la valeur d'une architecture robuste, de l'automatisation (relancement automatique, load balancing), et de la documentation.

Ce projet prouve qu'un side project passionné peut devenir quelque chose de significatif avec de la persévérance et une amélioration continue.

Liens

Projet suivantReferendum, application de vote sécurisée