reversi_client_rust

Description

This is a Rust library for a Reversi game client, specifically designed for BYU CS 470. It includes the ReversiClient struct, the GameState struct, and the ReversiStrategy trait, along with methods to manage game state and make moves.

Note, that this library is not a complete implementation of the Reversi game. It is designed to be used as a starting point for building a Reversi agent.

No support is provided or guaranteed by the TAs for anything here. Only use this if you know Rust, want to learn Rust, and are a strong programmer already. Pull requests are welcome.

Usage

use reversi_client::{ReversiClient, RandomStrategy, ReversiError};

fn main() -> Result<(), ReversiError> {
    let server_address = "127.0.0.1"; // Replace with your server address
    let player_number = 2; // Set the player number (1 or 2)
    let strategy = RandomStrategy; // Replace with your own strategy

    let mut client = ReversiClient::connect(server_address, player_number, strategy)?;
    client.run()?;

    Ok(())
}

API

ReversiClient

The client struct manages the connection to the server, game state, and applies the given strategy whenever a move is needed.

pub struct ReversiClient<S: ReversiStrategy> {
    stream: TcpStream,
    player_number: i8,
    strategy: S,
    game_minutes: f32,
    board: [[i8; 8]; 8],
}

Fields

connect()

ReversiClient::connect() - Connects to the server and initializes the game state, returns a client struct.

run()

ReversiClient::run() - Starts the game loop, handling incoming messages and making moves according to the strategy.

get_valid_moves()

ReversiClient::get_valid_moves() - Returns a vector of valid moves for a given player and board state.

ReversiStrategy

This trait defines the strategy for choosing moves in the game. You can implement your own strategy by creating a struct that implements this trait.

pub trait ReversiStrategy {
    fn choose_move(&self, valid_moves: &[(i8, i8)]) -> (i8, i8);
}

You can use the &self parameter of the choose_move() method to access the fields of your client and calculate the best move based on your own strategy.

For example consider the following strategy that chooses a random valid move:

pub struct RandomStrategy;

impl ReversiStrategy for RandomStrategy {
    fn choose_move(&self, valid_moves: &[(i8, i8)]) -> (i8, i8) {
        let mut rng = rand::thread_rng();
        valid_moves[rng.gen_range(0..valid_moves.len())]
    }
}