1. Spécification des composants

Objectif

Découpage de la solution en composants (ou sous-systèmes), affectation des responsabilités aux composants et spécification des interfaces fournies et requises par ces composants

Moyens

Utilisez des diagrammes d’interaction (séquence, communication) pour décrire l’échange de messages entre les composants pour en déduire leurs interfaces.

Introduction

Ce document présente une vue détaillée de l’architecture du système de jeu interactif. Chaque composant du système est soigneusement conçu pour assurer une performance optimale, facilitant ainsi une expérience utilisateur engageante et efficace. L’architecture modulaire permet une flexibilité et une évolutivité, garantissant la pérennité et la maintenance aisée du système. Ce document couvre la description de l’architecture globale, les détails des composants individuels et les cas d’utilisation.

1. Description de l’Architecture Globale

2. Vue d’Ensemble

L’architecture de notre système de jeu est conçue pour offrir une expérience de jeu interactive et robuste, tout en assurant une gestion efficace des ressources et une évolutivité. Le système est construit autour d’une série de composants interdépendants, chacun ayant des responsabilités spécifiques, et communiquant entre eux via des interfaces bien définies. Cette architecture modulaire permet une maintenance et une mise à jour aisées des différentes parties du système.

3. Composants Clés et Leurs Interactions

  1. Game Board Component (Composant Plateau de Jeu): Ce composant est le cœur de l’expérience de jeu. Il initialise le plateau de jeu, gère les connexions des joueurs, orchestre les tours de jeu, et détermine le gagnant. Il interagit étroitement avec le Game Management Component pour la gestion des tours et des événements de jeu.

  2. Game Management Component (Composant Gestion de Partie): Ce composant est responsable de l’initialisation des jeux, de la détermination de l’ordre des tours, et de l’évaluation des conditions de victoire. Il collabore avec le Dice and Movement Component pour les mouvements des joueurs et avec le Players Component pour la gestion des informations des joueurs.

  3. Dice and Movement Component (Composant Dés et Mouvement): Il simule les lancers de dés et calcule les mouvements des joueurs sur le plateau. Il fournit des données essentielles au Game Management Component pour la progression du jeu.

  4. Question Cards Component (Composant Cartes de Questions): Ce composant stocke et gère les questions et les réponses.Il distribue les questions aux joueurs et valide les réponses, en interaction avec le Game Management Component.

  5. Players Component (Composant Joueurs): Il gère les profils des joueurs, suit les scores et met à jour les statuts des joueurs. Ce composant est essentiel pour personnaliser l’expérience de jeu et maintenir l’engagement des joueurs.

  6. Game Server Component (Composant Serveur de Jeu): Ce composant central coordonne toutes les interactions entre les joueurs et le jeu. Il s’occupe de l’authentification, de la gestion des sessions et des comptes, et interagit avec la base de données pour la persistance des données.

  7. Base de Données: Un composant essentiel pour la persistance des états de jeu, des scores, et des informations des joueurs. Il est intégré au Game Server Component pour stocker et récupérer des données.

4. Intégration et Flux de Données

Les interactions entre ces composants sont conçues pour être fluides et efficaces. Par exemple, lorsqu’un joueur lance le dé (via le Dice and Movement Component), le résultat est transmis au Game Management Component, qui à son tour, met à jour le Game Board Component avec le nouveau positionnement du joueur.

En parallèle, les informations des joueurs sont constamment synchronisées avec la base de données via le Game Server Component.

diagram

Détails des Composants Individuels

1. Game Board Component (Composant Plateau de Jeu)

diagram

1.1. Responsabilités du Game Board Component

  1. Initialisation du Plateau de Jeu :

    • Crée et initialise la représentation du plateau de jeu avec toutes les cases et pions des joueurs.

  2. Gestion des Connexions au Plateau :

    • Gère les connexions des joueurs au plateau de jeu et attribue les pions de manière unique.

  3. Début de la Partie :

    • Lance la partie une fois que tous les joueurs sont prêts et distribue les éléments nécessaires pour débuter, comme les cartes de départ.

  4. Gestion des Tours

    • À chaque tour, gère la réception des choix des joueurs, y compris les cartes jouées et les actions entreprises.

  5. Distribution des Mises à Jour de Jeu :

    • Après chaque tour, envoie aux joueurs les mises à jour nécessaires, telles que de nouvelles cartes et les actions des autres joueurs.

  6. Détermination du Gagnant :

    • À la fin de la partie, évalue les conditions de victoire pour déterminer le gagnant.

