Merge branch 'master' into undefined_name/School_Project#8

.drone.yml

@@ -0,0 +1,43 @@
+---
+kind: pipeline
+type: docker
+name: Check_Requirement
+
+steps:
+  - name: base_check
+    image: gradle:jdk11-alpine 
+    commands:
+      - ./gradlew clean
+      - ./gradlew build
+      - ./gradlew test
+
+---
+kind: pipeline
+type: docker
+name: master_build
+
+steps:
+  - name: make_archive
+    image: alpine:latest
+    volumes: 
+      - name: archives
+        path: /build
+    commands:
+      - tar cvzf /build/$(git log -n 1 --format="%h")_school_archive.gz.tar app/ gradle/ gradlew/ gradlew.bat README.md settings.gradle
+    trigger:
+      - branch:
+          - master
+        event:
+          - include:
+            - push
+volumes: 
+  - name: archives
+    host:
+      path: /srv/drone/school_project/archive/
+depends_on:
+  - Check_Requirement
+---
+kind: signature
+hmac: 82ce5e9bc63570a5614c4e7b3ddc888fadb36f7660ab0ab521d0cda3c5842e05
+
+...

.gitattributes

@@ -0,0 +1,9 @@
+#
+# https://help.github.com/articles/dealing-with-line-endings/
+#
+# Linux start script should use lf
+/gradlew        text eol=lf
+
+# These are Windows script files and should use crlf
+*.bat           text eol=crlf
+

.gitignore

@@ -50,3 +50,6 @@ replay_pid*
 
 # Ignore Gradle build output directory
 build
+
+.idea/
+.settings/

JournalDeBord/src/SUMMARY.md

@@ -1,3 +1,6 @@
 # Summary
 
-- [First Toughts](./chapter_1.md)
+# Rapports 
+
+- [Première entrevue](./rapports/130223.md)
+- [Deuxième entrevue](./rapports/200223.md)

JournalDeBord/src/chapter2.md

@@ -1 +0,0 @@
-Ceci est la page 2 du site

JournalDeBord/src/chapter_1.md

@@ -1,5 +0,0 @@
-# First Toughts
-
-[Here will be transcribed the tought about the first reunion]
-
-blop

JournalDeBord/src/rapports/130223.md

