init

.gitignore

+### IntelliJ IDEA ###
+out/
+!**/src/main/**/out/
+!**/src/test/**/out/
+
+### Eclipse ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+bin/
+!**/src/main/**/bin/
+!**/src/test/**/bin/
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+
+### VS Code ###
+.vscode/
+
+### Mac OS ###
+.DS_Store
\ No newline at end of file

.idea/.gitignore

+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/misc.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_22" project-jdk-name="homebrew-22" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>
\ No newline at end of file

.idea/modules.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/IMfighTer.iml" filepath="$PROJECT_DIR$/IMfighTer.iml" />
+    </modules>
+  </component>
+</project>
\ No newline at end of file

IMfighTer.iml

+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="module-library">
+      <library name="JUnit5.8.1">
+        <CLASSES>
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter/5.8.1/junit-jupiter-5.8.1.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-api/5.8.1/junit-jupiter-api-5.8.1.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/opentest4j/opentest4j/1.2.0/opentest4j-1.2.0.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-commons/1.8.1/junit-platform-commons-1.8.1.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/apiguardian/apiguardian-api/1.1.2/apiguardian-api-1.1.2.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-params/5.8.1/junit-jupiter-params-5.8.1.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-engine/5.8.1/junit-jupiter-engine-5.8.1.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-engine/1.8.1/junit-platform-engine-1.8.1.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="JUnit4">
+        <CLASSES>
+          <root url="jar://$MAVEN_REPOSITORY$/junit/junit/4.13.1/junit-4.13.1.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/hamcrest/hamcrest-core/1.3/hamcrest-core-1.3.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+    <orderEntry type="module-library">
+      <library name="JUnit5.8.1">
+        <CLASSES>
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter/5.8.1/junit-jupiter-5.8.1.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-api/5.8.1/junit-jupiter-api-5.8.1.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/opentest4j/opentest4j/1.2.0/opentest4j-1.2.0.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-commons/1.8.1/junit-platform-commons-1.8.1.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/apiguardian/apiguardian-api/1.1.2/apiguardian-api-1.1.2.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-params/5.8.1/junit-jupiter-params-5.8.1.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-engine/5.8.1/junit-jupiter-engine-5.8.1.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-engine/1.8.1/junit-platform-engine-1.8.1.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+  </component>
+</module>
\ No newline at end of file

src/Entity/Carte.java

+// _________ .__                         _________                __
+// \_   ___ \|  | _____    ______ ______ \_   ___ \_____ ________/  |_  ____
+// /    \  \/|  | \__  \  /  ___//  ___/ /    \  \/\__  \\_  __ \   ___/ __ \
+// \     \___|  |__/ __ \_\___ \ \___ \  \     \____/ __ \|  | \/|  | \  ___/
+//  \______  |____(____  /____  /____  >  \______  (____  |__|   |__|  \___  >
+//         \/          \/     \/     \/          \/     \/                 \/
+package Entity;
+
+public class Carte {
+    //Définition des caractéristiques d'un objet Carte
+    private String lieu;
+    private String nom;
+    private int deb;
+    private int fin;
+    private int longueur;
+
+    //Définition du constructeur Cartes
+    public Carte(String lieu, String nom, int deb, int fin, int longueur) {
+        this.lieu = lieu;
+        this.nom = nom;
+        this.deb = deb;
+        this.fin = fin;
+        this.longueur = longueur;
+    }
+
+    //Définition des Getters et Setters
+    // Getter et Setter de lieu
+    public String getLieu() {
+        return lieu;
+    }
+    public void setLieu(String lieu) {
+        this.lieu = lieu;
+    }
+
+    // Getter et Setter de nom
+    public String getNom() {
+        return nom;
+    }
+    public void setNom(String nom) {
+        this.nom = nom;
+    }
+
+    // Getter et Setter de deb
+    public int getDeb() {
+        return deb;
+    }
+    public void setDeb(int deb) {
+        this.deb = deb;
+    }
+
+    // Getter et Setter de fin
+    public int getFin() {
+        return fin;
+    }
+    public void setFin(int fin) {
+        this.fin = fin;
+    }
+
+    // Getter et Setter de longueur
+    public int getLongueur() {
+        return longueur;
+    }
+    public void setLongueur(int longueur) {
+        this.longueur = longueur;
+    }
+}
+

src/Entity/Gentil.java

