Last changes

src/modeles/Armes.java

@@ -0,0 +1,75 @@
+package modeles;
+/**
+ * Classe permettant de réprésenter les 5 types d'armes disponibles dans le jeu
+ * 
+ * @author courtecuisse
+ *
+ */
+public class Armes {
+	protected int attaque; // Attaque bonus que procure cette arme
+	protected String nom; // Le nom de l'arme
+	protected int niveauMinimum; // Le niveau minimum pour l'utiliser
+	
+	/**
+	 * Constructeur permettant de donner l'arme par defaut une dague avec un attaque.  
+	 * 
+	 */
+	Armes (){
+		this.attaque = 1;
+		this.nom = "Dague";
+		this.niveauMinimum = 1;
+	}
+	
+	
+	public void armeAleatoire (){
+		
+		switch ((int) (Math.random() * 5) + 1)
+		{
+		case 1: 			
+			this.attaque = 2;
+			this.nom = "Epee";
+			this.niveauMinimum = 1; 
+		break;
+		case 2: 			
+			this.attaque = 3;
+			this.nom = "Arbalette";
+			this.niveauMinimum = 1; 
+		break;
+		case 3: 			
+			this.attaque = 4;
+			this.nom = "Hache";
+			this.niveauMinimum = 2;
+		break;
+		case 4:
+			this.attaque = 5;
+			this.nom = "Lance";
+			this.niveauMinimum = 2;
+		break;
+		case 5:
+			this.attaque = 6;
+			this.nom = "Hallebarde";
+			this.niveauMinimum = 3;
+		break;
+		default:
+			this.attaque = 1;
+			this.nom = "Dague";
+			this.niveauMinimum = 1;
+		}
+
+		
+	}
+	
+	public int getAttaque() {
+		return attaque;
+	}
+
+	public String getNom() {
+		return nom;
+	}
+
+	public int getNiveauMinimum() {
+		return niveauMinimum;
+	}
+	
+	
+}

src/modeles/Combat.java

@@ -0,0 +1,360 @@
+package modeles;
+
+
+/**
+ * Classe Représentant un combat entre deux Joueurs. Un combat se déroule entre
+ * 2 joueurs, en 4 rounds, à l'issue desquels il y a un vainqueur et un perdant.
+ * 
+ */
+
+public class Combat {
+
+	private EtatJeu etat; // Répresente l'état du jeu
+
+	public Combat(EtatJeu etat) {
+		this.etat = etat;
+	}
+
+	/**
+	 * Effectue un round, le joueur 1 est l'attaquant et le joueur 2 est le
+	 * défenseur
+	 * 
+	 * @param attaquant
+	 *            L'attaquant du round
+	 * @param defenseur
+	 *            Le défenseur
+	 * @return int -1 Si il y'a eu un mort et le nombre de dégats dans le cas
+	 *         contraire
+	 */
+
+	public int round(Joueur attaquant, Joueur defenseur) {
+		int j1Attaque = attaquant.attaque();
+		int j2Defense = defenseur.seDefend(j1Attaque);
+		int j2PvRestant = defenseur.getPv() - j2Defense;
+
+		// Si le combat n'est pas terminé, on enleve les points de vie a j2
+		// sinon on met ses points de vie a zero et on envoie la solution du
+		// problème.
+		if (!combatFini(j2PvRestant)) {
+
+			defenseur.setPv(j2PvRestant);
+
+			return j2Defense;
+		} else {
+
+			defenseur.setPv(0);
+
+			return -1;
+		}
+	}
+
+	/**
+	 * Cette méthode permet de faire tourner les 4 rounds, deux par deux. Le per
+	 * 
+	 * @return Joueur Le joueur gagnant le round
+	 */
+	public Joueur lancer() {
+
+		// Les variables permettant de gérer le round
+		int solutionRounds = 0; // La solution du round retourne -1 si il y'a eu
+		// un mort ou le dégats du défenseur
+		int nbreRound = 0; // Le nombre de rounds
+
+		int degatsTotalsJ1 = 0, degatsTotalsJ2 = 0; // Contient le total de
+		// dégats de joueur 1 et
+		// joueur 2
+
+		Joueur joueurPerdant = null; // Le joueur qui n'a pas gagné le match
+
+		// Pour économiser de la place et en clarté on fait deux tours par
+		// boucle
+		while (nbreRound <= Ressources.nbRounds && joueurPerdant == null) {
+			// On joue le premier tour joueur 1 est attaquant et joueur 2
+			// défenseur
+
+			solutionRounds = round(etat.getJoueurCourrant(), etat
+					.getJoueurDefense());
+
+			// Si joueur2 n'est pas mort dans le round 1 ou 3
+			if (solutionRounds != -1) {
+				degatsTotalsJ1 += solutionRounds;
+
+				// Deuxième tour, joueur 2 est attaquant et joueur 1 défenseur
+				solutionRounds = round(etat.getJoueurDefense(), etat
+						.getJoueurCourrant());
+
+				// Si joueur1 n'est pas mort dans le round 2 ou 4
+				if (solutionRounds != -1)
+					degatsTotalsJ2 += solutionRounds;
+				else
+					joueurPerdant = etat.getJoueurCourrant();
+
+			} else
+				joueurPerdant = etat.getJoueurDefense();
+
+			nbreRound = nbreRound + 2;
+
+		}
+
+		// Résolution du combat, si il n'y a aucun mort
+		if (joueurPerdant == null) {
+			joueurPerdant = siPasDeGagnant(etat.getJoueurCourrant(), etat
+					.getJoueurDefense(), joueurPerdant, degatsTotalsJ2,
+					degatsTotalsJ1);
+		}
+
+		return joueurPerdant;
+	}
+
+	/**
+	 * verifie si le combat est fini
+	 * 
+	 * @param j2PvRestant
+	 * @return joueurPerdant
+	 */
+	public boolean combatFini(int j2PvRestant) {
+		return j2PvRestant <= 0;
+	}
+
+	/**
+	 * Designe le perdant avec les dégats des joueurs
+	 * 
+	 * @param joueurPerdant
+	 *            Le joueur est normallement a null
+	 * @param degatsTotalsJ2
+	 *            Les dégats totals du joueur 2
+	 * @param degatsTotalsJ1
+	 *            Les dégats totals du joueur 1
+	 * @return joueurPerdant
+	 */
+	public Joueur siPasDeGagnant(Joueur joueur1, Joueur joueur2,
+			Joueur joueurPerdant, int degatsTotalsJ2, int degatsTotalsJ1) {
+
+		// Résolution du combat, si il n'y a aucun mort
+		if (joueurPerdant == null) {
+
+			// Elle se fait par le nombre de dégats infligé par le joueur
+			if (degatsTotalsJ2 == degatsTotalsJ1)
+				joueurPerdant = null;
+			else if (degatsTotalsJ2 > degatsTotalsJ1)
+				joueurPerdant = joueur1;
+			else
+				joueurPerdant = joueur2;
+
+		}
+
+		return joueurPerdant;
+	}
+
+	/**
+	 * Gère le problême égalité parfaite entre les deux joueurs, c'est a dire
+	 * qu'il ont perdu le même nombre de dégats. Les deux joueurs sont
+	 * téléportés sur une case aléatoire un message est aussi affiché dans
+	 * l'interface
+	 * 
+	 * @param positionChoisie
+	 *            Position La position du joueur qui était attqué
+	 * @param joueur
+	 *            Joueur L'attaquant
+	 * 
+	 */
+	public void egalite(Position positionChoisie, Joueur joueur) {
+		etat.getTerrain().getOccupant(positionChoisie).seTeleporte();
+		joueur.seTeleporte();
+
+	}
+
+	/**
+	 * Cas ou l'occupant de la case perd le combat, l'occupant est alors déplacé
+	 * aléatoirement sur le terrain et le gagnant est positionné sur la case
+	 * voulu
+	 * 
+	 * @param joueurPerdant
+	 *            Joueur Le joueur ayant perdu le round
+	 * @param joueur
+	 *            Joueur est l'attaquant
+	 * @param positionChoisie
+	 *            Position La position choisie sur le terrain
+	 * @return joueur Joueur le gagnant
+	 */
+	public Joueur occupantPerd(Joueur joueurPerdant, Joueur joueur,
+			Position positionChoisie) {
+		joueurPerdant.seTeleporte();
+		etat.getTerrain().PositionnerJoueurs(joueur, positionChoisie);
+		return joueur;
+	}
+
+	/**
+	 * Cas ou l'attaquant de la case perd le combat, l'occupant garde sa case et
+	 * l'atatquant est alors déplacé aléatoirement sur le terrain.
+	 * 
+	 * @param joueurPerdant
+	 *            Joueur Le joueur ayant perdu le round
+	 * @param joueur
+	 *            Joueur est l'attaquant
+	 * @param positionChoisie
+	 *            Position La position choisie sur le terrain
+	 * @return joueur Joueur le gagnant
+	 */
+	public Joueur attaquantPerd(Joueur joueurPerdant, Joueur joueur,
+			Position positionChoisie) {
+		joueur = etat.getTerrain().getOccupant(positionChoisie);
+		joueurPerdant.seTeleporte();
+		return joueur;
+	}
+
+	/**
+	 * Resout un combat si un des joueurs est mort pendant le jeu
+	 * 
+	 * @param joueurMort
+	 *            Le joueurMort est celui qui est mort
+	 */
+	public void CombatSiMort(Joueur joueurMort) {
+
+		etat.supprimerArrayListJoueur(joueurMort);
+		etat.getTerrain().getTuile(joueurMort.getPosition()).setOccupant(null);
+		joueurMort.setPosition(null);
+	}
+
+	/**
+	 * Resout un combat si le joueur 2 a encore des vies.
+	 * 
+	 * @param joueurGagnant
+	 *            Le joueurGagnant est celui qui a gagné
+	 * @param joueurPerdant
+	 *            Le joueurPerdant est celui qui a perdu
+	 */
+	public void CombatAvecMortEtRenaissance(Joueur joueurGagnant,
+			Joueur joueurPerdant) {
+		// Combat avec mort et renaissance
+		joueurGagnant
+				.setPv(joueurPerdant.getHeritage() + joueurGagnant.getPv());
+		joueurPerdant.setPv(Ressources.pv);
+	}
+
+	/**
+	 * Resout combat en connaisant le perdant
+	 * 
+	 * @param joueurPerdant
+	 *            Le joueur perdant le round
+	 * 
+	 * @param positionChoisie
+	 *            La position chisie par le joueur l'indice du joueur courant
+	 *            dans l'arrayList
+	 */
+	public void resoudreCombat(Joueur joueurPerdant, Position positionChoisie) {
+		Joueur joueurGagnant = null;
+
+		// Si il y'a pas eu d'égalité, c'est à dire que les joueurs n'ont pas eu
+		// le même nombre de dégats
+		if (joueurPerdant == null)
+			egalite(positionChoisie, etat.getJoueurCourrant());
+		else {
+
+			// Determination du gagnant car pour l'instant on ne connait que le
+			// perdant
+			joueurGagnant = determinerJoueurGagnant(joueurPerdant,
+					positionChoisie);
+
+			// Résolution du combat, si il a eu des morts
+			resolutionCombat(joueurPerdant, joueurGagnant, positionChoisie);
+
+		}
+	}
+
+	/**
+	 * Determine le joueur gagnant du round
+	 * 
+	 * @param joueurPerdant
+	 * @param positionChoisie
+	 * @return joueurGagnant
+	 */
+	public Joueur determinerJoueurGagnant(Joueur joueurPerdant,
+			Position positionChoisie) {
+
+		if (joueurPerdant.getNom() == etat.getJoueurCourrant().getNom())
+			// Si il est gagnant on le positionne sur la case du perdant et
+			// on positionne le perdant sur une case vide
+			return etat.getJoueurDefense();
+		else
+			// Si il n'est pas le gagnant, on le possitione aléatoirement
+			// sur le terrain et l'occupant de la case reste le même
+			return etat.getJoueurCourrant();
+
+	}
+
+	/**
+	 * reolution du combat
+	 * 
+	 * @param joueurPerdant
+	 * @param joueurGagnant
+	 */
+	public void resolutionCombat(Joueur joueurPerdant, Joueur joueurGagnant,
+			Position positionChoisie) {
+
+		// Teste si il doit changer de niveau
+
+		// On met l'expérience en fonction du niveau
+
+			joueurGagnant.setXp(joueurGagnant.getXp() + 1 * 10);
+
+		if (joueurPerdant.getPv() <= 0) {
+			// On enlève une vie au joueur et on rajoute de l'expérience au
+			// gagnant eu perdant
+			joueurPerdant.setNbVies(joueurPerdant.getNbVies() - 1);
+
+			// Si il a encore des vies on le fait renaitre sur une case vide
+			// aléatoire du tableau
+			if (joueurPerdant.getNbVies() >= 0){
+				CombatAvecMortEtRenaissance(joueurGagnant, joueurPerdant);
+
+			// Si il n'a plus de vie on l'élimine du terrain et de
+			// l'ArrayList de joueur
+			}else{
+				CombatSiMort(joueurPerdant);
+				
+				// On met une arme au joueur gagnant
+				Armes arme= new Armes();
+				arme.armeAleatoire();
+				if (arme.getAttaque()>joueurGagnant.getArme().getAttaque() && joueurGagnant.getNiveau()>= arme.getNiveauMinimum())
+					joueurGagnant.setArme(arme);
+				
+			}
+		}
+		if (joueurPerdant.getNbVies() >= 0) {
+			if (joueurPerdant.getNom() == etat.getTerrain().getOccupant(
+					positionChoisie).getNom())
+				occupantPerd(joueurPerdant, etat.getJoueurCourrant(),
+						positionChoisie);
+			else
+				attaquantPerd(etat.getJoueurCourrant(), etat.getTerrain()
+						.getTuile(positionChoisie).getOccupant(),
+						positionChoisie);
+		} else {
+			if (joueurGagnant.getPosition() != positionChoisie) {
+
+				etat.getTerrain().PositionnerJoueurs(joueurGagnant,
+						positionChoisie);
+			}
+
+		}
+
+		siNiveauSuperrieur(joueurGagnant);
+	}
+
+	/**
+	 * On attribut des P att par rapport au niveau du joueur
+	 * 
+	 * @param joueur
+	 */
+	public void siNiveauSuperrieur(Joueur joueur) {
+		
+		if (joueur.getMaxXp() <= joueur.getXp()) {
+			joueur.setXp(0);
+			joueur.setNiveau(joueur.getNiveau() + 1);
+			joueur.setAtt(joueur.getAtt() + 2);
+			joueur.setMaxXp(joueur.getMaxXp()+10);
+		}
+		
+	}
+}

