Simple Rock, Paper, Scissors Game

Introduction:

The Rock Paper Scissors game is a classic hand-based strategy game traditionally
played between two participants. This Python implementation transforms the
physical game into a digital, interactive experience, where the player competes
against a computer opponent in a best-of-five match format.

Key Features

 Interactive Terminal-Based Gameplay – Simple text interface for ease of

use.
 Randomized Computer Opponent – Uses Python’s random module for fair
play.
 Score Tracking System – First player to 5 wins claims victory.
 Input Validation – Ensures only valid moves (rock, paper, scissors) are
accepted.
 Play-Again Option – Allows replaying full matches without restarting the
program.

Game Rules & Logic

2.1 Traditional Rules

The game follows the standard rules:

- Rock crushes Scissors (Rock wins)

- Scissors cut Paper (Scissors win)
- Paper covers Rock (Paper wins)

- Tie occurs if both players choose the same move.

2.2 Digital Implementation

- This version enhances the game with:

- Best-of-5 Matches: The first to win 5 rounds wins the match.

- Dynamic Score Updates: Displays real-time scores after each round.

- Quit Option ('q'): Allows players to exit mid-game.

3. Technical Implementation

3.1 Core Mechanics

Component Description

User Input Handling Validates player moves and prevents crashes.

Computer AI Uses random.choice() for unbiased decisions.

Win Condition Checker Compares moves and updates scores.

Match Loop Runs until a player reaches 5 wins.

3.2 Code Structure

The game is built using modular functions:

- get_user_choice() – Gets and validates player input.

- get_computer_choice() – Generates a random move for the computer.
- determine_winner() – Decides the winner of each round.
- play_match() – Manages the full best-of-5 match.
- main() – Controls the game loop and restart option.

1. Core Python Components

1.1 Functions
 Definition: Reusable blocks of code that perform specific tasks

Usage in Game:
def get_user_choice():
# Gets and validates user input
while True:
user_choice = input("Choose rock, paper, or scissors: ").lower()
if user_choice in ['rock', 'paper', 'scissors']:
return user_choice
print("Invalid choice. Please try again.")

- Purpose: Encapsulate game logic into modular units

- Advantages: Improves code readability and reusability

1.2 Conditional Statements

- Types Used:

if
elif
else

- Game Implementation:
if user_choice == computer_choice:
return "tie"
elif (user_choice == 'rock' and computer_choice == 'scissors') or \
(user_choice == 'paper' and computer_choice == 'rock') or \
(user_choice == 'scissors' and computer_choice == 'paper'):
return "user"
else:
return "computer"

- Purpose: Determine game outcomes based on rules

- Logic Flow: Compares user and computer choices
1.3 Loops

While Loops:

while user_score < 5 and computer_score < 5:

# Game round logic

- Purpose: Continue game until win condition met

- Exit Condition: Either player reaches 5 points

Infinite Loop with Break:

while True:
# Main game loop
play_again = input("Play again? (y/n): ")
if play_again != 'y':
break
2. Python Standard Library Modules
2.1 random Module

Import Statement:
python
Copy
import random
Key Function Used:

python
Copy
random.choice(['rock', 'paper', 'scissors'])

- Purpose: Generate computer's random move

- Behavior: Selects uniformly from options
2.2 Built-in Functions
input():

python
Copy
user_choice = input("Choose rock, paper, or scissors: ")
Purpose: Get player input

String Handling: .lower() for case normalization

print():

print(f"You chose: {user_choice}")

Purpose: Display game information

Formatting: f-strings for variable interpolation

3. Data Structures
3.1 Lists
Usage Examples:

['rock', 'paper', 'scissors'] # Valid choices

Purpose: Store collections of related items

Operations: Membership testing with in keyword

3.2 Dictionaries (Potential Enhancement)

Suggested Use:

win_conditions = {
'rock': 'scissors',
'paper': 'rock',
'scissors': 'paper'
}
Advantage: More maintainable win logic

4. Program Control Flow

4.1 Main Game Loop
def main():
while True: # Outer loop for multiple matches
play_match()
if not play_again():
break

Components:

- Match Loop: play_match() handles individual matches