+// _________ .__                           ________               __  .__.__
+// \_   ___ \|  | _____    ______ ______  /  _____/  ____   _____/  |_|__|  |
+// /    \  \/|  | \__  \  /  ___//  ___/ /   \  ____/ __ \ /    \   __|  |  |
+// \     \___|  |__/ __ \_\___ \ \___ \  \    \_\  \  ___/|   |  |  | |  |  |__
+//  \______  |____(____  /____  /____  >  \______  /\___  |___|  |__| |__|____/
+//         \/          \/     \/     \/          \/     \/     \/
+package Entity;
+
+import Interfaces.ActionPersonnage;
+import Enum.CapaciteSpeciale;
+
+
+import java.util.logging.Level;
+// Création de la classe Gentil qui est enfant de la classe Personnage et qui utilise l'interface ActionPersonnage
+public class Gentil extends Personnage implements ActionPersonnage {
+    // Définition des différentes caractéristiques d'un gentil
+    private CapaciteSpeciale capaciteSpeciale;
+    public Gentil(char symbole, int defense, int pa, int pv, String nom, CapaciteSpeciale capaciteSpeciale) {
+        super(symbole, defense, pa, pv, nom);
+        this.capaciteSpeciale = capaciteSpeciale;
+    }
+    public CapaciteSpeciale getCapaciteSpeciale() {
+        return capaciteSpeciale;
+    }
+    public void setCapaciteSpeciale(CapaciteSpeciale capaciteSpeciale) {
+        this.capaciteSpeciale = capaciteSpeciale;
+    }
+    // Permet de pouvoir afficher les caractéristiques d'un gentil dans le terminal
+    @Override
+    public String toString() {
+        return "Gentil{" +
+                "nom='" + this.getNom() + '\'' +
+                ", pv=" + this.getPv() +
+                ", pa=" + this.getPa() +
+                ", defense=" + this.getDefense() +
+                ", symbole=" + this.getSymbole() +
+                ", capaciteSpeciale=" + this.capaciteSpeciale.getNom() +
+                '}';
+    }
+    // Fonction qui permet à un personnage (gentil) d'attaquer sa cible (méchant) et de lui infliger des dégats
+    @Override
+    public void attaquer(Personnage cible) {
+        if (cible != null) { // Si la cible est un personnage
+            int degats = this.getPa() - cible.getDefense();
+            if (degats < 0) {degats = 0;}
+            System.out.println(this.getNom() +" a attaqué " + cible.getNom() + " et lui a infligé " + degats + " points de dégats");
+            MyLogger.getInstance().log(this.getNom() +" a attaqué " + cible.getNom() + " et lui a infligé " + degats + " points de dégats");
+            cible.setPv(cible.getPv() - degats); // On met à jour les points de vie de la cible
+        }
+    }
+    // Fonction qui permet à un gentil d'utiliser sa capacité spéciale sur un méchant
+    @Override
+    public void utiliserPouvoir(Personnage cible) { // si c'est un soin le personnage récupère des points de vie, sinon il inflige des dégats à la cible
+        if (capaciteSpeciale.estSoins()) {
+            System.out.println(this.getNom() + " utilise " + this.capaciteSpeciale.getNom() + " et récupère " + capaciteSpeciale.getEffet() + " PV.");
+            MyLogger.getInstance().log(this.getNom() + " utilise " + this.capaciteSpeciale.getNom() + " et récupère " + capaciteSpeciale.getEffet() + " PV.");
+            this.setPv(Math.min(50, getPv() + capaciteSpeciale.getEffet())); // Limite des PV à 50
+        } else if (capaciteSpeciale.getNom() == "Multi shot") {
+            System.out.println(this.getNom() + " utilise " + this.capaciteSpeciale.getNom() + " et attaque trois fois");
+            MyLogger.getInstance().log(this.getNom() + " utilise " + this.capaciteSpeciale.getNom() + " et attaque trois fois");
+            this.attaquer(cible);
+            this.attaquer(cible);
+            this.attaquer(cible);
+        } else if (capaciteSpeciale.getNom() == "Gonflette") {
+            System.out.println(this.getNom() + " utilise " + this.capaciteSpeciale.getNom() + " et augmente ses pv de 25");
+            MyLogger.getInstance().log(this.getNom() + " utilise " + this.capaciteSpeciale.getNom() + " et augmente ses pv de 25");
+            this.setPv(this.getPv() + capaciteSpeciale.getEffet());
+        } else {
+            int pa = this.getPa();
+            this.setPa(pa + this.capaciteSpeciale.getEffet());
+            this.attaquer(cible);
+            this.setPa(pa);
+        }
+        this.setCapaciteSpeciale(null);
+        MyLogger.getInstance().log(this.getNom() + " n'a plus de capacité spéciale.");
+
+    }
+}

