Add secret mode to Rock Paper Scissors game with additional options

Author: chrisreddington

cmd/rockpaperscissors.go

@@ -13,6 +13,8 @@ import (
 	"github.com/spf13/cobra"
 )
 
+var secretMode bool
+
 // rootCmd represents the base command when called without any subcommands
 var rockPaperScissorsCmd = &cobra.Command{
 	Use:   "rockpaperscissors",
@@ -21,6 +23,11 @@ var rockPaperScissorsCmd = &cobra.Command{
 You can choose from rock, paper, or scissors. The computer will randomly choose its move and the winner will be determined based on the rules of the game.`,
 	Run: func(cmd *cobra.Command, args []string) {
 		input := userPrompt.New(os.Stdin, os.Stdout, os.Stderr)
-		rockpaperscissors.PlayGame(input)
+		rockpaperscissors.PlayGame(input, secretMode)
 	},
 }
+
+func init() {
+	rockPaperScissorsCmd.Flags().BoolVar(&secretMode, "spock", false, "Enable secret game mode")
+	rootCmd.AddCommand(rockPaperScissorsCmd)
+}

internal/rockpaperscissors/rockpaperscissors.go

@@ -9,7 +9,8 @@ import (
 
 // Game options
 var (
-	options = []string{"rock", "paper", "scissors", "exit"}
+	standardOptions = []string{"rock", "paper", "scissors", "exit"}
+	secretOptions   = []string{"rock", "paper", "scissors", "lizard", "spock", "exit"}
 )
 
 // Game represents a single game of Rock Paper Scissors.
@@ -32,14 +33,16 @@ type Game struct {
 	GameOverMessage string
 	// GamesPlayed tracks the number of games played
 	GamesPlayed int
+	// SecretMode indicates if the game is in secret mode
+	SecretMode bool
 }
 
 // Prompter defines an interface for getting user input
 type Prompter interface {
 	Select(prompt, defaultValue string, options []string) (int, error)
 }
 
-func NewGame(bestOf int) *Game {
+func NewGame(bestOf int, secretMode bool) *Game {
 	if bestOf%2 == 0 {
 		bestOf++ // Ensure we have an odd number for "best of"
 	}
@@ -53,6 +56,7 @@ func NewGame(bestOf int) *Game {
 		BestOf:          bestOf,
 		GameOver:        false,
 		GameOverMessage: "",
+		SecretMode:      secretMode,
 	}
 }
 
@@ -78,6 +82,10 @@ func (g *Game) Play(playerChoice string) {
 // getComputerChoice returns the choice made by the computer.
 func (g *Game) getComputerChoice() string {
 	rand.Seed(time.Now().UnixNano())
+	options := standardOptions
+	if g.SecretMode {
+		options = secretOptions
+	}
 	// Only use the game options excluding "exit"
 	choices := options[:len(options)-1]
 	return choices[rand.Intn(len(choices))]
@@ -88,10 +96,19 @@ func (g *Game) getWinner() string {
 	if g.PlayerChoice == g.ComputerChoice {
 		return "draw"
 	}
-	if (g.PlayerChoice == "rock" && g.ComputerChoice == "scissors") ||
-		(g.PlayerChoice == "paper" && g.ComputerChoice == "rock") ||
-		(g.PlayerChoice == "scissors" && g.ComputerChoice == "paper") {
-		return "player"
+
+	winningMoves := map[string][]string{
+		"rock":     {"scissors", "lizard"},
+		"paper":    {"rock", "spock"},
+		"scissors": {"paper", "lizard"},
+		"lizard":   {"paper", "spock"},
+		"spock":    {"rock", "scissors"},
+	}
+
+	for _, beatenChoice := range winningMoves[g.PlayerChoice] {
+		if g.ComputerChoice == beatenChoice {
+			return "player"
+		}
 	}
 	return "computer"
 }
@@ -143,7 +160,7 @@ func (g *Game) getRoundResultMessage() string {
 }
 
 // PlayGame plays a game of Rock Paper Scissors.
-func PlayGame(prompter Prompter) {
+func PlayGame(prompter Prompter, secretMode bool) {
 	// Get the number of rounds from the user
 	roundOptions := []string{"3", "5", "7", "9"}
 	roundIndex, err := prompter.Select("How many rounds would you like to play (best of)?", "3", roundOptions)
@@ -156,12 +173,20 @@ func PlayGame(prompter Prompter) {
 		bestOf = parseInt(roundOptions[roundIndex])
 	}
 
-	game := NewGame(bestOf)
+	game := NewGame(bestOf, secretMode)
 	fmt.Printf("Playing best of %d games\n", bestOf)
+	if secretMode {
+		fmt.Println("🖖 Secret mode activated: Rock Paper Scissors Lizard Spock!")
+	}
 
 	for !game.GameOver {
 		fmt.Printf("\nCurrent score - Player: %d, Computer: %d\n", game.PlayerScore, game.ComputerScore)
-
+		
+		options := standardOptions
+		if secretMode {
+			options = secretOptions
+		}
+		
 		// Get player choice using prompter
 		playerChoiceIndex, err := prompter.Select("Choose your move", "rock", options)
 		if err != nil {

internal/rockpaperscissors/rockpaperscissors_test.go

@@ -2,36 +2,52 @@ package rockpaperscissors
 
 import (
 	"fmt"
+	"strings"
 	"testing"
 )
 
 func TestNewGame(t *testing.T) {
 	tests := []struct {
 		name            string
 		bestOf          int
+		secretMode      bool
 		wantBestOf      int
 		wantGameOver    bool
 		wantGamesPlayed int
+		wantSecretMode  bool
 	}{
 		{
 			name:            "New game with odd number of rounds",
 			bestOf:          3,
+			secretMode:      false,
 			wantBestOf:      3,
 			wantGameOver:    false,
 			wantGamesPlayed: 0,
+			wantSecretMode:  false,
 		},
 		{
 			name:            "New game with even number of rounds should increment to odd",
 			bestOf:          4,
+			secretMode:      false,
 			wantBestOf:      5,
 			wantGameOver:    false,
 			wantGamesPlayed: 0,
+			wantSecretMode:  false,
+		},
+		{
+			name:            "New game with secret mode enabled",
+			bestOf:          3,
+			secretMode:      true,
+			wantBestOf:      3,
+			wantGameOver:    false,
+			wantGamesPlayed: 0,
+			wantSecretMode:  true,
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			game := NewGame(tt.bestOf)
+			game := NewGame(tt.bestOf, tt.secretMode)
 			if game.BestOf != tt.wantBestOf {
 				t.Errorf("NewGame() BestOf = %v, want %v", game.BestOf, tt.wantBestOf)
 			}
@@ -40,6 +56,9 @@ func TestNewGame(t *testing.T) {
 			}
 			if game.GamesPlayed != tt.wantGamesPlayed {
 				t.Errorf("NewGame() GamesPlayed = %v, want %v", game.GamesPlayed, tt.wantGamesPlayed)
+				if game.SecretMode != tt.wantSecretMode {
+					t.Errorf("NewGame() SecretMode = %v, want %v", game.SecretMode, tt.wantSecretMode)
+				}
 			}
 		})
 	}
@@ -50,69 +69,94 @@ func TestGame_getWinner(t *testing.T) {
 		name           string
 		playerChoice   string
 		computerChoice string
+		secretMode     bool
 		want           string
 	}{
 		{
 			name:           "Player wins with rock vs scissors",
 			playerChoice:   "rock",
 			computerChoice: "scissors",
+			secretMode:     false,
 			want:           "player",
 		},
 		{
 			name:           "Player wins with paper vs rock",
 			playerChoice:   "paper",
 			computerChoice: "rock",
+			secretMode:     false,
 			want:           "player",
 		},
 		{
 			name:           "Player wins with scissors vs paper",
 			playerChoice:   "scissors",
 			computerChoice: "paper",
+			secretMode:     false,
 			want:           "player",
 		},
 		{
 			name:           "Player loses with rock vs paper",
 			playerChoice:   "rock",
 			computerChoice: "paper",
+			secretMode:     false,
 			want:           "computer",
 		},
 		{
 			name:           "Player loses with paper vs scissors",
 			playerChoice:   "paper",
 			computerChoice: "scissors",
+			secretMode:     false,
 			want:           "computer",
 		},
 		{
 			name:           "Player loses with scissors vs rock",
 			playerChoice:   "scissors",
 			computerChoice: "rock",
+			secretMode:     false,
 			want:           "computer",
 		},
 		{
 			name:           "Draw with same choices (rock)",
 			playerChoice:   "rock",
 			computerChoice: "rock",
+			secretMode:     false,
 			want:           "draw",
 		},
 		{
 			name:           "Draw with same choices (paper)",
 			playerChoice:   "paper",
 			computerChoice: "paper",
+			secretMode:     false,
 			want:           "draw",
 		},
 		{
 			name:           "Draw with same choices (scissors)",
 			playerChoice:   "scissors",
 			computerChoice: "scissors",
+			secretMode:     false,
 			want:           "draw",
 		},
+		{
+			name:           "Secret mode - Player wins - rock beats lizard",
+			playerChoice:   "rock",
+			computerChoice: "lizard",
+			secretMode:     true,
+			want:           "player",
+		},
+		{
+			name:           "Secret mode - Computer wins - spock beats rock",
+			playerChoice:   "rock",
+			computerChoice: "spock",
+			secretMode:     true,
+			want:           "computer",
+		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			g := &Game{
 				PlayerChoice:   tt.playerChoice,
 				ComputerChoice: tt.computerChoice,
+				SecretMode:     tt.secretMode,
 			}
 			if got := g.getWinner(); got != tt.want {
 				t.Errorf("Game.getWinner() = %v, want %v", got, tt.want)
@@ -126,6 +170,7 @@ func TestGame_Play(t *testing.T) {
 		name              string
 		bestOf            int
 		moves             []string
+		secretMode        bool
 		wantGameOver      bool
 		wantPlayerScore   int
 		wantComputerScore int
@@ -134,6 +179,7 @@ func TestGame_Play(t *testing.T) {
 			name:              "Game ends when player chooses exit",
 			bestOf:            3,
 			moves:             []string{"exit"},
+			secretMode:        false,
 			wantGameOver:      true,
 			wantPlayerScore:   0,
 			wantComputerScore: 0,
@@ -142,6 +188,7 @@ func TestGame_Play(t *testing.T) {
 			name:              "Game continues for valid moves",
 			bestOf:            3,
 			moves:             []string{"rock"},
+			secretMode:        false,
 			wantGameOver:      false,
 			wantPlayerScore:   0, // Score will depend on random computer choice
 			wantComputerScore: 0, // Score will depend on random computer choice
@@ -150,7 +197,7 @@ func TestGame_Play(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			g := NewGame(tt.bestOf)
+			g := NewGame(tt.bestOf, tt.secretMode)
 			for _, move := range tt.moves {
 				g.Play(move)
 			}
@@ -302,7 +349,7 @@ func TestGame_getGameOverMessage(t *testing.T) {
 			if got == "" {
 				t.Error("getGameOverMessage() returned empty string")
 			}
-			if !contains(got, tt.wantMsgContains) {
+			if !strings.Contains(got, tt.wantMsgContains) {
 				t.Errorf("getGameOverMessage() = %v, want it to contain %v", got, tt.wantMsgContains)
 			}
 		})
@@ -337,43 +384,47 @@ func (m *mockPromptSequence) Select(prompt, defaultValue string, options []strin
 
 func TestPlayGame(t *testing.T) {
 	tests := []struct {
-		name         string
-		prompter     Prompter
-		wantGameOver bool
+		name       string
+		prompter   Prompter
+		secretMode bool
 	}{
 		{
-			name: "Complete game sequence",
+			name: "Complete game sequence - standard mode",
+			prompter: &mockPromptSequence{
+				returns: []int{1, 0, 0, 0}, // Select 5 rounds, then rock three times
+				errors:  []error{nil, nil, nil, nil},
+			},
+			secretMode: false,
+		},
+		{
+			name: "Complete game sequence - secret mode",
 			prompter: &mockPromptSequence{
 				returns: []int{1, 0, 0, 0}, // Select 5 rounds, then rock three times
 				errors:  []error{nil, nil, nil, nil},
 			},
+			secretMode: true,
 		},
 		{
 			name: "Error on rounds selection",
 			prompter: &mockPromptSequence{
 				returns: []int{0},
 				errors:  []error{fmt.Errorf("mock error")},
 			},
+			secretMode: false,
 		},
 		{
 			name: "Error on move selection",
 			prompter: &mockPromptSequence{
 				returns: []int{0, 0},
 				errors:  []error{nil, fmt.Errorf("mock error")},
 			},
-		},
-		{
-			name: "Invalid round index",
-			prompter: &mockPromptSequence{
-				returns: []int{99, 3}, // Invalid round index, then exit
-				errors:  []error{nil, nil},
-			},
+			secretMode: false,
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			PlayGame(tt.prompter)
+			PlayGame(tt.prompter, tt.secretMode)
 		})
 	}
 }