diff --git a/Partie_3/.vscode/settings.json b/Partie_3/.vscode/settings.json
index 3e5eb956e1aac2b053a4d09e761fcc26bb2b106e..1152b26c4f7b3e09717bc55acb4ffa24c81ecc42 100644
--- a/Partie_3/.vscode/settings.json
+++ b/Partie_3/.vscode/settings.json
@@ -55,5 +55,6 @@
   "C_Cpp_Runner.useLeakSanitizer": false,
   "C_Cpp_Runner.showCompilationTime": false,
   "C_Cpp_Runner.useLinkTimeOptimization": false,
-  "C_Cpp_Runner.msvcSecureNoWarnings": false
+  "C_Cpp_Runner.msvcSecureNoWarnings": false,
+  "java.configuration.updateBuildConfiguration": "interactive"
 }
\ No newline at end of file
diff --git a/Partie_3/pom.xml b/Partie_3/pom.xml
index 7cb8921635687777cf25035757163633f56ebad6..a8dc63e3d7322b47fbfe43c3739f9655dca1814a 100644
--- a/Partie_3/pom.xml
+++ b/Partie_3/pom.xml
@@ -19,7 +19,13 @@
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
-            <version>4.11</version>
+            <version>4.13.2</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-engine</artifactId>
+            <version>5.9.1</version>
             <scope>test</scope>
         </dependency>
         <dependency>
@@ -27,6 +33,11 @@
             <artifactId>javafx-controls</artifactId>
             <version>19</version>
         </dependency>
+        <dependency>
+            <groupId>com.opencsv</groupId>
+            <artifactId>opencsv</artifactId>
+            <version>5.9</version>
+        </dependency>
     </dependencies>
 
     <build>
diff --git a/Partie_3/save.csv b/Partie_3/save.csv
new file mode 100644
index 0000000000000000000000000000000000000000..f481abffdbc7df4d1718d6dcc2639b0a4f25b9de
--- /dev/null
+++ b/Partie_3/save.csv
@@ -0,0 +1,3 @@
+Human,100.0,0
+Player_1,190.0,1
+Player_2,305.0,1
diff --git a/Partie_3/src/main/java/ch/hepia/App.java b/Partie_3/src/main/java/ch/hepia/App.java
index eeac9451b948fbdd7753195b64a4da5cc81fed51..b99e87fcaf53d954cec2092e1548f78da9934187 100644
--- a/Partie_3/src/main/java/ch/hepia/App.java
+++ b/Partie_3/src/main/java/ch/hepia/App.java
@@ -1,5 +1,6 @@
 package ch.hepia;
 