src/modeles/EtatJeu.java

@@ -0,0 +1,115 @@
+package modeles;
+
+import java.util.ArrayList;
+
+import modeles.Joueur;
+import modeles.Terrain;
+import modeles.EtatJeu;
+/**
+ * représente l'état actuel du jeu.
+ * @author abouabdallaoui
+ *
+ */
+public class EtatJeu {
+		/**
+		 * le terrain du jeu
+		 */
+		private Terrain terrain;
+
+		/**
+		 * Les joueurs participant au jeu
+		 */
+		public ArrayList<Joueur> joueurs;
+		/**
+		 * le joueur courrant
+		 */
+		private Joueur joueurCourrant;
+		/**
+		 * le joueur qui se défend
+		 */
+		private Joueur joueurDefense;
+		
+		public EtatJeu(Terrain terrain,ArrayList<Joueur> joueurs){
+			this.terrain= terrain;
+			this.joueurs=joueurs;
+			this.joueurCourrant=this.joueurs.get(0);
+			this.joueurDefense=null;
+		}
+		
+		public Joueur getJoueurCourrant (){
+			return  joueurCourrant;
+		}
+		
+		public void setJoueurCourrant (Joueur joueurCourrant){
+			this.joueurCourrant = joueurCourrant;
+		}
+		
+		public Terrain getTerrain (){
+			return  this.terrain;
+		}
+		
+		public void setTerrain (Terrain terrain){
+			 this.terrain = terrain;
+		}
+		
+		public Joueur getJoueurDefense (){
+			return  this.joueurDefense;
+		}
+		
+		public void setJoueurDefense (Joueur joueur){
+			 this.joueurDefense = joueur;
+		}
+		
+		public ArrayList<Joueur> getJoueurs (){
+			return this.joueurs;
+		}
+		
+		public void setJoueurs (Joueur joueurCourrant){
+			 this.joueurs.add(joueurCourrant);
+		}
+		
+		public void setArrayListJoueurs (ArrayList<Joueur> joueurs){
+			 this.joueurs = joueurs;
+		}
+		/**
+		 * supprimer le joueur de l'arrayList
+		 * @param joueur
+		 */
+		public void supprimerArrayListJoueur(Joueur joueur) {
+
+			for (int i = 0; i < this.joueurs.size(); i++) {
+				if (joueurs.get(i) == joueur) {
+					joueurs.remove(i);
+				}
+			}
+		}
+		
+		/**
+		 * Méthode testant la fin du jeu
+		 * 
+		 * @return true ssi le jeu est terminé
+		 */
+		public boolean jeuFini() {
+			return joueurs.size() == 1;
+		}
+		/**
+		 * passer au premier joueur de la liste
+		 */
+		public void remiseAZero(){
+
+				joueurCourrant=joueurs.get(0);
+			
+		}
+		/**
+		 * permet de passer au joueur suivant dans l'arrayList
+		 */
+		public void passeLeTour() {
+			int index=this.joueurs.indexOf(joueurCourrant);
+			index++;
+			if(index >= joueurs.size()){
+				setJoueurCourrant(joueurs.get(0));
+			}
+			else
+			setJoueurCourrant(joueurs.get(index));
+		}
+}

src/modeles/Joueur.java

@@ -0,0 +1,334 @@
+package modeles;
+
+import java.beans.PropertyChangeListener;
+import java.beans.PropertyChangeSupport;
+
+
+/**
+ * Représente un joueur (réel ou ordi)
+ * 
+ */
+
+public abstract class Joueur {
+
+	private PropertyChangeSupport pcsPointDeVie = new PropertyChangeSupport(
+			this);// pour les points de vie
+	private PropertyChangeSupport pcsXp = new PropertyChangeSupport(this);// pour
+																			// les
+																			// XP
+	private PropertyChangeSupport pcsPa = new PropertyChangeSupport(this);// pour
+																			// les
+																			// Points
+																			// attaque
+	private PropertyChangeSupport pcsNbVies = new PropertyChangeSupport(this);// pour
+																				// les
+																				// points
+																				// de
+																				// Vie
+	private PropertyChangeSupport pcsNiveau = new PropertyChangeSupport(this);// pour
+																				// les
+																				// niveaux
+	private PropertyChangeSupport pcsArme = new PropertyChangeSupport(this);
+	/**
+	 * la position du joueur sur le terrain
+	 */
+	protected int maxXP;
+	protected Position position;
+	/**
+	 * le terrain sur lequel joue le joueur
+	 */
+	protected Terrain terrain;
+	/**
+	 * le nom du joueur
+	 */
+	private String nom = "";
+	/**
+	 * les points de vie du joueur
+	 */
+	protected int pv;
+	/**
+	 * l'xp du joueur
+	 */
+	protected int xp;
+	/**
+	 * la capacité d'attaque du joueur
+	 */
+	protected int att;
+	/**
+	 * l'héritage du joueur
+	 */
+	protected int heritage;
+	/**
+	 * la capacité de deplacement du joueur
+	 */
+	protected int deplacement;
+	/**
+	 * le nombre de vies du joueur
+	 */
+	protected int nbVies;
+	/**
+	 * la défense du joueur
+	 */
+	protected int def;
+	/**
+	 * le niveau du joueur
+	 */
+	protected int niveau;
+	
+	protected int pion;
+	
+	protected Armes arme;
+	
+	public Armes getArme() {
+		return arme;
+	}
+
+	public void setArme(Armes arme) {
+		
+		Armes ancienneArme = this.arme;
+
+		this.arme = arme;
+
+		this.pcsArme
+				.firePropertyChange("arme", ancienneArme, this.arme);
+
+	}
+
+	public int getPion() {
+		return pion;
+	}
+
+	public void setPion(int pion) {
+		this.pion = pion;
+	}
+
+	public Joueur(Terrain terrain, Position position) {
+		this.terrain = terrain;
+		this.position = position;
+		this.pv = Ressources.pv;
+		this.xp = Ressources.xp;
+		this.att = Ressources.att;
+		this.heritage = Ressources.heritage;
+		this.deplacement = Ressources.deplacement;
+		this.nbVies = Ressources.nbVies;
+		this.def = Ressources.def;
+		this.niveau = 1;
+		this.maxXP = 30;
+		this.arme = new Armes () ;
+	}
+
+	/**
+	 * retourne les points de dégats (lancé de dé + capacité d'attaque) qu'il
+	 * peut infliger à son adversaire
+	 * 
+	 * @return int att retourne les points de dégats
+	 */
+	public int attaque() {
+		return lancerDe() + this.att+this.arme.getAttaque();
+	}
+
+	/**
+	 * le défenseur retranche du coup de l'attaquant ses points de défense.
+	 * 
+	 * @param coup
+	 *            représente l'attaque portée par l'attaquant.
+	 * @return les dégats réellement infligés au défenseur.
+	 */
+	public int seDefend(int coup) {
+		if ((coup - this.def) < 0)
+			return 0;
+		else
+			return (coup - this.def);
+	}
+
+	/**
+	 * On voit si le joueur reçoit des dégats
+	 * 
+	 * @param degatsRecus
+	 *            les dégats après décompte de la défense du défenseur.
+	 * @return true si le joueur n'a pas perdu de vie durant le combat.
+	 * */
+	public boolean recoitDegat(int degatsRecus) {
+		return degatsRecus <= 0;
+	}
+
+	/**
+	 * déplace le joueur sur une case vide du terrain choisie aléatoirement
+	 */
+	public void seTeleporte() {
+		Position position = terrain.getTuileVideAleatoire();
+		terrain
+				.PositionnerJoueurs(terrain.getOccupant(this.position),
+						position);
+	}
+
+	/**
+	 * Retourne un nombre aléatoire grâce a Math.random entre 1 et 6
+	 * 
+	 * @return int un nombre entre un 1 et 6
+	 */
+	public int lancerDe() {
+		return (int) (Math.random() * 5) + 1;
+	}
+
+	public Position getPosition() {
+		return position;
+	}
+
+	public Terrain getTerrain() {
+		return terrain;
+	}
+
+	public String getNom() {
+		return nom;
+	}
+
+	public int getPv() {
+		return pv;
+	}
+
+	public int getAtt() {
+		return att;
+	}
+
+	public void setAtt(int att) {
+		int ancienAttaque = this.att;
+
+		this.att = att;
+
+		this.pcsPa.firePropertyChange("pa", ancienAttaque, this.att);
+
+	}
+
+	public int getNbVies() {
+		return nbVies;
+	}
+
+	public int getdef() {
+		return def;
+	}
+
+	public int getXp() {
+		return xp;
+	}
+
+	public void setPosition(Position position) {
+		this.position = position;
+	}
+
+	public void setNom(String nom) {
+		this.nom = nom;
+	}
+
+	public void setPv(int pv) {
+		int ancienPv = this.pv;
+
+		this.pv = pv;
+
+		this.pcsPointDeVie.firePropertyChange("pv", ancienPv, this.pv);
+	}
+
+	public void setXp(int xp) {
+
+		int ancienXp = this.xp;
+
+		this.xp = xp;
+
+		this.pcsXp.firePropertyChange("xp", ancienXp, this.xp);
+	}
+
+	public void setNbVies(int nbVies) {
+
+		int ancienNbreVies = this.nbVies;
+
+		this.nbVies = nbVies;
+
+		this.pcsNbVies
+				.firePropertyChange("nbVies", ancienNbreVies, this.nbVies);
+	}
+
+	public void setNiveau(int niveau) {
+
+		int ancienNiveau = this.niveau;
+
+		this.niveau = niveau;
+
+		this.pcsNiveau.firePropertyChange("niveau", ancienNiveau, this.niveau);
+	}
+
+	public int getNiveau() {
+		return this.niveau;
+	}
+
+	public int getHeritage() {
+		return this.heritage;
+	}
+
+	/**
+	 * Ajout d'un écouteur de changement de point de vie.
+	 */
+	public void ajouterEcouteurPointDeVie(PropertyChangeListener ecouteur) {
+		pcsPointDeVie.addPropertyChangeListener(ecouteur);
+	}
+
+	/**
+	 * Ajout d'un écouteur de changement d'XP.
+	 */
+	public void ajouterEcouteurXp(PropertyChangeListener ecouteur) {
+		pcsXp.addPropertyChangeListener(ecouteur);
+	}
+
+	/**
+	 * Ajout d'un écouteur de changement de points d'attaque
+	 */
+	public void ajouterEcouteurPa(PropertyChangeListener ecouteur) {
+		pcsPa.addPropertyChangeListener(ecouteur);
+	}
+
+	/**
+	 * Ajout d'un écouteur de changement de nombre de vie
+	 */
+	public void ajouterEcouteurNbreVies(PropertyChangeListener ecouteur) {
+		pcsNbVies.addPropertyChangeListener(ecouteur);
+	}
+	
+	/**
+	 * Ajout d'un écouteur de changement d'arme
+	 */
+	public void ajouterEcouteurArme(PropertyChangeListener ecouteur) {
+		pcsArme.addPropertyChangeListener(ecouteur);
+	}
+	
+	/**
+	 * Ajout d'un écouteur de changement de Niveau
+	 */
+	public void ajouterEcouteurNiveau(PropertyChangeListener ecouteur) {
+		pcsNiveau.addPropertyChangeListener(ecouteur);
+	}
+
+	public void setHeritage(int i) {
+		this.heritage=i;
+		
+	}
+
+	public void setDef(int i) {
+		this.def=i;
+		
+	}
+	
+	public int getMaxXp(){
+		return maxXP;
+	}
+	public void setMaxXp(int max){
+		this.maxXP=max;
+	}
+
+	public int getDeplacement() {
+		return deplacement;
+	}
+
+	public void setDeplacement(int deplacement) {
+		this.deplacement = deplacement;
+	}
+	
+}

