4 * ----------------------------------------------------------------------
5 * Copyright (c) 1993, 1994, 1995 Matthias Mutz
6 * Copyright (c) 1999 Michael Vanier and the Free Software Foundation
8 * GNU SHOGI is based on GNU CHESS
10 * Copyright (c) 1988, 1989, 1990 John Stanback
11 * Copyright (c) 1992 Free Software Foundation
13 * This file is part of GNU SHOGI.
15 * GNU Shogi is free software; you can redistribute it and/or modify it
16 * under the terms of the GNU General Public License as published by the
17 * Free Software Foundation; either version 3 of the License,
18 * or (at your option) any later version.
20 * GNU Shogi is distributed in the hope that it will be useful, but WITHOUT
21 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
22 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
25 * You should have received a copy of the GNU General Public License along
26 * with GNU Shogi; see the file COPYING. If not, see
27 * <http://www.gnu.org/licenses/>.
28 * ----------------------------------------------------------------------
37 /* Declarations of read(), write(), close(), and lseek(). */
47 unsigned booksize = BOOKSIZE;
48 unsigned short bookmaxply = BOOKMAXPLY;
49 unsigned bookcount = 0;
52 char *bookfile = BOOK;
54 char *bookfile = NULL;
58 char *binbookfile = BINBOOK;
60 char *binbookfile = NULL;
63 static char bmvstr[3][7];
66 static ULONG bhashkey;
72 * Generate move strings in different formats.
76 Balgbr(short f, short t, short flag)
78 short promoted = false;
89 piece = f - NO_SQUARES;
91 if (f > (NO_SQUARES + NO_PIECES))
94 flag = (dropmask | piece);
103 if ((f == t) && ((f != 0) || (t != 0)))
106 * error in algbr: FROM=TO=t
109 bmvstr[0][0] = bmvstr[1][0] = bmvstr[2][0] = '\0';
113 if ((flag & dropmask) != 0)
115 /* bmvstr[0]: P*3c bmvstr[1]: P'3c */
116 short piece = flag & pmask;
117 bmvstr[0][0] = pxx[piece];
119 bmvstr[0][2] = cxx[column(t)];
120 bmvstr[0][3] = rxx[row(t)];
121 bmvstr[0][4] = bmvstr[2][0] = '\0';
122 strcpy(bmvstr[1], bmvstr[0]);
127 if ((f != 0) || (t != 0))
129 /* algebraic notation */
130 /* bmvstr[0]: 7g7f bmvstr[1]:
131 * (+)P7g7f(+) bmvstr[2]: (+)P7f(+) */
132 bmvstr[0][0] = cxx[column(f)];
133 bmvstr[0][1] = rxx[row(f)];
134 bmvstr[0][2] = cxx[column(t)];
135 bmvstr[0][3] = rxx[row(t)];
140 bmvstr[1][0] = bmvstr[2][0] = '+';
141 bmvstr[1][1] = bmvstr[2][1] = pxx[board[f]];
142 strcpy(&bmvstr[1][2], &bmvstr[0][0]);
143 strcpy(&bmvstr[2][2], &bmvstr[0][2]);
147 bmvstr[1][0] = bmvstr[2][0] = pxx[board[f]];
148 strcpy(&bmvstr[1][1], &bmvstr[0][0]);
149 strcpy(&bmvstr[2][1], &bmvstr[0][2]);
154 strcat(bmvstr[0], "+");
155 strcat(bmvstr[1], "+");
156 strcat(bmvstr[2], "+");
161 bmvstr[0][0] = bmvstr[1][0] = bmvstr[2][0] = '\0';
172 bkdisplay(char *s, int cnt, int moveno)
179 printf("matches = %d\n", cnt);
180 printf("inout move is :%s: move number %d side %s\n",
181 s, moveno / 2 + 1, (moveno & 1) ? "white" : "black");
183 #ifndef SEMIQUIETBOOKGEN
184 printf("legal moves are \n");
186 while (pnt < TrPnt[3])
190 if (is_promoted[board[node->f]] )
191 Balgbr(node->f | 0x80, node->t, (short) node->flags);
193 Balgbr(node->f, node->t, (short) node->flags);
196 bmvstr[0], bmvstr[1], bmvstr[2]);
199 printf("\n current board is\n");
201 for (r = (NO_ROWS - 1); r >= 0; r--)
203 for (c = 0; c <= (NO_COLS - 1); c++)
208 pc = (is_promoted[board[l]] ? '+' : ' ');
210 if (color[l] == neutral)
212 else if (color[l] == black)
213 printf("%c%c", pc, qxx[board[l]]);
215 printf("%c%c", pc, pxx[board[l]]);
225 for (color = black; color <= white; color++)
229 printf((color == black) ? "black " : "white ");
231 for (piece = pawn; piece <= king; piece++)
233 if ((c = Captured[color][piece]))
234 printf("%i%c ", c, pxx[piece]);
240 #endif /* SEMIQUIETBOOKGEN */
243 #endif /* QUIETBOOKGEN */
248 * BVerifyMove(s, mv, moveno)
250 * Compare the string 's' to the list of legal moves available for the
251 * opponent. If a match is found, make the move on the board.
255 BVerifyMove(char *s, unsigned short *mv, int moveno)
257 static short pnt, tempb, tempc, tempsf, tempst, cnt;
258 static struct leaf xnode;
263 MoveList(opponent, 2, -2, true);
266 while (pnt < TrPnt[3])
270 if (is_promoted[board[node->f]] )
271 Balgbr(node->f | 0x80, node->t, (short) node->flags);
273 Balgbr(node->f, node->t, (short) node->flags);
275 if (strcmp(s, bmvstr[0]) == 0 || strcmp(s, bmvstr[1]) == 0 ||
276 strcmp(s, bmvstr[2]) == 0)
287 MakeMove(opponent, &xnode, &tempb,
288 &tempc, &tempsf, &tempst, &INCscore);
290 if (SqAttacked(PieceList[opponent][0], computer, &blockable))
292 UnmakeMove(opponent, &xnode, &tempb, &tempc, &tempsf, &tempst);
293 /* Illegal move in check */
294 #if !defined QUIETBOOKGEN
295 /* 077: "Illegal move (in check) %s" */
297 bkdisplay(s, cnt, moveno);
303 *mv = (xnode.f << 8) | xnode.t;
305 if (is_promoted[board[xnode.t]] )
306 Balgbr(xnode.f | 0x80, xnode.t, false);
308 Balgbr(xnode.f, xnode.t, false);
315 #if !defined QUIETBOOKGEN
316 /* 075: "Illegal move (no match)%s\n" */
318 bkdisplay(s, cnt, moveno);
329 * Reset the board and other variables to start a new game.
338 flag.illegal = flag.mate = flag.post = flag.quit
339 = flag.reverse = flag.bothsides = flag.onemove = flag.force
342 flag.material = flag.coords = flag.hash = flag.easy
343 = flag.beep = flag.rcptr
346 flag.stars = flag.shade = flag.back = flag.musttimeout = false;
350 CptrFlag[0] = TesujiFlag[0] = false;
354 for (l = 0; l < NO_SQUARES; l++)
356 board[l] = Stboard[l];
357 color[l] = Stcolor[l];
363 hashbd = hashkey = 0;
370 Vparse (FILE * fd, USHORT *mv, USHORT *flags, USHORT side, int moveno)
379 while (((c = getc(fd)) == ' ')
380 || (c == '!') || (c == '/') || (c == '\n'));
384 /* amount of time spent for the last move */
385 while (((c = getc(fd)) != ')') && (c != EOF));
389 while (((c = getc(fd)) == ' ') || (c == '\n'));
395 /* comment for the actual game */
396 while (((c = getc(fd))) != ']' && (c != EOF));
400 while (((c = getc(fd))) == ' ' || (c == '\n'));
416 /* goes to end of line */
429 while ((c >= '0') && (c <= '9'))
437 while (((c = getc(fd)) == ' ') || (c == '.') || (c == '\n'));
441 while (((c = getc(fd)) != '?') && (c != '!') && (c != ' ')
442 && (c != '(') && (c != '\n') && (c != '\t') && (c != EOF))
447 if ((c != 'x') && (c != '-') && (c != ',')
448 && (c != ';') && (c != '='))
458 while (((c = getc(fd)) != ')') && (c != EOF));
469 while ((c != '\n') && (c != EOF))
478 if (strcmp(s, "draw") == 0)
480 else if (strcmp(s, "1-0") == 0)
482 else if (strcmp(s, "0-1") == 0)
484 else if (strcmp(s, "Resigns") == 0)
486 else if (strcmp(s, "Resigns.") == 0)
488 else if (strcmp(s, "Sennichite") == 0)
490 else if (strcmp(s, "Sennichite.") == 0)
492 else if (strcmp(s, "Jishogi") == 0)
494 else if (strcmp(s, "Jishogi.") == 0)
500 i = BVerifyMove(s, mv, moveno);
504 /* Bad move, not for the program to play */
505 *flags |= BADMOVE; /* Flag it ! */
506 while (((c = getc(fd)) == '?') || (c == '!') || (c == '/'));
511 /* Do not use by computer */
512 *flags |= BADMOVE; /* Flag it ! */
514 while (((c = getc(fd)) == '?') || (c == '!') || (c == '/'));
520 *flags |= GOODMOVE; /* Flag it ! */
522 while (((c = getc(fd)) == '?') || (c == '!') || (c == '/'));
530 while (((c = getc(fd)) != ')') && (c != EOF));
534 /* flush to start of next */
535 while (((c = getc(fd)) != '#') && (c != EOF));
553 static struct gdxadmin ADMIN;
555 static struct gdxdata DATA;
557 /* lts(l) returns most significant 16 bits of l */
559 #if SIZEOF_LONG == 8 /* 64-bit long i.e. 8 bytes */
560 # define lts(x) (USHORT)(((x >> 48) & 0xfffe) | side)
562 # if defined USE_LTSIMP
563 static USHORT ltsimp(long x)
566 n = (((x >> 16) & 0xfffe));
569 # define lts(x) (USHORT)(ltsimp(x) | side)
571 # define lts(x) (USHORT)(((x >> 16)&0xfffe) | side)
576 /* #define HashValue(l) lts(l) */
577 #define HashValue(l) (USHORT)(l & 0xffff)
581 static ULONG currentoffset;
584 #define MAXOFFSET(B) ((B.booksize - 1) * sizeof_gdxdata + sizeof_gdxadmin)
586 #define HashOffset(hashkey, B) \
588 currentoffset = ((ULONG)hashkey % B.booksize) \
589 * sizeof_gdxdata + sizeof_gdxadmin; \
593 #define NextOffset(B) \
595 currentoffset += sizeof_gdxdata; \
596 if (currentoffset > B.maxoffset) \
597 currentoffset = sizeof_gdxadmin; \
601 #define WriteAdmin() \
604 write(gfd, (char *)&ADMIN, sizeof_gdxadmin); \
607 #define WriteData() \
611 lseek(gfd, currentoffset, 0); \
612 write(gfd, (char *)&DATA, sizeof_gdxdata); \
617 static int ReadAdmin(void)
620 return (sizeof_gdxadmin == read(gfd, (char *)&ADMIN, sizeof_gdxadmin));
623 static int ReadData(struct gdxdata *DATA)
625 lseek(gfd, currentoffset, 0);
626 return (sizeof_gdxdata == read(gfd, (char *)DATA, sizeof_gdxdata));
633 * CHECKME: is this still valid esp. wrt gnushogi.book?
635 * Read in the Opening Book file and parse the algebraic notation for a move
636 * into an unsigned integer format indicating the from and to square. Create
637 * a linked list of opening lines of play, with entry->next pointing to the
638 * next line and entry->move pointing to a chunk of memory containing the
639 * moves. More Opening lines of up to 100 half moves may be added to
640 * gnushogi.book. But now it's a hashed table by position which yields a move
641 * or moves for each position. It no longer knows about openings per se only
642 * positions and recommended moves in those positions.
650 int mustwrite = false, first;
651 unsigned short xside, side;
655 unsigned int games = 0;
661 if ((fd = fopen(bookfile, "r")) == NULL)
662 fd = fopen("gnushogi.tbk", "r");
666 /* yes add to book */
667 /* open book as writer */
668 gfd = open(binbookfile, O_RDONLY | O_BINARY);
674 B.bookcount = ADMIN.bookcount;
675 B.booksize = ADMIN.booksize;
676 B.maxoffset = ADMIN.maxoffset;
678 if (B.booksize && !(B.maxoffset == MAXOFFSET(B)))
680 printf("bad format %s\n", binbookfile);
686 printf("bad format %s\n", binbookfile);
690 gfd = open(binbookfile, O_RDWR | O_BINARY);
695 gfd = open(binbookfile, O_RDWR | O_CREAT | O_BINARY, 0644);
697 ADMIN.bookcount = B.bookcount = 0;
698 ADMIN.booksize = B.booksize = booksize;
699 B.maxoffset = ADMIN.maxoffset = MAXOFFSET(B);
706 write(gfd, (char *)&ADMIN, sizeof_gdxadmin);
707 printf("creating bookfile %s %ld %ld\n",
708 binbookfile, B.maxoffset, B.booksize);
710 for (x = 0; x < B.booksize; x++)
712 write(gfd, (char *)&DATA, sizeof_gdxdata);
718 /* setvbuf(fd, buffr, _IOFBF, 2048); */
721 hashbd = hashkey = 0;
724 while ((c = Vparse(fd, &mv, &flags, side, i)) >= 0)
729 * If this is not the first move of an opening and
730 * if it's the first time we have seen it then
731 * save the next move as a hint.
735 if (i < bookmaxply + 2)
737 if (i > 1 && !(flags & BADMOVE))
740 if (i < bookmaxply + 1)
743 * See if this position and move already
744 * exist from some other opening.
748 HashOffset(bhashkey, B);
753 if (!ReadData(&DATA))
754 break; /* corrupted binbook file */
757 break; /* free entry */
759 if (DATA.hashkey == HashValue(bhashkey)
760 && DATA.hashbd == bhashbd)
762 if (DATA.bmove == mv)
765 * Yes, so just bump count - count
766 * is used to choose the opening
767 * move in proportion to its
768 * presence in the book.
781 if (DATA.flags & LASTMOVE)
783 DATA.flags &= (~LASTMOVE);
795 * Doesn't exist so add it to the book.
802 if ((B.bookcount % 1000) == 0)
804 /* CHECKME: may want to get rid of this,
805 * especially for xshogi. */
806 printf("%ld rec %d openings "
811 /* initialize a record */
812 DATA.hashbd = bhashbd;
813 DATA.hashkey = HashValue(bhashkey);
815 DATA.flags = flags | LASTMOVE;
824 opponent = computer ^ 1;
831 /* reset for next opening */
844 /* write admin rec with counts */
845 ADMIN.bookcount = B.bookcount;
852 if (binbookfile != NULL)
854 /* open book as reader */
855 gfd = open(binbookfile, O_RDONLY | O_BINARY);
859 if (ReadAdmin() && (!ADMIN.booksize
860 || (ADMIN.maxoffset == MAXOFFSET(ADMIN))))
862 B.bookcount = ADMIN.bookcount;
863 B.booksize = ADMIN.booksize;
864 B.maxoffset = ADMIN.maxoffset;
868 printf("bad format %s\n", binbookfile);
876 B.booksize = booksize;
880 /* 213: "Book used %d(%d)." */
881 sprintf(msg, CP[213], B.bookcount, B.booksize);
885 /* Set everything back to start the game. */
889 /* Now get ready to play .*/
892 /* 212: "Can't find book." */
893 ShowMessage(CP[212]);
901 * OpeningBook(hint, side)
903 * Go through each of the opening lines of play and check for a match with
904 * the current game listing. If a match occurs, generate a random
905 * number. If this number is the largest generated so far then the next
906 * move in this line becomes the current "candidate". After all lines are
907 * checked, the candidate move is put at the top of the Tree[] array and
908 * will be played by the program. Note that the program does not handle
909 * book transpositions.
913 OpeningBook(unsigned short *hint, short side)
916 int possibles = TrPnt[2] - TrPnt[1];
918 gsrand((unsigned int) time((long *) 0));
922 * Find all the moves for this position - count them and get their
931 struct gdxdata OBB[128];
933 if (B.bookcount == 0)
940 HashOffset(hashkey, B);
942 printf("looking for book move, bhashbd = 0x%lx bhashkey = 0x%x\n",
943 (ULONG)hashbd, HashValue(hashkey));
947 if (!ReadData(&OBB[x]))
950 if (OBB[x].bmove == 0)
954 printf("compare with bhashbd = 0x%lx bhashkey = 0x%x\n",
955 OBB[x].hashbd, OBB[x].hashkey);
957 if ((OBB[x].hashkey == HashValue(hashkey))
958 && (OBB[x].hashbd == (ULONG)hashbd))
962 if (OBB[x-1].flags & LASTMOVE)
970 printf("%d book move(s) found.\n", x);
979 for (i = 0; i < x; i++)
981 if (OBB[i].flags & BADMOVE)
985 /* Is the move in the MoveList? */
986 for (b = TrPnt[1]; b < (unsigned) TrPnt[2]; b++)
988 if (((Tree[b].f << 8) | Tree[b].t) == m)
991 Tree[b].score = DONTUSE;
1000 movealgbr(m = OBB[i].bmove, s);
1001 printf("finding book move: %s\n", s);
1003 summ += OBB[i].count;
1013 r = (urand() % summ);
1015 for (i = 0; i < x; i++)
1017 if (!(OBB[i].flags & BADMOVE))
1019 if (r < OBB[i].count)
1034 /* Make sure the move is in the MoveList. */
1035 for (b = TrPnt[1]; b < (unsigned) TrPnt[2]; b++)
1037 if (((Tree[b].f << 8) | Tree[b].t) == m)
1039 Tree[b].flags |= book;
1045 /* Make sure it's the best. */
1047 pick(TrPnt[1], TrPnt[2] - 1);
1049 if (Tree[TrPnt[1]].score)
1056 /* Ok, pick up the hint and go. */