TDD-ing Chess in C#

Part 1 - The Position - C#

Introduction

This is the first post in a series of posts where I will implement a chess game in the TDD workflow. Though others have already done something similar (e.g. TDD and modeling a chess game by Erik Dietrich), I'm doing this to craft my TDD workflow and share its values and result with you. Some explanations will be skipped here as they are already covered in that series TTD-ing Avatar Health in C# and C++.

The rules

Chess has been played for over a thousand years and it evolved roughly into its current form by about 1500. The chess rules are known to many and the basic rules are:

• The game of chess is a two player turn based game where each player controls sixteen pieces on a chessboard
• The board is 8x8 squares, 8 horizontal rows that are called Ranks (and presented as letters from 'a' to 'h'), and 8 vertical columns that are called Files (presented numbers as 1 to 8)
• Each piece has a position in one of the squares and can move to a new position, capturing an opponent piece if in that position
• Each piece type (King, Queen, Rook, Knight, Bishop, Pawn) moves in its unique way
• The object of the game is to checkmate the opponent's King

The Position

A Position data structure seems to be at the base of the domain model. The board squares are positions, and the pieces have a position and move into a new position. To streamline calculations in the domain model the Position will be defined as 0-based Column and Row, although the presentation / view will be 'a' to 'h' Rank and 1-based File. I deem it well fitting to define Position as a Struct.

Some upfront design like this fits well with the TDD workflow, as long as it does go towards wholistic water flow design phase, as the TDD cycles should drive most of the design by taking on the next rule / requirement, one at a time.

Cycling the Position

RED (does not compile)

// PositionTest.cs
using NUnit.Framework;

namespace PositionTest
{
	public class Constructor
	{
		[Test]
		public void ColumnAndRow_AreInitialized()
		{
			var position = new Position(0, 1);
			Assert.That(position.Column, Is.EqualTo(0));
			Assert.That(position.Row, Is.EqualTo(1));
		}
	}
}

RED (test fails)

// Position.cs
public struct Position
{
	public int Column;
	public int Row;

	public Position(int column, int row)
	{
		Column = -1;
		Row = -1;
	}
}

GREEN

// Position.cs
public struct Position
{
	public int Row;
	public int Column;

	public Position(int column, int row)
	{
		Column = column;
		Row = row;
	}
}

REFACTOR

// Position.cs
public readonly struct Position
{
	public int Column { get; }
	public int Row { get; }

	public Position(int column, int row)
	{
		Column = column;
		Row = row;
	}
}

Comparing positions

GREEN

// PositionTest.cs
public class Equals
{
	[Test]
	public void AreEqual_WhenWithSameRowAndSameColumn()
	{
		var pos1 = new Position(0, 0);
		var pos2 = new Position(0, 0);
		Assert.That(pos1.Equals(pos2), Is.True);
	}

	[Test]
	public void AreNotEqual_WhenNotWithSameRowAndSameColumn()
	{
		var pos1 = new Position(1, 0);
		var pos2 = new Position(0, 0);
		Assert.That(pos1.Equals(pos2), Is.False);
	}
}

RED (does not compile)

// PositionTest.cs
[Test]
public void AreEqual_WhenWithSameRowAndSameColumn_UsingOperator()
{
	var pos1 = new Position(0, 0);
	var pos2 = new Position(0, 0);
	Assert.That(pos1 == pos2, Is.True);
}

[Test]
public void AreNotEqual_WhenNotWithSameRowAndSameColumn_UsingOperator()
{
	var pos1 = new Position(1, 0);
	var pos2 = new Position(0, 0);
	Assert.That(pos1 != pos2, Is.True);
}

GREEN and REFACTOR

// Position.cs
public readonly struct Position : IEquatable<Position>
{
	// ...
	public bool Equals(Position other)
	{
		return Column == other.Column && Row == other.Row;
	}

	public override bool Equals(object obj)
	{
		return obj is Position other && Equals(other);
	}

	public override int GetHashCode()
	{
		return HashCode.Combine(Column, Row);
	}

	public static bool operator ==(Position left, Position right)
	{
		return left.Equals(right);
	}

	public static bool operator !=(Position left, Position right)
	{
		return !left.Equals(right);
	}
}