@@ -0,0 +1,59 @@
+# 13 Février 2023
+
+Nous nous sommes réunis ce **Lundi 13 Février** pour une première entre-vue et pour discuter de notre vision vis à vis du projet.
+
+Nous avons pu discuter de plusieurs choses, notament:
+
+- Methode pour travailler en équipe
+- Structure du projet
+- Petite explication du fonctionnement de git
+- Brainstorming des idées du jeu
+
+## Projet d'équipe
+
+Pour travailler en équipe nous allons utiliser gitea (équivalent à github) hosté par Anthony. (juste parce qu'il n'aime pas Microsoft)
+Le projet est donc hosté à [cette addresse](http://git.herisson.ovh/undefined_name/School_Project.git). Il est dans un premier temps privé car d'autre membres de l'école
+sont sur cette instance de gitea et ca serait dommage de leurs donner toutes nos idées!
+
+L'avantage de gitea est que nous pouvons utiliser une vue kanban des issues, ce qui nous permetterais de nous organiser plus facilement et de voir l'avancement
+du projet!
+
+Nous avons également accés à ce Journal de bord à l'addresse (school.debucquoy.me)[http://school.debucquoy.me] sur un nom de domaine appartenant déjà à anthony qui nous
+évide de payer un nouveau nom de domaine dans un premier temps
+
+Ce journal de bord devrais contenir tout les points important du dévelopement du projet ainsi que les rapports des différentes réunions.
+Il nous sera autant utile pour améliorer notre structure et ne pas oublier des points précédament dit que pour les correcteurs voulants "aprécier" notre méthode de travaille
+
+## Idées
+
+Les premières idées du jeu ont pu être trouvée mais ne sont absolument pas fixe et pourrons donc être modifié à volonté lors du dévelopement.
+
+Le but serait de rendre le jeu plus intéréssant en y implémentant une histoire un peut intéréssante. (comme un visual novel)
+L'histoire serait qu'un étudiant sur le point d'emménager dans un nouvel appartement doit donc ranger ses affaire dans un premier temps
+
+Nous aurions donc:
+1) Level 1-10: Rangement des affaires dans des cartons
+2) Level 11-20: Rangement des cartons dans un camion
+3) Level 21-30: Rangement des nouvelles affaires dans un camion
+
+La représenations des pièces se ferait à l'aide d'éléments dans des matrices. Nous devons donc trouver un moyen de sauvegarder les différent niveau.
+
+## Easter Egg
+
+**Attention ne pas lire ce qui suit et passer directement au prochain chapitre pour ne pas être spoiler de ce potentiel easter-egg**
+
+Une idée d'easter-egg que nous pourrions implémenter dans le jeu si nous avons le temps serait de transformer le jeu en Tetris (car les pièces sont trés resemblantes)
+et pour activer cet easter-egg, il faudrait lors des derniers niveau utiliser le bureau à placer d'une certaine manière pas encore définie. comme si nous jouions sur le pc
+du bureau
+
+## Objectif pour la prochaine entre-vue / réunion
+
+Etant donnée que le java n'est pas encore un acquis pour tous, nous allons commencer par des prototypes en python.
+Ces prototypes n'ont pas besoin d'être trés complexe puisque le but est de représenter une seule fonctionnalitée du jeu et
+de le faire bien. ainsi lors du dévelopement on pourrait traduire nos code de python à java en ayant déjà une vision plus aboutie
+du dévelopement
+
+Dans un premier temps donc, nous allons faire des prototypes de parties du jeu chaquns pour soi puis les mettre dans [le dossier prototype](https://git.herisson.ovh/undefined_name/School_Project/src/branch/master/prototypes)
+du repo. Vu que chaques modifications de la master branche du repo doivent être aprouvée par les 3 membres, celà va permettre à chaquns d'entre nous de donner un
+avis constructifs sur les prototypes fait ce qui peut nous permettre de nous améliorer
+

JournalDeBord/src/rapports/200223.md

@@ -0,0 +1,56 @@
+# 20 fevrier 2023
+
+En date **Lundi 20 Février** à eu lieu notre deuxième meeting.
+
+En occasion de cette deuxième rencontre nous avons continué à proposer des idées pour renforcer les bases de ce projet.
+
+## Prototypes
+
+Nous avons commencé par une exposition et analyse des prototypes qui avaient été créé jusqu’à ce jour.
+
+**Prototype Anthony**
+
+Anthony se pose le challenge de réussir à résumer toute les informations du projet et du développement du jeu en très peu d’espace sans perdre des datas .
+
+Le résultat de son travail est un fichier répartie en en tête (SMS) et pied de page 
+(SME) entre ces deux il y stocké les infos suivantes: map size , map data , nombre de pieces , (piece size and data) ; chaque info est un octet .
+
+**prototype Mat**
+
+Mat concentre sont travail sur la création d’un code qui puisse servir de fondements pour notre moteur de jeux .
+
+On y trouve un algorithme pour le choix du niveau et le pick des pieces et une fonction pour tourner les pièce à l’aide du module rotate_matrix , tout ça à l’intérieur d’une boucle while qui permet de run le jeu temps que la condition est respectée.
+
+## Brainstorming
+
+En un deuxième moment on est passé à un brainstorming pour trouver des nouvelles idées concernat le moteur de jeu:
+
+- piece ~> objects avec des attributes communs 
+
+- attributes 
+    - tourner 
+    - lock
+    - léger 
+    - lourd (les objects lourd écrasent les légères)
+
+- selection objects
+    - vibrations objects 
+
+- chois du teme (histoire)
+    - étudiant qui déménage 
+
+- objects en general
+    - game logic ~>
+        - menu
+        - jeux > map(shape) > pieces(formes et propriétés)
+
+En dernier on à apportè des modifications sur notre serveur git pour améliorer l’organisation du travail :
+
+- cration du gradle
+
+- creation d’un 'ideas' 
+(à faire après les to do)
+
+## Directives pour le prochain meeting
+
+Pour le prochain meeting on créera des nouveaux prototypes et on pensera à des manières pour accéder aux images et au sons , multimédias du jeu.

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

@@ -0,0 +1,41 @@
+/*
+ * This file was generated by the Gradle 'init' task.
+ *
+ * This generated file contains a sample Java application project to get you started.
+ * For more details take a look at the 'Building Java & JVM projects' chapter in the Gradle
+ * User Manual available at https://docs.gradle.org/8.0/userguide/building_java_projects.html
+ */
+
+plugins {
+    // Apply the application plugin to add support for building a CLI application in Java.
+    id 'application'
+    id 'org.openjfx.javafxplugin' version '0.0.13'
+}
+
+repositories {
+    // Use Maven Central for resolving dependencies.
+    mavenCentral()
+}
+
+dependencies {
+    // Use JUnit Jupiter for testing.
+    testImplementation 'org.junit.jupiter:junit-jupiter:5.9.1'
+
+    // This dependency is used by the application.
+    implementation 'com.google.guava:guava:31.1-jre'
+}
+
+application {
+    // Define the main class for the application.
+    mainClass = 'school_project.Controller'
+}
+
+javafx {
+    version = "19"
+    modules = [ 'javafx.controls' ]
+}
+
+tasks.named('test') {
+    // Use JUnit Platform for unit tests.
+    useJUnitPlatform()
+}

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

@@ -0,0 +1,32 @@
+/*
+ * 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.Scene;
+import javafx.scene.control.Button;
+import javafx.stage.Stage;
+
+public class Controller extends Application {
+
+    @Override
+    public void start(Stage primaryStage) throws Exception {
+        primaryStage.setTitle("test");
+        Button btn = new Button("test");
+        btn.setOnAction(event -> System.out.println("hey"));
+
+        Group root = new Group();
+        root.getChildren().add(btn);
+
+        Scene scene = new Scene(root, 300,300);
+        primaryStage.setScene(scene);
+
+        primaryStage.show();
+    }
+
+    public static void main(String[] args) {
+       launch();
+    }
+}

app/src/test/java/school_project/AppTest.java

@@ -0,0 +1,12 @@
+/*
+ * This Java source file was generated by the Gradle 'init' task.
+ */
+package school_project;
+
+import org.junit.jupiter.api.Test;
+
+class AppTest {
+    @Test void appHasAGreeting() {
+        Controller classUnderTest = new Controller();
+    }
+}

gradle/wrapper/gradle-wrapper.properties

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

gradlew

@@ -0,0 +1,244 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+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 
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC3045 
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -0,0 +1,92 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if %ERRORLEVEL% equ 0 goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

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/saves_prototypes/README

@@ -0,0 +1,35 @@
+# Prototypes Saves files
+
+This prototype is aiming at defining a structure for saving "map" files.
+
+The objective is to have it quite modular so that if we want to add more level we can easily do so.
+
+Another objective is that theses files are as small as possible without missing information.
+
+## What needs to be saved
+
+We need to have the shape of the map itself and the shape and number of each pieces it is a minimum
+
+I also want to define an header (and maybe a footer) to the file so that it is easier to recover if any corruption occure to a drive
+(we all been trough that)
+
+## Method
+
+I would like to save a file as byte so I need to have a bitewise parser. This is the objective of this prototype
+
+## Structure
+
+The map file should have the following structure:
+- The file should be named <map_name>.shmap (where shmap stand for shape map)
+- The file should start with the ascii characters S, M then S (0x534D53)
+- The file should end with the ascii characters S, M then E (0x534D45)
+- First we define the map shape
+    1) the map should always be a square. the lenght of this square will be the first octet after the header.
+    2) next we have s x s (where s is the size of the square) bits (1/0) where
+        - 0 represent an empty cell (where we can place a shape)
+        - 1 represent a filled cell (where we can't place a shape)
+- Next we define the amount of shape for this level with a number on one octet
+- Next we define each shapes with the same method defined previously for a map
+
+With all that we should have all that is needed for a level to work... further information could be added later this is just a prototype atm
+

prototypes/saves_prototypes/parser.py

@@ -0,0 +1,197 @@
+#!/bin/python
+import os
+
+
+class MapNotSquareException(Exception):
+    """
+    Matrix used is not a Square and cannot be interpretted as a piece
+    """
+
+
+class PieceNotSquareException(Exception):
+    """
+    Matrix used is not a Square and cannot be interpretted as a piece
+    """
+
+
+class SaveParser:
+    """
+    Parser for the game file
+    """
+    def __init__(self):
+        self.map_shape = [[0]]
+        self.pieces = []
+
+    def define_map(self, map_shape):
+        size = len(map_shape)
+        for row in map_shape:
+            if size != len(row):
+                raise MapNotSquareException
+        self.map_shape = map_shape
+
+    def add_piece(self, piece_shape):
+        size = len(piece_shape)
+        for row in piece_shape:
+            if size != len(row):
+                raise PieceNotSquareException
+        self.pieces.append(piece_shape)
+
+    def __str__(self):
+        return str(self.map_shape)
+
+    def shape_to_bytes(self, shape_matrix):
+        shape_list = [b for r in shape_matrix for b in r]
+        byte_ammount = len(shape_list) // 8 + 1
+        tray = 0
+        for i in shape_list:
+            tray = (tray << 1) | i
+        return tray.to_bytes(byte_ammount, 'big')
+
+    def bytes_to_shape(self, bytes_list, map_size):
+        list_octet = []
+        for octet in bytes_list:
+            octet_data = list(f"{octet:08b}")
+            [list_octet.append(d) for d in octet_data]
+        list_octet = list_octet[-(map_size**2):]
+
+        matrix = []
+        for i in range(map_size):
+            matrix.append([])
+            for j in range(map_size):
+                matrix[i].append(list_octet.pop(0))
+        return matrix
+
+    def load(self, filename):
+        """
+        load the file and prepare to parse informations
+        """
+        with open(filename, mode='br') as file:
+            data = list(file.read())
+
+            data_pos = [0, 0]
+            for i in range(len(data)):
+                if data[i] == 83 and data[i+1] == 77 and data[i+2] == 83:  # SMS
+                    data_pos[0] = i+3
+                    break
+            for i in range(data_pos[0], len(data)):
+                if data[i] == 83 and data[i+1] == 77 and data[i+2] == 69:  # SME
+                    data_pos[1] = i
+                    break
+            map_data = data[data_pos[0]:data_pos[1]]
+            self.define_map(self.bytes_to_shape(map_data[1:((map_data[0]**2)//8)+2], map_data[0]))
+            map_data = map_data[(map_data[0]**2) // 8 + 2:]
+            pieces_ammount = map_data.pop(0)
+            for i in range(pieces_ammount):
+                print(map_data)
+                piece_size = map_data.pop(0)
+                print(piece_size)
+                piece_data = map_data[:(piece_size**2) // 8 + 1]
+                print(piece_data)
+                map_data = map_data[(map_data[0]**2) // 8 + 2:]
+                print(map_data)
+                self.add_piece(self.bytes_to_shape(piece_data, piece_size))
+
+    def save(self, filename):
+        """
+        save parsed info to the file
+        """
+        save_data = b''
+        save_data += b'SMS'
+        save_data += len(self.map_shape).to_bytes(1, 'big')
+        save_data += self.shape_to_bytes(self.map_shape)
+        save_data += len(self.pieces).to_bytes(1, 'big')
+        for piece in self.pieces:
+            save_data += len(piece).to_bytes(1, 'big')
+            save_data += self.shape_to_bytes(piece)
+        save_data += b'SME'
+        with open(filename, mode='bw') as file:
+            file.write(save_data)
+
+
+def show_matrix(matrix, highlight: tuple = None):
+    """
+    :matrix: matrix to draw
+    :highlight: tuple of the coordinates to hightligh
+    """
+    size = len(matrix)
+    h_x, h_y = None, None
+    if highlight:
+        h_x, h_y = highlight
+    if size != len(matrix[0]):
+        print("ERROR: The matrix is not square")
+        return
+
+    line_str = "+" + ''.join(['-+' for _ in range(size)])
+
+    for k, x in enumerate(matrix):
+        print(line_str)
+        print('|', end="")
+        for l, y in enumerate(x):
+            if k == h_x and l == h_y:
+                print("\033[42m", end="")
+            print(str(y) + "\033[00m" + '|', end="")
+        print()
+    print(line_str)
+
+
+def cls():
+    'clear the screen'
+    for _ in range(os.get_terminal_size()[1]):
+        print()
+
+
+def menu(P):
+    """draw a simple menu to test the SaveParser class"""
+
+    print("1) define terrain")
+    print("2) add a piece")
+    print("3) show data")
+    print("4) save data")
+    print("5) load data")
+    print("6) quit")
+    item = int(input("Select an option :"))
+    cls()
+    match item:
+        case 1:
+            size = int(input("what is the size of the map: "))
+            P.map_shape = [[0 for _ in range(size)] for _ in range(size)]
+            for i in range(size):
+                for j in range(size):
+                    cls()
+                    show_matrix(P.map_shape, (i,j))
+                    P.map_shape[i][j] = int(input("0: empty; 1: filled :"))
+        case 2:
+            size = int(input("what is the size of the piece: "))
+            temp = [[0 for _ in range(size)] for _ in range(size)]
+            for i in range(size):
+                for j in range(size):
+                    cls()
+                    show_matrix(temp, (i,j))
+                    temp[i][j] = int(input("0: empty; 1: filled :"))
+            P.add_piece(temp)
+        case 3:
+            if P.map_shape:
+                print("map:")
+                show_matrix(P.map_shape)
+                for i, v in enumerate(P.pieces):
+                    print()
+                    print(f"piece {i+1}")
+                    show_matrix(v)
+        case 4:
+            filename = input('enter the file name (default: default.smap):')
+            filename = filename if filename else "default.smap"
+            P.save(filename)
+        case 5:
+            filename = input('enter the file name (default: default.smap):')
+            filename = filename if filename else "default.smap"
+            P.load(filename)
+        case 6:
+            return False
+    return True
+
+
+if __name__ == "__main__":
+    cls()
+    P = SaveParser()
+    while menu(P):
+        pass

settings.gradle

@@ -0,0 +1,11 @@
+/*
+ * This file was generated by the Gradle 'init' task.
+ *
+ * The settings file is used to specify which projects to include in your build.
+ *
+ * Detailed information about configuring a multi-project build in Gradle can be found
+ * in the user manual at https://docs.gradle.org/8.0/userguide/multi_project_builds.html
+ */
+
+rootProject.name = 'School_Project'
+include('app')