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
No results found
Select Git revision
  • adam
  • main
  • thomas
3 results
Show changes

Commits on Source 2

3 files
+ 167
− 32
Compare changes
  • Side-by-side
  • Inline

Files

app.js

+9 −7
Original line number Original line Diff line number Diff line
@@ -5,7 +5,7 @@ const express = require('express'); 
const app = express();

const app = express();

const http = require('http').createServer(app);

const http = require('http').createServer(app);

const path = require('path');

const path = require('path');

const port = 8080;

const port = 8060;





const io = require('socket.io')(http);

const io = require('socket.io')(http);
@@ -19,9 +19,9 @@ app.get('/', (req, res) => { 
    res.sendFile(path.join(__dirname, 'htdocs/page_acceuil2.html'));

    res.sendFile(path.join(__dirname, 'htdocs/page_acceuil2.html'));

});

});

app.use(express.static(path.join(__dirname, 'htdocs')));

app.use(express.static(path.join(__dirname, 'htdocs')));

app.get('/',(req,res)=>{

// app.get('/',(req,res)=>{

    res.sendFile(path.join(__dirname,'htdocs/page_jeu.html'));

//     res.sendFile(path.join(__dirname,'htdocs/page_jeu.html'));

});

// });





http.listen(port , ()=>{

http.listen(port , ()=>{

    console.log("Listening on http://localhost${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

        console.log(`[Server] Play reçu : ${JSON.stringify(data)}`);  // Debugging

        socket.broadcast.emit('roque', data);  // On diffuse à tous les clients

        socket.broadcast.emit('roque', data);  // On diffuse à tous les clients

    });

    });



    socket.on('mat', () =>{

    socket.on('echec', () => {

        socket.broadcast.emit('mat');

        socket.broadcast.emit('echec');

    });

    socket.on('echec', (dataEchec) => {

        socket.broadcast.emit('echec',dataEchec);

    });

    });

htdocs/index.js

+157 −25
Original line number Original line Diff line number Diff line
@@ -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");

    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) => {

socket.on('play', (moveData) => {

    //console.log("[Client] Mouvement reçu : ", moveData.move.to.x, 'et', moveData.move.to.y,'et', tour, 'et', selectedPosition);

    //console.log("[Client] Mouvement reçu : ", moveData.move.to.x, 'et', moveData.move.to.y,'et', tour, 'et', selectedPosition);

    selectedPiece = moveData.move.piece;

    selectedPiece = moveData.move.piece;
@@ -177,11 +184,13 @@ socket.on('roque', (moveData) =>{ 
    console.log(board)

    console.log(board)

    draw()

    draw()





})

});

socket.on('play again', (players) => {

// socket.on('play again', (players) => {

    restartGame(players);

//     restartGame(players);

})

// });



socket.on('mat', () =>{

    document.getElementById("echec-et-mat-message").classList.remove("d-none");

});





function startGame(players) {

function startGame(players) {

    restartArea.classList.add('d-none');

    restartArea.classList.add('d-none');
@@ -327,12 +336,12 @@ function selectPiece(row, col) { 
    selectedPosition = {row, col};

    selectedPosition = {row, col};

    if (current_piece !== "" && player.pieces.includes(current_piece)) {  // Vérifier que ce n'est pas une case vide

    if (current_piece !== "" && player.pieces.includes(current_piece)) {  // Vérifier que ce n'est pas une case vide

        selectedPiece = current_piece;

        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 = [];

    let ennemyPieces = [];

    if (player.isBlackPlayer===false){

    if (player.isBlackPlayer===false){

        ennemyPieces = ["T", "C", "F", "Q", "K", "P"];

        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

        // Trouve la position du roi ennemi

        let piecesAttaquant = [];

        let piecesAttaquant = [];

        let kingRow, kingCol;

        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) {

    if (player.isBlackPlayer === false) {

        [kingRow, kingCol] = find_pieces("K", board); // Roi noir (adverse) si c'est au joueur blanc de jouer

        [kingRow, kingCol] = find_pieces("K", board); // Roi noir (adverse) si c'est au joueur blanc de jouer

        piecesAttaquant = ["t", "c", "f", "q", "k", "p"];

        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

        [kingRow, kingCol] = find_pieces("k", board); // Roi blanc (adverse) si c'est au joueur noir de jouer

        piecesAttaquant = ["T", "C", "F", "Q", "K", "P"];

        piecesAttaquant = ["T", "C", "F", "Q", "K", "P"];

    }

    }



}

    

    

    for (let i = 0; i < board.length; i++) {

    for (let i = 0; i < board.length; i++) {

        for (let j = 0; j < board[i].length; j++) {

        for (let j = 0; j < board[i].length; j++) {

            const pieceAttack = board[i][j];

            const pieceAttack = board[i][j];





            if (pieceAttack !== "" && piecesAttaquant.includes(pieceAttack)) {

            if (pieceAttack !== "" && piecesAttaquant.includes(pieceAttack)) {

                moves=highlightMoves(board,pieceAttack , i, j)

                moves=highlightMoves(pieceAttack , i, j)

                for (k =0; k<moves.length;k++){

                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) {

function movePiece(piece, newRow, newCol) {

    document.getElementById("echec-message").classList.add("d-none");

    document.getElementById("echec-message").classList.add("d-none");

    if (!piece) return;

    if (!piece) return;





    // Vérifier si le mouvement est valide

    // 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 }

    // 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);

    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

        // Déplacer la pièce

        board[newRow][newCol] = piece;

        board[newRow][newCol] = piece;

        board[selectedPosition.row][selectedPosition.col] = "";

        board[selectedPosition.row][selectedPosition.col] = "";

        console.log(echec(board));











        //currentPlayer=(currentPlayer+1)%2;

        //currentPlayer=(currentPlayer+1)%2;
@@ -693,9 +710,9 @@ function movePiece(piece, newRow, newCol) { 
                piece: selectedPiece            // Nom de la pièce (ex: "pion", "tour", etc.)

                piece: selectedPiece            // Nom de la pièce (ex: "pion", "tour", etc.)

            }

            }

        });

        });



        dataEchec = echec(board,"attaquant");

        if (echec(board)){

        if (dataEchec[0]) {

            socket.emit('echec');

            socket.emit('echec', dataEchec);  

        }

        }





        //Verifie si c'était un rock

        //Verifie si c'était un rock
@@ -769,3 +786,118 @@ function movePiece(piece, newRow, newCol) { 
        selectedPiece=null;

        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;

}

htdocs/page_acceuil2.html

+1 −0
Original line number Original line Diff line number Diff line
@@ -89,6 +89,7 @@ 
        </div>

        </div>

    </div>

    </div>

    <div id="echec-message" class="d-none">Échec !</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>

    <canvas id="chessboard" class="board" width="480" height="480"></canvas>

    <script src="./jquery/jquery.min.js"></script>

    <script src="./jquery/jquery.min.js"></script>

    <script src="./bootstrap/js/bootstrap.min.js"></script>

    <script src="./bootstrap/js/bootstrap.min.js"></script>