C# Piece.MovePosition方法代码示例

    List<Vector2> IsTheKingPutInCheck(List<Vector2> moves, Piece piece)
    {
        //In this method I am going to simulate the board state and then
        //Move the piece in question to see if its movement will open
        //an attack route to the king, if it does the move will be prohibited.

        List<Vector2> allowedMoves = new List<Vector2>();

        Tile[,] clonedTiles = MakeVirtualTiles(tiles);

        Piece[] clonedPieces = MakeVirtualPieces(pieces);

        Piece pieceClone = new Piece();

        //Deep Clones the Peice so I can move it around.
        foreach (Piece clonedPiece in clonedPieces)
        {
            if (clonedPiece.MyCoordinates() == piece.MyCoordinates())
            {
                pieceClone = clonedPiece;
            }
        }

        Vector2 origin = piece.MyCoordinates();

        foreach (Vector2 move in moves)
        {
            pieceClone.MovePosition(move);

            //These did not help
            clonedTiles[(int)origin.x, (int)origin.y].occupied = false;
            clonedTiles[(int)move.x, (int)move.y].occupied = true;

            ThreatCheck(clonedTiles, clonedPieces);

            if (!CheckCheck(pieceClone.player, clonedPieces, clonedTiles))
            {
                allowedMoves.Add(move);
            }

            pieceClone.MovePosition(origin);

            clonedTiles[(int)origin.x, (int)origin.y].occupied = true;
            clonedTiles[(int)move.x, (int)move.y].occupied = false;
        }

        return allowedMoves;
    }

    List<Vector2> GetOutOfCheck(List<Vector2> moves, Piece piece)
    {
        //NOTE problem with pawns captureing other pawns to remove the king from check
        //By the time I get here I get 6 make Virtual Piece calls gotta fix that. (Should be 4) TODO

        // The way I do this will be horribly inneficent I think. If performance becomes an issue
        //I should head here first. Most notably if I pass a list instead of a single peice when
        //Used to determin checkmate it will reduce the generation of virtual stuff to once
        //Instead of once per piece.

        //TODO we gotta add captures to the equation.

        List<Vector2> allowedMoves = new List<Vector2>();

        Tile[,] virtualTiles = MakeVirtualTiles(tiles);
        Piece[] virtualPieces = MakeVirtualPieces(pieces);
        Piece virtualPiece = new Piece();

        //Clones the piece in question
        foreach (Piece vPiece in virtualPieces)
        {
            if (piece.MyCoordinates() == vPiece.MyCoordinates())
            {
                virtualPiece = vPiece;
            }
        }

        Vector2 origin = virtualPiece.MyCoordinates();

        Debug.Log(moves.Count + " moves to check");
        foreach (Vector2 move in moves)
        {
            foreach (Piece vPiece in virtualPieces)
            {
                if (vPiece.MyCoordinates() == move)
                {
                    Debug.Log("Captured @ " + move);
                    vPiece.captured = true;
                }
            }

            virtualPiece.MovePosition(move);

            UpdateTileOccupation(virtualTiles, virtualPieces);

            ClearThreats(virtualTiles);

            ThreatCheck(virtualTiles, virtualPieces);

            if (!CheckCheck(virtualPiece.player, virtualPieces, virtualTiles))
            {
                allowedMoves.Add(move);
            }

            //Return Peice to location and try next move.
            virtualPiece.MovePosition(origin);
        }

        return allowedMoves;
    }