1.2. Interfaces fournies

1.2.1. BoardLayoutInterface

png

  1. initializeGameBoard() : GameBoardState

    • Description : Initialise le plateau de jeu pour la nouvelle partie.

    • Aucun paramètre.

    • Retour : GameBoardState - État initial du plateau de jeu.

  2. connectPlayer(playerId: String[1..1], playerToken: Token[1..1]) : Boolean

    • Description : Connecte un joueur au jeu et lui attribue un pion.

    • Paramètres : playerId - L’identifiant unique du joueur, playerToken - Le pion attribué au joueur.

    • Retour : Boolean - Succès ou échec de la connexion.

  3. startGame() : GameStartOutcome

    • Description : Démarre la partie une fois tous les joueurs connectés.

    • Aucun paramètre.

    • Retour : GameStartOutcome - Détails sur le démarrage de la partie, y compris l’ordre des joueurs

  4. receiveTurnActions(actions: List<Action>[1..*]) : TurnOutcome

    • Description : Reçoit et traite les actions des joueurs pour un tour.

    • Paramètres : actions - Liste des actions entreprises par les joueurs pendant leur tour.

    • Retour : TurnOutcome - Résultat du traitement des actions du tour.

  5. endGame() : GameEndOutcome

    • Description : Termine la partie et détermine le gagnant.

    • Aucun paramètre.

    • Retour : GameEndOutcome - Résultat de la partie, y compris le gagnant et les scores finaux.

1.3. Contraintes OCL pour BoardInterface

context BoardInterface::connectPlayer(playerId: String, playerToken: Token): Boolean

pre: -- Le joueur n'est pas déjà connecté.
      not GameBoard.allInstances().players->exists(p | p.id = playerId)

post: -- Si la méthode retourne vrai, alors le joueur est ajouté à la liste des joueurs du plateau de jeu avec le pion spécifié.
      result = true implies (GameBoard.allInstances().players->any(p | p.id = playerId).token = playerToken)

2. Définition du Type GameStartOutcome

Le type GameStartOutcome est crucial pour comprendre le résultat de l’initialisation d’une partie de jeu. Il est utilisé par le Game Board Component et le Game Management Component pour communiquer le succès ou l’échec du démarrage d’une partie de jeu.

2.1. Structure de GameStartOutcome

diagram
GameStartOutcome comprend les champs suivants :

  • success (Boolean) : Indique si la partie a été lancée avec succès.

  • message (String) : Fournit des détails sur le processus d’initialisation ou une explication en cas d’échec.

  • gameId (String) : L’identifiant unique de la partie de jeu démarrée.

  • gameSettings (GameSettings): Les paramètres spécifiques à la partie démarrée.

  • playersInfo (PlayerInfo[*]) : Informations sur les joueurs participant à la partie.

  • initialGameState (GameState) : État initial du jeu au moment du démarrage.

  • startTime (DateTime) : L’heure à laquelle la partie a commencé.

2.2. Utilisation de GameStartOutcome

Dans le processus d’initialisation du jeu : Le Game Board Component appelle initializeGameBoard() et reçoit un GameStartOutcome comme résultat. Ce résultat est ensuite utilisé pour informer les autres composants du système, tels que le Game Management Component, sur l’état de la partie démarrée. Cela permet une communication claire et structurée entre les composants concernant le démarrage d’une nouvelle partie de jeu.

3. Définition du Type GameBoardState

Le type GameBoardState est essentiel pour représenter l’état courant du plateau de jeu. Il est utilisé par le Game Board Component pour suivre et gérer l’état du jeu à tout moment.

3.1. Structure de GameBoardState

diagram
GameBoardState comprend les champs suivants :

  • boardLayout (BoardLayout) : La configuration actuelle du plateau de jeu.

  • playerPositions (Map<Player, Position>) : La position de chaque joueur sur le plateau.

  • currentTurn (Player) : Le joueur dont c’est le tour actuel.

  • gameStatus (GameStatus) : L’état actuel du jeu (en cours, terminé, etc.).

  • specialEvents (List<Event>) : Les événements spéciaux qui peuvent affecter le jeu.

3.2. Utilisation de GameBoardState

Le GameBoardState est constamment mis à jour par le Game Board Component à chaque action dans le jeu : * Lorsque les joueurs se déplacent sur le plateau. * Quand un tour de jeu est terminé. * Lorsque des événements spéciaux se produisent.

