// Méthode qui permet à un joueur de participer aux constructions en cours.
public String[] participerAuChantier(Joueur ceJoueur) {
String[] fini = {"", ""};
int num, choix, pointUse;
// S'il existe des batiments en cours de construction
if (!this.getBatimentEnCours().isEmpty()) {
Outils.affichage(afficherConstructionEnCours());
Outils.affichage(Journal.consulterDescription(36));
choix = Outils.donnerReponseChiffre(batimentEnCours.size() - 1);
Outils.affichage(
Journal.consulterDescription(74)
+ batimentEnCours.get(choix).getConso_pa()
+ Journal.consulterDescription(75));
Outils.affichage(Journal.consulterDescription(76));
// Si le joueur confirme vouloir participer aux constructions
if (Outils.conversionBoolean(sc.next())) {
Outils.affichage(Journal.consulterDescription(77));
num = Outils.donnerReponseChiffre(ceJoueur.getPa());
pointUse = batimentEnCours.get(choix).getConso_pa();
if (batimentEnCours
.get(choix)
.setConso_pa((batimentEnCours.get(choix).getConso_pa() - num))) {
fini[0] = "Y";
fini[1] = batimentEnCours.get(choix).getNom();
ceJoueur.setPa(ceJoueur.getPa() - pointUse);
} else {
ceJoueur.setPa(ceJoueur.getPa() - num);
}
}
} else {
fini[0] = "N";
fini[1] = Journal.consulterDescription(115);
}
return fini;
}
/**
* Permet de recuperer le score de l'equipe qui correspond à la somme des scores de joueurs de
* l'équipe.
*
* @return le score
*/
public int getScore() {
int somme = 0;
for (Joueur joueur : joueurs) somme += joueur.getScore();
return somme;
}
/** Traitement lors d'un clic sur le bouton fin redéploiement */
public void cliqueFinRedeploiement() {
if (joueurEnCours.getPeuple().getNbUniteEnMain() == 0) {
if ((etape == 2 || etape == 3)) {
if (Game.getInstance().askConf("Confirmer la fin du redéploiement ?")) {
if (etape == 2) {
if (tempEnDeclin) {
joueurEnCours.getPeuple().decliner();
tempEnDeclin = false;
}
/* on passe à l'étape redéploiement des autres joueurs */
setEtape(3);
/* et on indique que le joueur passe au tour suivant pour après ne pas le faire rejouer */
indexSauvJoueurEnCours = indexJoueurEnCours;
indexJoueurEnCours = 0;
}
if (!deploiementSuivant()) {
joueurSuivant();
}
Game.getInstance().majInfos();
}
}
} else {
new WinWarn("Il vous reste des unités en main, placez-les !");
}
}
/**
* Voir les informations des personnages sur les bandeaux des joueurs
*
* @param positionCaseSelectionné position de la case selectionné
*/
public void voirInfoPersonnage(int[] positionCaseSelectionné) {
Personnage p = plateau.caseGetPersonnage(positionCaseSelectionné);
if (p != null) {
if (joueur1.possedePersonnage(p)) ihmjeu.getBandeau1().getInfo().miseAJour(p);
else if (joueur2.possedePersonnage(p)) ihmjeu.getBandeau2().getInfo().miseAJour(p);
}
}
/** Demande aux joueurs ayant des unités en main de les placer */
public boolean deploiementSuivant() {
int nextJoueur =
(indexSauvJoueurEnCours + 1) == lstJoueurs.size() ? 0 : (indexSauvJoueurEnCours + 1);
for (; indexJoueurEnCours < lstJoueurs.size(); indexJoueurEnCours++) {
if (indexJoueurEnCours == nextJoueur) {
continue;
}
joueurEnCours = lstJoueurs.get(indexJoueurEnCours);
Peuple p = joueurEnCours.getPeuple();
if (p != null && p.getNbUniteEnMain() > 0) {
Game.getInstance().showTemp(joueurEnCours.getNom() + " se redéploie.");
return true;
}
}
indexJoueurEnCours = indexSauvJoueurEnCours;
joueurEnCours = lstJoueurs.get(indexSauvJoueurEnCours);
return false;
}
/** Verifie si un des deux joueurs gagne la partie */
public void verifiegagner() {
Joueur j;
if (this.verifieEquipeKO(joueur1)) j = joueur2;
else if (this.verifieEquipeKO(joueur2)) j = joueur1;
else j = null;
if (j != null) {
JOptionPane.showMessageDialog(
null,
"Bravo le joueur " + j.getNom() + " a gagner la partie",
"Fin de la Partie",
JOptionPane.NO_OPTION,
new ImageIcon("image/gagner.png"));
Object[] options = {"Recommencer une nouvelle partie", " Quitter le jeu"};
int confirm =
JOptionPane.showOptionDialog(
null,
"Que voulez vous faire ?",
"Quitter le jeu",
JOptionPane.YES_NO_OPTION,
JOptionPane.QUESTION_MESSAGE,
null,
options,
options[1]);
if (confirm == 1) {
System.exit(0);
} else if (confirm == 0) {
ihmjeu.dispose();
new Jeu();
}
}
}
/** Phase de redeploiement */
public void redeploiement() {
setEtape(2);
miseEnMain();
joueurEnCours.getPeuple().calcBonusUnite();
Game.getInstance().majInfos();
Game.getInstance().showTemp(joueurEnCours.getNom() + " se redéploie.");
}
/** De 2 à 5 joueurs */
@Override
public void initialisation(Plateau p, List<Joueur> joueurs) {
premierTour = true;
initialiserCouleurs();
this.joueurs = joueurs;
for (Joueur joueur : joueurs) {
joueur.initialiserTasDeCartes();
}
joueurCourant = joueurs.get(0);
}
/** Permet de récupérer les cartes dans la main des joueurs. */
private void recupererCartesMain() {
Joueur premierJoueur = this.joueurCourant;
do {
for (Carte carte : joueurCourant.getMain().hashtableToList()) {
this.table.getPaquet().ajouter(carte);
joueurCourant.getMain().supprimer(carte);
}
this.joueurCourant = table.joueurSuivant(this.joueurCourant);
} while (this.joueurCourant != premierJoueur);
}
/**
* Permet de retirer un joueur de l'equipe. Corollaire : Le joueur quittera egalement son
* emplacement.
*
* @param joueur le joueur
*/
public void retirerJoueur(Joueur joueur) {
// effacement
joueurs.remove(joueur);
// quitte l'emplacement
if (joueur.getEmplacement() != null) joueur.getEmplacement().retirerJoueur();
// quitte l'equipe
joueur.setEquipe(null);
}
/**
* Permet de savoir si l'équipe est hors jeu.
*
* <p>Si tous les joueurs de l'équipe sont hors jeu, l'équipe est considérée comme hors jeu.
*
* @return true si elle l'est, false sinon
*/
public boolean estHorsJeu() {
Joueur joueur;
Enumeration<Joueur> e = joueurs.elements();
while (e.hasMoreElements()) {
joueur = e.nextElement();
// si il y au moins un joueur pas hors jeu
if (!joueur.estHorsJeu()) return false;
}
return true;
}
@Override
public Joueur gagne() {
Joueur gagnant = new Joueur("test", "J", 0);
if (jeuFini()) {
for (Joueur j : joueurs) {
if (gagnant.getArgentGagne() < j.getArgentGagne()) {
gagnant = j;
}
}
}
return gagnant;
}
@Override
public String toString() {
return "Match Simple ("
+ getTour()
+ ") : "
+ j1.prenomNom()
+ " VS "
+ j2.prenomNom()
+ " - "
+ getDate()
+ ", à "
+ getRealTime();
}
/**
* Traitements en fonction du territoire cliqué
*
* @param territoire Territoire cliqué par l'utilisateur
*/
public void cliqueTerritoire(Territoire territoire) {
if (etape == 0 || etape == 1) {
// Phase d'attaque
if (joueurEnCours.getPeuple().equals(territoire.getOccupant())) {
List<Peuple> ls = territoire.getPrisesDuTerritoire(tourEnCours);
if (!ls.contains(getJoueurEnCours().getPeuple())
&& Game.getInstance().askAbandon(territoire)) {
getJoueurEnCours().getPeuple().abandonTerritoire(territoire);
}
} else {
// if(coutAttaque(territoire) > joueurEnCours.getPeuple().)
if (getJoueurEnCours().peutAttaquerUnTerritoire(territoire) || territoire.estEnBordure()) {
if (Game.getInstance().askAttaque(territoire)) {
if (getJoueurEnCours().attaquer(territoire) && etape == 0) {
etape = 1;
}
}
} else {
new WinWarn("Vous ne pouvez pas attaquer ce territoire.");
return;
}
}
Game.getInstance().majInfos();
} else if (etape == 2 || etape == 3) {
// Phase de redéploiement
if (joueurEnCours.getPeuple().equals(territoire.getOccupant())) {
int nbPion = Game.getInstance().askNbPion(territoire);
if (nbPion > 0) {
getJoueurEnCours().getPeuple().addNbUniteEnMain(-(nbPion - territoire.getNbUnite()));
territoire.setNbUnite(nbPion);
} else if (nbPion == 0) {
if (Game.getInstance().askAbandon(territoire)) {
getJoueurEnCours().getPeuple().abandonTerritoire(territoire);
}
}
Game.getInstance().majInfos();
} else {
new WinWarn("Vous ne pouvez que vous redéployer sur un de vos territoires");
}
}
}
public void initHands() {
for (Joueur joueur : joueurs) {
joueur.prendreCarte(pioche.piocherCarte());
joueur.prendreCarte(pioche.piocherCarte());
fini.put(joueur, new StringBuffer("f"));
}
for (Joueur joueur : joueurs) {
if (joueur.getPts() == 21) {
for (Joueur j : joueurs) fini.get(j).setCharAt(0, 't');
JOptionPane.showMessageDialog(null, "BLACKJACK ! Bien joué " + joueur.getPseudo() + "!");
}
}
}
public String affiche() {
return "Match Simple - "
+ getTour()
+ " ("
+ getDate()
+ " à "
+ getRealTime()
+ ")\nSur le "
+ getCourt()
+ ".\n\n"
+ j1.prenomNom()
+ " Contre "
+ j2.prenomNom()
+ "\n\nVoulez-vous modifier ce match ?";
}
/**
* On distribue 2 cartes troupes à chaque joueur Methode appelé dans "distributionCartesDepart(x,
* y)"
*
* @param hjoueur hashset des joueurs
* @param htitre hashset des titres
*/
public void distributionTitreDepart(Set<Joueur> hjoueur, Set<Titre> htitre) {
// On copie le hashSet des titre dans un tableau
// On modifiera donc uniquement le tableau et non le hashSet d'initialisation
Titre[] tabtitre = htitre.toArray(new Titre[htitre.size()]);
// On convertit le tableau en liste pour mélanger et plus de simplicitée.
ArrayList<Titre> list = new ArrayList<Titre>(Arrays.asList(tabtitre));
Collections.shuffle(list);
for (Joueur j : hjoueur) {
// On affecte le titre au joueur
j.setTitre(list.get(0));
// On supprimer le titre de la liste pour ne pas le redonner
list.remove(0);
}
}
/** {@inheritDoc} */
@Override
public int determinerJoueurLePlusFort(Partie p) {
int indexJoueur = -1;
for (Iterator<Joueur> joueurs = p.getJoueurs().iterator(); joueurs.hasNext(); ) {
Joueur j = joueurs.next();
if (indexJoueur == -1 && !j.equals(p.getJoueurPresent())) {
indexJoueur = p.getJoueurs().indexOf(j);
} else if (!j.equals(p.getJoueurPresent())
&& (j.getNombreTotalDeCartes()
< p.getJoueurs().get(indexJoueur).getNombreTotalDeCartes())) {
indexJoueur = p.getJoueurs().indexOf(j);
}
}
return indexJoueur;
}
/** Traitement lors d'un clic sur le bouton passer en déclin */
public void cliqueDeclin() {
if (etape == 0
&& joueurEnCours.getPeupleDeclin() == null
&& Game.getInstance().askConf("Confirmer le passage en déclin ?")) {
// joueurEnCours.getPeuple().decliner();
// joueurSuivant();
tempEnDeclin = true;
setEtape(2);
miseEnMain();
Game.getInstance().showTemp(joueurEnCours.getNom() + " se redéploie.");
}
Game.getInstance().majInfos();
}
/**
* permet de fournir le coût de l'attaque d'un territoire donnée appelé depuis TerritoireCase
*
* @param t
* @return
*/
public double coutAttaque(Territoire t) {
try {
return t.coutAttaque(joueurEnCours.getPeuple());
} catch (Exception e) {
}
return 0.0;
}
@Override
public Boolean jouer(Joueur j, Carte c) {
Boolean ok = j.poserCarte(plateau, c);
if (jeuFini()) {
System.out.println("Le joueur " + gagne().getIdJoueur() + " a gagné !");
}
return ok;
}
/** Met à jour les personnages s'ils sont KO */
public void MAJPVPersonnage() {
for (Personnage p : joueur1.getEquipe()) {
if (p.isPointVieEgal0() && !p.isKO()) {
p.setKO();
Case c = plateau.getCase(p.getPosition());
c.liberer();
}
}
for (Personnage p : joueur2.getEquipe()) {
if (p.isPointVieEgal0() && !p.isKO()) {
p.setKO();
Case c = plateau.getCase(p.getPosition());
c.liberer();
}
}
}
/**
* Distribution de 2 cartes Troupes à chaque joueurs On retire les deux dernières cartes du paquet
* de troupes
*
* @param hjoueur liste des joueurs
* @param llct paquet des cartes troupes qui sert à donner des cartes aux joueurs
*/
public void distributionCartesDepart(Set<Joueur> hjoueur, LinkedList<CarteTroupe> llct) {
for (Joueur j : hjoueur) {
// Distibution des titres aléatoirement
distributionTitreDepart(hjoueur, hashTitre);
int i = 0;
// On prend la liste de carte troupe du joueur
ArrayList<CarteTroupe> alct = j.getAlctroupe();
// On ne prend que deux cartes troupes (à chaque fois la dernière du paquet)
while (i < 2) {
alct.add(llct.getLast());
// On supprime la carte pour ne plus l'avoir dans le paquet
llct.removeLast();
i++;
}
}
}
/** Traitement lors d'un clic sur le bouton fin tour */
public void cliqueFinTour() {
/* en mode conquete, confirmé, et possède au moins un territoire (sinon il ne peut pas redéployer...) */
if (joueurEnCours.getPeuple().getTerritoiresOccupes().isEmpty()) {
new WinWarn("Veuillez tout d'abord prendre au moins un territoire");
} else if ((etape == 0 || etape == 1)
&& Game.getInstance().askConf("Confirmer la fin du tour ?")) {
redeploiement();
}
}
public void methode(int valeurMalus, Joueur joueur) {
valeurCarac = r.nextInt(carac.length);
switch (valeurCarac) {
case 0:
joueur.setAttaque(joueur.attaque + valeurMalus);
break;
case 1:
joueur.setDefense(joueur.defense + valeurMalus);
break;
case 2:
joueur.setVitesse(joueur.vitesse + valeurMalus);
break;
case 3:
joueur.setChance(joueur.chance + valeurMalus);
break;
}
joueur.checkStat();
}
/**
* Permet d'ajouter un joueur dans l'équipe à un emplacement particulier.
*
* @param joueur le joueur
* @param ej l'emplacement
* @throws EmplacementOccupeException
*/
public void ajouterJoueur(Joueur joueur, EmplacementJoueur ej) throws EmplacementOccupeException {
if (joueur == null) throw new IllegalArgumentException();
if (ej == null) throw new IllegalArgumentException();
if (ej.getJoueur() != null) throw new EmplacementOccupeException("EmplacementJoueur occupé");
// on retire le joueur de son ancienne equipe
if (joueur.getEquipe() != null) joueur.getEquipe().retirerJoueur(joueur);
// on l'ajout dans la nouvelle equipe
joueurs.add(joueur);
// on modifier sont equipe
joueur.setEquipe(this);
// on lui attribut le nouvel emplacement
joueur.setEmplacementJoueur(ej);
}
/** Changement de joueur dans le tour donné */
public void joueurSuivant() {
setEtape(0);
/* on calcule les gains du tour et on met à jour les pts de victoire */
int argent = joueurEnCours.calcArgentTour();
Game.getInstance().showTemp(argent + " point(s) gagné(s) durant ce tour !");
joueurEnCours.addArgent(argent);
if (indexJoueurEnCours == lstJoueurs.size() - 1) {
nouveauTour();
} else {
indexJoueurEnCours++;
joueurEnCours = lstJoueurs.get(indexJoueurEnCours);
if (joueurEnCours.getPeuple() == null) {
Game.getInstance().selectionPeuple();
} else if (joueurEnCours.getPeuple().getNbUnite() == 0) {
remettreBoite(joueurEnCours.getPeuple());
Game.getInstance().selectionPeuple();
}
miseEnMain();
Game.getInstance().showTemp(joueurEnCours.getNom() + " attaque !");
}
}
/**
* Place un personnage sur le plateau
*
* @param j joueur qui va placer les personnages
* @param idPersonnage numero du personnage dans l'équipe du joueur
* @param positionCaseSelectionné position de la case à placer le joueur
* @throws CaseNonVide Exception
* @throws CaseAdverse Exception
*/
public void placerPersonnage(Joueur j, int idPersonnage, int[] positionCaseSelectionné)
throws CaseNonVide, CaseAdverse {
if (plateau.caseEstVide(positionCaseSelectionné)) {
if (j == joueur1 && positionCaseSelectionné[0] < TaillePlateauX / 2
|| j == joueur2 && positionCaseSelectionné[0] >= (TaillePlateauX - TaillePlateauX / 2)) {
Personnage p = j.getPersonnage(idPersonnage);
p.setPosition(positionCaseSelectionné);
plateau.poser(p, positionCaseSelectionné);
} else throw new CaseAdverse();
} else {
throw new CaseNonVide();
}
}
// prélève de l'argent a tous les joueurs (sauf celui ayant tiré la carte)
// pour le donner au joueur ayant tiré la carte (peut provoquer une faillite)
@Override
public void applyEffect(Joueur jou) {
int i = 0;
for (Joueur j : this.getMonopoly().getJoueurs()) {
if (!j.equals(jou)) {
if (j.getCash() - getMontant() >= 0) {
j.setCash(j.getCash() - getMontant());
} else {
j.faillite();
}
i++;
}
}
jou.setCash(jou.getCash() + (i * getMontant()));
}
/** Méthode permettant de passer au tour suivant */
public void nouveauTour() {
tourEnCours++;
if (tourEnCours >= nbTours) {
Game.gameOver();
} else {
// RAZ des étapes
etape = 0;
indexJoueurEnCours = 0;
joueurEnCours = this.lstJoueurs.get(indexJoueurEnCours);
// Si le peuple n'a pas de joueur, il doit en choisir un
if (joueurEnCours.getPeuple() == null) {
Game.getInstance().selectionPeuple();
}
Game.getInstance().showTemp(joueurEnCours.getNom() + " attaque !");
miseEnMain();
}
}
