Example #1
0
/* ---------------------------------------------------------------------------------------
	void generate_moves(CHESS_STATE *current_state)
	
	purpose: the search tree function - gets all child states for a given state.
	NOTE: this function simply gets all moves for an immediate chess state using
	bitboard maths etc. It _may_ include illegal moves (eg if king is left exposed.
	Such illegal moves are filtered out using iterative deepening function (see later
	in source), using flg_is_illegal flag on node.
   --------------------------------------------------------------------------------------- */
void generate_moves(CHESS_STATE *current_state)
{
	bitboard pieces=0;		// bitboard of pieces under investigation
	bitboard piece;			// bitboard of single piece

	COLOR_ENUM color = (current_state->flg_is_white_move) ? BB_WHITE : BB_BLACK;
	COLOR_ENUM opponent_color = (current_state->flg_is_white_move) ? BB_BLACK : BB_WHITE;

	// calculated bitboards
	int i;

	// empty and opponents squares cached for performance
	bitboard empty_squares = EMPTY_BOARD;
	bitboard opponents_squares = EMPTY_BOARD;
		
	for (i=0; i< BB_COUNT; i++)
	{
		empty_squares |= current_state->boards[i];
	}
	empty_squares = ~empty_squares;
	
	for (i=0; i<6; i++)
	{
		opponents_squares |= current_state->boards[opponent_color+i];
	}
		
	// pawns
	pawn_moves(current_state,empty_squares);
	pawn_double_moves(current_state,empty_squares);
	en_passant_moves(current_state);
	pawn_capture_moves(current_state,empty_squares, opponents_squares);

	//knight
	fp_cached_move_mask knight_func = &cached_knight_move_mask;
	simple_move_mask_moves(current_state, BB_KNIGHT, knight_func, empty_squares, opponents_squares);

	//king
	fp_cached_move_mask king_func = &cached_king_move_mask;
	simple_move_mask_moves(current_state, BB_KING, king_func, empty_squares, opponents_squares);

	// rook
	fp_cached_sliding_move_mask rook_func = &cached_rook_move_mask;
	sliding_moves(current_state,empty_squares,opponents_squares,BB_ROOK,rook_func);
		
	// bishop
	fp_cached_sliding_move_mask bishop_func = &cached_bishop_move_mask;
	sliding_moves(current_state,empty_squares,opponents_squares,BB_BISHOP,bishop_func);
	
	// queen
	sliding_moves(current_state,empty_squares,opponents_squares,BB_QUEEN,rook_func);
	sliding_moves(current_state,empty_squares,opponents_squares,BB_QUEEN,bishop_func);
	
}
Example #2
0
void gen_moves(const board& b, piece_colour pc, move* movelist, int& num_moves)
{
  for (int i = 0; i < 8; i++)
  {
    for (int j = 0; j < 8; j++)
    {
      row_col rc(i, j);
      square s = b.get(rc);
      if (pc == get_piece_colour(s))
      {
         piece_type pt = get_piece_type(s);
         switch (pt)
         {
         case NONE:
           assert(0); // only here if square contains one of our pieces
           break;
         case PAWN:
           pawn_moves(pc, rc, b, movelist, num_moves);
           break; 
         case KNIGHT:
           knight_moves(pc, rc, b, movelist, num_moves);
           break;
         case BISHOP:
           bishop_moves(pc, rc, b, movelist, num_moves);
           break;
         case ROOK:
           rook_moves(pc, rc, b, movelist, num_moves);
           break;
         case KING:
           king_moves(pc, rc, b, movelist, num_moves);
           break;
         case QUEEN:
           queen_moves(pc, rc, b, movelist, num_moves);
           break;
         }
      }
    }
  }
}
Example #3
0
File: Chess.c Project: ishefi/chess
/*
* return the non-eat (simple) moves.
* curr = starting coordinate of the move
* max_step = length of maximal possible step (1 for man, BOARD_SIZE for king)
* in case of an error - return error_moves
*/
moves get_simple_moves(settings * set, cord curr){
	char piece = board_piece(set->board, curr);
	int color = which_color(piece);
	int type = tolower(piece);
	moves all_simple_moves = { 0 };
	switch (type)
	{
	case PAWN:
		return pawn_moves(set, curr, color);
	case BISHOP:
		return bishop_moves(set, curr, color, FALSE);
	case ROOK:
		return rook_moves(set, curr, color, FALSE);
	case KNIGHT:
		return knight_moves(set, curr, color);
	case QUEEN:
		return queen_moves(set, curr, color, FALSE);
	case KING:
		return king_moves(set, curr, color);
	default:
		return all_simple_moves;
	}
}
Example #4
0
File: move.c Project: jes/zoe
/* return the set of all squares the given piece is able to move to, without
 * considering a king left in check */
uint64_t generate_moves(Game *game, int tile) {
    Board *board = &(game->board);
    int colour = !(board->b[WHITE][OCCUPIED] & (1ull << tile));
    int type = board->mailbox[tile];
    uint64_t moves = 0;
    uint64_t blockers;

    switch(type) {
    case PAWN:
        moves = pawn_moves(board, tile);

        int x = tile % 8, y = tile / 8;

        if((game->ep == x + 1 || game->ep == x - 1) && (y == 4 - colour))
            moves |= 1ull << ((5 - colour * 3) * 8 + game->ep);
        break;

    case KNIGHT:
        moves = knight_moves[tile];
        break;

    case BISHOP:
        moves = bishop_moves(board, tile);
        break;

    case ROOK:
        moves = rook_moves(board, tile);
        break;

    case QUEEN:
        moves = bishop_moves(board, tile) | rook_moves(board, tile);
        break;

    case KING:
        moves = king_moves[tile];

        /* queenside castling */
        if(game->can_castle[colour][QUEENSIDE]) {
            blockers = ((1ull << (tile - 1)) | (1ull << (tile - 2))
                | (1ull << (tile - 3))) & board->occupied;

            /* if there are no pieces in the way and no intermediate tiles are
             * threatened, add the move
             */
            if(!blockers && !is_threatened(board, tile)
                    && !is_threatened(board, tile - 1)
                    && !is_threatened(board, tile - 2))
                moves |= 1ull << (tile - 2);
        }

        /* kingisde castling */
        if(game->can_castle[colour][KINGSIDE]) {
            blockers = ((1ull << (tile + 1)) | (1ull << (tile + 2)))
                & board->occupied;

            /* if there are no pieces in the way and no intermediate tiles are
             * threatened, add the move
             */
            if(!blockers && !is_threatened(board, tile)
                    && !is_threatened(board, tile + 1)
                    && !is_threatened(board, tile + 2))
                moves |= 1ull << (tile + 2);
        }
        break;
    }

    /* return the moves, removing the final tile if it ended on our own
     * colour.
     */
    return moves & ~board->b[colour][OCCUPIED];
}