import java.util.*;
import java.awt.*;

public class RoomAlea{

	private Entite objet=new Entite();
	private Entite objet2=new Entite();
	
	String tileMurStr=new String();
			
	public RoomAlea(Catalog cat,int porteCouloirInt,int xCouloir,int yCouloir,Monde monde,String modelWall,int coorX,int coorY,int etendueX,int etendueY){
		
		
		
		
		ArrayList grille[][]=monde.grille;
		ArrayList bestiaire=cat.bestiaire;
		ArrayList piegesCatalogue=cat.piegesCatalogue;
		ArrayList contenantsCatalogue=cat.contenantsCatalogue;
		ArrayList armesCatalogue=cat.armesCatalogue;
		ArrayList armuresCatalogue=cat.armuresCatalogue;
		ArrayList outilsCatalogue=cat.outilsCatalogue;
		ArrayList comestiblesCatalogue=cat.comestiblesCatalogue;
		
		ArrayList ecritMagiqueCatalogue=cat.ecritMagiqueCatalogue;
		ArrayList sortCatalogue=cat.sortCatalogue;
		
		
		Personnage perso=monde.perso;
		
		
		int indexTileMur=(int)((Math.abs(Math.random()*4))+1);
		String tileWall="./images/walls/randomizer/type"+new Integer(indexTileMur).toString()+"base.gif";
		
		tileMurStr=tileWall;
		
		String tileSol="./images/surfaces/f"+new Integer((int)(Math.abs(Math.random()*6))+1).toString()+".gif";
		
		
		ArrayList coordMurs1=new ArrayList();
		ArrayList coordMurs2=new ArrayList();
		ArrayList coordMurs3=new ArrayList();
		ArrayList coordMurs4=new ArrayList();
		
		ArrayList coordPortes=new ArrayList();
		
		
		int nbrObjets=0;
		
		boolean stairDown=false;
		
		
		
		
		//////////SOL//////////////////////////
		int cfX=coorX;
		int cfY=coorY;
		int coY=coorY;
		
		
		Surface sol=new Surface(true,tileSol,2,true);
		for(int x=0;x<=etendueX+1;x++){
			coY=cfY;
			for(int y=0;y<=etendueY+1;y++){
				
				destructeurMurs(cfX,coY,grille);
				grille[cfX][coY].add(sol);
				
				
				coY++;
					
			}
			cfX++;
		}
		//////////////////////////////////////////
		
		
		
		////////////////coins
		//coordMurs1  //coorX,coorY  et  coorX+etendueX+1,coorY
		//coordMurs4  //coorX+etendueX+1,coorY  et  coorX+etendueX+1,coorY+etendueY+1	
		//coordMurs3  //coorX+etendueX+1,coorY+etendueY+1 et coorX,coorY+etendueY+1
		//coordMurs2  //coorX,coorY+etendueY+1 et coorX,coorY	
		
		////////////////////MURS/////////////////
		
		
		///////////Deco mur nord///////////////////
		String murDecoTile=new String();
		
		int rdeco=0;
		
		
		int cX=coorX;
		int cY=coorY;
		for(int x=0;x<=etendueX;x++){
				destructeurMurs(cX,cY,grille);
				
				
				rdeco=((int)(Math.abs(Math.random()*100))+1);
		
				if(rdeco>15){
					murDecoTile=tileWall;
				}
				else if(rdeco>10 && rdeco<=15){
					murDecoTile="./images/walls/randomizer/type"+indexTileMur+"col.gif";
				}
				else if(rdeco>5 && rdeco<=10){
					murDecoTile="./images/walls/randomizer/type"+indexTileMur+"font.gif";
				}
				else{
					murDecoTile="./images/walls/randomizer/type"+indexTileMur+"arm.gif";
				}
				
				
				
				grille[cX][cY].add(new Wall(false,modelWall,"Un mur","A wall","Obstacle",true,murDecoTile,"./images/walls/rocks.gif"));
				
				if(cX!=coorX && cX!=coorX+etendueX+1) {
						
					String c=new String(new Integer(cX).toString()+"&"+new Integer(cY).toString());
					coordMurs1.add(c);
						
					
					
				
				}
				
				cX++;
		}
		
		cX=coorX;
		cY=coorY;
		for(int y=0;y<=etendueY;y++){
				destructeurMurs(cX,cY,grille);
				grille[cX][cY].add(new Wall(false,modelWall,"Un mur","A wall","Obstacle",true,tileWall,"./images/walls/rocks.gif"));
				
				if(cY!=coorY+etendueY+1 && cY!=coorY){
					String c=new String(new Integer(cX).toString()+"&"+new Integer(cY).toString());
					coordMurs4.add(c);
						
					//System.out.println("STOCK: "+cX+" "+cY);
					
				}
				
				
				cY++;
		}
		
		for(int x=0;x<=etendueX;x++){
				destructeurMurs(cX,cY,grille);
				grille[cX][cY].add(new Wall(false,modelWall,"Un mur","A wall","Obstacle",true,tileWall,"./images/walls/rocks.gif"));
				
				if(cX!=coorX+etendueX+1 && cX!=coorX){
					
					String c=new String(new Integer(cX).toString()+"&"+new Integer(cY).toString());
					coordMurs3.add(c);
						
					//System.out.println("STOCK: "+cX+" "+cY);
						
				}
				
				
				cX++;
		}
		
		
		for(int y=0;y<=etendueY+1;y++){
				destructeurMurs(cX,cY,grille);
				grille[cX][cY].add(new Wall(false,modelWall,"Un mur","A wall","Obstacle",true,tileWall,"./images/walls/rocks.gif"));
				
				if(cY!=coorY && cY!=coorY+etendueY+1){
					
					String c=new String(new Integer(cX).toString()+"&"+new Integer(cY).toString());
					coordMurs2.add(c);
						
					//System.out.println("STOCK: "+cX+" "+cY);
						
				}
				
				
				cY--;
		}
		//////////////////////////////////////////
		
		////test
		/*
		if(coordMurs1.size()==0){System.out.println("ALARM 1");
		}
		if(coordMurs2.size()==0){System.out.println("ALARM 2");
		}
		if(coordMurs3.size()==0){System.out.println("ALARM 3");
		}
		if(coordMurs4.size()==0){System.out.println("ALARM 4");
		}
		*/
		
		/////////PORTES//////////////////////
		
		/*
		for(int x=0;x<coordMurs1.size();x++){
			
			System.out.println((String) coordMurs1.get(x));
		}
		
		System.out.println("******************");
		for(int x=0;x<coordMurs2.size();x++){
			
			System.out.println((String) coordMurs2.get(x));
		}
		System.out.println("******************");
		for(int x=0;x<coordMurs3.size();x++){
			
			System.out.println((String) coordMurs3.get(x));
		}
		System.out.println("******************");
		for(int x=0;x<coordMurs4.size();x++){
			
			System.out.println((String) coordMurs4.get(x));
		}
		*/
		
		///////////////////////PORTES//////////////////////////////////
		
		//int nbrePortes=(int)(Math.abs(Math.random()*4))+1;
		
		int nbrePortes=(int)(Math.abs(Math.random()*6))+1;
		System.out.println("nbr portes "+nbrePortes);
		
		
		
		
		boolean estPlace1=false;
		boolean estPlace2=false;
		boolean estPlace3=false;
		boolean estPlace4=false;
		
		if(porteCouloirInt==1){estPlace1=true; 
		}
		
		if(porteCouloirInt==2){estPlace2=true; 
		}
		
		if(porteCouloirInt==3){estPlace3=true; 
		}
		
		if(porteCouloirInt==4){estPlace4=true; 
		}
		
		////on enleve le mur et la porte correspondant à l'acces du couloir
		if(porteCouloirInt==1 || porteCouloirInt==2 || porteCouloirInt==3 || porteCouloirInt==4){
		
			for(int i=0;i<grille[xCouloir][yCouloir].size();i++){	
				try{	
					objet = (Entite)grille[xCouloir][yCouloir].get(i);		
				
					if(objet.getTypeObjet().compareTo("Obstacle")==0 || objet.getClass().getName().compareTo("Gate")==0) {
						grille[xCouloir][yCouloir].remove(objet);
						
					}		
				}
				catch(NoSuchElementException exc){};
			}
			
			//on remet eventuellement une porte 
			if((int)(Math.abs(Math.random()*100))>50){
				boolean locked=false;
				if(((int)(Math.abs(Math.random()*100))+1)>65){
					locked=true;
				}
				
				boolean visible=false;
				if(((int)(Math.abs(Math.random()*100))+1)>25){
					visible=true;
				}
				
				grille[xCouloir][yCouloir].add(new Gate("Une porte","A door",locked,rDiff(monde),false,false,"standarddoor",visible,"./images/doors/randomizer/type"+new Integer(indexTileMur).toString()+"closed.gif","./images/doors/randomizer/type"+new Integer(indexTileMur).toString()+"open.gif",tileWall,"./sons/door_open.wav","./sons/door_close.wav"));

				
				
			}
			
			
			
		}
		
		
		
		
		
		
		
		
		
		for(int x=0;x<nbrePortes;x++){
			
			int surMur=(int)(Math.abs(Math.random()*4))+1;
			
			
			//if(surMur==1 && !estPlace1){
			if(surMur==1){	
				//coordMurs1
				int locMur=(int)(Math.abs(Math.random()*coordMurs1.size()));
				
				String[] tab=((String) coordMurs1.get(locMur)).split("&");
				
				System.out.println("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&");
				System.out.println(tab[0]);
				System.out.println(tab[1]);
				
				for(int i=0;i<grille[Integer.valueOf(tab[0]).intValue()][Integer.valueOf(tab[1]).intValue()].size();i++){
						
			 			try{	
			 				objet = (Entite) grille[Integer.valueOf(tab[0]).intValue()][Integer.valueOf(tab[1]).intValue()].get(i);		
							String typedelobjet=objet.getTypeObjet();
							
							if(typedelobjet.compareTo("Obstacle")==0){
								grille[Integer.valueOf(tab[0]).intValue()][Integer.valueOf(tab[1]).intValue()].remove(objet);
							
								boolean locked=false;
								if(((int)(Math.abs(Math.random()*100))+1)>65){
									locked=true;
								}
								
								
								boolean visible=false;
								if(((int)(Math.abs(Math.random()*100))+1)>25){
									visible=true;
								}
								
								
								
								
								
								grille[Integer.valueOf(tab[0]).intValue()][Integer.valueOf(tab[1]).intValue()].add(new Gate("Une porte","A door",locked,rDiff(monde),false,false,"standarddoor",visible,"./images/doors/randomizer/type"+new Integer(indexTileMur).toString()+"closed.gif","./images/doors/randomizer/type"+new Integer(indexTileMur).toString()+"open.gif",tileWall,"./sons/door_open.wav","./sons/door_close.wav"));
								coordPortes.add(new Point(Integer.valueOf(tab[0]).intValue(),Integer.valueOf(tab[1]).intValue()));
							
							}
									
		 				}
		 				catch(NoSuchElementException exc){};
		 				
		 				
		 			}
				
				estPlace1=true;
				
			}
			
			
			
			///////////////////////////////////
			//if(surMur==2 && !estPlace2){
			if(surMur==2){
				//coordMurs2
				int locMur=(int)(Math.abs(Math.random()*coordMurs2.size()));
				
				String[] tab=((String) coordMurs2.get(locMur)).split("&");
				
				System.out.println("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&");
				System.out.println(tab[0]);
				System.out.println(tab[1]);
				
				for(int i=0;i<grille[Integer.valueOf(tab[0]).intValue()][Integer.valueOf(tab[1]).intValue()].size();i++){
						
			 			try{	
			 				objet = (Entite) grille[Integer.valueOf(tab[0]).intValue()][Integer.valueOf(tab[1]).intValue()].get(i);		
							String typedelobjet=objet.getTypeObjet();
							
							if(typedelobjet.compareTo("Obstacle")==0){
								grille[Integer.valueOf(tab[0]).intValue()][Integer.valueOf(tab[1]).intValue()].remove(objet);
								
								boolean locked=false;
								if(((int)(Math.abs(Math.random()*100))+1)>65){
									locked=true;
								}
								
								
								boolean visible=false;
								if(((int)(Math.abs(Math.random()*100))+1)>25){
									visible=true;
								}
								
								grille[Integer.valueOf(tab[0]).intValue()][Integer.valueOf(tab[1]).intValue()].add(new Gate("Une porte","A door",locked,rDiff(monde),false,false,"standarddoor",visible,"./images/doors/randomizer/type"+new Integer(indexTileMur).toString()+"closed.gif","./images/doors/randomizer/type"+new Integer(indexTileMur).toString()+"open.gif",tileWall,"./sons/door_open.wav","./sons/door_close.wav"));
								coordPortes.add(new Point(Integer.valueOf(tab[0]).intValue(),Integer.valueOf(tab[1]).intValue()));
							}
									
		 				}
		 				catch(NoSuchElementException exc){};
		 				
		 				
		 		}
				estPlace2=true;
				
			}
			
			
			
			///////////////////////////////////
			//if(surMur==3 && !estPlace3){
			if(surMur==3){
				//coordMurs3
				int locMur=(int)(Math.abs(Math.random()*coordMurs3.size()));
				
				String[] tab=((String) coordMurs3.get(locMur)).split("&");
				
				System.out.println("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&");
				System.out.println(tab[0]);
				System.out.println(tab[1]);
				
				for(int i=0;i<grille[Integer.valueOf(tab[0]).intValue()][Integer.valueOf(tab[1]).intValue()].size();i++){
						
			 			try{	
			 				objet = (Entite) grille[Integer.valueOf(tab[0]).intValue()][Integer.valueOf(tab[1]).intValue()].get(i);		
							String typedelobjet=objet.getTypeObjet();
							
							if(typedelobjet.compareTo("Obstacle")==0){
								grille[Integer.valueOf(tab[0]).intValue()][Integer.valueOf(tab[1]).intValue()].remove(objet);
								
								boolean locked=false;
								if(((int)(Math.abs(Math.random()*100))+1)>65){
									locked=true;
								}
								
								
								boolean visible=false;
								if(((int)(Math.abs(Math.random()*100))+1)>25){
									visible=true;
								}
								
								grille[Integer.valueOf(tab[0]).intValue()][Integer.valueOf(tab[1]).intValue()].add(new Gate("Une porte","A door",locked,rDiff(monde),false,false,"standarddoor",visible,"./images/doors/randomizer/type"+new Integer(indexTileMur).toString()+"closed.gif","./images/doors/randomizer/type"+new Integer(indexTileMur).toString()+"open.gif",tileWall,"./sons/door_open.wav","./sons/door_close.wav"));
								coordPortes.add(new Point(Integer.valueOf(tab[0]).intValue(),Integer.valueOf(tab[1]).intValue()));
							}
									
		 				}
		 				catch(NoSuchElementException exc){};
		 				
		 				
		 			}
				estPlace3=true;
				
			}
			
			
			
			///////////////////////////////////	
			//if(surMur==4 && !estPlace4){
			if(surMur==4){
				//coordMurs4
				int locMur=(int)(Math.abs(Math.random()*coordMurs4.size()));
				
				String[] tab=((String) coordMurs4.get(locMur)).split("&");
				
				System.out.println("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&");
				System.out.println(tab[0]);
				System.out.println(tab[1]);
				
				for(int i=0;i<grille[Integer.valueOf(tab[0]).intValue()][Integer.valueOf(tab[1]).intValue()].size();i++){
						
			 			try{	
			 				objet = (Entite) grille[Integer.valueOf(tab[0]).intValue()][Integer.valueOf(tab[1]).intValue()].get(i);		
							String typedelobjet=objet.getTypeObjet();
							
							if(typedelobjet.compareTo("Obstacle")==0){
								grille[Integer.valueOf(tab[0]).intValue()][Integer.valueOf(tab[1]).intValue()].remove(objet);
								
								boolean locked=false;
								if(((int)(Math.abs(Math.random()*100))+1)>65){
									locked=true;
								}
								
								
								boolean visible=false;
								if(((int)(Math.abs(Math.random()*100))+1)>25){
									visible=true;
								}
								
								grille[Integer.valueOf(tab[0]).intValue()][Integer.valueOf(tab[1]).intValue()].add(new Gate("Une porte","A door",locked,rDiff(monde),false,false,"standarddoor",visible,"./images/doors/randomizer/type"+new Integer(indexTileMur).toString()+"closed.gif","./images/doors/randomizer/type"+new Integer(indexTileMur).toString()+"open.gif",tileWall,"./sons/door_open.wav","./sons/door_close.wav"));
								coordPortes.add(new Point(Integer.valueOf(tab[0]).intValue(),Integer.valueOf(tab[1]).intValue()));
							}
									
		 				}
		 				catch(NoSuchElementException exc){};
		 				
		 				
		 			}
				estPlace4=true;
				
			}
		}
		
		
		
		
		
		
		//////pieges///////////////
		
		//un piege dans la piece ?
		//int jet=(int)(Math.abs(Math.random()*2)); //0 1
		
		
		if((int)(Math.abs(Math.random()*100)+1)>65){
			nbrObjets=(int)(Math.abs(Math.random()*3));
		
			while(nbrObjets!=0){
			
				int xp=(int)(Math.abs(Math.random()*etendueX)+1);
				int yp=(int)(Math.abs(Math.random()*etendueY)+1);
				cfX=coorX+1;
				cfY=coorY+1;
				coY=coorY+1;
				
				
				objet= (Entite) piegesCatalogue.get((int)(Math.abs(Math.random()*piegesCatalogue.size())));
				
				grille[coorX+xp][coorY+yp].add(new Piege(monde,true,0,0,true,0,false,objet.getModele(),objet.getNom(),objet.getNomE(),"Piege",false,objet.getTileStr(),objet.getSonActivation()));
				
				System.out.println(objet.getModele()+" en "+(coorX+xp)+" "+(coorY+yp));
				
				nbrObjets--;
			}
			
		}
		
		
		//////////escalier down///////
	
		if((int)(Math.abs(Math.random()*100)+1)>60 && !stairDown){
			
			int xp=(int)(Math.abs(Math.random()*etendueX)+1);
			int yp=(int)(Math.abs(Math.random()*etendueY)+1);
			cfX=coorX+1;
			cfY=coorY+1;
			coY=coorY+1;
			
			if(!chercheEntiteBool("Piege",coorX+xp,coorY+yp,grille) && !chercheEntiteBool("Escalier",coorX+xp,coorY+yp,grille)){
				
				if(((int)(Math.random()*100)+1)%2==0){
				
					grille[coorX+xp][coorY+yp].add(new Escalier(false,"standardstairDOWN","Un escalier vers le bas","Down Stair","Escalier",true,"./images/escaliers/escalierdown.gif"));
					System.out.println("****************Escalier down en "+(coorX+xp)+" "+(coorY+yp));
				}
				else{
				
				/////////TEST***************!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
					grille[coorX+xp][coorY+yp].add(new Escalier(false,"standardstairUP","Un escalier vers le haut","Up stair","Escalier",true,"./images/escaliers/escalierup.gif"));
					System.out.println("****************Escalier up en "+(coorX+xp)+" "+(coorY+yp));
				
				}
		
				
			
				stairDown=true;
			}
			
		}
		
		
		
		
		
		
		
		////////objets///////////////
		
		//mobilier & contenants
		if((int)(Math.abs(Math.random()*100)+1)>75){
			nbrObjets=(int)(Math.abs(Math.random()*3));
		
			while(nbrObjets!=0){
			
				int xp=(int)(Math.abs(Math.random()*etendueX)+1);
				int yp=(int)(Math.abs(Math.random()*etendueY)+1);
				cfX=coorX+1;
				cfY=coorY+1;
				coY=coorY+1;
				
				objet= (Entite) contenantsCatalogue.get((int)(Math.abs(Math.random()*contenantsCatalogue.size())));
				
				grille[coorX+xp][coorY+yp].add(new Contenant(cat,monde,true,true,false,0,false,false,objet.getModele(),objet.getNom(),objet.getNomE(),true,objet.getTileFerme(),objet.getTileOuvert(),objet.getSonOuverture(),objet.getSonFermeture()));			

				System.out.println(objet.getNom()+" en "+(coorX+xp)+" "+(coorY+yp));
				
				nbrObjets--;
			}
			
			
		}
		
		
		
		//ecritMagiqueCatalogue sortCatalogue
		if((int)(Math.abs(Math.random()*100)+1)>90){
			nbrObjets=(int)(Math.abs(Math.random()*2));
			String tileStr=new String();
			while(nbrObjets!=0){
			
				int xp=(int)(Math.abs(Math.random()*etendueX)+1);
				int yp=(int)(Math.abs(Math.random()*etendueY)+1);
				cfX=coorX+1;
				cfY=coorY+1;
				coY=coorY+1;
				
				objet= (Entite) ecritMagiqueCatalogue.get((int)(Math.abs(Math.random()*ecritMagiqueCatalogue.size())));
				objet2= (Entite) sortCatalogue.get((int)(Math.abs(Math.random()*sortCatalogue.size())));
				
				if(objet.getModele().compareTo("magicscroll")==0){
					tileStr="./images/ecritsmagiques/scroll"+new Integer((int)(Math.abs(Math.random()*2))+1).toString()+".gif";
				}
				else{
					tileStr="./images/ecritsmagiques/grim"+new Integer((int)(Math.abs(Math.random()*30))+1).toString()+".gif";
				}
				
				grille[coorX+xp][coorY+yp].add(new EcritMagique(coorX+xp,coorY+yp,false,objet.getModele(),objet.getNom(),objet.getNomE(),"EcritMagique",true,tileStr,(Spell)objet2));			

				System.out.println(objet.getNom()+" en "+(coorX+xp)+" "+(coorY+yp));
				
				nbrObjets--;
			}
			
			
		}
		
		
		
		
		//armes
		if((int)(Math.abs(Math.random()*100)+1)>80){
			nbrObjets=(int)(Math.abs(Math.random()*3));
		
			while(nbrObjets!=0){
			
				int xp=(int)(Math.abs(Math.random()*etendueX)+1);
				int yp=(int)(Math.abs(Math.random()*etendueY)+1);
				cfX=coorX+1;
				cfY=coorY+1;
				coY=coorY+1;
				
				
				objet= (Entite) armesCatalogue.get((int)(Math.abs(Math.random()*armesCatalogue.size())));
				
				
				
				//int bonusM=(int)(Math.abs(Math.random()*(perso.getNiveau()*10))-(perso.getNiveau()*5));
				
				int bonusM=rBonus(monde);
				
				if(bonusM<0){bonusM=0;
				}
				
				grille[coorX+xp][coorY+yp].add(new Arme(false,objet.getModele(),objet.getNom(),objet.getNomE(),bonusM,"Objet",true,objet.getTileStr()));
			
				
				System.out.println(objet.getModele()+" en "+(coorX+xp)+" "+(coorY+yp));
				
				nbrObjets--;
			}
			
			
		}
		
		
		
		
		
		//armures
		if((int)(Math.abs(Math.random()*100)+1)>95){
			nbrObjets=(int)(Math.abs(Math.random()*3));
		
			while(nbrObjets!=0){
			
				int xp=(int)(Math.abs(Math.random()*etendueX)+1);
				int yp=(int)(Math.abs(Math.random()*etendueY)+1);
				cfX=coorX+1;
				cfY=coorY+1;
				coY=coorY+1;
				
				
				objet= (Entite) armuresCatalogue.get((int)(Math.abs(Math.random()*armuresCatalogue.size())));
				
				//int bonusM=(int)(Math.abs(Math.random()*(perso.getNiveau()*10))-(perso.getNiveau()*5));
				int bonusM=rBonus(monde);
				
				if(bonusM<0){bonusM=0;
				}
												
				grille[coorX+xp][coorY+yp].add(new Armure(false,objet.getModele(),objet.getNom(),objet.getNomE(),bonusM,"Objet",true,objet.getTileStr()));
			
				
				System.out.println(objet.getModele()+" en "+(coorX+xp)+" "+(coorY+yp));
				
				nbrObjets--;
			}
			
			
		}
		
		
		//outils
		if((int)(Math.abs(Math.random()*100)+1)>75){
			nbrObjets=(int)(Math.abs(Math.random()*3));
		
			while(nbrObjets!=0){
			
				int xp=(int)(Math.abs(Math.random()*etendueX)+1);
				int yp=(int)(Math.abs(Math.random()*etendueY)+1);
				cfX=coorX+1;
				cfY=coorY+1;
				coY=coorY+1;
				
				
				objet= (Entite) outilsCatalogue.get((int)(Math.abs(Math.random()*outilsCatalogue.size())));
				
				//int bonusM=(int)(Math.abs(Math.random()*(perso.getNiveau()*10))-(perso.getNiveau()*5));
				int bonusM=rBonus(monde);
				
				if(bonusM<0){bonusM=0;
				}
				
				
				Outil outil=new Outil(false,objet.getModele(),objet.getNom(),objet.getNomE(),bonusM,"Objet",true,objet.getTileStr());
				
				
				if(objet.getPeutEclairer()){
					
					if((int)(Math.abs(Math.random()*2))>0){
						outil.setAlume(true);
						//outil.setNomDequipement("@"+outil.getNomDequipement());
					}
					
				}
												
				grille[coorX+xp][coorY+yp].add(outil);
				
				
				
				System.out.println(objet.getModele()+" en "+(coorX+xp)+" "+(coorY+yp));
				
				nbrObjets--;
			}
			
			
		}
		
		
		
		
		
		
		
		
		
		//potions
		//comestibles
		
		if((int)(Math.abs(Math.random()*100)+1)>60){
			nbrObjets=(int)(Math.abs(Math.random()*3));
			String tileStr=new String();
			while(nbrObjets!=0){
			
				int xp=(int)(Math.abs(Math.random()*etendueX)+1);
				int yp=(int)(Math.abs(Math.random()*etendueY)+1);
				cfX=coorX+1;
				cfY=coorY+1;
				coY=coorY+1;
				
				
				objet= (Entite) comestiblesCatalogue.get((int)(Math.abs(Math.random()*comestiblesCatalogue.size())));
				
				
				if((objet.getClass().getName()).compareTo("Nourriture")==0){
				
					if(objet.getNom().compareTo("champignon")==0){
						tileStr="./images/comestible/champi"+new Integer((int)(Math.abs(Math.random()*5))+1).toString()+".gif";
					}
					
					if(objet.getNom().compareTo("ration")==0){
						tileStr="./images/comestible/ration"+new Integer((int)(Math.abs(Math.random()*3))+1).toString()+".gif";
					}
					
					if(objet.getNom().compareTo("potiron")==0){
						tileStr="./images/comestible/potiron.gif";
					}
					
					grille[coorX+xp][coorY+yp].add(new Nourriture(false,objet.getModele(),objet.getNom(),objet.getNomE(),"Comestible",true,tileStr));
				}
				
				
				
				if((objet.getClass().getName()).compareTo("Boisson")==0){
					
					tileStr="./images/comestible/potion"+new Integer((int)(Math.abs(Math.random()*4))+1).toString()+".gif";
					
					if(objet.getModele().compareTo("fountain")==0){
						tileStr="./images/comestible/fountain.gif";
					}
				
					grille[coorX+xp][coorY+yp].add(new Boisson(false,objet.getModele(),objet.getNom(),objet.getNomE(),"Comestible",true,tileStr));
				}
				
				
				
				System.out.println(objet.getModele()+" en "+(coorX+xp)+" "+(coorY+yp));
				
				nbrObjets--;
			}
			
			
		}
		
		
		
		
		
		//ecrits
		
		
		
		//obstacles décoratifs bloquants (arbres, etc)
		
		
		
		//décoratifs non bloquants
		
		
		
	
		//baguettes
		
		//parchemins magiques
		
		
		//grimoires
		
		
		//amulettes, casques, capes, bottes, anneaux, argent, outils divers, etc...
		
		
		
		
		
		////////creatures////////////
		int typeMonstre=0;
		
		
		if((int)(Math.abs(Math.random()*100)+1)>50){ //il y a t'il des creatures ?
			nbrObjets=(int)(Math.abs(Math.random()*4)+1); //combien en y a t'il ?
		
			while(nbrObjets!=0){
			
				int xp=(int)(Math.abs(Math.random()*etendueX)+1); // a quel endroit ?
				int yp=(int)(Math.abs(Math.random()*etendueY)+1);
				cfX=coorX+1;
				cfY=coorY+1;
				coY=coorY+1;
				
				boolean p=false;;
				
				
				
				ArrayList selection=new ArrayList();
				
				for(int x=0;x<bestiaire.size()&&!p;x++){
					
					 objet= (Entite) bestiaire.get(x);
					 if(objet.getNiveau()<=perso.getNiveau()+5 && objet.getNiveau()>perso.getNiveau()-5){
					 	selection.add(objet);
					 }
				}
				
				
				objet= (Entite) selection.get((int)(Math.abs(Math.random()*selection.size())));
				
				if((objet.getClass().getName()).compareTo("UndeadCategory")==0){
					
						UndeadCategory creature=new UndeadCategory(false,objet.getEspece(),objet.getNom(),objet.getNomE(),true,"Creature",true,objet.getTileStrVivant(),objet.getTileStrMort(),objet.getCri());
						creature.setCooX(coorX+xp);
						creature.setCooY(coorY+yp);
						grille[coorX+xp][coorY+yp].add(creature);
						System.out.println(objet.getHostilite()+"Class "+objet.getClass().getName()+" Model "+objet.getEspece()+" Niveau "+objet.getNiveau()+" en "+(coorX+xp)+" / "+(coorY+yp));
						p=true;
					
					
					
				}
				
				if((objet.getClass().getName()).compareTo("GoblinoidCategory")==0){
					
						
						GoblinoidCategory creature=new GoblinoidCategory(false,objet.getEspece(),objet.getNom(),objet.getNomE(),true,"Creature",true,objet.getTileStrVivant(),objet.getTileStrMort(),objet.getCri());
						creature.setCooX(coorX+xp);
						creature.setCooY(coorY+yp);
						grille[coorX+xp][coorY+yp].add(creature);
						System.out.println(objet.getHostilite()+" Class "+objet.getClass().getName()+" Model "+objet.getEspece()+" Niveau "+objet.getNiveau()+" en "+(coorX+xp)+" / "+(coorY+yp));
						p=true;
					
					
				}
				
				
				if((objet.getClass().getName()).compareTo("CritterCategory")==0){
					
						
						CritterCategory creature=new CritterCategory(false,objet.getEspece(),objet.getNom(),objet.getNomE(),true,"Creature",true,objet.getTileStrVivant(),objet.getTileStrMort(),objet.getCri());
						creature.setCooX(coorX+xp);
						creature.setCooY(coorY+yp);
						grille[coorX+xp][coorY+yp].add(creature);
						System.out.println(objet.getHostilite()+" Class "+objet.getClass().getName()+" Model "+objet.getEspece()+" Niveau "+objet.getNiveau()+" en "+(coorX+xp)+" / "+(coorY+yp));
						p=true;
					
					
				}
				
				if((objet.getClass().getName()).compareTo("DragonCategory")==0){
					
						
						DragonCategory creature=new DragonCategory(false,objet.getEspece(),objet.getNom(),objet.getNomE(),true,"Creature",true,objet.getTileStrVivant(),objet.getTileStrMort(),objet.getCri());
						creature.setCooX(coorX+xp);
						creature.setCooY(coorY+yp);
						grille[coorX+xp][coorY+yp].add(creature);
						System.out.println(objet.getHostilite()+" Class "+objet.getClass().getName()+" Model "+objet.getEspece()+" Niveau "+objet.getNiveau()+" en "+(coorX+xp)+" / "+(coorY+yp));
						p=true;
					
					
				}
				
				
				
				if((objet.getClass().getName()).compareTo("AnimalCategory")==0){
					
						
						AnimalCategory creature=new AnimalCategory(false,objet.getEspece(),objet.getNom(),objet.getNomE(),true,"Creature",true,objet.getTileStrVivant(),objet.getTileStrMort(),objet.getCri());
						creature.setCooX(coorX+xp);
						creature.setCooY(coorY+yp);
						grille[coorX+xp][coorY+yp].add(creature);
						System.out.println(objet.getHostilite()+" Class "+objet.getClass().getName()+" Model "+objet.getEspece()+" Niveau "+objet.getNiveau()+" en "+(coorX+xp)+" / "+(coorY+yp));
						p=true;
					
					
				}
				
				
				if((objet.getClass().getName()).compareTo("CthulianCategory")==0){
					
						
						CthulianCategory creature=new CthulianCategory(false,objet.getEspece(),objet.getNom(),objet.getNomE(),true,"Creature",true,objet.getTileStrVivant(),objet.getTileStrMort(),objet.getCri());
						creature.setCooX(coorX+xp);
						creature.setCooY(coorY+yp);
						grille[coorX+xp][coorY+yp].add(creature);
						System.out.println(objet.getHostilite()+" Class "+objet.getClass().getName()+" Model "+objet.getEspece()+" Niveau "+objet.getNiveau()+" en "+(coorX+xp)+" / "+(coorY+yp));
						p=true;
					
					
				}
				
				if((objet.getClass().getName()).compareTo("DemonCategory")==0){
					
						
						DemonCategory creature=new DemonCategory(false,objet.getEspece(),objet.getNom(),objet.getNomE(),true,"Creature",true,objet.getTileStrVivant(),objet.getTileStrMort(),objet.getCri());
						creature.setCooX(coorX+xp);
						creature.setCooY(coorY+yp);
						grille[coorX+xp][coorY+yp].add(creature);
						System.out.println(objet.getHostilite()+" Class "+objet.getClass().getName()+" Model "+objet.getEspece()+" Niveau "+objet.getNiveau()+" en "+(coorX+xp)+" / "+(coorY+yp));
						p=true;
					
					
				}
				
				if((objet.getClass().getName()).compareTo("ElementalCategory")==0){
					
						
						ElementalCategory creature=new ElementalCategory(false,objet.getEspece(),objet.getNom(),objet.getNomE(),true,"Creature",true,objet.getTileStrVivant(),objet.getTileStrMort(),objet.getCri());
						creature.setCooX(coorX+xp);
						creature.setCooY(coorY+yp);
						grille[coorX+xp][coorY+yp].add(creature);
						System.out.println(objet.getHostilite()+" Class "+objet.getClass().getName()+" Model "+objet.getEspece()+" Niveau "+objet.getNiveau()+" en "+(coorX+xp)+" / "+(coorY+yp));
						p=true;
					
					
				}
				
				
					
				
				nbrObjets--;
			}
			
			
		}
		
		
		
		
		
		
		
		
		
		
		
		
		
	//////////COULOIRS//////////////C'est ici que l'on verifie s'il y a la place pour en mettre un
	/////////////////////////////////////
		
		boolean couloirPossible=true;
		
		if(coordPortes.size()>0){
			
			
			for(int x=0;x<coordPortes.size();x++){
			
				couloirPossible=true;
				
				Point insertPt=(Point)coordPortes.get(x);
				int insertX=(int)insertPt.getX();
				int insertY=(int)insertPt.getY();
				
				
				
				int range=(int)(Math.abs(Math.random()*8)+3);
				
				//for(int rx=10;rx<tailleGrille-10;rx++){
					
						
				if(insertX==coorX+etendueX+1){//EST
					
					int distanceAuBord=(monde.tailleGrille-11)-insertX;
					
					if(distanceAuBord>range){
						if(!chercheObstacle(insertX,insertY,2,range,3,grille)){
						
							new Couloir(cat,monde,tileWall,indexTileMur,tileSol,insertPt,2,range);  
						}
						else{
							couloirPossible=false;
						}
					}
					else{
						couloirPossible=false;
					}
				}
				
				
						
				else if(insertY==coorY+etendueY+1){//SUD
					
					int distanceAuBord=(monde.tailleGrille-11)-insertY;
					
					if(distanceAuBord>range){
						if(!chercheObstacle(insertX,insertY,3,3,range,grille)){
						
							new Couloir(cat,monde,tileWall,indexTileMur,tileSol,insertPt,3,range);
						}
						else{
							couloirPossible=false;
						}
					}
					else{
						couloirPossible=false;
					}
						
				}
						
					
					
					
				else if(insertY==coorY && insertX!=coorX){ // 1 NORD
						
					int distanceAuBord=insertY-11;
					
					if(distanceAuBord>range){
						if(!chercheObstacle(insertX,insertY,1,3,range,grille)){
						
							new Couloir(cat,monde,tileWall,indexTileMur,tileSol,insertPt,1,range);
						}
						else{
							couloirPossible=false;
						}
					}
					else{
						couloirPossible=false;
					}
						
				}
						
						
						
						
				else if(insertX==coorX && insertY!=coorY){ // 4 //OUEST
					
					int distanceAuBord=insertX-11;
					
					if(distanceAuBord>range){
						if(!chercheObstacle(insertX,insertY,4,range,3,grille)){
						
							new Couloir(cat,monde,tileWall,indexTileMur,tileSol,insertPt,4,range);
						}
						else{
							couloirPossible=false;
						}
						
						
					}
					else{
						couloirPossible=false;
					}	
						
						
				}
				
				if(!couloirPossible){
					destructeurPorteCreateurMur(insertX,insertY,grille);	
				}
					
			}
		}
		
		
	/////////////////////////////////////	
		
	}
	
	
	
	
	
