Correction de la doc

docs/archi.md

@@ -6,13 +6,13 @@ Le programe comporte plusieurs composants. Il y a :
 
     - des queues, pour comuniquer entre les threads,
 
-    - des varriables partagées (type black board),
+    - des variables partagées (type black board),
 
-    - un mutex, pour gérer l'acces à l'écran
+    - un mutex, pour gérer l'accès à l'écran
 
 - des [classes](class.md)
 
-- des pérriférique:
+- des périphériques :
 
     - L'[écran](lcd.md)
 
@@ -24,7 +24,7 @@ Le programe comporte plusieurs composants. Il y a :
 
 ## Diagramme des composants :
 
-Les composants intéragicent de la manière suivante :
+Les composants interagissent de la manière suivante :
 ![Schéma des composants](Architecture_projet.svg)
 
 ## Principales variables :

docs/bitmap.md

@@ -1,18 +1,18 @@
 # Génération d'```image.h```
 
-Pour utilisé les bitmaps dans le code, il fait convertir les ```.bmp``` en un ```.h```. Pour cela, on utilise un script python dévelopé pour l'ocasion : ```BmpToHConvertor.py```. Il permet de composé un header comportant autant de bitmap que voulue.
+Pour utiliser les bitmaps dans le code, il faut convertir les ```.bmp``` en un ```.h```. Pour celà, on utilise un script python dévelopé pour l'occasion : ```BmpToHConvertor.py```. Il permet de composer un header comportant autant de bitmaps que voulus.
 
 ## Utilisation
 
-L'usage du script est simple, ainsi pour crée notre ```image.h```, nous avons utilisé la commande suivante :
+L'usage du script est simple, ainsi pour créer notre ```image.h```, nous avons utilisé la commande suivante :
 ``` bash
 python3 BmpToHConvertor.py --HEADER_NAME Core/Inc/images --INPUT_FILE asset_brut/Coeur_E.bmp asset_brut/Coeur_F.bmp asset_brut/Joueur.bmp asset_brut/Ennemi_1.bmp asset_brut/Ennemi_2.bmp asset_brut/Ennemi_3.bmp asset_brut/Ennemi_4.bmp --VAR_NAMES tex_coeur_E tex_coeur_F tex_joueur tex_ennemi_1 tex_ennemi_2 tex_ennemi_3 tex_ennemi_4
 ```
-Bien qu'elle soit longue, elle ne fait que lister les fichier d'entrés et le nom des varriables de sortie.
+Bien qu'elle soit longue, elle ne fait que lister les fichiers d'entrée et le nom des variables de sortie.
 
 ## Contrainte sur les images
 
-Pour que les images soit compatibles, il faut que elles soit enregistre avec un codage ```R5G6B5``` sur 16 bits. De plus, il ne faut pas utiliser de pallette de couleur.
+Pour que les images soit compatibles, il faut que elles soient enregistrées avec un codage ```R5G6B5``` sur 16 bits. De plus, il ne faut pas utiliser de pallette de couleur.
 
 !!! info
-    Il faut absolument que l'image ais une largeure multiple de 4, sinon un bug d'affichage déformant l'image se produit.
+    Il faut absolument que l'image ait une largeur multiple de 4, sinon un bug d'affichage déformant l'image se produit.

docs/class.md

@@ -1,23 +1,23 @@
-# Classe
+# Classes
 
 Les classes utilisées sont les suivantes :
 
 ![Diagramme de classes](class.svg)
 
-## Classe de representation
+## Classe de représentation
 
-Pour representer les élements dans le jeu, on utilise les classes :
+Pour représenter les éléments dans le jeu, on utilise les classes :
 
-- ```Joueur``` qui n'est instancier qu'une seule fois, et qui represente le joueur,
+- ```Joueur``` qui n'est instanciée qu'une seule fois, et qui représente le joueur,
 
-- ```Monster``` qui represente les monstres,
+- ```Monster``` qui représente les monstres,
 
-- ```Missile``` qui represente les projectiles.
+- ```Missile``` qui représente les projectiles.
 
-Des instances de la classe ```Missile``` sont memebres des deux autres classes car elles representent les projeciles de basse.
+Des instances de la classe ```Missile``` sont membres des deux autres classes car elles représentent les projectiles de base.
 
