Enhance Tic-tac-toe game with computer opponent and game mode selection

Author: chrisreddington

cmd/tictactoe.go

@@ -4,40 +4,92 @@ import (
 	"fmt"
 	"os"
 
+	"github.com/charmbracelet/lipgloss"
 	"github.com/chrisreddington/gh-game/internal/tictactoe"
 	userPrompt "github.com/cli/go-gh/v2/pkg/prompter"
 	"github.com/spf13/cobra"
 )
 
+var (
+	xStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("45"))  // bright blue
+	oStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("226")) // bright yellow
+)
+
 var tictactoeCmd = &cobra.Command{
 	Use:   "tictactoe",
 	Short: "Play Tic-tac-toe",
-	Long:  `Start a game of Tic-tac-toe where X and O take turns to play.`,
+	Long: `Start a game of Tic-tac-toe where you can play against another player locally or against the computer.
+Choose between two game modes:
+- Local Multiplayer: Play against another player on the same computer
+- Play Against Computer: Play against an AI opponent that uses basic strategy`,
 	Run: func(cmd *cobra.Command, args []string) {
-		game := tictactoe.NewGame()
 		prompter := userPrompt.New(os.Stdin, os.Stdout, os.Stderr)
 
+		// Select game mode
+		modeIndex, err := prompter.Select(
+			"Select game mode:",
+			"Local Multiplayer",
+			[]string{"Local Multiplayer", "Play Against Computer"},
+		)
+		if err != nil {
+			fmt.Printf("Error selecting game mode: %v\n", err)
+			return
+		}
+
+		// Initialize game with selected mode
+		mode := tictactoe.LocalGame
+		if modeIndex == 1 {
+			mode = tictactoe.ComputerGame
+		}
+		game := tictactoe.NewGame(mode)
+
+		// Main game loop
 		for {
 			fmt.Println(game)
-			fmt.Printf("Player %s's turn\n", game.CurrentPlayer)
+			currentMark := game.CurrentPlayer
+			style := xStyle
+			if currentMark == "O" {
+				style = oStyle
+			}
+			fmt.Printf("Player %s's turn\n", style.Render(currentMark))
 
-			row, col, err := tictactoe.GetPlayerMove(prompter, game)
-			if err != nil {
-				fmt.Printf("Error getting move: %v\n", err)
-				return
+			// Get move from either computer or human player
+			var rowIndex, columnIndex int
+			if game.IsComputerTurn() {
+				rowIndex, columnIndex = game.GetComputerMove()
+				position := rowIndex*3 + columnIndex + 1
+				fmt.Printf("Computer places %s at position %d\n", oStyle.Render("O"), position)
+			} else {
+				var err error
+				rowIndex, columnIndex, err = tictactoe.GetPlayerMove(prompter, game)
+				if err != nil {
+					fmt.Printf("Error getting move: %v\n", err)
+					return
+				}
 			}
 
-			if err := game.MakeMove(row, col); err != nil {
+			// Apply the move
+			if err := game.MakeMove(rowIndex, columnIndex); err != nil {
 				fmt.Printf("Invalid move: %v\n", err)
 				continue
 			}
 
+			// Check win condition
 			if winner := game.GetWinner(); winner != "" {
 				fmt.Println(game)
-				fmt.Printf("Player %s wins!\n", winner)
+				style := xStyle
+				if winner == "O" {
+					style = oStyle
+				}
+				if game.Mode == tictactoe.ComputerGame && winner == game.ComputerMark {
+					fmt.Printf("Computer (%s) wins!\n", style.Render(winner))
+				} else {
+					fmt.Printf("Player %s wins!\n", style.Render(winner))
+				}
 				return
 			}
 
+			// Check draw condition
 			if game.IsBoardFull() {
 				fmt.Println(game)
 				fmt.Println("It's a draw!")

internal/tictactoe/tictactoe.go

@@ -1,12 +1,31 @@
-// Package tictactoe implements a classic Tic-tac-toe game where two players
-// take turns marking spaces on a 3x3 grid. Players alternate placing X's and O's
-// on the board until either one player wins by placing three marks in a row,
-// column, or diagonal, or the game ends in a draw when the board is full.
+// Package tictactoe implements a classic Tic-tac-toe game where players can play
+// against another player locally or against a computer opponent.
 package tictactoe
 
 import (
 	"errors"
 	"fmt"
+	"math/rand"
+	"time"
+
+	"github.com/charmbracelet/lipgloss"
+)
+
+// GameMode represents the type of game being played (local multiplayer or against computer)
+type GameMode int
+
+const (
+	// LocalGame represents a game played between two local players
+	LocalGame GameMode = iota
+	// ComputerGame represents a game played against the computer
+	ComputerGame
+)
+
+var (
+	// Use accessible colors - blue for X and yellow for O
+	// These colors have good contrast and are distinguishable for most types of color blindness
+	xStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("45"))  // bright blue
+	oStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("226")) // bright yellow
 )
 
 // Prompter defines an interface for getting user input
@@ -26,17 +45,25 @@ type Board [3][3]string
 
 // Game represents the current state of a Tic-tac-toe game.
 type Game struct {
-	board         Board  // The game board storing player moves ("X" or "O", or empty for unplayed)
-	CurrentPlayer string // CurrentPlayer indicates whose turn it is ("X" or "O")
+	board         Board    // The game board storing player moves ("X" or "O", or empty for unplayed)
+	CurrentPlayer string   // CurrentPlayer indicates whose turn it is ("X" or "O")
+	Mode          GameMode // Mode indicates if playing against computer or local player
+	ComputerMark  string   // ComputerMark stores which mark (X/O) the computer is using
 }
 
 // NewGame creates and initializes a new Tic-tac-toe game with an empty board.
 // Setting as X always plays first.
-func NewGame() *Game {
-	return &Game{
+func NewGame(mode GameMode) *Game {
+	game := &Game{
 		board:         Board{},
 		CurrentPlayer: "X",
+		Mode:          mode,
+	}
+	if mode == ComputerGame {
+		// Computer always plays as O
+		game.ComputerMark = "O"
 	}
+	return game
 }
 
 // MakeMove attempts to place the current player's mark at the specified position.
@@ -113,8 +140,8 @@ func (g *Game) IsBoardFull() bool {
 
 // String returns a formatted string representation of the current board state.
 // Empty squares are shown as numbers 1-9 for position selection, making it
-// easier for players to choose their moves. Played squares show the player's mark.
-// The board is displayed with column separators (|) and row separators (-).
+// easier for players to choose their moves. Played squares show the player's mark
+// in their respective colors (blue for X, yellow for O).
 func (g *Game) String() string {
 	result := "\n"
 	position := 1
@@ -125,11 +152,16 @@ func (g *Game) String() string {
 				result += " "
 			}
 
-			// Show position number for empty squares, otherwise show the player's mark
+			// Show position number for empty squares, otherwise show the colored player's mark
 			if g.board[rowIndex][columnIndex] == "" {
 				result += fmt.Sprintf("%d", position)
 			} else {
-				result += g.board[rowIndex][columnIndex]
+				mark := g.board[rowIndex][columnIndex]
+				if mark == "X" {
+					result += xStyle.Render("X")
+				} else {
+					result += oStyle.Render("O")
+				}
 			}
 
 			// Add column separators except for the last column
@@ -218,3 +250,82 @@ func GetPlayerMove(prompter Prompter, game GameInterface) (rowIndex, columnIndex
 
 	return rowIndex, columnIndex, nil
 }
+
+// IsComputerTurn returns true if it's the computer's turn in a computer game.
+// This will only return true if the game mode is ComputerGame and the current
+// player matches the computer's mark.
+func (g *Game) IsComputerTurn() bool {
+	return g.Mode == ComputerGame && g.CurrentPlayer == g.ComputerMark
+}
+
+// GetComputerMove determines the computer's next move using a simple strategy:
+// 1. Win if possible
+// 2. Block opponent's winning move if possible
+// 3. Take center if available
+// 4. Take a random corner if available
+// 5. Take any available space
+// Returns row and column indices for the chosen move.
+func (g *Game) GetComputerMove() (rowIndex, columnIndex int) {
+	// Try to win if possible
+	if move := g.findWinningMove(g.ComputerMark); move != nil {
+		return move[0], move[1]
+	}
+
+	// Block opponent's winning move if possible
+	playerMark := "X" // Player is always X
+	if move := g.findWinningMove(playerMark); move != nil {
+		return move[0], move[1]
+	}
+
+	// Take center if available
+	if g.board[1][1] == "" {
+		return 1, 1
+	}
+
+	// Take a corner if available
+	corners := [][2]int{{0, 0}, {0, 2}, {2, 0}, {2, 2}}
+	rand.Seed(time.Now().UnixNano())
+	rand.Shuffle(len(corners), func(i, j int) {
+		corners[i], corners[j] = corners[j], corners[i]
+	})
+	for _, corner := range corners {
+		if g.board[corner[0]][corner[1]] == "" {
+			return corner[0], corner[1]
+		}
+	}
+
+	// Take any available space
+	for rowIndex := 0; rowIndex < 3; rowIndex++ {
+		for columnIndex := 0; columnIndex < 3; columnIndex++ {
+			if g.board[rowIndex][columnIndex] == "" {
+				return rowIndex, columnIndex
+			}
+		}
+	}
+
+	return -1, -1
+}
+
+// findWinningMove checks if there's a winning move available for the given mark.
+// It simulates placing the mark in each empty position and checks if it results in a win.
+// Returns the [row, column] indices of the winning move, or nil if no winning move exists.
+func (g *Game) findWinningMove(mark string) []int {
+	// Try each empty position
+	for rowIndex := 0; rowIndex < 3; rowIndex++ {
+		for columnIndex := 0; columnIndex < 3; columnIndex++ {
+			if g.board[rowIndex][columnIndex] == "" {
+				// Try the move
+				g.board[rowIndex][columnIndex] = mark
+				// Check if it's a winning move
+				if g.GetWinner() == mark {
+					// Undo the move and return the position
+					g.board[rowIndex][columnIndex] = ""
+					return []int{rowIndex, columnIndex}
+				}
+				// Undo the move
+				g.board[rowIndex][columnIndex] = ""
+			}
+		}
+	}
+	return nil
+}