Cela permet une représentation précise et actualisée de l’état du jeu, essentielle pour la prise de décisions et la progression du jeu.

3.2.1. SpecialEventInterface

diagram

  1. triggerSpecialEvent(eventType: EventType) : EventOutcome

    • Description : Déclenche un événement spécial sur le plateau de jeu.

    • Paramètres : eventType - Le type d’événement spécial à déclencher.

    • Retour : EventOutcome - Résultat de l’événement spécial, y compris ses effets sur le jeu.

4. Question Categories Component (Composant Catégories de Questions)

diagram

4.1. Responsabilités du Question Categories Component

  • Gestion des Catégories :

    • Maintient une liste de catégories de questions disponibles dans le jeu.

  • Distribution des Questions :

    • Fournit des questions à d’autres composants en fonction de la catégorie demandée.

  • Mise à jour des Catégories :

    • Permet l’ajout de nouvelles catégories ou la modification des catégories existantes.

4.2. Interfaces fournies

4.2.1. CategoryInterface

  1. getCategories() : List<Category>

    • Description : Récupère une liste de toutes les catégories de questions disponibles.

    • Aucun paramètre.

    • Retour : List<Category> - Liste des catégories de questions.

  2. getQuestionsByCategory(categoryId: String[1]) : List<Question>

    • Description : Récupère les questions pour une catégorie de questions spécifique.

    • Paramètres : categoryId - L’identifiant unique de la catégorie de questions.

    • Retour : List<Question> - Liste des questions associées à la catégorie spécifiée.

  3. addCategory(category: Category) : Boolean

    • Description : Ajoute une nouvelle catégorie de questions au système.

    • Paramètres : category - L’objet catégorie à ajouter.

    • Retour : Boolean - Indique si la catégorie a été ajoutée avec succès.

  4. updateCategory(categoryId: String[1], newDetails: Category) : Boolean

    • Description : Met à jour les détails d’une catégorie de questions existante.

    • Paramètres :

      • categoryId - L’identifiant unique de la catégorie à mettre à jour.

      • newDetails - Les nouveaux détails de la catégorie.

    • Retour : Boolean - Succès ou échec de la mise à jour.

4.3. Contraintes OCL pour CategoryInterface

context CategoryInterface::getQuestionsByCategory(categoryId: String): List<Question>

pre: -- La catégorie demandée doit exister.
      QuestionCategories.allInstances().categories->exists(c | c.id = categoryId)

post: -- Le résultat doit être une liste de questions qui appartient uniquement à la catégorie spécifiée.
      result = QuestionCategories.allInstances().categories->select(c | c.id = categoryId).questions


context CategoryInterface::addCategory(category: Category): Boolean

pre: -- La catégorie ne doit pas déjà exister.
not QuestionCategories.allInstances().categories->exists(c | c.id = category.id)

post: -- Si la méthode retourne vrai, alors la nouvelle catégorie est ajoutée.
result = true implies (QuestionCategories.allInstances().categories->includes(category))

5. Question Cards Component (Composant Cartes de Questions)

diagram

5.1. Responsabilités du Question Cards Component

  • Stockage des Questions et Réponses :

    • Maintient une base de données des cartes de questions, chacune avec sa question et sa réponse associée.

  • Distribution des Questions :

    • Sélectionne et fournit des questions aux joueurs ou autres composants en fonction de la demande.

  • Validation des Réponses :

    • Permet la vérification des réponses soumises par les joueurs.

5.2. Interfaces fournies

5.2.1. CardsInterface

  1. getQuestion(cardId: String[1]) : Question

    • Description : Récupère une question spécifique basée sur l’identifiant de la carte de question.

    • Paramètres : cardId - L’identifiant unique de la carte de question.

    • Retour : Question - La question associée à la carte de question spécifiée.

  2. validateAnswer(cardId: String[1], answer: String) : Boolean

    • Description : Vérifie si la réponse fournie est correcte pour la question spécifiée.

    • Paramètres :

      • cardId - L’identifiant de la carte de question.

      • answer - La réponse à valider.

    • Retour : Boolean - Vrai si la réponse est correcte, faux sinon.

  3. addQuestionCard(questionCard: QuestionCard) : Boolean

    • Description : Ajoute une nouvelle carte de question à la base de données.

    • Paramètres : questionCard - L’objet carte de question à ajouter.

    • Retour : Boolean - Indique si la carte de question a été ajoutée avec succès.

  4. updateQuestionCard(cardId: String[1], newDetails: QuestionCard) : Boolean

    • Description : Met à jour les détails d’une carte de question existante.

    • Paramètres :

      • cardId - L’identifiant unique de la carte de question à mettre à jour.

      • newDetails - Les nouveaux détails de la carte de question.

    • Retour : Boolean - Succès ou échec de la mise à jour.

