import javax.swing.*;
import java.awt.*;
import java.util.*;

//TILES = 32 X 32 !!!!!!!

class TerrainPanel extends JPanel{
	
	ArrayList lumieresVusParPerso=new ArrayList();//XXXXXXXXXXXXXXXXXXX
	
	int x=0;
	int y=0;
	int thisX=0;
	int thisY=0;
	int xAf=0;
	int yAf=0;
	Vide vide=new Vide();
	int xA=0;
	int yA=0;
	int i=0;
	String[] strTree;
	String[] strTree2;
	
	boolean ausec=false;
	ArrayList infraArray=new ArrayList();
	int b=0;
	int z=0;
	int convX=0;
	int convY=0;
	Enumeration e;
	boolean ok=true;
	
	
	
	
	//LOS
	boolean clair=true;
	boolean stair=false;
	Point[] tabloPt;
	Point liPt=new Point(0,0);
	
	
	//on cree un vecteur d'affichage
    ArrayList grilleAffiche[][]=new ArrayList[20][15];
	
	///////////////////////////////TIR
	int xTir=0;
	int yTir=0;
	int xan=0;
	int yan=0;
	
	boolean boolTir=false;
	int xTo=0;
	int yTo=0;
	int xFrom=0;
	int yFrom=0;
	
	String missileStr=new String();
	
	int orientTir=0;
	int incrX=0;
	int incrY=0;
	
	//////////////////////////////TIR
	
	
	
	
	int vx=0;
	int vy=0;
	int vmin=0;
	int sight=0;
	
	
	private Entite objet=new Entite();
	private Entite objet2=new Entite();
	
	private Graphics buffer;
	private Image image;
	
	
	private Graphics gOffScreenImage;
	
	
	private CryptRL leJeu;
	//private PanneauJeu jeuPan;
	
	private String thisTile=new String();
	
	private Image imageTile;
	private Toolkit toolkit = Toolkit.getDefaultToolkit();
	
	//boolean marqueurCycleNuit=true;
	
	private ArrayList boundArray=new ArrayList();
	Entite ici=new Entite();
    Point persoPt=new Point(0,0); //centre
    Point studyPt=new Point(0,0);
	Point lightPt=new Point(0,0); //centre
	ArrayList lightArray=new ArrayList();
	
	ArrayList torchArray=new ArrayList();///XXXXXX
	ArrayList murArray=new ArrayList();///XXXXXX
	ArrayList coordMurArray=new ArrayList();///XXXXXX
	
	///PLUIE//////////////////////////////////////////////////
	//String pluieStr=new String();
	
	int intpluie=0;
	//String pluieStr0=new String("./images/special/rain1.gif");
	//String pluieStr1=new String("./images/special/rain2.gif");
	//String pluieStr2=new String("./images/special/rain3.gif");
	private Image imageTilePluie0=toolkit.getImage("./images/special/rain1.gif");
	private Image imageTilePluie1=toolkit.getImage("./images/special/rain2.gif");
	private Image imageTilePluie2=toolkit.getImage("./images/special/rain3.gif");
	
	boolean tonnerre=false;
	float volumeTonnerre=0;
	
	
	
	////////CIEL////////////
	private Image imageCiel=toolkit.getImage("./images/special/sky.jpg");
	
	
	////////NUAGES//////////
	private Image imageNuage1=toolkit.getImage("./images/special/cloud1.gif");
	private Image imageNuage2=toolkit.getImage("./images/special/cloud2.gif");
	short nuageX=640;
    short nuageY=0;
	short nuage2X=320;
    short nuage2Y=100;
    short nuage3X=50;
    short nuage3Y=200;
	
	
	////*************************
	private Image imageTilevide=toolkit.getImage("./images/special/vide.gif");
	private Image imageTiletenebres=toolkit.getImage("./images/special/tenebres.gif");
	
	private Image imageTileNightVision=toolkit.getImage("./images/special/infraL.gif");
	
	
	private Image imageTileBlood1=toolkit.getImage("./images/special/blood1.gif");
	private Image imageTileBlood2=toolkit.getImage("./images/special/blood2.gif");
	private Image imageTileBlood3=toolkit.getImage("./images/special/blood3.gif");
	private Image imageTileStorm=toolkit.getImage("./images/special/white.gif");
    private Image imageTilepenombre2=toolkit.getImage("./images/special/penombre2.gif");
    private Image imageTileRIP=toolkit.getImage("./images/logoRIP.gif");
	
	
	
	////GIFS ETATS
	private Image imageTileInfravision=toolkit.getImage("./images/sorts/infravision.gif");
	private Image imageTileInvisible=toolkit.getImage("./images/sorts/1.gif");
	private Image imageTilePasseMuraille=toolkit.getImage("./images/sorts/4.gif");
	private Image imageTileXRay=toolkit.getImage("./images/sorts/rayonX.gif");
	private Image imageTileFly=toolkit.getImage("./images/sorts/fly.gif");
	
	////*************************
		
