droidfish/DroidFish/jni/gtb/gtb-att.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;
}