Enum MoveType 

pub enum MoveType {
    Rock,
    Paper,
    Scissors,
    None,
}

MoveType Enum

Represents the possible moves in the game, providing safety and clarity in game logic. Now includes a None variant for uninitialized or invalid move states.

Variants

• MoveType::Rock: The “Rock” move.
• MoveType::Paper: The “Paper” move.
• MoveType::Scissors: The “Scissors” move.
• MoveType::None: A default state to handle uninitialized or invalid moves.

Key Features

• Randomized Moves: Generates a random move using random_move().
• String Conversion: Converts moves to a user-friendly String using convert_to_string().
• Controlled User Input: Converts valid input into a MoveType using from_user_input().

Examples

Create a MoveType

use rock_paper_scissors::MoveType;

let move_type = MoveType::Rock;
assert_eq!(move_type.convert_to_string(), "Rock");

Generate a Random Move

use rock_paper_scissors::MoveType;

let random_move = MoveType::random_move();
assert!(matches!(random_move, MoveType::Rock | MoveType::Paper | MoveType::Scissors));

Handle Uninitialized Moves

The None variant is helpful when moves are not immediately set:

use rock_paper_scissors::MoveType;

let move_type = MoveType::None;
assert_eq!(move_type.convert_to_string(), "None");

Convert User Input

use rock_paper_scissors::MoveType;

println!("Enter your move: 1 (Rock), 2 (Paper), or 3 (Scissors)");
let user_move = MoveType::from_user_input();

match user_move {
    Ok(move_type) => println!("You chose: {}", move_type.convert_to_string()),
    Err(err) => println!("Error: {}", err),
}

Variants

Rock

Paper

Scissors

None

Implementations

impl MoveType

pub fn random_move() -> MoveType

Generates a random MoveType (one of Rock, Paper, or Scissors).

Examples

use rock_paper_scissors::MoveType;

let random_move = MoveType::random_move();
assert!(matches!(random_move, MoveType::Rock | MoveType::Paper | MoveType::Scissors));

Examples found in repository

examples/sim.rs (line 11)

fn main() {
    let loops: u8 = 255;

    let mut scores = Scores::new();

    let mut player_moves = PlayerMoves::new();

    for _ in 0..=loops {
        (player_moves.user_move, player_moves.enemy_move) = (MoveType::random_move(), MoveType::random_move());

        let winner = player_moves.check_who_wins_round();

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

    println!("{:?}", scores);
}

pub fn convert_to_string(&self) -> String

Converts the MoveType to a human-readable String.

Examples

use rock_paper_scissors::MoveType;

let move_type = MoveType::Scissors;
assert_eq!(move_type.convert_to_string(), "Scissors");

Examples found in repository

examples/interactive.rs (line 17)

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/configurable.rs (line 23)

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());
}

examples/colored.rs (line 31)

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());
    }

}

pub fn from_user_input() -> Result<MoveType, String>

Gets the User’s Move

Handles user input from the console, validates it, and converts it into a MoveType.

The user is prompted to enter a number corresponding to their move:

• 1 for Rock
• 2 for Paper
• 3 for Scissors

The function will ensure valid input by repeatedly asking for input until a valid value is provided.

Examples

use rock_paper_scissors::MoveType;

println!("Enter your move: (1 = Rock, 2 = Paper, 3 = Scissors)");
let user_move = MoveType::from_user_input();

assert!(matches!(user_move, Ok(MoveType::Rock) | Ok(MoveType::Paper) | Ok(MoveType::Scissors)));

Behavior

When the user provides invalid input (e.g., letters or numbers outside the valid range), the function will re-prompt for valid input until it is received

Trait Implementations

impl Debug for MoveType

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

Formats the value using the given formatter.

impl PartialEq for MoveType

fn eq(&self, other: &MoveType) -> 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 MoveType