import java.awt.*;
import java.nio.*;
import java.nio.channels.*;

import java.util.*;
import java.io.*;



//import java.io.*;
//import java.util.*;
import java.util.zip.*;
//import java.util.Enumeration;
import java.text.*;
import sun.text.Normalizer;

public class Monde implements java.io.Serializable{
	
	transient int zoom=0;
	
	transient String typedelobjet=new String();
	transient String strClass =new String();
	transient String strModele= new String();
	transient String nivDest=new String();
	transient boolean dejavu=false;
	transient String classdelobjet=new String();
	transient String strType=new String() ;

	//transient String ti=new String();
	//transient String tiC=new String();

	transient String n=new String();
	transient String nightStr=new String();
	transient String dest=new String();
	transient String sourceName=new String();
	transient Object source=new Object();
	transient String night=new String();
	transient String temp=new String();
    transient String fichier=new String();
	transient String direct=new String();
	
	
	private transient Font police=new Font("Arial",Font.BOLD,12);
	private transient Font police2=new Font("Arial",Font.BOLD,18);
	
	
	transient boolean bruitPas=true;
	
	public Font getPolice(){
		
		try
	    {
	        File file = new File("./fonts/Berylium.ttf");
			FileInputStream fis = new FileInputStream(file);
			police = Font.createFont(Font.TRUETYPE_FONT, fis);
	        fis.close();
	    }
	    catch(Exception e)
	    {
	        e.printStackTrace();
	    }
		
		police = police.deriveFont(Font.BOLD,12f);
		
		
		return police;
	}
	
	public Font getPolice2(){
		return police2;	
	}
	
	
	/**
	 * Taille générique du tampon en lecture et écriture
	 */
	static final int BUFFER = 2048;
	
	transient boolean reinerTrees=true;
	
	transient boolean pluie=true;
	transient int precedentTourPluie=0;
	
	////////////////////////////////////////
	transient boolean open=false;
	
	transient boolean losOn=true;
	
	private transient int dommageEquip=0;
	
	
	transient boolean messageErrorMem=false;
	
	private transient Entite objet=new Entite();
	
	transient int tailleGrille=100; 
	
	//////////////////////////////////////////////////////////////////////
	ArrayList grille[][]=new ArrayList[tailleGrille][tailleGrille];
	
	
	transient int shadowGrid[][]=new int[tailleGrille][tailleGrille];
	transient int eclairageGrid[][]=new int[tailleGrille][tailleGrille];
	
	//grille des animations
	transient int animGrid[][]=new int[tailleGrille][tailleGrille];
	
	//grille de nightvision du perso
	transient int infraRedGrid[][]=new int[tailleGrille][tailleGrille];
	
	//grille Rayon X
	transient int xRayGrid[][]=new int[tailleGrille][tailleGrille];
	
	//grille minimap
	int mapGrid[][]=new int[tailleGrille][tailleGrille];
	//////////////////////////////////////////////////////////////////////
	
	transient Personnage perso=new Personnage(this,new String(),new String(),0,0,0,0,0,0,0,0,0,0,0,0,0,0);
	
	private transient boolean nuit=false;
	private transient int precedentTourNuit=0;
	
	private transient int tour=0;
	
	transient PanneauJeu jeuPan;
	
	private transient int orient=0;
	private transient Point insertPt=new Point(0,0);
	private transient Point oldInsertPt=new Point(0,0);
	
	
	
	transient Catalog cat;
	
	public Monde(PanneauJeu pj,Catalog ct){
		jeuPan=pj;
		
		cat=ct;
		
		
		
		initialisationMapGrid();
		
		
		
	}
	
	/////////////////////////////////////////////////////
	/////////////////////////////////////////////////////
	
	
	public void ambiance(){
		//System.out.println("ambiance");
		new ThreadSonAmbiance(0,this).start();
	}
	
	
	
	/////////////////////////////////////////////////////
	/////////////////////////////////////////////////////
	public void initialisationMapGrid(){
		for(int x=0;x<tailleGrille;x++){
			for(int y=0;y<tailleGrille;y++){
        	
	        	
	        	mapGrid[x][y]=9;
	        	
	        	
		 	}
		 }
		
	}
	
	
	
	
	
	
	
	/////////////////MESSAGES///////////////////////////
	public void message(String me,boolean l){
		jeuPan.messagesPanel.remplissageMessages(me,l);
	}
	
	
	
	
	
	
	
	
	////////////////////////////BOF////////////////////////////////////PAS UTILISE
	///////////////////Pour le premier terrain uniquement////
	
	public void killUndeads(){
				
		ArrayList livingDeads=chercheEntites("UndeadCategory");
		if(!livingDeads.isEmpty()){
				
			for(int i=0;i<livingDeads.size();i++){
							
	 			try{
	 				objet = (Entite) livingDeads.get(i);
	 				
	 				if(!nuit){  //DEAD BY DAWN
	 					objet.setMort(this,true,0,0);
	 					objet.setCurrentHitPts(0);
	 				}		
 				}
				catch(NoSuchElementException exc){};
 			}
	 	}
	 
	}
	////////////////////////////BOF////////////////////////////////////
	
	
	
	
	
	
	
	///////////////////////////////////////////////////////
	/////////// JET DE DES/////////////////////////////////
	///////////////////////////////////////////////////////
/*	
	public int rollxdy(int x,int y,boolean openended){
		
		int jet=(int)(Math.abs(Math.random()*y))+1;
		
		int jetFinal=jet*x;
		
		
		//OPEN-ENDED +
		if(openended==true && y==100 && jetFinal>=96){
			
			int jetSup=rollxdy(1,100,true);
			
			jetFinal=jetFinal+jetSup;
			
		}
		
		
		//OPEN-ENDED -
		if(openended==true && y==100 && jetFinal<=4){
			
			int jetSup=rollxdy(1,100,true);
			
			jetFinal=jetFinal-jetSup;
			
		}
		
		
		
		return jetFinal;
		
		
		
	}*/
	
	
	public int roll(){
		int d1=(int)(Math.abs(Math.random()*10))+1;
		int d2=(int)(Math.abs(Math.random()*10))+1;
		
		int result=d1+d2;
		
		if(d1==1 && d2==1 && !open){
			return result;
		}
		
		if(d1==d2){
			open=true;
			result=result+roll();
		}
		
		open=false;
		return result;
	}
	
	
	