src/Entity/Jeu.java

+// _________ .__                              ____.
+// \_   ___ \|  | _____    ______ ______     |    | ____  __ __
+// /    \  \/|  | \__  \  /  ___//  ___/     |    _/ __ \|  |  \
+// \     \___|  |__/ __ \_\___ \ \___ \  /\__|    \  ___/|  |  /
+//  \______  |____(____  /____  /____  > \________|\___  |____/
+//         \/          \/     \/     \/                \/
+package Entity;
+
+import java.util.List;
+
+public class Jeu {
+    //Définition des caractéristiques d'un objet jeu
+    private Carte carte; // choix d'une carte dans une liste
+    private Gentil gentil; // choix d'un gentil dans une liste
+    private List<Mechant> mechants ; // liste de méchants choisis aléatoirement
+    private Personnage[] tableau; // le tableau montrant le déroulement du jeu
+
+    //Définition du constructeur
+    public Jeu(Carte carte, Gentil gentil, List<Mechant> mechants, Personnage[] tableau) {
+        this.carte = carte;
+        this.gentil = gentil;
+        this.mechants = mechants;
+        this.tableau = tableau;
+    }
+    //Définition des Getters et Setters
+    //Getter et Setter de la carte choisi
+    public Carte getCarte() {
+        return carte;
+    }
+    public void setCarte(Carte carte) {
+        this.carte = carte;
+    }
+    //Getter et Setter du gentil choisi
+    public Gentil getGentil() {
+        return gentil;
+    }
+    public void setGentil(Gentil gentil) {
+        this.gentil = gentil;
+    }
+    //Getter et Setter de la liste de mechant
+    public List<Mechant> getMechants() {
+        return mechants;
+    }
+    public void setMechants(List<Mechant> mechants) {
+        this.mechants = mechants;
+    }
+    //Getter et Setter du tableau
+    public Personnage[] getTableau() {
+        return tableau;
+    }
+    public void setTableau(Personnage[] tableau) {
+        this.tableau = tableau;
+    }
+}

src/Entity/Mechant.java

+// _________ .__                            _____               .__                   __
+// \_   ___ \|  | _____    ______ ______   /     \   ____  ____ |  |__ _____    _____/  |_
+// /    \  \/|  | \__  \  /  ___//  ___/  /  \ /  \_/ __ _/ ___\|  |  \\__  \  /    \   __\
+// \     \___|  |__/ __ \_\___ \ \___ \  /    Y    \  ___\  \___|   Y  \/ __ \|   |  |  |
+//  \______  |____(____  /____  /____  > \____|__  /\___  \___  |___|  (____  |___|  |__|
+//         \/          \/     \/     \/          \/     \/    \/     \/     \/     \/
+package Entity;
+
+import Interfaces.ActionPersonnage;
+import Enum.TypeMechant;
+// Création de la classe Mechant qui est enfant de la classe Personnage et qui utilise l'interface ActionPersonnage
+public class Mechant extends Personnage implements ActionPersonnage {
+    // Définition des différentes caractéristiques d'un méchant
+    TypeMechant type;
+    public Mechant(char symbole, String nom, TypeMechant type) {
+        super(symbole, type.getBonusDefense(), type.getBonusPa(), type.getBonusPv(), nom); // les pv d'un méchant sont issus de son type 
+        this.type = type;
+    }
+    public TypeMechant getType() {
+        return type;
+    }
+    public void setType(TypeMechant type) {
+        this.type = type;
+    }
+    // Permet de pouvoir afficher les caractéristiques d'un méchant dans le terminal
+    @Override
+    public String toString() {
+        return "Mechant de type "+ this.getType().getNom()+"{" +
+                "nom='" + this.getNom() + '\'' +
+                ", pv=" + this.getPv() +
+                ", pa=" + this.getPa() +
+                ", defense=" + this.getDefense() +
+                ", symbole=" + this.getSymbole() +
+                '}';
+    }
+    // Fonction qui permet à un personnage (méchant) d'attaquer sa cible (gentil) et de lui infliger des dégats
+    @Override
+    public void attaquer(Personnage cible) {
+        int degats = this.getPa() - cible.getDefense();
+        if (degats < 0) {degats = 0;}
+        System.out.println(this.getNom() +" à attaqué " + cible.getNom() + " et lui a infligé " + degats + " points de dégats");
+        MyLogger.getInstance().log(this.getNom() +" à attaqué " + cible.getNom() + " et lui a infligé " + degats + " points de dégats");
+        cible.setPv(cible.getPv() - degats);
+    }
+    // Fonction qui informe qu'un méchant n'a pas de capacité spéciale
+    @Override
+    public void utiliserPouvoir(Personnage cible) {
+        System.out.println("Les méchants n'ont pas de pouvoir !!");
+    }
+}

