Doc base

.gitignore

@@ -1,3 +1,6 @@
 Debug/*
 debug
 Debug/
+
+site/*
+out/*

docs/archi.md

@@ -0,0 +1,36 @@
+# Architecture du programme
+
+Le programe comporte plusieurs composants. Il y a :
+
+- des [threads](thread.md)
+
+    - des queues, pour comuniquer entre les threads,
+
+    - des varriables partagées (type black board),
+
+    - un mutex, pour gérer l'acces à l'écran
+
+- des [classes](class.md)
+
+- des pérriférique:
+
+    - L'[écran](lcd.md)
+
+    - Le [générateur de nombre aléatoire](rng.md)
+
+    - Les [leds](led.md)
+
+    - Le [joystick](joystick.md)
+
+## Diagramme des composants :
+
+Les composants intéragicent de la manière suivante :
+![Schéma des composants](Architecture_projet.svg)
+
+## Principales variables :
+
+Les principales variables sont :
+
+- ```joueur``` qui représente l'entier joueur et contient toutes les informations nécéssaires,
+- ```Table_ennemis``` qui contient tous les monstres ainsi que leurs informations.
+

docs/class.md

@@ -0,0 +1,23 @@
+# Classe
+
+Les classes utilisées sont les suivantes :
+
+![Diagramme de classes](class.svg)
+
+## Classe de representation
+
+Pour representer les élements dans le jeu, on utilise les classes :
+
+- ```Joueur``` qui n'est instancier qu'une seule fois, et qui represente le joueur,
+
+- ```Monster``` qui represente les monstres,
+
+- ```Missile``` qui represente les projectiles.
+
+Des instances de la classe ```Missile``` sont memebres des deux autres classes car elles representent les projeciles de basse.
+
+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.
+
+## 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).

docs/extra.css

@@ -0,0 +1,5 @@
+:root {
+    --md-primary-fg-color:        #00778B;
+    --md-primary-fg-color--light: #ECB7B7;
+    --md-primary-fg-color--dark:  #90030C;
+  }

docs/index.md

@@ -0,0 +1,15 @@
+# Space Invader
+
+Projet du second semetre de :
+
+* [Léopold Clément](mail:leopold.clement@ens-paris-saclay.fr)
+
+* [Thomas Omarini](mail:thomas.omarini@ens-paris-saclay.fr)
+
+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).
+
+!!! info "Record de fin"
+    Si vous arrivé jusqu'à la vague 15, prévenez nous.
+

docs/joystick.md

@@ -0,0 +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.

docs/led.md

@@ -0,0 +1,10 @@
+# LED et GPIO
+
+## 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}}```.
+
+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.
+
+## Lecture sur les boutons
+On lis aussi l'état des bouton ```BP1``` et ```BP2``` via les GPIO.

docs/thread.md

@@ -0,0 +1,46 @@
+# Les threads
+
+## 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 est le plus important, car sans ses acions, 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é
+
+### ```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 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 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 a une priorité basse.
+
+### ```chargeur```
+Ce thread sert a incrémenter régulierement le compteur representant 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```.
+
+### ```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).
+
+### ```Queue_E```
+On envoie un objet ```struct collision``` qui comporte le numéro du monstre et les dégats à lui appliqué.

docs/tuto.md

@@ -0,0 +1,19 @@
+# Tutoriel 
+
+## Controls
+
+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).
+
+L'attaque secondaire à besoin de se recharger pendant quelque seconde, le tau 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).
+
+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.
+## Fin
+Le jeu prend fin lorsque vous n'avez plus de vie. 
+
+

mkdocs.yml

@@ -0,0 +1,29 @@
+site_name: Space Invader's
+site_url: https://example.com/
+theme: material
+
+nav :
+  - 'Home' : 'index.md'
+  - 'Tutoriel' : 'tuto.md'
+  - 'Architecture du code' : 'archi.md'
+  - 'Thread' : 'thread.md'
+  - 'Classe' : 'class.md'
+  - 'Perriphériques' :
+    - 'Ecran' : 'lcd.md'
+    - 'Aléatoire' : 'rng.md'
+    - 'Leds' : 'led.md'
+    - 'Joystick' : 'joystick.md'
+
+markdown_extensions:
+  - admonition
+  - pymdownx.arithmatex:
+      generic: true
+  - pymdownx.superfences
+
+extra_javascript:
+  - javascripts/config.js
+  - https://polyfill.io/v3/polyfill.min.js?features=es6
+  - https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js
+
+extra_css:
+  - extra.css