rock-paper-scissors-lizard-spock

name	Rock Paper Scissors Lizard Spock
description	Play the classic Rock Paper Scissors Lizard Spock game (popularized by The Big Bang Theory) with an AI opponent. Includes both decorated terminal and interactive GUI modes with score tracking, statistics, and animations.
version	1.0.0
author	AM (akm626)
tags	["game","entertainment","interactive","python","gui","terminal"]
requires	{"bins":["python3"],"packages":["rich"]}

Rock Paper Scissors Lizard Spock Game

An enhanced implementation of Rock Paper Scissors Lizard Spock with beautiful UI, statistics tracking, and multiple play modes.

Game Rules

Classic RPSLS Rules (from The Big Bang Theory):

• 🪨 Rock crushes Scissors and crushes Lizard
• 📄 Paper covers Rock and disproves Spock
• ✂️ Scissors cuts Paper and decapitates Lizard
• 🦎 Lizard eats Paper and poisons Spock
• 🖖 Spock smashes Scissors and vaporizes Rock

Each choice defeats exactly 2 others and loses to exactly 2 others.

Skill Capabilities

This skill provides three ways to play:

1. Decorated Terminal Mode - Beautiful ASCII art UI with colors and animations
2. Interactive GUI Mode - HTML/JavaScript artifact with click-based gameplay
3. Quick Play Mode - Single command for fast games

Usage

Start a Game

Terminal Mode (Recommended):

"Let's play Rock Paper Scissors Lizard Spock"
"Play RPSLS in terminal mode"
"Start a decorated RPSLS game"

GUI Mode:

"Show me the RPSLS GUI"
"Play RPSLS with a visual interface"
"Create an interactive RPSLS game"

Quick Commands

"Play rock" / "Choose rock" → Makes a move
"RPSLS stats" → View game statistics
"RPSLS rules" → Display game rules
"Best of 3" / "Best of 5" → Start tournament mode

Implementation

When the user requests to play Rock Paper Scissors Lizard Spock, follow these steps:

Step 1: Determine Mode

Ask which mode they prefer (or default to terminal if not specified):

• Terminal mode (decorated, colorful CLI)
• GUI mode (interactive HTML artifact)
• Quick play (single round)

Step 2: Create the Game

For Terminal Mode:

Create a Python script using rich library for beautiful terminal UI:

#!/usr/bin/env python3
"""
Rock Paper Scissors Lizard Spock - Decorated Terminal Edition
Beautiful ASCII art game with colors, animations, and statistics
"""

from rich.console import Console
from rich.table import Table
from rich.panel import Panel
from rich.text import Text
from rich.prompt import Prompt
from rich import box
import random
import json
import os
from datetime import datetime

console = Console()

# Game rules: what each choice defeats
DEFEATS = {
    "rock": {"scissors": "crushes", "lizard": "crushes"},
    "paper": {"rock": "covers", "spock": "disproves"},
    "scissors": {"paper": "cuts", "lizard": "decapitates"},
    "lizard": {"paper": "eats", "spock": "poisons"},
    "spock": {"scissors": "smashes", "rock": "vaporizes"}
}

# Emojis for choices
EMOJIS = {
    "rock": "🪨",
    "paper": "📄",
    : ,
    : ,
    : 
}


