Last changes
BIN
images/Guerrier1.gif
Normal file
After Width: | Height: | Size: 26 KiB |
BIN
images/Guerrier1.jpg
Normal file
After Width: | Height: | Size: 14 KiB |
BIN
images/Guerrier2.gif
Normal file
After Width: | Height: | Size: 26 KiB |
BIN
images/Guerrier2.jpg
Normal file
After Width: | Height: | Size: 14 KiB |
BIN
images/Guerrier3.gif
Normal file
After Width: | Height: | Size: 26 KiB |
BIN
images/Guerrier3.jpg
Normal file
After Width: | Height: | Size: 14 KiB |
BIN
images/Guerrier4.gif
Normal file
After Width: | Height: | Size: 29 KiB |
BIN
images/Guerrier4.jpg
Normal file
After Width: | Height: | Size: 15 KiB |
BIN
images/alien1.gif
Normal file
After Width: | Height: | Size: 25 KiB |
BIN
images/alien1.jpg
Normal file
After Width: | Height: | Size: 12 KiB |
BIN
images/alien2.gif
Normal file
After Width: | Height: | Size: 25 KiB |
BIN
images/alien2.jpg
Normal file
After Width: | Height: | Size: 12 KiB |
BIN
images/alien3.gif
Normal file
After Width: | Height: | Size: 25 KiB |
BIN
images/alien3.jpg
Normal file
After Width: | Height: | Size: 12 KiB |
BIN
images/alien4.gif
Normal file
After Width: | Height: | Size: 26 KiB |
BIN
images/alien4.jpg
Normal file
After Width: | Height: | Size: 12 KiB |
BIN
images/plateauJeu.png
Normal file
After Width: | Height: | Size: 68 KiB |
BIN
images/potion1.gif
Normal file
After Width: | Height: | Size: 34 KiB |
BIN
images/potion1.jpg
Normal file
After Width: | Height: | Size: 11 KiB |
BIN
images/potion2.gif
Normal file
After Width: | Height: | Size: 29 KiB |
BIN
images/potion2.jpg
Normal file
After Width: | Height: | Size: 17 KiB |
BIN
images/potion3.gif
Normal file
After Width: | Height: | Size: 38 KiB |
BIN
images/potion3.jpg
Normal file
After Width: | Height: | Size: 16 KiB |
BIN
images/tuile.jpg
Normal file
After Width: | Height: | Size: 104 KiB |
75
src/modeles/Armes.java
Normal file
@ -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;
|
||||
}
|
||||
|
||||
|
||||
}
|
360
src/modeles/Combat.java
Normal file
@ -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);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
115
src/modeles/EtatJeu.java
Normal file
@ -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));
|
||||
}
|
||||
}
|
334
src/modeles/Joueur.java
Normal file
@ -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;
|
||||
}
|
||||
|
||||
}
|
24
src/modeles/Position.java
Normal file
@ -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;
|
||||
}
|
||||
|
||||
}
|
21
src/modeles/Ressources.java
Normal file
@ -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
|
||||
|
||||
}
|
145
src/modeles/Terrain.java
Normal file
@ -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;
|
||||
}
|
||||
|
||||
}
|
80
src/modeles/Tuile.java
Normal file
@ -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);
|
||||
}
|
||||
|
||||
}
|
128
src/modeles/joueurOrdinateur.java
Normal file
@ -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;
|
||||
|
||||
}
|
||||
}
|
29
src/modeles/joueurReel.java
Normal file
@ -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;
|
||||
}
|
||||
}
|
53
src/modeles/pionsReg.java
Normal file
@ -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;
|
||||
}
|
||||
|
||||
|
||||
}
|
208
src/vue/swing/CreerJeu.java
Normal file
@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
166
src/vue/swing/CreerJeuFenetre.java
Normal file
@ -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);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
48
src/vue/swing/CreerJeuFenetreInfo.java
Normal file
@ -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;
|
||||
}
|
||||
}
|
12
src/vue/swing/LancerJeu.java
Normal file
@ -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();
|
||||
}
|
||||
}
|
82
src/vue/swing/MediateurVuePrincipale.java
Normal file
@ -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());
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
146
src/vue/swing/MenuInterfaceGraphique.java
Normal file
@ -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;
|
||||
}
|
||||
}
|
141
src/vue/swing/UtilisateurDialog.java
Normal file
@ -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);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
42
src/vue/swing/UtilisateurDialogInfo.java
Normal file
@ -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;
|
||||
}
|
||||
}
|
253
src/vue/swing/VueJoueur.java
Normal file
@ -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") );
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
});
|
||||
|
||||
}
|
||||
|
||||
}
|
129
src/vue/swing/VuePrincipale.java
Normal file
@ -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);
|
||||
}
|
||||
}
|
||||
}
|
41
src/vue/swing/VueTerrain.java
Normal file
@ -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)));
|
||||
|
||||
|
||||
}
|
||||
}
|
102
src/vue/swing/VueTuile.java
Normal file
@ -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();
|
||||
}
|
||||
|
||||
}
|
||||
}
|