Socket.io chess check control

The given code snippet is a JavaScript function that handles the dropping of a chess piece in an online chess game. Here is a brief explanation of the functions present in the code:

1. onDrop(source, target): This function is triggered when a chess piece is dropped on the board. It performs various actions related to the game logic, such as determining the current player's turn, validating the move, making the move, emitting events to update the game state, checking for checks, and updating the user interface.

2. removeGreySquares(): This function is called to remove any gray highlighting on the chessboard, which might have been used to indicate valid moves for the player.

3. engine.getSide(): This function returns the side (color) of the current player.

4. engine.promotedToString(promotedPiece): This function converts a promoted piece code to its string representation. It is used to represent a pawn promotion move.

5. engine.moveFromString(move): This function takes a move string in algebraic notation and returns a numeric move if it is a valid move, or 0 if it is an invalid move.

6. engine.generateLegalMoves(): This function generates all legal moves for the current position in the chess engine.

7. engine.makeMove(validMove): This function makes a move on the chessboard based on the valid move passed as an argument.

8. engine.printBoard(): This function prints the current state of the chessboard.

9. engine.generateFen(): This function generates the Forsyth–Edwards Notation (FEN) string representing the current position on the chessboard.

10. socket.emit('makeMove', { source, target, fen }): This line emits a 'makeMove' event using the WebSocket (socket.io) to send the source square, target square, and the FEN string to the server.

11. playSound(soundFile): This function plays a sound file located in the 'Sounds' directory.

12. socket.on('checkControl', (data) => { ... }): This event handler receives the 'checkControl' event from the server, which is emitted when a check condition occurs in the game. It triggers the redSquare function and performs further actions based on the check information.

13. sendCheck(message, checkCoord): This function emits a 'check' event to the server, sending a message and the coordinates of the checked square.

14. engine.inCheck():This function returns true or false based on the color [white:0,black:1] of the current player.

// on dropping piece
function onDrop(source, target) {
  console.log(informationArea);
  let currentPlayerColor;
  if (socket.id=== informationArea.roomOwnerSocketId&&localStorage.getItem('sessionId')===informationArea.roomOwnerSessionId) {
    currentPlayerColor = informationArea.roomOwnerColor;
  }
  else if(socket.id=== informationArea.roomFirstOpponent&&localStorage.getItem('sessionId')===informationArea.roomOpponentSessionId) {
    currentPlayerColor = informationArea.roomOpponentColor;
  }
  if(!currentPlayerColor){
    return;
  }
  let isPlayerTurn = (engine.getSide() === (currentPlayerColor === "white" ? 0 : 1));

  if (!isPlayerTurn) {
    return;
  }
  removeGreySquares();

  let promotedPiece = (engine.getSide() ? (5 + 6) : 5) // queen promotion only for now
  let move = source + target + engine.promotedToString(promotedPiece);
  let validMove = engine.moveFromString(move);

  console.log('user move', promotedPiece);

  // invalid move
  if (validMove == 0) return 'snapback';

  let legalMoves = engine.generateLegalMoves();
  let isLegal = 0;

  for (let count = 0; count < legalMoves.length; count++) {
    if (validMove == legalMoves[count].move) isLegal = 1;
  }

  // illegal move
  if (isLegal == 0) {return 'snapback'}
  
 
  //updateStatus();
  
  // make user move
  engine.makeMove(validMove);
  engine.printBoard();
  playSound('move.wav');
  let fen=engine.generateFen()
  socket.emit('makeMove', { source, target, fen});
  // make engine move
  var moves = board.move({
    verbose: true
  })
  
  let checkControl = localStorage.getItem('playerColor') === "white" ? 0 : 1;
  if(engine.inCheck(checkControl)){
    for (var key in moves) {
      console.log(moves[key])
      if (moves.hasOwnProperty(key)) {
        if (moves[key] === "wK"&& checkControl===0) {
          // "wK" taşının konumu key'de bulunuyor
          console.log("wK taşı bulundu! Konum: " + key);
          redSquare(key);
          sendCheck('whitecheck',key)
        }
        else if(moves[key] === "bK"&& checkControl===1){
          console.log("bK taşı bulundu! Konum: " + key);
          redSquare(key);
          sendCheck('blackcheck',key);
          
       
        }
      }
    }
    
  }

  console.log(engine.generateFen());
  $fen.html(engine.generateFen());

  // TODO: update game status
  // isGameOver();
}
function sendCheck(message,checkCoord){
  socket.emit('check',{message:message,checkCoord:checkCoord});
}

function playSound(soundFile) {
  var audio = new Audio('./Sounds/' + soundFile);
  audio.play();
}

socket.on('checkControl',(data)=>{
  console.log(data.message)
    redSquare(data.checkCoord);
})

These functions together handle the game logic, user interface updates, and communication with the server in an online chess game.
I have a problem related to the sendCheck function in the frontend code I shared with you above. When I manually execute this function in the browser's console, the signal reaches the backend correctly, and the backend responds to the other user with an io.emit, completing the checkControl process. As a result, the background of the piece in the specified coordinates turns red. However, this sequence doesn't happen when playing the game interactively using the onDrop function. In fact, no signal reaches the backend during the onDrop function. What could be the reason for this? I'm also sharing the backend code that is related on that sockets in below.

socket.on('check',(data)=>{
            io.to(user.room).emit('checkControl', { message: data.message, checkCoord: data.checkCoord })
            console.log(data.message,data.checkCoord)
          })

I understood the problem and appreciated it for helping @RokoC.Buljan . Instead of checking whether the opponent's king is in check, I am currently checking my own board. This is why the algorithm is incorrect. Here's how I solved the problem:

I realized that by reversing the logic, I can check if the opponent's board is being threatened or not. So, I made the following change:

From:

let checkControl = localStorage.getItem('playerColor') === "white" ? 0 : 1;

To:

let checkControl = localStorage.getItem('playerColor') === "white" ? 1 : 0;

By making this change, the expected trigger occurs, and the signal reaches the backend.