mirror of
https://github.com/peterosterlund2/droidfish.git
synced 2024-12-05 01:35:50 +01:00
391 lines
8.2 KiB
C
391 lines
8.2 KiB
C
/*
|
|
This Software is distributed with the following X11 License,
|
|
sometimes also known as MIT license.
|
|
|
|
Copyright (c) 2010 Miguel A. Ballicora
|
|
|
|
Permission is hereby granted, free of charge, to any person
|
|
obtaining a copy of this software and associated documentation
|
|
files (the "Software"), to deal in the Software without
|
|
restriction, including without limitation the rights to use,
|
|
copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
copies of the Software, and to permit persons to whom the
|
|
Software is furnished to do so, subject to the following
|
|
conditions:
|
|
|
|
The above copyright notice and this permission notice shall be
|
|
included in all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
|
|
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
OTHER DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include "gtb-att.h"
|
|
|
|
#if 0
|
|
|
|
#include "mtypes.h"
|
|
#include "bool_t.h"
|
|
#include "maindef.h"
|
|
|
|
#else
|
|
|
|
/* mtypes.h */
|
|
|
|
typedef unsigned int SQUARE;
|
|
typedef unsigned char SQ_CONTENT;
|
|
|
|
/* bool_t.h */
|
|
|
|
#if !defined(bool_t)
|
|
typedef int bool_t;
|
|
#endif
|
|
|
|
#if !defined(TRUE)
|
|
#define TRUE ((bool_t)1)
|
|
#endif
|
|
|
|
#if !defined(FALSE)
|
|
#define FALSE ((bool_t)0)
|
|
#endif
|
|
|
|
/* maindef.h */
|
|
|
|
#define NOPIECE 0u
|
|
#define PAWN 1u
|
|
#define KNIGHT 2u
|
|
#define BISHOP 3u
|
|
#define ROOK 4u
|
|
#define QUEEN 5u
|
|
#define KING 6u
|
|
#define PIECE_MASK (KING|PAWN|KNIGHT|BISHOP|ROOK|QUEEN)
|
|
|
|
/*Whites*/
|
|
#define wK (KING | WHITES)
|
|
#define wP (PAWN | WHITES)
|
|
#define wN (KNIGHT | WHITES)
|
|
#define wB (BISHOP | WHITES)
|
|
#define wR (ROOK | WHITES)
|
|
#define wQ (QUEEN | WHITES)
|
|
|
|
/*Blacks*/
|
|
#define bK (KING | BLACKS)
|
|
#define bP (PAWN | BLACKS)
|
|
#define bN (KNIGHT | BLACKS)
|
|
#define bB (BISHOP | BLACKS)
|
|
#define bR (ROOK | BLACKS)
|
|
#define bQ (QUEEN | BLACKS)
|
|
|
|
/*Bits that define color */
|
|
|
|
#define WHITES (1u<<6)
|
|
#define BLACKS (1u<<7)
|
|
|
|
/*squares*/
|
|
enum SQUARES {
|
|
A1,B1,C1,D1,E1,F1,G1,H1,
|
|
A2,B2,C2,D2,E2,F2,G2,H2,
|
|
A3,B3,C3,D3,E3,F3,G3,H3,
|
|
A4,B4,C4,D4,E4,F4,G4,H4,
|
|
A5,B5,C5,D5,E5,F5,G5,H5,
|
|
A6,B6,C6,D6,E6,F6,G6,H6,
|
|
A7,B7,C7,D7,E7,F7,G7,H7,
|
|
A8,B8,C8,D8,E8,F8,G8,H8,
|
|
NOSQUARE,
|
|
ERRSQUARE = 128
|
|
};
|
|
#endif
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
#ifndef NDEBUG
|
|
#define NDEBUG
|
|
#endif
|
|
#ifdef DEBUG
|
|
#undef NDEBUG
|
|
#endif
|
|
#include "assert.h"
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
/* global variables */
|
|
uint64_t Reach [7] [64];
|
|
|
|
/* static variables */
|
|
static unsigned char attmap [64] [64];
|
|
static unsigned int attmsk [256];
|
|
|
|
/* static functions */
|
|
static unsigned int mapx88 (unsigned int x);
|
|
|
|
/* macros */
|
|
#define BB_ISBITON(bb,bit) (0 != (((bb)>>(bit)) & U64(1)))
|
|
|
|
#define map88(x) ( (x) + ((x)&070) )
|
|
#define unmap88(x) ( ( (x) + ((x)& 07) ) >> 1 )
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static unsigned int
|
|
mapx88 (unsigned int x)
|
|
{
|
|
return ((x & 070) << 1) | (x & 07);
|
|
}
|
|
|
|
|
|
void
|
|
attack_maps_init(void)
|
|
{
|
|
int i;
|
|
unsigned int m, from, to;
|
|
unsigned int to88, fr88;
|
|
int diff;
|
|
|
|
uint64_t rook, bishop, queen, knight, king;
|
|
|
|
if (!reach_was_initialized()) {
|
|
printf ("Wrong initialization order of data\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
for (i = 0; i < 256; ++i) {
|
|
attmsk [i] = 0;
|
|
}
|
|
attmsk[wP] = 1 << 0;
|
|
attmsk[bP] = 1 << 1;
|
|
|
|
attmsk[KNIGHT] = 1 << 2;
|
|
attmsk[wN] = 1 << 2;
|
|
attmsk[bN] = 1 << 2;
|
|
|
|
attmsk[BISHOP] = 1 << 3;
|
|
attmsk[wB] = 1 << 3;
|
|
attmsk[bB] = 1 << 3;
|
|
|
|
attmsk[ROOK ] = 1 << 4;
|
|
attmsk[wR] = 1 << 4;
|
|
attmsk[bR] = 1 << 4;
|
|
|
|
attmsk[QUEEN ] = 1 << 5;
|
|
attmsk[wQ] = 1 << 5;
|
|
attmsk[bQ] = 1 << 5;
|
|
|
|
attmsk[KING ] = 1 << 6;
|
|
attmsk[wK] = 1 << 6;
|
|
attmsk[bK] = 1 << 6;
|
|
|
|
for (to = 0; to < 64; ++to) {
|
|
for (from = 0; from < 64; ++from) {
|
|
m = 0;
|
|
rook = Reach [ROOK] [from];
|
|
bishop = Reach [BISHOP] [from];
|
|
queen = Reach [QUEEN] [from];
|
|
knight = Reach [KNIGHT] [from];
|
|
king = Reach [KING] [from];
|
|
|
|
if (BB_ISBITON (knight, to)) {
|
|
m |= attmsk[wN];
|
|
}
|
|
if (BB_ISBITON (king, to)) {
|
|
m |= attmsk[wK];
|
|
}
|
|
if (BB_ISBITON (rook, to)) {
|
|
m |= attmsk[wR];
|
|
}
|
|
if (BB_ISBITON (bishop, to)) {
|
|
m |= attmsk[wB];
|
|
}
|
|
if (BB_ISBITON (queen, to)) {
|
|
m |= attmsk[wQ];
|
|
}
|
|
|
|
to88 = mapx88(to);
|
|
fr88 = mapx88(from);
|
|
diff = (int)to88 - (int)fr88;
|
|
|
|
if (diff == 17 || diff == 15) {
|
|
m |= attmsk[wP];
|
|
}
|
|
if (diff == -17 || diff == -15) {
|
|
m |= attmsk[bP];
|
|
}
|
|
|
|
attmap [to] [from] = (unsigned char) m;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
bool_t
|
|
possible_attack(unsigned int from, unsigned int to, unsigned int piece)
|
|
{
|
|
|
|
assert (piece < 256);
|
|
assert (from < 64 && to < 64);
|
|
assert (reach_was_initialized());
|
|
assert (attmsk [piece] != 0 || 0==fprintf(stderr, "PIECE=%d\n",piece) ); /* means piece has been considered */
|
|
|
|
return 0 != (attmap [to] [from] & attmsk [piece]);
|
|
}
|
|
|
|
/*
|
|
|
|
|
| REACH ROUTINES
|
|
|
|
|
\*----------------------------------------------*/
|
|
|
|
|
|
enum Key {REACH_INITIALIZED_KEY = 0x1313};
|
|
static int reach_initialized_key = 0;
|
|
|
|
bool_t
|
|
reach_was_initialized (void)
|
|
{
|
|
return reach_initialized_key == REACH_INITIALIZED_KEY;
|
|
}
|
|
|
|
void
|
|
reach_init (void)
|
|
{
|
|
SQUARE buflist[64+1], *list;
|
|
SQ_CONTENT pc;
|
|
int stp_a [] = {15, -15 };
|
|
int stp_b [] = {17, -17 };
|
|
int STEP_A, STEP_B;
|
|
unsigned int side;
|
|
unsigned int index;
|
|
SQUARE sq, us;
|
|
|
|
int s;
|
|
|
|
for (pc = KNIGHT; pc < (KING+1); pc++) {
|
|
for (sq = 0; sq < 64; sq++) {
|
|
uint64_t bb = U64(0x0);
|
|
tolist_rev (U64(0x0), pc, sq, buflist);
|
|
for (list = buflist; *list != NOSQUARE; list++) {
|
|
bb |= U64(1) << *list;
|
|
}
|
|
Reach [pc] [sq] = bb;
|
|
}
|
|
}
|
|
|
|
for (side = 0; side < 2; side++) {
|
|
index = 1u ^ side;
|
|
STEP_A = stp_a[side];
|
|
STEP_B = stp_b[side];
|
|
for (sq = 0; sq < 64; sq++) {
|
|
|
|
int sq88 = (int)map88(sq);
|
|
uint64_t bb = U64(0x0);
|
|
|
|
list = buflist;
|
|
|
|
|
|
s = sq88 + STEP_A;
|
|
if (0 == (s & 0x88)) {
|
|
us = (SQUARE)unmap88(s);
|
|
*list++ = us;
|
|
}
|
|
s = sq88 + STEP_B;
|
|
if (0 == (s & 0x88)) {
|
|
us = (SQUARE)unmap88(s);
|
|
*list++ = us;
|
|
}
|
|
*list = NOSQUARE;
|
|
|
|
for (list = buflist; *list != NOSQUARE; list++) {
|
|
bb |= U64(1) << *list;
|
|
}
|
|
Reach [index] [sq] = bb;
|
|
}
|
|
}
|
|
reach_initialized_key = REACH_INITIALIZED_KEY;
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------------*/
|
|
|
|
static const int bstep[] = { 17, 15, -15, -17, 0};
|
|
static const int rstep[] = { 1, 16, -1, -16, 0};
|
|
static const int nstep[] = { 18, 33, 31, 14, -18, -33, -31, -14, 0};
|
|
static const int kstep[] = { 1, 17, 16, 15, -1, -17, -16, -15, 0};
|
|
|
|
static const
|
|
int *psteparr[] = {NULL, NULL, /* NOPIECE & PAWN */
|
|
nstep, bstep, rstep, kstep, kstep /* same for Q & K*/
|
|
};
|
|
static const
|
|
int pslider[] = {FALSE, FALSE,
|
|
FALSE, TRUE, TRUE, TRUE, FALSE
|
|
};
|
|
|
|
void
|
|
tolist_rev (uint64_t occ, SQ_CONTENT input_piece, SQUARE sq, SQUARE *list)
|
|
/* reversible moves from pieces. Output is a list of squares */
|
|
{
|
|
int direction;
|
|
unsigned int pc;
|
|
int s;
|
|
int from;
|
|
int step;
|
|
const int *steparr;
|
|
bool_t slider;
|
|
SQUARE us;
|
|
|
|
assert (sq < 64);
|
|
|
|
/* i.e. no pawn allowed as input */
|
|
assert (input_piece == KNIGHT || input_piece == BISHOP ||
|
|
input_piece == ROOK || input_piece == QUEEN ||
|
|
input_piece == KING);
|
|
|
|
from = (int)map88(sq);
|
|
|
|
pc = input_piece & (PAWN|KNIGHT|BISHOP|ROOK|QUEEN|KING);
|
|
|
|
steparr = psteparr [pc];
|
|
slider = pslider [pc];
|
|
|
|
if (slider) {
|
|
|
|
for (direction = 0; steparr[direction] != 0; direction++) {
|
|
step = steparr[direction];
|
|
s = from + step;
|
|
while (0 == (s & 0x88)) {
|
|
us = (SQUARE)unmap88(s);
|
|
if (0 != (0x1u & (unsigned int)(occ >> us)))
|
|
break;
|
|
*list++ = us;
|
|
s += step;
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
for (direction = 0; steparr[direction] != 0; direction++) {
|
|
step = steparr[direction];
|
|
s = from + step;
|
|
if (0 == (s & 0x88)) {
|
|
us = (SQUARE)unmap88(s);
|
|
if (0 == (0x1u & (unsigned int)(occ >> us))) {
|
|
*list++ = us;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
*list = NOSQUARE;
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
|