src/modeles/Position.java

@@ -0,0 +1,24 @@
+package modeles;
+
+/**
+ * La position d'un joueur ou d'une tuile. Permet de gérer les coordonnées
+ * 
+ */
+public class Position {
+	private int ligne; // La ligne ou la coordonnée X dans un plan
+	private int col; // La ligne ou la coordonnée Y dans un plan
+
+	public Position(int ligns, int cols) {
+		this.ligne = ligns;
+		this.col = cols;
+	}
+
+	public int getLigne() {
+		return ligne;
+	}
+
+	public int getCol() {
+		return col;
+	}
+
+}

src/modeles/Ressources.java

@@ -0,0 +1,21 @@
+package modeles;
+
+/**
+ * Classe permettant de gérer toutes les ressources du jeu
+ */
+public class Ressources {
+
+	// Pour les joueurs
+	public static int pv = 20; // Les points de vie du joueur
+	public static int xp = 0; // Son xp au départ
+	public static int att = 10; // Ses points d'attaque
+	public static int heritage = 3; // Ses points d'heritage
+	public static int deplacement = 5; // Ses points de déplacement
+	public static int nbVies = 1; // Ses points de vies
+	public static int def = 4; // Ses points de défense
+
+	// Pour les combats
+	public static int nbRounds = 3; // Le nombre de round en comptant a partir
+									// de zéro
+
+}

src/modeles/Terrain.java

@@ -0,0 +1,145 @@
+package modeles;
+
+import java.util.ArrayList;
+
+/**
+ * Classe représentant le terrain de jeu. Le terrain est un tableau de tuiles.
+ * Est responsable de vérifier si une position donnée est une position possible
+ * d'une tuile du terrain, de fournir une tuile vide du terrain, de positionner
+ * un joueur sur une tuile du terrain.
+ * 
+ */
+public class Terrain {
+	private int lignes; // Le nombre de lignes du terrain
+	private int cols; // Le nombre de colonnes du terrain
+	private Tuile[][] tab; // tableau de Tuiles: Les Lignes est la première dimension du tableau
+
+	/**
+	 * Initialise le terrain sans joueur
+	 * 
+	 * @param lignes
+	 *            Le nombre de lignes du terrain
+	 * @param cols
+	 *            Le nombre de colonnes du terrain
+	 */
+	public Terrain(int lignes, int cols) {
+		this.lignes = lignes;
+		this.cols = cols;
+
+		tab = new Tuile[lignes][cols];
+
+		for (int i = 0; i < lignes; i++)
+			for (int j = 0; j < cols; j++)
+				this.tab[i][j] = new Tuile();
+
+	}
+
+	/**
+	 * Retourne la position d'une tuile vide du plateau, choisie aléatoirement.
+	 * 
+	 * @return position une instance de position générée aléatoirement
+	 */
+	public Position getTuileVideAleatoire() {
+		Position position;
+
+		do {
+			position = new Position((int) (Math.random() * lignes), (int) (Math
+					.random() * cols));
+		} while (!(getTuile(position).estVide()));// tuile doit être vide
+
+		return position;
+	}
+
+	/**
+	 * Retourne la position d'une tuile vide du plateau, choisie aléatoirement
+	 * en fonction des points de déplacement.
+	 * 
+	 * @param tuilesAccesibles
+	 *            arraylist de tuiles accessibles
+	 * @return position une instance de position générée aléatoirement en
+	 *         foction des tuiles accéssibles autours du pion
+	 */
+	public Position getTuileVidePourDeplacement(
+			ArrayList<Position> tuilesAccesibles) {
+
+		return tuilesAccesibles.get((int) (Math.random() * tuilesAccesibles
+				.size()));
+	}
+
+	/**
+	 * Retourne la tuile en position p sur le terrain. Permet de faire le lien
+	 * entre une position et une tuile
+	 * 
+	 * @param p
+	 *            La position de la tuile désirée
+	 */
+	public Tuile getTuile(Position p) {
+		return tab[p.getLigne()][p.getCol()];
+	}
+
+	/**
+	 * Retourne l'occupant de la tuile en position p, null si la tuile est vide.
+	 * 
+	 * @param p
+	 *            La position de la tuile
+	 * @return null ou occupant Retourne null si il n'y a pas d'occupant ou une
+	 *         instance de Joueur si il y'a un occupant
+	 */
+	public Joueur getOccupant(Position p) {
+
+		if (getTuile(p).estVide())
+			return null;
+		else
+			return getTuile(p).getOccupant();
+
+	}
+
+	/**
+	 * Positionne les joueurs sur le terrain. Doit choisir des positions valides
+	 * du terrain. Un seul joueur par tuile.
+	 * 
+	 * @param joueur
+	 *            Joueur instance de type Joueur qu'il faut positionner
+	 */
+	public void PositionnerJoueurs(Joueur joueur, Position position) {
+
+		// Met a jour la tuile l'ancienne tuile
+		getTuile(joueur.getPosition()).setOccupant(null);
+		
+		// On modifie la position du joueur dans la classe joueur
+		joueur.setPosition(position);
+
+		// Met a jour la nouvelle tuile avec un occupant
+		getTuile(position).setOccupant(joueur);
+
+	}
+
+	/**
+	 * Vérifie que p est une position correcte du terrain.
+	 * 
+	 * @return true ssi p designe une case du tableau
+	 */
+	public boolean positionCorrecte(Position p) {
+		boolean positionOK = false;
+		if ((p.getCol() >= 0 && p.getCol() < this.cols)
+				&& (p.getLigne() >= 0 && p.getLigne() < this.lignes)) { // les
+																		// ligne/
+																		// colonnes
+																		// sont
+																		// dans
+																		// le
+																		// tableau
+			positionOK = true;
+		}
+		return positionOK;
+	}
+
+	public int getLigne() {
+		return lignes;
+	}
+
+	public int getCol() {
+		return cols;
+	}
+
+}

src/modeles/Tuile.java