src/Entity/MyLogger.java

+// _________ .__                            _____        .____
+// \_   ___ \|  | _____    ______ ______   /     \ ___.__|    |    ____   ____   ____   ___________
+// /    \  \/|  | \__  \  /  ___//  ___/  /  \ /  <   |  |    |   /  _ \ / ___\ / ___\_/ __ \_  __ \
+// \     \___|  |__/ __ \_\___ \ \___ \  /    Y    \___  |    |__(  <_> / /_/  / /_/  \  ___/|  | \/
+//  \______  |____(____  /____  /____  > \____|__  / ____|_______ \____/\___  /\___  / \___  |__|
+//         \/          \/     \/     \/          \/\/            \/    /_____//_____/      \/
+package Entity;
+
+import java.io.FileWriter;
+import java.io.IOException;
+import java.time.LocalDateTime;
+// Création de la classe MyLogger qui permet de créer le fichier de log
+public class MyLogger {
+    private static MyLogger instance;
+    private FileWriter writer;
+
+    private MyLogger() {
+        try {
+            writer = new FileWriter("IMfighTer.log", true);
+        } catch (IOException e) {
+            System.out.println("Erreur lors de l'initialisation du logger : " + e.getMessage());
+        }
+    }
+
+    public static MyLogger getInstance() {
+        if (instance == null) {
+            instance = new MyLogger();
+        }
+        return instance;
+    }
+
+    public void log(String message) {
+        try {
+            String timestamp = "[" + LocalDateTime.now() + "] ";
+            writer.write(timestamp + message + "\n");
+            writer.flush();
+        } catch (IOException e) {
+            System.out.println("Erreur lors de l'écriture dans le fichier de log : " + e.getMessage());
+        }
+    }
+}
\ No newline at end of file

src/Entity/Personnage.java

+// _________ .__                         __________
+// \_   ___ \|  | _____    ______ ______ \______   \ ___________ __________   ____   ____ _____    ____   ____
+// /    \  \/|  | \__  \  /  ___//  ___/  |     ____/ __ \_  __ /  ___/  _ \ /    \ /    \\__  \  / ___\_/ __ \
+// \     \___|  |__/ __ \_\___ \ \___ \   |    |   \  ___/|  | \\___ (  <_> |   |  |   |  \/ __ \/ /_/  \  ___/
+//  \______  |____(____  /____  /____  >  |____|    \___  |__| /____  \____/|___|  |___|  (____  \___  / \___  >
+//         \/          \/     \/     \/                 \/          \/           \/     \/     \/_____/      \/
+package Entity;
+// Création de la classe Personnage
+public class Personnage {
+    // Définition des différentes caractéristiques d'un personnage
+    private String nom;
+    private int pv; // Points de vie
+    private int pa; // Points d'attaque
+    private int defense; // Point de défense
+    private char symbole; // charactère pour afficher le personnage dans le Jeu.tableau
+    private boolean isAlive; // vrai si le personnage est en vi
+    // Définition du constructeur
+    public Personnage(char symbole, int defense, int pa, int pv, String nom) {
+        this.symbole = symbole;
+        this.defense = defense;
+        this.pa = pa;
+        if( 0< pv  && pv < 51){
+            this.pv = pv;
+        }else{
+            throw new IllegalArgumentException("Les PV de base doivent être compris entre 10 et 50");
+        }
+        this.nom = nom;
+        this.isAlive = true;
+    }
+    // Fonction qui permet de retourner si un personnage est en vie ou non
+    public boolean getIsAlive() {
+        return isAlive;
+    }
+    // Définition de la variable isAlive en fonction de l'état du personnage
+    public void setIsAlive(boolean alive) {
+        isAlive = alive;
+    }
+    //Fonction qui permet de retourner le symbole du personnage
+    public char getSymbole() {
+        return symbole;
+    }
+    // Définition du symbole qui correspond au personnage
+    public void setSymbole(char symbole) {
+        this.symbole = symbole;
+    }
+    // Fonction qui permet de retourner les points de défense d'un personnage
+    public int getDefense() {
+        return defense;
+    }
+    // Définition des points de défense d'un personnage
+    public void setDefense(int defense) {
+        this.defense = defense;
+    }
+    // Fonction qui permet de retourner les points d'attaque d'un personnage
+    public int getPa() {
+        return pa;
+    }
+    // Définition des points d'attaque d'un personnage
+    public void setPa(int pa) {
+        this.pa = pa;
+    }
+    // Fonction qui permet de retourner les points de vie d'un personnage
+    public int getPv() {
+        return pv;
+    }
+    // Définition des points de vie d'un personnage
+    public void setPv(int pv) {
+        this.pv = pv;
+        if(pv <= 0){
+            this.setIsAlive(false);
+            this.pv = 0;
+            System.out.println(this.getNom()+" est mort");
+            MyLogger.getInstance().log(this.getNom()+" est mort");
+        }
+    }
+    // Fonction qui permet de retourner le nom d'un personnage
+    public String getNom() {
+        return nom;
+    }
+    // Définition du nom du personnage
+    public void setNom(String nom) {
+        this.nom = nom;
+    }
+    // Permet de pouvoir afficher les caractéristiques d'un personnage dans le terminal
+    @Override
+    public String toString() {
+        return "Personnage{" +
+                "nom='" + nom + '\'' +
+                ", pv=" + pv +
+                ", pa=" + pa +
+                ", defense=" + defense +
+                ", symbole=" + symbole +
+                '}';
+    }
+}