+import java.io.File;
 import java.util.Scanner;
 
 public class App {
@@ -28,83 +29,124 @@ public class App {
         int numPlayers;
         int startMoney;
         int computerStrategy = 1;
+        boolean loadSave = false;
+        String filePath = "save.csv";
 
-        // Ask the number of players until a valide answer is given
-        while (true) {
+        File f = new File(filePath);
 
-            System.out.print("How many players ? ");
+        // Check if a save file exists
+        if (f.exists() && !f.isDirectory()) {
 
-            // Check that the input is an valid int
-            while (!App.in.hasNextInt()) {
-                System.out.println(
-                        App.ANSI_YELLOW + "Please enter a valid number for the number of players." + App.ANSI_RESET);
-                System.out.print("How many players ? ");
-                App.in.next();
-            }
+            char choice = 'x';
+
+            System.out.print("Do you want to load last game save (y/n) ? ");
+
+            while (true) {
 
-            numPlayers = App.in.nextInt();
+                choice = App.in.next().charAt(0);
+
+                // Choices are checked with available one for confirmation
+                if (choice == 'y' || choice == 'n') {
+                    break;
+                } else {
+                    System.out.println(App.ANSI_YELLOW + "Please enter a valid choice." + App.ANSI_RESET);
+                }
+            }
 
-            // Player count must be between 1 and 7
-            if (numPlayers >= 1 && numPlayers <= 7) {
-                System.out.print("");
-                break;
-            } else {
-                System.out.println(
-                        App.ANSI_YELLOW + "Please enter a number of players between 1 and 7." + App.ANSI_RESET);
+            if (choice == 'y') {
+                loadSave = true;
             }
         }
 
-        // Ask the start money count for each players until a valide answer is given
-        while (true) {
+        GameManager BlackJack;
 
-            System.out.print("How much money do you start with ? ");
+        if (loadSave) {
 
-            // Check that the input is an valid int
-            while (!App.in.hasNextInt()) {
-                System.out.println(App.ANSI_YELLOW + "Please enter a valid number for your Money." + App.ANSI_RESET);
-                System.out.print("How much money do you start with ? ");
-                App.in.next();
-            }
+            // Load save to create game
+            Save Game = new Save();
+
+            BlackJack = new GameManager(Game.loadMoney(), Game.loadStrategy());
+
+        } else {
+            // Ask the number of players until a valide answer is given
+            while (true) {
 
-            startMoney = App.in.nextInt();
+                System.out.print("How many players ? ");
 
-            // Starting money must be more or equal to minimum bid amount
-            if (startMoney >= 10) {
-                System.out.print("");
-                break;
-            } else {
-                System.out.println(App.ANSI_YELLOW + "Please enter an amount above 10." + App.ANSI_RESET);
+                // Check that the input is an valid int
+                while (!App.in.hasNextInt()) {
+                    System.out.println(
+                            App.ANSI_YELLOW + "Please enter a valid number for the number of players."
+                                    + App.ANSI_RESET);
+                    System.out.print("How many players ? ");
+                    App.in.next();
+                }
+
+                numPlayers = App.in.nextInt();
+
+                // Player count must be between 1 and 7
+                if (numPlayers >= 1 && numPlayers <= 7) {
+                    System.out.print("");
+                    break;
+                } else {
+                    System.out.println(
+                            App.ANSI_YELLOW + "Please enter a number of players between 1 and 7." + App.ANSI_RESET);
+                }
             }
-        }
 
-        // Ask if the Computer players should be smart of not
-        if (numPlayers > 1) {
+            // Ask the start money count for each players until a valide answer is given
             while (true) {
 
-                System.out.print("Should the Compter players be [1] Smart or [2] Stupid ? ");
+                System.out.print("How much money do you start with ? ");
 
                 // Check that the input is an valid int
                 while (!App.in.hasNextInt()) {
                     System.out
-                            .println(App.ANSI_YELLOW + "Please enter a valid choice." + App.ANSI_RESET);
-                    System.out.print("Should the Compter players be [1] Smart or [2] Stupid ? ");
+                            .println(App.ANSI_YELLOW + "Please enter a valid number for your Money." + App.ANSI_RESET);
+                    System.out.print("How much money do you start with ? ");
                     App.in.next();
                 }
 
-                computerStrategy = App.in.nextInt();
+                startMoney = App.in.nextInt();
 
-                // Check if the value i s valide
-                if (computerStrategy == 1 || computerStrategy == 2) {
+                // Starting money must be more or equal to minimum bid amount
+                if (startMoney >= 10) {
                     System.out.print("");
                     break;
                 } else {
-                    System.out.println(App.ANSI_YELLOW + "Please enter a valid choice." + App.ANSI_RESET);
+                    System.out.println(App.ANSI_YELLOW + "Please enter an amount above 10." + App.ANSI_RESET);
                 }
             }
-        }
 
-        // Create a new game
-        GameManager BlackJack = new GameManager(numPlayers, startMoney, computerStrategy);
+            // Ask if the Computer players should be smart of not
+            if (numPlayers > 1) {
+                while (true) {
+
+                    System.out.print("Should the Compter players be [1] Smart or [2] Stupid ? ");
+
+                    // Check that the input is an valid int
+                    while (!App.in.hasNextInt()) {
+                        System.out
+                                .println(App.ANSI_YELLOW + "Please enter a valid choice." + App.ANSI_RESET);
+                        System.out.print("Should the Compter players be [1] Smart or [2] Stupid ? ");
+                        App.in.next();
+                    }
+
+                    computerStrategy = App.in.nextInt();
+
+                    // Check if the value i s valide
+                    if (computerStrategy == 1 || computerStrategy == 2) {
+                        System.out.print("");
+                        break;
+                    } else {
+                        System.out.println(App.ANSI_YELLOW + "Please enter a valid choice." + App.ANSI_RESET);
+                    }
+                }
+            }
+
+            // Create a new game
+            BlackJack = new GameManager(numPlayers, startMoney, computerStrategy);
+        }
 
         boolean GameOver = false;
 
diff --git a/Partie_3/src/main/java/ch/hepia/GameManager.java b/Partie_3/src/main/java/ch/hepia/GameManager.java
index e5ce28379105e6514d69a11921c226f257d41b25..2cc3940f7e6485114af15f378c94242b079d1859 100644
--- a/Partie_3/src/main/java/ch/hepia/GameManager.java
+++ b/Partie_3/src/main/java/ch/hepia/GameManager.java
@@ -33,6 +33,29 @@ public class GameManager {
         this.Dealer = new JoueurCroupier(Deck);
     }
 
+    public GameManager(ArrayList<Double> Money, ArrayList<Integer> Strategy) {
+
+        // Create a new BlackJack Deck of card (6 x 52 cards game)
+        this.Deck = new JeudeCarte(new Paquet(6, 52));
+
+        this.Players = new ArrayList<>();
+
+        // First Player is always the humain
+        this.Players.add(new JoueurHumain(Deck, Money.get(0)));
+
+        this.ComputerPlayers = 0;
+
+        // All other are controlled by the computer
+        if (Money.size() > 1) {
+            for (int x = 1; x < Money.size(); x++) {
+                ComputerPlayers++;
+                this.Players.add(new JoueurOrdinateur(Deck, Money.get(x), Strategy.get(x)));
+            }
+        }
+
+        this.Dealer = new JoueurCroupier(Deck);
+    }
+
     // Phase 1 (StartTurn):
     // Ask the player how much he wan't to bid
     public void StartTurn() {
@@ -308,6 +331,199 @@ public class GameManager {
              */
             if (this.Players.get(x).GetStrategy() == 1) {
 
+                char[][][] Choices_2Cards = {
+                        {
+                                { 'S', 'T', 'T', 'T', 'T', 'T', 'T', 'R', 'R', 'R' },
+                                { 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'T' },
+                                { 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'T' },
+                                { 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'T' },
+                                { 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'T' },
+                                { 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'R' },
+                                { 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'R', 'R' },
+                                { 'R', 'T', 'T', 'T', 'T', 'T', 'T', 'S', 'R', 'R' },
+                                { 'R', 'T', 'T', 'T', 'T', 'T', 'R', 'R', 'R', 'R' },
+                                { 'R', 'T', 'T', 'T', 'T', 'R', 'R', 'R', 'R', 'R' },
+                        },
+                        {
+                                { 'S', 'T', 'T', 'T', 'T', 'T', 'R', 'R', 'R', 'R' },
+                                { 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'T' },
+                                { 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'R' },
+                                { 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'R', 'R' },
+                                { 'T', 'T', 'T', 'T', 'D', 'T', 'T', 'R', 'R', 'R' },
+                                { 'T', 'T', 'T', 'T', 'T', 'T', 'R', 'R', 'R', 'R' },
+                                { 'R', 'T', 'T', 'T', 'T', 'R', 'S', 'R', 'R', 'R' },
+                                { 'R', 'T', 'T', 'T', 'R', 'R', 'R', 'S', 'R', 'R' },
+                                { 'R', 'T', 'T', 'R', 'R', 'R', 'R', 'R', 'S', 'R' },
+                                { 'R', 'T', 'R', 'R', 'R', 'R', 'R', 'R', 'R', 'R' },
+                        },
+                        {
+                                { 'S', 'T', 'T', 'T', 'T', 'D', 'D', 'R', 'R', 'R' },
+                                { 'T', 'T', 'T', 'T', 'T', 'T', 'D', 'D', 'D', 'T' },
+                                { 'T', 'T', 'T', 'T', 'T', 'D', 'D', 'D', 'T', 'R' },
+                                { 'T', 'T', 'T', 'T', 'D', 'D', 'D', 'T', 'R', 'R' },
+                                { 'T', 'T', 'T', 'D', 'D', 'D', 'T', 'R', 'R', 'R' },
+                                { 'D', 'T', 'D', 'D', 'D', 'S', 'R', 'R', 'R', 'R' },
+                                { 'D', 'D', 'D', 'D', 'T', 'R', 'S', 'R', 'R', 'R' },
+                                { 'R', 'D', 'D', 'T', 'R', 'R', 'R', 'S', 'R', 'R' },
+                                { 'R', 'D', 'T', 'R', 'R', 'R', 'R', 'R', 'S', 'R' },
+                                { 'R', 'T', 'R', 'R', 'R', 'R', 'R', 'R', 'R', 'R' },
+                        },
+                        {
+                                { 'S', 'T', 'T', 'D', 'D', 'D', 'D', 'R', 'R', 'R' },
+                                { 'T', 'S', 'T', 'T', 'T', 'T', 'D', 'D', 'D', 'R' },
+                                { 'T', 'T', 'S', 'T', 'T', 'D', 'D', 'D', 'R', 'R' },
+                                { 'D', 'T', 'T', 'T', 'D', 'D', 'D', 'R', 'R', 'R' },
+                                { 'D', 'T', 'T', 'D', 'D', 'D', 'R', 'R', 'R', 'R' },
+                                { 'D', 'T', 'D', 'D', 'D', 'S', 'R', 'R', 'R', 'R' },
+                                { 'D', 'D', 'D', 'D', 'R', 'R', 'S', 'R', 'R', 'R' },
+                                { 'R', 'D', 'D', 'R', 'R', 'R', 'R', 'S', 'R', 'R' },
+                                { 'R', 'D', 'R', 'R', 'R', 'R', 'R', 'R', 'S', 'R' },
+                                { 'R', 'R', 'R', 'R', 'R', 'R', 'R', 'R', 'R', 'R' },
+                        },
+                        {
+                                { 'S', 'D', 'D', 'D', 'D', 'D', 'D', 'R', 'R', 'R' },
+                                { 'D', 'S', 'T', 'T', 'T', 'T', 'D', 'D', 'D', 'R' },
+                                { 'D', 'T', 'S', 'T', 'T', 'D', 'D', 'D', 'R', 'R' },
+                                { 'D', 'T', 'T', 'T', 'D', 'D', 'D', 'R', 'R', 'R' },
+                                { 'D', 'T', 'T', 'D', 'D', 'D', 'R', 'R', 'R', 'R' },
+                                { 'D', 'T', 'D', 'D', 'D', 'S', 'R', 'R', 'R', 'R' },
+                                { 'D', 'D', 'D', 'D', 'R', 'R', 'S', 'R', 'R', 'R' },
+                                { 'R', 'D', 'D', 'R', 'R', 'R', 'R', 'S', 'R', 'R' },
+                                { 'R', 'D', 'R', 'R', 'R', 'R', 'R', 'R', 'S', 'R' },
+                                { 'R', 'R', 'R', 'R', 'R', 'R', 'R', 'R', 'R', 'R' },
+                        },
+                        {
+                                { 'S', 'D', 'D', 'D', 'D', 'D', 'D', 'R', 'R', 'R' },
+                                { 'D', 'S', 'T', 'T', 'T', 'T', 'D', 'D', 'D', 'R' },
+                                { 'D', 'T', 'S', 'T', 'T', 'D', 'D', 'D', 'R', 'R' },
+                                { 'D', 'T', 'T', 'T', 'D', 'D', 'D', 'R', 'R', 'R' },
+                                { 'D', 'T', 'T', 'D', 'D', 'D', 'R', 'R', 'R', 'R' },
+                                { 'D', 'T', 'D', 'D', 'D', 'S', 'R', 'R', 'R', 'R' },
+                                { 'D', 'D', 'D', 'D', 'R', 'R', 'S', 'R', 'R', 'R' },
+                                { 'R', 'D', 'D', 'R', 'R', 'R', 'R', 'S', 'R', 'R' },
+                                { 'R', 'D', 'R', 'R', 'R', 'R', 'R', 'R', 'S', 'R' },
+                                { 'R', 'R', 'R', 'R', 'R', 'R', 'R', 'R', 'R', 'R' },
+                        },
+                        {
+                                { 'S', 'T', 'T', 'T', 'T', 'T', 'R', 'R', 'R', 'R' },
+                                { 'T', 'S', 'T', 'T', 'T', 'T', 'T', 'D', 'D', 'T' },
+                                { 'T', 'T', 'S', 'T', 'T', 'T', 'D', 'D', 'T', 'T' },
+                                { 'T', 'T', 'T', 'T', 'T', 'D', 'D', 'T', 'T', 'T' },
+                                { 'T', 'T', 'T', 'T', 'D', 'D', 'T', 'T', 'T', 'T' },
+                                { 'T', 'T', 'T', 'D', 'D', 'T', 'T', 'T', 'T', 'T' },
+                                { 'R', 'T', 'D', 'D', 'T', 'T', 'S', 'T', 'T', 'R' },
+                                { 'R', 'D', 'D', 'T', 'T', 'T', 'T', 'S', 'R', 'R' },
+                                { 'R', 'D', 'T', 'T', 'T', 'T', 'T', 'R', 'R', 'R' },
+                                { 'R', 'T', 'T', 'T', 'T', 'T', 'R', 'R', 'R', 'R' },
+                        },
+                        {
+                                { 'S', 'T', 'T', 'T', 'T', 'T', 'R', 'R', 'R', 'R' },
+                                { 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'D', 'D', 'T' },
+                                { 'T', 'T', 'T', 'T', 'T', 'T', 'D', 'D', 'T', 'T' },
+                                { 'T', 'T', 'T', 'T', 'T', 'D', 'D', 'T', 'T', 'T' },
+                                { 'T', 'T', 'T', 'T', 'D', 'D', 'T', 'T', 'T', 'T' },
+                                { 'T', 'T', 'T', 'D', 'D', 'T', 'T', 'T', 'T', 'T' },
+                                { 'R', 'T', 'D', 'D', 'T', 'T', 'T', 'T', 'T', 'R' },
+                                { 'R', 'D', 'D', 'T', 'T', 'T', 'T', 'S', 'R', 'R' },
+                                { 'R', 'D', 'T', 'T', 'T', 'T', 'T', 'R', 'S', 'R' },
+                                { 'R', 'T', 'T', 'T', 'T', 'T', 'R', 'R', 'R', 'R' },
+                        },
+                        {
+                                { 'S', 'T', 'T', 'T', 'T', 'T', 'T', 'R', 'R', 'R' },
+                                { 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'D', 'D', 'T' },
+                                { 'T', 'T', 'T', 'T', 'T', 'T', 'D', 'D', 'T', 'T' },
+                                { 'T', 'T', 'T', 'T', 'T', 'D', 'D', 'T', 'T', 'T' },
+                                { 'T', 'T', 'T', 'T', 'D', 'D', 'T', 'T', 'T', 'T' },
+                                { 'T', 'T', 'T', 'D', 'D', 'T', 'T', 'T', 'T', 'R' },
+                                { 'T', 'T', 'D', 'D', 'T', 'T', 'T', 'T', 'R', 'R' },
+                                { 'R', 'D', 'D', 'T', 'T', 'T', 'T', 'S', 'R', 'R' },
+                                { 'R', 'D', 'T', 'T', 'T', 'T', 'R', 'R', 'S', 'R' },
+                                { 'R', 'T', 'T', 'T', 'T', 'R', 'R', 'R', 'R', 'R' },
+                        },
+                        {
+                                { 'S', 'T', 'T', 'T', 'T', 'T', 'T', 'R', 'R', 'R' },
+                                { 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'D', 'T' },
+                                { 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'D', 'T', 'T' },
+                                { 'T', 'T', 'T', 'T', 'T', 'T', 'D', 'T', 'T', 'T' },
+                                { 'T', 'T', 'T', 'T', 'T', 'D', 'T', 'T', 'T', 'R' },
+                                { 'T', 'T', 'T', 'T', 'D', 'T', 'T', 'T', 'R', 'R' },
+                                { 'T', 'T', 'T', 'D', 'T', 'T', 'T', 'R', 'R', 'R' },
+                                { 'R', 'T', 'D', 'T', 'T', 'T', 'R', 'S', 'R', 'R' },
+                                { 'R', 'D', 'T', 'T', 'T', 'R', 'R', 'R', 'R', 'R' },
+                                { 'R', 'T', 'T', 'T', 'R', 'R', 'R', 'R', 'R', 'R' },
+                        }
+                };
+
+                char[][] Choices_MoreThan2Cards = {
+                        { 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'T', 'R', 'R' },
+                        { 'T', 'T', 'D', 'D', 'T', 'R', 'R', 'R', 'R', 'R' },
+                        { 'T', 'D', 'D', 'D', 'T', 'R', 'R', 'R', 'R', 'R' },
+                        { 'T', 'D', 'D', 'D', 'R', 'R', 'R', 'R', 'R', 'R' },
+                        { 'T', 'D', 'D', 'D', 'R', 'R', 'R', 'R', 'R', 'R' },
+                        { 'T', 'D', 'D', 'D', 'R', 'R', 'R', 'R', 'R', 'R' },
+                        { 'T', 'T', 'D', 'D', 'T', 'T', 'T', 'T', 'T', 'R' },
+                        { 'T', 'T', 'D', 'D', 'T', 'T', 'T', 'T', 'T', 'R' },
+                        { 'T', 'T', 'D', 'D', 'T', 'T', 'T', 'T', 'R', 'R' },
+                        { 'T', 'T', 'T', 'D', 'T', 'T', 'T', 'R', 'R', 'R' }
+                };
+
+                char Choice = 'R';
+
+                // Go thew all the hands of the computer player
+                for (int HandNb = 0; HandNb < this.Players.get(x).GetNbHands(); HandNb++) {
+
+                    if (this.Players.get(x).GetNbCards(HandNb) == 2) {
+                        Choice = Choices_2Cards[this.Dealer.GetCardStrength(0, 0) - 1][this.Players.get(x)
+                                .GetCardStrength(HandNb, 0) - 1][this.Players.get(x).GetCardStrength(HandNb, 1) - 1];
+                    } else {
+                        if (this.Players.get(x).GetStrength(HandNb) <= 8) {
+                            Choice = Choices_MoreThan2Cards[this.Dealer.GetCardStrength(0, 0) - 1][0];
+                        } else if (this.Players.get(x).GetStrength(HandNb) == 9) {
+                            Choice = Choices_MoreThan2Cards[this.Dealer.GetCardStrength(0, 0) - 1][1];
+                        } else if (this.Players.get(x).GetStrength(HandNb) == 10) {
+                            Choice = Choices_MoreThan2Cards[this.Dealer.GetCardStrength(0, 0) - 1][2];
+                        } else if (this.Players.get(x).GetStrength(HandNb) == 11) {
+                            Choice = Choices_MoreThan2Cards[this.Dealer.GetCardStrength(0, 0) - 1][3];
+                        } else if (this.Players.get(x).GetStrength(HandNb) == 12) {
+                            Choice = Choices_MoreThan2Cards[this.Dealer.GetCardStrength(0, 0) - 1][4];
+                        } else if (this.Players.get(x).GetStrength(HandNb) == 13) {
+                            Choice = Choices_MoreThan2Cards[this.Dealer.GetCardStrength(0, 0) - 1][5];
+                        } else if (this.Players.get(x).GetStrength(HandNb) == 14) {
+                            Choice = Choices_MoreThan2Cards[this.Dealer.GetCardStrength(0, 0) - 1][6];
+                        } else if (this.Players.get(x).GetStrength(HandNb) == 15) {
+                            Choice = Choices_MoreThan2Cards[this.Dealer.GetCardStrength(0, 0) - 1][7];
+                        } else if (this.Players.get(x).GetStrength(HandNb) == 16) {
+                            Choice = Choices_MoreThan2Cards[this.Dealer.GetCardStrength(0, 0) - 1][8];
+                        } else if (this.Players.get(x).GetStrength(HandNb) >= 17) {
+                            Choice = Choices_MoreThan2Cards[this.Dealer.GetCardStrength(0, 0) - 1][9];
+                        }
+                    }
+
+                    if (Choice == 'T') {
+                        // Draw
+
+                        this.Players.get(x).DrawCard(HandNb, this.Deck);
+                        // Go back 1 hand to stay on the same hand in the for loop
+                        HandNb--;
+
+                    } else if (Choice == 'R') {
+                        // Stay
+
+                    } else if (Choice == 'D') {
+                        // Double
+
+                        this.Players.get(x).Double(HandNb, this.Deck);
+                        // Go back 1 hand to stay on the same hand in the for loop
+                        HandNb--;
+                    } else if (Choice == 'S') {
+                        // Split
+
+                        this.Players.get(x).Split(HandNb, this.Deck);
+                        // Go back 1 hand to stay on the same hand in the for loop
+                        HandNb--;
+                    }
+                }
+
             } else if (this.Players.get(x).GetStrategy() == 2) {
                 while (this.Players.get(x).GetStrength(0) <= 15) {
                     this.Players.get(x).DrawCard(0, this.Deck);
@@ -486,29 +702,51 @@ public class GameManager {
         // Show the final player balance
         System.out.println("\nMoney : " + App.ANSI_BLUE + this.Players.get(0).GetMoney() + App.ANSI_RESET);
 
-        System.out.print("> ");
+        // Show Choices
+        System.out.println("\n--- " + App.ANSI_GREEN + "Choices" + App.ANSI_RESET + " ---\n");
 
-        // Wait for a simple input of the player
-        try {
-            System.in.read();
-        } catch (Exception e) {
-        }
+        System.out.println(App.ANSI_BLUE + "[c]" + App.ANSI_RESET + " Continue");
+        System.out.println(App.ANSI_BLUE + "[s]" + App.ANSI_RESET + " Save & Quit");
 
-        // If the player has less than the minimum bid amount allowed
-        if (this.Players.get(0).GetMoney() <= 10) {
-            return true;
-        }
+        char choice = 'x';
+
+        // Ask for the player choice until a valide one is given
+        while (true) {
+            System.out.print("> ");
 
-        // If more thn 75% of the Deck has been used, reshuffle all cards. In our case:
-        // simply recreate a new deck
-        if (this.Deck.GetNbCards() < 78) {
-            this.Deck = new JeudeCarte(new Paquet(6, 52));
+            choice = App.in.next().charAt(0);
+
+            // Choices are checked with available one for confirmation
+            if (choice == 'c' || choice == 's') {
+                break;
+            } else {
+                System.out.println(App.ANSI_YELLOW + "Please enter a valid choice." + App.ANSI_RESET);
+            }
         }
 
-        // Reset all hands
-        this.Dealer.Reset(this.Deck);
-        for (Joueur Player : this.Players) {
-            Player.Reset(this.Deck);
+        if (choice == 'c') {
+            // If the player has less than the minimum bid amount allowed
+            if (this.Players.get(0).GetMoney() <= 10) {
+                return true;
+            }
+
+            // If more thn 75% of the Deck has been used, reshuffle all cards. In our case:
+            // simply recreate a new deck
+            if (this.Deck.GetNbCards() < 78) {
+                this.Deck = new JeudeCarte(new Paquet(6, 52));
+            }
+
+            // Reset all hands
+            this.Dealer.Reset(this.Deck);
+            for (Joueur Player : this.Players) {
+                Player.Reset(this.Deck);
+            }
+        } else if (choice == 's') {
+
+            Save Game = new Save();
+            Game.save(this.Players, this.ComputerPlayers);
+
+            return true;
         }
 
         return false;
diff --git a/Partie_3/src/main/java/ch/hepia/Joueur.java b/Partie_3/src/main/java/ch/hepia/Joueur.java
index 036088f0018e7dab3436092c2cccd8948734adb2..e69d341308e200397ff706a20aab3267e9d0019c 100644
--- a/Partie_3/src/main/java/ch/hepia/Joueur.java
+++ b/Partie_3/src/main/java/ch/hepia/Joueur.java
@@ -79,7 +79,7 @@ class JoueurHumain implements Joueur {
     private double Insurance;
     private boolean Insured;
 
-    public JoueurHumain(JeudeCarte Jeu, int Money) {
+    public JoueurHumain(JeudeCarte Jeu, double Money) {
 
         this.Hands = new ArrayList<>();
 
@@ -342,7 +342,7 @@ class JoueurOrdinateur implements Joueur {
      */
     private int Strategy;
 
-    public JoueurOrdinateur(JeudeCarte Jeu, int Money, int Strategy) {
+    public JoueurOrdinateur(JeudeCarte Jeu, double Money, int Strategy) {
 
         this.Hands = new ArrayList<>();
 
@@ -354,6 +354,7 @@ class JoueurOrdinateur implements Joueur {
         this.Money = Money;
         this.Insurance = 0;
         this.Insured = false;
+
         this.Strategy = Strategy;
     }
 
diff --git a/Partie_3/src/main/java/ch/hepia/Save.java b/Partie_3/src/main/java/ch/hepia/Save.java
new file mode 100644
index 0000000000000000000000000000000000000000..d66eaa2917f5d6490e862edd6cc920a6ecb9043b
--- /dev/null
+++ b/Partie_3/src/main/java/ch/hepia/Save.java
@@ -0,0 +1,100 @@
+package ch.hepia;
+
+import com.opencsv.CSVWriter;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.List;
+
+public class Save {
+
+    public void save(ArrayList<Joueur> Players, int ComputerPlayers) {
+
+        String filePath = "save.csv";
+
+        File file = new File(filePath);
+
+        try {
+            // Create FileWriter object
+            FileWriter outputfile = new FileWriter(file);
+
+            // Create CSVWriter object filewriter
+            CSVWriter writer = new CSVWriter(outputfile, ',',
+                    CSVWriter.NO_QUOTE_CHARACTER,
+                    CSVWriter.DEFAULT_ESCAPE_CHARACTER,
+                    CSVWriter.DEFAULT_LINE_END);
+
+            String[] data = { "Human", Double.toString(Players.get(0).GetMoney()), "0" };
+
+            writer.writeNext(data);
+
+            for (int x = 1; x <= ComputerPlayers; x++) {
+
+                data[0] = "Player_" + x;
+                data[1] = Double.toString(Players.get(x).GetMoney());
+                data[2] = Integer.toString(Players.get(x).GetStrategy());
+
+                writer.writeNext(data);
+            }
+
+            // Closing writer connection
+            writer.close();
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+    }
+
+    public ArrayList<Double> loadMoney() {
+
+        File file = new File("save.csv");
+
+        ArrayList<Double> Money = new ArrayList<>();
+
+        try {
+
+            List<String> lines = Files.readAllLines(file.toPath(), StandardCharsets.UTF_8);
+
+            for (String string : lines) {
+
+                String[] array = string.split(",");
+
+                Money.add(Double.valueOf(array[1]));
+            }
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        return Money;
+    }
+
+    public ArrayList<Integer> loadStrategy() {
+
+        File file = new File("save.csv");
+
+        ArrayList<Integer> Strategy = new ArrayList<>();
+
+        try {
+
+            List<String> lines = Files.readAllLines(file.toPath(), StandardCharsets.UTF_8);
+
+            for (String string : lines) {
+
+                String[] array = string.split(",");
+
+                Strategy.add(Integer.valueOf(array[2]));
+            }
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        return Strategy;
+    }
+}
diff --git a/Partie_3/src/test/java/ch/hepia/CarteTest.java b/Partie_3/src/test/java/ch/hepia/CarteTest.java
deleted file mode 100644
index f1ac133fe7f7a24190d80d303fd27399edda526f..0000000000000000000000000000000000000000
--- a/Partie_3/src/test/java/ch/hepia/CarteTest.java
+++ /dev/null
@@ -1,49 +0,0 @@
-package ch.hepia;
-
-import static org.junit.Assert.assertEquals;
-import org.junit.Test;
-
-public class CarteTest {
-
-    @Test
-    public void testGetCouleur() {
-        Carte carte = new Carte(COULEUR.coeur, 2);
-        assertEquals(COULEUR.coeur, carte.getCouleur());
-    }
-
-    @Test
-    public void testGetRang() {
-        Carte carte = new Carte(COULEUR.carreau, 7);
-        assertEquals(7, carte.getRang());
-    }
-
-    @Test
-    public void testGetForce() {
-        Carte carte = new Carte(COULEUR.trefle, 12, 10);
-        assertEquals(10, carte.getForce());
-    }
-
-    @Test
-    public void testGetNomCouleur() {
-        Carte carte = new Carte(COULEUR.coeur, 0);
-        assertEquals("Coeur", carte.getNomCouleur());
-    }
-
-    @Test
-    public void testGetNomRang() {
-        Carte carte = new Carte(COULEUR.coeur, 2);
-        assertEquals("2", carte.getNomRang());
-    }
-
-    @Test
-    public void testGetNomComplet() {
-        Carte carte = new Carte(COULEUR.carreau, 12);
-        assertEquals("Dame de Carreau", carte.getNomComplet());
-    }
-
-    @Test
-    public void testGetNomComplet_2() {
-        Carte carte = new Carte(COULEUR.carreau, 0);
-        assertEquals("Joker", carte.getNomComplet());
-    }
-}
\ No newline at end of file
diff --git a/Partie_3/src/test/java/ch/hepia/JoueurTest.java b/Partie_3/src/test/java/ch/hepia/JoueurTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..836b221b5da855987b44520d0ab78f2c53aad800
--- /dev/null
+++ b/Partie_3/src/test/java/ch/hepia/JoueurTest.java
@@ -0,0 +1,302 @@
+package ch.hepia;
+
+import static org.junit.Assert.*;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+
+import org.junit.Test;
+
+public class JoueurTest {
+
+    @Test
+    public void testAddMoney() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(6, 52));
+        JoueurHumain joueur = new JoueurHumain(Deck, 0);
+        joueur.AddMoney(100);
+
+        assertEquals(100, joueur.GetMoney(), 0);
+    }
+
+    @Test
+    public void testAddZeroMoney() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(6, 52));
+        JoueurHumain joueur = new JoueurHumain(Deck, 0);
+        joueur.AddMoney(0);
+
+        assertEquals(0, joueur.GetMoney(), 0);
+    }
+
+    @Test
+    public void testAddNegativeMoney() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(6, 52));
+        JoueurHumain joueur = new JoueurHumain(Deck, 0);
+
+        assertThrows(RuntimeException.class, () -> joueur.AddMoney(-50));
+    }
+
+    @Test
+    public void testRemoveMoney() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(6, 52));
+        JoueurHumain joueur = new JoueurHumain(Deck, 100);
+        joueur.RemoveMoney(10);
+
+        assertEquals(90, joueur.GetMoney(), 0);
+    }
+
+    @Test
+    public void testRemoveZeroMoney() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(6, 52));
+        JoueurHumain joueur = new JoueurHumain(Deck, 0);
+        joueur.RemoveMoney(0);
+
+        assertEquals(0, joueur.GetMoney(), 0);
+    }
+
+    @Test
+    public void testRemoveNegativeMoney() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(6, 52));
+        JoueurHumain joueur = new JoueurHumain(Deck, 100);
+
+        assertThrows(RuntimeException.class, () -> joueur.RemoveMoney(-50));
+    }
+
+    @Test
+    public void testAddBet() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(6, 52));
+        JoueurHumain joueur = new JoueurHumain(Deck, 100);
+        joueur.SetBet(10, 0);
+
+        assertEquals(10, joueur.GetBet(0), 0);
+    }
+
+    @Test
+    public void testAddNegativeBet() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(6, 52));
+        JoueurHumain joueur = new JoueurHumain(Deck, 100);
+
+        assertThrows(RuntimeException.class, () -> joueur.SetBet(-10, 0));
+    }
+
+    @Test
+    public void testAddTooBigBet() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(6, 52));
+        JoueurHumain joueur = new JoueurHumain(Deck, 100);
+
+        assertThrows(RuntimeException.class, () -> joueur.SetBet(101, 0));
+    }
+
+    @Test
+    public void testAddBetWrongHand() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(6, 52));
+        JoueurHumain joueur = new JoueurHumain(Deck, 100);
+
+        assertThrows(RuntimeException.class, () -> joueur.SetBet(1, 1));
+    }
+
+    @Test
+    public void testGetBetWrongHand() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(6, 52));
+        JoueurHumain joueur = new JoueurHumain(Deck, 100);
+        joueur.SetBet(10, 0);
+
+        assertThrows(RuntimeException.class, () -> joueur.GetBet(1));
+    }
+
+    @Test
+    public void testDrawCard() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(6, 52));
+        JoueurHumain joueur = new JoueurHumain(Deck, 0);
+        joueur.DrawCard(0, Deck);
+
+        assertEquals(3, joueur.GetNbCards(0));
+    }
+
+    @Test
+    public void testDrawCardWrongHand() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(6, 52));
+        JoueurHumain joueur = new JoueurHumain(Deck, 0);
+
+        assertThrows(RuntimeException.class, () -> joueur.DrawCard(1, Deck));
+    }
+
+    @Test
+    public void testCardStrength() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(1, 2));
+        JoueurHumain joueur = new JoueurHumain(Deck, 0);
+
+        assertEquals(0, joueur.GetCardStrength(0, 0));
+    }
+
+    @Test
+    public void testCardStrengthWrongCard() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(1, 2));
+        JoueurHumain joueur = new JoueurHumain(Deck, 0);
+
+        assertThrows(RuntimeException.class, () -> joueur.GetCardStrength(0, 2));
+    }
+
+    @Test
+    public void testCardStrengthWrongHand() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(1, 2));
+        JoueurHumain joueur = new JoueurHumain(Deck, 0);
+
+        assertThrows(RuntimeException.class, () -> joueur.GetCardStrength(1, 0));
+    }
+
+    @Test
+    public void testCardCount() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(1, 2));
+        JoueurHumain joueur = new JoueurHumain(Deck, 0);
+
+        assertEquals(2, joueur.GetNbCards(0));
+    }
+
+    @Test
+    public void testCardCountWrongHand() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(1, 2));
+        JoueurHumain joueur = new JoueurHumain(Deck, 0);
+
+        assertThrows(RuntimeException.class, () -> joueur.GetNbCards(1));
+    }
+
+    @Test
+    public void testShowHand() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(1, 2));
+        JoueurHumain joueur = new JoueurHumain(Deck, 0);
+
+        ByteArrayOutputStream outputStreamCaptor = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(outputStreamCaptor));
+
+        joueur.ShowHand(0);
+
+        System.setOut(System.out);
+        String printedOutput = outputStreamCaptor.toString().trim();
+
+        assertTrue(printedOutput.contains("🃟 🃟"));
+    }
+
+    @Test
+    public void testWrongShowHand() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(1, 2));
+        JoueurHumain joueur = new JoueurHumain(Deck, 0);
+
+        assertThrows(RuntimeException.class, () -> joueur.ShowHand(1));
+    }
+
+    @Test
+    public void testShowHands() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(1, 2));
+        JoueurHumain joueur = new JoueurHumain(Deck, 0);
+
+        ByteArrayOutputStream outputStreamCaptor = new ByteArrayOutputStream();
+        System.setOut(new PrintStream(outputStreamCaptor));
+
+        joueur.ShowHands();
+
+        System.setOut(System.out);
+        String printedOutput = outputStreamCaptor.toString().trim();
+
+        assertTrue(printedOutput.contains("🃟 🃟"));
+    }
+
+    @Test
+    public void testNumberHands() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(1, 2));
+        JoueurHumain joueur = new JoueurHumain(Deck, 0);
+
+        assertEquals(1, joueur.GetNbHands());
+    }
+
+    @Test
+    public void testHandStrength() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(1, 2));
+        JoueurHumain joueur = new JoueurHumain(Deck, 0);
+
+        assertEquals(0, joueur.GetStrength(0));
+    }
+
+    @Test
+    public void testWrongHandStrength() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(1, 2));
+        JoueurHumain joueur = new JoueurHumain(Deck, 0);
+
+        assertThrows(RuntimeException.class, () -> joueur.GetStrength(1));
+    }
+
+    @Test
+    public void testDoubled() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(1, 2));
+        JoueurHumain joueur = new JoueurHumain(Deck, 0);
+
+        assertEquals(false, joueur.HasDoubled(0));
+    }
+
+    @Test
+    public void testCanSplit() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(1, 2));
+        JoueurHumain joueur = new JoueurHumain(Deck, 0);
+
+        assertEquals(true, joueur.CanSplit(0));
+    }
+
+    @Test
+    public void testCantSplit() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(1, 3));
+        JoueurHumain joueur = new JoueurHumain(Deck, 0);
+
+        joueur.DrawCard(0, Deck);
+
+        assertEquals(false, joueur.CanSplit(0));
+    }
+
+    @Test
+    public void testSplit() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(1, 5));
+        JoueurHumain joueur = new JoueurHumain(Deck, 0);
+
+        joueur.Split(0, Deck);
+
+        assertEquals(true, joueur.HasSplit(0));
+    }
+
+    @Test
+    public void testSplitMax() {
+
+        JeudeCarte Deck = new JeudeCarte(new Paquet(1, 15));
+        JoueurHumain joueur = new JoueurHumain(Deck, 0);
+
+        joueur.Split(0, Deck);
+        joueur.Split(1, Deck);
+
+        assertThrows(RuntimeException.class, () -> joueur.Split(0, Deck));
+    }
+}
diff --git a/Partie_3/target/classes/ch/hepia/App.class b/Partie_3/target/classes/ch/hepia/App.class
index 2cd8ba87eca313ce79e1f20008967fe2848f2513..aad0e41606823ab879200272efe2f63852dccb72 100644
Binary files a/Partie_3/target/classes/ch/hepia/App.class and b/Partie_3/target/classes/ch/hepia/App.class differ
diff --git a/Partie_3/target/classes/ch/hepia/GameManager.class b/Partie_3/target/classes/ch/hepia/GameManager.class
index 73ed8bf9a6302d0a47db71fa3b031bb7bbb9c49e..0ae3f3d24bc760587c947162801cc9ccb6df14b6 100644
Binary files a/Partie_3/target/classes/ch/hepia/GameManager.class and b/Partie_3/target/classes/ch/hepia/GameManager.class differ
diff --git a/Partie_3/target/classes/ch/hepia/JoueurCroupier.class b/Partie_3/target/classes/ch/hepia/JoueurCroupier.class
index 9a717ff4c56ce683fff710ba2f2f33ca8966b558..1d0bb3797ec4281bcbc48e36763785c6e864c086 100644
Binary files a/Partie_3/target/classes/ch/hepia/JoueurCroupier.class and b/Partie_3/target/classes/ch/hepia/JoueurCroupier.class differ
diff --git a/Partie_3/target/classes/ch/hepia/JoueurHumain.class b/Partie_3/target/classes/ch/hepia/JoueurHumain.class
index f48be18eb326b030e967eb4fcd4a691e8fb62038..068028eff942eafbe3b36e821e7fc43a0fe1309b 100644
Binary files a/Partie_3/target/classes/ch/hepia/JoueurHumain.class and b/Partie_3/target/classes/ch/hepia/JoueurHumain.class differ
diff --git a/Partie_3/target/classes/ch/hepia/JoueurOrdinateur.class b/Partie_3/target/classes/ch/hepia/JoueurOrdinateur.class
index 5d518578ec450182ac80c003ccfe22567f6000dd..e8925bd7d60d537103d49935df82fae23c2b1f36 100644
Binary files a/Partie_3/target/classes/ch/hepia/JoueurOrdinateur.class and b/Partie_3/target/classes/ch/hepia/JoueurOrdinateur.class differ
diff --git a/Partie_3/target/classes/ch/hepia/Save.class b/Partie_3/target/classes/ch/hepia/Save.class
new file mode 100644
index 0000000000000000000000000000000000000000..9573a2e368dea090dc72a1674ce1aa82a9c79b87
Binary files /dev/null and b/Partie_3/target/classes/ch/hepia/Save.class differ
diff --git a/Partie_3/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst b/Partie_3/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst
index 127925b311677c80a5bd237e82f96ceaac2d73ed..aacaf9de67b552001c795abf890bbc4f2a439106 100644
--- a/Partie_3/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst
+++ b/Partie_3/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst
@@ -5,3 +5,4 @@
 /home/padi/Git/java-card-game/Partie_3/src/main/java/ch/hepia/Carte.java
 /home/padi/Git/java-card-game/Partie_3/src/main/java/ch/hepia/GameManager.java
 /home/padi/Git/java-card-game/Partie_3/src/main/java/ch/hepia/JeudeCarte.java
+/home/padi/Git/java-card-game/Partie_3/src/main/java/ch/hepia/Save.java
diff --git a/Partie_3/target/test-classes/ch/hepia/CarteTest.class b/Partie_3/target/test-classes/ch/hepia/CarteTest.class
deleted file mode 100644
index 655456ed1f9c7073c51fefd5a6f05ec8d78d542b..0000000000000000000000000000000000000000
Binary files a/Partie_3/target/test-classes/ch/hepia/CarteTest.class and /dev/null differ
diff --git a/Partie_3/target/test-classes/ch/hepia/JoueurTest.class b/Partie_3/target/test-classes/ch/hepia/JoueurTest.class
new file mode 100644
index 0000000000000000000000000000000000000000..6c1eb68d4853e00d11fada367c940922ce2fed72
Binary files /dev/null and b/Partie_3/target/test-classes/ch/hepia/JoueurTest.class differ