@@ -0,0 +1,80 @@
+package modeles;
+
+import java.beans.PropertyChangeListener;
+import java.beans.PropertyChangeSupport;
+
+/**
+ * Classe representant une tuile du terrain dans le module du jeu. Communement
+ * appelée "Case" par les joueurs
+ * 
+ * @author amine BOUABDALLAOUI, hugo COURTECUISSE, edouard DELANOE
+ */
+public class Tuile {
+	/**
+	 * occupant de la case
+	 */
+	private Joueur occupant;
+	/**
+	 * pour permetre au modèle d'envoyer des évènements aux vues.
+	 */
+	private PropertyChangeSupport pcsOccupant = new PropertyChangeSupport(this);
+
+	/**
+	 * Initialise la tuile sans occupant
+	 */
+	public Tuile() {
+		occupant = null;
+	}
+
+	/**
+	 * Retourne true si aucun joueur n'est sur la case.
+	 * 
+	 * @return boolean true si ausun joueur n'est sur la case, false si il y'en
+	 *         a un
+	 */
+	public boolean estVide() {
+		return this.occupant == null;
+	}
+
+	/**
+	 * Retourne l'occupant ne marche uniquement que si la case n'est pas vide !
+	 * 
+	 * @return occupant une instance de Joueur qui occupe la case
+	 */
+	public Joueur getOccupant() {
+		return this.occupant;
+	}
+
+	/**
+	 * Ajoute et enlève l'occupant sur la case
+	 * 
+	 * @param occupant
+	 *            : L'occupant de la case, une instance de Joueur
+	 */
+	public void setOccupant(Joueur occupant) {
+
+		
+		Joueur ancienOccupant = (Joueur) this.occupant;
+
+		
+		this.occupant = occupant;
+
+
+		this.pcsOccupant.firePropertyChange("occupant", ancienOccupant, this.occupant);
+	}
+
+	/**
+	 * Ajout d'un écouteur de changement d'occupant.
+	 */
+	public void ajouterEcouteurOccupant(PropertyChangeListener ecouteur) {
+		pcsOccupant.addPropertyChangeListener(ecouteur);
+	}
+
+	/**
+	 * Suppression d'un écouteur de changement d'occupant.
+	 */
+	public void retirerOccupantEcouteur(PropertyChangeListener ecouteur) {
+		pcsOccupant.removePropertyChangeListener(ecouteur);
+	}
+
+}

src/modeles/joueurOrdinateur.java

@@ -0,0 +1,128 @@
+package modeles;
+
+import java.util.ArrayList;
+/**
+ * joueur ordinateur
+ *
+ */
+public class joueurOrdinateur extends Joueur {
+	public joueurOrdinateur(Terrain terrain, Position position) {
+		super(terrain, position);
+	}
+
+	/**
+	 * Cette méthode permet au pionMachine de récupérer la position d'un joueur
+	 * se trouvant dans son rayon d'attaque! Attention cette méthode ne met pas
+	 * a jours la position du joueur sur le plateau
+	 * 
+	 * @return position La position voulu par le joueur
+	 */
+	public Position proposeDeplacement() {
+
+		int col, max, min;
+		ArrayList<Joueur> joueursDetectes = new ArrayList<Joueur>();
+		ArrayList<Position> tuilesAccesibles = new ArrayList<Position>();
+
+		Position position;
+
+		min = this.getPosition().getLigne();
+		max = this.getPosition().getLigne();
+
+		for (col = this.getPosition().getCol() - super.deplacement; col <= this
+				.getPosition().getCol()
+				+ super.deplacement; col++) {
+			for (int i = min; i <= max; i++) {
+
+				if (terrain.positionCorrecte(new Position(i, col))) {// position
+					// correcte
+					position = new Position(i, col);
+					if (!terrain.getTuile(position).estVide()) {// si la case
+						// est occupée
+						joueursDetectes.add(terrain.getTuile(position)
+								.getOccupant());// on ajoute la case a l'array
+						// pour l'utilisre plus tard
+
+					} else
+						tuilesAccesibles.add(position);// sinon la case est
+					// libre
+
+				}
+			}
+			if (col >= this.getPosition().getCol()) {// pour décrémanter après
+				// avoir dépassé la case
+				// du milieu
+				min = min + 2;
+				max = max - 2;
+			}
+			min = min - 1;
+			max = max + 1;
+
+		}
+
+		if (joueurLePlusPret(joueursDetectes) != null) {
+			position = joueurLePlusPret(joueursDetectes).getPosition();// si il
+			// y a
+			// un
+			// joueur
+			// proche,
+			// on se
+			// dirige
+			// vers
+			// lui
+
+		} else {
+			position = terrain.getTuileVidePourDeplacement(tuilesAccesibles);// sinon
+			// on
+			// se
+			// délace
+			// aléatoirement
+			// (avec
+			// points
+			// déplacement)
+		}
+		return position;
+	}
+
+	/**
+	 * Permet de trouver le joueur le plus pret du pionOrdinateur qui jou
+	 * 
+	 * @param joueurDetecter
+	 * @return joueurLePlusPret
+	 */
+
+	public Joueur joueurLePlusPret(ArrayList<Joueur> joueurDetecter) {
+
+		Joueur joueurLePlusPret = null;
+
+		int colLePlusPret;
+		int ligneLePlusPret;
+		int distance = super.deplacement;
+		int plusproche;
+
+		for (int i = 0; i < joueurDetecter.size(); i++) {
+			if (this.getNom() != joueurDetecter.get(i).getNom()) {
+
+				colLePlusPret = this.getPosition().getCol()
+						- joueurDetecter.get(i).getPosition().getCol();
+				ligneLePlusPret = this.getPosition().getLigne()
+						- joueurDetecter.get(i).getPosition().getLigne();
+
+				plusproche = colLePlusPret + ligneLePlusPret;
+
+				if (plusproche < 0) {
+					plusproche = -plusproche;
+				}
+
+				if (distance >= plusproche) {
+
+					distance = Math.abs(colLePlusPret + ligneLePlusPret);
+
+					joueurLePlusPret = joueurDetecter.get(i);
+				}
+			}
+		}
+
+		return joueurLePlusPret;
+
+	}
+}

src/modeles/joueurReel.java

@@ -0,0 +1,29 @@
+package modeles;
+
+/**
+ * Classe représentant un joueur réel
+ */
+public class joueurReel extends Joueur {
+	/**
+	 * place un joueur réel sur le terrain a une position donnée
+	 * 
+	 * @param terrain
+	 * @param position
+	 */
+	public joueurReel(Terrain terrain, Position position) {
+		super(terrain, position);
+	}
+
+	/**
+	 * verifie si le joueur réel peut aller sur la position
+	 * 
+	 * @param position
+	 * @return vrai si le joueur peut se déplacer sur la case
+	 */
+	public boolean ecartCorrect(Position position) {
+		return Math.abs((this.getPosition().getCol() - position.getCol()))
+				+ Math
+						.abs((this.getPosition().getLigne() - position
+								.getLigne())) > super.deplacement;
+	}
+}

src/modeles/pionsReg.java

@@ -0,0 +1,53 @@
+package modeles;
+
+/**
+ * Les pions regenérants sont des pions permettant de redonner un peu de vie au joueur 
+ * qui tombe sur sa case. Appellé aussi potion.
+ * 
+ *
+ */
+
+public class pionsReg extends Joueur{
+	
+	int type; // Le type correspond a la taille de la potion une potion de type 1 
+			  // donneras moins de point de vie qu'une potion de type 2
+	
+	/**
+	 * Constructeur
+	 * 
+	 * @param terrain leTerrain de jeu
+	 */
+	public pionsReg(Terrain terrain){
+		
+		super(terrain, terrain.getTuileVideAleatoire());
+
+		super.pv = 1;
+		super.xp = 0;
+		super.att = 1;
+		super.deplacement = 0;
+		super.nbVies = 0;
+		super.def = 0;
+		super.niveau = 1;
+		super.maxXP = 1;
+		terrain.getTuile(super.getPosition()).setOccupant(this);
+		this.type = (int) (Math.random() * 3) + 1;
+		
+		if (this.type == 1)
+			super.heritage = 5;
+		else if (this.type == 2)
+			super.heritage = 10;
+		else
+			super.heritage = 20;
+		
+	}
+
+	public int getType() {
+		return type;
+	}
+
+	public void setType(int type) {
+		this.type = type;
+	}
+	
+	
+}

src/vue/swing/CreerJeu.java