src/Enum/CapaciteSpeciale.java

+// ___________                      _________                            .__  __           _________                   .__       .__
+// \_   _____/ ____  __ __  _____   \_   ___ \_____  ___________    ____ |___/  |_  ____  /   ___________   ____  ____ |_______  |  |   ____
+//  |    __)_ /    \|  |  \/     \  /    \  \/\__  \ \____ \__  \ _/ ___\|  \   ___/ __ \ \_____  \\____ \_/ __ _/ ___\|  \__  \ |  | _/ __ \
+//  |        |   |  |  |  |  Y Y  \ \     \____/ __ \|  |_> / __ \\  \___|  ||  | \  ___/ /        |  |_> \  ___\  \___|  |/ __ \|  |_\  ___/
+// /_______  |___|  |____/|__|_|  /  \______  (____  |   __(____  /\___  |__||__|  \___  /_______  |   __/ \___  \___  |__(____  |____/\___  >
+//         \/     \/            \/          \/     \/|__|       \/     \/              \/        \/|__|        \/    \/        \/          \/
+package Enum;
+// Création de l'enum CapaciteSpeciale
+public enum CapaciteSpeciale {
+    // Définition des différentes capacité spéciale du jeu
+    SOIN("Soin", 25, true),
+    ONE_SHOT("One Shot", 100, false),
+    MULTI_SHOT("Multi shot", 0, false),
+    TREMPETTE("Trempette", 0, false ),
+    GONFLETTE("Gonflette", 25, false );
+    // Définition des différentes caractéristiques des capacités spéciales
+    private final String nom; // Nom de la capacité spéciale
+    private final int effet; // Points à ajouter (soin) ou à infliger (attaque)
+    private final boolean estSoins; // Vrai si c'est une capacité de soin, faux sinon
+    // Définition du constructeur
+    CapaciteSpeciale(String nom, int effet, boolean estSoins) {
+        this.nom = nom;
+        this.effet = effet;
+        this.estSoins = estSoins;
+    }
+    // Fonction qui permet de retourner le nom de la capacité spéciale
+    public String getNom() {
+        return nom;
+    }
+    // Fonction qui permet de retourner les effets de la capacité spéciale
+    public int getEffet() {
+        return effet;
+    }
+    // Fonction qui permet de retourner si la capacité spéciale permet de soigné ou non
+    public boolean estSoins() {
+        return estSoins;
+    }
+}

src/Enum/TypeMechant.java

