776 lines
31 KiB
C#
776 lines
31 KiB
C#
/// ETML
|
|
/// Autheur : Théophile BORBOËN
|
|
/// Date : 30.10.2024
|
|
/// Description : Puissance 4 en programmation orientée objet en C#
|
|
namespace P4
|
|
{
|
|
|
|
// Création d'un enum pour les jetons
|
|
public enum Token
|
|
{
|
|
None,
|
|
FirstPlayer,
|
|
SecondPlayer,
|
|
}
|
|
|
|
/// <summary>
|
|
/// Classe programme c'est la classe qui est exécutée par le programme
|
|
/// </summary>
|
|
public class Program
|
|
{
|
|
// Déclaration des couleurs des joueurs
|
|
public readonly ConsoleColor FIRSTPLAYERCOLOR = ConsoleColor.Red;
|
|
public readonly ConsoleColor SECONDPLAYERCOLOR = ConsoleColor.Yellow;
|
|
|
|
// Déclaration des couleurs de la console
|
|
const ConsoleColor BACKGROUND_COLOR = ConsoleColor.Black;
|
|
const ConsoleColor FOREGROUND_COLOR = ConsoleColor.White;
|
|
|
|
/// <summary>
|
|
/// Méthode pour changer les couleurs de la console
|
|
/// </summary>
|
|
/// <param name="backgroundColor">couleur de fond</param>
|
|
/// <param name="foregroundColor">couleur du texte</param>
|
|
public void SetColor(ConsoleColor backgroundColor = BACKGROUND_COLOR, ConsoleColor foregroundColor = FOREGROUND_COLOR)
|
|
{
|
|
Console.ForegroundColor = foregroundColor;
|
|
Console.BackgroundColor = backgroundColor;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Méthode Main la méthode qui s'exécute au lancement du programme
|
|
/// </summary>
|
|
/// <param name="args">tableau des arguments données au programme</param>
|
|
static void Main(string[] args)
|
|
{
|
|
// on définit les couleurs par défaut de la console
|
|
new Program().SetColor();
|
|
|
|
// on vide la console
|
|
Console.Clear();
|
|
|
|
// on dessine le titre
|
|
new Draw().DrawTitle();
|
|
|
|
// on enlève le curseur
|
|
Console.CursorVisible = false;
|
|
|
|
// on récupère la taille du plateau
|
|
int[] boardSize = new Board().BoardSize();
|
|
|
|
// on crée un tableau de jetons
|
|
Token[,] board = new Token[boardSize[0], boardSize[1]];
|
|
|
|
// on lance le jeu
|
|
new Game().Start(board);
|
|
|
|
// on demande si les joueurs veulent rejouer
|
|
new Game().Replay(boardSize);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Classe Game qui contient toutes les méthodes pour jouer
|
|
/// </summary>
|
|
public class Game
|
|
{
|
|
// on crée des instances d'autres classes
|
|
private Draw _draw = new Draw();
|
|
private Program _program = new Program();
|
|
|
|
/// <summary>
|
|
/// Méthode pour demander si les joueurs veulent rejouer et pour relancer le jeu si c'est le cas
|
|
/// </summary>
|
|
public void Replay(int[] boardSize)
|
|
{
|
|
Console.SetCursorPosition(0, _draw.topSpacing + boardSize[0] * 2 + 4);
|
|
// on demande si l'utilisateur veut rejouer
|
|
Console.Write("Voulez-vous rejouer ? (o/n): ");
|
|
|
|
// on regarde quelle touche a été pressée
|
|
switch (Console.ReadKey().Key)
|
|
{
|
|
case ConsoleKey.O:
|
|
// si c'est oui on relance le jeu
|
|
new Program().SetColor();
|
|
Console.Clear();
|
|
new Draw().DrawTitle();
|
|
boardSize = new Board().BoardSize();
|
|
Token[,] board = new Token[boardSize[0], boardSize[1]];
|
|
new Game().Start(board);
|
|
new Game().Replay(boardSize);
|
|
break;
|
|
case ConsoleKey.N:
|
|
// si c'est non on quitte le programme
|
|
return;
|
|
default:
|
|
Console.SetCursorPosition(0, _draw.topSpacing + boardSize[0] * 2 + 5);
|
|
// sinon on demande de réessayer
|
|
Console.Write("Entrée invalide");
|
|
Replay(boardSize);
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Méthode pour lancer la boucle principale du jeu
|
|
/// </summary>
|
|
/// <param name="board">tableau de jetons en 2 dimensions</param>
|
|
public void Start(Token[,] board)
|
|
{
|
|
|
|
// initialisation des variables
|
|
int currentPosition = 0; // position actuelle
|
|
Token currentPlayer = Token.FirstPlayer; // joueur actuel
|
|
bool placed = false; // vérification s'il on peut placer un jeton
|
|
|
|
// on vide la console
|
|
Console.Clear();
|
|
|
|
// on efface le curseur au cas où la taille de la fenêtre aurait changé
|
|
Console.CursorVisible = false;
|
|
|
|
// on dessine le titre l'espace de jeu le plateau et l'aide
|
|
_draw.DrawTitle(_draw.leftSpacing);
|
|
_draw.DrawPlayGroundBorder(board);
|
|
_draw.DrawBorder(board);
|
|
_draw.DrawHelp(board);
|
|
|
|
// boucle principale du jeu
|
|
while (!CheckWin(board))
|
|
{
|
|
// on vérifie s'il y a égalité
|
|
if (CheckDraw(board))
|
|
break;
|
|
|
|
// on dessine les jetons dans l'espace de jeu et le plateau
|
|
_draw.DrawBoard(board);
|
|
_draw.DrawPlayGround(board, currentPlayer, currentPosition);
|
|
|
|
// on récupère la touche pressée
|
|
ConsoleKey key = Console.ReadKey(true).Key;
|
|
|
|
// on regarde si la touche est escape
|
|
if (key == ConsoleKey.Escape)
|
|
{
|
|
// s'il le joueur appuie sur escape il n'y a pas de gagnant donc on set le currentPlayer à None
|
|
currentPlayer = Token.None;
|
|
break;
|
|
}
|
|
|
|
// on regarde les actions des joueurs
|
|
switch (key)
|
|
{
|
|
case ConsoleKey.RightArrow:
|
|
// on incrémente la position actuelle si elle est inférieure à la taille du plateau
|
|
if (currentPosition < board.GetLength(0) - 1)
|
|
currentPosition++;
|
|
else
|
|
// on loop si on est à la fin du plateau
|
|
currentPosition = 0;
|
|
break;
|
|
|
|
case ConsoleKey.LeftArrow:
|
|
// on decremente la position actuelle si elle est supérieure à 0
|
|
if (currentPosition > 0)
|
|
currentPosition--;
|
|
else
|
|
// on loop si on est à le début du plateau
|
|
currentPosition = board.GetLength(0) - 1;
|
|
break;
|
|
|
|
case ConsoleKey.Enter:
|
|
case ConsoleKey.Spacebar:
|
|
// on place le jeton et on change de joueur
|
|
placed = PlaceToken(board, currentPlayer, currentPosition);
|
|
if (placed && currentPlayer == Token.FirstPlayer)
|
|
currentPlayer = Token.SecondPlayer;
|
|
else if (placed && currentPlayer == Token.SecondPlayer)
|
|
currentPlayer = Token.FirstPlayer;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// on dessine les derniers jetons
|
|
_draw.DrawBoard(board);
|
|
_draw.DrawPlayGround(board, currentPlayer, currentPosition);
|
|
|
|
// on reset les couleurs
|
|
_program.SetColor();
|
|
|
|
// on place le curseur en bas du tableau avec le bon spacing
|
|
Console.SetCursorPosition(0, board.GetLength(1) * 2 + _draw.topSpacing + 4);
|
|
|
|
// on verifie s'il y a une égalité
|
|
if (CheckDraw(board))
|
|
Console.WriteLine("il y a eu une égalité");
|
|
else if (currentPlayer == Token.FirstPlayer)
|
|
{
|
|
// si le joueur actuel est le joueur 1 cela signifie que le joueur 2 a gagné
|
|
Console.Write("Le ");
|
|
_program.SetColor(foregroundColor: _program.SECONDPLAYERCOLOR);
|
|
Console.Write("joueur 2");
|
|
_program.SetColor();
|
|
Console.WriteLine(" a gagné");
|
|
|
|
}
|
|
else if (currentPlayer == Token.SecondPlayer)
|
|
{
|
|
// si le joueur actuel est le joueur 2 cela signifie que le joueur 1 a gagné
|
|
Console.Write("Le ");
|
|
_program.SetColor(foregroundColor: _program.FIRSTPLAYERCOLOR);
|
|
Console.Write("joueur 1");
|
|
_program.SetColor();
|
|
Console.WriteLine(" a gagné");
|
|
}
|
|
else if (currentPlayer == Token.None)
|
|
{
|
|
// si le joueur actuel est None cela signifie que la partie a été arrêtée
|
|
Console.WriteLine("La partie a été arrêtée");
|
|
}
|
|
// on affiche le nombre de tours
|
|
Console.WriteLine("La partie a duré " + Turn(board) + " tours");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Méthode pour compter le nombre de jetons sur le plateau
|
|
/// </summary>
|
|
/// <param name="board">tableau de jetons</param>
|
|
/// <returns>nombre de jetons sur le plateau</returns>
|
|
int Turn(Token[,] board)
|
|
{
|
|
int count = 0; // compteur
|
|
for (int y = 0; y < board.GetLength(1); y++)
|
|
{
|
|
for (int x = 0; x < board.GetLength(0); x++)
|
|
if (board[x, y] != 0)
|
|
{
|
|
// ajoute 1 si le jeton n'est pas égal à 0
|
|
count++;
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Méthode pour vérifier s'il y a une égalité
|
|
/// </summary>
|
|
/// <param name="board">tableau de jetons</param>
|
|
/// <returns>return false t'en qu'il y a au moins 1 0 sur le plateau</returns>
|
|
private bool CheckDraw(Token[,] board)
|
|
{
|
|
for (int y = 0; y < board.GetLength(1); y++)
|
|
{
|
|
for (int x = 0; x < board.GetLength(0); x++)
|
|
{
|
|
if (board[x, y] == 0)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Méthode qui vérifie si un joueur a gagné
|
|
/// </summary>
|
|
/// <param name="board">tableau de jetons</param>
|
|
/// <returns>return true s'il y a une combinaison gagnante</returns>
|
|
private bool CheckWin(Token[,] board)
|
|
{
|
|
// tableau des joueurs
|
|
Token[] players = {Token.FirstPlayer, Token.SecondPlayer};
|
|
// boucle qui alterne entre les joueurs 1 et 2
|
|
foreach (Token j in players)
|
|
{
|
|
// boucle qui fait toutes les colonnes
|
|
for (int y = 0; y < board.GetLength(1); y++)
|
|
{
|
|
// boucle qui fait toute la valeur des colonnes
|
|
for (int x = 0; x < board.GetLength(0); x++)
|
|
{
|
|
// on check les bordures horizontales
|
|
if (x + 3 < board.GetLength(0))
|
|
{
|
|
// on check les 4 prochains jetons dans le sens horizontal
|
|
if (board[x, y] == j &&
|
|
board[x + 1, y] == j &&
|
|
board[x + 2, y] == j &&
|
|
board[x + 3, y] == j)
|
|
{
|
|
// on retourne vrai si la condition est respectée
|
|
return true;
|
|
}
|
|
}
|
|
// on check les bordure verticales
|
|
if (y + 3 < board.GetLength(1))
|
|
{
|
|
// on check les 4 prochains jetons dans le sens vertical
|
|
if (board[x, y] == j &&
|
|
board[x, y + 1] == j &&
|
|
board[x, y + 2] == j &&
|
|
board[x, y + 3] == j)
|
|
{
|
|
// on retourne vrai si la condition est respectée
|
|
return true;
|
|
}
|
|
}
|
|
// on check les bordures horizontales et verticales
|
|
if (y + 3 < board.GetLength(1) && x + 3 < board.GetLength(0))
|
|
{
|
|
// on check les 4 prochains jetons dans le sens horizontal et vertical
|
|
if (board[x, y] == j &&
|
|
board[x + 1, y + 1] == j &&
|
|
board[x + 2, y + 2] == j &&
|
|
board[x + 3, y + 3] == j)
|
|
{
|
|
// on retourne vrai si la condition est respectée
|
|
return true;
|
|
}
|
|
}
|
|
// on check les bordures horizontales et verticales
|
|
if (y - 3 > 0 && x + 3 < board.GetLength(0))
|
|
{
|
|
// on check les 4 prochains jetons dans le sens horizontal et vertical
|
|
if (board[x, y] == j &&
|
|
board[x + 1, y - 1] == j &&
|
|
board[x + 2, y - 2] == j &&
|
|
board[x + 3, y - 3] == j)
|
|
{
|
|
// on retourne vrai si la condition est respectée
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// si rien n'a été trouvé, on retourne false
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Méthode qui place un jeton sur le plateau
|
|
/// </summary>
|
|
/// <param name="board">tableau de jetons</param>
|
|
/// <param name="currentPlayer">joueur actuel</param>
|
|
/// <param name="currentPosition">position du joueur</param>
|
|
/// <returns></returns>
|
|
private bool PlaceToken(Token[,] board, Token currentPlayer, int currentPosition)
|
|
{
|
|
for (int i = board.GetLength(1) - 1; i >= 0; i--)
|
|
{
|
|
// si la case est déjà occupée on continue
|
|
if (board[currentPosition, i] != Token.None) continue;
|
|
|
|
// sinon on place le jeton
|
|
board[currentPosition, i] = currentPlayer;
|
|
|
|
// on revoie vrai s'il on a placé le jeton
|
|
return true;
|
|
}
|
|
// on revoie faux s'il on n'a pas placé le jeton
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Classe Board contient les méthodes pour la création du tableau
|
|
/// </summary>
|
|
public class Board
|
|
{
|
|
private Program _program = new Program();
|
|
public int[] BoardSize()
|
|
{
|
|
int[] boardSize = { 0, 0 }; // initialisation de la taille
|
|
string[] input = { "", "" }; // initialisation de l'entrée utilisateur
|
|
// écriture des instructions en couleur grâce à la méthode WriteColor
|
|
Console.SetCursorPosition(0, 4);
|
|
Console.Write("La taille doit être comprise entre ");
|
|
_program.SetColor(foregroundColor: ConsoleColor.Red);
|
|
Console.Write("5x6");
|
|
_program.SetColor();
|
|
Console.Write(" et ");
|
|
_program.SetColor(foregroundColor: ConsoleColor.Red);
|
|
Console.WriteLine("13x16");
|
|
_program.SetColor();
|
|
Console.WriteLine("exemple: 6x7 (6 lignes et 7 colonnes)");
|
|
Console.SetCursorPosition(0, 6);
|
|
Console.Write(" ");
|
|
Console.SetCursorPosition(0, 6);
|
|
Console.Write("taille: ");
|
|
|
|
// récupération de l'entrée utilisateur dans une liste grâce à un split
|
|
input = Console.ReadLine().Split('x');
|
|
|
|
// on essaye de Parse en int les entrées, sinon on fait une récursion
|
|
try
|
|
{
|
|
boardSize[0] = int.Parse(input[1]);
|
|
boardSize[1] = int.Parse(input[0]);
|
|
}
|
|
catch
|
|
{
|
|
Console.WriteLine("La taille est invalide. réessayer");
|
|
return BoardSize();
|
|
}
|
|
|
|
// on check si les entrées sont incorrectes si oui on fait une récursion
|
|
if (boardSize[1] <= 5 || boardSize[1] >= 13 || boardSize[0] <= 6 || boardSize[0] >= 16)
|
|
{
|
|
Console.WriteLine("La taille est invalide. réessayer");
|
|
return BoardSize();
|
|
}
|
|
|
|
// et si tous les checks sont passés, on retourne la taille
|
|
Console.WriteLine("taille valide");
|
|
return boardSize;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Classe Draw qui contient toutes les méthodes pour render
|
|
/// </summary>
|
|
public class Draw
|
|
{
|
|
// on instancie la classe Program
|
|
private Program _program = new Program();
|
|
|
|
// on définit les espacements
|
|
public int topSpacing = 4;
|
|
public int leftSpacing = 10;
|
|
|
|
/// <summary>
|
|
/// Méthode DrawPlayGroundBorder qui dessine le terrain de jeu
|
|
/// </summary>
|
|
/// <param name="board">tableau de jetons</param>
|
|
|
|
public void DrawPlayGroundBorder(Token[,] board)
|
|
{
|
|
for (int y = 0; y < 3; y++)
|
|
for (int x = 0; x < board.GetLength(0) * 4 + 1; x++)
|
|
{
|
|
// on met la position partout où l'on va écrire un caractère
|
|
Console.SetCursorPosition(x + leftSpacing, y + topSpacing);
|
|
|
|
// case 0, 0
|
|
if (x == 0 && y == 0)
|
|
Console.Write('╔');
|
|
|
|
// case 0, 2
|
|
if (x == 0 && y == 2)
|
|
Console.Write('╚');
|
|
|
|
// toutes 4 case de la 2eme ligne
|
|
if (x % 4 == 0 && y == 1)
|
|
Console.Write('║');
|
|
|
|
// tout le reste
|
|
if (x % 4 != 0 && y != 1)
|
|
Console.Write('═');
|
|
|
|
// dernière case de la première rangée
|
|
if (x == board.GetLength(0) * 4 && y == 0)
|
|
Console.Write('╗');
|
|
|
|
// dernière case de la première rangée
|
|
if (x == board.GetLength(0) * 4 && y == 2)
|
|
Console.Write('╝');
|
|
|
|
// tous les case 4 case de la première ligne
|
|
if (x != board.GetLength(0) * 4 && x % 4 == 0 && y == 0)
|
|
Console.Write('╦');
|
|
|
|
// tous les case 4 case de la dernière ligne
|
|
if (x != board.GetLength(0) * 4 && x % 4 == 0 && y == 2)
|
|
Console.Write('╩');
|
|
}
|
|
}
|
|
|
|
/*public void DrawPlayGroundBorder(Token[,] board)
|
|
{
|
|
// on place le curseur en haut du terrain de jeu après le titre
|
|
Console.SetCursorPosition(leftSpacing, topSpacing);
|
|
// on dessine la première ligne du terrain de jeu
|
|
Console.Write("╔═══");
|
|
for (int x = 0; x < board.GetLength(0) - 1; x++)
|
|
{
|
|
Console.Write("╦═══");
|
|
}
|
|
Console.Write("╗");
|
|
|
|
|
|
// on dessine les autres lignes du terrain de jeu
|
|
for (int y = 0; y < board.GetLength(1); y++)
|
|
{
|
|
for (int x = 0; x < board.GetLength(0); x++)
|
|
{
|
|
Console.SetCursorPosition(leftSpacing + x * 4, y * 2 + topSpacing + 1);
|
|
Console.Write("║");
|
|
}
|
|
Console.Write(" ║");
|
|
}
|
|
|
|
// on dessine la dernière ligne du terrain de jeu
|
|
Console.SetCursorPosition(leftSpacing, topSpacing + 2);
|
|
Console.Write("╚═══");
|
|
for (int x = 0; x < board.GetLength(0) - 1; x++)
|
|
{
|
|
Console.Write("╩═══");
|
|
}
|
|
Console.Write("╝");
|
|
}*/
|
|
|
|
/// <summary>
|
|
/// Méthode DrawPlayGround qui dessine les jetons dans le terrain de jeu
|
|
/// </summary>
|
|
/// <param name="board">tableau de jetons</param>
|
|
/// <param name="currentPlayer">joueur actuel</param>
|
|
/// <param name="currentPosition">position du joueur actuel</param>
|
|
public void DrawPlayGround(Token[,] board, Token currentPlayer, int currentPosition)
|
|
{
|
|
for (int x = 0; x < board.GetLength(0); x++)
|
|
{
|
|
// on place le curseur dans chaque case du terrain de jeu
|
|
Console.SetCursorPosition(leftSpacing + x * 4+2, topSpacing + 1);
|
|
|
|
// on dessine le jeton du joueur actuel si la position actuelle est égale à la position x sinon on ne dessine rien
|
|
if (currentPosition == x) Console.Write(DrawToken(currentPlayer));
|
|
else Console.Write(DrawToken(Token.None));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Méthode DrawBorder qui dessine les bordures du plateau
|
|
/// </summary>
|
|
/// <param name="board">tableau de jetons</param>
|
|
public void DrawBorder(Token[,] board)
|
|
{
|
|
for (int y = 0; y < board.GetLength(1) * 2 + 1; y++)
|
|
for (int x = 0; x < board.GetLength(0) * 4 + 1; x++)
|
|
{
|
|
// on place le curseur
|
|
Console.SetCursorPosition(x + leftSpacing, y + topSpacing + 3);
|
|
|
|
// la première case
|
|
if (x == 0 && y == 0)
|
|
Console.Write('╔');
|
|
|
|
// une case sur deux en y et une case sur quatre en y
|
|
if (x % 4 == 0 && y % 2 == 1)
|
|
Console.Write('║');
|
|
|
|
// toutes les case qui ne sont pas toutes les 4 case en x et toutes les 2 case en y
|
|
if (x % 4 != 0 && y % 2 == 0)
|
|
Console.Write('═');
|
|
|
|
// dans la première colonne toutes les deux cases
|
|
if (x == 0 && y == board.GetLength(1) * 2)
|
|
Console.Write('╚');
|
|
|
|
// la dernière case de la première ligne
|
|
if (x == board.GetLength(0) * 4 && y == 0)
|
|
Console.Write('╗');
|
|
|
|
// la dernière case de la dernière ligne
|
|
if (x == board.GetLength(0) * 4 && y == board.GetLength(1) * 2)
|
|
Console.Write('╝');
|
|
|
|
// toutes les 4 case de la première ligne sauf la première et la dernière
|
|
if (x != 0 &&
|
|
x != board.GetLength(0) * 4 &&
|
|
x % 4 == 0 &&
|
|
y == 0)
|
|
Console.Write('╦');
|
|
|
|
// toutes les 4 case de la dernière ligne sauf la première et la dernière
|
|
if (x != 0 &&
|
|
x != board.GetLength(0) * 4 &&
|
|
x % 4 == 0 &&
|
|
y == board.GetLength(1) * 2)
|
|
Console.Write('╩');
|
|
|
|
// toutes les 2 case d'une ligne sur deux dans la dernière colonne sauf la première et la dernière
|
|
if (y != 0 &&
|
|
y != board.GetLength(1) * 2 &&
|
|
x == board.GetLength(0) * 4 &&
|
|
y % 2 == 0)
|
|
Console.Write('╣');
|
|
|
|
// toutes les 2 case d'une ligne sur deux dans la première colonne sauf la première et la dernière
|
|
if (y != 0 &&
|
|
y != board.GetLength(1) * 2 &&
|
|
x == 0 &&
|
|
y % 2 == 0)
|
|
Console.Write('╠');
|
|
|
|
// toutes les cases au milieu
|
|
if (x != 0 &&
|
|
x != board.GetLength(0) * 4 &&
|
|
y != 0 &&
|
|
y != board.GetLength(1) * 2 &&
|
|
x % 4 == 0 &&
|
|
y % 2 == 0)
|
|
Console.Write('╬');
|
|
}
|
|
}
|
|
|
|
/*public void DrawBorder(Token[,] board)
|
|
{
|
|
// déclaration de l'espacement du plateau
|
|
int playgroundSpacing = topSpacing + 3;
|
|
|
|
// on place le curseur en haut du plateau
|
|
Console.SetCursorPosition(leftSpacing, playgroundSpacing);
|
|
|
|
// on dessine la première ligne du plateau
|
|
Console.Write("╔═══");
|
|
for (int x = 0; x < board.GetLength(0) - 1; x++)
|
|
{
|
|
Console.Write("╦═══");
|
|
}
|
|
Console.Write("╗");
|
|
|
|
// on dessine les autres lignes du plateau
|
|
for (int y = 0; y < board.GetLength(1); y++)
|
|
{
|
|
for (int x = 0; x < board.GetLength(0); x++)
|
|
{
|
|
Console.SetCursorPosition(leftSpacing + x * 4, y * 2 + playgroundSpacing + 1);
|
|
Console.Write("║");
|
|
}
|
|
Console.SetCursorPosition(leftSpacing + board.GetLength(0) * 4, y * 2 + playgroundSpacing + 1);
|
|
Console.Write("║");
|
|
}
|
|
|
|
// on dessine les interligne du plateau
|
|
for (int y = 0; y < board.GetLength(1) - 1; y++)
|
|
{
|
|
Console.SetCursorPosition(leftSpacing, y * 2 + playgroundSpacing + 2);
|
|
Console.Write("╠═══");
|
|
for (int x = 1; x < board.GetLength(0); x++)
|
|
{
|
|
Console.SetCursorPosition(leftSpacing + x * 4, y * 2 + playgroundSpacing + 2);
|
|
Console.Write("╬═══");
|
|
}
|
|
Console.Write("╣");
|
|
}
|
|
|
|
// on dessine la dernière ligne du plateau
|
|
Console.SetCursorPosition(leftSpacing, board.GetLength(1) * 2 + playgroundSpacing);
|
|
Console.Write("╚═══");
|
|
for (int x = 0; x < board.GetLength(0) - 1; x++)
|
|
{
|
|
Console.Write("╩═══");
|
|
}
|
|
Console.Write("╝");
|
|
}*/
|
|
|
|
/// <summary>
|
|
/// Méthode DrawBoard qui dessine les jetons sur le plateau
|
|
/// </summary>
|
|
/// <param name="board">tableau de jetons</param>
|
|
public void DrawBoard(Token[,] board)
|
|
{
|
|
// déclaration de l'espacement du plateau
|
|
int playgroundSpacing = topSpacing + 3;
|
|
for (int y = 0; y < board.GetLength(1); y++)
|
|
for (int x = 0; x < board.GetLength(0); x++)
|
|
{
|
|
// on place le curseur dans chaque case du plateau
|
|
Console.SetCursorPosition(leftSpacing + x * 4 + 2, y * 2 + playgroundSpacing + 1);
|
|
// on dessine le jeton qui correspond à la case
|
|
Console.Write(DrawToken(board[x, y]));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Méthode DrawToken qui transforme un jeton en string
|
|
/// </summary>
|
|
/// <param name="token">jeton à transformer</param>
|
|
/// <returns>jeton transformé</returns>
|
|
public string DrawToken(Token token)
|
|
{
|
|
switch (token)
|
|
{
|
|
case Token.FirstPlayer:
|
|
// on set la couleur du premier joueur
|
|
_program.SetColor(foregroundColor: _program.FIRSTPLAYERCOLOR);
|
|
// on retourne le jeton
|
|
return "■";
|
|
case Token.SecondPlayer:
|
|
// on set la couleur du deuxième joueur
|
|
_program.SetColor(foregroundColor: _program.SECONDPLAYERCOLOR);
|
|
// on retourne le jeton
|
|
return "■";
|
|
case Token.None:
|
|
// on set la couleur par défaut
|
|
_program.SetColor(foregroundColor: ConsoleColor.DarkGray);
|
|
// on retourne le jeton
|
|
return "≡";
|
|
default:
|
|
// revoye le rest au cas où
|
|
return default;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Méthode DrawTitle qui dessine le titre du jeu
|
|
/// </summary>
|
|
/// <param name="spacing">espacement entre le bord et le titre</param>
|
|
public void DrawTitle(int spacing = 0)
|
|
{
|
|
// on met le curseur à la bonne position avant d'écrire chaques lignes
|
|
Console.SetCursorPosition(spacing, 0);
|
|
Console.WriteLine("╔═══════════════════════════════════╗");
|
|
Console.SetCursorPosition(spacing, 1);
|
|
Console.WriteLine("║ Bienvenue dans le jeu Puissance 4 ║");
|
|
Console.SetCursorPosition(spacing, 2);
|
|
Console.WriteLine("║ Réalisé par Théophile Borboën ║");
|
|
Console.SetCursorPosition(spacing, 3);
|
|
Console.WriteLine("╚═══════════════════════════════════╝");
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Méthode DrawHelp qui dessine l'aide du jeu
|
|
/// </summary>
|
|
/// <param name="board">tableau de jetons</param>
|
|
public void DrawHelp(Token[,] board)
|
|
{
|
|
// on dessine l'aide relative au plateau et qu'avec des positions
|
|
WriteHelp(board, 0, 0, "Mode d'utilisation");
|
|
WriteHelp(board, 0, 1, "-------------------");
|
|
WriteHelp(board, 4, 2, "Déplacement");
|
|
WriteHelp(board, 18, 2, "Touches directionnelles");
|
|
WriteHelp(board, 4, 3, "Tir");
|
|
WriteHelp(board, 18, 3, "Spacebar ou Enter");
|
|
WriteHelp(board, 4, 4, "Quitter");
|
|
WriteHelp(board, 18, 4, "Escape");
|
|
_program.SetColor(foregroundColor: _program.FIRSTPLAYERCOLOR);
|
|
WriteHelp(board, 4, 6, "Joueur 1: ");
|
|
_program.SetColor(_program.FIRSTPLAYERCOLOR);
|
|
WriteHelp(board, 14, 6, " ");
|
|
_program.SetColor(foregroundColor: _program.SECONDPLAYERCOLOR);
|
|
WriteHelp(board, 18, 6, "Joueur 2: ");
|
|
_program.SetColor(_program.SECONDPLAYERCOLOR);
|
|
WriteHelp(board, 28, 6, " ");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Méthode WriteHelp qui écrit les phrases de l'aide
|
|
/// </summary>
|
|
/// <param name="board">tableau de jetons</param>
|
|
/// <param name="x">position x</param>
|
|
/// <param name="y">position y</param>
|
|
/// <param name="text">text à écrire à cette position</param>
|
|
private void WriteHelp(Token[,] board, int x, int y, string text)
|
|
{
|
|
Console.SetCursorPosition(leftSpacing + board.GetLength(0) * 4 + 8 + x, topSpacing + y);
|
|
Console.Write(text);
|
|
}
|
|
}
|
|
}
|