@@ -0,0 +1,208 @@
+package vue.swing;
+
+import java.awt.BorderLayout;
+import java.awt.Dimension;
+import java.util.ArrayList;
+import javax.swing.JFrame;
+import javax.swing.JScrollPane;
+import javax.swing.JTextPane;
+
+import modeles.EtatJeu;
+import modeles.Joueur;
+import modeles.Position;
+import modeles.Terrain;
+import modeles.joueurOrdinateur;
+import modeles.joueurReel;
+
+/**
+ * Cette classe permet de tester le jeu en mode console avec l'interface swing
+ * 
+ * @version 1 15 juin 2010
+ * @author Amine, Hugo, Edouard
+ */
+public class CreerJeu {
+
+	/**
+	 * On lance le jeu en 3 étapes grâce a cette méthode, les ressources du jeu
+	 * sont paramètrés dans la classe Ressource
+	 */
+	@SuppressWarnings("static-access")
+	public CreerJeu(){
+		CreerJeuFenetre CreerJeuFenetre = new CreerJeuFenetre(null, "Informations sur le jeu", true);
+		CreerJeuFenetreInfo info = CreerJeuFenetre.showZDialog(); 
+		
+		/* 1. Création des objets du modèle */
+
+		ArrayList<Joueur> joueurs = new ArrayList<Joueur>();
+		Terrain leTerrain = new Terrain(info.getTailleTerrain(), info.getTailleTerrain());
+
+		/* 2. Création des composants visuels de départ */
+
+		JTextPane fenetreText = new JTextPane();
+			fenetreText.setEditable(false);
+			fenetreText.setPreferredSize(new Dimension(100,100));
+			JScrollPane scrollPane = new JScrollPane(fenetreText);
+		scrollPane.setPreferredSize(new Dimension(800,100));
+		JFrame fenetrePrincipale = new JFrame();
+		fenetrePrincipale.setPreferredSize(new Dimension(600,800));
+		fenetrePrincipale.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+		fenetrePrincipale.setLayout(new BorderLayout());
+		VueTerrain composantVisuelTerrain = new VueTerrain(leTerrain);
+		fenetrePrincipale.add(composantVisuelTerrain, BorderLayout.CENTER);
+		fenetrePrincipale.setTitle("RPG");
+
+		fenetrePrincipale.setJMenuBar(new MenuInterfaceGraphique(fenetreText).creeMenu(fenetrePrincipale));
+		
+		fenetrePrincipale.setPreferredSize(new Dimension(800, 600));
+		fenetrePrincipale.pack();
+		fenetrePrincipale.setExtendedState(fenetrePrincipale.MAXIMIZED_BOTH);
+		fenetrePrincipale.add(scrollPane, BorderLayout.SOUTH);
+		fenetrePrincipale.setVisible(true);
+
+		
+		/* 3. Initialisation : placement des joueurs */
+
+		joueurs = creerLesPersos(info.getNombrePersonnageOrdinateur(), info.getNombrePersonnageReel(), leTerrain);
+
+		EtatJeu etat = new EtatJeu(leTerrain, joueurs);
+
+		associerVue(etat, fenetrePrincipale, fenetreText);
+		VuePrincipale vue = new VuePrincipale();
+		
+		
+		new MediateurVuePrincipale(composantVisuelTerrain, etat, vue, fenetreText);
+		
+		vue.commencerJeu (etat, fenetreText);
+	}
+
+	/**
+	 * créer les personnages
+	 * 
+	 * @param nombre
+	 *            de joueurs
+	 * @param terrain
+	 *            ou positionner les joueurs
+	 * @return arrayList de joueurs
+	 */
+	public static ArrayList<Joueur> creerLesPersos(int nombrePersonnageOrdinateur, int nombrePersonnageJoueur, Terrain terrain) {
+		ArrayList<Joueur> joueurs = new ArrayList<Joueur>();
+		Position position = null;
+
+		// Tant qu'il ne reste pas des joueurs a créer
+		for (int i = 0; i < nombrePersonnageJoueur; i++) {
+			
+	        
+            UtilisateurDialog zd = new UtilisateurDialog(null, "Information sur le joueur", true);
+            UtilisateurDialogInfo zInfo = zd.showZDialog(); 
+
+			// Pour la nouvelle fênetre
+        	do {
+				position = terrain.getTuileVideAleatoire();
+			} while (siPositionExiste(position, joueurs));
+
+			Joueur joueur = new joueurReel(terrain, position);
+			joueur.setNom(zInfo.getNom());
+
+			// On modifie la position du joueur dans la classe joueur
+			joueur.setPosition(position);
+			
+			
+			if (zInfo.getTuxChoisis() == "Le premier Tux")
+				joueur.setPion(1);
+			else if (zInfo.getTuxChoisis() == "Le deuxieme Tux") 
+				joueur.setPion(2);
+			else if (zInfo.getTuxChoisis() == "Le troisieme Tux") 
+				joueur.setPion(3);
+			else  
+				joueur.setPion(4);
+			
+			// Met a jour la nouvelle tuile avec un occupant
+			terrain.getTuile(position).setOccupant(joueur);
+			
+			joueurs.add(joueur);
+        	
+		}
+
+		// On créé les pionsOridnateurs
+		for (int j = 1; j < nombrePersonnageOrdinateur+1; j++) {
+			do {
+				position = terrain.getTuileVideAleatoire();
+			} while (siPositionExiste(position, joueurs));
+			Joueur joueur = new joueurOrdinateur(terrain, position);
+			joueur.setNom(String.valueOf("*" + j + "*"));
+			
+			// On modifie la position du joueur dans la classe joueur
+			joueur.setPosition(position);
+
+			// Met a jour la nouvelle tuile avec un occupant
+			terrain.getTuile(position).setOccupant(joueur);
+			
+			joueur.setPion ( j);
+			
+			joueurs.add(joueur);
+		}
+
+		return joueurs;
+	}
+
+	/**
+	 * verifie si le nom existe dans l'arrayList
+	 * 
+	 * @param nom
+	 * @param joueurs
+	 * @return boolean
+	 */
+	public static boolean siNomExiste(String nom, ArrayList<Joueur> joueurs) {
+		boolean siExiste = false; // Retourne true ssi le nom est dans
+		// l'ArayList
+		int i = 0; // Variable de boucle
+
+		while (!siExiste && i < joueurs.size()) {
+			if (joueurs.get(i).getNom().contains(nom)) {
+				siExiste = true;
+			}
+			i += 1;
+		}
+		return siExiste;
+	}
+
+	/**
+	 * test si la position est déja prise par un autre jouer
+	 * 
+	 * @param position
+	 * @return boolean
+	 */
+
+	public static boolean siPositionExiste(Position position,
+			ArrayList<Joueur> joueurs) {
+		boolean siPosExiste = false; // Retourne true ssi le nom est dans
+		// l'ArayList
+		int i = 0; // Variable de boucle
+
+		while (!siPosExiste && i < joueurs.size()) {
+			if (joueurs.get(i).getPosition().getCol() == position.getCol()
+					&& joueurs.get(i).getPosition().getLigne() == position
+							.getLigne()) {
+				siPosExiste = true;
+			}
+			i += 1;
+		}
+		return siPosExiste;
+	}
+
+	/**
+	 * permet de rajouter un ecouteur aux pions
+	 * 
+	 * @param etat
+	 * @param fenetrePrincipale
+	 */
+	public static void associerVue(EtatJeu etat, JFrame fenetrePrincipale,
+			JTextPane fenetreText) {
+		for (int i = 0; i < etat.joueurs.size(); i++) {
+
+			VueJoueur vueDuJoueur = new VueJoueur(etat.joueurs.get(i));
+			vueDuJoueur.ajouterEcouteur(fenetrePrincipale, fenetreText);
+		}
+	}
+	
+}

src/vue/swing/CreerJeuFenetre.java

@@ -0,0 +1,166 @@
+package vue.swing;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.GridLayout;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.ImageIcon;
+import javax.swing.JButton;
+import javax.swing.JComboBox;
+import javax.swing.JDialog;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+
+/**
+ * Permet de lancer la fenetre qui permet de choisir la taille du terrain et le nombre de 
+ * pions utilisateur et le nombre de pions machine
+ * 
+ * @author courtecuisse
+ *
+ */
+@SuppressWarnings("serial")
+public class CreerJeuFenetre extends JDialog {
+
+        private CreerJeuFenetreInfo infoCreerJeu = new CreerJeuFenetreInfo(); // classe permettant la liaison entre creerJeu et la fenetre
+        @SuppressWarnings("unused")
+		private boolean sendData; 
+        private JLabel labelTerrain;
+
+        protected JFrame fenetre;
+        /**
+         * Constructeur
+         * @param parent
+         * @param title
+         * @param modal
+         */
+        public CreerJeuFenetre(JFrame parent, String title, boolean modal){
+                super(parent, title, modal); // Fentre modale oblige
+                this.setSize(550, 270);
+                this.setLocationRelativeTo(null);
+                this.setResizable(false);
+                this.setDefaultCloseOperation(JDialog.DO_NOTHING_ON_CLOSE);
+                this.initComponent();
+                this.fenetre=parent;
+        }
+        
+        /**
+         * Méthode appelée pour utiliser la boîte 
+         * @return zInfo
+         */
+        public CreerJeuFenetreInfo showZDialog(){
+                this.sendData = false;
+                this.setVisible(true);          
+                return this.infoCreerJeu;              
+        }
+        
+        /**
+         * Initialise le contenu de la boîte
+         */
+        private void initComponent(){
+
+                
+                //Le terrain
+                JPanel panTerrain = new JPanel();
+                panTerrain.setBackground(Color.white);
+                
+                panTerrain.setLayout(new BorderLayout());
+                
+                	final JComboBox tailleTerrain = new JComboBox();
+                	
+                	labelTerrain = new JLabel("La taille du terrain :");
+                	
+    	       		for (int i=3; i<=30; i++){
+    	       		tailleTerrain.addItem(i);
+    	       		}
+                	
+                panTerrain.add(labelTerrain,BorderLayout.NORTH);
+                
+                panTerrain.add(tailleTerrain, BorderLayout.SOUTH);
+                
+                JPanel panPlateujeu = new JPanel();
+                panPlateujeu.setBackground(Color.white);
+                panPlateujeu.add (new JLabel(new ImageIcon("images/plateauJeu.png")));
+                
+                panTerrain.add(panPlateujeu, BorderLayout.CENTER);
+                
+    	       // Liste déroulante pour le nombre de personnage
+    	       JPanel conteneurNombrePersonnage = new JPanel();
+    	       conteneurNombrePersonnage.setBackground(Color.white);
+
+    	       
+		           	final JComboBox nombrePersonnageReel = new JComboBox();
+		           	final JComboBox nombrePersonnageOrdinateur = new JComboBox();
+		        	
+		        
+		       		for (int i=1; i<=4; i++){
+		       			nombrePersonnageReel.addItem(i);
+		       		}
+		       		
+		       		for (int i=1; i<=4; i++){
+		       			nombrePersonnageOrdinateur.addItem(i);
+		       		}
+                	
+	     	    conteneurNombrePersonnage.add(new JLabel("Le nombre de joueur r<>els :"));
+	     	    conteneurNombrePersonnage.add(nombrePersonnageReel);
+    	       	
+     	        // Liste déroulante pour le nombre de personnage
+     	        JPanel conteneurNombrePersonnageOrdi = new JPanel();
+     	        conteneurNombrePersonnageOrdi.setBackground(Color.white);
+
+     	        conteneurNombrePersonnageOrdi.add(new JLabel("Le nombre de joueur Ordinateur :"));
+     	        conteneurNombrePersonnageOrdi.add(nombrePersonnageOrdinateur);
+    	       	
+     	        //Icone
+                JPanel conteneurIcon = new JPanel();
+                conteneurIcon.setBackground(Color.white);
+                conteneurIcon.setLayout(new GridLayout(1,3));
+                conteneurIcon.setPreferredSize(new Dimension(320, 120));
+
+    	            conteneurIcon.add(new JLabel(new ImageIcon("images/Guerrier1.gif")));
+    	            conteneurIcon.add(new JLabel(new ImageIcon("images/Guerrier2.gif")));
+    	            conteneurIcon.add(new JLabel(new ImageIcon("images/Guerrier3.gif")));
+    	            conteneurIcon.add(new JLabel(new ImageIcon("images/Guerrier4.gif")));
+    	        
+    	        JPanel conteneurIconEtListeDeroulante= new JPanel ();
+
+    	        conteneurIconEtListeDeroulante.add(conteneurNombrePersonnage, BorderLayout.NORTH);
+    	        conteneurIconEtListeDeroulante.add(conteneurIcon, BorderLayout.CENTER);
+    	        conteneurIconEtListeDeroulante.add(conteneurNombrePersonnageOrdi, BorderLayout.SOUTH);
+    	        conteneurIconEtListeDeroulante.setBackground(Color.white);
+    	        
+                JPanel control = new JPanel();
+                JButton okBouton = new JButton("OK");
+                
+                okBouton.addActionListener(new ActionListener(){
+                        public void actionPerformed(ActionEvent arg0) {                         
+                        		infoCreerJeu = new CreerJeuFenetreInfo( (int)(Integer) nombrePersonnageOrdinateur.getSelectedItem(), (Integer) nombrePersonnageReel.getSelectedItem(), (Integer) tailleTerrain.getSelectedItem());
+                                setVisible(false);
+                        }
+                   
+                });
+                
+                JButton cancelBouton = new JButton("Annuler");
+                cancelBouton.addActionListener(new ActionListener(){
+                        public void actionPerformed(ActionEvent arg0) {
+                    			infoCreerJeu = new CreerJeuFenetreInfo( 1, 1, 10);
+                                setVisible(false);
+                        }                       
+                });
+                
+                control.add(okBouton);
+                control.add(cancelBouton);
+                
+                this.getRootPane().setDefaultButton(okBouton);
+                this.getContentPane().add(panTerrain, BorderLayout.WEST);
+                this.getContentPane().add(conteneurIconEtListeDeroulante, BorderLayout.CENTER);
+                this.getContentPane().add(control, BorderLayout.SOUTH);
+        }  
+
+        
+}
+

src/vue/swing/CreerJeuFenetreInfo.java

