397 lines
10 KiB
Java
397 lines
10 KiB
Java
package fr.blankoworld.plateau;
|
||
|
||
import java.util.Vector;
|
||
|
||
/**
|
||
* @author Olivier DOSSMANN
|
||
*
|
||
*/
|
||
/**
|
||
* Classe plateau qui permet de creer un plateau de jeu
|
||
*/
|
||
public class PlateauPuissance4 {
|
||
|
||
private Jeton[][] grille;
|
||
private int[] positions;
|
||
private boolean alternanceJoueur = true;
|
||
private Joueurs j1;
|
||
private Joueurs j2;
|
||
private Joueurs j0;
|
||
private Vector CollectionJoueurs;
|
||
|
||
public int nbreColonnes = 7;
|
||
public int nbreLignes = 6;
|
||
|
||
/**
|
||
*
|
||
* @param args - Arguments passes en parametre
|
||
*/
|
||
/**
|
||
* Methode principale MAIN
|
||
*/
|
||
public static void main(String args[]){
|
||
// System.out.println("Bienvenue dans Blankuissance4, le nouveau jeu fecal de puissance 4 !");
|
||
|
||
// Instanciation de l'objet a partir de la classe PlateauPuissance4
|
||
PlateauPuissance4 p4 = new PlateauPuissance4();
|
||
|
||
p4.lancer();
|
||
}
|
||
|
||
/**
|
||
* Initialisation des variables, des joueurs, de la grille, etc ...
|
||
*
|
||
*/
|
||
public void initialiser()
|
||
{
|
||
// Initialisation des joueurs
|
||
j1 = new Joueurs("Joueur Un", "R");
|
||
j2 = new Joueurs("Joueur Deux", "J");
|
||
j0 = new Joueurs("Joueur inexistant", " ");
|
||
|
||
// On remplit la collection de joueurs
|
||
CollectionJoueurs = new Vector();
|
||
CollectionJoueurs.add(j0);
|
||
CollectionJoueurs.add(j1);
|
||
CollectionJoueurs.add(j2);
|
||
|
||
// Creation de la grille
|
||
grille = new Jeton[nbreColonnes][nbreLignes];
|
||
|
||
// Creation tu tableau de positionnement
|
||
positions = new int[7];
|
||
|
||
// Initialisation du tableau
|
||
for (int i = 0; i < nbreColonnes; i++){
|
||
for(int j = 0; j < nbreLignes; j++){
|
||
grille[i][j] = j0.donneJeton();
|
||
}
|
||
}
|
||
|
||
// Initialisation des positions
|
||
for (int i = 0; i < nbreColonnes; i++){
|
||
positions[i] = 0;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Permet de relancer le jeu (prevu pour l'ajout supplementaire d'un menu)
|
||
*
|
||
*/
|
||
public void reinitialiser(){
|
||
lancer();
|
||
}
|
||
|
||
/**
|
||
* Affiche la grille de jeu
|
||
*
|
||
*/
|
||
public void afficherGrille(){
|
||
for (int i = nbreLignes - 1; i >= 0; i--){
|
||
for(int j = 0; j < nbreColonnes; j++){
|
||
System.out.print(grille[j][i].getCouleur() + "|");
|
||
}
|
||
System.out.print("\n");
|
||
}
|
||
for (int k = 0; k < nbreColonnes; k++){
|
||
System.out.print("--");
|
||
}
|
||
System.out.print("\n");
|
||
|
||
for (int l = 0; l < nbreColonnes; l++){
|
||
System.out.print(Integer.toString(l + 1) + "|");
|
||
}
|
||
System.out.print("\n");
|
||
}
|
||
|
||
/**
|
||
* C'est ici que le jeu se deroule, que les appels sont faits, etc ...
|
||
* Tout est la !
|
||
*
|
||
*/
|
||
public void lancer(){
|
||
System.out.println("Lancement du jeu de plateau");
|
||
|
||
// Initialisation du plateau
|
||
this.initialiser();
|
||
|
||
// Affichage du plateau pour verification
|
||
this.afficherGrille();
|
||
|
||
// Creation d'une aide pour les entrees de l'utilisateur
|
||
AideSaisie aide = new AideSaisie();
|
||
|
||
// Affichage des joueurs
|
||
System.out.println("Affichage des deux joueurs : ");
|
||
System.out.println(" - " + j1.toString() + ".");
|
||
System.out.println(" - " + j2.toString() + ".");
|
||
|
||
// Creation d'un joueur generique
|
||
Joueurs joueur = new Joueurs("joueur de base", " ");
|
||
|
||
// Numero de colonne choisi
|
||
int colonne = 0;
|
||
|
||
// incrementeur de jetons
|
||
int i = 0;
|
||
|
||
// Contrele d'entree de boucle
|
||
boolean aGagne = false;
|
||
|
||
while (aGagne == false && i < (nbreColonnes * nbreLignes))
|
||
{
|
||
|
||
// Methode pour alterner de joueur : entre le joueur Un et le joueur Deux
|
||
joueur = alterneJoueur(j1,j2);
|
||
|
||
boolean ok = true;
|
||
// Recuperation de la proposition de colonne de l'utilisateur
|
||
while(ok){
|
||
String proposition = aide.getEntreeUtilisateur("Colonne (entre 1 et " + nbreColonnes + ") : ");
|
||
System.out.println("Colonne choisie par " + joueur.getNom() + " : " + proposition);
|
||
|
||
// Traduction en entier du numero de colonne
|
||
if (proposition == null){
|
||
colonne = nbreColonnes;
|
||
}
|
||
else{
|
||
colonne = Integer.parseInt(proposition);
|
||
|
||
// Mise a niveau de la colonne vis a vis de la structure Java
|
||
colonne --;
|
||
}
|
||
|
||
// Verification que la colonne n'est pas pleine ou hors limite
|
||
if (colonne > nbreColonnes - 1 || colonne < 0){
|
||
ok = true;
|
||
System.out.println("Hors limites !");
|
||
}
|
||
else if (!grille[colonne][5].getCouleur().equals(" ")){
|
||
ok = true;
|
||
System.out.println("Colonne a ras bord !");
|
||
}
|
||
else{
|
||
ok = false;
|
||
System.out.println("Longueur du tableau : " + grille[colonne].length);
|
||
|
||
// Si colonne pas pleine, verifier a quel position les pions precedents sont poses
|
||
// Si aucun pion, alors poser tout en bas
|
||
|
||
this.ajoutPion(colonne, joueur.donneJeton().getCouleur());
|
||
this.afficherGrille();
|
||
}
|
||
}
|
||
|
||
// Il faut minimum 7 pions poses, avant de savoir si le joueur a gagne ou pas
|
||
// Comme nous commencons a 0 l'incr<63>menteur (7 - 1 = 6), et que le jeton actuel
|
||
// n'est pas encore compte (6 - 1 = 5),
|
||
// alors on met la valeur a 5. C'est a dire que nous aurons deja i a 7 au minimum quand on fera
|
||
// ce test, et que nous serons dans le cas du 8i<38>me jeton.
|
||
if (i > 5){
|
||
|
||
// Verification si le joueur gagne
|
||
// On decremente de 1 positions[colonne] car nous y avons ajoute 1 pour le pion suivant
|
||
aGagne = gagnant(colonne, positions[colonne] - 1);
|
||
}
|
||
|
||
// Instanciation de i pour confirmer que le coup est lance
|
||
i++;
|
||
// Idem mais alternance du joueur
|
||
alternanceJoueur = !alternanceJoueur;
|
||
System.out.println("Coup numero " + i + " joue !");
|
||
System.out.print("\n");
|
||
}
|
||
|
||
if (i < (nbreColonnes * nbreLignes)){
|
||
System.out.println(joueur.getNom() + " a gagne !");
|
||
System.out.println("Merci au joueur de l'autre equipe d'avoir participe.");
|
||
}
|
||
else{
|
||
System.out.println("Jeu termine, aucun gagnant !");
|
||
System.out.println("Merci d'avoir joue.");
|
||
}
|
||
}
|
||
|
||
/**
|
||
*
|
||
* @param jUn - Joueur Un
|
||
* @param jDeux - Joueur Deux
|
||
* @return Joueur qui dois jouer
|
||
*/
|
||
/**
|
||
* On recupere le joueur qui doit jouer
|
||
*/
|
||
public Joueurs alterneJoueur(Joueurs jUn, Joueurs jDeux){
|
||
|
||
if (alternanceJoueur){
|
||
return jUn;
|
||
}
|
||
else{
|
||
return jDeux;
|
||
}
|
||
}
|
||
|
||
/**
|
||
*
|
||
* @param positionColonne - Position de la colonne choisie
|
||
* @param couleur - Couleur du pion pose
|
||
*/
|
||
/**
|
||
* Ajoute un pion dans la colonne choisie en donnant la couleur dudit pion
|
||
*/
|
||
public void ajoutPion(int positionColonne, String couleur){
|
||
Jeton nouveauPion = new Jeton(couleur);
|
||
int positionJeton = positions[positionColonne];
|
||
|
||
grille[positionColonne][positionJeton] = nouveauPion;
|
||
positions[positionColonne] ++;
|
||
}
|
||
|
||
/**
|
||
*
|
||
* @param colonneChoisie - Colonne que l'utilisateur a choisi
|
||
* @param positionPion - Position du pion dans ladite colonne
|
||
* @return Avons nous un gagnant ? Oui ou non ?
|
||
*/
|
||
/**
|
||
* Determine si le pion pose donne un jeu gagnant au joueur qui l'a pose ou pas
|
||
*/
|
||
public boolean gagnant(int colonneChoisie, int positionPion){
|
||
|
||
// Entier qui permet de definir le nombre de puissance 4 effectues
|
||
int puissance4 = 1;
|
||
|
||
puissance4 = estAligne(2,0,colonneChoisie,positionPion) + estAligne(1,0,colonneChoisie,positionPion) + 1;
|
||
if( puissance4 < 4){
|
||
//System.out.println(puissance4);
|
||
puissance4 = estAligne(0,2,colonneChoisie,positionPion) + estAligne(0,1,colonneChoisie,positionPion) + 1;
|
||
if(puissance4 < 4){
|
||
//System.out.println(puissance4);
|
||
puissance4 = estAligne(2,2,colonneChoisie,positionPion) + estAligne(1,1,colonneChoisie,positionPion) + 1;
|
||
if(puissance4 < 4){
|
||
//System.out.println(puissance4);
|
||
puissance4 = estAligne(1,2,colonneChoisie,positionPion) + estAligne(2,1,colonneChoisie,positionPion) + 1;
|
||
if(puissance4 < 4){
|
||
//System.out.println(puissance4);
|
||
return false;
|
||
}
|
||
else return true;
|
||
}
|
||
else return true;
|
||
}
|
||
else return true;
|
||
}
|
||
else return true;
|
||
}
|
||
|
||
/**
|
||
*
|
||
* @param X - Valeur 0,1 ou 2. Avec 1 nous incrementons, avec 2 l'inverse, et avec 0 nous ne faisons rien
|
||
* @param Y - Idem que X
|
||
* @param colonneChoisie - Colonne de laquelle nous partons
|
||
* @param positionPion - position du pion de lequel nous partons
|
||
* @return Avons nous une ligne de puissance 4 ? Combien de pions alors ?
|
||
*/
|
||
/**
|
||
* Renvoie le nombre de pions de meme couleur alignes
|
||
*/
|
||
public int estAligne(int X, int Y, int colonneChoisie, int positionPion){
|
||
int puissance4 = 0;
|
||
boolean ok = true;
|
||
int colonneTestee = colonneChoisie, ligneTestee = positionPion;
|
||
|
||
// Verification à l'écran que nous nous trouvons au bon endroit
|
||
//System.out.println("X: " + X + " Y: " + Y + " Colonne choisie: " + colonneChoisie + " Position choisie: " + positionPion);
|
||
|
||
if(Y == 1){
|
||
colonneTestee++;
|
||
}
|
||
else if(Y == 2){
|
||
colonneTestee--;
|
||
}
|
||
else{
|
||
// Rien
|
||
}
|
||
if(X == 1){
|
||
ligneTestee++;
|
||
}
|
||
else if(X == 2){
|
||
ligneTestee--;
|
||
}
|
||
else{
|
||
// Rien
|
||
}
|
||
|
||
if(colonneTestee < 0 || colonneTestee > nbreColonnes - 1){
|
||
ok = false;
|
||
}
|
||
if(ligneTestee < 0 || ligneTestee > nbreLignes - 1){
|
||
ok = false;
|
||
}
|
||
|
||
//System.out.println("Debut des tests : " + ligneTestee);
|
||
while(ok == true && grille[colonneTestee][ligneTestee].getCouleur().equals(grille[colonneChoisie][positionPion].getCouleur())){
|
||
puissance4++;
|
||
if(Y == 1){
|
||
colonneTestee++;
|
||
}
|
||
else if(Y == 2){
|
||
colonneTestee--;
|
||
}
|
||
else{
|
||
// Rien
|
||
}
|
||
if(X == 1){
|
||
ligneTestee++;
|
||
}
|
||
else if(X == 2){
|
||
ligneTestee--;
|
||
}
|
||
else{
|
||
// Rien
|
||
}
|
||
//System.out.println("Colonne : " + colonneTestee + ". Ligne : " + ligneTestee);
|
||
if(colonneTestee < 0 || colonneTestee > nbreColonnes - 1){
|
||
ok = false;
|
||
}
|
||
if(ligneTestee < 0 || ligneTestee > nbreLignes - 1){
|
||
ok = false;
|
||
}
|
||
}
|
||
|
||
return puissance4;
|
||
}
|
||
|
||
/**
|
||
*
|
||
* @param colonne - Colonne choisise
|
||
* @return Position du pion dans la colonne
|
||
*/
|
||
/**
|
||
* Permet de recuperer la position du pion dans une colonne donnee
|
||
*/
|
||
public int getPosition(int colonne)
|
||
{
|
||
return positions[colonne];
|
||
}
|
||
|
||
/**
|
||
*
|
||
* @return Collection de joueurs
|
||
*/
|
||
/**
|
||
* On recupere une collection de joueurs sous forme de Vecteurs
|
||
*/
|
||
public Vector getJoueurs(){
|
||
return CollectionJoueurs;
|
||
}
|
||
|
||
/**
|
||
* Affirme que nous changeons de joueurs (ce qui n'inclue pas le fait que nous ayons a le recuperer !)
|
||
*
|
||
*/
|
||
public void setAlternanceJoueur(){
|
||
alternanceJoueur = !alternanceJoueur;
|
||
}
|
||
}
|