- Restart Logic: play_again() prompts for continuation

4.2 Function Chaining

mermaid
graph TD
A[main()] --> B[play_match()]
B --> C[get_user_choice()]
B --> D[get_computer_choice()]
B --> E[determine_winner()]
B --> F[update_score()]

- Flow: Hierarchical function calls

- Benefit: Separation of concerns

5. Error Handling
5.1 Input Validation
while True:
choice = input("Your choice: ").lower()
if choice in valid_options:
return choice
print("Invalid input!")

- Mechanism: Infinite loop until valid input

- Robustness: Prevents program crashes

5.2 Potential Enhancements

try:
user_choice = input("Choice: ")
except KeyboardInterrupt:
print("\nGame exited by user")
sys.exit(0)

- Suggested Improvement: Handle forced exits

6. Variable Types and Scope

6.1 Variable Types Used

Strings: Store text data ('rock', 'paper')

- Integers: Track scores (user_score = 0)

- Booleans: Control flow (play_again == 'y')

6.2 Scope Management

Local Variables: Confined to functions

def play_match():
user_score = 0 # Local to function

- Global Avoidance: Prevents side effects

7. String Manipulation
7.1 Key Operations
Case Conversion:

user_choice.lower()
String Formatting:

print(f"Score: {user_score}-{computer_score}")
8. Program Structure Best Practices
8.1 Modular Design

Separation of:
- User input handling
- Game logic
- Display/output

- Benefits:

- Easier debugging
- Simple enhancements

8.2 Entry Point Convention

if __name__ == "__main__":
main()

- Purpose: Prevent execution when imported

 - Pythonic Practice: Standard script structure

Code:

import random

def get_user_choice():
"""Get and validate user input"""
while True:
user_choice = input("Choose rock, paper, or scissors (or 'q' to quit): ").lower()
if user_choice in ['rock', 'paper', 'scissors', 'q']:
return user_choice
print("Invalid choice. Please try again.")

def get_computer_choice():
"""Generate random computer choice"""
return random.choice(['rock', 'paper', 'scissors'])

def determine_winner(user, computer):

"""Determine the round winner"""
if user == computer:
return "tie"
elif (user == 'rock' and computer == 'scissors') or \
(user == 'paper' and computer == 'rock') or \
(user == 'scissors' and computer == 'paper'):
return "user"
else:
return "computer"
def play_match():
"""Play a best-of-5 match"""
user_score = 0
computer_score = 0
round_num = 1

print("\n=== New Match (First to 5 wins) ===")

while user_score < 5 and computer_score < 5:

print(f"\n--- Round {round_num} ---")
print(f"Current Score - You: {user_score} | Computer: {computer_score}")

user_choice = get_user_choice()
if user_choice == 'q':
return None

computer_choice = get_computer_choice()

print(f"\nYou chose: {user_choice}")

print(f"Computer chose: {computer_choice}")

result = determine_winner(user_choice, computer_choice)

if result == "tie":
print("It's a tie! No points awarded.")
elif result == "user":
print("You win this round!")
user_score += 1
else:
print("Computer wins this round!")
computer_score += 1

round_num += 1
 # Match conclusion
print("\n=== Match Result ===")
print(f"Final Score - You: {user_score} | Computer: {computer_score}")
if user_score == 5:
print("Congratulations! You won the match!")
else:
print("Computer won the match. Better luck next time!")

return True

def main():
"""Main game function"""
print("Welcome to Rock, Paper, Scissors - Best of 5!")
print("--------------------------------------------")

while True:
match_result = play_match()

if match_result is None: # User quit mid-match

print("\nMatch abandoned. Thanks for playing!")
break

play_again = input("\nPlay another full match? (y/n): ").lower()

if play_again != 'y':
print("\nThanks for playing!")
break

if __name__ == "__main__":
main()
OUTPUT:

Conclusion:

This implementation demonstrates proper use of:

- Fundamental Python syntax
 - Control structures
- Standard library features
- Program design principles

The game serves as an excellent example of how basic Python components can
combine to create interactive applications while following software engineering
best practices. Each element has been carefully selected to fulfill specific game
requirements while maintaining code clarity and extensibility.