@@ -0,0 +1,48 @@
+package vue.swing;
+/**
+ * Classe permettant la liaison entre la classe creerJeu et la fenetre
+ * 
+ * @author courtecuisse
+ *
+ */
+public class CreerJeuFenetreInfo {
+
+	private int tailleTerrain;
+	private int nombrePersonnageReel;
+	private int nombrePersonnageOrdinateur;
+	
+	public CreerJeuFenetreInfo(){
+		
+	}
+	
+	public CreerJeuFenetreInfo(int nombrePersonnageOrdinateur, int nombrePersonnageReel, int tailleTerrain) {
+		this.nombrePersonnageOrdinateur = nombrePersonnageOrdinateur;
+		this.nombrePersonnageReel = nombrePersonnageReel;
+		this.tailleTerrain = tailleTerrain;
+	}
+
+	public int getTailleTerrain() {
+		return tailleTerrain;
+	}
+
+	public void setTailleTerrain(int tailleTerrain) {
+		this.tailleTerrain = tailleTerrain;
+	}
+
+	public int getNombrePersonnageReel() {
+		return nombrePersonnageReel;
+	}
+
+	public void setNombrePersonnageReel(int nombrePersonnage) {
+		this.nombrePersonnageReel = nombrePersonnage;
+	}
+
+	
+	public int getNombrePersonnageOrdinateur() {
+		return nombrePersonnageOrdinateur;
+	}
+
+	public void setNombrePersonnageOrdinateur(int nombrePersonnageOrdinateur) {
+		this.nombrePersonnageOrdinateur = nombrePersonnageOrdinateur;
+	}
+}

src/vue/swing/LancerJeu.java

@@ -0,0 +1,12 @@
+package vue.swing;
+/**
+ * Permet de lancer le jeu 
+ * 
+ * @author courtecuisse
+ *
+ */
+public class LancerJeu {
+	public static void main(String [] args){
+		new CreerJeu();
+	}
+}

src/vue/swing/MediateurVuePrincipale.java

@@ -0,0 +1,82 @@
+package vue.swing;
+
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JTextPane;
+
+
+import modeles.EtatJeu;
+import modeles.Joueur;
+import modeles.joueurReel;
+import modeles.pionsReg;
+
+
+public class MediateurVuePrincipale {
+
+	/**
+	 * Référence vers notre joueur courant.
+	 */
+	EtatJeu etatJeu;
+
+	/**
+	 * Composant visuel représentant le terrain.
+	 */
+	private VueTerrain composantVisuelTerrain;
+
+	public VueTerrain getComposantTerrain() {
+		return this.composantVisuelTerrain;
+	}
+
+	/**
+	 * Constructeur.
+	 * @param fenetreText 
+	 */
+	public MediateurVuePrincipale(VueTerrain composantTerrain,
+			final EtatJeu etatJeu, final VuePrincipale vue, final JTextPane fenetreText) {
+
+		this.composantVisuelTerrain = composantTerrain;
+		this.etatJeu = etatJeu;
+
+		// On place un écouteur de clic sur chacune des tuiles du terrain.
+		for (int i = 0; i < this.composantVisuelTerrain.getComponentCount(); i++) {
+			final VueTuile composantVisuelTuile = (VueTuile) this.composantVisuelTerrain
+					.getComponent(i);
+			composantVisuelTuile.addMouseListener(new MouseAdapter() {
+				@SuppressWarnings("static-access")
+				public void mouseClicked(MouseEvent e) {
+
+					if (etatJeu.getJoueurCourrant() instanceof joueurReel) {
+						if (etatJeu.getJoueurs().size() != 1){
+							if(( (joueurReel) etatJeu.getJoueurCourrant()).ecartCorrect(composantVisuelTuile.getPosition())){
+								JOptionPane erreur = new JOptionPane();
+								erreur.showMessageDialog(null, "Impossible de se déplacer ici, vous n'avez que "+etatJeu.getJoueurCourrant().getDeplacement()+ " de déplacement", "Erreur", JOptionPane.ERROR_MESSAGE);
+							}else{
+															
+								vue.jouerUnTour(etatJeu, fenetreText, composantVisuelTuile.getPosition());
+							}
+						}
+					}
+				}
+				
+				public void mouseEntered(MouseEvent e) {
+					if (etatJeu.getTerrain().getOccupant(composantVisuelTuile.getPosition()) != null){
+						Joueur joueurCase = etatJeu.getTerrain().getOccupant(composantVisuelTuile.getPosition());
+						// -- Version sur deux lignes avec les problémes d'affichages
+						//composantVisuelTuile.setToolTipText("<html>Nom Hp/HpMax Attaque Def heritage Nombre de vie Niveau Arme <br /> " +
+															//joueurCourant.getNom()+" "+ joueurCourant.getPv()+"/"+joueurCourant.getPv()+"     "+ joueurCourant.getAtt()+"      "+ joueurCourant.getdef()+"    "+joueurCourant.getHeritage()+"        "+joueurCourant.getNbVies()+"          "+joueurCourant.getNiveau()+"     "+joueurCourant.getArme().getNom()+" </html>");
+						if(joueurCase instanceof pionsReg){
+							composantVisuelTuile.setToolTipText("<html><b>Points vie</b> : "+joueurCase.getHeritage());
+						}
+						else
+						composantVisuelTuile.setToolTipText("<html><b>Nom</b> : "+joueurCase.getNom()+" <b>Hp</b> : "+ joueurCase.getPv()+" <b>Attaque</b> : "+ joueurCase.getAtt()+" <b>Def</b> : "+ joueurCase.getdef()+" <b>Heritage</b> : "+joueurCase.getHeritage()+" <br> <b>Nombre de vie</b> : "+joueurCase.getNbVies()+"  <b>Niveau</b> : "+joueurCase.getNbVies()+" <b>Arme</b> : "+joueurCase.getArme().getNom());
+					}
+				} 
+			});
+		}
+	}
+}

src/vue/swing/MenuInterfaceGraphique.java

@@ -0,0 +1,146 @@
+package vue.swing;
+
+import java.awt.BorderLayout;
+import java.awt.Dimension;
+import java.awt.Font;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JMenu;
+import javax.swing.JMenuBar;
+import javax.swing.JMenuItem;
+import javax.swing.JScrollPane;
+import javax.swing.JTextArea;
+import javax.swing.JTextPane;
+
+/**
+ * Cette classe permet d'instancié le menu qui est tout en haut
+ * 
+ * @author Hugo, Amine, Edouard
+ *
+ */
+public class MenuInterfaceGraphique {
+	
+	private JMenuBar menuBar = new JMenuBar();
+    private JMenu MenuFichier = new JMenu("Fichier");
+    private JMenu MenuAPropos = new JMenu("Aide");
+    
+    private JMenuItem MenuFichier_Ouvrir = new JMenuItem("Nouvelle partie");
+    private JMenuItem MenuFichier_Fermer = new JMenuItem("Fermer");
+    private JMenuItem MenuFichier_AfficherCombat = new JMenuItem("Afficher Combat");
+    private JMenuItem MenuFichier_Regles = new JMenuItem("Regles");
+    private JMenuItem MenuFichier_Auteur = new JMenuItem("Les auteurs");
+    private JTextPane fenetre;
+	public MenuInterfaceGraphique (JTextPane fenetreText) {
+		this.fenetre = fenetreText;
+	}
+	
+	/**
+	 * Création du menu avec ses sous catégories
+	 * 
+	 * @return JMenuBar Le menu avec tous ses éléments 
+	 */
+	public JMenuBar creeMenu (final JFrame frame){
+        
+			MenuFichier_Ouvrir.addActionListener(new ActionListener(){
+	            public void actionPerformed(ActionEvent arg0) {
+	            	frame.dispose();
+	            	new CreerJeu();
+	            }                               
+	        });
+	        this.MenuFichier.add(MenuFichier_Ouvrir);
+	        
+	        
+		   	MenuFichier_AfficherCombat.addActionListener(new ActionListener(){
+		        public void actionPerformed(ActionEvent arg0) {
+		        	JFrame fenetreCombat= new JFrame();
+		        	JTextPane fenetreText = new JTextPane();
+					fenetreText.setEditable(false);
+					fenetreCombat.setTitle("Resume du combat");
+					fenetreText.setText(fenetre.getText());
+					JScrollPane scrollPane = new JScrollPane(fenetreText);
+					fenetreCombat.add(scrollPane);
+					scrollPane.setPreferredSize(new Dimension(500,500));
+					fenetreCombat.setVisible(true);
+					fenetreCombat.pack();
+
+		        } 
+                
+		   	});
+		   	this.MenuFichier.add(MenuFichier_AfficherCombat);
+		   	
+
+        	MenuFichier_Fermer.addActionListener(new ActionListener(){
+	                public void actionPerformed(ActionEvent arg0) {
+	                        System.exit(0);
+	                }                               
+	        });
+        
+	   this.MenuFichier.add(MenuFichier_Fermer);
+	   
+
+
+
+	   
+	   		MenuFichier_Regles.addActionListener(new ActionListener(){
+	           public void actionPerformed(ActionEvent arg0) {
+	                   // On doit afficher les régles ici
+	        	   JFrame fenetreRegles = new JFrame();
+	        	   fenetreRegles.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
+	        	   fenetreRegles.setLayout(new BorderLayout ());	
+	        	    
+	        	   		fenetreRegles.setTitle("Regles du jeu");
+	        	   		
+	        	   		JTextArea fenetreText = new JTextArea(5, 30);
+	        	   		
+	        	   		fenetreText.setFont(new Font("Arial", Font.PLAIN, 18));
+	        	   		fenetreText.setEditable(false);
+	        	   		fenetreText.setText("Les joueurs choisissent un nom, et un personnage."+
+	        	   						"A tours de role les joueurs se déplacerons sur le terrain.\n"+
+										"Pour attaquer un joueur, il faut se déplacer sur sa case. "+
+										"Un combat se déroule en 4 round "+
+										"Au premier round le joueur qui se déplace attaque.\nCelui qui se defend attaque au deuxième et ainsi de suite."+
+										"Si personne ne meurt pendant le combat: "+
+										" \nLe gagnant sera celui qui perdra le moins de vie\n"+
+										"Si l'attaquant gagne le combat, son adversaire sera téléporté et l'attaquant prendra sa place"+
+										" sinon l'attaquant est téléporté.\n"+
+										"Quand tous les joueurs se sont déplacés, c'est le tours des pions Ordinateurs qui se déplacent. \nIls attaquent automatiquement le joueur le plus proche. \n"+
+										"Le jeu se termine quand il n'y a plus qu'un joueur sur le terrain: LE VAINQUEUR");
+	        	   
+	        	 
+	        	   fenetreRegles.add (fenetreText, BorderLayout.CENTER);
+	        	   fenetreRegles.pack();
+	        	   fenetreRegles.setLocationRelativeTo(null);
+	        	   fenetreRegles.setVisible(true);
+	           }                               
+		   });
+	
+	  this.MenuAPropos.add(MenuFichier_Regles);
+
+	  		MenuFichier_Auteur.addActionListener(new ActionListener(){
+			    public void actionPerformed(ActionEvent arg0) {
+			          // Afficher les auteurs ici
+			    	 JFrame fenetreRegles = new JFrame();
+		        	 fenetreRegles.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
+		        	 fenetreRegles.setTitle("Createurs");
+		        	 fenetreRegles.add(new JLabel ("Créé par Amine B., Hugo C., Edouard D."));
+		        	 
+		        	 fenetreRegles.pack();
+		        	 fenetreRegles.setLocationRelativeTo(null);
+		        	 fenetreRegles.setVisible(true);
+			    }                               
+			});
+
+	this.MenuAPropos.add(MenuFichier_Auteur);
+	
+	
+	
+	   // /!\ Attention : l'odre est important les menus seront créé de gauche a droite 
+       this.menuBar.add(MenuFichier);
+       this.menuBar.add(MenuAPropos);
+       
+       return menuBar;
+	}
+}