-De plus, les threads ```Joueur_1``` et ```Block_Enemie``` envoie des objet ```Missile``` dans la ```queue_N``` vers le thread ```Projectile``` pour lui signaler les nouveaux missiles à simuler.
+De plus, les threads ```Joueur_1``` et ```Block_Enemie``` envoient des objets ```Missile``` dans la ```queue_N``` vers le thread ```Projectile``` pour lui signaler les nouveaux missiles à simuler.
 
 ## Classe de messagerie
 
-Les classes utiles pour les messages sont ```struct Collision``` qui peremt de transmetre toutes les informations relatives à un choc avec un monstre en même temps, et la class ```enum End_Type``` qui décrit le type de fin de vague que l'on rencontre (défaite des monstre ou du joueur).
+Les classes utiles pour les messages sont ```struct Collision``` qui permet de transmettre toutes les informations relatives à un choc avec un monstre en même temps, et la classe ```enum End_Type``` qui décrit le type de fin de vague que l'on rencontre (défaite des monstres ou du joueur).

docs/index.md

@@ -1,6 +1,6 @@
 # Space Invader
 
-Projet du second semetre de :
+Projet du second semestre de :
 
 * [Léopold Clément](mailto:leopold.clement@ens-paris-saclay.fr)
 
@@ -8,9 +8,9 @@ Projet du second semetre de :
 
 Si vous avez des difficultés avec le jeu, un tutoriel est disponible [ici](tuto.md).
 
-Sinon, tous les détails techniques sont expliquer [ici](archi.md).
+Sinon, tous les détails techniques sont expliqués [ici](archi.md).
 
 !!! info "Record de fin"
-    Si vous arrivé jusqu'à la vague 15, prévenez nous.
+    Si vous arrivez jusqu'à la vague 15, prévenez nous.
 
-Nous remercions [Maïna Garnero](mailto:maina.garnero@ens-paris-saclay.fr), biologiste de son état, pour sa participation à la réalisation de tout les élements graphique du jeu.
+Nous remercions [Maïna Garnero](mailto:maina.garnero@ens-paris-saclay.fr), biologiste de son état, pour sa participation à la réalisation de tous les éléments graphiques du jeu.

docs/joystick.md

@@ -1,3 +1,3 @@
 # Joystick
 
-On réaliste un seuillage autour de la valeur centrale. Le joystick n'est pas vraiment annalogique, il n'y a que 8 directions possibles.
+On réalise un seuillage autour de la valeur centrale. Le joystick n'est pas vraiment annalogique, il n'y a que 8 directions possibles.

docs/lcd.md

@@ -1,13 +1,13 @@
 # L'écran
 
 ## Organisation de l'écran
-Les dix pixel en haut de l'écran sont reservés pour l'affichage des informations.
+Les dix pixels en haut de l'écran sont reservés pour l'affichage des informations.
 
 Les monstres sont rangés sur trois rangs
 
 ## Mutex
-Pour ne pas aoir de problème d'interruption entre les threads pendant la manipulation de la mémoire de l'écran, on utilise un mutex ainsi que une série de fonction permetant de faire automatiquement l'attente et le relachement du mutex.
+Pour ne pas avoir de problème d'interruption entre les threads pendant la manipulation de la mémoire de l'écran, on utilise un mutex ainsi qu'une série de fonctions permettant de faire automatiquement l'attente et le relachement du mutex.
 
 ## Bitmap
-Toutes les textures sont stoké dans ```image.h```. Les textures des coeurs et du joueur sont utilisé dirrectement, alors que pour les 4 texture des monstres, on utilise une liste de pointeur vers les textures. Ainsi, on peut changé rapidement la texture utilisé par les monstres pour avoir des sorte d'annimation.
-La generation des bitmap est abordé dans un [partie dédiée](bitmap.md).
+Toutes les textures sont stokées dans ```image.h```. Les textures des coeurs et du joueur sont utilisées directement, alors que pour les 4 textures des monstres, on utilise une liste de pointeurs vers les textures. Ainsi, on peut changer rapidement la texture utilisée par les monstres pour avoir des sortes d'animation.
+La génération des bitmaps est abordée dans une [partie dédiée](bitmap.md).

docs/led.md

@@ -2,9 +2,9 @@
 
 ## Ecriture sur les LEDs
 
