From 0c2c3ee5a55f36d270171f2f67938542e251fdc5 Mon Sep 17 00:00:00 2001
From: polo <ordipolo@gmx.fr>
Date: Thu, 2 Jul 2026 00:14:17 +0200
Subject: fork utilisant maven

---
 src/main/java/controlleur/BDD.java                 | 322 +++++++++++++++++++++
 src/main/java/controlleur/Connexion.java           |  65 +++++
 src/main/java/controlleur/ControllerAdmin.java     | 119 ++++++++
 src/main/java/controlleur/ControllerTopMenu.java   |  58 ++++
 src/main/java/controlleur/ControlleurSimu.java     | 218 ++++++++++++++
 src/main/java/controlleur/CreationCompte.java      |  38 +++
 src/main/java/controlleur/EvenementController.java | 267 +++++++++++++++++
 src/main/java/controlleur/GestionListe.java        |  82 ++++++
 src/main/java/controlleur/Instanciation.java       | 304 +++++++++++++++++++
 src/main/java/controlleur/ModificationListe.java   | 214 ++++++++++++++
 src/main/java/controlleur/StockageCreerListe.java  |  75 +++++
 src/main/java/controlleur/SupprListe.java          |  27 ++
 12 files changed, 1789 insertions(+)
 create mode 100644 src/main/java/controlleur/BDD.java
 create mode 100644 src/main/java/controlleur/Connexion.java
 create mode 100644 src/main/java/controlleur/ControllerAdmin.java
 create mode 100644 src/main/java/controlleur/ControllerTopMenu.java
 create mode 100644 src/main/java/controlleur/ControlleurSimu.java
 create mode 100644 src/main/java/controlleur/CreationCompte.java
 create mode 100644 src/main/java/controlleur/EvenementController.java
 create mode 100644 src/main/java/controlleur/GestionListe.java
 create mode 100644 src/main/java/controlleur/Instanciation.java
 create mode 100644 src/main/java/controlleur/ModificationListe.java
 create mode 100644 src/main/java/controlleur/StockageCreerListe.java
 create mode 100644 src/main/java/controlleur/SupprListe.java

(limited to 'src/main/java/controlleur')