5.3. Contraintes OCL pour CardsInterface

context CardsInterface::getQuestion(cardId: String): Question

pre: -- La carte de question demandée doit exister dans le système.
      QuestionCards.allInstances().cards->exists(c | c.id = cardId)

post: -- Le résultat doit être la question qui est associée à l'identifiant de carte de question donné.
      result = QuestionCards.allInstances().cards->select(c | c.id = cardId).question

context CardsInterface::validateAnswer(cardId: String, answer: String): Boolean

pre: -- La carte de question pour laquelle la validation est demandée doit exister.
      QuestionCards.allInstances().cards->exists(c | c.id = cardId)

post: -- Le résultat indique si la réponse donnée correspond à la réponse correcte pour la question.
      result = (QuestionCards.allInstances().cards->select(c | c.id = cardId).correctAnswer = answer)

6. Players Component (Composant Joueurs)

diagram

6.1. Responsabilités du Players Component

  • Gestion des Profils des Joueurs :

    • Maintient les profils des joueurs, y compris leurs informations personnelles et leur état dans le jeu.

  • Suivi des Scores :

    • Suit les scores des joueurs tout au long du jeu et met à jour les classements.

  • Gestion des Statuts des Joueurs :

    • Met à jour et contrôle les statuts des joueurs, comme actif, en attente, ou déconnecté.

6.2. Interfaces fournies

6.2.1. PlayerInterface

  1. getPlayerInfo(playerId: String[1]) : PlayerInfo

    • Description : Récupère les informations d’un joueur spécifique.

    • Paramètres : playerId - L’identifiant unique du joueur.

    • Retour : PlayerInfo - Les informations détaillées du joueur.

  2. updateScore(playerId: String[1], score: Integer) : Boolean

    • Description : Met à jour le score d’un joueur.

    • Paramètres :

      • playerId - L’identifiant du joueur.

      • score - Le nouveau score à attribuer au joueur.

    • Retour : Boolean - Vrai si la mise à jour est réussie, faux sinon.

  3. setPlayerStatus(playerId: String[1], status: PlayerStatus) : Boolean

    • Description : Change le statut d’un joueur dans le jeu.

    • Paramètres :

      • playerId - L’identifiant du joueur.

      • status - Le nouveau statut à définir pour le joueur.

    • Retour : Boolean - Vrai si le statut est mis à jour avec succès, faux sinon.

6.3. Contraintes OCL pour PlayerInterface

context PlayerInterface::getPlayerInfo(playerId: String): PlayerInfo

pre: -- Le joueur demandé doit exister dans le système.
      Players.allInstances().playerList->exists(p | p.id = playerId)

post: -- Le résultat doit être les informations correspondant au joueur demandé.
      result = Players.allInstances().playerList->select(p | p.id = playerId).info

context PlayerInterface::updateScore(playerId: String, score: Integer): Boolean

pre: -- Le joueur doit exister et le score doit être non négatif.
      Players.allInstances().playerList->exists(p | p.id = playerId) and
      score >= 0

post: -- Si la méthode retourne vrai, alors le score du joueur est mis à jour.
      result = true implies
      (Players.allInstances().playerList->select(p | p.id = playerId).score = score)


context PlayerInterface::setPlayerStatus(playerId: String, status: PlayerStatus): Boolean

pre: -- Le joueur doit exister dans le système.
Players.allInstances().playerList->exists(p | p.id = playerId)

post: -- Si la méthode retourne vrai, alors le statut du joueur est mis à jour avec le nouveau statut.
result = true implies
(Players.allInstances().playerList->select(p | p.id = playerId).status = status)

7. Game Management Component (Composant Gestion de Partie)

diagram

7.1. Responsabilités du Game Management Component

  • Initialisation du Jeu :

    • Configure et initialise une nouvelle partie de jeu avec ses paramètres.

  • Gestion de l’Ordre des Tours :

    • Détermine et gère l’ordre dans lequel les joueurs effectuent leurs tours.

  • Conditions de Victoire :

    • Évalue les conditions de victoire pour déterminer le gagnant de la partie.

7.2. Interfaces fournies

