corrections

- Section Personelle
- Generateur de niveaux
- Organisation

.drone.yml

@@ -0,0 +1,49 @@
+---
+kind: pipeline
+type: docker
+name: Check_Requirement
+
+steps:
+  - name: base_check
+    image: gradle:jdk11-alpine
+    commands:
+      - ./gradlew clean
+      - ./gradlew build
+      - ./gradlew test
+
+  - name: syntax_check
+    image: gradle:jdk11-alpine
+    commands:
+      - ./gradlew check
+
+---
+kind: pipeline
+type: docker
+name: master_build
+
+steps:
+  - name: make_archive
+    image: alpine:latest
+    volumes: 
+      - name: archives
+        path: /build
+    commands:
+      - apk add --no-cache git
+      - tar cvzf /build/$(git log -n 1 --format="%h")_school_archive.gz.tar app/ gradle/ gradlew/ gradlew.bat README.md settings.gradle
+    when:
+      branch:
+        - master
+      event:
+        exclude:
+          - pull_request
+volumes:
+  - name: archives
+    host:
+      path: /srv/drone/school_project/archive/
+depends_on:
+  - Check_Requirement
+---
+kind: signature
+hmac: 6b154c74ec624ce2d5867386bb7a6ee51cae9153457a8ce15f53e54546ccbc0e
+
+...

.gitignore

@@ -53,3 +53,4 @@ build
 
 .idea/
 .settings/
+*.slevel

JournalDeBord/rapport/.gitignore

@@ -0,0 +1,2 @@
+rapport.aux
+rapport.toc

JournalDeBord/rapport/rapport.tex

