using System;
using System.Collections.Generic;

namespace SimpleCheckers
{
    public enum PlayerType { None, Computer, Human };

    /// <summary>
    /// Reprezinta o piesa de joc
    /// </summary>
    public class Piece
    {
        public int Id { get; set; } // identificatorul piesei
        public int X { get; set; } // pozitia X pe tabla de joc
        public int Y { get; set; } // pozitia Y pe tabla de joc
        public PlayerType Player { get; set; } // carui tip de jucator apartine piesa (om sau calculator)

        public Piece(int x, int y, int id, PlayerType player)
        {
            X = x;
            Y = y;
            Id = id;
            Player = player;
        }

        /// <summary>
        /// Returneaza lista tuturor mutarilor permise pentru piesa curenta (this)
        /// in configuratia (tabla de joc) primita ca parametru
        /// </summary>
        public List<Move> ValidMoves(Board currentBoard)
        {
            // throw new Exception("Aceasta metoda trebuie implementata");
            List<Move> validMovesList = new List<Move>();

            // consideram toate mutarile posibile din jurul pozitiei curente
            for (int x = X - 1; x <= X + 1; ++x)
            {
                for (int y = Y - 1; y <= Y + 1; ++y)
                {
                    Move mutare = new Move(Id, x, y);

                    // si verificam care mutari sunt valide
                    if (IsValidMove(currentBoard, mutare))
                    {
                        validMovesList.Add(mutare);
                    }
                }
            }

            return validMovesList;
        }

        /// <summary>
        /// Testeaza daca o mutare este valida intr-o anumita configuratie
        /// </summary>
        public bool IsValidMove(Board currentBoard, Move move)
        {
            // throw new Exception("Aceasta metoda trebuie implementata");
            // verificam ca mutarea sa fie la doar un patrat distanta
            if (Math.Abs(move.NewX - X) > 1 || Math.Abs(move.NewY - Y) > 1)
            {
                return false;
            }

            // verificam ca noile coordonate sa nu fie in afara tablei de joc
            if (move.NewX < 0 || move.NewX >= currentBoard.Size
                || move.NewY < 0 || move.NewY >= currentBoard.Size)
            {
                return false;
            }

            // verificam daca pe pozitia noua se afla vreo alta piesa
            foreach (Piece piesa in currentBoard.Pieces)
            {
                if (piesa.X == move.NewX && piesa.Y == move.NewY)
                {
                    return false;
                }
            }

            // daca totul e in regula, mutarea este valida
            return true;
        }
    }
}


__________________________________MINMAX.cs_____________________________




using System;
using System.Collections.Generic;

namespace SimpleCheckers
{
    /// <summary>
    /// Implementeaza algoritmul de cautare a mutarii optime
    /// </summary>
    public class Minimax
    {
        private static Random _rand = new Random();

        /// <summary>
        /// Primeste o configuratie ca parametru, cauta mutarea optima si returneaza configuratia
        /// care rezulta prin aplicarea acestei mutari optime
        /// </summary>
        public static Board FindNextBoard(Board currentBoard)
        {
            // throw new Exception("Aceasta metoda trebuie implementata");
            // = algoritmul Minimax
            List<Board> listaConfiguratii = new List<Board>();
            List<Move> listaMutariValide;

            // parcurgem fiecare piesa de pe tabla
            foreach (Piece piesa in currentBoard.Pieces)
            {
                // doar in cazul pieselor computer-ului (nivelul maximizant)
                if (piesa.Player == PlayerType.Computer)
                {
                    // preluam lista de mutari valide ale piesei curente
                    listaMutariValide = piesa.ValidMoves(currentBoard);

                    // transformam aceasta lista de mutari intr-o lista de configuratii posibile
                    foreach (Move m in listaMutariValide)
                    {
                        listaConfiguratii.Add(currentBoard.MakeMove(m));
                    }
                }
            }

            // cautam mutarea pentru care functia de evaluare statica este maxima
            // consideram, initial, ca functia de evaluare este maxima in prima configuratie posibila
            double f_eval_max = listaConfiguratii[0].EvaluationFunction();
            double f_eval_curent;
            for (int i = 1; i < listaConfiguratii.Count; ++i)
            {
                f_eval_curent = listaConfiguratii[i].EvaluationFunction();
                if (f_eval_curent > f_eval_max)
                {
                    f_eval_max = f_eval_curent;
                }
            }

            // verificam daca exista mai multe maxime
            List<Board> listaConfiguratiiCuFEvalMaxim = new List<Board>();
            foreach (Board b in listaConfiguratii)
            {
                if (b.EvaluationFunction() == f_eval_max) // punem fiecare "cea mai buna configuratie" in lista
                {
                    listaConfiguratiiCuFEvalMaxim.Add(b);
                }
            }

            // daca exista mai multe configuratii cu aceeasi functie de evaluare maxima, returnam una aleatorie
            return listaConfiguratiiCuFEvalMaxim[_rand.Next(listaConfiguratiiCuFEvalMaxim.Count)];
        }
    }
}