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

public class Personnage extends Entite{
	
	//boolean dansLeVide=false;
	
	String typedelobjet=new String();
	String missString=new String();
	String strClass =new String();
	String strModele=new String();
	
	
	
	boolean open=false;
	
	private Entite objet=new Entite();
	//private Entite objetPJ=new Entite();
	private Entite objetAuSol=new Entite();	
	private Entite objetCible=new Entite();	
	
	private int niveau=1;
	private int xp=0;
	private int xpNiveauSuivant=0;
	private int xpNiveauCourant=0;
	
	private String pas1=new String("./sons/step1.wav");
	private String pas2=new String("./sons/step2.wav");
	
	int indexTerrainX=0;
	int indexTerrainY=0;
	int indexTerrainZ=0;
	
	
	Monde monde;
	private String nom=new String();
	
	private boolean mort=false;
	
	private String typeObjet=new String("PJ");
	private boolean visible=true;
	private String tileStr=new String();
	private int coordX=0;
	private int coordY=0;
	
	private int vueInitiale=0; // vue non modifiée
	private int vue=0; //vue modifiée
	
	
	//Point targetPoint=new Point(0,0);
	private String ordreString=new String("");
	

	private int rapidite=1;
	private int compteurRapidite=1;
	
	
	private boolean marqueurSonPas=true;
	
	////STATS//////////
	private int force=0;
	private int dexterite=0;
	private int intelligence=0;
	private int constitution=0;
	////////////////////
	
	/////SKILLS/////////
	int perception=0;
	int discretion=0;
	int melee=0;
	int distance=0;
	int magie=0;
	int attunement=0;
	int crocheter=0;
	int pieges=0;
	int identification=0;
	int baratin=0;
	////////////////////
	int perceptionLvl=0;
	int discretionLvl=0;
	int meleeLvl=0;
	int distanceLvl=0;
	int magieLvl=0;
	int attunementLvl=0;
	int crocheterLvl=0;
	int piegesLvl=0;
	int identificationLvl=0;
	int baratinLvl=0;
	
	
	
	
	
	///////STATS SECONDAIRES///////
	private int baseAtk=0;
	private int atkModifiee=0;
	private int baseDef=0;
	private int defModifiee=0;
	private int maxHitPoints=0;
	private int currentHitPoints=0;
	
	
	int maxPower=0;
	int currentPower=0;
	
	
	private int bonusAtkArme=0;
	private int bonusDefArmure=0;
	
	
	private int encCapacity=0;
	private int encombrement=0;
	
	private int parade=0;
	
	private int faim=0;
	
	Vector equipementVect=new Vector(); // les objets réels de l'équipement
	//Vector equipementVectNOMS=new Vector(); // les noms des objets, pour l'affichage dans l'equipement
	
	
	
	
	
	/////////MEMOIRES////////////////////
	//Sorts Connus
	private Vector memSorts=new Vector();
	
							
		
	
	
		
	///////COMPTEURS DUREES EFFETS///////////////
	
	private int dureeEffetSlow=0;
	private int dureeEffetSpeed=0;
	private int dureeEffetInvisibility=0;
	private int dureeEffetPasseMuraille=0;
	private int dureeEffetNightVision=0;
	private int dureeEffetRayonX=0;
	private int dureeEffetVolant=0;
	
	/////////ETATS//////////////////////////////
	
	private boolean invisible=false;
	private boolean passemuraille=false;
	private boolean volant=false; ///////////////////
	private boolean nightvision=false;
	private boolean rayonX=false;
	
	// LIMITES D'OBJET EQUIPES/////////////////////////////////
	
	private boolean uneArmeEnMain=false;
	private boolean uneArmurePortee=false;
	private boolean unCollierPorte=false;
	private boolean unePaireDeBottes=false;
	private int anneauxPortes=0;
	private boolean deuxAnneauxPortes=false;
	private boolean unePaireDeGants=false;
	private boolean uneCape=false;
	
	
	
	///////////////////////////////////////////////////////////
	private Entite arme=new Entite();
	private Entite armure=new Entite();
	
	
	
	
	private int dommageEquip=0;
	
	
	
	
	
	boolean estDehors=true;
	
	
	private boolean stealthmode=false;
	
	
	
	private boolean estEclaireParCeQuilPorte=false;
	private boolean estEclaireParObjetProche=false;
	
	
	/////////////////////
	public void setEstEclaireParCeQuilPorte(boolean pcp){
		estEclaireParCeQuilPorte=pcp;
	}
	public boolean getEstEclaireParCeQuilPorte(){
		return estEclaireParCeQuilPorte;
	}
	/////
	public void setEstEclaireParObjetProche(boolean pop){
		estEclaireParObjetProche=pop;
	}
	public boolean getEstEclaireParObjetProche(){
		return estEclaireParObjetProche;
	}
	
	
	//////////////////////
	





	public Personnage(Monde world,String imagePerso,String nomPerso,int fo,int dx,int co,int intel, int perLvl, int disLvl, int melLvl, int distLvl, int magLvl,int attuLvl, int crocLvl,int piegLvl,int identLvl,int barLvl){
		
		monde=world;
		tileStr=imagePerso;
		nom=nomPerso;
		
		force=fo;
		dexterite=dx;
		constitution=co;
		intelligence=intel;
		
		
		//baseAtk=(force+dexterite)/2;
		//atkModifiee=baseAtk;
		
		baseDef=dexterite;
		defModifiee=baseDef;
		
		maxHitPoints=constitution*20;
		currentHitPoints=maxHitPoints;
		
		encCapacity=force*10;
		
		/*
		perception=(int)(((perLvl/10)+0.5)*intelligence);
		discretion=(int)(((disLvl/10)+0.5)*dexterite);
		melee=(int)(((melLvl/10)+0.5)*dexterite);
		distance=(int)(((distLvl/10)+0.5)*dexterite);
		magie=(int)(((magLvl/10)+0.5)*intelligence);
		attunement=(int)(((attuLvl/10)+0.5)*intelligence);
		crocheter=(int)(((crocLvl/10)+0.5)*dexterite);
		pieges=(int)(((piegLvl/10)+0.5)*dexterite);
		identification=(int)(((identLvl/10)+0.5)*intelligence);
		baratin=(int)(((barLvl/10)+0.5)*intelligence);
		*/
		perception=(int)Math.round((perLvl+intelligence)/2);
		discretion=(int)Math.round((disLvl+dexterite)/2);
		melee=(int)Math.round((melLvl+dexterite+force)/3);
		distance=(int)Math.round((distLvl+dexterite)/2);
		magie=(int)Math.round((magLvl+intelligence)/2);
		attunement=(int)Math.round((attuLvl+intelligence)/2);
		crocheter=(int)Math.round((crocLvl+dexterite)/2);
		pieges=(int)Math.round((piegLvl+dexterite)/2);
		identification=(int)Math.round((identLvl+intelligence)/2);
		baratin=(int)Math.round((barLvl+intelligence)/2);
		
		
		perceptionLvl=perLvl;
		discretionLvl=disLvl;
		meleeLvl=melLvl;
		distanceLvl=distLvl;
		magieLvl=magLvl;
		attunementLvl=attuLvl;
		crocheterLvl=crocLvl;
		piegesLvl=piegLvl;
		identificationLvl=identLvl;
		baratinLvl=barLvl;
		
		
		baseAtk=melee;
		atkModifiee=baseAtk;
		
		maxPower=magLvl*2;
		currentPower=maxPower;
	
	}
	
	
	
	

	
	
	//////////////////////////////////////////
	
	//public boolean getDansLeVide(){
	
	//	return dansLeVide;	
	//}
	
	
	
	public boolean getStealthmode(){
		return stealthmode;
	}
	public void setStealthmode(boolean sm){
		stealthmode=sm;
	}
	
	public int getIndexTerrainX(){
		return indexTerrainX;
	}
	
	public int getIndexTerrainY(){
		return indexTerrainY;
	}
	
	public int getIndexTerrainZ(){
		return indexTerrainZ;
	}
	
	
	
	public Vector getMemSorts(){
		return memSorts;
	}
	public void setMemSorts(Vector ms){
		memSorts=ms;
	}
	
	public String getNomE(){
		return nom;
	}
	
	
	
	
	
	public boolean getRayonX(){
		return rayonX;
	}
	public void setRayonX(boolean nv){
		rayonX=nv;
	}
	
	
	
	public boolean getNightvision(){
		return nightvision;
	}
	public void setNightvision(boolean nv){
		nightvision=nv;
	}
	
	
	public void setInvisible(boolean inv){
		invisible=inv;
	}
	
	public boolean getInvisible(){
		return invisible;
	}
	
	public boolean getPasseMuraille(){
		return passemuraille;
	}
	
	public void setPasseMuraille(boolean passW){
		passemuraille=passW;
	}
	
	
	
	public boolean getVolant(){
		return volant;
	}
	
	public void setVolant(boolean v){
		volant=v;
	}
	
	
	public int getFaim(){
		return faim;
	}
	
	public void setFaim(int nut){
		faim=nut;
	}
	
	public int getNiveau(){
		return niveau;
	}
	public void setNiveau(int n){
		niveau=n;
	}
	public int getXp(){
		return xp;
	}
	public void setXp(int x){
		xp=x;
		xpNiveauSuivant=(((niveau+1)*(niveau))/2)*1000;
	}
	
	
	
	
	public void setDureeEffetVolant(int s){
		dureeEffetVolant=s;
	}
	
	public int getDureeEffetVolant(){
		return dureeEffetVolant;
	}
	
	
	
	
	
	
	public void setDureeEffetRayonX(int s){
		dureeEffetRayonX=s;
	}
	
	public int getDureeEffetRayonX(){
		return dureeEffetRayonX;
	}
	
	
	
	public void setDureeEffetNightVision(int s){
		dureeEffetNightVision=s;
	}
	
	public int getDureeEffetNightVision(){
		return dureeEffetNightVision;
	}
	
	
	
	public void setDureeEffetPasseMuraille(int s){
		dureeEffetPasseMuraille=s;
	}
	
	public int getdureePasseMuraille(){
		return dureeEffetPasseMuraille;
	}
	
	
	
	
	public void setDureeEffetInvisibility(int s){
		dureeEffetInvisibility=s;
	}
	
	public int getdureeEffetInvisibility(){
		return dureeEffetInvisibility;
	}
	
	
	
	
	public void setDureeEffetSlow(int s){
		dureeEffetSlow=s;
	}
	
	public int getDureeEffetSlow(){
		return dureeEffetSlow;
	}
	
	public void setDureeEffetSpeed(int s){
		dureeEffetSpeed=s;
	}
	
	public int getDureeEffetSpeed(){
		return dureeEffetSpeed;
	}
	
	
	
	
	
	public void setArmeEquipe(Entite w){
		if(!w.getCasse()){
			arme=w;
			setbonusAtkArme(arme.getBonusAtk());
		}
	}
	
	
	
	public void setArmureEquipe(Entite a){
		if(!a.getCasse()){
			armure=a;
			setbonusDefArmure(armure.getBonusDef());
		}
	}
	
	
	
	public Entite getArmeEquipe(){
		return arme;
	}
	
	public Entite getArmureEquipe(){
		return armure;
	}
	
	
	public Vector getEquipementVect(){
		
		return equipementVect;
	}
	
	
	
	public int getbonusAtkArme(){
		return bonusAtkArme;
	}
	
	public void setbonusAtkArme(int bonWeap){
		bonusAtkArme=bonWeap;
	}
	
	public int getbonusDefArmure(){
		
		//System.out.println(getNom()+"bonus Def armure = "+bonusDefArmure);
		return bonusDefArmure;
	}
	
	public void setbonusDefArmure(int bonDef){
		bonusDefArmure=bonDef;
	}
	
	
	public int getBaseAtk(){
		return baseAtk;
	}
	
	public void setBaseAtk(int atkBase){
		baseAtk=atkBase;
		
	}
	
	
	public int getAtkModifiee(){
		
		atkModifiee=getBaseAtk()+getbonusAtkArme();
		
		return atkModifiee;
	}
	

	public void setAtkModifiee(int atkModif){
		atkModifiee=atkModif;
		
	}
	
	
	public int getBaseDef(){
		return baseDef;
	}
	
	public void setBaseDef(int defBase){
		baseDef=defBase;
	}
	
	public int getDefModifiee(){
		defModifiee=getBaseDef()+getbonusDefArmure();
		
		return defModifiee;
	}
	

	public void setDefModifiee(int defModif){
		defModifiee=defModif;
		
	}
	
	
	public void setMort(Monde monde,boolean ded, int x, int y){
		mort=ded;
	}
	public boolean getMort(){
		return mort;
	}
	
	
	
	
	//************************************
	public int getIntelligence(){
		return intelligence;
	}
	
	public void setIntelligence(int intel){
		intelligence=intel;
		
		//perception=(int)(((perceptionLvl/10)+0.5)*intelligence);
		//magie=(int)(((magieLvl/10)+0.5)*intelligence);
		//attunement=(int)(((attunementLvl/10)+0.5)*intelligence);
		//identification=(int)(((identificationLvl/10)+0.5)*intelligence);
		//baratin=(int)(((baratinLvl/10)+0.5)*intelligence);
		perception=(int)Math.round((perceptionLvl+intelligence)/2);
		magie=(int)Math.round((magieLvl+intelligence)/2);
		attunement=(int)Math.round((attunementLvl+intelligence)/2);
		identification=(int)Math.round((identificationLvl+intelligence)/2);
		baratin=(int)Math.round((baratinLvl+intelligence)/2);
		
		
		
		
		
	}
	
	public int getConstitution(){
		return constitution;
	}
	
	public void setConstitution(int co){
		constitution=co;
		
		maxHitPoints=constitution*20;
		currentHitPoints=maxHitPoints;
		
	}
	
	
	
	
	public int getForce(){
		return force;
	}
	
	public void setForce(int fo){
		force=fo;
		
		melee=(int)Math.round((meleeLvl+dexterite+force)/3);
		baseAtk=melee;
		atkModifiee=getBaseAtk()+getbonusAtkArme();
		encCapacity=force*10;
		
	}
	
	
	public int getDexterite(){
		return dexterite;
	}
	
	
	
	public void setDexterite(int dex){
		dexterite=dex;
		
		melee=(int)Math.round((meleeLvl+dexterite+force)/3);
		
		//melee=(int)(((meleeLvl/10)+0.5)*dexterite);
		
		baseAtk=melee;
		atkModifiee=getBaseAtk()+getbonusAtkArme();
		
		
		//discretion=(int)(((discretionLvl/10)+0.5)*dexterite);
		//distance=(int)(((distanceLvl/10)+0.5)*dexterite);
		//crocheter=(int)(((crocheterLvl/10)+0.5)*dexterite);
		//pieges=(int)(((piegesLvl/10)+0.5)*dexterite);
		
		discretion=(int)Math.round((discretionLvl+dexterite)/2);
		distance=(int)Math.round((distanceLvl+dexterite)/2);
		crocheter=(int)Math.round((crocheterLvl+dexterite)/2);
		pieges=(int)Math.round((piegesLvl+dexterite)/2);
		
		
		defModifiee=getBaseDef()+getbonusDefArmure();
		baseDef=dexterite;
		
	}
	
	
	public void setMeleeLvl(int ml){
		meleeLvl=ml;
		
		melee=(int)Math.round((meleeLvl+dexterite+force)/3);
		
		//melee=(int)(((meleeLvl/10)+0.5)*dexterite);
		baseAtk=melee;
		atkModifiee=getBaseAtk()+getbonusAtkArme();
	}
	
	public void setPerceptionLvl(int pl){
		perceptionLvl=pl;
		//perception=(int)(((perceptionLvl/10)+0.5)*intelligence);
		perception=(int)Math.round((perceptionLvl+intelligence)/2);
		
	}
	public void setDiscretionLvl(int sl){
		discretionLvl=sl;
		//discretion=(int)(((discretionLvl/10)+0.5)*dexterite);
		discretion=(int)Math.round((discretionLvl+dexterite)/2);
	}
	public void setDistanceLvl(int dl){
		distanceLvl=dl;
		//distance=(int)(((distanceLvl/10)+0.5)*dexterite);
		distance=(int)Math.round((distanceLvl+dexterite)/2);
	}
	public void setMagieLvl(int ml){
		magieLvl=ml;
		//magie=(int)(((magieLvl/10)+0.5)*intelligence);
		magie=(int)Math.round((magieLvl+intelligence)/2);
		maxPower=magieLvl*2;
		
	}
	