	int oldDisplayCount=0;	
		
			
	public TerrainPanel(CryptRL game){//,PanneauJeu gamePan){
		leJeu=game;
		//jeuPan=gamePan;
		
		creationBoundArray();
		
		setLayout(null);
		
		
		
		
		new AnimThread(this).start();
			
	}	
	
	
	public void creationBoundArray(){
	
		
		for(x=10;x<leJeu.monde.tailleGrille-10;x++){
			boundArray.add(new Point(x,10));
			boundArray.add(new Point(x,leJeu.monde.tailleGrille-11));
		}
		
		for(y=10;y<leJeu.monde.tailleGrille-10;y++){
			boundArray.add(new Point(10,y));
			boundArray.add(new Point(leJeu.monde.tailleGrille-11,y));
		}
		
	}
	
	
	
	
	
	
	public void update(Graphics g){
		
		
		if ( image == null ){
			image =createImage( getSize().width,getSize().height ); 
			gOffScreenImage= image.getGraphics();
		
		}

   		 
		
		//paintComponent(gOffScreenImage); ///ou paint ?
		paintComponent(gOffScreenImage); ///ou paint ?
		
		g.drawImage(image, 0, 0, this);
		gOffScreenImage.dispose(); 
		
		
		/*
		paint(g);
		*/
	}
	
	
		
		
		
	
	public void paintComponent(Graphics g){ /// ou paint ?
		oldDisplayCount=0;
		
		//System.out.println("PERSO ="+leJeu.monde.perso.getCooX()+" "+leJeu.monde.perso.getCooY());
		
		
		//création du buffer s'il n'existe pas
 		if(buffer == null){
 			
 			image = createImage(640 ,480 );
 			buffer = image.getGraphics();
 		}
		
	
		// on dessine le terrain noir.
 		//buffer.setColor(Color.black);
        //buffer.fillRect(5,5,640,480);
        
        
        //////////////////////////////////////////////////////////////////////////
        //////////////////////////////////////////////////////////////////////////
        //AFFICHAGE
        
        
        //on obtient les coordonnées du perso
        thisX=leJeu.monde.perso.getCooX();
        thisY=leJeu.monde.perso.getCooY();
        
        
        
        //on rempli ArrayList pour éviter les NullPointers
        for(xAf=0;xAf<20;xAf++){
			for(yAf=0;yAf<15;yAf++){
				grilleAffiche[xAf][yAf]=new ArrayList();
					
				grilleAffiche[xAf][yAf].add(vide);
			}
			
		}
        
       	//les coordonnées thisX;thisY doivent correspondre aux coordonnées 10,7 de la grilleAffichage
        //on balaie leJeu.grille
        //dans grilleAffiche on met les objets trouvés
        
        //pour que le perso soit centré on se place à 2,4 sur leJeu.grille
        int coorGrilleAffichX=0;
        int coorGrilleAffichY=0;
        
        for(xA=thisX-10+1;xA<thisX+9+2;xA++){
        	coorGrilleAffichY=0;
        	for(yA=thisY-10+3;yA<thisY+4+4;yA++){
        		
        		grilleAffiche[coorGrilleAffichX][coorGrilleAffichY]=leJeu.monde.grille[xA][yA];
        		coorGrilleAffichY++;
        		
        	}
        	coorGrilleAffichX++;
        }
        
        
        
        
        /////////////////////
        //on affiche tout////
        /////////////////////
        
        
        //assombrissement:
        // 0 clair
        // 1 penombre
        // 2 los
        // 3 nuit ou sous terre
        
        if(leJeu.monde.losOn){
        	
	        assombrissementTout();
	        
	        
	        if(leJeu.monde.getNuit()==true || leJeu.monde.perso.indexTerrainZ>0){
	        	assombrissementEclairageTout();
	        	illumination();// objets éclairants au sol et portés par créatures
	        	eclairage(leJeu.monde.perso.getCooX(),leJeu.monde.perso.getCooY(),leJeu.monde.perso.getVue(),leJeu.monde.perso,true);
	        	
	        	
	        	
	        	
	        }
	        
	        else if(leJeu.monde.getNuit()==false || leJeu.monde.perso.indexTerrainZ<=0){
	        	eclairageJour();
	        }
	        
	        
	        los();
        
        
        
        
        }
        else{
        	for(x=0;x<leJeu.monde.tailleGrille;x++){
				for(y=0;y<leJeu.monde.tailleGrille;y++){
	        		leJeu.monde.shadowGrid[x][y]=0;
	        		leJeu.monde.eclairageGrid[x][y]=0;
		 		}
		 	}
		 	
        }
        
        
        
        
        ///////GRILLE NIGHTVISION
        infravisionPJ();
        rayonX();
        
        
        
        
        
        
        //////////////////////////////////////////////////////////////////////////
        for(y=0;y<15;y++){
       	 for(x=0;x<20;x++){
       	 	
       	 		//FOND et OMBRAGES TENEBRES
       	 		////Passage initial d'affichage d'un fond dans la zone jouable
        		//imageTile=toolkit.getImage("./images/special/vide.gif");
				
				
				if(leJeu.monde.perso.indexTerrainZ>=0){
					buffer.drawImage(imageTilevide, x*32, y*32, this);
				}
				else{
					buffer.drawImage(imageCiel, x*32, y*32, this);
				}
					
        		
        	
        		//passage avec les ombrages
				if(leJeu.monde.shadowGrid[x+leJeu.monde.perso.getCooX()-9][y+leJeu.monde.perso.getCooY()-7]==2){
					//imageTile=toolkit.getImage("./images/special/tenebres.gif");
					buffer.drawImage(imageTiletenebres, x*32, y*32, this);
				}
				
				
				
				
				
        		if(leJeu.monde.eclairageGrid[x+leJeu.monde.perso.getCooX()-9][y+leJeu.monde.perso.getCooY()-7]==2){
        			//imageTile=toolkit.getImage("./images/special/tenebres.gif");
					buffer.drawImage(imageTiletenebres, x*32, y*32, this);
        		}
        		
        		
        		
        		
        		
        	}
        }
        
        
        //////////////////////////////////////////////////////////////////////////
        //  1 ////////////////////////////////////////////////////////////////////////
        //////////////////////////////////////////////////////////////////////////
        for(y=0;y<15;y++){
       	 for(x=0;x<20;x++){
       	 	
        		
        		if(!grilleAffiche[x][y].isEmpty()){
					
					
					for(i=0;i<grilleAffiche[x][y].size();i++){
					
		 				objet = (Entite) grilleAffiche[x][y].get(i);
		 				///passage initial uniquement les surface , gate
	 					if(!doitEtreOcculte(x,y) && objet.getVisible()==true && (objet.getClass().getName().compareTo("Gate")==0 ||objet.getClass().getName().compareTo("Surface")==0)){
	 						//thisTile=objet.getTileStr();
		 					//imageTile=toolkit.getImage(thisTile);
		 					
		 					
		 					
		 					
		 				//***********************************	
		 					if(leJeu.monde.cat.imagesCatStr.contains(objet.getTileStr())){
		 						imageTile=(Image)leJeu.monde.cat.imagesCat.get(leJeu.monde.cat.imagesCatStr.indexOf(objet.getTileStr()));
		 					}
		 					
		 					else{
		 						thisTile=objet.getTileStr();
		 						imageTile=toolkit.getImage(thisTile);
		 						oldDisplayCount++;
		 					}
			 			//***********************************		
		 					
		 					
		 					buffer.drawImage(imageTile, (x*32)-(imageTile.getWidth(this))+32 -16 +(imageTile.getWidth(this)/2), (y*32)-(imageTile.getHeight(this))+32, this);
							
							
							
							
	 					}
	 					else if(!doitEtreOcculte(x,y) && objet.getTileCache()!=null && (objet.getClass().getName().compareTo("Gate")==0 || objet.getClass().getName().compareTo("Surface")==0)){
	 						//thisTile=objet.getTileCache();
		 					//imageTile=toolkit.getImage(thisTile);
							
							
		 					
		 				//***********************************
		 					if(leJeu.monde.cat.imagesCatStr.contains(objet.getTileCache())){
		 						imageTile=(Image)leJeu.monde.cat.imagesCat.get(leJeu.monde.cat.imagesCatStr.indexOf(objet.getTileCache()));
		 					}
		 				//***********************************
		 					
		 					else{
		 						thisTile=objet.getTileCache();
		 						imageTile=toolkit.getImage(thisTile);
		 						oldDisplayCount++;
		 					}
							
							
							
							buffer.drawImage(imageTile, (x*32)-(imageTile.getWidth(this))+32 -16 +(imageTile.getWidth(this)/2), (y*32)-(imageTile.getHeight(this))+32, this);
							
	 					}
		 				
		 				
		 			
		 			}
		 		}
		 	}
		 }
        
        
        
        
        
        
        
        
        
        //////////////////////////////////////////////////////////////////////////
        //////////////////////////////////////////////////////////////////////////
        for(y=0;y<15;y++){
       	 for(x=0;x<20;x++){
       	 	
       	 		
        		
        		//////////////////////////////////////////////////////////////////////////
        		//////////////////////////////////////////////////////////////////////////
        
        		
        		if(!grilleAffiche[x][y].isEmpty()){
					
					
					for(i=0;i<grilleAffiche[x][y].size();i++){
					
		 				objet = (Entite) grilleAffiche[x][y].get(i);
		 				
        				
	 					
	 					//////////////////////////////////////////////////////////////////////////
        				//////////////////////////////////////////////////////////////////////////
        				
        				///1er passage le reste sauf ombrage, creature ,personnage, surface, gate et obstacle
		 					
		 					if(!doitEtreOcculte(x,y) && objet.getVisible()==true && objet.getClass().getName().compareTo("Ombrage")!=0 && objet.getTypeObjet().compareTo("Creature")!=0 && objet.getClass().getName().compareTo("Personnage")!=0 && objet.getClass().getName().compareTo("Gate")!=0 && objet.getClass().getName().compareTo("Surface")!=0 && objet.getTypeObjet().compareTo("Obstacle")!=0&& objet.getTypeObjet().compareTo("Water")!=0&& objet.getTypeObjet().compareTo("Passage")!=0){
		 						//thisTile=objet.getTileStr();
			 					//imageTile=toolkit.getImage(thisTile);
			 					
			 					//***********************************
								if(leJeu.monde.cat.imagesCatStr.contains(objet.getTileStr())){
			 						imageTile=(Image)leJeu.monde.cat.imagesCat.get(leJeu.monde.cat.imagesCatStr.indexOf(objet.getTileStr()));
			 					}
			 					else{
			 						thisTile=objet.getTileStr();
			 						imageTile=toolkit.getImage(thisTile);
			 						oldDisplayCount++;
			 					}
								//***********************************
								
								buffer.drawImage(imageTile, (x*32)-(imageTile.getWidth(this))+32 -16 +(imageTile.getWidth(this)/2), (y*32)-(imageTile.getHeight(this))+32, this);
							
		 					}
		 					else if(!doitEtreOcculte(x,y) && objet.getTileCache()!=null && objet.getClass().getName().compareTo("Ombrage")!=0 && objet.getTypeObjet().compareTo("Creature")!=0 && objet.getClass().getName().compareTo("Personnage")!=0 && objet.getClass().getName().compareTo("Gate")!=0 && objet.getClass().getName().compareTo("Surface")!=0 && objet.getTypeObjet().compareTo("Obstacle")!=0&& objet.getTypeObjet().compareTo("Water")!=0&& objet.getTypeObjet().compareTo("Passage")!=0){
		 						//thisTile=objet.getTileCache();
			 					//imageTile=toolkit.getImage(thisTile);
								
								//***********************************
								if(leJeu.monde.cat.imagesCatStr.contains(objet.getTileCache())){
			 						imageTile=(Image)leJeu.monde.cat.imagesCat.get(leJeu.monde.cat.imagesCatStr.indexOf(objet.getTileCache()));
			 					}
			 					else{
			 						thisTile=objet.getTileCache();
			 						imageTile=toolkit.getImage(thisTile);
			 						oldDisplayCount++;
			 					}
								//***********************************
								
								buffer.drawImage(imageTile, (x*32)-(imageTile.getWidth(this))+32 -16 +(imageTile.getWidth(this)/2), (y*32)-(imageTile.getHeight(this))+32, this);
							
		 						
		 					}
		 					
		 					
		 					
		 					
		 					
		 					 //Passage uniquement obstacles cassés  (murs et arbres cassés)****
		 					if(!doitEtreOcculte(x,y) && objet.getCasse() && objet.getVisible()==true && objet.getTypeObjet().compareTo("Obstacle")==0){
		 						//thisTile=objet.getTileStr();
			 					//imageTile=toolkit.getImage(thisTile);
								//***********************************
								if(leJeu.monde.cat.imagesCatStr.contains(objet.getTileStr())){
			 						imageTile=(Image)leJeu.monde.cat.imagesCat.get(leJeu.monde.cat.imagesCatStr.indexOf(objet.getTileStr()));
			 					}
			 					else{
			 						thisTile=objet.getTileStr();
			 						imageTile=toolkit.getImage(thisTile);
			 						oldDisplayCount++;
			 					}
								//***********************************
								buffer.drawImage(imageTile, (x*32)-(imageTile.getWidth(this))+32 -16 +(imageTile.getWidth(this)/2), (y*32)-(imageTile.getHeight(this))+32, this);
								
		 					}
		 					else if(!doitEtreOcculte(x,y) && objet.getCasse() && objet.getTileCache()!=null && objet.getTypeObjet().compareTo("Obstacle")==0){
		 						//thisTile=objet.getTileCache();
			 					//imageTile=toolkit.getImage(thisTile);
								//***********************************
								if(leJeu.monde.cat.imagesCatStr.contains(objet.getTileCache())){
			 						imageTile=(Image)leJeu.monde.cat.imagesCat.get(leJeu.monde.cat.imagesCatStr.indexOf(objet.getTileCache()));
			 					}
			 					else{
			 						thisTile=objet.getTileCache();
			 						imageTile=toolkit.getImage(thisTile);
			 						oldDisplayCount++;
			 					}
								//***********************************
								
		 						buffer.drawImage(imageTile, (x*32)-(imageTile.getWidth(this))+32 -16 +(imageTile.getWidth(this)/2), (y*32)-(imageTile.getHeight(this))+32, this);
								
		 					}
		 					
//objet.getClass().getName().compareTo("Wall")==0		 					
//objet.getClass().getName().compareTo("Arbre")==0		 					
		 					
		 					
		 					
		 					//2ème passage avec les créatures mortes uniquement
		 					if(!doitEtreOcculte(x,y) && objet.getMort() && objet.getVisible()==true && objet.getTypeObjet().compareTo("Creature")==0){
		 						//thisTile=objet.getTileStr();
			 					//imageTile=toolkit.getImage(thisTile);
								//***********************************
								if(leJeu.monde.cat.imagesCatStr.contains(objet.getTileStr())){
			 						imageTile=(Image)leJeu.monde.cat.imagesCat.get(leJeu.monde.cat.imagesCatStr.indexOf(objet.getTileStr()));
			 					}
			 					else{
			 						thisTile=objet.getTileStr();
			 						imageTile=toolkit.getImage(thisTile);
			 						oldDisplayCount++;
			 					}
								//***********************************
								
								buffer.drawImage(imageTile, (x*32)-(imageTile.getWidth(this))+32 -16 +(imageTile.getWidth(this)/2), (y*32)-(imageTile.getHeight(this))+32, this);
							
		 					}
		 					
		 					
		 					
		 					
		 					//Passage uniquement obstacles pas cassés   (murs pas cassés et eau)*****
		 					if(!doitEtreOcculte(x,y) && !objet.getCasse() && objet.getVisible()==true && (objet.getClass().getName().compareTo("Water")==0 || objet.getClass().getName().compareTo("Wall")==0)){
		 						//thisTile=objet.getTileStr();
			 					//imageTile=toolkit.getImage(thisTile);
								//***********************************
								if(leJeu.monde.cat.imagesCatStr.contains(objet.getTileStr())){
			 						imageTile=(Image)leJeu.monde.cat.imagesCat.get(leJeu.monde.cat.imagesCatStr.indexOf(objet.getTileStr()));
			 					}
			 					else{
			 						thisTile=objet.getTileStr();
			 						imageTile=toolkit.getImage(thisTile);
			 						oldDisplayCount++;
			 					}
								//***********************************
								buffer.drawImage(imageTile, (x*32)-(imageTile.getWidth(this))+32 -16 +(imageTile.getWidth(this)/2), (y*32)-(imageTile.getHeight(this))+32, this);
								
		 					}
		 					else if(!doitEtreOcculte(x,y) && !objet.getCasse() && objet.getTileCache()!=null && (objet.getClass().getName().compareTo("Water")==0 || objet.getClass().getName().compareTo("Wall")==0)){
		 						//thisTile=objet.getTileCache();
			 					//imageTile=toolkit.getImage(thisTile);
								//***********************************
								if(leJeu.monde.cat.imagesCatStr.contains(objet.getTileCache())){
			 						imageTile=(Image)leJeu.monde.cat.imagesCat.get(leJeu.monde.cat.imagesCatStr.indexOf(objet.getTileCache()));
			 					}
			 					else{
			 						thisTile=objet.getTileCache();
			 						imageTile=toolkit.getImage(thisTile);
			 						oldDisplayCount++;
			 					}
								//***********************************
								
								
		 						buffer.drawImage(imageTile, (x*32)-(imageTile.getWidth(this))+32 -16 +(imageTile.getWidth(this)/2), (y*32)-(imageTile.getHeight(this))+32, this);
								
		 					}
		 					
		 					
		 					
		 					////passages (ponts, etc)
		 					if(!doitEtreOcculte(x,y) && objet.getVisible()==true &&objet.getClass().getName().compareTo("Passage")==0){
		 						
								//***********************************
								if(leJeu.monde.cat.imagesCatStr.contains(objet.getTileStr())){
			 						imageTile=(Image)leJeu.monde.cat.imagesCat.get(leJeu.monde.cat.imagesCatStr.indexOf(objet.getTileStr()));
			 					}
			 					else{
			 						thisTile=objet.getTileStr();
			 						imageTile=toolkit.getImage(thisTile);
			 						oldDisplayCount++;
			 					}
								//***********************************
								buffer.drawImage(imageTile, (x*32)-(imageTile.getWidth(this))+32 -16 +(imageTile.getWidth(this)/2), (y*32)-(imageTile.getHeight(this))+32, this);
								
		 					}
		 					else if(!doitEtreOcculte(x,y)&& objet.getTileCache()!=null &&objet.getClass().getName().compareTo("Passage")==0){
		 						
								//***********************************
								if(leJeu.monde.cat.imagesCatStr.contains(objet.getTileCache())){
			 						imageTile=(Image)leJeu.monde.cat.imagesCat.get(leJeu.monde.cat.imagesCatStr.indexOf(objet.getTileCache()));
			 					}
			 					else{
			 						thisTile=objet.getTileCache();
			 						imageTile=toolkit.getImage(thisTile);
			 						oldDisplayCount++;
			 					}
								//***********************************
								
		 						buffer.drawImage(imageTile, (x*32)-(imageTile.getWidth(this))+32 -16 +(imageTile.getWidth(this)/2), (y*32)-(imageTile.getHeight(this))+32, this);
								
		 					}
		 					
		 					
		 					
		 					
		 					
		 					
		 					
		 					
		 					
    						//passage avec arbres pas cassés
		 					if(!doitEtreOcculte(x,y) && !objet.getCasse() && objet.getVisible() && objet.getClass().getName().compareTo("Arbre")==0){
			 						if(leJeu.monde.reinerTrees){
			 							//thisTile=objet.getTileStr();
			 							//***********************************
										if(leJeu.monde.cat.imagesCatStr.contains(objet.getTileStr())){
					 						imageTile=(Image)leJeu.monde.cat.imagesCat.get(leJeu.monde.cat.imagesCatStr.indexOf(objet.getTileStr()));
					 					}
					 					else{
					 						thisTile=objet.getTileStr();
					 						imageTile=toolkit.getImage(thisTile);
					 						oldDisplayCount++;
					 					}
										//***********************************
			 							buffer.drawImage(imageTile, (x*32)-(imageTile.getWidth(this))+32 -16 +(imageTile.getWidth(this)/2), (y*32)-(imageTile.getHeight(this))+32, this);
										
			 							
			 						}
			 						else{
			 							//lourdingue
			 							strTree=objet.getTileStr().split("./images/vegetation/t");
			 							strTree2=strTree[1].split(".gif");
			 							//System.out.println(strTree2[0]);
			 							
			 							if(Integer.parseInt(strTree2[0])<12){
			 								thisTile="./images/vegetation/arbremort.gif";
			 							}
			 							if(Integer.parseInt(strTree2[0])>=12 && Integer.parseInt(strTree2[0])<18){
			 								thisTile="./images/vegetation/tallTree.gif";
			 							}
			 							if(Integer.parseInt(strTree2[0])>=18 && Integer.parseInt(strTree2[0])<24){
			 								thisTile="./images/vegetation/arbuste.gif";
			 							}
			 							if(Integer.parseInt(strTree2[0])>=24){
			 								thisTile="./images/vegetation/sapin.gif";
			 							}
			 							imageTile=toolkit.getImage(thisTile);
										buffer.drawImage(imageTile, (x*32)-(imageTile.getWidth(this))+32 -16 +(imageTile.getWidth(this)/2), (y*32)-(imageTile.getHeight(this))+32, this);
										
			 						}
			 							
				 					
				 					
				 					
		 					}
		 					else if(!doitEtreOcculte(x,y) && !objet.getCasse() && objet.getTileCache()!=null && objet.getClass().getName().compareTo("Arbre")==0){
		 						//thisTile=objet.getTileCache();
			 					//imageTile=toolkit.getImage(thisTile);
		 						//***********************************
								if(leJeu.monde.cat.imagesCatStr.contains(objet.getTileCache())){
			 						imageTile=(Image)leJeu.monde.cat.imagesCat.get(leJeu.monde.cat.imagesCatStr.indexOf(objet.getTileCache()));
			 					}
			 					else{
			 						thisTile=objet.getTileCache();
			 						imageTile=toolkit.getImage(thisTile);
			 						oldDisplayCount++;
			 					}
								//***********************************
								
		 						buffer.drawImage(imageTile, (x*32)-(imageTile.getWidth(this))+32 -16 +(imageTile.getWidth(this)/2), (y*32)-(imageTile.getHeight(this))+32, this);
								
		 					}
		 					
		 					
		 					
		 					
		 					
		 					
		 					//passage avec les créatures vivantes uniquement
		 					if(!doitEtreOcculte(x,y) && !objet.getMort() && objet.getVisible()==true && objet.getTypeObjet().compareTo("Creature")==0){
		 						//thisTile=objet.getTileStr();
			 					//imageTile=toolkit.getImage(thisTile);
								//***********************************
								if(leJeu.monde.cat.imagesCatStr.contains(objet.getTileStr())){
			 						imageTile=(Image)leJeu.monde.cat.imagesCat.get(leJeu.monde.cat.imagesCatStr.indexOf(objet.getTileStr()));
			 					}
			 					else{
			 						thisTile=objet.getTileStr();
			 						imageTile=toolkit.getImage(thisTile);
			 						oldDisplayCount++;
			 					}
								//***********************************
								
								
								buffer.drawImage(imageTile, (x*32)-(imageTile.getWidth(this))+32 -16 +(imageTile.getWidth(this)/2), (y*32)-(imageTile.getHeight(this))+32, this);
								
								
								
								
								if(objet.getCurrentHitPts()<=objet.getMaxHitPts()*3/4 && objet.getCurrentHitPts()>objet.getMaxHitPts()*2/4){
									
									buffer.drawImage(imageTileBlood1, (x*32)-(imageTile.getWidth(this))+32 -16 +(imageTile.getWidth(this)/2), (y*32)-(imageTile.getHeight(this))+32, this);
								
								}
								if(objet.getCurrentHitPts()<=objet.getMaxHitPts()*2/4 && objet.getCurrentHitPts()>objet.getMaxHitPts()*1/4){
									
									buffer.drawImage(imageTileBlood2, (x*32)-(imageTile.getWidth(this))+32 -16 +(imageTile.getWidth(this)/2), (y*32)-(imageTile.getHeight(this))+32, this);
								
								}
								if(objet.getCurrentHitPts()<=objet.getMaxHitPts()*1/4){
									
									buffer.drawImage(imageTileBlood3, (x*32)-(imageTile.getWidth(this))+32 -16 +(imageTile.getWidth(this)/2), (y*32)-(imageTile.getHeight(this))+32, this);
								
								}
								
		 					}
		 					
		 					
		 					
		 					
		 					
		 					
		 					//3ème passage avec uniquement le personnage
		 					if(!doitEtreOcculte(x,y) && objet.getVisible()==true && objet.getClass().getName().compareTo("Personnage")==0){
		 						
		 						
			 					//imageTile=toolkit.getImage(thisTile);
			 					
			 					//***********************************
			 					if(!objet.getInvisible()){
									if(leJeu.monde.cat.imagesCatStr.contains(objet.getTileStr())){
				 						imageTile=(Image)leJeu.monde.cat.imagesCat.get(leJeu.monde.cat.imagesCatStr.indexOf(objet.getTileStr()));
				 					}
				 					else{
				 						thisTile=objet.getTileStr();
				 						imageTile=toolkit.getImage(thisTile);
				 						//System.out.println("OLD DISPLAY");
				 						oldDisplayCount++;
				 					}
				 				}
				 				else{thisTile="./images/pjs/invisible.gif";imageTile=toolkit.getImage(thisTile);}
								//***********************************
			 					
								
								buffer.drawImage(imageTile, (x*32)-(imageTile.getWidth(this))+32 -16 +(imageTile.getWidth(this)/2), (y*32)-(imageTile.getHeight(this))+32, this);
							
							
							
								if(objet.getCurrentHitPts()<=objet.getMaxHitPts()*3/4 && objet.getCurrentHitPts()>objet.getMaxHitPts()*2/4){
									
									buffer.drawImage(imageTileBlood1, (x*32)-(imageTile.getWidth(this))+32 -16 +(imageTile.getWidth(this)/2), (y*32)-(imageTile.getHeight(this))+32, this);
								
								}
								if(objet.getCurrentHitPts()<=objet.getMaxHitPts()*2/4 && objet.getCurrentHitPts()>objet.getMaxHitPts()*1/4){
									
									buffer.drawImage(imageTileBlood2, (x*32)-(imageTile.getWidth(this))+32 -16 +(imageTile.getWidth(this)/2), (y*32)-(imageTile.getHeight(this))+32, this);
								
								}
								if(objet.getCurrentHitPts()<=objet.getMaxHitPts()*1/4){
									
									buffer.drawImage(imageTileBlood3, (x*32)-(imageTile.getWidth(this))+32 -16 +(imageTile.getWidth(this)/2), (y*32)-(imageTile.getHeight(this))+32, this);
								
								}
							
		 					}
        				
        				//////////////////////////////////////////////////////////////////////////
        				//////////////////////////////////////////////////////////////////////////
        				
        				//Passage avec les anim et les entites feu
        		
		        		/*if(leJeu.monde.animGrid[x+leJeu.monde.perso.getCooX()-9][y+leJeu.monde.perso.getCooY()-7]==1){
							imageTile=toolkit.getImage("./images/anim/lancer.gif");
							//buffer.drawImage(imageTile, x*32, y*32, this);
							buffer.drawImage(imageTile, (x*32)-(imageTile.getWidth(this))+32 -16 +(imageTile.getWidth(this)/2), (y*32)-(imageTile.getHeight(this))+32, this);
									
						}*/
						
						
						if(leJeu.monde.animGrid[x+leJeu.monde.perso.getCooX()-9][y+leJeu.monde.perso.getCooY()-7]==2){
							imageTile=toolkit.getImage("./images/anim/fire.gif");
							
							buffer.drawImage(imageTile, (x*32)-(imageTile.getWidth(this))+32 -16 +(imageTile.getWidth(this)/2), (y*32)-(imageTile.getHeight(this))+32, this);
									
						}
						if(leJeu.monde.animGrid[x+leJeu.monde.perso.getCooX()-9][y+leJeu.monde.perso.getCooY()-7]==3){
							imageTile=toolkit.getImage("./images/anim/ice.gif");
							
							buffer.drawImage(imageTile, (x*32)-(imageTile.getWidth(this))+32 -16 +(imageTile.getWidth(this)/2), (y*32)-(imageTile.getHeight(this))+32, this);
									
						}
						if(leJeu.monde.animGrid[x+leJeu.monde.perso.getCooX()-9][y+leJeu.monde.perso.getCooY()-7]==4){
							imageTile=toolkit.getImage("./images/anim/acide.gif");
							
							buffer.drawImage(imageTile, (x*32)-(imageTile.getWidth(this))+32 -16 +(imageTile.getWidth(this)/2), (y*32)-(imageTile.getHeight(this))+32, this);
									
						}
        				//////////////////////////////////////////////////////////////////////////
        				//////////////////////////////////////////////////////////////////////////
        				
        				
        
        
        			}
		 		}
        	}
        	
        }
        
        
        
       
       
        
        
        /////PLUIE
        ausec=false;
        for(y=0;y<15;y++){
        	for(x=0;x<20;x++){
        		
        		ausec=false;
        		
        		
        		if(!doitEtreOcculte(x,y) && leJeu.monde.pluie && leJeu.monde.perso.indexTerrainZ<=0){
		        
	        		//if(!grilleAffiche[x][y].isEmpty()){
						
						
						for(i=0;i<grilleAffiche[x][y].size();i++){
						
		 					objet = (Entite) grilleAffiche[x][y].get(i);
		 					
		 					if(objet.getModele().compareTo("statue")!=0 && objet.getModele().compareTo("colonne")!=0 && objet.getClass().getName().compareTo("Wall")==0){
		 						ausec=true;
		 					}
		 					
		 					if(objet.getClass().getName().compareTo("Gate")==0){
		 						ausec=true;
		 					}
		 					
		 					if(objet.getInterieur()){
		 						ausec=true;
		 					}
							
						}
					//}
					
					if(!ausec){
						
						if(intpluie==0){
							intpluie=1;
							buffer.drawImage(imageTilePluie0, x*32, y*32, this);
							
						}
						else if(intpluie==1){
							intpluie=2;
							buffer.drawImage(imageTilePluie1, x*32, y*32, this);
							
						}
						else{
							intpluie=0;
							buffer.drawImage(imageTilePluie2, x*32, y*32, this);
							
						}
						
						//System.out.println(intpluie);
						
						//imageTile=toolkit.getImage(pluieStr);
						//buffer.drawImage(imageTile, x*32, y*32, null);
					}
						
		        }
				
        	}
        	
        }
        
        
        
        
        
		
		if(leJeu.monde.pluie && leJeu.monde.perso.indexTerrainZ<=0){
			
			if((Math.random()*100)+1<2){tonnerre=true;}
			
			if(tonnerre){
				
				volumeTonnerre=(float)((int)(Math.random()*15)+1)*(-1);
				
				new ThreadSon("./sons/ambiance/tonnerre.wav",volumeTonnerre).start();
				
				if(leJeu.monde.perso.estDehors && Math.abs(volumeTonnerre)<8){
					//imageTileStorm=toolkit.getImage("./images/special/white.gif");
					buffer.drawImage(imageTileStorm, 0, 0, this);
				}
					
				
				tonnerre=false;
			}
			
		}
        
        
        
        
        
        
        
        /////////NUAGES
        if(leJeu.monde.perso.indexTerrainZ<-1){
        		
        	buffer.drawImage(imageNuage1,nuageX,nuageY, this);
        	nuageX--;
        	nuageY++;
        	
        	if(nuageX==0){nuageX=640;
        	}
        	
        	if(nuageY==480){nuageY=0;
        		
        	}
        	
        	
        	buffer.drawImage(imageNuage2,nuage2X,nuage2Y, this);
        	nuage2X--;
        	nuage2Y++;
        	
        	if(nuage2X==0){nuage2X=640;
        	}
        	
        	if(nuage2Y==480){nuage2Y=0;
        		
        	}
        	
        	
        	buffer.drawImage(imageNuage1,nuage3X,nuage3Y, this);
        	nuage3X--;
        	nuage3Y++;
        	
        	if(nuage3X==0){nuage3X=640;
        	}
        	
        	if(nuage3Y==480){nuage3Y=0;
        		
        	}
        	
       	}
        
        
        
        
        
        //////////////////////////////////////////////////////////////////////////
        //////////////////////////////////////////////////////////////////////////
        //OMBRAGES PENOMBRE
        for(y=0;y<15;y++){
        	for(x=0;x<20;x++){
        		
        		
				if(leJeu.monde.eclairageGrid[x+leJeu.monde.perso.getCooX()-9][y+leJeu.monde.perso.getCooY()-7]==1){
        			
					buffer.drawImage(imageTilepenombre2, x*32, y*32, this);
        		}
				
				
				
				
        		/////////NIGHTVISION
        		if(leJeu.monde.perso.getNightvision() && leJeu.monde.infraRedGrid[x+leJeu.monde.perso.getCooX()-9][y+leJeu.monde.perso.getCooY()-7]==1){
					buffer.drawImage(imageTileNightVision, x*32, y*32, this);
					//System.out.println(leJeu.monde.infraRedGrid[x+leJeu.monde.perso.getCooX()-9][y+leJeu.monde.perso.getCooY()-7]);
        		
        		}
        		
        		
				
				
        	}
        	
        }
        //////////////////////////////////////////////////////////////////////////
        //////////////////////////////////////////////////////////////////////////
        
        if(leJeu.monde.perso.getMort()){
        	
        	buffer.drawImage(imageTileRIP, 0, 0, this);
        }
        
        
        
        
        
        //////////////////////////////TIR////////////////////////////
        //System.out.println(boolTir);
        if(boolTir){
        
        	imageTile=toolkit.getImage(missileStr);
	    	buffer.drawImage(imageTile, xTir, yTir, this);
	    	xTir=xTir+(incrX*32);
	   		yTir=yTir+(incrY*32);
	   		
	   		//orientTir
	   		if(orientTir==1){//n
	   			if(yTir<=yTo){boolTir=false;}
	   		}
	   		
	   		if(orientTir==2){//ne
	   			if(xTir>=xTo || yTir<=yTo){boolTir=false;}
	   		}
	   		
	   		if(orientTir==3){//e
	   			if(xTir>=xTo){boolTir=false;}
	   		}
	   		
	   		if(orientTir==4){//se////////
	   			if(xTir>=xTo || yTir>=yTo){boolTir=false;}
	   		}
	   		
	   		if(orientTir==5){//s
	   			if(yTir>=yTo){boolTir=false;}
	   		}
	   		
	   		if(orientTir==6){//sw
	   			if(xTir<=xTo || yTir>=yTo){boolTir=false;}
	   		}
	   		
	   		if(orientTir==7){//w
	   			if(xTir<=xTo){boolTir=false;}
	   		}
	   		
	   		if(orientTir==8){//nw
	   			if(xTir<=xTo || yTir<=yTo){boolTir=false;}
	   		}
	   		
	   		if(orientTir==0){//self
	   			boolTir=false;
	   		}
	   		
	   		
	   		//System.out.println(xTir+" "+xTo);
	   		//System.out.println(yTir+" "+yTo);
	   		
       	}
        //////////////////////////////TIR
        
        
        
        
        //System.out.println("oldDisplayCount "+oldDisplayCount);
        
        
        
        
        
        
        
        /////ETAT SORTS //// faudra les mettre dans le panel Equipement !!!!!!!!
        if(leJeu.monde.perso.getNightvision()){
        	buffer.drawImage(imageTileInfravision, 608, 0, this);
        }
        
        if(leJeu.monde.perso.getInvisible()){
        	buffer.drawImage(imageTileInvisible, 608, 32, this);
        }
        
        if(leJeu.monde.perso.getPasseMuraille()){
        	buffer.drawImage(imageTilePasseMuraille, 608, 64, this);
        }
        
        
        if(leJeu.monde.perso.getRayonX()){
        	buffer.drawImage(imageTileXRay, 608, 96, this);
        }
        
        
        if(leJeu.monde.perso.getVolant()){
        	buffer.drawImage(imageTileFly, 608, 128, this);
        }
        
        
        
		//finalement le buffer mémoire est dessiné dans le buffer d'affichage
		
		
		
		
		if(leJeu.monde.zoom!=0){
			g.drawImage(
				image,
				-((leJeu.monde.zoom/2)-((16*leJeu.monde.zoom)/(32*16))),
				-(leJeu.monde.zoom/2),
				image.getWidth(this)+leJeu.monde.zoom,
				image.getHeight(this)+leJeu.monde.zoom,
				this);
		}
		else{
			g.drawImage(image,0,0,this);
		}


		
		//////TEST
		setOpaque( false );
		super.paintComponent(g);
		
	}
	
	
	
	
	