	//////////////////////////////////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////
	//////////////LE TOUR DU MJ///////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////
	public void tourMonde(){
		
		
		jeuPan.mapPanel.mapGrid=mapGrid;
		
		
		///Reinitialisation d'animGrid à 0
		for(int x=0;x<tailleGrille;x++){
			for(int y=0;y<tailleGrille;y++){
        	
	        	
	        	animGrid[x][y]=0;
	        	
	        	
		 	}
		 }
		
		
		
		
		
		//System.out.println(perso.xpNiveauSuivant);
		
		//Parcourir la grille à la recherche des creatures
		
		//on reinitialise les aBouge des creatures à false et on modifie les flee////////////
		
		for(int x=0;x<tailleGrille;x++){
        	for(int y=0;y<tailleGrille;y++){
        		
        		
				if(!this.grille[x][y].isEmpty()){
					
						
		 			for(int i=0;i<this.grille[x][y].size();i++){
					
		 					
			 			try{
			 					
			 					
			 				objet = (Entite) this.grille[x][y].get(i);		
		 				
							typedelobjet=objet.getTypeObjet();
							
							
							if(typedelobjet.compareTo("Creature")==0 && objet.getABouge()==true){
								objet.setABouge(false);
								
								
								if(objet.getClass().getName().compareTo("UndeadCategory")!=0 && objet.getClass().getName().compareTo("DemonCategory")!=0 && objet.getClass().getName().compareTo("DragonCategory")!=0 && objet.getClass().getName().compareTo("CthulianCategory")!=0 && !objet.getMort() && objet.getCurrentHitPts()<Math.round(objet.getMaxHitPts()/4)){
								
									objet.setFlee(true);
								}
								
							}
							
								
		 				}
		 				catch(NoSuchElementException exc){};
		 				
		 				
		 			}
		 		}
        	}
        	
        }
		
		
		
		//////////////////LES CREATURES BOUGENT//////////////////////////////////
        
        for(int x=0;x<tailleGrille;x++){
        	for(int y=0;y<tailleGrille;y++){
        		
        		
        		if(!this.grille[x][y].isEmpty()){
					
					
					for(int i=0;i<this.grille[x][y].size();i++){
					
		 					
			 			try{
			 					
			 					
			 				objet = (Entite) this.grille[x][y].get(i);
		 					
		 					
							typedelobjet=objet.getTypeObjet();
							
							
					
							
							//Conditions de mouvement-----------------
							
							if(typedelobjet.compareTo("Creature")==0 && objet.getABouge()==false && objet.getMort()==false){
						
								
									int rapidite=1;	
									while(rapidite<=objet.getRapidite()){
										
										objet.mouvement(this,objet.getCooX(),objet.getCooY());
										
										
										rapidite++;
											
					 				}
									objet.setABouge(true);
							
							}	
							
										 					
		 				}
		 				catch(NoSuchElementException exc){};
		 			}
		 		}
        	}
        	
        }
		
		
		
		/////INTERROGATION DES OBJETS DANS L'INVENTAIRE DU PERSONNAGE/////////////
		
		int ec=0;
		
		if(!perso.equipementVect.isEmpty()){
					
			for(Enumeration e = perso.equipementVect.elements();e.hasMoreElements();){
                
 				try{
 					objet=(Entite) e.nextElement();
					classdelobjet=objet.getClass().getName();
					
					
					////// PERTE D'HUILE///////////////
					if(classdelobjet.compareTo("Outil")==0 && objet.getAlume()==true){
						
						
						if(objet.getHuile()<=0){
							objet.setAlume(false);
						}
						
						if(objet.getHuile()>0){
							objet.setHuile(objet.getHuile()-1);
						}
						
					}
					
					
					
					if(objet.getAlume() && objet.getEclairage()>=ec){
						ec=objet.getEclairage();	
					}
					
					
					if(objet.getStructureMat()<=0){
						objet.setCasse(true);
						
					}
					
					
						
				}
				catch(NoSuchElementException exc){};
			}
		}
		
		perso.setVue(ec);
		
		
		//////////////////////////////
		if(ec!=0){
			perso.setEstEclaireParCeQuilPorte(true);
		}
		else{
			perso.setEstEclaireParCeQuilPorte(false);
		}
		//////////////////////////////
		
		
		if(eclairageGrid[perso.getCooX()][perso.getCooY()]!=2){
			perso.setEstEclaireParObjetProche(true);
		}
		else{perso.setEstEclaireParObjetProche(false);
		}
		
		
		//System.out.println("PersoEstEclaireParCeQuilPorte "+perso.getEstEclaireParCeQuilPorte());
		//System.out.println("PersoEstEclaireParObjetProche "+perso.getEstEclaireParObjetProche());
		
		
		
		
		
		
		
		
		/////AUGMENTATION FAIM//////
		
		perso.setFaim(perso.getFaim()+1);
		
		if(perso.getFaim()>=1000){
			perso.setFaim(1000);
			perso.setCurrentHitPts(perso.getCurrentHitPts()-1);
			message("Vous mourrez de faim !",false);
			message("You're starving !",true);
		}
		
		
		
		
		////////////////////BRUITAGES AMBIANCE/////////////////////////////
		
		
		/*
		double aleaBruits=(int)((Math.random()*200)+1);
		
		///////En surface
		if(nuit==true && perso.indexTerrainZ<=0){
			if(aleaBruits==1){
				
				new ThreadSon("./sons/hibou-grand-duc.wav",0).start();
			}
			
			if(aleaBruits==2){
				
				new ThreadSon("./sons/chouette-hulotte.wav",-5).start();
			}	
		}
		
		
		if(nuit==false && perso.indexTerrainZ<=0){
			if(aleaBruits==1){
				
				new ThreadSon("./sons/fauvette-a-tete-noire.wav",-8).start();
			}
			
			if(aleaBruits==2){
				
				new ThreadSon("./sons/grand-corbeau.wav",0).start();
			}
			
		}
		
		
		//sous terre
		if(perso.indexTerrainZ>0){
			if(aleaBruits==1){
				
				new ThreadSon("./sons/rats.wav",0).start();
			}
			
			if(aleaBruits==2){
				
				new ThreadSon("./sons/secret_door.wav",0).start();
			}
			
				
				
		}
		*/
		
			
		
		
		
		
		/////CYCLE JOUR/NUIT/////////////////////////
		
		if(tour==precedentTourNuit+300 && nuit==true){
			nuit=false;precedentTourNuit=tour;
			message("Le jour se leve",false);
			message("A new day",true);
			
			new ThreadSon("./sons/coq.wav",0).start();
			
		}
		
		
		if(tour==precedentTourNuit+300 && nuit==false){
			nuit=true;
			precedentTourNuit=tour;
			message("La nuit tombe",false);
			message("Nightfall",true);
			
			new ThreadSon("./sons/cloche.wav",0).start();
			
				
		}
		
		
		
		/////CYCLE PLUIE
		if(tour==precedentTourPluie+100 && pluie==true){
			if((int)(Math.random()*100)+1>50){
				pluie=false;
				
			}
			precedentTourPluie=tour;	
			
		}
		if(tour==precedentTourPluie+100 && pluie==false){
			if((int)(Math.random()*100)+1>50){
				pluie=true;
				
			}
			precedentTourPluie=tour;					
		}
		
		
		
		
		
		///////TEST jour/nuit sur morts-vivants
	 	undeads();
		
		
		//////////TUE PERSO SI DANS MUR OU DANS LE VIDE
		testSiPersoDansMurOuVide();
		

	
		
		
		
		
		/////MODIFICATIONS DE L'ETAT DU PERSONNAGE
		System.out.println("duree poison "+perso.getDureeEffetPoisonned());
		// POISON //
		if(perso.getPoisonned()){
			perso.setCurrentHitPts(
				perso.getCurrentHitPts()-
				perso.getDegatPoisonned()
			);
			
			message("Poison: You lose "+perso.getDegatPoisonned()+" Hits",true);
			message("Poison: Vous perdez "+perso.getDegatPoisonned()+" Pts de vie",false);
			new ThreadSon("./sons/attributeLost.wav",0).start();
		}
			
		
		
		
		//////////VERIFICATION DE L'ETAT DE SANTE DU PERSONNAGE///////////
	
		if(perso.getCurrentHitPts()<1){
			perso.setMort(this,true,0,0);	
		}
		
		if(perso.getMort()==true){
			
			new ThreadSon("./sons/death.wav",0).start();
			
			message("VOUS ETES MORT",false);
			message("YOU ARE DEAD",true);
			
			//new RIP();
			
		}
		
		
		
		
		
		////////RECUPERATIONS PtsVie et PowerPoints
		
		if(perso.currentPower<perso.maxPower && tour%10==0){
			perso.currentPower++;
			
		}
		
		if(perso.getCurrentHitPts()<perso.getConstitution()*20 && tour%5==0){
			perso.setCurrentHitPts(perso.getCurrentHitPts()+1);
		}
		
		
		
		
		
		//////////////////UPDATES/////////////////////
		tour++;
		
		miseAJourResumeStatsPanel();
		
		
		//ancienne méthode
		//jeuPan.equipementpanel.verifModif(this,perso.equipementVect);
		
		
		//jeuPan.terrainPanel.repaint();
		//jeuPan.repaint();
		
		

		
		
		System.out.println("*****************************");
		System.out.println("MaxMemory ="+(int)(java.lang.Runtime.getRuntime().maxMemory()/1000000)+" meg");
		System.out.println("UsedMemory="+(int)((java.lang.Runtime.getRuntime().maxMemory()-java.lang.Runtime.getRuntime().freeMemory ())/1000000));
		System.out.println("FreeMemory="+(int)(java.lang.Runtime.getRuntime().freeMemory ()/1000000)+" meg");
		
		if(!messageErrorMem && (int)(java.lang.Runtime.getRuntime().maxMemory()/1000000)<120){
		
			
			message("THE HEAP MEMORY MAXIMUM IS LOW, PLEASE LAUNCH CRYPTRL THIS WAY: ",true);
			message("LA QUANTITE DE MEMOIRE RESERVEE EST FAIBLE, VEUILLEZ LANCER CRYPTRL DE CETTE MANIERE:",false);
			message("java -cp . -Xms128m -Xmx128m CryptRL",true);
			message("java -cp . -Xms128m -Xmx128m CryptRL",false);
			messageErrorMem=true;
		}
		
		System.out.println("*****************************");
		
		
		
		jeuPan.mapPanel.repaint();
		
	}
	
	
	
	
	/////MORTS VIVANTS////////
	public void undeads(){
		
				
		ArrayList livingDeads=chercheEntites("UndeadCategory");
		if(!livingDeads.isEmpty()){
				
			for(int i=0;i<livingDeads.size();i++){
							
	 			try{
	 				objet = (Entite) livingDeads.get(i);
	 				
	 				if(nuit && precedentTourNuit==tour){ //RETURN OF THE LIVING DEAD
	 					objet.setMort(this,false,0,0);
	 					objet.setCurrentHitPts(objet.getMaxHitPts());
	 					objet.aCrie=false;
	 				
	 				}
	 				
	 				if(!nuit && perso.indexTerrainZ<=0){  //DEAD BY DAWN
	 					objet.setMort(this,true,0,0);
	 					objet.setCurrentHitPts(0);
	 				}		
		 				
	 				
 				}
				catch(NoSuchElementException exc){};
 			}
	 	}
	 	if(nuit && precedentTourNuit==tour){
	 		message("Le retour des morts vivants...",false);
	 		message("Return of the living dead...",true);
	 				
	 	}
		
	}
	
	
	
	
	//////////////////////////////////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////
	public void testSiPersoDansMurOuVide(){
		/////////ON VERIFIE SI LE PERSO EST DANS UN OBSTACLE CASSE ET N'EST PAS PASSE MURAILLE
		boolean dieMur=false;
		boolean dieVide=false;
		
		if(!grille[perso.getCooX()][perso.getCooY()].isEmpty()){
				for(int i=0;i<grille[perso.getCooX()][perso.getCooY()].size();i++){	
		 			try{
		 					
		 				objet = (Entite)grille[perso.getCooX()][perso.getCooY()].get(i);
	 					
						typedelobjet=objet.getTypeObjet();
						
						
						if(typedelobjet.compareTo("Obstacle")==0&&!objet.getOuvert()&&!objet.getCasse()&&!perso.getPasseMuraille()){
							dieMur=true;
						}
						
						if(objet.getClass().getName().compareTo("VraiVide")==0){
							dieVide=true;
						}
						
					
					}
					catch(NoSuchElementException exc){};
				}
			}
			
			if(dieMur){
				message("Vous fusionnez avec cet obstacle. Une mort amusante.",false);
				message("You amalgamates with this obstacle. Very nice death.",true);
				
				losOn=false;
				
				perso.setMort(this,true,0,0);
				new ThreadSon("./sons/death.wav",0).start();

				message("VOUS ETES MORT",false);
				message("YOU ARE DEAD",true);
	
			}
			
		
			if(dieVide && !perso.getVolant()){
				message("YOU FALL !!! .....and die",true);
				message("Vous tombez !!! .....et vous ecrasez",false);
				new ThreadSon("./sons/fall_down_level.wav",0).start();
				perso.setMort(this,true,0,0);
			}
			
		
	}
	
	
	//////////////////////////////////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////
	//////OUTIL DE RECHERCHE GENERIQUE D'ENTITES//////////////////////////////
	//////////////////////////////////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////
	public ArrayList chercheEntites(String genre){
		ArrayList listeTrouvesStr=new ArrayList();
		
		//on cherche dans toute la grille
		// a chaque fois qu'on trouve une entite du genre recherché on la stocke dans le vecteur
		for(int x=0;x<tailleGrille;x++){
        	for(int y=0;y<tailleGrille;y++){	
        		
        		
        		if(!grille[x][y].isEmpty()){
					
					for(int i=0;i<grille[x][y].size();i++){
					
		 					
			 			try{
			 					
			 					
			 				objet = (Entite) grille[x][y].get(i);
							typedelobjet =objet.getTypeObjet();
							strClass = (objet.getClass().getName());
							strModele= objet.getModele();
							
							
							
							if(typedelobjet.compareTo(genre)==0 || strClass.compareTo(genre)==0 || strModele.compareTo(genre)==0){
								listeTrouvesStr.add(objet);
							
							}
							
							
						}
						catch(NoSuchElementException exc){};
					}
				}
			}
		}
		
		return listeTrouvesStr;
	}
	
	
	//////////////////////////////////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////
	//////OUTIL DE RECHERCHE GENERIQUE D'ENTITES avec retour booleen//////////
	//////////////////////////////////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////
	public boolean chercheEntiteBool(String genre,int x,int y){
		if(!grille[x][y].isEmpty()){
			for(int i=0;i<grille[x][y].size();i++){
	 			try{	
	 				objet = (Entite)grille[x][y].get(i);
					typedelobjet=objet.getTypeObjet();
					strClass = (objet.getClass().getName());
					strModele= objet.getModele();
					if(typedelobjet.compareTo(genre)==0 || strClass.compareTo(genre)==0 || strModele.compareTo(genre)==0){
						return true;
					}
				}
				catch(NoSuchElementException exc){};
			}
		}
		return false;
	}
	
	
	//////////////////////////////////////////////////////////////////////////
	
	
	
	
	
	
	
	
	
	
	
	//////////////////////////////////////////////////////////////////////////
	
	public void setNuit(boolean etatnuit){
		
		nuit=etatnuit;	
	}
	
	public boolean getNuit(){
		return nuit;
	}
	
	////////////////////MISE A JOUR RESUMEPANEL/////////////////////////////////
	public void miseAJourResumeStatsPanel(){
		
		jeuPan.resumestatsPanel.nomTxt.setText(perso.getNom());
		jeuPan.resumestatsPanel.forceInt.setText(new Integer(perso.getForce()).toString());
		jeuPan.resumestatsPanel.dexteriteInt.setText(new Integer(perso.getDexterite()).toString());
		jeuPan.resumestatsPanel.constitutionInt.setText(new Integer(perso.getConstitution()).toString());
		jeuPan.resumestatsPanel.intelligenceInt.setText(new Integer(perso.getIntelligence()).toString());
		jeuPan.resumestatsPanel.atkInt.setText(new Integer(perso.getBaseAtk()).toString());
		jeuPan.resumestatsPanel.atkModifieeInt.setText(new Integer(perso.getAtkModifiee()).toString());
		jeuPan.resumestatsPanel.defInt.setText(new Integer(perso.getBaseDef()).toString());
		jeuPan.resumestatsPanel.defModifieeInt.setText(new Integer(perso.getDefModifiee()).toString());
		jeuPan.resumestatsPanel.vieMaxInt.setText(new Integer(perso.getMaxHitPts()).toString());
		jeuPan.resumestatsPanel.vieActuelleInt.setText(new Integer(perso.getCurrentHitPts()).toString());
		jeuPan.resumestatsPanel.rapiditeInt.setText(new Integer(perso.getRapidite()).toString());
		jeuPan.resumestatsPanel.paradeInt.setText(new Integer(perso.getParade()).toString());
		jeuPan.resumestatsPanel.encInt.setText(new Integer(perso.getEncombrement()).toString());
		jeuPan.resumestatsPanel.encMax.setText(new Integer(perso.getEncCapacity()).toString());
		jeuPan.resumestatsPanel.niveauTxt.setText(new Integer(perso.getNiveau()).toString());
		jeuPan.resumestatsPanel.xpTxt.setText(new Integer(perso.getXp()).toString());
		jeuPan.resumestatsPanel.rndIntLbl.setText(new Integer(tour).toString());
		jeuPan.resumestatsPanel.xGLOBALLbl.setText(new Integer(perso.indexTerrainX).toString());
		jeuPan.resumestatsPanel.yGLOBALLbl.setText(new Integer(perso.indexTerrainY).toString());
		jeuPan.resumestatsPanel.zGLOBALLbl.setText(new Integer(perso.indexTerrainZ).toString());
		jeuPan.resumestatsPanel.xLbl.setText(new Integer(perso.getCooX()).toString());
		jeuPan.resumestatsPanel.yLbl.setText(new Integer(perso.getCooY()).toString());
		jeuPan.resumestatsPanel.faimInt.setText(new Integer(perso.getFaim()).toString());
		
		jeuPan.resumestatsPanel.perceptionLvl.setText(new Integer(perso.perceptionLvl).toString());
		jeuPan.resumestatsPanel.discretionLvl.setText(new Integer(perso.discretionLvl).toString());
		jeuPan.resumestatsPanel.meleeLvl.setText(new Integer(perso.meleeLvl).toString());
		jeuPan.resumestatsPanel.distanceLvl.setText(new Integer(perso.distanceLvl).toString());
		jeuPan.resumestatsPanel.magieLvl.setText(new Integer(perso.magieLvl).toString());
		jeuPan.resumestatsPanel.attunementLvl.setText(new Integer(perso.attunementLvl).toString());
		jeuPan.resumestatsPanel.crocheterLvl.setText(new Integer(perso.crocheterLvl).toString());
		jeuPan.resumestatsPanel.piegesLvl.setText(new Integer(perso.piegesLvl).toString());
		jeuPan.resumestatsPanel.identificationLvl.setText(new Integer(perso.identificationLvl).toString());
		jeuPan.resumestatsPanel.baratinLvl.setText(new Integer(perso.baratinLvl).toString());
		
		jeuPan.resumestatsPanel.perceptionTot.setText(new Integer(perso.perception).toString());
		jeuPan.resumestatsPanel.discretionTot.setText(new Integer(perso.discretion).toString());
		jeuPan.resumestatsPanel.meleeTot.setText(new Integer(perso.melee).toString());
		jeuPan.resumestatsPanel.distanceTot.setText(new Integer(perso.distance).toString());
		jeuPan.resumestatsPanel.magieTot.setText(new Integer(perso.magie).toString());
		jeuPan.resumestatsPanel.attunementTot.setText(new Integer(perso.attunement).toString());
		jeuPan.resumestatsPanel.crocheterTot.setText(new Integer(perso.crocheter).toString());
		jeuPan.resumestatsPanel.piegesTot.setText(new Integer(perso.pieges).toString());
		jeuPan.resumestatsPanel.identificationTot.setText(new Integer(perso.identification).toString());
		jeuPan.resumestatsPanel.baratinTot.setText(new Integer(perso.baratin).toString());
		
		jeuPan.resumestatsPanel.ppInt.setText(new Integer(perso.currentPower).toString());
		
		
		
		if(nuit && jeuPan.lang){
			jeuPan.resumestatsPanel.dayLbl.setText("Night");
		}
		if(!nuit && jeuPan.lang){
			jeuPan.resumestatsPanel.dayLbl.setText("Day");
		}
		
		if(nuit && !jeuPan.lang){
			jeuPan.resumestatsPanel.dayLbl.setText("Nuit");
		}
		if(!nuit && !jeuPan.lang){
			jeuPan.resumestatsPanel.dayLbl.setText("Jour");
		}
		
		
		
		
	}
	
	
	//////////////////////////////////////
	
