Validating Player Moves

1. From Pseudo-Legal to Legal

The core rule we need to enforce is this: a player cannot make a move that leaves their own king in check.

Your move generation functions from Module 5 and 7 produce what we call pseudo-legal moves—moves that follow a piece's basic movement rules. For example, they know a bishop moves diagonally. However, they don't account for the context of the entire board, such as whether a move would expose the king to an attack.

A legal move is a pseudo-legal move that also passes this critical safety check.

2. The Strategy: A "Look Ahead" Simulation

So, how can we know if a move will result in our king being in check before we actually make the move on the main board? The most common and reliable method is a simple simulation:

1. Create a temporary copy of the game board.
2. Execute the potential move on this temporary copy.
3. On this modified temporary board, check if the current player's king is now under attack.
4. If the king is not under attack, the move is legal.
5. If the king is under attack, the move is illegal. Discard the temporary board and reject the move.

This "clone, execute, check" strategy is a cornerstone of chess programming.

3. Hands-On: Implementing Move Validation

Excellent! You now have the theory and the strategy. The great news is that from your work in Module 6, you already have the key functions we need: execute_move and is_in_check. Let's put them to work.

Step 1: Making the Board Clone-able

Our strategy relies on creating a temporary copy of the board. To do this in Rust, our Board struct needs to implement the Clone trait.

Open the file containing your Board struct and add #[derive(Clone)] above it. You will also need to ensure that any structs contained within Board (like your Piece struct and Color enum) derive Clone and Copy.

// In your board representation file, e.g., src/board.rs

// Add Clone and Copy to your enums and piece struct



#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Color { /* ... */ }




#[derive(Debug, Clone, Copy, PartialEq)]
pub enum PieceType { /* ... */ }




#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Piece {
    pub piece_type: PieceType,
    pub color: Color,
}

// And finally, derive Clone for the board itself



#[derive(Debug, Clone)] // No Copy for Board, it's too large
pub struct Board {
    // your 8x8 array of Option<Piece>
    // ...
}

Note: We use Copy for small, simple data like enums and the Piece struct, but only Clone for the Board itself, as copying an entire 8x8 array is not a trivial operation.

Step 2: Creating a Validation Function

Let's create a single, clean function to check if a move is legal. A good place for this is in your Game struct's implementation block, as it involves the context of the current_turn.

// In src/main.rs, inside the `impl Game` block

/// Checks if a given move is legal in the current game state.
pub fn is_move_legal(&self, mv: &input::Move) -> bool {
    // First, generate all pseudo-legal moves for the current player.
    // You should have a function for this from modules 5 & 7.
    // Let's assume it's called `generate_pseudo_legal_moves`.
    let pseudo_legal_moves = self.board.generate_pseudo_legal_moves(self.current_turn);

    // 1. Is the requested move even pseudo-legal?
    if !pseudo_legal_moves.contains(mv) {
        return false;
    }

    // 2. If it is, perform the "look ahead" check.
    let mut temp_board = self.board.clone();
    
    // You wrote execute_move in Module 6!
    temp_board.execute_move(mv); 

    // You wrote is_in_check in Module 6!
    // The move is legal if, after making it, the current player is NOT in check.
    !temp_board.is_in_check(self.current_turn)
}

This function does two things:

1. It quickly rejects any move that doesn't follow the basic piece movement rules.
2. For moves that are pseudo-legal, it performs our simulation to ensure they don't result in self-check.

Step 3: Integrating into the Game Loop

Now for the final step. Let's update the main function to use our new is_move_legal validator.

// In src/main.rs, in your main function's loop

// ... inside your loop ...
match input::parse_move(user_input.trim()) {
    Ok(parsed_move) => {
        // Use our new validation function!
        if game.is_move_legal(&parsed_move) {
            println!("Executing legal move: {:?}", parsed_move);
            game.board.execute_move(&parsed_move); // Apply to the *real* board
            game.switch_turn();
        } else {
            println!("Illegal move: {}. This move is not allowed.", user_input.trim());
            // Do not switch turns, let the player try again.
        }
    }
    Err(e) => {
        println!("Error parsing move: {}. Please try again.", e);
    }
}
// ...

And that's it! Your game loop no longer blindly accepts any formatted string. It now consults your game's logic to determine if a move is valid before applying it and switching turns.

For a great example of this pattern in a real Rust crate, you can look at the dsaiko/chessgen repository.

Conclusion

Congratulations! You've just made a massive leap forward. Your chess engine is no longer just a board and pieces; it's now a referee that understands and enforces one of the most fundamental rules of chess.

Key Takeaways:

• A legal move is a pseudo-legal move that does not leave the moving player's king in check.
• The "clone, execute, check" strategy is a robust way to validate move legality without altering the actual game state.
• Rust's trait system (Clone) allows for easy implementation of this pattern.
• By integrating this logic into the game loop, you ensure that only valid moves are ever played.

Preview of the Next Lesson

Your game now correctly handles turn-by-turn play. But what happens when the game is over? In the next lesson, we will build on today's logic to integrate checkmate and stalemate detection to end the game appropriately.