Build an AI Rock, Paper, Scissors Game: Step-by-Step Python Tutorial | AI Valley Tricity

pip install opencv-python mediapipe

A clean screenshot of a simple webcam feed opening on a computer screen showing a person waving.

import cv2

# Initialize the webcam (0 is usually the default laptop camera)
cap = cv2.VideoCapture(0)

# Set the width and height of our camera window for a high-definition view
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 1280)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 720)

print("Camera starting... Press 'q' to quit.")

while True:
    # Read the current frame (picture) from the webcam
    success, img = cap.read()
    
    # If the camera fails to grab a frame, skip to the next loop
    if not success:
        print("Failed to grab frame. Retrying...")
        continue
    
    # Flip the image horizontally (1) so it acts like a mirror
    # This makes it much less confusing when you move your hands!
    img = cv2.flip(img, 1)
    
    # Display the image in a window titled "AI Rock Paper Scissors"
    cv2.imshow("AI Rock Paper Scissors", img)
    
    # Wait for 1 millisecond; if 'q' is pressed, break out of the infinite loop
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# Release the camera hardware and close all GUI windows safely
cap.release()
cv2.destroyAllWindows()

A screenshot of a hand on a webcam feed with brightly colored Mediapipe digital nodes and connecting lines overlaid on the fingers.

import cv2
import mediapipe as mp

# Initialize Mediapipe Hand Tracking modules
mp_hands = mp.solutions.hands
# We set min_detection_confidence to 0.7 (70%) to avoid false positives
hands = mp_hands.Hands(max_num_hands=1, min_detection_confidence=0.7)
mp_draw = mp.solutions.drawing_utils

cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 1280)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 720)

while True:
    success, img = cap.read()
    if not success:
        continue
        
    img = cv2.flip(img, 1)
    
    # CRITICAL: Mediapipe requires RGB color format, but OpenCV natively uses BGR.
    # We must convert the image colors before the AI can process it.
    img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    
    # Process the frame to find hands
    results = hands.process(img_rgb)
    
    # If a hand is found, draw the 21 landmarks (joints) and connecting lines
    if results.multi_hand_landmarks:
        for hand_landmarks in results.multi_hand_landmarks:
            mp_draw.draw_landmarks(img, hand_landmarks, mp_hands.HAND_CONNECTIONS)
            
    cv2.imshow("AI Rock Paper Scissors", img)
    
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

A close-up diagram or screenshot showing a hand making a 'Scissors' gesture with an AI overlay classifying it as Scissors.

def detect_gesture(hand_landmarks):
    # The landmark IDs for the tips of the Index, Middle, Ring, and Pinky fingers
    tips = [8, 12, 16, 20]
    fingers_up = []
    
    # Check each finger: if the tip's y-coordinate is LESS than the joint below it,
    # the finger is extended (UP). 
    # Note: On computer screens, Y=0 is the TOP of the screen, so a smaller Y means HIGHER up.
    for tip in tips:
        if hand_landmarks.landmark[tip].y < hand_landmarks.landmark[tip - 2].y:
            fingers_up.append(1)  # Finger is UP
        else:
            fingers_up.append(0)  # Finger is DOWN
            
    total_up = sum(fingers_up)
    
    # Classify the gesture based on how many fingers are extended
    if total_up == 0:
        return "Rock"
    elif total_up == 4:
        return "Paper"
    # If exactly 2 fingers are up, AND they are the index (0) and middle (1) fingers:
    elif total_up == 2 and fingers_up[0] == 1 and fingers_up[1] == 1:
        return "Scissors"
    else:
        return "Unknown"

A visual representation showing game logic: a Python code snippet alongside icons of rock, paper, and scissors.

A complete screenshot of the working AI Rock Paper Scissors game showing the webcam feed, the digital hand landmarks, user score, computer score, and a 'You Win!' text overlay.

import cv2
import mediapipe as mp
import random

# --- AI Setup ---
mp_hands = mp.solutions.hands
hands = mp_hands.Hands(max_num_hands=1, min_detection_confidence=0.7)
mp_draw = mp.solutions.drawing_utils

# --- Camera Setup ---
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 1280)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 720)

# --- Game State Variables ---
user_score = 0
comp_score = 0
user_choice = "None"
comp_choice = "None"
result_text = "Press 'S' to Play!"
options = ["Rock", "Paper", "Scissors"]

# --- Gesture Brain ---
def detect_gesture(hand_landmarks):
    tips = [8, 12, 16, 20]
    fingers_up = []
    for tip in tips:
        if hand_landmarks.landmark[tip].y < hand_landmarks.landmark[tip - 2].y:
            fingers_up.append(1)
        else:
            fingers_up.append(0)
            
    total = sum(fingers_up)
    if total == 0: return "Rock"
    elif total == 4: return "Paper"
    elif total == 2 and fingers_up[0] == 1 and fingers_up[1] == 1: return "Scissors"
    return "Unknown"

# --- Main Video Loop ---
while True:
    success, img = cap.read()
    if not success: 
        continue
    
    img = cv2.flip(img, 1)
    img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    results = hands.process(img_rgb)

    current_gesture = "Unknown"

    if results.multi_hand_landmarks:
        for hand_landmarks in results.multi_hand_landmarks:
            mp_draw.draw_landmarks(img, hand_landmarks, mp_hands.HAND_CONNECTIONS)
            current_gesture = detect_gesture(hand_landmarks)

    # ---- UI TEXT OVERLAYS ----
    # Draw a black filled rectangle to make text highly readable
    cv2.rectangle(img, (10, 10), (850, 260), (0, 0, 0), cv2.FILLED)

    # Display current gesture detected in real-time
    cv2.putText(img, f"AI Sees: {current_gesture}", (20, 50), 
                cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)
    
    # Display the last locked-in battle
    cv2.putText(img, f"Battle: You ({user_choice}) vs Comp ({comp_choice})", (20, 110), 
                cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
    
    # Display the result (Win, Lose, Tie)
    cv2.putText(img, f"Result: {result_text}", (20, 170), 
                cv2.FONT_HERSHEY_SIMPLEX, 1.5, (0, 0, 255), 4)
                
    # Display the ongoing Score
    cv2.putText(img, f"SCORE -> You: {user_score} | Computer: {comp_score}", (20, 230), 
                cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 0), 2)

    cv2.imshow("AI Rock Paper Scissors", img)

    # ---- KEYBOARD CONTROLS & LOGIC ----
    key = cv2.waitKey(1) & 0xFF
    
    # If the 's' key is pressed, play a round!
    if key == ord('s'):
        if current_gesture in options:
            user_choice = current_gesture
            comp_choice = random.choice(options)
            
            # Classic Rock Paper Scissors Rules
            if user_choice == comp_choice:
                result_text = "It's a Tie!"
            elif (user_choice == "Rock" and comp_choice == "Scissors") or \
                 (user_choice == "Paper" and comp_choice == "Rock") or \
                 (user_choice == "Scissors" and comp_choice == "Paper"):
                result_text = "You Win!"
                user_score += 1
            else:
                result_text = "Computer Wins!"
                comp_score += 1
        else:
            result_text = "Make a valid gesture!"
            
    # If the 'q' key is pressed, quit the game
    if key == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()