	//////////RAYONX///////////////////////
	public void rayonX(){
		
		for(x=0;x<leJeu.monde.tailleGrille;x++){
			for(y=0;y<leJeu.monde.tailleGrille;y++){
				leJeu.monde.xRayGrid[x][y]=0;
				
			}
		}
		
		
		if(leJeu.monde.perso.getRayonX()){
		
			for(x=leJeu.monde.perso.getCooX()-3;x<=leJeu.monde.perso.getCooX()+3;x++){
				for(y=leJeu.monde.perso.getCooY()-3;y<=leJeu.monde.perso.getCooY()+3;y++){
					//leJeu.monde.eclairageGrid[x][y]=0;
					//leJeu.monde.shadowGrid[x][y]=0;
					leJeu.monde.xRayGrid[x][y]=1;
					
				 }
			}
		}
		
	}
	
	
	////////////INFRAVISION PJ////////////
	public void infravisionPJ(){
		
		//infraArray=new ArrayList();
		infraArray.clear();
		
		for(x=0;x<leJeu.monde.tailleGrille;x++){
			for(y=0;y<leJeu.monde.tailleGrille;y++){
				leJeu.monde.infraRedGrid[x][y]=0;
				
			}
		}
		
		if(leJeu.monde.perso.getNightvision()){
			
			
			boolean ok=true;
			
			for(x=leJeu.monde.perso.getCooX()-3;x<=leJeu.monde.perso.getCooX()+3;x++){
				for(y=leJeu.monde.perso.getCooY()-3;y<=leJeu.monde.perso.getCooY()+3;y++){
					infraArray.add(new Point(x,y));
					
					//leJeu.monde.infraRedGrid[x][y]=1;
					
				 }
			}
			
			for(i=0;i<infraArray.size();i++){
	    		
	    		liPt=(Point)infraArray.get(i);
	    		tabloPt=bresenham_line(leJeu.monde.perso.getCooX(),leJeu.monde.perso.getCooY(),(int)liPt.getX(),(int)liPt.getY());
				
				ok=true;
				
				for(b=0;b<tabloPt.length;b++){
		    			
		    		studyPt=tabloPt[b];
		    		if(ok){
		    			leJeu.monde.infraRedGrid[(int)studyPt.getX()][(int)studyPt.getY()]=1;
		    		}
		    		
		    		for(z=0;z<leJeu.monde.grille[(int)studyPt.getX()][(int)studyPt.getY()].size();z++){
						ici = (Entite) leJeu.monde.grille[(int)studyPt.getX()][(int)studyPt.getY()].get(z);
				 		
						if((ici.getClass().getName().compareTo("Gate")==0 || ici.getClass().getName().compareTo("Wall")==0) && !ici.getCasse() && !ici.getOuvert() && !ici.getTransparent()){
							ok=false;			
							
						}
						
				 	}
		    		
		    		
		    	}
		    }
		   	
		}
		
		
	}
	
	
	
	
	//////////////////////////////TIR////////////
	public void paramTirRender(int fromX,int fromY,int toX,int toY, String misTr){
		
		if(toX>fromX){
			
			if(toY==fromY){//E
				//System.out.println("E");
				orientTir=3;
				incrX=1;
				incrY=0;
			}
			
			if(toY<fromY){//NE
				//System.out.println("NE");
				orientTir=2;
				incrX=1;
				incrY=-1;	
			}
			
			if(toY>fromY){//SE
				//System.out.println("SE");
				orientTir=4;
				incrX=1;
				incrY=1;	
			}
			
		}
		
		if(toX<fromX){
			
			if(toY==fromY){//W
				//System.out.println("W");
				orientTir=7;
				incrX=-1;
				incrY=0;
			}
			
			if(toY<fromY){//NW
				//System.out.println("NW");
				orientTir=8;
				incrX=-1;
				incrY=-1;	
			}
			
			if(toY>fromY){//SW
				//System.out.println("SW");
				orientTir=6;
				incrX=-1;
				incrY=1;	
			}
		}
		
		if(toX==fromX){
			if(toY==fromY){//SELF
				//System.out.println("SELF");
				orientTir=0;
				incrX=0;
				incrY=0;	
			}
			
			if(toY<fromY){//N
				//System.out.println("N");
				orientTir=1;
				incrX=0;
				incrY=-1;		
			}
			
			if(toY>fromY){//S
				//System.out.println("S");
				orientTir=5;
				incrX=0;
				incrY=1;		
			}
		}
		
		
		boolTir=true;
		xTo=(int)conversionGridToRender(toX,toY).getX();
		yTo=(int)conversionGridToRender(toX,toY).getY();
		
		xFrom=(int)conversionGridToRender(fromX,fromY).getX();
		yFrom=(int)conversionGridToRender(fromX,fromY).getY();
		
		//xFrom=288; perso
		//yFrom=224; perso
		
		xTir=xFrom;
		yTir=yFrom;
		missileStr=misTr;
		
		
		//(288,224,640,480,"./images/comestible/potionrouge.gif")
		
	}
	//////////////////////////////TIR
	
	
	
