Player.cs

using UnityEngine;

using System;


namespace ConnectFourGame
{
    public class Player
    {
        protected int id;

        public void SetID(int num)
        {
            id = num;
        }

        public int GetID()
        {
            return id;
        }
        public static int MakeMove(ref Board board, int dificulty)
        {
            System.Random rand = new System.Random();
            int[] availableColumns = new int[7];
            int availableCount = 0;

            // Find available columns (top row empty)
            for (int col = 0; col < 7; col++)
            {
                if (board.CanDrop(col))
                {
                    availableColumns[availableCount] = col;
                    availableCount++;
                }
            }


            //AI code bellow

            int depth = dificulty; // Adjust for stronger/weaker AI
            int bestScore = int.MinValue;
            int bestCol = availableColumns[availableCount/2]; // Fallback on middle col

            for (int i = 0; i < availableCount; i++)
            {
                int col = availableColumns[i];

                // Simulate move
                Board boardCopy = board.Clone();
                boardCopy.Drop(2, col); // 2 = AI's player number

                int score = Minimax(boardCopy, depth - 1, false, int.MinValue, int.MaxValue);

                if (score > bestScore)
                {
                    bestScore = score;
                    bestCol = col;
                }
            }

            int thiscol = bestCol;
            return thiscol;
        }

        public static int Minimax(Board board, int depth, bool maximizingPlayer, int alpha, int beta)
        {
            // 2 = AI, 1 = Human.
            if (board.PlayerIsWin(2)) return 1000 + depth;
            if (board.PlayerIsWin(1)) return -1000 - depth;
            if (board.IsFull() || depth == 0) return EvaluateBoard(board);

            if (maximizingPlayer)
            {
                int maxEval = int.MinValue;
                for (int col = 0; col < 7; col++)
                {
                    if (!board.CanDrop(col)) continue;
                    Board boardCopy = board.Clone();
                    boardCopy.Drop(2, col);
                    int eval = Minimax(boardCopy, depth - 1, false, alpha, beta);
                    maxEval = Math.Max(maxEval, eval);
                    alpha = Math.Max(alpha, eval);
                    if (beta <= alpha)
                        break;
                }
                return maxEval;
            }
            else
            {
                int minEval = int.MaxValue;
                for (int col = 0; col < 7; col++)
                {
                    if (!board.CanDrop(col)) continue;
                    Board boardCopy = board.Clone();
                    boardCopy.Drop(1, col);
                    int eval = Minimax(boardCopy, depth - 1, true, alpha, beta);
                    minEval = Math.Min(minEval, eval);
                    beta = Math.Min(beta, eval);
                    if (beta <= alpha)
                        break;
                }
                return minEval;
            }
        }

        // Simple heuristic: prefers center and possible connections
        static int EvaluateWindow(int[] window, int piece)
        {
            int score = 0;
            int opponentPiece = (piece == 1) ? 2 : 1;
            int countPiece = 0, countOpponent = 0, countEmpty = 0;

            foreach (int cell in window)
            {
                if (cell == piece) countPiece++;
                else if (cell == opponentPiece) countOpponent++;
                else countEmpty++;
            }

            if (countPiece == 4)
                score += 100;
            else if (countPiece == 3 && countEmpty == 1)
                score += 5;
            else if (countPiece == 2 && countEmpty == 2)
                score += 2;

            if (countOpponent == 3 && countEmpty == 1)
                score -= 4;

            return score;
        }

        public static int EvaluateBoard(Board boardObj)
        {
            int[,] board = boardObj.board;
            int score = 0;

            // Center column preference
            int centerCol = 7 / 2;
            int centerCount = 0;
            for (int r = 0; r < 6; r++)
                if (board[r, centerCol] == 2)
                    centerCount++;
            score += centerCount * 6;

            // Horizontal
            for (int r = 0; r < 6; r++)
                for (int c = 0; c < 7 - 3; c++)
                {
                    int[] window = { board[r, c], board[r, c + 1], board[r, c + 2], board[r, c + 3] };
                    score += EvaluateWindow(window, 2);
                    score -= EvaluateWindow(window, 1); // Subtract human's perspective
                }

            // Vertical
            for (int c = 0; c < 7; c++)
                for (int r = 0; r < 6 - 3; r++)
                {
                    int[] window = { board[r, c], board[r + 1, c], board[r + 2, c], board[r + 3, c] };
                    score += EvaluateWindow(window, 2);
                    score -= EvaluateWindow(window, 1);
                }

            // Positive diagonal (\)
            for (int r = 0; r < 6 - 3; r++)
                for (int c = 0; c < 7 - 3; c++)
                {
                    int[] window = { board[r, c], board[r + 1, c + 1], board[r + 2, c + 2], board[r + 3, c + 3] };
                    score += EvaluateWindow(window, 2);
                    score -= EvaluateWindow(window, 1);
                }

            // Negative diagonal (/)
            for (int r = 3; r < 6; r++)
                for (int c = 0; c < 7 - 3; c++)
                {
                    int[] window = { board[r, c], board[r - 1, c + 1], board[r - 2, c + 2], board[r - 3, c + 3] };
                    score += EvaluateWindow(window, 2);
                    score -= EvaluateWindow(window, 1);
                }

            return score;
        }

    }
}