	public int getMagieLvl(){
		return magieLvl;
	}
	
	
	public void setAttunementLvl(int al){
		attunementLvl=al;
		//attunement=(int)(((attunementLvl/10)+0.5)*intelligence);
		attunement=(int)Math.round((attunementLvl+intelligence)/2);
	}
	public void setCrocheterLvl(int cl){
		crocheterLvl=cl;
		//crocheter=(int)(((crocheterLvl/10)+0.5)*dexterite);
		crocheter=(int)Math.round((crocheterLvl+dexterite)/2);
	}
	public void setPiegesLvl(int pil){
		piegesLvl=pil;
		//pieges=(int)(((piegesLvl/10)+0.5)*dexterite);
		pieges=(int)Math.round((piegesLvl+dexterite)/2);
	}
	public void setIdentificationLvl(int il){
		identificationLvl=il;
		//identification=(int)(((identificationLvl/10)+0.5)*intelligence);
		identification=(int)Math.round((identificationLvl+intelligence)/2);
	}
	public void setBaratinLvl(int bl){
		baratinLvl=bl;
		//baratin=(int)(((baratinLvl/10)+0.5)*intelligence);
		baratin=(int)Math.round((baratinLvl+intelligence)/2);
	}

	
	//************************************
	
	
	
	public int getParade(){
		return parade;
	}
	
	public void setParade(int par){
		parade=par;
	}
	
	public int getEncCapacity(){
		return encCapacity;
	}
	
	public void setEncCapacity(int enccap){
		encCapacity=enccap;
	}
	
	public int getEncombrement(){
		return encombrement;
	}
	
	public void setEncombrement(int enc){
		encombrement=enc;
	}

	
	

	
	
	public int getMaxHitPts(){
		return maxHitPoints;
	}
	
	public void setMaxHitPts(int mxHitPts){
		maxHitPoints=mxHitPts;
	}
	
	public int getCurrentHitPts(){
		return currentHitPoints;
	}
	
	public void setCurrentHitPts(int currentHitPts){
		currentHitPoints=currentHitPts;
	}
	
	
	//maxPower
	//currentPower
	
	public int getMaxPower(){
		return maxPower;
	}
	
	public void setMaxPower(int mxPower){
		maxPower=mxPower;
	}
	
	public int getCurrentPower(){
		return currentPower;
	}
	
	public void setCurrentPower(int currentPow){
		currentPower=currentPow;
	}
	
	
	
	
	
	
	
	
	
	
	public int getRapidite(){
		return rapidite;	
	}
	
	public void setRapidite(int rapid){
		rapidite=rapid;
	}
	
	
	
	public String getNom(){
		return nom;
	}
		
	
	
	public boolean getVisible(){
		return visible;
	}
	
	public void setVisible(boolean visibility){
		visible=visibility;
	}
	
	public int getVue(){
		return vue;
	}
	
	public void setVue(int view){
		
		vue=view;
	}
	
	public int getVueInitiale(){
		return vueInitiale;
	}
	
	public void setVueInitiale(int viewInit){
		
		vueInitiale=viewInit;
	}
	
	
	public int getCooX(){
		return coordX;
	}
	
	public int getCooY(){
		return coordY;
	}
	
	public void setCooX(int cooX){
		coordX=cooX;
	}
	
	public void setCooY(int cooY){
		coordY=cooY;
	}
	
	
	public String getTileStr(){
		
		return tileStr;
	}
	
	
	public String getTypeObjet(){
		return typeObjet;
	}
	
	
	
	
	///////////////////////////////////////////////////////////////
	///////////////////////////////////////////////////////////////
	/////////////RAPIDITE & COMPTEURS//////////////////////////////
	///////////////////////////////////////////////////////////////
	///////////////////////////////////////////////////////////////
	
	public void testerCompteurRapidite(){
		
		compteurRapidite--;
		
		//System.out.println(dureeEffetPasseMuraille);
		
		///si compteurs à 0////////
		if(dureeEffetSpeed==0){rapidite=1;
		}
		
		if(dureeEffetInvisibility==0){invisible=false;
		}
		
		if(dureeEffetPasseMuraille==0){passemuraille=false;
		}
		
		if(dureeEffetNightVision==0){nightvision=false;
		}
		
		if(dureeEffetRayonX==0){rayonX=false;
		}
		
		if(dureeEffetVolant==0){volant=false;
		}
		
		//////////////////////////////////////////
		if(compteurRapidite==0){
			compteurRapidite=rapidite;
			monde.tourMonde();
			
		}
		//////////////////////////////////////////
		
		////////decrementer compteurs//////////
		if(dureeEffetSpeed>0){dureeEffetSpeed--;}
		if(dureeEffetInvisibility>0){dureeEffetInvisibility--;}
		if(dureeEffetPasseMuraille>0){dureeEffetPasseMuraille--;}
		if(dureeEffetNightVision>0){dureeEffetNightVision--;}
		if(dureeEffetRayonX>0){dureeEffetRayonX--;}
		if(dureeEffetVolant>0){dureeEffetVolant--;}
		
		//System.out.println("Duree effet volant "+dureeEffetVolant);
		
		//System.out.println("Duree Nightvision: "+dureeEffetNightVision);
		//System.out.println("Duree RayonX: "+dureeEffetRayonX);
		
		//monde.testSiPersoDansMur();
		
	}
	
	///////////////////////////////////////////////////////////////
	///////////////////////////////////////////////////////////////
	public void parade(boolean mod){
		
		//if(mod==true && getParade()+10<=getBaseAtk()){
			
		if(mod==true && getBaseAtk()>=1){
				
			message("PARADE +",false);
			message("PARRY +",true);
			
			setParade(getParade()+1);
			
			setBaseAtk(getBaseAtk()-1);
			setBaseDef(getBaseDef()+1);
			
			//setAtkModifiee(getAtkModifiee()-10);
			//setDefModifiee(getDefModifiee()+10);
			
			monde.miseAJourResumeStatsPanel();	
		}
		
		
		if(mod==false && getParade()>=1){
			message("PARADE -",false);
			message("PARRY -",true);
			
			setParade(getParade()-1);
			
			
			setBaseAtk(getBaseAtk()+1);
			setBaseDef(getBaseDef()-1);
			
			//setAtkModifiee(getAtkModifiee()+10);
			//setDefModifiee(getDefModifiee()-10);
			
			monde.miseAJourResumeStatsPanel();
		}
		
		
	}
	
	
	
	///////////////////////////////////////////////////////////////
	///////////////////////////////////////////////////////////////
	///////////////////////////////////////////////////////////////
	
	public void afficheInventaire(){
	
		new InventaireJDialog(monde,equipementVect);
	
	}
	public void afficheGrimoire(){
		new InventaireJDialog(monde,this.getMemSorts());
		
		
		
	}
	
	//////////////LANCEMENT DE SORT//////////////////////////
	public void spellCasting(){
		ordreString="cast";
		SelecteurDansEquipement selecteurEquipDialog=new SelecteurDansEquipement(monde,memSorts,null);
	}
	
	
	
	
	///////////////ACTIVER/DESACTIVER///////////////////////////////////////
	public void activerDesactiver(){
		ordreString="trapUntrap";
		DirectionJDialog directionDialog=new DirectionJDialog(monde,null);
	}
	
	
	/////////////////REGARDER///////////////////////////////
	public void regarder(){
		ordreString="look";
		SelecteurSolEquipement sel=new SelecteurSolEquipement(monde);//selecteur mixte
		//DirectionJDialog directionDialog=new DirectionJDialog(monde,null);
	}
	
	
	////////////////////SEARCH////////////////////
	public void chercher(){
		monde.search();
		//compteurRapidite++;
		testerCompteurRapidite();
	}
	
	
	////////////////////APPLY////////////////////
	public void apply(){
		ordreString="apply";
		SelecteurDansEquipement selecteurEquipDialog=new SelecteurDansEquipement(monde,equipementVect,null);
	}
	
	///////////////////ACTIVER//////////////////
	public void activer(){
		ordreString="activer";
		//SelecteurObjetAuSol selecteurSolDialog=new SelecteurObjetAuSol(monde);
		DirectionJDialog directionDialog=new DirectionJDialog(monde,null);
		
	}
	
	////////////////////LANCER////////////////////
	public void lancer(){
		ordreString="lancer";
		SelecteurDansEquipement selecteurEquipDialog=new SelecteurDansEquipement(monde,equipementVect,null);
	}
	
	
	//////////////MAGIC MISSILE///////////////////
	public void magicMissile(Spell sort){
		ordreString="magicMissile";
		DirectionJDialog directionDialog=new DirectionJDialog(monde,sort);
	}
	
	
	
	//////////////////LOOT (fouiller un contenant)/////////////
	public void loot(){
		ordreString="loot";
		SelecteurObjetAuSol selecteurSolDialog=new SelecteurObjetAuSol(monde,getCooX(),getCooY());
	}
	
	///////////////////KICK////////////////////////
	public void kick(){
		ordreString="kick";
		DirectionJDialog directionDialog=new DirectionJDialog(monde,null);
	}
	
	///////////////BOIRE//////////////////////////
	public void boire(){
		ordreString="boire";
		SelecteurSolEquipement sel=new SelecteurSolEquipement(monde);//selecteur mixte
	}
	
	/////////////MANGER////////////////////////////
	public void manger(){
		ordreString="manger";
		SelecteurSolEquipement sel=new SelecteurSolEquipement(monde);//selecteur mixte
	}
	
	
	////////////////LIRE//////////////////////////
	public void lire(){
		ordreString="lire";
		SelecteurSolEquipement sel=new SelecteurSolEquipement(monde);//selecteur mixte
	}
	
	
	////////////////////GET/PRENDRE////////////////////
	public void get(){
		ordreString="get";
		
		new ThreadSon("./sons/itempick.wav",0).start();
		
		int nbrObjetsAuSol=0;
		//Entite objetAuSol=new Entite();	
		
		
		if(!monde.grille[this.getCooX()][this.getCooY()].isEmpty()){		
			for(int i=0;i<monde.grille[this.getCooX()][this.getCooY()].size();i++){
					
		 					
	 			try{
	 					
	 					
	 				objet = (Entite) monde.grille[this.getCooX()][this.getCooY()].get(i);
					
					
					if(objet.getClass().getName().compareTo("Vide")!=0 && objet.getClass().getName().compareTo("Ombrage")!=0 && objet.getTypeObjet().compareTo("PJ")!=0 && objet.getClass().getName().compareTo("Surface")!=0){
						
						nbrObjetsAuSol++;
						objetAuSol=objet;
					}
					
				}
				catch(NoSuchElementException exc){};
			}
		}
		if(nbrObjetsAuSol==1){
			retourDeSelectionAuSol(objetAuSol);
		}
		else if(nbrObjetsAuSol>1){
			
			SelecteurObjetAuSol selecteurSolDialog=new SelecteurObjetAuSol(monde,getCooX(),getCooY());
			
		}
		
		//System.out.println("Objets au sol="+nbrObjetsAuSol+" "+this.getCooX()+" "+this.getCooY());
		
	
		
		
		
		
	}
	
	
	///////////////////DROP/DEPOSER////////////////////
	public void drop(){
		ordreString="drop";
		SelecteurDansEquipement selecteurEquipDialog=new SelecteurDansEquipement(monde,equipementVect,null);
	}
	
	
	
	//////////////////S'EQUIPER D'UNE ARME/////////////
	public void equipArme(){
		ordreString="equiparme";
		SelecteurDansEquipement selecteurEquipDialog=new SelecteurDansEquipement(monde,equipementVect,null);
	}
	
	//////////////////S'EQUIPER D'UNE ARMURE///////////
	public void equipArmure(){
		ordreString="equiparmure";
		SelecteurDansEquipement selecteurEquipDialog=new SelecteurDansEquipement(monde,equipementVect,null);
	}
	
	public void desequipArme(){
		ordreString="desequiparme";
		SelecteurDansEquipement selecteurEquipDialog=new SelecteurDansEquipement(monde,equipementVect,null);

	}
	
	public void desequipArmure(){
		ordreString="desequiparmure";
		SelecteurDansEquipement selecteurEquipDialog=new SelecteurDansEquipement(monde,equipementVect,null);

		
	}
	
	/////////////////MONTER/DESCENDRE///////////////
	public void descendre(){
		ordreString="descendre";
		analyseDuSol(getCooX(),getCooY());
	}
	
	public void monter(){
		ordreString="monter";
		analyseDuSol(getCooX(),getCooY());
	}
	
	
	///////////////////////////////////////////////////////////////
	///////////////////////////////////////////////////////////////
	////////////////////RETOUR GENERIQUE DU SelecteurObjetAuSol/////////////////
	public void retourDeSelectionAuSol(Entite laSelection){
		
		
		//////////REGARDER////////////////////
		if(ordreString.compareTo("look")==0){
			if(laSelection.getVisible() && laSelection.getClass().getName().compareTo("Vide")!=0 && laSelection.getClass().getName().compareTo("Ombrage")!=0 && laSelection.getTypeObjet().compareTo("PJ")!=0 && laSelection.getClass().getName().compareTo("Surface")!=0){

				int diff=(laSelection.getNiveau()-this.getNiveau())*7;
				int jet=roll();
				int score=(identification*jet)-diff;
				
				new LookJDialog(monde,monde.jeuPan.lang,laSelection,Math.round(score/10));
				
				testerCompteurRapidite();
				
				
			}
		}
		
		
		
		if(ordreString.compareTo("activer")==0){
		
			if(laSelection.getTypeObjet().compareTo("Activable")==0){
			
				if(!laSelection.getCasse()){
					
					if(!laSelection.getOnOff()){
						laSelection.setOnOff(true);
						
					}
					else{
						laSelection.setOnOff(false);
						
					}
					
					laSelection.effetActivable(monde);
					
					laSelection.bruit(monde,laSelection.getCooX(),laSelection.getCooY());
					testerCompteurRapidite();
				}
				else{
					message("C'est casse",false);
					message("It's broken",true);
				}
			}
			else{
				message("Ca ne peut pas etre activer",false);
				message("It cannot be activated",true);
			}
		}
		
		
		
		
		
		if(ordreString.compareTo("lire")==0){
			
			if(laSelection.getTypeObjet().compareTo("Ecrit")==0){
				
				if(laSelection.getCasse()==false){
					if(!monde.jeuPan.lang){
						LectureJDialog jd=new LectureJDialog(monde,laSelection.getTexte());
					}
					else{
						LectureJDialog jd=new LectureJDialog(monde,laSelection.getTexteE());
					}
						
					
					testerCompteurRapidite();
				}
				else{
					message("Trop endommage, c est illisible",false);
					message("Too much damaged. You cant read that",true);
				}
		
			}
			
			else if(laSelection.getTypeObjet().compareTo("EcritMagique")==0){
				
				if(laSelection.getCasse()==false){
					laSelection.effetEcritMagique(monde,this);	
					
					testerCompteurRapidite();
				}
				else{
					message("Trop endommage, c est illisible",false);
					message("Too much damaged. You cant read that",true);
				}
		
			}
			
			else{
				message("Ca ne se lit pas",false);
				message("You cant read that",true);
			}
			
		}
		
		
		
		//Si l'action est prendre alors...
		if(ordreString.compareTo("get")==0){
			
			if(getEncombrement()+laSelection.getPoids()<=getEncCapacity()){
			
				setEncombrement(getEncombrement()+laSelection.getPoids());
			
				message("Vous avez pris : "+laSelection.getNom(),false);
				message("You pick up : "+laSelection.getNomE(),true);
				//on enleve l'objet du sol
				
				
				monde.grille[getCooX()][getCooY()].remove(laSelection);
				equipementVect.add(laSelection);
				//equipementVectNOMS.add(laSelection.getNomDequipement());
				
				
				monde.miseAJourResumeStatsPanel();
				
				//Ancienne méthode*****
				//monde.jeuPan.equipementpanel.updateEquipementList(monde,equipementVect);
				
				
				
				
				
				/////// int ec=0
			 	///////parcours dans equipementVect, cherche les eclairants allumés
			 	//////a chaque fois qu'on en trouve un si objet.getEclairage()>=ec
			 	//alors ec=objet.getEclairage() et au final setVue(ec);
			 	//
			 	int ec=getVueInitiale();
			 	if(!equipementVect.isEmpty()){
		
					for(Enumeration e = equipementVect.elements();e.hasMoreElements();){
		                
		 				try{	
		 						
		 					objet=(Entite) e.nextElement();
		 					
							if(objet.getAlume() && objet.getEclairage()>=ec){
								ec=objet.getEclairage();	
							}
								
		 				}
		 				catch(NoSuchElementException exc){};
		 			}
		 		}
			 	setVue(ec);
				
				
				//monde.jeuPan.terrainPanel.repaint();
				//monde.jeuPan.repaint();
				
				testerCompteurRapidite();
				
			
			}
			else{
				message("Trop lourd",false);
				message("Too heavy",true);
			}
					
		}
		
		
		
		
		
		
		
		if(ordreString.compareTo("loot")==0 && laSelection.getClass().getName().compareTo("Contenant")==0){
			
			if(laSelection.getOuvert()==true){
				
				// une petite JDialog pour savoir si cest get ou drop 
				
				ContenantJDialog contenantJD=new ContenantJDialog(monde,laSelection);
				
				testerCompteurRapidite();
				testerCompteurRapidite();
				
			}
			else{
				message("C est ferme",false);
				message("It s closed",true);
			}
			
		}
		
		
		
		if(ordreString.compareTo("boire")==0){
			
			if(laSelection.getClass().getName().compareTo("Boisson")==0){
				
				if(laSelection.getCasse()==false){
					laSelection.effetBoisson(this,monde);
					
					
					new ThreadSon("./sons/verse.wav",0).start();
					
					//if(laSelection.getModele().compareTo("fountain")!=0){
					//	monde.grille[getCooX()][getCooY()].remove(laSelection);
					//}
					
					monde.miseAJourResumeStatsPanel();
					//monde.jeuPan.terrainPanel.repaint();
					//monde.jeuPan.repaint();
					
					testerCompteurRapidite();
					testerCompteurRapidite();
				}
				else{
					message("C est brise, le contenu est repandu sur le sol",false);
					message("It s broken. The liquid is spreading on the ground",true);
					
				}
				
			}
			else{
				message("Ca ne se boit pas",false);
				message("You cant drink that",true);
			}
		}
		
		///////////////
		
		
		if(ordreString.compareTo("manger")==0){
			
			if(laSelection.getClass().getName().compareTo("Nourriture")==0 || laSelection.getTypeObjet().compareTo("Creature")==0){
				
				laSelection.effetNourriture(this);
				
				new ThreadSon("./sons/dripp.wav",0).start();
					
				monde.grille[getCooX()][getCooY()].remove(laSelection);
				monde.miseAJourResumeStatsPanel();
				//monde.jeuPan.terrainPanel.repaint();
				//monde.jeuPan.repaint();
					
				testerCompteurRapidite();
				testerCompteurRapidite();
				
			}
			else{
				message("Ca ne se mange pas",false);
				message("You cant eat that",true);
			}
		}
		
		
		
		
		
		

			
	}
	
