reversi_client/

lib.rs

// reversi_client/src/lib.rs

use rand::Rng;
use std::io::{Read, Write};
use std::net::{SocketAddr, TcpStream};
use std::str::FromStr;
use thiserror::Error;

#[derive(Debug, Error)]
pub enum ReversiError {
    #[error("Connection error: {0}")]
    ConnectionError(String),
    #[error("IO error: {0}")]
    IoError(#[from] std::io::Error),
    #[error("Protocol error: {0}")]
    ProtocolError(String),
}

#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub struct Position {
    pub row: i8,
    pub col: i8,
}

// Directions: (dx, dy) for all 8 possible directions
const DIRECTIONS: [(i8, i8); 8] = [
            (-1, -1),
            (-1, 0),
            (-1, 1),
            (0, -1),
            (0, 1),
            (1, -1),
            (1, 0),
            (1, 1),
        ];

#[derive(Debug, Clone)]
pub struct Board {
    pub board: [[i8; 8]; 8],
}

#[derive(Debug, Clone)]
pub struct GameState {
    pub turn: i8,
    pub round: i32,
    pub t1: f32,
    pub t2: f32,
    pub board: [[i8; 8]; 8], // 0: empty, 1: player1, 2: player2
}

impl GameState {
    pub fn get_initial_state() -> Self {
        GameState {
            turn: 0,
            round: 0,
            t1: 0.0,
            t2: 0.0,
            board: [[0; 8]; 8],
        }
    }

    pub fn print_board(&self) {
        for row in &self.board {
            for &cell in row {
                print!("{} ", cell);
            }
            println!();
        }
    }

    fn get_valid_moves_first_4(&self) -> Vec<Position> {
        let mut moves = Vec::with_capacity(4);

        if self.board[3][3] == 0 {
            moves.push(Position { row: 3, col: 3 });
        }

        if self.board[3][4] == 0 {
            moves.push(Position { row: 3, col: 4 });
        }

        if self.board[4][3] == 0 {
            moves.push(Position { row: 4, col: 3 });
        }

        if self.board[4][4] == 0 {
            moves.push(Position { row: 4, col: 4 });
        }

        moves
    }

    pub fn get_valid_moves(&self, player_num: i8) -> Vec<Position> {
        if self.round < 4 { // TODO check if this should be a <= (aka, the server starts the game at round 1 vs 0)
            return self.get_valid_moves_first_4();
        }

        let mut moves: Vec<Position> = Vec::with_capacity(24);
        let opponent = 3 - player_num; // Player numbers are 1 or 2


        for (i, row) in self.board.iter().enumerate() {
            for (j, &cell) in row.iter().enumerate() {
                if cell != 0 {
                    continue;
                }

                'directions: for &(dx, dy) in &DIRECTIONS {
                    let mut x = i as i8 + dx;
                    let mut y = j as i8 + dy;
                    let mut found_opponent = false;

                    while x >= 0 && x < 8 && y >= 0 && y < 8 {
                        let current = self.board[x as usize][y as usize];

                        match current {
                            // Empty space, can't flank
                            0 => break,
                            // Found player's piece after opponent's
                            p if p == player_num => {
                                if found_opponent {
                                    moves.push(Position { row: i as i8, col: j as i8 });
                                    break 'directions;
                                }
                                break;
                            }
                            // Found opponent's piece
                            p if p == opponent => {
                                found_opponent = true;
                            }
                            _ => break,
                        }

                        x += dx;
                        y += dy;
                    }
                }
            }
        }

        moves
    }

    pub fn get_state_after_move(&self, position: Position, player_num: i8) -> GameState {
        #[cfg(debug_assertions)]
        {
            let valid_moves = self.get_valid_moves(player_num);
            debug_assert!(valid_moves.contains(&position), "Invalid move attempted: ({}, {}) is not valid", position.row, position.col);
        }
        let mut new_board = self.board.clone();
        new_board[position.row as usize][position.col as usize] = player_num;

        for &(dx, dy) in &DIRECTIONS {
            let mut x = position.row + dx;
            let mut y = position.col + dy;
            let mut found_opponent = false;

            'line: while x >= 0 && x < 8 && y >= 0 && y < 8 {
                let current = new_board[x as usize][y as usize];

                match current {
                    // Empty space, can't flank
                    0 => break 'line,
                    // Found player's piece after opponent's
                    p if p == player_num => {
                        if found_opponent {
                            // Flip the pieces
                            let mut flip_x = position.row + dx;
                            let mut flip_y = position.col + dy;

                            while flip_x < x || flip_y < y {
                                new_board[flip_x as usize][flip_y as usize] = player_num;

                                flip_x += dx;
                                flip_y += dy;
                            }
                        }
                        found_opponent = false;
                    }
                    // Found opponent's piece
                    p if p == 3 - player_num => {
                        found_opponent = true;
                    }
                    _ => break,
                }

                x += dx;
                y += dy;
            }
        }

        GameState {
            turn: 3 - self.turn, // Turn should be 1 or 2, so this switches them
            round: self.round + 1, // increment round
            t1: self.t1, // We'll ignore this for now
            t2: self.t2,
            board: new_board, // attach the new board
        }
    }
}