7.2.1. GameManagementInterface

  1. initializeGame(params: GameParameters) : Boolean

    • Description : Initialise une nouvelle partie de jeu avec les paramètres spécifiés.

    • Paramètres : params - Les paramètres de configuration de la partie.

    • Retour : Boolean - Vrai si l’initialisation réussit, faux sinon.

  2. determineTurnOrder(players: List<PlayerInfo>[2..*]) : List<PlayerInfo>

    • Description : Détermine l’ordre dans lequel les joueurs effectueront leurs tours.

    • Paramètres : players - La liste des informations sur les joueurs.

    • Retour : List<PlayerInfo> - La liste des joueurs dans l’ordre des tours.

  3. checkVictoryConditions(gameState: GameState) : PlayerInfo

    • Description : Évalue les conditions de victoire pour déterminer le gagnant de la partie.

    • Paramètres : gameState - L’état actuel du jeu.

    • Retour : PlayerInfo - Les informations sur le joueur gagnant ou null s’il n’y a pas encore de gagnant.

7.3. Contraintes OCL pour GameManagementInterface

context GameManagementInterface::initializeGame(params: GameParameters): Boolean

pre: -- Les paramètres de configuration doivent être valides.
      params.isValid()

post: -- Si la méthode retourne vrai, alors le jeu est correctement initialisé.
      result = true implies
      (GameState.allInstances().exists(g | g.params = params))

context GameManagementInterface::determineTurnOrder(players: List<PlayerInfo>): List<PlayerInfo>

pre: -- Il doit y avoir au moins deux joueurs.
      players->size() >= 2

post: -- Le résultat doit contenir tous les joueurs une fois, sans répétition.
      result->size() = players->size() and
      players->forAll(p | result->includes(p))

context GameManagementInterface::checkVictoryConditions(gameState: GameState): PlayerInfo

pre: -- L'état du jeu doit être valide.
      gameState.isValid()

post: -- Si un joueur a rempli les conditions de victoire, il est désigné comme gagnant.
      result = gameState.winner

8. Dice and Movement Component (Composant Dés et Mouvement)

diagram

8.1. Responsabilités du Dice and Movement Component

  • Simulation de Lancer de Dés :

    • Gère la simulation du lancer de dés pour déterminer un nombre aléatoire.

  • Calcul du Nombre de Mouvements :

    • Utilise les résultats des lancers de dés pour déterminer le nombre de mouvements d’un joueur.

8.2. Interfaces fournies

8.2.1. DiceInterface

  1. rollDice() : Integer

    • Description : Simule le lancer d’un dé et retourne un nombre aléatoire.

    • Aucun paramètre.

    • Retour : Integer - Le résultat du lancer de dé, un nombre entre 1 et 6.

  2. calculateMovements(diceResult: Integer[1..1]) : Integer

    • Description : Calcule le nombre de mouvements pour un joueur en fonction du résultat du lancer de dés.

    • Paramètres : diceResult - Le résultat du lancer de dé.

    • Retour : Integer - Le nombre de mouvements calculé.

8.3. Contraintes OCL pour DiceInterface

context DiceInterface::rollDice(): Integer

pre: -- Aucune précondition particulière pour le lancer de dé.

post: -- Le résultat du lancer de dé doit être un nombre entre 1 et 6.
      result >= 1 and result <= 6

context DiceInterface::calculateMovements(diceResult: Integer[1..1]): Integer

pre: -- Le résultat du lancer de dés doit être fourni.
      diceResult->notEmpty()

post: -- Le nombre de mouvements calculé doit être positif.
      result > 0

9. Game Server Component (Composant Serveur de Jeu)

Ce composant est le cœur du système de jeu, il coordonne toutes les interactions entre les joueurs et le jeu. Il est responsable de l’authentification des joueurs, de la gestion des sessions, de la gestion des comptes, de la préparation et de l’orchestration des parties, ainsi que de l’interaction avec la base de données pour la persistance des données du jeu.

9.1. Responsabilités du Game Server Component

  1. Authentification des Joueurs :

    • Valide les identifiants des joueurs et crée une session de jeu sécurisée.

  2. Gestion des Sessions :

    • Gère la vie des sessions de jeu, de la création à la destruction après la déconnexion.

  3. Gestion des Comptes :

    • Permet aux joueurs de créer et de gérer leurs comptes, y compris les fonctionnalités de modification du mot de passe et de récupération de compte.

  4. Orchestration du Jeu :

    • Prépare et lance les parties, gère l’état du jeu et les interactions entre les composants.

  5. Interaction avec la Base de Données :

    • Enregistre et récupère les données de jeu, assure la persistance des états de partie et des scores.