	///////////////////////////////////////////////////////////////
	///////////////////////////////////////////////////////////////
	//////////////////RETOUR GENERIQUE DE CONTENANTJDIALOG/////////////
	public void retourContenantJDialog(Entite leContenant,String lordre){
		ordreString=lordre;
		//message(ordreString);
		
		
		if(ordreString.compareTo("getContenant")==0){
			
			SelecteurDansEquipement selecteurEquipDialog=new SelecteurDansEquipement(monde,leContenant.getContenu(),leContenant);
			
		}
		
		if(ordreString.compareTo("dropContenant")==0){///////////////equipementVect
			
			message("Choisissez l objet a mettre dans ce contenant",false);
			message("Choose an item to put in it",true);
			
			SelecteurDansEquipement selecteurEquipDialog=new SelecteurDansEquipement(monde,equipementVect,leContenant);
			
		}
		
	}
	
	///////////////////////////////////////////////////////////////
	///////////////////////////////////////////////////////////////
	////////////////////RETOUR GENERIQUE DU SelecteurDansEquipement/////////////////
	public void retourDeSelectionDansEquipement(Entite laSelection,Entite outil){
		
		//////////REGARDER////////////////////
		if(ordreString.compareTo("look")==0){
			if(laSelection.getVisible() && laSelection.getClass().getName().compareTo("Vide")!=0 && laSelection.getClass().getName().compareTo("Ombrage")!=0 && laSelection.getTypeObjet().compareTo("PJ")!=0 && laSelection.getClass().getName().compareTo("Surface")!=0){

				int diff=(laSelection.getNiveau()-this.getNiveau())*7;
				int jet=roll();
				int score=(identification*jet)-diff;
				
				new LookJDialog(monde,monde.jeuPan.lang,laSelection,Math.round(score/10));
				
				testerCompteurRapidite();
				
				
			}
		}
		
		
		
		
		
		
		if(ordreString.compareTo("cast")==0){
			
			if(currentPower>=laSelection.getNiveau()){
				
				setStealthmode(false);
				
				boolean reussit=false;
				
				int casting=magie*roll();
				int defSort=laSelection.getNiveau()*roll();
				
				
				//System.out.println(casting);
				//System.out.println(defSort);
				
				
				if(casting-defSort>=0){
					reussit=true;
				}
				
				
				if(reussit){
				
					currentPower=currentPower-laSelection.getNiveau();
				
					laSelection.effetSort(monde,this);
					
					int tempsLancement=0;
					while(tempsLancement<laSelection.getNiveau()){
					
						testerCompteurRapidite();
						tempsLancement++;
					}
				}
				else{
					
					currentPower=currentPower-(laSelection.getNiveau()/2);
					
					int tempsLancement=0;
					while(tempsLancement<(laSelection.getNiveau()/2)){
					
						testerCompteurRapidite();
						tempsLancement++;
					}
					
					
					message("Vous vous trompez dans la formule",false);
					message("Spell casting failure",true);
				}
				
			}
			else{
				message("Pas assez de points de pouvoir",false);
				message("Not enough power points",true);
			}
			
		}
		
		
		
		if(ordreString.compareTo("lire")==0){
			
			if(laSelection.getTypeObjet().compareTo("Ecrit")==0 ){
				
				if(laSelection.getCasse()==false){
					
					if(!monde.jeuPan.lang){
						LectureJDialog jd=new LectureJDialog(monde,laSelection.getTexte());
					}
					else{
						LectureJDialog jd=new LectureJDialog(monde,laSelection.getTexteE());
					}
					
					
					
					testerCompteurRapidite();
				}
				else{
					message("Trop endommage, c est illisible",false);
					message("Too much damaged. You cant read that",true);
				}
		
			}
			
			
			else if(laSelection.getTypeObjet().compareTo("EcritMagique")==0 ){
				
				if(laSelection.getCasse()==false){
					
					laSelection.effetEcritMagique(monde,this);
					
					testerCompteurRapidite();
				}
				else{
					message("Trop endommage, c est illisible",false);
					message("Too much damaged. You cant read that",true);
				}
		
			}
			else{
				message("Ca ne se lit pas",false);
				message("You cant read that",true);
			}
			
			
			
		}
		
		
		if(ordreString.compareTo("dropContenant")==0){
			
			if(laSelection.getEquiped()==false){
				
				//if(laSelection.getAlume()==false){
				
					setEncombrement(getEncombrement()-laSelection.getPoids());
					
					message("Vous deposez: "+laSelection.getNom(),false);
					message("You drop: "+laSelection.getNomE(),true);
					
					new ThreadSon("./sons/drop.wav",0).start();
					//monde.grille[getCooX()][getCooY()].add(laSelection);
					
					equipementVect.remove(laSelection);
					//equipementVectNOMS.remove(laSelection.getNomDequipement());// PAS TERRIBLE
					
					Vector cont=outil.getContenu();
					cont.add(laSelection);
					outil.setContenu(cont);
					
					//Ancienne méthode*****
					//monde.jeuPan.equipementpanel.updateEquipementList(monde,equipementVect);
					
					
					monde.miseAJourResumeStatsPanel();
					
					//monde.jeuPan.terrainPanel.repaint();
					//monde.jeuPan.repaint();
					
				
					//new ThreadSon("./sons/drop.wav").start();
				//}
				//else{
				//	message("Eteignez le avant",false);
				//	message("Please extinguish it before",true);
				//}
				
			}
			else{
				message("Impossible, cet objet est equipe",false);
				message("You cant, this item is equipped",true);
			}
		}
		
		
		
		
		//Si l'action est prendre alors...
		if(ordreString.compareTo("getContenant")==0){
			
			if(getEncombrement()+laSelection.getPoids()<=getEncCapacity()){
			
				setEncombrement(getEncombrement()+laSelection.getPoids());
			
				message("Vous avez pris : "+laSelection.getNom(),false);
				message("You pick up : "+laSelection.getNomE(),true);
				
				new ThreadSon("./sons/itempick.wav",0).start();
				//on enleve l'objet du contenant
				
				Vector cont=outil.getContenu();
				cont.remove(laSelection);
				outil.setContenu(cont);
					
					
					
				
				equipementVect.add(laSelection);
				//equipementVectNOMS.add(laSelection.getNom());
				//equipementVectNOMS.add(laSelection.getNomDequipement());// PAS TERRIBLE
				
				monde.miseAJourResumeStatsPanel();
				
				//Ancienne méthode*****
				//monde.jeuPan.equipementpanel.updateEquipementList(monde,equipementVect);
				
				
				//monde.jeuPan.terrainPanel.repaint();
				//monde.jeuPan.repaint();
				
				
			
				//new ThreadSon("./sons/get.wav").start();
			}
			else{
				message("Trop lourd",false);
				message("Too heavy",true);
			}
					
		}
		
		
		
		if(ordreString.compareTo("boire")==0){
			
			if(laSelection.getClass().getName().compareTo("Boisson")==0){
				if(laSelection.getCasse()==false){
					laSelection.effetBoisson(this,monde);
					
				
					
					new ThreadSon("./sons/verse.wav",0).start();
					
					setEncombrement(getEncombrement()-laSelection.getPoids());
					equipementVect.remove(laSelection);
					//equipementVectNOMS.remove(laSelection.getNomDequipement());
					
					//Ancienne méthode*****
					//monde.jeuPan.equipementpanel.updateEquipementList(monde,equipementVect);
					
					monde.miseAJourResumeStatsPanel();
					//monde.jeuPan.terrainPanel.repaint();
					//monde.jeuPan.repaint();
					
					testerCompteurRapidite();
					testerCompteurRapidite();
				}
				else{
					message("Impossible, c est brise",false);
					message("You cant, its broken",true);
				}
				
			}
			else{
				message("Ca ne se boit pas",false);
				message("You cant drink that",true);
			}
		}
		
		
		
		
		
		
		if(ordreString.compareTo("manger")==0){
			
			if(laSelection.getClass().getName().compareTo("Nourriture")==0 || laSelection.getTypeObjet().compareTo("Creature")==0){
				
				laSelection.effetNourriture(this);
				
				new ThreadSon("./sons/dripp.wav",0).start();
					
				setEncombrement(getEncombrement()-laSelection.getPoids());
				equipementVect.remove(laSelection);
				//equipementVectNOMS.remove(laSelection.getNomDequipement());
				
				//Ancienne méthode*****
				//monde.jeuPan.equipementpanel.updateEquipementList(monde,equipementVect);
				
				monde.miseAJourResumeStatsPanel();
				//monde.jeuPan.terrainPanel.repaint();
				//monde.jeuPan.repaint();
				
				testerCompteurRapidite();
				testerCompteurRapidite();
				
			}
			else{
				message("Ca ne se mange pas",false);
				message("You cant eat that",true);
			}
		}
		
		
		
		
		
		
		
		if(ordreString.compareTo("drop")==0){
			
			if(laSelection.getEquiped()==false){
				
				
				
				
				//if(laSelection.getAlume()==false){
				
				
				
				
					setEncombrement(getEncombrement()-laSelection.getPoids());
					
					message("Vous deposez: "+laSelection.getNom(),false);
					message("You drop: "+laSelection.getNomE(),true);
					
					monde.grille[getCooX()][getCooY()].add(laSelection);
					
					laSelection.setCooX(getCooX());
					laSelection.setCooY(getCooY());
					
					equipementVect.remove(laSelection);
					
					//equipementVectNOMS.remove(laSelection.getNomDequipement());
					
					
					
					
					//Ancienne méthode*****
					//monde.jeuPan.equipementpanel.updateEquipementList(monde,equipementVect);
					
					
					monde.miseAJourResumeStatsPanel();
					
					//monde.jeuPan.terrainPanel.repaint();
					//monde.jeuPan.repaint();
				
					new ThreadSon("./sons/drop.wav",0).start();
					
					
					
					
					//if(laSelection.getAlume()){
					//	setVue(getVueInitiale());
						//estDejaEclaire=false;
					//}
				//}
				//else{
				//	message("Eteignez le avant");
				//}
				
				
				/////// int ec=0
			 	///////parcours dans equipementVect, cherche les eclairants allumés
			 	//////a chaque fois qu'on en trouve un si objet.getEclairage()>=ec
			 	//alors ec=objet.getEclairage() et au final setVue(ec);
			 	//
			 	int ec=getVueInitiale();
			 	if(!equipementVect.isEmpty()){
		
					for(Enumeration e = equipementVect.elements();e.hasMoreElements();){
		                
		 				try{	
		 						
		 					objet=(Entite) e.nextElement();
		 					
							if(objet.getAlume() && objet.getEclairage()>=ec){
								ec=objet.getEclairage();	
							}
								
		 				}
		 				catch(NoSuchElementException exc){};
		 			}
		 		}
			 	setVue(ec);
				
				
				
				
				
			}
			else{
				message("Impossible, cet objet est equipe",false);
				message("You cant, it s equipped",true);
			}
		}
		
		
		
		
		
		
		
		
		if(ordreString.compareTo("equiparme")==0){
			
			if(laSelection.getClass().getName().compareTo("Arme")==0 ||(laSelection.getClass().getName().compareTo("Outil")==0 && laSelection.getUseAsWeapon()==true ) ){
			
				 if(laSelection.getEquiped()==false){
				 
				 	if(uneArmeEnMain==false){
				 	
				 		if(laSelection.getCasse()==false){
				 			
				 			/*
							String matosTrouve=new String();
							int indexObjet=equipementVectNOMS.indexOf(laSelection.getNomDequipement());
							matosTrouve=equipementVectNOMS.elementAt(indexObjet).toString();
							matosTrouve="#"+matosTrouve;
							laSelection.setNomDequipement(matosTrouve);
							equipementVectNOMS.setElementAt(matosTrouve,indexObjet);
							*/
							
							
							
							//Ancienne méthode*****
							//monde.jeuPan.equipementpanel.updateEquipementList(monde,equipementVect);
							
							message("Vous vous equipe de : "+laSelection.getNom(),false);
							message("You equip : "+laSelection.getNomE(),true);
							
					
							laSelection.setEquiped(true);
							
							uneArmeEnMain=true;
							
							setArmeEquipe(laSelection);
							//bonusAtkArme=laSelection.getBonusAtk();
							setAtkModifiee(getBaseAtk()+bonusAtkArme);
							
							
							monde.miseAJourResumeStatsPanel();
							
							//monde.jeuPan.terrainPanel.repaint();
							//monde.jeuPan.repaint();
							
							new ThreadSon("./sons/bastards.wav",0).start();
							
							//si on veut que le fait de s'equiper coûte une action///OPTION
							
							testerCompteurRapidite();
						}
						else{
							message("Cette arme est cassee !",false);
							message("This weapon is broken !",true);
						}
							
						
					}
					else{
						message("Une arme a la fois !",false);
						message("Just one weapon please",true);
					}
					
				}
				else{
					message("Cet objet est deja equipe",false);
					message("It s already equipped",true);
					
				}
			}
			else{
				message("Ce n est pas une arme",false);
				message("This is not a weapon",true);
			}
		}
		
		
		
		if(ordreString.compareTo("equiparmure")==0){
			
			if(laSelection.getClass().getName().compareTo("Armure")==0){
				 
				 if(laSelection.getEquiped()==false){
				 
				 	if(uneArmurePortee==false){
				 	
				 		if(laSelection.getCasse()==false){
							
							/*
							String matosTrouve=new String();
							int indexObjet=equipementVectNOMS.indexOf(laSelection.getNomDequipement());
							matosTrouve=equipementVectNOMS.elementAt(indexObjet).toString();
							matosTrouve="#"+matosTrouve;
							laSelection.setNomDequipement(matosTrouve);
							equipementVectNOMS.setElementAt(matosTrouve,indexObjet);
							*/
						
						
							message("Vous vous equipe de : "+laSelection.getNom(),false);
							message("You equip : "+laSelection.getNomE(),true);
							
							//Ancienne méthode*****
							//monde.jeuPan.equipementpanel.updateEquipementList(monde,equipementVect);
					
					
							laSelection.setEquiped(true);
							uneArmurePortee=true;
							
							setArmureEquipe(laSelection);
							
							
							//bonusDefArmure=laSelection.getBonusDef();
							setDefModifiee(getBaseDef()+bonusDefArmure);
							
							monde.miseAJourResumeStatsPanel();
							
							//monde.jeuPan.terrainPanel.repaint();
							//monde.jeuPan.repaint();
							
							
							new ThreadSon("./sons/chainmed.wav",0).start();
							
							//si on veut que le fait de s'equiper coûte une action///OPTION
							
							testerCompteurRapidite();
							testerCompteurRapidite();
							testerCompteurRapidite();
						}
						else{
							message("Cette armure est cassee !",false);
							message("This armor is broken !",true);
						}
						
					}	
					else{
						message("Une armure a la fois !",false);
						message("Only one armor please !",true);
					}
					
				}
				else{
					message("Cet objet est deja equipe",false);
					message("It s alreay equipped",true);
				}
			}
			else{
				message("Ce n est pas une armure",false);
				message("This is not an armor",true);
			}
		}
		
		
		
		
		
		
		if(ordreString.compareTo("desequiparme")==0){
			
			//if(laSelection.getClass().getName().compareTo("Arme")==0 ||(laSelection.getClass().getName().compareTo("Outil")==0 && laSelection.getUseAsWeapon()==true ) ){
			
			if(laSelection.getClass().getName().compareTo("Arme")==0 || laSelection.getClass().getName().compareTo("Outil")==0){
				
				 if(laSelection.getEquiped()==true){
				 	
				 	laSelection.setEquiped(false);
				 	
				 	uneArmeEnMain=false;
				 	
				 	
				 	
				 	
				 	//setAtkModifiee(getAtkModifiee()-laSelection.getBonusAtk());
				 	bonusAtkArme=0;
		
		
		
				 	message("Vous n etes plus equipe de : "+laSelection.getNom(),false);
				 	message("You release : "+laSelection.getNomE(),true);
			
				 
				 	//Tout ça pour virer le #...
				 	/*
				 	String matosTrouve=new String();
					int indexObjet=equipementVectNOMS.indexOf(laSelection.getNomDequipement());
					matosTrouve=equipementVectNOMS.elementAt(indexObjet).toString();
					int indexAsterisk=matosTrouve.indexOf("#");
					
					if(matosTrouve.startsWith("@")==true){
						matosTrouve="@"+matosTrouve.substring(indexAsterisk+1,matosTrouve.length());
					}
					else{
						matosTrouve=matosTrouve.substring(indexAsterisk+1,matosTrouve.length());
					}
					
					
					laSelection.setNomDequipement(matosTrouve);
					equipementVectNOMS.setElementAt(matosTrouve,indexObjet);
				 	*/
				 	//
				 	
				 	
				 	//Ancienne méthode*****
				 	//monde.jeuPan.equipementpanel.updateEquipementList(monde,equipementVect);
				 	
				 	monde.miseAJourResumeStatsPanel();
					//monde.jeuPan.terrainPanel.repaint();
					//monde.jeuPan.repaint();
					
					testerCompteurRapidite();
				
					//new ThreadSon("./sons/equip.wav").start();
					
				 }
				 else{
					message("Cet objet n est pas equipe",false);
					message("It s not equipped",true);
				}
				
			}
			else{
				message("Ce n est pas une arme",false);
				message("This is not a weapon",true);
			}
		}
		
		
		if(ordreString.compareTo("desequiparmure")==0){
			
			if(laSelection.getClass().getName().compareTo("Armure")==0){
				
				 if(laSelection.getEquiped()==true){
				 	
				 	laSelection.setEquiped(false);
				 	
				 	uneArmurePortee=false;
				 	
				 	//setDefModifiee(getDefModifiee()-laSelection.getBonusDef());
				 	bonusDefArmure=0;
				 	
				 	
				 	message("Vous n etes plus equipe de : "+laSelection.getNom(),false);
				 	message("You take off : "+laSelection.getNomE(),true);
				 	
				 
				 	//Tout ça pour virer le #..
				 	/*.
				 	String matosTrouve=new String();
					int indexObjet=equipementVectNOMS.indexOf(laSelection.getNomDequipement());
					matosTrouve=equipementVectNOMS.elementAt(indexObjet).toString();
					int indexAsterisk=matosTrouve.indexOf("#");
					
					
					if(matosTrouve.startsWith("@")==true){
						matosTrouve="@"+matosTrouve.substring(indexAsterisk+1,matosTrouve.length());
					}
					else{
						matosTrouve=matosTrouve.substring(indexAsterisk+1,matosTrouve.length());
					}
					
					
					laSelection.setNomDequipement(matosTrouve);
					equipementVectNOMS.setElementAt(matosTrouve,indexObjet);
				 	*/
				 	////
				 	
				 	
				 	//Ancienne méthode*****
				 	//monde.jeuPan.equipementpanel.updateEquipementList(monde,equipementVect);
				 	
				 	
				 	monde.miseAJourResumeStatsPanel();
					//monde.jeuPan.terrainPanel.repaint();
					//monde.jeuPan.repaint();
					
					testerCompteurRapidite();
					testerCompteurRapidite();
					//new ThreadSon("./sons/equip.wav").start();
					
				 }
				 else{
					message("Cet objet n est pas equipe",false);
					message("It s not equipped",true);
				}
			}
			else{
				message("Ce n est pas une armure",false);
				message("This is not an armor",true);
			}
		}
		
		/////////////REMPLISSAGE HUILE//////////////Entite laSelection,Entite outil
		if(ordreString.compareTo("fuel")==0){
			
			if(laSelection.getModele().compareTo("lanterne")==0){
				
				if(outil.getHuile()>0){
					
				
					if(laSelection.getCasse()==false){
						message("Vous remplissez "+laSelection.getNom()+" avec "+outil.getNom(),false);
						message("You fill "+laSelection.getNomE()+" with "+outil.getNomE(),true);
						new ThreadSon("./sons/verse.wav",0).start();
						// 100 part du principe que lanternes et flasques sont toutes du même modele
						while(outil.getHuile()>0 && laSelection.getHuile()<laSelection.getMaxHuile()){ 
							outil.setHuile(outil.getHuile()-1);
							laSelection.setHuile(laSelection.getHuile()+1);
						}
						
						testerCompteurRapidite();
						testerCompteurRapidite();
						
						message("Flasque: "+outil.getHuile()+"  /  Lanterne: "+laSelection.getHuile(),false);
						message("Oil flask: "+outil.getHuile()+"  /  Lantern: "+laSelection.getHuile(),true);
					}
					else{
						message("La lanterne est cassee",false);
						message("The lantern is broken",true);
					}
					
			
				}
				else{
					message("La flasque est vide",false);
					message("The Oil flask is empty",true);
				}
				
			}
			else{
				message("Ca n est pas fait pour recevoir de l huile",false);
				message("It cannot be filled with oil",true);
			}
				
		}
		
		
		
		/////////LANCER////////////////////////////
		
		if(ordreString.compareTo("lancer")==0){
			if(!laSelection.getEquiped()){
			
				DirectionJDialog directionDialog=new DirectionJDialog(monde,laSelection);
			}
			else{message("Non, c'est equipe",false);message("You cant, it s equipped",true);
			}
			
		}
		
		
		
		////////////APPLY/////////////////////////////////////
		if(ordreString.compareTo("apply")==0){
			if(laSelection.getClass().getName().compareTo("Outil")==0){
				
				//System.out.println("PEUT CREUSER "+laSelection.getPeutCreuser());
				
				if(laSelection.getPeutCreuser()){
					ordreString="creuser";
					DirectionJDialog directionDialog=new DirectionJDialog(monde,laSelection);
					
				}
				
				
				
				if(laSelection.getPeutEclairer()==true){
					
					//if(estDejaEclaire==false){
					
						if(laSelection.getAlume()==false){  // ALLUME
							
							if(laSelection.getHuile()>0){
								message("Vous allumez "+laSelection.getNom(),false);
								message("You light "+laSelection.getNomE(),true);
								
								laSelection.setAlume(true);
								new ThreadSon("./sons/torchLit.wav",0).start();
								
								if(laSelection.getEclairage()>getVue()){
								
									setVue(getVueInitiale()+laSelection.getEclairage());
								}
								
								
								//estDejaEclaire=true;
								
								testerCompteurRapidite();
								
								/*
								String matosTrouve=new String();
								int indexObjet=equipementVectNOMS.indexOf(laSelection.getNomDequipement());
								matosTrouve=equipementVectNOMS.elementAt(indexObjet).toString();
								matosTrouve="@"+matosTrouve;
								laSelection.setNomDequipement(matosTrouve);
								equipementVectNOMS.setElementAt(matosTrouve,indexObjet);
								*/
								
								
								//Ancienne méthode*****
								//monde.jeuPan.equipementpanel.updateEquipementList(monde,equipementVect);
								
							}
							else{
								message("Plus de combustible",false);
								message("No more fuel",true);
							}
							
						}
					//}
					else if(laSelection.getAlume()==true){	//ETEINT
						laSelection.setAlume(false);
						message("Vous eteignez "+laSelection.getNom(),false);
						message("You extinguish "+laSelection.getNomE(),true);
						new ThreadSon("./sons/torchGoesOut.wav",0).start();
						
						//setVue(getVueInitiale());
						//estDejaEclaire=false;
						
						testerCompteurRapidite();
						 
						////Tout ça pour virer le @...
						/*
					 	String matosTrouve=new String();
						int indexObjet=equipementVectNOMS.indexOf(laSelection.getNomDequipement());
						matosTrouve=equipementVectNOMS.elementAt(indexObjet).toString();
						int indexAsterisk=matosTrouve.indexOf("@");
						
						if(matosTrouve.startsWith("#")==true){
						matosTrouve="#"+matosTrouve.substring(indexAsterisk+1,matosTrouve.length());
						}
						else{
							matosTrouve=matosTrouve.substring(indexAsterisk+1,matosTrouve.length());
						}
						
						laSelection.setNomDequipement(matosTrouve);
						equipementVectNOMS.setElementAt(matosTrouve,indexObjet);
						*/
						
						//Ancienne méthode*****
						//monde.jeuPan.equipementpanel.updateEquipementList(monde,equipementVect);
					 	
					 	
					 	
					 	/////// int ec=0
					 	///////parcours dans equipementVect, cherche les eclairants allumés
					 	//////a chaque fois qu'on en trouve un si objet.getEclairage()>=ec
					 	//alors ec=objet.getEclairage() et au final setVue(ec);
					 	//
					 	int ec=getVueInitiale();
					 	if(!equipementVect.isEmpty()){
				
							for(Enumeration e = equipementVect.elements();e.hasMoreElements();){
				                
				 				try{	
				 						
				 					objet=(Entite) e.nextElement();
				 					
									if(objet.getAlume() && objet.getEclairage()>=ec){
										ec=objet.getEclairage();	
									}
										
				 				}
				 				catch(NoSuchElementException exc){};
				 			}
				 		}
					 	setVue(ec);
					 	
					 	
					 	
					 	
					 	////
						 
					}
					//else{
					//	message("Vous avez deja un eclairage");
					//}
					
					
					
				}
				
				
				
				if(laSelection.getPeutCasser()==true){
					ordreString="casser";
					DirectionJDialog directionDialog=new DirectionJDialog(monde,laSelection);
					//cela va ensuite vers actionSurCible avec l'ordre "casser"
				}
				
				
				
				if(laSelection.getPeutCrocheter()==true){
					ordreString="crocheter";
					DirectionJDialog directionDialog=new DirectionJDialog(monde,laSelection);
					//cela va ensuite vers actionSurCible avec l'ordre "crocheter"
				}
				
				
				if(laSelection.getModele().compareTo("oilflask")==0){
					ordreString="fuel";
					message("***Choisissez une lanterne***",false);
					message("***Choose a lantern***",true);
					
					SelecteurDansEquipement selecteurEquipDialog=new SelecteurDansEquipement(monde,equipementVect,laSelection);
				}
				
				
				
				//monde.jeuPan.terrainPanel.repaint();
				//monde.jeuPan.repaint();
				
			}
			else{
				message("Ce n est pas un outil",false);
				message("This is not a tool",true);
			}
		}
		
	}
	
	
	public void unequipArme(Entite arme){
		ordreString="desequiparme";
		retourDeSelectionDansEquipement(arme,null);
	}
	