	/////CONVERTIR DES COORDONNEES DE GRID EN COORDONNEES D'AFFICHAGE en px
	public Point conversionGridToRender(int gx,int gy){
		convX=gx-leJeu.monde.perso.getCooX()+9;//=>9*32
        convY=gy-leJeu.monde.perso.getCooY()+7;//=>7*32
		
		return new Point(convX*32,convY*32);
	
	}
	
	
	
	
	
	
	///////////////////////////////////////////////////////////
	///////////////////////////////////////////////////////////
	///////////////////////////////////////////////////////////
	///////////////////////////////////////////////////////////
	///////////////////////////////////////////////////////////
	///////////////////////////////////////////////////////////
	public boolean doitEtreOcculte(int xo, int yo){
		if(leJeu.monde.xRayGrid[xo+leJeu.monde.perso.getCooX()-9][yo+leJeu.monde.perso.getCooY()-7]!=1 && leJeu.monde.infraRedGrid[xo+leJeu.monde.perso.getCooX()-9][yo+leJeu.monde.perso.getCooY()-7]!=1){
		
			if(leJeu.monde.shadowGrid[xo+leJeu.monde.perso.getCooX()-9][yo+leJeu.monde.perso.getCooY()-7]==2 || leJeu.monde.eclairageGrid[xo+leJeu.monde.perso.getCooX()-9][yo+leJeu.monde.perso.getCooY()-7]==2){
				return true;
			}
		}
		return false;
	}
	
	
	
	
	