+// ___________                      ___________                      _____               .__                   __
+// \_   _____/ ____  __ __  _____   \__    ______.________   ____   /     \   ____  ____ |  |__ _____    _____/  |_
+//  |    __)_ /    \|  |  \/     \    |    | <   |  \____ \_/ __ \ /  \ /  \_/ __ _/ ___\|  |  \\__  \  /    \   __\
+//  |        |   |  |  |  |  Y Y  \   |    |  \___  |  |_> \  ___//    Y    \  ___\  \___|   Y  \/ __ \|   |  |  |
+// /_______  |___|  |____/|__|_|  /   |____|  / ____|   __/ \___  \____|__  /\___  \___  |___|  (____  |___|  |__|
+//         \/     \/            \/            \/    |__|        \/        \/     \/    \/     \/     \/     \/
+package Enum;
+// Création de l'enum TypeMechant
+public enum TypeMechant {
+    // Définition des différents types de méchants du jeu
+    CATCHEUR ("Catcheur",10,7,3),
+    GANGSTER ("Gangster",5, 9, 2),
+    BRUTE("Brute",15, 8, 4),
+    TIREUR("Tireur",2, 12, 1),
+    BOSS("BOSS", 17,11,5);
+    // Définition des différentes caractéristiques du type de méchant
+    private final int bonusPv; // points de vie de base du type de méchant
+    private final int bonusPa; // points d'attaque de base du type de méchant
+    private final int bonusDefense; // défense de base du type de méchant
+    private final String nom; // nom du type de méchant
+    // Définition du constructeur
+    TypeMechant(String nom, int bonusPv, int bonusPa, int bonusDefense) {
+        this.bonusPv = bonusPv;
+        this.bonusPa = bonusPa;
+        this.bonusDefense = bonusDefense;
+        this.nom = nom;
+    }
+    // Fonction qui permet de retourner les points d'attaque du type de méchant
+    public int getBonusPa() {
+        return bonusPa;
+    }
+    // Fonction qui permet de retourner les points de vie du type de méchant
+    public int getBonusPv() {
+        return bonusPv;
+    }
+    // Fonction qui permet de retourner les points de défense du type de méchant
+    public int getBonusDefense() {
+        return bonusDefense;
+    }
+    // Fonction qui permet de retourner le nom du type de méchant
+    public String getNom() {
+        return nom;
+    }
+}

src/Interfaces/ActionPersonnage.java

+//.___        __                 _____                         _____          __  .__             __________
+//|   | _____/  |_  ____________/ _________    ____  ____     /  _  \   _____/  |_|__| ____   ____\______   \ ___________ __________   ____   ____ _____    ____   ____
+//|   |/    \   ___/ __ \_  __ \   __\\__  \ _/ ____/ __ \   /  /_\  \_/ ___\   __|  |/  _ \ /    \|     ____/ __ \_  __ /  ___/  _ \ /    \ /    \\__  \  / ___\_/ __ \
+//|   |   |  |  | \  ___/|  | \/|  |   / __ \\  \__\  ___/  /    |    \  \___|  | |  (  <_> |   |  |    |   \  ___/|  | \\___ (  <_> |   |  |   |  \/ __ \/ /_/  \  ___/
+//|___|___|  |__|  \___  |__|   |__|  (____  /\___  \___  > \____|__  /\___  |__| |__|\____/|___|  |____|    \___  |__| /____  \____/|___|  |___|  (____  \___  / \___  >
+//         \/          \/                  \/     \/    \/          \/     \/                    \/              \/          \/           \/     \/     \/_____/      \/
+package Interfaces;
+
+import Entity.Personnage;
+//Création de l'interface ActionPersonnage
+public interface ActionPersonnage {
+    // Appel de la fonction attaquer()
+    void attaquer(Personnage cible);
+    // Appel de la fonction utiliserPouvoir()
+    void utiliserPouvoir(Personnage cible);
+}

src/Main.java

+//.___   _____    /\   _____.__       .__  ___________
+//|   | /     \   )/ _/ ____|__| ____ |  |_\__    ______________
+//|   |/  \ /  \     \   __\|  |/ ___\|  |  \|    |_/ __ \_  __ \
+//|   /    Y    \     |  |  |  / /_/  |   Y  |    |\  ___/|  | \/
+//|___\____|__  /     |__|  |__\___  /|___|  |____| \___  |__|
+//            \/              /_____/      \/           \/
+import Entity.Context;
+import Entity.MyLogger;
+
+import java.io.IOException;
+// Création de la classe Main
+public class Main {
+    public static void main(String[] args) throws IOException {
+        // Message d'accueil
+        System.out.println("\n*** Bienvenue dans IM'fighTer par DEPINOY Solène et DUBOT Thomas ***\n");
+        MyLogger.getInstance().log("\n");
+        MyLogger.getInstance().log("\n*** Bienvenue dans IM'fighTer par DEPINOY Solène et DUBOT Thomas ***\n");
+        Context context = new Context();
+        context.CreationJeu();
+
+    }
+}
\ No newline at end of file

src/Tests/Test.java

