using System;

​

using System.Collections.Generic;

using System.Linq;

​

​

namespace Connect4simul

{

       class Program

    {

​

        const int NumberOfGames = 10000;

​

        static void Main(string[] args)

        {

​

​

            var myd = 0;

            var myr = 0;

            var myy = 0;

​

            var gameN = 0;

​

            var showDraw = true;

            //loop for number of trials

            for (var c = 0; c < NumberOfGames; c++)

            {

                gameN++;

                moveResult res = moveResult.noResult;

                var x = new Board();

                var move = 0;

                do

                {

                    ++move;

                    res = x.RandomMove(x.WhosMove);

                    if (res == moveResult.noResult)

                        x.ChangeMove();

                    //Console.WriteLine(x.ViewBoard);

​

                } while (res == moveResult.noResult);

​

                //this shows a sample drawn position

                if (showDraw && res == moveResult.draw)

                {

                    Console.WriteLine(string.Format("Game = {0}", gameN));

                    Console.WriteLine(x.ViewBoard);

                    Console.WriteLine("");

                    showDraw = false;

                }

​

                //keep tally of stats

                switch (res)

                {

                    case moveResult.draw:

                        ++myd;

                        break;

                    case moveResult.redWin:

                        ++myr;

                        break;

                    case moveResult.yellowWin:

                        ++myy;

                        break;

​

                }

​

            }

​

            //show results

            var tot = myd + myr + myy;

​

            var resString = string.Format("Red Wins : {0} / {1} = {2:F2}%    Yellow wins : {3} / {1} = {4:F2}%      Draws :  {5} / {1} = {6:F2}%", myr, tot,(double) myr / tot * 100, myy, (double) myy / tot * 100, myd, (double) myd / tot * 100);

​

            Console.WriteLine(resString);

        }

    }

​

            //a class to simulate a random game of connect 4

​

 public enum piece

    {

        empty,

        red,

        yellow

    }

​

    public enum moveResult

    {

        fail,

        redWin,

        yellowWin,

        draw,

        noResult

    }

​

    class Board

    {

        //board is a list of lists of pieces

        const int Rows = 6;

        const int Cols = 7;

​

        private List<List<piece>> _board;

​

        private Random rn ;

​

​

        public piece WhosMove { get; set; }

​

​

​

​

        public Board()

        {

            rn = new Random();

            basey();

        }

​

        public Board(int seed)

        {

​

            rn = new Random(seed);

            basey();

        }

​

        private void basey()

        {

            //set up a board

            _board = new List<List<piece>>();

            for (var i = 0; i < Cols; i++)

            {

                var n = new List<piece>();

                for (var j = 0; j < Rows; j++)

                    n.Add(piece.empty);

​

                _board.Add(n);

            }

​

            this.WhosMove = piece.red;

        }

​

        public void ChangeMove()

        {

            this.WhosMove = (this.WhosMove == piece.red ? piece.yellow : piece.red);

        }

​

        public moveResult PlayMove(int col, piece p)

        {

            if ((p != piece.red && p != piece.yellow) || col >= Cols || !_board[col].Where(x => x == piece.empty).Any())

            {

                return moveResult.fail;

            }

            else

            {

                var pos = 0;

                while (_board[col][pos] != piece.empty)

                    pos++;

​

                _board[col][pos] = p;

                return CheckPos(col, pos);

            }

​

​

        }

​

​

        public string ViewBoard

        {

            //make a string to show the board visually

            get

            {

                var retval = "";

                for(var row = Rows-1; row>=0; row--)

                {

                    for (var col = 0; col < Cols; col ++)

                    {

                        var t = _board[col][row];

                        string  pi="";

                        if (t == piece.empty)

                        {

                            pi = " . ";

                        }

                        if (t == piece.red)

                        {

                            pi = " R ";

                        }

                        if (t == piece.yellow)

                        {

                            pi = " Y ";

                        }

                        retval += pi;

                    }

                    retval += "\n\r";

                }

                return retval;

            }

        }

​

​

​

​

        public moveResult RandomMove(piece p)

        {

            //make a random move

            var spaced = _board.Select((x, i) => (x.Where(y => y == piece.empty).Any() ? i : -1)).Where(z => z > -1).ToList();

​

​

            var move = (int)Math.Floor((double) spaced.Count() * rn.NextDouble());

​

            return PlayMove(spaced[move], p);

​

        }

​

        private moveResult CheckPos(int col, int row)

        {

​

            //check for 4 in a row, up, down, 2 x diagonal directions

​

            var myMove = _board[col][row];

​

            var x1 = col;

            var x2 = col;

            while (x1 > 0 && _board[x1 - 1][row] == myMove)

                x1--;

            while (x2 < Cols - 1 && _board[x2 + 1][row] == myMove)

                x2++;

​

            var y1 = row;

            while (y1 > 0 && _board[col][y1 - 1] == myMove)

                y1--;

            var y2 = row;

            while (y2 < Rows - 1 && _board[col][y2 + 1] == myMove)

                y2++;

​

            var d1 = col;

            var d2 = row;

            while (d1 > 0 && d2 > 0 && _board[d1 - 1][d2 - 1] == myMove)

            {

                d1--;

                d2--;

            }

​

            var d3 = col;

            var d4 = row;

            while (d3 < Cols - 1  && d4 < Rows - 1  && _board[d3+1][d4+1] == myMove)

            {

                d3++;

                d4++;

            }

​

​

            var d5 = col;

            var d6 = row;

            while (d5 < Cols - 1 && d6 > 0 && _board[d5 + 1][d6 - 1] == myMove)

            {

                d5++;

                d6--;

            }

​

​

            var d7 = col;

            var d8 = row;

            while (d7 > 0 && d8 < Rows - 1 && _board[d7 - 1][d8 + 1] == myMove)

            {

                d7--;

                d8++;

            }

​

​

            var rowc = x2 - x1 + 1;

            var colc = y2 - y1 + 1;

            var d1c = d3 - d1 + 1;

            var d2c = d8 - d6 + 1;

​

            if (d2c == 4)

            { 

                var ttt = 99;

                ttt++;

            }

​

            if (rowc >= 4 || colc >= 4 || d1c >= 4 || d2c >= 4)

            {

                //this means someone won

                return (myMove == piece.red) ? moveResult.redWin : moveResult.yellowWin;

            }

            else

            {

                //have we got any spaces left?

                return (_board.Where(x => x.Where(y => y == piece.empty).Any()).Any()) ? moveResult.noResult : moveResult.draw;

            }

​

        }

    }

}