2 * book.c -- code for probing Polyglot opening books
4 * This code was first released in the public domain by Michel Van den Bergh.
5 * The array Random64 is taken from the Polyglot source code.
6 * I am pretty sure that a table of random numbers is never protected
9 * It s adapted by H.G. Muller for working with xboard / Winboard
11 * The following terms apply to the enhanced version of XBoard distributed
12 * by the Free Software Foundation:
13 * ------------------------------------------------------------------------
15 * GNU XBoard is free software: you can redistribute it and/or modify
16 * it under the terms of the GNU General Public License as published by
17 * the Free Software Foundation, either version 3 of the License, or (at
18 * your option) any later version.
20 * GNU XBoard is distributed in the hope that it will be useful, but
21 * WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 * General Public License for more details.
25 * You should have received a copy of the GNU General Public License
26 * along with this program. If not, see http://www.gnu.org/licenses/. *
28 * ------------------------------------------------------------------------
46 # define _(s) gettext (s)
47 # define N_(s) gettext_noop (s)
54 typedef unsigned __int64 uint64;
56 typedef unsigned long long int uint64;
60 # define U64(u) (u##ui64)
62 # define U64(u) (u##ULL)
65 typedef unsigned char uint8;
66 typedef unsigned short uint16;
67 typedef unsigned int uint32;
77 entry_t entry_none = {
81 char *promote_pieces=" nbrqac=+";
83 uint64 Random64[781] = {
84 U64(0x9D39247E33776D41), U64(0x2AF7398005AAA5C7), U64(0x44DB015024623547), U64(0x9C15F73E62A76AE2),
85 U64(0x75834465489C0C89), U64(0x3290AC3A203001BF), U64(0x0FBBAD1F61042279), U64(0xE83A908FF2FB60CA),
86 U64(0x0D7E765D58755C10), U64(0x1A083822CEAFE02D), U64(0x9605D5F0E25EC3B0), U64(0xD021FF5CD13A2ED5),
87 U64(0x40BDF15D4A672E32), U64(0x011355146FD56395), U64(0x5DB4832046F3D9E5), U64(0x239F8B2D7FF719CC),
88 U64(0x05D1A1AE85B49AA1), U64(0x679F848F6E8FC971), U64(0x7449BBFF801FED0B), U64(0x7D11CDB1C3B7ADF0),
89 U64(0x82C7709E781EB7CC), U64(0xF3218F1C9510786C), U64(0x331478F3AF51BBE6), U64(0x4BB38DE5E7219443),
90 U64(0xAA649C6EBCFD50FC), U64(0x8DBD98A352AFD40B), U64(0x87D2074B81D79217), U64(0x19F3C751D3E92AE1),
91 U64(0xB4AB30F062B19ABF), U64(0x7B0500AC42047AC4), U64(0xC9452CA81A09D85D), U64(0x24AA6C514DA27500),
92 U64(0x4C9F34427501B447), U64(0x14A68FD73C910841), U64(0xA71B9B83461CBD93), U64(0x03488B95B0F1850F),
93 U64(0x637B2B34FF93C040), U64(0x09D1BC9A3DD90A94), U64(0x3575668334A1DD3B), U64(0x735E2B97A4C45A23),
94 U64(0x18727070F1BD400B), U64(0x1FCBACD259BF02E7), U64(0xD310A7C2CE9B6555), U64(0xBF983FE0FE5D8244),
95 U64(0x9F74D14F7454A824), U64(0x51EBDC4AB9BA3035), U64(0x5C82C505DB9AB0FA), U64(0xFCF7FE8A3430B241),
96 U64(0x3253A729B9BA3DDE), U64(0x8C74C368081B3075), U64(0xB9BC6C87167C33E7), U64(0x7EF48F2B83024E20),
97 U64(0x11D505D4C351BD7F), U64(0x6568FCA92C76A243), U64(0x4DE0B0F40F32A7B8), U64(0x96D693460CC37E5D),
98 U64(0x42E240CB63689F2F), U64(0x6D2BDCDAE2919661), U64(0x42880B0236E4D951), U64(0x5F0F4A5898171BB6),
99 U64(0x39F890F579F92F88), U64(0x93C5B5F47356388B), U64(0x63DC359D8D231B78), U64(0xEC16CA8AEA98AD76),
100 U64(0x5355F900C2A82DC7), U64(0x07FB9F855A997142), U64(0x5093417AA8A7ED5E), U64(0x7BCBC38DA25A7F3C),
101 U64(0x19FC8A768CF4B6D4), U64(0x637A7780DECFC0D9), U64(0x8249A47AEE0E41F7), U64(0x79AD695501E7D1E8),
102 U64(0x14ACBAF4777D5776), U64(0xF145B6BECCDEA195), U64(0xDABF2AC8201752FC), U64(0x24C3C94DF9C8D3F6),
103 U64(0xBB6E2924F03912EA), U64(0x0CE26C0B95C980D9), U64(0xA49CD132BFBF7CC4), U64(0xE99D662AF4243939),
104 U64(0x27E6AD7891165C3F), U64(0x8535F040B9744FF1), U64(0x54B3F4FA5F40D873), U64(0x72B12C32127FED2B),
105 U64(0xEE954D3C7B411F47), U64(0x9A85AC909A24EAA1), U64(0x70AC4CD9F04F21F5), U64(0xF9B89D3E99A075C2),
106 U64(0x87B3E2B2B5C907B1), U64(0xA366E5B8C54F48B8), U64(0xAE4A9346CC3F7CF2), U64(0x1920C04D47267BBD),
107 U64(0x87BF02C6B49E2AE9), U64(0x092237AC237F3859), U64(0xFF07F64EF8ED14D0), U64(0x8DE8DCA9F03CC54E),
108 U64(0x9C1633264DB49C89), U64(0xB3F22C3D0B0B38ED), U64(0x390E5FB44D01144B), U64(0x5BFEA5B4712768E9),
109 U64(0x1E1032911FA78984), U64(0x9A74ACB964E78CB3), U64(0x4F80F7A035DAFB04), U64(0x6304D09A0B3738C4),
110 U64(0x2171E64683023A08), U64(0x5B9B63EB9CEFF80C), U64(0x506AACF489889342), U64(0x1881AFC9A3A701D6),
111 U64(0x6503080440750644), U64(0xDFD395339CDBF4A7), U64(0xEF927DBCF00C20F2), U64(0x7B32F7D1E03680EC),
112 U64(0xB9FD7620E7316243), U64(0x05A7E8A57DB91B77), U64(0xB5889C6E15630A75), U64(0x4A750A09CE9573F7),
113 U64(0xCF464CEC899A2F8A), U64(0xF538639CE705B824), U64(0x3C79A0FF5580EF7F), U64(0xEDE6C87F8477609D),
114 U64(0x799E81F05BC93F31), U64(0x86536B8CF3428A8C), U64(0x97D7374C60087B73), U64(0xA246637CFF328532),
115 U64(0x043FCAE60CC0EBA0), U64(0x920E449535DD359E), U64(0x70EB093B15B290CC), U64(0x73A1921916591CBD),
116 U64(0x56436C9FE1A1AA8D), U64(0xEFAC4B70633B8F81), U64(0xBB215798D45DF7AF), U64(0x45F20042F24F1768),
117 U64(0x930F80F4E8EB7462), U64(0xFF6712FFCFD75EA1), U64(0xAE623FD67468AA70), U64(0xDD2C5BC84BC8D8FC),
118 U64(0x7EED120D54CF2DD9), U64(0x22FE545401165F1C), U64(0xC91800E98FB99929), U64(0x808BD68E6AC10365),
119 U64(0xDEC468145B7605F6), U64(0x1BEDE3A3AEF53302), U64(0x43539603D6C55602), U64(0xAA969B5C691CCB7A),
120 U64(0xA87832D392EFEE56), U64(0x65942C7B3C7E11AE), U64(0xDED2D633CAD004F6), U64(0x21F08570F420E565),
121 U64(0xB415938D7DA94E3C), U64(0x91B859E59ECB6350), U64(0x10CFF333E0ED804A), U64(0x28AED140BE0BB7DD),
122 U64(0xC5CC1D89724FA456), U64(0x5648F680F11A2741), U64(0x2D255069F0B7DAB3), U64(0x9BC5A38EF729ABD4),
123 U64(0xEF2F054308F6A2BC), U64(0xAF2042F5CC5C2858), U64(0x480412BAB7F5BE2A), U64(0xAEF3AF4A563DFE43),
124 U64(0x19AFE59AE451497F), U64(0x52593803DFF1E840), U64(0xF4F076E65F2CE6F0), U64(0x11379625747D5AF3),
125 U64(0xBCE5D2248682C115), U64(0x9DA4243DE836994F), U64(0x066F70B33FE09017), U64(0x4DC4DE189B671A1C),
126 U64(0x51039AB7712457C3), U64(0xC07A3F80C31FB4B4), U64(0xB46EE9C5E64A6E7C), U64(0xB3819A42ABE61C87),
127 U64(0x21A007933A522A20), U64(0x2DF16F761598AA4F), U64(0x763C4A1371B368FD), U64(0xF793C46702E086A0),
128 U64(0xD7288E012AEB8D31), U64(0xDE336A2A4BC1C44B), U64(0x0BF692B38D079F23), U64(0x2C604A7A177326B3),
129 U64(0x4850E73E03EB6064), U64(0xCFC447F1E53C8E1B), U64(0xB05CA3F564268D99), U64(0x9AE182C8BC9474E8),
130 U64(0xA4FC4BD4FC5558CA), U64(0xE755178D58FC4E76), U64(0x69B97DB1A4C03DFE), U64(0xF9B5B7C4ACC67C96),
131 U64(0xFC6A82D64B8655FB), U64(0x9C684CB6C4D24417), U64(0x8EC97D2917456ED0), U64(0x6703DF9D2924E97E),
132 U64(0xC547F57E42A7444E), U64(0x78E37644E7CAD29E), U64(0xFE9A44E9362F05FA), U64(0x08BD35CC38336615),
133 U64(0x9315E5EB3A129ACE), U64(0x94061B871E04DF75), U64(0xDF1D9F9D784BA010), U64(0x3BBA57B68871B59D),
134 U64(0xD2B7ADEEDED1F73F), U64(0xF7A255D83BC373F8), U64(0xD7F4F2448C0CEB81), U64(0xD95BE88CD210FFA7),
135 U64(0x336F52F8FF4728E7), U64(0xA74049DAC312AC71), U64(0xA2F61BB6E437FDB5), U64(0x4F2A5CB07F6A35B3),
136 U64(0x87D380BDA5BF7859), U64(0x16B9F7E06C453A21), U64(0x7BA2484C8A0FD54E), U64(0xF3A678CAD9A2E38C),
137 U64(0x39B0BF7DDE437BA2), U64(0xFCAF55C1BF8A4424), U64(0x18FCF680573FA594), U64(0x4C0563B89F495AC3),
138 U64(0x40E087931A00930D), U64(0x8CFFA9412EB642C1), U64(0x68CA39053261169F), U64(0x7A1EE967D27579E2),
139 U64(0x9D1D60E5076F5B6F), U64(0x3810E399B6F65BA2), U64(0x32095B6D4AB5F9B1), U64(0x35CAB62109DD038A),
140 U64(0xA90B24499FCFAFB1), U64(0x77A225A07CC2C6BD), U64(0x513E5E634C70E331), U64(0x4361C0CA3F692F12),
141 U64(0xD941ACA44B20A45B), U64(0x528F7C8602C5807B), U64(0x52AB92BEB9613989), U64(0x9D1DFA2EFC557F73),
142 U64(0x722FF175F572C348), U64(0x1D1260A51107FE97), U64(0x7A249A57EC0C9BA2), U64(0x04208FE9E8F7F2D6),
143 U64(0x5A110C6058B920A0), U64(0x0CD9A497658A5698), U64(0x56FD23C8F9715A4C), U64(0x284C847B9D887AAE),
144 U64(0x04FEABFBBDB619CB), U64(0x742E1E651C60BA83), U64(0x9A9632E65904AD3C), U64(0x881B82A13B51B9E2),
145 U64(0x506E6744CD974924), U64(0xB0183DB56FFC6A79), U64(0x0ED9B915C66ED37E), U64(0x5E11E86D5873D484),
146 U64(0xF678647E3519AC6E), U64(0x1B85D488D0F20CC5), U64(0xDAB9FE6525D89021), U64(0x0D151D86ADB73615),
147 U64(0xA865A54EDCC0F019), U64(0x93C42566AEF98FFB), U64(0x99E7AFEABE000731), U64(0x48CBFF086DDF285A),
148 U64(0x7F9B6AF1EBF78BAF), U64(0x58627E1A149BBA21), U64(0x2CD16E2ABD791E33), U64(0xD363EFF5F0977996),
149 U64(0x0CE2A38C344A6EED), U64(0x1A804AADB9CFA741), U64(0x907F30421D78C5DE), U64(0x501F65EDB3034D07),
150 U64(0x37624AE5A48FA6E9), U64(0x957BAF61700CFF4E), U64(0x3A6C27934E31188A), U64(0xD49503536ABCA345),
151 U64(0x088E049589C432E0), U64(0xF943AEE7FEBF21B8), U64(0x6C3B8E3E336139D3), U64(0x364F6FFA464EE52E),
152 U64(0xD60F6DCEDC314222), U64(0x56963B0DCA418FC0), U64(0x16F50EDF91E513AF), U64(0xEF1955914B609F93),
153 U64(0x565601C0364E3228), U64(0xECB53939887E8175), U64(0xBAC7A9A18531294B), U64(0xB344C470397BBA52),
154 U64(0x65D34954DAF3CEBD), U64(0xB4B81B3FA97511E2), U64(0xB422061193D6F6A7), U64(0x071582401C38434D),
155 U64(0x7A13F18BBEDC4FF5), U64(0xBC4097B116C524D2), U64(0x59B97885E2F2EA28), U64(0x99170A5DC3115544),
156 U64(0x6F423357E7C6A9F9), U64(0x325928EE6E6F8794), U64(0xD0E4366228B03343), U64(0x565C31F7DE89EA27),
157 U64(0x30F5611484119414), U64(0xD873DB391292ED4F), U64(0x7BD94E1D8E17DEBC), U64(0xC7D9F16864A76E94),
158 U64(0x947AE053EE56E63C), U64(0xC8C93882F9475F5F), U64(0x3A9BF55BA91F81CA), U64(0xD9A11FBB3D9808E4),
159 U64(0x0FD22063EDC29FCA), U64(0xB3F256D8ACA0B0B9), U64(0xB03031A8B4516E84), U64(0x35DD37D5871448AF),
160 U64(0xE9F6082B05542E4E), U64(0xEBFAFA33D7254B59), U64(0x9255ABB50D532280), U64(0xB9AB4CE57F2D34F3),
161 U64(0x693501D628297551), U64(0xC62C58F97DD949BF), U64(0xCD454F8F19C5126A), U64(0xBBE83F4ECC2BDECB),
162 U64(0xDC842B7E2819E230), U64(0xBA89142E007503B8), U64(0xA3BC941D0A5061CB), U64(0xE9F6760E32CD8021),
163 U64(0x09C7E552BC76492F), U64(0x852F54934DA55CC9), U64(0x8107FCCF064FCF56), U64(0x098954D51FFF6580),
164 U64(0x23B70EDB1955C4BF), U64(0xC330DE426430F69D), U64(0x4715ED43E8A45C0A), U64(0xA8D7E4DAB780A08D),
165 U64(0x0572B974F03CE0BB), U64(0xB57D2E985E1419C7), U64(0xE8D9ECBE2CF3D73F), U64(0x2FE4B17170E59750),
166 U64(0x11317BA87905E790), U64(0x7FBF21EC8A1F45EC), U64(0x1725CABFCB045B00), U64(0x964E915CD5E2B207),
167 U64(0x3E2B8BCBF016D66D), U64(0xBE7444E39328A0AC), U64(0xF85B2B4FBCDE44B7), U64(0x49353FEA39BA63B1),
168 U64(0x1DD01AAFCD53486A), U64(0x1FCA8A92FD719F85), U64(0xFC7C95D827357AFA), U64(0x18A6A990C8B35EBD),
169 U64(0xCCCB7005C6B9C28D), U64(0x3BDBB92C43B17F26), U64(0xAA70B5B4F89695A2), U64(0xE94C39A54A98307F),
170 U64(0xB7A0B174CFF6F36E), U64(0xD4DBA84729AF48AD), U64(0x2E18BC1AD9704A68), U64(0x2DE0966DAF2F8B1C),
171 U64(0xB9C11D5B1E43A07E), U64(0x64972D68DEE33360), U64(0x94628D38D0C20584), U64(0xDBC0D2B6AB90A559),
172 U64(0xD2733C4335C6A72F), U64(0x7E75D99D94A70F4D), U64(0x6CED1983376FA72B), U64(0x97FCAACBF030BC24),
173 U64(0x7B77497B32503B12), U64(0x8547EDDFB81CCB94), U64(0x79999CDFF70902CB), U64(0xCFFE1939438E9B24),
174 U64(0x829626E3892D95D7), U64(0x92FAE24291F2B3F1), U64(0x63E22C147B9C3403), U64(0xC678B6D860284A1C),
175 U64(0x5873888850659AE7), U64(0x0981DCD296A8736D), U64(0x9F65789A6509A440), U64(0x9FF38FED72E9052F),
176 U64(0xE479EE5B9930578C), U64(0xE7F28ECD2D49EECD), U64(0x56C074A581EA17FE), U64(0x5544F7D774B14AEF),
177 U64(0x7B3F0195FC6F290F), U64(0x12153635B2C0CF57), U64(0x7F5126DBBA5E0CA7), U64(0x7A76956C3EAFB413),
178 U64(0x3D5774A11D31AB39), U64(0x8A1B083821F40CB4), U64(0x7B4A38E32537DF62), U64(0x950113646D1D6E03),
179 U64(0x4DA8979A0041E8A9), U64(0x3BC36E078F7515D7), U64(0x5D0A12F27AD310D1), U64(0x7F9D1A2E1EBE1327),
180 U64(0xDA3A361B1C5157B1), U64(0xDCDD7D20903D0C25), U64(0x36833336D068F707), U64(0xCE68341F79893389),
181 U64(0xAB9090168DD05F34), U64(0x43954B3252DC25E5), U64(0xB438C2B67F98E5E9), U64(0x10DCD78E3851A492),
182 U64(0xDBC27AB5447822BF), U64(0x9B3CDB65F82CA382), U64(0xB67B7896167B4C84), U64(0xBFCED1B0048EAC50),
183 U64(0xA9119B60369FFEBD), U64(0x1FFF7AC80904BF45), U64(0xAC12FB171817EEE7), U64(0xAF08DA9177DDA93D),
184 U64(0x1B0CAB936E65C744), U64(0xB559EB1D04E5E932), U64(0xC37B45B3F8D6F2BA), U64(0xC3A9DC228CAAC9E9),
185 U64(0xF3B8B6675A6507FF), U64(0x9FC477DE4ED681DA), U64(0x67378D8ECCEF96CB), U64(0x6DD856D94D259236),
186 U64(0xA319CE15B0B4DB31), U64(0x073973751F12DD5E), U64(0x8A8E849EB32781A5), U64(0xE1925C71285279F5),
187 U64(0x74C04BF1790C0EFE), U64(0x4DDA48153C94938A), U64(0x9D266D6A1CC0542C), U64(0x7440FB816508C4FE),
188 U64(0x13328503DF48229F), U64(0xD6BF7BAEE43CAC40), U64(0x4838D65F6EF6748F), U64(0x1E152328F3318DEA),
189 U64(0x8F8419A348F296BF), U64(0x72C8834A5957B511), U64(0xD7A023A73260B45C), U64(0x94EBC8ABCFB56DAE),
190 U64(0x9FC10D0F989993E0), U64(0xDE68A2355B93CAE6), U64(0xA44CFE79AE538BBE), U64(0x9D1D84FCCE371425),
191 U64(0x51D2B1AB2DDFB636), U64(0x2FD7E4B9E72CD38C), U64(0x65CA5B96B7552210), U64(0xDD69A0D8AB3B546D),
192 U64(0x604D51B25FBF70E2), U64(0x73AA8A564FB7AC9E), U64(0x1A8C1E992B941148), U64(0xAAC40A2703D9BEA0),
193 U64(0x764DBEAE7FA4F3A6), U64(0x1E99B96E70A9BE8B), U64(0x2C5E9DEB57EF4743), U64(0x3A938FEE32D29981),
194 U64(0x26E6DB8FFDF5ADFE), U64(0x469356C504EC9F9D), U64(0xC8763C5B08D1908C), U64(0x3F6C6AF859D80055),
195 U64(0x7F7CC39420A3A545), U64(0x9BFB227EBDF4C5CE), U64(0x89039D79D6FC5C5C), U64(0x8FE88B57305E2AB6),
196 U64(0xA09E8C8C35AB96DE), U64(0xFA7E393983325753), U64(0xD6B6D0ECC617C699), U64(0xDFEA21EA9E7557E3),
197 U64(0xB67C1FA481680AF8), U64(0xCA1E3785A9E724E5), U64(0x1CFC8BED0D681639), U64(0xD18D8549D140CAEA),
198 U64(0x4ED0FE7E9DC91335), U64(0xE4DBF0634473F5D2), U64(0x1761F93A44D5AEFE), U64(0x53898E4C3910DA55),
199 U64(0x734DE8181F6EC39A), U64(0x2680B122BAA28D97), U64(0x298AF231C85BAFAB), U64(0x7983EED3740847D5),
200 U64(0x66C1A2A1A60CD889), U64(0x9E17E49642A3E4C1), U64(0xEDB454E7BADC0805), U64(0x50B704CAB602C329),
201 U64(0x4CC317FB9CDDD023), U64(0x66B4835D9EAFEA22), U64(0x219B97E26FFC81BD), U64(0x261E4E4C0A333A9D),
202 U64(0x1FE2CCA76517DB90), U64(0xD7504DFA8816EDBB), U64(0xB9571FA04DC089C8), U64(0x1DDC0325259B27DE),
203 U64(0xCF3F4688801EB9AA), U64(0xF4F5D05C10CAB243), U64(0x38B6525C21A42B0E), U64(0x36F60E2BA4FA6800),
204 U64(0xEB3593803173E0CE), U64(0x9C4CD6257C5A3603), U64(0xAF0C317D32ADAA8A), U64(0x258E5A80C7204C4B),
205 U64(0x8B889D624D44885D), U64(0xF4D14597E660F855), U64(0xD4347F66EC8941C3), U64(0xE699ED85B0DFB40D),
206 U64(0x2472F6207C2D0484), U64(0xC2A1E7B5B459AEB5), U64(0xAB4F6451CC1D45EC), U64(0x63767572AE3D6174),
207 U64(0xA59E0BD101731A28), U64(0x116D0016CB948F09), U64(0x2CF9C8CA052F6E9F), U64(0x0B090A7560A968E3),
208 U64(0xABEEDDB2DDE06FF1), U64(0x58EFC10B06A2068D), U64(0xC6E57A78FBD986E0), U64(0x2EAB8CA63CE802D7),
209 U64(0x14A195640116F336), U64(0x7C0828DD624EC390), U64(0xD74BBE77E6116AC7), U64(0x804456AF10F5FB53),
210 U64(0xEBE9EA2ADF4321C7), U64(0x03219A39EE587A30), U64(0x49787FEF17AF9924), U64(0xA1E9300CD8520548),
211 U64(0x5B45E522E4B1B4EF), U64(0xB49C3B3995091A36), U64(0xD4490AD526F14431), U64(0x12A8F216AF9418C2),
212 U64(0x001F837CC7350524), U64(0x1877B51E57A764D5), U64(0xA2853B80F17F58EE), U64(0x993E1DE72D36D310),
213 U64(0xB3598080CE64A656), U64(0x252F59CF0D9F04BB), U64(0xD23C8E176D113600), U64(0x1BDA0492E7E4586E),
214 U64(0x21E0BD5026C619BF), U64(0x3B097ADAF088F94E), U64(0x8D14DEDB30BE846E), U64(0xF95CFFA23AF5F6F4),
215 U64(0x3871700761B3F743), U64(0xCA672B91E9E4FA16), U64(0x64C8E531BFF53B55), U64(0x241260ED4AD1E87D),
216 U64(0x106C09B972D2E822), U64(0x7FBA195410E5CA30), U64(0x7884D9BC6CB569D8), U64(0x0647DFEDCD894A29),
217 U64(0x63573FF03E224774), U64(0x4FC8E9560F91B123), U64(0x1DB956E450275779), U64(0xB8D91274B9E9D4FB),
218 U64(0xA2EBEE47E2FBFCE1), U64(0xD9F1F30CCD97FB09), U64(0xEFED53D75FD64E6B), U64(0x2E6D02C36017F67F),
219 U64(0xA9AA4D20DB084E9B), U64(0xB64BE8D8B25396C1), U64(0x70CB6AF7C2D5BCF0), U64(0x98F076A4F7A2322E),
220 U64(0xBF84470805E69B5F), U64(0x94C3251F06F90CF3), U64(0x3E003E616A6591E9), U64(0xB925A6CD0421AFF3),
221 U64(0x61BDD1307C66E300), U64(0xBF8D5108E27E0D48), U64(0x240AB57A8B888B20), U64(0xFC87614BAF287E07),
222 U64(0xEF02CDD06FFDB432), U64(0xA1082C0466DF6C0A), U64(0x8215E577001332C8), U64(0xD39BB9C3A48DB6CF),
223 U64(0x2738259634305C14), U64(0x61CF4F94C97DF93D), U64(0x1B6BACA2AE4E125B), U64(0x758F450C88572E0B),
224 U64(0x959F587D507A8359), U64(0xB063E962E045F54D), U64(0x60E8ED72C0DFF5D1), U64(0x7B64978555326F9F),
225 U64(0xFD080D236DA814BA), U64(0x8C90FD9B083F4558), U64(0x106F72FE81E2C590), U64(0x7976033A39F7D952),
226 U64(0xA4EC0132764CA04B), U64(0x733EA705FAE4FA77), U64(0xB4D8F77BC3E56167), U64(0x9E21F4F903B33FD9),
227 U64(0x9D765E419FB69F6D), U64(0xD30C088BA61EA5EF), U64(0x5D94337FBFAF7F5B), U64(0x1A4E4822EB4D7A59),
228 U64(0x6FFE73E81B637FB3), U64(0xDDF957BC36D8B9CA), U64(0x64D0E29EEA8838B3), U64(0x08DD9BDFD96B9F63),
229 U64(0x087E79E5A57D1D13), U64(0xE328E230E3E2B3FB), U64(0x1C2559E30F0946BE), U64(0x720BF5F26F4D2EAA),
230 U64(0xB0774D261CC609DB), U64(0x443F64EC5A371195), U64(0x4112CF68649A260E), U64(0xD813F2FAB7F5C5CA),
231 U64(0x660D3257380841EE), U64(0x59AC2C7873F910A3), U64(0xE846963877671A17), U64(0x93B633ABFA3469F8),
232 U64(0xC0C0F5A60EF4CDCF), U64(0xCAF21ECD4377B28C), U64(0x57277707199B8175), U64(0x506C11B9D90E8B1D),
233 U64(0xD83CC2687A19255F), U64(0x4A29C6465A314CD1), U64(0xED2DF21216235097), U64(0xB5635C95FF7296E2),
234 U64(0x22AF003AB672E811), U64(0x52E762596BF68235), U64(0x9AEBA33AC6ECC6B0), U64(0x944F6DE09134DFB6),
235 U64(0x6C47BEC883A7DE39), U64(0x6AD047C430A12104), U64(0xA5B1CFDBA0AB4067), U64(0x7C45D833AFF07862),
236 U64(0x5092EF950A16DA0B), U64(0x9338E69C052B8E7B), U64(0x455A4B4CFE30E3F5), U64(0x6B02E63195AD0CF8),
237 U64(0x6B17B224BAD6BF27), U64(0xD1E0CCD25BB9C169), U64(0xDE0C89A556B9AE70), U64(0x50065E535A213CF6),
238 U64(0x9C1169FA2777B874), U64(0x78EDEFD694AF1EED), U64(0x6DC93D9526A50E68), U64(0xEE97F453F06791ED),
239 U64(0x32AB0EDB696703D3), U64(0x3A6853C7E70757A7), U64(0x31865CED6120F37D), U64(0x67FEF95D92607890),
240 U64(0x1F2B1D1F15F6DC9C), U64(0xB69E38A8965C6B65), U64(0xAA9119FF184CCCF4), U64(0xF43C732873F24C13),
241 U64(0xFB4A3D794A9A80D2), U64(0x3550C2321FD6109C), U64(0x371F77E76BB8417E), U64(0x6BFA9AAE5EC05779),
242 U64(0xCD04F3FF001A4778), U64(0xE3273522064480CA), U64(0x9F91508BFFCFC14A), U64(0x049A7F41061A9E60),
243 U64(0xFCB6BE43A9F2FE9B), U64(0x08DE8A1C7797DA9B), U64(0x8F9887E6078735A1), U64(0xB5B4071DBFC73A66),
244 U64(0x230E343DFBA08D33), U64(0x43ED7F5A0FAE657D), U64(0x3A88A0FBBCB05C63), U64(0x21874B8B4D2DBC4F),
245 U64(0x1BDEA12E35F6A8C9), U64(0x53C065C6C8E63528), U64(0xE34A1D250E7A8D6B), U64(0xD6B04D3B7651DD7E),
246 U64(0x5E90277E7CB39E2D), U64(0x2C046F22062DC67D), U64(0xB10BB459132D0A26), U64(0x3FA9DDFB67E2F199),
247 U64(0x0E09B88E1914F7AF), U64(0x10E8B35AF3EEAB37), U64(0x9EEDECA8E272B933), U64(0xD4C718BC4AE8AE5F),
248 U64(0x81536D601170FC20), U64(0x91B534F885818A06), U64(0xEC8177F83F900978), U64(0x190E714FADA5156E),
249 U64(0xB592BF39B0364963), U64(0x89C350C893AE7DC1), U64(0xAC042E70F8B383F2), U64(0xB49B52E587A1EE60),
250 U64(0xFB152FE3FF26DA89), U64(0x3E666E6F69AE2C15), U64(0x3B544EBE544C19F9), U64(0xE805A1E290CF2456),
251 U64(0x24B33C9D7ED25117), U64(0xE74733427B72F0C1), U64(0x0A804D18B7097475), U64(0x57E3306D881EDB4F),
252 U64(0x4AE7D6A36EB5DBCB), U64(0x2D8D5432157064C8), U64(0xD1E649DE1E7F268B), U64(0x8A328A1CEDFE552C),
253 U64(0x07A3AEC79624C7DA), U64(0x84547DDC3E203C94), U64(0x990A98FD5071D263), U64(0x1A4FF12616EEFC89),
254 U64(0xF6F7FD1431714200), U64(0x30C05B1BA332F41C), U64(0x8D2636B81555A786), U64(0x46C9FEB55D120902),
255 U64(0xCCEC0A73B49C9921), U64(0x4E9D2827355FC492), U64(0x19EBB029435DCB0F), U64(0x4659D2B743848A2C),
256 U64(0x963EF2C96B33BE31), U64(0x74F85198B05A2E7D), U64(0x5A0F544DD2B1FB18), U64(0x03727073C2E134B1),
257 U64(0xC7F6AA2DE59AEA61), U64(0x352787BAA0D7C22F), U64(0x9853EAB63B5E0B35), U64(0xABBDCDD7ED5C0860),
258 U64(0xCF05DAF5AC8D77B0), U64(0x49CAD48CEBF4A71E), U64(0x7A4C10EC2158C4A6), U64(0xD9E92AA246BF719E),
259 U64(0x13AE978D09FE5557), U64(0x730499AF921549FF), U64(0x4E4B705B92903BA4), U64(0xFF577222C14F0A3A),
260 U64(0x55B6344CF97AAFAE), U64(0xB862225B055B6960), U64(0xCAC09AFBDDD2CDB4), U64(0xDAF8E9829FE96B5F),
261 U64(0xB5FDFC5D3132C498), U64(0x310CB380DB6F7503), U64(0xE87FBB46217A360E), U64(0x2102AE466EBB1148),
262 U64(0xF8549E1A3AA5E00D), U64(0x07A69AFDCC42261A), U64(0xC4C118BFE78FEAAE), U64(0xF9F4892ED96BD438),
263 U64(0x1AF3DBE25D8F45DA), U64(0xF5B4B0B0D2DEEEB4), U64(0x962ACEEFA82E1C84), U64(0x046E3ECAAF453CE9),
264 U64(0xF05D129681949A4C), U64(0x964781CE734B3C84), U64(0x9C2ED44081CE5FBD), U64(0x522E23F3925E319E),
265 U64(0x177E00F9FC32F791), U64(0x2BC60A63A6F3B3F2), U64(0x222BBFAE61725606), U64(0x486289DDCC3D6780),
266 U64(0x7DC7785B8EFDFC80), U64(0x8AF38731C02BA980), U64(0x1FAB64EA29A2DDF7), U64(0xE4D9429322CD065A),
267 U64(0x9DA058C67844F20C), U64(0x24C0E332B70019B0), U64(0x233003B5A6CFE6AD), U64(0xD586BD01C5C217F6),
268 U64(0x5E5637885F29BC2B), U64(0x7EBA726D8C94094B), U64(0x0A56A5F0BFE39272), U64(0xD79476A84EE20D06),
269 U64(0x9E4C1269BAA4BF37), U64(0x17EFEE45B0DEE640), U64(0x1D95B0A5FCF90BC6), U64(0x93CBE0B699C2585D),
270 U64(0x65FA4F227A2B6D79), U64(0xD5F9E858292504D5), U64(0xC2B5A03F71471A6F), U64(0x59300222B4561E00),
271 U64(0xCE2F8642CA0712DC), U64(0x7CA9723FBB2E8988), U64(0x2785338347F2BA08), U64(0xC61BB3A141E50E8C),
272 U64(0x150F361DAB9DEC26), U64(0x9F6A419D382595F4), U64(0x64A53DC924FE7AC9), U64(0x142DE49FFF7A7C3D),
273 U64(0x0C335248857FA9E7), U64(0x0A9C32D5EAE45305), U64(0xE6C42178C4BBB92E), U64(0x71F1CE2490D20B07),
274 U64(0xF1BCC3D275AFE51A), U64(0xE728E8C83C334074), U64(0x96FBF83A12884624), U64(0x81A1549FD6573DA5),
275 U64(0x5FA7867CAF35E149), U64(0x56986E2EF3ED091B), U64(0x917F1DD5F8886C61), U64(0xD20D8C88C8FFE65F),
276 U64(0x31D71DCE64B2C310), U64(0xF165B587DF898190), U64(0xA57E6339DD2CF3A0), U64(0x1EF6E6DBB1961EC9),
277 U64(0x70CC73D90BC26E24), U64(0xE21A6B35DF0C3AD7), U64(0x003A93D8B2806962), U64(0x1C99DED33CB890A1),
278 U64(0xCF3145DE0ADD4289), U64(0xD0E4427A5514FB72), U64(0x77C621CC9FB3A483), U64(0x67A34DAC4356550B),
279 U64(0xF8D626AAAF278509),
282 uint64 *RandomPiece =Random64;
283 uint64 *RandomCastle =Random64+768;
284 uint64 *RandomEnPassant =Random64+772;
285 uint64 *RandomTurn =Random64+780;
291 int r, f, p_enc, squareNr, pieceGroup;
292 uint64 key=0, holdingsKey=0, Zobrist;
293 VariantClass v = gameInfo.variant;
297 case VariantFischeRandom: // compatible with normal
298 case VariantNoCastle:
299 case VariantXiangqi: // for historic reasons; does never collide anyway because of other King type
301 case VariantGiveaway: // in opening same as suicide
302 key += VariantSuicide;
304 case VariantGothic: // these are special cases of CRC, and can share book
305 case VariantCapablanca:
306 v = VariantCapaRandom;
308 key += v; // variant type incorporated in key to allow mixed books without collisions
311 for(f=0; f<BOARD_WIDTH; f++){
312 for(r=0; r<BOARD_HEIGHT;r++){
313 ChessSquare p = boards[moveNr][r][f];
314 if(f == BOARD_LEFT-1 || f == BOARD_RGHT) continue; // between board and holdings
315 if(p != EmptySquare){
316 int j = (int)p, promoted = 0;
317 j -= (j >= (int)BlackPawn) ? (int)BlackPawn :(int)WhitePawn;
318 if(j >= CHUPROMOTED WhitePawn) promoted++, j -= CHUPROMOTED WhitePawn;
319 if(j > (int)WhiteQueen) j++; // make space for King
320 if(j > (int) WhiteKing) j = (int)WhiteQueen + 1;
321 p_enc = 2*j + ((int)p < (int)BlackPawn);
322 // holdings squares get nmbers immediately after board; first left, then right holdings
323 if(f == BOARD_LEFT-2) squareNr = (BOARD_RGHT - BOARD_LEFT)*BOARD_HEIGHT + r; else
324 if(f == BOARD_RGHT+1) squareNr = (BOARD_RGHT - BOARD_LEFT + 1)*BOARD_HEIGHT + r; else
325 squareNr = (BOARD_RGHT - BOARD_LEFT)*r + (f - BOARD_LEFT);
326 // note that in normal Chess squareNr < 64 and p_enc < 12. The following code
327 // maps other pieces and squares in this range, and then modify the corresponding
328 // Zobrist random by rotating its bitpattern according to what the piece really was.
329 pieceGroup = p_enc / 12;
331 Zobrist = RandomPiece[64*p_enc + (squareNr & 63)];
332 if(pieceGroup & 4) Zobrist *= 987654321;
333 switch(pieceGroup & 3) {
334 case 1: // pieces 5-10 (FEACWM)
335 Zobrist = (Zobrist << 16) ^ (Zobrist >> 48);
337 case 2: // pieces 11-16 (OHIJGD)
338 Zobrist = (Zobrist << 32) ^ (Zobrist >> 32);
340 case 3: // pieces 17-20 (VLSU)
341 Zobrist = (Zobrist << 48) ^ (Zobrist >> 16);
344 if(promoted) Zobrist ^= 123456789*RandomPiece[squareNr & 63];
345 if(squareNr & 64) Zobrist = (Zobrist << 8) ^ (Zobrist >> 56);
346 if(squareNr & 128) Zobrist = (Zobrist << 4) ^ (Zobrist >> 60);
347 // holdings have separate (additive) key, to encode presence of multiple pieces on same square
348 if(f == BOARD_LEFT-2) holdingsKey += Zobrist * boards[moveNr][r][f+1]; else
349 if(f == BOARD_RGHT+1) holdingsKey += Zobrist * boards[moveNr][r][f-1]; else
355 if(boards[moveNr][CASTLING][2] != NoRights) {
356 if(boards[moveNr][CASTLING][0] != NoRights) key^=RandomCastle[0];
357 if(boards[moveNr][CASTLING][1] != NoRights) key^=RandomCastle[1];
359 if(boards[moveNr][CASTLING][5] != NoRights) {
360 if(boards[moveNr][CASTLING][3] != NoRights) key^=RandomCastle[2];
361 if(boards[moveNr][CASTLING][4] != NoRights) key^=RandomCastle[3];
364 f = boards[moveNr][EP_STATUS];
366 if(!WhiteOnMove(moveNr)){
367 // the test for neighboring Pawns might not be needed,
368 // as epStatus already kept track of it, but better safe than sorry.
369 if((f>0 && boards[moveNr][3][f-1]==BlackPawn)||
370 (f<7 && boards[moveNr][3][f+1]==BlackPawn)){
371 key^=RandomEnPassant[f];
374 if((f>0 && boards[moveNr][4][f-1]==WhitePawn)||
375 (f<7 && boards[moveNr][4][f+1]==WhitePawn)){
376 key^=RandomEnPassant[f];
381 if(WhiteOnMove(moveNr)){
384 return key + holdingsKey;
389 // fs routines read from memory buffer if no file specified
391 static unsigned char *memBuf, *memPtr;
396 fsseek (FILE *f, int n, int mode)
398 if(f) return fseek(f, n, mode);
399 if(mode == SEEK_SET) memPtr = memBuf + n; else
400 if(mode == SEEK_END) memPtr = memBuf + 16*bufSize + n;
401 return memPtr < memBuf || memPtr > memBuf + 16*bufSize;
407 if(f) return ftell(f);
408 return memPtr - memBuf;
414 if(f) return fgetc(f);
415 if(memPtr >= memBuf + 16*bufSize) return EOF;
420 int_from_file (FILE *f, int l, uint64 *r)
434 entry_from_file (FILE *f, entry_t *entry)
438 if(!f) { *entry = *(entry_t*) memPtr; memPtr += 16; return 0; }
439 ret=int_from_file(f,8,&r);
442 ret=int_from_file(f,2,&r);
445 ret=int_from_file(f,2,&r);
448 ret=int_from_file(f,2,&r);
451 ret=int_from_file(f,2,&r);
453 entry->learnPoints=r;
458 find_key (FILE *f, uint64 key, entry_t *entry)
460 int first, last, middle;
461 entry_t last_entry,middle_entry;
463 if(fsseek(f,-16,SEEK_END)){
465 entry->key=key+1; //hack
469 entry_from_file(f,&last_entry);
475 middle=(first+last)/2;
476 fsseek(f,16*middle,SEEK_SET);
477 entry_from_file(f,&middle_entry);
478 if(key<=middle_entry.key){
480 last_entry=middle_entry;
487 static int xStep[] = { 0, 1, 1, 1, 0,-1,-1,-1 };
488 static int yStep[] = { 1, 1, 0,-1,-1,-1, 0, 1 };
491 move_to_string (char move_s[20], uint16 move)
493 int f,fr,ff,t,tr,tf,p;
494 int width = BOARD_RGHT - BOARD_LEFT, size; // allow for alternative board formats
496 size = width * BOARD_HEIGHT;
497 p = move / (size*size);
498 move = move % (size*size);
505 snprintf(move_s, 9, "%c%d%c%d", ff + 'a', fr + 1 - (BOARD_HEIGHT == 10), tf + 'a', tr + 1 - (BOARD_HEIGHT == 10));
507 if(IS_SHOGI(gameInfo.variant) && p) {
508 if(p == 2) p = 10; // Lion moves, for boards so big that 10 is out of range
509 else if(p != 7) p = 8; // use '+' for all others that do not explicitly defer
512 // kludge: encode drops as special promotion code
513 if(gameInfo.holdingsSize && p == 9) {
514 move_s[0] = f + '@'; // from square encodes piece type
515 move_s[1] = '@'; // drop symbol
517 } else if(p == 10) { // decode Lion move
518 int i = t & 7, j = t >> 3 & 7;
519 tf = ff + xStep[i] + xStep[j]; tr = fr + yStep[i] + yStep[j]; // calculate true to-square
520 snprintf(move_s, 20, "%c%d%c%d,%c%d%c%d", ff + 'a', fr + 1 - (BOARD_HEIGHT == 10),
521 ff + xStep[i] + 'a', fr + yStep[i] + 1 - (BOARD_HEIGHT == 10),
522 ff + xStep[i] + 'a', fr + yStep[i] + 1 - (BOARD_HEIGHT == 10),
523 tf + 'a', tr + 1 - (BOARD_HEIGHT == 10) );
527 // add promotion piece, if any
529 int len = strlen(move_s);
530 move_s[len] = promote_pieces[p];
531 move_s[len+1] = '\0';
534 if(gameInfo.variant != VariantNormal) return;
536 // correct FRC-style castlings in variant normal.
537 // [HGM] This is buggy code! e1h1 could very well be a normal R or Q move.
538 if(!strcmp(move_s,"e1h1")){
539 safeStrCpy(move_s,"e1g1", 6);
540 }else if(!strcmp(move_s,"e1a1")){
541 safeStrCpy(move_s,"e1c1", 6);
542 }else if(!strcmp(move_s,"e8h8")){
543 safeStrCpy(move_s,"e8g8", 6);
544 }else if(!strcmp(move_s,"e8a8")){
545 safeStrCpy(move_s,"e8c8", 6);
550 GetBookMoves (FILE *f, int moveNr, entry_t entries[], int max)
551 { // retrieve all entries for given position from book in 'entries', return number.
559 if(appData.debugMode) fprintf(debugFP, "book key = %08x%08x\n", (unsigned int)(key>>32), (unsigned int)key);
561 offset=find_key(f, key, &entry);
562 if(entry.key != key) {
567 fsseek(f, 16*(offset+1), SEEK_SET);
569 ret=entry_from_file(f, &entry);
573 if(entry.key != key){
576 if(count == max) break;
577 entries[count++] = entry;
585 ReadFromBookFile (int moveNr, char *book, entry_t entries[])
586 { // retrieve all entries for given position from book in 'entries', return number.
587 static FILE *f = NULL;
588 static char curBook[MSG_SIZ];
590 if(book == NULL) return -1;
591 if(dirty) { if(f) fclose(f); dirty = 0; f = NULL; }
592 if(!f || strcmp(book, curBook)){ // keep book file open until book changed
593 strncpy(curBook, book, MSG_SIZ);
595 f = fopen(book,"rb");
598 DisplayError(_("Polyglot book not valid"), 0);
599 appData.usePolyglotBook = FALSE;
603 return GetBookMoves(f, moveNr, entries, MOVE_BUF);
606 // next three made into subroutines to facilitate future changes in storage scheme (e.g. 2 x 3 bytes)
611 return e->learnPoints;
617 return e->learnCount;
621 CountMove (entry_t *e, int result)
624 case 0: e->learnCount ++; break;
625 case 1: e->learnCount ++; // count draw as win + loss
626 case 2: e->learnPoints ++; break;
630 #define MERGESIZE 2048
631 #define HASHSIZE 1024*1024*4
633 entry_t *memBook, *hashTab, *mergeBuf;
634 int bookSize=1, mergeSize=1, mask = HASHSIZE-1;
639 static int initDone = FALSE;
641 memBook = (entry_t *) calloc(1024*1024, sizeof(entry_t));
642 hashTab = (entry_t *) calloc(HASHSIZE, sizeof(entry_t));
643 mergeBuf = (entry_t *) calloc(MERGESIZE+5, sizeof(entry_t));
644 memBook[0].key = -1LL;
645 mergeBuf[0].key = -1LL;
652 int count, count2, games, i, choice=0;
653 entry_t entries[MOVE_BUF];
654 float nominal[MOVE_BUF], tot, deficit, max, min;
655 static char move_s[6];
658 memBuf = (unsigned char*) memBook; bufSize = bookSize; // in MC mode book resides in memory
659 count = GetBookMoves(NULL, moveNr, entries, MOVE_BUF);
660 if(count < 0) count = 0; // don't care about miss yet
661 memBuf = (unsigned char*) mergeBuf; bufSize = mergeSize; // there could be moves still waiting to be merged
662 count2 = count + GetBookMoves(NULL, moveNr, entries+count, MOVE_BUF - count);
663 if(appData.debugMode) fprintf(debugFP, "MC probe: %d/%d (%d+%d)\n", count, count2,bookSize,mergeSize);
664 if(!count2) return NULL;
666 for(i=0; i<count2; i++) {
667 float w = wins(entries+i) + 10., l = losses(entries+i) + 10.;
668 float h = (w*w*w*w + 22500.*w*w) / (l*l*l*l + 22500.*l*l);
669 tot += nominal[i] = h;
670 games += wins(entries+i) + losses(entries+i);
672 tot = games / tot; max = min = 0;
673 for(i=0; i<count2; i++) {
674 nominal[i] *= tot; // normalize so they sum to games
675 deficit = nominal[i] - (wins(entries+i) + losses(entries+i));
676 if(deficit > max) max = deficit, choice = i;
677 if(deficit < min) min = deficit;
678 } // note that a single move will never be underplayed
679 if(max - min > 0.5*sqrt(nominal[choice])) { // if one of the listed moves is significantly under-played, play it now.
680 move_to_string(move_s, entries[choice].move);
681 if(appData.debugMode) fprintf(debugFP, "book move field = %d\n", entries[choice].move);
684 return NULL; // otherwise fake book miss to force engine think, hoping for hitherto unplayed move.
688 *ProbeBook (int moveNr, char *book)
690 entry_t entries[MOVE_BUF];
693 static char move_s[6];
696 if(moveNr >= 2*appData.bookDepth) return NULL;
697 if(mcMode) return MCprobe(moveNr);
699 if((count = ReadFromBookFile(moveNr, book, entries)) <= 0) return NULL; // no book, or no hit
701 if(appData.bookStrength != 50) { // transform weights
702 double power = 0, maxWeight = 0.0;
703 if(appData.bookStrength) power = (100.-appData.bookStrength)/appData.bookStrength;
704 for(i=0; i<count; i++) if(entries[i].weight > maxWeight) maxWeight = entries[i].weight;
705 for(i=0; i<count; i++){
706 double weight = entries[i].weight / maxWeight;
708 entries[i].weight = appData.bookStrength || weight == 1.0 ? 1e4*exp(power * log(weight)) + 0.5 : 0.0;
712 for(i=0; i<count; i++){
713 total_weight += entries[i].weight;
715 if(total_weight == 0) return NULL; // force book miss rather than playing moves with weight 0.
716 j = (random() & 0xFFF) * total_weight >> 12; // create random < total_weight
718 for(i=0; i<count; i++){
719 total_weight += entries[i].weight;
720 if(total_weight > j) break;
722 if(i >= count) DisplayFatalError(_("Book Fault"), 0, 1); // safety catch, cannot happen
723 move_to_string(move_s, entries[i].move);
724 if(appData.debugMode) fprintf(debugFP, "book move field = %d\n", entries[i].move);
729 extern char yy_textstr[];
730 entry_t lastEntries[MOVE_BUF];
733 MovesToText(int count, entry_t *entries)
735 int i, totalWeight = 0;
737 char *p = (char*) malloc(40*count+1);
738 for(i=0; i<count; i++) totalWeight += entries[i].weight;
740 for(i=0; i<count; i++) {
741 char buf[MSG_SIZ], c1, c2, c3; int i1, i2, i3;
742 move_to_string(algMove, entries[i].move);
743 if(sscanf(algMove, "%c%d%*c%*d,%c%d%c%d", &c1, &i1, &c2, &i2, &c3, &i3) == 6)
744 snprintf(algMove, 12, "%c%dx%c%d-%c%d", c1, i1, c2, i2, c3, i3); // cast double-moves in format SAN parser will understand
746 if(entries[i].learnCount || entries[i].learnPoints)
747 snprintf(buf, MSG_SIZ, " {%d/%d}", entries[i].learnPoints, entries[i].learnCount);
748 snprintf(p+strlen(p), 40, "%5.1f%% %5d %s%s\n", 100*entries[i].weight/(totalWeight+0.001),
749 entries[i].weight, algMove, buf);
750 //lastEntries[i] = entries[i];
756 CoordsToMove (int fromX, int fromY, int toX, int toY, char promoChar)
758 int i, width = BOARD_RGHT - BOARD_LEFT;
759 int to = toX - BOARD_LEFT + toY * width;
760 int from = fromX - BOARD_LEFT + fromY * width;
761 for(i=0; promote_pieces[i]; i++) if(promote_pieces[i] == promoChar) break;
762 if(!promote_pieces[i]) i = 0;
763 else if(i == 9 && gameInfo.variant == VariantChu) i = 1; // on 12x12 only 3 promotion codes available, so use 1 to indicate promotion
764 if(fromY == DROP_RANK) i = 9, from = ToUpper(PieceToChar(fromX)) - '@';
765 if(killX >= 0) { // multi-leg move
766 int dx = killX - fromX, dy = killY - fromY;
767 for(i=0; i<8; i++) if(dx == xStep[i] && dy == yStep[i]) {
769 dx = toX - killX; dy = toY - killY;
770 for(j=0; j<8; j++) if(dx == xStep[j] && dy == yStep[j]) {
771 // special encoding in to-square, with promoType = 2. Assumes board >= 64 squares!
772 return i + 8*j + (2 * width * BOARD_HEIGHT + from) * width * BOARD_HEIGHT;
775 i = 0; // if not a valid Lion move, ignore kill-square and promoChar
777 return to + (i * width * BOARD_HEIGHT + from) * width * BOARD_HEIGHT;
781 TextToMoves (char *text, int moveNum, entry_t *entries)
784 uint64 hashKey = hash(moveNum);
785 int fromX, fromY, toX, toY;
787 char promoChar, valid;
790 entries[0].key = hashKey; // make sure key is returned even if no moves
791 while((i=sscanf(text, "%f%%%d", &dummy, &w))==2 || (i=sscanf(text, "%d", &w))==1) {
792 if(i == 2) text = strchr(text, '%') + 1; // skip percentage
793 if(w == 1) text = strstr(text, "1 ") + 2; // skip weight that could be recognized as move number one
794 valid = ParseOneMove(text, moveNum, &moveType, &fromX, &fromY, &toX, &toY, &promoChar);
795 text = strstr(text, yy_textstr) + strlen(yy_textstr); // skip what we parsed
796 if(!valid || moveType != NormalMove && moveType != WhiteDrop && moveType != BlackDrop
797 && moveType != FirstLeg
798 && moveType != WhitePromotion && moveType != BlackPromotion
799 && moveType != WhiteCapturesEnPassant && moveType != BlackCapturesEnPassant
800 && moveType != WhiteKingSideCastle && moveType != BlackKingSideCastle
801 && moveType != WhiteQueenSideCastle && moveType != BlackQueenSideCastle
802 && moveType != WhiteNonPromotion && moveType != BlackNonPromotion) continue;
803 if(*text == ' ' && sscanf(text+1, "{%hd/%hd}", &entries[count].learnPoints, &entries[count].learnCount) == 2) {
804 text = strchr(text+1, '}') + 1;
806 entries[count].learnPoints = 0;
807 entries[count].learnCount = 0;
809 entries[count].move = CoordsToMove(fromX, fromY, toX, toY, promoChar); killX = killY = -1;
810 entries[count].key = hashKey;
811 entries[count].weight = w;
821 DisplayBook (int moveNr)
823 entry_t entries[MOVE_BUF];
826 if(!bookUp) return FALSE;
827 count = currentCount = ReadFromBookFile(moveNr, appData.polyglotBook, entries);
828 if(count < 0) return FALSE;
829 p = MovesToText(count, entries);
830 EditTagsPopUp(p, NULL);
832 addToBookFlag = FALSE;
840 bookUp = DisplayBook(currentMove);
844 int_to_file (FILE *f, int l, uint64 r)
847 for(i=l-1;i>=0;i--) fputc(r>>8*i & 255, f);
851 entry_to_file (FILE *f, entry_t *entry)
853 int_to_file(f,8,entry->key);
854 int_to_file(f,2,entry->move);
855 int_to_file(f,2,entry->weight);
856 int_to_file(f,2,entry->learnCount);
857 int_to_file(f,2,entry->learnPoints);
860 char buf1[4096], buf2[4096];
863 SaveToBook (char *text)
865 entry_t entries[MOVE_BUF], entry;
866 int count = TextToMoves(text, currentMove, entries);
867 int offset, i, len1=0, len2, readpos=0, writepos=0;
869 if(!count && !currentCount) return;
870 f=fopen(appData.polyglotBook, "rb+");
871 if(!f){ DisplayError(_("Polyglot book not valid"), 0); return; }
872 offset=find_key(f, entries[0].key, &entry);
873 if(entries[0].key != entry.key && currentCount) {
874 DisplayError(_("Hash keys are different"), 0);
878 if(count != currentCount) {
879 readpos = 16*(offset + currentCount);
880 writepos = 16*(offset + count);
881 fsseek(f, readpos, SEEK_SET);
882 readpos += len1 = fread(buf1, 1, 4096 - 16*currentCount, f); // salvage some entries immediately behind change
884 fsseek(f, 16*(offset), SEEK_SET);
885 for(i=0; i<count; i++) entry_to_file(f, entries + i); // save the change
886 if(count != currentCount) {
888 for(i=0; i<len1; i++) buf2[i] = buf1[i]; len2 = len1;
889 if(readpos > writepos) {
890 fsseek(f, readpos, SEEK_SET);
891 readpos += len1 = fread(buf1, 1, 4096, f);
892 } else len1 = 0; // wrote already past old EOF
893 fsseek(f, writepos, SEEK_SET);
894 fwrite(buf2, 1, len2, f);
903 NewEntry (entry_t *e, uint64 key, int move, int result)
909 CountMove(e, result);
917 if(appData.debugMode) fprintf(debugFP, "book merge %d moves (old size %d)\n", mergeSize, bookSize);
919 bookSize += --mergeSize;
920 for(i=bookSize-1; mergeSize; i--) {
921 while(mergeSize && (i < mergeSize || mergeBuf[mergeSize-1].key >= memBook[i-mergeSize].key))
922 memBook[i--] = mergeBuf[--mergeSize];
924 memBook[i] = memBook[i-mergeSize];
926 if(mergeSize) DisplayFatalError("merge error", 0, 0); // impossible
928 mergeBuf[0].key = -1LL;
932 AddToBook (int moveNr, int result)
935 int offset, start, move;
937 int i, j, fromY, toY;
938 char fromX, toX, promo;
939 extern char moveList[][MOVE_LEN];
941 if(!moveList[moveNr][0] || moveList[moveNr][0] == '\n') return; // could be terminal position
943 if(appData.debugMode) fprintf(debugFP, "add move %d to book %s", moveNr, moveList[moveNr]);
945 // calculate key and book representation of move
947 if(moveList[moveNr][1] == '@') {
948 sscanf(moveList[moveNr], "%c@%c%d", &promo, &toX, &toY);
949 fromX = CharToPiece(WhiteOnMove(moveNr) ? ToUpper(promo) : ToLower(promo));
950 fromY = DROP_RANK; promo = NULLCHAR;
951 } else sscanf(moveList[moveNr], "%c%d%c%d%c", &fromX, &fromY, &toX, &toY, &promo), fromX -= AAA, fromY -= ONE - '0';
952 move = CoordsToMove(fromX, fromY, toX-AAA, toY-ONE+'0', promo);
954 // if move already in book, just add count
955 memBuf = (unsigned char*) memBook; bufSize = bookSize; // in MC mode book resides in memory
956 offset = find_key(NULL, key, &entry);
957 while(memBook[offset].key == key) {
958 if(memBook[offset].move == move) {
959 CountMove(memBook+offset, result); return;
962 // move did not occur in the main book
963 memBuf = (unsigned char*) mergeBuf; bufSize = mergeSize; // it could be amongst moves still waiting to be merged
964 start = offset = find_key(NULL, key, &entry);
965 while(mergeBuf[offset].key == key) {
966 if(mergeBuf[offset].move == move) {
967 if(appData.debugMode) fprintf(debugFP, "found in book merge buf @ %d\n", offset);
968 CountMove(mergeBuf+offset, result); return;
971 if(start != offset) { // position was in mergeBuf, but move is new
972 if(appData.debugMode) fprintf(debugFP, "add in book merge buf @ %d\n", offset);
973 for(i=mergeSize++; i>offset; i--) mergeBuf[i] = mergeBuf[i-1]; // make room
974 NewEntry(mergeBuf+offset, key, move, result);
977 // position was not in mergeBuf; look in hash table
978 i = (key & mask); offset = -1;
979 while(hashTab[i].key) { // search in hash table (necessary because sought item could be re-hashed)
980 if(hashTab[i].key == 1 && offset < 0) offset = i; // remember first invalidated entry we pass
981 if(!((hashTab[i].key - key) & ~1)) { // hit
982 if(hashTab[i].move == move) {
983 CountMove(hashTab+i, result);
984 for(j=mergeSize++; j>start; j--) mergeBuf[j] = mergeBuf[j-1];
986 // position already in hash now occurs with different move; move both moves to mergeBuf
987 for(j=mergeSize+1; j>start+1; j--) mergeBuf[j] = mergeBuf[j-2];
988 NewEntry(mergeBuf+start+1, key, move, result); mergeSize += 2;
990 hashTab[i].key = 1; // kludge to invalidate hash entry
991 mergeBuf[start] = hashTab[i]; mergeBuf[start].key = key;
992 if(mergeSize >= MERGESIZE) Merge();
995 i = i+1 & mask; // wrap!
997 // position did not yet occur in hash table. Put it there
998 if(offset < 0) offset = i;
999 NewEntry(hashTab+offset, key, move, result);
1000 if(appData.debugMode)
1001 fprintf(debugFP, "book hash @ %d (%d-%d)\n", offset, hashTab[offset].learnPoints, hashTab[offset].learnCount);
1005 AddGameToBook (int always)
1009 if(!mcMode && !always) return;
1012 switch(gameInfo.result) {
1013 case GameIsDrawn: result = 1; break;
1014 case WhiteWins: result = 2; break;
1015 case BlackWins: result = 0; break;
1016 default: return; // don't treat games with unknown result
1019 if(appData.debugMode) fprintf(debugFP, "add game to book (%d-%d)\n", backwardMostMove, forwardMostMove);
1020 for(i=backwardMostMove; i<forwardMostMove && i < 2*appData.bookDepth; i++)
1021 AddToBook(i, WhiteOnMove(i) ? result : 2-result); // flip result when black moves
1025 PlayBookMove(char *text, int index)
1027 char *start = text+index, *end = start;
1028 while(start > text && start[-1] != ' ' && start[-1] != '\t') start--;
1029 while(*end && *++end != ' ' && *end != '\n'); *end = NULLCHAR; // find clicked word
1030 if(start != end) TypeInDoneEvent(start); // fake it was typed in move type-in
1040 Merge(); // flush merge buffer to memBook
1042 if(f = fopen(appData.polyglotBook, "wb")) {
1043 for(i=0; i<bookSize; i++) {
1044 entry_t entry = memBook[i];
1045 entry.weight = entry.learnPoints;
1046 // entry.learnPoints = 0;
1047 // entry.learnCount = 0;
1048 entry_to_file(f, &entry);
1050 } else DisplayError(_("Could not create book"), 0);