pub trait ReversiStrategy {
    fn choose_move(&self, game_state: &GameState, player_num: i8) -> Position;
}

pub struct RandomStrategy;

impl ReversiStrategy for RandomStrategy {
    fn choose_move(&self, game_state: &GameState, player_num: i8) -> Position {
        let mut rng = rand::thread_rng();
        let valid_moves = game_state.get_valid_moves(player_num);

        valid_moves[rng.gen_range(0..valid_moves.len())]
    }
}

#[derive(Debug)]
pub struct ReversiClient<S: ReversiStrategy> {
    stream: TcpStream,
    player_number: i8,
    strategy: S,
    game_state: GameState,
}

impl<S: ReversiStrategy> ReversiClient<S> {
    pub fn connect(
        server_addr: &str,
        player_number: i8,
        strategy: S,
    ) -> Result<Self, ReversiError> {
        let port = 3333 + player_number as i32;
        let addr = SocketAddr::from_str(&format!("{}:{}", server_addr, port))
            .map_err(|e| ReversiError::ConnectionError(e.to_string()))?;

        let mut stream = TcpStream::connect(addr)?;

        let mut buffer = [0u8; 1024];
        let mut bytes_read = stream.read(&mut buffer)?;

        while bytes_read == 0 {
            bytes_read = stream.read(&mut buffer)?;
        }

        let message = String::from_utf8_lossy(&buffer[..bytes_read]);

        let parts: Vec<&str> = message.split(' ').collect();
        println!("{:?}", parts);
        let server_player_number = parts[0].parse().unwrap_or(-1);
        let game_minutes = parts[1].trim().parse::<f32>().unwrap_or(0.0);
        println!("Playing a {} minute game", game_minutes);

        if player_number != server_player_number {
            return Err(ReversiError::ProtocolError(format!(
                "Player number mismatch: expected {}, got {}",
                player_number, server_player_number
            )));
        }

        Ok(ReversiClient {
            stream,
            player_number,
            strategy,
            game_state: GameState::get_initial_state(),
        })
    }

    pub fn run(&mut self) -> Result<(), ReversiError> {
        let mut buffer = [0u8; 1024];

        loop {
            let bytes_read = self.stream.read(&mut buffer)?;
            if bytes_read == 0 {
                return Err(ReversiError::ConnectionError("Connection closed".into()));
            }

            let message = String::from_utf8_lossy(&buffer[..bytes_read]);
            match self.parse_message(&message) {
                Ok(()) => {
                    println!("Parsed state!");
                    if self.game_state.turn == self.player_number {
                        let chosen_move = self.strategy.choose_move(&self.game_state, self.player_number);
                        self.send_move(&chosen_move)?;
                    }
                }
                Err(e) => {
                    println!("Failed to parse message: {}", e);
                }
            }
        }
    }

    fn parse_message(&mut self, message: &str) -> Result<(), ReversiError> {
        let parts: Vec<&str> = message.split('\n').collect();
        println!("{:?}", parts);
        let turn=  parts[0].parse::<i32>().unwrap_or(-1);
        if turn == -999 {
            println!("Game over");
            return Err(ReversiError::ProtocolError("Game over".into()));
        }

        if parts.len() < 69 {
            return Err(ReversiError::ProtocolError("Message was too short to contain the board".into()));
        }

        let mut board: [[i8; 8]; 8] = [[0; 8]; 8];
        let mut index = 4;
        for i in 0..8 {
            for j in 0..8 {
                board[i][j] = parts[index].parse().unwrap_or(0);
                index += 1;
            }
        }

        self.game_state = GameState {
            turn: turn as i8,
            round: parts[1].parse().unwrap_or(0),
            t1: parts[2].parse::<f32>().unwrap_or(0.0),
            t2: parts[3].parse::<f32>().unwrap_or(0.0),
            board: board
        };

        Ok(())
    }

    // fn get_valid_moves_first_4(&self, board: &[[i8; 8]; 8]) -> Vec<(i8, i8)> {
    //     let mut moves = Vec::with_capacity(4);

    //     if board[3][3] == 0 {
    //         moves.push((3, 3));
    //     }

    //     if board[3][4] == 0 {
    //         moves.push((3, 4));
    //     }

    //     if board[4][3] == 0 {
    //         moves.push((4, 3));
    //     }

    //     if board[4][4] == 0 {
    //         moves.push((4, 4));
    //     }

    //     moves
    // }

    // pub fn get_valid_moves(&self, board: &[[i8; 8]; 8], player: i8) -> Vec<(i8, i8)> {
    //     let mut moves: Vec<(i8, i8)> = Vec::with_capacity(24);
    //     let opponent = 3 - player; // Player numbers are 1 or 2

    //     // Directions: (dx, dy) for all 8 possible directions
    //     const DIRECTIONS: [(i8, i8); 8] = [
    //         (-1, -1),
    //         (-1, 0),
    //         (-1, 1),
    //         (0, -1),
    //         (0, 1),
    //         (1, -1),
    //         (1, 0),
    //         (1, 1),
    //     ];