9.2. Interfaces fournies

9.2.1. AuthenticationInterface

  1. login(username: String, password: String) : SessionToken

    • Description : Authentifie le joueur et retourne un jeton de session si les identifiants sont valides.

    • Paramètres : username - Le nom d’utilisateur du joueur, password - Le mot de passe du joueur.

    • Retour : SessionToken - Le jeton de session authentifiée.

  2. logout(sessionToken: SessionToken) : Boolean

    • Description : Déconnecte le joueur et termine la session de jeu.

    • Paramètres : sessionToken - Le jeton de session du joueur à déconnecter.

    • Retour : Boolean - Indique si la déconnexion a été réussie.

9.2.2. AccountManagementInterface

  1. createAccount(accountDetails: AccountDetails) : AccountCreationResult

    • Description : Crée un nouveau compte joueur avec les détails fournis.

    • Paramètres : accountDetails - Les informations nécessaires à la création du compte.

    • Retour : AccountCreationResult - Le résultat de la tentative de création de compte.

  2. changePassword(accountId: String, oldPassword: String, newPassword: String) : Boolean

    • Description : Change le mot de passe d’un compte existant après vérification de l’ancien mot de passe.

    • Paramètres : accountId - L’ID du compte, oldPassword - L’ancien mot de passe, newPassword - Le nouveau mot de passe.

    • Retour : Boolean - Indique si le changement a été effectué avec succès.

9.2.3. GameSessionInterface

  1. initializeGame(gameDetails: GameDetails) : GameSession

    • Description : Initialise une nouvelle partie avec les détails fournis et prépare l’état du jeu.

    • Paramètres : gameDetails - Les informations nécessaires pour configurer la nouvelle partie.

    • Retour : GameSession - Les détails de la session de jeu initialisée.

  2. startGame(sessionToken: SessionToken) : GameStartResult

    • Description : Démarre la partie pour la session de jeu authentifiée.

    • Paramètres : sessionToken - Le jeton de session du joueur qui démarre la partie.

    • Retour : GameStartResult - Le résultat du démarrage de la partie, y compris l’ordre des joueurs.

  3. endGame(sessionToken: SessionToken) : GameEndResult

    • Description : Termine la partie en cours et détermine le résultat final.

    • Paramètres : sessionToken - Le jeton de session du joueur qui termine la partie.

    • Retour : GameEndResult - Le résultat de la partie terminée, y compris le gagnant et les scores finaux.

9.2.4. DatabaseInterface

  1. queryDatabase(query: String) : QueryResult

    • Description : Exécute une requête sur la base de données et retourne les résultats.

    • Paramètres : query - La requête SQL à exécuter.

    • Retour : QueryResult - Les résultats de la requête.

  2. updateDatabase(updateDetails: UpdateDetails) : Boolean

    • Description : Met à jour les informations dans la base de données conformément aux détails fournis.

    • Paramètres : updateDetails - Les détails de la mise à jour à effectuer dans la base de données.

    • Retour : Boolean - Indique si la mise à jour a été réussie.

10. Game Server Component (Composant Serveur de Jeu)

diagram

10.1. Responsabilités du Game Server Component

  1. Gestion des Sessions de Joueurs :

    • Authentifie les joueurs et maintient les sessions de jeu.

  2. Authentification :

    • Gère le processus de login/logout des joueurs.

  3. Gestion des Comptes :

    • Permet la création et la modification de comptes, y compris la réinitialisation des mots de passe.

  4. Préparation et Lancement du Jeu :

    • Prépare et lance une nouvelle session de jeu pour les joueurs connectés.

  5. Interaction avec la Base de Données :

    • Gère les échanges avec la base de données pour toutes les opérations de données.

  6. Tableau de Bord des Résultats :

    • Fournit les résultats et statistiques des parties précédentes aux joueurs.

10.2. Interfaces fournies

10.2.1. AuthenticationInterface

diagram

  1. login(username: String, password: String) : LoginResult

    • Description : Authentifie un joueur et crée une session de jeu.

    • Paramètres : username - Le nom d’utilisateur, password - Le mot de passe du joueur.

    • Retour : LoginResult - Le résultat de la tentative de connexion, y compris un jeton de session si réussie.

  2. logout(sessionToken: SessionToken) : Boolean

    • Description : Déconnecte un joueur et termine sa session de jeu.

    • Paramètres : sessionToken - Le jeton de session du joueur.

    • Retour : Boolean - Indique si le joueur a été déconnecté avec succès.

