Board.cs

using System.Collections.Generic;

namespace ConnectFourGame
{
    // Logic-only class: not a MonoBehaviour, do not attach to GameObject
    public class Board
    {
        public int[,] board = new int[6, 7];
        private Stack<Move> moves = new Stack<Move>();
        private Stack<Move> undoedMoves = new Stack<Move>();

        public void Reset()
        {
            board = new int[6, 7];
            moves.Clear();
            undoedMoves.Clear();
        }

        public bool IsWin(int row, int col)
        {
            bool iswin = false;
            int color = board[row, col];

            // vertical
            if (row + 3 < 6 &&
                board[row + 1, col] == color &&
                board[row + 2, col] == color &&
                board[row + 3, col] == color)
                iswin = true;

            // diagonal y=x
            if (row + 3 < 6 && col + 3 < 7 &&
                board[row + 1, col + 1] == color &&
                board[row + 2, col + 2] == color &&
                board[row + 3, col + 3] == color)
                iswin = true;

            if (row + 2 < 6 && col + 2 < 7 && row - 1 >= 0 && col - 1 >= 0 &&
                board[row + 2, col + 2] == color &&
                board[row + 1, col + 1] == color &&
                board[row - 1, col - 1] == color)
                return true;

            if (row + 1 < 6 && col + 1 < 7 && row - 2 >= 0 && col - 2 >= 0 &&
                board[row - 2, col - 2] == color &&
                board[row + 1, col + 1] == color &&
                board[row - 1, col - 1] == color)
                return true;

            if (row - 3 >= 0 && col - 3 >= 0 &&
                board[row - 1, col - 1] == color &&
                board[row - 2, col - 2] == color &&
                board[row - 3, col - 3] == color &&
                board[row, col] == color)
                iswin = true;

            // diagonal y=-x
            if (row + 3 < 6 && col - 3 >= 0 &&
                board[row, col] == color &&
                board[row + 1, col - 1] == color &&
                board[row + 2, col - 2] == color &&
                board[row + 3, col - 3] == color)
                return true;

            if (row - 1 >= 0 && col + 1 < 7 && row + 2 < 6 && col - 2 >= 0 &&
                board[row + 2, col - 2] == color &&
                board[row + 1, col - 1] == color &&
                board[row - 1, col + 1] == color)
                return true;

            if (row - 2 >= 0 && col + 2 < 7 && row + 1 < 6 && col - 1 >= 0 &&
                board[row - 2, col + 2] == color &&
                board[row - 1, col + 1] == color &&
                board[row + 1, col - 1] == color)
                return true;

            if (row - 3 >= 0 && col + 3 < 7 &&
                board[row - 1, col + 1] == color &&
                board[row - 2, col + 2] == color &&
                board[row - 3, col + 3] == color &&
                board[row, col] == color)
                iswin = true;

            // horizontal
            if (col + 3 < 7 &&
                board[row, col + 1] == color &&
                board[row, col + 2] == color &&
                board[row, col + 3] == color &&
                board[row, col] == color)
                iswin = true;

            if (col - 1 >= 0 && col + 2 < 7 &&
                board[row, col - 1] == color &&
                board[row, col + 1] == color &&
                board[row, col + 2] == color)
                return true;

            if (col - 2 >=0 && col + 1 < 7 &&
                board[row, col - 1] == color &&
                board[row, col - 2] == color &&
                board[row, col + 1] == color &&
                board[row, col] == color)
                iswin = true;

            if (col - 3 >= 0 &&
                board[row, col - 1] == color &&
                board[row, col - 2] == color &&
                board[row, col - 3] == color &&
                board[row, col] == color)
                iswin = true;

            return iswin;
        }

        public bool CanDrop(int col)
        {
            return board[0, col] == 0;
        }

        // Returns the row where the piece was dropped, or -1 if not possible
        public int Drop(int id, int col)
        {
            if (CanDrop(col))
            {
                for (int i = 5; i >= 0; i--)
                {
                    if (board[i, col] == 0)
                    {
                        board[i, col] = id;
                        moves.Push(new Move(i, col, id));
                        ClearUndoedMoves();
                        return i;
                    }
                }
            }
            return -1;
        }

        public bool IsDraw()
        {
            for (int i = 0; i < 7; i++)
                if (CanDrop(i))
                    return false;
            return true;
        }

        public int UnDo()
        {
            if (moves.Count > 0)
            {
                Move last = moves.Pop();
                board[last.Row, last.Column] = 0;
                undoedMoves.Push(last);
                return 0;
            }
            else
            {
                // TODO: Show "no previous moves" message in Unity UI if desired
                return -1;
            }
        }

        public int ReDo()
        {
            if (undoedMoves.Count > 0)
            {
                Move last = undoedMoves.Pop();
                board[last.Row, last.Column] = last.Id;
                moves.Push(last);
                return 0;
            }
            else
            {
                // TODO: Show "no undoed moves" message in Unity UI if desired
                return -1;
            }
        }

        public void ClearUndoedMoves()
        {
            undoedMoves.Clear();
        }

        public List<int> LegalMoves()
        {
            var legalmoves = new List<int>();
            for (int i = 0; i < 7; i++)
                if (CanDrop(i))
                    legalmoves.Add(i);
            return legalmoves;
        }

        public int GetCell(int row, int col)
        {
            return board[row, col];
        }
        public Board Clone()
        {
            Board newBoard = new Board();

            // Assuming your board has a 2D array called grid[,] and other relevant state
            for (int row = 0; row < 6; row++)
            {
                for (int col = 0; col < 7; col++)
                {
                    newBoard.board[row, col] = this.board[row, col];
                }
            }

            // Copy any other relevant fields (e.g., turn count, last move, etc.)
            // Example:
            // newBoard.turnCount = this.turnCount;
            // newBoard.lastMove = this.lastMove;

            return newBoard;
        }

        public bool PlayerIsWin(int id)
        {
            // Horizontal check
            for (int row = 0; row < 6; row++)
            {
                for (int col = 0; col < 4; col++)
                {
                    if (board[row, col] == id &&
                        board[row, col + 1] == id &&
                        board[row, col + 2] == id &&
                        board[row, col + 3] == id)
                    {
                        return true;
                    }
                }
            }

            // Vertical check
            for (int col = 0; col < 7; col++)
            {
                for (int row = 0; row < 3; row++)
                {
                    if (board[row, col] == id &&
                        board[row + 1, col] == id &&
                        board[row + 2, col] == id &&
                        board[row + 3, col] == id)
                    {
                        return true;
                    }
                }
            }

            // Diagonal down-right check
            for (int row = 0; row < 3; row++)
            {
                for (int col = 0; col < 4; col++)
                {
                    if (board[row, col] == id &&
                        board[row + 1, col + 1] == id &&
                        board[row + 2, col + 2] == id &&
                        board[row + 3, col + 3] == id)
                    {
                        return true;
                    }
                }
            }

            // Diagonal up-right check
            for (int row = 3; row < 6; row++)
            {
                for (int col = 0; col < 4; col++)
                {
                    if (board[row, col] == id &&
                        board[row - 1, col + 1] == id &&
                        board[row - 2, col + 2] == id &&
                        board[row - 3, col + 3] == id)
                    {
                        return true;
                    }
                }
            }

            return false;
        }
        public bool IsFull()
        {
            for (int i = 0; i < 6; i++)
            {
                if (CanDrop(i))
                    return false;
            }
            return true;
        }
    }
}