示例#1
0
 public FastMove(FastIndex start, FastIndex target, MoveType moveType, FastPiece promoteTo)
 {
     this.start     = start;
     this.target    = target;
     this.moveType  = moveType;
     this.promoteTo = promoteTo;
 }
示例#2
0
 public FastMove(HexAIMove move)
 {
     this.start     = FastIndex.FromByte(move.start.ToByte());
     this.target    = FastIndex.FromByte(move.target.ToByte());
     this.moveType  = move.moveType;
     this.promoteTo = move.promoteTo.ToFastPiece();
 }
示例#3
0
 public FastMove(Index start, Index target, MoveType moveType, FastPiece promoteTo)
 {
     this.start     = FastIndex.FromByte(start.ToByte());
     this.target    = FastIndex.FromByte(target.ToByte());
     this.moveType  = moveType;
     this.promoteTo = promoteTo;
 }
示例#4
0
    static int GetPieceValue(FastPiece piece)
    {
        switch (piece)
        {
        case FastPiece.King:
            return(10000);

        case FastPiece.Queen:
            return(1000);

        case FastPiece.Rook:
            return(525);

        case FastPiece.Knight:
            return(350);

        case FastPiece.Bishop:
            return(350);

        case FastPiece.Squire:
            return(300);

        case FastPiece.Pawn:
        default:
            return(100);
        }
    }
示例#5
0
        public static Piece ToPiece(this FastPiece piece)
        {
            switch (piece)
            {
            case FastPiece.King:
                return(Piece.King);

            case FastPiece.Queen:
                return(Piece.Queen);

            case FastPiece.Rook:
                return(Piece.KingsRook);

            case FastPiece.Bishop:
                return(Piece.KingsBishop);

            case FastPiece.Knight:
                return(Piece.KingsKnight);

            case FastPiece.Squire:
                return(Piece.GraySquire);

            case FastPiece.Pawn:
                return(Piece.Pawn1);

            default:
                return(Piece.Pawn1);
            }
        }
 private static bool IsDefendable(FastPiece needle)
 {
     return(needle == FastPiece.King ||
            needle == FastPiece.Queen ||
            needle == FastPiece.Knight ||
            needle == FastPiece.Bishop ||
            needle == FastPiece.Squire);
 }
    public static void AddAllPossibleMoves(List <FastMove> moves, FastIndex start, FastPiece piece, Team team, FastBoardNode boardNode, bool generateQuiet = true)
    {
        switch (piece)
        {
        case FastPiece.King:
            AddAllPossibleKingMoves(moves, start, team, boardNode, generateQuiet);
            return;

        case FastPiece.Queen:
            AddAllPossibleQueenMoves(moves, start, team, boardNode, generateQuiet);
            return;

        case FastPiece.Rook:
            AddAllPossibleRookMoves(moves, start, team, boardNode, generateQuiet);
            return;

        case FastPiece.Knight:
            AddAllPossibleKnightMoves(moves, start, team, boardNode, generateQuiet);
            return;

        case FastPiece.Bishop:
            AddAllPossibleBishopMoves(moves, start, team, boardNode, generateQuiet);
            return;

        case FastPiece.Squire:
            AddAllPossibleSquireMoves(moves, start, team, boardNode, generateQuiet);
            return;

        case FastPiece.Pawn:
            AddAllPossiblePawnMoves(moves, start, team, boardNode, generateQuiet);
            return;

        default:
            throw new ArgumentException($"Unhandled piece type: {piece}", nameof(piece));
        }
    }
 private static bool Contains(FastPiece[] haystack, FastPiece needle)
 {
     return(Array.IndexOf(haystack, needle) >= 0);
 }