10.2.2. AccountManagementInterface

diagram

  1. createAccount(accountDetails: AccountDetails) : AccountResult

    • Description : Crée un nouveau compte pour un joueur.

    • Paramètres : accountDetails - Les détails du compte à créer.

    • Retour : AccountResult - Les détails du résultat de la création du compte.

  2. changePassword(accountId: String, newPassword: String) : Boolean

    • Description : Change le mot de passe d’un compte existant.

    • Paramètres : accountId - L’identifiant du compte, newPassword - Le nouveau mot de passe.

    • Retour : Boolean - Indique si le mot de passe a été changé avec succès.

10.2.3. GameSessionInterface

diagram

  1. initializeGame(gameDetails: GameDetails) : GameInitializationResult

    • Description : Prépare une nouvelle partie de jeu.

    • Paramètres : gameDetails - Les détails de la partie à initialiser.

    • Retour : GameInitializationResult - Le résultat de l’initialisation de la partie.

  2. startGame(gameId: String) : GameStartResult

    • Description : Lance la partie préparée pour les joueurs connectés.

    • Paramètres : gameId - L’identifiant de la partie.

    • Retour : GameStartResult - Le résultat du démarrage de la partie.

10.2.4. DatabaseInterface

diagram

  1. queryDatabase(query: String) : QueryResult

    • Description : Exécute une requête sur la base de données et récupère les résultats.

    • Paramètres : query - La requête à exécuter.

    • Retour : QueryResult - Le résultat de la requête.

  2. updateDatabase(updateDetails: UpdateDetails) : Boolean

    • Description : Met à jour les informations dans la base de données.

    • Paramètres : updateDetails - Les détails de la mise à jour à effectuer.

    • Retour : Boolean - Indique si la mise à jour a été effectuée avec succès.

10.3. Contraintes OCL pour GameServerComponent

context AuthenticationInterface::login(username: String, password: String): LoginResult

pre: -- Les informations de connexion doivent être valides et le joueur ne doit pas déjà être connecté.
      not GameServer.allInstances().sessions->exists(s | s.username = username)

post: -- Si la méthode retourne un succès, alors une nouvelle session est créée.
      result.success implies (GameServer.allInstances().sessions->exists(s | s.username = username))

context AccountManagementInterface::createAccount(accountDetails: AccountDetails): AccountResult

pre: -- Les détails du compte doivent être complets et le nom d'utilisateur ne doit pas déjà être pris.
      accountDetails.username->notEmpty() and
      not GameServer.allInstances().accounts->exists(a | a.username = accountDetails.username)

post: -- Si la méthode retourne un succès, alors un nouveau compte est créé.
      result.success implies (GameServer.allInstances().accounts->exists(a | a.username = accountDetails.username))

Cas d’Utilisation : Joindre une partie (FR-1)

1. Identification

  • Acteur Principal : Le joueur

  • Système : Serveur de jeu

2. Scénario d’Interaction

  1. Le joueur ouvre son navigateur et accède à la plateforme en ligne.

  2. Le joueur saisit ses identifiants et soumet ces informations.

  3. Le serveur valide les identifiants et propose une liste de parties disponibles.

  4. Le joueur sélectionne une partie à rejoindre et envoie sa sélection au serveur.

  5. Le serveur confirme la participation du joueur à la partie sélectionnée.

3. Diagramme de Séquence UML pour "Joindre une partie"

png

Cas d’Utilisation : Jouer un Tour (FR-2)

1. Identification

  • Acteur Principal : Un joueur

  • Système : Système de jeu Trivial Pursuit

2. Scénario d’Interaction

  1. Le système informe le joueur que c’est son tour.

  2. Le joueur demande le lancer de dé.

  3. Le système affiche le résultat du dé.

  4. Le système propose des destinations possibles basées sur le résultat du dé.

  5. Le joueur sélectionne une destination.

  6. Le système déplace le pion du joueur à la destination sélectionnée.

  7. Le système tire une carte de question et la présente au joueur.

  8. Le joueur répond à la question.

  9. Le système valide la réponse et indique la suite du tour (nouveau tour, fin du tour, victoire).

3. Diagramme de Séquence UML

png

Cas d’Utilisation : Créer un Compte (FR-3)

1. Identification

  • Acteur Principal : Le joueur

  • Système : Serveur d’identification