src/vue/swing/UtilisateurDialog.java

@@ -0,0 +1,141 @@
+package vue.swing;
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.GridLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.BorderFactory;
+import javax.swing.ImageIcon;
+import javax.swing.JButton;
+import javax.swing.JComboBox;
+import javax.swing.JDialog;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JTextField;
+
+/**
+ * Classe permettant au joueur de choisir le nom de son pion ainsi que l'image qui le réprésente 
+ * 
+ *
+ */
+@SuppressWarnings("serial")
+public class UtilisateurDialog extends JDialog {
+
+        private UtilisateurDialogInfo zInfo = new UtilisateurDialogInfo();
+        @SuppressWarnings("unused")
+		private boolean sendData;
+        private JLabel nomLabel;
+        private JTextField nom;
+        protected JFrame fenetre;
+        /**
+         * Constructeur
+         * @param parent
+         * @param title
+         * @param modal
+         */
+        public UtilisateurDialog(JFrame parent, String title, boolean modal){
+                super(parent, title, modal);
+                this.setSize(550, 270);
+                this.setLocationRelativeTo(null);
+                this.setResizable(false);
+                this.setDefaultCloseOperation(JDialog.DO_NOTHING_ON_CLOSE);
+                this.initComponent();
+                this.fenetre=parent;
+        }
+        
+        /**
+         * Méthode appelée pour utiliser la boîte 
+         * @return zInfo
+         */
+        public UtilisateurDialogInfo showZDialog(){
+                this.sendData = false;
+                this.setVisible(true);          
+                return this.zInfo;              
+        }
+        
+        /**
+         * Initialise le contenu de la boîte
+         */
+        private void initComponent(){
+
+                
+                //Le nom
+                JPanel panNom = new JPanel();
+                panNom.setBackground(Color.white);
+                panNom.setPreferredSize(new Dimension(220, 60));
+                nom = new JTextField();
+                nom.setPreferredSize(new Dimension(100, 25));
+                panNom.setBorder(BorderFactory.createTitledBorder("Nom du personnage"));
+                nomLabel = new JLabel("Saisir un nom :");
+                panNom.add(nomLabel);
+                panNom.add(nom);
+                
+                
+                //Icone
+                JPanel conteneurIcon = new JPanel();
+                conteneurIcon.setBackground(Color.white);
+                conteneurIcon.setLayout(new GridLayout(1,3));
+                conteneurIcon.setPreferredSize(new Dimension(250, 250));
+
+    	            conteneurIcon.add(new JLabel(new ImageIcon("images/Guerrier1.gif")));
+    	            conteneurIcon.add(new JLabel(new ImageIcon("images/Guerrier2.gif")));
+    	            conteneurIcon.add(new JLabel(new ImageIcon("images/Guerrier3.gif")));
+    	            conteneurIcon.add(new JLabel(new ImageIcon("images/Guerrier4.gif")));
+    	            
+    	       // Liste déroulante
+    	       JPanel conteneurlisteDeroulante = new JPanel();
+    	       conteneurlisteDeroulante.setBackground(Color.white);
+               conteneurlisteDeroulante.setPreferredSize(new Dimension(220, 120));
+               
+    	       		final JComboBox listeDeroulanteAvatar = new JComboBox();
+    	       		listeDeroulanteAvatar.setPreferredSize(new Dimension(130, 25));
+    	       		listeDeroulanteAvatar.addItem("Le premier Tux");
+    	       		listeDeroulanteAvatar.addItem("Le deuxieme Tux");
+    	       		listeDeroulanteAvatar.addItem("Le troisieme Tux");
+    	       		listeDeroulanteAvatar.addItem("La quatrieme Tux");
+    	       		
+           		conteneurlisteDeroulante.setBorder(BorderFactory.createTitledBorder("Avatar :"));
+           		conteneurlisteDeroulante.add(new JLabel("Choisir son avatar :"));
+           		conteneurlisteDeroulante.add(listeDeroulanteAvatar);
+           		
+                JPanel content = new JPanel();
+                content.setBackground(Color.white);
+                content.add(conteneurlisteDeroulante);
+                content.add(conteneurIcon);
+
+    
+                
+                JPanel control = new JPanel();
+                JButton okBouton = new JButton("OK");
+                
+                okBouton.addActionListener(new ActionListener(){
+                        public void actionPerformed(ActionEvent arg0) {                         
+                                zInfo = new UtilisateurDialogInfo(nom.getText(), (String) listeDeroulanteAvatar.getSelectedItem());
+                                setVisible(false);
+                        }
+                   
+                });
+                
+                JButton cancelBouton = new JButton("Annuler");
+                cancelBouton.addActionListener(new ActionListener(){
+                        public void actionPerformed(ActionEvent arg0) {
+                                setVisible(false);
+                        }                       
+                });
+                
+                control.add(okBouton);
+                control.add(cancelBouton);
+                
+                this.getRootPane().setDefaultButton(okBouton);
+                this.getContentPane().add(panNom, BorderLayout.WEST);
+                this.getContentPane().add(content, BorderLayout.CENTER);
+                this.getContentPane().add(control, BorderLayout.SOUTH);
+        }  
+
+        
+}
+

src/vue/swing/UtilisateurDialogInfo.java

@@ -0,0 +1,42 @@
+package vue.swing;
+/**
+ * Classe permettant la transition entre la fenetre (UtilisateurDialog) et la classe qui en a besoin
+ * 
+ *
+ */
+public class UtilisateurDialogInfo {
+
+
+
+		private String nom;
+        private String tuxChoisis;
+        
+        public UtilisateurDialogInfo(){}
+        public UtilisateurDialogInfo(String nom, String tuxChoisis){
+                this.nom = nom;
+                this.tuxChoisis = tuxChoisis;
+        }
+        
+        //------------------------------------
+        
+        public String getTuxChoisis() {
+    		return tuxChoisis;
+    	}
+    	public void setTuxChoisis(String tuxChoisis) {
+    		this.tuxChoisis = tuxChoisis;
+    	}
+    	
+        public String getNom() {
+                return nom;
+        }
+
+        public void setNom(String nom) {
+                this.nom = nom;
+        }
+
+        public String toString(){
+                String str;
+                        str = "Nom : " + this.nom + "\n "+tuxChoisis;
+                return str;
+        }
+}

src/vue/swing/VueJoueur.java

@@ -0,0 +1,253 @@
+package vue.swing;
+
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.Image;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.io.File;
+import java.io.IOException;
+import javax.imageio.ImageIO;
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+import javax.swing.JTextPane;
+
+import modeles.Armes;
+import modeles.Joueur;
+import modeles.joueurOrdinateur;
+import modeles.joueurReel;
+import modeles.pionsReg;
+
+/**
+ * Permet de représenter un joueur sur le terrain
+ * 
+ *
+ */
+@SuppressWarnings("serial")
+public class VueJoueur extends JPanel {
+
+	/**
+	 * Référence vers un modèle de joueur.
+	 */
+	private Joueur joueur;
+
+	
+	/**
+	 * Constructeur.
+	 */
+	public VueJoueur(Joueur j) {
+		this.joueur = j;
+		this.setBackground(Color.white);
+		this.setPreferredSize(new Dimension(49,49));
+	}
+	
+
+	/**
+	 * Méthode se chargant automatiquement permettant de créé l'image du guerrier
+	 * 
+	 */
+    public void paintComponent(Graphics g){
+        try {
+        	Image img;
+        	if (this.joueur instanceof joueurReel) 
+        		img = ImageIO.read(new File("images/Guerrier"+joueur.getPion()+".gif"));
+        	else if (this.joueur instanceof joueurOrdinateur)
+        		img = ImageIO.read(new File("images/alien"+joueur.getPion()+".gif"));
+        	else if  (this.joueur instanceof pionsReg)
+        		img = ImageIO.read(new File("images/potion"+((pionsReg) this.joueur).getType()+".gif"));
+        	else
+        		img = null;
+        	
+           g.drawImage(img, 0, 0, this.getWidth(), this.getHeight(), this);
+
+        } catch (IOException e) {
+                e.printStackTrace();
+        }
+        
+        
+    } 
+    
+	/**
+	 * ajouter des écouteurs pour les caractéristiques du joueurs
+	 */
+	public void ajouterEcouteur(JFrame fenetrePrincipale, JTextPane fenetreText) {
+		ecouteurPointDeVie(fenetrePrincipale, fenetreText);
+		ecouteurNbVies(fenetrePrincipale, fenetreText);
+		ecouteurNiveau(fenetrePrincipale, fenetreText);
+		ecouteurPa(fenetrePrincipale, fenetreText);
+		ecouteurXp(fenetrePrincipale, fenetreText);
+		ecouteurArme(fenetrePrincipale, fenetreText);
+		
+	}
+
+    // Ecouteurs
+
+	/**
+	 * écouteur pour les PV
+	 * @param fenetreText 
+	 * 
+	 * @param etat
+	 */
+	public void ecouteurPointDeVie(final JFrame fenetrePrincipale, final JTextPane fenetreText) {
+
+		joueur.ajouterEcouteurPointDeVie(new PropertyChangeListener() {
+
+			@Override
+			public void propertyChange(PropertyChangeEvent evt) {
+
+				if (evt.getNewValue() != null) {
+					int OldValue = ((Integer) (evt.getOldValue()));
+					int NewValue = ((Integer) (evt.getNewValue()));
+					
+					if (OldValue - NewValue > 0)
+						fenetreText.setText(fenetreText.getText()+"\n"+((Joueur) evt.getSource()).getNom()
+								+ " recoit " + (OldValue - NewValue)
+								+ " de degat");
+					
+					fenetreText.setText(fenetreText.getText()+"\nIl reste a "
+							+ ((Joueur) evt.getSource()).getNom() + " "
+							+ evt.getNewValue() + " PV\n");
+
+				}
+			}
+
+		});
+
+	}
+
+	/**
+	 * écouteur XP
+	 * @param fenetreText 
+	 * 
+	 * @param etat
+	 */
+	public void ecouteurXp(final JFrame fenetrePrincipale, final JTextPane fenetreText) {
+
+		joueur.ajouterEcouteurXp(new PropertyChangeListener() {
+
+			@Override
+			public void propertyChange(PropertyChangeEvent evt) {
+
+				if (evt.getNewValue() != null) {
+					if((Integer)evt.getNewValue() - (Integer)evt.getOldValue()>0)
+						fenetreText.setText(fenetreText.getText()+"\n"+((Joueur) evt.getSource()).getNom()+" gagne " + ((Integer)evt.getNewValue() - (Integer)evt.getOldValue()) + " XP");
+
+				}
+			}
+
+		});
+
+	}
+
+	/**
+	 * écouteur Points attaque
+	 * @param fenetreText 
+	 * 
+	 * @param etat
+	 */
+	public void ecouteurPa(final JFrame fenetrePrincipale, final JTextPane fenetreText) {
+
+		joueur.ajouterEcouteurPa(new PropertyChangeListener() {
+
+			@Override
+			public void propertyChange(PropertyChangeEvent evt) {
+
+				if (evt.getNewValue() != null)
+					
+					fenetreText.setText(fenetreText.getText()+"\n"+((Joueur) evt.getSource()).getNom()
+							+ " a maintenant " + evt.getNewValue()
+							+ " d'attaque\n");
+				
+			}
+
+		});
+
+	}
+
+	/**
+	 * écouteur nbVies
+	 * @param fenetreText 
+	 * 
+	 * @param etat
+	 */
+	public void ecouteurNbVies(final JFrame fenetrePrincipale, final JTextPane fenetreText) {
+
+		joueur.ajouterEcouteurNbreVies(new PropertyChangeListener() {
+
+			@Override
+			public void propertyChange(PropertyChangeEvent evt) {
+
+				if (evt.getNewValue() != null) {
+					int NewValue = ((Integer) (evt.getNewValue()));
+				
+
+					if (NewValue >= 0)
+						fenetreText.setText(fenetreText.getText()+"\n"+((Joueur) evt.getSource()).getNom()
+								+ " a maintenant " + evt.getNewValue()
+								+ " vie(s)\n");
+					else
+						fenetreText.setText(fenetreText.getText()+"\n"+((Joueur) evt.getSource()).getNom()
+						+ " est mort\n");
+
+				}
+			}
+
+		});
+
+	}
+
+	/**
+	 * écouteur Niveau
+	 * @param fenetreText 
+	 * 
+	 * @param etat
+	 */
+	public void ecouteurNiveau(final JFrame fenetrePrincipale, final JTextPane fenetreText) {
+
+		joueur.ajouterEcouteurNiveau(new PropertyChangeListener() {
+
+			@Override
+			public void propertyChange(PropertyChangeEvent evt) {
+
+				if (evt.getNewValue() != null) {
+
+					fenetreText.setText(fenetreText.getText()+"\n"+((Joueur) evt.getSource()).getNom() 
+							+ " a atteint le niveau " + evt.getNewValue()); 
+
+				}
+			}
+
+		});
+
+	}
+	
+	/**
+	 * écouteur Arme
+	 * @param fenetreText 
+	 * @param fenetrePrincipale 
+	 * @param fenetreText 
+	 * 
+	 * @param etat
+	 */
+	public void ecouteurArme(JFrame fenetrePrincipale, final JTextPane fenetreText) {
+
+		joueur.ajouterEcouteurArme(new PropertyChangeListener() {
+
+			@Override
+			public void propertyChange(PropertyChangeEvent evt) {
+
+				if (evt.getNewValue() != null) {
+					
+					fenetreText.setText(fenetreText.getText()+"\n"+((Joueur) evt.getSource()).getNom() 
+							+ " a maintenant une " + (((Armes) evt.getNewValue()).getNom()+"\n") );
+					
+
+				}
+			}
+
+		});
+
+	}
+
+}

