# Projet : FOC21

- Rédacteur: Pierre Lenertz
- URL GIT : https://git.unistra.fr/deleted_user_177013/t4-foc21

## Description des objectifs pédagogiques du jeu

### **Objectif pédagogique général**


Montrer comment les exercices de morphologie dérivationnelle peuvent permettre aux enfants dyslexiques de déduire la signification de mots inconnus et de développer leur vocabulaire.

### **Description des objectifs pédagogiques**

#### Comprendre les principes de la morphologie dérivationnelle

- De nombreux mots sont composés de plusieurs parties appelées morphèmes.
- Les morphèmes peuvent être catégorisés selon leur utilisation : Préfixes, radicaux et suffixes.
- Chaque morphèmes d'un mot apporte à sa signification. 

#### Comprendre les difficultés des dyslexiques

- Les enfants dyslexiques éprouvent des difficultés de lecture et se retrouvent souvent face à des mots inconnus.
- L’étude de la morphologie peut servir d’astuce pour comprendre des mots compliqués en subdivisant la tâche en tâches plus faciles.

<br>

## Description du jeu

- **Type de jeu**: Jeu éducatif
- **Incarnation du joueur**: Un enfant dyslexique

### **Déroulement d’une partie**

A chaque tour de partie sera présenté au joueur un mot généré par combinaison de morphèmes, qu’il existe ou non.<br>
Le joueur va alors pouvoir découper le mot selon les morphèmes reconnus.<br>
Le joueur peut se tromper et découper le mot comme il le souhaite.<br>
Le joueur peut alors valider son choix pour passer au tour suivant.<br>
En fin de partie, le joueur verra une récapitulation de ses tours ainsi qu’une correction. Pour chaque morphème d’un mot sera affichée une courte description de son sens.

### **Paramétrage d’une partie**

- nombre de mots : nombre de mots(tours) pour cette partie
- complexité des mots: nombre de morphèmes moyen dans les mots générés pour la partie

## Modèle conceptuel applicatif

Liste decrivant les classes et entités du jeu :
- *Model*
  - *Tables* 
    - *Radical: <u>id</u>, rad, terminaison, desc*
    - *Prefixe: <u>id</u>, pre, desc*
    - *Suffixe: <u>id</u>, suf, desc*
  - *Partie(int nbMots, float complexite):*
    - *correction:  List<[string]> liste des mots générés servant de correction*
    - *decoupage:  List<[string]> propositions de découpage donnés par l’utilisateur* 
    - *motCourant : int*
    - *genererMots(int nb, float complexite): List<[string]> génère les mots à partir de la base de données* 
    - *formaterPropositions() initialise une version collée des mots se trouvant dans la correction*
    - *getMot(int nb) : [string] récupère un mot prêt à être découpé par l’utilisateur*
    - *setMot(int nb, [string]) sauvegarde la proposition de découpage de l’utilisateur*
    - *compterPoints() : int compte le nombre de découpage correct*
    - *getCorrection(int nb): [string] récupère la correction pour un mot*
    - *getMotCourant() : [string] recupere le mot courant*
    - *validerMotCourant([string] mot) valide le mot courant et incremente le mot courant*
- *Controleur*
  - *PartieCtrl (Partie model):*
    - *model : Partie*
    - *getMotSuivant() : [string] mot à découper*
    - *validerMot[string] mot) valide le découpage d’un mot*
    - *getMot(int nb) : [string] récupère une proposition de mot donnée prealablement*
    - *getCorrection(int nb) : [string] récupère la correction d’un mot*