	//////////////////////////////////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////
	//////////////////////////ASSOMBRISSEMENT/////////////////////////////////
	//////////////////////////////////////////////////////////////////////////
	public void assombrissementTout(){
		
		 for(x=0;x<leJeu.monde.tailleGrille;x++){
			for(y=0;y<leJeu.monde.tailleGrille;y++){
        	
	        	
	        	leJeu.monde.shadowGrid[x][y]=2;
	        	
	        	
		 	}
		 }
		 	 
	}
	
	
	public void assombrissementEclairageTout(){
		
		 for(x=0;x<leJeu.monde.tailleGrille;x++){
			for(y=0;y<leJeu.monde.tailleGrille;y++){
        	
	        	
	        	leJeu.monde.eclairageGrid[x][y]=2;
	        	
	        	
		 	}
		 }
		  
	}
	
	
	//////////////////////////////////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////
	//////////////////////////ILLUMINATION////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////
	public void illumination(){
		
		for(x=0;x<leJeu.monde.tailleGrille;x++){
			for(y=0;y<leJeu.monde.tailleGrille;y++){	
        		if(!leJeu.monde.grille[x][y].isEmpty()){
					for(i=0;i<leJeu.monde.grille[x][y].size();i++){
		 				try{
		 					
		 					
		 					objet = (Entite) leJeu.monde.grille[x][y].get(i);
		 					
		 					if(objet.getClass().getName().compareTo("Outil")==0 && objet.getAlume()){
		 						/////////////////////////////////////////////////////////////////
		 						/////////////////////////////////////////////////////////////////
		 						
		 						
		 						eclairage(x,y,objet.getEclairage(),objet,false);
		 						
		 						/////////////////////////////////////////////////////////////////
		 						//////////////////////////////////////////////////////////////////
		 					}
		 					
		 					if(objet.getTypeObjet().compareTo("Creature")==0){
				 					
				 					//objet.equipementVect
				 					//eclairage(objet.getCooX(),objet.getCooY(),objet.getEclairage());
	        						if(!objet.getEquipementVect().isEmpty()){
		
										for(e = objet.getEquipementVect().elements();e.hasMoreElements();){
							                
							 				try{	
							 						
							 					objet2=(Entite) e.nextElement();
							 					
												if(objet2.getAlume() && objet2.getEclairage()>0){
													eclairage(objet.getCooX(),objet.getCooY(),objet2.getEclairage(),objet,false);
												}
													
							 				}
							 				catch(NoSuchElementException exc){};
							 			}
							 		}
	        						
	        						////
				 			}
		 					
		 				}
		 				catch(NoSuchElementException exc){};
		 				
		 			}
		 		}
		 	}
		 }
		 		 
	}
	
