diff --git a/images/Guerrier1.gif b/images/Guerrier1.gif new file mode 100644 index 0000000..83564a8 Binary files /dev/null and b/images/Guerrier1.gif differ diff --git a/images/Guerrier1.jpg b/images/Guerrier1.jpg new file mode 100644 index 0000000..d29db51 Binary files /dev/null and b/images/Guerrier1.jpg differ diff --git a/images/Guerrier2.gif b/images/Guerrier2.gif new file mode 100644 index 0000000..a2fd88b Binary files /dev/null and b/images/Guerrier2.gif differ diff --git a/images/Guerrier2.jpg b/images/Guerrier2.jpg new file mode 100644 index 0000000..94c5a94 Binary files /dev/null and b/images/Guerrier2.jpg differ diff --git a/images/Guerrier3.gif b/images/Guerrier3.gif new file mode 100644 index 0000000..d4ee077 Binary files /dev/null and b/images/Guerrier3.gif differ diff --git a/images/Guerrier3.jpg b/images/Guerrier3.jpg new file mode 100644 index 0000000..ff1147f Binary files /dev/null and b/images/Guerrier3.jpg differ diff --git a/images/Guerrier4.gif b/images/Guerrier4.gif new file mode 100644 index 0000000..91743c3 Binary files /dev/null and b/images/Guerrier4.gif differ diff --git a/images/Guerrier4.jpg b/images/Guerrier4.jpg new file mode 100644 index 0000000..5680576 Binary files /dev/null and b/images/Guerrier4.jpg differ diff --git a/images/alien1.gif b/images/alien1.gif new file mode 100644 index 0000000..ec0b701 Binary files /dev/null and b/images/alien1.gif differ diff --git a/images/alien1.jpg b/images/alien1.jpg new file mode 100644 index 0000000..0758aa5 Binary files /dev/null and b/images/alien1.jpg differ diff --git a/images/alien2.gif b/images/alien2.gif new file mode 100644 index 0000000..5db3bf8 Binary files /dev/null and b/images/alien2.gif differ diff --git a/images/alien2.jpg b/images/alien2.jpg new file mode 100644 index 0000000..95c2d49 Binary files /dev/null and b/images/alien2.jpg differ diff --git a/images/alien3.gif b/images/alien3.gif new file mode 100644 index 0000000..487c649 Binary files /dev/null and b/images/alien3.gif differ diff --git a/images/alien3.jpg b/images/alien3.jpg new file mode 100644 index 0000000..9bebc2a Binary files /dev/null and b/images/alien3.jpg differ diff --git a/images/alien4.gif b/images/alien4.gif new file mode 100644 index 0000000..ba78025 Binary files /dev/null and b/images/alien4.gif differ diff --git a/images/alien4.jpg b/images/alien4.jpg new file mode 100644 index 0000000..8e0eaa1 Binary files /dev/null and b/images/alien4.jpg differ diff --git a/images/plateauJeu.png b/images/plateauJeu.png new file mode 100644 index 0000000..b9cacda Binary files /dev/null and b/images/plateauJeu.png differ diff --git a/images/potion1.gif b/images/potion1.gif new file mode 100644 index 0000000..756f4ad Binary files /dev/null and b/images/potion1.gif differ diff --git a/images/potion1.jpg b/images/potion1.jpg new file mode 100644 index 0000000..37576ca Binary files /dev/null and b/images/potion1.jpg differ diff --git a/images/potion2.gif b/images/potion2.gif new file mode 100644 index 0000000..3e52f05 Binary files /dev/null and b/images/potion2.gif differ diff --git a/images/potion2.jpg b/images/potion2.jpg new file mode 100644 index 0000000..09817cf Binary files /dev/null and b/images/potion2.jpg differ diff --git a/images/potion3.gif b/images/potion3.gif new file mode 100644 index 0000000..3922eea Binary files /dev/null and b/images/potion3.gif differ diff --git a/images/potion3.jpg b/images/potion3.jpg new file mode 100644 index 0000000..5472731 Binary files /dev/null and b/images/potion3.jpg differ diff --git a/images/tuile.jpg b/images/tuile.jpg new file mode 100644 index 0000000..fe94def Binary files /dev/null and b/images/tuile.jpg differ diff --git a/src/modeles/Armes.java b/src/modeles/Armes.java new file mode 100644 index 0000000..14b13eb --- /dev/null +++ b/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; + } + + +} diff --git a/src/modeles/Combat.java b/src/modeles/Combat.java new file mode 100644 index 0000000..eabace5 --- /dev/null +++ b/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); + } + + } +} diff --git a/src/modeles/EtatJeu.java b/src/modeles/EtatJeu.java new file mode 100644 index 0000000..361bcec --- /dev/null +++ b/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 joueurs; + /** + * le joueur courrant + */ + private Joueur joueurCourrant; + /** + * le joueur qui se défend + */ + private Joueur joueurDefense; + + public EtatJeu(Terrain terrain,ArrayList 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 getJoueurs (){ + return this.joueurs; + } + + public void setJoueurs (Joueur joueurCourrant){ + this.joueurs.add(joueurCourrant); + } + + public void setArrayListJoueurs (ArrayList 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)); + } +} \ No newline at end of file diff --git a/src/modeles/Joueur.java b/src/modeles/Joueur.java new file mode 100644 index 0000000..2ebd020 --- /dev/null +++ b/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; + } + +} \ No newline at end of file diff --git a/src/modeles/Position.java b/src/modeles/Position.java new file mode 100644 index 0000000..40f82f8 --- /dev/null +++ b/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; + } + +} diff --git a/src/modeles/Ressources.java b/src/modeles/Ressources.java new file mode 100644 index 0000000..99c7296 --- /dev/null +++ b/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 + +} diff --git a/src/modeles/Terrain.java b/src/modeles/Terrain.java new file mode 100644 index 0000000..3a76967 --- /dev/null +++ b/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 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; + } + +} diff --git a/src/modeles/Tuile.java b/src/modeles/Tuile.java new file mode 100644 index 0000000..3b70221 --- /dev/null +++ b/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); + } + +} diff --git a/src/modeles/joueurOrdinateur.java b/src/modeles/joueurOrdinateur.java new file mode 100644 index 0000000..5fab965 --- /dev/null +++ b/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 joueursDetectes = new ArrayList(); + ArrayList tuilesAccesibles = new ArrayList(); + + 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 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; + + } +} diff --git a/src/modeles/joueurReel.java b/src/modeles/joueurReel.java new file mode 100644 index 0000000..7d640c8 --- /dev/null +++ b/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; + } +} diff --git a/src/modeles/pionsReg.java b/src/modeles/pionsReg.java new file mode 100644 index 0000000..2cbe130 --- /dev/null +++ b/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; + } + + +} diff --git a/src/vue/swing/CreerJeu.java b/src/vue/swing/CreerJeu.java new file mode 100644 index 0000000..ea2012f --- /dev/null +++ b/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 joueurs = new ArrayList(); + 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 creerLesPersos(int nombrePersonnageOrdinateur, int nombrePersonnageJoueur, Terrain terrain) { + ArrayList joueurs = new ArrayList(); + 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 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 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); + } + } + +} diff --git a/src/vue/swing/CreerJeuFenetre.java b/src/vue/swing/CreerJeuFenetre.java new file mode 100644 index 0000000..675b1be --- /dev/null +++ b/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); + } + + +} + diff --git a/src/vue/swing/CreerJeuFenetreInfo.java b/src/vue/swing/CreerJeuFenetreInfo.java new file mode 100644 index 0000000..040fa5b --- /dev/null +++ b/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; + } +} diff --git a/src/vue/swing/LancerJeu.java b/src/vue/swing/LancerJeu.java new file mode 100644 index 0000000..4f15209 --- /dev/null +++ b/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(); + } +} diff --git a/src/vue/swing/MediateurVuePrincipale.java b/src/vue/swing/MediateurVuePrincipale.java new file mode 100644 index 0000000..9ae42d7 --- /dev/null +++ b/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("Nom Hp/HpMax Attaque Def heritage Nombre de vie Niveau Arme
" + + //joueurCourant.getNom()+" "+ joueurCourant.getPv()+"/"+joueurCourant.getPv()+" "+ joueurCourant.getAtt()+" "+ joueurCourant.getdef()+" "+joueurCourant.getHeritage()+" "+joueurCourant.getNbVies()+" "+joueurCourant.getNiveau()+" "+joueurCourant.getArme().getNom()+" "); + if(joueurCase instanceof pionsReg){ + composantVisuelTuile.setToolTipText("Points vie : "+joueurCase.getHeritage()); + } + else + composantVisuelTuile.setToolTipText("Nom : "+joueurCase.getNom()+" Hp : "+ joueurCase.getPv()+" Attaque : "+ joueurCase.getAtt()+" Def : "+ joueurCase.getdef()+" Heritage : "+joueurCase.getHeritage()+"
Nombre de vie : "+joueurCase.getNbVies()+" Niveau : "+joueurCase.getNbVies()+" Arme : "+joueurCase.getArme().getNom()); + } + } + }); + } + } +} \ No newline at end of file diff --git a/src/vue/swing/MenuInterfaceGraphique.java b/src/vue/swing/MenuInterfaceGraphique.java new file mode 100644 index 0000000..587ed13 --- /dev/null +++ b/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; + } +} diff --git a/src/vue/swing/UtilisateurDialog.java b/src/vue/swing/UtilisateurDialog.java new file mode 100644 index 0000000..dce8975 --- /dev/null +++ b/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); + } + + +} + diff --git a/src/vue/swing/UtilisateurDialogInfo.java b/src/vue/swing/UtilisateurDialogInfo.java new file mode 100644 index 0000000..e8c4baf --- /dev/null +++ b/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; + } +} \ No newline at end of file diff --git a/src/vue/swing/VueJoueur.java b/src/vue/swing/VueJoueur.java new file mode 100644 index 0000000..8b6b3b0 --- /dev/null +++ b/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") ); + + + } + } + + }); + + } + +} diff --git a/src/vue/swing/VuePrincipale.java b/src/vue/swing/VuePrincipale.java new file mode 100644 index 0000000..5bcbfe1 --- /dev/null +++ b/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); + } + } +} diff --git a/src/vue/swing/VueTerrain.java b/src/vue/swing/VueTerrain.java new file mode 100644 index 0000000..9046c9d --- /dev/null +++ b/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))); + + + } +} diff --git a/src/vue/swing/VueTuile.java b/src/vue/swing/VueTuile.java new file mode 100644 index 0000000..2cb9832 --- /dev/null +++ b/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(); + } + + } +}