	//////////////////////////////////////
	
	//////////////////////////////////////
	
	//////////////////////////////////////
	
	//////////////////////////////////////
	
	// COMBAT MELEE
	
	//////////////////////////////////////
	
	public void combatMelee(Entite attaquant,Entite defenseur, int xdef, int ydef){
		
	
		if(defenseur.getTypeObjet().compareTo("Creature")==0 || defenseur.getClass().getName().compareTo("Personnage")==0){
		
		
			int jetAtk=roll();
			int jetDef=roll();
			
			int atk=attaquant.getAtkModifiee()*jetAtk;
			int def=defenseur.getDefModifiee()*jetDef;
			int hitActuelsDef=defenseur.getCurrentHitPts();
			int degats=atk-def;
			
			
			//jeuPan.messagesPanel.remplissageMessages("*********************************");
			
			message(attaquant.getNom()+" ATK: "+attaquant.getAtkModifiee()+"+"+" ROLL: "+jetAtk,false);
			message(defenseur.getNom()+" DEF: "+defenseur.getDefModifiee()+"+"+"ROLL: "+jetDef,false);
			message(attaquant.getNomE()+" ATK: "+attaquant.getAtkModifiee()+"+"+" ROLL: "+jetAtk,true);
			message(defenseur.getNomE()+" DEF: "+defenseur.getDefModifiee()+"+"+"ROLL: "+jetDef,true);
			
			/*
			if(attaquant.getArmeEquipe()!=null){
				jeuPan.messagesPanel.remplissageMessages(attaquant.getNom()+" : "+attaquant.getArmeEquipe().getNom()+"(+"+attaquant.getbonusAtkArme()+")");
			}
			
			if(attaquant.getArmureEquipe()!=null){
				jeuPan.messagesPanel.remplissageMessages(attaquant.getNom()+" : "+attaquant.getArmureEquipe().getNom()+"(+"+attaquant.getbonusDefArmure()+")");
			}
			
			
			if(defenseur.getArmeEquipe()!=null){
				jeuPan.messagesPanel.remplissageMessages(defenseur.getNom()+" : "+defenseur.getArmeEquipe().getNom()+"(+"+defenseur.getbonusAtkArme()+")");
			}
			
			if(defenseur.getArmureEquipe()!=null){
				jeuPan.messagesPanel.remplissageMessages(defenseur.getNom()+" : "+defenseur.getArmureEquipe().getNom()+"(+"+defenseur.getbonusDefArmure()+")");
			}
			*/
			
			
			
			
			////////DEGATS MATERIELS///////////////
			
			dommageEquip=attaquant.getArmeEquipe().getResistanceMat()-defenseur.getArmureEquipe().getResistanceMat();
			
			//System.out.println("***"+attaquant.getArmeEquipe().getResistanceMat()+" "+defenseur.getArmureEquipe().getResistanceMat());
			
			
			if(dommageEquip<0 && attaquant.getArmeEquipe().getStructureMat()>0){
				attaquant.getArmeEquipe().setStructureMat(attaquant.getArmeEquipe().getStructureMat()-Math.abs(Math.round(dommageEquip/2)));
				if(attaquant.getArmeEquipe().getStructureMat()<=0){attaquant.getArmeEquipe().setCasse(true);
				}
			}
			
			if(dommageEquip>0 && defenseur.getArmureEquipe().getStructureMat()>0){
				defenseur.getArmureEquipe().setStructureMat(defenseur.getArmureEquipe().getStructureMat()-Math.abs(Math.round(dommageEquip/2)));
				if(defenseur.getArmureEquipe().getStructureMat()<=0){defenseur.getArmureEquipe().setCasse(true);
				}
			}
			
			if(attaquant.getArmeEquipe().getCasse()){
				//System.out.println("ARME ATK CASSEEE");
				attaquant.unequipArme(attaquant.getArmeEquipe());
				
			}
			
			if(defenseur.getArmureEquipe().getCasse()){
				//System.out.println("ARMURE DEF CASSEE");
				defenseur.unequipArmure(defenseur.getArmureEquipe());
			}
			
			
			
			
			//System.out.println(attaquant.getArmeEquipe().getResistanceMat()+" "+defenseur.getArmureEquipe().getResistanceMat()+"***");
			//System.out.println("Str"+ attaquant.getArmeEquipe().getStructureMat()+" Str"+defenseur.getArmureEquipe().getStructureMat());
			
			/*
			attaquant.arme.getResistanceMat()
			attaquant.arme.getStructureMat()
			attaquant.arme.setStructureMat()
			
			defenseur.armure.getResistanceMat()
			defenseur.armure.getStructureMat()
			defenseur.armure.setStructureMat()
			*/
			
			
			
			
			
			//////////DEGATS CORPORELS////////////////
			
			if(degats>0 && defenseur.getCurrentHitPts()>0){
				defenseur.setCurrentHitPts(hitActuelsDef-degats);
				message(attaquant.getNom()+" inflige "+degats+"pts de degats a "+defenseur.getNom()+"     /     "+"sante de "+defenseur.getNom()+" = "+defenseur.getCurrentHitPts()+"/"+defenseur.getMaxHitPts(),false);
				message(attaquant.getNomE()+" inflicts "+degats+"wound points to "+defenseur.getNomE()+"     /     "+"health of "+defenseur.getNomE()+" = "+defenseur.getCurrentHitPts()+"/"+defenseur.getMaxHitPts(),true);
				
				//jeuPan.messagesPanel.remplissageMessages("sante de "+defenseur.getNom()+" = "+defenseur.getCurrentHitPts()+"/"+defenseur.getMaxHitPts());
			
				
				new ThreadSon("./sons/hit_slash.wav",0).start();
			}
			else{
				//jeuPan.messagesPanel.remplissageMessages(attaquant.getNom()+" rate "+defenseur.getNom());
			
				if(Math.random()*100<50){
					new ThreadSon("./sons/hit_block.wav",-5).start();
				}
				else{
					new ThreadSon("./sons/swing.wav",0).start();
				}
				
				
			}
			
			
			
			//un defenseur "amical" devient "Hostile"
			if(defenseur.getTypeObjet().compareTo("Creature")==0){
				if(defenseur.getHostilite()==false){
					defenseur.setHostilite(true);
					message(defenseur.getNom()+" devient hostile",false);
					message(defenseur.getNomE()+" is becoming hostile",true);
				}
			}
			
			
			
			if(defenseur.getCurrentHitPts()<1){
				defenseur.setMort(this,true,xdef,ydef);
			
				new ThreadSon("./sons/kill1.wav",0).start();
				
				if(defenseur.getTypeObjet().compareTo("Creature")==0){
					message(defenseur.getNom()+" EST MORT",false);
					message(defenseur.getNomE()+" IS DEAD",true);
				}
				
				//XPS
				if(defenseur.getTypeObjet().compareTo("Creature")==0 && attaquant.getClass().getName().compareTo("Personnage")==0){
					message("Vous gagnez "+(defenseur.getNiveau()*250)+" points d experience",false);
					message("You earn "+(defenseur.getNiveau()*250)+" experience points",true);
					
					perso.setXp(perso.getXp()+(defenseur.getNiveau()*250));
					perso.testExperience();
			
				}
				
				
				
			}
		}
		
	}
	
	

	
	



	////////////////////////KICKER///////////////////////////
	
	public void kickerCible(Entite casseur,Entite cible,int cx,int cy){
		
		
		if(cible.getStructureMat()>0 && cible.getTypeObjet().compareTo("Creature")!=0 && cible.getClass().getName().compareTo("Vide")!=0 && cible.getClass().getName().compareTo("Personnage")!=0){
			
			//jeuPan.messagesPanel.remplissageMessages("Resistance: "+cible.getResistanceMat()+"/ Structure: "+cible.getStructureMat());
			
			int jet=roll();
			
			
			int degats=(casseur.getForce()*jet)-50-cible.getResistanceMat();
			
			//int degats=casseur.getForce()+jet-100-cible.getResistanceMat();
			
			if(degats>0){
				cible.setStructureMat(cible.getStructureMat()-degats);
				//jeuPan.messagesPanel.remplissageMessages(" Degats: "+degats);
				
				if(cible.getClass().getName().compareTo("Piege")==0){
						declencheurPiege(perso,cible,perso.getCooX(),perso.getCooY());
				}
				
			}
			else{
				message("Aie !...",false);
				message("Ouch !...",true);
				
				if((perso.getbonusDefArmure()*10)<cible.getResistanceMat()){
					perso.setCurrentHitPts(perso.getCurrentHitPts()-((int)(Math.random()*5)+1));
				}
				//else{System.out.println("protege par larmure");
				//}
				
			}
			
			
			
			
			if(cible.getStructureMat()<=0 && cible.getClass().getName().compareTo("Nourriture")!=0){
				cible.setCasse(true);
				//cible.setUnlocked(true);
				//cible.setOuvert(true);
				message("Vous l avez casse",false);
				message("You ve broke it",true);
			}
		}
		
		
		
		
		if(cible.getCurrentHitPts()>0 && cible.getTypeObjet().compareTo("Creature")==0){
			
			//jeuPan.messagesPanel.remplissageMessages("Vous comptez latter tout le monde comme ca ?");
			int jetAtk=roll();
			int jetDef=roll();
			
			int atk=(casseur.getForce()-4)*jetAtk;
			int def=cible.getDefModifiee()*jetDef;
			int hitActuelsDef=cible.getCurrentHitPts();
			int degats=atk-def;
			
			
			
			//jeuPan.messagesPanel.remplissageMessages(casseur.getNom()+" ATK: "+(casseur.getForce()-40)+" +"+" JET: "+jetAtk);
			//jeuPan.messagesPanel.remplissageMessages(cible.getNom()+" DEF: "+cible.getDefModifiee()+" +"+"JET: "+jetDef);
	
			
			
			
			if(degats>0){
				cible.setCurrentHitPts(hitActuelsDef-degats);
				message(casseur.getNom()+" inflige "+degats+"pts de degats a "+cible.getNom()+"     /     "+"Sante de "+cible.getNom()+" = "+cible.getCurrentHitPts()+"/"+cible.getMaxHitPts(),false);
				message(casseur.getNomE()+" inflicts "+degats+"damage points to "+cible.getNomE()+"     /     "+"Health of "+cible.getNomE()+" = "+cible.getCurrentHitPts()+"/"+cible.getMaxHitPts(),true);
				
				//jeuPan.messagesPanel.remplissageMessages("Sante de "+cible.getNom()+" = "+cible.getCurrentHitPts()+"/"+cible.getMaxHitPts());
		
				//new ThreadSon("./sons/hit_slash.wav").start();
			}
			else{
				message(casseur.getNom()+" rate "+cible.getNom(),false);
				message(casseur.getNomE()+" miss "+cible.getNomE(),true);
			
				if(Math.random()*100<50){
					new ThreadSon("./sons/hit_block.wav",-5).start();
				}
				else{
					new ThreadSon("./sons/swing.wav",0).start();
				}
			}
			
			
			if(cible.getTypeObjet().compareTo("Creature")==0){
				if(cible.getHostilite()==false){
					cible.setHostilite(true);
					message(cible.getNom()+" devient hostile",false);
					message(cible.getNomE()+" is becoming hostile",true);
				}
				
			}
			
			if(cible.getCurrentHitPts()<1){
				cible.setMort(this,true,cx,cy);
			
				new ThreadSon("./sons/kill1.wav",0).start();
				
				message(cible.getNom()+" EST MORT",false);
				message(cible.getNomE()+" IS DEAD",true);
				
			}
			
		}
		
	
		new ThreadSon("./sons/kick.wav",0).start();
		
		
		//jeuPan.terrainPanel.repaint();
		//jeuPan.repaint();
		
	
		
	}
	
	
	
