+++ /dev/null
-/*
- * book.c -- code for probing Polyglot opening books
- *
- * This code was first released in the public domain by Michel Van den Bergh.
- * The array Random64 is taken from the Polyglot source code.
- * I am pretty sure that a table of random numbers is never protected
- * by copyright.
- *
- * It s adapted by H.G. Muller for working with xboard / Winboard
- *
- * The following terms apply to the enhanced version of XBoard distributed
- * by the Free Software Foundation:
- * ------------------------------------------------------------------------
- *
- * GNU XBoard is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or (at
- * your option) any later version.
- *
- * GNU XBoard is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see http://www.gnu.org/licenses/. *
- *
- * ------------------------------------------------------------------------
- */
-
-#include "config.h"
-
-#include <stdio.h>
-#include <string.h>
-#include <time.h>
-#include <stdlib.h>
-#include <math.h>
-
-#include "common.h"
-#include "frontend.h"
-#include "backend.h"
-#include "moves.h"
-#include "gettext.h"
-
-#ifdef ENABLE_NLS
-# define _(s) gettext (s)
-# define N_(s) gettext_noop (s)
-#else
-# define _(s) (s)
-# define N_(s) s
-#endif
-
-#ifdef _MSC_VER
- typedef unsigned __int64 uint64;
-#else
- typedef unsigned long long int uint64;
-#endif
-
-#ifdef _MSC_VER
-# define U64(u) (u##ui64)
-#else
-# define U64(u) (u##ULL)
-#endif
-
-typedef unsigned char uint8;
-typedef unsigned short uint16;
-typedef unsigned int uint32;
-
-typedef struct {
- uint64 key;
- uint16 move;
- uint16 weight;
- uint16 learnPoints;
- uint16 learnCount;
-} entry_t;
-
-entry_t entry_none = {
- 0, 0, 0, 0
-};
-
-char *promote_pieces=" nbrqac=+";
-
-uint64 Random64[781] = {
- U64(0x9D39247E33776D41), U64(0x2AF7398005AAA5C7), U64(0x44DB015024623547), U64(0x9C15F73E62A76AE2),
- U64(0x75834465489C0C89), U64(0x3290AC3A203001BF), U64(0x0FBBAD1F61042279), U64(0xE83A908FF2FB60CA),
- U64(0x0D7E765D58755C10), U64(0x1A083822CEAFE02D), U64(0x9605D5F0E25EC3B0), U64(0xD021FF5CD13A2ED5),
- U64(0x40BDF15D4A672E32), U64(0x011355146FD56395), U64(0x5DB4832046F3D9E5), U64(0x239F8B2D7FF719CC),
- U64(0x05D1A1AE85B49AA1), U64(0x679F848F6E8FC971), U64(0x7449BBFF801FED0B), U64(0x7D11CDB1C3B7ADF0),
- U64(0x82C7709E781EB7CC), U64(0xF3218F1C9510786C), U64(0x331478F3AF51BBE6), U64(0x4BB38DE5E7219443),
- U64(0xAA649C6EBCFD50FC), U64(0x8DBD98A352AFD40B), U64(0x87D2074B81D79217), U64(0x19F3C751D3E92AE1),
- U64(0xB4AB30F062B19ABF), U64(0x7B0500AC42047AC4), U64(0xC9452CA81A09D85D), U64(0x24AA6C514DA27500),
- U64(0x4C9F34427501B447), U64(0x14A68FD73C910841), U64(0xA71B9B83461CBD93), U64(0x03488B95B0F1850F),
- U64(0x637B2B34FF93C040), U64(0x09D1BC9A3DD90A94), U64(0x3575668334A1DD3B), U64(0x735E2B97A4C45A23),
- U64(0x18727070F1BD400B), U64(0x1FCBACD259BF02E7), U64(0xD310A7C2CE9B6555), U64(0xBF983FE0FE5D8244),
- U64(0x9F74D14F7454A824), U64(0x51EBDC4AB9BA3035), U64(0x5C82C505DB9AB0FA), U64(0xFCF7FE8A3430B241),
- U64(0x3253A729B9BA3DDE), U64(0x8C74C368081B3075), U64(0xB9BC6C87167C33E7), U64(0x7EF48F2B83024E20),
- U64(0x11D505D4C351BD7F), U64(0x6568FCA92C76A243), U64(0x4DE0B0F40F32A7B8), U64(0x96D693460CC37E5D),
- U64(0x42E240CB63689F2F), U64(0x6D2BDCDAE2919661), U64(0x42880B0236E4D951), U64(0x5F0F4A5898171BB6),
- U64(0x39F890F579F92F88), U64(0x93C5B5F47356388B), U64(0x63DC359D8D231B78), U64(0xEC16CA8AEA98AD76),
- U64(0x5355F900C2A82DC7), U64(0x07FB9F855A997142), U64(0x5093417AA8A7ED5E), U64(0x7BCBC38DA25A7F3C),
- U64(0x19FC8A768CF4B6D4), U64(0x637A7780DECFC0D9), U64(0x8249A47AEE0E41F7), U64(0x79AD695501E7D1E8),
- U64(0x14ACBAF4777D5776), U64(0xF145B6BECCDEA195), U64(0xDABF2AC8201752FC), U64(0x24C3C94DF9C8D3F6),
- U64(0xBB6E2924F03912EA), U64(0x0CE26C0B95C980D9), U64(0xA49CD132BFBF7CC4), U64(0xE99D662AF4243939),
- U64(0x27E6AD7891165C3F), U64(0x8535F040B9744FF1), U64(0x54B3F4FA5F40D873), U64(0x72B12C32127FED2B),
- U64(0xEE954D3C7B411F47), U64(0x9A85AC909A24EAA1), U64(0x70AC4CD9F04F21F5), U64(0xF9B89D3E99A075C2),
- U64(0x87B3E2B2B5C907B1), U64(0xA366E5B8C54F48B8), U64(0xAE4A9346CC3F7CF2), U64(0x1920C04D47267BBD),
- U64(0x87BF02C6B49E2AE9), U64(0x092237AC237F3859), U64(0xFF07F64EF8ED14D0), U64(0x8DE8DCA9F03CC54E),
- U64(0x9C1633264DB49C89), U64(0xB3F22C3D0B0B38ED), U64(0x390E5FB44D01144B), U64(0x5BFEA5B4712768E9),
- U64(0x1E1032911FA78984), U64(0x9A74ACB964E78CB3), U64(0x4F80F7A035DAFB04), U64(0x6304D09A0B3738C4),
- U64(0x2171E64683023A08), U64(0x5B9B63EB9CEFF80C), U64(0x506AACF489889342), U64(0x1881AFC9A3A701D6),
- U64(0x6503080440750644), U64(0xDFD395339CDBF4A7), U64(0xEF927DBCF00C20F2), U64(0x7B32F7D1E03680EC),
- U64(0xB9FD7620E7316243), U64(0x05A7E8A57DB91B77), U64(0xB5889C6E15630A75), U64(0x4A750A09CE9573F7),
- U64(0xCF464CEC899A2F8A), U64(0xF538639CE705B824), U64(0x3C79A0FF5580EF7F), U64(0xEDE6C87F8477609D),
- U64(0x799E81F05BC93F31), U64(0x86536B8CF3428A8C), U64(0x97D7374C60087B73), U64(0xA246637CFF328532),
- U64(0x043FCAE60CC0EBA0), U64(0x920E449535DD359E), U64(0x70EB093B15B290CC), U64(0x73A1921916591CBD),
- U64(0x56436C9FE1A1AA8D), U64(0xEFAC4B70633B8F81), U64(0xBB215798D45DF7AF), U64(0x45F20042F24F1768),
- U64(0x930F80F4E8EB7462), U64(0xFF6712FFCFD75EA1), U64(0xAE623FD67468AA70), U64(0xDD2C5BC84BC8D8FC),
- U64(0x7EED120D54CF2DD9), U64(0x22FE545401165F1C), U64(0xC91800E98FB99929), U64(0x808BD68E6AC10365),
- U64(0xDEC468145B7605F6), U64(0x1BEDE3A3AEF53302), U64(0x43539603D6C55602), U64(0xAA969B5C691CCB7A),
- U64(0xA87832D392EFEE56), U64(0x65942C7B3C7E11AE), U64(0xDED2D633CAD004F6), U64(0x21F08570F420E565),
- U64(0xB415938D7DA94E3C), U64(0x91B859E59ECB6350), U64(0x10CFF333E0ED804A), U64(0x28AED140BE0BB7DD),
- U64(0xC5CC1D89724FA456), U64(0x5648F680F11A2741), U64(0x2D255069F0B7DAB3), U64(0x9BC5A38EF729ABD4),
- U64(0xEF2F054308F6A2BC), U64(0xAF2042F5CC5C2858), U64(0x480412BAB7F5BE2A), U64(0xAEF3AF4A563DFE43),
- U64(0x19AFE59AE451497F), U64(0x52593803DFF1E840), U64(0xF4F076E65F2CE6F0), U64(0x11379625747D5AF3),
- U64(0xBCE5D2248682C115), U64(0x9DA4243DE836994F), U64(0x066F70B33FE09017), U64(0x4DC4DE189B671A1C),
- U64(0x51039AB7712457C3), U64(0xC07A3F80C31FB4B4), U64(0xB46EE9C5E64A6E7C), U64(0xB3819A42ABE61C87),
- U64(0x21A007933A522A20), U64(0x2DF16F761598AA4F), U64(0x763C4A1371B368FD), U64(0xF793C46702E086A0),
- U64(0xD7288E012AEB8D31), U64(0xDE336A2A4BC1C44B), U64(0x0BF692B38D079F23), U64(0x2C604A7A177326B3),
- U64(0x4850E73E03EB6064), U64(0xCFC447F1E53C8E1B), U64(0xB05CA3F564268D99), U64(0x9AE182C8BC9474E8),
- U64(0xA4FC4BD4FC5558CA), U64(0xE755178D58FC4E76), U64(0x69B97DB1A4C03DFE), U64(0xF9B5B7C4ACC67C96),
- U64(0xFC6A82D64B8655FB), U64(0x9C684CB6C4D24417), U64(0x8EC97D2917456ED0), U64(0x6703DF9D2924E97E),
- U64(0xC547F57E42A7444E), U64(0x78E37644E7CAD29E), U64(0xFE9A44E9362F05FA), U64(0x08BD35CC38336615),
- U64(0x9315E5EB3A129ACE), U64(0x94061B871E04DF75), U64(0xDF1D9F9D784BA010), U64(0x3BBA57B68871B59D),
- U64(0xD2B7ADEEDED1F73F), U64(0xF7A255D83BC373F8), U64(0xD7F4F2448C0CEB81), U64(0xD95BE88CD210FFA7),
- U64(0x336F52F8FF4728E7), U64(0xA74049DAC312AC71), U64(0xA2F61BB6E437FDB5), U64(0x4F2A5CB07F6A35B3),
- U64(0x87D380BDA5BF7859), U64(0x16B9F7E06C453A21), U64(0x7BA2484C8A0FD54E), U64(0xF3A678CAD9A2E38C),
- U64(0x39B0BF7DDE437BA2), U64(0xFCAF55C1BF8A4424), U64(0x18FCF680573FA594), U64(0x4C0563B89F495AC3),
- U64(0x40E087931A00930D), U64(0x8CFFA9412EB642C1), U64(0x68CA39053261169F), U64(0x7A1EE967D27579E2),
- U64(0x9D1D60E5076F5B6F), U64(0x3810E399B6F65BA2), U64(0x32095B6D4AB5F9B1), U64(0x35CAB62109DD038A),
- U64(0xA90B24499FCFAFB1), U64(0x77A225A07CC2C6BD), U64(0x513E5E634C70E331), U64(0x4361C0CA3F692F12),
- U64(0xD941ACA44B20A45B), U64(0x528F7C8602C5807B), U64(0x52AB92BEB9613989), U64(0x9D1DFA2EFC557F73),
- U64(0x722FF175F572C348), U64(0x1D1260A51107FE97), U64(0x7A249A57EC0C9BA2), U64(0x04208FE9E8F7F2D6),
- U64(0x5A110C6058B920A0), U64(0x0CD9A497658A5698), U64(0x56FD23C8F9715A4C), U64(0x284C847B9D887AAE),
- U64(0x04FEABFBBDB619CB), U64(0x742E1E651C60BA83), U64(0x9A9632E65904AD3C), U64(0x881B82A13B51B9E2),
- U64(0x506E6744CD974924), U64(0xB0183DB56FFC6A79), U64(0x0ED9B915C66ED37E), U64(0x5E11E86D5873D484),
- U64(0xF678647E3519AC6E), U64(0x1B85D488D0F20CC5), U64(0xDAB9FE6525D89021), U64(0x0D151D86ADB73615),
- U64(0xA865A54EDCC0F019), U64(0x93C42566AEF98FFB), U64(0x99E7AFEABE000731), U64(0x48CBFF086DDF285A),
- U64(0x7F9B6AF1EBF78BAF), U64(0x58627E1A149BBA21), U64(0x2CD16E2ABD791E33), U64(0xD363EFF5F0977996),
- U64(0x0CE2A38C344A6EED), U64(0x1A804AADB9CFA741), U64(0x907F30421D78C5DE), U64(0x501F65EDB3034D07),
- U64(0x37624AE5A48FA6E9), U64(0x957BAF61700CFF4E), U64(0x3A6C27934E31188A), U64(0xD49503536ABCA345),
- U64(0x088E049589C432E0), U64(0xF943AEE7FEBF21B8), U64(0x6C3B8E3E336139D3), U64(0x364F6FFA464EE52E),
- U64(0xD60F6DCEDC314222), U64(0x56963B0DCA418FC0), U64(0x16F50EDF91E513AF), U64(0xEF1955914B609F93),
- U64(0x565601C0364E3228), U64(0xECB53939887E8175), U64(0xBAC7A9A18531294B), U64(0xB344C470397BBA52),
- U64(0x65D34954DAF3CEBD), U64(0xB4B81B3FA97511E2), U64(0xB422061193D6F6A7), U64(0x071582401C38434D),
- U64(0x7A13F18BBEDC4FF5), U64(0xBC4097B116C524D2), U64(0x59B97885E2F2EA28), U64(0x99170A5DC3115544),
- U64(0x6F423357E7C6A9F9), U64(0x325928EE6E6F8794), U64(0xD0E4366228B03343), U64(0x565C31F7DE89EA27),
- U64(0x30F5611484119414), U64(0xD873DB391292ED4F), U64(0x7BD94E1D8E17DEBC), U64(0xC7D9F16864A76E94),
- U64(0x947AE053EE56E63C), U64(0xC8C93882F9475F5F), U64(0x3A9BF55BA91F81CA), U64(0xD9A11FBB3D9808E4),
- U64(0x0FD22063EDC29FCA), U64(0xB3F256D8ACA0B0B9), U64(0xB03031A8B4516E84), U64(0x35DD37D5871448AF),
- U64(0xE9F6082B05542E4E), U64(0xEBFAFA33D7254B59), U64(0x9255ABB50D532280), U64(0xB9AB4CE57F2D34F3),
- U64(0x693501D628297551), U64(0xC62C58F97DD949BF), U64(0xCD454F8F19C5126A), U64(0xBBE83F4ECC2BDECB),
- U64(0xDC842B7E2819E230), U64(0xBA89142E007503B8), U64(0xA3BC941D0A5061CB), U64(0xE9F6760E32CD8021),
- U64(0x09C7E552BC76492F), U64(0x852F54934DA55CC9), U64(0x8107FCCF064FCF56), U64(0x098954D51FFF6580),
- U64(0x23B70EDB1955C4BF), U64(0xC330DE426430F69D), U64(0x4715ED43E8A45C0A), U64(0xA8D7E4DAB780A08D),
- U64(0x0572B974F03CE0BB), U64(0xB57D2E985E1419C7), U64(0xE8D9ECBE2CF3D73F), U64(0x2FE4B17170E59750),
- U64(0x11317BA87905E790), U64(0x7FBF21EC8A1F45EC), U64(0x1725CABFCB045B00), U64(0x964E915CD5E2B207),
- U64(0x3E2B8BCBF016D66D), U64(0xBE7444E39328A0AC), U64(0xF85B2B4FBCDE44B7), U64(0x49353FEA39BA63B1),
- U64(0x1DD01AAFCD53486A), U64(0x1FCA8A92FD719F85), U64(0xFC7C95D827357AFA), U64(0x18A6A990C8B35EBD),
- U64(0xCCCB7005C6B9C28D), U64(0x3BDBB92C43B17F26), U64(0xAA70B5B4F89695A2), U64(0xE94C39A54A98307F),
- U64(0xB7A0B174CFF6F36E), U64(0xD4DBA84729AF48AD), U64(0x2E18BC1AD9704A68), U64(0x2DE0966DAF2F8B1C),
- U64(0xB9C11D5B1E43A07E), U64(0x64972D68DEE33360), U64(0x94628D38D0C20584), U64(0xDBC0D2B6AB90A559),
- U64(0xD2733C4335C6A72F), U64(0x7E75D99D94A70F4D), U64(0x6CED1983376FA72B), U64(0x97FCAACBF030BC24),
- U64(0x7B77497B32503B12), U64(0x8547EDDFB81CCB94), U64(0x79999CDFF70902CB), U64(0xCFFE1939438E9B24),
- U64(0x829626E3892D95D7), U64(0x92FAE24291F2B3F1), U64(0x63E22C147B9C3403), U64(0xC678B6D860284A1C),
- U64(0x5873888850659AE7), U64(0x0981DCD296A8736D), U64(0x9F65789A6509A440), U64(0x9FF38FED72E9052F),
- U64(0xE479EE5B9930578C), U64(0xE7F28ECD2D49EECD), U64(0x56C074A581EA17FE), U64(0x5544F7D774B14AEF),
- U64(0x7B3F0195FC6F290F), U64(0x12153635B2C0CF57), U64(0x7F5126DBBA5E0CA7), U64(0x7A76956C3EAFB413),
- U64(0x3D5774A11D31AB39), U64(0x8A1B083821F40CB4), U64(0x7B4A38E32537DF62), U64(0x950113646D1D6E03),
- U64(0x4DA8979A0041E8A9), U64(0x3BC36E078F7515D7), U64(0x5D0A12F27AD310D1), U64(0x7F9D1A2E1EBE1327),
- U64(0xDA3A361B1C5157B1), U64(0xDCDD7D20903D0C25), U64(0x36833336D068F707), U64(0xCE68341F79893389),
- U64(0xAB9090168DD05F34), U64(0x43954B3252DC25E5), U64(0xB438C2B67F98E5E9), U64(0x10DCD78E3851A492),
- U64(0xDBC27AB5447822BF), U64(0x9B3CDB65F82CA382), U64(0xB67B7896167B4C84), U64(0xBFCED1B0048EAC50),
- U64(0xA9119B60369FFEBD), U64(0x1FFF7AC80904BF45), U64(0xAC12FB171817EEE7), U64(0xAF08DA9177DDA93D),
- U64(0x1B0CAB936E65C744), U64(0xB559EB1D04E5E932), U64(0xC37B45B3F8D6F2BA), U64(0xC3A9DC228CAAC9E9),
- U64(0xF3B8B6675A6507FF), U64(0x9FC477DE4ED681DA), U64(0x67378D8ECCEF96CB), U64(0x6DD856D94D259236),
- U64(0xA319CE15B0B4DB31), U64(0x073973751F12DD5E), U64(0x8A8E849EB32781A5), U64(0xE1925C71285279F5),
- U64(0x74C04BF1790C0EFE), U64(0x4DDA48153C94938A), U64(0x9D266D6A1CC0542C), U64(0x7440FB816508C4FE),
- U64(0x13328503DF48229F), U64(0xD6BF7BAEE43CAC40), U64(0x4838D65F6EF6748F), U64(0x1E152328F3318DEA),
- U64(0x8F8419A348F296BF), U64(0x72C8834A5957B511), U64(0xD7A023A73260B45C), U64(0x94EBC8ABCFB56DAE),
- U64(0x9FC10D0F989993E0), U64(0xDE68A2355B93CAE6), U64(0xA44CFE79AE538BBE), U64(0x9D1D84FCCE371425),
- U64(0x51D2B1AB2DDFB636), U64(0x2FD7E4B9E72CD38C), U64(0x65CA5B96B7552210), U64(0xDD69A0D8AB3B546D),
- U64(0x604D51B25FBF70E2), U64(0x73AA8A564FB7AC9E), U64(0x1A8C1E992B941148), U64(0xAAC40A2703D9BEA0),
- U64(0x764DBEAE7FA4F3A6), U64(0x1E99B96E70A9BE8B), U64(0x2C5E9DEB57EF4743), U64(0x3A938FEE32D29981),
- U64(0x26E6DB8FFDF5ADFE), U64(0x469356C504EC9F9D), U64(0xC8763C5B08D1908C), U64(0x3F6C6AF859D80055),
- U64(0x7F7CC39420A3A545), U64(0x9BFB227EBDF4C5CE), U64(0x89039D79D6FC5C5C), U64(0x8FE88B57305E2AB6),
- U64(0xA09E8C8C35AB96DE), U64(0xFA7E393983325753), U64(0xD6B6D0ECC617C699), U64(0xDFEA21EA9E7557E3),
- U64(0xB67C1FA481680AF8), U64(0xCA1E3785A9E724E5), U64(0x1CFC8BED0D681639), U64(0xD18D8549D140CAEA),
- U64(0x4ED0FE7E9DC91335), U64(0xE4DBF0634473F5D2), U64(0x1761F93A44D5AEFE), U64(0x53898E4C3910DA55),
- U64(0x734DE8181F6EC39A), U64(0x2680B122BAA28D97), U64(0x298AF231C85BAFAB), U64(0x7983EED3740847D5),
- U64(0x66C1A2A1A60CD889), U64(0x9E17E49642A3E4C1), U64(0xEDB454E7BADC0805), U64(0x50B704CAB602C329),
- U64(0x4CC317FB9CDDD023), U64(0x66B4835D9EAFEA22), U64(0x219B97E26FFC81BD), U64(0x261E4E4C0A333A9D),
- U64(0x1FE2CCA76517DB90), U64(0xD7504DFA8816EDBB), U64(0xB9571FA04DC089C8), U64(0x1DDC0325259B27DE),
- U64(0xCF3F4688801EB9AA), U64(0xF4F5D05C10CAB243), U64(0x38B6525C21A42B0E), U64(0x36F60E2BA4FA6800),
- U64(0xEB3593803173E0CE), U64(0x9C4CD6257C5A3603), U64(0xAF0C317D32ADAA8A), U64(0x258E5A80C7204C4B),
- U64(0x8B889D624D44885D), U64(0xF4D14597E660F855), U64(0xD4347F66EC8941C3), U64(0xE699ED85B0DFB40D),
- U64(0x2472F6207C2D0484), U64(0xC2A1E7B5B459AEB5), U64(0xAB4F6451CC1D45EC), U64(0x63767572AE3D6174),
- U64(0xA59E0BD101731A28), U64(0x116D0016CB948F09), U64(0x2CF9C8CA052F6E9F), U64(0x0B090A7560A968E3),
- U64(0xABEEDDB2DDE06FF1), U64(0x58EFC10B06A2068D), U64(0xC6E57A78FBD986E0), U64(0x2EAB8CA63CE802D7),
- U64(0x14A195640116F336), U64(0x7C0828DD624EC390), U64(0xD74BBE77E6116AC7), U64(0x804456AF10F5FB53),
- U64(0xEBE9EA2ADF4321C7), U64(0x03219A39EE587A30), U64(0x49787FEF17AF9924), U64(0xA1E9300CD8520548),
- U64(0x5B45E522E4B1B4EF), U64(0xB49C3B3995091A36), U64(0xD4490AD526F14431), U64(0x12A8F216AF9418C2),
- U64(0x001F837CC7350524), U64(0x1877B51E57A764D5), U64(0xA2853B80F17F58EE), U64(0x993E1DE72D36D310),
- U64(0xB3598080CE64A656), U64(0x252F59CF0D9F04BB), U64(0xD23C8E176D113600), U64(0x1BDA0492E7E4586E),
- U64(0x21E0BD5026C619BF), U64(0x3B097ADAF088F94E), U64(0x8D14DEDB30BE846E), U64(0xF95CFFA23AF5F6F4),
- U64(0x3871700761B3F743), U64(0xCA672B91E9E4FA16), U64(0x64C8E531BFF53B55), U64(0x241260ED4AD1E87D),
- U64(0x106C09B972D2E822), U64(0x7FBA195410E5CA30), U64(0x7884D9BC6CB569D8), U64(0x0647DFEDCD894A29),
- U64(0x63573FF03E224774), U64(0x4FC8E9560F91B123), U64(0x1DB956E450275779), U64(0xB8D91274B9E9D4FB),
- U64(0xA2EBEE47E2FBFCE1), U64(0xD9F1F30CCD97FB09), U64(0xEFED53D75FD64E6B), U64(0x2E6D02C36017F67F),
- U64(0xA9AA4D20DB084E9B), U64(0xB64BE8D8B25396C1), U64(0x70CB6AF7C2D5BCF0), U64(0x98F076A4F7A2322E),
- U64(0xBF84470805E69B5F), U64(0x94C3251F06F90CF3), U64(0x3E003E616A6591E9), U64(0xB925A6CD0421AFF3),
- U64(0x61BDD1307C66E300), U64(0xBF8D5108E27E0D48), U64(0x240AB57A8B888B20), U64(0xFC87614BAF287E07),
- U64(0xEF02CDD06FFDB432), U64(0xA1082C0466DF6C0A), U64(0x8215E577001332C8), U64(0xD39BB9C3A48DB6CF),
- U64(0x2738259634305C14), U64(0x61CF4F94C97DF93D), U64(0x1B6BACA2AE4E125B), U64(0x758F450C88572E0B),
- U64(0x959F587D507A8359), U64(0xB063E962E045F54D), U64(0x60E8ED72C0DFF5D1), U64(0x7B64978555326F9F),
- U64(0xFD080D236DA814BA), U64(0x8C90FD9B083F4558), U64(0x106F72FE81E2C590), U64(0x7976033A39F7D952),
- U64(0xA4EC0132764CA04B), U64(0x733EA705FAE4FA77), U64(0xB4D8F77BC3E56167), U64(0x9E21F4F903B33FD9),
- U64(0x9D765E419FB69F6D), U64(0xD30C088BA61EA5EF), U64(0x5D94337FBFAF7F5B), U64(0x1A4E4822EB4D7A59),
- U64(0x6FFE73E81B637FB3), U64(0xDDF957BC36D8B9CA), U64(0x64D0E29EEA8838B3), U64(0x08DD9BDFD96B9F63),
- U64(0x087E79E5A57D1D13), U64(0xE328E230E3E2B3FB), U64(0x1C2559E30F0946BE), U64(0x720BF5F26F4D2EAA),
- U64(0xB0774D261CC609DB), U64(0x443F64EC5A371195), U64(0x4112CF68649A260E), U64(0xD813F2FAB7F5C5CA),
- U64(0x660D3257380841EE), U64(0x59AC2C7873F910A3), U64(0xE846963877671A17), U64(0x93B633ABFA3469F8),
- U64(0xC0C0F5A60EF4CDCF), U64(0xCAF21ECD4377B28C), U64(0x57277707199B8175), U64(0x506C11B9D90E8B1D),
- U64(0xD83CC2687A19255F), U64(0x4A29C6465A314CD1), U64(0xED2DF21216235097), U64(0xB5635C95FF7296E2),
- U64(0x22AF003AB672E811), U64(0x52E762596BF68235), U64(0x9AEBA33AC6ECC6B0), U64(0x944F6DE09134DFB6),
- U64(0x6C47BEC883A7DE39), U64(0x6AD047C430A12104), U64(0xA5B1CFDBA0AB4067), U64(0x7C45D833AFF07862),
- U64(0x5092EF950A16DA0B), U64(0x9338E69C052B8E7B), U64(0x455A4B4CFE30E3F5), U64(0x6B02E63195AD0CF8),
- U64(0x6B17B224BAD6BF27), U64(0xD1E0CCD25BB9C169), U64(0xDE0C89A556B9AE70), U64(0x50065E535A213CF6),
- U64(0x9C1169FA2777B874), U64(0x78EDEFD694AF1EED), U64(0x6DC93D9526A50E68), U64(0xEE97F453F06791ED),
- U64(0x32AB0EDB696703D3), U64(0x3A6853C7E70757A7), U64(0x31865CED6120F37D), U64(0x67FEF95D92607890),
- U64(0x1F2B1D1F15F6DC9C), U64(0xB69E38A8965C6B65), U64(0xAA9119FF184CCCF4), U64(0xF43C732873F24C13),
- U64(0xFB4A3D794A9A80D2), U64(0x3550C2321FD6109C), U64(0x371F77E76BB8417E), U64(0x6BFA9AAE5EC05779),
- U64(0xCD04F3FF001A4778), U64(0xE3273522064480CA), U64(0x9F91508BFFCFC14A), U64(0x049A7F41061A9E60),
- U64(0xFCB6BE43A9F2FE9B), U64(0x08DE8A1C7797DA9B), U64(0x8F9887E6078735A1), U64(0xB5B4071DBFC73A66),
- U64(0x230E343DFBA08D33), U64(0x43ED7F5A0FAE657D), U64(0x3A88A0FBBCB05C63), U64(0x21874B8B4D2DBC4F),
- U64(0x1BDEA12E35F6A8C9), U64(0x53C065C6C8E63528), U64(0xE34A1D250E7A8D6B), U64(0xD6B04D3B7651DD7E),
- U64(0x5E90277E7CB39E2D), U64(0x2C046F22062DC67D), U64(0xB10BB459132D0A26), U64(0x3FA9DDFB67E2F199),
- U64(0x0E09B88E1914F7AF), U64(0x10E8B35AF3EEAB37), U64(0x9EEDECA8E272B933), U64(0xD4C718BC4AE8AE5F),
- U64(0x81536D601170FC20), U64(0x91B534F885818A06), U64(0xEC8177F83F900978), U64(0x190E714FADA5156E),
- U64(0xB592BF39B0364963), U64(0x89C350C893AE7DC1), U64(0xAC042E70F8B383F2), U64(0xB49B52E587A1EE60),
- U64(0xFB152FE3FF26DA89), U64(0x3E666E6F69AE2C15), U64(0x3B544EBE544C19F9), U64(0xE805A1E290CF2456),
- U64(0x24B33C9D7ED25117), U64(0xE74733427B72F0C1), U64(0x0A804D18B7097475), U64(0x57E3306D881EDB4F),
- U64(0x4AE7D6A36EB5DBCB), U64(0x2D8D5432157064C8), U64(0xD1E649DE1E7F268B), U64(0x8A328A1CEDFE552C),
- U64(0x07A3AEC79624C7DA), U64(0x84547DDC3E203C94), U64(0x990A98FD5071D263), U64(0x1A4FF12616EEFC89),
- U64(0xF6F7FD1431714200), U64(0x30C05B1BA332F41C), U64(0x8D2636B81555A786), U64(0x46C9FEB55D120902),
- U64(0xCCEC0A73B49C9921), U64(0x4E9D2827355FC492), U64(0x19EBB029435DCB0F), U64(0x4659D2B743848A2C),
- U64(0x963EF2C96B33BE31), U64(0x74F85198B05A2E7D), U64(0x5A0F544DD2B1FB18), U64(0x03727073C2E134B1),
- U64(0xC7F6AA2DE59AEA61), U64(0x352787BAA0D7C22F), U64(0x9853EAB63B5E0B35), U64(0xABBDCDD7ED5C0860),
- U64(0xCF05DAF5AC8D77B0), U64(0x49CAD48CEBF4A71E), U64(0x7A4C10EC2158C4A6), U64(0xD9E92AA246BF719E),
- U64(0x13AE978D09FE5557), U64(0x730499AF921549FF), U64(0x4E4B705B92903BA4), U64(0xFF577222C14F0A3A),
- U64(0x55B6344CF97AAFAE), U64(0xB862225B055B6960), U64(0xCAC09AFBDDD2CDB4), U64(0xDAF8E9829FE96B5F),
- U64(0xB5FDFC5D3132C498), U64(0x310CB380DB6F7503), U64(0xE87FBB46217A360E), U64(0x2102AE466EBB1148),
- U64(0xF8549E1A3AA5E00D), U64(0x07A69AFDCC42261A), U64(0xC4C118BFE78FEAAE), U64(0xF9F4892ED96BD438),
- U64(0x1AF3DBE25D8F45DA), U64(0xF5B4B0B0D2DEEEB4), U64(0x962ACEEFA82E1C84), U64(0x046E3ECAAF453CE9),
- U64(0xF05D129681949A4C), U64(0x964781CE734B3C84), U64(0x9C2ED44081CE5FBD), U64(0x522E23F3925E319E),
- U64(0x177E00F9FC32F791), U64(0x2BC60A63A6F3B3F2), U64(0x222BBFAE61725606), U64(0x486289DDCC3D6780),
- U64(0x7DC7785B8EFDFC80), U64(0x8AF38731C02BA980), U64(0x1FAB64EA29A2DDF7), U64(0xE4D9429322CD065A),
- U64(0x9DA058C67844F20C), U64(0x24C0E332B70019B0), U64(0x233003B5A6CFE6AD), U64(0xD586BD01C5C217F6),
- U64(0x5E5637885F29BC2B), U64(0x7EBA726D8C94094B), U64(0x0A56A5F0BFE39272), U64(0xD79476A84EE20D06),
- U64(0x9E4C1269BAA4BF37), U64(0x17EFEE45B0DEE640), U64(0x1D95B0A5FCF90BC6), U64(0x93CBE0B699C2585D),
- U64(0x65FA4F227A2B6D79), U64(0xD5F9E858292504D5), U64(0xC2B5A03F71471A6F), U64(0x59300222B4561E00),
- U64(0xCE2F8642CA0712DC), U64(0x7CA9723FBB2E8988), U64(0x2785338347F2BA08), U64(0xC61BB3A141E50E8C),
- U64(0x150F361DAB9DEC26), U64(0x9F6A419D382595F4), U64(0x64A53DC924FE7AC9), U64(0x142DE49FFF7A7C3D),
- U64(0x0C335248857FA9E7), U64(0x0A9C32D5EAE45305), U64(0xE6C42178C4BBB92E), U64(0x71F1CE2490D20B07),
- U64(0xF1BCC3D275AFE51A), U64(0xE728E8C83C334074), U64(0x96FBF83A12884624), U64(0x81A1549FD6573DA5),
- U64(0x5FA7867CAF35E149), U64(0x56986E2EF3ED091B), U64(0x917F1DD5F8886C61), U64(0xD20D8C88C8FFE65F),
- U64(0x31D71DCE64B2C310), U64(0xF165B587DF898190), U64(0xA57E6339DD2CF3A0), U64(0x1EF6E6DBB1961EC9),
- U64(0x70CC73D90BC26E24), U64(0xE21A6B35DF0C3AD7), U64(0x003A93D8B2806962), U64(0x1C99DED33CB890A1),
- U64(0xCF3145DE0ADD4289), U64(0xD0E4427A5514FB72), U64(0x77C621CC9FB3A483), U64(0x67A34DAC4356550B),
- U64(0xF8D626AAAF278509),
-};
-
-uint64 *RandomPiece =Random64;
-uint64 *RandomCastle =Random64+768;
-uint64 *RandomEnPassant =Random64+772;
-uint64 *RandomTurn =Random64+780;
-
-
-uint64
-hash (int moveNr)
-{
- int r, f, p_enc, squareNr, pieceGroup;
- uint64 key=0, holdingsKey=0, Zobrist;
- VariantClass v = gameInfo.variant;
-
- switch(v) {
- case VariantNormal:
- case VariantFischeRandom: // compatible with normal
- case VariantNoCastle:
- case VariantXiangqi: // for historic reasons; does never collide anyway because of other King type
- break;
- case VariantGiveaway: // in opening same as suicide
- key += VariantSuicide;
- break;
- case VariantGothic: // these are special cases of CRC, and can share book
- case VariantCapablanca:
- v = VariantCapaRandom;
- default:
- key += v; // variant type incorporated in key to allow mixed books without collisions
- }
-
- for(f=0; f<BOARD_WIDTH; f++){
- for(r=0; r<BOARD_HEIGHT;r++){
- ChessSquare p = boards[moveNr][r][f];
- if(f == BOARD_LEFT-1 || f == BOARD_RGHT) continue; // between board and holdings
- if(p != EmptySquare){
- int j = (int)p, promoted = 0;
- j -= (j >= (int)BlackPawn) ? (int)BlackPawn :(int)WhitePawn;
- if(j >= WhitePBishop && j != WhiteKing) promoted++, j -= WhiteTokin;
- if(j > (int)WhiteQueen) j++; // make space for King
- if(j > (int) WhiteKing) j = (int)WhiteQueen + 1;
- p_enc = 2*j + ((int)p < (int)BlackPawn);
- // holdings squares get nmbers immediately after board; first left, then right holdings
- if(f == BOARD_LEFT-2) squareNr = (BOARD_RGHT - BOARD_LEFT)*BOARD_HEIGHT + r; else
- if(f == BOARD_RGHT+1) squareNr = (BOARD_RGHT - BOARD_LEFT + 1)*BOARD_HEIGHT + r; else
- squareNr = (BOARD_RGHT - BOARD_LEFT)*r + (f - BOARD_LEFT);
- // note that in normal Chess squareNr < 64 and p_enc < 12. The following code
- // maps other pieces and squares in this range, and then modify the corresponding
- // Zobrist random by rotating its bitpattern according to what the piece really was.
- pieceGroup = p_enc / 12;
- p_enc = p_enc % 12;
- Zobrist = RandomPiece[64*p_enc + (squareNr & 63)];
- if(pieceGroup & 4) Zobrist *= 987654321;
- switch(pieceGroup & 3) {
- case 1: // pieces 5-10 (FEACWM)
- Zobrist = (Zobrist << 16) ^ (Zobrist >> 48);
- break;
- case 2: // pieces 11-16 (OHIJGD)
- Zobrist = (Zobrist << 32) ^ (Zobrist >> 32);
- break;
- case 3: // pieces 17-20 (VLSU)
- Zobrist = (Zobrist << 48) ^ (Zobrist >> 16);
- break;
- }
- if(promoted) Zobrist ^= 123456789*RandomPiece[squareNr & 63];
- if(squareNr & 64) Zobrist = (Zobrist << 8) ^ (Zobrist >> 56);
- if(squareNr & 128) Zobrist = (Zobrist << 4) ^ (Zobrist >> 60);
- // holdings have separate (additive) key, to encode presence of multiple pieces on same square
- if(f == BOARD_LEFT-2) holdingsKey += Zobrist * boards[moveNr][r][f+1]; else
- if(f == BOARD_RGHT+1) holdingsKey += Zobrist * boards[moveNr][r][f-1]; else
- key ^= Zobrist;
- }
- }
- }
-
- if(boards[moveNr][CASTLING][2] != NoRights) {
- if(boards[moveNr][CASTLING][0] != NoRights) key^=RandomCastle[0];
- if(boards[moveNr][CASTLING][1] != NoRights) key^=RandomCastle[1];
- }
- if(boards[moveNr][CASTLING][5] != NoRights) {
- if(boards[moveNr][CASTLING][3] != NoRights) key^=RandomCastle[2];
- if(boards[moveNr][CASTLING][4] != NoRights) key^=RandomCastle[3];
- }
-
- f = boards[moveNr][EP_STATUS];
- if(f >= 0 && f < 8){
- if(!WhiteOnMove(moveNr)){
- // the test for neighboring Pawns might not be needed,
- // as epStatus already kept track of it, but better safe than sorry.
- if((f>0 && boards[moveNr][3][f-1]==BlackPawn)||
- (f<7 && boards[moveNr][3][f+1]==BlackPawn)){
- key^=RandomEnPassant[f];
- }
- }else{
- if((f>0 && boards[moveNr][4][f-1]==WhitePawn)||
- (f<7 && boards[moveNr][4][f+1]==WhitePawn)){
- key^=RandomEnPassant[f];
- }
- }
- }
-
- if(WhiteOnMove(moveNr)){
- key^=RandomTurn[0];
- }
- return key + holdingsKey;
-}
-
-#define MOVE_BUF 100
-
-// fs routines read from memory buffer if no file specified
-
-static unsigned char *memBuf, *memPtr;
-static int bufSize;
-Boolean mcMode;
-
-int
-fsseek (FILE *f, int n, int mode)
-{
- if(f) return fseek(f, n, mode);
- if(mode == SEEK_SET) memPtr = memBuf + n; else
- if(mode == SEEK_END) memPtr = memBuf + 16*bufSize + n;
- return memPtr < memBuf || memPtr > memBuf + 16*bufSize;
-}
-
-int
-fstell (FILE *f)
-{
- if(f) return ftell(f);
- return memPtr - memBuf;
-}
-
-int
-fsgetc (FILE *f)
-{
- if(f) return fgetc(f);
- if(memPtr >= memBuf + 16*bufSize) return EOF;
- return *memPtr++ ;
-}
-
-int
-int_from_file (FILE *f, int l, uint64 *r)
-{
- int i,c;
- for(i=0;i<l;i++){
- c=fsgetc(f);
- if(c==EOF){
- return 1;
- }
- (*r)=((*r)<<8)+c;
- }
- return 0;
-}
-
-int
-entry_from_file (FILE *f, entry_t *entry)
-{
- int ret;
- uint64 r;
- if(!f) { *entry = *(entry_t*) memPtr; memPtr += 16; return 0; }
- ret=int_from_file(f,8,&r);
- if(ret) return 1;
- entry->key=r;
- ret=int_from_file(f,2,&r);
- if(ret) return 1;
- entry->move=r;
- ret=int_from_file(f,2,&r);
- if(ret) return 1;
- entry->weight=r;
- ret=int_from_file(f,2,&r);
- if(ret) return 1;
- entry->learnCount=r;
- ret=int_from_file(f,2,&r);
- if(ret) return 1;
- entry->learnPoints=r;
- return 0;
-}
-
-int
-find_key (FILE *f, uint64 key, entry_t *entry)
-{
- int first, last, middle;
- entry_t last_entry,middle_entry;
- first=-1;
- if(fsseek(f,-16,SEEK_END)){
- *entry=entry_none;
- entry->key=key+1; //hack
- return -1;
- }
- last=fstell(f)/16;
- entry_from_file(f,&last_entry);
- while(1){
- if(last-first==1){
- *entry=last_entry;
- return last;
- }
- middle=(first+last)/2;
- fsseek(f,16*middle,SEEK_SET);
- entry_from_file(f,&middle_entry);
- if(key<=middle_entry.key){
- last=middle;
- last_entry=middle_entry;
- }else{
- first=middle;
- }
- }
-}
-
-static int xStep[] = { 0, 1, 1, 1, 0,-1,-1,-1 };
-static int yStep[] = { 1, 1, 0,-1,-1,-1, 0, 1 };
-
-void
-move_to_string (char move_s[20], uint16 move)
-{
- int f,fr,ff,t,tr,tf,p;
- int width = BOARD_RGHT - BOARD_LEFT, size; // allow for alternative board formats
-
- size = width * BOARD_HEIGHT;
- p = move / (size*size);
- move = move % (size*size);
- f = move / size;
- fr = f / width;
- ff = f % width;
- t = move % size;
- tr = t / width;
- tf = t % width;
- snprintf(move_s, 9, "%c%d%c%d", ff + 'a', fr + 1 - (BOARD_HEIGHT == 10), tf + 'a', tr + 1 - (BOARD_HEIGHT == 10));
-
- if(IS_SHOGI(gameInfo.variant) && p) {
- if(p == 2) p = 10; // Lion moves, for boards so big that 10 is out of range
- else if(p != 7) p = 8; // use '+' for all others that do not explicitly defer
- }
-
- // kludge: encode drops as special promotion code
- if(gameInfo.holdingsSize && p == 9) {
- move_s[0] = f + '@'; // from square encodes piece type
- move_s[1] = '@'; // drop symbol
- p = 0;
- } else if(p == 10) { // decode Lion move
- int i = t & 7, j = t >> 3 & 7;
- tf = ff + xStep[i] + xStep[j]; tr = fr + yStep[i] + yStep[j]; // calculate true to-square
- snprintf(move_s, 20, "%c%d%c%d,%c%d%c%d", ff + 'a', fr + 1 - (BOARD_HEIGHT == 10),
- ff + xStep[i] + 'a', fr + yStep[i] + 1 - (BOARD_HEIGHT == 10),
- ff + xStep[i] + 'a', fr + yStep[i] + 1 - (BOARD_HEIGHT == 10),
- tf + 'a', tr + 1 - (BOARD_HEIGHT == 10) );
- p = 0;
- }
-
- // add promotion piece, if any
- if(p){
- int len = strlen(move_s);
- move_s[len] = promote_pieces[p];
- move_s[len+1] = '\0';
- }
-
- if(gameInfo.variant != VariantNormal) return;
-
- // correct FRC-style castlings in variant normal.
- // [HGM] This is buggy code! e1h1 could very well be a normal R or Q move.
- if(!strcmp(move_s,"e1h1")){
- safeStrCpy(move_s,"e1g1", 6);
- }else if(!strcmp(move_s,"e1a1")){
- safeStrCpy(move_s,"e1c1", 6);
- }else if(!strcmp(move_s,"e8h8")){
- safeStrCpy(move_s,"e8g8", 6);
- }else if(!strcmp(move_s,"e8a8")){
- safeStrCpy(move_s,"e8c8", 6);
- }
-}
-
-int
-GetBookMoves (FILE *f, int moveNr, entry_t entries[], int max)
-{ // retrieve all entries for given position from book in 'entries', return number.
- entry_t entry;
- int offset;
- uint64 key;
- int count;
- int ret;
-
- key = hash(moveNr);
- if(appData.debugMode) fprintf(debugFP, "book key = %08x%08x\n", (unsigned int)(key>>32), (unsigned int)key);
-
- offset=find_key(f, key, &entry);
- if(entry.key != key) {
- return FALSE;
- }
- entries[0] = entry;
- count=1;
- fsseek(f, 16*(offset+1), SEEK_SET);
- while(1){
- ret=entry_from_file(f, &entry);
- if(ret){
- break;
- }
- if(entry.key != key){
- break;
- }
- if(count == max) break;
- entries[count++] = entry;
- }
- return count;
-}
-
-static int dirty;
-
-int
-ReadFromBookFile (int moveNr, char *book, entry_t entries[])
-{ // retrieve all entries for given position from book in 'entries', return number.
- static FILE *f = NULL;
- static char curBook[MSG_SIZ];
-
- if(book == NULL) return -1;
- if(dirty) { if(f) fclose(f); dirty = 0; f = NULL; }
- if(!f || strcmp(book, curBook)){ // keep book file open until book changed
- strncpy(curBook, book, MSG_SIZ);
- if(f) fclose(f);
- f = fopen(book,"rb");
- }
- if(!f){
- DisplayError(_("Polyglot book not valid"), 0);
- appData.usePolyglotBook = FALSE;
- return -1;
- }
-
- return GetBookMoves(f, moveNr, entries, MOVE_BUF);
-}
-
-// next three made into subroutines to facilitate future changes in storage scheme (e.g. 2 x 3 bytes)
-
-static int
-wins(entry_t *e)
-{
- return e->learnPoints;
-}
-
-static int
-losses(entry_t *e)
-{
- return e->learnCount;
-}
-
-static void
-CountMove (entry_t *e, int result)
-{
- switch(result) {
- case 0: e->learnCount ++; break;
- case 1: e->learnCount ++; // count draw as win + loss
- case 2: e->learnPoints ++; break;
- }
-}
-
-#define MERGESIZE 2048
-#define HASHSIZE 1024*1024*4
-
-entry_t *memBook, *hashTab, *mergeBuf;
-int bookSize=1, mergeSize=1, mask = HASHSIZE-1;
-
-void
-InitMemBook ()
-{
- static int initDone = FALSE;
- if(initDone) return;
- memBook = (entry_t *) calloc(1024*1024, sizeof(entry_t));
- hashTab = (entry_t *) calloc(HASHSIZE, sizeof(entry_t));
- mergeBuf = (entry_t *) calloc(MERGESIZE+5, sizeof(entry_t));
- memBook[0].key = -1LL;
- mergeBuf[0].key = -1LL;
- initDone = TRUE;
-}
-
-char *
-MCprobe (int moveNr)
-{
- int count, count2, games, i, choice=0;
- entry_t entries[MOVE_BUF];
- float nominal[MOVE_BUF], tot, deficit, max, min;
- static char move_s[6];
-
- InitMemBook();
- memBuf = (unsigned char*) memBook; bufSize = bookSize; // in MC mode book resides in memory
- count = GetBookMoves(NULL, moveNr, entries, MOVE_BUF);
- if(count < 0) count = 0; // don't care about miss yet
- memBuf = (unsigned char*) mergeBuf; bufSize = mergeSize; // there could be moves still waiting to be merged
- count2 = count + GetBookMoves(NULL, moveNr, entries+count, MOVE_BUF - count);
- if(appData.debugMode) fprintf(debugFP, "MC probe: %d/%d (%d+%d)\n", count, count2,bookSize,mergeSize);
- if(!count2) return NULL;
- tot = games = 0;
- for(i=0; i<count2; i++) {
- float w = wins(entries+i) + 10., l = losses(entries+i) + 10.;
- float h = (w*w*w*w + 22500.*w*w) / (l*l*l*l + 22500.*l*l);
- tot += nominal[i] = h;
- games += wins(entries+i) + losses(entries+i);
- }
- tot = games / tot; max = min = 0;
- for(i=0; i<count2; i++) {
- nominal[i] *= tot; // normalize so they sum to games
- deficit = nominal[i] - (wins(entries+i) + losses(entries+i));
- if(deficit > max) max = deficit, choice = i;
- if(deficit < min) min = deficit;
- } // note that a single move will never be underplayed
- if(max - min > 0.5*sqrt(nominal[choice])) { // if one of the listed moves is significantly under-played, play it now.
- move_to_string(move_s, entries[choice].move);
- if(appData.debugMode) fprintf(debugFP, "book move field = %d\n", entries[choice].move);
- return move_s;
- }
- return NULL; // otherwise fake book miss to force engine think, hoping for hitherto unplayed move.
-}
-
-char
-*ProbeBook (int moveNr, char *book)
-{ //
- entry_t entries[MOVE_BUF];
- int count;
- int i, j;
- static char move_s[6];
- int total_weight;
-
- if(moveNr >= 2*appData.bookDepth) return NULL;
- if(mcMode) return MCprobe(moveNr);
-
- if((count = ReadFromBookFile(moveNr, book, entries)) <= 0) return NULL; // no book, or no hit
-
- if(appData.bookStrength != 50) { // transform weights
- double power = 0, maxWeight = 0.0;
- if(appData.bookStrength) power = (100.-appData.bookStrength)/appData.bookStrength;
- for(i=0; i<count; i++) if(entries[i].weight > maxWeight) maxWeight = entries[i].weight;
- for(i=0; i<count; i++){
- double weight = entries[i].weight / maxWeight;
- if(weight > 0)
- entries[i].weight = appData.bookStrength || weight == 1.0 ? 1e4*exp(power * log(weight)) + 0.5 : 0.0;
- }
- }
- total_weight = 0;
- for(i=0; i<count; i++){
- total_weight += entries[i].weight;
- }
- if(total_weight == 0) return NULL; // force book miss rather than playing moves with weight 0.
- j = (random() & 0xFFF) * total_weight >> 12; // create random < total_weight
- total_weight = 0;
- for(i=0; i<count; i++){
- total_weight += entries[i].weight;
- if(total_weight > j) break;
- }
- if(i >= count) DisplayFatalError(_("Book Fault"), 0, 1); // safety catch, cannot happen
- move_to_string(move_s, entries[i].move);
- if(appData.debugMode) fprintf(debugFP, "book move field = %d\n", entries[i].move);
-
- return move_s;
-}
-
-extern char yy_textstr[];
-entry_t lastEntries[MOVE_BUF];
-
-char *
-MovesToText(int count, entry_t *entries)
-{
- int i, totalWeight = 0;
- char algMove[12];
- char *p = (char*) malloc(40*count+1);
- for(i=0; i<count; i++) totalWeight += entries[i].weight;
- *p = 0;
- for(i=0; i<count; i++) {
- char buf[MSG_SIZ], c1, c2, c3; int i1, i2, i3;
- move_to_string(algMove, entries[i].move);
- if(sscanf(algMove, "%c%d%*c%*d,%c%d%c%d", &c1, &i1, &c2, &i2, &c3, &i3) == 6)
- snprintf(algMove, 12, "%c%dx%c%d-%c%d", c1, i1, c2, i2, c3, i3); // cast double-moves in format SAN parser will understand
- else if(sscanf(algMove, "%c%d%c%d%c", &c1, &i1, &c2, &i2, &c3) >= 4) {
- CoordsToAlgebraic(boards[currentMove], PosFlags(currentMove), i1-ONE+'0', c1-AAA, i2-ONE+'0', c2-AAA, c3, algMove);
- }
- buf[0] = NULLCHAR;
- if(entries[i].learnCount || entries[i].learnPoints)
- snprintf(buf, MSG_SIZ, " {%d/%d}", entries[i].learnPoints, entries[i].learnCount);
- snprintf(p+strlen(p), 40, "%5.1f%% %5d %s%s\n", 100*entries[i].weight/(totalWeight+0.001),
- entries[i].weight, algMove, buf);
-//lastEntries[i] = entries[i];
- }
- return p;
-}
-
-static int
-CoordsToMove (int fromX, int fromY, int toX, int toY, char promoChar)
-{
- int i, width = BOARD_RGHT - BOARD_LEFT;
- int to = toX - BOARD_LEFT + toY * width;
- int from = fromX - BOARD_LEFT + fromY * width;
- for(i=0; promote_pieces[i]; i++) if(promote_pieces[i] == promoChar) break;
- if(!promote_pieces[i]) i = 0;
- else if(i == 9 && gameInfo.variant == VariantChu) i = 1; // on 12x12 only 3 promotion codes available, so use 1 to indicate promotion
- if(fromY == DROP_RANK) i = 9, from = ToUpper(PieceToChar(fromX)) - '@';
- if(killX >= 0) { // multi-leg move
- int dx = killX - fromX, dy = killY - fromY;
- for(i=0; i<8; i++) if(dx == xStep[i] && dy == yStep[i]) {
- int j;
- dx = toX - killX; dy = toY - killY;
- for(j=0; j<8; j++) if(dx == xStep[j] && dy == yStep[j]) {
- // special encoding in to-square, with promoType = 2. Assumes board >= 64 squares!
- return i + 8*j + (2 * width * BOARD_HEIGHT + from) * width * BOARD_HEIGHT;
- }
- }
- i = 0; // if not a valid Lion move, ignore kill-square and promoChar
- }
- return to + (i * width * BOARD_HEIGHT + from) * width * BOARD_HEIGHT;
-}
-
-int
-TextToMoves (char *text, int moveNum, entry_t *entries)
-{
- int i, w, count=0;
- uint64 hashKey = hash(moveNum);
- int fromX, fromY, toX, toY;
- ChessMove moveType;
- char promoChar, valid;
- float dummy;
-
- entries[0].key = hashKey; // make sure key is returned even if no moves
- while((i=sscanf(text, "%f%%%d", &dummy, &w))==2 || (i=sscanf(text, "%d", &w))==1) {
- if(i == 2) text = strchr(text, '%') + 1; // skip percentage
- if(w == 1) text = strstr(text, "1 ") + 2; // skip weight that could be recognized as move number one
- valid = ParseOneMove(text, moveNum, &moveType, &fromX, &fromY, &toX, &toY, &promoChar);
- text = strstr(text, yy_textstr) + strlen(yy_textstr); // skip what we parsed
- if(!valid || moveType != NormalMove && moveType != WhiteDrop && moveType != BlackDrop
- && moveType != FirstLeg
- && moveType != WhitePromotion && moveType != BlackPromotion
- && moveType != WhiteCapturesEnPassant && moveType != BlackCapturesEnPassant
- && moveType != WhiteKingSideCastle && moveType != BlackKingSideCastle
- && moveType != WhiteQueenSideCastle && moveType != BlackQueenSideCastle
- && moveType != WhiteNonPromotion && moveType != BlackNonPromotion) continue;
- if(*text == ' ' && sscanf(text+1, "{%hd/%hd}", &entries[count].learnPoints, &entries[count].learnCount) == 2) {
- text = strchr(text+1, '}') + 1;
- } else {
- entries[count].learnPoints = 0;
- entries[count].learnCount = 0;
- }
- entries[count].move = CoordsToMove(fromX, fromY, toX, toY, promoChar); killX = killY = -1;
- entries[count].key = hashKey;
- entries[count].weight = w;
- count++;
- }
- return count;
-}
-
-Boolean bookUp;
-int currentCount;
-
-Boolean
-DisplayBook (int moveNr)
-{
- entry_t entries[MOVE_BUF];
- int count;
- char *p;
- if(!bookUp) return FALSE;
- count = currentCount = ReadFromBookFile(moveNr, appData.polyglotBook, entries);
- if(count < 0) return FALSE;
- p = MovesToText(count, entries);
- EditTagsPopUp(p, NULL);
- free(p);
- addToBookFlag = FALSE;
- return TRUE;
-}
-
-void
-EditBookEvent()
-{
- bookUp = TRUE;
- bookUp = DisplayBook(currentMove);
-}
-
-void
-int_to_file (FILE *f, int l, uint64 r)
-{
- int i;
- for(i=l-1;i>=0;i--) fputc(r>>8*i & 255, f);
-}
-
-void
-entry_to_file (FILE *f, entry_t *entry)
-{
- int_to_file(f,8,entry->key);
- int_to_file(f,2,entry->move);
- int_to_file(f,2,entry->weight);
- int_to_file(f,2,entry->learnCount);
- int_to_file(f,2,entry->learnPoints);
-}
-
-char buf1[4096], buf2[4096];
-
-void
-SaveToBook (char *text)
-{
- entry_t entries[MOVE_BUF], entry;
- int count = TextToMoves(text, currentMove, entries);
- int offset, i, len1=0, len2, readpos=0, writepos=0;
- FILE *f;
- if(!count && !currentCount) return;
- f=fopen(appData.polyglotBook, "rb+");
- if(!f){ DisplayError(_("Polyglot book not valid"), 0); return; }
- offset=find_key(f, entries[0].key, &entry);
- if(entries[0].key != entry.key && currentCount) {
- DisplayError(_("Hash keys are different"), 0);
- fclose(f);
- return;
- }
- if(count != currentCount) {
- readpos = 16*(offset + currentCount);
- writepos = 16*(offset + count);
- fsseek(f, readpos, SEEK_SET);
- readpos += len1 = fread(buf1, 1, 4096 - 16*currentCount, f); // salvage some entries immediately behind change
- }
- fsseek(f, 16*(offset), SEEK_SET);
- for(i=0; i<count; i++) entry_to_file(f, entries + i); // save the change
- if(count != currentCount) {
- do {
- for(i=0; i<len1; i++) buf2[i] = buf1[i]; len2 = len1;
- if(readpos > writepos) {
- fsseek(f, readpos, SEEK_SET);
- readpos += len1 = fread(buf1, 1, 4096, f);
- } else len1 = 0; // wrote already past old EOF
- fsseek(f, writepos, SEEK_SET);
- fwrite(buf2, 1, len2, f);
- writepos += len2;
- } while(len1);
- }
- dirty = 1;
- fclose(f);
-}
-
-void
-NewEntry (entry_t *e, uint64 key, int move, int result)
-{
- e->key = key;
- e->move = move;
- e->learnPoints = 0;
- e->learnCount = 0;
- CountMove(e, result);
-}
-
-void
-Merge ()
-{
- int i;
-
- if(appData.debugMode) fprintf(debugFP, "book merge %d moves (old size %d)\n", mergeSize, bookSize);
-
- bookSize += --mergeSize;
- for(i=bookSize-1; mergeSize; i--) {
- while(mergeSize && (i < mergeSize || mergeBuf[mergeSize-1].key >= memBook[i-mergeSize].key))
- memBook[i--] = mergeBuf[--mergeSize];
- if(i < 0) break;
- memBook[i] = memBook[i-mergeSize];
- }
- if(mergeSize) DisplayFatalError("merge error", 0, 0); // impossible
- mergeSize = 1;
- mergeBuf[0].key = -1LL;
-}
-
-void
-AddToBook (int moveNr, int result)
-{
- entry_t entry;
- int offset, start, move;
- uint64 key;
- int i, j, fromY, toY;
- char fromX, toX, promo;
-extern char moveList[][MOVE_LEN];
-
- if(!moveList[moveNr][0] || moveList[moveNr][0] == '\n') return; // could be terminal position
-
- if(appData.debugMode) fprintf(debugFP, "add move %d to book %s", moveNr, moveList[moveNr]);
-
- // calculate key and book representation of move
- key = hash(moveNr);
- if(moveList[moveNr][1] == '@') {
- sscanf(moveList[moveNr], "%c@%c%d", &promo, &toX, &toY);
- fromX = CharToPiece(WhiteOnMove(moveNr) ? ToUpper(promo) : ToLower(promo));
- fromY = DROP_RANK; promo = NULLCHAR;
- } else sscanf(moveList[moveNr], "%c%d%c%d%c", &fromX, &fromY, &toX, &toY, &promo), fromX -= AAA, fromY -= ONE - '0';
- move = CoordsToMove(fromX, fromY, toX-AAA, toY-ONE+'0', promo);
-
- // if move already in book, just add count
- memBuf = (unsigned char*) memBook; bufSize = bookSize; // in MC mode book resides in memory
- offset = find_key(NULL, key, &entry);
- while(memBook[offset].key == key) {
- if(memBook[offset].move == move) {
- CountMove(memBook+offset, result); return;
- } else offset++;
- }
- // move did not occur in the main book
- memBuf = (unsigned char*) mergeBuf; bufSize = mergeSize; // it could be amongst moves still waiting to be merged
- start = offset = find_key(NULL, key, &entry);
- while(mergeBuf[offset].key == key) {
- if(mergeBuf[offset].move == move) {
- if(appData.debugMode) fprintf(debugFP, "found in book merge buf @ %d\n", offset);
- CountMove(mergeBuf+offset, result); return;
- } else offset++;
- }
- if(start != offset) { // position was in mergeBuf, but move is new
- if(appData.debugMode) fprintf(debugFP, "add in book merge buf @ %d\n", offset);
- for(i=mergeSize++; i>offset; i--) mergeBuf[i] = mergeBuf[i-1]; // make room
- NewEntry(mergeBuf+offset, key, move, result);
- return;
- }
- // position was not in mergeBuf; look in hash table
- i = (key & mask); offset = -1;
- while(hashTab[i].key) { // search in hash table (necessary because sought item could be re-hashed)
- if(hashTab[i].key == 1 && offset < 0) offset = i; // remember first invalidated entry we pass
- if(!((hashTab[i].key - key) & ~1)) { // hit
- if(hashTab[i].move == move) {
- CountMove(hashTab+i, result);
- for(j=mergeSize++; j>start; j--) mergeBuf[j] = mergeBuf[j-1];
- } else {
- // position already in hash now occurs with different move; move both moves to mergeBuf
- for(j=mergeSize+1; j>start+1; j--) mergeBuf[j] = mergeBuf[j-2];
- NewEntry(mergeBuf+start+1, key, move, result); mergeSize += 2;
- }
- hashTab[i].key = 1; // kludge to invalidate hash entry
- mergeBuf[start] = hashTab[i]; mergeBuf[start].key = key;
- if(mergeSize >= MERGESIZE) Merge();
- return;
- }
- i = i+1 & mask; // wrap!
- }
- // position did not yet occur in hash table. Put it there
- if(offset < 0) offset = i;
- NewEntry(hashTab+offset, key, move, result);
- if(appData.debugMode)
- fprintf(debugFP, "book hash @ %d (%d-%d)\n", offset, hashTab[offset].learnPoints, hashTab[offset].learnCount);
-}
-
-void
-AddGameToBook (int always)
-{
- int i, result;
-
- if(!mcMode && !always) return;
-
- InitMemBook();
- switch(gameInfo.result) {
- case GameIsDrawn: result = 1; break;
- case WhiteWins: result = 2; break;
- case BlackWins: result = 0; break;
- default: return; // don't treat games with unknown result
- }
-
- if(appData.debugMode) fprintf(debugFP, "add game to book (%d-%d)\n", backwardMostMove, forwardMostMove);
- for(i=backwardMostMove; i<forwardMostMove && i < 2*appData.bookDepth; i++)
- AddToBook(i, WhiteOnMove(i) ? result : 2-result); // flip result when black moves
-}
-
-void
-PlayBookMove(char *text, int index)
-{
- char *start = text+index, *end = start;
- while(start > text && start[-1] != ' ' && start[-1] != '\t') start--;
- while(*end && *++end != ' ' && *end != '\n')
- ; *end = NULLCHAR; // find clicked word
- if(start != end) TypeInDoneEvent(start); // fake it was typed in move type-in
-}
-
-void
-FlushBook ()
-{
- FILE *f;
- int i;
-
- InitMemBook();
- Merge(); // flush merge buffer to memBook
-
- if(f = fopen(appData.polyglotBook, "wb")) {
- for(i=0; i<bookSize; i++) {
- entry_t entry = memBook[i];
- entry.weight = entry.learnPoints;
-// entry.learnPoints = 0;
-// entry.learnCount = 0;
- entry_to_file(f, &entry);
- }
- } else DisplayError(_("Could not create book"), 0);
-}
projects / xboard.git / blobdiff