connect4

Board.cs (4738B)

---

 using System;
 using System.Collections.Generic;
 using System.Linq;
 
 public class Board {
     private int _n; // number of columns
     private int _m; // number of rows
     private Cell[,] _board;
     private int[] _height;
     private Cell _next;
     private Status _status;
 
     public enum Cell {
         Free = 0, // make sure free is the default value
         PlayerX,
         PlayerO,
         None,
     }
 
     public enum Status {
         InProgress,
         PlayerXWon,
         PlayerOWon,
         Draw,
     }
 
     /*
      * Constructs a new board with m rows and n columns.
      */
     public Board( int n, int m ) {
         _m = m;
         _n = n;
         _board = new Cell[ m, n ];
         _height = new int[ n ];
         _next = Cell.PlayerX; // player X starts
         _status = Status.InProgress;
     }
 
     /*
      * Constructs a new board with the given board
      */
     public Board( Board board ) {
         _m = board._m;
         _n = board._n;
         _board = new Cell[ _m, _n ];
         _height = new int[ _n ];
         // why does it have to be so difficult to deep copy a 2d array?
         for ( int j = 0; j < _m; j ++ ) {
             for ( int i = 0; i < _n; i ++ ) {
                 _board[ j, i ] = board._board[ j, i ];
             }
         }
         board._height.CopyTo( _height, 0 );
         _next = board._next;
         _status = board._status;
     }
 
     /*
      * Determines if it is legal to play a piece in the given column
      */
     public bool IsLegal( int column ) {
         return _height[ column ] < _m;
     }
 
     /*
      * assumes play is legal
      */
     public void Play( int column ) {
         _board[ _m - _height[ column ] - 1, column ] = _next;
         _height[ column ] ++;
         _next = ( _next == Cell.PlayerX ) ? Cell.PlayerO : Cell.PlayerX;
         ComputeStatus();
     }
 
     /*
      * returns whos turn it is
      */
     public Cell GetNext() {
         return _next;
     }
 
     /*
      * returns who just played
      */
     public Cell GetPrevious() {
         return _next == Cell.PlayerX ? Cell.PlayerO : Cell.PlayerX;
     }
 
     /*
      * Pretty prints the board
      */
     public void PrettyPrint() {
         char[] prettyChar = { '.', 'X', 'O' };
         Console.WriteLine( $"{ _status }:" );
         for ( int j = 0; j < _m; j++ ) {
             for ( int i = 0; i < _n; i++ ) {
                 Console.Write( $" { prettyChar[ (int) _board[ j, i ] ] } " );
             }
             Console.Write( "\n" );
         }
     }
 
     /*
      * Returns a list of all legal moves on this board 
      */
     public List< int > LegalMoves() {
         List< int > legalMoves = new List< int >();
         if ( _status == Status.InProgress ) {
             for ( int i = 0; i < _n; i ++ ) {
                 if ( IsLegal( i ) ) {
                     legalMoves.Add( i );
                 }
             }
         }
         return legalMoves;
     }
 
     public Status GetStatus() {
         return _status;
     }
 
     public int GetHeight() {
         return _m;
     }
 
     public int GetWidth() {
         return _n;
     }
 
     /*
      * Indexer to grant read-only access to the board
      */
      public Cell this[ int j, int i ] {
         get {
             if ( 0 <= j && j < _m && 0 <= i && i < _n ) {
                 return _board[ j, i ];
             } else {
                 return Cell.None;
             }
         }
      }
 
 
     /*
      * Computes the status of this board, ie. has someone won by obtaining four in a row.
      */
     public Status ComputeStatus() {
         int FourInARow = NumberQInRow( 4, GetPrevious() );
 
         if ( FourInARow > 0 ) {
             _status = _next == Cell.PlayerO ? Status.PlayerXWon : Status.PlayerOWon;
         }
         return _status;
     }
 
     /*
      * Returns the number of q in a row for player.
      * Note: this also counts instance of more than q in a row.
      */
     public int NumberQInRow( int q, Cell player ) {
         var rows = Enumerable.Range( 0, _m );
         var columns = Enumerable.Range( 0, _n );
 
         var indices = new Func< int, int, int, ( int, int ) >[] {
             ( j, i, k ) => ( j + k, i ),
             ( j, i, k ) => ( j, i + k ),
             ( j, i, k ) => ( j + k, i + k ),
             ( j, i, k ) => ( j - k, i + k ),
         };
 
         int count =
             (   from index in indices
                 from j in rows
                 from i in columns
                 select Enumerable.All(
                     Enumerable.Range( 0, q ),
                     k => {
                         var ( jj, ii ) = index( j, i, k );
                         return this[ jj, ii ] == player;
                     }
                 )
             ).Where( b => b )
             .Count();
         return count;
     }
 }