/**
*Programme cree par The Clusters
*Classe de IHM graphique du plateau de chkoba 4 joueurs
*@see IHMPlateau.java
*@author The Clusters
*@version 1.0
**/

package chkoba;

import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
import java.io.*;
import java.util.Scanner;
import chkoba.*;
import java.util.ArrayList;

/**
*	Classe IHMPlateau4j
*/

public class IHMPlateau4j extends JFrame implements ActionListener
{
	private JPanel jpPrincipal, jpCentral, pdecoD, pdecoG, pdecoF, jpCartePlateau;
	private JTextField jtfNomJoueur1, jtfNomJoueur2, jtfNomJoueur3, jtfNomJoueur4, montscore, sontscore;
	private JMenuBar jmbMenu;
	private JMenu jmFichier,jmAffichage,jmAide,jmAPropos,jmInterro;
	private JMenuItem jmiNouveau,jmiStatistiques,jmiOption,jmiQuitter,jmiManuel,jmiAPropos,jmiAstuce,jmiRegles,jmiSkin;
	private JLabel monscore, sonscore,testPan4, mainJoueurFace, mainJoueurGauche, mainJoueurDroite, vide2, vide3, vide4, vide5, vide6, vide7, pioche, carteGagneAdv, vide8;
	private JLabel dessousTable1, dessousTable2, dessousTable3;	
	private DonneePartie adversaire, joueur;
	private ArrayList<BoutonCarte> carteTapis, carteMain;
	private BoutonCarte carteUnTemp, carteDeuxTemp, carteTroisTemp, carteGagneJoueur,carteCourante;
	private JButton chat, carteD;
	private Color c;
	private Couleur coul, coul1;
	private int val, val1, index, compt = 0; 
	private Integer nbjoueur;
	private Index ind;
	private int nbJoueursIA, numJoueur1=0, numJoueur2=1, numJoueur3=2, numJoueur4=3, nbJoueursMan, moniscore=0, soniscore=0;
	private IPlateau pl;
	private Toolkit tk = Toolkit.getDefaultToolkit();       
	private Point p = new Point(31, 31) ;
	private Image icon ;       
	private Cursor cursor ;
	private ArrayList<Integer> manuels, team1, team2;
	private ArrayList<ICarte> tmpTapis, aPrendre;
	private ICarte cartas;
	private ThreadActu4j thread;
	private boolean creer, numFait;
	private String nom, skin;
	private CarteRamassage cRam = new CarteRamassage();

	
	public IHMPlateau4j(Index i, boolean creer, ArrayList<Integer> tm1, ArrayList<Integer>tm2, int nbJoueursMan, String nom, int moniscore, int soniscore)
	{		
		String nom1="", nom2="", nom3="", nom4="";
		carteTapis=new ArrayList<BoutonCarte>();
		carteMain=new ArrayList<BoutonCarte>();
		aPrendre=new ArrayList<ICarte>();
		nbJoueursIA=4-nbJoueursMan;
		team1=new ArrayList<Integer>(tm1);
		team2=new ArrayList<Integer>(tm2);
		this.creer=creer;
		this.nbJoueursMan=nbJoueursMan;
		this.nom=nom;
		this.moniscore = moniscore;
		this.soniscore = soniscore;
		
		manuels = new ArrayList<Integer>();	
		
		for ( int z=1; z<=nbJoueursMan; z++)
		{
			manuels.add(z);
		}
		
		setTitle("Chkoba");
		setSize(1000, 800);
		setResizable(false);
		setBackground(c);
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		c = new Color(0,200,0);
		ind = i;
		tk = Toolkit.getDefaultToolkit();
		
		
		setIconImage(Toolkit.getDefaultToolkit().getImage(IHMPlateau.class.getResource("./icone.png")));	//permet de changer l'image dans le haut de la frame
		
		tmpTapis=new ArrayList<ICarte>();
		
		/*******************************
		/*Debut Ajout de la Barre de Menu
		/*******************************/
		jmbMenu = new JMenuBar();
		
			jmFichier = new JMenu("Fichier");
			
			jmiNouveau = new JMenuItem("Nouvelle Partie");
			jmiNouveau.addActionListener(this);
			jmFichier.add(jmiNouveau);
			
			jmiStatistiques = new JMenuItem("Statistiques");
			jmiStatistiques.addActionListener(this);
			jmFichier.add(jmiStatistiques);
			
			jmiOption = new JMenuItem("Option");
			jmiOption.addActionListener(this);
			jmFichier.add(jmiOption);
			
			jmiQuitter = new JMenuItem("Quitter");
			jmiQuitter.addActionListener(this);
			jmFichier.add(jmiQuitter);
			
		jmbMenu.add(jmFichier);
			
			jmAffichage = new JMenu("Affichage");
			jmiSkin = new JMenuItem("Skin");
			jmiSkin.addActionListener(this);
			jmAffichage.add(jmiSkin);
		jmbMenu.add(jmAffichage);

			jmAide = new JMenu("Aide");
			jmiManuel = new JMenuItem("Manuel");
			jmiManuel.addActionListener(this);
			jmAide.add(jmiManuel);

			jmiAstuce = new JMenuItem("Astuce");
			jmiAstuce.addActionListener(this);
			jmAide.add(jmiAstuce);
		jmbMenu.add(jmAide);
			
			jmInterro = new JMenu("?");
			jmiRegles = new JMenuItem("Regles");
			jmiRegles.addActionListener(this);
			jmInterro.add(jmiRegles);
			
			jmiAPropos = new JMenuItem("A propos");
			jmiAPropos.addActionListener(this);
			jmInterro.add(jmiAPropos);
		jmbMenu.add(jmInterro);
		
		setJMenuBar(jmbMenu);
		/*Fin Ajout de la Barre de Menu*/

		/***************************************
		/*Debut Ajout du panel de toute la fenetre
		/***************************************/
		jpPrincipal = new JPanel(new BorderLayout());
		jpPrincipal.setOpaque(true);

			
			/*****************************************
			/*Debut Ajout du panel a gauche de la fenetre
			/*****************************************/
			JPanel jpPartGauche = new JPanel(new GridLayout(3,1));
			jpPartGauche.setOpaque(true);
			
				
				/*******************************************************
				/*Debut Ajout du tableau de donnees concernant l'adversaire
				/*******************************************************/
				adversaire = new DonneePartie();
				adversaire.setPreferredSize(new Dimension(120,100));
			jpPartGauche.add(adversaire);
				/*******************************************************
				/*FIN Ajout du tableau de donnees concernant l'adversaire
				/*******************************************************/
				
				/*******************************************************
				/*Debut Ajout du d'un panel contenant une image de la pioche
				/*******************************************************/
				JPanel jpPlacePioche = new JPanel();
				jpPlacePioche.setOpaque(true);
					jpPlacePioche.setLayout(null);
					pioche = new JLabel();
					pioche.setBounds(20,20, 122, 193);
					pioche.setVisible(true);
				jpPlacePioche.add(pioche);
			jpPartGauche.add(jpPlacePioche);
				/*******************************************************
				/*FIN Ajout du d'un panel contenant une image de la pioche
				/*******************************************************/
			
				
				/***************************************************************
				/*Debut Ajout du d'un panel contenant une image des cartes ramasses
				/***************************************************************/
				JPanel jpPlaceCarteGagneJoueur = new JPanel();
				jpPlaceCarteGagneJoueur.setOpaque(true);
					jpPlaceCarteGagneJoueur.setLayout(null);
					carteGagneJoueur = new BoutonCarte();	
					carteGagneJoueur.setBounds(20,20, 90, 150);
					carteGagneJoueur.setVisible(false);
				jpPlaceCarteGagneJoueur.add(carteGagneJoueur);
			jpPartGauche.add(jpPlaceCarteGagneJoueur);
				/***************************************************************
				/*FIN Ajout du d'un panel contenant une image des cartes ramasses
				/***************************************************************/
		
		
		jpPrincipal.add(jpPartGauche, BorderLayout.WEST);
			/*****************************************
			/*FIN Ajout du panel a gauche de la fenetre
			/*****************************************/
			
			
			/*****************************************
			/*Debut Ajout du panel a droite de la fenetre
			/*****************************************/
			JPanel jpPartDroite = new JPanel(new GridLayout(3,1));
			jpPartDroite.setOpaque(true);
				
				
				/**************************************************************************
				/*Debut Ajout du panel contenant une image des cartes ramasses par l'adversaire
				/**************************************************************************/
				JPanel jpPlaceCarteGagneAdv = new JPanel();
					jpPlaceCarteGagneAdv.setOpaque(true);
					jpPlaceCarteGagneAdv.setLayout(null);
					carteGagneAdv = new JLabel();
					carteGagneAdv.setBounds(20,20, 114, 189);
					carteGagneAdv.setVisible(false);
				jpPlaceCarteGagneAdv.add(carteGagneAdv);
			jpPartDroite.add(jpPlaceCarteGagneAdv);
				/**************************************************************************
				/*FIN Ajout du panel contenant une image des cartes ramasses par l'adversaire
				/**************************************************************************/
			
				/********************************************************************************************
				/*Debut Ajout d'un panel vide car on veut mettre dans le gridlayout tout en bas les donnees du joueur
				/********************************************************************************************/
				JPanel vide = new JPanel();	
				vide.setOpaque(true);
			jpPartDroite.add(vide);
				/********************************************************************************************
				/*FIN Ajout d'un panel vide car on veut mettre dans le gridlayout tout en bas les donnees du joueur
				/********************************************************************************************/
			
			
				/****************************************************
				/*Debut Ajout du tableau de donnees concernant le joueur
				/****************************************************/
				joueur = new DonneePartie();
				joueur.setPreferredSize(new Dimension(120,100));
			jpPartDroite.add(joueur);
				/****************************************************
				/*FIN Ajout du tableau de donnees concernant le joueur
				/****************************************************/
		jpPrincipal.add(jpPartDroite, BorderLayout.EAST);
			/*****************************************
			/*FIN Ajout du panel a droite de la fenetre
			/*****************************************/
			
			JPanel pscore = new JPanel(new FlowLayout());
			monscore = new JLabel("Votre Score :");
			sonscore = new JLabel("Score Adverse:");
			montscore = new JTextField("0");
			sontscore = new JTextField("0");
			montscore.setEditable(false);
			sontscore.setEditable(false);
			pscore.add(monscore);
			pscore.add(montscore);
			pscore.add(sonscore);
			pscore.add(sontscore);
			pscore.setOpaque(true);
		jpPrincipal.add(pscore, BorderLayout.SOUTH);

		/*****************************************************************
		/*Debut Ajout du joueur de gauche
		/*****************************************************************/
	jpCentral = new JPanel(new BorderLayout());
		jpCentral.setOpaque(true);
			JPanel jpJoueurGauche = new JPanel(new BorderLayout());
			jtfNomJoueur3 = new JTextField();
			jtfNomJoueur3.setEditable(false);
			//~ ImageIcon carteJoueuragauche = new ImageIcon("./Skin/Skin3/gauche3.png");
			mainJoueurGauche = new JLabel();
			jpJoueurGauche.setOpaque(true);
			jpJoueurGauche.add(mainJoueurGauche);
			jpJoueurGauche.setBackground(c);
			pdecoG = new JPanel(new BorderLayout());
			vide3 = new JLabel("<html><br/><br/><br/><br/><br/><br/><br/><br/></html>");
			vide5 = new JLabel("<html><br/><br/><br/><br/><br/><br/><br/><br/><br/></html>");
			pdecoG.add(jtfNomJoueur3, "North");
			pdecoG.add(vide3);
			pdecoG.setOpaque(true);
			pdecoG.setBackground(c);
		jpJoueurGauche.add(pdecoG, "South");
		jpJoueurGauche.add(vide5, "North");
			
	jpCentral.add(jpJoueurGauche, "West");
		/*****************************************************************
		/*Fin Ajout du joueur de gauche
		/*****************************************************************/
	
		/*****************************************************************
		/*Debut Ajout du joueur de droite
		/*****************************************************************/
		JPanel jpJoueurDroite = new JPanel(new BorderLayout());
			jtfNomJoueur4 = new JTextField();
			jtfNomJoueur4.setEditable(false);
			mainJoueurDroite = new JLabel();
			jpJoueurDroite.setOpaque(true);
			jpJoueurDroite.add(mainJoueurDroite);
			jpJoueurDroite.setBackground(c);
			pdecoD = new JPanel(new BorderLayout());
			vide4 = new JLabel("<html><br/> <br/> <br/> <br/> <br/> <br/> <br/><br/> </html>");
			vide6 = new JLabel("<html><br/> <br/> <br/> <br/> <br/> <br/> <br/><br/><br/> </html>");
			pdecoD.add(jtfNomJoueur4, "North");
			pdecoD.add(vide4);
			pdecoD.setOpaque(true);
			pdecoD.setBackground(c);
		jpJoueurDroite.add(pdecoD, "South");
		jpJoueurDroite.add(vide6, "North");
		
	jpCentral.add(jpJoueurDroite, "East");
		/*****************************************************************
		/*Fin Ajout du joueur de droite
		/*****************************************************************/

		/****************************************************
		/*Debut Ajout du panel contenant le tapis
		/****************************************************/
			
			/*****************************************************************
			/*Debut Ajout du panel contenant les cartes en main du joueur, son nom et tchat
			/*****************************************************************/
			JPanel jpJoueur = new JPanel(new BorderLayout());
				
				/*****************************************************************
				/*Debut Ajout du panel contenant le textfield du nom du joueur
				/*****************************************************************/
				JPanel jpText = new JPanel(new BorderLayout());
					jpText.setOpaque(true);
					jpText.setBackground(c);
					jtfNomJoueur1 = new JTextField();
					jtfNomJoueur1.setEditable(false);
				jpText.add(jtfNomJoueur1, "West");
			jpJoueur.add(jpText, BorderLayout.NORTH);
				/*****************************************************************
				/*FIN Ajout du panel contenant le textfield du nom du joueur
				/*****************************************************************/
				
				/* On cree le plateau */
				if ( creer )
				{
					try
					{
						pl=new PlateauImpl();
						pl.jeuAQuatre( tm1, tm2, manuels );
						
						//On gere les noms des joueurs
						try
						{
							FileReader fr = new FileReader ("config.txt");
							Scanner scan = new Scanner(fr);
							scan.useDelimiter("\t");
							
							nom1 = scan.next();
							nom2 = scan.next();
							nom3 = scan.next();
							nom4 = scan.next();
							
							pl.getJoueurs().get(numJoueur1).setNom(nom1);
							pl.getJoueurs().get(numJoueur2).setNom(nom2);
							pl.getJoueurs().get(numJoueur3).setNom(nom3);
							pl.getJoueurs().get(numJoueur3).setNom(nom4);
							
							scan.close();
						}
						catch ( Exception e)
						{
							e.printStackTrace();
							System.out.println("erreur dans le fichier affichage.txt : Mise a jour des noms des joueurs");
						}
						
						for (int c=4;c<carteTapis.size();c++)
							carteTapis.get(c).setVisible(false);
						
						
					}
					catch(Exception e)
					{
						e.printStackTrace();
						System.out.println("Erreur creation du plateau");
					}
				} /*  On recupere le plateau */
				else
				{
					try
					{
						Thread.sleep(100);
						
						pl=PlateauImpl.lookup();
						nbJoueursMan=pl.getNbJoueursMan();
						
						if ( pl.getJoueurs().size() < 4 && pl.getJoueursM().size() < nbJoueursMan)
						{
							// Si il manque des joueurs manuels
							pl.ajouteJoueur(nom);
						}
						if ( pl.getJoueurs().size() < 4 && pl.getJoueursM().size() == nbJoueursMan )
								pl.ajouteJoueursIA();
						
						// Attente que tous les joueurs se soient connectes.
						try
						{
							int tmp=pl.getJoueurs().size(), compt=tmp;
							boolean b=true;
							
							if( tmp != 4 )
							{
								JOptionPane conf = new JOptionPane();
								conf.showMessageDialog(null,"Attente des autres joueurs","Alerte", conf.INFORMATION_MESSAGE);
								System.out.println("Attendons les autres joueurs");
							}
							
							while (b)
							{
								tmp=pl.getJoueurs().size();
								System.out.println("tmp : "+tmp);
								
								Thread.sleep(1000);
								
								if ( tmp == 4 )
									break;
							}
						}
						catch ( Exception e )
						{
							e.printStackTrace();
						}
						
						for (int c=4;c<carteTapis.size();c++)
							carteTapis.get(c).setVisible(false);
						
						// Initialisation des "joueurs courant"
						// Le numero du joueur dont on voit la main etant numjoueur1
						
						try
						{
							if ( tm1.size()==0)
							{
								if ( pl.getJoueurs().get(0).getFait() == true &&  pl.getJoueurs().get(1).getFait() == false)
								{
									numJoueur1=1;
									numJoueur2=2;
									numJoueur3=3;
									numJoueur4=0;
									pl.getJoueurs().get(numJoueur1).setFait();
								}
								else if ( pl.getJoueurs().get(1).getFait() == true &&  pl.getJoueurs().get(2).getFait() == false)
								{
									numJoueur1=2;
									numJoueur2=3;
									numJoueur3=0;
									numJoueur4=1;
									pl.getJoueurs().get(numJoueur1).setFait();
								}
								else if ( pl.getJoueurs().get(2).getFait() == true &&  pl.getJoueurs().get(3).getFait() == false)
								{
									numJoueur1=3;
									numJoueur2=0;
									numJoueur3=1;
									numJoueur4=2;
									pl.getJoueurs().get(numJoueur1).setFait();
								}
							}
						}
						catch (Exception e)
						{
							System.out.println("initialisation numjoueurs");
							e.printStackTrace();
						}
						
						System.out.println("joueur courant : "+pl.getJoueurCourant().affiche()+"\n");
					}
					catch ( Exception e)
					{
						System.out.println("Erreur initialisation reseau 4 joueur");
						e.printStackTrace();
					}
				}
				
				/*****************************************************************
				/*Debut Ajout du panel contenant les cartes en main du joueur et le tchat
				/*****************************************************************/
				JPanel jpCarteJoueur = new JPanel(new GridLayout(1, 4));
				jpCarteJoueur.setOpaque(true);
		
					/*****************************************************************
					/*Debut Ajout du panel contenant une carte
					/*****************************************************************/
					ImageIcon desous = new ImageIcon("./Skin/skin gene/vide.png");
					JPanel jpPlaceCarteUn = new JPanel();
						jpPlaceCarteUn.setLayout(null);
						jpPlaceCarteUn.setOpaque(true);
						
						try
						{
							carteMain.add( new BoutonCarte(pl.getJoueurs().get(numJoueur1).getMain().get(0)));
						}
						catch ( Exception e) { e.printStackTrace(); }
						dessousTable1 = new JLabel(desous);
						carteMain.get(0).addActionListener(this);
						dessousTable1.setBounds(10,1, 89, 148);
						carteMain.get(0).setBounds(10,1, 89, 148);
					jpPlaceCarteUn.add(carteMain.get(0));
					jpPlaceCarteUn.add(dessousTable1);
				jpCarteJoueur.add(jpPlaceCarteUn);
					
					/*****************************************************************
					/*FIN Ajout du panel contenant une carte
					/*****************************************************************/
					
				
					/*****************************************************************
					/*Debut Ajout du panel contenant une carte
					/*****************************************************************/
					JPanel jpPlaceCarteDeux = new JPanel();
						jpPlaceCarteDeux.setLayout(null);
						jpPlaceCarteDeux.setOpaque(true);
						try
						{
							carteMain.add(new BoutonCarte(pl.getJoueurs().get(numJoueur1).getMain().get(1)));	
						}
						catch ( Exception e) { e.printStackTrace(); }
						dessousTable2 = new JLabel(desous);
						carteMain.get(1).addActionListener(this);		
						dessousTable2.setBounds(10,1, 89, 148);
						carteMain.get(1).setBounds(10,1, 89, 148);
					jpPlaceCarteDeux.add(carteMain.get(1));
					jpPlaceCarteDeux.add(dessousTable2);
				jpCarteJoueur.add(jpPlaceCarteDeux);
					/*****************************************************************
					/*FIN Ajout du panel contenant une carte
					/*****************************************************************/
					
				
					/*****************************************************************
					/*Debut Ajout du panel contenant une carte
					/*****************************************************************/
					JPanel jpPlaceCarteTrois = new JPanel();
						jpPlaceCarteTrois.setLayout(null);
						jpPlaceCarteTrois.setOpaque(true);
						try
						{
							carteMain.add(new BoutonCarte(pl.getJoueurs().get(numJoueur1).getMain().get(2)));
						}
						catch ( Exception e ){ e.printStackTrace(); }
						dessousTable3 = new JLabel(desous);
						carteMain.get(2).addActionListener(this);	
						dessousTable3.setBounds(10,1, 89, 148);
						carteMain.get(2).setBounds(10,1, 89, 148);
					jpPlaceCarteTrois.add(carteMain.get(2));
					jpPlaceCarteTrois.add(dessousTable3);
				jpCarteJoueur.add(jpPlaceCarteTrois);
						
					// Affichage des cartes de la main du joueur courant
					try
					{
						for (int k=0; k<3; k++)
						{
							val = pl.getJoueurs().get(numJoueur1).getMain().get(k).getValeur();
							coul = pl.getJoueurs().get(numJoueur1).getMain().get(k).getCoul();
							
							ImageIcon carteTemp = new ImageIcon("./carte/"+val+""+coul+".png");
							carteMain.get(k).setIcon(carteTemp);
							carteMain.get(k).setCarte( pl.getJoueurs().get(numJoueur1).getMain().get(k));
						}
					}
					catch ( Exception e )
					{
						e.printStackTrace();
					}
					
					/*****************************************************************
					/*FIN Ajout du panel contenant une carte
					/*****************************************************************/
				
					testPan4 = new JLabel("");
					testPan4.setOpaque(true);
					testPan4.setPreferredSize(new Dimension(100, 150));
					testPan4.setOpaque(true);
				jpCarteJoueur.add(testPan4);
				
				
					/*****************************************************************
					/*Debut Ajout du panel contenant le tchat
					/*****************************************************************/
				JPanel tChat = new JPanel();
					tChat.setOpaque(true);
					tChat.setLayout(null);
					chat = new JButton("Tchat");
					chat.addActionListener(this);
					chat.setBounds(0,100,100,20);
					tChat.add(chat);
				jpCarteJoueur.add(tChat);
					/*****************************************************************
					/*FIN Ajout du panel contenant le tchat
					/*****************************************************************/					
			jpJoueur.add(jpCarteJoueur);
				/*****************************************************************
				/*FIN Ajout du panel contenant les cartes en main du joueur et le tchat
				/*****************************************************************/
		jpCentral.add(jpJoueur, "South");
			/*************************************************************************
			/*FIN Ajout du panel contenant les cartes en main du joueur, son nom et tchat
			/*************************************************************************/
			

			/*****************************************************************
			/*A FINIR
			/*****************************************************************/
			JPanel jpJoueurAdver = new JPanel(new BorderLayout());
				JPanel jpTextA = new JPanel(new BorderLayout());
					jtfNomJoueur2 = new JTextField();
					jtfNomJoueur2.setEditable(false);
					jpTextA.setOpaque(true);
					jpTextA.setBackground(c);
				jpTextA.add(jtfNomJoueur2, BorderLayout.WEST);
				mainJoueurFace = new JLabel();
				vide8 = new JLabel("                                                                                                            ");
				jpJoueurAdver.add(vide8, "West");
				jpJoueurAdver.add(mainJoueurFace);
				jpJoueurAdver.setOpaque(true);
				pdecoF = new JPanel(new BorderLayout());
				vide7 = new JLabel("                                                                                                            ");
				pdecoF.add(vide7, "West");
				pdecoF.add(jpTextA);
				pdecoF.setOpaque(true);
				pdecoF.setBackground(c);
			jpJoueurAdver.add(pdecoF, "South");
			
		jpCentral.add(jpJoueurAdver, "North");

		
			/*****************************************************************
			/*Debut Ajout du panel cantenant le tapis
			/*****************************************************************/
			jpCartePlateau = new JPanel();
			jpCartePlateau.setOpaque(true);
			jpCartePlateau.setLayout(null);

			/*****************************************************************
			/* Creation des BoutonCarte sur le tapis
			/*****************************************************************/
			int x = 50;
			int decalage = 0;
		
			try
			{
				for (int j = 0; j !=15; j++)
				{					
					carteTapis.add(new BoutonCarte());
					carteTapis.get(j).setBounds(x + decalage, 100, 89, 148);
					decalage += (105 / 2);
					carteTapis.get(j).addActionListener(this);
					jpCartePlateau.add(carteTapis.get(j));
				}
				
				for ( int j=0; j<pl.getTapis().size();j++)
				{
					carteTapis.get(j).setCarte(pl.getTapis().get(j));
				}
				
				for ( int j=pl.getTapis().size(); j!=15;j++)
				{
					carteTapis.get(j).setVisible(false);
				}
			}
			catch ( Exception e )
			{
				e.printStackTrace();
			}
			
			ImageIcon carteDefausse = new ImageIcon("./Skin/skin gene/defausse.png");
			carteD = new JButton(carteDefausse);
			carteD.addActionListener(this);
			carteD.setBounds(340, 265, 148, 89);
			jpCartePlateau.add(carteD);
			
		jpCentral.add(jpCartePlateau);
			/*****************************************************************
			/*FIN Ajout du panel cantenant le tapis
			/*****************************************************************/

		jpPrincipal.add(jpCentral, BorderLayout.CENTER);
		/****************************************************
		/*FIN Ajout du panel contenant le tapis, main du joueur, nom des joueur.
		/****************************************************/
		
		/* On rend les panel opaque */
		jpPrincipal.setBackground(c);
		jpJoueurAdver.setBackground(c);
		jpPlaceCarteTrois.setBackground(c);
		jpPlaceCarteDeux.setBackground(c);
		jpPlaceCarteUn.setBackground(c);
		jpPartDroite.setBackground(c);
		tChat.setBackground(c);
		jpPlaceCarteGagneJoueur.setBackground(c);
		jpPlacePioche.setBackground(c);
		jpPartGauche.setBackground(c);
		jpCentral.setBackground(c);
		pscore.setBackground(c);
		testPan4.setBackground(c);
		jpPlaceCarteGagneAdv.setBackground(c);
		vide.setBackground(c);
		jpCartePlateau.setBackground(c);
		jpCarteJoueur.setBackground(c);
		
		try
		{
			FileReader fr = new FileReader ("affichage.txt");
			Scanner scan = new Scanner(fr);
			scan.useDelimiter("\t");
			String skin = scan.next();
			
			if ( skin.equals("1"))
				changeSkin(1);
			if ( skin.equals("2"))
				changeSkin(2);
			if ( skin.equals("3"))
				changeSkin(3);
			if ( skin.equals("4"))
				changeSkin(4);
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
		
		try
		{
			if ( creer == true )
			{
				jtfNomJoueur1.setText(nom1);
				jtfNomJoueur2.setText(nom2);
				jtfNomJoueur3.setText(nom3);
				jtfNomJoueur4.setText(nom4);
			}
			else
			{
				jtfNomJoueur1.setText(pl.getJoueurs().get(numJoueur1).getNom());
				jtfNomJoueur2.setText(pl.getJoueurs().get(numJoueur2).getNom());
				jtfNomJoueur3.setText(pl.getJoueurs().get(numJoueur3).getNom());
				jtfNomJoueur4.setText(pl.getJoueurs().get(numJoueur4).getNom());
			}
		}
		catch ( Exception e)
		{
			e.printStackTrace();
			System.out.println("mise a jour Textfield noms joueurs");
		}
		
		montscore.setText(Integer.toString(moniscore));
		sontscore.setText(Integer.toString(soniscore));
		
		add(jpPrincipal);
		setVisible(true);
		
		if ( creer == false )
		{
			thread = new ThreadActu4j(this);
			thread.start();
		}
	}
	
	public IPlateau getPlateau(){return pl;}
	
	public void actionPerformed(ActionEvent e)
	{
		if (e.getSource() == jmiAPropos)
		{
			IHMaPropos aPropos= new IHMaPropos();
			aPropos.setVisible(true);
		}
		if (e.getSource() == jmiStatistiques)
		{
			Stat fenStat= new Stat(ind);
			fenStat.setVisible(true);
		}
		if(e.getSource()==jmiQuitter)
			System.exit(0);
		if(e.getSource()==chat)
		{
			String joueur1="";
			JOptionPane conf = new JOptionPane();
			try
			{
				FileReader fr = new FileReader ("config.txt");
				Scanner scan = new Scanner(fr);
				scan.useDelimiter("\t");
				joueur1 = scan.next();
				jtfNomJoueur1.setText(joueur1);
			}
			catch (Exception ex)
			{
				conf.showMessageDialog(null,"Erreur dans la sauvegarde !","Alerte", conf.WARNING_MESSAGE);
			}
			Tchat fenTchat = new Tchat(joueur1);
			fenTchat.setVisible(true);
		}
		if(e.getSource()==jmiNouveau)
		{
			try
			{
				String name=pl.getJoueurs().get(0).getNom();
				new IHMPlateau4j(ind, creer, team1, team2, nbJoueursMan, name, moniscore, soniscore);
				setVisible(false);
			}
			catch ( Exception ex)
			{
				ex.printStackTrace();
			}
		}
		if(e.getSource()==jmiManuel)
		{
			IHMaide fenAide = new IHMaide();
			fenAide.setVisible(true);
		}
		if(e.getSource()==jmiRegles)
		{
			Regle fenRegle= new Regle();
			fenRegle.setVisible(true);
		}
		if(e.getSource()==jmiOption)
		{
			Config fenConfig= new Config(ind);
			fenConfig.setVisible(true);
		}
		if(e.getSource()==jmiSkin)
		{
			Affichage fenSkin= new Affichage(ind);
			fenSkin.setVisible(true);
		}
		try
		{
			if(e.getSource()==carteTapis.get(0))
				if ( pl.getJoueurCourant().getMain().indexOf(carteCourante.getCarte()) != -1 )
					prendre(carteCourante, carteTapis.get(0));
			if(e.getSource()==carteTapis.get(1))
				if ( pl.getJoueurCourant().getMain().indexOf(carteCourante.getCarte()) != -1 )
					prendre(carteCourante, carteTapis.get(1));
			if(e.getSource()==carteTapis.get(2))
				if ( pl.getJoueurCourant().getMain().indexOf(carteCourante.getCarte()) != -1 )
					prendre(carteCourante, carteTapis.get(2));
			if(e.getSource()==carteTapis.get(3))
				if ( pl.getJoueurCourant().getMain().indexOf(carteCourante.getCarte()) != -1 )
					prendre(carteCourante, carteTapis.get(3));
			if(e.getSource()==carteTapis.get(4))
				if ( pl.getJoueurCourant().getMain().indexOf(carteCourante.getCarte()) != -1 )
					prendre(carteCourante, carteTapis.get(4));
			if(e.getSource()==carteTapis.get(5))
				if ( pl.getJoueurCourant().getMain().indexOf(carteCourante.getCarte()) != -1 )
					prendre(carteCourante, carteTapis.get(5));
			if(e.getSource()==carteTapis.get(6))
				if ( pl.getJoueurCourant().getMain().indexOf(carteCourante.getCarte()) != -1 )
					prendre(carteCourante, carteTapis.get(6));
			if(e.getSource()==carteTapis.get(7))
				if ( pl.getJoueurCourant().getMain().indexOf(carteCourante.getCarte()) != -1 )
					prendre(carteCourante, carteTapis.get(7));
			if(e.getSource()==carteTapis.get(8))
				if ( pl.getJoueurCourant().getMain().indexOf(carteCourante.getCarte()) != -1 )
					prendre(carteCourante, carteTapis.get(8));
			if(e.getSource()==carteTapis.get(9))
				if ( pl.getJoueurCourant().getMain().indexOf(carteCourante.getCarte()) != -1 )
					prendre(carteCourante, carteTapis.get(9));			
			if(e.getSource()==carteTapis.get(10))
				if ( pl.getJoueurCourant().getMain().indexOf(carteCourante.getCarte()) != -1 )
					prendre(carteCourante, carteTapis.get(10));
			if(e.getSource()==carteTapis.get(11))
				if ( pl.getJoueurCourant().getMain().indexOf(carteCourante.getCarte()) != -1 )
					prendre(carteCourante, carteTapis.get(11));
			if(e.getSource()==carteTapis.get(12))
				if ( pl.getJoueurCourant().getMain().indexOf(carteCourante.getCarte()) != -1 )
					prendre(carteCourante, carteTapis.get(12));

			if(e.getSource()==carteMain.get(0))
			{
				if ( carteMain.get(0).getCarte() != null)
				{
					if ( carteMain.get(0).getInt() != 0 )
					{
						if(this.getCursor().getType()  != Cursor.DEFAULT_CURSOR)
							remettreCarte(carteMain.get(0));
						else
							recupCurseur(carteMain.get(0));
					}
					else
						this.setCursor(cursor.DEFAULT_CURSOR);
				}
			}
			if(e.getSource()==carteMain.get(1))
			{
				if ( carteMain.get(1).getCarte() != null)
				{
					if ( carteMain.get(1).getInt() != 0 )
					{
						if(this.getCursor().getType()  != Cursor.DEFAULT_CURSOR)
							remettreCarte(carteMain.get(1));
						else
							recupCurseur(carteMain.get(1));
					}
					else
						this.setCursor(cursor.DEFAULT_CURSOR);
				}
			}	
			if(e.getSource()==carteMain.get(2))
			{
				if ( carteMain.get(2).getCarte() != null)
				{
					if ( carteMain.get(2).getInt() != 0 )
					{
						if(this.getCursor().getType() != Cursor.DEFAULT_CURSOR)
							remettreCarte(carteMain.get(2));
						else
							recupCurseur(carteMain.get(2));
					}
					else
						this.setCursor(cursor.DEFAULT_CURSOR);
				}
			}
			if(e.getSource()==carteD)
			{
				if ( pl.getJoueurCourant().getMain().indexOf(carteCourante.getCarte()) != -1 )
				{
					if(this.getCursor().getType()  != cursor.DEFAULT_CURSOR)
						defausse(carteCourante);
				}
			}
		}
		catch(Exception ex)
		{
			ex.printStackTrace();
		}
	}
	
	// Methode qui change toutes les cartes ayant un skin a modifier
	public void changeSkin(int i)
	{
		ImageIcon temp = new ImageIcon("./Skin/Skin"+i+"/face3.png");
		mainJoueurFace.setIcon(temp);
		temp=new ImageIcon("./Skin/Skin"+i+"/droite3.png");
		mainJoueurDroite.setIcon(temp);
		temp=new ImageIcon("./Skin/Skin"+i+"/gauche3.png");
		mainJoueurGauche.setIcon(temp);
		temp = new ImageIcon("./Skin/Skin"+i+"/dos_carte3envers.png");
		carteGagneAdv.setIcon(temp);
		temp = new ImageIcon("./Skin/Skin"+i+"/Dos_carte3fini.png");
		carteGagneJoueur.setIcon(temp);
		temp = new ImageIcon("./Skin/Skin"+i+"/pioche.png");
		pioche.setIcon(temp);
	}
	
	// Methode qui permet de remmetre l'image  sur le bouton sur lequel on vient de cliquer et creer un curseurpar defaut
	public void remettreCarte(BoutonCarte bCMain)
	{
		try
		{
			this.setCursor(cursor.DEFAULT_CURSOR);
			val = bCMain.getInt();
			coul = bCMain.getCoul();
			ImageIcon carteTi1 = new ImageIcon("./carte/"+val+""+coul+".png");
			bCMain.setIcon(carteTi1);
			this.actualiser();
		}
		catch(Exception ex)
		{
			ex.printStackTrace();
		}
	}
	
	// Methode qui permet de recuperer l'image  du bouton sur lequel on vient de cliquer et creer un curseur a cet effigie 
	public void recupCurseur(BoutonCarte bC)
	{
		try
		{
			if ( bC.getCarte() != null )
			{
				val1 = bC.getInt();
				coul1 =bC.getCoul();
				ImageIcon carteTi1 = new ImageIcon("./carte/carteGris/"+val1+""+coul1+".png");
				carteCourante=bC;
				Image ic1 = tk.createImage("./carte/"+val1+""+coul1+".png");
				cursor = tk.createCustomCursor(ic1, p, "lol");
				this.setCursor(cursor);
				
				if (bC==carteMain.get(0))
				{
					carteMain.get(0).setIcon(carteTi1);
					carteMain.get(1).setVisible(false);
					carteMain.get(2).setVisible(false);
				}
				else if (bC==carteMain.get(1))
				{
					carteMain.get(1).setIcon(carteTi1);
					carteMain.get(0).setVisible(false);
					carteMain.get(2).setVisible(false);
				}
				else
				{
					carteMain.get(2).setIcon(carteTi1);
					carteMain.get(0).setVisible(false);
					carteMain.get(1).setVisible(false);
				}
			}
		}
		catch(Exception ex)
		{
			ex.printStackTrace();
		}
	}
	
	// Methode qui permet de se defausser d'une carte
	public void defausse(BoutonCarte uneCarteMain)
	{
		try
		{			
			val1 =uneCarteMain.getInt();
			coul1 = uneCarteMain.getCoul();
			ImageIcon carteTi = new ImageIcon("./carte/"+val1+""+coul1+".png");
			if ( pl.getTapis().size() < 8 )
			{
				for(int i=0; i<pl.getTapis().size()+1;i++)
				{
					if(pl.getTapis().size() == i)
					{
						carteTapis.get(i).setVisible(true);
						carteTapis.get(i).setCarte(uneCarteMain.getCarte());
					}
					this.setCursor(cursor.DEFAULT_CURSOR);
				}
				pl.poser(uneCarteMain.getCarte());
				pl.effacerPlis();
				uneCarteMain.setNull();
				verif(uneCarteMain);
				pl.setJoueurCourant();
				this.actualiser();
				
				while (pl.getJoueursM().indexOf(pl.getJoueurCourant()) == -1)
				{
					faireJouerLIA();
					pl.setJoueurCourant();
				}
			}
			else
			{
				JOptionPane conf = new JOptionPane();
				conf.showMessageDialog(null,"Trop de cartes sur le tapis","Alerte", conf.WARNING_MESSAGE);
				this.remettreCarte(uneCarteMain);
			}
		}
		catch(Exception ex)
		{
			ex.printStackTrace();
		}
	}
	
	public void gagneCarte(BoutonCarte bCMain,BoutonCarte bCTapis)
	{
		try
		{
			this.setCursor(cursor.DEFAULT_CURSOR);
			verif(bCMain);
		}
		catch ( Exception e)
		{
			e.printStackTrace();
			System.out.println("gagneCarte dans IHMPlateau4J");
		}
	}
	
	public void actualiser()
	{
		try
		{
			if ( cRam.isVisible() )
				cRam.setVisible(false);
			
			if (cRam.getPlis().size() !=0 )
			{
				if ( pl.getDernierPlis().size() != 0)
				{
					if ( pl.getDernierPlis().get(0).getCoul() != null && pl.getDernierPlis() != cRam.getPlis())
					{
						int num=3-(pl.getJoueurs().indexOf(pl.getJoueurCourant()));
						cRam = new CarteRamassage(pl.getDernierPlis(),"Pli de "+pl.getJoueurs().get(num).getNom());
						cRam.setVisible(true);
					}
				}
				else 	cRam.setVisible(false);
			}
			
			for (int i=0; i<carteTapis.size(); i++)
			{
				carteTapis.get(i).setVisible(false);
			}
			for (int i=0; i<carteMain.size(); i++)
			{
				carteMain.get(i).setVisible(false);
			}
			
			for (int i=0; i<pl.getTapis().size(); i++)
			{
				carteTapis.get(i).setCarte(pl.getTapis().get(i));
				carteTapis.get(i).setVisible(true);
				carteTapis.get(i).setBounds((int)carteTapis.get(i).getBounds().getX(),100,89,148);
			}
			for (int i=0; i<pl.getJoueurs().get(numJoueur1).getMain().size(); i++)
			{
				carteMain.get(i).setCarte(pl.getJoueurs().get(numJoueur1).getMain().get(i));
				carteMain.get(i).setVisible(true);
			}
			
			if ( pl.getEquipe1().indexOf(numJoueur1) != -1 )
			{
				joueur.setSept(pl.getEquipe2().get(0).compteSept() + pl.getEquipe2().get(1).compteSept());
				joueur.setCarreaux(pl.getEquipe2().get(0).compteCarreaux() + pl.getEquipe2().get(1).compteCarreaux());
				joueur.setCarte(pl.getEquipe2().get(0).getTaillePlis() + pl.getEquipe2().get(1).getTaillePlis());
				joueur.setChkoba(pl.getEquipe2().get(0).getChkoba() + pl.getEquipe2().get(1).getChkoba());	
				
				adversaire.setSept(pl.getEquipe1().get(0).compteSept() + pl.getEquipe1().get(1).compteSept());
				adversaire.setCarreaux(pl.getEquipe1().get(0).compteCarreaux() + pl.getEquipe1().get(1).compteCarreaux());
				adversaire.setCarte(pl.getEquipe1().get(0).getTaillePlis() + pl.getEquipe1().get(1).getTaillePlis());
				adversaire.setChkoba(pl.getEquipe1().get(0).getChkoba() + pl.getEquipe1().get(1).getChkoba());	
			}
			else
			{
				joueur.setSept(pl.getEquipe1().get(0).compteSept() + pl.getEquipe1().get(1).compteSept());
				joueur.setCarreaux(pl.getEquipe1().get(0).compteCarreaux() + pl.getEquipe1().get(1).compteCarreaux());
				joueur.setCarte(pl.getEquipe1().get(0).getTaillePlis() + pl.getEquipe1().get(1).getTaillePlis());
				joueur.setChkoba(pl.getEquipe1().get(0).getChkoba() + pl.getEquipe1().get(1).getChkoba());	
				
				adversaire.setSept(pl.getEquipe2().get(0).compteSept() + pl.getEquipe2().get(1).compteSept());
				adversaire.setCarreaux(pl.getEquipe2().get(0).compteCarreaux() + pl.getEquipe2().get(1).compteCarreaux());
				adversaire.setCarte(pl.getEquipe2().get(0).getTaillePlis() + pl.getEquipe2().get(1).getTaillePlis());
				adversaire.setChkoba(pl.getEquipe2().get(0).getChkoba() + pl.getEquipe2().get(1).getChkoba());
			}
			
			FileReader fr1 = new FileReader ("affichage.txt");
			Scanner scan1 = new Scanner(fr1);
			scan1.useDelimiter("\t");
			skin = scan1.next();
			System.out.println(skin);
			
			this.changeImageMain(skin, 1);
			this.changeImageMain(skin, 2);
			this.changeImageMain(skin, 3);
			
			if (pl.resteCartes() ==false )
			{
				IJoueur j1, j2, j3, j4;
				int team1, team2;
				
				for ( int i=0; i<4; i++)
				{
					if ( pl.getJoueurs().get(i).getPris()==true )
					{
						int taille = pl.getTapis().size();
						for ( int j = 0 ; j!=taille;j++)
						{
							pl.getJoueurs().get(i).getPlis().add(pl.getTapis().get(0) );
							pl.getTapis().remove(0);
							carteTapis.get(j).setVisible(false);
						}
						
						// On doit recompter pour avoir les cartes qui etaient sur le tapis
						// mais qui sont partis dans la main du dernier joueur qui as pris.
						if ( pl.getEquipe1().indexOf(numJoueur1) != -1 )
						{
							joueur.setSept(pl.getEquipe2().get(0).compteSept() + pl.getEquipe2().get(1).compteSept());
							joueur.setCarreaux(pl.getEquipe2().get(0).compteCarreaux() + pl.getEquipe2().get(1).compteCarreaux());
							joueur.setCarte(pl.getEquipe2().get(0).getTaillePlis() + pl.getEquipe2().get(1).getTaillePlis());
							joueur.setChkoba(pl.getEquipe2().get(0).getChkoba() + pl.getEquipe2().get(1).getChkoba());	
							
							adversaire.setSept(pl.getEquipe1().get(0).compteSept() + pl.getEquipe1().get(1).compteSept());
							adversaire.setCarreaux(pl.getEquipe1().get(0).compteCarreaux() + pl.getEquipe1().get(1).compteCarreaux());
							adversaire.setCarte(pl.getEquipe1().get(0).getTaillePlis() + pl.getEquipe1().get(1).getTaillePlis());
							adversaire.setChkoba(pl.getEquipe1().get(0).getChkoba() + pl.getEquipe1().get(1).getChkoba());	
						}
						else
						{
							joueur.setSept(pl.getEquipe1().get(0).compteSept() + pl.getEquipe1().get(1).compteSept());
							joueur.setCarreaux(pl.getEquipe1().get(0).compteCarreaux() + pl.getEquipe1().get(1).compteCarreaux());
							joueur.setCarte(pl.getEquipe1().get(0).getTaillePlis() + pl.getEquipe1().get(1).getTaillePlis());
							joueur.setChkoba(pl.getEquipe1().get(0).getChkoba() + pl.getEquipe1().get(1).getChkoba());	
							
							adversaire.setSept(pl.getEquipe2().get(0).compteSept() + pl.getEquipe2().get(1).compteSept());
							adversaire.setCarreaux(pl.getEquipe2().get(0).compteCarreaux() + pl.getEquipe2().get(1).compteCarreaux());
							adversaire.setCarte(pl.getEquipe2().get(0).getTaillePlis() + pl.getEquipe2().get(1).getTaillePlis());
							adversaire.setChkoba(pl.getEquipe2().get(0).getChkoba() + pl.getEquipe2().get(1).getChkoba());
						}
						
						break;
					}
				}
				
				// methode qui change l'image de la main du joueur adverse en fonction du nombre de carte qu'il a dans la main
				
				
				j1=pl.getJoueurs().get(0); j2=pl.getJoueurs().get(1);
				j3=pl.getJoueurs().get(2); j4=pl.getJoueurs().get(3);
				
				j1.comptePoint(); j2.comptePoint();
				j3.comptePoint(); j4.comptePoint();
				
				team1=j1.getPoint()+j2.getPoint();
				team2=j3.getPoint()+j4.getPoint();
				
				int res = 0, partiegagne=0, partieperdue=0;
				JOptionPane conf = new JOptionPane();
				if ( team1 > team2 )
				{
					partiegagne = 1;
					partieperdue = 0;
					moniscore = Integer.parseInt(montscore.getText());
					moniscore++;
					montscore.setText(Integer.toString(moniscore));
					res = conf.showConfirmDialog(null,"L'equipe 1 est le vainqueur!!! Voulez vous rejouer ?","Trop fort!!", conf.WARNING_MESSAGE);
				}
				else if ( team1 < team2)
				{
					partiegagne = 0;
					partieperdue = 1;
					soniscore = Integer.parseInt(sontscore.getText());
					soniscore++;
					sontscore.setText(Integer.toString(soniscore));
					res = conf.showConfirmDialog(null,"L'equipe 2 est le vainqueur!!! Voulez vous rejouer ?","Trop fort!!", conf.WARNING_MESSAGE);
				}
				else
					res = conf.showConfirmDialog(null,"Match nul ! Voulez vous rejouer ?","Aussi fort", conf.WARNING_MESSAGE);
			
			
				int nbjoue=0, nbgagne=0, nbperdu=0, chkoba=0, carreau=0, plis=0, sept=0, septcarreau=0, ratio=0;
				//float  ratio=0;
				FileReader fr = new FileReader ("stat.txt");
				Scanner scan = new Scanner(fr);
				scan.useDelimiter("\t");		// Le délimiteur utilise ici est la tabulation, afin de bien lire les differents noms
				while (scan.hasNext()) 
				{
					nbjoue = Integer.parseInt(scan.next());			// Le premier champ est votre nom
					nbgagne = Integer.parseInt(scan.next());			// Le deuxieme champ est le nom du joueur en face de vous
					nbperdu = Integer.parseInt(scan.next());			// Le troisieme champ est le nom du joueur a votre gauche
					ratio = Integer.parseInt(scan.next());			// Le quatrieme champ est le nom du joueur a votre droite
					chkoba = Integer.parseInt(scan.next());			// Le dernier champ est l'int de la difficulte
					carreau = Integer.parseInt(scan.next());
					plis = Integer.parseInt(scan.next());
					sept = Integer.parseInt(scan.next());
					septcarreau = Integer.parseInt(scan.next());				
				}
				////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
				int temp=0;
				boolean boule = false;
				nbjoue = nbjoue+1;
				nbgagne = nbgagne+partiegagne;
				nbperdu = nbperdu+partieperdue;
				temp = pl.getJoueurs().get(numJoueur1).getChkoba();
				chkoba = chkoba+temp;
				temp = pl.getJoueurs().get(numJoueur1).compteCarreaux();
				carreau = carreau + temp;
				temp = pl.getJoueurs().get(numJoueur1).getTaillePlis();
				plis = plis+temp;
				temp = pl.getJoueurs().get(numJoueur1).compteSept();
				sept = sept+temp;
				boule = pl.getJoueurs().get(numJoueur1).septCarreau();
				if (boule)
					septcarreau = septcarreau + 1;
				//ratio = nbgagne/nbperdu;
				
				BufferedWriter save = new BufferedWriter(new FileWriter("stat.txt", false));
				PrintWriter pw = new PrintWriter(save);
				String s="";
				
				s += nbjoue+"\t"+nbgagne+"\t"+nbperdu+"\t"+ratio+"\t"+chkoba+"\t"+carreau+"\t"+plis+"\t"+sept+"\t"+septcarreau+"\t"; 
				pw.write(s);
				
				save.close();
				
				if (res == 0)
				{
					String name=pl.getJoueurs().get(0).getNom();
					new IHMPlateau4j(ind, true, this.team1, this.team2, nbJoueursMan, name, moniscore, soniscore);
					setVisible(false);	
					pl.setJoueurCourant();
				}
				
			}
			compt=0;
			aPrendre = new ArrayList<ICarte>();
			if (pl.getPioche().size() == 0)
				pioche.setVisible(false);
			if ( pl.getEquipe1().get(0).getTaillePlis() != 0 || pl.getEquipe1().get(1).getTaillePlis() != 0  )
					carteGagneJoueur.setVisible(true);
			if (pl.getEquipe2().get(0).getTaillePlis() != 0 || pl.getEquipe2().get(1).getTaillePlis() != 0)
					carteGagneAdv.setVisible(true);
		}
		catch ( Exception e)
		{
			e.printStackTrace();
		}
	}
	
	public void faireJouerLIA()
	{
		try
		{
			pl.getJoueurCourant().jouer(pl);
			actualiser();
		}
		catch(Exception e){e.printStackTrace();}

	}
	
	public void prendre(BoutonCarte bCMain,BoutonCarte bCTapis)
	{
		try
		{
			if(this.getCursor().getType()  != cursor.DEFAULT_CURSOR)	
			{
				for ( int i =0 ; i != carteTapis.size();i++)
				{
					if (carteTapis.get(i).getBounds().getY() != 150 && carteTapis.get(i)==bCTapis)
					{
						carteTapis.get(i).setBounds((int)carteTapis.get(i).getBounds().getX(),150,89,148);
						compt += bCTapis.getInt();
						aPrendre.add(bCTapis.getCarte());
						val1=bCMain.getInt();
						
						if(aPrendre.size() == pl.getJoueursM().get(0).coupsPossibles(bCMain.getCarte(),pl))
						{
							if (val1 == compt)
							{
								tmpTapis.add(bCTapis.getCarte());
								gagneCarte(bCMain,bCTapis);
								compt = 0;
								pl.majDernierPli(bCMain.getCarte(),aPrendre);
								pl.prendre(bCMain.getCarte(),aPrendre);
								
								if ( pl.getJoueurCourant().getPris() == false )
									pl.getJoueurCourant().setPris();
								
								this.actualiser();
								pl.setJoueurCourant();
								
								if ( pl.getJoueurCourant().getPris() == true )
									pl.getJoueurCourant().setPris();
								
								System.out.println(pl.getJoueurCourant().affiche());
								
								while (pl.getJoueursM().indexOf(pl.getJoueurCourant()) == -1)
								{
									faireJouerLIA();
									pl.setJoueurCourant();
								}
							}
						}
					}
					else if (carteTapis.get(i).getBounds().getY() == 150 && carteTapis.get(i)==bCTapis)
					{
						aPrendre.remove(bCTapis.getCarte());
						compt -= bCTapis.getInt();
						carteTapis.get(i).setBounds((int)carteTapis.get(i).getBounds().getX(),100,89,148);
					}
				}
			}
		}
		catch(Exception e){ e.printStackTrace();}
	}
	
	public void verif(BoutonCarte bC)
	{
		try
		{
			IMain tmp=pl.getJoueurs().get(0).getMain();
			bC.setVisible(false);
			
			if( tmp.size() > 0 && tmp.get(0).getValeur()!=0 )
				carteMain.get(0).setVisible(true);
			if( tmp.size() > 1 && tmp.get(1).getValeur()!=0 )
				carteMain.get(1).setVisible(true);
			if(tmp.size() > 2 && tmp.get(2).getValeur()!=0 )
				carteMain.get(2).setVisible(true);
		}
		catch( Exception e){ e.printStackTrace(); }
	}
	
	public void changeImageMain(String skin, int s)
	{
		try
		{
			ImageIcon imagic;
			
					if (pl.getJoueurs().get(s).getMain().size() == 0)
					{
						imagic = new ImageIcon("./Skin/Skin1/vide.png");
						mainJoueurFace.setIcon(imagic);
					}
						if (pl.getJoueurs().get(s).getMain().size() == 3)
						{
							if (s == 1)
							{
								imagic = new ImageIcon("./Skin/Skin"+skin+"/face3.png");
								mainJoueurFace.setIcon(imagic);
							}
							else if (s == 2)
							{
								imagic = new ImageIcon("./Skin/Skin"+skin+"/gauche3.png");
								mainJoueurGauche.setIcon(imagic);
							}
							else if (s == 3)
							{
								imagic = new ImageIcon("./Skin/Skin"+skin+"/droite3.png");
								mainJoueurDroite.setIcon(imagic);
							}
						}
						else if (pl.getJoueurs().get(s).getMain().size() == 2)
						{
							if (s == 1)
							{
							imagic = new ImageIcon("./Skin/Skin"+skin+"/face2.png");
							mainJoueurFace.setIcon(imagic);
							}
							else if (s == 2)
							{
								imagic = new ImageIcon("./Skin/Skin"+skin+"/gauche2.png");
								mainJoueurGauche.setIcon(imagic);
							}
							else if (s == 3)
							{
								imagic = new ImageIcon("./Skin/Skin"+skin+"/droite2.png");
								mainJoueurDroite.setIcon(imagic);
							}
						}
						else if (pl.getJoueurs().get(s).getMain().size() == 1)
						{
							if (s == 1)
							{
							imagic = new ImageIcon("./Skin/Skin"+skin+"/face1.png");
							mainJoueurFace.setIcon(imagic);
							}
							else if (s == 2)
							{
								imagic = new ImageIcon("./Skin/Skin"+skin+"/gauche1.png");
								mainJoueurGauche.setIcon(imagic);
							}
							else if (s == 3)
							{
								imagic = new ImageIcon("./Skin/Skin"+skin+"/droite1.png");
								mainJoueurDroite.setIcon(imagic);
							}
						}
					
				
			}catch(Exception excep){}
	}
}