COLORS = {
    : ,
    : ,
    : ,
    : ,
    : 
}

 :
     ():
        .stats = .load_stats()
        .session_wins = 
        .session_losses = 
        .session_ties = 
        
     ():
        
        stats_file = os.path.expanduser()
         os.path.exists(stats_file):
            :
                 (stats_file, )  f:
                     json.load(f)
            :
                
         {
            : ,
            : ,
            : ,
            : ,
            : {choice:   choice  DEFEATS.keys()},
            : ,
            : 
        }
    
     ():
        
        stats_file = os.path.expanduser()
        :
             (stats_file, )  f:
                json.dump(.stats, f, indent=)
        :
            
    
     ():
        
        banner = 
        console.(banner, style=)
    
     ():
        
        rules_table = Table(title=, box=box.ROUNDED, style=)
        rules_table.add_column(, style=)
        rules_table.add_column(, style=)
        rules_table.add_column(, style=)
        
        rules_table.add_row(, , )
        rules_table.add_row(, , )
        rules_table.add_row(, , )
        rules_table.add_row(, , )
        rules_table.add_row(, , )
        
        console.(rules_table)
    
     ():
        
        stats_panel = Panel(
            ,
            border_style=,
            title=,
            expand=
        )
        console.(stats_panel)
    
     ():
        
        choices = (DEFEATS.keys())
        choice_display = .join([  c  choices])
        
        console.()
        
         :
            choice = Prompt.ask(
                ,
                choices=choices + [, , , ],
                default=
            ).lower()
            
             choice  [, ]:
                 
             choice == :
                .show_stats()
                
             choice == :
                .show_rules()
                
             choice  choices:
                 choice
    
     ():
        
         random.choice((DEFEATS.keys()))
    
     ():
        
         player_choice == computer_choice:
             , 
         computer_choice  DEFEATS[player_choice]:
            action = DEFEATS[player_choice][computer_choice]
             , action
        :
            
            action = DEFEATS[computer_choice][player_choice]
             , action
    
     ():
        
        console.()
        
        choice_table = Table(box=box.ROUNDED, show_header=)
        choice_table.add_column(, style=, width=)
        choice_table.add_column(, style=, width=, justify=)
        choice_table.add_column(, style=, width=)
        
        player_display = 
        computer_display = 
        
        choice_table.add_row(player_display, , computer_display)
        console.(choice_table)
    
     ():
        
         result == :
            console.(Panel(
                ,
                border_style=,
                expand=
            ))
         result == :
            console.(Panel(
                
                
                ,
                border_style=,
                expand=
            ))
        :
            console.(Panel(
                
                
                ,
                border_style=,
                expand=
            ))
    
     ():
        
        .stats[] += 
        .stats[][player_choice] += 
        
         result == :
            .stats[] += 
            .session_wins += 
            .stats[] += 
             .stats[] > .stats[]:
                .stats[] = .stats[]
         result == :
            .stats[] += 
            .session_losses += 
            .stats[] = 
        :
            .stats[] += 
            .session_ties += 
        
        .save_stats()
    
     ():
        
        console.(
                     
                     
                     )
    
     ():
        
        player_choice = .get_player_choice()
        
         player_choice  :
               
        
        console.()
        computer_choice = .get_computer_choice()
        
        .show_choices(player_choice, computer_choice)
        
        result, action = .determine_winner(player_choice, computer_choice)
        .show_result(result, action, player_choice, computer_choice)
        
        .update_stats(result, player_choice)
        .show_score()
        
           
    
     ():
        
        .show_banner()
        console.()
        
         :
              .play_round():
                
            
            console.()  
        
        
        console.()
        .show_stats()

 ():
    game = RPSLSGame()
    game.play()

 __name__ == :
    main()

Key Features:

• 🎨 Beautiful colored terminal UI with rich library
• 📊 Persistent statistics tracking
• 🏆 Win streak tracking
• 🎯 Choice frequency analysis
• 📋 In-game rules and stats display
• 💾 Stats saved to ~/.rpsls_stats.json

To run: Save as rpsls_terminal.py and execute with python3 rpsls_terminal.py

For GUI Mode:

Create an interactive HTML artifact:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Rock Paper Scissors Lizard Spock</title>
    <style>
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }
        
        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            min-height: 100vh;
            display: flex;
            justify-content: center;
            align-items: center;
            padding: 20px;
        }
        
        .game-container {
            background: white;
            border-radius: 20px;
            padding: ;
            :    (,,,);
            : ;
            : ;
        }
        
         {
            : center;
            : ;
            : ;
            : ;
        }
        
         {
            : center;
            : ;
            : ;
            : italic;
        }
        
         {
            : grid;
            : (auto-fit, (, fr));
            : ;
            :  ;
        }
        
         {
            : (,  ,  );
            : none;
            : ;
            :  ;
            : pointer;
            : all  ease;
            : white;
            : ;
            :    (,,,);
        }
        
         {
            : (-);
            :    (,,,);
        }
        
         {
            : (-);
        }
        
         {
            : block;
            : ;
            : ;
            : bold;
        }
        
         {
            :  ;
            : ;
        }
        
         {
            : ;
            : ;
            : ;
            : center;
            :  ;
        }
        
         {
            : none;
        }
        
         {
            : flex;
            : space-around;
            : center;
            :  ;
        }
        
         {
            : center;
        }
        
         {
            : ;
            : ;
        }
        
         {
            : ;
            : bold;
            : ;
        }
        
         {
            : ;
            : bold;
            : ;
        }
        
         {
            : ;
            : bold;
            :  ;
        }
        
         {
            : ;
        }
        
         {
            : ;
        }
        
         {
            : ;
        }
        
         {
            : ;
            : ;
            : ;
        }
        
         {
            : grid;
            : (, fr);
            : ;
            :  ;
        }
        
         {
            : (,  ,  );
            : white;
            : ;
            : ;
            : center;
        }
        
         {
            : ;
            : ;
        }
        
         {
            : ;
            : bold;
            : ;
        }
        
         {
            : flex;
            : ;
            : center;
            : ;
        }
        
         {
            :  ;
            : none;
            : ;
            : pointer;
            : ;
            : bold;
            : all  ease;
        }
        
         {
            : (,  ,  );
            : white;
        }
        
         {
            : ;
            : ;
            :  solid ;
        }
        
         {
            : (-);
            :    (,,,);
        }
        
         {
            : ;
            : ;
            : ;
            : ;
        }
        
          {
            : ;
            : ;
        }
        
          {
            : none;
            : ;
        }
        
          {
            :  ;
            : ;
        }
        
           {
            : ;
        }
        
         shake {
            ,  { : (); }
             { : (-); }
             { : (); }
        }
        
         {
            : shake  ease;
        }
    


    
        🎮 Rock Paper Scissors Lizard Spock
        "A game of strategic brilliance!" - Sheldon Cooper
        
        
            
                Wins
                0
            
            
                Losses
                0
            
            
                Ties
                0
            
        
        
        
            
                🪨
                Rock
            
            
                📄
                Paper
            
            
                ✂️
                Scissors
            
            
                🦎
                Lizard
            
            
                🖖
                Spock
            
        
        
        
            
                
                    
                    You
                
                VS
                
                    
                    Computer
                
            
            
            
        
        
        
            Play Again
            Reset Score
            Rules
        
        
        
            📋 Game Rules
            
                🪨 Rock crushes Scissors and crushes Lizard
                📄 Paper covers Rock and disproves Spock
                ✂️ Scissors cuts Paper and decapitates Lizard
                🦎 Lizard eats Paper and poisons Spock
                🖖 Spock smashes Scissors and vaporizes Rock
            
        
    
    
    