	/////////DECLENCHEUR PIEGE/////////////
	public void declencheurPiege(Entite declencheur,Entite piege,int xAct,int yAct){
		
	
		if(declencheur.getClass().getName().compareTo("Personnage")==0){
			message("Attention au piege !",false);
			message("There is a trap !",true);
		}
	
		
		int jet=roll();
		
		
		if(piege.getModele().compareTo("trou")==0){
			if(piege.getPuissancePiege()-(declencheur.getDexterite()*jet)>0){
				
				if(declencheur.getClass().getName().compareTo("Personnage")==0){
					message("Vous glissez !!!",false);
					message("You slip !!!",true);
				}
				
				piege.effetPiege(declencheur,this,xAct,yAct);
			}
			else{
				
				if(declencheur.getClass().getName().compareTo("Personnage")==0){
					message("Vous avez failli tomber !",false);
					message("Wow... Dont stay too close to this hole !",true);
				}
			}
			
		}
		
		/////////////////////
		else if(piege.getActifPiege()==true){
				
				//a remettre après
				//if(declencheur.getClass().getName().compareTo("Personnage")==0){jeuPan.messagesPanel.remplissageMessages("Complexite: "+piege.getComplexitePiege()+"/    Votre Dex"+perso.getDexterite()+"   Jet: "+jet);}
				
				
				//jeuPan.messagesPanel.remplissageMessages("Complexite: "+piege.getComplexitePiege()+"/    Dex"+declencheur.getDexterite()+"   Jet: "+jet);
				
				
				if(piege.getComplexitePiege()-(declencheur.getDexterite()*jet)>0){
				
					if(declencheur.getClass().getName().compareTo("Personnage")==0){
						message("Il se declenche !!!",false);
						message("You re triggering the trap !!!",true);
					}
					
					piege.effetPiege(declencheur,this,xAct,yAct);
				}
				else{
					
					if(declencheur.getClass().getName().compareTo("Personnage")==0){
						message("Vous avez evite qu il se declenche !",false);
						message("This trap seems not to be triggered...",true);
					}
				}
				
		}
		//////////////////////
		
		else{
			
			if(declencheur.getClass().getName().compareTo("Personnage")==0){
				message("Il ne se produit rien de perceptible",false);
				message("Nothing happens",true);
			}
	
		}
		
		
		if(declencheur.getClass().getName().compareTo("Personnage")==0){piege.setVisible(true);}
			
		
		
	}
	
	///////////////////////SEARCH du Personnage, cherche objets dissimulés/////////////////
	
