Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found
Select Git revision
  • adam
  • main
  • thomas
3 results

Target

Select target project
  • aelarout/echecs
1 result
Select Git revision
  • adam
  • main
  • thomas
3 results
Show changes
Commits on Source (2)
......@@ -5,7 +5,7 @@ const express = require('express');
const app = express();
const http = require('http').createServer(app);
const path = require('path');
const port = 8080;
const port = 8060;
const io = require('socket.io')(http);
......@@ -19,9 +19,9 @@ app.get('/', (req, res) => {
res.sendFile(path.join(__dirname, 'htdocs/page_acceuil2.html'));
});
app.use(express.static(path.join(__dirname, 'htdocs')));
app.get('/',(req,res)=>{
res.sendFile(path.join(__dirname,'htdocs/page_jeu.html'));
});
// app.get('/',(req,res)=>{
// res.sendFile(path.join(__dirname,'htdocs/page_jeu.html'));
// });
http.listen(port , ()=>{
console.log("Listening on http://localhost${port}/");
......@@ -70,9 +70,11 @@ io.on('connection', (socket) => {
console.log(`[Server] Play reçu : ${JSON.stringify(data)}`); // Debugging
socket.broadcast.emit('roque', data); // On diffuse à tous les clients
});
socket.on('echec', () => {
socket.broadcast.emit('echec');
socket.on('mat', () =>{
socket.broadcast.emit('mat');
});
socket.on('echec', (dataEchec) => {
socket.broadcast.emit('echec',dataEchec);
});
......
......@@ -117,9 +117,16 @@ socket.on('start game', (players) => {
}
});
socket.on('echec', () => { // Fonction de callback correcte
socket.on('echec', (dataEchec) => { // Fonction de callback correcte
document.getElementById("echec-message").classList.remove("d-none");
console.log('je ne suis pas encore en echec et mat et voici la piece qui attaque', dataEchec);
if (estEchecEtMat(dataEchec[1], dataEchec[2], dataEchec[3])) { // On appelle la fonction estEchecEtMat
console.log('je suis en echec et mat');
document.getElementById("echec-et-mat-message").classList.remove("d-none");
socket.emit('mat');
}
});
socket.on('play', (moveData) => {
//console.log("[Client] Mouvement reçu : ", moveData.move.to.x, 'et', moveData.move.to.y,'et', tour, 'et', selectedPosition);
selectedPiece = moveData.move.piece;
......@@ -177,11 +184,13 @@ socket.on('roque', (moveData) =>{
console.log(board)
draw()
})
socket.on('play again', (players) => {
restartGame(players);
})
});
// socket.on('play again', (players) => {
// restartGame(players);
// });
socket.on('mat', () =>{
document.getElementById("echec-et-mat-message").classList.remove("d-none");
});
function startGame(players) {
restartArea.classList.add('d-none');
......@@ -327,12 +336,12 @@ function selectPiece(row, col) {
selectedPosition = {row, col};
if (current_piece !== "" && player.pieces.includes(current_piece)) { // Vérifier que ce n'est pas une case vide
selectedPiece = current_piece;
highlightMoves(tour,current_piece, row, col);
highlightMoves(current_piece, row, col);
}
}
}
function highlightMoves(tour,piece, row, col) {
function highlightMoves(piece, row, col) {
let ennemyPieces = [];
if (player.isBlackPlayer===false){
ennemyPieces = ["T", "C", "F", "Q", "K", "P"];
......@@ -636,13 +645,21 @@ function find_pieces(piece,board){
}
}
function echec(board) {
function echec(board, statut) {
// Trouve la position du roi ennemi
let piecesAttaquant = [];
let kingRow, kingCol;
let allPositions = [];
if (statut==="defenseur"){
if (player.isBlackPlayer === false) {
[kingRow, kingCol] = find_pieces("k", board); // Roi noir (adverse) si c'est au joueur blanc de jouer
piecesAttaquant = ["T", "C", "F", "Q", "K", "P"];
} else {
[kingRow, kingCol] = find_pieces("K", board); // Roi blanc (adverse) si c'est au joueur noir de jouer
piecesAttaquant = ["t", "c", "f", "q", "k", "p"];
}
}
else{
if (player.isBlackPlayer === false) {
[kingRow, kingCol] = find_pieces("K", board); // Roi noir (adverse) si c'est au joueur blanc de jouer
piecesAttaquant = ["t", "c", "f", "q", "k", "p"];
......@@ -650,28 +667,30 @@ function echec(board) {
[kingRow, kingCol] = find_pieces("k", board); // Roi blanc (adverse) si c'est au joueur noir de jouer
piecesAttaquant = ["T", "C", "F", "Q", "K", "P"];
}
}
for (let i = 0; i < board.length; i++) {
for (let j = 0; j < board[i].length; j++) {
const pieceAttack = board[i][j];
if (pieceAttack !== "" && piecesAttaquant.includes(pieceAttack)) {
moves=highlightMoves(board,pieceAttack , i, j)
moves=highlightMoves(pieceAttack , i, j)
for (k =0; k<moves.length;k++){
if (moves[k].row === kingRow && moves[k].col === kingCol) return true;
if (moves[k].row === kingRow && moves[k].col === kingCol) {
return [true,pieceAttack,i,j];
}
}
}
}
return false;
}
return [false];
}
function movePiece(piece, newRow, newCol) {
document.getElementById("echec-message").classList.add("d-none");
if (!piece) return;
// Vérifier si le mouvement est valide
const validMoves = highlightMoves(tour, piece, selectedPosition.row, selectedPosition.col);
const validMoves = highlightMoves(piece, selectedPosition.row, selectedPosition.col);
// Vérifier que validMoves est un tableau et qu'il contient des objets avec { row, col }
const isValidMove = Array.isArray(validMoves) && validMoves.some(m => m.row === newRow && m.col === newCol);
......@@ -680,8 +699,6 @@ function movePiece(piece, newRow, newCol) {
// Déplacer la pièce
board[newRow][newCol] = piece;
board[selectedPosition.row][selectedPosition.col] = "";
console.log(echec(board));
//currentPlayer=(currentPlayer+1)%2;
......@@ -693,9 +710,9 @@ function movePiece(piece, newRow, newCol) {
piece: selectedPiece // Nom de la pièce (ex: "pion", "tour", etc.)
}
});
if (echec(board)){
socket.emit('echec');
dataEchec = echec(board,"attaquant");
if (dataEchec[0]) {
socket.emit('echec', dataEchec);
}
//Verifie si c'était un rock
......@@ -769,3 +786,118 @@ function movePiece(piece, newRow, newCol) {
selectedPiece=null;
}
}
function estEchecEtMat(pieceAttack , rowPiece, colPiece) {
if (player.isBlackPlayer===true){
[kingRow, kingCol] = find_pieces("K", board);
}
else{
[kingRow, kingCol] = find_pieces("k", board);
}
if (peutSortirEchec(kingRow, kingCol)) return false; // Le roi peut s'échapper de l'échec
// À ce stade, le roi est en échec et ne peut pas s'échapper.
// Il faut maintenant vérifier si une pièce alliée peut intercepter ou capturer l'attaquant.
// Si aucune pièce ne peut intercepter l'attaque, c'est un échec et mat.
if (peutIntercepter(kingRow, kingCol, board, pieceAttack, {row : rowPiece, col : colPiece})) return false;
return true; // Si aucune option n'est possible, c'est un échec et mat
}
function peutSortirEchec(kingRow, kingCol) {
if(player.isBlackPlayer===true){
king="K";
}
else {
king="k";
}
const moves = highlightMoves(king, kingRow, kingCol);
newBoard = JSON.parse(JSON.stringify(board));
for (move of moves) {
// Simule le déplacement du roi
sauvegarde = newBoard[move.row][move.col];
newBoard[move.row][move.col] = king;
newBoard[kingRow][kingCol] = "";
if (!echec(newBoard,"defenseur")[0]) { // Si le roi peut se déplacer en sécurité
return true;
}
}
return false;
}
function peutIntercepter(kingRow, kingCol, board, attaquant, movesAttaquant) {
for (let i = 0; i < board.length; i++) {
for (let j = 0; j < board[i].length; j++) {
const piece = board[i][j];
if (piece.toUpperCase() !== 'K' && player.pieces.includes(piece)) { // On exclut le roi lui-même
const moves = highlightMoves(piece, i, j);
for (const move of moves) {
// Si la pièce peut capturer l'attaquant
if (move.row === movesAttaquant.row && move.col === movesAttaquant.col) {
return true;
}
// Vérifier si la pièce peut intercepter l'attaque en se positionnant entre le roi et l'attaquant
if (attaquant.toUpperCase() === 'T' || attaquant.toUpperCase() === 'F' || attaquant.toUpperCase() === 'Q') {
// Si l'attaque est horizontale ou verticale
if (kingRow === movesAttaquant.row || kingCol === movesAttaquant.col) {
if (kingRow === movesAttaquant.row || kingCol === movesAttaquant.col) {
if (kingRow === movesAttaquant.row) {
directionI = 0;
directionJ = Math.sign(movesAttaquant.col - kingCol);
}
else if (kingCol === movesAttaquant.col) {
directionI = Math.sign(movesAttaquant.row - kingRow);
directionJ = 0;
}
}
for (let i = kingRow + directionI, j = kingCol + directionJ;
(i !== movesAttaquant.row || j !== movesAttaquant.col);
i += directionI, j += directionJ) {
if (i === move.row && j === move.col) {
return true; // La pièce se place sur la trajectoire de l'attaque
}
}
}
// Vérifier si l'attaque est diagonale
else if (Math.abs(kingRow - movesAttaquant.row) === Math.abs(kingCol - movesAttaquant.col)) {
const directionI = Math.sign(movesAttaquant.row - kingRow);
const directionJ = Math.sign(movesAttaquant.col - kingCol);
let a = kingRow + directionI;
let b = kingCol + directionJ;
while (a !== movesAttaquant.row || b !== movesAttaquant.col) {
console.log(a, b);
console.log(movesAttaquant.row,movesAttaquant.col)
if (board[a][b] === '') { // Si une pièce est sur la trajectoire
if (a === move.row && b === move.col) {
return true; // La pièce se place correctement pour bloquer l'attaque
}
}
a += directionI;
b += directionJ;
}
}
}
}
}
}
}
return false;
}
......@@ -89,6 +89,7 @@
</div>
</div>
<div id="echec-message" class="d-none">Échec !</div>
<div id="echec-et-mat-message" class="d-none">Échec et mat !</div>
<canvas id="chessboard" class="board" width="480" height="480"></canvas>
<script src="./jquery/jquery.min.js"></script>
<script src="./bootstrap/js/bootstrap.min.js"></script>
......