	public void unequipArmure(Entite armure){
		ordreString="desequiparmure";
		retourDeSelectionDansEquipement(armure,null);
		
		
	}
	
	///////////////////////////////////////////////////////////////
	///////////////////////////////////////////////////////////////
	/*public void miseAjourVisuelEquipement(){
		//Ancienne méthode
		//monde.jeuPan.equipementpanel.updateEquipementList(monde,equipementVect);
	}*/
	
	///////////////////////////////////////////////////////////////
	///////////////////////////////////////////////////////////////
	
	
	
	
	////////////////////////////////////////////////////
	////////////////////////////////////////////////////
	////////////////////////////////////////////////////
	////////////////////////////////////////////////////
	//////////////Le Mouvement du personnage////////////
	////////////////////////////////////////////////////
	////////////////////////////////////////////////////
	////////////////////////////////////////////////////
	////////////////////////////////////////////////////
	public void mouvement(int coor){
		
		int voyage=0;
		
		//System.out.println(nom+" se deplace");
		
		int x2=0;
		int y2=0;
		int x=getCooX();
		int y=getCooY();
		
		//System.out.println("X=="+x+"  Y=="+y);
		
		
		///////////////////////////////////////////
		
 						
		if(coor==1){
			x2=x-1;
			y2=y+1;	
			
			if(x2==monde.tailleGrille-10 || x2==9){x2=x;}
			if(y2==monde.tailleGrille-10 || y2==9){y2=y;}
			
		}
		
		if(coor==2){
			x2=x;
			y2=y+1;	
			if(x2==monde.tailleGrille-10 || x2==9){x2=x;voyage=3;}
			if(y2==monde.tailleGrille-10 || y2==9){y2=y;voyage=3;}
		}
		
		if(coor==3){
			x2=x+1;
			y2=y+1;
			if(x2==monde.tailleGrille-10 || x2==9){x2=x;}
			if(y2==monde.tailleGrille-10 || y2==9){y2=y;}	
		}
		
		if(coor==4){
			x2=x-1;
			y2=y;
			if(x2==monde.tailleGrille-10 || x2==9){x2=x;voyage=4;}
			if(y2==monde.tailleGrille-10 || y2==9){y2=y;voyage=4;}
		}
		
		if(coor==6){
			x2=x+1;
			y2=y;
			if(x2==monde.tailleGrille-10 || x2==9){x2=x;voyage=2;}
			if(y2==monde.tailleGrille-10 || y2==9){y2=y;voyage=2;}
		}
		
		if(coor==7){
			x2=x-1;
			y2=y-1;
			if(x2==monde.tailleGrille-10 || x2==9){x2=x;}
			if(y2==monde.tailleGrille-10 || y2==9){y2=y;}
		}
		
		if(coor==8){
			x2=x;
			y2=y-1;
			if(x2==monde.tailleGrille-10 || x2==9){x2=x;voyage=1;}
			if(y2==monde.tailleGrille-10 || y2==9){y2=y;voyage=1;}
		}
		
		if(coor==9){
			x2=x+1;
			y2=y-1;
			if(x2==monde.tailleGrille-10 || x2==9){x2=x;}
			if(y2==monde.tailleGrille-10 || y2==9){y2=y;}
		}
		
		////////////ANALYSE DE L'ARRIVEE/////////////////
		ArrayList vecteurArrivee=monde.grille[x2][y2];
		Point coordonneesPt=analyseMouvementArrivee(this,vecteurArrivee,x,y,x2,y2);
		
		//System.out.println(coordonneesPt.toString());
		double xTest=coordonneesPt.getX();
		double yTest=coordonneesPt.getY();
		//System.out.println(xTest);
		
		x2=(int)xTest;
		y2=(int)yTest;
		
		
		
		
		////////////DEPLACEMENT///////////////////////////
		//System.out.println("X:"+x+" Y:"+y+"   X2:"+x2+" Y2:"+y2);
		monde.grille[x][y].remove(this);
		monde.grille[x2][y2].add(this);	
		monde.perso.setCooX(x2);
		monde.perso.setCooY(y2);
		
		
		//////////Bruits de pas//////////////
		
		if(!getVolant() && monde.bruitPas){
		
			if(marqueurSonPas==false){
			
				
				
				new ThreadSon(pas1,0).start();
				marqueurSonPas=true;
			}
			else{
				
				
				
				new ThreadSon(pas2,0).start();
				marqueurSonPas=false;
			}
		
		}
		
		
		
		//monde.jeuPan.repaint();
						
		
		if(getStealthmode()){/////le mode discretion coute un tour en plus
			testerCompteurRapidite();
			//testerCompteurRapidite();
		}
		
		
		testerCompteurRapidite();
		analyseDuSol(x2,y2);
		
		
		
		
		///////////////Test Voyage Vertical////////////////
		if(voyage!=0){monde.voyageHorizontal(voyage);}
		
	}
	

