January 2021 – Dmitrii's Blog

Our online Coding Dojo sessions became the most powerful learning experience for me, and recently we came across Conway’s Game of Life.

I remember playing this game on paper when I was a child. Yesterday I had the pleasure to code the rules and see them working.

To make it more fun, we in our Coding Dojo club decided to separate concerns between “cells” and “grid” where the cells exist. After an exciting discussion for which I am grateful to Dennis, Saeed and Byron, I had started an all-nighter.

Here is what I got with a sunrise:

	using System;
	using System.Threading.Tasks;

	namespace GameOfLife
	{
	internal class Program
	{
	private static void Main()
	{
	const int rows = 30;
	const int cols = 30;

	var grid = RandomCellsGrid(rows, cols, new Random());

	while (!Console.KeyAvailable)
	{
	Console.WriteLine(grid.ToString());

	grid = grid.NextGeneration();

	Task.Delay(1000).Wait();
	}

	Console.WriteLine("Done!");
	}

	private static Grid RandomCellsGrid(int rows, int cols, Random random)
	{
	var cells = new Cell[rows, cols];

	for (var row = 0; row < rows; row++)
	for (var col = 0; col < cols; col++)
	cells[row, col] = new Cell(RandomlyAlive(random));

	return new Grid(cells);
	}

	private static bool RandomlyAlive(Random random)
	{
	const double threshold = 0.5;
	return random.NextDouble() > threshold;
	}
	}
	}

view raw Program.cs hosted with

by GitHub

	namespace GameOfLife
	{
	internal abstract class AbstractLifeObject
	{
	private protected AbstractSpace Belongs;

	public void BelongsTo(AbstractSpace space)
	{
	Belongs = space;
	}

	public abstract AbstractLifeObject NextGeneration();
	}
	}

view raw AbstractLifeObject.cs hosted with

by GitHub

	using System.Linq;

	namespace GameOfLife
	{
	internal class Cell : AbstractLifeObject
	{
	private readonly bool _live;

	public Cell(bool live)
	{
	_live = live;
	}

	public override AbstractLifeObject NextGeneration()
	{
	var neighbors = Belongs.GetNeighbors(this).OfType<Cell>().Count(c => c._live);

	return new Cell(IsNextGenerationCellAlive(neighbors));
	}

	public override string ToString()
	{
	return _live ? "[]" : "--";
	}

	private bool IsNextGenerationCellAlive(int neighbors)
	{
	if (_live)
	return neighbors is not (< 2 or > 3);

	return neighbors == 3;
	}
	}
	}

view raw Cell.cs hosted with

by GitHub

	using System.Collections.Generic;

	namespace GameOfLife
	{
	internal abstract class AbstractSpace
	{
	public abstract IEnumerable<AbstractLifeObject> GetNeighbors(AbstractLifeObject obj);
	}
	}

view raw AbstractSpace.cs hosted with

by GitHub

	using System;
	using System.Collections.Generic;
	using System.Text;

	namespace GameOfLife
	{
	internal class Grid : AbstractSpace
	{
	private readonly int _cols;
	private readonly AbstractLifeObject[,] _lifeObjects;
	private readonly int _rows;

	public Grid(AbstractLifeObject[,] objects)
	{
	_rows = objects.GetLength(0);
	_cols = objects.GetLength(1);

	BelongsToThis(objects);

	_lifeObjects = objects;
	}

	public Grid NextGeneration()
	{
	var newLifeObjects = new AbstractLifeObject[_rows, _cols];

	for (var row = 0; row < _rows; row++)
	for (var col = 0; col < _cols; col++)
	newLifeObjects[row, col] = _lifeObjects[row, col].NextGeneration();

	return new Grid(newLifeObjects);
	}

	public override IEnumerable<AbstractLifeObject> GetNeighbors(AbstractLifeObject lifeObject)
	{
	var (objectRow, objectCol) = GetLocation(lifeObject);

	for (var row = objectRow - 1; row <= objectRow + 1; row++)
	for (var col = objectCol - 1; col <= objectCol + 1; col++)
	{
	if (row == objectRow && col == objectCol) continue;
	if (row < 0 \|\| col < 0) continue;
	if (row >= _rows \|\| col >= _cols) continue;

	yield return _lifeObjects[row, col];
	}
	}

	public override string ToString()
	{
	var strBuilder = new StringBuilder();

	for (var row = 0; row < _rows; row++)
	{
	for (var col = 0; col < _cols; col++) strBuilder.Append(_lifeObjects[row, col]);

	strBuilder.Append(Environment.NewLine);
	}

	return strBuilder.ToString();
	}

	private void BelongsToThis(AbstractLifeObject[,] objects)
	{
	for (var row = 0; row < _rows; row++)
	for (var col = 0; col < _cols; col++)
	objects[row, col].BelongsTo(this);
	}

	private (int row, int col) GetLocation(AbstractLifeObject lifeObject)
	{
	for (var row = 0; row < _rows; row++)
	for (var col = 0; col < _cols; col++)
	if (_lifeObjects[row, col].Equals(lifeObject))
	return (row, col);

	throw new ArgumentException("Grid does not contain this life object");
	}
	}
	}

view raw Grid.cs hosted with

by GitHub

Conclusion:

I can not deny that SOLID code has its price. It takes much more time (2x or maybe 3x to compare to writing a monolithic code).
Nevertheless, we get benefits such as extensibility and reusability.

Let’s say we want to run the same game in 3D space. We can easily make this modification with SOLID code.

Month: January 2021

Let’s make code SOLID: Conway’s Game of Life

Conclusion: