Jeu jouable avec fin de parti
This commit is contained in:
File diff suppressed because it is too large
Load Diff
@@ -4,126 +4,77 @@ import fr.iut_fbleau.GameAPI.AbstractPly;
|
||||
import fr.iut_fbleau.GameAPI.Player;
|
||||
|
||||
/**
|
||||
* Représente un coup dans le jeu Avalam.
|
||||
* Un coup consiste à déplacer une tour de la position (xFrom, yFrom)
|
||||
* vers la position (xTo, yTo).
|
||||
*
|
||||
* @author AMARY Aurelien, DICK Adrien, FELIX-VIMALARATNAM Patrick, RABAN Hugo
|
||||
* @version 1.0
|
||||
* Représente un coup (ply) dans le jeu Avalam.
|
||||
*
|
||||
* Un coup est défini par :
|
||||
* <ul>
|
||||
* <li>un joueur (PLAYER1 ou PLAYER2)</li>
|
||||
* <li>une position source (xFrom, yFrom)</li>
|
||||
* <li>une position destination (xTo, yTo)</li>
|
||||
* </ul>
|
||||
*
|
||||
* Ces coordonnées seront utilisées par <code>AvalamBoard</code> pour :
|
||||
* <ul>
|
||||
* <li>vérifier la légalité du coup</li>
|
||||
* <li>fusionner les tours concernées</li>
|
||||
* <li>mettre à jour la grille</li>
|
||||
* </ul>
|
||||
*
|
||||
* Cette classe ne contient aucune logique de vérification : tout est délégué
|
||||
* à <code>AvalamBoard.isLegal()</code> et <code>AvalamBoard.doPly()</code>.
|
||||
*/
|
||||
public class AvalamPly extends AbstractPly {
|
||||
/** Coordonnée X de la case source */
|
||||
private int xFrom;
|
||||
/** Coordonnée Y de la case source */
|
||||
private int yFrom;
|
||||
/** Coordonnée X de la case destination */
|
||||
private int xTo;
|
||||
/** Coordonnée Y de la case destination */
|
||||
private int yTo;
|
||||
/** Hauteur de la tour source (utilisée pour l'annulation de coup) */
|
||||
private int sourceHeight;
|
||||
|
||||
/** Coordonnées source */
|
||||
private final int xFrom;
|
||||
private final int yFrom;
|
||||
|
||||
/** Coordonnées destination */
|
||||
private final int xTo;
|
||||
private final int yTo;
|
||||
|
||||
/**
|
||||
* Constructeur par défaut d'un coup Avalam.
|
||||
* La hauteur de la source sera définie automatiquement lors de l'application du coup.
|
||||
*
|
||||
* @param joueur Le joueur qui effectue le coup
|
||||
* @param xFrom Coordonnée X de la case source
|
||||
* @param yFrom Coordonnée Y de la case source
|
||||
* @param xTo Coordonnée X de la case destination
|
||||
* @param yTo Coordonnée Y de la case destination
|
||||
* Constructeur principal.
|
||||
*
|
||||
* @param player joueur qui joue le coup
|
||||
* @param xFrom ligne d'origine
|
||||
* @param yFrom colonne d'origine
|
||||
* @param xTo ligne de destination
|
||||
* @param yTo colonne de destination
|
||||
*/
|
||||
public AvalamPly(Player joueur, int xFrom, int yFrom, int xTo, int yTo) {
|
||||
super(joueur);
|
||||
public AvalamPly(Player player, int xFrom, int yFrom, int xTo, int yTo) {
|
||||
super(player);
|
||||
this.xFrom = xFrom;
|
||||
this.yFrom = yFrom;
|
||||
this.xTo = xTo;
|
||||
this.yTo = yTo;
|
||||
this.sourceHeight = -1; // Sera défini lors du doPly
|
||||
}
|
||||
|
||||
/**
|
||||
* Constructeur avec hauteur de la source spécifiée.
|
||||
* Utilisé principalement pour l'annulation de coups.
|
||||
*
|
||||
* @param joueur Le joueur qui effectue le coup
|
||||
* @param xFrom Coordonnée X de la case source
|
||||
* @param yFrom Coordonnée Y de la case source
|
||||
* @param xTo Coordonnée X de la case destination
|
||||
* @param yTo Coordonnée Y de la case destination
|
||||
* @param sourceHeight Hauteur de la tour source avant le déplacement
|
||||
*/
|
||||
public AvalamPly(Player joueur, int xFrom, int yFrom, int xTo, int yTo, int sourceHeight) {
|
||||
super(joueur);
|
||||
this.xFrom = xFrom;
|
||||
this.yFrom = yFrom;
|
||||
this.xTo = xTo;
|
||||
this.yTo = yTo;
|
||||
this.sourceHeight = sourceHeight;
|
||||
}
|
||||
|
||||
/**
|
||||
* Retourne la coordonnée X de la case source.
|
||||
*
|
||||
* @return La coordonnée X de la case source
|
||||
*/
|
||||
/** Ligne d'origine */
|
||||
public int getXFrom() {
|
||||
return xFrom;
|
||||
}
|
||||
|
||||
/**
|
||||
* Retourne la coordonnée Y de la case source.
|
||||
*
|
||||
* @return La coordonnée Y de la case source
|
||||
*/
|
||||
/** Colonne d'origine */
|
||||
public int getYFrom() {
|
||||
return yFrom;
|
||||
}
|
||||
|
||||
/**
|
||||
* Retourne la coordonnée X de la case destination.
|
||||
*
|
||||
* @return La coordonnée X de la case destination
|
||||
*/
|
||||
/** Ligne de destination */
|
||||
public int getXTo() {
|
||||
return xTo;
|
||||
}
|
||||
|
||||
/**
|
||||
* Retourne la coordonnée Y de la case destination.
|
||||
*
|
||||
* @return La coordonnée Y de la case destination
|
||||
*/
|
||||
/** Colonne de destination */
|
||||
public int getYTo() {
|
||||
return yTo;
|
||||
}
|
||||
|
||||
/**
|
||||
* Retourne la hauteur de la tour source.
|
||||
*
|
||||
* @return La hauteur de la tour source, ou -1 si non définie
|
||||
*/
|
||||
public int getSourceHeight() {
|
||||
return sourceHeight;
|
||||
}
|
||||
|
||||
/**
|
||||
* Définit la hauteur de la tour source.
|
||||
* Cette méthode est appelée automatiquement lors de l'application du coup.
|
||||
*
|
||||
* @param height La hauteur de la tour source
|
||||
*/
|
||||
public void setSourceHeight(int height) {
|
||||
this.sourceHeight = height;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return "AvalamPly{" +
|
||||
"joueur=" + getPlayer() +
|
||||
", from=(" + xFrom + "," + yFrom + ")" +
|
||||
", to=(" + xTo + "," + yTo + ")" +
|
||||
"player=" + getPlayer() +
|
||||
", (" + xFrom + "," + yFrom + ") -> (" + xTo + "," + yTo + ")" +
|
||||
'}';
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,42 +1,139 @@
|
||||
package fr.iut_fbleau.Avalam;
|
||||
|
||||
import fr.iut_fbleau.Avalam.logic.*;
|
||||
import fr.iut_fbleau.Avalam.ui.*;
|
||||
import fr.iut_fbleau.Avalam.logic.BoardLoader;
|
||||
import fr.iut_fbleau.Avalam.ui.BoardView;
|
||||
import fr.iut_fbleau.Avalam.ui.ScoreView;
|
||||
import fr.iut_fbleau.Avalam.ui.TurnView;
|
||||
import fr.iut_fbleau.GameAPI.Player;
|
||||
import fr.iut_fbleau.GameAPI.Result;
|
||||
|
||||
import javax.swing.*;
|
||||
import java.awt.*;
|
||||
|
||||
/**
|
||||
* Fenêtre principale du jeu Avalam.
|
||||
*
|
||||
* Elle contient :
|
||||
* - le plateau (BoardView)
|
||||
* - l'affichage du score
|
||||
* - l'affichage du joueur courant
|
||||
*
|
||||
* Elle interagit directement avec AvalamBoard (moteur du jeu).
|
||||
*/
|
||||
public class AvalamWindow extends JFrame {
|
||||
|
||||
/** Moteur du jeu (API GameAPI) */
|
||||
private AvalamBoard board;
|
||||
|
||||
/** Vues graphiques */
|
||||
private ScoreView scoreView;
|
||||
private TurnView turnView;
|
||||
private BoardView boardView;
|
||||
|
||||
public AvalamWindow() {
|
||||
super("Avalam - Plateau Graphique");
|
||||
super("Avalam");
|
||||
|
||||
setSize(750, 800);
|
||||
setLocationRelativeTo(null);
|
||||
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
|
||||
setLayout(new BorderLayout());
|
||||
|
||||
Tower[][] grid = BoardLoader.loadFromFile("fr/iut_fbleau/Res/Plateau.txt");
|
||||
GameState gs = new GameState(grid);
|
||||
ScoreManager sm = new ScoreManager();
|
||||
// ----------------------------------------------------------
|
||||
// Chargement du plateau initial depuis Plateau.txt
|
||||
// ----------------------------------------------------------
|
||||
Tower[][] initialGrid = BoardLoader.loadFromFile("fr/iut_fbleau/Res/Plateau.txt");
|
||||
board = new AvalamBoard(initialGrid); // PLAYER1 commence
|
||||
|
||||
int y = sm.count(Color.COLOR1, grid);
|
||||
int r = sm.count(Color.COLOR2, grid);
|
||||
// ----------------------------------------------------------
|
||||
// PANNEAU SCORE + TOUR
|
||||
// ----------------------------------------------------------
|
||||
JPanel topPanel = new JPanel(new GridLayout(2, 1));
|
||||
topPanel.setBackground(new java.awt.Color(200, 200, 200));
|
||||
|
||||
ScoreView scoreView = new ScoreView(y, r);
|
||||
TurnView turnView = new TurnView("Tour du joueur : Jaune");
|
||||
scoreView = new ScoreView(
|
||||
computeScore(Color.YELLOW),
|
||||
computeScore(Color.RED)
|
||||
);
|
||||
|
||||
BoardView boardView = new BoardView(gs);
|
||||
turnView = new TurnView(turnMessage());
|
||||
|
||||
JPanel top = new JPanel(new GridLayout(2,1));
|
||||
top.add(scoreView);
|
||||
top.add(turnView);
|
||||
topPanel.add(scoreView);
|
||||
topPanel.add(turnView);
|
||||
|
||||
add(topPanel, BorderLayout.NORTH);
|
||||
|
||||
// ----------------------------------------------------------
|
||||
// PLATEAU (BoardView)
|
||||
// ----------------------------------------------------------
|
||||
boardView = new BoardView(board, this::onBoardUpdated);
|
||||
|
||||
add(top, BorderLayout.NORTH);
|
||||
add(boardView, BorderLayout.CENTER);
|
||||
|
||||
pack();
|
||||
setResizable(false);
|
||||
setLocationRelativeTo(null);
|
||||
setVisible(true);
|
||||
}
|
||||
|
||||
/* ================================================================
|
||||
* MISES À JOUR D’APRÈS LE MOTEUR
|
||||
* ================================================================ */
|
||||
|
||||
/**
|
||||
* Appelé automatiquement après chaque coup via BoardView → controller → board.
|
||||
*/
|
||||
public void onBoardUpdated() {
|
||||
|
||||
// Mise à jour du score et du joueur courant
|
||||
scoreView.updateScores(
|
||||
computeScore(Color.YELLOW),
|
||||
computeScore(Color.RED)
|
||||
);
|
||||
|
||||
turnView.setTurn(turnMessage());
|
||||
|
||||
// Détection de fin de partie
|
||||
if (board.isGameOver()) {
|
||||
Result res = board.getResult();
|
||||
|
||||
String msg;
|
||||
|
||||
switch (res) {
|
||||
case WIN -> msg = "Le joueur jaune a gagné !";
|
||||
case LOSS -> msg = "Le joueur rouge a gagné !";
|
||||
case DRAW -> msg = "Égalité !";
|
||||
default -> msg = "Fin de partie.";
|
||||
}
|
||||
|
||||
JOptionPane.showMessageDialog(this, msg, "Partie terminée",
|
||||
JOptionPane.INFORMATION_MESSAGE);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* ================================================================
|
||||
* OUTILS
|
||||
* ================================================================ */
|
||||
|
||||
/**
|
||||
* Calcule le score d'une couleur : nombre de tours contrôlées.
|
||||
*/
|
||||
private int computeScore(Color c) {
|
||||
int score = 0;
|
||||
for (int r = 0; r < AvalamBoard.SIZE; r++) {
|
||||
for (int col = 0; col < AvalamBoard.SIZE; col++) {
|
||||
Tower t = board.getTowerAt(r, col);
|
||||
if (t != null && t.getColor() == c) {
|
||||
score++;
|
||||
}
|
||||
}
|
||||
}
|
||||
return score;
|
||||
}
|
||||
|
||||
/**
|
||||
* Message du joueur dont c'est le tour.
|
||||
*/
|
||||
private String turnMessage() {
|
||||
return "Tour du joueur : " +
|
||||
(board.getCurrentPlayer() == Player.PLAYER1 ? "Jaune" : "Rouge");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,28 +1,23 @@
|
||||
package fr.iut_fbleau.Avalam;
|
||||
|
||||
/**
|
||||
* L'énumération <code>Color</code> représente la couleur du sommet d'une tour Avalam.
|
||||
*
|
||||
* COLOR1 : couleur du Joueur Jaune
|
||||
* COLOR2 : couleur du Joueur Rouge
|
||||
*
|
||||
* Les couleurs Swing associées peuvent être modifiées ici pour changer tout le jeu.
|
||||
*
|
||||
* @version 3.0
|
||||
*/
|
||||
public enum Color {
|
||||
|
||||
COLOR1(java.awt.Color.YELLOW), // Joueur Jaune
|
||||
COLOR2(java.awt.Color.RED); // Joueur Rouge
|
||||
YELLOW(255, 220, 0),
|
||||
RED(200, 40, 40);
|
||||
|
||||
/** Couleur Swing associée */
|
||||
private final java.awt.Color swingColor;
|
||||
|
||||
Color(java.awt.Color col) {
|
||||
this.swingColor = col;
|
||||
Color(int r, int g, int b) {
|
||||
this.swingColor = new java.awt.Color(r, g, b);
|
||||
}
|
||||
|
||||
public java.awt.Color getSwingColor() {
|
||||
return this.swingColor;
|
||||
return swingColor;
|
||||
}
|
||||
|
||||
public fr.iut_fbleau.GameAPI.Player toPlayer() {
|
||||
return (this == YELLOW ?
|
||||
fr.iut_fbleau.GameAPI.Player.PLAYER1 :
|
||||
fr.iut_fbleau.GameAPI.Player.PLAYER2);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,41 +1,50 @@
|
||||
package fr.iut_fbleau.Avalam ;
|
||||
package fr.iut_fbleau.Avalam;
|
||||
|
||||
/**
|
||||
* La classe <code>Tower</code> stocke la couleur de son pion haut et la hauteur de la tour.
|
||||
*
|
||||
* @version 1.0
|
||||
* @author Aurélien
|
||||
*/
|
||||
* Représente une tour dans le jeu Avalam.
|
||||
*
|
||||
* Une tour possède :
|
||||
* - la couleur de son sommet
|
||||
* - sa hauteur (nombre de pions)
|
||||
*/
|
||||
public class Tower {
|
||||
//Attributs
|
||||
private Color color ;
|
||||
private byte height = 1 ;
|
||||
|
||||
//Constructeur
|
||||
public Tower(Color color) {
|
||||
this.color = color ;
|
||||
}
|
||||
private Color color;
|
||||
private int height;
|
||||
|
||||
//Méthodes
|
||||
public Color getColor() {
|
||||
return this.color ;
|
||||
}
|
||||
/** Nouvelle tour de hauteur 1 */
|
||||
public Tower(Color color) {
|
||||
this.color = color;
|
||||
this.height = 1;
|
||||
}
|
||||
|
||||
public byte getHeight() {
|
||||
return this.height ;
|
||||
}
|
||||
/** Tour avec couleur et hauteur existantes */
|
||||
public Tower(Color color, int height) {
|
||||
this.color = color;
|
||||
this.height = height;
|
||||
}
|
||||
|
||||
/**
|
||||
* Méthode qui empile une autre tour sur l'objet sur lequel le méthode est appelée.
|
||||
* Aucune vérification de hauteur n'est effectuée.
|
||||
*/
|
||||
public void mergeTower(Tower tower) {
|
||||
this.color = tower.getColor();
|
||||
this.height += tower.getHeight();
|
||||
}
|
||||
public Color getColor() {
|
||||
return color;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return "" ;
|
||||
}
|
||||
public int getHeight() {
|
||||
return height;
|
||||
}
|
||||
|
||||
/**
|
||||
* Fusionne this (destination) avec src (source).
|
||||
* La source monte sur la destination →
|
||||
* - la couleur du sommet devient celle de src
|
||||
* - la hauteur s’additionne
|
||||
*/
|
||||
public void mergeTower(Tower src) {
|
||||
this.color = src.color;
|
||||
this.height = this.height + src.height;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return color + "(" + height + ")";
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2,51 +2,35 @@ package fr.iut_fbleau.Avalam.logic;
|
||||
|
||||
import fr.iut_fbleau.Avalam.Color;
|
||||
import fr.iut_fbleau.Avalam.Tower;
|
||||
|
||||
import java.io.*;
|
||||
|
||||
/**
|
||||
* La classe <code>BoardLoader</code> est responsable du chargement d'un plateau Avalam
|
||||
* depuis un fichier texte externe (généralement Plateau.txt).
|
||||
*
|
||||
* Le fichier doit contenir une matrice 9×9 de valeurs numériques séparées par des virgules :
|
||||
* - 0 : case vide (trou)
|
||||
* - 1 : pion appartenant au joueur COLOR1 (Jaune)
|
||||
* - 2 : pion appartenant au joueur COLOR2 (Rouge)
|
||||
*
|
||||
* Aucun contrôle de cohérence avancé n'est effectué, le chargeur se contente
|
||||
* d’interpréter les valeurs comme demandé.
|
||||
*
|
||||
* @author
|
||||
* @version 1.0
|
||||
* Charge un plateau Avalam depuis un fichier texte.
|
||||
* Format attendu : matrice 9×9 de 0,1,2 séparés par virgule.
|
||||
*/
|
||||
public class BoardLoader {
|
||||
|
||||
/**
|
||||
* Charge un plateau Avalam depuis un fichier.
|
||||
*
|
||||
* @param path chemin du fichier plateau.
|
||||
* @return un tableau 9×9 contenant des objets <code>Tower</code> ou <code>null</code>.
|
||||
*/
|
||||
public static Tower[][] loadFromFile(String path) {
|
||||
|
||||
public static Tower[][] loadFromFile(String file) {
|
||||
Tower[][] grid = new Tower[9][9];
|
||||
|
||||
try (BufferedReader br = new BufferedReader(new FileReader(new File(path)))) {
|
||||
try (BufferedReader br = new BufferedReader(new FileReader(file))) {
|
||||
|
||||
String line;
|
||||
int row = 0;
|
||||
|
||||
while ((line = br.readLine()) != null && row < 9) {
|
||||
|
||||
String[] parts = line.split(",");
|
||||
String[] vals = line.split(",");
|
||||
|
||||
for (int col = 0; col < 9; col++) {
|
||||
int v = Integer.parseInt(parts[col]);
|
||||
int v = Integer.parseInt(vals[col].trim());
|
||||
|
||||
// Interprétation des valeurs
|
||||
if (v == 1) grid[row][col] = new Tower(Color.COLOR1);
|
||||
else if (v == 2) grid[row][col] = new Tower(Color.COLOR2);
|
||||
else grid[row][col] = null; // Case vide
|
||||
switch (v) {
|
||||
case 1 -> grid[row][col] = new Tower(Color.YELLOW);
|
||||
case 2 -> grid[row][col] = new Tower(Color.RED);
|
||||
default -> grid[row][col] = null;
|
||||
}
|
||||
}
|
||||
row++;
|
||||
}
|
||||
|
||||
@@ -1,70 +0,0 @@
|
||||
package fr.iut_fbleau.Avalam.logic;
|
||||
|
||||
import fr.iut_fbleau.Avalam.Color;
|
||||
import fr.iut_fbleau.Avalam.Tower;
|
||||
|
||||
/**
|
||||
* La classe <code>GameState</code> représente l'état courant du jeu Avalam :
|
||||
* - la grille 9×9
|
||||
* - le joueur dont c'est le tour
|
||||
*
|
||||
* Elle ne contient aucune logique de déplacement ni de vérification des règles ;
|
||||
* son rôle est uniquement de stocker et de fournir l'état du jeu.
|
||||
*
|
||||
* @author
|
||||
* @version 1.0
|
||||
*/
|
||||
public class GameState {
|
||||
|
||||
/** Grille du plateau : 9×9 tours ou cases vides. */
|
||||
private Tower[][] grid;
|
||||
|
||||
/** Joueur dont c’est le tour (COLOR1 ou COLOR2). */
|
||||
private Color currentPlayer = Color.COLOR1;
|
||||
|
||||
/**
|
||||
* Constructeur.
|
||||
*
|
||||
* @param grid la grille initiale du plateau.
|
||||
*/
|
||||
public GameState(Tower[][] grid) {
|
||||
this.grid = grid;
|
||||
}
|
||||
|
||||
/**
|
||||
* Retourne la tour présente à la position (r,c), ou null.
|
||||
*/
|
||||
public Tower get(int r, int c) {
|
||||
return grid[r][c];
|
||||
}
|
||||
|
||||
/**
|
||||
* Retourne la grille complète.
|
||||
*/
|
||||
public Tower[][] getGrid() {
|
||||
return grid;
|
||||
}
|
||||
|
||||
/**
|
||||
* Retourne le joueur dont c'est le tour.
|
||||
*/
|
||||
public Color getCurrentPlayer() {
|
||||
return currentPlayer;
|
||||
}
|
||||
|
||||
/**
|
||||
* Change le joueur courant : COLOR1 → COLOR2 → COLOR1.
|
||||
*/
|
||||
public void switchPlayer() {
|
||||
currentPlayer = (currentPlayer == Color.COLOR1) ? Color.COLOR2 : Color.COLOR1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Vérifie si une position (r,c) est dans les limites du plateau.
|
||||
*
|
||||
* @return vrai si la position est comprise dans un plateau 9×9.
|
||||
*/
|
||||
public boolean isInside(int r, int c) {
|
||||
return r >= 0 && r < 9 && c >= 0 && c < 9;
|
||||
}
|
||||
}
|
||||
@@ -1,37 +0,0 @@
|
||||
package fr.iut_fbleau.Avalam.logic;
|
||||
|
||||
import fr.iut_fbleau.Avalam.Color;
|
||||
import fr.iut_fbleau.Avalam.Tower;
|
||||
|
||||
/**
|
||||
* La classe <code>ScoreManager</code> gère le calcul des scores
|
||||
* selon les règles officielles d’Avalam :
|
||||
*
|
||||
* Un joueur gagne 1 point par tour dont le sommet (couleur) lui appartient,
|
||||
* indépendamment de la hauteur de la tour.
|
||||
*
|
||||
* Cette classe n’a aucune responsabilité autre que compter.
|
||||
*
|
||||
* @author
|
||||
* @version 1.0
|
||||
*/
|
||||
public class ScoreManager {
|
||||
|
||||
/**
|
||||
* Compte le nombre de tours dont le sommet appartient à la couleur donnée.
|
||||
*
|
||||
* @param c couleur du joueur (COLOR1 ou COLOR2)
|
||||
* @param grid grille 9×9 contenant des tours ou null
|
||||
* @return score du joueur
|
||||
*/
|
||||
public static int count(Color c, Tower[][] grid) {
|
||||
int score = 0;
|
||||
|
||||
for (int i = 0; i < 9; i++)
|
||||
for (int j = 0; j < 9; j++)
|
||||
if (grid[i][j] != null && grid[i][j].getColor() == c)
|
||||
score++;
|
||||
|
||||
return score;
|
||||
}
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
package fr.iut_fbleau.Avalam.logic;
|
||||
|
||||
import fr.iut_fbleau.Avalam.Color;
|
||||
|
||||
/**
|
||||
* La classe <code>TurnManager</code> gère le déroulement des tours d’Avalam.
|
||||
*
|
||||
* Son rôle est simple :
|
||||
* - identifier le joueur dont c’est le tour
|
||||
* - passer au joueur suivant
|
||||
*
|
||||
* Elle ne contient pas de logique de mouvement, ni de validation.
|
||||
*
|
||||
* @author
|
||||
* @version 1.0
|
||||
*/
|
||||
public class TurnManager {
|
||||
|
||||
/** Joueur dont c'est le tour (COLOR1 commence la partie). */
|
||||
private Color current = Color.COLOR1;
|
||||
|
||||
/**
|
||||
* Retourne le joueur actuel.
|
||||
*/
|
||||
public Color getPlayer() {
|
||||
return current;
|
||||
}
|
||||
|
||||
/**
|
||||
* Passe au joueur suivant.
|
||||
*/
|
||||
public void next() {
|
||||
current = (current == Color.COLOR1) ? Color.COLOR2 : Color.COLOR1;
|
||||
}
|
||||
}
|
||||
@@ -1,84 +1,118 @@
|
||||
package fr.iut_fbleau.Avalam.ui;
|
||||
|
||||
import fr.iut_fbleau.Avalam.logic.GameState;
|
||||
import fr.iut_fbleau.Avalam.AvalamBoard;
|
||||
import fr.iut_fbleau.Avalam.Tower;
|
||||
|
||||
import javax.swing.*;
|
||||
import java.awt.*;
|
||||
|
||||
/**
|
||||
* La classe <code>BoardView</code> représente l'affichage complet du plateau Avalam.
|
||||
* Elle s’appuie sur une architecture en couches (layered pane) pour séparer proprement :
|
||||
* BoardView est la vue principale du plateau Avalam.
|
||||
*
|
||||
* <ul>
|
||||
* <li><b>HighlightLayer</b> : les cases jouables mises en surbrillance</li>
|
||||
* <li><b>PieceLayer</b> : les pions affichés sous forme de boutons ronds</li>
|
||||
* </ul>
|
||||
* Elle gère :
|
||||
* - l’affichage des tours (PieceLayer)
|
||||
* - l’affichage des coups possibles (HighlightLayer)
|
||||
* - les clics via InteractionController
|
||||
*
|
||||
* La vue ne contient pas la logique de jeu : elle la délègue entièrement
|
||||
* à un <code>InteractionController</code>.
|
||||
*
|
||||
* @author
|
||||
* @version 1.0
|
||||
* Toute la logique de jeu est déléguée au moteur AvalamBoard
|
||||
* et au contrôleur InteractionController.
|
||||
*/
|
||||
public class BoardView extends JLayeredPane {
|
||||
|
||||
/** Taille des pions affichés. */
|
||||
private final int size = 50;
|
||||
/** Référence au moteur Avalam */
|
||||
private AvalamBoard board;
|
||||
|
||||
/** Distance entre deux cases de la grille. */
|
||||
private final int spacing = 70;
|
||||
|
||||
/** Décalages pour centrer l'affichage. */
|
||||
private final int xBase = 60, yBase = 60;
|
||||
|
||||
/** Accès à l'état du jeu. */
|
||||
private GameState state;
|
||||
|
||||
/** Couche d'affichage des ronds verts. */
|
||||
/** Couche d’affichage des rond verts */
|
||||
private HighlightLayer highlightLayer;
|
||||
|
||||
/** Couche d'affichage des pions. */
|
||||
/** Couche d’affichage des tours */
|
||||
private PieceLayer pieceLayer;
|
||||
|
||||
/** Gestionnaire d'interactions utilisateur. */
|
||||
/** Contrôleur des interactions */
|
||||
private InteractionController controller;
|
||||
|
||||
/** Décalages et dimensions pour l'affichage */
|
||||
private final int size = 50;
|
||||
private final int spacing = 70;
|
||||
private final int xBase = 60;
|
||||
private final int yBase = 60;
|
||||
|
||||
/** Callback vers AvalamWindow pour mises à jour (score, tour, fin de partie) */
|
||||
private Runnable boardUpdateCallback;
|
||||
|
||||
/**
|
||||
* Constructeur de la vue du plateau.
|
||||
*
|
||||
* @param state l'état du jeu Avalam
|
||||
* @param board moteur Avalam utilisé pour afficher la grille
|
||||
* @param boardUpdateCallback callback appelé après chaque coup
|
||||
*/
|
||||
public BoardView(GameState state) {
|
||||
this.state = state;
|
||||
public BoardView(AvalamBoard board, Runnable boardUpdateCallback) {
|
||||
this.board = board;
|
||||
this.boardUpdateCallback = boardUpdateCallback;
|
||||
|
||||
setLayout(null);
|
||||
|
||||
controller = new InteractionController(state);
|
||||
// Contrôleur
|
||||
this.controller = new InteractionController(board, this);
|
||||
|
||||
// Couche Highlight
|
||||
highlightLayer = new HighlightLayer(xBase, yBase, spacing, size);
|
||||
pieceLayer = new PieceLayer();
|
||||
|
||||
add(highlightLayer, JLayeredPane.DEFAULT_LAYER);
|
||||
|
||||
// Couche des pièces
|
||||
pieceLayer = new PieceLayer();
|
||||
add(pieceLayer, JLayeredPane.PALETTE_LAYER);
|
||||
|
||||
setPreferredSize(new Dimension(800, 800));
|
||||
|
||||
refresh();
|
||||
}
|
||||
|
||||
/**
|
||||
* Met à jour l'affichage des couches en fonction de l'état actuel du jeu.
|
||||
* Appelée par InteractionController quand un coup est joué.
|
||||
* Permet à AvalamWindow de rafraîchir :
|
||||
* - scores
|
||||
* - affichage du joueur courant
|
||||
* - détection fin de partie
|
||||
*/
|
||||
public void onBoardUpdated() {
|
||||
if (boardUpdateCallback != null) {
|
||||
boardUpdateCallback.run();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Met à jour toutes les couches visuelles.
|
||||
*/
|
||||
public void refresh() {
|
||||
|
||||
// Mise à jour des pièces
|
||||
pieceLayer.displayGrid(
|
||||
state.getGrid(),
|
||||
xBase, yBase, spacing, size,
|
||||
|
||||
// Callback appelé lorsqu’un pion est cliqué
|
||||
(r, c) -> {
|
||||
controller.onPieceClicked(r, c);
|
||||
highlightLayer.setLegalMoves(controller.getLegalMoves());
|
||||
highlightLayer.repaint();
|
||||
}
|
||||
boardGrid(),
|
||||
xBase, yBase, spacing, size,
|
||||
(r, c) -> controller.onPieceClicked(r, c)
|
||||
);
|
||||
|
||||
// Mise à jour des highlights
|
||||
highlightLayer.setLegalMoves(controller.getLegalMoves());
|
||||
|
||||
highlightLayer.repaint();
|
||||
pieceLayer.repaint();
|
||||
repaint();
|
||||
}
|
||||
|
||||
/**
|
||||
* Renvoie la grille de tours depuis AvalamBoard.
|
||||
*/
|
||||
private Tower[][] boardGrid() {
|
||||
Tower[][] grid = new Tower[AvalamBoard.SIZE][AvalamBoard.SIZE];
|
||||
|
||||
for (int r = 0; r < AvalamBoard.SIZE; r++) {
|
||||
for (int c = 0; c < AvalamBoard.SIZE; c++) {
|
||||
grid[r][c] = board.getTowerAt(r, c);
|
||||
}
|
||||
}
|
||||
|
||||
return grid;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,116 +1,165 @@
|
||||
package fr.iut_fbleau.Avalam.ui;
|
||||
|
||||
import fr.iut_fbleau.Avalam.AvalamBoard;
|
||||
import fr.iut_fbleau.Avalam.AvalamPly;
|
||||
import fr.iut_fbleau.Avalam.Tower;
|
||||
import fr.iut_fbleau.Avalam.logic.GameState;
|
||||
|
||||
import java.awt.*;
|
||||
import fr.iut_fbleau.GameAPI.AbstractPly;
|
||||
import fr.iut_fbleau.GameAPI.Player;
|
||||
|
||||
import java.awt.Point;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* La classe <code>InteractionController</code> gère entièrement
|
||||
* la logique d'interaction de l'utilisateur :
|
||||
* Le contrôleur gère toute l'interaction entre l'utilisateur et le moteur Avalam.
|
||||
*
|
||||
* <ul>
|
||||
* <li>Sélection d'un pion</li>
|
||||
* <li>Annulation de la sélection</li>
|
||||
* <li>Calcul des cases de déplacement légales</li>
|
||||
* </ul>
|
||||
* Son rôle :
|
||||
* - gérer la sélection d’une tour
|
||||
* - générer les coups légaux via l’API (iterator)
|
||||
* - valider un déplacement (isLegal)
|
||||
* - appliquer un coup (doPly)
|
||||
* - mettre à jour le plateau (via refresh demandé au BoardView)
|
||||
*
|
||||
* Aucun affichage n'est réalisé ici ; la vue (BoardView) récupère
|
||||
* simplement les données calculées pour les afficher.
|
||||
*
|
||||
* @author
|
||||
* @version 1.0
|
||||
* IMPORTANT : ce contrôleur n’affiche rien. Il envoie les infos à BoardView.
|
||||
*/
|
||||
public class InteractionController {
|
||||
|
||||
private GameState state;
|
||||
private AvalamBoard board;
|
||||
|
||||
/** Position du pion sélectionné (ou -1 s'il n'y en a pas). */
|
||||
private int selectedRow = -1, selectedCol = -1;
|
||||
/** Position sélectionnée (-1 si aucune) */
|
||||
private int selectedRow = -1;
|
||||
private int selectedCol = -1;
|
||||
|
||||
/** Liste des déplacements possibles depuis la sélection. */
|
||||
/** Liste des coups légaux (en Point) autour de la sélection */
|
||||
private List<Point> legalMoves = new ArrayList<>();
|
||||
|
||||
/**
|
||||
* Constructeur.
|
||||
*
|
||||
* @param state état du jeu à manipuler
|
||||
*/
|
||||
public InteractionController(GameState state) {
|
||||
this.state = state;
|
||||
/** Référence à la vue pour la rafraîchir après déplacements */
|
||||
private BoardView view;
|
||||
|
||||
public InteractionController(AvalamBoard board, BoardView view) {
|
||||
this.board = board;
|
||||
this.view = view;
|
||||
}
|
||||
|
||||
/**
|
||||
* Retourne les cases jouables calculées.
|
||||
*/
|
||||
/** Retourne les cases jouables (pour HighlightLayer). */
|
||||
public List<Point> getLegalMoves() {
|
||||
return legalMoves;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gère le clic sur un pion donné.
|
||||
*
|
||||
* @param r ligne de la case cliquée
|
||||
* @param c colonne de la case cliquée
|
||||
* Appelé lorsqu’un pion est cliqué dans BoardView.
|
||||
* Gère :
|
||||
* - sélection d’une tour
|
||||
* - désélection
|
||||
* - tentative de déplacement (si clique sur un highlight)
|
||||
*/
|
||||
public void onPieceClicked(int r, int c) {
|
||||
|
||||
Tower t = state.get(r, c);
|
||||
if (t == null) return;
|
||||
|
||||
// Annulation si on reclique la sélection
|
||||
// Si on clique la même case ⇒ désélection
|
||||
if (r == selectedRow && c == selectedCol) {
|
||||
selectedRow = -1;
|
||||
selectedCol = -1;
|
||||
legalMoves.clear();
|
||||
clearSelection();
|
||||
view.refresh();
|
||||
return;
|
||||
}
|
||||
|
||||
// Interdiction de jouer le pion adverse
|
||||
if (t.getColor() != state.getCurrentPlayer()) {
|
||||
selectedRow = -1;
|
||||
selectedCol = -1;
|
||||
legalMoves.clear();
|
||||
// Si aucune sélection : on sélectionne un pion appartenant au joueur courant
|
||||
Tower t = board.getTowerAt(r, c);
|
||||
|
||||
if (t != null && t.getColor().toPlayer() == board.getCurrentPlayer()) {
|
||||
selectTower(r, c);
|
||||
view.refresh();
|
||||
return;
|
||||
}
|
||||
|
||||
// Sinon : tentons de jouer un coup (déplacement)
|
||||
if (selectedRow != -1 && selectedCol != -1) {
|
||||
tryMove(r, c);
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------------------------------------
|
||||
* SÉLECTION D’UNE TOUR
|
||||
* ---------------------------------------------------------------------- */
|
||||
|
||||
private void selectTower(int r, int c) {
|
||||
selectedRow = r;
|
||||
selectedCol = c;
|
||||
|
||||
computeLegalMoves();
|
||||
}
|
||||
|
||||
private void clearSelection() {
|
||||
selectedRow = -1;
|
||||
selectedCol = -1;
|
||||
legalMoves.clear();
|
||||
}
|
||||
|
||||
/**
|
||||
* Calcule toutes les cases accessibles à partir du pion sélectionné.
|
||||
* Identifie les destinations possibles depuis la tour sélectionnée.
|
||||
* Utilise l’API officielle : board.iterator()
|
||||
*/
|
||||
private void computeLegalMoves() {
|
||||
|
||||
legalMoves.clear();
|
||||
|
||||
Tower[][] grid = state.getGrid();
|
||||
Tower src = grid[selectedRow][selectedCol];
|
||||
int h = src.getHeight();
|
||||
Iterator<AbstractPly> it = board.iterator();
|
||||
|
||||
int[] d = {-1, 0, 1};
|
||||
while (it.hasNext()) {
|
||||
AbstractPly p = it.next();
|
||||
|
||||
for (int dr : d) {
|
||||
for (int dc : d) {
|
||||
if (!(p instanceof AvalamPly)) continue;
|
||||
AvalamPly ap = (AvalamPly) p;
|
||||
|
||||
if (dr == 0 && dc == 0) continue;
|
||||
|
||||
int nr = selectedRow + dr;
|
||||
int nc = selectedCol + dc;
|
||||
|
||||
if (!state.isInside(nr, nc)) continue;
|
||||
|
||||
Tower dest = grid[nr][nc];
|
||||
if (dest == null) continue;
|
||||
if (h + dest.getHeight() > 5) continue;
|
||||
|
||||
legalMoves.add(new Point(nr, nc));
|
||||
// On ne garde que les coups dont la source correspond à la sélection
|
||||
if (ap.getXFrom() == selectedRow && ap.getYFrom() == selectedCol) {
|
||||
legalMoves.add(new Point(ap.getXTo(), ap.getYTo()));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* -------------------------------------------------------------------------
|
||||
* TENTATIVE DE DÉPLACEMENT
|
||||
* ---------------------------------------------------------------------- */
|
||||
|
||||
/**
|
||||
* Tente d’exécuter un déplacement vers (r,c) si c’est un coup légal.
|
||||
*/
|
||||
private void tryMove(int r, int c) {
|
||||
// Vérifier si (r,c) est une destination légale
|
||||
boolean isLegalDest = false;
|
||||
for (Point p : legalMoves) {
|
||||
if (p.x == r && p.y == c) {
|
||||
isLegalDest = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!isLegalDest) {
|
||||
clearSelection(); // clic ailleurs = désélection
|
||||
view.refresh();
|
||||
return;
|
||||
}
|
||||
|
||||
// Construire le coup
|
||||
Player cur = board.getCurrentPlayer();
|
||||
AvalamPly ply = new AvalamPly(cur, selectedRow, selectedCol, r, c);
|
||||
|
||||
// Vérifier via l’API
|
||||
if (board.isLegal(ply)) {
|
||||
|
||||
// Appliquer via l’API
|
||||
board.doPly(ply);
|
||||
|
||||
// Réinitialiser la sélection
|
||||
clearSelection();
|
||||
|
||||
// Recalcul du score + joueur courant + fin de partie (handled in window)
|
||||
view.onBoardUpdated();
|
||||
|
||||
} else {
|
||||
// Coup impossible (rare, mais pour sécurité)
|
||||
clearSelection();
|
||||
}
|
||||
|
||||
view.refresh();
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user