	//////////////////////////////////////////////////////////////////////////////////
	///
	//////////////////////////////////////////////////////////////////////////////////
	public Point analyseMouvementArrivee(Entite persoEntite,ArrayList vectDestination,int xDep,int yDep,int xDest,int yDest){
			
			Point pointCoord=new Point(0,0);
			
			boolean blocage=false;
			
			
			
			if(!vectDestination.isEmpty()){
				
				
				for(int i=0;i<vectDestination.size();i++){
					
		 					
	 			try{
	 					
	 					
	 					objet = (Entite)vectDestination.get(i);
						
						typedelobjet=objet.getTypeObjet();
						
							
							
						if(typedelobjet.compareTo("Water")==0 || typedelobjet.compareTo("Passage")==0 || typedelobjet.compareTo("Obstacle")==0 || objet.getClass().getName().compareTo("Gate")==0 || typedelobjet.compareTo("Creature")==0){
						
							
							if(!getPasseMuraille()&&objet.getClass().getName().compareTo("Gate")==0){
								
								if(objet.getCasse()==false){
									blocage=true;
									
									if(objet.getOuvert()==false){
										blocage=true;
									}
									else{blocage=false;
								}		
								}
								else{blocage=false;
								}
									
							}
							
							
							if(!getPasseMuraille()&&typedelobjet.compareTo("Obstacle")==0 && objet.getCasse()==false){
								blocage=true;
								
							}
							
							
							//***********
							if(!getPasseMuraille()&&typedelobjet.compareTo("Water")==0){
								blocage=true;
								//System.out.println("EAU");
								
							}
							
							if(typedelobjet.compareTo("Passage")==0 && !objet.getCasse()){
								blocage=false;
							}
							//***********
							
								//////////////ATTAQUE !!!!!!
							if(typedelobjet.compareTo("Creature")==0 && objet.getMort()==false){
								blocage=true;
								setStealthmode(false);
								dureeEffetInvisibility=0;
								monde.combatMelee(persoEntite,objet,xDest,yDest);
							}
								
						}	
					
					}
					catch(NoSuchElementException exc){};
				}
				
			}
			
			
			if(blocage==true){
				pointCoord=new Point(xDep,yDep);
			}
			else{
				pointCoord=new Point(xDest,yDest);
			}
			return pointCoord;
			
	}

	
	///////////////////////////////////////////////////////////////////////////////////
	//////////////////////////ANALYSE DU SOL///////////////////////////////////////////
	///////////////////////////////////////////////////////////////////////////////////
	public void analyseDuSol(int xAct,int yAct){///////
		
		//dansLeVide=false;
		
		
		boolean descenteDouce=false;
		
		estDehors=true;
		
		if(!monde.grille[xAct][yAct].isEmpty()){
				
				
			for(int i=0;i<monde.grille[xAct][yAct].size();i++){
					
		 					
	 			try{
	 					
	 					
	 				objet = (Entite) monde.grille[xAct][yAct].get(i);
 					
 					
					//if(objet.getClass().getName().compareTo("VraiVide")==0){
					//	dansLeVide=true;
					//}
					
					
					// on affiche dans la zone de message ce qui est au sol
					if(objet.getClass().getName().compareTo("VraiVide")!=0 && objet.getClass().getName().compareTo("Vide")!=0 && objet.getClass().getName().compareTo("Ombrage")!=0 && objet.getTypeObjet().compareTo("PJ")!=0 && objet.getClass().getName().compareTo("Surface")!=0){
						//message("Au sol : "+typedelobjet+" "+strType+"  Poids:"+objet.getPoids());
						if(objet.getPoids()!=100000000){
							message("Au sol : "+objet.getNom()+"  Poids:"+objet.getPoids(),false);
							message("Ground : "+objet.getNomE()+"  Wt:"+objet.getPoids(),true);
						}
						else{message("Au sol : "+objet.getNom(),false);message("Ground : "+objet.getNomE(),true);
						}
						
				
					}
					
					///Pour savoir si le perso est à l'abri
					if(objet.getClass().getName().compareTo("Surface")==0){
						if(objet.getInterieur()){
							estDehors=false;
						}
							
					}
					
					
					
					/////////MONTER/DESCENDRE//////////
					if(objet.getModele().compareTo("trou")==0 || objet.getModele().compareTo("standardstairUP")==0 || objet.getModele().compareTo("standardstairDOWN")==0){
					
						if(objet.getModele().compareTo("standardstairUP")==0){
							
							if(ordreString.compareTo("monter")==0){
								message("Vous montez",false);
								message("You go up",true);
								new ThreadSon("./sons/upstairs.wav",0).start();
								testerCompteurRapidite();
								monde.voyageVertical(true);
							}
						}
						
						
						if(objet.getModele().compareTo("trou")==0 || objet.getModele().compareTo("standardstairDOWN")==0){
							
							if(ordreString.compareTo("descendre")==0){
								message("Vous descendez",false);
								message("You go down",true);
								new ThreadSon("./sons/upstairs.wav",0).start();
								descenteDouce=true;
								testerCompteurRapidite();
								monde.voyageVertical(false);
							}
						}
					}
					///////////////////////////////////
					
					//////MARCHE SUR UN PIEGE ////////////
					if(!descenteDouce && objet.getClass().getName().compareTo("Piege")==0 &&!getVolant()&& !getPasseMuraille()){
						monde.declencheurPiege(this,objet,xAct,yAct);
					}
					
					
					
					
					/////////CHANGEMENT SON PAS//////////////
					
					if(objet.getBruitagPas()==1){ //herbe
						pas1="./sons/step1.wav";
						pas2="./sons/step2.wav";
					}
					
					if(objet.getBruitagPas()==2){ //sol
						pas1="./sons/pas_dur1.wav"; 
						pas2="./sons/pas_dur2.wav";
					}
					
					
						
				}
				catch(NoSuchElementException exc){};
			 }
			 
		}
		ordreString="";
		
		//System.out.println("DANS LE VIDE "+dansLeVide);
		//System.out.println(" VOLANT "+getVolant());
		
		// dans le vide
		/*if(getDansLeVide() && !getVolant()){
			message("YOU FALL !!! .....and die",true);
			message("Vous tombez !!! .....et vous ecrasez",false);
			new ThreadSon("./sons/fall_down_level.wav",0).start();
			setMort(monde,true,0,0);
		}*/
		
		
		
		
	}
	
	
	////////////////////////////////////////////////////
	////////////////////////////////////////////////////
	////////////////////////////////////////////////////
	////////////////////////////////////////////////////
	//////////////Les actions sur cible/////////////////
	////////////////////////////////////////////////////
	////////////////////////////////////////////////////
	////////////////////////////////////////////////////
	////////////////////////////////////////////////////
	////////////////////////////////////////////////////
	public void actionSurCible(Entite outil,Point targetPoint){
		
		//System.out.println("CIBLE= "+targetPoint.toString());
		
		
		
		
		///////////MAGIC MISSILE
		if(ordreString.compareTo("magicMissile")==0){
			
			tirMagique(outil,(int)targetPoint.getX(),(int)targetPoint.getY(),getCooX(),getCooY());
		}
		
		
		
		
		
		
		////////////ACTIVER/////////////////////////
		if(ordreString.compareTo("activer")==0){
			
			SelecteurObjetAuSol selecteurSolDialog=new SelecteurObjetAuSol(monde,(int)targetPoint.getX(),(int)targetPoint.getY());
		}
		
		
		
					
					
		//////////////LANCER////////////////////
		if(ordreString.compareTo("lancer")==0){
			
			lancerObjet(outil,(int)targetPoint.getX(),(int)targetPoint.getY(),getCooX(),getCooY());
			
		}
					
		
		
		
		///////////////////////////////////////////////////
		///////////////////////////////////////////////////
		///////////////////////////////////////////////////
		boolean presenceMur=false;
		boolean presenceTrou=false;
		
		//analyse des objets aux coord cible
	
		if(!monde.grille[(int)targetPoint.getX()][(int)targetPoint.getY()].isEmpty()){
			
 					////////////////////////////////////////////////////
					///////////ACTIONS//////////////////////////////////
					//////////Selon ordre et selon getTypeObjet()///////
					
					
			for(int i=0;i<monde.grille[(int)targetPoint.getX()][(int)targetPoint.getY()].size();i++){
					
		 					
	 			try{
	 					
	 					
	 				objetCible = (Entite) monde.grille[(int)targetPoint.getX()][(int)targetPoint.getY()].get(i);		
					
					//////////Prealable à CREUSER////////////////////
					if(chercheEntiteBool("Escalier",(int)targetPoint.getX(),(int)targetPoint.getY()) || chercheEntiteBool("Gate",(int)targetPoint.getX(),(int)targetPoint.getY()) || objetCible.getTypeObjet().compareTo("Obstacle")==0){presenceMur=true;
					}
					if(objetCible.getModele().compareTo("trou")==0){presenceTrou=true;
					}
					
					
					
					
					/*
					//////////REGARDER////////////////////
					if(ordreString.compareTo("look")==0){
						if(objetCible.getVisible() && objetCible.getClass().getName().compareTo("Vide")!=0 && objetCible.getClass().getName().compareTo("Ombrage")!=0 && objetCible.getTypeObjet().compareTo("PJ")!=0 && objetCible.getClass().getName().compareTo("Surface")!=0){
	
							int diff=(objetCible.getNiveau()-this.getNiveau())*7;
							int jet=roll();
							int score=(identification*jet)-diff;
							
							new LookJDialog(monde,monde.jeuPan.lang,objetCible,Math.round(score/10));
							
							testerCompteurRapidite();
							
							
						}
					}
					*/
										
					
					
					
					
					
					/////////TRAP/UNTRAP/////////////////////
					if(ordreString.compareTo("trapUntrap")==0){
						if(objetCible.getVisible() && objetCible.getTypeObjet().compareTo("Piege")==0){
							if(!objetCible.getCasse()){
							
								if(objetCible.getActifPiege()){
									message("Complexite "+objetCible.getComplexitePiege(),false);
									message("Complexity "+objetCible.getComplexitePiege(),true);
									
									//int jet=rollxdy(1,100,true);
									int de=roll();
									int result=de*pieges;
									int finalResult=result-objetCible.getComplexitePiege();
									message("Votre jet final "+finalResult,false);
									message("Final roll "+finalResult,true);
									
									if(finalResult>=0){
										new ThreadSon("./sons/unlock.wav",0).start();
										message("Vous le desactivez",false);
										message("Successfull untrap",true);
										
										objetCible.setActifPiege(false);
									}
									else if(finalResult<=-30 || de==2){ //FUMBLE
										message("Attention, il se declencher !",false);
										message("It s triggered !",true);
										
										monde.declencheurPiege(this,objetCible,(int)targetPoint.getX(),(int)targetPoint.getY());
									}
									else{
										new ThreadSon("./sons/step4.wav",0).start();
										message("Rate",false);
										message("Failure",true);
									}
								}
								
								
								else{
									
									message("Vous l activez",false);
									message("You activate it",true);
									
									objetCible.setActifPiege(true);
								}
							}
							else{
								message("Impossible c est casse",false);
								
								message("You cant, it s broken",true);
							}
							
							
							testerCompteurRapidite();
							testerCompteurRapidite();
							
						}
					}
					
					
					
					//////////////CROCHETER////////////////////
					if(ordreString.compareTo("crocheter")==0){
						
 						if(objetCible.getVisible() && objetCible.getVerrouillable() && (objetCible.getClass().getName().compareTo("Gate")==0 || (objetCible.getClass().getName().compareTo("Contenant")==0) )){
 							
 							 crocheterCible(outil,objetCible,(int)targetPoint.getX(),(int)targetPoint.getY());
 							
 						}
 						
					}
					
					
					//OUVERTURE/FERMETURE
 					if(ordreString.compareTo("open")==0 || ordreString.compareTo("close")==0){
 						
 						
 						
 						if(objetCible.getVisible() && (objetCible.getClass().getName().compareTo("Gate")==0 || objetCible.getClass().getName().compareTo("Contenant")==0)){
 						
 						
 							//System.out.println("Verrouillable "+objetCible.getVerrouillable());
 							
 							
	 						if(ordreString.compareTo("open")==0){
								
								ouvertureGate(objetCible);
								//testerCompteurRapidite();
							}
							
							if(ordreString.compareTo("close")==0 && objetCible.getVerrouillable()){
								
								fermetureGate(objetCible);
								//testerCompteurRapidite();
							}
 						}
 						else{
 							
 							//System.out.println("Impossible");
 							//System.out.println("puisque c est "+objetCible.getNom()+ "!!");
 						}
 						
 					}
					////////////////////////////////////////////////////
					
					///////////////CASSER A L'AIDE D'UN OUTIL (pioche...)/////////////////////
					if(ordreString.compareTo("casser")==0){
						
						
 						//faire l'inverse= si n'est pas cassable
 						//if(objetCible.getTypeObjet().compareTo("Ecrit")==0 ||objetCible.getTypeObjet().compareTo("Obstacle")==0 ||objetCible.getTypeObjet().compareTo("Comestible")==0 || objetCible.getTypeObjet().compareTo("Objet")==0 || objetCible.getClass().getName().compareTo("Contenant")==0 || objetCible.getClass().getName().compareTo("Gate")==0){
 						if(objetCible.getClass().getName().compareTo("Ombrage")!=0 && objetCible.getClass().getName().compareTo("Vide")!=0 && objetCible.getClass().getName().compareTo("Surface")!=0){
 							
 							casserCible(outil,this,objetCible,(int)targetPoint.getX(),(int)targetPoint.getY());
 							
							testerCompteurRapidite();
 							
 						}
						
					}
					
					
					
					/////////////////KICK///////////////////////////
					if(ordreString.compareTo("kick")==0){
						
						////////!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 						//faire l'inverse= si n'est pas cassable
 						//if(objetCible.getTypeObjet().compareTo("Ecrit")==0 ||objetCible.getTypeObjet().compareTo("Obstacle")==0 ||objetCible.getTypeObjet().compareTo("Comestible")==0 || objetCible.getTypeObjet().compareTo("Objet")==0 || objetCible.getTypeObjet().compareTo("Contenant")==0 ||objetCible.getTypeObjet().compareTo("Creature")==0 || objetCible.getClass().getName().compareTo("Gate")==0 || objetCible.getTypeObjet().compareTo("Mobilier")==0){
 						if(objetCible.getClass().getName().compareTo("Ombrage")!=0 && objetCible.getClass().getName().compareTo("Vide")!=0 && objetCible.getClass().getName().compareTo("Surface")!=0){
 						
 						
 							monde.kickerCible(this,objetCible,(int)targetPoint.getX(),(int)targetPoint.getY());
 						
							testerCompteurRapidite();
 							
 						}
						
					}
					
					
					
					///////////////////////////////////////////////////
					
				}
				catch(NoSuchElementException exc){};
			}
		}
		
		
		///////////////////////////////////////////////////
		///////////////////////////////////////////////////
		/////////CREUSER///////////////////////////
		if(ordreString.compareTo("creuser")==0 && !presenceMur && !presenceTrou){
			
			
			
			boolean peutPlacer=true;
			
			testerCompteurRapidite();
			testerCompteurRapidite();
			testerCompteurRapidite();
			testerCompteurRapidite();
			
			
			new ThreadSon("./sons/dig.wav",0).start();
			
			//fait tomber les objets qui sont au dessus
			for(int i=0;i<monde.grille[(int)targetPoint.getX()][(int)targetPoint.getY()].size();i++){
					
		 					
	 			try{
	 						
	 				objetCible = (Entite) monde.grille[(int)targetPoint.getX()][(int)targetPoint.getY()].get(i);		
					
					if(objetCible.getClass().getName().compareTo("Gate")!=0 && objetCible.getModele().compareTo("standardpierretombale")!=0 && objetCible.getClass().getName().compareTo("Piege")!=0 && objetCible.getTypeObjet().compareTo("Creature")!=0 && objetCible.getClass().getName().compareTo("Vide")!=0 && objetCible.getClass().getName().compareTo("Ombrage")!=0 && objetCible.getTypeObjet().compareTo("PJ")!=0 && objetCible.getClass().getName().compareTo("Surface")!=0){
						
						monde.grille[(int)targetPoint.getX()][(int)targetPoint.getY()].remove(objetCible);
						
					}
					
					/*
					if(objetCible.getTypeObjet().compareTo("Creature")==0 && objetCible.getMort()){
						monde.grille[(int)targetPoint.getX()][(int)targetPoint.getY()].remove(objetCible);
						
					}*/
					
					if(!chercheEntiteBool("UndeadCategory",(int)targetPoint.getX(),(int)targetPoint.getY()) && objetCible.getModele().compareTo("standardpierretombale")==0){
						UndeadCategory skel=new UndeadCategory(true,"lesser skeleton","Un squelette","A skeleton",false,"Creature",true,"./images/creatures/undead/funkysquelette.gif","./images/creatures/bones.gif","./sons/gravel.wav");
						skel.setCooX((int)targetPoint.getX());
						skel.setCooY((int)targetPoint.getY());
						monde.grille[(int)targetPoint.getX()][(int)targetPoint.getY()].add(skel);
						message("Vous deterrez un squelette",false);
						message("You find a skeleton",true);
						
						peutPlacer=false;
					}
					
					if(objetCible.getModele().compareTo("standardpierretombale")==0){
						peutPlacer=false;
					}
					
					
					
					
					if(objetCible.getClass().getName().compareTo("Piege")==0){
						monde.declencheurPiege(this,objetCible,this.getCooX(),this.getCooY());
						peutPlacer=false;
					}
					
				}
				catch(NoSuchElementException exc){};
			}
			
			
			if(peutPlacer){	
				monde.grille[(int)targetPoint.getX()][(int)targetPoint.getY()].add(new Piege(monde,false,0,Math.round((this.getForce()+this.getDexterite())/2),true,0,false,"trou","Un trou","A hole","Piege",true,"./images/pieges/trou.gif","./sons/fall_down_level.wav"));
			}
			
			
			
			
			
			////////DEGATS SUR L'OUTIL-CREUSER/////////
			dommageEquip=(int)(Math.random()*30*indexTerrainZ*-1)-outil.getResistanceMat();
			
			if(dommageEquip>0){
				outil.setStructureMat(outil.getStructureMat()-Math.abs(Math.round(dommageEquip/5)));
			}
			
			if(outil.getStructureMat()<=0){
				outil.setCasse(true);
			}
			/////////////////////////////////
			//System.out.println("Resistance outil "+outil.getResistanceMat()+" Structure outil "+outil.getStructureMat());
			
			
			testerCompteurRapidite();
			///le dernier sur un total de 5 testerCompteurRapidite, le dernier sert à actualiser sir
			//le perso est mort
			
			
		}
		
		
	
		
	}
	
	
	//////////////////////////////////////////////////////////
	///////////////TIR MAGIQUE/////////////////////////////////////
	//////////////////////////////////////////////////////////
	
	
	public void tirMagique(Entite outil,int dx,int dy,int x, int y){
			
			//message("MAGIC MISSILE :"+outil.getNomE()+" Dmg sort "+outil.getMissileDmg(),true);
			//System.out.println("TIR MAGIQUE FCT");
			//System.out.println("MAGIC MISSILE :"+outil.getNomE()+" Dmg sort "+outil.getMissileDmg());
			
			int dist=outil.getPortee();
			int d=distance; // skill touche
			
			Point dirPt=new Point(0,0);
			Point ciblePt=new Point(0,0);
			Point ligneTir[];
			Entite ici=new Entite();
			boolean touched=false;
			
			int jetAtk=roll();
			int jetDef=roll();
			
			int domBase=0;
			
			
			
			int cX=0;
			int cY=0;
			
			//if(dist>0){
				
				//testerCompteurRapidite();
			
				//new ThreadSon("./sons/slash.wav",0).start();
				
				if(dx==x+1){
					if(dy==y){//message("E");
						dirPt=new Point(monde.tailleGrille-11,y);
					}
					
					if(dy==y+1){//message("SE");
						for(cX=x;cX<=monde.tailleGrille-11;cX++){
							for(cY=y;cY<=monde.tailleGrille-11;cY++){
							
								if(Math.abs(cX-x)==Math.abs(cY-y)){
									dirPt=new Point(cX,cY);
								}
							}	
						}
					}
					
					if(dy==y-1){//message("NE");
						for(cX=x;cX<=monde.tailleGrille-11;cX++){
							for(cY=y;cY>=10;cY--){
							
								if(Math.abs(cX-x)==Math.abs(cY-y)){
									dirPt=new Point(cX,cY);
								}
							}	
						}
					}	
				}
				
				//////////////////////////////////////
				//////////////////////////////////////
				if(dx==x){
					if(dy==y){//message("SELF");
						dirPt=new Point(x,y);
					}
					//////////////////////////////////////
					if(dy==y+1){//message("S");
						dirPt=new Point(x,monde.tailleGrille-11);
					}
					//////////////////////////////////////
					if(dy==y-1){//message("N");
						dirPt=new Point(x,10);
					}
				}
				
				
				//////////////////////////////////////
				//////////////////////////////////////
				if(dx==x-1){
					if(dy==y){//message("O");
						dirPt=new Point(10,y);
					}
					//////////////////////////////////////	
					if(dy==y+1){//message("SO");
						for(cX=x;cX>=10;cX--){
							for(cY=y;cY<=monde.tailleGrille-11;cY++){
							
								if(Math.abs(cX-x)==Math.abs(cY-y)){
									dirPt=new Point(cX,cY);
								}
							}	
						}
					}
					//////////////////////////////////////
					if(dy==y-1){//message("NO");
						for(cX=x;cX>=10;cX--){
							for(cY=y;cY>=10;cY--){
							
								if(Math.abs(cX-x)==Math.abs(cY-y)){
									dirPt=new Point(cX,cY);
								}
							}	
						}
					}
				}
				
				
				//System.out.println("CIBLE X "+dirPt.getX());
				//System.out.println("CIBLE Y "+dirPt.getY());
					
				//remove(outil);
				
				ligneTir=bresenham_line(new Point(x,y),dirPt);
				
				/*
				if(outil.getMissileDmg()>outil.getPoids()){domBase=Math.round(getForce()/10)+outil.getMissileDmg();
				}
				else{domBase=Math.round(getForce()/10)+outil.getPoids();
				}
				*/
				
				
				for(int b=0;b<ligneTir.length && b<=dist && !touched;b++){
    			
	    			ciblePt=ligneTir[b];
	    			
	    			
	    			
					//parcours dans ciblePt
					for(int z=0;z<monde.grille[(int)ciblePt.getX()][(int)ciblePt.getY()].size();z++){
						
			 			try{
			 					
			 				ici = (Entite) monde.grille[(int)ciblePt.getX()][(int)ciblePt.getY()].get(z);
							if((ici.getClass().getName().compareTo("Gate")==0 || ici.getTypeObjet().compareTo("Obstacle")==0 || ici.getTypeObjet().compareTo("Creature")==0) && !ici.getCasse() && !ici.getOuvert() && !ici.getMort()){
								message("CIBLE :"+(int)ciblePt.getX()+" "+(int)ciblePt.getY(),false);
								message("TARGET :"+(int)ciblePt.getX()+" "+(int)ciblePt.getY(),true);
								
								touched=true;
							}
							
							//////
							if((ici.getClass().getName().compareTo("Gate")==0 || ici.getTypeObjet().compareTo("Obstacle")==0) && !ici.getCasse() && !ici.getOuvert()){
								
								
								//domBase=d*jetAtk*outil.getMissileDmg();
								
								domBase=((d*jetAtk)-(5*10))*outil.getMissileDmg();
								
								int dmg=domBase-Math.round(ici.getResistanceMat());
								
								if(dmg<0){dmg=0;
								}
								ici.setStructureMat(ici.getStructureMat()-dmg);
								message(dmg+" points de degats structurels",false);
								message(dmg+" structural damage points",true);
								
								
								if(ici.getStructureMat()<=0){
									ici.setCasse(true);
									message("Vous l avez casse",false);
									message("You brake it",true);
								}
								new ThreadSon("./sons/kick.wav",0).start();
								
								
								/*
								if(ici.getResistanceMat()>outil.getResistanceMat()){
									outil.setStructureMat(outil.getStructureMat()-(ici.getResistanceMat()-outil.getResistanceMat()));
								}
								if(outil.getStructureMat()<=0){
									outil.setCasse(true);
								}*/
								
								
								
							}
							
							
							if(ici.getTypeObjet().compareTo("Creature")==0 && !ici.getMort()){
								
								//domBase=outil.getMissileDmg()*jetAtk;
								
								if((d*jetAtk)>(ici.getDexterite()*jetDef)){
									touched=true;
									message(ici.getNom()+" est touche",false);
									message(ici.getNomE()+" is hit",true);
									
									domBase=((d*jetAtk)-(ici.getDexterite()*jetDef))*outil.getMissileDmg();
									
									int dmg=domBase-Math.round(ici.getbonusDefArmure());
									
									if(dmg<0){dmg=0;
									}
									ici.setCurrentHitPts(ici.getCurrentHitPts()-dmg);
									
									message(dmg+" points de degats dans sa mouille",false);
									message(dmg+" damage points in his bloody face",true);
									
									new ThreadSon("./sons/bump.wav",0).start();
									
									
								}
								else{touched=false;
									message(ici.getNom()+" esquive",false);
									message(ici.getNomE()+" dodges",true);
								}
								
								////////////////
								if(ici.getCurrentHitPts()<1){
									ici.setMort(monde,true,(int)ciblePt.getX(),(int)ciblePt.getY());
								
									new ThreadSon("./sons/kill1.wav",0).start();
									
									message(ici.getNom()+" EST MORT",false);
									message(ici.getNomE()+" IS DEAD",true);
									
									//XPS
									message("Vous gagnez "+(ici.getNiveau()*250)+" points d experience",false);
									message("You earn "+(ici.getNiveau()*250)+" experience points",true);
									
									
									setXp(getXp()+(ici.getNiveau()*250));
									testExperience();
								
										
								}
								
								
								if(!ici.getHostilite() && !ici.getMort()){
									ici.setHostilite(true);
									message(ici.getNom()+" devient hostile",false);
									message(ici.getNomE()+" is becoming hostile",true);
								}
								
							}
										
						}
						catch(NoSuchElementException exc){};	
					}
					
					
					
					
					//// gif de lancer
					//if(!touched){
	    			//	monde.animGrid[(int)ciblePt.getX()][(int)ciblePt.getY()]=1;
	    			//}
					
    			}
    			
    			
    			///////////////////////
    			//arrivée//
    			///////////////////////
    			
    			int xanimDest=0;
    			int yanimDest=0;
    			
		    	if(dx==x+1){
					if(dy==y){//message("E");
						if(touched){////
							//monde.grille[(int)ciblePt.getX()-1][(int)ciblePt.getY()].add(outil);
							//message(outil.getNom()+" tombe en "+((int)ciblePt.getX()-1)+" "+(int)ciblePt.getY(),false);
							//message(outil.getNomE()+" falls: "+((int)ciblePt.getX()-1)+" "+(int)ciblePt.getY(),false);
							xanimDest=(int)ciblePt.getX()-1;
							yanimDest=(int)ciblePt.getY();
							
						}
		    			else{/////
		    				if(x+dist<=monde.tailleGrille-11){
		    					//monde.grille[x+dist][y].add(outil);
		    					xanimDest=x+dist;
								yanimDest=y;
		    				}
		    				else{//monde.grille[monde.tailleGrille-11][y].add(outil);
		    					xanimDest=monde.tailleGrille-11;
								yanimDest=y;
		    				}
		    			}
					}
					
					if(dy==y+1){//message("SE");
						if(touched){////
							//monde.grille[(int)ciblePt.getX()-1][(int)ciblePt.getY()-1].add(outil);
							//message(outil.getNom()+"tombe en "+((int)ciblePt.getX()-1)+" "+((int)ciblePt.getY()-1),false);
							//message(outil.getNomE()+"falls "+((int)ciblePt.getX()-1)+" "+((int)ciblePt.getY()-1),true);
							xanimDest=(int)ciblePt.getX()-1;
							yanimDest=(int)ciblePt.getY()-1;
							
						}
		    			else{/////
		    				if(x+dist<=monde.tailleGrille-11 && y+dist<=monde.tailleGrille-11){
		    					//monde.grille[x+dist][y+dist].add(outil);
		    					xanimDest=x+dist;
								yanimDest=y+dist;
		    				}
		    				else{//monde.grille[(int)dirPt.getX()][(int)dirPt.getY()].add(outil);
		    					//System.out.println("objet tombe en "+dirPt.getX()+" "+dirPt.getY());
		    					xanimDest=(int)dirPt.getX();
								yanimDest=(int)dirPt.getY();
		    				}
		    			}
					}
					
					if(dy==y-1){//message("NE");
						if(touched){////
							//monde.grille[(int)ciblePt.getX()-1][(int)ciblePt.getY()+1].add(outil);
							//message(outil.getNom()+"tombe en "+((int)ciblePt.getX()-1)+" "+((int)ciblePt.getY()+1),false);
							//message(outil.getNomE()+"falls "+((int)ciblePt.getX()-1)+" "+((int)ciblePt.getY()+1),true);
							xanimDest=(int)ciblePt.getX()-1;
							yanimDest=(int)ciblePt.getY()+1;
						}
		    			else{/////
		    				if(x+dist<=monde.tailleGrille-11 && y-dist>=10){
		    					//monde.grille[x+dist][y-dist].add(outil);
		    					xanimDest=x+dist;
								yanimDest=y-dist;
		    				}
		    				else{//monde.grille[(int)dirPt.getX()][(int)dirPt.getY()].add(outil);
		    					//System.out.println("objet tombe en "+dirPt.getX()+" "+dirPt.getY());
		    					xanimDest=(int)dirPt.getX();
								yanimDest=(int)dirPt.getY();
		    				}
		    			}
					}	
				}
				//////////////////////////////////////
				if(dx==x){
					if(dy==y){//message("SELF");
						xanimDest=x;
						yanimDest=y;
					}
					//////////////////////////////////////
					if(dy==y+1){//message("S");
						if(touched){////
							//monde.grille[(int)ciblePt.getX()][(int)ciblePt.getY()-1].add(outil);
							//message(outil.getNom()+"tombe en "+((int)ciblePt.getX())+" "+((int)ciblePt.getY()-1),false);
							//message(outil.getNomE()+"falls "+((int)ciblePt.getX())+" "+((int)ciblePt.getY()-1),true);
							xanimDest=(int)ciblePt.getX();
							yanimDest=(int)ciblePt.getY()-1;
							
						}
		    			else{/////
		    				if(y+dist<=monde.tailleGrille-11){
		    					//monde.grille[x][y+dist].add(outil);
		    					xanimDest=x;
								yanimDest=y+dist;
		    				}
		    				else{//monde.grille[x][monde.tailleGrille-11].add(outil);
		    					xanimDest=x;
								yanimDest=monde.tailleGrille-11;
		    				}
		    			}
					}
					//////////////////////////////////////
					if(dy==y-1){//message("N");
						if(touched){////
							//monde.grille[(int)ciblePt.getX()][(int)ciblePt.getY()+1].add(outil);
							//message(outil.getNom()+"tombe en "+((int)ciblePt.getX())+" "+((int)ciblePt.getY()+1),false);
							//message(outil.getNomE()+"falls "+((int)ciblePt.getX())+" "+((int)ciblePt.getY()+1),true);
							xanimDest=(int)ciblePt.getX();
							yanimDest=(int)ciblePt.getY()+1;
						}
		    			else{/////
		    				if(y-dist>9){
		    					//monde.grille[x][y-dist].add(outil);
		    					xanimDest=x;
								yanimDest=y-dist;
		    				}
		    				else{//monde.grille[x][10].add(outil);
		    					xanimDest=x;
								yanimDest=10;
		    				}
		    			}
					}
				}
				
				//////////////////////////////////////
				if(dx==x-1){
					if(dy==y){//message("O");
						if(touched){////
							//monde.grille[(int)ciblePt.getX()+1][(int)ciblePt.getY()].add(outil);
							//message(outil.getNom()+"tombe en "+((int)ciblePt.getX()+1)+" "+((int)ciblePt.getY()),false);
							//message(outil.getNomE()+"falls "+((int)ciblePt.getX()+1)+" "+((int)ciblePt.getY()),true);
							xanimDest=(int)ciblePt.getX()+1;
							yanimDest=(int)ciblePt.getY();	
						}
		    			else{/////
		    				if(x-dist>9){
		    					//monde.grille[x-dist][y].add(outil);
		    					xanimDest=x-dist;
								yanimDest=y;
		    				}
		    				else{//monde.grille[10][y].add(outil);
		    					xanimDest=10;
								yanimDest=y;
		    				}
		    			}
					}
					//////////////////////////////////////	
					if(dy==y+1){//message("SO");
						if(touched){////
							//monde.grille[(int)ciblePt.getX()+1][(int)ciblePt.getY()-1].add(outil);
							//message(outil.getNom()+"tombe en "+((int)ciblePt.getX()+1)+" "+((int)ciblePt.getY()-1),false);
							//message(outil.getNomE()+"falls "+((int)ciblePt.getX()+1)+" "+((int)ciblePt.getY()-1),true);
							xanimDest=(int)ciblePt.getX()+1;
							yanimDest=(int)ciblePt.getY()-1;
						}
		    			else{/////
		    				if(x-dist>=10 && y+dist<=monde.tailleGrille-11){
		    					//monde.grille[x-dist][y+dist].add(outil);
		    					xanimDest=x-dist;
								yanimDest=y+dist;
		    				}
		    				else{//monde.grille[(int)dirPt.getX()][(int)dirPt.getY()].add(outil);
		    					//System.out.println("objet tombe en "+dirPt.getX()+" "+dirPt.getY());
		    					xanimDest=(int)dirPt.getX();
								yanimDest=(int)dirPt.getY();
		    				}
		    			}
					}
					//////////////////////////////////////
					if(dy==y-1){//message("NO");
						if(touched){////
							//monde.grille[(int)ciblePt.getX()+1][(int)ciblePt.getY()+1].add(outil);
							//message(outil.getNom()+"tombe en "+((int)ciblePt.getX()+1)+" "+((int)ciblePt.getY()+1),false);
							//message(outil.getNomE()+"falls "+((int)ciblePt.getX()+1)+" "+((int)ciblePt.getY()+1),true);
							xanimDest=(int)ciblePt.getX()+1;
							yanimDest=(int)ciblePt.getY()+1;
						}
		    			else{/////
		    				if(x-dist>=10 && y-dist>=10){
		    					//monde.grille[x-dist][y-dist].add(outil);
		    					xanimDest=x-dist;
								yanimDest=y-dist;
		    				}
		    				else{//monde.grille[(int)dirPt.getX()][(int)dirPt.getY()].add(outil);
		    					//System.out.println("objet tombe en "+dirPt.getX()+" "+dirPt.getY());
		    					xanimDest=(int)dirPt.getX();
								yanimDest=(int)dirPt.getY();
		    				}
		    			}
					}
					
					
					
				}
		    	
		    	
		    	
		    	
		    	////LE BRUITAGE
				if(outil.getModele().compareTo("firebolt")==0){
					new ThreadSon("./sons/fireballWhoosh.wav",0).start();
					missString="./images/sorts/fire1.gif";
				}
				
				///// LE VISUEL
				monde.jeuPan.terrainPanel.paramTirRender(this.getCooX(),this.getCooY(),xanimDest,yanimDest,missString);
					
			//}
			
			
			//monde.jeuPan.repaint();
		
	}
	
	
	
	
	//////////////////////////////////////////////////////////
	//////////////////////ENLEVE DE L'EQUIPEMENT////////////////(ici pour le lancer,ne repose pas aux pieds du perso)
	//////////////////////////////////////////////////////////
	public void remove(Entite laSelection){
		if(laSelection.getEquiped()==false){
			setEncombrement(getEncombrement()-laSelection.getPoids());
			equipementVect.remove(laSelection);
			//equipementVectNOMS.remove(laSelection.getNomDequipement());
			
			int ec=getVueInitiale();
			 	if(!equipementVect.isEmpty()){
		
					for(Enumeration e = equipementVect.elements();e.hasMoreElements();){
		                
		 				try{	
		 						
		 					objet=(Entite) e.nextElement();
		 					
							if(objet.getAlume() && objet.getEclairage()>=ec){
								ec=objet.getEclairage();	
							}
								
		 				}
		 				catch(NoSuchElementException exc){};
		 			}
		 		}
			 setVue(ec);
			 	
			//Ancienne méthode 	
			//monde.jeuPan.equipementpanel.updateEquipementList(monde,equipementVect);
			
			
			monde.miseAJourResumeStatsPanel();
			//monde.jeuPan.terrainPanel.repaint();
			//monde.jeuPan.repaint();
			
		}
		else{
			message("Impossible, cet objet est equipe",false);
			message("You cant, it s equipped",true);
		}
	}
	