2. Scénario d’Interaction

  1. Le joueur accède au système et choisit de créer un compte.

  2. Le joueur remplit le formulaire d’inscription avec son adresse email, nom, prénom, date de naissance, et mot de passe.

  3. Le système envoie une URL unique à l’adresse email du joueur pour la validation.

  4. Le joueur reçoit l’email, ouvre l’URL pour confirmer l’inscription.

  5. Le serveur valide l’inscription et crée le compte du joueur.

3. Diagramme de Séquence UML

png

Cas d’Utilisation : Réinitialiser Mot de Passe (FR-4)

1. Identification

  • Acteur Principal : Le joueur

  • Système : Serveur d’identification

2. Scénario d’Interaction

  1. Le joueur accède au système et indique qu’il a oublié son mot de passe.

  2. Le joueur saisit son identifiant (ou adresse email).

  3. Le système vérifie l’identifiant et envoie une URL unique pour la réinitialisation du mot de passe.

  4. Le joueur reçoit l’email et clique sur l’URL.

  5. Le joueur saisit son nouveau mot de passe via la page de réinitialisation.

  6. Le système valide le nouveau mot de passe et met à jour les informations du compte.

3. Diagramme de Séquence UML

png

Interactions composants du Système de Jeu

1. Game Board Component (Composant Plateau de Jeu)

1.1. Responsabilités

  • Initialisation du plateau de jeu.

  • Gestion des connexions au plateau.

  • Gestion des tours et distribution des mises à jour de jeu.

  • Détermination du gagnant.

1.2. Interfaces Fournies

  • BoardLayoutInterface

  • SpecialEventInterface

1.3. Diagramme d’Interaction UML

png

2. Question Categories Component (Composant Catégories de Questions)

2.1. Responsabilités

  • Gestion des catégories de questions.

  • Distribution des questions selon la catégorie.

  • Mise à jour des catégories.

2.2. Interfaces Fournies

  • CategoryInterface

2.3. Diagramme d’Interaction UML

png

3. Question Cards Component (Composant Cartes de Questions)

3.1. Responsabilités

  • Stockage des questions et réponses.

  • Distribution et validation des réponses des questions.

3.2. Interfaces Fournies

  • CardsInterface

3.3. Diagramme d’Interaction UML

png

4. Players Component (Composant Joueurs)

4.1. Responsabilités

  • Gestion des profils des joueurs.

  • Suivi des scores.

  • Gestion des statuts des joueurs.

4.2. Interfaces Fournies

  • PlayerInterface

4.3. Diagramme d’Interaction UML

png

5. Game Management Component (Composant Gestion de Partie)

5.1. Responsabilités

  • Initialisation du jeu.

  • Gestion de l’ordre des tours.

  • Évaluation des conditions de victoire.

5.2. Interfaces Fournies

  • GameManagementInterface

5.3. Diagramme d’Interaction UML

png

6. Dice and Movement Component (Composant Dés et Mouvement)

6.1. Responsabilités

  • Simulation du lancer de dés.

  • Calcul du nombre de mouvements.

6.2. Interfaces Fournies

  • DiceInterface

6.3. Diagramme d’Interaction UML

png

7. Game Server Component (Composant Serveur de Jeu)

7.1. Responsabilités

  • Authentification des joueurs et gestion des sessions.

  • Gestion des comptes.

  • Orchestration du jeu.

  • Interaction avec la base de données.

7.2. Interfaces Fournies

  • AuthenticationInterface

  • AccountManagementInterface

  • GameSessionInterface

  • DatabaseInterface

7.3. Diagramme d’Interaction UML

png

Conclusion

Ce document a présenté une vue complète de l’architecture du système de jeu interactif, mettant en lumière le rôle et l’importance de chaque composant dans l’écosystème du jeu.

L’architecture modulaire a été soulignée, révélant comment elle contribue à une expérience utilisateur engageante et efficace tout en facilitant la maintenance et l’évolutivité du système. De l’initialisation du jeu par le Game Board Component à la gestion fine des détails par le Game Server Component, chaque partie joue un rôle crucial pour assurer le bon fonctionnement et la réactivité du système. L’intégration des composants et le flux de données entre eux garantissent une interaction fluide et cohérente, essentielle pour une expérience de jeu immersive.

En conclusion, cette spécification détaillée fournit une base solide pour le développement et l’amélioration continue du système de jeu, avec une attention particulière portée à l’expérience utilisateur, à la performance et à la flexibilité du design.