Projet 01 / Étude de cas

Prototype expérimental fonctionnel

LoL Analytics.

Un prototype local pour explorer des profils League of Legends, leurs parties et des statistiques observées. Mon premier projet pour apprendre à relier une interface, une API et des données.

  • Nuxt 4
  • Vue 3
  • TypeScript
  • API Riot Games
  • SQLite
  • Tailwind CSS
Lire l’expérience
Profil joueur du prototype LoL Analytics : identité, classement et synthèse des parties avec des données simulées.
Capture de validation · Données simuléesLe profil joueur

Capture du prototype local. Le profil et les statistiques présentés sont simulés.

Nature
Projet personnel
Résultat
Prototype local
Méthode
Sprints & assistance IA

Prototype expérimental fonctionnel en local, non déployé publiquement. Le mode réel nécessite une clé Riot privée côté serveur ; un mode démonstration distinct utilise des profils fictifs. Aucune démonstration publique, clé API ou base SQLite n’est accessible depuis ce portfolio.

01 / Présentation

D’une envie à un prototype.

L’idée de départ : explorer ce qu’il est possible de construire autour des données de League of Legends. Les plateformes d’analyse existantes ont donné envie d’essayer, à l’échelle d’un projet personnel.

Le projet a progressivement relié une interface Nuxt aux API officielles Riot, puis à une collecte locale et à des statistiques issues des parties. L’objectif était de découvrir ces outils et leurs limites en construisant un résultat concret.

02 / Objectifs

Ce que je voulais découvrir.

  • Découvrir une API externe et apprendre à lire sa documentation.
  • Construire une interface alimentée par des données réelles.
  • Comprendre la collecte, le stockage et le traitement statistique.
  • Expérimenter le développement assisté par IA et vérifier les résultats.

03 / Réalisation technique

Relier les différentes pièces.

Une application Nuxt indépendante

Nuxt 4, Vue 3 et TypeScript structurent les pages et les contrats de données. Les composants d’interface sont réutilisés, avec Tailwind CSS et des styles dédiés. Le portfolio et LoL Analytics restent deux applications autonomes dans un monorepo pnpm.

Riot côté serveur

Les services Account-v1, Summoner-v4, League-v4 et Match-v5 permettent de retrouver un compte, son profil, son classement et ses matchs. La clé reste côté serveur. Un cache, la déduplication et la gestion de Retry-After limitent les appels inutiles ; Data Dragon fournit les ressources officielles.

Une collecte et un stockage locaux

Les matchs et timelines Match-v5 sont collectés en quantité bornée. Weekly Meta utilise SQLite avec déduplication et séparation des patchs. Les statistiques personnelles partent du propre historique du joueur, distinct de l’échantillon multi-joueurs.

Visualiser et vérifier

Cartes, tableaux et graphiques présentent les résultats avec leurs échantillons. Les tests Playwright couvrent les calculs, les erreurs et les parcours. Git, GitHub, les pull requests et les vérifications automatisées accompagnent les changements par étapes.

Ce que permet le prototype

  • Recherche de profils EUW par Riot ID, classement et historique des parties.
  • Statistiques des matchs, participants, champions et objets.
  • Exploration des champions, objets et runes via Data Dragon.
  • Weekly Meta : statistiques hebdomadaires sur une collecte SQLite locale.
  • Builds et matchups observés, avec leurs tailles d’échantillon.
  • Statistiques personnelles : solo kills, morts isolées estimées et Jungle Proximity approximative.

04 / Méthode & IA

Cadrer, construire, vérifier.

J’ai utilisé des assistants de développement IA pour produire et faire évoluer le code. Mon travail a consisté à définir les objectifs, préciser les contraintes, essayer les versions en local et demander des corrections à partir des problèmes rencontrés.

Le projet a avancé par sprints et pull requests : démonstration, intégration Riot, exploration des données, statistiques personnelles, puis présentation visuelle. Cette méthode m’a permis d’expérimenter un dialogue de travail avec des agents IA et d’apprendre à examiner leurs résultats.

  1. Cadrer
  2. Construire
  3. Tester
  4. Corriger

06 / Difficultés rencontrées

Les contraintes font partie du projet.

Respecter les quotas Riot

Une clé de développement et les limites de requêtes imposent une collecte raisonnable. Les erreurs, les délais Retry-After et la reprise doivent rester compréhensibles, sans remplacer une panne par des données fictives.

Composer avec les données manquantes

Un compte peut être non classé, un match incomplet ou une timeline absente. Une valeur indisponible et sa raison sont plus utiles qu’un chiffre inventé.

Interpréter de petits échantillons

Une base locale limitée ne décrit pas toute la région EUW. Les patchs, rôles et dénominateurs doivent rester visibles. Un objet fréquent n’est pas automatiquement le meilleur choix.

Approcher des métriques avec les timelines

Les solo kills reposent sur les assistances enregistrées. Les morts isolées et la proximité du jungler utilisent des positions échantillonnées : ce sont des estimations, avec des cas non évaluables et des dénominateurs propres.

Comprendre le cadre d’un prototype local

Un outil personnel peut fonctionner en local sans être prêt pour une ouverture publique. Les quotas, la confidentialité des données, l’exploitation et la maintenance demanderaient un travail supplémentaire.

07 / Ce que j’ai appris

Ce que je garde de l’expérience.

  1. Structurer progressivement une application, séparer l’interface, les services et les données.
  2. Lire une documentation technique et relier les réponses d’une API à des types TypeScript.
  3. Tester un parcours, identifier une erreur et vérifier une correction.
  4. Organiser des changements avec Git, GitHub et des pull requests.
  5. Donner des instructions à des agents de développement IA et examiner le résultat obtenu.
  6. Présenter une analyse de données avec ses limites, ses absences et ses incertitudes.

08 / Résultat

Un projet qui a rempli son rôle.

Le résultat est un prototype expérimental fonctionnel en local, avec un mode Riot réel et une démonstration distincte. Il permet de parcourir une chaîne complète : récupérer des données, les stocker, les traiter et les rendre lisibles.

J’ai choisi d’arrêter l’ajout de fonctionnalités après avoir atteint mes objectifs d’apprentissage. Cette étude de cas conserve une trace de l’expérience, de la méthode et des limites du projet.

Pour aller plus loin

Pour aller plus loin, il faudrait notamment étudier la robustesse sur davantage de cas et les conditions d’une éventuelle ouverture publique. Ces pistes ne constituent pas un engagement de développement.

Une première exploration, documentée pour garder une trace du chemin parcouru.

Retour aux projets