GUI Features:

• 🎨 Beautiful gradient design
• 🖱️ Click-based gameplay
• 📊 Real-time score tracking
• 🎭 Animated results
• 📱 Responsive design
• 📋 Built-in rules display

Step 3: Provide Instructions

After creating the game, provide clear instructions:

• How to make choices
• How to view stats/rules
• How to exit
• Tips for playing

Step 4: Support Follow-up Actions

Handle these common requests:

• "Play again" → Start new round
• "Show stats" → Display statistics
• "Reset score" → Clear session stats
• "Explain the rules" → Show rules table
• "What beats rock?" → Explain game logic

Game Strategy Tips

Share these tips with players:

• Each choice wins against exactly 2 others
• Computer choice is truly random (no pattern)
• Lizard and Spock add complexity to traditional RPS
• Mix up your choices - patterns are exploitable
• There's no "best" choice - it's balanced!

Advanced Features

Tournament Mode

For "best of N" requests:

def tournament(rounds=3):
    game = RPSLSGame()
    player_score = 0
    computer_score = 0
    
    for round_num in range(1, rounds + 1):
        console.print(f"\n[bold]Round {round_num} of {rounds}[/bold]")
        result = game.play_round()
        # Track tournament progress
    
    # Declare tournament winner

Adaptive AI

For advanced mode, create an AI that learns from player patterns:

class AdaptiveAI:
    def __init__(self):
        self.player_history = []
        self.pattern_length = 3
    
    def predict_next_move(self):
        if len(self.player_history) < self.pattern_length:
            return random.choice(choices)
        
        # Look for patterns in recent history
        recent = tuple(self.player_history[-self.pattern_length:])
        # Predict and counter

Troubleshooting

Issue: "rich" module not found

Solution: Install with pip install rich --break-system-packages

Issue: Stats file permission error

Solution: Stats save to ~/.rpsls_stats.json - ensure write permissions

Issue: Terminal doesn't show colors

Solution: Try running with FORCE_COLOR=1 python3 script.py

Example Interactions

Example 1: Quick Game

User: "Let's play rock paper scissors lizard spock"
Claude: [Creates terminal game script]
"I've created a beautiful terminal version of RPSLS! 
 Run it with: python3 rpsls_terminal.py
 
 Features:
 - Colored UI with emojis
 - Statistics tracking
 - Win streaks
 - In-game rules
 
 Just choose rock, paper, scissors, lizard, or spock!"

Example 2: GUI Request

User: "Show me a visual RPSLS game"
Claude: [Creates HTML artifact]
"Here's an interactive RPSLS game! Click any choice to play:
 🪨 Rock  📄 Paper  ✂️ Scissors  🦎 Lizard  🖖 Spock
 
 The computer will make its choice instantly and show the result!"

Example 3: Stats Request

User: "Show my RPSLS stats"
Claude: [Reads ~/.rpsls_stats.json]
"Your RPSLS Statistics:
 
 Total Games: 47
 Wins: 18 (38.3%)
 Losses: 21 (44.7%)
 Ties: 8 (17.0%)
 
 Best Streak: 5 wins
 Most Used: Rock (15 times)"

Notes for Claude

• Always ask which mode (terminal/GUI) unless user specifies
• For terminal mode, ensure rich is available or offer to install it
• For GUI mode, create as an HTML artifact (not a file)
• Include emojis and colors for better UX
• Save stats persistently for long-term tracking
• Explain the rules if user seems unfamiliar with RPSLS
• Make it fun and engaging! This is entertainment.

Credits

Based on the Rock Paper Scissors Lizard Spock game popularized by:

• The Big Bang Theory TV show (Sheldon Cooper's game)
• Original concept: Sam Kass and Karen Bryla
• Enhanced by: AM (akm626) for OpenClaw

Version History

• v1.0.0 (2026-04-03): Initial release with terminal and GUI modes