Struct GameSettings 

pub struct GameSettings {
    pub first_to: u8,
}

GameSettings Struct

The GameSettings struct provides a simple yet flexible mechanism to configure the win conditions for a “Rock, Paper, Scissors” game session. It allows developers to define the number of wins required to declare an overall game winner.

Fields

• from_first_to
  • Specifies the number of round wins required for either the user or opponent to win the game.
  • This value defaults to 0 when initializing using GameSettings::new().

Methods

GameSettings::new()

Creates a new GameSettings instance with from_first_to set to 0. This can act as a placeholder until specific settings are defined.

use rock_paper_scissors::GameSettings;

let game_settings = GameSettings::new();
assert_eq!(game_settings.first_to, 1);

GameSettings::first_to_3()

Provides a predefined configuration where the game is set to end after 3 wins from either the user or the opponent.

use rock_paper_scissors::GameSettings;

let game_settings = GameSettings::from_first_to(3);
assert_eq!(game_settings.first_to, 3);

Examples

Using Custom Win Conditions

Developers can define their own win conditions by directly instantiating the GameSettings struct:

use rock_paper_scissors::GameSettings;

let custom_game_settings = GameSettings {
    first_to: 5,
};

assert_eq!(custom_game_settings.first_to, 5);

Combining with Scores

The GameSettings struct is designed to work seamlessly with the Scores struct to determine if a game session has reached its end:

use rock_paper_scissors::{Scores, GameSettings, Winner};

let game_settings = GameSettings::from_first_to(3);
let mut scores = Scores::new();

// Simulate some rounds
scores.user_wins = 3;

// Check for game winner
let winner = scores.check_for_winner(&game_settings);
assert_eq!(winner, Ok(Winner::User));

Fields

first_to: u8

Implementations

impl GameSettings

pub fn new() -> GameSettings

Creates a new game configuration with the default from_first_to value of 1.

Examples

use rock_paper_scissors::GameSettings;

let settings = GameSettings::new();
assert_eq!(settings.first_to, 1);

pub fn from_user_input() -> Result<GameSettings, &'static str>

The from_user_input method allows users to customize the game settings by providing input for the first_to win condition. The number entered defines how many victories are required to declare a winner in the game session.

Description

• This function prompts the user to input a number (representing the target win count).
• It validates the input to ensure it’s a valid positive integer (u8).
• If the input is valid, it returns a GameSettings instance with the first_to property set to the input value.
• In case of invalid input, such as non-numeric values or parsing errors, it returns an error message.

Behavior

• Reads a line of input from the console.
• Tries to parse the trimmed input into a u8 number.
• If parsing succeeds:
  • The parsed number is assigned to the first_to field of the GameSettings struct.
  • Returns Ok(GameSettings).
• If parsing fails:
  • Returns an error with a descriptive message (e.g., "Invalid input. Please enter a number.").

Use Case

This method is designed to make game initialization interactive by letting users define the win condition directly from the console. For example, users can adjust how many game rounds they need to win to end the game.

Examples

Correct Input

When valid input is provided:

use rock_paper_scissors::GameSettings;

// Simulating valid user input:
// Let's say user enters "5" (first to 5 wins).
// let game_settings = GameSettings::from_user_input();
// returns the following:
let game_settings: Result<GameSettings, &'static str> = Ok(GameSettings {
    first_to: 5,
});
match game_settings {
    Ok(settings) => assert_eq!(settings.first_to, 5),
    Err(_) => panic!("This should not happen for valid input"),
}

Invalid Input

Example of invalid

Examples found in repository

examples/configurable.rs (line 10)

fn main() {
    let mut scores = Scores::new();

    println!("Welcome to the Rock-Paper-Scissors game!");
    println!("Please enter what you want to play to: ");

    let game_settings = loop {
        match GameSettings::from_user_input() {
            Ok(game_settings) => break game_settings,
            Err(err) => println!("Error: {}", err),
        }
    };

    println!();
    let mut round_counter = 0;
    while scores.check_for_winner(&game_settings).is_err() {
        round_counter += 1;
        println!("Round {}:", round_counter);
        let player_moves = PlayerMoves::build_from_input();
        println!();
        println!("User: {}", player_moves.user_move.convert_to_string());
        println!("Enemy: {}", player_moves.enemy_move.convert_to_string());

        let round_winner = player_moves.check_who_wins_round();
        println!();
        match round_winner {
            Winner::Tie => {
                println!("Tie!");
                round_counter -= 1
            },
            Winner::User => {
                println!("User win");
                scores.user_wins += 1;
            },
            Winner::Enemy => {
                println!("Enemy win");
                scores.enemy_wins += 1;
            }
        }

        println!("Current Scores -> User: {} :: Enemy: {}", scores.user_wins, scores.enemy_wins);
    }

    let game_winner = scores.check_for_winner(&game_settings).unwrap(); // can use unwrap here because the while loop
    // will only break if the return is Ok()


    println!("Game Winner: {}", game_winner.convert_to_string());
}