	public boolean chercheObstacle(int ox,int oy,int direction,int rangeX,int rangeY,ArrayList grille[][]){
		boolean p=false;
		
		
		if(direction==1){
			//int x=ox;
			for(int x=ox-rangeX+2;x<ox+rangeX-1;x++){
				for(int y=oy-rangeY;y<oy;y++){
					for(int i=0;i<grille[x][y].size();i++){	
					try{	
						objet = (Entite)grille[x][y].get(i);		
						
						
						if(objet.getClass().getName().compareTo("Surface")==0) {
							p=true;
						}
						
								
					}
					catch(NoSuchElementException exc){};
					}
				}
			}
		}	
			
		if(direction==2){
			//int y=oy;
			for(int x=ox+1;x<ox+rangeX+1;x++){
				for(int y=oy-rangeY+2;y<oy+rangeY-1;y++){
					for(int i=0;i<grille[x][y].size();i++){	
					try{	
						objet = (Entite)grille[x][y].get(i);		
						
						if(objet.getClass().getName().compareTo("Surface")==0) {
							
							p=true;
						}		
					}
					catch(NoSuchElementException exc){};
					}
				}
			}
		}
		
		if(direction==3){
			//int x=ox;
			for(int x=ox-1;x<ox+rangeX-1;x++){
				for(int y=oy+1;y<oy+rangeY+1;y++){
					for(int i=0;i<grille[x][y].size();i++){	
					try{	
						objet = (Entite)grille[x][y].get(i);		
						
						if(objet.getClass().getName().compareTo("Surface")==0) {
							
							p=true;
						}		
					}
					catch(NoSuchElementException exc){};
					}
					
				}
			}
		}
		
		if(direction==4){
			//int y=oy;
			for(int x=ox-rangeX;x<ox;x++){
				for(int y=oy-rangeY+2;y<oy+rangeY-1;y++){
					for(int i=0;i<grille[x][y].size();i++){	
					try{	
						objet = (Entite)grille[x][y].get(i);		
						//System.out.println("analyse en "+x+" "+y+" rangeX "+rangeX+" rangeY "+rangeY);
						
						
						if(objet.getClass().getName().compareTo("Surface")==0) {
							//System.out.println("surface en "+x+" "+y+" rangeX "+rangeX+" rangeY "+rangeY);
							
							p=true;
						}		
					}
					catch(NoSuchElementException exc){};
					}
				}
			}
		}
		
		return p;	
	}
	
	
	
	
	