	//////////////////////////////////////////////////////////
	///////////////LANCER/////////////////////////////////////
	//////////////////////////////////////////////////////////
	
	
	public void lancerObjet(Entite outil,int dx,int dy,int x, int y){
			
			
			int poids=outil.getPoids();// distance et dmg
			int f=getForce(); // distance et dmg
			int dist=(int)((f*10)/poids);
			
			int d=distance; // touche
			
			//System.out.println("FORCE "+f);
			//System.out.println("POIDS "+poids);
			//System.out.println("DISTANCE "+distance);
			
			Point dirPt=new Point(0,0);
			Point ciblePt=new Point(0,0);
			Point ligneTir[];
			Entite ici=new Entite();
			boolean touched=false;
			
			int jetAtk=roll();
			int jetDef=roll();
			
			int objetDmgBase=0;
			int domBase=0;
			
			
			
			/*
			outil.getResistanceMat();
			outil.getStructureMat();
			outil.getCurrentHitPts()
			outil.getDefModifiee()
			
			ici.getResistanceMat();
			ici.getStructureMat();
			ici.getCurrentHitPts();
			ici.getbonusDefArmure();
			
			*/
			
			//int atk=attaquant.getAtkModifiee()+jetAtk;
			//int def=defenseur.getDefModifiee()+jetDef;
			//int hitActuelsDef=defenseur.getCurrentHitPts();
			//int degats=atk-def;
			
			int cX=0;
			int cY=0;
			
			if(dist>0){
				
				//testerCompteurRapidite();
			
				new ThreadSon("./sons/slash.wav",0).start();
				
				if(dx==x+1){
					if(dy==y){//message("E");
						dirPt=new Point(monde.tailleGrille-11,y);
					}
					
					if(dy==y+1){//message("SE");
						for(cX=x;cX<=monde.tailleGrille-11;cX++){
							for(cY=y;cY<=monde.tailleGrille-11;cY++){
							
								if(Math.abs(cX-x)==Math.abs(cY-y)){
									dirPt=new Point(cX,cY);
								}
							}	
						}
					}
					
					if(dy==y-1){//message("NE");
						for(cX=x;cX<=monde.tailleGrille-11;cX++){
							for(cY=y;cY>=10;cY--){
							
								if(Math.abs(cX-x)==Math.abs(cY-y)){
									dirPt=new Point(cX,cY);
								}
							}	
						}
					}	
				}
				
				//////////////////////////////////////
				//////////////////////////////////////
				if(dx==x){
					if(dy==y){//message("SELF");
						dirPt=new Point(x,y);
					}
					//////////////////////////////////////
					if(dy==y+1){//message("S");
						dirPt=new Point(x,monde.tailleGrille-11);
					}
					//////////////////////////////////////
					if(dy==y-1){//message("N");
						dirPt=new Point(x,10);
					}
				}
				
				
				//////////////////////////////////////
				//////////////////////////////////////
				if(dx==x-1){
					if(dy==y){//message("O");
						dirPt=new Point(10,y);
					}
					//////////////////////////////////////	
					if(dy==y+1){//message("SO");
						for(cX=x;cX>=10;cX--){
							for(cY=y;cY<=monde.tailleGrille-11;cY++){
							
								if(Math.abs(cX-x)==Math.abs(cY-y)){
									dirPt=new Point(cX,cY);
								}
							}	
						}
					}
					//////////////////////////////////////
					if(dy==y-1){//message("NO");
						for(cX=x;cX>=10;cX--){
							for(cY=y;cY>=10;cY--){
							
								if(Math.abs(cX-x)==Math.abs(cY-y)){
									dirPt=new Point(cX,cY);
								}
							}	
						}
					}
				}
				
				
				//System.out.println("CIBLE X "+dirPt.getX());
				//System.out.println("CIBLE Y "+dirPt.getY());
					
				remove(outil);
				
				ligneTir=bresenham_line(new Point(x,y),dirPt);
				
				
				
				
				
				if(outil.getMissileDmg()>outil.getPoids()){objetDmgBase=Math.round(getForce()/10)+outil.getMissileDmg();
				}
				else{objetDmgBase=Math.round(getForce()/10)+outil.getPoids();
				}
				
				//domBase=((d*jetAtk)-(ici.getDexterite()*jetDef))*objetDmgBase;
				
				
				
				for(int b=0;b<ligneTir.length && b<=dist && !touched;b++){
    			
	    			ciblePt=ligneTir[b];
	    			
	    			
	    			
					//parcours dans ciblePt
					for(int z=0;z<monde.grille[(int)ciblePt.getX()][(int)ciblePt.getY()].size();z++){
						
			 			try{
			 					
			 				ici = (Entite) monde.grille[(int)ciblePt.getX()][(int)ciblePt.getY()].get(z);
							if((ici.getClass().getName().compareTo("Gate")==0 || ici.getTypeObjet().compareTo("Obstacle")==0 || ici.getTypeObjet().compareTo("Creature")==0) && !ici.getCasse() && !ici.getOuvert() && !ici.getMort()){
								message("CIBLE :"+(int)ciblePt.getX()+" "+(int)ciblePt.getY(),false);
								message("TARGET :"+(int)ciblePt.getX()+" "+(int)ciblePt.getY(),true);
								
								touched=true;
							}
							
							//////
							if((ici.getClass().getName().compareTo("Gate")==0 || ici.getTypeObjet().compareTo("Obstacle")==0) && !ici.getCasse() && !ici.getOuvert()){
								
								domBase=((d*jetAtk)-(5*10))*objetDmgBase;
								
								int dmg=domBase-Math.round(ici.getResistanceMat());
								if(dmg<0){dmg=0;
								}
								ici.setStructureMat(ici.getStructureMat()-dmg);
								message(dmg+" points de degats structurels",false);
								message(dmg+" structural damage points",true);
								
								
								if(ici.getStructureMat()<=0){
									ici.setCasse(true);
									message("Vous l avez casse",false);
									message("You brake it",true);
								}
								new ThreadSon("./sons/kick.wav",0).start();
								
								
								
								if(ici.getResistanceMat()>outil.getResistanceMat()){
									outil.setStructureMat(outil.getStructureMat()-(ici.getResistanceMat()-outil.getResistanceMat()));
								}
								if(outil.getStructureMat()<=0){
									outil.setCasse(true);
								}
								
								
								
							}
							
							
							if(ici.getTypeObjet().compareTo("Creature")==0 && !ici.getMort()){
								if((d*jetAtk)>(ici.getDexterite()*jetDef)){
									touched=true;
									message(ici.getNom()+" est touche",false);
									message(ici.getNomE()+" is hit",true);
									
									//domBase=((d*jetAtk)-(ici.getDexterite()*jetDef))*outil.getMissileDmg();
									
									domBase=((d*jetAtk)-(ici.getDexterite()*jetDef))*objetDmgBase;
									
									int dmg=domBase-Math.round(ici.getbonusDefArmure());
									
									if(dmg<0){dmg=0;
									}
									ici.setCurrentHitPts(ici.getCurrentHitPts()-dmg);
									
									message(dmg+" points de degats dans sa mouille",false);
									message(dmg+" damage points in his bloody face",true);
									
									new ThreadSon("./sons/bump.wav",0).start();
									
									
								}
								else{touched=false;
									message(ici.getNom()+" esquive",false);
									message(ici.getNomE()+" dodges",true);
								}
								
								////////////////
								if(ici.getCurrentHitPts()<1){
									ici.setMort(monde,true,(int)ciblePt.getX(),(int)ciblePt.getY());
								
									new ThreadSon("./sons/kill1.wav",0).start();
									
									message(ici.getNom()+" EST MORT",false);
									message(ici.getNomE()+" IS DEAD",true);
									
									//XPS
									message("Vous gagnez "+(ici.getNiveau()*250)+" points d experience",false);
									message("You earn "+(ici.getNiveau()*250)+" experience points",true);
									
									
									setXp(getXp()+(ici.getNiveau()*250));
									testExperience();
								
										
								}
								
								
								if(!ici.getHostilite() && !ici.getMort()){
									ici.setHostilite(true);
									message(ici.getNom()+" devient hostile",false);
									message(ici.getNomE()+" is becoming hostile",true);
								}
								
							}
										
						}
						catch(NoSuchElementException exc){};	
					}
					
					
					
					
					//// gif de lancer
					//if(!touched){
	    			//	monde.animGrid[(int)ciblePt.getX()][(int)ciblePt.getY()]=1;
	    			//}
					
    			}
    			
    			
    			///////////////////////
    			//l'outil posé au sol//
    			///////////////////////
    			
    			int xanimDest=0;
    			int yanimDest=0;
    			
		    	if(dx==x+1){
					if(dy==y){//message("E");
						if(touched){////
							monde.grille[(int)ciblePt.getX()-1][(int)ciblePt.getY()].add(outil);
							message(outil.getNom()+" tombe en "+((int)ciblePt.getX()-1)+" "+(int)ciblePt.getY(),false);
							message(outil.getNomE()+" falls "+((int)ciblePt.getX()-1)+" "+(int)ciblePt.getY(),false);
							xanimDest=(int)ciblePt.getX()-1;
							yanimDest=(int)ciblePt.getY();
							
						}
		    			else{/////
		    				if(x+dist<=monde.tailleGrille-11){
		    					monde.grille[x+dist][y].add(outil);
		    					xanimDest=x+dist;
								yanimDest=y;
		    				}
		    				else{monde.grille[monde.tailleGrille-11][y].add(outil);
		    					xanimDest=monde.tailleGrille-11;
								yanimDest=y;
		    				}
		    			}
					}
					
					if(dy==y+1){//message("SE");
						if(touched){////
							monde.grille[(int)ciblePt.getX()-1][(int)ciblePt.getY()-1].add(outil);
							message(outil.getNom()+" tombe en "+((int)ciblePt.getX()-1)+" "+((int)ciblePt.getY()-1),false);
							message(outil.getNomE()+" falls "+((int)ciblePt.getX()-1)+" "+((int)ciblePt.getY()-1),true);
							xanimDest=(int)ciblePt.getX()-1;
							yanimDest=(int)ciblePt.getY()-1;
							
						}
		    			else{/////
		    				if(x+dist<=monde.tailleGrille-11 && y+dist<=monde.tailleGrille-11){
		    					monde.grille[x+dist][y+dist].add(outil);
		    					xanimDest=x+dist;
								yanimDest=y+dist;
		    				}
		    				else{monde.grille[(int)dirPt.getX()][(int)dirPt.getY()].add(outil);
		    					//System.out.println("objet tombe en "+dirPt.getX()+" "+dirPt.getY());
		    					xanimDest=(int)dirPt.getX();
								yanimDest=(int)dirPt.getY();
		    				}
		    			}
					}
					
					if(dy==y-1){//message("NE");
						if(touched){////
							monde.grille[(int)ciblePt.getX()-1][(int)ciblePt.getY()+1].add(outil);
							message(outil.getNom()+" tombe en "+((int)ciblePt.getX()-1)+" "+((int)ciblePt.getY()+1),false);
							message(outil.getNomE()+" falls "+((int)ciblePt.getX()-1)+" "+((int)ciblePt.getY()+1),true);
							xanimDest=(int)ciblePt.getX()-1;
							yanimDest=(int)ciblePt.getY()+1;
						}
		    			else{/////
		    				if(x+dist<=monde.tailleGrille-11 && y-dist>=10){
		    					monde.grille[x+dist][y-dist].add(outil);
		    					xanimDest=x+dist;
								yanimDest=y-dist;
		    				}
		    				else{monde.grille[(int)dirPt.getX()][(int)dirPt.getY()].add(outil);
		    					//System.out.println("objet tombe en "+dirPt.getX()+" "+dirPt.getY());
		    					xanimDest=(int)dirPt.getX();
								yanimDest=(int)dirPt.getY();
		    				}
		    			}
					}	
				}
				//////////////////////////////////////
				if(dx==x){
					if(dy==y){//message("SELF");
						xanimDest=x;
						yanimDest=y;
					}
					//////////////////////////////////////
					if(dy==y+1){//message("S");
						if(touched){////
							monde.grille[(int)ciblePt.getX()][(int)ciblePt.getY()-1].add(outil);
							message(outil.getNom()+" tombe en "+((int)ciblePt.getX())+" "+((int)ciblePt.getY()-1),false);
							message(outil.getNomE()+" falls "+((int)ciblePt.getX())+" "+((int)ciblePt.getY()-1),true);
							xanimDest=(int)ciblePt.getX();
							yanimDest=(int)ciblePt.getY()-1;
							
						}
		    			else{/////
		    				if(y+dist<=monde.tailleGrille-11){
		    					monde.grille[x][y+dist].add(outil);
		    					xanimDest=x;
								yanimDest=y+dist;
		    				}
		    				else{monde.grille[x][monde.tailleGrille-11].add(outil);
		    					xanimDest=x;
								yanimDest=monde.tailleGrille-11;
		    				}
		    			}
					}
					//////////////////////////////////////
					if(dy==y-1){//message("N");
						if(touched){////
							monde.grille[(int)ciblePt.getX()][(int)ciblePt.getY()+1].add(outil);
							message(outil.getNom()+" tombe en "+((int)ciblePt.getX())+" "+((int)ciblePt.getY()+1),false);
							message(outil.getNomE()+" falls "+((int)ciblePt.getX())+" "+((int)ciblePt.getY()+1),true);
							xanimDest=(int)ciblePt.getX();
							yanimDest=(int)ciblePt.getY()+1;
						}
		    			else{/////
		    				if(y-dist>9){
		    					monde.grille[x][y-dist].add(outil);
		    					xanimDest=x;
								yanimDest=y-dist;
		    				}
		    				else{monde.grille[x][10].add(outil);
		    					xanimDest=x;
								yanimDest=10;
		    				}
		    			}
					}
				}
				
				//////////////////////////////////////
				if(dx==x-1){
					if(dy==y){//message("O");
						if(touched){////
							monde.grille[(int)ciblePt.getX()+1][(int)ciblePt.getY()].add(outil);
							message(outil.getNom()+" tombe en "+((int)ciblePt.getX()+1)+" "+((int)ciblePt.getY()),false);
							message(outil.getNomE()+" falls "+((int)ciblePt.getX()+1)+" "+((int)ciblePt.getY()),true);
							xanimDest=(int)ciblePt.getX()+1;
							yanimDest=(int)ciblePt.getY();	
						}
		    			else{/////
		    				if(x-dist>9){
		    					monde.grille[x-dist][y].add(outil);
		    					xanimDest=x-dist;
								yanimDest=y;
		    				}
		    				else{monde.grille[10][y].add(outil);
		    					xanimDest=10;
								yanimDest=y;
		    				}
		    			}
					}
					//////////////////////////////////////	
					if(dy==y+1){//message("SO");
						if(touched){////
							monde.grille[(int)ciblePt.getX()+1][(int)ciblePt.getY()-1].add(outil);
							message(outil.getNom()+" tombe en "+((int)ciblePt.getX()+1)+" "+((int)ciblePt.getY()-1),false);
							message(outil.getNomE()+" falls "+((int)ciblePt.getX()+1)+" "+((int)ciblePt.getY()-1),true);
							xanimDest=(int)ciblePt.getX()+1;
							yanimDest=(int)ciblePt.getY()-1;
						}
		    			else{/////
		    				if(x-dist>=10 && y+dist<=monde.tailleGrille-11){
		    					monde.grille[x-dist][y+dist].add(outil);
		    					xanimDest=x-dist;
								yanimDest=y+dist;
		    				}
		    				else{monde.grille[(int)dirPt.getX()][(int)dirPt.getY()].add(outil);
		    					//System.out.println("objet tombe en "+dirPt.getX()+" "+dirPt.getY());
		    					xanimDest=(int)dirPt.getX();
								yanimDest=(int)dirPt.getY();
		    				}
		    			}
					}
					//////////////////////////////////////
					if(dy==y-1){//message("NO");
						if(touched){////
							monde.grille[(int)ciblePt.getX()+1][(int)ciblePt.getY()+1].add(outil);
							message(outil.getNom()+" tombe en "+((int)ciblePt.getX()+1)+" "+((int)ciblePt.getY()+1),false);
							message(outil.getNomE()+" falls "+((int)ciblePt.getX()+1)+" "+((int)ciblePt.getY()+1),true);
							xanimDest=(int)ciblePt.getX()+1;
							yanimDest=(int)ciblePt.getY()+1;
						}
		    			else{/////
		    				if(x-dist>=10 && y-dist>=10){
		    					monde.grille[x-dist][y-dist].add(outil);
		    					xanimDest=x-dist;
								yanimDest=y-dist;
		    				}
		    				else{monde.grille[(int)dirPt.getX()][(int)dirPt.getY()].add(outil);
		    					//System.out.println("objet tombe en "+dirPt.getX()+" "+dirPt.getY());
		    					xanimDest=(int)dirPt.getX();
								yanimDest=(int)dirPt.getY();
		    				}
		    			}
					}
				}
		    	
		    	
				monde.jeuPan.terrainPanel.paramTirRender(this.getCooX(),this.getCooY(),xanimDest,yanimDest,outil.getTileStr());
					
			}
			
			//monde.jeuPan.terrainPanel.repaint();
			//monde.jeuPan.repaint();
			
			
			if(dist>0){
				
				testerCompteurRapidite();
			}
		
	}
	
	
	
	
	