pub fn from_first_to(first_to: u8) -> GameSettings

Prebuilt configuration where the first player to win 3 rounds is declared the winner.

Examples

use rock_paper_scissors::GameSettings;

let settings = GameSettings::from_first_to(3);
assert_eq!(settings.first_to, 3);

Examples found in repository

examples/interactive.rs (line 6)

fn main() {
    let mut scores = Scores::new();

    let game_settings = GameSettings::from_first_to(3);

    println!("Welcome to Rock-Paper-Scissors!");

    // Game loop
    while scores.check_for_winner(&game_settings).is_err() {
        let player_moves = PlayerMoves::build_from_input();

        let round_winner = player_moves.check_who_wins_round();
        println!(
            "You chose {}. Enemy chose {}.",
            player_moves.user_move.convert_to_string(),
            player_moves.enemy_move.convert_to_string(),
        );
        println!("Result: {}", round_winner.convert_to_string());

        // Update scores
        match round_winner {
            Winner::User => scores.user_wins += 1,
            Winner::Enemy => scores.enemy_wins += 1,
            Winner::Tie => (),
        }

        println!(
            "Current Scores -> You: {}, Enemy: {}",
            scores.user_wins, scores.enemy_wins
        );
    }

    // Display final results
    let game_winner = scores.check_for_winner(&game_settings).unwrap();
    println!("Game over! {}", game_winner.convert_to_string());
}

examples/loop.rs (line 5)

fn main() {
    let game_settings = GameSettings::from_first_to(3);

    let mut scores = Scores::new();

    let mut round_counter = 0;

    loop {
        round_counter += 1;
        let player_moves = PlayerMoves::build_from_input();

        let winner = player_moves.check_who_wins_round();

        match winner {
            Winner::User => {
                scores.user_wins += 1;
                println!("User wins round {}", round_counter)

            },
            Winner::Enemy => {
                scores.enemy_wins += 1;
                println!("Enemy wins round {}", round_counter)
            },
            Winner::Tie => {
                println!("It's a tie! Replaying round {}...", round_counter);
                round_counter -= 1;
            },
        }

        if let Ok(winner) = scores.check_for_winner(&game_settings) {
            println!("Game Over! Winner: {}", winner.convert_to_string());
            println!();
            println!("Final Scores:");
            println!("    User: {}", scores.user_wins);
            println!("    Enemy: {}", scores.enemy_wins);
            break;
        }
    }
}

examples/colored.rs (line 8)

fn main() {
    println!("{}", "Welcome to rock paper scissors!".blue().bold());

    // create game_settings struct with 3.
    let game_settings = GameSettings::from_first_to(3);

    println!("{}", "Game will be first to 3 rounds.".blue().bold());

    let mut scores = Scores::new(); // instantiate Scores struct

    let mut round_counter = 0;

    while scores.check_for_winner(&game_settings).is_err() { // checking to see if there has been a winner yet.
        round_counter += 1;
        let player_moves = PlayerMoves::build_from_input(); // build a PlayerMoves struct from input
        let round_winner = player_moves.check_who_wins_round(); // check who wins round based on moves.

        println!(
            "{}{}{}",
            "-----Round ".magenta(),
            round_counter.to_string().magenta(),
            "-----".magenta()
        );

        println!(
            "{}{}{}{}{}",
            "User: ".italic(),
            player_moves.user_move.convert_to_string().italic(),
            " :: ".italic(),
            "Enemy: ".italic(),
            player_moves.enemy_move.convert_to_string().italic()
        );


        match round_winner {
            Winner::Tie => {
                println!("{}", "It's a tie!".blue());
                round_counter -= 1;
            },
            Winner::User => {
                println!("{}", "You win!".green());
                scores.user_wins += 1;
            },
            Winner::Enemy => {
                println!("{}", "Enemy wins!".red());
                scores.enemy_wins += 1;
            }
        }

        // print scores
        println!("{}", "[Scores]".magenta().bold());
        println!("{}{}", "User: ".magenta(), scores.user_wins.to_string().magenta());
        println!("{}{}", "Enemy: ".magenta(), scores.enemy_wins.to_string().magenta());
    }


    if scores.check_for_winner(&game_settings) == Ok(Winner::User) {
        println!("{}", "You won the game!".green());
    } else {
        println!("{}", "You lost the game!".red());
    }

}

Trait Implementations

impl Debug for GameSettings

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for GameSettings

fn eq(&self, other: &GameSettings) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for GameSettings