	public void destructeurMurs(int x,int y,ArrayList grille[][]){
			
		
		
		for(int i=0;i<grille[x][y].size();i++){	
			try{	
				objet = (Entite)grille[x][y].get(i);		
			
				if(objet.getTypeObjet().compareTo("Obstacle")==0) {
					grille[x][y].remove(objet);
					
				}		
			}
			catch(NoSuchElementException exc){};
		}
		
	}
	
	
	
	
	
	
	
	public void destructeurPorteCreateurMur(int x,int y,ArrayList grille[][]){
		for(int i=0;i<grille[x][y].size();i++){	
			try{	
				objet = (Entite)grille[x][y].get(i);		
			
				if(objet.getClass().getName().compareTo("Gate")==0) {
					grille[x][y].remove(objet);
					grille[x][y].add(new Wall(false,"standardwall","Un mur","A wall","Obstacle",true,tileMurStr,"./images/walls/rocks.gif"));
					
					//version test avec tile pourrie
					//grille[x][y].add(new Wall(false,"standardwall","Un mur","A wall","Obstacle",true,"./images/walls/w7.gif"));
					
				}		
			}
			catch(NoSuchElementException exc){};
		}
		
	}
	
	
	
	
	//////////////////////////////////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////
	//////OUTIL DE RECHERCHE GENERIQUE D'ENTITES avec retour booleen//////////
	//////////////////////////////////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////
	public boolean chercheEntiteBool(String genre,int x,int y,ArrayList grille[][]){
		if(!grille[x][y].isEmpty()){
			for(int i=0;i<grille[x][y].size();i++){
	 			try{	
	 				objet = (Entite)grille[x][y].get(i);
					String typedelobjet=objet.getTypeObjet();
					String strClass = (objet.getClass().getName());
					String strModele= objet.getModele();
					if(typedelobjet.compareTo(genre)==0 || strClass.compareTo(genre)==0 || strModele.compareTo(genre)==0){
						return true;
					}
				}
				catch(NoSuchElementException exc){};
			}
		}
		return false;
	}
	
	
	//////////////////////////////////////////////////////////////////////////
	//DIFFICULTES = (int)(Math.random()*monde.ipp()*20)+1
	//BONUS = (int)(Math.random()*(monde.ipp()-3))+1
	
	public int rDiff(Monde monde){
		
		return (int)(Math.random()*monde.ipp()*20)+1;
		
	}
	
	public int rBonus(Monde monde){
		return (int)(Math.random()*(monde.ipp()-3))+1;
	}
	
}