diff --git a/src/main/java/controlleur/BDD.java b/src/main/java/controlleur/BDD.java
new file mode 100644
index 0000000..af1a754
--- /dev/null
+++ b/src/main/java/controlleur/BDD.java
@@ -0,0 +1,322 @@
+package controlleur;
+
+import java.sql.Connection;
+import java.sql.Date;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.List;
+
+import javafx.scene.layout.VBox;
+import modele.Arme;
+import modele.ArmeeListe;
+import modele.Evenement;
+import modele.Unit;
+import modele.User;
+
+public class BDD {
+
+	private Connection connec;
+	private PreparedStatement stat = null;
+	private ResultSet rs ;
+	
+	private static String user;
+	private static String password;
+	private static String dbname;
+		
+	public BDD() {
+		try {
+			//Class.forName("com.mysql.cj.jdbc.Driver");
+			Class.forName("org.mariadb.jdbc.Driver");
+			//String host = "mysql-stathammer.alwaysdata.net";
+			String host = "localhost";
+			//this.connec = DriverManager.getConnection("jdbc:mysql://" + host + ":3306/"+ dbname, user, password);
+			this.connec = DriverManager.getConnection("jdbc:mariadb://" + host + ":3306/"+ dbname, user, password);
+			this.rs = connec.prepareStatement("SELECT * FROM faction;").executeQuery();
+		} catch (ClassNotFoundException e) {
+			// TODO: handle exception
+
+			e.printStackTrace();
+		} catch (SQLException e) {
+			System.err.println(e.getMessage());
+		}
+	}
+	
+	public static void setInfos(String login, String pwd, String base)
+	{
+		user = login;
+		password = pwd;
+		dbname = base;
+	}
+	
+	public Statement getStatement() throws SQLException
+	{
+		return connec.createStatement();
+	}
+	
+	public PreparedStatement getPreparedStatement(String sql, Object... params) throws SQLException
+	{
+		stat = connec.prepareStatement(sql);
+		if(params.length > 0)
+		{
+			for (int i = 0; i < params.length; i++) {
+				stat.setObject(i + 1, params[i]);
+			}
+		}
+		return stat;
+	}
+	
+	public ArrayList<Object> selectUtilisateur(String nom, String mdp) {
+		ArrayList<Object> rendu = new ArrayList<Object>();
+		try {
+
+			String requete = "SELECT id_utilisateur, nom_utilisateur, role_utilisateur FROM utilisateur WHERE nom_utilisateur=? AND mdp_utilisateur = ?;";
+			stat = connec.prepareStatement(requete);
+			stat.setString(1, nom);
+			stat.setString(2,String.valueOf(mdp));
+			//stat.setString(2,String.valueOf(mdp.hashCode()));
+
+			ResultSet rs = stat.executeQuery();
+			ResultSetMetaData md = rs.getMetaData();
+			ArrayList<String> column = new ArrayList<String>();
+
+			for (int i = 1; i <= md.getColumnCount(); i++) {
+				column.add(md.getColumnName(i));
+			}
+			while (rs.next()) {
+				rendu.add(rs.getString("nom_utilisateur"));
+				rendu.add(rs.getInt("id_utilisateur"));
+				rendu.add(rs.getString("role_utilisateur"));
+			}
+			return rendu;
+
+		} catch (SQLException e) {
+			// TODO: handle exception
+			System.err.println(e.getMessage());
+
+		}
+		return rendu;
+	}
+
+	public ArrayList<String> creerUtilisateur(String adresse, String nom, String mdp) {
+		ArrayList<String> crea = new ArrayList<String>();
+
+		String creationRequete = "INSERT INTO utilisateur" + " (nom_utilisateur, email_utilisateur, mdp_utilisateur)"
+				+ "VALUES (?, ?, ?);";
+		try {
+			if (connec == null || connec.isClosed()) {
+				System.err.println("La connexion à la bdd n'est pas possible.");
+				return crea;
+			}
+			PreparedStatement stat = connec.prepareStatement(creationRequete);
+			stat.setString(1, nom);
+			stat.setString(2, adresse);
+			stat.setString(3, mdp);
+
+			int rowsInserted = stat.executeUpdate();
+
+			if (rowsInserted > 0) {
+				crea.add(adresse);
+			}
+			stat.close();
+		} catch (SQLException e) {
+			System.err.println("Erreur SQL : " + e.getMessage());
+		}
+		return crea;
+	}
+
+	public Connection getConnection() {
+		return this.connec;
+	}
+
+	public void close() {
+		try {
+			connec.close();
+		} catch (SQLException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+	}
+	
+	public ArrayList<String> select(String requete,String... param ) throws SQLException{
+		ArrayList<String> rendu = new ArrayList<String>();
+		try {
+			PreparedStatement pstat = null;
+			
+			pstat = connec.prepareStatement(requete);
+			if(param.length>0) {
+				for(int i = 1;i<=param.length;i++) {
+					pstat.setString(i, param[i-1]);
+				}
+			}
+			
+			rs.close();
+			rs = pstat.executeQuery();
+			ResultSetMetaData md = rs.getMetaData();
+			ArrayList<String> column = new ArrayList<String>();
+			
+			
+			for(int i =1;i<=md.getColumnCount();i++) {
+				column.add(md.getColumnName(i));
+			}
+			while(rs.next()) {
+				for (String col : column) {
+					rendu.add(rs.getString(col));
+				}
+				
+				
+				
+			}
+			
+			return rendu;
+			
+		} catch (SQLException e) {
+			// TODO: handle exception
+			System.err.println(e.getMessage());
+			
+			
+		}
+		return rendu;
+	}
+	
+	public void updateUtilisateur(String pseudo,int id) {
+		try {
+			stat = this.getPreparedStatement("UPDATE `utilisateur` SET nom_utilisateur=? WHERE id_utilisateur=?;",pseudo,id);
+			stat.executeUpdate();
+			
+		} catch (SQLException e) {
+			// TODO: handle exception
+			System.err.println(e.getMessage());
+		}
+	}
+	public void insertListe(ArmeeListe armee,User session) {
+		try {
+			int id;
+			ArrayList<String> rendu = new ArrayList<String>();
+			String requete = "INSERT INTO liste VALUES(DEFAULT,?,?,?,?);";
+			stat = this.getPreparedStatement(requete);
+			stat.setString(1, armee.getName());
+			stat.setString(2, armee.getDescription());
+			stat.setString(3, armee.getData());
+			stat.setInt(4, session.getId());
+			stat.executeUpdate();
+			
+			requete = "SELECT id_liste FROM liste WHERE nom_liste = ?;";
+			
+			rendu = this.select(requete,armee.getName());
+			
+			id = Integer.parseInt(rendu.getFirst());
+			requete = "INSERT INTO contenir VALUES(?,?);";
+			
+			for(Unit unit : armee.getUnits()) {
+				
+				
+				stat = this.getPreparedStatement(requete);
+				stat.setInt(1, unit.getId());
+				stat.setInt(2, id);
+				stat.executeUpdate();
+			}
+			
+		} catch (SQLException e) {
+			// TODO: handle exception
+		}
+	}
+	
+	
+	public void updateMp(String mdp,int id) {
+		try {
+			//stat = this.getPreparedStatement("UPDATE `utilisateur` SET mdp_utilisateur=? WHERE id_utilisateur=?;",mdp.hashCode(),id);
+			stat = this.getPreparedStatement("UPDATE `utilisateur` SET mdp_utilisateur=? WHERE id_utilisateur=?;",mdp.hashCode(),id);
+			stat.executeUpdate();
+			
+		} catch (SQLException e) {
+			// TODO: handle exception
+			System.err.println(e.getMessage());
+		}
+	}
+	
+	public int UtilisateurID(String nom, String mdp) {
+		try {
+			stat = this.getPreparedStatement("SELECT id_utilisateur FROM utilisateur WHERE nom_utilisateur=? AND mdp_utilisateur = ?;",
+				nom, mdp);
+			
+			ResultSet rs = stat.executeQuery();
+			rs.next();
+			int id = rs.getInt("id_utilisateur");
+
+			return id;
+			
+		} catch (SQLException e) {
+			// TODO: handle exception
+			System.err.println(e.getMessage());
+			
+			return 0;
+		}
+	}
+	public String UtilisateurRole(String nom, String mdp) {
+		String role = "null";
+		try {
+			
+			stat = this.getPreparedStatement("SELECT role_utilisateur FROM utilisateur WHERE nom_utilisateur=? AND mdp_utilisateur = ?;",
+				nom, mdp);
+			
+			ResultSet rs = stat.executeQuery();
+			rs.next();
+			role = rs.getString("role_utilisateur");
+			
+			return role;
+			
+		} catch (SQLException e) {
+			// TODO: handle exception
+			System.err.println(e.getMessage());
+			
+			
+		}
+		return role;
+	}
+	
+	public String UtilisateurMdp(int id) {
+		String mdp = "test null";
+		try {
+			stat = this.getPreparedStatement("SELECT mdp_utilisateur FROM utilisateur WHERE id_utilisateur=?;",
+				id);
+			
+			ResultSet rs = stat.executeQuery();
+			rs.next();
+			mdp = rs.getString("mdp_utilisateur");
+
+			return mdp;
+			
+		} catch (SQLException e) {
+			// TODO: handle exception
+			System.err.println(e.getMessage());
+			
+			
+		}
+		return mdp;
+	}
+	
+	
+	public void ajouter(Arme a) {
+		try {
+			stat.executeUpdate("INSERT INTO arme (id,prenom,login,password,statut,age) VALUES (NULL,");
+		} catch (SQLException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+	}
+
+	public void supprimer(Arme a) {
+		try {
+			stat.executeUpdate("DELETE FROM acces WHERE login =''");
+		} catch (SQLException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+
+	}
+}
diff --git a/src/main/java/controlleur/Connexion.java b/src/main/java/controlleur/Connexion.java
new file mode 100644
index 0000000..f8c6b4f
--- /dev/null
+++ b/src/main/java/controlleur/Connexion.java
@@ -0,0 +1,65 @@
+package controlleur;
+
+import java.sql.SQLException;
+import java.util.ArrayList;
+
+import javafx.stage.Stage;
+import modele.Evenement;
+import modele.User;
+import vue.AfficheAccueil;
+import vue.AfficheConnexionFailed;
+
+public class Connexion {
+	public static EvenementController eventC ;
+	public static Evenement event ;
+	public static void verif(String login, String mdp,Stage primaryStage) {
+		
+		login = login.trim();
+		mdp = Integer.toString(mdp.hashCode());
+		BDD conec = new BDD();
+		
+		eventC = new EvenementController();
+    	event = new Evenement(eventC.getNom_event().get(0),
+				eventC.getNom_image().get(0),
+				eventC.getDesc_event().get(0),
+				eventC.getDate_event().get(0));
+		System.out.println(eventC.getNom_image().get(0));
+		ArrayList<Object> rendu = conec.selectUtilisateur(login, mdp);
+		int id = conec.UtilisateurID(login, mdp);
+		String role = conec.UtilisateurRole(login, mdp);
+		//System.out.println(role);
+		conec.close();
+		
+		try {
+			if (login.equals(rendu.get(0))) {
+				User session = new User(login,id,role);
+				
+				//primaryStage.close();
+				AfficheAccueil.affiche(primaryStage,session);
+			}
+			else {
+				System.out.println(rendu);
+			}
+		}
+		catch(Exception e) {
+			AfficheConnexionFailed.affiche(primaryStage);
+		}
+	}
+	
+	public static void updatePseudo(String pseudo,int id) throws SQLException {
+		BDD conec = new BDD();
+		conec.updateUtilisateur(pseudo,id);
+		conec.close();
+	}
+	public static void updateMdp(String mdp,int id) throws SQLException {
+		BDD conec = new BDD();
+		conec.updateMp(mdp,id);
+		conec.close();
+	}
+	public static String selectMdp(int id) throws SQLException {
+		BDD conec = new BDD();
+		String mdp =conec.UtilisateurMdp(id);
+		conec.close();
+		return mdp;
+	}
+}
\ No newline at end of file
diff --git a/src/main/java/controlleur/ControllerAdmin.java b/src/main/java/controlleur/ControllerAdmin.java
new file mode 100644
index 0000000..a12f01c
--- /dev/null
+++ b/src/main/java/controlleur/ControllerAdmin.java
@@ -0,0 +1,119 @@
+package controlleur;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+import javafx.geometry.Pos;
+import javafx.scene.control.Alert;
+import javafx.scene.control.Button;
+import javafx.scene.control.Label;
+import javafx.scene.image.Image;
+import javafx.scene.image.ImageView;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.VBox;
+import javafx.scene.text.Text;
+import javafx.stage.FileChooser;
+import javafx.stage.Stage;
+import vue.AfficheAccueil;
+import vue.AfficheAdmin;
+import vue.AfficheConnexionFailed;
+import modele.Evenement;
+import modele.User;
+
+public class ControllerAdmin {
+	private static String destinationDir;
+	private static File destinationFile ;
+	private static File file;
+	
+	public static void parcourir(Stage primaryStage, ImageView imageView) {
+        FileChooser fileChooser = new FileChooser();
+        fileChooser.getExtensionFilters().add(new FileChooser.ExtensionFilter("Fichiers Images", "*.png", "*.jpg"));
+        
+        // Ouvrir le file chooser et obtenir le fichier sélectionné
+        file = fileChooser.showOpenDialog(primaryStage);
+        
+       boolean nomFich = true;
+        
+        if (file != null) {
+
+        	for (int i = 0 ; i < Connexion.eventC.getNbrEvt();i++) {
+        		
+        		if (file.getName().equals(Connexion.eventC.getNom_image().get(i))) {
+        			
+        	        Alert alert = new Alert(Alert.AlertType.ERROR);
+        	        alert.setTitle("StatHammer : Nom d'image déjà existant");
+        	        alert.setHeaderText(null);
+        	        alert.setContentText("Le nom de l'image est déjà prise.");
+        	        alert.showAndWait();
+        	        nomFich = false;
+        	        
+        		}
+        	}
+        	if (nomFich) {
+            	System.out.println("Fichier sélectionné : " + file.getName());
+            	System.out.println("Chemin du fichier : " + file.getAbsolutePath());
+                
+                // Créer une nouvelle image à partir du chemin absolu du fichier
+                Image image = new Image("file:" + file.getAbsolutePath());
+                
+                // Définir l'image dans l'ImageView
+                imageView.setImage(image);
+
+                // Destination pour sauvegarder l'image
+                destinationDir = "src\\images"; 
+                File destinationFolder = new File(destinationDir);
+                
+                // Créez le répertoire s'il n'existe pas
+                if (!destinationFolder.exists()) {
+                    destinationFolder.mkdirs();
+                }
+                
+                File nouveauNom = new File(file.getName());
+                destinationFile = new File(destinationFolder, nouveauNom.getName());
+                		
+        	}
+
+        }
+	}
+	
+	
+	//méthode "valider"
+	public static VBox valider(String nom_evt, String nom_img, String desc, String date) {
+		Evenement evt = new Evenement(nom_evt, nom_img, desc, date);
+		VBox event = new VBox();
+		event.setPrefHeight(50);
+        event.setAlignment(Pos.CENTER);
+		try {
+            // Copier le fichier dans le dossier de destination
+            Files.copy(file.toPath(), destinationFile.toPath());
+            System.out.println("Fichier enregistré à : " + destinationFile.getAbsolutePath());
+            EvenementController.insererEvenement(evt);
+			event = EvenementController.EvenementVBox();
+			
+        } catch (IOException ioException) {
+        	System.out.println("Probleme sur Valider");
+            ioException.printStackTrace();
+        }
+		return event;
+    }
+	
+	public static File getFile() {
+		return file;
+	}
+
+
+	public static String getDestinationDir() {
+		return destinationDir;
+	}
+	
+
+	
+}
\ No newline at end of file
diff --git a/src/main/java/controlleur/ControllerTopMenu.java b/src/main/java/controlleur/ControllerTopMenu.java
new file mode 100644
index 0000000..baef8df
--- /dev/null
+++ b/src/main/java/controlleur/ControllerTopMenu.java
@@ -0,0 +1,58 @@
+package controlleur;
+
+import application.Battle;
+import javafx.stage.Stage;
+import modele.Evenement;
+import modele.User;
+import vue.AfficheAccueil;
+import vue.AfficheAdmin;
+import vue.AfficheConnexion;
+import vue.AfficheCreerListe;
+import vue.AfficheGestionCompte;
+import vue.GestionListe.AfficheGestionListe;
+import vue.simulation.AfficheSimulation;
+
+public class ControllerTopMenu {
+	static BDD db = new BDD();
+	
+	public static void go_accueil(Stage primaryStage,User session) { 
+		//primaryStage.close(); pour fermer stage
+		AfficheAccueil.affiche(primaryStage,session);
+	}
+	public static void go_gestion_compte(Stage primaryStage,User session) { 
+		AfficheGestionCompte.affiche(primaryStage,session);
+	}
+	public static void go_gestion_listes(Stage primaryStage,User session) { 
+
+//		db.getArmyLists(session);
+		AfficheGestionListe.affiche(primaryStage, session);
+
+		//
+
+	}
+	public static void go_deco(Stage primaryStage, User session) { 
+		AfficheSimulation.cleanWeaponsAtitudesMenu();
+		Battle.clean(); // VRAIMENT ?!
+		session = null;
+		AfficheConnexion.affiche(primaryStage);
+	}
+	public static void go_simulation(Stage primaryStage, User session){
+
+		
+		Instanciation.getArmyLists(session);
+
+		AfficheSimulation.affiche(primaryStage, session);
+	}
+	public static void go_admin(Stage primaryStage,User session) { 
+		AfficheAdmin.affiche(primaryStage,session);
+	}
+	public static void go_creer_liste(Stage primaryStage, User session) {
+		AfficheCreerListe.afficheCreerListe(primaryStage, session);
+	}
+//	public static void go_gestionliste(Stage primaryStage,User session) { 
+//		AfficheGestionListe.affiche(primaryStage,session);
+//	}
+}
+
+
+
diff --git a/src/main/java/controlleur/ControlleurSimu.java b/src/main/java/controlleur/ControlleurSimu.java
new file mode 100644
index 0000000..a349036
--- /dev/null
+++ b/src/main/java/controlleur/ControlleurSimu.java
@@ -0,0 +1,218 @@
+package controlleur;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import application.Battle;
+import javafx.scene.control.Button;
+import javafx.scene.control.ChoiceBox;
+import javafx.scene.image.Image;
+import javafx.scene.image.ImageView;
+import javafx.scene.layout.FlowPane;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.Pane;
+import modele.Aptitude;
+import modele.Arme;
+import modele.ArmeeListe;
+import modele.Calcul;
+import modele.Figurine;
+import modele.Unit;
+import vue.simulation.AfficheSimulation;
+import vue.simulation.SimAptAndWeaponsVBox;
+import vue.simulation.SimFigurinesVBox;
+import vue.simulation.SimHistogramme;
+import vue.simulation.SimUnitsVBox;
+
+public class ControlleurSimu
+{	
+	// déroulement des unités d'une liste (appui sur lists_drop_down.get(i) dans AfficheSimulation)
+	public static void selectAList(int num_list, ArrayList<ArmeeListe> lists, String choice)
+	{
+		// choix de la liste
+		for(ArmeeListe one_list : lists)
+		{
+			if(one_list.getName().equals(choice)) {
+				// "copie profonde" d'une liste
+				ArmeeListe list = new ArmeeListe(one_list.getName(), one_list.getDescription(), one_list.getData());
+				Battle.setSelectedList(num_list, list);
+				break; // choix unique
+			}
+		}
+		
+		// obtenir les unités, l'armée, les figurines, armes et aptitudes
+		Instanciation.getUnitsOfAList(Battle.getSelectedList(num_list));
+
+		Battle.setArmy(num_list, Battle.getSelectedList(num_list).getUnits().get(0).getArmee());
+
+	}
+	
+	// déroulement des figurines d'une unité (appui sur buttons.get(i) dans SimUnitsVBox)
+	public static void PullDownUnits(int num_list, HBox dropdown_menu_box, SimUnitsVBox list_box) {
+		ArmeeListe list = Battle.getSelectedList(num_list);
+		
+		// noms des unités
+		String[] unit_names = new String[list.getUnits().size()];
+		for(int i = 0; i < list.getUnits().size(); i++) {
+			unit_names[i] = list.getUnits().get(i).getName();
+		}
+		
+		// supprimer l'ancien logo
+		if(dropdown_menu_box.getChildren().size() == 2){
+			dropdown_menu_box.getChildren().remove(1);
+		}
+		
+		// logo de faction
+		Image logo_faction = null;
+		if(Battle.getArmy(num_list) != null) // possibilité d'une liste vide
+		{
+			String file_name = Battle.getArmy(num_list).getLogo();
+			logo_faction = new Image("/images/armees/" + file_name);
+		}
+		ImageView logo_box = new ImageView();
+		
+		logo_box.setPreserveRatio(true);
+		logo_box.fitHeightProperty().bind(dropdown_menu_box.heightProperty());
+		logo_box.setImage(logo_faction);
+		dropdown_menu_box.getChildren().add(logo_box);
+		
+		// effacer la zone armes et aptitudes
+		AfficheSimulation.getWeaponsAtitudesMenu().setStyle("-fx-border-width: 0;");
+		AfficheSimulation.getWeaponsAtitudesMenu().getChildren().clear();
+		
+		// effacer et recréer les unités
+		list_box.getButtons().clear();
+		list_box.getFigBoxes().clear();
+		list_box.getChildren().clear();
+		list_box.setList(num_list);
+	}
+	
+	// déroulement des figurines d'une unité (appui sur buttons.get(i) dans SimUnitsVBox)
+	public static void selectAnUnit(SimUnitsVBox lists, int col, int j)
+	{
+		ArrayList<Button> buttons = lists.getButtons();
+		SimFigurinesVBox old_fig_boxes = null;
+        SimFigurinesVBox new_fig_boxes = lists.getFigBoxes().get(j);
+        
+        // il y a déjà une unité sélectionnée
+        if(Battle.getSelectedUnitIndex(col) > -1)
+        {
+			buttons.get(Battle.getSelectedUnitIndex(col)).setStyle("-fx-border-width: 0;");// retirer bordure unité sélectionnée
+        	AfficheSimulation.getWeaponsAtitudesMenu().getChildren().clear(); // supprimer fenêtre combat si existe
+        	
+        	// bouton même unité => ferme
+        	if(Battle.getSelectedUnitIndex(col) == j)
+            {
+        		new_fig_boxes.getChildren().clear();
+        		Battle.setSelectedUnit(col, -1);
+            }
+        	// bouton autre unité
+        	else
+        	{
+        		old_fig_boxes = lists.getFigBoxes().get(Battle.getSelectedUnitIndex(col));
+	        	if(old_fig_boxes != null) {
+					old_fig_boxes.getChildren().clear(); // supprimer ancienne zone de figurines
+				}
+	        	Battle.setSelectedUnit(col, j);
+	        	buttons.get(j).setStyle("-fx-border-width: 2; -fx-border-color: yellow; -fx-border-radius: 2;"); // bordure unité sélectionnée
+	        	new_fig_boxes.setFigurines(); // on ouvre
+        	}
+        }
+        // pas d'unité sélectionnée => on ouvre
+        else
+        {
+        	Battle.setSelectedUnit(col, j);
+        	buttons.get(j).setStyle("-fx-border-width: 2; -fx-border-color: yellow; -fx-border-radius: 2;"); // bordure unité sélectionnée
+        	new_fig_boxes.setFigurines();
+        }
+	}
+	
+	// slider des PV des figurines
+	public static void hpUpdate(int hp, Figurine fig, ImageView one_image_box) {
+		int old_hp = fig.getHP();
+		fig.setHP(hp);
+		
+		Image one_image;
+		if(old_hp == 0 && fig.getHP() > 0) {
+			one_image = new Image("/images/android-fill.png");
+			one_image_box.setImage(one_image);
+		}
+		else if(old_hp > 0 && fig.getHP() == 0){ // utile?
+			one_image = new Image("/images/android-line.png");
+			one_image_box.setImage(one_image);
+		}
+	}
+	
+	// afficher la zone des armes et aptitudes
+	public static void makeWeaponsAndAptitudeZone(ArrayList<Figurine> fig_group, SimAptAndWeaponsVBox weapons_aptitudes_menu) {
+		ArrayList<Arme> weapon_list = fig_group.get(0).getArmes();
+		ArrayList<Aptitude> aptitude_list = fig_group.get(0).getAptitudes();
+		
+		weapons_aptitudes_menu.setArmes(weapon_list);
+		weapons_aptitudes_menu.setAptitudes(aptitude_list);
+		weapons_aptitudes_menu.setAptAndWeapons(fig_group); // contenu de la vue
+		AfficheSimulation.refreshWeaponAndAptitude(weapons_aptitudes_menu); // insersion dans la vue principale
+	}
+	
+	public static void selectAWeapon(SimAptAndWeaponsVBox view, String weapon_name, ArrayList<Figurine> fig_group, FlowPane weapon_stats) {
+		Arme weapon = fig_group.get(0).getWeaponByName(weapon_name); // recherche dans les armes de la 1ère figurine
+		// on équipe le groupe
+		for(Figurine fig : fig_group) {
+			fig.setWeapon(weapon);
+		}
+		weapon_stats.getChildren().clear();
+		view.setWeaponStats(weapon, weapon_stats);
+	}
+	
+	public static void AliveFigsChoice(int col, int value, String group_name) {
+		// on considère que ceux qui n'attaquent pas sont morts
+		ArrayList<Figurine> fig_group = Battle.getSelectedUnit(col).getIdenticalFigsGroups().get(group_name);
+		for(int i = 0; i < value; i++) {
+			fig_group.get(i).setHP(fig_group.get(i).getHPMax());
+		}
+		for(int i = value; i < fig_group.size(); i++) {
+			fig_group.get(i).setHP(0);
+		}
+		
+		System.out.println("weaponNumberChoice => trouver un moyen de modifier instantanément les images");
+	}
+	
+	public static void checkOrUncheckAnAptitude(boolean isSelected, String aptitude_name, ArrayList<Figurine> fig_group) {
+		for(Aptitude apti : fig_group.get(0).getAptitudes()) // recherche dans les aptitudes de la 1ère figurine
+		{
+			if(apti.getName() == aptitude_name) {
+				for(Figurine fig : fig_group)
+				{
+					HashMap<String, Aptitude> selectedAptitudes = fig.getSelectedAptitudes();
+					if(isSelected) {
+						selectedAptitudes.put(aptitude_name, apti);
+					}
+					else {
+						if(selectedAptitudes.containsKey(aptitude_name)) {
+							selectedAptitudes.remove(aptitude_name);
+						}
+					}
+				}
+				break; // on ne gère pas le cas où deux aptitudes ont le même nom
+			}
+		}
+	}
+	
+	// histogramme
+	public static void afficheSimu(Pane p,Unit u1,Unit u2) {
+		p.getChildren().clear();
+		Calcul c =Calcul.bataille(u1, u2);
+		
+		SimHistogramme.setHist(c.getTabdegat1(), c.getTabmort1(), c.getDegat_moyen1(), c.getMort_moyen1(),p);
+	}
+
+	public static void reverseArmies(ArrayList<ChoiceBox<String>> lists_drop_down) {
+		Battle.reverseArmies();
+		AfficheSimulation.inversion = true;
+		for(int i = 0; i < 2; i++)
+        {
+			// déclenche la sélection d'une liste dans le menu déroulant, mais avec du code
+			lists_drop_down.get(i).getSelectionModel().select(Battle.getSelectedList(i + 1).getName());
+			Battle.setSelectedUnit(i + 1, -1); // plus d'unité sélectionnée
+        }
+		AfficheSimulation.inversion = false;
+	}
+}
diff --git a/src/main/java/controlleur/CreationCompte.java b/src/main/java/controlleur/CreationCompte.java
new file mode 100644
index 0000000..0cd78ba
--- /dev/null
+++ b/src/main/java/controlleur/CreationCompte.java
@@ -0,0 +1,38 @@
+package controlleur;
+
+import java.util.ArrayList;
+
+import javafx.stage.Stage;
+import modele.User;
+import vue.AfficheAccueil;
+import vue.AfficheConnexion;
+import vue.AfficheConnexionFailed;
+
+public class CreationCompte {
+	public static void verif(String Email, String Pseudo, String Mdp, Stage primaryStage) {
+
+		Email = Email.trim();
+		Pseudo = Pseudo.trim();
+		Mdp = Mdp.trim();
+		BDD conec = new BDD();
+		ArrayList<String> crea = conec.creerUtilisateur(Email, Pseudo, Mdp);
+		int id = conec.UtilisateurID(Pseudo, Mdp);
+		String role = conec.UtilisateurRole(Pseudo, Mdp);
+		User session = new User(Pseudo,id,role);
+		conec.close();
+		if (!crea.isEmpty() && Email.equals(crea.getFirst().trim())) {
+
+			System.out.println("Compté créé" + crea);
+			primaryStage.close();
+			AfficheAccueil.affiche(primaryStage, session);
+		} else {
+			System.out.println("échec de la création de compte" + crea);
+			AfficheConnexionFailed.affiche(primaryStage);
+		}
+	}
+	
+	public static void getBack(Stage primaryStage) {
+		AfficheConnexion.affiche(primaryStage);
+	}
+
+}
diff --git a/src/main/java/controlleur/EvenementController.java b/src/main/java/controlleur/EvenementController.java
new file mode 100644
index 0000000..ad21353
--- /dev/null
+++ b/src/main/java/controlleur/EvenementController.java
@@ -0,0 +1,267 @@
+package controlleur;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import javafx.geometry.Pos;
+import javafx.scene.control.Button;
+import javafx.scene.control.Label;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.VBox;
+import modele.Evenement;
+import vue.AfficheAdmin;
+
+
+public class EvenementController {
+	private static int nbrEvt;
+	
+	public void setNbrEvt(int nbrEvt) {
+		EvenementController.nbrEvt = nbrEvt;
+	}
+
+	private static ArrayList<String> nom_event;
+	private static ArrayList<String> nom_image;
+	private static ArrayList<String> desc_event;
+	private static ArrayList<String> date_event;
+	
+	
+    public ArrayList<String> getNom_event() {
+		return nom_event;
+	}
+
+	public ArrayList<String> getNom_image() {
+		return nom_image;
+	}
+
+	public ArrayList<String> getDesc_event() {
+		return desc_event;
+	}
+
+	public ArrayList<String> getDate_event() {
+		return date_event;
+	}
+
+	//EvenementController permet de recenser tous les évènements sous forme d'ArrayList<String> 
+	//Le rôle de ce constructeur a changé pas mal de fois, d'où un nom peu cohérent...
+	public EvenementController() {
+		
+		nbrEvt = 0;
+		
+		nom_event= new ArrayList<String>();
+		nom_image= new ArrayList<String>();
+		desc_event= new ArrayList<String>();
+		date_event= new ArrayList<String>();
+		
+		
+        // Créer une instance de BDD
+        BDD bdd = new BDD();
+        
+        try {
+            // Requête SQL
+            String sql = "SELECT * FROM evenement";  // Requête
+            PreparedStatement ps = bdd.getPreparedStatement(sql);
+
+            // Exécution de la requête
+            ResultSet rs = ps.executeQuery();
+            
+
+            // Traiter les résultats
+            while (rs.next()) {
+            	int i=0;
+            	nbrEvt = getNbrEvt() + 1;
+            	
+            	String nom_evt = rs.getString("nom_evenement");
+                String nom_img = rs.getString("nom_image");
+                String desc_evt = rs.getString("description_evenement");
+                String date_evt = rs.getString("date_evenement");
+                
+                nom_event.add(nom_evt);
+                nom_image.add(nom_img);
+                desc_event.add(desc_evt);
+                date_event.add(date_evt);
+
+                // Afficher les résultats ou les ajouter à une liste/structure de données
+                System.out.println("Image : " + nom_img);
+                System.out.println("Événement : " + nom_evt);
+                System.out.println("Description : " + desc_evt);
+                System.out.println("Date : " + date_evt);
+                i++;
+            }
+        } catch (SQLException e) {
+            System.err.println("Erreur lors de l'accès à la base de données : " + e.getMessage());
+        } finally {
+            // Être sûr de fermer la connexion à la base de données
+            bdd.close();
+        }
+    }
+    
+	//Méthode pour insérer un évènement dans la BDD ainsi que d'ajouter cet évènement dans EvenementController
+    public static void insererEvenement(Evenement evt) {
+        // Créer une instance de BDD
+        BDD bdd = new BDD();
+        try {
+            // Requête SQL
+            String sql = "INSERT INTO evenement (nom_evenement, nom_image, description_evenement, date_evenement, id_utilisateur) VALUES (?, ?, ?, ?, 3)";  // Requête
+            PreparedStatement ps = bdd.getPreparedStatement(sql);
+            
+	        // Associer les valeurs aux paramètres
+	        ps.setString(1, evt.getNom_evenement());
+	        ps.setString(2, evt.getNom_image());
+	        ps.setString(3, evt.getDescritption_evenement());
+	        ps.setString(4, evt.getData_evenement());
+	        
+	        Connexion.eventC.getNom_event().add(evt.getNom_evenement());
+	        Connexion.eventC.getNom_image().add(evt.getNom_image());
+	        Connexion.eventC.getDesc_event().add(evt.getDescritption_evenement());
+	        Connexion.eventC.getDate_event().add(evt.getData_evenement());
+	        
+	        Connexion.eventC.setNbrEvt(Connexion.eventC.getNbrEvt()+1);
+	        
+	        // Exécution de la requête
+	        ps.executeUpdate();
+	        System.out.println("Insertion réussiedans la base données");
+
+        } catch (SQLException e) {
+            System.err.println("Erreur lors de l'accès à la base de données : " + e.getMessage());
+        } finally {
+            // Être sûr de fermer la connexion à la base de données
+            bdd.close();
+        }
+    }
+    
+    
+    public static VBox EvenementVBox() {
+        VBox event = new VBox();
+        event.setPrefHeight(50);
+        event.setAlignment(Pos.CENTER);
+            
+        for (int i = 0; i < Connexion.eventC.getNbrEvt() ; i++) {
+        	            	
+            	HBox hevent = new HBox();
+            	hevent.setAlignment(Pos.CENTER);
+            	hevent.setPrefHeight(50);
+
+            	String num_evt = new String(i+1+". ");
+            	Label numLabel = new Label(num_evt);
+            	numLabel.setPrefWidth(25);
+            	hevent.getChildren().add(numLabel);
+            	
+            	
+            	String nom_evt = Connexion.eventC.getNom_event().get(i);
+            	Label nomLabel = new Label(nom_evt);
+            	nomLabel.setPrefWidth(150);
+            	hevent.getChildren().add(nomLabel);
+            	
+            	String nom_img = Connexion.eventC.getNom_image().get(i);
+            	Label imgLabel = new Label(nom_img);
+            	imgLabel.setPrefWidth(150);
+            	hevent.getChildren().add(imgLabel);
+            	
+                String desc_evt = Connexion.eventC.getDesc_event().get(i);
+                Label descLabel = new Label(desc_evt);
+                descLabel.setPrefWidth(150);
+            	hevent.getChildren().add(descLabel);
+            	
+                String date_evt = Connexion.eventC.getDate_event().get(i);
+                Label dateLabel = new Label(date_evt);
+                dateLabel.setPrefWidth(100);
+            	hevent.getChildren().add(dateLabel);
+            	
+            	Button bouton = new Button("X");
+    		    hevent.getChildren().add(bouton);
+                
+    		    Evenement evt = new Evenement(nom_evt,nom_img,desc_evt,date_evt);
+    		    
+    		    bouton.setOnAction(e -> {
+    		        EvenementController.supprimerEvenement(evt);
+    		        
+    		    });
+    		    
+    		    event.getChildren().add(hevent);
+                
+            }
+            
+        return event;
+    }
+
+    
+	// Méthode "supprimer" modifiée pour accepter un argument
+	public static void supprimerEvenement(Evenement evt) {
+		// Créer une instance de BDD
+		BDD bdd = new BDD();
+		try {
+		    // Requête SQL
+		    String sql = "DELETE FROM evenement WHERE nom_evenement = ?";  // Requête DELETE
+		    PreparedStatement ps = bdd.getPreparedStatement(sql);
+		    
+		    // Associer l'ID de l'événement à supprimer
+		    ps.setString(1, evt.getNom_evenement());
+		    
+		    // Exécution de la requête
+		    int rowsAffected = ps.executeUpdate();
+		    if (rowsAffected > 0) {
+		    	EvenementController.effacerImage(evt.getNom_image());
+		    	
+		        Connexion.eventC.getNom_event().remove(evt.getNom_evenement());
+		        Connexion.eventC.getNom_image().remove(evt.getNom_image());
+		        Connexion.eventC.getDesc_event().remove(evt.getDescritption_evenement());
+		        Connexion.eventC.getDate_event().remove(evt.getData_evenement());
+		        
+		        Connexion.eventC.setNbrEvt(Connexion.eventC.getNbrEvt()-1);
+		    	
+		    	
+		    	AfficheAdmin.setEvents(EvenementController.EvenementVBox());
+	            Connexion.event = new Evenement(Connexion.eventC.getNom_event().get(0),
+	            		Connexion.eventC.getNom_image().get(0),
+	            		Connexion.eventC.getDesc_event().get(0),
+	            		Connexion.eventC.getDate_event().get(0));
+	    		System.out.println(Connexion.eventC.getNom_image().get(0));
+		    	AfficheAdmin.affiche(AfficheAdmin.getStage(), AfficheAdmin.getSess());
+		    	
+
+		        System.out.println("Suppression réussie dans la base de données");
+		        
+		        
+		    } else {
+		        System.out.println("Aucun événement trouvé avec cet ID.");
+		    }
+		    
+		    
+
+		} catch (SQLException e) {
+		    System.err.println("Erreur lors de l'accès à la base de données : " + e.getMessage());
+		} finally {
+		    // Être sûr de fermer la connexion à la base de données
+		    bdd.close();
+		}
+		
+	}
+	
+	public static void effacerImage(String nom_img) {
+	    String file_name = ControllerAdmin.getDestinationDir()+"/"+nom_img;
+	    
+	    Path path = Paths.get(file_name);
+	    try {
+	      boolean result = Files.deleteIfExists(path);
+	      if (result) {
+	        System.out.println("Image effacée !");
+	      } else {
+	        System.out.println("Oups, impossible d'effacer.");
+	      }
+	    } catch (IOException e) {
+	      e.printStackTrace();
+	    }
+	}
+
+	public int getNbrEvt() {
+		return nbrEvt;
+	}
+}
diff --git a/src/main/java/controlleur/GestionListe.java b/src/main/java/controlleur/GestionListe.java
new file mode 100644
index 0000000..bd37589
--- /dev/null
+++ b/src/main/java/controlleur/GestionListe.java
@@ -0,0 +1,82 @@
+package controlleur;
+
+import java.io.File;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+import javafx.stage.FileChooser;
+import javafx.stage.Stage;
+import modele.ArmeeListe;
+
+public class GestionListe {
+
+	// Objet pour gérer la connexion à la bdd
+	private BDD conec;
+
+	// Constructeur de la clasee qui initialise la connexion à la bdd
+	public GestionListe() {
+		this.conec = new BDD();
+	}
+
+	// récupération de l'id utilisateur et les listes d'armée
+	public ArrayList<ArmeeListe> getArmeeListe(int idUtilisateur) {
+	    ArrayList<ArmeeListe> listes = new ArrayList<>();
+	    // Requête pour récupérer les listes d'armée avec leurs unités associées
+	    String requete = """
+	        SELECT l.id_liste, l.nom_liste, l.description_liste, l.data_liste, u.nom_unite, u.id_armee
+	        FROM liste l
+	        LEFT JOIN contenir c ON l.id_liste = c.id_liste
+	        LEFT JOIN unite u ON c.id_unite = u.id_unite
+	        WHERE l.id_utilisateur = ?
+	    """;
+
+	    try (Connection conn = conec.getConnection();
+	         PreparedStatement stmt = conn.prepareStatement(requete)) {
+
+	        stmt.setInt(1, idUtilisateur);
+	        ResultSet recup = stmt.executeQuery();
+	        // Stocker les objets ArmeeListe par ID pour éviter les doublons
+	        HashMap<Integer, ArmeeListe> mapListes = new HashMap<>();
+	        System.out.print(stmt + "côté controlleur");
+	        while (recup.next()) {
+	            int id = recup.getInt("id_liste");
+	            String nom = recup.getString("nom_liste");
+	            String description = recup.getString("description_liste");
+	            String data = recup.getString("data_liste");
+	            String nomUnite = recup.getString("nom_unite");
+	            int idArmee = recup.getInt("id_armee");
+	            // Vérifier si la liste existe déjà dans la map
+	            ArmeeListe liste = mapListes.get(id);
+	            if (liste == null) {
+	                liste = new ArmeeListe(id, idArmee, nom, description, data, idArmee);
+	                liste.setUniteListe(new ArrayList<>()); // Initialiser la liste des unités
+	                mapListes.put(id, liste);
+	            }
+
+	            // Ajouter l'unité si elle existe (éviter null)
+	            if (nomUnite != null) {
+	                liste.getUniteListe().add(nomUnite);
+	            }
+	        }
+
+	        listes.addAll(mapListes.values());
+
+	    } catch (SQLException e) {
+	        e.printStackTrace();
+	    }
+
+	    return listes;
+	}
+	
+	public static void importer(Stage primaryStage, File file) {
+		FileChooser fileChooser = new FileChooser();
+        fileChooser.getExtensionFilters().add(new FileChooser.ExtensionFilter("Fichier de liste d'armée", "*.*"));
+        file = fileChooser.showOpenDialog(primaryStage);
+        
+        // parsing du fichier
+	}
+}
diff --git a/src/main/java/controlleur/Instanciation.java b/src/main/java/controlleur/Instanciation.java
new file mode 100644
index 0000000..3ee39d0
--- /dev/null
+++ b/src/main/java/controlleur/Instanciation.java
@@ -0,0 +1,304 @@
+package controlleur;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+
+
+import application.Battle;
+import modele.Aptitude;
+import modele.AptitudeArme;
+import modele.Arme;
+import modele.ArmeDist;
+import modele.ArmeMelee;
+import modele.Armee;
+import modele.ArmeeListe;
+import modele.Faction;
+import modele.Figurine;
+import modele.Unit;
+import modele.User;
+
+public class Instanciation {
+
+	
+	//classe qui fait des appel à la BDD pour instancier les classes modele
+	
+	private static BDD conec;
+	private static Battle battle_data = new Battle();
+	
+	public static Battle getBattleData() {
+		return battle_data;
+	}
+	public static void resetBattle() {
+		battle_data = null;
+		battle_data = new Battle();
+	}
+	
+	//recupere la liste des faction de la BDD
+	public static ArrayList<Faction> getFaction() {
+		
+		ArrayList<Faction> rendu = new ArrayList<Faction>();
+		ArrayList<String> nom = new ArrayList<String>();
+		try {
+			conec = new BDD();
+			nom = conec.select("SELECT nom_faction FROM faction;" );
+			
+			for (String string : nom) {
+				rendu.add(new Faction(string));
+			}
+			
+		}catch(SQLException e) {
+			
+		}
+		conec.close();
+		return rendu;
+	}
+	
+	//recupere la liste des armée d'une Faction précise
+	public static ArrayList<Armee> getArmee(Faction faction){
+		ArrayList<Armee> rendu = new ArrayList<Armee>();
+		ArrayList<String> nom = new ArrayList<String>();
+		try {
+			conec = new BDD();
+
+			nom = conec.select("SELECT a.nom_armee,a.logo_armee FROM armee a JOIN faction f USING (id_faction) WHERE f.nom_faction = ?;",faction.getNom() );
+			
+			
+			for (int i = 0;i<nom.size();i = i+2) {
+				
+				rendu.add(new Armee(nom.get(i),nom.get(i+1),faction));
+			}
+			
+		}catch(SQLException e) {
+			
+		}
+		conec.close();
+		return rendu;
+	}
+	
+	//Récupere la liste des unités d'une armée précise
+	public static ArrayList<Unit> getUniteOfArmy(Armee armee){
+		ArrayList<Unit> rendu = new ArrayList<Unit>();
+		ArrayList<String> nom = new ArrayList<String>();
+		try {
+			conec = new BDD();
+			nom = conec.select("SELECT u.id_unite, u.nom_unite,  u.points_unite,u.logo_unite FROM unite u JOIN armee a USING (id_armee) WHERE a.nom_armee = ? LIMIT 20;",armee.getName() );
+			
+			
+			for (int i = 0;i<nom.size();i = i+4) {
+				rendu.add(new Unit(Instanciation.getFigurine(nom.get(i+1)),Integer.parseInt(nom.get(i)),nom.get(i+1), Integer.parseInt(nom.get(i+2)),nom.get(i+3),armee));
+			}
+			
+			
+			
+			
+		}catch(SQLException e) {
+			
+		}
+		conec.close();
+		return rendu;
+	}
+	
+	public static ArrayList<Unit> getUniteOfArmyLimited(Armee armee){
+		ArrayList<Unit> rendu = new ArrayList<Unit>();
+		ArrayList<String> nom = new ArrayList<String>();
+		try {
+			conec = new BDD();
+			nom = conec.select("SELECT u.id_unite, u.nom_unite,  u.points_unite,u.logo_unite FROM unite u JOIN armee a USING (id_armee) WHERE a.nom_armee = ? LIMIT 20;",armee.getName() );
+			
+			
+			for (int i = 0;i<nom.size();i = i+4) {
+				rendu.add(new Unit(null,Integer.parseInt(nom.get(i)),nom.get(i+1), Integer.parseInt(nom.get(i+2)),nom.get(i+3),armee));
+			}
+			
+			
+			
+			
+		}catch(SQLException e) {
+			
+		}
+		conec.close();
+		return rendu;
+	}
+	
+	
+	public static void getArmyLists(User session)
+	{
+		conec = new BDD();
+		String sql = "SELECT nom_liste, description_liste, data_liste FROM liste WHERE id_utilisateur = ?;";
+		try {
+			PreparedStatement stat = conec.getPreparedStatement(sql, session.getId());
+			ResultSet rs = stat.executeQuery();
+			session.getListes().clear();
+			while(rs.next()){
+				ArmeeListe one_list = new ArmeeListe(rs.getString("nom_liste"), rs.getString("description_liste"), rs.getString("data_liste"));
+				session.addArmee(one_list);
+			}
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+		conec.close();
+	}
+	
+	public static void getUnitsOfAList(ArmeeListe list) {
+		conec = new BDD();
+		String sql = "SELECT nom_unite, points_unite, logo_unite, nom_armee, logo_armee"
+			+ " FROM unite JOIN contenir USING (id_unite) JOIN liste USING (id_liste) JOIN armee USING (id_armee)"
+			+ " WHERE liste.nom_liste = ? AND unite.id_unite = contenir.id_unite AND contenir.id_liste = liste.id_liste;";
+		
+		try {
+			PreparedStatement stat = conec.getPreparedStatement(sql, list.getName());
+			ResultSet rs = stat.executeQuery();
+			
+			while(rs.next()) {
+				list.addUnit(new Unit(Instanciation.getFigurine(rs.getString(1)),
+						rs.getString(1), rs.getInt(2), rs.getString(3),
+						new Armee(rs.getString(4), rs.getString(5))));
+			}
+		}
+		catch (SQLException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		conec.close();
+	}
+	
+	//Récupere les Figurine présente dans une unité précise
+	public static ArrayList<Figurine> getFigurine(String unitName){
+		ArrayList<Figurine> rendu = new ArrayList<Figurine>();
+		ArrayList<String> temp = new ArrayList<String>();
+		try {
+			
+			temp = conec.select("SELECT f.nom_figurine,f.M,f.E,f.SV,f.PV,f.CD,f.CO,r.nb_figurine FROM figurine f "
+					+ "JOIN remplir r USING (id_figurine) JOIN unite u USING(id_unite) WHERE u.nom_unite = ?;",unitName );
+			
+			
+			for (int i = 0;i<temp.size();i = i+8) {
+				for (int j =0;j< Integer.parseInt(temp.get(7));j++) {
+					rendu.add(new Figurine(Instanciation.getArme(temp.get(i)),Instanciation.getAptitude(temp.get(i)),temp.get(i),"",temp.get(i+1),Integer.parseInt(temp.get(i+2)),Integer.parseInt(temp.get(i+3)),Integer.parseInt(temp.get(i+4)),Integer.parseInt(temp.get(i+5)),Integer.parseInt(temp.get(i+6))));
+			
+				}
+			}
+			
+			
+			
+			
+		}catch(SQLException e) {
+			
+		}
+		
+		return rendu;
+	}
+	
+	public static ArrayList<Figurine> getFigurine2(String unitName){
+		ArrayList<Figurine> rendu = new ArrayList<Figurine>();
+		ArrayList<String> temp = new ArrayList<String>();
+		try {
+			conec = new BDD();
+			temp = conec.select("SELECT f.nom_figurine,f.M,f.E,f.SV,f.PV,f.CD,f.CO,r.nb_figurine FROM figurine f "
+					+ "JOIN remplir r USING (id_figurine) JOIN unite u USING(id_unite) WHERE u.nom_unite = ?;",unitName );
+			
+			
+			for (int i = 0;i<temp.size();i = i+8) {
+				for (int j =0;j< Integer.parseInt(temp.get(7));j++) {
+					rendu.add(new Figurine(Instanciation.getArme(temp.get(i)),Instanciation.getAptitude(temp.get(i)),temp.get(i),"",temp.get(i+1),Integer.parseInt(temp.get(i+2)),Integer.parseInt(temp.get(i+3)),Integer.parseInt(temp.get(i+4)),Integer.parseInt(temp.get(i+5)),Integer.parseInt(temp.get(i+6))));
+			
+				}
+			}
+			
+			
+			
+			
+		}catch(SQLException e) {
+			
+		}
+		conec.close();
+		return rendu;
+	}
+	
+	//Récupère les armes d'une figurine donnée
+	public static ArrayList<Arme> getArme(String figNom){
+		ArrayList<Arme> rendu = new ArrayList<Arme>();
+		ArrayList<String> nom = new ArrayList<String>();
+		try {
+			
+			nom = conec.select("SELECT a.nom_arme,a.PORTEE,a.A,a.F,a.PA,a.D,t.CT,m.CC FROM figurine f JOIN equiper e USING(id_figurine) JOIN arme a USING (id_arme) LEFT JOIN tir t USING (id_tir) LEFT JOIN melee m USING(id_melee) WHERE f.nom_figurine = ?;",figNom );
+			
+			
+			for (int i = 0;i<nom.size();i = i+8) {
+				if (nom.get(i+7) == null) {
+					rendu.add(new ArmeDist(nom.get(i),Instanciation.getAptitudeArme(nom.get(i)),nom.get(i+1),nom.get(i+2),Integer.parseInt(nom.get(i+3)),Integer.parseInt(nom.get(i+4)),nom.get(i+5),Integer.parseInt(nom.get(i+6))));
+				}else {
+					rendu.add(new ArmeMelee(nom.get(i),Instanciation.getAptitudeArme(nom.get(i)),nom.get(i+1),nom.get(i+2),Integer.parseInt(nom.get(i+3)),Integer.parseInt(nom.get(i+4)),nom.get(i+5),Integer.parseInt(nom.get(i+7))));
+				}
+			}
+			
+			
+			
+			
+			
+		}catch(SQLException e) {
+			
+		}
+		
+		return rendu;
+	}
+	
+	//Récupère les Aptitude d'une figurine donnée
+	public static ArrayList<Aptitude> getAptitude(String figNom){
+		ArrayList<Aptitude> rendu = new ArrayList<Aptitude>();
+		ArrayList<String> nom = new ArrayList<String>();
+		try {
+			
+			nom = conec.select("SELECT a.nom_aptitude FROM aptitude a JOIN permettre USING (id_aptitude) JOIN figurine f USING(id_figurine) WHERE f.nom_figurine = ?;",figNom );
+			
+			
+			for (int i = 0;i<nom.size(); i++) {
+				rendu.add(new Aptitude(nom.get(i)));
+			}
+			
+			
+			
+			
+			
+			
+		}catch(SQLException e) {
+			
+		}
+		
+		return rendu;
+	}
+	
+	//Récupère les Aptitude d'une arme donnée
+	public static ArrayList<AptitudeArme> getAptitudeArme(String armeNom){
+		ArrayList<AptitudeArme> rendu = new ArrayList<AptitudeArme>();
+		ArrayList<String> nom = new ArrayList<String>();
+		try {
+			
+			nom = conec.select("SELECT a.nom_aptitude_arme FROM aptitude_arme a JOIN posseder USING (id_aptitude_arme) JOIN arme ar USING(id_arme) WHERE ar.nom_arme = ?;",armeNom );
+			
+			
+			for (int i = 0;i<nom.size();i = i++) {
+				rendu.add(new AptitudeArme(nom.get(i)));
+			}
+			
+			
+			
+			
+			
+		}catch(SQLException e) {
+			
+		}
+		
+		return rendu;
+	}
+	
+	//Insert une Armée crée dans l'application dans la base de donée en la liant à un utilisateur
+	public static void insertListe(ArmeeListe armee,User session) {
+		conec = new BDD();
+		conec.insertListe(armee, session);
+		conec.close();
+	}
+	
+}
diff --git a/src/main/java/controlleur/ModificationListe.java b/src/main/java/controlleur/ModificationListe.java
new file mode 100644
index 0000000..7de1b59
--- /dev/null
+++ b/src/main/java/controlleur/ModificationListe.java
@@ -0,0 +1,214 @@
+package controlleur;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+import modele.ArmeeListe;
+import modele.Figurine;
+
+public class ModificationListe {
+
+    private BDD conec; // Instance de la classe BDD qui gère la connexion à la bdd
+
+    public ModificationListe() {
+        this.conec = new BDD();
+    }
+
+    // Récupère la liste des armées en fonction de l'id de la liste choisie
+    public ArrayList<ArmeeListe> getArmeeListe(int idListe) {
+        ArrayList<ArmeeListe> listes = new ArrayList<>();
+        String requete = """
+            SELECT l.id_liste, l.nom_liste, l.description_liste, l.data_liste, u.nom_unite
+            FROM liste l
+            LEFT JOIN contenir c ON l.id_liste = c.id_liste
+            LEFT JOIN unite u ON c.id_unite = u.id_unite
+            WHERE l.id_liste = ?;
+        """;
+
+        try (Connection conn = reopenConnection();
+             PreparedStatement stmt = conn.prepareStatement(requete)) {
+
+            stmt.setInt(1, idListe);
+            ResultSet recup = stmt.executeQuery();
+            HashMap<Integer, ArmeeListe> mapListes = new HashMap<>();
+
+            while (recup.next()) {
+                int id = recup.getInt("id_liste");
+                String nom = recup.getString("nom_liste");
+                String description = recup.getString("description_liste");
+                String data = recup.getString("data_liste");
+                String nomUnite = recup.getString("nom_unite");
+
+                ArmeeListe liste = mapListes.get(id);
+                if (liste == null) {
+                    liste = new ArmeeListe(id, id, nom, description, data, id);
+                    liste.setUniteListe(new ArrayList<>());
+                    mapListes.put(id, liste);
+                }
+
+                if (nomUnite != null) {
+                    liste.getUniteListe().add(nomUnite);
+                }
+            }
+            listes.addAll(mapListes.values());
+
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+        return listes;
+    }
+
+    public ArrayList<Figurine> getFigurineListe(int idListe, String nomUnit) {
+        ArrayList<Figurine> listesFigurine = new ArrayList<>();
+        String requete = """
+            SELECT f.nom_figurine, f.M, f.E, f.SV, f.PV, f.CD, f.CO
+            FROM liste l
+            JOIN contenir c ON l.id_liste = c.id_liste
+            JOIN unite u ON c.id_unite = u.id_unite
+            JOIN remplir r ON u.id_unite = r.id_unite
+            JOIN figurine f ON r.id_figurine = f.id_figurine
+            WHERE l.id_liste = ? AND u.nom_unite = ?;
+        """;
+
+        try (Connection conn = reopenConnection();
+             PreparedStatement stmt = conn.prepareStatement(requete)) {
+
+            stmt.setInt(1, idListe);
+            stmt.setString(2, nomUnit);
+            ResultSet recup = stmt.executeQuery();
+
+            while (recup.next()) { // récupère toutes les info de la figurine
+                String nomFigurine = recup.getString("nom_figurine");
+                String M = recup.getString("M");
+                int E = recup.getInt("E");
+                int SV = recup.getInt("SV");
+                int PV = recup.getInt("PV");
+                int CD = recup.getInt("CD");
+                int CO = recup.getInt("CO");
+
+                Figurine figurine = new Figurine(new ArrayList<>(), new ArrayList<>(), nomFigurine, "", M, E, SV, PV, CD, CO);
+                listesFigurine.add(figurine);
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+        return listesFigurine;
+    }
+
+    public ArrayList<ArmeeListe> getAllUnites(int idArmee, int idListe) {
+        ArrayList<ArmeeListe> toutesUnites = new ArrayList<>();
+        String requete = "SELECT u.nom_unite\r\n"
+        		+ "FROM unite u\r\n"
+        		+ "WHERE u.id_armee = ?\r\n"
+        		+ "AND u.nom_unite NOT IN (\r\n"
+        		+ "    SELECT un.nom_unite\r\n"
+        		+ "    FROM unite un\r\n"
+        		+ "    JOIN contenir c ON un.id_unite = c.id_unite\r\n"
+        		+ "    WHERE c.id_liste = ?\r\n"
+        		+ ");";
+
+        try (Connection conn = reopenConnection();
+             PreparedStatement stmt = conn.prepareStatement(requete)) {
+
+            stmt.setInt(1, idArmee);
+            stmt.setInt(2, idListe);
+            ResultSet recup = stmt.executeQuery();
+
+            while (recup.next()) {
+                String nomUnite = recup.getString("nom_unite");
+                ArmeeListe armee = new ArmeeListe(idArmee, idArmee, nomUnite, nomUnite, nomUnite, idListe);
+                armee.setUniteListe(new ArrayList<>());
+                armee.getUniteListe().add(nomUnite);
+                toutesUnites.add(armee);
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+        return toutesUnites;
+    }
+
+    public ArrayList<Figurine> getAllFigurineListe(int idArmee, String unit) {
+        ArrayList<Figurine> listesAllFigurine = new ArrayList<>();
+        String requete = """
+            SELECT DISTINCT f.nom_figurine, f.M, f.E, f.SV, f.PV, f.CD, f.CO
+            FROM unite u
+            JOIN remplir r ON u.id_unite = r.id_unite
+            JOIN figurine f ON r.id_figurine = f.id_figurine
+            WHERE u.id_armee = ? AND u.nom_unite = ?;
+        """;
+
+        try (Connection conn = reopenConnection();
+             PreparedStatement stmt = conn.prepareStatement(requete)) {
+
+            stmt.setInt(1, idArmee);
+            stmt.setString(2, unit);
+            ResultSet recup = stmt.executeQuery();
+
+            while (recup.next()) { // récupère toutes les info de la figurine
+                String nomFigurine = recup.getString("nom_figurine");
+                String M = recup.getString("M");
+                int E = recup.getInt("E");
+                int SV = recup.getInt("SV");
+                int PV = recup.getInt("PV");
+                int CD = recup.getInt("CD");
+                int CO = recup.getInt("CO");
+
+                Figurine figurine = new Figurine(new ArrayList<>(), new ArrayList<>(), nomFigurine, "", M, E, SV, PV, CD, CO);
+                listesAllFigurine.add(figurine);
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+        return listesAllFigurine;
+    }
+
+    private Connection reopenConnection() throws SQLException {
+        if (conec.getConnection().isClosed()) {
+            conec = new BDD();
+        }
+        return conec.getConnection();
+    }
+
+    public void ajouterUnites(int idListe, ArrayList<String> unites) {
+        String query =  """
+        	    INSERT INTO contenir (id_unite, id_liste)
+        	    SELECT id_unite, ? FROM unite WHERE nom_unite = ? LIMIT 1
+        	""";
+        try (Connection conn = reopenConnection();
+             PreparedStatement pstmt = conn.prepareStatement(query)) {
+
+            for (String unite : unites) {
+                pstmt.setInt(1, idListe);
+                pstmt.setString(2, unite);
+                System.out.println("Requête: " + pstmt);
+                pstmt.addBatch();
+            }
+            pstmt.executeBatch();
+
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void supprimerUnites(int idListe, ArrayList<String> unites) {
+        String query = "DELETE FROM contenir WHERE id_liste = ? AND id_unite = (SELECT id_unite FROM unite WHERE nom_unite = ? LIMIT 1)";
+        try (Connection conn = reopenConnection();
+             PreparedStatement pstmt = conn.prepareStatement(query)) {
+
+            for (String unite : unites) {
+                pstmt.setInt(1, idListe);
+                pstmt.setString(2, unite);
+                System.out.println("Requête: " + pstmt);
+                pstmt.addBatch();
+            }
+            pstmt.executeBatch();
+
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+}
diff --git a/src/main/java/controlleur/StockageCreerListe.java b/src/main/java/controlleur/StockageCreerListe.java
new file mode 100644
index 0000000..82f4448
--- /dev/null
+++ b/src/main/java/controlleur/StockageCreerListe.java
@@ -0,0 +1,75 @@
+package controlleur;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+import modele.Armee;
+import modele.ArmeeListe;
+import modele.Faction;
+import modele.Unit;
+
+public class StockageCreerListe {
+	
+	//sauvegarde les nom des armée, des unités et des factions pour ne pas refaire appel à la BDD en boucle
+	
+	private static final HashMap<String,Faction> faction = new HashMap<String, Faction>();
+	private static final HashMap<String,Armee> armee = new HashMap<String, Armee>();
+	private static final HashMap<String,Unit> unit = new HashMap<String, Unit>();
+	private static ArmeeListe armeeListe;
+	
+	
+	public static void initFaction() {
+		faction.clear();
+		for(Faction fac : Instanciation.getFaction()) {
+			faction.put(fac.getNom(), fac);
+		}
+	}
+	
+	public static ArrayList<String> getNomFac(){
+		ArrayList<String> rendu = new ArrayList<String>();
+		for(Faction fac :faction.values() ) {
+			rendu.add(fac.getNom());
+		}
+		return rendu;
+	}
+	
+	public static void initArmee(String nomFaction) {
+		armee.clear();
+		 for(Armee arm:Instanciation.getArmee(faction.get(nomFaction))) {
+			 armee.put(arm.getName(), arm);
+		 }
+	}
+
+	public static ArrayList<String> getNomArmee() {
+		ArrayList<String> rendu = new ArrayList<String>();
+		
+		for(String arm : armee.keySet()) {
+			rendu.add(arm);
+		}
+		//rendu.add(rendu.removeFirst());
+		return rendu;
+	}
+	public static void initUnit(String nomArmee) {
+		unit.clear();
+		for(Unit uni:Instanciation.getUniteOfArmyLimited(armee.get(nomArmee))) {
+			unit.put(uni.getName(), uni);
+		}
+	}
+	public static ArrayList<String> getNomUnit() {
+		ArrayList<String> rendu = new ArrayList<String>();
+		for(Unit uni : unit.values()) {
+			rendu.add(uni.getName());
+		}
+		
+		return rendu;
+	}
+	public static void initArmeeListe() {
+		armeeListe = new ArmeeListe(new ArrayList<Unit>(),"nom_temp","desc","data");
+	}
+	public static ArmeeListe getArmeeListe() {
+		return armeeListe;
+	}
+	public static Unit getUnit(String nomUnit) {
+		return unit.get(nomUnit);
+	}
+}
diff --git a/src/main/java/controlleur/SupprListe.java b/src/main/java/controlleur/SupprListe.java
new file mode 100644
index 0000000..6e2f488
--- /dev/null
+++ b/src/main/java/controlleur/SupprListe.java
@@ -0,0 +1,27 @@
+package controlleur;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+
+public class SupprListe {
+	private BDD conec;
+
+	public SupprListe() {
+		this.conec = new BDD();
+	}
+
+	public void Suppression(int idListe) {
+
+		String requeteSuppr = "DELETE FROM liste WHERE id_liste=?;";
+
+		try (Connection conn = conec.getConnection(); PreparedStatement stmt = conn.prepareStatement(requeteSuppr)) {
+
+			stmt.setInt(1, idListe);
+			stmt.executeUpdate();
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+	}
+
+}
-- 
cgit v1.2.3