	//////////////////////////////////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////
	//////////////////////////ECLAIRAGE///////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////
	
	
	public void eclairageJour(){
		
        
        for(x=0;x<leJeu.monde.tailleGrille;x++){
			for(y=0;y<leJeu.monde.tailleGrille;y++){
        	
	        	
	        	leJeu.monde.eclairageGrid[x][y]=0;
	        	
	        	
		 	}
		 }
	}
	
	
	//////////////////////////////////////////////////////////////////////////
	public void eclairage(int ox,int oy,int zone,Entite lum,Boolean porteeParPerso){
		/*
		///VERSION SIMPLE
		for(int xe=ox-zone*2;xe<=ox+zone*2 && xe<leJeu.monde.tailleGrille && xe>0;xe++){
        	for(int ye=oy-zone*2;ye<=oy+zone*2 && ye<leJeu.monde.tailleGrille && ye>0;ye++){
		 		if(leJeu.monde.eclairageGrid[xe][ye]!=0){
		 			leJeu.monde.eclairageGrid[xe][ye]=1;
		 		}
		 	}
		 	
		}
		for(int xe=ox-zone;xe<=ox+zone && xe<leJeu.monde.tailleGrille && xe>0;xe++){
		 	for(int ye=oy-zone;ye<=oy+zone && ye<leJeu.monde.tailleGrille && ye>0;ye++){
		 		
		 		leJeu.monde.eclairageGrid[xe][ye]=0;
		 		
		 	}
		 	
		}
		*/
		
		
		Point cooMurToAnalyse;
		
		//VERSION AVANCEE
		
		torchArray.clear();///XXXXXX
		murArray.clear();///XXXXXX
		coordMurArray.clear();//XXXXXXX
		
		//System.out.println("torcharray "+torchArray.size());
		
		ok=true;
		
		lightPt=new Point(ox,oy); //centre
    	studyPt=new Point(ox,oy);
    	lightArray.clear();
    	
    	for(int xe=ox-zone*2;xe<=ox+zone*2 && xe<leJeu.monde.tailleGrille && xe>0;xe++){
        	for(int ye=oy-zone*2;ye<=oy+zone*2 && ye<leJeu.monde.tailleGrille && ye>0;ye++){
		 		// creation lightArray
		 		lightArray.add(new Point(xe,ye));	
		 	}
		 	
		}
		
		 
		for(int ie=0;ie<lightArray.size();ie++){
    		liPt=(Point)lightArray.get(ie);
    		tabloPt=bresenham_line(ox,oy,(int)liPt.getX(),(int)liPt.getY());
			ok=true;
			
			for(int be=0;be<tabloPt.length;be++){
	    			
	    		studyPt=tabloPt[be];
	    		if(porteeParPerso&&ok && leJeu.monde.eclairageGrid[(int)studyPt.getX()][(int)studyPt.getY()]!=0){
			 		leJeu.monde.eclairageGrid[(int)studyPt.getX()][(int)studyPt.getY()]=1;
			 		
			 		
			 		if(!torchArray.contains(tabloPt[be])){torchArray.add(tabloPt[be]);}//XXXXXX
			 		
			 	}
	    		for(int ze=0;ze<leJeu.monde.grille[(int)studyPt.getX()][(int)studyPt.getY()].size();ze++){
					ici = (Entite) leJeu.monde.grille[(int)studyPt.getX()][(int)studyPt.getY()].get(ze);
			 		
					if((ici.getClass().getName().compareTo("Gate")==0 || ici.getClass().getName().compareTo("Wall")==0) && !ici.getCasse() && !ici.getOuvert() && !ici.getTransparent()){
						if(ok&&!murArray.contains(ici)){
							murArray.add(ici);
							coordMurArray.add(new Point((int)studyPt.getX(),(int)studyPt.getY()));
						}
						ok=false;			
						
					}
					
			 	}
			 	if(!porteeParPerso&&ok && leJeu.monde.eclairageGrid[(int)studyPt.getX()][(int)studyPt.getY()]!=0){
			 		leJeu.monde.eclairageGrid[(int)studyPt.getX()][(int)studyPt.getY()]=1;
			 		
			 		
			 		if(!torchArray.contains(tabloPt[be])){torchArray.add(tabloPt[be]);}//XXXXXX
			 		
			 	}
			 		
	    	}
	    	
	   	 		
	    	
	    	
	    	
		}
    	
    	//PARCOURIR murArray
		// Si source de lumiere est dans Los du Perso alors eclairage de la case du mur
		
		if(!porteeParPerso){
			for(int ie=0;ie<murArray.size();ie++){
				
				cooMurToAnalyse=(Point)coordMurArray.get(ie);
				
				//if(lumiereEstEntreMurEtPerso(cooMurToAnalyse,lum)){
				if(lumieresVusParPerso.contains(lum)){				
					leJeu.monde.eclairageGrid[(int)cooMurToAnalyse.getX()][(int)cooMurToAnalyse.getY()]=1;
					
				}
			}
    	}
    	/////////////////////////////////////////////////////
    	
    	
    	lightPt=new Point(ox,oy); //centre
    	studyPt=new Point(ox,oy);
    	lightArray.clear();
    	
    	murArray.clear();
    	coordMurArray.clear();
    	
		for(int xe=ox-zone;xe<=ox+zone && xe<leJeu.monde.tailleGrille && xe>0;xe++){
		 	for(int ye=oy-zone;ye<=oy+zone && ye<leJeu.monde.tailleGrille && ye>0;ye++){
		 		// creation lightArray
		 		lightArray.add(new Point(xe,ye));	
		 	}
		 	
		}
		
		 
		for(int ie=0;ie<lightArray.size();ie++){
    		liPt=(Point)lightArray.get(ie);
    		tabloPt=bresenham_line(ox,oy,(int)liPt.getX(),(int)liPt.getY());
			ok=true;
			
			for(int be=0;be<tabloPt.length;be++){
	    			
	    		studyPt=tabloPt[be];
	    		
	    		if(porteeParPerso&&ok){
			 		leJeu.monde.eclairageGrid[(int)studyPt.getX()][(int)studyPt.getY()]=0;
			 		
			 		if(!torchArray.contains(tabloPt[be])){torchArray.add(tabloPt[be]);}//XXXXXX
			 		
			 	}
			 	
	    		for(int ze=0;ze<leJeu.monde.grille[(int)studyPt.getX()][(int)studyPt.getY()].size();ze++){
					ici = (Entite) leJeu.monde.grille[(int)studyPt.getX()][(int)studyPt.getY()].get(ze);
			 		
					if((ici.getClass().getName().compareTo("Gate")==0 || ici.getClass().getName().compareTo("Wall")==0) && !ici.getCasse() && !ici.getOuvert() && !ici.getTransparent()){
						
						if(ok&&!murArray.contains(ici)){
							murArray.add(ici);
							coordMurArray.add(new Point((int)studyPt.getX(),(int)studyPt.getY()));
						}
						ok=false;			
					}
					
			 	}
			 	if(!porteeParPerso&&ok){
			 		leJeu.monde.eclairageGrid[(int)studyPt.getX()][(int)studyPt.getY()]=0;
			 		
			 		if(!torchArray.contains(tabloPt[be])){torchArray.add(tabloPt[be]);}//XXXXXX
			 		
			 	}
			 	
			 		
	    	}
		}
		
		
		
		//PARCOURIR murArray
		// Si source de lumiere est dans Los du Perso alors eclairage de la case du mur
		
		if(!porteeParPerso){
			for(int ie=0;ie<murArray.size();ie++){
				
				cooMurToAnalyse=(Point)coordMurArray.get(ie);
				
				//if(lumiereEstEntreMurEtPerso(cooMurToAnalyse,lum)&&lumieresVusParPerso.contains(lum)){
				if(lumieresVusParPerso.contains(lum)){				
					leJeu.monde.eclairageGrid[(int)cooMurToAnalyse.getX()][(int)cooMurToAnalyse.getY()]=0;
					
				}
			}
		}
		
		//System.out.println(lumieresVusParPerso.size());
		
		
		
	}
	
	
	
	
	