	//////////////////////////////////////////////////////////
	///////////////////OUVERTURE//////////////////////////////
	//////////////////////////////////////////////////////////
	public void ouverture(String ordreStr){
		ordreString=ordreStr;
		//System.out.println("ORDRE="+ordreString);
		DirectionJDialog directionDialog=new DirectionJDialog(monde,null);
	
		
		
		
	}
	
	
	////////////////////////////////////////////////////
	////////////////OUVERTURE GATE//////////////////////
	////////////////////////////////////////////////////
	
	public void ouvertureGate(Entite gateTarget){
	
		if(gateTarget.getCasse()==false){
		
			if(gateTarget.getUnlocked()==true){
			
		
				if(gateTarget.getOuvert()==false){
						gateTarget.bruit();
					}
					
				gateTarget.setOuvert(true);
				
				
			}
			else{
				message("C est verrouille",false);
				message("It s locked",true);
				new ThreadSon("./sons/step4.wav",0).start();
			}
	
			//monde.jeuPan.terrainPanel.repaint();
			//monde.jeuPan.repaint();
			
			testerCompteurRapidite();
		}
		else{
			message("Impossible c est casse.",false);
			message("You cant, it s broken.",true);
		}
	}
	
	////////////////////////////////////////////////////
	////////////////FERMETURE GATE//////////////////////
	////////////////////////////////////////////////////
	