    //     for (i, row) in board.iter().enumerate() {
    //         for (j, &cell) in row.iter().enumerate() {
    //             if cell != 0 {
    //                 continue;
    //             }

    //             'directions: for &(dx, dy) in &DIRECTIONS {
    //                 let mut x = i as i8 + dx;
    //                 let mut y = j as i8 + dy;
    //                 let mut found_opponent = false;

    //                 while x >= 0 && x < 8 && y >= 0 && y < 8 {
    //                     let current = board[x as usize][y as usize];

    //                     match current {
    //                         // Empty space, can't flank
    //                         0 => break,
    //                         // Found player's piece after opponent's
    //                         p if p == player => {
    //                             if found_opponent {
    //                                 moves.push((i as i8, j as i8));
    //                                 break 'directions;
    //                             }
    //                             break;
    //                         }
    //                         // Found opponent's piece
    //                         p if p == opponent => {
    //                             found_opponent = true;
    //                         }
    //                         _ => break,
    //                     }

    //                     x += dx;
    //                     y += dy;
    //                 }
    //             }
    //         }
    //     }

    //     moves
    // }

    fn send_move(&mut self, pos: &Position) -> Result<(), ReversiError> {
        let move_str = format!("{}\n{}\n", pos.row, pos.col);
        self.stream.write_all(move_str.as_bytes())?;
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use std::{net::TcpListener, thread};

    use super::*;

    fn create_mock_stream() -> TcpStream {
        let listener = TcpListener::bind("127.0.0.1:0").unwrap();
        let addr = listener.local_addr().unwrap();

        thread::spawn(move || {
            let (mut socket, _) = listener.accept().unwrap();
            let _ = socket.write_all(b"");
        });

        TcpStream::connect(addr).unwrap()
    }


    #[test]
    fn test_parse_message_valid() {
        let mut client = ReversiClient {
            stream: create_mock_stream(),
            player_number: 1,
            strategy: RandomStrategy,
            game_state: GameState::get_initial_state(),
        };

        let message = "1\n0\n0.0\n0.0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n0\n";
        client.parse_message(message).unwrap();

        assert_eq!(client.game_state.turn, 1);
        assert_eq!(client.game_state.round, 0);
        assert_eq!(client.game_state.t1, 0.0);
        assert_eq!(client.game_state.t2, 0.0);
        assert_eq!(client.game_state.board, [[0; 8]; 8]);
    }

    #[test]
    fn test_parse_message_invalid() {
        let mut client = ReversiClient {
            stream: create_mock_stream(),
            player_number: 1,
            strategy: RandomStrategy,
            game_state: GameState::get_initial_state(),
        };

        let message = "invalid\nmessage\n";
        let result = client.parse_message(message);

        assert!(result.is_err());
    }

    #[test]
    fn test_parse_message_game_over() {
        let mut client = ReversiClient {
            stream: create_mock_stream(),
            player_number: 1,
            strategy: RandomStrategy,
            game_state: GameState::get_initial_state(),
        };

        let message = "-999\n";
        let result = client.parse_message(message);
        if let Err(ReversiError::ProtocolError(ref e)) = result {
            assert_eq!(e, "Game over");
        } else {
            panic!("Expected ProtocolError with 'Game over'");
        }
    }

    #[test]
    fn test_get_valid_moves_first_4() {
        let client = ReversiClient {
            stream: create_mock_stream(),
            player_number: 1,
            strategy: RandomStrategy,
            game_state: GameState::get_initial_state(),
        };
    
        let valid_moves = client.game_state.get_valid_moves(1);
    
        assert_eq!(valid_moves, vec![
            Position { row: 3, col: 3 },
            Position { row: 3, col: 4 },
            Position { row: 4, col: 3 },
            Position { row: 4, col: 4 },
        ]);
    }

    #[test]
    fn test_get_valid_moves() {
        let mut client = ReversiClient {
            stream: create_mock_stream(),
            player_number: 1,
            strategy: RandomStrategy,
            game_state: GameState::get_initial_state(),
        };

        let mut board = [[0; 8]; 8];
        board[3][3] = 2;
        board[3][4] = 1;
        board[4][3] = 1;
        board[4][4] = 2;

        client.game_state.board = board;
        client.game_state.round = 5;

        let valid_moves = client.game_state.get_valid_moves(1);

        assert_eq!(valid_moves, vec![
            Position { row: 2, col: 3 },
            Position { row: 3, col: 2 },
            Position { row: 4, col: 5 },
            Position { row: 5, col: 4 },
        ]);
    }

    #[test]
    fn test_send_move() {
        let mut client = ReversiClient {
            stream: create_mock_stream(),
            player_number: 1,
            strategy: RandomStrategy,
            game_state: GameState::get_initial_state(),
        };

        let result = client.send_move(&Position{row: 3, col: 4});

        assert!(result.is_ok());
    }
}