	public void search(){
		message("Vous examinez votre entourage",false);
		message("You check your surroundings",true);
		
		int cX=perso.getCooX();
		int cY=perso.getCooY();
		int view=perso.getVue();
		//int intPj=perso.getIntelligence();;
		
		if(nuit==false){
			view=4;
		}
		
		
		for(int x=cX-view;x<=cX+view;x++){
        	for(int y=cY-view;y<=cY+view;y++){	
        		
        		
        		
        		//if(!grille[x][y].isEmpty() && cibleEstDansLOSPerso(cX,cY,x,y) ){
				if(!grille[x][y].isEmpty() && shadowGrid[x][y]!=2 ){
					
						for(int i=0;i<grille[x][y].size();i++){
					
		 					
			 			try{
			 					
			 					
			 				objet = (Entite) grille[x][y].get(i);
							
							int distanceX=Math.abs(x-cX);
							int distanceY=Math.abs(y-cY);
							int distanceReel=0;
							if(distanceX<=distanceY){distanceReel=distanceY;}
							if(distanceX>distanceY){distanceReel=distanceX;}
							int jet=roll();
							
							if(view>=distanceReel){
								if((jet*perso.perception)>=(55+(distanceReel*15))){
									objet.setVisible(true);
									
									//jeuPan.messagesPanel.remplissageMessages("view= "+view);
									//jeuPan.messagesPanel.remplissageMessages("jet+int "+(jet+intPj));
									//jeuPan.messagesPanel.remplissageMessages("distance "+distance);
								}
							}
							
						}
						catch(NoSuchElementException exc){};
					}
				}
			}
		}
		
		
	}
	//////////////////////////////////////////////////
	
	
	
	
	//////////////////////////////////////////////////
	public void voyageVertical(boolean sens){
		
		boolean random=false;
		//sauvegarde precedent terrain
		
		//grille[perso.getCooX()][perso.getCooY()].remove(perso);
		
		WaitJDialog wjd=new WaitJDialog();
		
		FileOutputStream out=null;
		ObjectOutputStream flux=null;
		try{
				out=new FileOutputStream("./TERRAINSActuelsPerso/"+perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ+".sav");
				flux=new ObjectOutputStream(out);
				flux.writeObject(grille);
				flux.close();
				flux.flush();
				
			}
		catch(IOException i){i.printStackTrace();}
		finally{
			 try {
			    flux.flush();
			    flux.close();
			    out.close();
			 }
			 catch (IOException e1) {e1.printStackTrace();}
		}
		
		//Minimap
		
		try{
				out=new FileOutputStream("./TERRAINSActuelsPerso/mapGrid"+perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ+".sav");
				flux=new ObjectOutputStream(out);
				flux.writeObject(mapGrid);
				flux.close();
				flux.flush();
				
			}
		catch(IOException i){i.printStackTrace();}
		finally{
			 try {
			    flux.flush();
			    flux.close();
			    out.close();
			 }
			 catch (IOException e1) {e1.printStackTrace();}
		}
		
///////////////////////ZIP *******************************
		zip("./TERRAINSActuelsPerso/",perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ);
		zip("./TERRAINSActuelsPerso/","mapGrid"+perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ);
		
		videur("./TERRAINSActuelsPerso/");
		
		
		
		//up
		if(sens){
			perso.indexTerrainZ--;
		}
		
		//down
		if(!sens){
			perso.indexTerrainZ++;
		}
		
		
		
		//
		//savoir si déjà venu ou non !!////////////////////////////////
		///Chargement de la liste des deja vu////////////////////////
		FileInputStream out4=null;
   		ObjectInputStream flux4=null;
		
		ArrayList dv=new ArrayList();
		
		try{
				out4=new FileInputStream("./TERRAINSActuelsPerso/"+perso.getNom()+"DejaVus.dat");
				flux4=new ObjectInputStream(out4);
				
				dv=(ArrayList)flux4.readObject();
					
		}
		catch(ClassNotFoundException f){f.printStackTrace();}
		catch(IOException i){i.printStackTrace();}
		finally{
			try {
		        flux4.close();
		  		out4.close();
			} 
			catch (IOException e1) {e1.printStackTrace();}
		}
		
		////////////////////////////////////////////////////////////
		//String niveau destination =
		
		//nivDest=new String();
		dejavu=false;
		
		for(int i=0;i<dv.size();i++){
			nivDest=dv.get(i).toString();
			
			if(nivDest.compareTo(perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ+".sav")==0){dejavu=true;
			}
		}
		
		
		//
		
		if(dejavu){
			//chargement SI ANCIEN
			
/////////////////UNZIP********************
			unzip("./TERRAINSActuelsPerso/",perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ);
			
			unzip("./TERRAINSActuelsPerso/","mapGrid"+perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ);
				
			FileInputStream out2=null;
	   		ObjectInputStream flux2=null;
			
			try{
					out2=new FileInputStream("./TERRAINSActuelsPerso/"+perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ+".sav");
					flux2=new ObjectInputStream(out2);
					
					ArrayList[][] grid=(ArrayList[][])flux2.readObject();
					
					grille=grid;
					
					for(int x=0;x<tailleGrille;x++){
						for(int y=0;y<tailleGrille;y++){
							
							if(!grille[x][y].isEmpty()){
						
							
					 			for(int i=0;i<grille[x][y].size();i++){
								
					 					
						 			try{
						 					
						 					
						 				objet = (Entite)grille[x][y].get(i);		
					 				
					 					if(objet.getClass().getName().compareTo("Personnage")==0) {
					 						grille[x][y].remove(objet);
					 						break;
					 					}
											
									}
									catch(NoSuchElementException exc){};
								}
							}
							
							
						}
					}
					
					grille[perso.getCooX()][perso.getCooY()].add(perso);
					
					random=false;//*************
				}
			catch(ClassNotFoundException f){f.printStackTrace();}
			catch(IOException i){i.printStackTrace();}
			finally{
				try {
			        flux2.close();
			  		out2.close();
				} 
				catch (IOException e1) {e1.printStackTrace();}
			}
			
			//Minimap///////////////
			try{
					out2=new FileInputStream("./TERRAINSActuelsPerso/"+"mapGrid"+perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ+".sav");
					flux2=new ObjectInputStream(out2);
					
					int[][] grid=(int[][])flux2.readObject();
					
					mapGrid=grid;
					
					
				}
			catch(ClassNotFoundException f){f.printStackTrace();}
			catch(IOException i){i.printStackTrace();}
			finally{
				try {
			        flux2.close();
			  		out2.close();
				} 
				catch (IOException e1) {e1.printStackTrace();}
			}
			
			
			
		}
		else{
			///chargement SI NOUVEAU
			
			///////////////////////////UNZIP***************
				unzip("./TERRAINSstockMonde/","terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ);
			
			
			
			FileInputStream out2=null;
	   		ObjectInputStream flux2=null;
			
			boolean boolFlux=true;
			
			try{
				

				
					out2=new FileInputStream("./TERRAINSstockMonde/terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ+".sav");
					flux2=new ObjectInputStream(out2);
					
					ArrayList[][] grid=(ArrayList[][])flux2.readObject();
					
					grille=grid;
					
					for(int x=0;x<tailleGrille;x++){
						for(int y=0;y<tailleGrille;y++){
							
							if(!grille[x][y].isEmpty()){
						
							
					 			for(int i=0;i<grille[x][y].size();i++){
								
					 					
						 			try{
						 					
						 				objet = (Entite)grille[x][y].get(i);		
					 				
					 					if(objet.getClass().getName().compareTo("Personnage")==0) {
					 						grille[x][y].remove(objet);
					 						break;
					 					}
											
									}
									catch(NoSuchElementException exc){};
								}
							}
							
							
						}
					}
					
					grille[perso.getCooX()][perso.getCooY()].add(perso);
					
					random=false;//*************
				}
			
			catch(FileNotFoundException fnfe){
				////SI LE TERRAIN CIBLE N'EXISTE PAS LANCER UNE GENERATION ALEATOIRE
				
				//1. creation d'un terrain aleatoire et chargement du terrain
				
				creationTerrainAleatoire(true,sens);//vertical/sens
				boolFlux=false;
				
				//System.out.println("********GENERATION ALEATOIRE V***********");
				
				random=true;//*************
				
			}
			
			catch(ClassNotFoundException f){f.printStackTrace();}
			catch(IOException i){i.printStackTrace();}
			finally{
				if(boolFlux){
				
					try {
				        flux2.close();
				  		out2.close();
					} 
					catch (IOException e1) {e1.printStackTrace();}
				}
			}
			
			
			
			
			
			
			//////////Sauvegarde de la liste des deja vu
			dv.add(perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ+".sav");
			FileOutputStream out3=null;
			ObjectOutputStream flux3=null;
			try{
					out3=new FileOutputStream("./TERRAINSActuelsPerso/"+perso.getNom()+"DejaVus.dat");
					flux3=new ObjectOutputStream(out3);
					flux3.writeObject(dv);
					
					message("****Mise a jour faite****",false);
					message("****Updated****",true);
					
				}
			catch(IOException i){i.printStackTrace();}
			finally{
				 try {
				    flux3.flush();
				    flux3.close();
				    out3.close();
				 }
				 catch (IOException e1) {e1.printStackTrace();}
			}
			//////////////////////////////////////////////
			initialisationMapGrid();	
		}
		
		
		
		
		////si descente et arrivee existante
		//System.out.println("Demande correction");
		if(!random){correctionIllogismesVerticaux(sens);
			//System.out.println("Lancement correction");
		}
		//System.out.println("RANDOM "+random);
		//System.out.println("SENS "+sens);
		
		
		
//////////videur***************		
		videur("./TERRAINSstockMonde/");
		
		
		
		
		wjd.dispose();
		
		jeuPan.mapPanel.mapGrid=mapGrid;
		
		//*************************************
		cat.creationImagesCat(this);
		//*************************************
		
		
		
		//perso.analyseDuSol(perso.getCooX(),perso.getCooY());
		
		
		miseAJourResumeStatsPanel();
		
	
		
		
		undeads();/// marche mal
		
		
		
	}
	
	
	///////////////////////////////////////////////
	//////////////////////////////////////////////
	
	
	/////////METHODE SIMPLE///////////////à améliorer
	public void correctionIllogismesVerticaux(boolean sens){
		//System.out.println("******************CORRECTION VERTICALE******************");
	
		//////////////On casse le mur sur lequel le personnage pourrait éventuellement arriver
		for(int i=0;i<grille[perso.getCooX()][perso.getCooY()].size();i++){	
			try{	
				Entite objet = (Entite)grille[perso.getCooX()][perso.getCooY()].get(i);		
			
				if(objet.getTypeObjet().compareTo("Obstacle")==0) {
					grille[perso.getCooX()][perso.getCooY()].remove(objet);
					
				}		
			}
			catch(NoSuchElementException exc){};
		}
		//////////////on place un escalier montant s'il n'y en a pas dejà un///////////
		boolean presenceEscalier=false;
		for(int i=0;i<grille[perso.getCooX()][perso.getCooY()].size();i++){	
			try{	
				Entite objet = (Entite)grille[perso.getCooX()][perso.getCooY()].get(i);		
			
				if(objet.getTypeObjet().compareTo("Escalier")==0) {
					
					presenceEscalier=true;
				}		
			}
			catch(NoSuchElementException exc){};
		}
		
		if(!presenceEscalier && !sens){
			
			grille[perso.getCooX()][perso.getCooY()].add(new Escalier(false,"standardstairUP","Un escalier vers le haut","Up Stair","Escalier",true,"./images/escaliers/escalierup.gif"));
			//System.out.println("CORRECTION ESCALIER UP ");
			
		}
		
		if(!presenceEscalier && sens){
			boolean unTrou=false;
			
			for(int i=0;i<grille[perso.getCooX()][perso.getCooY()].size();i++){	
				try{	
					Entite objet = (Entite)grille[perso.getCooX()][perso.getCooY()].get(i);		
				
					if(objet.getModele().compareTo("trou")==0) {
						
						unTrou=true;
					}		
				}
				catch(NoSuchElementException exc){};
			}
			
			//a condition qu'il n'y ait pas de trou
			
			if(!unTrou){
				grille[perso.getCooX()][perso.getCooY()].add(new Escalier(false,"standardstairDOWN","Un escalier vers le bas","Down Stair","Escalier",true,"./images/escaliers/escalierdown.gif"));
				//System.out.println("CORRECTION ESCALIER DOWN ");
		
			}
	
	
		}

	}
	
	
	
	
	//////////////////////////////////////////////////
	
	
	
	//Teleportation par utilisation de téléporteurs fixes ou sorts
	public void teleportation(String [] coordTab){
		
		WaitJDialog wjd=new WaitJDialog();
		
		int wX=Integer.parseInt(coordTab[1]);
		int wY=Integer.parseInt(coordTab[3]);
		int wZ=Integer.parseInt(coordTab[5]);
		int lX=Integer.parseInt(coordTab[6]);
		int lY=Integer.parseInt(coordTab[7]);
		
		if(coordTab[0].compareTo("-")==0){
			wX=-wX;
		}
		
		if(coordTab[2].compareTo("-")==0){
			wY=-wY;
		}
		
		if(coordTab[4].compareTo("-")==0){
			wZ=-wZ;
		}
		
		//System.out.println(wX+" "+wY+" "+wZ+" "+lX+" "+lY);
		
		
		boolean sens=false;
		
		if(perso.indexTerrainZ>wZ){sens=true;
			
		}
		
		
		//sauvegarde precedent terrain
		grille[perso.getCooX()][perso.getCooY()].remove(perso);
		FileOutputStream out=null;
		ObjectOutputStream flux=null;
		try{
				out=new FileOutputStream("./TERRAINSActuelsPerso/"+perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ+".sav");
				flux=new ObjectOutputStream(out);
				flux.writeObject(grille);
				flux.close();
				flux.flush();
				
			}
		catch(IOException i){i.printStackTrace();}
		finally{
			 try {
			    flux.flush();
			    flux.close();
			    out.close();
			 }
			 catch (IOException e1) {e1.printStackTrace();}
		}
		
		
		///MINIMAP
		try{
				out=new FileOutputStream("./TERRAINSActuelsPerso/mapGrid"+perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ+".sav");
				flux=new ObjectOutputStream(out);
				flux.writeObject(mapGrid);
				flux.close();
				flux.flush();
				
			}
		catch(IOException i){i.printStackTrace();}
		finally{
			 try {
			    flux.flush();
			    flux.close();
			    out.close();
			 }
			 catch (IOException e1) {e1.printStackTrace();}
		}
		
		

//////////ZIP*****************
		zip("./TERRAINSActuelsPerso/",perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ);
		zip("./TERRAINSActuelsPerso/","mapGrid"+perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ);
		
		
		
		perso.setCooX(lX);
		perso.setCooY(lY);
		
		perso.indexTerrainX=wX;
		perso.indexTerrainY=wY;
		perso.indexTerrainZ=wZ;
		
		
		////////////////////
		////////////////////
		////////////////////
		/////////////////////
		//
		//savoir si déjà venu ou non !!////////////////////////////////
		///Chargement de la liste des deja vu////////////////////////
		FileInputStream out4=null;
   		ObjectInputStream flux4=null;
		
		ArrayList dv=new ArrayList();
		
		try{
				out4=new FileInputStream("./TERRAINSActuelsPerso/"+perso.getNom()+"DejaVus.dat");
				flux4=new ObjectInputStream(out4);
				
				dv=(ArrayList)flux4.readObject();
					
		}
		catch(ClassNotFoundException f){f.printStackTrace();}
		catch(IOException i){i.printStackTrace();}
		finally{
			try {
		        flux4.close();
		  		out4.close();
			} 
			catch (IOException e1) {e1.printStackTrace();}
		}
		
		////////////////////////////////////////////////////////////
		//String niveau destination =
		
		
		//String nivDest=new String();
		
		dejavu=false;
		
		for(int i=0;i<dv.size();i++){
			nivDest=dv.get(i).toString();
			
			if(nivDest.compareTo(perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ+".sav")==0){dejavu=true;
			}
		}
		
		
		//
		
		if(dejavu){
			//chargement SI ANCIEN	
/////////////UNZIP******************
			unzip("./TERRAINSActuelsPerso/",perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ);
			unzip("./TERRAINSActuelsPerso/","mapGrid"+perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ);
			
			
			FileInputStream out2=null;
	   		ObjectInputStream flux2=null;
			
			try{
					out2=new FileInputStream("./TERRAINSActuelsPerso/"+perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ+".sav");
					flux2=new ObjectInputStream(out2);
					
					ArrayList[][] grid=(ArrayList[][])flux2.readObject();
					
					grille=grid;
					
					for(int x=0;x<tailleGrille;x++){
						for(int y=0;y<tailleGrille;y++){
							
							if(!grille[x][y].isEmpty()){
						
							
					 			for(int i=0;i<grille[x][y].size();i++){
								
					 					
						 			try{
						 					
						 					
						 				objet = (Entite)grille[x][y].get(i);		
					 				
													
										strType = (objet.getClass().getName());
					 				
					 					if(strType.compareTo("Personnage")==0) {
					 						grille[x][y].remove(objet);
					 						break;
					 					}
											
									}
									catch(NoSuchElementException exc){};
								}
							}
							
							
						}
					}
					
					grille[perso.getCooX()][perso.getCooY()].add(perso);
					
				}
			catch(ClassNotFoundException f){f.printStackTrace();}
			catch(IOException i){i.printStackTrace();}
			finally{
				try {
			        flux2.close();
			  		out2.close();
				} 
				catch (IOException e1) {e1.printStackTrace();}
			}
			
			////MINIMAP//////////////////////
			try{
					out2=new FileInputStream("./TERRAINSActuelsPerso/mapGrid"+perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ+".sav");
					flux2=new ObjectInputStream(out2);
					
					int[][] grid=(int[][])flux2.readObject();
					
					mapGrid=grid;
					
				}
			catch(ClassNotFoundException f){f.printStackTrace();}
			catch(IOException i){i.printStackTrace();}
			finally{
				try {
			        flux2.close();
			  		out2.close();
				} 
				catch (IOException e1) {e1.printStackTrace();}
			}
			
			
			
			
		}
		else{
/////////////UNZIP******************			
			unzip("./TERRAINSstockMonde/","terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ);
			///chargement SI NOUVEAU
			
			FileInputStream out2=null;
	   		ObjectInputStream flux2=null;
			boolean boolFlux=true;
			
			try{
					out2=new FileInputStream("./TERRAINSstockMonde/terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ+".sav");
					flux2=new ObjectInputStream(out2);
					
					ArrayList[][] grid=(ArrayList[][])flux2.readObject();
					
					grille=grid;
					
					for(int x=0;x<tailleGrille;x++){
						for(int y=0;y<tailleGrille;y++){
							
							if(!grille[x][y].isEmpty()){
						
							
					 			for(int i=0;i<grille[x][y].size();i++){
								
					 					
						 			try{
						 					
						 					
						 				objet = (Entite)grille[x][y].get(i);		
					 				
										//String strType ;			
										strType = (objet.getClass().getName());
					 				
					 					if(strType.compareTo("Personnage")==0) {
					 						grille[x][y].remove(objet);
					 						break;
					 					}
											
									}
									catch(NoSuchElementException exc){};
								}
							}
							
							
						}
					}
					
					grille[perso.getCooX()][perso.getCooY()].add(perso);
					
				}
			catch(FileNotFoundException fnfe){
				////SI LE TERRAIN CIBLE N'EXISTE PAS LANCER UNE GENERATION ALEATOIRE
				
				//1. creation d'un terrain aleatoire et chargement du terrain
				
				
				//si arrivée en surface
				if(wZ<=0){
					
					
				creationTerrainAleatoire(false,false);
				//System.out.println("********GENERATION ALEATOIRE H***********");	
					
					
				}	
				
				else{// arrivée sous terre
				
				
				creationTerrainAleatoire(true,sens);
				//System.out.println("********GENERATION ALEATOIRE V***********");
				
				
				
				}
				
				
				boolFlux=false;
				
				
				
			}
			
			catch(ClassNotFoundException f){f.printStackTrace();}
			catch(IOException i){i.printStackTrace();}
			
			
			
			finally{
				if(boolFlux){
				
					try {
				        flux2.close();
				  		out2.close();
					} 
					catch (IOException e1) {e1.printStackTrace();}
				}
			}
			
			
			
			//////////Sauvegarde de la liste des deja vu
			dv.add(perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ+".sav");
			FileOutputStream out3=null;
			ObjectOutputStream flux3=null;
			try{
					out3=new FileOutputStream("./TERRAINSActuelsPerso/"+perso.getNom()+"DejaVus.dat");
					flux3=new ObjectOutputStream(out3);
					flux3.writeObject(dv);
					
					message("****Mise a jour faite****",false);
					message("****Updated****",true);
					
				}
			catch(IOException i){i.printStackTrace();}
			finally{
				 try {
				    flux3.flush();
				    flux3.close();
				    out3.close();
				 }
				 catch (IOException e1) {e1.printStackTrace();}
			}
			//////////////////////////////////////////////
			initialisationMapGrid();	
		}
		
		
		
		
		
		////////////////////
		////////////////////
		////////////////////
		
		
//////////videur***************		
		videur("./TERRAINSstockMonde/");
		
		
		
		//test
		//grille[perso.getCooX()][perso.getCooY()].add(perso);
		
		wjd.dispose();
		jeuPan.mapPanel.mapGrid=mapGrid;
		//jeuPan.terrainPanel.repaint();
		//jeuPan.repaint();
		
		//*************************************
		cat.creationImagesCat(this);
		//*************************************
		
		
		
		
		miseAJourResumeStatsPanel();
		
		//miseAJourNomEquipementLANG(jeuPan.lang);
		
		//initialisationMapGrid();
		testSiPersoDansMurOuVide();
		
	}
	
	
	
	//////////////////////////////////////////////////
	
	
	
	///////////////////////////////////////////////////
	///////////////////////////////////////////////////
	public void voyageHorizontal(int direction){
		
		WaitJDialog wjd=new WaitJDialog();
		
		
		//sauvegarde precedent terrain
		grille[perso.getCooX()][perso.getCooY()].remove(perso);
		FileOutputStream out=null;
		ObjectOutputStream flux=null;
		try{
				out=new FileOutputStream("./TERRAINSActuelsPerso/"+perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ+".sav");
				flux=new ObjectOutputStream(out);
				flux.writeObject(grille);
				flux.close();
				flux.flush();
				
			}
		catch(IOException i){i.printStackTrace();}
		finally{
			 try {
			    flux.flush();
			    flux.close();
			    out.close();
			 }
			 catch (IOException e1) {e1.printStackTrace();}
		}
		
		/////MINIMAP////////
		try{
				out=new FileOutputStream("./TERRAINSActuelsPerso/mapGrid"+perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ+".sav");
				flux=new ObjectOutputStream(out);
				flux.writeObject(mapGrid);
				flux.close();
				flux.flush();
				
			}
		catch(IOException i){i.printStackTrace();}
		finally{
			 try {
			    flux.flush();
			    flux.close();
			    out.close();
			 }
			 catch (IOException e1) {e1.printStackTrace();}
		}
		
		
		
		
/////////ZIP*******************
		zip("./TERRAINSActuelsPerso/",perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ);
		zip("./TERRAINSActuelsPerso/","mapGrid"+perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ);
		
		
		videur("./TERRAINSActuelsPerso/");
		
		oldInsertPt=new Point(perso.getCooX(),perso.getCooY());
		
		
		//changement coordonnées perso
		if(direction==1){//NORD
			perso.indexTerrainY--;
			perso.setCooY(tailleGrille-11);
		}
		
		if(direction==2){//EST
			perso.indexTerrainX++;
			perso.setCooX(10);
		}
		
		if(direction==3){//SUD
			perso.indexTerrainY++;
			perso.setCooY(10);
		}
		
		if(direction==4){//OUEST
			perso.indexTerrainX--;
			perso.setCooX(tailleGrille-11);
		}
		
		
		
		
		//
		//savoir si déjà venu ou non !!////////////////////////////////
		///Chargement de la liste des deja vu////////////////////////
		FileInputStream out4=null;
   		ObjectInputStream flux4=null;
		
		ArrayList dv=new ArrayList();
		
		try{
				out4=new FileInputStream("./TERRAINSActuelsPerso/"+perso.getNom()+"DejaVus.dat");
				flux4=new ObjectInputStream(out4);
				
				dv=(ArrayList)flux4.readObject();
					
		}
		catch(ClassNotFoundException f){f.printStackTrace();}
		catch(IOException i){i.printStackTrace();}
		finally{
			try {
		        flux4.close();
		  		out4.close();
			} 
			catch (IOException e1) {e1.printStackTrace();}
		}
		
		////////////////////////////////////////////////////////////
		//String niveau destination =
		
		
		//String nivDest=new String();
		
		dejavu=false;
		
		for(int i=0;i<dv.size();i++){
			nivDest=dv.get(i).toString();
			
			if(nivDest.compareTo(perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ+".sav")==0){dejavu=true;
			}
		}
		
		
		//
		
		if(dejavu){
			//chargement SI ANCIEN	
			
/////////////UNZIP*****************			
			unzip("./TERRAINSActuelsPerso/",perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ);
			unzip("./TERRAINSActuelsPerso/","mapGrid"+perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ);
			
			
			
			FileInputStream out2=null;
	   		ObjectInputStream flux2=null;
			
			try{
					out2=new FileInputStream("./TERRAINSActuelsPerso/"+perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ+".sav");
					flux2=new ObjectInputStream(out2);
					
					ArrayList[][] grid=(ArrayList[][])flux2.readObject();
					
					grille=grid;
					
					for(int x=0;x<tailleGrille;x++){
						for(int y=0;y<tailleGrille;y++){
							
							if(!grille[x][y].isEmpty()){
						
							
					 			for(int i=0;i<grille[x][y].size();i++){
								
					 					
						 			try{
						 					
						 					
						 				objet = (Entite)grille[x][y].get(i);		
					 				
										//String strType ;			
										strType = (objet.getClass().getName());
					 				
					 					if(strType.compareTo("Personnage")==0) {
					 						grille[x][y].remove(objet);
					 						break;
					 					}
											
									}
									catch(NoSuchElementException exc){};
								}
							}
							
							
						}
					}
					
					grille[perso.getCooX()][perso.getCooY()].add(perso);
					
				}
			catch(ClassNotFoundException f){f.printStackTrace();}
			catch(IOException i){i.printStackTrace();}
			finally{
				try {
			        flux2.close();
			  		out2.close();
				} 
				catch (IOException e1) {e1.printStackTrace();}
			}
			
			
			///MINIMAP
			try{
					out2=new FileInputStream("./TERRAINSActuelsPerso/mapGrid"+perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ+".sav");
					flux2=new ObjectInputStream(out2);
					
					int[][] grid=(int[][])flux2.readObject();
					
					mapGrid=grid;
					
					
				}
			catch(ClassNotFoundException f){f.printStackTrace();}
			catch(IOException i){i.printStackTrace();}
			finally{
				try {
			        flux2.close();
			  		out2.close();
				} 
				catch (IOException e1) {e1.printStackTrace();}
			}
			
		}
		else{
			///chargement SI NOUVEAU
			
/////////////UNZIP*******************************			
			unzip("./TERRAINSstockMonde/","terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ);
			
			FileInputStream out2=null;
	   		ObjectInputStream flux2=null;
			boolean boolFlux=true;
			
			try{
					out2=new FileInputStream("./TERRAINSstockMonde/terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ+".sav");
					flux2=new ObjectInputStream(out2);
					
					ArrayList[][] grid=(ArrayList[][])flux2.readObject();
					
					grille=grid;
					
					for(int x=0;x<tailleGrille;x++){
						for(int y=0;y<tailleGrille;y++){
							
							if(!grille[x][y].isEmpty()){
						
							
					 			for(int i=0;i<grille[x][y].size();i++){
								
					 					
						 			try{
						 					
						 					
						 				objet = (Entite)grille[x][y].get(i);		
					 				
										//String strType ;			
										strType = (objet.getClass().getName());
					 				
					 					if(strType.compareTo("Personnage")==0) {
					 						grille[x][y].remove(objet);
					 						break;
					 					}
											
									}
									catch(NoSuchElementException exc){};
								}
							}
							
							
						}
					}
					
					grille[perso.getCooX()][perso.getCooY()].add(perso);
					
				}
			catch(FileNotFoundException fnfe){
				////SI LE TERRAIN CIBLE N'EXISTE PAS LANCER UNE GENERATION ALEATOIRE
				
				//1. creation d'un terrain aleatoire et chargement du terrain
				
				creationTerrainAleatoire(false,false);
				boolFlux=false;
				
				//System.out.println("********GENERATION ALEATOIRE H***********");
				
			}
			
			catch(ClassNotFoundException f){f.printStackTrace();}
			catch(IOException i){i.printStackTrace();}
			
			
			
			finally{
				if(boolFlux){
				
					try {
				        flux2.close();
				  		out2.close();
					} 
					catch (IOException e1) {e1.printStackTrace();}
				}
			}
			
			
			
			//////////Sauvegarde de la liste des deja vu
			dv.add(perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ+".sav");
			FileOutputStream out3=null;
			ObjectOutputStream flux3=null;
			try{
					out3=new FileOutputStream("./TERRAINSActuelsPerso/"+perso.getNom()+"DejaVus.dat");
					flux3=new ObjectOutputStream(out3);
					flux3.writeObject(dv);
					
					message("****Mise a jour faite****",false);
					message("****Updated****",true);
					
				}
			catch(IOException i){i.printStackTrace();}
			finally{
				 try {
				    flux3.flush();
				    flux3.close();
				    out3.close();
				 }
				 catch (IOException e1) {e1.printStackTrace();}
			}
			//////////////////////////////////////////////
			initialisationMapGrid();	
		}
		
		
		
//////////videur***************		
		videur("./TERRAINSstockMonde/");
		
		
		
		
		
		
		wjd.dispose();
		jeuPan.mapPanel.mapGrid=mapGrid;
		//tourMonde();
		//jeuPan.terrainPanel.repaint();
		
		
		//*************************************
		cat.creationImagesCat(this);
		//*************************************
		
		
		
		//perso.analyseDuSol(perso.getCooX(),perso.getCooY());
		
		
		miseAJourResumeStatsPanel();
		
		
		
		
		undeads();//marche mal
		
		
		
	}
	
	
	
	///////////////QUAND UN TERRAIN N'EXISTE PAS//////////////////
	///////////////////////////////////////////////////
	public void creationTerrainAleatoire(boolean vertical,boolean sens){

		grille=new ArrayList[tailleGrille][tailleGrille];
		
//TOUS		
		////////////////CREATION DE LA BORDURE///////////////////////////////
		Vide vide=new Vide();
		for(int x=0;x<tailleGrille;x++){
			for(int y=0;y<tailleGrille;y++){
				grille[x][y]=new ArrayList();	
				grille[x][y].add(vide);
			}
		}
		
				
		
		//CIEL
		if(perso.indexTerrainZ<0){
			new GenAleaCiel(this,cat, oldInsertPt, tailleGrille,vertical,sens,grille,perso);
		}
		
		
		//DONJON
		if(perso.indexTerrainZ>0){
			new GenAleaDonjon(this,cat, oldInsertPt, tailleGrille,vertical,sens,grille,perso);
		}
		
		//EXTERIEUR
		if(perso.indexTerrainZ==0){
			new GenAleaExterieur(this,cat, oldInsertPt, tailleGrille,vertical,sens,grille,perso);
		}
		
		
		

		//////////////////////////////////////////////////////////////////////////////////
		//////////////////////////////////////////////////////////////////////////////////
		//////////////////////////////////////////////////////////////////////////////////
		
		/////SAUVEGARDE DANS ACTUEL
		FileOutputStream out=null;
		ObjectOutputStream flux=null;
		try{
				out=new FileOutputStream("./TERRAINSActuelsPerso/"+perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ+".sav");
				flux=new ObjectOutputStream(out);
				flux.writeObject(grille);
				flux.close();
				flux.flush();
				
			}
		catch(IOException i){i.printStackTrace();}
		finally{
			 try {
			    flux.flush();
			    flux.close();
			    out.close();
			 }
			 catch (IOException e1) {e1.printStackTrace();}
		}
		
		//////CHARGEMENT
		
			FileInputStream out2=null;
	   		ObjectInputStream flux2=null;
			
			try{
					out2=new FileInputStream("./TERRAINSActuelsPerso/"+perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ+".sav");
					flux2=new ObjectInputStream(out2);
					ArrayList[][] grid=(ArrayList[][])flux2.readObject();
					grille=grid;
					
					for(int x=0;x<tailleGrille;x++){
						for(int y=0;y<tailleGrille;y++){
							if(!grille[x][y].isEmpty()){
					 			for(int i=0;i<grille[x][y].size();i++){	
						 			try{	
						 				objet = (Entite)grille[x][y].get(i);		
					 				
										//String strType ;			
										strType = (objet.getClass().getName());
					 				
					 					if(strType.compareTo("Personnage")==0) {
					 						grille[x][y].remove(objet);
					 						break;
					 					}		
									}
									catch(NoSuchElementException exc){};
								}
							}	
						}
					}
					
					grille[perso.getCooX()][perso.getCooY()].add(perso);
					//System.out.println("PERSO PLACE EN "+perso.getCooX()+" "+perso.getCooY());
					
				}
			
			catch(ClassNotFoundException f){f.printStackTrace();}
			catch(IOException i){i.printStackTrace();}
			finally{
				try {
			        flux2.close();
			  		out2.close();
				} 
				catch (IOException e1) {e1.printStackTrace();}
			}
			
///////////ZIP************************
			zip("./TERRAINSActuelsPerso/",perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ);
			
			
		//miseAJourNomEquipementLANG(jeuPan.lang);
	}
	
	///////////////////////////////////////////////////
	///////////////////////////////////////////////////
	
	
	
	///////////////////////////////////////////////////
	///////////////////////////////////////////////////
	public void copyFile(File in, File out) throws Exception {
	    FileInputStream fis  = new FileInputStream(in);
	    FileOutputStream fos = new FileOutputStream(out);
	    byte[] buf = new byte[1024];
	    int i = 0;
	    while((i=fis.read(buf))!=-1) {
	      fos.write(buf, 0, i);
	      }
	    fis.close();
	    fos.close();
   	}
	
	
	///////////////////////////////////////////////////
	///////////////////////////////////////////////////
	
	///////////////////////////////////////////////////
	///////////////////////////////////////////////////
	public void saveGame(){
		
		if(perso.getNom().compareTo("")!=0){
			
			WaitJDialog wjd=new WaitJDialog();
			
			////FAIRE UN ENREGISTREMENT DU TERRAIN actuel DANS ACTUEL////
			FileOutputStream out6=null;
			ObjectOutputStream flux6=null;
			try{	//"./TERRAINSActuelsPerso/"+perso.getNom()+"terrainx0y0z0.sav"
					out6=new FileOutputStream("./TERRAINSActuelsPerso/"+perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ+".sav");
					flux6=new ObjectOutputStream(out6);
					flux6.writeObject(grille);
					
				}
			catch(IOException i){i.printStackTrace();}
			finally{
				 try {
				    flux6.flush();
				    flux6.close();
				    out6.close();
				 }
				 catch (IOException e1) {e1.printStackTrace();}
			}
			
			//////MINIMAP
			try{	//"./TERRAINSActuelsPerso/"+perso.getNom()+"terrainx0y0z0.sav"
					out6=new FileOutputStream("./TERRAINSActuelsPerso/mapGrid"+perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ+".sav");
					flux6=new ObjectOutputStream(out6);
					flux6.writeObject(mapGrid);
					
				}
			catch(IOException i){i.printStackTrace();}
			finally{
				 try {
				    flux6.flush();
				    flux6.close();
				    out6.close();
				 }
				 catch (IOException e1) {e1.printStackTrace();}
			}
			
			
			////////****************************
			////////****************************
			////////****************************
/////////////ZIP**********************************
			zip("./TERRAINSActuelsPerso/",perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ);
			zip("./TERRAINSActuelsPerso/","mapGrid"+perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ);
			
			
			videur("./TERRAINSActuelsPerso/");
			
			
			
			////////*********//////
			////ON COPIE TOUS LES FICHIERS CONTENUS DANS ACTUELS VERS LE DOSSIER SAVE
			
			
			//deplaceur("zip","./TERRAINSActuelsPerso/","./TERRAINSSavesPersos/");
			//copieur("dat","./TERRAINSActuelsPerso/","./TERRAINSSavesPersos/");
			//copieur("zip","./TERRAINSActuelsPerso/","./TERRAINSSavesPersos/");
			
			//try{
			//	copyDirectory(new File("./TERRAINSActuelsPerso/*.*"),new File("./TERRAINSSavesPersos/*.*"));
			//}
			//catch(IOException ii){
			//	
			//}
			
			
			//déplacement
			//File source = new File("mon fichier");
			//File destination = new File("mon fichier renommé");
			//source.renameTo(destination);
			
			File repertoire=new File("./TERRAINSActuelsPerso/");
			File[] list = repertoire.listFiles();
			for(int i=0;i<list.length;i++){
				
				
				//System.out.println("Copie Save: "+ list[i].getName());
				
				try{
					//new JCopy().
					copyFile(new File("./TERRAINSActuelsPerso/"+list[i].getName()),new File("./TERRAINSSavesPersos/"+list[i].getName()));
				}
				catch(Exception xc){xc.printStackTrace();}
			}
			
			
			
			
			
			
			////////****************************
			////////****************************
			////////****************************
			////////****************************
			
			
			// sauvegarde d'un string avec nomfichier
			
			n=perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ;
			
			//String n=new String(perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ);
			
			
			FileOutputStream out3=null;
			ObjectOutputStream flux3=null;
			try{
					out3=new FileOutputStream("./TERRAINSSavesPersos/"+perso.getNom()+".dat");
					flux3=new ObjectOutputStream(out3);
					flux3.writeObject(n);
					
					
					
				}
			catch(IOException i){i.printStackTrace();}
			finally{
				 try {
				    flux3.flush();
				    flux3.close();
				    out3.close();
				 }
				 catch (IOException e1) {e1.printStackTrace();}
			}
			
			
			
			// sauvegarde de la nuit...
			
			if(nuit){nightStr="nuit";}
			else{nightStr="jour";}
			
			FileOutputStream out7=null;
			ObjectOutputStream flux7=null;
			try{
					out7=new FileOutputStream("./TERRAINSSavesPersos/"+perso.getNom()+"nuit.dat");
					flux7=new ObjectOutputStream(out7);
					flux7.writeObject(nightStr);
					
					//jeuPan.messagesPanel.remplissageMessages("****Night Saved****");
					
				}
			catch(IOException i){i.printStackTrace();}
			finally{
				 try {
				    flux7.flush();
				    flux7.close();
				    out7.close();
				 }
				 catch (IOException e1) {e1.printStackTrace();}
			}
			
			
			
			
			message("****Game Saved****",true);
			message("****Partie sauvee****",false);
			
			wjd.dispose();
			
			
				
		}
		else{System.out.println("impossible car pas de partie en cours");
		}
		
		
		/////////////ZIP*****************
		//zip("./TERRAINSActuelsPerso/",perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ);
		//zip("./TERRAINSSavesPersos/",perso.getNom()+"terrain"+"x"+perso.indexTerrainX+"y"+perso.indexTerrainY+"z"+perso.indexTerrainZ);
		
		//videur("./TERRAINSActuelsPerso/");
		//videur("./TERRAINSSavesPersos/");
		
		
			
	}
	
	
	
	
	///////////////////////////////////////////////////
	///////////////////////////////////////////////////
	
	public void loadGame(String nomPJ){
		
		boolean fileExist=true;
		
		
		WaitJDialog wjd=new WaitJDialog();
		
		//// load string
		//String n=new String();
		
		FileInputStream out=null;
   		ObjectInputStream flux=null;
		
		try{
				out=new FileInputStream("./TERRAINSSavesPersos/"+nomPJ+".dat");
				flux=new ObjectInputStream(out);
				
				n=(String)flux.readObject();
					
		}
		catch(FileNotFoundException fnf){fileExist=false;
			message("Pas de sauvegarde a ce nom !",false);
			message("There is no save file named like this !",true);
			wjd.dispose();
			
		}
		
		catch(ClassNotFoundException f){f.printStackTrace();}
		catch(IOException i){i.printStackTrace();}
		finally{
			if(fileExist){
			
				try {
			        flux.close();
			  		out.close();
				} 
				catch (IOException e1) {e1.printStackTrace();}
			}
		}
		
		
		
		
		if(fileExist){	
			
			////SUPPRESSION DU CONTENU DU DOSSIER TERRAINSActuelsPerso
			File repertoire=new File("./TERRAINSActuelsPerso/");
			
			File[] list = repertoire.listFiles();
			
			for(int i=0;i<list.length;i++){
				list[i].delete();
			}
			
			
			
			
			////////////////////////////////////////////////////////////
			
			
			
			///ON COPIE DANS ACTUEL TOUS LES FICHIERS DU DOSSIER SAVE '''CONTENANT LE NOM DU PERSO''' DANS LEURS NOMS
			
				File repertoireSource=new File("./TERRAINSSavesPersos/");
				
				File[] list2 = repertoireSource.listFiles();
				
				
				
				
				
				
				dest="./TERRAINSActuelsPerso/";
				
				
				
				
				
				for(int u=0;u<list2.length;u++){
					
					if(list2[u].getName().startsWith(nomPJ) || list2[u].getName().startsWith("mapGrid"+nomPJ)){
						
							
						//System.out.println("A COPIER "+list2[u].getName());
							
						try{
							//new JCopy().
							copyFile(new File("./TERRAINSSavesPersos/"+list2[u].getName()),new File("./TERRAINSActuelsPerso/"+list2[u].getName()));
							
						}
						catch(Exception xc){xc.printStackTrace();}
							
					}	
					
				}
			
			
			
			
			
			
			
			
			
			////ON CHARGE LE TERRAIN OU SE TROUVE LE PERSONNAGE


/////UNZIP************


//System.out.println("N: "+n);		
unzip("./TERRAINSActuelsPerso/",n);
unzip("./TERRAINSActuelsPerso/","mapGrid"+n);			
			
			
			/////load game
			FileInputStream out2=null;
	   		ObjectInputStream flux2=null;
			
			try{
					out2=new FileInputStream("./TERRAINSActuelsPerso/"+n+".sav");
					flux2=new ObjectInputStream(out2);
					
					ArrayList[][] grid=(ArrayList[][])flux2.readObject();
					
					grille=new ArrayList[tailleGrille][tailleGrille];
					grille=grid;
					
					
				
					
					for(int x=0;x<tailleGrille;x++){
						for(int y=0;y<tailleGrille;y++){
							
							if(!grille[x][y].isEmpty()){
						
							
					 			for(int i=0;i<grille[x][y].size();i++){
								
					 					
						 			try{
						 					
						 					
						 				objet = (Entite)grille[x][y].get(i);		
					 				
										//String strType ;			
										strType = (objet.getClass().getName());
					 				
					 					if(strType.compareTo("Personnage")==0) {
					 						//jeuPan.messagesPanel.remplissageMessages("****PJ FOUND****");
					 						perso=(Personnage)objet;
					 						perso.monde=this;
					 						
					 						//Ancienne méthode
					 						//jeuPan.equipementpanel.updateEquipementList(this,perso.equipementVect);
					 						
					 						//System.out.println("nom PERSO "+perso.getNom()+"cooX"+perso.getCooX()+"cooY"+perso.getCooY());
					
					 						break;
					 					}
										
										
										
									}
									catch(NoSuchElementException exc){};
								}
							}
							
							
						}
					}
					
					
					
						
			}
			catch(ClassNotFoundException f){f.printStackTrace();}
			catch(IOException i){i.printStackTrace();}
			finally{
				try {
			        flux2.close();
			  		out2.close();
				} 
				catch (IOException e1) {e1.printStackTrace();}
			}
			
			///////MINIMAP////////////////////
			try{
					out2=new FileInputStream("./TERRAINSActuelsPerso/mapGrid"+n+".sav");
					flux2=new ObjectInputStream(out2);
					
					int[][] grid=(int[][])flux2.readObject();
					
					mapGrid=new int[tailleGrille][tailleGrille];
					mapGrid=grid;
							
			}
			catch(ClassNotFoundException f){f.printStackTrace();}
			catch(IOException i){i.printStackTrace();}
			finally{
				try {
			        flux2.close();
			  		out2.close();
				} 
				catch (IOException e1) {e1.printStackTrace();}
			}
			
			
			
			
			/*
			//On cherche à savoir s'il fait jour ou nuit dans le terrain chargé
			//puis on modifie nuit en conséquence
			for(int x=0;x<tailleGrille;x++){
				for(int y=0;y<tailleGrille;y++){
					if(!grille[x][y].isEmpty()){
			 			for(int i=0;i<grille[x][y].size();i++){	
				 			try{	
				 				Entite objet = (Entite)grille[x][y].get(i);		
								String strType ;			
								strType = (objet.getClass().getName());
								if(strType.compareTo("Ombrage")==0 && objet.getVisible()){
									nuit=true;
									break;
								}
							}
							catch(NoSuchElementException exc){};
						}
					}
				}
			}
			*/
			
			//On cherche à savoir s'il fait jour ou nuit dans le terrain chargé
			//puis on modifie nuit en conséquence
			
		
			FileInputStream outn=null;
	   		ObjectInputStream fluxn=null;
			
			try{
					outn=new FileInputStream("./TERRAINSSavesPersos/"+nomPJ+"nuit.dat");
					fluxn=new ObjectInputStream(outn);
					
					night=(String)fluxn.readObject();
						
			}
			catch(FileNotFoundException fnf){fileExist=false;
				message("Pas de fichier nuit a ce nom !",false);
				message("There is no night file named like this !",true);
			}
			catch(ClassNotFoundException f){f.printStackTrace();}
			catch(IOException i){i.printStackTrace();}
			finally{
				if(fileExist){
				
					try {
				        fluxn.close();
				  		outn.close();
					} 
					catch (IOException e1) {e1.printStackTrace();}
				}
			}
			
			if(night.compareTo("nuit")==0){ nuit=true;}
			else{nuit=false;
			}
			
			
			
			message("****Partie chargee****",false);
			message("****Game Loaded****",true);
			
			
			
			
			wjd.dispose();
			
			jeuPan.mapPanel.mapGrid=mapGrid;
			
			
			//*************************************
			cat.creationImagesCat(this);
			//*************************************
		
			
			
			
			//jeuPan.terrainPanel.repaint();
			//jeuPan.repaint();
			
			miseAJourResumeStatsPanel();
		}
		
		
		//miseAJourNomEquipementLANG(jeuPan.lang);
		//perso.miseAJourNomEquipementLANG(jeuPan.lang);
		
		//initialisationMapGrid();
		jeuPan.leJeu.jeuInit2=true;	
		
		
		jeuPan.mapPanel.repaint();
		
	}
	
	
	
	
	
	
	
	
	/*
	/////////////////////////////////////// Pour l'instant ne sert pas
	///////////////////////////////////
	
	public boolean cibleEstDansLOSPerso(int px,int py,int cx, int cy){
		
	
		boolean reponse=true;
		
		
		Entite ici=new Entite();
		Point persoPt=new Point(px,py);
		Point ciblePt=new Point(cx,cy);	
		Point studyPt=new Point(px,py);
		
		
		
		Point[] tabloPt=bresenham_line(persoPt,ciblePt);
		
		
		for(int b=0;b<tabloPt.length;b++){	
			
			
			studyPt=tabloPt[b];
			
			
			//parcours dans studyPt
			for(int i=0;i<grille[(int)studyPt.getX()][(int)studyPt.getY()].size();i++){
					
	 			try{
	 					
	 				ici = (Entite)grille[(int)studyPt.getX()][(int)studyPt.getY()].get(i);
 					
 					
					if((ici.getClass().getName().compareTo("Gate")==0 || ici.getTypeObjet().compareTo("Obstacle")==0) && !ici.getCasse() && !ici.getOuvert()){
						
						reponse=false;
						
						if((int)studyPt.getX()==cx && (int)studyPt.getY()==cy){
	 						reponse=true;
	 					}
						
						
					}
					
					
				}
				catch(NoSuchElementException exc){};
			}
			
			
		}
		
		
		return reponse;
	}
	
	///////////////////////////////////
	*/
	
	
	
	
	
	
	
	public final static Point[] bresenham_line(Point pt1, Point pt2) {
        return bresenham_line(pt1.x, pt1.y, pt2.x, pt2.y);
    }

   
    public final static Point[] bresenham_line(int x1, int y1, int x2, int y2) {
        
        int i;
        int d, x, y, ax, ay, sx, sy, dx, dy, t;

        dx = x2 - x1;
        ax = Math.abs(dx) << 1;
        sx = sign(dx);
        dy = y2 - y1;
        ay = Math.abs(dy) << 1;
        sy = sign(dy);

        t = Math.max(Math.abs(dx), Math.abs(dy)) + 1;
        Point[] ret_val = new Point[t];

        x = x1;
        y = y1;
        if (ax > ay) { /* x dominant */
            d = ay - (ax >> 1);
            for (i = 0;;) {
                ret_val[i++] = new Point(x, y);
                //ret_val[i].x = x; ret_val[i++].y = y;
                if (x == x2)
                    return ret_val;
                if (d >= 0) {
                    y += sy;
                    d -= ax;
                }
                x += sx;
                d += ay;
            }
        } else { /* y dominant */
            d = ax - (ay >> 1);
            for (i = 0;;) {
                ret_val[i++] = new Point(x, y);
                //ret_val[i].x = x; ret_val[i++].y = y;
                if (y == y2)
                    return ret_val;
                if (d >= 0) {
                    x += sx;
                    d -= ay;
                }
                y += sy;
                d += ax;
            }
        }
    }
    
    
    /**
     * Return sign of number.
     * 
     * @param x short
     * @return int sign -1, 1
     */
    public static final int sign(short x) {
        return (x < 0) ? -1 : 1;
    }

    /**
     * Return sign of number.
     * 
     * @param x int
     * @return int sign -1, 1
     */
    public static final int sign(int x) {
        return (x < 0) ? -1 : 1;
    }

    /**
     * Return sign of number.
     * 
     * @param x long
     * @return int sign -1, 1
     */
    public static final int sign(long x) {
        return (x < 0) ? -1 : 1;
    }

    /**
     * Return sign of number.
     * 
     * @param x float
     * @return int sign -1, 1
     */
    public static final int sign(float x) {
        return (x < 0f) ? -1 : 1;
    }

    /**
     * Return sign of number.
     * 
     * @param x double
     * @return int sign -1, 1
     */
    public static final int sign(double x) {
        return (x < 0d) ? -1 : 1;
    }







	public int ipp(){
		
		return Math.round((perso.getNiveau()-1)/4)+5;
		
		
	}

///////////////////////////////////////////////////////////
	public String unAccent(String s) {
		temp = Normalizer.normalize(s, Normalizer.DECOMP, 0);
		return temp.replaceAll("[^\\p{ASCII}]","");
	}
	
	
///////////////////////////////////////////////////////////	
	public void zip(String dossier,String nomFich){
		
   		/*************
   		 * Compression
   		 *************/
		try {
      	
      		// création d'un flux d'écriture sur fichier
			FileOutputStream dest = new FileOutputStream(dossier+nomFich+".zip");
			
			// calcul du checksum : Adler32 (plus rapide) ou CRC32
			CheckedOutputStream checksum = new CheckedOutputStream(dest, new Adler32());

      		// création d'un buffer d'écriture
			BufferedOutputStream buff = new BufferedOutputStream(checksum);
			
      		// création d'un flux d'écriture Zip
			ZipOutputStream out = new ZipOutputStream(buff);
			

         	// spécification de la méthode de compression
			out.setMethod(ZipOutputStream.DEFLATED);
			
			// spécifier la qualité de la compression 0..9
			out.setLevel(Deflater.BEST_COMPRESSION);
			
         
         	// buffer temporaire des données à écriture dans le flux de sortie
			byte data[] = new byte[BUFFER];
         
         
//JACKterrainx0y0z1.sav
         
			
			fichier=dossier+nomFich+".sav";
			
			FileInputStream fi = new FileInputStream(fichier);
	            
            // création d'un tampon de lecture sur ce flux
            BufferedInputStream buffi = new BufferedInputStream(fi, BUFFER);
            
            // création d'en entrée Zip pour ce fichier
            String [] fich=fichier.split(dossier);
            
            
            ZipEntry entry = new ZipEntry(unAccent(fich[1]));
            
            
            // ajout de cette entrée dans le flux d'écriture de l'archive Zip
            out.putNextEntry(entry);
            
            // écriture du fichier par paquet de BUFFER octets
            // dans le flux d'écriture
            int count;
            while((count = buffi.read(data, 0, BUFFER)) != -1) {
               out.write(data, 0, count);
			}
            
			// Close the current entry
     		out.closeEntry();
     		
     	    // fermeture du flux de lecture
			buffi.close();
			
			// fermeture du flux d'écriture
			out.close();
			buff.close();
			checksum.close();
			dest.close();

			//System.out.println("checksum: " + checksum.getChecksum().getValue());

         
		// traitement de toute exception         
		} catch(Exception e) {
			e.printStackTrace();
		}
		
		
		
		
		
	}
	
	
///////////////////////////////////////////////////////////	
	public void unzip(String dossier,String nomFich){
		
   		 
		try {
			
			// fichier destination
			BufferedOutputStream dest = null;
			
			// ouverture fichier entrée
			FileInputStream fis = new FileInputStream(dossier+nomFich+".zip");
			
			// ouverture fichier de buffer
			BufferedInputStream buffi = new BufferedInputStream(fis);
			
			// ouverture archive Zip d'entrée
			ZipInputStream zis = new ZipInputStream(buffi);
			
			// entrée Zip
			ZipEntry entry;

			// parcours des entrées de l'archive
			while((entry = zis.getNextEntry()) != null) {
				
				// affichage du nom de l'entrée
				//System.out.println("Extracting: " +entry);
				
				int count;
				byte data[] = new byte[BUFFER];
				
				// création fichier
				//FileOutputStream fos = new FileOutputStream(entry.getName());
				FileOutputStream fos = new FileOutputStream(dossier+entry.getName());
				
				
				// affectation buffer de sortie
				dest = new BufferedOutputStream(fos, BUFFER);
				
				// écriture sur disque
				while ((count = zis.read(data, 0, BUFFER)) != -1) {
					dest.write(data, 0, count);
				}
				
				// vidage du tampon
				dest.flush();
				
				// fermeture fichier
				dest.close();
			}
			
			// fermeture archive
			zis.close();
			
		} catch(Exception e) {
			//e.printStackTrace();
			//System.out.println("DOSS: "+dossier+"    FILE: "+nomFich+" not found (UNZIP)");
		}
		
	}
	
	////////////////////supprimer les .sav dans un dossier
	public void videur(String dos){
		File repertoire=new File(dos);
		
		
        
        direct = ".";
        File f1 = new File(direct);
        int k;
        String[] ls;
        FilenameFilter filter = new FiltreFichier("sav");
        //System.out.println("Sav Files: " );
        //for (ls = f1.list(filter), k = 0;
        //     ls != null && k < ls.length;
        //     System.out.println("\t" + ls[k++]));
    
		File[] list = repertoire.listFiles(filter);
		
		
		for(int i=0;i<list.length;i++){
			list[i].delete();
		}
		
		
	}
	
	
	
	

		
		
	
	
	
	/*
	/////un test pour ThreadSonAmbiance
	public Personnage getPersoFromMonde(){
		
		return perso;
		
	}*/
	
	
	
	
	/*
	////////////////////////////////////////////
	public void deplaceur(String ext, String dosSource, String dosDest){
		
	
	
		File repertoireActuels=new File(dosSource);		
		FilenameFilter filter = new FiltreFichier(ext);
		File[] list = repertoireActuels.listFiles(filter);
		String sourceName=new String();
		
		for(int u=0;u<list.length;u++){				
			
			sourceName=dosSource+list[u].getName();
			// File (or directory) to be moved
		    File file = new File(sourceName);
		    
		    // Destination directory
		    File dir = new File(dosDest);
		    
		    // Move file to new directory
		    boolean success = file.renameTo(new File(dir, file.getName()));
		    if (!success) {
		    	System.out.println("Erreur de deplacement");
		        // File was not successfully moved
		    }
				
		}		
	
		
	}
	
	
	
	public void copieur(String ext, String dosSource, String dosDest){
	
		
		
		
		//ON COPIE TOUS LES FICHIERS CONTENUS DANS ACTUELS VERS LE DOSSIER SAVE
			
			
			
			File repertoireActuels=new File(dosSource);
			
			
			FilenameFilter filter = new FiltreFichier(ext);
			File[] list = repertoireActuels.listFiles(filter);
			
			String dest=new String(dosDest);
			
			String sourceName=new String();
			
			Object source=new Object();
			
			for(int u=0;u<list.length;u++){
				sourceName=list[u].getName();
				
				//System.out.println(sourceName);
				//jeuPan.messagesPanel.remplissageMessages(sourceName);
				
				//CHARGE
				FileInputStream out2=null;
		   		ObjectInputStream flux2=null;
				
				try{
						out2=new FileInputStream(dosSource+sourceName);
						flux2=new ObjectInputStream(out2);
						
						source=flux2.readObject();
						
					}
				catch(ClassNotFoundException f){f.printStackTrace();}
				catch(IOException i){i.printStackTrace();}
				finally{
					try {
				        flux2.close();
				  		out2.close();
					} 
					catch (IOException e1) {e1.printStackTrace();}
				}
				
				
				
				//COPIE
				FileOutputStream out5=null;
				ObjectOutputStream flux5=null;
				try{
						out5=new FileOutputStream(dosDest+sourceName);
						flux5=new ObjectOutputStream(out5);
						flux5.writeObject(source);
						
					}
				catch(IOException i){i.printStackTrace();}
				finally{
					 try {
					    flux5.flush();
					    flux5.close();
					    out5.close();
					 }
					 catch (IOException e1) {e1.printStackTrace();}
				}	
				
				
			}
	
	
	
	}
	
	

		
	// Copies all files under srcDir to dstDir.
    // If dstDir does not exist, it will be created.
    public void copyDirectory(File srcDir, File dstDir) throws IOException {
        if (srcDir.isDirectory()) {
            
            String[] children = srcDir.list();
            for (int i=0; i<children.length; i++) {
                copyDirectory(new File(srcDir, children[i]),
                                     new File(dstDir, children[i]));
            }
        } 
        else {
        	System.out.println("Echec copie");
            // This method is implemented in e1071 Copying a File
            //copyFile(srcDir, dstDir);
        }
    }
	*/
	
}