-Pour facilité l'utilisation des LEDs, on utilise une liste d'objet ```struct led```, ainsi ```Leds[n] = {{LEDXX_GPIO_Port, LEDXX_Pin}}```.
+Pour faciliter l'utilisation des LEDs, on utilise une liste d'objets ```struct led```, ainsi ```Leds[n] = {{LEDXX_GPIO_Port, LEDXX_Pin}}```.
 
-On peut ainsi utilisé la ligne ```HAL_GPIO_WritePin(Leds[idx].port, Leds[idx].pin, !(charge-1<idx));``` ce qui simplifit l'itération sur toutes les leds.
+On peut ainsi utiliser la ligne ```HAL_GPIO_WritePin(Leds[idx].port, Leds[idx].pin, !(charge-1<idx));``` ce qui simplifie l'itération sur toutes les leds.
 
 ## Lecture sur les boutons
-On lis aussi l'état des bouton ```BP1``` et ```BP2``` via les GPIO.
+On lit aussi l'état des boutons ```BP1``` et ```BP2``` via les GPIO.

docs/rng.md

@@ -12,6 +12,6 @@ On utilise le code suivant, car il n'y a pas toujours de nouveau nombre aléatoi
 
 On définit deux fonctions pour la suite :
 
-- ```uint8_t proba_bernoulli(uint32_t numerateur, uint32_t denominateur)``` qui revoit ```1``` avec une probabilité de $\frac{\text{numerateur}}{\text{denominateur}}$, ```0``` sinon,
+- ```uint8_t proba_bernoulli(uint32_t numerateur, uint32_t denominateur)``` qui revoie ```1``` avec une probabilité de $\frac{\text{numerateur}}{\text{denominateur}}$, ```0``` sinon,
 
-- ```uint8_t proba_tirrage(uint8_t nombre_valeur)``` qui renvoit une nombre entre $1$ et $\text{nombre_valeur}$ avec une probabilité uniforme, utile pour tirer un objet au hasard dans un liste.
+- ```uint8_t proba_tirrage(uint8_t nombre_valeur)``` qui renvoie un nombre entre $1$ et $\text{nombre_valeur}$ avec une probabilité uniforme, utile pour tirer un objet au hasard dans un liste.

docs/thread.md

@@ -3,44 +3,44 @@
 ## Description des threads :
 
 ### ```GameMaster```
-Ce thread permet de gérer la fin des niveaux, càd que faire lorsque il n'y a plus de mostres ou plus de vie pour le joueur. Le thread est bloqué tant qu'il ne ressoit pas de message par ```queue_F```.
+Ce thread permet de gérer la fin des niveaux, c'est-à-dire que faire lorsque il n'y a plus de mostres ou plus de vie pour le joueur. Le thread est bloqué tant qu'il ne reçoit pas de message par ```queue_F```.
 
-Ce thread est le plus important, car sans ses acions, le jeu ne peut pas avancer, il a donc la plus grande priorité
+Ce thread est le plus important, car sans ses actions, le jeu ne peut pas avancer, il a donc la plus grande priorité
 
 ### ```Joueur_1```
 Ce tread gère les déplacements et l'affichage du joueur ainsi que ses tirs.
 
-Ce thread est important à la fluidité du jeu, il à donc la deuxième plus grande priorité
+Ce thread est important à la fluidité du jeu, il a donc la deuxième plus grande priorité
 
 ### ```Block_Enemie```
-Ce thread gère le block d'ennemis, leurs vies, et leurs tirs. Pour chaque pas de temps, chaque monstre à une probabilité de tirer de $\frac{\text{numéro de la vague}}{15}$. Ainsi, à chaque vague le jeu deviens plus dur.
+Ce thread gère le block d'ennemis, leurs vies, et leurs tirs. Pour chaque pas de temps, chaque monstre a une probabilité de tirer de $\frac{\text{numéro de la vague}}{15}$. Ainsi, à chaque vague le jeu devient plus dur.
 
 Ce thread a une priorité normale.
 ### ```Projectile```