+//__________.__       .__    .__               ___________             __
+//\_   _____|__| ____ |  |__ |__| ___________  \__    _______   ______/  |_
+// |    __) |  _/ ___\|  |  \|  _/ __ \_  __ \   |    |_/ __ \ /  ___\   __\
+// |     \  |  \  \___|   Y  |  \  ___/|  | \/   |    |\  ___/ \___ \ |  |
+// \___  /  |__|\___  |___|  |__|\___  |__|      |____| \___  /____  >|__|
+//     \/           \/     \/        \/                     \/     \/
+package Tests;
+
+import Entity.*;
+import Enum.CapaciteSpeciale;
+import Enum.TypeMechant;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+class Test {
+//___________             __     ____
+//\__    _______   ______/  |_  /_   |
+//  |    |_/ __ \ /  ___\   __\  |   |
+//  |    |\  ___/ \___ \ |  |    |   |
+//  |____| \___  /____  >|__|    |___|
+//             \/     \/
+    @org.junit.jupiter.api.Test
+    // Ce test s'assure que lorsque le gentil attaque il est en capacité de tuer le méchant
+    public final void testAttaqueTue() {
+        // Création d'un gentil
+        Gentil gentil = new Gentil('*', 50, 7, 50, "Thomas", CapaciteSpeciale.ONE_SHOT);
+        // Création d'un méchant
+        Mechant mechant = new Mechant( '!', "Sbire", TypeMechant.GANGSTER);
+        // Le gentil attaque le méchant
+        gentil.attaquer(mechant);
+        if(mechant.getIsAlive()){
+            // Si le méchant est en vie alors le test est raté
+            fail("\n ///////// \ntestAttaqueTue raté\n ///////// \n");
+        }else{
+            // Si le méchant n'est plus en vie alors le test est réussi
+            System.out.println("\n /////////\ntestAttaqueTue réussi \n ///////// \n");
+        }
+    }
+//___________             __    ________
+//\__    _______   ______/  |_  \_____  \
+//  |    |_/ __ \ /  ___\   __\  /  ____/
+//  |    |\  ___/ \___ \ |  |   /       \
+//  |____| \___  /____  >|__|   \_______ \
+//             \/     \/                \/
+    @org.junit.jupiter.api.Test
+    // Ce test vérifie ce qu'il se passe si le gentil meurt avant d'arriver à la fin de la carte
+    public final void testGentilMeurtAvantFin(){
+        Context context = new Context();
+        // Création d'une carte
+        Carte carte = new Carte("Désert", "Gobie", 0, 4, 5);
+        // Création du gentil
+        Gentil gentil = new Gentil('*', 1, 1, 10, "Thomas", CapaciteSpeciale.ONE_SHOT);
+        // Création des méchants
+        Mechant catcheur = new Mechant('!', "Catcheur", TypeMechant.CATCHEUR);
+        Mechant brute = new Mechant('!', "Brute", TypeMechant.BRUTE);
+        Mechant tireur = new Mechant('!', "Tireur", TypeMechant.TIREUR);
+        Mechant gangster = new Mechant('!', "Gangster", TypeMechant.GANGSTER);
+        Mechant boss = new Mechant('$', "Boss", TypeMechant.BOSS);
+        // Création d'une liste ou on stocke les diférents méchants
+        List<Mechant> listeMechant = new ArrayList<Mechant>();
+        listeMechant.add(catcheur);
+        listeMechant.add(brute);
+        listeMechant.add(tireur);
+        listeMechant.add(gangster);
+        listeMechant.add(boss);
+        // Création d'un tableau qui représente la map de jeu
+        Personnage[] tableau = new Personnage[7];
+        tableau[0] = gentil;
+        tableau[1] = catcheur;
+        tableau[2] = brute;
+        tableau[3] = tireur;
+        tableau[4] = gangster;
+        tableau[5] = boss;
+        tableau[6] = null;
+        // Création du jeu avec les éléments définis au dessus
+        Jeu jeu = new Jeu(carte, gentil, listeMechant, tableau);
+        while(gentil.getIsAlive()){
+            // Lancement automatique de tour tant que le gentil est en vie
+            context.LancementTourAutomatique(tableau, gentil, context);
+            if (tableau[tableau.length - 1] == gentil) {
+                // Si le gentil arrive à la fin de la map sans être mort alors le test est raté
+                fail("\n ///////// \ntestGentilMeurtAvantFin raté\n ///////// \n");
+            }else{
+                // Si le gentil meurt avant la fin de la map alors le test est réussi
+                System.out.println("\n ///////// \ntestGentilMeurtAvantFin réussi\n ///////// \n");
+            }
+        }
+    }
+//___________             __    ________
+//\__    _______   ______/  |_  \_____  \
+//  |    |_/ __ \ /  ___\   __\   _(__  <
+//  |    |\  ___/ \___ \ |  |    /       \
+//  |____| \___  /____  >|__|   /______  /
+//             \/     \/               \/
+    @org.junit.jupiter.api.Test
+    // Ce test s'assure que le gentil avance sur la case suivante si il n'y a pas de méchant dessus
+    public final void testGentilAvanceCaseVide(){
+        Context context = new Context();
+        // Création de la carte
+        Carte carte = new Carte("Désert", "Gobie", 0, 4, 5);
+        // Création du gentil
+        Gentil gentil = new Gentil('*', 1, 1, 10, "Thomas", CapaciteSpeciale.ONE_SHOT);
+        // Création d'un tableau qui représente la map de jeu
+        Personnage[] tableau = new Personnage[7];
+        tableau[0] = gentil;
+        // Lancement automatique de tour tant que le gentil est en vie
+        context.LancementTourAutomatique(tableau, gentil, context);
+        if (tableau[1] != gentil) {
+            // Si après 1 tour la case 1 du tableau n'est pas le gentil alors le test est raté
+            fail("\n ///////// \ntestGentilAvanceCaseVide raté\n ///////// \n");
+        }else{
+            // Si après 1 tour la case 1 du tableau est le gentil alors le test est réussi
+            System.out.println("\n ///////// \ntestGentilAvanceCaseVide réussi\n ///////// \n");
+        }
+    }
+//___________             __       _____
+//\__    _______   ______/  |_    /  |  |
+//  |    |_/ __ \ /  ___\   __\  /   |  |_
+//  |    |\  ___/ \___ \ |  |   /    ^   /
+//  |____| \___  /____  >|__|   \____   |
+//             \/     \/             |__|
+    @org.junit.jupiter.api.Test
+    // Ce test s'assure que si le gentil arrive à la fin de la map il gagne
+    public final void testVictoireGentil(){
+        Context context = new Context();
+        // Création de la carte
+        Carte carte = new Carte("Désert", "Gobie", 0, 4, 5);
+        // Création du gentil
+        Gentil gentil = new Gentil('*', 1, 1, 10, "Thomas", CapaciteSpeciale.ONE_SHOT);
+        // Création d'un tableau qui représente la map de jeu
+        Personnage[] tableau = new Personnage[7];
+        tableau[0] = gentil;
+        while(gentil.getIsAlive()){
+            // Lancement automatique du tour tant que le gentil est en vie
+            context.LancementTourAutomatique(tableau, gentil, context);
+            if (tableau[tableau.length - 1] == gentil) {
+                // Si la dernière case du tableau est égale au gentil alors le test est réussi
+                System.out.println("\n ///////// \ntestVictoireGentil réussi\n ///////// \n");
+                break;
+            }
+        }
+        if(!gentil.getIsAlive()){
+            // Si le gentil meurt avant d'arriver à la fin du tableau alors le test est raté
+            fail("\n ///////// \ntestVictoireGentil raté\n ///////// \n");
+        }
+
+    }
+//___________             __     .________
+//\__    _______   ______/  |_   |   ____/
+//  |    |_/ __ \ /  ___\   __\  |____  \
+//  |    |\  ___/ \___ \ |  |    /       \
+//  |____| \___  /____  >|__|   /______  /
+//             \/     \/               \/
+    @org.junit.jupiter.api.Test
+    // Ce test s'assure que le gentil ne peut utiliser sa capacité spéciale qu'une seule fois
+    public final void testCapaciteSpecialeUneFois(){
+        Context context = new Context();
+        // Création d'un gentil
+        Gentil gentil = new Gentil('*', 1, 1, 10, "Thomas", CapaciteSpeciale.TREMPETTE);
+        // Création d'un méchant
+        Mechant boss = new Mechant('$', "Boss", TypeMechant.BOSS);
+        // Utilisation de la capacité spéciale du gentil sur le méchant
+        gentil.utiliserPouvoir(boss);
+        if (gentil.getCapaciteSpeciale() != null){
+            // Si la capacité spéciale du gentil n'est pas égale à "null" alors le test est raté
+            fail("\n ///////// \ntestCapaciteSpecialeUneFois raté\n ///////// \n");
+        }else{
+            // Si la capacité spéciale du gentil est égale à "null" alors le test est réussi
+            System.out.println("\n ///////// \ntestCapaciteSpecialeUneFois réussi\n ///////// \n");
+        }
+    }
+}
\ No newline at end of file