- *Vues:*
  - *DecoupageMot(PartieCtrl ctrl):*
    - *ctrl: PartieCtrl contrôleur de la partie*
    - *mot: [string] découpage du mot*
    - *afficheMot() affiche le mot à découper en créant un label par lettre des string, et entre les tring ajoute un espace cliquable pour lancer la fonction de recolage de mot*
    - *decouperMot(int index) découpe le mot à un indice donné du mot total*
    - *recolletMot(int index) recole la partie d’indice index à la partie suivante*
    - *valider() valide le mot au contrôleur et ferme cette vue*
  - *Resultats(PartieCtrl ctrl)*
    - *ctrl: PartieCtrl contrôleur de la partie*
    - *afficherCorrection() afficher le découpage correct comparé à celui donné pour chaque mot de la partie*
    - *fin() : Validation finale pour finir la partie*

## Description des fonctionnalités

### **Entrée**

#### **Gestion des tours**

- **Valider** : Valide le choix de découpage et passe au tour suivant

#### **Découpage des mots**

- **Couper** : En passant la souris sur le mot, le joueur pourra séparer le mot, en cliquant il pourra couper le mot à l'endroit sélectionné. L'action peut être répétée.
- **Annuler** : En cliquant sur un espace créé par découpage, celui-ci peut être annulé pour recoller le mot.

### **Sorties**

#### **Progression**

- **TotalMots** : nombre de mots total générés pour la partie.
- **NumMotActuel** : progression actuelle dans la partie

#### **Mots**

- **Mot** : Le mot à découper

#### **Fin de partie**

- **Decoupage** : Le mot découpé par l’utilisateur
- **Correction** : le découpage correct pour le mot, (vert si juste, rouge si faux)

### Moteur interne

Liste des interactions entre entrées et sorties

#### **Gestion des tours**

- Valider :
  - MotActuel++
  -Envoi du découpage au model

#### **Découpage**

Le découpage est en local dans l'interface et envoyé au modèle lors de la validation.

## Scénarios

### **Scénario tutoriel**

Décrire en détail un scénario qui s'appuie sur toutes les fonctionnalités mais sans difficulté pour le joueur
*Paramètres:*
- *nombre de mots : 3*
- *complexité des mots : 2*
- *mots générés : ["radisologue"],["pediplateau"],["cartonivore"]*

#### ***Déroulement gagnant :***

1. *Le joueur découpe le mot  [“radisologue”] en [“radis”, ”ologue”]
sur la base des morphèmes radis et ologue*
2. *Le joueur découpe le mot  [“pediplateau”] en [“pedi”, ”plateau”]
sur la base des morphèmes pedi et plateau*
3. *Le joueur découpe le mot  [“cartonivore”] en [“carton”, ”ivore”]
sur la base des morphèmes carton et ivore*

#### ***Déroulement perdant :***

1. *Le joueur découpe le mot  [“radisologue”] en [“rad”, ”iso”, ”logue”]
et se trompe.*
2. *Le joueur découpe le mot  [“pediplateau”] en [“pedipl”, ”ateau”]
et se trompe.*
3. *Le joueur découpe le mot  [“cartonivore”] en [“cart”, ”onivore”]
et se trompe.*

### **Scénarios complémentaires**

Décrire moins précisément des idées de scénarios.
*Exemple :*

1. *Scénario ne permettant pas au joueur d’être à 100% sûr du résultat, obligeant le joueur à contrôler le risque.*
- *équipe : [<Alice,1,0>,<Bob,1,0>,<Carole,1,0>]*
- *tableau des objectifs : [<objectif1,3,2>,<objectif2,3,2>]*
- *nombre de tours : 3*
2. *Scénario où les membres ont des compétences différentes pour apprendre à les gérer*

### **Fonctionnalités additionnelles**

Décrire ici les idées de fonctionnalités additionnelles. Cette partie ne doit servir qu’en dernier recours, pour transmettre ce qui n’a pas été inclus dans les fonctionnalités faute de temps.

*Exemple :*
- *Ajouter l’endurance pour les projet très longs*
- *Ajouter les compétences sociales et les conflits entre membres*
- *Ajouter la dépendance entre les objectifs et un taux de rentabilité pour chacun*