	///NE SERT PAS///////////////////NE SERT PAS///////////NE SERT PAS//////////
	public boolean lumiereEstEntreMurEtPerso(Point murTarget,Entite lumiere){
		boolean rep=false;
		ArrayList listToAnalyse=new ArrayList();
		
		tabloPt=bresenham_line(leJeu.monde.perso.getCooX(),leJeu.monde.perso.getCooY(),(int)murTarget.getX(),(int)murTarget.getY());
		
		for(int t=0;t<tabloPt.length;t++){
					
	    	studyPt=tabloPt[t];
	    	
	    	for(int ze=0;ze<leJeu.monde.grille[(int)studyPt.getX()][(int)studyPt.getY()].size();ze++){
				ici = (Entite) leJeu.monde.grille[(int)studyPt.getX()][(int)studyPt.getY()].get(ze);
				listToAnalyse.add(ici);	
			}
	    		
		}
		
		if(listToAnalyse.contains(lumiere)){
			rep=true;
			
		}
		
		return rep;
	}
	/////////////////////////////////
	
	

	//////////////////////////////////////////////////////////////////////////
	//////////////////////////////L . O . S///////////////////////////////////
	//////////////////////////////////////////////////////////////////////////
	
    public void los(){
	    try	{
	    	
	    	
	    	//CREATION FRONTIERES CIBLES
	    /*	
	    	boundArray.clear();
	    	
	    
	    	for(int x=leJeu.monde.perso.getCooX()-9;x<=leJeu.monde.perso.getCooX()+10;x++){
				boundArray.add(new Point(x,leJeu.monde.perso.getCooY()-7));
				boundArray.add(new Point(x,leJeu.monde.perso.getCooY()+7));
			}
			
			for(int y=leJeu.monde.perso.getCooY()-7;y<=leJeu.monde.perso.getCooY()+7;y++){
				boundArray.add(new Point(leJeu.monde.perso.getCooX()-9,y));
				boundArray.add(new Point(leJeu.monde.perso.getCooX()+10,y));
			}
			
			
			
			
			System.out.println(boundArray.size());
		*/	
			
			//for(int i=0;i<boundArray.size();i++){
			//	Point p=(Point)boundArray.get(i);
				//if(p.getX()==leJeu.monde.perso.getCooX()-9 && p.getY()==leJeu.monde.perso.getCooY()+6){System.out.println((Point)boundArray.get(i));}
			//}
	
	    	/////////////////////////////////////////////////////////:
	    	
	    
	    	//ici=new Entite();
	    	
	    	
	    	
	    	
	    	lumieresVusParPerso.clear();
	    	lumieresVusParPerso.trimToSize(); 

	    	
	    	
	    	persoPt=new Point(leJeu.monde.perso.getCooX(),leJeu.monde.perso.getCooY()); //centre
	    	studyPt=new Point(leJeu.monde.perso.getCooX(),leJeu.monde.perso.getCooY());
	    	
	    	for(i=0;i<boundArray.size();i++){
	    		
	    		tabloPt=bresenham_line(persoPt,(Point)boundArray.get(i));
	    		
	    		
	    		clair=true;
	    		stair=false;
	    		
	    		
	    			
	    		for(b=0;b<tabloPt.length;b++){
	    			
	    			studyPt=tabloPt[b];
	    			
	    			
	    			/////////////////////////////////////////////////////
						
						if(clair){
							leJeu.monde.shadowGrid[(int)studyPt.getX()][(int)studyPt.getY()]=0;
						
						}
						
						
						stair=false;
						
						//parcours dans studyPt
						for(z=0;z<leJeu.monde.grille[(int)studyPt.getX()][(int)studyPt.getY()].size();z++){
							
							
							
				 			try{
				 					
				 				ici = (Entite) leJeu.monde.grille[(int)studyPt.getX()][(int)studyPt.getY()].get(z);
			 					
								
								if((ici.getClass().getName().compareTo("Gate")==0 || ici.getClass().getName().compareTo("Wall")==0) && !ici.getCasse() && !ici.getOuvert() && !ici.getTransparent()){
								
									clair=false;
									
									
								}
								
								if(ici.getVisible() && (ici.getModele().compareTo("trou")==0 || ici.getModele().compareTo("standardstairUP")==0 || ici.getModele().compareTo("standardstairDOWN")==0)){
					
									stair=true;
								}
								
								if(clair&&!lumieresVusParPerso.contains(ici)&&ici.getClass().getName().compareTo("Outil")==0 && ici.getAlume()){
									lumieresVusParPerso.add(ici);
								}
										
							}
							catch(NoSuchElementException exc){};
							
							
							
							
							
						}
						
						//////////////////////////////////
						//////////////MINIMAP/////////////
						///////////////////////////////////
						vx=Math.abs((int)studyPt.getX()-leJeu.monde.perso.getCooX());
						vy=Math.abs((int)studyPt.getY()-leJeu.monde.perso.getCooY());
						
						if(vx<vy){
							vmin=vy;
						}
						else{vmin=vx;
						}
						
						
						
						if(leJeu.monde.getNuit() || leJeu.monde.perso.indexTerrainZ>0){
							sight=leJeu.monde.perso.getVue()+1;
						}
						else{
							sight=10;
						}
						
						
						if(clair  && vmin<=sight && leJeu.monde.mapGrid[(int)studyPt.getX()][(int)studyPt.getY()]!=3){
						
							leJeu.monde.mapGrid[(int)studyPt.getX()][(int)studyPt.getY()]=0;
							
						}
						
						if(!clair  && vmin<=sight && leJeu.monde.mapGrid[(int)studyPt.getX()][(int)studyPt.getY()]!=3){
							if(leJeu.monde.mapGrid[(int)studyPt.getX()][(int)studyPt.getY()]!=0){
								leJeu.monde.mapGrid[(int)studyPt.getX()][(int)studyPt.getY()]=1;
							}
							
						}
						
						if(stair  && vmin<=sight && leJeu.monde.mapGrid[(int)studyPt.getX()][(int)studyPt.getY()]!=1){
							leJeu.monde.mapGrid[(int)studyPt.getX()][(int)studyPt.getY()]=3;
						}
						
						
						leJeu.monde.mapGrid[leJeu.monde.perso.getCooX()][leJeu.monde.perso.getCooY()]=2;
						////////////////////////////	
						///////////////////////////////////
	    				
	    				
	    				
	    		}
		    			
				
			}
	    	///////////////////////////////////:
	    	
	    }
	    catch(Exception e){e.printStackTrace();
	    }
	    		
    }
	
	
	
	
	
	
	
	
	
	
	
	
	
	
    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;
    }
    
	
}



//////////////////////////////TIR
class AnimThread extends Thread{
	
	TerrainPanel an;
	public AnimThread(TerrainPanel a){
		
		an=a;
	}
	
	
	public void run(){
		while(true){
			try{
				
				an.repaint();
			
			
			sleep(75);
			}catch(Exception ex){}
		}	
		
	}
		
	
}
//////////////////////////////TIR