Projet Loldle — Quiz League of Legends en JavaFX avec JSON

Présentation du projet

Loldle est un jeu de type quiz inspiré du célèbre Wordle, mais dédié aux champions de League of Legends.
Le but est de deviner un champion en un nombre limité d’essais, avec des indices basés sur ses caractéristiques (rôle, région, type de ressource, etc.).

Le projet est réalisé en Java, avec une interface graphique développée en JavaFX et utilise un fichier JSON contenant les données des champions pour alimenter le quiz.

Objectifs du projet

• Apprendre à manipuler des fichiers JSON en Java.
• Concevoir une interface graphique interactive avec JavaFX.
• Implémenter la logique du jeu (vérification des réponses, affichage des indices).
• Gérer la persistance des données et l’affichage dynamique.

Architecture du projet

1. Données des champions (fichier JSON)

Le fichier champions.json contient un tableau d’objets, chaque objet représentant un champion avec ses attributs :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

[
  {
    "name": "Ahri",
    "gender": "Femme",
    "positions": ["Mid"],
    "species": "Vastaya",
    "resource": "Mana",
    "rangeType": "Distance",
    "regions": ["Ionia"],
    "releaseYear": 2011
  },
  {
    "name": "Yone",
    "gender": "Homme",
    "positions": ["Mid", "Top"],
    "species": "Humain altéré magiquement",
    "resource": "Aucune",
    "rangeType": "Corps à corps",
    "regions": ["Ionia"],
    "releaseYear": 2020
  }
]

2. Modèle de données (Classe Champion)

La classe Champion représente un champion avec tous ses attributs. Elle utilise des getters/setters pour l’encapsulation et est compatible avec Jackson pour la sérialisation JSON.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public class Champion {
    private String name;
    private String gender;
    private List<String> positions;
    private String species;
    private String resource;
    private String rangeType;
    private List<String> regions;
    private int releaseYear;
    // getters et setters...
}

3. Chargement JSON avec Jackson

1
2
3
4
5

ObjectMapper mapper = new ObjectMapper();
List<Champion> champions = mapper.readValue(
    new File("champions.json"),
    new TypeReference<List<Champion>>() {}
);

L’utilisation de Jackson permet de transformer automatiquement le JSON en objets Java. La classe ChampionLoader gère le chargement des données, la sélection aléatoire du champion mystère et la recherche par nom.

4. Interface JavaFX et logique de jeu

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

@FXML
private TextField guessInput;

@FXML
private void onGuessSubmit() {
    String guess = guessInput.getText();
    if (isValidChampion(guess)) {
        checkGuess(guess);
        updateUI();
    } else {
        showAlert("Champion invalide !");
    }
    guessInput.clear();
}

Le contrôleur JavaFX gère l’interaction utilisateur. Chaque tentative est validée puis comparée au champion mystère. La méthode checkGuess() compare chaque attribut et applique un code couleur :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

private void checkGuess(String guess) {
    Champion guessedChampion = findChampionByName(guess);
    // comparaison attribut par attribut
    if (guessedChampion.getGender().equals(secretChampion.getGender())) {
        // marquer en vert
    } else if (/* condition de proximité */) {
        // marquer en jaune
    } else {
        // marquer en gris
    }
    // répéter pour chaque attribut...
}

🎮 Fonctionnalités implémentées

Système d’indices colorés

Le jeu utilise un système visuel d’indices similaire à Wordle :

• 🟢 Vert : L’attribut correspond exactement
• 🔴 Rouge : L’attribut ne correspond pas

Interface utilisateur intuitive

• Champ de saisie avec validation en temps réel
• Historique des tentatives affiché sous forme de tableau
• Bouton nouvelle partie pour recommencer

Validation et gestion d’erreurs

• Vérification de l’existence du champion saisi
• Prévention des doublons (même champion proposé deux fois)
• Messages d’erreur clairs et informatifs
• Gestion robuste des exceptions lors du chargement JSON

🛠️ Technologies utilisées

• Java 11+ : Langage de programmation principal
• JavaFX : Framework pour l’interface graphique moderne
• Jackson : Bibliothèque pour le parsing JSON performant
• FXML : Séparation claire entre la vue et la logique métier
• Data Dragon (Riot CDN) : Utilisation des images officielles des champions directement depuis le CDN (Content Delivery Network) public de Riot pour un affichage fidèle et à jour des visuels.

🎯 Points techniques remarquables

Architecture MVC respectée

• Modèle : Classes Champion et ChampionLoader
• Vue : Fichier FXML avec interface utilisateur
• Contrôleur : GameController gérant la logique métier

Code réutilisable et extensible

Le système est conçu pour être facilement extensible. Ajouter de nouveaux champions ou attributs ne nécessite que de modifier le fichier JSON.

Performance optimisée

• Chargement unique des données au démarrage
• Interface réactive grâce aux listeners JavaFX

📈 Résultats et apprentissages

Ce projet m’a permis de maîtriser :

• La manipulation avancée de JSON en Java avec Jackson
• Le développement d’interfaces modernes avec JavaFX
• L’implémentation de logiques de jeu complexes
• La gestion d’états et d’événements dans une application graphique
• L’architecture logicielle avec séparation des responsabilités

Le résultat est une application fonctionnelle, attractive et facilement maintenable qui démontre une bonne maîtrise des technologies Java.