public static IEnumerable<IMove> GetAllMovesForPlayer(GameBoard board, PlayerColor player)
        {
            IEnumerable<GameField> fields = board.GetFieldsByPlayer(player);
            List<IMove> forcedMoves = new List<IMove>();
            List<IMove> idleMoves = new List<IMove>();

            bool forcedOnly;

            foreach (GameField f in fields)
            {
                var moves = GetAllMovesFromField(board, f.Position, out forcedOnly);

                if (forcedOnly) forcedMoves.AddRange(moves);
                else idleMoves.AddRange(moves);
            }

            if (forcedMoves.Count > 0)
            {
                int longest = 0;

                forcedMoves.ForEach(mv => { if (mv.Length > longest) longest = mv.Length; });
                return forcedMoves.Where(mv => mv.Length == longest).ForEach<IMove, GameBoard>(SetMoveCaptures, board);
            }

            return idleMoves;
        }

    void ChangeOutfit(PlayerColor color)
    {
        transform.FindChild("Change_Fx_Front").GetComponent<Animator>().SetTrigger("Change");
        transform.FindChild("Change_Fx_Back").GetComponent<Animator>().SetTrigger("Change");

        StartCoroutine(DelayToChange(color));
    }

 private static Player CreatePlayer(string name, PlayerColor color, Sex sex, int n)
 {
     var player = new Player(name, color, sex);
       int i = 0;
       StuffManager stuffManager = StuffManager.Instance;
       foreach (IDxMCard dxMCard in stuffManager.DxMCards)
       {
     if (dxMCard is ICheatCard) continue;
     if (dxMCard is IRaceCard && player.RaceCards.Count < 2)
       player.RaceCards.Add((IRaceCard)dxMCard);
     else if (dxMCard is IClassCard && player.ClassCards.Count < 2)
       player.ClassCards.Add((IClassCard)dxMCard);
     else if (dxMCard is IHalfBreededCard)
       player.HalfBreededCard = (IHalfBreededCard)dxMCard;
     else if (dxMCard is ISuperManchkinCard)
       player.SuperManchkinCard = (ISuperManchkinCard)dxMCard;
     else
       player.HandCards.Add(dxMCard);
       }
       foreach (ITreasureCard treasureCard in stuffManager.TreasureCards)
       {
     ICheatCard cheatCard = i++ == 4 ? stuffManager.DxMCards.OfType<ICheatCard>().Single() : null;
     player.WornItems.Add(Tuple.Create(treasureCard, cheatCard));
       }
       /*
     for (int j = 0; j < n * 2; j++)
       player.HandCards.Add(cardManager.TreasureCards.First());
       */
       return player;
 }

 public Piece(PlayerColor playerColor, PieceType pieceType, byte x, byte y)
 {
     playerColorValue = playerColor;
     pieceTypeValue = pieceType;
     xValue = x;
     yValue = y;
 }

        public static bool CheckForGameEnd(GameBoard board, out PlayerColor winner)
        {
            int whitePieces = board.GetPieceCountByOccupation(PlayerColor.White);
            int blackPieces = board.GetPieceCountByOccupation(PlayerColor.Black);

            if (whitePieces == 0)
            {
                winner = PlayerColor.Black;
                return true;
            }
            else if (blackPieces == 0)
            {
                winner = PlayerColor.White;
                return true;
            }
            else if (board.IdleMoves >= MAX_IDLE_MOVES)
            {
                if (whitePieces == blackPieces)
                {
                    winner = PlayerColor.None;
                    return true;
                }

                winner = whitePieces > blackPieces ? PlayerColor.White : PlayerColor.Black;
                return true;
            }

            winner = PlayerColor.None;
            return false;
        }

 public EndGameAction(System.IO.BinaryReader reader)
 {
     this.hasCheckmate = reader.ReadBoolean();
     if (this.hasCheckmate)
         this.looser = (PlayerColor)reader.ReadByte();
     else
         this.stalemateReason = (StalemateReason)reader.ReadByte();
 }

 public Player(string name, int playerNumber, PlayerColor color, string textualRepresentation)
 {
     this.Pawns = new List<Pawn>(5);
     this.Name = name;
     this.PlayerNumber = playerNumber;
     this.Color = color;
     this.TextualRepresentation = textualRepresentation;
 }

        public Player GetPlayer(PlayerColor color)
        {
            if (this.PlayerColor == color)
                return new HumanPlayer();
            //return new ComputerPlayer(AILevel.Hard);

            return new ComputerPlayer(this.AILevel < AILevel.Easy ? AILevel.Medium : this.AILevel);
        }

        public Piece(PlayerColor couleur, String nom)
        {
            if (couleur == PlayerColor.White)
                this.nom = nom + "B";
            else
                this.nom = nom + "N";

            this.couleur = couleur;
        }

 public WinBoard(PlayerColor color, AILevel aiLevel, string startFen, string engine)
 {
     this.color = color;
     this.AILevel = aiLevel;
     this.startFen = startFen;
     var psi = new ProcessStartInfo { UseShellExecute = false, CreateNoWindow = true, FileName = "engines\\polyglot", Arguments = "engines\\" + engine + ".ini", RedirectStandardInput = true, RedirectStandardOutput = true };
     this.process = Process.Start(psi);
     this.output = this.process.StandardOutput;
     this.input = this.process.StandardInput;
 }

 private static Image DrawSquare(SquareColor color, PlayerColor player = 0, Type piece = null)
 {
     var image = new Bitmap(100, 100);
     using (var g = Graphics.FromImage(image))
     {
         g.FillRectangle(new SolidBrush(color.ToColor()), 0, 0, 100, 100);
         if (piece != null)
             g.DrawImage(Images.GetPieceImage(player, piece), 0, 0, 100, 100);
     }
     return image;
 }

 //
 public void PlayerDied(PlayerColor color)
 {
     foreach(var startingPosObj in this.StartingPositions.transform)
     {
         var startingPos =  ((Transform)startingPosObj).GetComponent<StartingPosition>();
         if (startingPos.IsActive && startingPos.PlayerColor == color)
         {
             StartCoroutine( startingPos.SpawnPlayer() );
             break;
         }
     }
 }

 public Player(PlayerColor color, RaceName race, bool isHuman)
 {
     Color = color;
     Race = race;
     Money = 70;
     TimeLeft =      30 * 25;
     MaxTurnTime =   30 * 25;
     UnitCount = 0;
     StationCount = 0;
     IsHuman = isHuman;
     Strategy = new HumanStrategy();
 }

        private void AddPlayer(string playerTokenUrl, PlayerColor playerColor)
        {
            NumberOfPlayers++;
            var player = new Player
            {
                Name = string.Format("Player {0}", NumberOfPlayers),
                ImageUri = new Uri(playerTokenUrl),
                TurnOrder = NumberOfPlayers,
                GameTokenColor = playerColor
            };

            PlayerList.Add(player);
        }

    // Use this for initialization
    void Start()
    {
        var kvp = PlayerManager.Instance.GetPlayerFor( this.MatchupForPlayers );
        if (kvp.HasValue)
        {
            this.IsActive = true;

            this.PlayerColor = kvp.Value.Key;
            this.playerActions = kvp.Value.Value;

            StartCoroutine( this.SpawnPlayer() );
        }
    }

 public void ComputeBestMove(GameBoard board, PlayerColor player, int depth)
 {
     VerifyAccess();
     Reset();
     CTS = new CancellationTokenSource();
     AIState state = new AIState(board, player, depth);
     _task = new Task<IMove>(GetBestMove, state, CTS.Token);
     _task.ContinueWith(task =>
         {
             BestMove = task.Result;
             Dispatcher.BeginInvoke((Action)OnBestMoveChosen, null);
         });
     _task.Start();
 }

 public static bool isLegalMove(Piece movingPiece, Piece targetPiece, PlayerColor currentPlayer)
 {
     if (movingPiece.playerColor == currentPlayer && targetPiece.playerColor != currentPlayer)
     {
         if (Math.Abs(movingPiece.x - targetPiece.x) == 1)
         {
             if ((movingPiece.playerColor == PlayerColor.White &&
                 movingPiece.y - targetPiece.y == 1) ||
                 (movingPiece.playerColor == PlayerColor.Black &&
                 movingPiece.y - targetPiece.y == -1)) return true;
         }
     }
     return false;
 }

 public static PlayerColor OtherPlayer(PlayerColor player)
 {
     switch (player)
     {
         case PlayerColor.None:
             throw new ArgumentException();
         case PlayerColor.Black:
             return PlayerColor.White;
         case PlayerColor.White:
             return PlayerColor.Black;
         default:
             throw new ArgumentException();
     }
 }

        public Token3D(Vector3D basePoint, PlayerColor color)
            : base(basePoint)
        {
            switch (color) {
                case PlayerColor.Black:
                    firstColor = Color.Blue;
                    secondColor = Color.DarkBlue;
                    break;
                case PlayerColor.White:
                    firstColor = Color.Red;
                    secondColor = Color.DarkRed;
                    break;
            }

            List<Vector3D> up = new List<Vector3D>();
            List<Vector3D> down = new List<Vector3D>();

            for (int i = 0; i <= 16; ++i) {
                int gegenkathete = (int) (Math.Sin((Math.PI / (RESOLUTION / 2)) * i) * RADIUS);
                int ankathete = (int)(Math.Cos((Math.PI / (RESOLUTION / 2)) * i) * RADIUS);

                up.Add(new Vector3D(ankathete, gegenkathete, HEIGHT));
                down.Add(new Vector3D(ankathete, gegenkathete, 0));
            }

            // Circle down
            for (int i = 0; i < down.Count - 1; ++i) {
                this.addTriangle(new Triangle3D(new Vector3D(0, 0, 10), down[i], down[i + 1], firstColor));
            }
            this.addTriangle(new Triangle3D(new Vector3D(0, 0, 10), down[down.Count - 1], down[0], firstColor));

            // Side Triangle up, up, down
            for (int i = 0; i < up.Count - 1; ++i) {
                this.addTriangle(new Triangle3D(up[i], up[i + 1], down[i], secondColor));
            }
            this.addTriangle(new Triangle3D(up[up.Count - 1], up[1], down[down.Count - 1], secondColor));

            // Side Triangle down, down, up
            for (int i = 0; i < down.Count - 1; ++i) {
                this.addTriangle(new Triangle3D(down[i], down[i + 1], up[i + 1], secondColor));
            }
            this.addTriangle(new Triangle3D(down[down.Count - 1], down[1], up[1], secondColor));

            // Circle Up
            for (int i = 0; i < up.Count - 1; ++i) {
                this.addTriangle(new Triangle3D(new Vector3D(0, 0, 10), up[i], up[i + 1], firstColor));
            }
            this.addTriangle(new Triangle3D(new Vector3D(0, 0, 10), up[up.Count - 1], up[0], firstColor));
        }

        public Plateau()
        {
            rectangleSelection = new Selection();
            plateauRectangle = new Rectangle(0, 0, 352, 352);
            plateauValeur = new Case[8, 8];
            positionPossibilities = new List<Point>();
            playerTour = PlayerColor.White;

            pieceIsSelected = false;
            isEchec = false;
            isEchecEtMat = false;

            CaseHeight = 44;
            CaseWidth = 44;
        }