Building a Tic Tac Toe Console Game in C#

When learning a new programming language, a common exercise is to create a classic game, such as Tic Tac Toe. In this post, I'll guide you through creating a simple, console-based Tic Tac Toe game in C#.

First, let's start with the challenge we're trying to solve:

Tic Tac Toe is a two-player game. We need to handle input from two players and alternate between them.

The game is played on a 3x3 grid. We need to keep track of the state of this grid.

A player wins by marking three spots in a row, either horizontally, vertically, or diagonally.

The game continues until a player has won or all spots on the grid have been marked, in which case the game is a draw.

To address these challenges, we need to develop a problem-solving mindset. Let's break down the problem into smaller, manageable pieces and think about how we could solve each one. This process is known as "decomposition" and it's a fundamental skill in programming and problem-solving in general.

Step 1: Storing the Game State

We'll use a simple one-dimensional array to store the state of the 3x3 game grid. Each element of the array corresponds to a spot on the grid, like this:

1 | 2 | 3
--+---+---
4 | 5 | 6
--+---+---
7 | 8 | 9

Each spot can be empty, marked by player 1 (we'll use 'X'), or marked by player 2 (we'll use 'O').

Here's how we can initialize our game state with a simple array:

class Board
{
    private readonly char[] positions;

    public Board()
    {
        positions = new[] { '1', '2', '3', '4', '5', '6', '7', '8', '9' };
    }
}

Step 2: Player Input

We need to take input from the players in turn. We'll prompt the current player to choose a spot to mark by entering a number from 1 to 9. After they choose a spot, we mark it and it's the next player's turn.

We create a Player class to handle the player input:

class Player
{
    public char Symbol { get; }

    public Player(char symbol)
    {
        Symbol = symbol;
    }
}

Then, we can get input from the players in the main game loop:

Console.WriteLine($"Player {player.Symbol}, it's your turn.");
Console.Write("Enter position (1-9): ");
var position = int.Parse(Console.ReadLine());

Step 3: Checking for a Winner

We'll check after each move if that move has made the current player a winner. There are eight ways to win Tic Tac Toe (three rows, three columns, two diagonals), so we could write eight separate conditions to check for a win. However, to reduce code duplication (following the DRY, or "Don't Repeat Yourself", principle), we'll store these combinations in a 2D array and use a loop to check them.

In the Board class, we define all winning combinations and provide a method to check if a player has won:

class Board
{
    // ... existing code ...

    private static readonly int[][] winningCombinations =
    {
        new[] { 0, 1, 2 },
        new[] { 3, 4, 5 },
        new[] { 6, 7, 8 },
        new[] { 0, 3, 6 },
        new[] { 1, 4, 7 },
        new[] { 2, 5, 8 },
        new[] { 0, 4, 8 },
        new[] { 2, 4, 6 }
    };

    // ... existing code ...

    public bool HasPlayerWon(char symbol)
    {
        return winningCombinations.Any(combination =>
            combination.All(index => positions[index] == symbol));
    }
}

Step 4: End of the Game

The game ends when a player wins, or when all spots on the grid have been marked. In the latter case, the game is a draw.

We've just followed the "Single Responsibility Principle" which is a part of SOLID principles, where each function in our program does one and only one thing.

Here's the code for our Tic Tac Toe game, implemented with these problem-solving steps in mind. Refer to the previous conversation to understand the code in detail.

We also add methods in the Board class to check if a position is taken, to mark a position, and to check if the board is full:

class Board
{
    // ... existing code ...

    public bool IsPositionTaken(int position)
    {
        return positions[position - 1] == 'X' || positions[position - 1] == 'O';
    }

    public void MakeMove(int position, char symbol)
    {
        positions[position - 1] = symbol;
    }

    public bool IsFull()
    {
        return positions.All(position => position == 'X' || position == 'O');
    }
}

Bringing It All Together

Now that we have the building blocks for our game, let's see how they all fit together in the main game loop:

static void Main()
{
    var board = new Board();
    var players = new[] { new Player('X'), new Player('O') };

    while (true)
    {
        foreach (var player in players)
        {
            Console.Clear();
            Console.WriteLine(board);

            Console.WriteLine($"Player {player.Symbol}, it's your turn.");
            Console.Write("Enter position (1-9): ");

            var position = int.Parse(Console.ReadLine());

            if (board.IsPositionTaken(position))
            {
                Console.WriteLine("Position is already taken, try again.");
                Console.ReadKey();
                continue;
            }

            board.MakeMove(position, player.Symbol);

            if (board.HasPlayerWon(player.Symbol))
            {
                Console.Clear();
                Console.WriteLine(board);
                Console.WriteLine($"Player {player.Symbol} wins!");
                return;
            }

            if (board.IsFull())
            {
                Console.Clear();
                Console.WriteLine(board);
                Console.WriteLine("The game is a draw!");
                return;
            }
        }
    }
}

Overcoming Technical Challenges

During the development, some challenges might have arisen. For example, we need to handle the possibility that a player could try to mark a spot that has already been marked. We overcome this by checking if a spot is already marked before we try to mark it.

Another challenge is keeping the code maintainable as we add more features. For example, if we decided to add a feature to let the players choose their own symbols instead of 'X' and 'O', it could involve many changes if the symbols were hardcoded throughout the code. To keep our code maintainable and easy to change, we encapsulate the concept of a player into a Player class and use instances

You can download the source code from here.

And that's it! You now have a simple, console-based Tic Tac Toe game in C#. It's a simple application, but it involves a variety of fundamental concepts in programming, such as loops, arrays, and classes. Happy coding!