-Ce thread gère les missiles. Il recois les demandes les nouveaux missiles par la ```queue_N```, et si il n'y a pas trop de missiles déjà en jeu (moins de $200$), il le rajoute et commence à le simuler. C'est ce thread qui gère toutes les collisions. En cas de collisions détecter, il tue le missile incriminé et envoie un messega via la ```queue_J``` quand le choc est avec le joueur, et la ```queue_E``` lorsque le choc implique un monstre.
+Ce thread gère les missiles. Il reçoit les demandes de création de nouveaux missiles par la ```queue_N```, et si il n'y a pas trop de missiles déjà en jeu (moins de $200$), il le rajoute et commence à le simuler. C'est ce thread qui gère toutes les collisions. En cas de collision détectée, il tue le missile incriminé et envoie un messega via la ```queue_J``` quand le choc est avec le joueur, et la ```queue_E``` lorsque le choc implique un monstre.
 
 Ce thread a une priorité normale.
 
 ### ```HUD```
-Ce thread gère l'affichage de la bar d'info en haut de l'écran, il ne fait que lire des varriables partagé.
+Ce thread gère l'affichage de la bar d'informations en haut de l'écran, il ne fait que lire des variables partagées.
 
 Ce thread a une priorité basse.
 
 ### ```chargeur```
-Ce thread sert a incrémenter régulierement le compteur representant la charge du tir secondaire.
+Ce thread sert a incrémenter régulièrement le compteur représentant la charge du tir secondaire.
 
 Ce thread a une priorité basse.
 
 ## Communication entre les threads :
 
 ### ```Queue_F```
-On envoie un objet ```enum End_Type```, cela permet de débloqué le thread ```GameMaster```.
+On envoie un objet ```enum End_Type```, cela permet de débloquer le thread ```GameMaster```.
 
 ### ```Queue_N```
 On envoie un objet ```struct Missile```, cela permet de demander la création d'un nouveau missile.
 
 ### ```Queue_J```
-On envoie un ```int8_t``` qui represente les dégats a appliquer au joueur (on peut imaginer des dégats négatif pour des soins).
+On envoie un ```int8_t``` qui represente les dégats à appliquer au joueur (on peut imaginer des dégats négatifs pour des soins).
 
 ### ```Queue_E```
-On envoie un objet ```struct collision``` qui comporte le numéro du monstre et les dégats à lui appliqué.
+On envoie un objet ```struct collision``` qui comporte le numéro du monstre et les dégats à lui appliquer.

docs/tuto.md

@@ -1,18 +1,18 @@
 # Tutoriel 
 
-## Controls
+## Contrôles
 
-Le vaiseau se déplace avec le joystick. Pour utilisé le tir principale, il faut presser le bouton ```BP1``` (en bas). On dispose d'une seconde attaque, lancant une multitude de missile avec le bouton ```BP2```(en haut).
+Le vaisseau se déplace avec le joystick. Pour utiliser le tir principal, il faut presser le bouton ```BP1``` (en bas). On dispose d'une seconde attaque, lançant une multitude de missiles avec le bouton ```BP2```(en haut).
 
-L'attaque secondaire à besoin de se recharger pendant quelque seconde, le tau de charge est modélisé par les leds à droite de la carte.
+L'attaque secondaire a besoin de se recharger pendant quelques secondes, le taux de charge est modélisé par les leds à droite de la carte.
 
 ## Mécanique
-Le but est de détruire tous les vaisseaux ennemis. Une fois tous les vaisseaux détruit, une nouvelle vague apparait. Chaque vague est plus dur que la pressedante (les ennemis tir plus de projectils).
+Le but est de détruire toutes les créatures ennemies. Une fois tous les monstres détruits, une nouvelle vague apparaît. Chaque vague est plus dure que la précédante (les ennemis tirent plus de projectiles).
 
 Vous ne pouvez prendre que 5 dégats avant la fin de la partie.
 
 !!! hint
-    Le tir secondair est très puissant, il ne faut pas hésité à l'utiliser. De plus, il faut se consentrer sur l'évitement des projectils ennemis.
+    Le tir secondaire est très puissant, il ne faut pas hésiter à l'utiliser. De plus, il faut se consentrer sur l'évitement des projectiles ennemis.
 ## Fin
 Le jeu prend fin lorsque vous n'avez plus de vie. 
 

mkdocs.yml

@@ -9,8 +9,8 @@ nav :
   - 'Home' : 'index.md'
   - 'Tutoriel' : 'tuto.md'
   - 'Architecture du code' : 'archi.md'
-  - 'Thread' : 'thread.md'
-  - 'Classe' : 'class.md'
+  - 'Threads' : 'thread.md'
+  - 'Classes' : 'class.md'
   - 'Perriphériques' :
     - 'Aléatoire' : 'rng.md'
     - 'Leds' : 'led.md'