@@ -0,0 +1,278 @@
+\documentclass[12pt,a4paper]{article}
+
+\usepackage{amsmath}
+\usepackage{listings}
+\usepackage{tikz}
+\usepackage{csquotes}
+
+\begin{document}
+
+\title{Rapport du projet informatique 2023 \\ "Road to Master"}
+\author{Debucquoy Anthony \and Matteo Di Leto}
+\date{May 2023}
+
+\maketitle
+\newpage
+
+\tableofcontents
+\newpage
+
+
+\section*{Introduction}
+
+Lors de ce deuxième quadrimèstre, le projet Informatique proposé par notre université fut partie intégrante de notre emploi du temps.
+Régulièrement nous nous sommes rassemblés pour nous organiser et trouver une direction dans laquelle nous voulions voir notre projet évoluer.
+Grâce aux objectifs fixés par nos enseignants, nous sommes - je le pense - maintenant plus apte à nous confronter à ce genre d'objectifs. Tant au niveau personel qu'en tant que groupe.
+Il va sans dire que comme pour tout projets, notre chemin a été semé d'embuches. En l'occurence, nous souhaitons faire part de l'abandon d'un de nos membre. Eddy Jiofak qui souhaite se réorienter.
+Nous lui souhaitons une bonne reconversion.
+
+\section*{Objectifs}
+
+Voici l'objectif fixé par nos enseignants. (document de consignes)
+
+\begin{displayquote}
+
+Le but final de ce projet est de réaliser une application graphique en Java permettant de
+jouer au jeu "Cats Organized Neatly". Ce jeu est un jeu de type "puzzle" où le joueur doit
+placer des pièces de formes différentes pour combler l'aire de jeu. L'application devra permettre
+de sauvegarder et charger une partie et de créer des niveaux automatiquement.
+
+\end{displayquote}
+
+\newpage
+
+\section{Organisation}
+
+Lors de nos rassemblement pour le projet, toutes les idées émises se sont retrouvés sur un blog afin de pouvoir y accéder de manière efficace.
+Ce blog nous sert également à garder une trace de l'évolution du projet.
+
+\subsection{Choix}
+
+\begin{itemize}
+	\item{le VCS git pour garder une trace de l'avancement du projet. Avec comme remote une instance privée de gitea nous permettant de vérifier les MR/PR plus efficacement.}
+	\item{Une instance de DroneCI permettant de vérifier que le projet soit toujours compilable et que les tests ne soient pas ratés sans que nous nous en rendions compte.}
+	\item{Javafx, comme recommandé par nos enseignants.}
+	\item{Les pièces et niveaux sont stockées sous forme de matrice de booléen}
+	\item{Un parser de fichiers efficace et donnant des fichier légers.}
+\end{itemize}
+
+\subsubsection*{Shapes}
+
+Les pièces ainsi que la carte sont représentés par une matrice de booléen \verb|boolean[][]|.
+Nous avons donc une classe \verb|shape|, parent de \verb|Map| et de \verb|Piece| dans lequel nous stockons notre matrice.
+Ensuite, \verb|Map| Contient une liste de \verb|Piece|. Ces pièces contiennent une position représentée par la classe \verb|Vec2|.
+Cette position est la position du carré supérieur gauche dans la \verb|Map|.
+Avec toutes ces informations nous avons le nécessaire pour le moteur du jeu.
+
+Il est facilement possible de manipuler la carte et les pièces. Il nous suffit alors de faire correspondre l'affichage avec
+ces différentes classes. Ce qui est entrepris par la classe \verb|GameUI|.
+
+Le tout est géré par la classe \verb|Controller| qui permet de choisir entre l'affichage d'un menu ou d'une partie en cours.
+
+% \subsection{Difficultés}
+
+\section{Points Forts}
+
+\subsection{Parser de fichiers}
+
+Pour la rétention des niveaux, plusieurs possibilités s'offraient à nous. Nous avons alors décidés d'accomplir une série d'objectifs propre à notre projet avec un parser de fichiers dédié.
+Nous voulions que ce parser accomplisse les objectifs suivants:
+\begin{itemize}
+	\item{Les données du niveau seront encapsulées dans un header/footer pour laisser la possibilité d'enregistrer plus d'informations (images/musiques) dans un seul fichier dans le futur.}
+	\item{La taille du fichier devra être aussi petite que possible, tout en gardant les informations nécessaire au bon fonctionnement du jeu.}
+	\item{Il sera possible d'enregistrer l'état d'une partie en cours.}
+\end{itemize}
+
+Ce parser est implémenté par la classe \verb|BinaryParser|.
+
+\subsubsection*{spécification}
+
+\begin{description}
+	\item[Header/Footer]{ Les données du niveau commencent par les 3 \emph{caractères} 'S', 'M', 'S' (ou \verb|0x534D53|) et se terminent par les 3 \emph{caractères} 'S', 'M', 'E' (ou \verb|0x534D45|)}
+	\item[Taille de carte]{ Le premier octet des données représente la largeur de la carte, le second sa hauteur.}
+	\item[Forme de la carte]{ Chaques cellules de la carte est représenté par un 1 ou un 0. le 1 représente un emplacement libre, un 0 une cellule vide.
+		La forme de la carte peut alors être répartie sur un nombre indéterminé d'octets.
+		Nous pouvons déterminer ce nombre grace à
+		$$\frac{\text{largeur} * \text{hauteur } (+1 \text{ si multiple de } 8)}{8}$$ 
+		en division entière.}
+	\item[Nombre de pièce]{ L' (les) octet(s) qui forme(nt) la carte représente le nombre de pièce}
+	\item[Pour chaques pièces]{
+			\
+			\begin{description}
+				\item[Taille de la pièce]{La taille est représentée sur un seul octet sous forme de nibble\footnote{https://en.wikipedia.org/wiki/Nibble}. La première partie du nibble est la largeur. La seconde partie du nibble est la hauteur }
+				\item[Forme de la pièce]{ Chaques cellules de la pièce est représentée par un 1 ou un 0. la manière de le représenter et exactement la même que pour la forme de la carte }
+			\end{description}
+			Dans le cas où le fichier sauvegarde l'état de la partie, à la fin, et pour chaques pièces dans le même ordre que l'apparition des pièces:
+			\begin{description}
+				\item[Position de la pièce]{2 octets par pièces, 1 octet pour sa position en x et 1 octet pour sa position en y.
+					Dans le cas où la pièce est flotante (n'est pas placée dans la carte.), les octets contenant les caractères F puis L (0x464C) remplacent les coordonées}
+			\end{description}
+		}
+\end{description}
+
+\subsubsection*{Exemple}
+
+Voici le 'hexdump' du niveau 11
+
+\begin{verbatim}
+53 4d 53 05 05 e7 ff ff  80 06 33 ff 80 22 f0 22  |SMS.......3.."."|
+b0 22 70 22 b0 11 80 53  4d 45                    |."p"...SME|
+\end{verbatim}
+
+représente une carte de la forme :
+
+\begin{tikzpicture}
+	\filldraw[blue] (0,0) -- (0,5) -- (3,5) -- (3,4) -- (5,4) -- (5,0) -- cycle;
+	\draw[step=1cm,gray] (0, 0) grid (5,5);
+\end{tikzpicture}
+
+avec les pièces :
+
+\begin{tikzpicture}
+	\fill[red] (1,1) rectangle (4,4);
+	\fill[red] (5,1) rectangle (7,3);
+	\fill[red] (8,1) -- (8,3) -- (9,3) -- (9,2) -- (10,2) -- (10,1) -- cycle;
+	\fill[red] (11,1) -- (11,2) -- (12,2) -- (12,3) -- (13,3) -- (13,1) -- cycle;
+	\fill[red] (1,-2) -- (1,0) -- (2,0) -- (2,-1) -- (3,-1) -- (3,-2) -- cycle;
+	\fill[red] (4, -2) rectangle (5, -1);
+	\draw[step=1cm,gray] (0.5, -2.5) grid (13.5, 4.5);
+\end{tikzpicture}
+
+En plus de ce parser, et dans le cas où ce premier parser ne serait pas capable de stocker certaine carte (par exemple si une pièce mesure plus de 15x15).
+Nous avons également implémenté un parser très simple en utilisant l'interface \verb|Serialize| de java. Ce parser est implémenté et fonctionnel,
+mais n'est pas utilisé dans le projet à l'heure actuelle.
+
+Ces deux parseurs implémentent l'interface \verb|FileParser|.
+
+Finalement, La classe \verb|FileParserFactory| permet une utilisation simple de ces parseurs. Celle-ci contient deux fonctions statiques.
+\begin{itemize}
+	\item{\verb|Map loadMapFromFile(File)|}
+		permet de retourner la Map d'un fichier chargé.
+	\item{\verb|void saveFileFromMap(File, Map)|}
+		permet de sauvegarder une map dans un fichier.
+\end{itemize}
+
+Dans le cas d'une sauvegarde ou d'un chargement, le parser est choisi en fonction de l'extension de fichier ('.level', '.slevel', .'serialized', '.sserialized').
+
+L'avantage de ce system est que nous pouvons facilement ajouter d'autres parser de fichier dans le futurs.
+
+\subsection{Générateur de niveaux}
+
+Le générateur de niveaux a été conçu de sorte à proposer 3 difficultés différentes
+
+\begin{itemize}
+	\item{Niveau Facile}
+	\item{Niveau Moyen}
+	\item{Niveau Difficile}
+\end{itemize}
+
+L'algorithme derrière est le même en voici le principe :
+
+\subsubsection*{Gestion du plateau}
+
+Le joueur choisi une difficultée. En fonction de la difficultée choisie la grandeur du plateau de jeu sera différente.
+Si la difficulté choisie est facile ou moyenne, alors un curseur parcour les extrémités du niveau.
+Ce curseur sélectionne aléatoirement les cellules qui seront gardés ou non.
+Grâce à ça, la forme du plateau n'est pas trop carrée.
+
+Nous nous sommes basé sur le même principe pour le niveau de difficulté difficile mais en plus d'une taille encore plus grande,
+le curseur parcours les extrémités avec une profondeur de 2 afin de faire varier la carte plus grande.
+Cela introduit le problème des cases isolés. c'est pourquoi une boucle vérifie chaques cellules et la supprime si celle si est isolée.
+
+\subsubsection*{Gestion des pièces}
+
+Peu importe la difficulté du niveau voici le fonctionnement :
+
+Une taille maximum des pièces a été fixée au préalable à 3x3.
+Par la suite, un curseur parcours des cases de la carte préalablement conçue de manière aléatoire.
+Pour chaques cases, l'algorithme teste pour chaques cases de la pièce, si l'espace est disponible.
+Si ca n'est pas le cas, alors la pièce est modifiée afin de faire correspondre la pièce et la carte.
+
+L'avantage de cette méthode est que les niveaux sont tous très différents.
+Les désavantages sont que, par malchance, il est possible d'avoir énormément de piece 1x1.
+Ainsi qu'il est plus difficile d'appliquer des textures et dessins - à l'image du jeu de base - sur les pièces.
+
+Malgrés tout, avec nos nombreux test, ce générateur de niveaux nous satisfait vraiment bien et la difficultée des niveaux coorespond bien aux attentes.
+
+\subsection{Interface graphique}
+L'interface graphique du jeu tient sur 5 classes différentes.
+
+\subsubsection*{Controller}
+Classe principale. Elle s'occupe de la gestion des autres classe, et de la cohérence entre elles.
+Toutes les autres classes (présentes dans le package \verb|Scenes|) sont des sous classe de Parents.
+Celà permet de les afficher grace à la méthode statique \verb|switchRoot|.
+C'est aussi le point d'entrée du programme.
+
+\subsubsection*{MenuAccueil}
+Classe s'occupant de générer la page d'accueil du jeu.
+C'est-à-dire la première page que vera l'utilisateur.
+Cette page permet d'accéder aux niveaux du jeu de base, mais également de générer les niveaux aléatoires.
+De plus un dernier boutons "Load Game" permet de revenir sur la dernière partie en cours du joueur.
+
+\subsubsection*{MenuLevel}
+Classe s'occupant d'afficher les niveaux proposés dans le jeu, et qui,
+en fonction du jour choisir, change les boutons et les niveaux disponibles.
+
+\subsubsection*{ScreenLevelFinish}
+Classe qui s'affiche à l'écran dès que le joueur a fini le niveau.
+Celle-ci propose également de réessayer le niveau ou de retourner au menu principal.
+
+\subsubsection*{GameUI}
+Classe s'occupant de l'affichage d'un niveau.
+S'occupe dans un premier temps d'afficher le plateau au milieu de l'écrant.
+Par la suite, les pièces sont dispérsées à la gauche de l'écrant et sont rendu disponible à l'utilisateurs.
+Ces pièces sont déplacables à l'aide de la souris.
+Si elles sont lachées sur un emplacement disponible du plateau, alors elle vont s'alligner avec ses cellules.
+Pour se faire, nous regardons si le centre d'une cellule (la plus en haut à gauche) est présente dans une cellule du plateau.
+Ensuite, on vérifie que toutes les cellules de la pièces ont bien la place dans le plateau pour se poser. si c'est le cas, alors la pièce est posée.
+
+\section{Points Faibles}
+
+Bien que l'interface graphique permet de naviguer de manière fluide dans le jeu, il y a clairement un manque d'animation et de dynamisme
+\emph{i.e}: transition de page à une autre, apparition des boutons ainsi qu'un manque de musique.
+Toujours concernant l'affichage l'adaptation à la taille de l'écran peut être revue.
+
+De plus suite à la perte de notre membre nous n'avons pas su gérer la partie du projet qui concerne le design/textures des pièces ainsi que l'histoire jeu préparée auparavant.
+
+\section{Apports Positifs et négatifs}
+
+\subsection{Anthony}
+
+Personellement, ce projet m'a permis de me plonger dans la conception d'un format de fichier personnalisé.
+C'est une chôse que je n'avais pas encore fait jusqu'à maintenant.
+Et malgré mes efforts pour prévoir un maximum de choses à l'avance afin d'éviter de devoir 
+modifier ma spécification pendant le dévelopement. Je me suis vite rendu compte que je n'avais pas pensé
+à tout et que je devrais changer des choses pour pouvoir arriver à mes fins.
+Je pense que ce parser de fichier est vraiment améliorable mais je suis relativement fier du résultat.
+
+J'ai pu présenter ce parser à Dr Quoitin qui a pu me conseiller sur différentes approches à ce problème.
+J'en prend bonne notes.
+
+\subsection{Matteo}
+
+Il est clair que je peux tirer plusieurs enseignement grâce à la réalisation de notre projet.
+Tout d'abord, j'ai pu en apprendre beaucoup plus concernant la P.O.O en java, mais aussi  j'en ai appris
+d'avantage sur l'utilisation de la bibliotheque JavaFx.
+
+De plus, durant la réalisation du projet, comme dit précédemment nous avons utilisé plusieurs outils et dont la plus grande découverte pour moi :
+Git. Qui révèle son intérêt pour les travaux de groupes, et qui selon moi se révélera tout aussi essentiel pour mes futurs projets
+scolaires ainsi que professionnels.
+
+\section{conclusion}
+
+En conclusion nous pouvons séparer notre travail en trois partie différentes
+
+\begin{enumerate}
+	\item Le parser de fichier (gestion sauvegarder/charger partie)
+	\item Logique du jeu (Map,Vec2,Shapes)
+	\item Liaison à l'UI (Javafx)
+\end{enumerate}
+
+Malgré notre travail concentré sur le bon fonctionnement du jeu avec un parser suivant nos objectifs, une utilisation de la P.O.O de manière très efficace,
+ainsi qu'une approche correcte de l'utilisation du framework Javafx, d'autre améliorations sont toujours possible !
+En effet l'idée de rajouter une histoire, des trophées, un easter egg, des pièces spéciales ou un encore un table de score basée sur le temps,
+reste possible afin de rendre notre jeu encore plus complet.
+
+En conclusion, notre jeu a encore plein de possibilité afin d'être encore plus complet et amusant!
+
+\end{document}

JournalDeBord/src/SUMMARY.md

@@ -3,4 +3,13 @@
 # Rapports 
 
 - [Première entrevue](./rapports/130223.md)
-- [Deuxième entrevue](./rapports/200223.md)
+- [Deuxième entrevue](./rapports/200223.md)
+- [Troisième entrevue](./rapports/230323.md)
+
+# Specification
+
+- [File Parser](./spec/FileParser.md)
+
+# Histoire
+
+- [Plot Story](./histoire/plot_story.md)

JournalDeBord/src/histoire/plot_story.md

@@ -0,0 +1,69 @@
+
+# Intro histoire 
+
+
+Après notre premier quadri à l unif assez compliqué entre calculus, inégalités et physique 
+et la perte de temps dans les transports en commun.
+Je décide de enfin me prendre un kot à Mons pour réussir ce quadri en beauté 
+
+# Day 1
+## intro à jouer 
+
+Faire les cartons de différentes cours 
+Calculus --> big carton( encombrant pas possible de tourner) 
+Algo 1 --> pc portable (fragile)
+Math elem carton avec une inégalité dessus qui change dès qu on tourne la pièce) 
+Objet perso à chacun 
+1. Mat --> poids de sport
+2. Eddy --> balle de basket,...
+3. Anthony --> tenue de scout 
+
+## Déménagement histoire  :
+
+Arrivé à l appartement :
+La pièce est assez petite mais avec assez d'imagination je serai tout mettre
+(j'aurais aimé déjà être en master pour faire une AI qui me aiderai à ranger tous 
+ça peut-etre que chatgpt pourrait m aider..)
+
+## Déménagement à jouer :
+
+Galère à tout rangé --> (interaction avec le jouer)
+--> en repensant c est peut-être pour ça que l ancien propriétaire et partie et que le prix était de si bas
+Notion de jour donc cours unifs -> pas le temps de ranger dans le WK on doit terminer en semaine
+
+# Day 2 
+
+## continuité histoire 
+
+Après un long mardi terminer par le cours d algo 2 il est 
+tant de ranger le dernier carton dans la buanderie après une 10 minute de marche 
+j arrive à mon kot mais qlq chose à changer, la couleur de la porte n est plus la même. 
+De plus il faut tirer et plus poussé pour l ouvrir.
+Après être rentré tous les cartons sont refait et l ordre des pièces à changer
+
+## à jouer
+
+----> refaire des niveaux différents pour ranger les cartons
+
+(intercation pendant le jeu)
+--> Hormis la fatigue qui me gagne et se sentiment étrange par rapport à ce kot 
+je defais encore une fois tous mes cartons 
+(je ne sais pas comment mais tout mes exo en calculus ont été corrigées les cartons sont tous remplie de rouge) Après avoir défait le dernier carton dans le bureau je remarque une Trap mystérieuse mais il est déjà 23h et demain j'ai une longue journée qui m'attend (8-10 et 15h45-17h45)
+
+# Day 3 histoire
+La nuit passe --> rien ne bouge
+(Level bonus) 
+(choix entre faire le petit dej ou allez directement en cours)
+
+## Si choix petit dej 
+
+Après un bon petit déj --> puzzle cassé les oeuf au bonne endroit dans la poêle 
+mettre le bacon au bonne endroit
+
+## si choix rien déjeuner
+ rien ne se passer (peut avoir de l'importance pour la suite ex : fin pendant la journée donc allez faire des courses idée de niveau de remplir le caddie)
+
+
+La journée se termine je croise les doigts pour que tout reste comme avant 
+Puis on ouvre la Trap est...  space cat avec qlq level 
+ou reveil devant l examen de calculus

JournalDeBord/src/rapports/230323.md

@@ -0,0 +1,34 @@
+# 23 mars 2023
+
+Nous nous sommes rassemblés ce jeudi afin de parler de plusieurs sujets tel que :
+
+1. L'avancement du travail d'Eddy.
+2. Clarifiction sur les tâches.
+3. Rassembler notre travail.
+
+## L'avancement du travail d'Eddy
+
+Eddy a commencé à travailler avec javaFX afin de modéliser les premiers mouvements/ déplacement sur les pièces dont nous aurons besoins pour la suite du projet. Il va rajouter son travail sur notre git.
+
+## Clarifiction sur les tâches du projet 
+
+En ceux qui concerne Eddy va continuer de :
+        - Travailler sur les mouvements des pièces
+        - Faire l'interface graphique pour le jeu.
+
+Anthony va :
+        - Continuer à travailler sur Map
+        - Travailler sur son Parser 
+
+Pour finir Matteo va :
+        - S'occuper de faire le menu du jeu
+        - Faire la musique du jeu
+
+## Rassembler notre travail
+
+Après la mise en commun du travaille d'Eddy avec celle d'Anthony deux points important ont été souligné. 
+
+En effet désormais Anthony se consacre sur toutes les propriétés des pièces à l'intérieur du plateau de jeu, tandis que Eddy lui fait en sorte de lier son travail pour les mouvements en dehors du plateau c'est-à-dire la sélection des pièces, la sélections de la texture en bref l'interface graphique.
+De plus concernant la position des pièces il a été décidé de se référer au coin en haut à gauche de la matrice une méthode qui pourra nous aider est la méthode Vec2 qui Anthony a rajouté
+
+En ce qui concerne la création du menu pour Matteo, il faudrait créer une classe select level pour que chaque level contiennent : le parser qui est relié à Shape et à Pièce mais aussi à l'interface graphique.

JournalDeBord/src/spec/FileParser.md

@@ -0,0 +1,50 @@
+<!-- --- -->
+<!-- title: File Parser -->
+<!-- author: Debucquoy Anthony (tonitch) -->
+<!-- date: 5 March 2023 -->
+<!-- --- -->
+# File Parser Specification
+
+For the Project, I wanted to challenge myself, I decided to do my own file parser with my own specification that would
+have the special objective of being really small.
+
+## The File format
+
+The file would use the .level file extension.
+
+The file can contain anything, the used data is enclosed between a header and a footer.
+This could be used to add: musics, images and other stuff in the level file itself 
+
+Only one Header and One Footer should be present in the file.
+The parser will only read the first one it finds so to avoid problem, it is best practise to put the
+level data at the top of the file.
+
+- The HEADER will be defined by the succesion of the characters 'S', 'M' then 'S' 
+- The FOOTER will be defined by the succesion of the characters 'S', 'M', then 'E'
+- The bytes in between are the level data
+  - byte 1: Width of the map
+  - byte 2: Height of the map
+  - bytes 3 -> Width * Height (+1 if Width * Height % 8 is not 0)
+  - byte after Map Data: Pieces amount
+  - for each pieces
+    - 1 byte: size of the piece
+      - 4 first bits : width
+      - 4 last bits: height
+    - next bytes -> Width * Height (+1 if Width * Height % 8 is not 0)
+
+### Saved file
+
+For saved file, the extension will be .slevel
+The only difference is that at the end of the map data (after the pieces and before the
+Footer. there will be the position of each pieces from their top-left corner in the map.
+following this pattern for each pieces
+
+  - 'F' and 'L' on 2 bytes for floating positions when the piece is not placed
+  - x and y on 2 bytes for position if the piece is placed
+
+## Known Limitation
+
+1) by putting the piece size on one byte. We limit the maximum piece size to 15 x 15 (1111 | 1111)
+I don't think we will ever need a piece larger than 5x5 so this is clearly a feature, not a bug! :-)
+We might use the same methods for the pieces positions but there could be a posibility to have
+larger map if I use 2 bytes for the positions.

README.md

@@ -1,3 +1,5 @@
 # School_Project
 
+[![Build Status](http://drone.herisson.ovh/api/badges/undefined_name/School_Project/status.svg)](http://drone.herisson.ovh/undefined_name/School_Project)
+
 School Project based on Cats Organized Neatly

app/build.gradle

@@ -19,7 +19,9 @@ repositories {
 
 dependencies {
     // Use JUnit Jupiter for testing.
-    testImplementation 'org.junit.jupiter:junit-jupiter:5.9.1'
+    testImplementation 'org.junit.jupiter:junit-jupiter:5.9.2'
+    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.9.2'
+    testImplementation 'org.junit.jupiter:junit-jupiter-params:5.9.2'
 
     // This dependency is used by the application.
     implementation 'com.google.guava:guava:31.1-jre'
@@ -27,7 +29,7 @@ dependencies {
 
 application {
     // Define the main class for the application.
-    mainClass = 'school_project.Controller'
+    mainClass = project.hasProperty("mainClass") ? project.getProperty("mainClass") : 'school_project.Controller'
 }
 
 javafx {
@@ -39,3 +41,7 @@ tasks.named('test') {
     // Use JUnit Platform for unit tests.
     useJUnitPlatform()
 }
+
+run{
+standardInput = System.in
+}

app/src/main/java/school_project/Controller.java

@@ -1,32 +1,69 @@
-/*
- * This Java source file was generated by the Gradle 'init' task.
- */
 package school_project;
 
 import javafx.application.Application;
-import javafx.scene.Group;
+import javafx.scene.Parent;
 import javafx.scene.Scene;
-import javafx.scene.control.Button;
+
+import javafx.scene.input.KeyCode;
+import javafx.scene.input.KeyCombination;
+import javafx.stage.Screen;
 import javafx.stage.Stage;
+import school_project.Menu.MenuAccueil;
+import school_project.Parsers.FileParserFactory;
+
+import java.io.File;
+import java.io.IOException;
+
 
 public class Controller extends Application {
+    private static Stage stage;
+    Parent root;
+    public static Vec2 screen_size;
 
     @Override
-    public void start(Stage primaryStage) throws Exception {
-        primaryStage.setTitle("test");
-        Button btn = new Button("test");
-        btn.setOnAction(event -> System.out.println("hey"));
+    public void start(Stage primaryStage) throws IOException {
+        new File("save.slevel");
+        stage = primaryStage;
+        screen_size = new Vec2(
+            (int) Screen.getPrimary().getBounds().getWidth(),
+            (int) Screen.getPrimary().getBounds().getHeight()
+        );
 
-        Group root = new Group();
-        root.getChildren().add(btn);
+        stage.setTitle("ROAD TO MASTER YOU");
 
-        Scene scene = new Scene(root, 300,300);
-        primaryStage.setScene(scene);
+        // Full Screen mode
 
-        primaryStage.show();
+        root = new MenuAccueil();
+
+        switchRoot(root);
+        stage.show();
     }
 
+
+    public static void switchRoot(Parent root){
+        Scene scene = new Scene(root);
+        if(root instanceof GameUI){
+            scene.setOnKeyPressed(event ->{
+                GameUI game = (GameUI) root;
+                if(event.getCode() == KeyCode.ESCAPE){
+                    try {
+                        FileParserFactory.saveFileFromMap(new File("save.slevel"), game.getLevel());
+                        switchRoot(new MenuAccueil());
+                    } catch (IOException e) {
+                        throw new RuntimeException(e);
+                    }
+                }
+            });
+        }
+        stage.setScene(scene);
+
+        stage.setFullScreen(true);
+        stage.setFullScreenExitHint("");
+        stage.setFullScreenExitKeyCombination(KeyCombination.NO_MATCH);
+    }
     public static void main(String[] args) {
-       launch();
+        launch();
     }
 }
+
+

app/src/main/java/school_project/GameUI.java

@@ -0,0 +1,96 @@
+package school_project;
+
+import javafx.scene.Group;
+import javafx.scene.input.MouseButton;
+
+import school_project.Menu.ScreenLevelFinish;
+import school_project.Utils.MatrixShape;
+
+import java.io.FileNotFoundException;
+
+public class GameUI extends Group{
+    public final static int SEGMENT_SIZE = 50;
+    public final static int SPACE_SIZE = 5;
+    private final Vec2 piece_pos_click = new Vec2();
+
+    private Map level;
+
+    public GameUI(Map level) throws FileNotFoundException {
+        super();
+        this.level = level;
+
+        MatrixShape grid = new MatrixShape(level);
+
+        //center the grid
+        grid.setLayoutX((Controller.screen_size.x - grid.boundary_size.x) >> 1);
+        grid.setLayoutY((Controller.screen_size.y - grid.boundary_size.y) >> 1);
+
+        getChildren().add(grid);
+
+        Vec2 piece_space = new Vec2(SPACE_SIZE, SPACE_SIZE);
+        int column = 0;
+        for (Piece p : level.getPieces()) {
+            MatrixShape _piece = new MatrixShape(p);
+
+            if(piece_space.y + _piece.boundary_size.y >= Controller.screen_size.y){
+                column++;
+                piece_space.y = SPACE_SIZE;
+                piece_space.x = (SEGMENT_SIZE*3 + SPACE_SIZE*4 )* column;
+            }
+
+            _piece.setLayoutX(piece_space.x);
+            _piece.setLayoutY(piece_space.y);
+
+            piece_space.y += _piece.boundary_size.y;
+
+            if(p.getPosition() != null){
+                _piece.setLayoutX(grid.getLayoutX() + p.getPosition().y * (SEGMENT_SIZE+SPACE_SIZE));
+                _piece.setLayoutY(grid.getLayoutY() + p.getPosition().x * (SEGMENT_SIZE+SPACE_SIZE));
+            }
+
+            // Pieces Events
+            _piece.setOnMouseClicked(event -> {
+                if(event.getButton() == MouseButton.SECONDARY){
+                    ((Piece) _piece.shape).RotateRight(1);
+                    _piece.update();
+                }
+            });
+            _piece.setOnMousePressed(event -> {
+                piece_pos_click.x = (int) event.getX();
+                piece_pos_click.y = (int) event.getY();
+            });
+            _piece.setOnMouseDragged(event -> {
+                _piece.toFront();
+                _piece.setLayoutX(event.getSceneX() - piece_pos_click.x);
+                _piece.setLayoutY(event.getSceneY() - piece_pos_click.y);
+            });
+            _piece.setOnMouseReleased(event -> {
+                if(event.getButton() != MouseButton.PRIMARY)
+                    return;
+                p.setPosition(null);
+                if(event.getSceneX() > grid.getLayoutX() && event.getSceneX() < grid.getLayoutX() + grid.boundary_size.x
+                    && event.getSceneY() > grid.getLayoutY() && event.getSceneY() < grid.getLayoutY() + grid.boundary_size.y )
+                {
+                    // Inverted because screen is x →; y ↓ and matrix is x ↓; y →
+                    Vec2 piece_position_in_grid = new Vec2(
+                            (int) (_piece.getLayoutY() + (SEGMENT_SIZE+SPACE_SIZE)/2 - grid.getLayoutY())/(SEGMENT_SIZE+SPACE_SIZE),
+                            (int) (_piece.getLayoutX() + (SEGMENT_SIZE+SPACE_SIZE)/2 - grid.getLayoutX())/(SEGMENT_SIZE+SPACE_SIZE)
+                    );
+                    level.placePiece(p, piece_position_in_grid);
+                    if(p.getPosition() != null){
+                        _piece.setLayoutX(grid.getLayoutX() + p.getPosition().y * (SEGMENT_SIZE+SPACE_SIZE));
+                        _piece.setLayoutY(grid.getLayoutY() + p.getPosition().x * (SEGMENT_SIZE+SPACE_SIZE));
+                    }
+                    if(level.gameDone()){
+                        Controller.switchRoot(new ScreenLevelFinish(level));
+                    }
+                }
+            });
+            getChildren().add(_piece);
+        }
+    }
+
+    public Map getLevel() {
+        return level;
+    }
+}

app/src/main/java/school_project/Map.java

@@ -1,9 +1,14 @@
 package school_project;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 
+/**
+ * Represent the map with its pieces.
+ * Every piece has a position element that represent its position on the map
+ */
 public class Map extends Shape{
-    private ArrayList<Piece> pieces;
+    private final ArrayList<Piece> pieces = new ArrayList<>();
 
     public Map(boolean[][] matrix) {
         super(matrix);
@@ -13,8 +18,119 @@ public class Map extends Shape{
         super();
     }
 
-    // TODO: 2/27/23 Tests for Map 
-    public void AddShape(Piece piece){
+    public void addPiece(Piece piece){
+        piece.setLinked_map(this);
         pieces.add(piece);
     }
+
+    public void addPiece(Piece[] pieces) {
+        for (Piece p : pieces)
+            this.addPiece(p);
+    }
+
+    /**
+     * try to place a piece on the map, return true if succeed and false if it failed
+     * @param piece the piece to place
+     * @param pos the position to place the piece in matrix position
+     * @return true if the piece can and is placed and false if it can't and won't not be palced
+     */
+    public boolean placePiece(Piece piece, Vec2 pos){
+
+        if(!pieces.contains(piece))
+            return false;
+
+        piece.setPosition(null);
+        // In the map limits
+        if (    pos.x + piece.height > height
+                || pos.y+piece.width > width
+                || pos.x < 0
+                || pos.y < 0)
+            return false;
+
+        ArrayList<Vec2> occupation = new ArrayList<>();
+        for(Piece p: pieces){
+            if(p.getPosition() == null || p == piece)
+                continue;
+            for (Vec2 o : p.getOccupation()) {
+                occupation.add(o);
+            }
+        }
+
+        for (int x = pos.x; x < pos.x + piece.height; x++) {
+            for (int y = pos.y; y < pos.y + piece.width; y++) {
+                if ((!getShape()[x][y] || occupation.contains(new Vec2(x, y))) && piece.getShape()[x - pos.x][y - pos.y]) {
+                    return false;
+                }
+            }
+        }
+
+        piece.setPosition(pos);
+        return true;
+    }
+
+    /**
+     * Check if every pieces has a space on the board to know if the game is finished
+     * @return true if the game is finished, false if not
+     */
+    public boolean gameDone(){
+        ArrayList<Vec2> posList = getPosList();
+        for(Piece p: pieces){
+            posList.removeAll(p.getOccupation());
+        }
+        return posList.isEmpty();
+    }
+
+    /**
+     * Return a matrix with all used space on the map to see if a piece can fit in a space
+     *
+     * @return matrix of boolean with false being the not used space
+     */
+    public boolean[][] getUsedSpace(){
+
+        // Copy of the map to avoid side effect
+        boolean[][] used = new boolean[height][width];
+        for (int i = 0; i < height; i++) {
+            used[i] = Arrays.copyOf(matrix[i], width);
+        }
+
+        for (Piece p : pieces) {
+            if(p.getPosition() == null)
+                continue;
+            for(int x = 0; x < p.height; x++){
+                for(int y = 0; y < p.width; y++){
+                    if (p.getShape()[x][y]){
+                        used[p.getPosition().x + x][p.getPosition().y + y] = false;
+                    }
+                }
+            }
+        }
+        return used;
+    }
+
+    public ArrayList<Piece> getPieces() {
+        return pieces;
+    }
+
+    /**
+     * return a new Clean Map without any pieces on it for saving purpose
+     * @return a New Map Object without any pieces or saved data
+     */
+    public Map getCleanedMap() {
+        try {
+            Map ret = (Map) this.clone();
+            ret.getPieces().clear();
+            return ret;
+        } catch (CloneNotSupportedException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * set the position of each pieces in the map to null
+     */
+    public void resetPiecesPositions(){
+        for (Piece p : pieces) {
+            p.setPosition(null);
+        }
+    }
 }

app/src/main/java/school_project/MapGenerator.java

@@ -0,0 +1,102 @@
+package school_project;
+
+import school_project.Utils.Array;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Random;
+
+public class MapGenerator {
+    private static final Random rand = new Random();
+    public enum Difficulty {
+        Easy,
+        Medium,
+        Difficult,
+    }
+    public static Map generate(Difficulty difficulty){
+        Vec2 map_size;
+        int depth = 1; // how much the map shape generator could grind
+
+        // define map size depending on the difficulty
+        switch (difficulty){
+            case Easy:
+                map_size = new Vec2(rand.nextInt(2) + 3, rand.nextInt(2) + 3);
+                break;
+            case Medium:
+                map_size = new Vec2(rand.nextInt(3)+5, rand.nextInt(3)+5);
+                break;
+            case Difficult:
+                map_size = new Vec2(rand.nextInt(2)+8, rand.nextInt(2)+8);
+                depth = 2;
+                break;
+            default:
+                map_size = new Vec2();
+                break;
+        }
+
+        // Cut edges
+        boolean[][] map_shape = new boolean[map_size.x][map_size.y];
+        for (boolean[] b : map_shape) {
+            Arrays.fill(b, true);
+        }
+        for (int i = 0; i < map_shape.length; i++) {
+            for (int j = 0; j < map_shape[0].length; j++) {
+                if(i > depth - 1 && i < map_shape.length - depth && j > depth - 1 && j < map_shape[0].length - depth){
+                        j = map_shape[0].length - depth;
+                }
+                map_shape[i][j] = rand.nextBoolean();
+            }
+        }
+        //delete lonely piece
+        for (int i =0;i<map_shape.length;i++){
+            for (int j = 0; j<map_shape[i].length;j++){
+                boolean test = false;
+                if(map_shape[i][j]){
+                    for(int k = Math.max(i - 1, 0); k<= Math.min(i+1,map_shape.length-1); k++){
+                        for (int l = Math.max(j - 1, 0); l<= Math.min(j+1,map_shape[i].length-1); l++){
+                            if (k==i && l == j)
+                                continue;
+                            if (map_shape[k][l])
+                                test = true;
+                        }
+                    }
+                    if (!test)
+                        map_shape[i][j] = false;
+                }
+            }
+        }
+        Map ret = new Map(map_shape);
+        boolean[][] piece_layout = Array.MatrixCopyOf(map_shape);
+        ArrayList<Vec2> EmptySlots = new ArrayList<>();
+
+        for (int i = 0; i < piece_layout.length; i++) {
+            for (int j = 0; j < piece_layout[i].length; j++) {
+                if(piece_layout[i][j]){
+                    EmptySlots.add(new Vec2(i, j));
+                }
+            }
+        }
+
+        while (EmptySlots.size() > 0){
+            Collections.shuffle(EmptySlots);
+            Vec2 selected = EmptySlots.get(0);
+            int size = 3;
+            boolean[][] shape = new boolean[size][size];
+            for(int i = 0; i < size; i++){
+                for (int j = 0; j < size; j++) {
+                    Vec2 checked = new Vec2(i, j).add(selected);
+                    if(EmptySlots.contains(checked)){
+                        EmptySlots.remove(checked);
+                        piece_layout[checked.x][checked.y] = false;
+                        shape[i][j] = true;
+                    }
+                }
+            }
+            ret.addPiece(new Piece(shape));
+        }
+
+        //generate pieces
+        return ret;
+    }
+}

app/src/main/java/school_project/MapParser.java

@@ -1,44 +0,0 @@
-package school_project;
-
-import java.io.*;
-import java.lang.reflect.Array;
-import java.util.Arrays;
-
-public class MapParser {
-    public static Map ParseMapFile(File file) throws IllegalArgumentException, IllegalAccessException, IOException {
-        System.out.println(file.getAbsolutePath());
-        FileInputStream fileStream = new FileInputStream(file);
-        if(!file.isFile()) throw new IllegalArgumentException("The argument should be a file");
-        if(!file.canRead()) throw new IllegalAccessException("This file can't be read");
-
-        byte[] bytes = fileStream.readAllBytes();
-        int start_position = 0, end_position = 0;
-        for (int i = 0; i < bytes.length; i++) {
-            if(bytes[i] == 83 && bytes[i+1] == 77 && bytes[i+2] == 83){ // SMS
-                start_position = i+3;
-                break;
-            }
-        }
-
-        for (int i = start_position; i < bytes.length; i++) {
-            if(bytes[i] == 83 && bytes[i+1] == 77 && bytes[i+2] == 69){ // SME
-                end_position = i;
-                break;
-            }
-        }
-
-        byte[] map_data = Arrays.copyOfRange(bytes, start_position, end_position); //TODO tonitch cursor
-
-
-        fileStream.close();
-        return new Map(); //TODO: Send the parsed map
-    }
-
-//    public static void SaveMapFile(File file){
-//    }
-
-    public static void main(String[] args) throws IOException, IllegalAccessException {
-        ParseMapFile(new File("test.smap"));
-    }
-
-}

app/src/main/java/school_project/Menu/MenuAccueil.java

@@ -0,0 +1,90 @@
+package school_project.Menu;
+import javafx.geometry.Insets;
+import javafx.geometry.Pos;
+import javafx.scene.control.Button;
+import javafx.scene.control.ChoiceBox;
+import javafx.scene.control.Label;
+import javafx.scene.layout.StackPane;
+import javafx.scene.paint.Color;
+import javafx.scene.text.Font;
+import school_project.Controller;
+import school_project.GameUI;
+import school_project.MapGenerator;
+import school_project.Parsers.FileParserFactory;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+public class MenuAccueil extends StackPane {
+    public MenuAccueil(){
+        super();
+        //create all the objet that I need
+        ChoiceBox<String> SlctDifficulty = new ChoiceBox<>();
+        SlctDifficulty.getItems().addAll("Easy", "Medium", "Difficult");
+
+        Label RdmLvl = new Label("Random Level : ");
+        Button LoadLvl = new Button("Load game");
+        Button SelectLevel= new Button("Select Level");
+
+        Label Title = new Label("Welcome to Road to Master");
+            SlctDifficulty.setOnAction(event -> {
+                String choosediff = SlctDifficulty.getSelectionModel().getSelectedItem();
+                System.out.println(choosediff);
+                switch (choosediff) {
+                    case "Easy":
+                        try {
+                            Controller.switchRoot(new GameUI(MapGenerator.generate(MapGenerator.Difficulty.Easy)));
+                        } catch (FileNotFoundException e) {
+                            throw new RuntimeException(e);
+                        }
+                        break;
+                    case "Medium":
+                            try {
+                                Controller.switchRoot(new GameUI(MapGenerator.generate(MapGenerator.Difficulty.Medium)));
+                            } catch (FileNotFoundException e) {
+                                throw new RuntimeException(e);
+                            }
+                        break;
+                    case "Difficult":
+                            try {
+                                Controller.switchRoot(new GameUI(MapGenerator.generate(MapGenerator.Difficulty.Difficult)));
+                            } catch (FileNotFoundException e) {
+                                throw new RuntimeException(e);
+                            }
+                        break;
+                }
+            });
+
+        //set up all the Button where I need
+
+        getChildren().addAll(Title,SlctDifficulty,SelectLevel,RdmLvl,LoadLvl);
+        RdmLvl.setFont(Font.font(25));
+        RdmLvl.setTextFill(Color.GOLD);
+        Title.setFont(Font.font(40));
+        Title.setTextFill(Color.RED);
+        setAlignment(Title, Pos.TOP_CENTER);
+        setAlignment(LoadLvl,Pos.BOTTOM_CENTER);
+        setAlignment(SlctDifficulty,Pos.CENTER_LEFT);
+        setAlignment(SelectLevel,Pos.CENTER_RIGHT);
+        setAlignment(RdmLvl, Pos.CENTER_LEFT);
+
+        setMargin(RdmLvl,new Insets(0,0,0,100));
+        setMargin(SlctDifficulty,new Insets(0,0,0,300));
+        setMargin(SelectLevel,new Insets(0,300,0,0));
+        setMargin(Title,new Insets(200,0,0,0));
+        setMargin(LoadLvl,new Insets(0,0,200,0));
+
+        SelectLevel.setOnAction(event ->  Controller.switchRoot(new MenuLevel(1)));
+        LoadLvl.setOnAction(event -> {
+            try {
+                Controller.switchRoot(new GameUI(FileParserFactory.loadMapFromFile(new File("save.slevel"))));
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        });
+
+        getStyleClass().add("BorderPane");
+        getStylesheets().add(String.valueOf(getClass().getResource("StyleMenuAcceuil.css")));
+    }
+}

app/src/main/java/school_project/Menu/MenuLevel.java

@@ -0,0 +1,123 @@
+package school_project.Menu;
+
+import javafx.geometry.HPos;
+import javafx.geometry.Insets;
+import javafx.scene.control.Button;
+import javafx.scene.layout.ColumnConstraints;
+import javafx.scene.layout.GridPane;
+import javafx.scene.layout.RowConstraints;
+import school_project.Controller;
+import school_project.GameUI;
+import school_project.Parsers.FileParserFactory;
+
+import java.io.File;
+import java.io.IOException;
+
+public class MenuLevel extends GridPane {
+    private int StartLevel;
+    public MenuLevel(int choose_day) {
+
+        //create all Object that I need
+        RowConstraints[] Rows = new RowConstraints[5];
+        ColumnConstraints[] Columns = new ColumnConstraints[3];
+        Button[] Days = new Button[3];
+        Button BckMenu = new Button("Back to menu");
+
+        BckMenu.setOnAction(event -> Controller.switchRoot(new MenuAccueil()));
+        setHalignment(BckMenu,HPos.CENTER);
+        add(BckMenu,2,4);
+
+
+        for (int i = 0; i < Days.length; i++){
+            Days[i] = new Button("Day"+(i+1));
+        }
+
+        //it's here that I know which day I can show on the screen
+
+        if (choose_day == 1) {
+            StartLevel = 1;
+            add(Days[1],0,0);
+            add(Days[2],2,0);
+            setHalignment(Days[1], HPos.CENTER);
+            setHalignment(Days[2], HPos.CENTER);
+        }
+
+        else if (choose_day == 2) {
+            StartLevel = 11;
+            add(Days[0], 0, 0);
+            add(Days[2], 2, 0);
+            setHalignment(Days[0], HPos.CENTER);
+            setHalignment(Days[2], HPos.CENTER);
+        }
+
+        else if (choose_day == 3) {
+            StartLevel = 21;
+            add(Days[0], 0, 0);
+            add(Days[1], 2, 0);
+            setHalignment(Days[0], HPos.CENTER);
+            setHalignment(Days[1], HPos.CENTER);
+        }
+
+        Days[0].setOnAction(event -> Controller.switchRoot(new MenuLevel(1)));
+        Days[1].setOnAction(event -> Controller.switchRoot(new MenuLevel(2)));
+        Days[2].setOnAction(event -> Controller.switchRoot(new MenuLevel(3)));
+
+        //It's here that I put all buttons where I need (base on column not row)
+        for (int i = 0; i < 3; i++) {
+            for (int j = 1; j < 5; j++) {
+				Button levelButton = new Button("level "+(StartLevel));
+                levelButton.setOnAction(event -> {
+                    try {
+                        String levelName = ((Button)event.getSource()).getText().replace(" ", "") + ".level";
+                        System.out.println(levelName);
+                        GameUI level = new GameUI(FileParserFactory.loadMapFromFile(new File(Controller.class.getResource("levels/" + levelName).getFile())));
+                        Controller.switchRoot(level);
+                    } catch (IOException e) {
+                        System.out.println("Le niveau " + StartLevel + "n'existe pas.");
+                    }
+                });
+                if(i==0){
+                    StartLevel+=3;
+                    add(levelButton,i,j);
+                    setHalignment(levelButton,HPos.CENTER);
+                    if(j==4){
+                        StartLevel-=11;
+                    }
+                }
+                else if(i==1&&j!=4) {
+                    StartLevel += 3;
+                    add(levelButton, i, j);
+                    setHalignment(levelButton,HPos.CENTER);
+                    if (j == 3) {
+                        StartLevel -=8;
+
+                    }
+                }
+                else if(i==2&&j!=4){
+                    StartLevel+=3;
+                    add(levelButton,i,j);
+                    setHalignment(levelButton,HPos.CENTER);
+                }
+            }
+        }
+
+        for(int i=0;i<=2;i++){
+            Columns[i] = new ColumnConstraints();
+            Columns[i].setPercentWidth(33);
+            getColumnConstraints().addAll(Columns[i]);
+        }
+
+        for (int i= 0;i<=4;i++){
+            Rows[i] = new RowConstraints();
+            Rows[i].setPercentHeight(20);
+            getRowConstraints().addAll(Rows[i]);
+        }
+
+        setHgap(20);
+        setVgap(20);
+        setPadding(new Insets(20,10,10,20));
+        getStyleClass().add("GridPane");
+        getStylesheets().add(String.valueOf(getClass().getResource("StyleMenuAcceuil.css")));
+    }
+}
+

app/src/main/java/school_project/Menu/ScreenLevelFinish.java

@@ -0,0 +1,52 @@
+package school_project.Menu;
+
+
+import javafx.geometry.Insets;
+import javafx.geometry.Pos;
+import javafx.scene.control.Button;
+import javafx.scene.control.Label;
+
+import javafx.scene.layout.StackPane;
+import javafx.scene.text.Font;
+import school_project.Controller;
+import school_project.GameUI;
+import school_project.Map;
+import java.io.FileNotFoundException;
+
+public class ScreenLevelFinish extends StackPane {
+
+    public ScreenLevelFinish(Map lastlevel){
+        super();
+        Button retry = new Button("Retry Level");
+        Label CongraMess  = new Label(" LEVEL DONE GREAT JOB ");
+        CongraMess.setFont(Font.font(40));
+        Button BckMenu = new Button("Back to Menu");
+        BckMenu.setFont(Font.font(25));
+        Button ChooseLvl = new Button("Choose level");
+        ChooseLvl.setFont(Font.font(25));
+
+        BckMenu.setOnAction(event -> Controller.switchRoot(new MenuAccueil()));
+        ChooseLvl.setOnAction(event -> Controller.switchRoot(new MenuLevel(1)));
+        retry.setOnAction(event -> {
+            try {
+                lastlevel.resetPiecesPositions();
+                Controller.switchRoot(new GameUI(lastlevel));
+            } catch (FileNotFoundException e) {
+                throw new RuntimeException(e);
+            }
+        });
+
+        getChildren().addAll(BckMenu,ChooseLvl,CongraMess,retry);
+        setAlignment(retry,Pos.BOTTOM_CENTER);
+        setAlignment(BckMenu, Pos.CENTER_RIGHT);
+        setAlignment(ChooseLvl, Pos.CENTER_LEFT);
+        setAlignment(CongraMess, Pos.TOP_CENTER);
+        setMargin(BckMenu, new Insets(0,300,0,0 ));
+        setMargin(ChooseLvl,new Insets(0,0,0,300));
+        setMargin(CongraMess,new Insets(300,0,0,0));
+        setMargin(retry,new Insets(0,0,300,0));
+
+        getStyleClass().add("StackPane");
+        getStylesheets().add(String.valueOf(getClass().getResource("StyleMenuAcceuil.css")));
+    }
+}

app/src/main/java/school_project/Parsers/BinaryParser.java

@@ -0,0 +1,221 @@
+package school_project.Parsers;
+
+import school_project.Map;
+import school_project.Piece;
+import school_project.Utils.Bitwise;
+import school_project.Vec2;
+
+import java.io.*;
+import java.util.Arrays;
+
+public class BinaryParser implements FileParser {
+
+    @Override
+    public Map getLevel(File file, boolean saved_data) throws IOException {
+        Map ret;
+
+        FileInputStream fileStream = new FileInputStream(file);
+
+        byte[] level_data = ExtractLevelData(fileStream);
+
+        ret = new Map(ExtractMapFromLevelData(level_data));
+
+        ret.addPiece(ExtractPiecesFromLevelData(level_data, saved_data));
+        
+        fileStream.close();
+        return ret;
+    }
+
+    @Override
+    public void saveLevel(File file, Map level_data, boolean save_data) throws IOException {
+        int byteSize = getByteSizeForMap(level_data, save_data);
+        byte[] data = new byte[byteSize];
+        int i = 0;
+        data[i++] = 'S'; data[i++] = 'M'; data[i++] = 'S';
+        data[i++] = (byte) level_data.getWidth(); data[i++] = (byte) level_data.getHeight();
+        for(byte b : BuildByteFromMatrix(level_data.getShape())){
+            data[i++] = b;
+        }
+        data[i++] = (byte) level_data.getPieces().size();
+        for (Piece p : level_data.getPieces()) {
+            data[i++] = Bitwise.NibbleToByte((byte) p.getWidth(), (byte) p.getHeight());
+            for(byte b : BuildByteFromMatrix(p.getShape())){
+                data[i++] = b;
+            }
+        }
+        if (save_data){
+            for (Piece p : level_data.getPieces()) {
+                Vec2 _piece_pos = p.getPosition();
+                if(_piece_pos == null){
+                    data[i++] = 'F';
+                    data[i++] = 'L';
+                }else{
+                    data[i++] = (byte) _piece_pos.x;
+                    data[i++] = (byte) _piece_pos.y;
+                }
+            }
+        }
+        data[i++] = 'S'; data[i++] = 'M'; data[i++] = 'E';
+        FileOutputStream save_file = new FileOutputStream(file);
+        save_file.write(data);
+        save_file.flush();
+        save_file.close();
+    }
+
+    /**
+     * Extract Level data from file content
+     * @param fileStream file stream to read extract data from
+     * @return Level data as an array of byte
+     * @throws IOException Expected if we can't read the file
+     */
+    static byte[] ExtractLevelData(InputStream fileStream) throws IOException {
+
+        byte[] bytes = fileStream.readAllBytes();
+
+        int start_position = 0, end_position = 0;
+        for (int i = 0; i < bytes.length; i++) {
+            if(bytes[i] == 83 && bytes[i+1] == 77 && bytes[i+2] == 83){ // SMS
+                start_position = i+3;
+                break;
+            }
+        }
+
+        for (int i = start_position; i < bytes.length - 2; i++) {
+            if(bytes[i] == 83 && bytes[i+1] == 77 && bytes[i+2] == 69){ // SME
+                end_position = i;
+                break;
+            }
+        }
+
+        return Arrays.copyOfRange(bytes, start_position, end_position);
+    }
+
+    /**
+     * Get Pieces out of the level data
+     *
+     * @param levelData  full data of the level without header and footer
+     * @param saved_data Should extract saved data and included it in the pieces
+     * @return array of Piece from level data
+     */
+    static Piece[] ExtractPiecesFromLevelData(byte[] levelData, boolean saved_data) {
+        byte map_width = levelData[0], map_height = levelData[1];
+        byte piece_count = levelData[2 + map_width * map_height / 8 + (map_height * map_width % 8 != 0 ? 1 : 0)];
+        Piece[] ret = new Piece[piece_count];
+        byte[] pieces_data = Arrays.copyOfRange(levelData, 3 + map_width * map_height / 8 + (map_height * map_width % 8 != 0 ? 1 : 0), levelData.length);
+        byte[] pieces_positions = saved_data ? Arrays.copyOfRange(levelData, levelData.length - piece_count*2,levelData.length ): null;
+        int piece_offset = 0;
+        for (int piece_index = 0; piece_index < piece_count; piece_index++) {
+            Vec2 _piece_size = Bitwise.ByteToNible(pieces_data[piece_index + piece_offset]);
+
+            byte[] _piece_data = Arrays.copyOfRange(pieces_data, piece_index + piece_offset + 1, piece_index + piece_offset + 1 + _piece_size.x * _piece_size.y / 8 + (_piece_size.x * _piece_size.y % 8 != 0 ? 1 : 0));
+
+            boolean[][] _piece_matrix = BuildMatrixFromBytes(_piece_size.x, _piece_size.y, _piece_data);
+
+            ret[piece_index] = new Piece(_piece_matrix);
+
+            if(saved_data){
+                Vec2 _piece_pos = (pieces_positions[piece_index*2] == 70 && pieces_positions[piece_index*2+1] == 76) ?
+                        null : new Vec2(pieces_positions[piece_index*2], pieces_positions[piece_index*2 + 1]);
+                ret[piece_index].setPosition(_piece_pos);
+            }
+
+            piece_offset += _piece_size.x * _piece_size.y / 8 + (_piece_size.x * _piece_size.y % 8 != 0 ? 1 : 0);
+        }
+        return ret;
+    }
+
+    /**
+     * Get the Map Matrix out of the level data
+     * @param level_data full data of the level without header and footer
+     * @return boolean matrix of the map
+     */
+    static boolean[][] ExtractMapFromLevelData(byte[] level_data){
+        int map_width = level_data[0], map_height = level_data[1];
+        byte[] map_data = Arrays.copyOfRange(level_data, 2, 2 + map_width * map_height / 8 + (map_height * map_width % 8 != 0 ? 1 : 0));
+        return BuildMatrixFromBytes(map_width, map_height, map_data);
+    }
+
+    /**
+     * take a boolean matrix and build an array of byte following the specs of the parser
+     * @param shape bolean matrix where true are 1 and false are 0
+     * @return byte array with each element compiled for file format
+     */
+    static byte[] BuildByteFromMatrix(boolean[][] shape){
+        int width = shape[0].length , height = shape.length;
+        boolean[] b_list = new boolean[width * height];
+        for (int x = 0; x < shape.length; x++) {
+            for (int y = 0; y < shape[x].length; y++) {
+                b_list[x * shape[x].length + y] = shape[x][y];
+            }
+        }
+        byte[] ret = new byte[width * height  / 8 + (width * height % 8 == 0 ? 0 : 1)];
+        for (int i = 0; i < ret.length; i++) {
+            byte current_byte = 0;
+            boolean[] current_byte_data = Arrays.copyOfRange(b_list, i * 8, i * 8 + 8);
+            for (boolean curr_data: current_byte_data) {
+                current_byte = (byte) (current_byte << 1);
+                current_byte = (byte) (current_byte | (curr_data ? 1 : 0));
+            }
+            ret[i] = current_byte;
+        }
+        return ret;
+    }
+
+    /**
+     * Build a boolean Matrix From a byte array
+     * Each Byte is composed of 8 bit, each bit is 1 or 0
+     *  if the bit is 0 then it's a false for this cell
+     *  else it's true for this cell
+     * @param matrix_width width of the matrix
+     * @param matrix_height height of the matrix
+     * @param matrix_data byte array of the data to export
+     * @return boolean Matrix of the data decompiled
+     */
+    static boolean[][] BuildMatrixFromBytes(int matrix_width, int matrix_height, byte[] matrix_data){
+        boolean[][] ret = new boolean[matrix_height][matrix_width];
+
+        // Transforming the bit from matrix_data's byte into boolean array for better manipulation
+        boolean[] b_array = new boolean[matrix_height * matrix_width];
+        int index = 0;
+        for(byte b: matrix_data){
+            for (int i = 0; i < 8; i++) { // because 8 bit in a byte
+                b_array[index] = Bitwise.IsBitSetAt(b, i);
+                index++;
+                if(index >= matrix_height * matrix_width)
+                    break;
+            }
+        }
+
+        // Transforming b_array to a 2D matrix
+        for (int x = 0; x < matrix_height; x++) {
+            for (int y = 0; y < matrix_width; y++) {
+                ret[x][y] = b_array[y + x * matrix_width];
+            }
+        }
+        return ret;
+    }
+
+    /**
+     * give the amount of byte needed to store the given Map
+     * following the binary file format
+     * @param level the map to check
+     * @param data should add save data or only level data
+     * @return integer of the ammount of byte needed
+     */
+    public static int getByteSizeForMap(Map level, boolean data){
+        int ret = 6; // header + footer
+        ret += 2; //size of the piece
+        ret += ((level.getWidth() * level.getHeight()) / 8); // size of the map
+        ret += level.getHeight() * level.getWidth() % 8 == 0 ? 0 : 1; // Add 1 if the size of map is not a mult of 8
+        ret += 1; // amount of pieces
+        for(Piece p: level.getPieces()){
+            ret += 1; // size of the piece
+            ret += p.getHeight() * p.getWidth() / 8;
+            ret += p.getHeight() * p.getWidth() % 8 == 0 ? 0 : 1; // add 1 if the size of the piece is not mult of 8
+            if(data){
+                ret += 2; // if the piece is not placed, only one byte else 2
+            }
+        }
+        return ret;
+    }
+}

app/src/main/java/school_project/Parsers/FileParser.java

@@ -0,0 +1,33 @@
+package school_project.Parsers;
+
+import school_project.Map;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+public interface FileParser {
+
+    /**
+     * Parse the file and create a Map with its shape and pieces setup
+     *
+     * @param file file to parse
+     * @param saved_data does the saved data should be added to the map
+     * @return Map Object parsed with file data
+     * @see <a href="http://school.debucquoy.me/spec/FileParser.html#file-parser-specification"> Parser Specification</a>
+     * @throws FileNotFoundException if the file was not found or was not accessible
+     * @throws IOException if an I/O occurs
+     */
+    Map getLevel(File file, boolean saved_data) throws IOException;
+
+    /**
+     * Save Map to a file without all it's data
+     * Could be used for generating level file. might not be used in game.
+     * @param file the file where to save
+     * @param levelData the map to save
+     * @param save_data should save the map data (need to be false only in development I think)
+     * @throws FileNotFoundException The file could not be created
+     * @throws IOException if an I/O occurs
+     */
+    void saveLevel(File file, Map levelData, boolean save_data) throws IOException;
+}

app/src/main/java/school_project/Parsers/FileParserFactory.java

@@ -0,0 +1,132 @@
+package school_project.Parsers;
+
+import javafx.util.Pair;
+import school_project.Map;
+import school_project.Piece;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.NotSerializableException;
+import java.util.Scanner;
+
+/**
+ * This is used to find the right parser to parser a save/level file.
+ * This should be the only right way to save/load a file! you can just use `Map loadMapFromFile(File)` to load a file
+ * and `void saveFileFromMap(File, Map)` to save a file
+ *
+ * <p>
+ * there is currently 2 file format with 2 variation each (save file or level file)
+ * - BinaryParser
+ *  - ".level"
+ *  - ".slevel"
+ * - SerializeParser
+ *  - ".serialized"
+ *  - ".sserialized"
+ * </p>
+ *
+ * <p>
+ * More file format can be added in the future by adding a new class that implement parser
+ * and adding it to this file
+ * </p>
+ *
+ * @author tonitch
+ */
+public class FileParserFactory {
+    /**
+     * Load a file and return a map
+     * If this is a save map, return the map with its save data
+     * @param file file to get data from
+     * @return Map generated from the file
+     * @throws FileNotFoundException if the file was not found or was not accessible
+     * @throws IOException if an I/O occurs
+     */
+    public static Map loadMapFromFile(File file) throws IOException {
+        Pair<FileParser, Boolean> parser= getFileParser(file);
+        return parser.getKey().getLevel(file, parser.getValue());
+    }
+
+    /**
+     * Save a file in a specific format, this format is defined by the file extension
+     * This file extention could be: ".level", ".slevel", ".serialized", ".sserialized"
+     * for save file use the .s variations
+     * @param file file name to be saved to with the right extension
+     * @param map map file to save
+     * @throws NotSerializableException the file extension is not recognised
+     * @throws FileNotFoundException The file could not be created
+     * @throws IOException if an I/O occurs
+     */
+    public static void saveFileFromMap(File file, Map map) throws IOException {
+        Pair<FileParser, Boolean> parser= getFileParser(file);
+        parser.getKey().saveLevel(file, map, parser.getValue());
+    }
+
+    private static Pair<FileParser, Boolean> getFileParser(File file) throws NotSerializableException {
+        FileParser fileParser;
+        boolean save_data;
+
+        if (file.toString().toLowerCase().endsWith(".level")){
+            fileParser = new BinaryParser();
+            save_data = false;
+        }else if(file.toString().toLowerCase().endsWith(".slevel")){
+            fileParser = new BinaryParser();
+            save_data = true;
+        }else if(file.toString().toLowerCase().endsWith(".serialized")){
+            fileParser = new SerializeParser();
+            save_data = false;
+        }else if(file.toString().toLowerCase().endsWith(".sserialized")) {
+            fileParser = new SerializeParser();
+            save_data = true;
+        }else {
+            throw new NotSerializableException("This file format is not supported");
+        }
+        return new Pair<FileParser, Boolean>(fileParser, save_data);
+    }
+
+    public static void main(String[] args) throws IOException {
+        Scanner in = new Scanner(System.in);
+        Map level = new Map();
+
+        System.out.print("Entrez le nom du fichier:");
+        File file = new File(in.nextLine());
+
+        System.out.print("Entrez la largeur de la map:");
+        int map_width = in.nextInt();
+
+        System.out.print("Entrez la hauteur de la map:");
+        int map_height = in.nextInt();
+
+        boolean[][] map_shape = new boolean[map_height][map_width];
+
+        for (int i = 0; i < map_height; i++) {
+            for (int j = 0; j < map_width; j++) {
+                System.out.print("mur (" + i + ", " + j + ")? (y/n):");
+                map_shape[i][j] = in.next(".").charAt(0) != 'y';
+            }
+        }
+
+        level.setShape(map_shape);
+        System.out.println(level);
+        System.out.print("Entrez le nombre de pieces:");
+        int piece_amount = in.nextInt();
+
+        for (int i = 0; i < piece_amount; i++) {
+            System.out.print("Entrez la largeur de la piece" + (i+1) +": ");
+            int _piece_width = in.nextInt();
+
+            System.out.print("Entrez la hauteur de la piece" + (i+1) +": ");
+            int _piece_height = in.nextInt();
+            boolean[][] _piece_shape = new boolean[_piece_height][_piece_width];
+
+            for (int k = 0; k < _piece_height; k++) {
+                for (int j = 0; j < _piece_width; j++) {
+                    System.out.print("mur (" + k + ", " + j + ")? (y/n):");
+                    _piece_shape[k][j] = in.next(".").charAt(0) != 'y';
+                }
+            }
+
+            level.addPiece(new Piece(_piece_shape));
+        }
+        saveFileFromMap(file, level);
+    }
+}

app/src/main/java/school_project/Parsers/SerializeParser.java

@@ -0,0 +1,32 @@
+package school_project.Parsers;
+
+import school_project.Map;
+
+import java.io.*;
+
+public class SerializeParser implements FileParser{
+
+    @Override
+    public Map getLevel(File file, boolean saved_data) throws IOException {
+        // saved_data is ignored in this case because the file is serialized data and it already knows if should have saved_data or not at this point
+        FileInputStream fileStream = new FileInputStream(file);
+        ObjectInputStream objectStream = new ObjectInputStream(fileStream);
+        try {
+            return (Map) objectStream.readObject();
+        } catch (ClassNotFoundException e) {
+            throw new IOException("the serialized file format has not found any object in the file");
+        }
+    }
+
+    @Override
+    public void saveLevel(File file, Map levelData, boolean save_data) throws IOException {
+        FileOutputStream fileStream = new FileOutputStream(file);
+        ObjectOutputStream objectStream = new ObjectOutputStream(fileStream);
+        objectStream.writeObject(save_data ? levelData : levelData.getCleanedMap());
+
+        objectStream.close();
+        fileStream.close();
+    }
+
+
+}

app/src/main/java/school_project/Piece.java

@@ -1,14 +1,66 @@
 package school_project;
 
+import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
+
+import java.util.ArrayList;
+import java.util.Random;
+
+/**
+ * Represent a Piece in the game.
+ * Every Piece should be contained in a Map Object.
+ * A piece has a position witch is the position of its top-leftest position in its matrix.
+ * If the piece is not placed in the Map (in a floating state) the position should be null;
+ */
 public class Piece extends Shape{
 
-    private int x,y; // Position in the Map Object
-    public Piece() {
-        super();
-    }
+    private Vec2 Position;
+    private Map linked_map;
+    private transient Paint color; // https://www.baeldung.com/java-transient-keyword
 
     public Piece(boolean[][] matrix) {
         super(matrix);
+        Random rand = new Random();
+        // the %.8 is there to avoid pieces that are too "white" so that we can see them
+        color = new Color(rand.nextDouble()%.8, rand.nextDouble() %.8, rand.nextDouble()%.8, 1);
+    }
+
+    public void setColor(Paint p){
+        color = p;
+    }
+
+    public Paint getColor(){
+        return color;
+    }
+
+    public Vec2 getPosition() {
+        return Position;
+    }
+
+    public void setPosition(Vec2 position){
+        this.Position = position;
+    }
+
+    public ArrayList<Vec2> getOccupation(){
+        ArrayList<Vec2> ret = new ArrayList<>();
+        if(Position == null)
+            return ret;
+        for (int x = 0; x < height; x++) {
+            for (int y = 0; y < width; y++) {
+               if(getShape()[x][y]){
+                   ret.add(new Vec2(getPosition().x + x, getPosition().y + y));
+               }
+            }
+        }
+        return ret;
+    }
+
+    /**
+     * set the map the piece is into the the map argument
+     * @param map map where to place the piece
+     */
+    public void setLinked_map(Map map){
+        this.linked_map = map;
     }
 
     /**
@@ -26,6 +78,20 @@ public class Piece extends Shape{
             }
             times--;
             matrix = temp_matrix;
+            height = matrix.length;
+            width = matrix[0].length;
         }
     }
+
+    @Override
+    public boolean equals(Object obj) {
+        if(obj instanceof Piece){
+            Piece pieceObj = (Piece) obj;
+            if (pieceObj.getPosition() != null && this.getPosition() != null){
+                return pieceObj.getPosition().equals(this.getPosition()) && pieceObj.getShape().equals(getShape());
+            }
+            return pieceObj.getShape().equals(getShape());
+        }
+        return false;
+    }
 }

app/src/main/java/school_project/Shape.java

@@ -1,8 +1,17 @@
 package school_project;
 
 
-public class Shape {
+import school_project.Utils.Array;
 
+import java.io.Serializable;
+import java.util.ArrayList;
+
+/**
+ * Base class for everything that is a shape kind, like map and pieces
+ * it contain a matrix of boolean where the shape is defined by the true's
+ */
+public class Shape implements Serializable, Cloneable{
+    
     protected boolean[][] matrix;
     protected int height, width;
 
@@ -15,14 +24,52 @@ public class Shape {
     }
 
     public void setShape(boolean[][] matrix) throws IllegalArgumentException{
-        height = matrix.length;
-        width = matrix[0].length;
 
         for (boolean[] row: matrix){
-            if(row.length != width){
+            if(row.length != matrix[0].length){
                 throw new IllegalArgumentException("The argument should be a square matrix");
             }
         }
+
+        for (int i = 0; i < matrix.length; i++) {
+            if(!Array.isRowOnlyFalse(matrix, i)) {
+                for (int j = 0; j < i; j++) {
+                    matrix = Array.MatrixRemoveRow(matrix, 0);
+                }
+                break;
+            }
+        }
+
+        for (int i = matrix.length-1; i >= 0; i--) {
+            if(!Array.isRowOnlyFalse(matrix, i)) {
+                for (int j = matrix.length-1; j > i; j--) {
+                    matrix = Array.MatrixRemoveRow(matrix, j);
+                }
+                break;
+            }
+        }
+
+        for (int i = 0; i < matrix[0].length; i++) {
+            if(!Array.isColumnOnlyFalse(matrix, i)) {
+                for (int j = 0; j < i; j++) {
+                    matrix = Array.MatrixRemoveColumn(matrix, 0);
+                }
+                break;
+            }
+        }
+
+        for (int i = matrix[0].length-1; i >= 0; i--){
+            if(!Array.isColumnOnlyFalse(matrix, i)) {
+                for (int j = matrix[0].length-1; j > i; j--) {
+                    matrix = Array.MatrixRemoveColumn(matrix, j);
+                }
+                break;
+            }
+        }
+
+        height = matrix.length;
+        width = matrix[0].length;
+
         this.matrix = matrix;
     }
 
@@ -37,4 +84,33 @@ public class Shape {
     public boolean[][] getShape() {
         return matrix;
     }
-}
+
+    /**
+     * Get the list of all the open possition of the map
+     * @return ArrayList of vec2 of all the positions
+     */
+    public ArrayList<Vec2> getPosList(){
+        ArrayList<Vec2> ret = new ArrayList<>();
+        for (int x = 0; x < height; x++) {
+            for (int y = 0; y < width; y++) {
+                if(matrix[x][y]){
+                    ret.add(new Vec2(x, y));
+                }
+            }
+        }
+        return ret;
+    }
+
+    @Override
+    public String toString() {
+        String ret = "";
+        for (boolean[] row : matrix) {
+            for (boolean el : row) {
+                if(el) ret = ret.concat("⬛");
+                else ret = ret.concat("⬜");
+            }
+            ret = ret.concat("\n");
+        }
+        return ret;
+    }
+}

app/src/main/java/school_project/Utils/Array.java

@@ -0,0 +1,61 @@
+package school_project.Utils;
+
+import java.util.Arrays;
+
+public class Array{
+    public static boolean[][] MatrixCopyOf(boolean[][] o){
+        boolean[][] ret =  new boolean[o.length][];
+        for (int i = 0; i < o.length; i++){
+            ret[i] = Arrays.copyOf(o[i], o[i].length);
+        }
+        return ret;
+    }
+
+    public static boolean[][] MatrixRemoveRow(boolean[][] o, int row){
+        boolean[][] newMatrix = new boolean[o.length - 1][o[0].length];
+        int newRow = 0;
+        for (int i = 0; i < o.length; i++) {
+            if(i == row)
+                i++;
+            if(i >= o.length)
+                continue;
+            newMatrix[newRow] = o[i];
+            newRow++;
+        }
+        return newMatrix;
+    }
+
+    public static boolean[][] MatrixRemoveColumn(boolean[][] o, int col){
+        boolean[][] newMatrix = new boolean[o.length][o[0].length - 1];
+        for (int i = 0; i < o.length; i++) {
+            int newCol = 0;
+            for(int j = 0; j < o[0].length; j++){
+                if(j == col)
+                    j++;
+                if(j >= o[0].length)
+                    continue;
+                newMatrix[i][newCol] = o[i][j];
+                newCol++;
+            }
+        }
+        return newMatrix;
+    }
+
+    public static boolean isRowOnlyFalse(boolean[][] o, int row){
+        boolean mark = true;
+        for (int i = 0; i < o[row].length; i++) {
+            if(o[row][i])
+                mark = false;
+        }
+        return mark;
+    }
+
+    public static boolean isColumnOnlyFalse(boolean[][] o, int column){
+        boolean mark = true;
+        for (int i = 0; i < o.length; i++) {
+            if(o[i][column])
+                mark = false;
+        }
+        return mark;
+    }
+}

app/src/main/java/school_project/Utils/Bitwise.java

@@ -0,0 +1,43 @@
+package school_project.Utils;
+
+import school_project.Vec2;
+
+public class Bitwise {
+
+    /**
+     * Check if the bit at pos is 1 or 0
+     * @param b byte to test
+     * @param pos position in b to check
+     * @return true if the bit at pos is 1 or false if it is 0
+     */
+    public static boolean IsBitSetAt(byte b, int pos){
+        pos = 7 - pos;
+        return (b & (1 << pos))!= 0;
+    }
+
+    /**
+     * Transform a byte (8 bit) to two Nible (4 bit) with a split in the middle
+     * Exemple:
+     * in = 01000101 (=69)
+     * out = { 00000100, 00000101 } (={4, 5})
+     *
+     * @param in the byte to split
+     * @return an arrya of 2 byte ret[0] = left part; ret[1] = right part
+     */
+    public static Vec2 ByteToNible(byte in){
+        Vec2 ret = new Vec2();
+        ret.x = (byte) (in >> 4);
+        ret.y = (byte) (in & 15); // apply the mask '00001111'
+        return ret;
+    }
+
+    /**
+     * Transform 2 byte into 1 with a left part ( 4 bits ) and a right part ( 4 bits)
+     * @param left first 4 bits
+     * @param right last 4 bits
+     * @return concatenated byte
+     */
+    public static byte NibbleToByte(byte left, byte right){
+        return (byte) ((left << 4) | right);
+    }
+}

app/src/main/java/school_project/Utils/MatrixShape.java

@@ -0,0 +1,64 @@
+package school_project.Utils;
+
+import javafx.scene.Node;
+import javafx.scene.image.Image;
+import javafx.scene.image.ImageView;
+import javafx.scene.layout.GridPane;
+import javafx.scene.layout.Pane;
+import javafx.scene.paint.Paint;
+import javafx.scene.shape.Rectangle;
+import school_project.*;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+
+public class MatrixShape extends GridPane {
+    public Shape shape;
+    public Vec2 boundary_size = new Vec2();
+    private Paint color;
+    public MatrixShape(Shape shape) {
+        super();
+        this.shape = shape;
+        if(shape instanceof Piece){
+            Piece p = (Piece) shape;
+            color = p.getColor();
+        }
+
+        update();
+
+        setHgap(GameUI.SPACE_SIZE);
+        setVgap(GameUI.SPACE_SIZE);
+    }
+
+    public void update(){
+        getChildren().clear();
+        boolean[][] shape_matrix = shape.getShape();
+        for (int i = 0; i < shape_matrix.length; i++) {
+            for (int j = 0; j < shape_matrix[i].length; j++) {
+                Node _cell;
+                if(shape_matrix[i][j]){
+                    if(shape instanceof Piece){
+                        Piece p = (Piece) shape;
+                        _cell = new Rectangle(GameUI.SEGMENT_SIZE, GameUI.SEGMENT_SIZE);
+                        ((Rectangle) _cell).setFill(color);
+                    }else{
+                        try {
+                          _cell = new ImageView(new Image(new FileInputStream(Controller.class.getResource("tile.png").getFile())));
+                        } catch (FileNotFoundException e) {
+                            throw new RuntimeException(e);
+                        }
+                    }
+                }
+                else{
+                    _cell = new Pane();
+                    ((Pane) _cell).setPrefSize(GameUI.SEGMENT_SIZE, GameUI.SEGMENT_SIZE);
+                }
+                add(_cell, j, i);
+            }
+        }
+        boundary_size = new Vec2((GameUI.SEGMENT_SIZE + GameUI.SPACE_SIZE) * shape.getWidth(), (GameUI.SEGMENT_SIZE + GameUI.SPACE_SIZE) * shape.getHeight());
+    }
+    public void setColor(Paint p) {
+        color = p;
+    }
+}

app/src/main/java/school_project/Vec2.java

@@ -0,0 +1,39 @@
+package school_project;
+
+import java.io.Serializable;
+
+/**
+ * This is used to represent a position/vector/... any ensemble of 2 elements that have to work together in
+ * a plan. This way we can use some basic operations over them.
+ */
+public class Vec2 implements Serializable {
+    public int x, y;
+
+    public Vec2() {
+        x = 0;
+        y = 0;
+    }
+
+    public Vec2(int x, int y ){
+        this.x = x;
+        this.y = y;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof Vec2) {
+            Vec2 vec = (Vec2) obj;
+            return this.x == vec.x && this.y == vec.y;
+        }
+        return false;
+    }
+
+    public Vec2 add(Vec2 o){
+        return new Vec2(x + o.x, y + o.y);
+    }
+
+    @Override
+    public String toString() {
+        return "("+x+","+y+")";
+    }
+}

app/src/main/resources/school_project/Menu/StyleMenuAcceuil.css

@@ -0,0 +1,11 @@
+.BorderPane{
+    -fx-background-image: url("BackGround-menu.jpg");
+    -fx-background-position:center;
+}
+.GridPane{
+    -fx-background-image: url("Background-select-level.jpg");
+    -fx-background-position:right;
+}
+.StackPane{
+    -fx-background-image: url("BackGround-LvlFinish.jpg");
+}

app/src/main/resources/school_project/levels/level1.level

@@ -0,0 +1 @@
+SMS
<03>
<13>SME

app/src/main/resources/school_project/levels/level10.level

@@ -0,0 +1 @@
+SMS<04><>"<22>"<22>"p1<70>SME

app/src/main/resources/school_project/levels/level11.level

@@ -0,0 +1 @@
+SMS<05><><EFBFBD><EFBFBD>3<><33>"<22>"<22>"p"<22><11>SME

app/src/main/resources/school_project/levels/level12.level

@@ -0,0 +1 @@
+SMS<05><><EFBFBD><EFBFBD>"<22>1<EFBFBD><13>2<EFBFBD>"p3<70><33>SME

app/src/main/resources/school_project/levels/level13.level

@@ -0,0 +1 @@
+SMS?<3F><><EFBFBD><EFBFBD><13>"<22>3<EFBFBD><33><13>"<22>2<EFBFBD>3<EFBFBD><33>SME

app/src/main/resources/school_project/levels/level14.level

@@ -0,0 +1 @@
+SMSf<><66><EFBFBD><	1<>"<22>"p<11>&<26><>"<22>"<22>"<22><13>SME

app/src/main/resources/school_project/levels/level15.level

@@ -0,0 +1 @@
+SMS<05><><EFBFBD>"<22>1<EFBFBD><11>"p#<23><12>!<21>SME

app/src/main/resources/school_project/levels/level16.level

@@ -0,0 +1 @@
+SMS<05><><EFBFBD><EFBFBD>"<22><13><11>"p3<70><33>3o<33>SME

app/src/main/resources/school_project/levels/level17.level

@@ -0,0 +1 @@
+SMS<06><><EFBFBD><EFBFBD><EFBFBD>3<><33>3<EFBFBD><33>1<EFBFBD>1<EFBFBD>#<23>#<23>SME

app/src/main/resources/school_project/levels/level19.level

@@ -0,0 +1 @@
+SMS<06><><EFBFBD><EFBFBD><EFBFBD><13>3<EFBFBD><33>3o<33>4<34>"<22>SME

app/src/main/resources/school_project/levels/level2.level

@@ -0,0 +1 @@
+SMS
<01>
1<>SME

app/src/main/resources/school_project/levels/level20.level

@@ -0,0 +1 @@
+SMS<05><><EFBFBD><EFBFBD><12>3<EFBFBD><33>"<22>2<EFBFBD>3<EFBFBD><33>SME

app/src/main/resources/school_project/levels/level22.level

@@ -0,0 +1 @@
+SMS<05><><EFBFBD><EFBFBD>"p<13><12>"<22>#<23>#<23>#<23>SME

app/src/main/resources/school_project/levels/level23.level

@@ -0,0 +1 @@
+SMS<05><><EFBFBD><EFBFBD>2<><13>"<22>#<23>#<23>BSME

app/src/main/resources/school_project/levels/level24.level

@@ -0,0 +1 @@
+SMSv<><76><EFBFBD>#<23><11><11>#<23>#<23>BSME

app/src/main/resources/school_project/levels/level25.level

@@ -0,0 +1 @@
+SMS<06><><EFBFBD><EFBFBD><EFBFBD>#<23>#|!<21>#\#<23>2<EFBFBD>2<EFBFBD>BSME

app/src/main/resources/school_project/levels/level27.level

@@ -0,0 +1 @@
+SMS<06><><EFBFBD><EFBFBD><EFBFBD>#<23>#<23>!<21>!<21>#<23>4<34>3o<33>SME

app/src/main/resources/school_project/levels/level28.level

@@ -0,0 +1 @@
+SMS<07><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>2<>B#|3?<3F>3<EFBFBD><33>#<23>&<26><>SME

app/src/main/resources/school_project/levels/level29.level

@@ -0,0 +1 @@
+SMSy<><79>y<EFBFBD>B<>!<21>B<EFBFBD>$<24>#<23>#<23>SME

app/src/main/resources/school_project/levels/level3.level

@@ -0,0 +1 @@
+SMS<03><>#<23><13>SME

app/src/main/resources/school_project/levels/level30.level

@@ -0,0 +1 @@
+SMS<07><><EFBFBD>}<7D>߀$<24>3ۀ2<DB80><11><11>"<22>2x"p2<70>"<22>2<EFBFBD>SME

app/src/main/resources/school_project/levels/level4.level

@@ -0,0 +1 @@
+SMS<04><>#<23>#<23><11>1<EFBFBD>SME

app/src/main/resources/school_project/levels/level5.level

@@ -0,0 +1 @@
+SMS<>p<11><11>1<EFBFBD>#<23>#<23>SME

app/src/main/resources/school_project/levels/level6.level

@@ -0,0 +1 @@
+SMS<>3<><33><13>1<EFBFBD>SME

app/src/main/resources/school_project/levels/level7.level

@@ -0,0 +1 @@
+SMS3<>2<><13>"<22>SME

app/src/main/resources/school_project/levels/level8.level

@@ -0,0 +1 @@
+SMS<05><><EFBFBD><EFBFBD>2<>"<22>"<22>"p1<70><11>1<EFBFBD>"pSME

app/src/main/resources/school_project/levels/level9.level

@@ -0,0 +1 @@
+SMS<05><>߀1<>1<EFBFBD>3<EFBFBD><33>#<23>"<22>SME

app/src/test/java/school_project/MapGeneratorTest.java

@@ -0,0 +1,26 @@
+package school_project;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class MapGeneratorTest {
+
+    @Test
+    void generate() {
+        Map[] maps = new Map[] {
+            MapGenerator.generate(MapGenerator.Difficulty.Easy),
+            MapGenerator.generate(MapGenerator.Difficulty.Medium),
+            MapGenerator.generate(MapGenerator.Difficulty.Difficult),
+        };
+
+        for(Map m: maps){
+            System.out.println("==========");
+            System.out.println(m);
+            System.out.println("++++++++++++++++++++");
+            for (Piece p: m.getPieces()){
+                System.out.println(p);
+            }
+        }
+    }
+}

app/src/test/java/school_project/MapTest.java

@@ -0,0 +1,35 @@
+package school_project;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class MapTest {
+
+    @Test
+    void getUsedSpace() {
+        boolean[][] map_matrix = {
+                {false, true, true, false},
+                {false, true, true, true},
+                {true, true, true, false},
+                {false, true, true, true}
+        };
+        Map testMap = new Map(map_matrix);
+
+        boolean[][] piece1_matrix = {
+                {true, true},
+                {true, true},
+        };
+        Piece piece1 = new Piece(piece1_matrix);
+        testMap.addPiece(piece1);
+        piece1.setPosition(new Vec2(0,1));
+
+        boolean[][] result_matrix = {
+                {false, false, false, false},
+                {false, false, false, true},
+                {true, true, true, false},
+                {false, true, true, true}
+        };
+        assertArrayEquals(result_matrix, testMap.getUsedSpace());
+    }
+}

app/src/test/java/school_project/Parsers/BinaryParserTest.java

@@ -0,0 +1,177 @@
+package school_project.Parsers;
+
+import org.junit.jupiter.api.Test;
+import school_project.Map;
+import school_project.Piece;
+import school_project.Vec2;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.util.Arrays;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class BinaryParserTest {
+
+    static byte[] file_data = {
+            'S', 'M', 'S',
+            6, 5, (byte) 0x31, (byte) 0xEC, (byte) 0xF3, (byte) 0xFC,
+            4,
+            (byte) 0x22, (byte) 0x70,
+            (byte) 0x33, (byte) 0x99, (byte) 0x80,
+            (byte) 0x32, (byte) 0x7C,
+            (byte) 0x33, (byte) 0xDB, (byte) 0x80,
+            'S', 'M', 'E'
+    };
+
+    @Test
+    void getByteSizeForMap() {
+        boolean[][] map_shape = {
+                { true, true, true },
+                { true, false, true },
+                { true, true, true },
+
+        };
+        boolean[][] piece1_shape = {
+                { true, true },
+                { true, false },
+                { true, true },
+
+        };
+        boolean[][] piece2_shape = {
+                { true },
+                { true },
+                { true },
+
+        };
+        Map map = new Map(map_shape);
+        Piece piece1 = new Piece(piece1_shape);
+        Piece piece2 = new Piece(piece2_shape);
+
+        map.addPiece(new Piece[]{piece1, piece2});
+        piece2.setPosition(new Vec2(0, 2));
+
+
+        assertEquals(15, BinaryParser.getByteSizeForMap(map, false));
+        assertEquals(19, BinaryParser.getByteSizeForMap(map, true));
+    }
+
+
+    @Test
+    void BuildByteFromMatrix(){
+        byte[] map_data = Arrays.copyOfRange(file_data, 5, 9);
+        boolean[][] map_shape = {
+                {false, false, true, true, false, false},
+                {false, true, true, true, true, false},
+                {true, true, false, false, true, true},
+                {true, true, false, false, true, true},
+                {true, true, true, true, true, true},
+        };
+        assertArrayEquals(map_data, BinaryParser.BuildByteFromMatrix(map_shape));
+    }
+
+    @Test
+    void BuildMatrixFromByte_map(){
+        byte[] map_data = Arrays.copyOfRange(file_data, 5, 9);
+        boolean[][] map_shape = {
+                {false, false, true, true, false, false},
+                {false, true, true, true, true, false},
+                {true, true, false, false, true, true},
+                {true, true, false, false, true, true},
+                {true, true, true, true, true, true},
+        };
+        assertArrayEquals(map_shape, BinaryParser.BuildMatrixFromBytes(6, 5, map_data));
+    }
+
+    @Test
+    void BuildMatrixFromByte_piece1(){
+        byte[] piece1_data = Arrays.copyOfRange(file_data, 11, 12);
+        boolean[][] piece1_shape = {
+                {false, true},
+                {true, true},
+        };
+        assertArrayEquals(piece1_shape, BinaryParser.BuildMatrixFromBytes(2, 2, piece1_data));
+    }
+
+    @Test
+    void BuildMatrixFromByte_piece2(){
+        byte[] piece2_data = Arrays.copyOfRange(file_data, 13, 15);
+        boolean[][] piece2_shape = {
+                {true, false, false},
+                {true, true, false},
+                {false, true, true},
+        };
+        assertArrayEquals(piece2_shape, BinaryParser.BuildMatrixFromBytes(3, 3, piece2_data));
+    }
+
+    @Test
+    void BuildMatrixFromByte_piece3(){
+        byte[] piece3_data = Arrays.copyOfRange(file_data, 16, 17);
+        boolean[][] piece3_shape = {
+                {false, true, true},
+                {true, true, true},
+        };
+        assertArrayEquals(piece3_shape, BinaryParser.BuildMatrixFromBytes(3, 2, piece3_data));
+    }
+
+    @Test
+    void BuildMatrixFromByte_piece4(){
+        byte[] piece4_data = Arrays.copyOfRange(file_data, 18, 20);
+        boolean[][] piece4_shape = {
+                {true, true, false},
+                {true, true, false},
+                {true, true, true},
+        };
+        assertArrayEquals(piece4_shape, BinaryParser.BuildMatrixFromBytes(3, 3, piece4_data));
+    }
+
+    @Test
+    void ExtractLevelData() throws IOException {
+        boolean[][] expected_map_shape = {
+                {false, false, true, true, false, false},
+                {false, true, true, true, true, false},
+                {true, true, false, false, true, true},
+                {true, true, false, false, true, true},
+                {true, true, true, true, true, true},
+        };
+
+        byte[] level_data = BinaryParser.ExtractLevelData(new ByteArrayInputStream(file_data));
+        boolean[][] map = BinaryParser.ExtractMapFromLevelData(level_data);
+
+        assertArrayEquals(expected_map_shape, map);
+    }
+
+    @Test
+    void ExtractPiecesFronLevelDataTest() throws IOException {
+        boolean[][] piece1_shape = {
+                {false, true},
+                {true, true},
+        };
+        boolean[][] piece2_shape = {
+                {true, false, false},
+                {true, true, false},
+                {false, true, true},
+        };
+        boolean[][] piece3_shape = {
+                {false, true, true},
+                {true, true, true},
+        };
+        boolean[][] piece4_shape = {
+                {true, true, false},
+                {true, true, false},
+                {true, true, true},
+        };
+        boolean[][][] pieces_shapes = {
+                piece1_shape,
+                piece2_shape,
+                piece3_shape,
+                piece4_shape
+        };
+        byte[] level_data = BinaryParser.ExtractLevelData(new ByteArrayInputStream(file_data));
+        Piece[] pieces = BinaryParser.ExtractPiecesFromLevelData(level_data, false);
+
+        for (int i = 0; i < pieces_shapes.length; i++) {
+            assertArrayEquals(pieces_shapes[i], pieces[i].getShape());
+        }
+    }
+}

app/src/test/java/school_project/Parsers/FileParserFactoryTest.java

@@ -0,0 +1,103 @@
+package school_project.Parsers;
+
+import org.junit.jupiter.api.*;
+import org.junit.jupiter.api.io.TempDir;
+import school_project.Map;
+import school_project.Piece;
+import school_project.Vec2;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Path;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class FileParserFactoryTest {
+
+    static Map generateMapTest(){
+        boolean[][] map_shape = {
+                {false, false, true, true, false, false},
+                {false, true, true, true, true, false},
+                {true, true, false, false, true, true},
+                {true, true, false, false, true, true},
+                {true, true, true, true, true, true},
+        };
+        boolean[][] piece1_shape = {
+                {false, true},
+                {true, true},
+        };
+        boolean[][] piece2_shape = {
+                {true, false, false},
+                {true, true, false},
+                {false, true, true},
+        };
+        boolean[][] piece3_shape = {
+                {false, true, true},
+                {true, true, true},
+        };
+        boolean[][] piece4_shape = {
+                {true, true, false},
+                {true, true, false},
+                {true, true, true},
+        };
+        Piece[] pieces = { new Piece(piece1_shape), new Piece(piece2_shape), new Piece(piece3_shape), new Piece(piece4_shape) };
+        Map map = new Map(map_shape);
+        map.addPiece(pieces);
+
+        pieces[0].setPosition(new Vec2(1, 0));
+        pieces[1].setPosition(new Vec2(3, 0));
+        pieces[2].setPosition(new Vec2(3, 3));
+        pieces[3].setPosition(new Vec2(0, 2));
+        return map;
+    }
+
+    @Test
+    void saveLoadFileFromMap_Binary(@TempDir Path tmpFolder) throws IOException {
+        Map map = generateMapTest();
+        FileParserFactory.saveFileFromMap(tmpFolder.resolve("TestBinaryLevel.level").toFile(), map);
+
+        Map testMap = FileParserFactory.loadMapFromFile(tmpFolder.resolve("TestBinaryLevel.level").toFile());
+        assertArrayEquals(map.getCleanedMap().getShape(), testMap.getShape());
+        for (int i = 0; i < map.getPieces().size(); i++) {
+            assertArrayEquals(map.getPieces().get(i).getShape(), testMap.getPieces().get(i).getShape());
+        }
+    }
+
+    @Test
+    void saveLoadFileFromMap_save_Binary(@TempDir Path tmpFolder) throws IOException {
+        Map map = generateMapTest();
+        FileParserFactory.saveFileFromMap(tmpFolder.resolve("TestBinarySave.slevel").toFile(), map);
+
+        Map testMap = FileParserFactory.loadMapFromFile(tmpFolder.resolve("TestBinarySave.slevel").toFile());
+        assertArrayEquals(map.getShape(), testMap.getShape());
+        for (int i = 0; i < map.getPieces().size(); i++) {
+            assertArrayEquals(map.getPieces().get(i).getShape(), testMap.getPieces().get(i).getShape());
+            assertEquals(map.getPieces().get(i).getPosition(), testMap.getPieces().get(i).getPosition());
+        }
+    }
+    @Test
+    void saveLoadFileFromMap_Serialized(@TempDir Path tmpFolder) throws IOException {
+        Map map = generateMapTest();
+        FileParserFactory.saveFileFromMap( tmpFolder.resolve("TestSerializedLevel.serialized").toFile(), map);
+
+        Map testMap = FileParserFactory.loadMapFromFile( tmpFolder.resolve("TestSerializedLevel.serialized").toFile());
+        assertArrayEquals(map.getShape(), testMap.getShape());
+        for (int i = 0; i < map.getPieces().size(); i++) {
+            assertArrayEquals(map.getPieces().get(i).getShape(), testMap.getPieces().get(i).getShape());
+        }
+
+    }
+
+    @Test
+    void saveLoadFileFromMap_save_Serialized(@TempDir Path tmpFolder) throws IOException{
+        Map map = generateMapTest();
+        FileParserFactory.saveFileFromMap(tmpFolder.resolve("TestSerializedSave.sserialized").toFile(), map);
+
+        Map testMap = FileParserFactory.loadMapFromFile(tmpFolder.resolve("TestSerializedSave.sserialized").toFile());
+        assertArrayEquals(map.getShape(), testMap.getShape());
+        for (int i = 0; i < map.getPieces().size(); i++) {
+            assertArrayEquals(map.getPieces().get(i).getShape(), testMap.getPieces().get(i).getShape());
+            assertEquals(map.getPieces().get(i).getPosition(), testMap.getPieces().get(i).getPosition());
+        }
+    }
+}

app/src/test/java/school_project/PieceTest.java

@@ -17,7 +17,6 @@ class PieceTest {
         boolean[][] piece1_matrix_result = {
                 {true, false, true},
                 {true, true, false},
-                {false, false, false},
         };
 
         boolean[][] piece2_matrix = {
@@ -31,12 +30,11 @@ class PieceTest {
         };
 
         boolean[][] piece3_matrix_result = {
-                {false, false, false},
                 {false, true, true},
                 {true, false, true},
         };
 
-        Piece piece1 = new Piece();
+        Piece piece1 = new Piece(piece2_matrix);
         piece1.setShape(piece1_matrix);
 
         Piece piece2 = new Piece(piece2_matrix);

app/src/test/java/school_project/ShapeTest.java

@@ -1,6 +1,9 @@
 package school_project;
 
 import org.junit.jupiter.api.Test;
+import school_project.Utils.Array;
+
+import java.util.Arrays;
 
 import static org.junit.jupiter.api.Assertions.*;
 
@@ -29,6 +32,30 @@ class ShapeTest {
                 {true}
         };
 
+        boolean[][] matrix_shape5 = {
+                {false, false, false, false, false},
+                {false, false, false, false, false},
+                {false, true, true, true, false},
+                {false, true, false, true, false},
+                {false, false, false, false, false},
+                {false, false, false, false, false},
+        };
+
+        boolean[][] matrix_shape5_result = {
+                {true, true, true},
+                {true, false, true},
+        };
+
+        boolean[][] matrix_shape6 = {
+                {true, false},
+                {false, false}
+        };
+
+        boolean[][] matrix_shape6_result = {
+                {true},
+        };
+
+        System.out.println(Array.isRowOnlyFalse(matrix_shape1, 0));
         Shape shape1 = new Shape();
         shape1.setShape(matrix_shape1);
         assertEquals(3, shape1.getHeight());
@@ -44,5 +71,11 @@ class ShapeTest {
         assertEquals(3, shape4.getHeight());
         assertEquals(1, shape4.getWidth());
 
+        Shape shape5 = new Shape(matrix_shape5);
+        assertArrayEquals(matrix_shape5_result, shape5.getShape());
+
+        Shape shape6 = new Shape(matrix_shape6);
+        assertArrayEquals(matrix_shape6_result, shape6.getShape());
+
     }
 }

app/src/test/java/school_project/Utils/ArrayTest.java

@@ -0,0 +1,81 @@
+package school_project.Utils;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ArrayTest {
+
+    @Test
+    void matrixCopyOf() {
+        boolean[][] a = new boolean[][] {
+                {true, false, true},
+                {false, false, false},
+                {true, false, true},
+        };
+        boolean[][] b = new boolean[][] {
+                {true, false, true},
+                {false, false, false},
+                {true, false, true},
+        };
+        boolean[][] c = Array.MatrixCopyOf(a);
+        assertArrayEquals(a, c);
+        a[1][1] = true;
+        assertArrayEquals(b, c);
+    }
+
+    @Test
+    void matrixRemoveRow() {
+        boolean[][] a = new boolean[][] {
+                {true, false, true},
+                {false, false, false},
+                {true, false, true},
+        };
+        boolean[][] b = new boolean[][] {
+                {true, false, true},
+                {true, false, true},
+        };
+
+        boolean[][] result = Array.MatrixRemoveRow(a, 1);
+        assertArrayEquals(b, result);
+    }
+
+    @Test
+    void matrixRemoveColumn() {
+        boolean[][] a = new boolean[][] {
+                {true, false, true},
+                {false, false, false},
+                {true, false, true},
+        };
+        boolean[][] b = new boolean[][] {
+                {true, true},
+                {false, false},
+                {true, true},
+        };
+
+        boolean[][] result = Array.MatrixRemoveColumn(a, 1);
+        assertArrayEquals(b, result);
+    }
+
+    @Test
+    void isRowOnlyFalse() {
+        boolean[][] a = new boolean[][] {
+                {true, false, true},
+                {false, false, false},
+                {true, false, true},
+        };
+        assertTrue(Array.isRowOnlyFalse(a, 1));
+        assertFalse(Array.isRowOnlyFalse(a, 0));
+    }
+
+    @Test
+    void isColumnOnlyFalse() {
+        boolean[][] a = new boolean[][] {
+                {true, false, true},
+                {false, false, false},
+                {true, false, true},
+        };
+        assertTrue(Array.isColumnOnlyFalse(a, 1));
+        assertFalse(Array.isColumnOnlyFalse(a, 0));
+    }
+}

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.0-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.6-bin.zip
 networkTimeout=10000
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

@@ -144,7 +144,7 @@ if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
     case $MAX_FD in #(
       max*)
         # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC3045
+        # shellcheck disable=SC3045 
         MAX_FD=$( ulimit -H -n ) ||
             warn "Could not query maximum file descriptor limit"
     esac
@@ -152,7 +152,7 @@ if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
       '' | soft) :;; #(
       *)
         # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC3045
+        # shellcheck disable=SC3045 
         ulimit -n "$MAX_FD" ||
             warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac

misc/pre-commit.sh

@@ -0,0 +1,82 @@
+#!/bin/sh
+
+echo 'Lovely Idea';
+
+BASE_DIR="$(dirname $(readlink -f $0))/.."
+cd $BASE_DIR
+echo $BASE_DIR
+
+function clean() {
+	echo "Cleaning the folder"
+	$BASE_DIR/gradlew clean
+	
+}
+
+function build() {
+	echo "Building the project"
+	$BASE_DIR/gradlew build
+	
+}
+
+function test() {
+	echo "Testing the project"
+	$BASE_DIR/gradlew test
+	
+}
+
+function run() {
+	echo "Running the project"
+	$BASE_DIR/gradlew run &
+	_PID=$!
+	sleep 3
+	killpid $_PID
+}
+
+function check_syntax() {
+	echo "Checking the syntax"
+	echo 'TODO Tonitch: check syntax script'
+	
+}
+
+function make_archive() {
+	echo "Creating the archive on the parent folder"
+	tar --create --gzip --exclude-vcs --exclude-vcs-ignores -f ../archive.tar.gz "${BASE_DIR}/{app/, gradle/, gralew, gradlew.bat, settings.gradle}"
+}
+
+case $1 in
+
+	clean )
+		clean ;;
+
+	build )
+		build ;;
+
+	test )
+		test ;;
+
+	run )
+		run ;;
+
+	syntax )
+		check_syntax ;;
+
+	archive )
+		clean &&
+		build &&
+		test &&
+		run &&
+		check_syntax &&
+		make_archive ;;
+
+	all )
+		clean &&
+		build &&
+		test &&
+		run &&
+		check_syntax ;;
+	* )
+		clean &&
+		build &&
+		test &&
+		check_syntax ;;
+esac

prototypes/cat_puzzle.py

@@ -0,0 +1,77 @@
+import os
+import rotate_matrix
+def turn_piece(piece):      #based on a matrix MxN ie [(0,0),(0,0),(0,0)] m = 3 and n = 2
+    new_piece = rotate_matrix.clockwise(piece)
+    return new_piece
+    
+game = True
+while game:
+    print('Bienvenue dans le jeu cat puzzle')
+
+    choose_level = 0
+    while choose_level == 0:
+        choose_level = input('Choissisez un niveau à résoudre\n')   #choose a level of the game
+        try:
+            choose_level = int(choose_level)
+        except ValueError:
+            choose_level= 0
+            print('Il me faut un nombre')
+        if choose_level!=1:
+            choose_level = 0
+            print('Il n\'existe que le niveau 1 pour l\'instant')
+
+    print('Découvrons ensemeble le niveau',choose_level)     #make a first level
+
+    if choose_level ==1:        #select the level one and print it 
+        level_one = [(1,1,1),(1,1,0),(1,1,1)]
+        print(level_one[0])
+        print(level_one[1])
+        print(level_one[2])
+
+
+    print('Voilà les pièces que vous disposez pour complèter le puzzle')     #make piece for resolve the puzzle 
+    
+    piece_for_level = {
+        1:[(1,1),(1,0)],2:[(1,0),(1,0),(1,0)],3:[(1,1)]}
+    
+
+    print('Voilà la pièce 1:')     #show the piece at the player
+    for i in piece_for_level[1]:
+        print(i)
+
+    print('Voilà la pièce 2:')
+    for i in piece_for_level[2]:
+        print(i)
+
+    print('Voilà la pièce 3:')
+    for i in piece_for_level[3]:
+        print(i)
+
+    choose_piece = 0
+    while choose_piece ==0:
+        choose_piece = input('Choissisez la pièce que vous voulez bouger ? ')   #choice of the piece to move 
+        try:
+            choose_piece = int(choose_piece)  
+        except ValueError:
+            choose_piece =0
+            print('J\'ai besoin d\'un nombre')
+
+    
+
+    move_piece = input('Voulez vous tournez la pièce ? (o/n)\n')
+    if move_piece== 'o':
+        print('Voilà la pièce tourner')
+        piece_turn = turn_piece(piece_for_level[choose_piece])
+        for i in piece_turn:
+            print(i)
+        
+    m = input('A quelle ligne voulez-vous mettre la pièce ? ')
+    n = input("A quelle colonne voulez-vous mettre la pièce ? ")
+    m,n=m-1,n-1
+    
+    
+
+    game=False
+    
+    
+os.system('pause')

prototypes/interface-menu/Road-to-masterU/Level.html

@@ -0,0 +1,32 @@
+<!DOCTYPE html>
+<html lang="fr">
+    <head>
+        <meta charset="utf-8">
+        <title>Level - Road to masterU</title>
+        <link href="style-Level.css" rel="stylesheet">
+    </head>
+<body>
+    <main>
+        <section class="select-day">
+            <h1>Day 1</h1>
+            <a href="" class="lien-icone">></a>
+        </section>
+        <section class="select-level">
+            <div class="level"><a href="">1</a></div>
+            <div class="level"><a href="">2</a></div>
+            <div class="level"><a href="">3</a></div>
+            <div class="level"><a href="">4</a></div>
+            <div class="level"><a href="">5</a></div>
+            <div class="level"><a href="">6</a></div>
+            <div class="level"><a href="">7</a></div>
+            <div class="level"><a href="">8</a></div>
+            <div class="level"><a href="">9</a></div>
+            <div class="level"><a href="">10</a></div>
+            
+        </section>
+    </main>
+    <footer>
+        <a href="Menu.html" class="back-to-accueil">Menu</a>
+    </footer>
+
+</body>

prototypes/interface-menu/Road-to-masterU/Menu.html

@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html lang="fr">
+    <head>
+        <meta charset="utf-8">
+        <title>Menu - Road to masterU</title>
+        <link href="style-menu.css" rel="stylesheet">
+    </head>
+<body>
+    <main>
+        <section class="title">
+            <h1>ROAD TO MASTERU </h1>
+        </section>
+        <section class="setting">
+            <a href="" class="setting-Play"><h2>Play</h2></a>
+            <a href="Level.html" class="setting-level"><h2>Level</h2></a>
+        </section>
+    </main>
+        <footer>
+            <a href="" class="lien-icone"><img src="../Trophee-pic.jpg" alt="trophy"></a>
+            <a href="" class="lien-icone"><img src="" alt="link-setting"></a>
+        </footer>
+    
+</body>

prototypes/interface-menu/Road-to-masterU/style-Level.css

@@ -0,0 +1,45 @@
+body{
+    background-image: url("../Background-select-level.jpg");
+    background-position: right;
+}
+h1,.lien-icone,.back-to-accueil{
+    font-size: 75px;
+    padding-top: 80px;
+    color:gold;
+}
+footer{
+    text-align: center;
+    padding:50px
+
+}
+a{
+    text-decoration: none;
+    color:black;
+}
+.select-day{
+    display: flex;
+    flex-direction: row;
+    justify-content: center;
+    align-items: baseline;
+
+}
+.select-level{
+    display:grid;
+    grid-template-columns: 40px 40px 40px;
+    grid-gap: 30px;
+    justify-content: center;
+}
+.level{
+    height: 60px;
+    border:3px solid black;
+    
+}
+.level>a{
+    font-size:30px;
+    display: flex;
+    justify-content:center;
+}
+.lien-icone{
+    padding-left: 10px;
+}
+

prototypes/interface-menu/Road-to-masterU/style-menu.css

@@ -0,0 +1,27 @@
+body{
+    background-image: url("../BackGround-menu.jpg");
+    background-position: center;
+}
+h1{
+    font-size: 75px;
+    padding-top: 80px;
+    text-decoration: underline;
+}
+h1,h2{
+    text-align: center;
+    color: gold;
+}
+h2{
+    font-size: 50px;
+    padding-top: 40px;
+}
+footer{
+    position:absolute;
+   bottom:0;
+   padding-bottom: 10px;
+   right:10px;
+
+}
+a{
+    text-decoration: none;
+}