	public void fermetureGate(Entite gateTarget){
	
		if(gateTarget.getCasse()==false){
			if(gateTarget.getOuvert()==true){
				gateTarget.bruit();
			}
				
			gateTarget.setOuvert(false);
			
			
			//monde.jeuPan.terrainPanel.repaint();
			//monde.jeuPan.repaint();
			
			testerCompteurRapidite();
		}
		else{
			message("Impossible c est casse.",false);
			message("You cant, it s broken.",true);
		}	
	}
	
	
	
	
	
	/////////////////////////////////////////////////////////////
	////////////////////////CROCHETAGE///////////////////////////
	/////////////////////////////////////////////////////////////
	/////////////////////////////////////////////////////////////
	
	public void crocheterCible(Entite outil,Entite cible,int cx,int cy){
		
		//jeuPan.messagesPanel.remplissageMessages("*********************************");
		
		
		if(cible.getCasse()==false){
		
		
			if(cible.getUnlocked()==false){
			
			
				int jet=roll();
				
				//message("Votre Dex: "+getDexterite()+" Outil :"+outil.getNom()+"(+"+outil.getBonusCrochetage()+")",true);
				//message("serrure :"+cible.getComplexiteSerrure(),true);
				//message("Votre jet: "+(crocheter+outil.getBonusCrochetage()+jet),true);
				
				if((crocheter+outil.getBonusCrochetage())*jet>=cible.getComplexiteSerrure()){
					cible.setUnlocked(true);
					new ThreadSon("./sons/unlock.wav",0).start();
					message("La serrure est deverrouillee",false);
					message("You unlock it",true);
				}
				
				
				
				//if((crocheter+outil.getBonusCrochetage()+jet)-cible.getComplexiteSerrure()>-30 && crocheter+outil.getBonusCrochetage()+jet<cible.getComplexiteSerrure()){
				if((crocheter+outil.getBonusCrochetage())*jet<cible.getComplexiteSerrure()){
				
					new ThreadSon("./sons/step4.wav",0).start();
					message("La serrure resiste",false);
					message("You fail to unlock it",true);
				}
				
				
				if(((crocheter+outil.getBonusCrochetage())*jet)-cible.getComplexiteSerrure()<=-30){
				
					int dom=(cible.getComplexiteSerrure()-(crocheter+outil.getBonusCrochetage()+jet));
					dom=dom-outil.getResistanceMat();
					if(dom>0){
						outil.setStructureMat(outil.getStructureMat()-dom);
						//System.out.println("Struct outils = "+outil.getStructureMat());
						message("Vous endommager vos outils de crochetage !",false);
						message("You are damaging your picking tools!",true);
						
						new ThreadSon("./sons/equip.wav",0).start();
					}
					
				}
				
				
				/*
				else{
				
					new ThreadSon("./sons/step4.wav",0).start();
					message("La serrure resiste",false);
					message("You fail to unlock it",true);
				}*/
				
				
				
			}
			else{
				
				if(cible.getOuvert()==false){
					new ThreadSon("./sons/unlock.wav",0).start();
					message("Vous reverrouillez la serrure",false);
					message("You lock it",true);
					cible.setUnlocked(false);
				}
				else{
					message("Fermez la d abord",false);
					message("Please close it before",true);
				}
			}
			
			
			testerCompteurRapidite();
			testerCompteurRapidite();
			
		
		}
		else{
			message("Impossible, c est casse.",false);
			message("You cant, it s broken.",true);
		}
	}
	
	
	
	
	//////////////////////////////////////////////////////
	////////////////////////CASSER///////////////////////////
	//////////////////////////////////////////////////////
	
	public void casserCible(Entite outil,Entite casseur,Entite cible,int cx,int cy){
		
		if(cible.getStructureMat()>0 && cible.getTypeObjet().compareTo("Creature")!=0 && cible.getClass().getName().compareTo("Vide")!=0 && cible.getClass().getName().compareTo("Personnage")!=0){
		
			//message("Resistance: "+cible.getResistanceMat()+"/ Structure: "+cible.getStructureMat());
			
			int jet=roll();
			
			
			int degats=((casseur.getForce()+Math.round(outil.getBonusAtk()/2))*jet)-cible.getResistanceMat();
			//int degats=casseur.getForce()+jet+outil.getResistanceMat()-cible.getResistanceMat();
			
			if(degats>0){
				cible.setStructureMat(cible.getStructureMat()-degats);
				//message("Degats: "+degats);
				
				if(cible.getClass().getName().compareTo("Piege")==0){
						monde.declencheurPiege(this,cible,this.getCooX(),this.getCooY());
				}
				
				
				
			}
			//else{message("Pathetique...",false);message("You re a funny person...",true);}
			
			
			
			if(cible.getStructureMat()<=0 && cible.getClass().getName().compareTo("Nourriture")!=0){
				
				cible.setCasse(true);
				//cible.setUnlocked(true);
				//cible.setOuvert(true);
				message("Vous l avez casse",false);
				message("You break it",true);
			}
			
			
			
			////////DEGATS SUR L'OUTIL/////////
			dommageEquip=outil.getResistanceMat()-cible.getResistanceMat();
			
			if(dommageEquip<0){
				outil.setStructureMat(outil.getStructureMat()-Math.abs(Math.round(dommageEquip/5)));
			}
			
			if(outil.getStructureMat()<=0){
				outil.setCasse(true);
			}
			/////////////////////////////////
			//System.out.println("Resistance outil "+outil.getResistanceMat()+" Structure outil "+outil.getStructureMat());
			
			
			
			
			new ThreadSon("./sons/kick.wav",0).start();
			
			//monde.jeuPan.terrainPanel.repaint();
			//monde.jeuPan.repaint();
		
		}
		
	}
	
	
	
	
	
	///////////////////////////////////////////////////////
	/////////// JET DE DES/////////////////////////////////
	///////////////////////////////////////////////////////
	/*
	public int rollxdy(int x,int y,boolean openended){
		
		int jet=(int)(Math.abs(Math.random()*y))+1;
		
		int jetFinal=jet*x;
		
		
		//OPEN-ENDED +
		if(openended==true && y==100 && jetFinal>=96){
			
			int jetSup=rollxdy(1,100,true);
			
			jetFinal=jetFinal+jetSup;
			
		}
		
		
		//OPEN-ENDED -
		if(openended==true && y==100 && jetFinal<=4){
			
			int jetSup=rollxdy(1,100,true);
			
			jetFinal=jetFinal-jetSup;
			
		}
		
		
		
		return jetFinal;
		
	}*/
	
	
	
	public int roll(){
		int d1=(int)(Math.abs(Math.random()*10))+1;
		int d2=(int)(Math.abs(Math.random()*10))+1;
		
		int result=d1+d2;
		
		if(d1==1 && d2==1 && !open){
			return result;
		}
		
		if(d1==d2){
			open=true;
			result=result+roll();
		}
		
		open=false;
		
		//System.out.println("JET ="+result);
		return result;
	}
	
	
	
	
	
	public void testExperience(){
		
		xpNiveauSuivant=((niveau+1)*(niveau))*500;
		xpNiveauCourant=niveau*(niveau-1)*500;
		
		int xpNextTemp=xpNiveauSuivant;
		
		//System.out.println("xpNiveauCourant "+xpNiveauCourant);
		//System.out.println("xpNiveauSuivant "+xpNiveauSuivant);
		
		int statPts=0;
		int skillPts=0;
		int maxSkillDev=0;
		int level=niveau;
		
		if(xp>=xpNiveauSuivant){
		
			while(xp>=xpNextTemp){
				
				//xpNiveauCourant=level*(level-1)*500;
				xpNextTemp=((level+1)*(level))*500;
				
				level++;
					
					
			}
			
		}
		
		//System.out.println("*************************");
		//System.out.println("xpNiveauCourant "+xpNiveauCourant);
		//System.out.println("xpNiveauSuivant "+xpNiveauSuivant);
		//System.out.println("xpNextTemp "+xpNextTemp);
		//System.out.println("level "+level);
		
		if(level-1>niveau){
			new ThreadSon("./sons/drain.wav",0).start();
			
			statPts=1*(level-niveau);
			skillPts=5*(level-niveau);
			maxSkillDev=1*(level-niveau);
			
			niveau=level-1;
			message("Vous passez au niveau "+niveau+" !",false);
			message("You rise to level "+niveau+" !",true);
			
			
			xpNiveauSuivant=((niveau+1)*(niveau))*500;
			message("Prochain niveau a "+xpNiveauSuivant+" points d experience",false);
			message("Next level : "+xpNiveauSuivant+" experience points",true);
			
			new LevelUPJDialog(this,monde,statPts-1,skillPts-5,maxSkillDev-1);
		}
		
	}
	
	
	
	public void message(String me,boolean l){
		monde.jeuPan.messagesPanel.remplissageMessages(me,l);
	}
	
	
	
	
	//////////////////////////////////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////
	//////OUTIL DE RECHERCHE GENERIQUE D'ENTITES avec retour booleen//////////
	//////////////////////////////////////////////////////////////////////////
	//////////////////////////////////////////////////////////////////////////
	public boolean chercheEntiteBool(String genre,int x,int y){
		if(!monde.grille[x][y].isEmpty()){
			for(int i=0;i<monde.grille[x][y].size();i++){
	 			try{	
	 				objet = (Entite) monde.grille[x][y].get(i);
	 				
	 				
	 				
					typedelobjet=objet.getTypeObjet();
					strClass = (objet.getClass().getName());
					strModele= objet.getModele();
					
					
					if(typedelobjet.compareTo(genre)==0 || strClass.compareTo(genre)==0 || strModele.compareTo(genre)==0){
						return true;
					}
				}
				catch(NoSuchElementException exc){};
			}
		}
		return false;
	}
	
	
	//////////////////////////////////////////////////////////////////////////
	
	/////////A CORRIGER/////////////////////////////////////////
	/////////A CORRIGER/////////////////////////////////////////
	/////////A CORRIGER/////////////////////////////////////////
	/////////A CORRIGER/////////////////////////////////////////
	/*
	public void miseAJourNomEquipementLANG(boolean la){
		
		if(!equipementVect.isEmpty()){
					
			for(Enumeration e = equipementVect.elements();e.hasMoreElements();){
                
 				try{
 					objet=(Entite) e.nextElement();
					//String classdelobjet=objet.getClass().getName();
					
					if(la){
						objet.setNomDequipement(objet.getNomE());
					}
					else{
						objet.setNomDequipement(objet.getNom());
					}
					
					//if(objet.getEquiped()&& !objet.getAlume()){objet.setNomDequipement("#"+objet.getNomDequipement());}
					//if(objet.getAlume() && !objet.getEquiped()){objet.setNomDequipement("@"+objet.getNomDequipement());}
					//if(objet.getEquiped()&& objet.getAlume()){objet.setNomDequipement("#@"+objet.getNomDequipement());}
					
				}
				catch(NoSuchElementException exc){};
			}
		}
		
		
		
		
		
	}*/
	
	
	
	
	
	
	
	
	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;
    }
	
	
	
	
}