CHESS IN RUST

// src/piece.rs
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum Color {
    White,
    Black,
}

#[derive(Clone, Copy, Debug, PartialEq)]
pub enum Type {
    Pawn,
    Rook,
    Knight,
    Bishop,
    Queen,
    King,
}

#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Figure {
    pub color: Color,
    pub ty: Type,
}

// src/board.rs
pub type Board = [[Option<Figure>; 8]; 8];

pub fn create_starting_board() -> Board {
    let mut board = [[None; 8]; 8];
    for i in 0..8 {
        let figures: [Type; 8] = [
            Type::Rook, Type::Knight, Type::Bishop, Type::Queen,
            Type::King, Type::Bishop, Type::Knight, Type::Rook,
        ];
        board[0][i] = Some(Figure { color: Color::White, ty: figures[i] });
        board[1][i] = Some(Figure { color: Color::White, ty: Type::Pawn });
        board[6][i] = Some(Figure { color: Color::Black, ty: Type::Pawn });
        board[7][i] = Some(Figure { color: Color::Black, ty: figures[i] });
    }
    board
}

// Generowanie wszystkich ruchów dla skoczka z użyciem offsetów:
if figure.ty == Type::Knight {
    let knight_offsets: [isize; 9] = [2, -1, -2, 1, -2, -1, 2, 1, 2];
    for i in 0..8 {
        let x = start[0] as isize + knight_offsets[i];
        let y = start[1] as isize + knight_offsets[i + 1];
        if (0..8).contains(&x) && (0..8).contains(&y) {
            let target = [x as usize, y as usize];
            if board[target[1]][target[0]].is_none() || is_enemy_piece_at(board, start, target) {
                options.push([x as usize, y as usize]);
            }
        }
    }
}

// Promienie gońca (Bishop) - raycasting po 4 przekątnych:
if figure.ty == Type::Bishop {
    let bishop_offsets: [[isize; 2]; 4] = [[-1, 1], [1, 1], [1, -1], [-1, -1]];
    for [dx, dy] in bishop_offsets {
        for distance in 1..8 {
            let x = start[0] as isize + distance as isize * dx;
            let y = start[1] as isize + distance as isize * dy;
            if (0..8).contains(&x) && (0..8).contains(&y) {
                if board[y as usize][x as usize].is_none() {
                    options.push([x as usize, y as usize]);
                } else {
                    if is_enemy_piece_at(board, start, [x as usize, y as usize]) {
                        options.push([x as usize, y as usize]);
                    }
                    break;
                }
            } else { break; }
        }
    }
}

// Sprawdzenie czy dany ruch piona to bicie w przelocie:
let is_en_passant = figure.ty == Type::Pawn
    && en_passant == Some(direction)
    && position[0] != direction[0]
    && board[direction[1]][direction[0]].is_none();

if is_en_passant {
    // Usunięcie zbijanego piona z linii przelotu:
    board[position[1]][direction[0]] = None;
}

board[direction[1]][direction[0]] = board[position[1]][position[0]];
board[position[1]][position[0]] = None;

// Rejestracja pola En Passant po podwójnym kroku piona:
en_passant = if figure.ty == Type::Pawn && position[1].abs_diff(direction[1]) == 2 {
    Some([position[0], (position[1] + direction[1]) / 2])
} else {
    None
};

// Krótka roszada: król (e -> g), wieża (h -> f)
if castle[rights]
    && board[home][5].is_none()
    && board[home][6].is_none()
    && board[home][7] == Some(Figure { color: figure.color, ty: Type::Rook })
{
    let mut transit = *board;
    transit[home][4] = None;
    transit[home][5] = Some(figure);
    
    let mut destination = *board;
    destination[home][4] = None;
    destination[home][6] = Some(figure);
    
    let side = if figure.color == Color::White { 0 } else { 1 };
    // Król NIE MOŻE przejść przez szach ani wejść w szach:
    if !is_king_in_check(&transit, side) && !is_king_in_check(&destination, side) {
        options.push([6, home]);
    }
}

// Rollback nielegalnego ruchu (gracz nie może wejść pod szach):
if is_king_in_check(&board, turn) {
    board = board_save;
    println!("Illegal move");
} else {
    promotion(&mut board, turn);
    update_castling_rights(&mut castle, figure, position, direction);
    turn += 1;
    
    // Sprawdzenie warunków końca partii:
    if is_king_in_check(&board, turn) && !has_any_legal_moves(&board, turn, castle, en_passant) {
        println!("{:?} player wins", color_for_turn(turn - 1));
        break 'game;
    } else if !is_king_in_check(&board, turn) && !has_any_legal_moves(&board, turn, castle, en_passant) {
        println!("stalemate");
        break 'game;
    }
}

// Parsowanie notacji szachowej ("e2" -> [4, 1]):
pub fn parse_square(code: &str) -> [usize; 2] {
    let letters: Vec<&str> = code.split("").filter(|s| !s.is_empty()).collect();
    let mut first: usize = 0;
    for i in 0..8 {
        let arr = ["a", "b", "c", "d", "e", "f", "g", "h"];
        if letters[0] == arr[i] {
            first = i;
        }
    }
    [first, letters[1].parse::<usize>().unwrap() - 1]
}

// Promocja piona na ostatniej linii:
pub fn promotion(board: &mut [[Option<Figure>; 8]; 8], turn: i32) {
    let current_color = color_for_turn(turn);
    let promotion_row = match current_color {
        Color::White => 7,
        Color::Black => 0,
    };
    for col in 0..8 {
        if let Some(piece) = board[promotion_row][col] && piece.ty == Type::Pawn {
            println!("Promote pawn at column {} (Knight, Bishop, Queen, Rook):", col + 1);
            // Odczyt ze standardowego wejścia io::stdin().read_line(...)
        }
    }
}