src/vue/swing/VuePrincipale.java

@@ -0,0 +1,129 @@
+package vue.swing;
+
+
+import javax.swing.JTextPane;
+
+import modeles.Combat;
+import modeles.EtatJeu;
+import modeles.Joueur;
+import modeles.joueurReel;
+import modeles.joueurOrdinateur;
+import modeles.Position;
+import modeles.pionsReg;
+
+/**
+ * Classe principale du jeu!
+ * 
+ */
+public class VuePrincipale {
+	
+	/**
+	 * Permet de joueur 
+	 * 
+	 * @param etat
+	 * @param fenetreText
+	 */
+	public void commencerJeu(EtatJeu etat, JTextPane fenetreText) {
+		if ((int) (Math.random() * 10) + 1==10)
+			new pionsReg(etat.getTerrain());
+	
+
+		fenetreText.setText(fenetreText.getText()
+				+ "\nC'est le tour du joueur: "
+				+ etat.getJoueurCourrant().getNom()+"\n");
+
+		if (etat.getJoueurCourrant() instanceof joueurReel) {
+			// Si on est un joueur utilisateur on attend le click
+		} else {
+
+			// retourne la position du pionMachine ou du pion utilisateur
+			Position positionChoisie = ((joueurOrdinateur) etat
+					.getJoueurCourrant()).proposeDeplacement();
+
+			jouerUnTour(etat, fenetreText, positionChoisie);
+		}
+
+	}
+	
+	/**
+	 * Cette méthode commune au pions reel et au pions machine permet de detecter un combat 
+	 * ou un pions regénérateur et de positionner le joueur sur le terrain
+	 * 
+	 * 
+	 * @param etat
+	 * @param fenetreText
+	 * @param positionChoisie
+	 */
+	public void jouerUnTour(EtatJeu etat, JTextPane fenetreText,
+			Position positionChoisie) {
+
+		Joueur joueurPerdant;
+
+		// Si le joueur a choisit une case différente de la sienne
+		if (etat.getTerrain().getOccupant(positionChoisie) != etat
+				.getJoueurCourrant()) {
+			//Si il y a quelqu'un sur la case choisie
+			if (etat.getTerrain().getOccupant(positionChoisie) != null) {
+				//Si le pion est un pionReg
+				if (etat.getTerrain().getOccupant(positionChoisie) instanceof pionsReg) {
+					fenetreText.setText(fenetreText.getText()
+							+ "\n"+etat.getJoueurCourrant().getNom()+" utilise une potion \n");
+					etat.getJoueurCourrant().setPv(
+							etat.getJoueurCourrant().getPv()
+									+ etat.getTerrain().getOccupant(
+											positionChoisie).getHeritage());
+					etat.getTerrain().getTuile(positionChoisie).setOccupant(
+							null);
+					etat.getTerrain().PositionnerJoueurs(
+							etat.getJoueurCourrant(), positionChoisie);
+				} else {
+					fenetreText
+							.setText(fenetreText.getText()
+									+ "\nUn combat est lancé, il se déroule en 4 rounds \n");
+
+					etat.setJoueurDefense(etat.getTerrain().getOccupant(
+							positionChoisie));
+
+					// Initialise et lance le combat, le joueur perdant sera
+					// determiné a la fin du round
+					Combat combat = new Combat(etat);
+					joueurPerdant = combat.lancer();
+
+					if (joueurPerdant == null)
+					    	
+						fenetreText
+								.setText(fenetreText.getText()
+										+ " \nEgalité les deux joueurs sont téléportés !\n");
+			
+					else
+						fenetreText.setText(fenetreText.getText() + "\n"
+								+ joueurPerdant.getNom() + " a perdu !\n");
+					
+
+					combat.resoudreCombat(joueurPerdant, positionChoisie);
+
+					// Si il y'a pas eu de combat on le positionne sur la case
+					// voulue
+				}
+			} else {
+				etat.getTerrain().PositionnerJoueurs(etat.getJoueurCourrant(),
+						positionChoisie);
+			}
+		}
+
+		if (etat.getJoueurs().size() == 1) {
+			if (etat.getJoueurs().get(0) instanceof joueurReel)
+			fenetreText.setText(fenetreText.getText() + "\nFélicitaion "
+					+ etat.getJoueurs().get(0).getNom() + "! Vous avez gagné.\nLe monde vous doit une fière chandelle");
+			else
+				fenetreText.setText(fenetreText.getText() + "\n\n"
+						+ etat.getJoueurs().get(0).getNom() + " a gagné! Il va conquérir le reste du monde.\nMais qu'allons nous faire?");
+		} else {
+			etat.passeLeTour();
+			
+			
+			
+			commencerJeu(etat, fenetreText);
+		}
+	}
+}

src/vue/swing/VueTerrain.java

@@ -0,0 +1,41 @@
+package vue.swing;
+
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.GridLayout;
+
+import javax.swing.JPanel;
+
+import modeles.Position;
+import modeles.Terrain;
+
+/**
+ * Permet de représenter le terrain qui est un tableau de vue tuile
+ * 
+ *
+ */
+@SuppressWarnings("serial")
+public class VueTerrain extends JPanel {
+
+	/**
+	 * Référence vers un modèle de terrain.
+	 */
+	private Terrain terrain;
+
+	public Terrain getTerrain() {
+		return this.terrain;
+	}
+
+	public VueTerrain(Terrain t) {
+		this.terrain = t;
+		this.setBackground(Color.BLACK);
+		GridLayout gl = new GridLayout(this.terrain.getCol(), this.terrain.getLigne());
+		this.setLayout(gl);
+this.setPreferredSize(new Dimension(t.getLigne()*50,t.getCol()*50));
+		for (int i = 0; i < this.terrain.getCol(); i++) 
+			for (int j = 0; j < this.terrain.getLigne(); j++) 
+				this.add(new VueTuile(this.terrain, new Position (i,j)));
+			
+		
+	}
+}

src/vue/swing/VueTuile.java

@@ -0,0 +1,102 @@
+package vue.swing;
+
+
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.GridLayout;
+import java.awt.Image;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.io.File;
+import java.io.IOException;
+import javax.imageio.ImageIO;
+import javax.swing.JPanel;
+
+import modeles.Joueur;
+import modeles.Position;
+import modeles.Terrain;
+import modeles.Tuile;
+
+/**
+ * Permet de représenter la tuile sur le terrain
+ * 
+ *
+ */
+@SuppressWarnings("serial")
+public class VueTuile extends JPanel {
+
+	public static final Integer LARGEUR = 50;
+	public static final Integer HAUTEUR = 50;
+
+	/**
+	 * Référence vers un modèle de tuile.
+	 */
+	private Tuile tuile;
+
+	public Tuile getTuile() {
+		return this.tuile;
+	}
+	
+	/**
+	 * Position de la tuile.
+	 */
+	private Position position;
+
+	public Position getPosition() {
+		return this.position;
+	}
+
+	/**
+	 * Référence vers l'objet VueJoueur pouvant être présent sur la tuile.
+	 */
+	private VueJoueur pion;
+
+	/**
+	 * Constructeur.
+	 */
+	public VueTuile(Terrain terrain, Position position) {
+		this.tuile = terrain.getTuile(position);
+		this.position = position;
+
+		this.setPreferredSize(new Dimension(LARGEUR, HAUTEUR));
+		this.setLayout(new GridLayout(1, 1));
+
+		// La VueTuile courante se met à l'écoute des changements d'occupant de
+		// son modèle de Tuile.
+		 terrain.getTuile(position).ajouterEcouteurOccupant(new PropertyChangeListener() {
+
+			@Override
+			public void propertyChange(PropertyChangeEvent evt) {
+					if (evt.getNewValue() == null) {
+					remove(pion);
+					pion = null;
+					repaint();
+				}
+					else {
+						
+
+						repaint();
+					pion = new VueJoueur((Joueur) evt.getNewValue());
+					add(pion);
+					pion.setPreferredSize(new Dimension(LARGEUR, HAUTEUR));
+					revalidate();
+				}
+			}
+
+		});
+	}
+	
+	/**
+	 * Méthode se chargant automatiquement permettant de créé l'image de la tuile
+	 * 
+	 */
+    public void paintComponent(Graphics g){
+        try {
+                Image img = ImageIO.read(new File("images/tuile.jpg"));
+                g.drawImage(img, 0, 0, this.getWidth(), this.getHeight(), this);
+        } catch (IOException e) {
+                e.printStackTrace();
+        }
+        
+    } 
+}