src/chess/king.c

Thu, 17 Apr 2014 11:41:02 +0200

author
Mike Becker <universe@uap-core.de>
date
Thu, 17 Apr 2014 11:41:02 +0200
changeset 44
1891d88cbd10
parent 25
3ab0c2e1a4e2
child 47
d726e4b46c33
permissions
-rw-r--r--

surrender is now resign

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2014 Mike Becker. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 */

#include "rules.h"
#include "king.h"
#include <stdlib.h>

static _Bool king_castling_chkmoved(GameState *gamestate,
    uint8_t row, uint8_t file) {
    
    MoveList *ml = gamestate->movelist;
    while (ml) {
        if (ml->move.fromfile == file && ml->move.fromrow == row) {
            return 1;
        }
        ml = ml->next;
    }
    
    return 0;
}

_Bool king_chkrules(GameState *gamestate, Move* move) {
    if (abs(move->torow - move->fromrow) <= 1 &&
        abs(move->tofile - move->fromfile) <= 1) {
        return 1;
    } else {
        /* castling */
        if (move->fromrow == move->torow &&
            move->fromrow == ((move->piece&COLOR_MASK) == WHITE ? 0 : 7) &&
            move->fromfile == fileidx('e') &&
            (move->tofile == fileidx('c') || move->tofile == fileidx('g'))) {
            
            return !king_castling_chkmoved(gamestate,
                move->fromrow, move->fromfile) &&
                !king_castling_chkmoved(gamestate, move->fromrow,
                move->tofile == fileidx('c') ? 0 : 7);
        } else {
            return 0;
        }
    }
}

_Bool king_isblocked(GameState *gamestate, Move *move) {
    
    uint8_t opponent_color = opponent_color(move->piece&COLOR_MASK);
    _Bool blocked = is_covered(gamestate, move->torow, move->tofile,
        opponent_color);
    
    if (abs(move->tofile - move->fromfile) == 2) {
        if (move->tofile == fileidx('c')) {
            blocked |= gamestate->board[move->torow][fileidx('b')];
        }
        uint8_t midfile = (move->tofile+move->fromfile)/2;
        blocked |= gamestate->lastmove->move.check ||
            gamestate->board[move->torow][midfile] ||
            is_covered(gamestate, move->torow, midfile, opponent_color);
    }
    
    return blocked;
}

int king_getlocation(GameState *gamestate, Move *move) {
    
    uint8_t file, row;
    
    for (int f = -1 ; f <= 1 ; f++) {
        for (int r = -1 ; r <= 1 ; r++) {
            if (f == 0 && r == 0) {
                continue;
            }
            file = move->tofile + f;
            row = move->torow + r;
            if (isidx(file) && isidx(row)) {
                if (gamestate->board[row][file] == move->piece) {
                    if ((move->fromfile != POS_UNSPECIFIED
                        && move->fromfile != file) ||
                        (move->fromrow != POS_UNSPECIFIED
                        && move->fromrow != row)) {
                        return INVALID_POSITION;
                    }
                    move->fromfile = file;
                    move->fromrow = row;
                    return VALID_MOVE_SYNTAX;
                }
            }
        }
    }
    
    return INVALID_POSITION;
}

mercurial