Remove Whitespaces from chessbox
Remove 1616 Whitespaces from chessbox Change-Id: I84c0dbd4a177eba50b9f7427f5695ae4b266aa5e
This commit is contained in:
William Wilgus
parent
324ad2483a
commit
37522ec63a
6 changed files with 1616 additions and 1616 deletions
|
|
@ -7,7 +7,7 @@
|
|||
* \/ \/ \/ \/ \/
|
||||
* $Id$
|
||||
*
|
||||
* Copyright (C) 2006 Miguel A. Arévalo
|
||||
* Copyright (C) 2006 Miguel A. Arévalo
|
||||
* Color graphics from eboard
|
||||
* GNUChess v2 chess engine Copyright (c) 1988 John Stanback
|
||||
*
|
||||
|
|
@ -20,7 +20,7 @@
|
|||
* KIND, either express or implied.
|
||||
*
|
||||
****************************************************************************/
|
||||
|
||||
|
||||
#include "plugin.h"
|
||||
|
||||
#if (MEMORYSIZE > 8) /* Lowmem doesn't have playback in chessbox */
|
||||
|
|
@ -80,7 +80,7 @@ short plugin_mode;
|
|||
|
||||
/* level+1's string */
|
||||
const char *level_string[] = { "Level 1: 60 moves / 5 min" ,
|
||||
"Level 2: 60 moves / 15 min" ,
|
||||
"Level 2: 60 moves / 15 min" ,
|
||||
"Level 3: 60 moves / 30 min" ,
|
||||
"Level 4: 40 moves / 30 min" ,
|
||||
"Level 5: 40 moves / 60 min" ,
|
||||
|
|
@ -120,7 +120,7 @@ static void cb_drawboard (void) {
|
|||
short r , c , x , y ;
|
||||
short l , piece , p_color ;
|
||||
int b_color=1;
|
||||
|
||||
|
||||
rb->lcd_clear_display();
|
||||
|
||||
for (r = 0; r < 8; r++) {
|
||||
|
|
@ -132,8 +132,8 @@ static void cb_drawboard (void) {
|
|||
if ( piece == no_piece ) {
|
||||
rb->lcd_bitmap_part ( chessbox_pieces , 0 ,
|
||||
TILE_HEIGHT * b_color ,
|
||||
STRIDE( SCREEN_MAIN,
|
||||
BMPWIDTH_chessbox_pieces,
|
||||
STRIDE( SCREEN_MAIN,
|
||||
BMPWIDTH_chessbox_pieces,
|
||||
BMPHEIGHT_chessbox_pieces) ,
|
||||
XOFS + x*TILE_WIDTH ,
|
||||
YOFS + ( 7 - y )*TILE_HEIGHT ,
|
||||
|
|
@ -146,8 +146,8 @@ static void cb_drawboard (void) {
|
|||
4 * TILE_HEIGHT * ( piece - 1 ) +
|
||||
2 * TILE_HEIGHT * p_color +
|
||||
TILE_HEIGHT * b_color ,
|
||||
STRIDE( SCREEN_MAIN,
|
||||
BMPWIDTH_chessbox_pieces,
|
||||
STRIDE( SCREEN_MAIN,
|
||||
BMPWIDTH_chessbox_pieces,
|
||||
BMPHEIGHT_chessbox_pieces) ,
|
||||
XOFS + x*TILE_WIDTH ,
|
||||
YOFS + (7 - y)*TILE_HEIGHT ,
|
||||
|
|
@ -158,7 +158,7 @@ static void cb_drawboard (void) {
|
|||
}
|
||||
b_color = (b_color == 1) ? 0 : 1 ;
|
||||
}
|
||||
|
||||
|
||||
/* draw board limits */
|
||||
#if (LCD_WIDTH > TILE_WIDTH*8) && (LCD_HEIGHT > TILE_HEIGHT*8)
|
||||
rb->lcd_drawrect(XOFS - 1, YOFS - 1, TILE_WIDTH*8 + 2, TILE_HEIGHT*8 + 2);
|
||||
|
|
@ -186,7 +186,7 @@ static void cb_switch ( short x , short y ) {
|
|||
/* ---- callback for capturing interaction while thinking ---- */
|
||||
static void cb_wt_callback ( void ) {
|
||||
int button = BUTTON_NONE;
|
||||
|
||||
|
||||
wt_command = COMMAND_NOP;
|
||||
button = rb->button_get(false);
|
||||
switch (button) {
|
||||
|
|
@ -270,7 +270,7 @@ static void cb_saveposition ( void ) {
|
|||
int fd;
|
||||
short sq,i,c;
|
||||
unsigned short temp;
|
||||
|
||||
|
||||
rb->splash ( 0 , "Saving position" );
|
||||
|
||||
fd = rb->open(SAVE_FILE, O_WRONLY|O_CREAT, 0666);
|
||||
|
|
@ -323,7 +323,7 @@ static void cb_restoreposition ( void ) {
|
|||
int fd;
|
||||
short sq;
|
||||
unsigned short m;
|
||||
|
||||
|
||||
if ( (fd = rb->open(SAVE_FILE, O_RDONLY)) >= 0 ) {
|
||||
rb->splash ( 0 , "Loading position" );
|
||||
rb->read(fd, &(computer), sizeof(computer));
|
||||
|
|
@ -393,10 +393,10 @@ static int cb_menu_viewer(void)
|
|||
int selection;
|
||||
int result = 0;
|
||||
bool menu_quit = false;
|
||||
|
||||
|
||||
MENUITEM_STRINGLIST(menu,"Chessbox Menu",NULL,"Restart Game",
|
||||
"Select Other Game", "Quit");
|
||||
|
||||
"Select Other Game", "Quit");
|
||||
|
||||
while(!menu_quit)
|
||||
{
|
||||
switch(rb->do_menu(&menu, &selection, NULL, false))
|
||||
|
|
@ -422,7 +422,7 @@ static int cb_menu_viewer(void)
|
|||
static struct cb_command cb_get_viewer_command (void) {
|
||||
int button;
|
||||
struct cb_command result = { 0, {0,0,0,0,0}, 0 };
|
||||
|
||||
|
||||
/* main loop */
|
||||
while ( true ) {
|
||||
button = rb->button_get(true);
|
||||
|
|
@ -476,7 +476,7 @@ static void cb_start_viewer(char* filename){
|
|||
|
||||
/* init board */
|
||||
GNUChess_Initialize();
|
||||
|
||||
|
||||
/* draw the board */
|
||||
cb_drawboard();
|
||||
|
||||
|
|
@ -494,7 +494,7 @@ static void cb_start_viewer(char* filename){
|
|||
rb->splash ( HZ*2 , "At the begining of the game" );
|
||||
break;
|
||||
}
|
||||
board[locn[curr_ply->row_from][curr_ply->column_from]]
|
||||
board[locn[curr_ply->row_from][curr_ply->column_from]]
|
||||
= board[locn[curr_ply->row_to][curr_ply->column_to]];
|
||||
color[locn[curr_ply->row_from][curr_ply->column_from]]
|
||||
= color[locn[curr_ply->row_to][curr_ply->column_to]];
|
||||
|
|
@ -601,14 +601,14 @@ static int cb_menu(void)
|
|||
int selection;
|
||||
int result = 0;
|
||||
bool menu_quit = false;
|
||||
|
||||
|
||||
MENUITEM_STRINGLIST(menu,"Chessbox Menu",NULL,"New Game","Resume Game",
|
||||
"Save Game", "Restore Game",
|
||||
#ifdef HAVE_PLAYBACK_CONTROL
|
||||
"Playback Control",
|
||||
#endif
|
||||
"Quit");
|
||||
|
||||
"Quit");
|
||||
|
||||
while(!menu_quit)
|
||||
{
|
||||
switch(rb->do_menu(&menu, &selection, NULL, false))
|
||||
|
|
@ -654,7 +654,7 @@ static struct cb_command cb_getcommand (void) {
|
|||
int marked = false , from_marked = false ;
|
||||
short marked_x = 0 , marked_y = 0 ;
|
||||
struct cb_command result = { 0, {0,0,0,0,0}, 0 };
|
||||
|
||||
|
||||
cb_switch ( x , y );
|
||||
/* main loop */
|
||||
while ( true ) {
|
||||
|
|
@ -815,11 +815,11 @@ static void cb_play_game(void) {
|
|||
|
||||
/* init PGN history data structures */
|
||||
game = pgn_init_game();
|
||||
|
||||
|
||||
/* restore saved position, if saved */
|
||||
cb_restoreposition();
|
||||
/* TODO: save/restore the PGN history of unfinished games */
|
||||
|
||||
|
||||
/* draw the board */
|
||||
/* I don't like configscreens, start game inmediatly */
|
||||
cb_drawboard();
|
||||
|
|
@ -937,7 +937,7 @@ static void cb_play_game(void) {
|
|||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
cb_saveposition();
|
||||
/* TODO: save/restore the PGN history of unfinished games */
|
||||
rb->lcd_setfont(FONT_UI);
|
||||
|
|
@ -948,7 +948,7 @@ static void cb_play_game(void) {
|
|||
* plugin entry point.
|
||||
******************************************************************************/
|
||||
enum plugin_status plugin_start(const void* parameter) {
|
||||
|
||||
|
||||
/* plugin init */
|
||||
|
||||
#if LCD_DEPTH > 1
|
||||
|
|
@ -957,7 +957,7 @@ enum plugin_status plugin_start(const void* parameter) {
|
|||
|
||||
/* end of plugin init */
|
||||
|
||||
/* if the plugin was invoked as a viewer, parse the file and show the game list
|
||||
/* if the plugin was invoked as a viewer, parse the file and show the game list
|
||||
* else, start playing a game
|
||||
*/
|
||||
if (parameter != NULL) {
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
* \/ \/ \/ \/ \/
|
||||
* $Id$
|
||||
*
|
||||
* Copyright (C) 2007 Mauricio Peccorini
|
||||
* Copyright (C) 2007 Mauricio Peccorini
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
|
|
@ -417,7 +417,7 @@ static void coords_to_pgn(struct pgn_ply_node* ply){
|
|||
&& ply->column_to + kn_offs[i][1] >= 0 && ply->column_to + kn_offs[i][1] <= 7
|
||||
&& board[locn[ply->row_to + kn_offs[i][0]][ply->column_to + kn_offs[i][1]]] == knight
|
||||
&& color[locn[ply->row_to + kn_offs[i][0]][ply->column_to + kn_offs[i][1]]] == ply->player
|
||||
&& (ply->row_to + kn_offs[i][0] != ply->row_from
|
||||
&& (ply->row_to + kn_offs[i][0] != ply->row_from
|
||||
|| ply->column_to + kn_offs[i][1] != ply->column_from)){
|
||||
if (ply->row_to + kn_offs[i][0] != ply->row_from){
|
||||
unambiguous_position = '1' + ply->row_from;
|
||||
|
|
@ -878,5 +878,5 @@ void pgn_store_game(struct pgn_game_node* game){
|
|||
/* leave a blank line between the tag section and the game section */
|
||||
rb->fdprintf(fhandler,"\n\n");
|
||||
|
||||
rb->close(fhandler);
|
||||
rb->close(fhandler);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
* \/ \/ \/ \/ \/
|
||||
* $Id$
|
||||
*
|
||||
* Copyright (C) 2007 Mauricio Peccorini
|
||||
* Copyright (C) 2007 Mauricio Peccorini
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
|
|
|
|||
|
|
@ -128,7 +128,7 @@ short unmap[120]=
|
|||
40,41,42,43,44,45,46,47,-1,-1,-1,-1,-1,-1,-1,-1,
|
||||
48,49,50,51,52,53,54,55,-1,-1,-1,-1,-1,-1,-1,-1,
|
||||
56,57,58,59,60,61,62,63};
|
||||
short Dcode[120]=
|
||||
short Dcode[120]=
|
||||
{0,1,1,1,1,1,1,1,0,0,0,0,0,0,0x0E,0x0F,
|
||||
0x10,0x11,0x12,0,0,0,0,0,0,0,0,0,0,0,0x0F,0x1F,
|
||||
0x10,0x21,0x11,0,0,0,0,0,0,0,0,0,0,0x0F,0,0,
|
||||
|
|
@ -243,7 +243,7 @@ short PawnAdvance[64]=
|
|||
12,16,24,32,32,24,16,12,
|
||||
12,16,24,32,32,24,16,12,
|
||||
0, 0, 0, 0, 0, 0, 0, 0};
|
||||
|
||||
|
||||
/* ............ prototypes ............ */
|
||||
void ScorePosition( short side, short *score );
|
||||
void ScoreLoneKing( short side, short *score );
|
||||
|
|
@ -273,7 +273,7 @@ void PutInTTable ( short side, short score, short depth,
|
|||
short alpha, short beta, unsigned short mv );
|
||||
void ZeroTTable ( void );
|
||||
void MoveList ( short side, short ply );
|
||||
|
||||
|
||||
void GenMoves ( short ply, short sq, short side, short xside );
|
||||
void LinkMove ( short ply, short f, short t, short xside );
|
||||
void CaptureList ( short side, short xside, short ply );
|
||||
|
|
@ -294,19 +294,19 @@ void ataks ( short side, short *a );
|
|||
void algbr ( short f, short t, short flag );
|
||||
void ElapsedTime( short iop);
|
||||
|
||||
void NewGame(void);
|
||||
void NewGame(void);
|
||||
|
||||
|
||||
/* ............ POSITIONAL EVALUATION ROUTINES ............ */
|
||||
|
||||
|
||||
|
||||
void ScorePosition(side,score)
|
||||
short side,*score;
|
||||
|
||||
/*
|
||||
Perform normal static evaluation of board position. A score is
|
||||
generated for each piece and these are summed to get a score for each
|
||||
side.
|
||||
Perform normal static evaluation of board position. A score is
|
||||
generated for each piece and these are summed to get a score for each
|
||||
side.
|
||||
*/
|
||||
|
||||
{
|
||||
|
|
@ -334,10 +334,10 @@ short pscore[3];
|
|||
}
|
||||
if (hung[side] > 1) pscore[side] += HUNGX;
|
||||
if (hung[xside] > 1) pscore[xside] += HUNGX;
|
||||
|
||||
|
||||
*score = mtl[side] - mtl[xside] + pscore[side] - pscore[xside] + 10;
|
||||
if (dither) *score += rb->rand() % dither;
|
||||
|
||||
|
||||
if (*score > 0 && pmtl[side] == 0) {
|
||||
if (emtl[side] < valueR) {
|
||||
*score = 0;
|
||||
|
|
@ -352,7 +352,7 @@ short pscore[3];
|
|||
if (-*score < valueR) *score /= 2;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (mtl[xside] == valueK && emtl[side] > valueB) *score += 200;
|
||||
if (mtl[side] == valueK && emtl[xside] > valueB) *score -= 200;
|
||||
}
|
||||
|
|
@ -361,7 +361,7 @@ short pscore[3];
|
|||
void ScoreLoneKing(side,score)
|
||||
short side,*score;
|
||||
|
||||
/*
|
||||
/*
|
||||
Static evaluation when loser has only a king and winner has no pawns
|
||||
or no pieces.
|
||||
*/
|
||||
|
|
@ -373,19 +373,19 @@ register short winner,loser,king1,king2,s,i;
|
|||
if (mtl[white] > mtl[black]) winner = white; else winner = black;
|
||||
loser = otherside[winner];
|
||||
king1 = PieceList[winner][0]; king2 = PieceList[loser][0];
|
||||
|
||||
|
||||
s = 0;
|
||||
|
||||
|
||||
if (pmtl[winner] > 0)
|
||||
for (i = 1; i <= PieceCnt[winner]; i++)
|
||||
s += ScoreKPK(side,winner,loser,king1,king2,PieceList[winner][i]);
|
||||
|
||||
|
||||
else if (emtl[winner] == valueB+valueN)
|
||||
s = ScoreKBNK(winner,king1,king2);
|
||||
|
||||
|
||||
else if (emtl[winner] > valueB)
|
||||
s = 500 + emtl[winner] - 2*KingEnding[king2] - 2*distance(king1,king2);
|
||||
|
||||
|
||||
if (side == winner) *score = s; else *score = -s;
|
||||
}
|
||||
|
||||
|
|
@ -399,7 +399,7 @@ short side,winner,loser,king1,king2,sq;
|
|||
|
||||
{
|
||||
register short s,r;
|
||||
|
||||
|
||||
if (PieceCnt[winner] == 1) s = 50; else s = 120;
|
||||
if (winner == white)
|
||||
{
|
||||
|
|
@ -569,8 +569,8 @@ short s,piece,in_square,r,mob,e,c;
|
|||
if (PC2[7] == 0) s += KHOPNX;
|
||||
}
|
||||
}
|
||||
|
||||
if (a2 > 0)
|
||||
|
||||
if (a2 > 0)
|
||||
{
|
||||
c = (control[piece] & 0x4FFF);
|
||||
if (a1 == 0 || a2 > c+1)
|
||||
|
|
@ -665,13 +665,13 @@ void BRscan(sq,s,mob)
|
|||
short sq,*s,*mob;
|
||||
|
||||
/*
|
||||
Find Bishop and Rook mobility, XRAY attacks, and pins. Increment the
|
||||
hung[] array if a pin is found.
|
||||
Find Bishop and Rook mobility, XRAY attacks, and pins. Increment the
|
||||
hung[] array if a pin is found.
|
||||
*/
|
||||
|
||||
{
|
||||
register short m,u,d,m0,j,piece,pin;
|
||||
short *Kf;
|
||||
short *Kf;
|
||||
|
||||
Kf = Kfield[c1];
|
||||
*mob = 0;
|
||||
|
|
@ -763,9 +763,9 @@ register short u,m,d,i,m0;
|
|||
void ExaminePosition()
|
||||
|
||||
/*
|
||||
This is done one time before the search is started. Set up arrays
|
||||
Mwpawn, Mbpawn, Mknight, Mbishop, Mking which are used in the
|
||||
SqValue() function to determine the positional value of each piece.
|
||||
This is done one time before the search is started. Set up arrays
|
||||
Mwpawn, Mbpawn, Mknight, Mbishop, Mking which are used in the
|
||||
SqValue() function to determine the positional value of each piece.
|
||||
*/
|
||||
|
||||
{
|
||||
|
|
@ -800,14 +800,14 @@ short wpadv,bpadv,wstrong,bstrong,z,side,pp,j,val,Pd,fyle,rank;
|
|||
if (!PawnStorm && stage < 5)
|
||||
PawnStorm = ((column[wking] < 3 && column[bking] > 4) ||
|
||||
(column[wking] > 4 && column[bking] < 3));
|
||||
|
||||
|
||||
CopyBoard(pknight,Mknight[white]);
|
||||
CopyBoard(pknight,Mknight[black]);
|
||||
CopyBoard(pbishop,Mbishop[white]);
|
||||
CopyBoard(pbishop,Mbishop[black]);
|
||||
BlendBoard(KingOpening,KingEnding,Mking[white]);
|
||||
BlendBoard(KingOpening,KingEnding,Mking[black]);
|
||||
|
||||
|
||||
for (sq = 0; sq < 64; sq++)
|
||||
{
|
||||
fyle = column[sq]; rank = row[sq];
|
||||
|
|
@ -845,7 +845,7 @@ short wpadv,bpadv,wstrong,bstrong,z,side,pp,j,val,Pd,fyle,rank;
|
|||
if ((column[bking] < 4 && fyle > 4) ||
|
||||
(column[bking] > 3 && fyle < 3)) Mbpawn[sq] -= 3*rank;
|
||||
}
|
||||
|
||||
|
||||
Mknight[white][sq] += 5 - distance(sq,bking);
|
||||
Mknight[white][sq] += 5 - distance(sq,wking);
|
||||
Mknight[black][sq] += 5 - distance(sq,wking);
|
||||
|
|
@ -862,24 +862,24 @@ short wpadv,bpadv,wstrong,bstrong,z,side,pp,j,val,Pd,fyle,rank;
|
|||
if (bstrong) Mknight[black][sq] += KNIGHTSTRONG;
|
||||
if (wstrong) Mbishop[white][sq] += BISHOPSTRONG;
|
||||
if (bstrong) Mbishop[black][sq] += BISHOPSTRONG;
|
||||
|
||||
|
||||
if (HasBishop[white] == 2) Mbishop[white][sq] += 8;
|
||||
if (HasBishop[black] == 2) Mbishop[black][sq] += 8;
|
||||
if (HasKnight[white] == 2) Mknight[white][sq] += 5;
|
||||
if (HasKnight[black] == 2) Mknight[black][sq] += 5;
|
||||
|
||||
|
||||
if (board[sq] == bishop) {
|
||||
if (rank % 2 == fyle % 2) {
|
||||
KBNKsq = 0;
|
||||
} else {
|
||||
} else {
|
||||
KBNKsq = 7;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Kfield[white][sq] = Kfield[black][sq] = 0;
|
||||
if (distance(sq,wking) == 1) Kfield[black][sq] = KATAK;
|
||||
if (distance(sq,bking) == 1) Kfield[white][sq] = KATAK;
|
||||
|
||||
|
||||
Pd = 0;
|
||||
for (i = 0; i < 64; i++)
|
||||
if (board[i] == pawn)
|
||||
|
|
@ -912,9 +912,9 @@ short wpadv,bpadv,wstrong,bstrong,z,side,pp,j,val,Pd,fyle,rank;
|
|||
|
||||
void UpdateWeights()
|
||||
|
||||
/*
|
||||
If material balance has changed, determine the values for the
|
||||
positional evaluation terms.
|
||||
/*
|
||||
If material balance has changed, determine the values for the
|
||||
positional evaluation terms.
|
||||
*/
|
||||
|
||||
{
|
||||
|
|
@ -932,7 +932,7 @@ register short tmtl;
|
|||
if (tmtl > 3600) stage2 = 0;
|
||||
else if (tmtl < 1400) stage2 = 10;
|
||||
else stage2 = (3600-tmtl) / 220;
|
||||
|
||||
|
||||
PEDRNK2B = -15; /* centre pawn on 2nd rank & blocked */
|
||||
PBLOK = -4; /* blocked backward pawn */
|
||||
PDOUBLED = -14; /* doubled pawn */
|
||||
|
|
@ -941,27 +941,27 @@ register short tmtl;
|
|||
PADVNCM = 10; /* advanced pawn multiplier */
|
||||
PADVNCI = 7; /* muliplier for isolated pawn */
|
||||
PawnBonus = stage;
|
||||
|
||||
|
||||
KNIGHTPOST = (stage+2)/3; /* knight near enemy pieces */
|
||||
KNIGHTSTRONG = (stage+6)/2; /* occupies pawn hole */
|
||||
|
||||
|
||||
BISHOPSTRONG = (stage+6)/2; /* occupies pawn hole */
|
||||
BishopBonus = 2*stage;
|
||||
|
||||
|
||||
RHOPN = 10; /* rook on half open file */
|
||||
RHOPNX = 4;
|
||||
RookBonus = 6*stage;
|
||||
|
||||
|
||||
XRAY = 8; /* Xray attack on piece */
|
||||
PINVAL = 10; /* Pin */
|
||||
|
||||
|
||||
KHOPN = (3*stage-30) / 2; /* king on half open file */
|
||||
KHOPNX = KHOPN / 2;
|
||||
KCASTLD = 10 - stage;
|
||||
KMOVD = -40 / (stage+1); /* king moved before castling */
|
||||
KATAK = (10-stage) / 2; /* B,R attacks near enemy king */
|
||||
if (stage < 8) KSFTY = 16-2*stage; else KSFTY = 0;
|
||||
|
||||
|
||||
ATAKD = -6; /* defender > attacker */
|
||||
HUNGP = -8; /* each hung piece */
|
||||
HUNGX = -12; /* extra for >1 hung piece */
|
||||
|
|
@ -1003,12 +1003,12 @@ register int sq;
|
|||
int SelectMove( short side, short iop , void (*callback)(void), char* move_buffer)
|
||||
|
||||
/*
|
||||
Select a move by calling function search() at progressively deeper
|
||||
ply until time is up or a mate or draw is reached. An alpha-beta
|
||||
window of -90 to +90 points is set around the score returned from the
|
||||
previous iteration. If Sdepth != 0 then the program has correctly
|
||||
predicted the opponents move and the search will start at a depth of
|
||||
Sdepth+1 rather than a depth of 1.
|
||||
Select a move by calling function search() at progressively deeper
|
||||
ply until time is up or a mate or draw is reached. An alpha-beta
|
||||
window of -90 to +90 points is set around the score returned from the
|
||||
previous iteration. If Sdepth != 0 then the program has correctly
|
||||
predicted the opponents move and the search will start at a depth of
|
||||
Sdepth+1 rather than a depth of 1.
|
||||
*/
|
||||
|
||||
{
|
||||
|
|
@ -1032,7 +1032,7 @@ static short i,alpha,beta,score,tempb,tempc,tempsf,tempst,xside,rpt;
|
|||
ExaminePosition();
|
||||
ScorePosition(side,&score);
|
||||
Pscore[0] = -score;
|
||||
|
||||
|
||||
if (Sdepth == 0)
|
||||
{
|
||||
ZeroTTable();
|
||||
|
|
@ -1043,7 +1043,7 @@ static short i,alpha,beta,score,tempb,tempc,tempsf,tempst,xside,rpt;
|
|||
if (iop != 2) hint = 0;
|
||||
for (i = 0; i < maxdepth; i++)
|
||||
PrVar[i] = killr0[i] = killr1[i] = killr2[i] = killr3[i] = 0;
|
||||
|
||||
|
||||
alpha = -9000; beta = 9000;
|
||||
rpt = 0;
|
||||
TrPnt[1] = 0; root = &Tree[0];
|
||||
|
|
@ -1054,7 +1054,7 @@ static short i,alpha,beta,score,tempb,tempc,tempsf,tempst,xside,rpt;
|
|||
NodeCnt = ETnodes = EvalNodes = HashCnt = 0;
|
||||
Zscore = 0; zwndw = 20;
|
||||
}
|
||||
|
||||
|
||||
while (!timeout && Sdepth < MaxSearchDepth)
|
||||
{
|
||||
Sdepth++;
|
||||
|
|
@ -1120,7 +1120,7 @@ static short i,alpha,beta,score,tempb,tempc,tempsf,tempst,xside,rpt;
|
|||
if (score == -9999 || score == 9998) mate = true;
|
||||
if (mate) hint = 0;
|
||||
if (root->flags & cstlmask) Game50 = GameCnt;
|
||||
else if (board[root->t] == pawn || (root->flags & capture))
|
||||
else if (board[root->t] == pawn || (root->flags & capture))
|
||||
Game50 = GameCnt;
|
||||
GameList[GameCnt].score = score;
|
||||
GameList[GameCnt].nodes = NodeCnt;
|
||||
|
|
@ -1142,13 +1142,13 @@ static short i,alpha,beta,score,tempb,tempc,tempsf,tempst,xside,rpt;
|
|||
void OpeningBook()
|
||||
|
||||
/*
|
||||
Go thru each of the opening lines of play and check for a match with
|
||||
the current game listing. If a match occurs, generate a random number.
|
||||
If this number is the largest generated so far then the next move in
|
||||
this line becomes the current "candidate". After all lines are
|
||||
checked, the candidate move is put at the top of the Tree[] array and
|
||||
will be played by the program. Note that the program does not handle
|
||||
book transpositions.
|
||||
Go thru each of the opening lines of play and check for a match with
|
||||
the current game listing. If a match occurs, generate a random number.
|
||||
If this number is the largest generated so far then the next move in
|
||||
this line becomes the current "candidate". After all lines are
|
||||
checked, the candidate move is put at the top of the Tree[] array and
|
||||
will be played by the program. Note that the program does not handle
|
||||
book transpositions.
|
||||
*/
|
||||
|
||||
{
|
||||
|
|
@ -1203,12 +1203,12 @@ int search( short side, short ply, short depth,
|
|||
void (*callback)(void) )
|
||||
|
||||
/*
|
||||
Perform an alpha-beta search to determine the score for the current
|
||||
board position. If depth <= 0 only capturing moves, pawn promotions
|
||||
and responses to check are generated and searched, otherwise all
|
||||
moves are processed. The search depth is modified for check evasions,
|
||||
certain re-captures and threats. Extensions may continue for up to 11
|
||||
ply beyond the nominal search depth.
|
||||
Perform an alpha-beta search to determine the score for the current
|
||||
board position. If depth <= 0 only capturing moves, pawn promotions
|
||||
and responses to check are generated and searched, otherwise all
|
||||
moves are processed. The search depth is modified for check evasions,
|
||||
certain re-captures and threats. Extensions may continue for up to 11
|
||||
ply beyond the nominal search depth.
|
||||
*/
|
||||
|
||||
#define prune (cf && score+node->score < alpha)
|
||||
|
|
@ -1234,13 +1234,13 @@ struct leaf *node,tmp;
|
|||
|
||||
NodeCnt++;
|
||||
xside = otherside[side];
|
||||
|
||||
|
||||
if (ply <= Sdepth+3) repetition(rpt); else *rpt = 0;
|
||||
if (*rpt >= 2) return(0);
|
||||
|
||||
score = evaluate(side,xside,ply,depth,alpha,beta);
|
||||
if (score > 9000) return(score);
|
||||
|
||||
|
||||
if (depth > 0)
|
||||
{
|
||||
if (InChk || PawnThreat[ply-1] || ReCapture) ++depth;
|
||||
|
|
@ -1251,7 +1251,7 @@ struct leaf *node,tmp;
|
|||
(InChk || PawnThreat[ply-1] || Parry)) depth = 1;
|
||||
else if (score <= beta && MateThreat) depth = 1;
|
||||
}
|
||||
|
||||
|
||||
PV = 0;
|
||||
if (depth > 0 && hashflag && ply > 1)
|
||||
{
|
||||
|
|
@ -1261,7 +1261,7 @@ struct leaf *node,tmp;
|
|||
if (beta == -20000) return(score);
|
||||
if (alpha > beta) return(alpha);
|
||||
}
|
||||
|
||||
|
||||
if (Sdepth == 1) d = 7; else d = 11;
|
||||
if (ply > Sdepth+d || (depth <= 0 && score > beta)) return(score);
|
||||
|
||||
|
|
@ -1272,14 +1272,14 @@ struct leaf *node,tmp;
|
|||
CaptureList(side,xside,ply);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (TrPnt[ply] == TrPnt[ply+1]) return(score);
|
||||
|
||||
|
||||
cf = (depth < 1 && ply > Sdepth+1 && !ChkFlag[ply-2] && !slk);
|
||||
|
||||
if (depth > 0) best = -12000; else best = score;
|
||||
if (best > alpha) alpha = best;
|
||||
|
||||
|
||||
for (pnt = pbst = TrPnt[ply];
|
||||
pnt < TrPnt[ply+1] && best <= beta;
|
||||
pnt++)
|
||||
|
|
@ -1288,7 +1288,7 @@ struct leaf *node,tmp;
|
|||
node = &Tree[pnt];
|
||||
mv = (node->f << 8) + node->t;
|
||||
nxtline[ply+1] = 0;
|
||||
|
||||
|
||||
if (prune) break;
|
||||
if (ply == 1) UpdateSearchStatus;
|
||||
|
||||
|
|
@ -1339,7 +1339,7 @@ struct leaf *node,tmp;
|
|||
if (NodeCnt > ETnodes) ElapsedTime(0);
|
||||
if (timeout) return(-Tscore[ply-1]);
|
||||
}
|
||||
|
||||
|
||||
node = &Tree[pbst];
|
||||
mv = (node->f<<8) + node->t;
|
||||
if (hashflag && ply <= Sdepth && *rpt == 0 && best == alpha)
|
||||
|
|
@ -1368,13 +1368,13 @@ int evaluate(side,xside,ply,depth,alpha,beta)
|
|||
short side,xside,ply,depth,alpha,beta;
|
||||
|
||||
/*
|
||||
Compute an estimate of the score by adding the positional score from
|
||||
the previous ply to the material difference. If this score falls
|
||||
inside a window which is 180 points wider than the alpha-beta window
|
||||
(or within a 50 point window during quiescence search) call
|
||||
ScorePosition() to determine a score, otherwise return the estimated
|
||||
score. If one side has only a king and the other either has no pawns
|
||||
or no pieces then the function ScoreLoneKing() is called.
|
||||
Compute an estimate of the score by adding the positional score from
|
||||
the previous ply to the material difference. If this score falls
|
||||
inside a window which is 180 points wider than the alpha-beta window
|
||||
(or within a 50 point window during quiescence search) call
|
||||
ScorePosition() to determine a score, otherwise return the estimated
|
||||
score. If one side has only a king and the other either has no pawns
|
||||
or no pieces then the function ScoreLoneKing() is called.
|
||||
*/
|
||||
|
||||
{
|
||||
|
|
@ -1384,13 +1384,13 @@ register short evflag;
|
|||
hung[white] = hung[black] = 0;
|
||||
slk = ((mtl[white] == valueK && (pmtl[black] == 0 || emtl[black] == 0)) ||
|
||||
(mtl[black] == valueK && (pmtl[white] == 0 || emtl[white] == 0)));
|
||||
|
||||
|
||||
if (slk) evflag = false;
|
||||
else evflag =
|
||||
else evflag =
|
||||
(ply == 1 || ply < Sdepth ||
|
||||
(depth == 0 && Xscore > alpha-xwndw && Xscore < beta+xwndw) ||
|
||||
(depth < 0 && Xscore > alpha-25 && Xscore < beta+25));
|
||||
|
||||
|
||||
if (evflag)
|
||||
{
|
||||
EvalNodes++;
|
||||
|
|
@ -1406,7 +1406,7 @@ register short evflag;
|
|||
InChk = SqAtakd(PieceList[side][0],xside);
|
||||
if (slk) ScoreLoneKing(side,&Xscore);
|
||||
}
|
||||
|
||||
|
||||
Pscore[ply] = Xscore - mtl[side] + mtl[xside];
|
||||
if (InChk) ChkFlag[ply-1] = Pindex[TOsquare];
|
||||
else ChkFlag[ply-1] = 0;
|
||||
|
|
@ -1417,7 +1417,7 @@ register short evflag;
|
|||
int ProbeTTable(side,depth,alpha,beta,score)
|
||||
short side,depth,*alpha,*beta,*score;
|
||||
|
||||
/*
|
||||
/*
|
||||
Look for the current board position in the transposition table.
|
||||
*/
|
||||
|
||||
|
|
@ -1466,7 +1466,7 @@ short hindx;
|
|||
ptbl = (ttable + hindx);
|
||||
ptbl->hashbd = hashbd;
|
||||
ptbl->depth = depth;
|
||||
ptbl->score = score;
|
||||
ptbl->score = score;
|
||||
ptbl->mv = mv;
|
||||
ptbl->flags = 0;
|
||||
if (score < alpha) ptbl->flags |= upperbound;
|
||||
|
|
@ -1491,10 +1491,10 @@ void MoveList(side,ply)
|
|||
short side,ply;
|
||||
|
||||
/*
|
||||
Fill the array Tree[] with all available moves for side to play. Array
|
||||
TrPnt[ply] contains the index into Tree[] of the first move at a ply.
|
||||
Fill the array Tree[] with all available moves for side to play. Array
|
||||
TrPnt[ply] contains the index into Tree[] of the first move at a ply.
|
||||
*/
|
||||
|
||||
|
||||
{
|
||||
register short i,xside,f;
|
||||
|
||||
|
|
@ -1528,15 +1528,15 @@ void GenMoves(ply,sq,side,xside)
|
|||
short ply,sq,side,xside;
|
||||
|
||||
/*
|
||||
Generate moves for a piece. The from square is mapped onto a special
|
||||
board and offsets (taken from array Dir[]) are added to the mapped
|
||||
location. The newly generated square is tested to see if it falls off
|
||||
the board by ANDing the square with 88 HEX. Legal moves are linked
|
||||
into the tree.
|
||||
Generate moves for a piece. The from square is mapped onto a special
|
||||
board and offsets (taken from array Dir[]) are added to the mapped
|
||||
location. The newly generated square is tested to see if it falls off
|
||||
the board by ANDing the square with 88 HEX. Legal moves are linked
|
||||
into the tree.
|
||||
*/
|
||||
|
||||
|
||||
{
|
||||
register short m,u,d,i,m0,piece;
|
||||
register short m,u,d,i,m0,piece;
|
||||
|
||||
piece = board[sq]; m0 = map[sq];
|
||||
if (sweep[piece])
|
||||
|
|
@ -1605,7 +1605,7 @@ short ply,f,t,xside;
|
|||
2. Capture of last moved piece
|
||||
3. Other captures (major pieces first)
|
||||
4. Killer moves
|
||||
5. "history" killers
|
||||
5. "history" killers
|
||||
*/
|
||||
|
||||
{
|
||||
|
|
@ -1688,7 +1688,7 @@ struct leaf *node;
|
|||
}
|
||||
PL = PieceList[side];
|
||||
for (i = 0; i <= PieceCnt[side]; i++)
|
||||
{
|
||||
{
|
||||
sq = PL[i];
|
||||
m0 = map[sq]; piece = board[sq];
|
||||
j1 = Dstart[piece]; j2 = Dstop[piece];
|
||||
|
|
@ -1724,7 +1724,7 @@ struct leaf *node;
|
|||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
int castle(side,kf,kt,iop)
|
||||
short side,kf,kt,iop;
|
||||
|
||||
|
|
@ -1792,7 +1792,7 @@ register short l;
|
|||
{
|
||||
board[l] = no_piece; color[l] = neutral;
|
||||
}
|
||||
else
|
||||
else
|
||||
{
|
||||
board[l] = pawn; color[l] = xside;
|
||||
}
|
||||
|
|
@ -1805,11 +1805,11 @@ short side,*tempc,*tempb,*tempsf,*tempst;
|
|||
struct leaf *node;
|
||||
|
||||
/*
|
||||
Update Arrays board[], color[], and Pindex[] to reflect the new board
|
||||
position obtained after making the move pointed to by node. Also
|
||||
update miscellaneous stuff that changes when a move is made.
|
||||
Update Arrays board[], color[], and Pindex[] to reflect the new board
|
||||
position obtained after making the move pointed to by node. Also
|
||||
update miscellaneous stuff that changes when a move is made.
|
||||
*/
|
||||
|
||||
|
||||
{
|
||||
register short f,t,xside,ct,cf;
|
||||
|
||||
|
|
@ -1874,7 +1874,7 @@ register short f,t,xside,ct,cf;
|
|||
UpdateHashbd(side,queen,f,-1);
|
||||
}
|
||||
INCscore -= *tempsf;
|
||||
}
|
||||
}
|
||||
if (board[t] == king) ++kingmoved[side];
|
||||
if (node->flags & epmask) EnPassant(xside,f,t,1);
|
||||
else if (hashflag) UpdateHashbd(side,board[t],f,t);
|
||||
|
|
@ -1913,7 +1913,7 @@ register short f,t,xside;
|
|||
UpdateHashbd(side,queen,-1,t);
|
||||
UpdateHashbd(side,pawn,-1,t);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (*tempc != neutral)
|
||||
{
|
||||
UpdatePieceList(*tempc,t,2);
|
||||
|
|
@ -1938,10 +1938,10 @@ void UpdateHashbd(side,piece,f,t)
|
|||
short side,piece,f,t;
|
||||
|
||||
/*
|
||||
hashbd contains a 32 bit "signature" of the board position. hashkey
|
||||
contains a 16 bit code used to address the hash table. When a move is
|
||||
made, XOR'ing the hashcode of moved piece on the from and to squares
|
||||
with the hashbd and hashkey values keeps things current.
|
||||
hashbd contains a 32 bit "signature" of the board position. hashkey
|
||||
contains a 16 bit code used to address the hash table. When a move is
|
||||
made, XOR'ing the hashcode of moved piece on the from and to squares
|
||||
with the hashbd and hashkey values keeps things current.
|
||||
*/
|
||||
|
||||
{
|
||||
|
|
@ -1962,8 +1962,8 @@ void UpdatePieceList(side,sq,iop)
|
|||
short side,sq,iop;
|
||||
|
||||
/*
|
||||
Update the PieceList and Pindex arrays when a piece is captured or
|
||||
when a capture is unmade.
|
||||
Update the PieceList and Pindex arrays when a piece is captured or
|
||||
when a capture is unmade.
|
||||
*/
|
||||
|
||||
{
|
||||
|
|
@ -1989,13 +1989,13 @@ register short i;
|
|||
void InitializeStats()
|
||||
|
||||
/*
|
||||
Scan thru the board seeing what's on each square. If a piece is found,
|
||||
update the variables PieceCnt, PawnCnt, Pindex and PieceList. Also
|
||||
determine the material for each side and set the hashkey and hashbd
|
||||
variables to represent the current board position. Array
|
||||
PieceList[side][indx] contains the location of all the pieces of
|
||||
either side. Array Pindex[sq] contains the indx into PieceList for a
|
||||
given square.
|
||||
Scan thru the board seeing what's on each square. If a piece is found,
|
||||
update the variables PieceCnt, PawnCnt, Pindex and PieceList. Also
|
||||
determine the material for each side and set the hashkey and hashbd
|
||||
variables to represent the current board position. Array
|
||||
PieceList[side][indx] contains the location of all the pieces of
|
||||
either side. Array Pindex[sq] contains the indx into PieceList for a
|
||||
given square.
|
||||
*/
|
||||
|
||||
{
|
||||
|
|
@ -2027,9 +2027,9 @@ register short i,sq;
|
|||
void pick(p1,p2)
|
||||
short p1,p2;
|
||||
|
||||
/*
|
||||
Find the best move in the tree between indexes p1 and p2. Swap the
|
||||
best move into the p1 element.
|
||||
/*
|
||||
Find the best move in the tree between indexes p1 and p2. Swap the
|
||||
best move into the p1 element.
|
||||
*/
|
||||
|
||||
{
|
||||
|
|
@ -2081,7 +2081,7 @@ short sq,side;
|
|||
/*
|
||||
See if any piece with color 'side' ataks sq. First check for pawns
|
||||
or king, then try other pieces. Array Dcode is used to check for
|
||||
knight attacks or R,B,Q co-linearity.
|
||||
knight attacks or R,B,Q co-linearity.
|
||||
*/
|
||||
|
||||
{
|
||||
|
|
@ -2095,7 +2095,7 @@ register short m,d,m0,m1,i,loc,piece,*PL;
|
|||
if (!(m & 0x88))
|
||||
if (board[unmap[m]] == pawn && color[unmap[m]] == side) return(true);
|
||||
if (distance(sq,PieceList[side][0]) == 1) return(true);
|
||||
|
||||
|
||||
PL = PieceList[side];
|
||||
for (i = 1; i <= PieceCnt[side]; i++)
|
||||
{
|
||||
|
|
@ -2128,8 +2128,8 @@ short side,*a;
|
|||
{
|
||||
register short u,m,d,c,m0;
|
||||
short j,j1,j2,piece,i,sq,*PL;
|
||||
|
||||
for (u = 0; u < 64; a[u++] = 0);
|
||||
|
||||
for (u = 0; u < 64; a[u++] = 0);
|
||||
Dstart[pawn] = Dpwn[side]; Dstop[pawn] = Dstart[pawn] + 1;
|
||||
PL = PieceList[side];
|
||||
for (i = 0; i <= PieceCnt[side]; i++)
|
||||
|
|
@ -2164,10 +2164,10 @@ short j,j1,j2,piece,i,sq,*PL;
|
|||
|
||||
void ElapsedTime(iop)
|
||||
|
||||
/*
|
||||
Determine the time that has passed since the search was started. If
|
||||
the elapsed time exceeds the target (ResponseTime+ExtraTime) then set
|
||||
timeout to true which will terminate the search.
|
||||
/*
|
||||
Determine the time that has passed since the search was started. If
|
||||
the elapsed time exceeds the target (ResponseTime+ExtraTime) then set
|
||||
timeout to true which will terminate the search.
|
||||
*/
|
||||
|
||||
short iop;
|
||||
|
|
@ -2230,7 +2230,7 @@ void SetTimeControl( void )
|
|||
int VerifyMove(short player, char s[],short iop,unsigned short *mv, char *move_buffer)
|
||||
|
||||
/*
|
||||
Compare the string 's' to the list of legal moves available for the
|
||||
Compare the string 's' to the list of legal moves available for the
|
||||
player. If a match is found, make the move on the board. This was originally
|
||||
fixed for the opponent, but allowing the player to be specified will make
|
||||
possible to use GnuChess as a human vs human game verifier. It also allows
|
||||
|
|
@ -2277,7 +2277,7 @@ short opponent_player = (player == white)?black:white;
|
|||
/*if (xnode.flags & epmask) UpdateDisplay(0,0,1,0);
|
||||
else UpdateDisplay(xnode.f,xnode.t,0,xnode.flags & cstlmask);*/
|
||||
if (xnode.flags & cstlmask) Game50 = GameCnt;
|
||||
else if (board[xnode.t] == pawn || (xnode.flags & capture))
|
||||
else if (board[xnode.t] == pawn || (xnode.flags & capture))
|
||||
Game50 = GameCnt;
|
||||
GameList[GameCnt].depth = GameList[GameCnt].score = 0;
|
||||
GameList[GameCnt].nodes = 0;
|
||||
|
|
@ -2298,7 +2298,7 @@ short opponent_player = (player == white)?black:white;
|
|||
}
|
||||
|
||||
return(true);
|
||||
}
|
||||
}
|
||||
}
|
||||
/*if (cnt > 1) ShowMessage("Ambiguous Move!");*/
|
||||
return(false);
|
||||
|
|
@ -2363,7 +2363,7 @@ void GNUChess_Initialize ( void ) {
|
|||
TCminutes = 5;
|
||||
TCflag = true;
|
||||
NewGame();
|
||||
MaxSearchDepth = 29 ;
|
||||
MaxSearchDepth = 29 ;
|
||||
}
|
||||
|
||||
void algbr(f,t,flag)
|
||||
|
|
@ -2381,7 +2381,7 @@ short f,t,flag;
|
|||
rb->memcpy(mvstr2,"o-o-o", 5);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (board[f] == pawn) mvstr3[0] = mvstr1[0];
|
||||
else mvstr3[0] = qxx[board[f]];
|
||||
if (color[t] != neutral)
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
#define neutral 2
|
||||
#define white 0
|
||||
#define black 1
|
||||
#define black 1
|
||||
#define no_piece 0
|
||||
#define pawn 1
|
||||
#define knight 2
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
Loading…
Reference in a new issue